diff --git a/.gitattributes b/.gitattributes
index 2359c57cac3b08f3d3ae92164479a1d7267344ab..e134f5509bbe68d47ab00df92967243d1a12b3e7 100644
--- a/.gitattributes
+++ b/.gitattributes
@@ -4015,3 +4015,34 @@ tool_server/.venv/lib/python3.12/site-packages/sympy/polys/matrices/tests/__pyca
 tool_server/.venv/lib/python3.12/site-packages/sympy/polys/numberfields/__pycache__/resolvent_lookup.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
 tool_server/.venv/lib/python3.12/site-packages/sympy/polys/tests/__pycache__/test_rings.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
 tool_server/.venv/lib/python3.12/site-packages/sympy/polys/tests/__pycache__/test_polytools.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+tool_server/.venv/lib/python3.12/site-packages/sympy/printing/__pycache__/latex.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+tool_server/.venv/lib/python3.12/site-packages/sympy/printing/__pycache__/mathml.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+tool_server/.venv/lib/python3.12/site-packages/sympy/printing/pretty/__pycache__/pretty.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+tool_server/.venv/lib/python3.12/site-packages/sympy/printing/pretty/tests/__pycache__/test_pretty.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/__pycache__/test_latex.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/__pycache__/test_mathml.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+tool_server/.venv/lib/python3.12/site-packages/sympy/series/tests/__pycache__/test_limits.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+tool_server/.venv/lib/python3.12/site-packages/sympy/sets/__pycache__/sets.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+tool_server/.venv/lib/python3.12/site-packages/sympy/sets/tests/__pycache__/test_fancysets.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+tool_server/.venv/lib/python3.12/site-packages/sympy/sets/tests/__pycache__/test_sets.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/__pycache__/hyperexpand.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/__pycache__/solvers.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/__pycache__/solveset.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/diophantine/__pycache__/diophantine.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/ode/__pycache__/ode.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/ode/__pycache__/single.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/ode/tests/__pycache__/test_ode.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/ode/tests/__pycache__/test_single.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/ode/tests/__pycache__/test_systems.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/tests/__pycache__/test_solvers.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/tests/__pycache__/test_solveset.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+tool_server/.venv/lib/python3.12/site-packages/sympy/stats/__pycache__/crv_types.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+tool_server/.venv/lib/python3.12/site-packages/sympy/stats/__pycache__/stochastic_process_types.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+tool_server/.venv/lib/python3.12/site-packages/sympy/stats/tests/__pycache__/test_continuous_rv.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/__pycache__/tensor.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/expressions/__pycache__/array_expressions.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/tests/__pycache__/test_tensor.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/__pycache__/iterables.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/tests/__pycache__/test_lambdify.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/tests/__pycache__/test_wester.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+tool_server/.venv/lib/python3.12/site-packages/pkg_resources/__pycache__/__init__.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
diff --git a/tool_server/.venv/lib/python3.12/site-packages/_distutils_hack/__pycache__/__init__.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/_distutils_hack/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..2a7f6f09478d075aa3825a07faa18def039360ef
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/_distutils_hack/__pycache__/__init__.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/_distutils_hack/__pycache__/override.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/_distutils_hack/__pycache__/override.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..67d32245069d2f5af8df8b23e21b391432f396f2
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/_distutils_hack/__pycache__/override.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/pkg_resources/__pycache__/__init__.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/pkg_resources/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..cc9c3a3e7788ad0af745cc832743cff71a9c478f
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/pkg_resources/__pycache__/__init__.cpython-312.pyc
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:21ed4a3bf8c35fd02aa7f6bdbc92750e07228491c56ed4c8504cc9d9d9dacb93
+size 164697
diff --git a/tool_server/.venv/lib/python3.12/site-packages/pkg_resources/tests/__init__.py b/tool_server/.venv/lib/python3.12/site-packages/pkg_resources/tests/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/tool_server/.venv/lib/python3.12/site-packages/pkg_resources/tests/__pycache__/__init__.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/pkg_resources/tests/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..1eafac00b733ae04fb1cb9692423fbe3d7558d3d
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/pkg_resources/tests/__pycache__/__init__.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/pkg_resources/tests/__pycache__/test_find_distributions.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/pkg_resources/tests/__pycache__/test_find_distributions.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..dbb2bb319b3f811bee3d947751bb54444ad20193
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/pkg_resources/tests/__pycache__/test_find_distributions.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/pkg_resources/tests/__pycache__/test_integration_zope_interface.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/pkg_resources/tests/__pycache__/test_integration_zope_interface.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b4222303b8d227e778317bbed343f0299aeffa59
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/pkg_resources/tests/__pycache__/test_integration_zope_interface.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/pkg_resources/tests/__pycache__/test_markers.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/pkg_resources/tests/__pycache__/test_markers.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..2d106e261093b8c0899eabb4d761d4829dcb6a95
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/pkg_resources/tests/__pycache__/test_markers.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/pkg_resources/tests/__pycache__/test_pkg_resources.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/pkg_resources/tests/__pycache__/test_pkg_resources.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..86630b8845f0c68aeb6119d72489a86b05182fc2
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/pkg_resources/tests/__pycache__/test_pkg_resources.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/pkg_resources/tests/__pycache__/test_resources.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/pkg_resources/tests/__pycache__/test_resources.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..7c2065a75baa6ca6efdfc7d2c32c46b7c3ca5fd4
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/pkg_resources/tests/__pycache__/test_resources.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/pkg_resources/tests/__pycache__/test_working_set.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/pkg_resources/tests/__pycache__/test_working_set.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a602d88e44bdff104ad0d295127005b2ef58ae43
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/pkg_resources/tests/__pycache__/test_working_set.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/pkg_resources/tests/data/my-test-package-source/__pycache__/setup.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/pkg_resources/tests/data/my-test-package-source/__pycache__/setup.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..11881b0b1d5da5bce5567c5082b8b6ba49a046bd
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/pkg_resources/tests/data/my-test-package-source/__pycache__/setup.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/pkg_resources/tests/data/my-test-package-source/setup.cfg b/tool_server/.venv/lib/python3.12/site-packages/pkg_resources/tests/data/my-test-package-source/setup.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/tool_server/.venv/lib/python3.12/site-packages/pkg_resources/tests/data/my-test-package-source/setup.py b/tool_server/.venv/lib/python3.12/site-packages/pkg_resources/tests/data/my-test-package-source/setup.py
new file mode 100644
index 0000000000000000000000000000000000000000..ce9080640c0cf4a5b42274ac0c91278d6df17643
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/pkg_resources/tests/data/my-test-package-source/setup.py
@@ -0,0 +1,7 @@
+import setuptools
+
+setuptools.setup(
+    name="my-test-package",
+    version="1.0",
+    zip_safe=True,
+)
diff --git a/tool_server/.venv/lib/python3.12/site-packages/pkg_resources/tests/data/my-test-package-zip/my-test-package.zip b/tool_server/.venv/lib/python3.12/site-packages/pkg_resources/tests/data/my-test-package-zip/my-test-package.zip
new file mode 100644
index 0000000000000000000000000000000000000000..400905eecf0385de4d3b8e50b9892e1302b2b894
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/pkg_resources/tests/data/my-test-package-zip/my-test-package.zip
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:01845c437f4655e3cf9cc4fc4e49cfd607431f22675e1b611129a90239f34822
+size 1809
diff --git a/tool_server/.venv/lib/python3.12/site-packages/pkg_resources/tests/data/my-test-package_unpacked-egg/my_test_package-1.0-py3.7.egg/EGG-INFO/PKG-INFO b/tool_server/.venv/lib/python3.12/site-packages/pkg_resources/tests/data/my-test-package_unpacked-egg/my_test_package-1.0-py3.7.egg/EGG-INFO/PKG-INFO
new file mode 100644
index 0000000000000000000000000000000000000000..7328e3f7d18d31422d13b4fd63a7ef746956b7db
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/pkg_resources/tests/data/my-test-package_unpacked-egg/my_test_package-1.0-py3.7.egg/EGG-INFO/PKG-INFO
@@ -0,0 +1,10 @@
+Metadata-Version: 1.0
+Name: my-test-package
+Version: 1.0
+Summary: UNKNOWN
+Home-page: UNKNOWN
+Author: UNKNOWN
+Author-email: UNKNOWN
+License: UNKNOWN
+Description: UNKNOWN
+Platform: UNKNOWN
diff --git a/tool_server/.venv/lib/python3.12/site-packages/pkg_resources/tests/data/my-test-package_unpacked-egg/my_test_package-1.0-py3.7.egg/EGG-INFO/SOURCES.txt b/tool_server/.venv/lib/python3.12/site-packages/pkg_resources/tests/data/my-test-package_unpacked-egg/my_test_package-1.0-py3.7.egg/EGG-INFO/SOURCES.txt
new file mode 100644
index 0000000000000000000000000000000000000000..3c4ee1676d4fec9f10f3c0f58c2d992d97975b85
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/pkg_resources/tests/data/my-test-package_unpacked-egg/my_test_package-1.0-py3.7.egg/EGG-INFO/SOURCES.txt
@@ -0,0 +1,7 @@
+setup.cfg
+setup.py
+my_test_package.egg-info/PKG-INFO
+my_test_package.egg-info/SOURCES.txt
+my_test_package.egg-info/dependency_links.txt
+my_test_package.egg-info/top_level.txt
+my_test_package.egg-info/zip-safe
\ No newline at end of file
diff --git a/tool_server/.venv/lib/python3.12/site-packages/pkg_resources/tests/data/my-test-package_unpacked-egg/my_test_package-1.0-py3.7.egg/EGG-INFO/dependency_links.txt b/tool_server/.venv/lib/python3.12/site-packages/pkg_resources/tests/data/my-test-package_unpacked-egg/my_test_package-1.0-py3.7.egg/EGG-INFO/dependency_links.txt
new file mode 100644
index 0000000000000000000000000000000000000000..8b137891791fe96927ad78e64b0aad7bded08bdc
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/pkg_resources/tests/data/my-test-package_unpacked-egg/my_test_package-1.0-py3.7.egg/EGG-INFO/dependency_links.txt
@@ -0,0 +1 @@
+
diff --git a/tool_server/.venv/lib/python3.12/site-packages/pkg_resources/tests/data/my-test-package_unpacked-egg/my_test_package-1.0-py3.7.egg/EGG-INFO/top_level.txt b/tool_server/.venv/lib/python3.12/site-packages/pkg_resources/tests/data/my-test-package_unpacked-egg/my_test_package-1.0-py3.7.egg/EGG-INFO/top_level.txt
new file mode 100644
index 0000000000000000000000000000000000000000..8b137891791fe96927ad78e64b0aad7bded08bdc
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/pkg_resources/tests/data/my-test-package_unpacked-egg/my_test_package-1.0-py3.7.egg/EGG-INFO/top_level.txt
@@ -0,0 +1 @@
+
diff --git a/tool_server/.venv/lib/python3.12/site-packages/pkg_resources/tests/data/my-test-package_unpacked-egg/my_test_package-1.0-py3.7.egg/EGG-INFO/zip-safe b/tool_server/.venv/lib/python3.12/site-packages/pkg_resources/tests/data/my-test-package_unpacked-egg/my_test_package-1.0-py3.7.egg/EGG-INFO/zip-safe
new file mode 100644
index 0000000000000000000000000000000000000000..8b137891791fe96927ad78e64b0aad7bded08bdc
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/pkg_resources/tests/data/my-test-package_unpacked-egg/my_test_package-1.0-py3.7.egg/EGG-INFO/zip-safe
@@ -0,0 +1 @@
+
diff --git a/tool_server/.venv/lib/python3.12/site-packages/pkg_resources/tests/data/my-test-package_zipped-egg/my_test_package-1.0-py3.7.egg b/tool_server/.venv/lib/python3.12/site-packages/pkg_resources/tests/data/my-test-package_zipped-egg/my_test_package-1.0-py3.7.egg
new file mode 100644
index 0000000000000000000000000000000000000000..5115b8957da8213d02b718649c8702ac88bf0e72
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/pkg_resources/tests/data/my-test-package_zipped-egg/my_test_package-1.0-py3.7.egg differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/pkg_resources/tests/test_find_distributions.py b/tool_server/.venv/lib/python3.12/site-packages/pkg_resources/tests/test_find_distributions.py
new file mode 100644
index 0000000000000000000000000000000000000000..301b36d6cdbf128f839db473aa6b191eba694937
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/pkg_resources/tests/test_find_distributions.py
@@ -0,0 +1,56 @@
+import shutil
+from pathlib import Path
+
+import pytest
+
+import pkg_resources
+
+TESTS_DATA_DIR = Path(__file__).parent / 'data'
+
+
+class TestFindDistributions:
+    @pytest.fixture
+    def target_dir(self, tmpdir):
+        target_dir = tmpdir.mkdir('target')
+        # place a .egg named directory in the target that is not an egg:
+        target_dir.mkdir('not.an.egg')
+        return target_dir
+
+    def test_non_egg_dir_named_egg(self, target_dir):
+        dists = pkg_resources.find_distributions(str(target_dir))
+        assert not list(dists)
+
+    def test_standalone_egg_directory(self, target_dir):
+        shutil.copytree(
+            TESTS_DATA_DIR / 'my-test-package_unpacked-egg',
+            target_dir,
+            dirs_exist_ok=True,
+        )
+        dists = pkg_resources.find_distributions(str(target_dir))
+        assert [dist.project_name for dist in dists] == ['my-test-package']
+        dists = pkg_resources.find_distributions(str(target_dir), only=True)
+        assert not list(dists)
+
+    def test_zipped_egg(self, target_dir):
+        shutil.copytree(
+            TESTS_DATA_DIR / 'my-test-package_zipped-egg',
+            target_dir,
+            dirs_exist_ok=True,
+        )
+        dists = pkg_resources.find_distributions(str(target_dir))
+        assert [dist.project_name for dist in dists] == ['my-test-package']
+        dists = pkg_resources.find_distributions(str(target_dir), only=True)
+        assert not list(dists)
+
+    def test_zipped_sdist_one_level_removed(self, target_dir):
+        shutil.copytree(
+            TESTS_DATA_DIR / 'my-test-package-zip', target_dir, dirs_exist_ok=True
+        )
+        dists = pkg_resources.find_distributions(
+            str(target_dir / "my-test-package.zip")
+        )
+        assert [dist.project_name for dist in dists] == ['my-test-package']
+        dists = pkg_resources.find_distributions(
+            str(target_dir / "my-test-package.zip"), only=True
+        )
+        assert not list(dists)
diff --git a/tool_server/.venv/lib/python3.12/site-packages/pkg_resources/tests/test_integration_zope_interface.py b/tool_server/.venv/lib/python3.12/site-packages/pkg_resources/tests/test_integration_zope_interface.py
new file mode 100644
index 0000000000000000000000000000000000000000..4e37c3401b50c9f7387647303990887c7ce670f5
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/pkg_resources/tests/test_integration_zope_interface.py
@@ -0,0 +1,54 @@
+import platform
+from inspect import cleandoc
+
+import jaraco.path
+import pytest
+
+pytestmark = pytest.mark.integration
+
+
+# For the sake of simplicity this test uses fixtures defined in
+# `setuptools.test.fixtures`,
+# and it also exercise conditions considered deprecated...
+# So if needed this test can be deleted.
+@pytest.mark.skipif(
+    platform.system() != "Linux",
+    reason="only demonstrated to fail on Linux in #4399",
+)
+def test_interop_pkg_resources_iter_entry_points(tmp_path, venv):
+    """
+    Importing pkg_resources.iter_entry_points on console_scripts
+    seems to cause trouble with zope-interface, when deprecates installation method
+    is used. See #4399.
+    """
+    project = {
+        "pkg": {
+            "foo.py": cleandoc(
+                """
+                from pkg_resources import iter_entry_points
+
+                def bar():
+                    print("Print me if you can")
+                """
+            ),
+            "setup.py": cleandoc(
+                """
+                from setuptools import setup, find_packages
+
+                setup(
+                    install_requires=["zope-interface==6.4.post2"],
+                    entry_points={
+                        "console_scripts": [
+                            "foo=foo:bar",
+                        ],
+                    },
+                )
+                """
+            ),
+        }
+    }
+    jaraco.path.build(project, prefix=tmp_path)
+    cmd = ["pip", "install", "-e", ".", "--no-use-pep517"]
+    venv.run(cmd, cwd=tmp_path / "pkg")  # Needs this version of pkg_resources installed
+    out = venv.run(["foo"])
+    assert "Print me if you can" in out
diff --git a/tool_server/.venv/lib/python3.12/site-packages/pkg_resources/tests/test_markers.py b/tool_server/.venv/lib/python3.12/site-packages/pkg_resources/tests/test_markers.py
new file mode 100644
index 0000000000000000000000000000000000000000..9306d5b3483e8913b4a04d702091fb5efbc3f444
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/pkg_resources/tests/test_markers.py
@@ -0,0 +1,8 @@
+from unittest import mock
+
+from pkg_resources import evaluate_marker
+
+
+@mock.patch('platform.python_version', return_value='2.7.10')
+def test_ordering(python_version_mock):
+    assert evaluate_marker("python_full_version > '2.7.3'") is True
diff --git a/tool_server/.venv/lib/python3.12/site-packages/pkg_resources/tests/test_pkg_resources.py b/tool_server/.venv/lib/python3.12/site-packages/pkg_resources/tests/test_pkg_resources.py
new file mode 100644
index 0000000000000000000000000000000000000000..cfc9b16c0f187175a0fa504f0b07968c0551333b
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/pkg_resources/tests/test_pkg_resources.py
@@ -0,0 +1,485 @@
+from __future__ import annotations
+
+import builtins
+import datetime
+import inspect
+import os
+import plistlib
+import stat
+import subprocess
+import sys
+import tempfile
+import zipfile
+from unittest import mock
+
+import pytest
+
+import pkg_resources
+from pkg_resources import DistInfoDistribution, Distribution, EggInfoDistribution
+
+import distutils.command.install_egg_info
+import distutils.dist
+
+
+class EggRemover(str):
+    def __call__(self):
+        if self in sys.path:
+            sys.path.remove(self)
+        if os.path.exists(self):
+            os.remove(self)
+
+
+class TestZipProvider:
+    finalizers: list[EggRemover] = []
+
+    ref_time = datetime.datetime(2013, 5, 12, 13, 25, 0)
+    "A reference time for a file modification"
+
+    @classmethod
+    def setup_class(cls):
+        "create a zip egg and add it to sys.path"
+        egg = tempfile.NamedTemporaryFile(suffix='.egg', delete=False)
+        zip_egg = zipfile.ZipFile(egg, 'w')
+        zip_info = zipfile.ZipInfo()
+        zip_info.filename = 'mod.py'
+        zip_info.date_time = cls.ref_time.timetuple()
+        zip_egg.writestr(zip_info, 'x = 3\n')
+        zip_info = zipfile.ZipInfo()
+        zip_info.filename = 'data.dat'
+        zip_info.date_time = cls.ref_time.timetuple()
+        zip_egg.writestr(zip_info, 'hello, world!')
+        zip_info = zipfile.ZipInfo()
+        zip_info.filename = 'subdir/mod2.py'
+        zip_info.date_time = cls.ref_time.timetuple()
+        zip_egg.writestr(zip_info, 'x = 6\n')
+        zip_info = zipfile.ZipInfo()
+        zip_info.filename = 'subdir/data2.dat'
+        zip_info.date_time = cls.ref_time.timetuple()
+        zip_egg.writestr(zip_info, 'goodbye, world!')
+        zip_egg.close()
+        egg.close()
+
+        sys.path.append(egg.name)
+        subdir = os.path.join(egg.name, 'subdir')
+        sys.path.append(subdir)
+        cls.finalizers.append(EggRemover(subdir))
+        cls.finalizers.append(EggRemover(egg.name))
+
+    @classmethod
+    def teardown_class(cls):
+        for finalizer in cls.finalizers:
+            finalizer()
+
+    def test_resource_listdir(self):
+        import mod  # pyright: ignore[reportMissingImports] # Temporary package for test
+
+        zp = pkg_resources.ZipProvider(mod)
+
+        expected_root = ['data.dat', 'mod.py', 'subdir']
+        assert sorted(zp.resource_listdir('')) == expected_root
+
+        expected_subdir = ['data2.dat', 'mod2.py']
+        assert sorted(zp.resource_listdir('subdir')) == expected_subdir
+        assert sorted(zp.resource_listdir('subdir/')) == expected_subdir
+
+        assert zp.resource_listdir('nonexistent') == []
+        assert zp.resource_listdir('nonexistent/') == []
+
+        import mod2  # pyright: ignore[reportMissingImports] # Temporary package for test
+
+        zp2 = pkg_resources.ZipProvider(mod2)
+
+        assert sorted(zp2.resource_listdir('')) == expected_subdir
+
+        assert zp2.resource_listdir('subdir') == []
+        assert zp2.resource_listdir('subdir/') == []
+
+    def test_resource_filename_rewrites_on_change(self):
+        """
+        If a previous call to get_resource_filename has saved the file, but
+        the file has been subsequently mutated with different file of the
+        same size and modification time, it should not be overwritten on a
+        subsequent call to get_resource_filename.
+        """
+        import mod  # pyright: ignore[reportMissingImports] # Temporary package for test
+
+        manager = pkg_resources.ResourceManager()
+        zp = pkg_resources.ZipProvider(mod)
+        filename = zp.get_resource_filename(manager, 'data.dat')
+        actual = datetime.datetime.fromtimestamp(os.stat(filename).st_mtime)
+        assert actual == self.ref_time
+        f = open(filename, 'w', encoding="utf-8")
+        f.write('hello, world?')
+        f.close()
+        ts = self.ref_time.timestamp()
+        os.utime(filename, (ts, ts))
+        filename = zp.get_resource_filename(manager, 'data.dat')
+        with open(filename, encoding="utf-8") as f:
+            assert f.read() == 'hello, world!'
+        manager.cleanup_resources()
+
+
+class TestResourceManager:
+    def test_get_cache_path(self):
+        mgr = pkg_resources.ResourceManager()
+        path = mgr.get_cache_path('foo')
+        type_ = str(type(path))
+        message = "Unexpected type from get_cache_path: " + type_
+        assert isinstance(path, str), message
+
+    def test_get_cache_path_race(self, tmpdir):
+        # Patch to os.path.isdir to create a race condition
+        def patched_isdir(dirname, unpatched_isdir=pkg_resources.isdir):
+            patched_isdir.dirnames.append(dirname)
+
+            was_dir = unpatched_isdir(dirname)
+            if not was_dir:
+                os.makedirs(dirname)
+            return was_dir
+
+        patched_isdir.dirnames = []
+
+        # Get a cache path with a "race condition"
+        mgr = pkg_resources.ResourceManager()
+        mgr.set_extraction_path(str(tmpdir))
+
+        archive_name = os.sep.join(('foo', 'bar', 'baz'))
+        with mock.patch.object(pkg_resources, 'isdir', new=patched_isdir):
+            mgr.get_cache_path(archive_name)
+
+        # Because this test relies on the implementation details of this
+        # function, these assertions are a sentinel to ensure that the
+        # test suite will not fail silently if the implementation changes.
+        called_dirnames = patched_isdir.dirnames
+        assert len(called_dirnames) == 2
+        assert called_dirnames[0].split(os.sep)[-2:] == ['foo', 'bar']
+        assert called_dirnames[1].split(os.sep)[-1:] == ['foo']
+
+    """
+    Tests to ensure that pkg_resources runs independently from setuptools.
+    """
+
+    def test_setuptools_not_imported(self):
+        """
+        In a separate Python environment, import pkg_resources and assert
+        that action doesn't cause setuptools to be imported.
+        """
+        lines = (
+            'import pkg_resources',
+            'import sys',
+            ('assert "setuptools" not in sys.modules, "setuptools was imported"'),
+        )
+        cmd = [sys.executable, '-c', '; '.join(lines)]
+        subprocess.check_call(cmd)
+
+
+def make_test_distribution(metadata_path, metadata):
+    """
+    Make a test Distribution object, and return it.
+
+    :param metadata_path: the path to the metadata file that should be
+        created. This should be inside a distribution directory that should
+        also be created. For example, an argument value might end with
+        "<project>.dist-info/METADATA".
+    :param metadata: the desired contents of the metadata file, as bytes.
+    """
+    dist_dir = os.path.dirname(metadata_path)
+    os.mkdir(dist_dir)
+    with open(metadata_path, 'wb') as f:
+        f.write(metadata)
+    dists = list(pkg_resources.distributions_from_metadata(dist_dir))
+    (dist,) = dists
+
+    return dist
+
+
+def test_get_metadata__bad_utf8(tmpdir):
+    """
+    Test a metadata file with bytes that can't be decoded as utf-8.
+    """
+    filename = 'METADATA'
+    # Convert the tmpdir LocalPath object to a string before joining.
+    metadata_path = os.path.join(str(tmpdir), 'foo.dist-info', filename)
+    # Encode a non-ascii string with the wrong encoding (not utf-8).
+    metadata = 'née'.encode('iso-8859-1')
+    dist = make_test_distribution(metadata_path, metadata=metadata)
+
+    with pytest.raises(UnicodeDecodeError) as excinfo:
+        dist.get_metadata(filename)
+
+    exc = excinfo.value
+    actual = str(exc)
+    expected = (
+        # The error message starts with "'utf-8' codec ..." However, the
+        # spelling of "utf-8" can vary (e.g. "utf8") so we don't include it
+        "codec can't decode byte 0xe9 in position 1: "
+        'invalid continuation byte in METADATA file at path: '
+    )
+    assert expected in actual, f'actual: {actual}'
+    assert actual.endswith(metadata_path), f'actual: {actual}'
+
+
+def make_distribution_no_version(tmpdir, basename):
+    """
+    Create a distribution directory with no file containing the version.
+    """
+    dist_dir = tmpdir / basename
+    dist_dir.ensure_dir()
+    # Make the directory non-empty so distributions_from_metadata()
+    # will detect it and yield it.
+    dist_dir.join('temp.txt').ensure()
+
+    dists = list(pkg_resources.distributions_from_metadata(dist_dir))
+    assert len(dists) == 1
+    (dist,) = dists
+
+    return dist, dist_dir
+
+
+@pytest.mark.parametrize(
+    ("suffix", "expected_filename", "expected_dist_type"),
+    [
+        ('egg-info', 'PKG-INFO', EggInfoDistribution),
+        ('dist-info', 'METADATA', DistInfoDistribution),
+    ],
+)
+@pytest.mark.xfail(
+    sys.version_info[:2] == (3, 12) and sys.version_info.releaselevel != 'final',
+    reason="https://github.com/python/cpython/issues/103632",
+)
+def test_distribution_version_missing(
+    tmpdir, suffix, expected_filename, expected_dist_type
+):
+    """
+    Test Distribution.version when the "Version" header is missing.
+    """
+    basename = f'foo.{suffix}'
+    dist, dist_dir = make_distribution_no_version(tmpdir, basename)
+
+    expected_text = (
+        f"Missing 'Version:' header and/or {expected_filename} file at path: "
+    )
+    metadata_path = os.path.join(dist_dir, expected_filename)
+
+    # Now check the exception raised when the "version" attribute is accessed.
+    with pytest.raises(ValueError) as excinfo:
+        dist.version
+
+    err = str(excinfo.value)
+    # Include a string expression after the assert so the full strings
+    # will be visible for inspection on failure.
+    assert expected_text in err, str((expected_text, err))
+
+    # Also check the args passed to the ValueError.
+    msg, dist = excinfo.value.args
+    assert expected_text in msg
+    # Check that the message portion contains the path.
+    assert metadata_path in msg, str((metadata_path, msg))
+    assert type(dist) is expected_dist_type
+
+
+@pytest.mark.xfail(
+    sys.version_info[:2] == (3, 12) and sys.version_info.releaselevel != 'final',
+    reason="https://github.com/python/cpython/issues/103632",
+)
+def test_distribution_version_missing_undetected_path():
+    """
+    Test Distribution.version when the "Version" header is missing and
+    the path can't be detected.
+    """
+    # Create a Distribution object with no metadata argument, which results
+    # in an empty metadata provider.
+    dist = Distribution('/foo')
+    with pytest.raises(ValueError) as excinfo:
+        dist.version
+
+    msg, dist = excinfo.value.args
+    expected = (
+        "Missing 'Version:' header and/or PKG-INFO file at path: [could not detect]"
+    )
+    assert msg == expected
+
+
+@pytest.mark.parametrize('only', [False, True])
+def test_dist_info_is_not_dir(tmp_path, only):
+    """Test path containing a file with dist-info extension."""
+    dist_info = tmp_path / 'foobar.dist-info'
+    dist_info.touch()
+    assert not pkg_resources.dist_factory(str(tmp_path), str(dist_info), only)
+
+
+def test_macos_vers_fallback(monkeypatch, tmp_path):
+    """Regression test for pkg_resources._macos_vers"""
+    orig_open = builtins.open
+
+    # Pretend we need to use the plist file
+    monkeypatch.setattr('platform.mac_ver', mock.Mock(return_value=('', (), '')))
+
+    # Create fake content for the fake plist file
+    with open(tmp_path / 'fake.plist', 'wb') as fake_file:
+        plistlib.dump({"ProductVersion": "11.4"}, fake_file)
+
+    # Pretend the fake file exists
+    monkeypatch.setattr('os.path.exists', mock.Mock(return_value=True))
+
+    def fake_open(file, *args, **kwargs):
+        return orig_open(tmp_path / 'fake.plist', *args, **kwargs)
+
+    # Ensure that the _macos_vers works correctly
+    with mock.patch('builtins.open', mock.Mock(side_effect=fake_open)) as m:
+        pkg_resources._macos_vers.cache_clear()
+        assert pkg_resources._macos_vers() == ["11", "4"]
+        pkg_resources._macos_vers.cache_clear()
+
+    m.assert_called()
+
+
+class TestDeepVersionLookupDistutils:
+    @pytest.fixture
+    def env(self, tmpdir):
+        """
+        Create a package environment, similar to a virtualenv,
+        in which packages are installed.
+        """
+
+        class Environment(str):
+            pass
+
+        env = Environment(tmpdir)
+        tmpdir.chmod(stat.S_IRWXU)
+        subs = 'home', 'lib', 'scripts', 'data', 'egg-base'
+        env.paths = dict((dirname, str(tmpdir / dirname)) for dirname in subs)
+        list(map(os.mkdir, env.paths.values()))
+        return env
+
+    def create_foo_pkg(self, env, version):
+        """
+        Create a foo package installed (distutils-style) to env.paths['lib']
+        as version.
+        """
+        ld = "This package has unicode metadata! ❄"
+        attrs = dict(name='foo', version=version, long_description=ld)
+        dist = distutils.dist.Distribution(attrs)
+        iei_cmd = distutils.command.install_egg_info.install_egg_info(dist)
+        iei_cmd.initialize_options()
+        iei_cmd.install_dir = env.paths['lib']
+        iei_cmd.finalize_options()
+        iei_cmd.run()
+
+    def test_version_resolved_from_egg_info(self, env):
+        version = '1.11.0.dev0+2329eae'
+        self.create_foo_pkg(env, version)
+
+        # this requirement parsing will raise a VersionConflict unless the
+        # .egg-info file is parsed (see #419 on BitBucket)
+        req = pkg_resources.Requirement.parse('foo>=1.9')
+        dist = pkg_resources.WorkingSet([env.paths['lib']]).find(req)
+        assert dist.version == version
+
+    @pytest.mark.parametrize(
+        ("unnormalized", "normalized"),
+        [
+            ('foo', 'foo'),
+            ('foo/', 'foo'),
+            ('foo/bar', 'foo/bar'),
+            ('foo/bar/', 'foo/bar'),
+        ],
+    )
+    def test_normalize_path_trailing_sep(self, unnormalized, normalized):
+        """Ensure the trailing slash is cleaned for path comparison.
+
+        See pypa/setuptools#1519.
+        """
+        result_from_unnormalized = pkg_resources.normalize_path(unnormalized)
+        result_from_normalized = pkg_resources.normalize_path(normalized)
+        assert result_from_unnormalized == result_from_normalized
+
+    @pytest.mark.skipif(
+        os.path.normcase('A') != os.path.normcase('a'),
+        reason='Testing case-insensitive filesystems.',
+    )
+    @pytest.mark.parametrize(
+        ("unnormalized", "normalized"),
+        [
+            ('MiXeD/CasE', 'mixed/case'),
+        ],
+    )
+    def test_normalize_path_normcase(self, unnormalized, normalized):
+        """Ensure mixed case is normalized on case-insensitive filesystems."""
+        result_from_unnormalized = pkg_resources.normalize_path(unnormalized)
+        result_from_normalized = pkg_resources.normalize_path(normalized)
+        assert result_from_unnormalized == result_from_normalized
+
+    @pytest.mark.skipif(
+        os.path.sep != '\\',
+        reason='Testing systems using backslashes as path separators.',
+    )
+    @pytest.mark.parametrize(
+        ("unnormalized", "expected"),
+        [
+            ('forward/slash', 'forward\\slash'),
+            ('forward/slash/', 'forward\\slash'),
+            ('backward\\slash\\', 'backward\\slash'),
+        ],
+    )
+    def test_normalize_path_backslash_sep(self, unnormalized, expected):
+        """Ensure path seps are cleaned on backslash path sep systems."""
+        result = pkg_resources.normalize_path(unnormalized)
+        assert result.endswith(expected)
+
+
+class TestWorkdirRequire:
+    def fake_site_packages(self, tmp_path, monkeypatch, dist_files):
+        site_packages = tmp_path / "site-packages"
+        site_packages.mkdir()
+        for file, content in self.FILES.items():
+            path = site_packages / file
+            path.parent.mkdir(exist_ok=True, parents=True)
+            path.write_text(inspect.cleandoc(content), encoding="utf-8")
+
+        monkeypatch.setattr(sys, "path", [site_packages])
+        return os.fspath(site_packages)
+
+    FILES = {
+        "pkg1_mod-1.2.3.dist-info/METADATA": """
+            Metadata-Version: 2.4
+            Name: pkg1.mod
+            Version: 1.2.3
+            """,
+        "pkg2.mod-0.42.dist-info/METADATA": """
+            Metadata-Version: 2.1
+            Name: pkg2.mod
+            Version: 0.42
+            """,
+        "pkg3_mod.egg-info/PKG-INFO": """
+            Name: pkg3.mod
+            Version: 1.2.3.4
+            """,
+        "pkg4.mod.egg-info/PKG-INFO": """
+            Name: pkg4.mod
+            Version: 0.42.1
+            """,
+    }
+
+    @pytest.mark.parametrize(
+        ("version", "requirement"),
+        [
+            ("1.2.3", "pkg1.mod>=1"),
+            ("0.42", "pkg2.mod>=0.4"),
+            ("1.2.3.4", "pkg3.mod<=2"),
+            ("0.42.1", "pkg4.mod>0.2,<1"),
+        ],
+    )
+    def test_require_non_normalised_name(
+        self, tmp_path, monkeypatch, version, requirement
+    ):
+        # https://github.com/pypa/setuptools/issues/4853
+        site_packages = self.fake_site_packages(tmp_path, monkeypatch, self.FILES)
+        ws = pkg_resources.WorkingSet([site_packages])
+
+        for req in [requirement, requirement.replace(".", "-")]:
+            [dist] = ws.require(req)
+            assert dist.version == version
+            assert os.path.samefile(
+                os.path.commonpath([dist.location, site_packages]), site_packages
+            )
diff --git a/tool_server/.venv/lib/python3.12/site-packages/pkg_resources/tests/test_resources.py b/tool_server/.venv/lib/python3.12/site-packages/pkg_resources/tests/test_resources.py
new file mode 100644
index 0000000000000000000000000000000000000000..70436c08812df9a36d4fe5d40fb0b3bc07f02db9
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/pkg_resources/tests/test_resources.py
@@ -0,0 +1,869 @@
+import itertools
+import os
+import platform
+import string
+import sys
+
+import pytest
+from packaging.specifiers import SpecifierSet
+
+import pkg_resources
+from pkg_resources import (
+    Distribution,
+    EntryPoint,
+    Requirement,
+    VersionConflict,
+    WorkingSet,
+    parse_requirements,
+    parse_version,
+    safe_name,
+    safe_version,
+)
+
+
+# from Python 3.6 docs. Available from itertools on Python 3.10
+def pairwise(iterable):
+    "s -> (s0,s1), (s1,s2), (s2, s3), ..."
+    a, b = itertools.tee(iterable)
+    next(b, None)
+    return zip(a, b)
+
+
+class Metadata(pkg_resources.EmptyProvider):
+    """Mock object to return metadata as if from an on-disk distribution"""
+
+    def __init__(self, *pairs) -> None:
+        self.metadata = dict(pairs)
+
+    def has_metadata(self, name) -> bool:
+        return name in self.metadata
+
+    def get_metadata(self, name):
+        return self.metadata[name]
+
+    def get_metadata_lines(self, name):
+        return pkg_resources.yield_lines(self.get_metadata(name))
+
+
+dist_from_fn = pkg_resources.Distribution.from_filename
+
+
+class TestDistro:
+    def testCollection(self):
+        # empty path should produce no distributions
+        ad = pkg_resources.Environment([], platform=None, python=None)
+        assert list(ad) == []
+        assert ad['FooPkg'] == []
+        ad.add(dist_from_fn("FooPkg-1.3_1.egg"))
+        ad.add(dist_from_fn("FooPkg-1.4-py2.4-win32.egg"))
+        ad.add(dist_from_fn("FooPkg-1.2-py2.4.egg"))
+
+        # Name is in there now
+        assert ad['FooPkg']
+        # But only 1 package
+        assert list(ad) == ['foopkg']
+
+        # Distributions sort by version
+        expected = ['1.4', '1.3-1', '1.2']
+        assert [dist.version for dist in ad['FooPkg']] == expected
+
+        # Removing a distribution leaves sequence alone
+        ad.remove(ad['FooPkg'][1])
+        assert [dist.version for dist in ad['FooPkg']] == ['1.4', '1.2']
+
+        # And inserting adds them in order
+        ad.add(dist_from_fn("FooPkg-1.9.egg"))
+        assert [dist.version for dist in ad['FooPkg']] == ['1.9', '1.4', '1.2']
+
+        ws = WorkingSet([])
+        foo12 = dist_from_fn("FooPkg-1.2-py2.4.egg")
+        foo14 = dist_from_fn("FooPkg-1.4-py2.4-win32.egg")
+        (req,) = parse_requirements("FooPkg>=1.3")
+
+        # Nominal case: no distros on path, should yield all applicable
+        assert ad.best_match(req, ws).version == '1.9'
+        # If a matching distro is already installed, should return only that
+        ws.add(foo14)
+        assert ad.best_match(req, ws).version == '1.4'
+
+        # If the first matching distro is unsuitable, it's a version conflict
+        ws = WorkingSet([])
+        ws.add(foo12)
+        ws.add(foo14)
+        with pytest.raises(VersionConflict):
+            ad.best_match(req, ws)
+
+        # If more than one match on the path, the first one takes precedence
+        ws = WorkingSet([])
+        ws.add(foo14)
+        ws.add(foo12)
+        ws.add(foo14)
+        assert ad.best_match(req, ws).version == '1.4'
+
+    def checkFooPkg(self, d):
+        assert d.project_name == "FooPkg"
+        assert d.key == "foopkg"
+        assert d.version == "1.3.post1"
+        assert d.py_version == "2.4"
+        assert d.platform == "win32"
+        assert d.parsed_version == parse_version("1.3-1")
+
+    def testDistroBasics(self):
+        d = Distribution(
+            "/some/path",
+            project_name="FooPkg",
+            version="1.3-1",
+            py_version="2.4",
+            platform="win32",
+        )
+        self.checkFooPkg(d)
+
+        d = Distribution("/some/path")
+        assert d.py_version == f'{sys.version_info.major}.{sys.version_info.minor}'
+        assert d.platform is None
+
+    def testDistroParse(self):
+        d = dist_from_fn("FooPkg-1.3.post1-py2.4-win32.egg")
+        self.checkFooPkg(d)
+        d = dist_from_fn("FooPkg-1.3.post1-py2.4-win32.egg-info")
+        self.checkFooPkg(d)
+
+    def testDistroMetadata(self):
+        d = Distribution(
+            "/some/path",
+            project_name="FooPkg",
+            py_version="2.4",
+            platform="win32",
+            metadata=Metadata(('PKG-INFO', "Metadata-Version: 1.0\nVersion: 1.3-1\n")),
+        )
+        self.checkFooPkg(d)
+
+    def distRequires(self, txt):
+        return Distribution("/foo", metadata=Metadata(('depends.txt', txt)))
+
+    def checkRequires(self, dist, txt, extras=()):
+        assert list(dist.requires(extras)) == list(parse_requirements(txt))
+
+    def testDistroDependsSimple(self):
+        for v in "Twisted>=1.5", "Twisted>=1.5\nZConfig>=2.0":
+            self.checkRequires(self.distRequires(v), v)
+
+    needs_object_dir = pytest.mark.skipif(
+        not hasattr(object, '__dir__'),
+        reason='object.__dir__ necessary for self.__dir__ implementation',
+    )
+
+    def test_distribution_dir(self):
+        d = pkg_resources.Distribution()
+        dir(d)
+
+    @needs_object_dir
+    def test_distribution_dir_includes_provider_dir(self):
+        d = pkg_resources.Distribution()
+        before = d.__dir__()
+        assert 'test_attr' not in before
+        d._provider.test_attr = None
+        after = d.__dir__()
+        assert len(after) == len(before) + 1
+        assert 'test_attr' in after
+
+    @needs_object_dir
+    def test_distribution_dir_ignores_provider_dir_leading_underscore(self):
+        d = pkg_resources.Distribution()
+        before = d.__dir__()
+        assert '_test_attr' not in before
+        d._provider._test_attr = None
+        after = d.__dir__()
+        assert len(after) == len(before)
+        assert '_test_attr' not in after
+
+    def testResolve(self):
+        ad = pkg_resources.Environment([])
+        ws = WorkingSet([])
+        # Resolving no requirements -> nothing to install
+        assert list(ws.resolve([], ad)) == []
+        # Request something not in the collection -> DistributionNotFound
+        with pytest.raises(pkg_resources.DistributionNotFound):
+            ws.resolve(parse_requirements("Foo"), ad)
+
+        Foo = Distribution.from_filename(
+            "/foo_dir/Foo-1.2.egg",
+            metadata=Metadata(('depends.txt', "[bar]\nBaz>=2.0")),
+        )
+        ad.add(Foo)
+        ad.add(Distribution.from_filename("Foo-0.9.egg"))
+
+        # Request thing(s) that are available -> list to activate
+        for i in range(3):
+            targets = list(ws.resolve(parse_requirements("Foo"), ad))
+            assert targets == [Foo]
+            list(map(ws.add, targets))
+        with pytest.raises(VersionConflict):
+            ws.resolve(parse_requirements("Foo==0.9"), ad)
+        ws = WorkingSet([])  # reset
+
+        # Request an extra that causes an unresolved dependency for "Baz"
+        with pytest.raises(pkg_resources.DistributionNotFound):
+            ws.resolve(parse_requirements("Foo[bar]"), ad)
+        Baz = Distribution.from_filename(
+            "/foo_dir/Baz-2.1.egg", metadata=Metadata(('depends.txt', "Foo"))
+        )
+        ad.add(Baz)
+
+        # Activation list now includes resolved dependency
+        assert list(ws.resolve(parse_requirements("Foo[bar]"), ad)) == [Foo, Baz]
+        # Requests for conflicting versions produce VersionConflict
+        with pytest.raises(VersionConflict) as vc:
+            ws.resolve(parse_requirements("Foo==1.2\nFoo!=1.2"), ad)
+
+        msg = 'Foo 0.9 is installed but Foo==1.2 is required'
+        assert vc.value.report() == msg
+
+    def test_environment_marker_evaluation_negative(self):
+        """Environment markers are evaluated at resolution time."""
+        ad = pkg_resources.Environment([])
+        ws = WorkingSet([])
+        res = ws.resolve(parse_requirements("Foo;python_version<'2'"), ad)
+        assert list(res) == []
+
+    def test_environment_marker_evaluation_positive(self):
+        ad = pkg_resources.Environment([])
+        ws = WorkingSet([])
+        Foo = Distribution.from_filename("/foo_dir/Foo-1.2.dist-info")
+        ad.add(Foo)
+        res = ws.resolve(parse_requirements("Foo;python_version>='2'"), ad)
+        assert list(res) == [Foo]
+
+    def test_environment_marker_evaluation_called(self):
+        """
+        If one package foo requires bar without any extras,
+        markers should pass for bar without extras.
+        """
+        (parent_req,) = parse_requirements("foo")
+        (req,) = parse_requirements("bar;python_version>='2'")
+        req_extras = pkg_resources._ReqExtras({req: parent_req.extras})
+        assert req_extras.markers_pass(req)
+
+        (parent_req,) = parse_requirements("foo[]")
+        (req,) = parse_requirements("bar;python_version>='2'")
+        req_extras = pkg_resources._ReqExtras({req: parent_req.extras})
+        assert req_extras.markers_pass(req)
+
+    def test_marker_evaluation_with_extras(self):
+        """Extras are also evaluated as markers at resolution time."""
+        ad = pkg_resources.Environment([])
+        ws = WorkingSet([])
+        Foo = Distribution.from_filename(
+            "/foo_dir/Foo-1.2.dist-info",
+            metadata=Metadata((
+                "METADATA",
+                "Provides-Extra: baz\nRequires-Dist: quux; extra=='baz'",
+            )),
+        )
+        ad.add(Foo)
+        assert list(ws.resolve(parse_requirements("Foo"), ad)) == [Foo]
+        quux = Distribution.from_filename("/foo_dir/quux-1.0.dist-info")
+        ad.add(quux)
+        res = list(ws.resolve(parse_requirements("Foo[baz]"), ad))
+        assert res == [Foo, quux]
+
+    def test_marker_evaluation_with_extras_normlized(self):
+        """Extras are also evaluated as markers at resolution time."""
+        ad = pkg_resources.Environment([])
+        ws = WorkingSet([])
+        Foo = Distribution.from_filename(
+            "/foo_dir/Foo-1.2.dist-info",
+            metadata=Metadata((
+                "METADATA",
+                "Provides-Extra: baz-lightyear\n"
+                "Requires-Dist: quux; extra=='baz-lightyear'",
+            )),
+        )
+        ad.add(Foo)
+        assert list(ws.resolve(parse_requirements("Foo"), ad)) == [Foo]
+        quux = Distribution.from_filename("/foo_dir/quux-1.0.dist-info")
+        ad.add(quux)
+        res = list(ws.resolve(parse_requirements("Foo[baz-lightyear]"), ad))
+        assert res == [Foo, quux]
+
+    def test_marker_evaluation_with_multiple_extras(self):
+        ad = pkg_resources.Environment([])
+        ws = WorkingSet([])
+        Foo = Distribution.from_filename(
+            "/foo_dir/Foo-1.2.dist-info",
+            metadata=Metadata((
+                "METADATA",
+                "Provides-Extra: baz\n"
+                "Requires-Dist: quux; extra=='baz'\n"
+                "Provides-Extra: bar\n"
+                "Requires-Dist: fred; extra=='bar'\n",
+            )),
+        )
+        ad.add(Foo)
+        quux = Distribution.from_filename("/foo_dir/quux-1.0.dist-info")
+        ad.add(quux)
+        fred = Distribution.from_filename("/foo_dir/fred-0.1.dist-info")
+        ad.add(fred)
+        res = list(ws.resolve(parse_requirements("Foo[baz,bar]"), ad))
+        assert sorted(res) == [fred, quux, Foo]
+
+    def test_marker_evaluation_with_extras_loop(self):
+        ad = pkg_resources.Environment([])
+        ws = WorkingSet([])
+        a = Distribution.from_filename(
+            "/foo_dir/a-0.2.dist-info",
+            metadata=Metadata(("METADATA", "Requires-Dist: c[a]")),
+        )
+        b = Distribution.from_filename(
+            "/foo_dir/b-0.3.dist-info",
+            metadata=Metadata(("METADATA", "Requires-Dist: c[b]")),
+        )
+        c = Distribution.from_filename(
+            "/foo_dir/c-1.0.dist-info",
+            metadata=Metadata((
+                "METADATA",
+                "Provides-Extra: a\n"
+                "Requires-Dist: b;extra=='a'\n"
+                "Provides-Extra: b\n"
+                "Requires-Dist: foo;extra=='b'",
+            )),
+        )
+        foo = Distribution.from_filename("/foo_dir/foo-0.1.dist-info")
+        for dist in (a, b, c, foo):
+            ad.add(dist)
+        res = list(ws.resolve(parse_requirements("a"), ad))
+        assert res == [a, c, b, foo]
+
+    @pytest.mark.xfail(
+        sys.version_info[:2] == (3, 12) and sys.version_info.releaselevel != 'final',
+        reason="https://github.com/python/cpython/issues/103632",
+    )
+    def testDistroDependsOptions(self):
+        d = self.distRequires(
+            """
+            Twisted>=1.5
+            [docgen]
+            ZConfig>=2.0
+            docutils>=0.3
+            [fastcgi]
+            fcgiapp>=0.1"""
+        )
+        self.checkRequires(d, "Twisted>=1.5")
+        self.checkRequires(
+            d, "Twisted>=1.5 ZConfig>=2.0 docutils>=0.3".split(), ["docgen"]
+        )
+        self.checkRequires(d, "Twisted>=1.5 fcgiapp>=0.1".split(), ["fastcgi"])
+        self.checkRequires(
+            d,
+            "Twisted>=1.5 ZConfig>=2.0 docutils>=0.3 fcgiapp>=0.1".split(),
+            ["docgen", "fastcgi"],
+        )
+        self.checkRequires(
+            d,
+            "Twisted>=1.5 fcgiapp>=0.1 ZConfig>=2.0 docutils>=0.3".split(),
+            ["fastcgi", "docgen"],
+        )
+        with pytest.raises(pkg_resources.UnknownExtra):
+            d.requires(["foo"])
+
+
+class TestWorkingSet:
+    def test_find_conflicting(self):
+        ws = WorkingSet([])
+        Foo = Distribution.from_filename("/foo_dir/Foo-1.2.egg")
+        ws.add(Foo)
+
+        # create a requirement that conflicts with Foo 1.2
+        req = next(parse_requirements("Foo<1.2"))
+
+        with pytest.raises(VersionConflict) as vc:
+            ws.find(req)
+
+        msg = 'Foo 1.2 is installed but Foo<1.2 is required'
+        assert vc.value.report() == msg
+
+    def test_resolve_conflicts_with_prior(self):
+        """
+        A ContextualVersionConflict should be raised when a requirement
+        conflicts with a prior requirement for a different package.
+        """
+        # Create installation where Foo depends on Baz 1.0 and Bar depends on
+        # Baz 2.0.
+        ws = WorkingSet([])
+        md = Metadata(('depends.txt', "Baz==1.0"))
+        Foo = Distribution.from_filename("/foo_dir/Foo-1.0.egg", metadata=md)
+        ws.add(Foo)
+        md = Metadata(('depends.txt', "Baz==2.0"))
+        Bar = Distribution.from_filename("/foo_dir/Bar-1.0.egg", metadata=md)
+        ws.add(Bar)
+        Baz = Distribution.from_filename("/foo_dir/Baz-1.0.egg")
+        ws.add(Baz)
+        Baz = Distribution.from_filename("/foo_dir/Baz-2.0.egg")
+        ws.add(Baz)
+
+        with pytest.raises(VersionConflict) as vc:
+            ws.resolve(parse_requirements("Foo\nBar\n"))
+
+        msg = "Baz 1.0 is installed but Baz==2.0 is required by "
+        msg += repr(set(['Bar']))
+        assert vc.value.report() == msg
+
+
+class TestEntryPoints:
+    def assertfields(self, ep):
+        assert ep.name == "foo"
+        assert ep.module_name == "pkg_resources.tests.test_resources"
+        assert ep.attrs == ("TestEntryPoints",)
+        assert ep.extras == ("x",)
+        assert ep.load() is TestEntryPoints
+        expect = "foo = pkg_resources.tests.test_resources:TestEntryPoints [x]"
+        assert str(ep) == expect
+
+    def setup_method(self, method):
+        self.dist = Distribution.from_filename(
+            "FooPkg-1.2-py2.4.egg", metadata=Metadata(('requires.txt', '[x]'))
+        )
+
+    def testBasics(self):
+        ep = EntryPoint(
+            "foo",
+            "pkg_resources.tests.test_resources",
+            ["TestEntryPoints"],
+            ["x"],
+            self.dist,
+        )
+        self.assertfields(ep)
+
+    def testParse(self):
+        s = "foo = pkg_resources.tests.test_resources:TestEntryPoints [x]"
+        ep = EntryPoint.parse(s, self.dist)
+        self.assertfields(ep)
+
+        ep = EntryPoint.parse("bar baz=  spammity[PING]")
+        assert ep.name == "bar baz"
+        assert ep.module_name == "spammity"
+        assert ep.attrs == ()
+        assert ep.extras == ("ping",)
+
+        ep = EntryPoint.parse(" fizzly =  wocka:foo")
+        assert ep.name == "fizzly"
+        assert ep.module_name == "wocka"
+        assert ep.attrs == ("foo",)
+        assert ep.extras == ()
+
+        # plus in the name
+        spec = "html+mako = mako.ext.pygmentplugin:MakoHtmlLexer"
+        ep = EntryPoint.parse(spec)
+        assert ep.name == 'html+mako'
+
+    reject_specs = "foo", "x=a:b:c", "q=x/na", "fez=pish:tush-z", "x=f[a]>2"
+
+    @pytest.mark.parametrize("reject_spec", reject_specs)
+    def test_reject_spec(self, reject_spec):
+        with pytest.raises(ValueError):
+            EntryPoint.parse(reject_spec)
+
+    def test_printable_name(self):
+        """
+        Allow any printable character in the name.
+        """
+        # Create a name with all printable characters; strip the whitespace.
+        name = string.printable.strip()
+        spec = "{name} = module:attr".format(**locals())
+        ep = EntryPoint.parse(spec)
+        assert ep.name == name
+
+    def checkSubMap(self, m):
+        assert len(m) == len(self.submap_expect)
+        for key, ep in self.submap_expect.items():
+            assert m.get(key).name == ep.name
+            assert m.get(key).module_name == ep.module_name
+            assert sorted(m.get(key).attrs) == sorted(ep.attrs)
+            assert sorted(m.get(key).extras) == sorted(ep.extras)
+
+    submap_expect = dict(
+        feature1=EntryPoint('feature1', 'somemodule', ['somefunction']),
+        feature2=EntryPoint(
+            'feature2', 'another.module', ['SomeClass'], ['extra1', 'extra2']
+        ),
+        feature3=EntryPoint('feature3', 'this.module', extras=['something']),
+    )
+    submap_str = """
+            # define features for blah blah
+            feature1 = somemodule:somefunction
+            feature2 = another.module:SomeClass [extra1,extra2]
+            feature3 = this.module [something]
+    """
+
+    def testParseList(self):
+        self.checkSubMap(EntryPoint.parse_group("xyz", self.submap_str))
+        with pytest.raises(ValueError):
+            EntryPoint.parse_group("x a", "foo=bar")
+        with pytest.raises(ValueError):
+            EntryPoint.parse_group("x", ["foo=baz", "foo=bar"])
+
+    def testParseMap(self):
+        m = EntryPoint.parse_map({'xyz': self.submap_str})
+        self.checkSubMap(m['xyz'])
+        assert list(m.keys()) == ['xyz']
+        m = EntryPoint.parse_map("[xyz]\n" + self.submap_str)
+        self.checkSubMap(m['xyz'])
+        assert list(m.keys()) == ['xyz']
+        with pytest.raises(ValueError):
+            EntryPoint.parse_map(["[xyz]", "[xyz]"])
+        with pytest.raises(ValueError):
+            EntryPoint.parse_map(self.submap_str)
+
+    def testDeprecationWarnings(self):
+        ep = EntryPoint(
+            "foo", "pkg_resources.tests.test_resources", ["TestEntryPoints"], ["x"]
+        )
+        with pytest.warns(pkg_resources.PkgResourcesDeprecationWarning):
+            ep.load(require=False)
+
+
+class TestRequirements:
+    def testBasics(self):
+        r = Requirement.parse("Twisted>=1.2")
+        assert str(r) == "Twisted>=1.2"
+        assert repr(r) == "Requirement.parse('Twisted>=1.2')"
+        assert r == Requirement("Twisted>=1.2")
+        assert r == Requirement("twisTed>=1.2")
+        assert r != Requirement("Twisted>=2.0")
+        assert r != Requirement("Zope>=1.2")
+        assert r != Requirement("Zope>=3.0")
+        assert r != Requirement("Twisted[extras]>=1.2")
+
+    def testOrdering(self):
+        r1 = Requirement("Twisted==1.2c1,>=1.2")
+        r2 = Requirement("Twisted>=1.2,==1.2c1")
+        assert r1 == r2
+        assert str(r1) == str(r2)
+        assert str(r2) == "Twisted==1.2c1,>=1.2"
+        assert Requirement("Twisted") != Requirement(
+            "Twisted @ https://localhost/twisted.zip"
+        )
+
+    def testBasicContains(self):
+        r = Requirement("Twisted>=1.2")
+        foo_dist = Distribution.from_filename("FooPkg-1.3_1.egg")
+        twist11 = Distribution.from_filename("Twisted-1.1.egg")
+        twist12 = Distribution.from_filename("Twisted-1.2.egg")
+        assert parse_version('1.2') in r
+        assert parse_version('1.1') not in r
+        assert '1.2' in r
+        assert '1.1' not in r
+        assert foo_dist not in r
+        assert twist11 not in r
+        assert twist12 in r
+
+    def testOptionsAndHashing(self):
+        r1 = Requirement.parse("Twisted[foo,bar]>=1.2")
+        r2 = Requirement.parse("Twisted[bar,FOO]>=1.2")
+        assert r1 == r2
+        assert set(r1.extras) == set(("foo", "bar"))
+        assert set(r2.extras) == set(("foo", "bar"))
+        assert hash(r1) == hash(r2)
+        assert hash(r1) == hash((
+            "twisted",
+            None,
+            SpecifierSet(">=1.2"),
+            frozenset(["foo", "bar"]),
+            None,
+        ))
+        assert hash(
+            Requirement.parse("Twisted @ https://localhost/twisted.zip")
+        ) == hash((
+            "twisted",
+            "https://localhost/twisted.zip",
+            SpecifierSet(),
+            frozenset(),
+            None,
+        ))
+
+    def testVersionEquality(self):
+        r1 = Requirement.parse("foo==0.3a2")
+        r2 = Requirement.parse("foo!=0.3a4")
+        d = Distribution.from_filename
+
+        assert d("foo-0.3a4.egg") not in r1
+        assert d("foo-0.3a1.egg") not in r1
+        assert d("foo-0.3a4.egg") not in r2
+
+        assert d("foo-0.3a2.egg") in r1
+        assert d("foo-0.3a2.egg") in r2
+        assert d("foo-0.3a3.egg") in r2
+        assert d("foo-0.3a5.egg") in r2
+
+    def testSetuptoolsProjectName(self):
+        """
+        The setuptools project should implement the setuptools package.
+        """
+
+        assert Requirement.parse('setuptools').project_name == 'setuptools'
+        # setuptools 0.7 and higher means setuptools.
+        assert Requirement.parse('setuptools == 0.7').project_name == 'setuptools'
+        assert Requirement.parse('setuptools == 0.7a1').project_name == 'setuptools'
+        assert Requirement.parse('setuptools >= 0.7').project_name == 'setuptools'
+
+
+class TestParsing:
+    def testEmptyParse(self):
+        assert list(parse_requirements('')) == []
+
+    def testYielding(self):
+        for inp, out in [
+            ([], []),
+            ('x', ['x']),
+            ([[]], []),
+            (' x\n y', ['x', 'y']),
+            (['x\n\n', 'y'], ['x', 'y']),
+        ]:
+            assert list(pkg_resources.yield_lines(inp)) == out
+
+    def testSplitting(self):
+        sample = """
+                    x
+                    [Y]
+                    z
+
+                    a
+                    [b ]
+                    # foo
+                    c
+                    [ d]
+                    [q]
+                    v
+                    """
+        assert list(pkg_resources.split_sections(sample)) == [
+            (None, ["x"]),
+            ("Y", ["z", "a"]),
+            ("b", ["c"]),
+            ("d", []),
+            ("q", ["v"]),
+        ]
+        with pytest.raises(ValueError):
+            list(pkg_resources.split_sections("[foo"))
+
+    def testSafeName(self):
+        assert safe_name("adns-python") == "adns-python"
+        assert safe_name("WSGI Utils") == "WSGI-Utils"
+        assert safe_name("WSGI  Utils") == "WSGI-Utils"
+        assert safe_name("Money$$$Maker") == "Money-Maker"
+        assert safe_name("peak.web") != "peak-web"
+
+    def testSafeVersion(self):
+        assert safe_version("1.2-1") == "1.2.post1"
+        assert safe_version("1.2 alpha") == "1.2.alpha"
+        assert safe_version("2.3.4 20050521") == "2.3.4.20050521"
+        assert safe_version("Money$$$Maker") == "Money-Maker"
+        assert safe_version("peak.web") == "peak.web"
+
+    def testSimpleRequirements(self):
+        assert list(parse_requirements('Twis-Ted>=1.2-1')) == [
+            Requirement('Twis-Ted>=1.2-1')
+        ]
+        assert list(parse_requirements('Twisted >=1.2, \\ # more\n<2.0')) == [
+            Requirement('Twisted>=1.2,<2.0')
+        ]
+        assert Requirement.parse("FooBar==1.99a3") == Requirement("FooBar==1.99a3")
+        with pytest.raises(ValueError):
+            Requirement.parse(">=2.3")
+        with pytest.raises(ValueError):
+            Requirement.parse("x\\")
+        with pytest.raises(ValueError):
+            Requirement.parse("x==2 q")
+        with pytest.raises(ValueError):
+            Requirement.parse("X==1\nY==2")
+        with pytest.raises(ValueError):
+            Requirement.parse("#")
+
+    def test_requirements_with_markers(self):
+        assert Requirement.parse("foobar;os_name=='a'") == Requirement.parse(
+            "foobar;os_name=='a'"
+        )
+        assert Requirement.parse(
+            "name==1.1;python_version=='2.7'"
+        ) != Requirement.parse("name==1.1;python_version=='3.6'")
+        assert Requirement.parse(
+            "name==1.0;python_version=='2.7'"
+        ) != Requirement.parse("name==1.2;python_version=='2.7'")
+        assert Requirement.parse(
+            "name[foo]==1.0;python_version=='3.6'"
+        ) != Requirement.parse("name[foo,bar]==1.0;python_version=='3.6'")
+
+    def test_local_version(self):
+        parse_requirements('foo==1.0+org1')
+
+    def test_spaces_between_multiple_versions(self):
+        parse_requirements('foo>=1.0, <3')
+        parse_requirements('foo >= 1.0, < 3')
+
+    @pytest.mark.parametrize(
+        ("lower", "upper"),
+        [
+            ('1.2-rc1', '1.2rc1'),
+            ('0.4', '0.4.0'),
+            ('0.4.0.0', '0.4.0'),
+            ('0.4.0-0', '0.4-0'),
+            ('0post1', '0.0post1'),
+            ('0pre1', '0.0c1'),
+            ('0.0.0preview1', '0c1'),
+            ('0.0c1', '0-rc1'),
+            ('1.2a1', '1.2.a.1'),
+            ('1.2.a', '1.2a'),
+        ],
+    )
+    def testVersionEquality(self, lower, upper):
+        assert parse_version(lower) == parse_version(upper)
+
+    torture = """
+        0.80.1-3 0.80.1-2 0.80.1-1 0.79.9999+0.80.0pre4-1
+        0.79.9999+0.80.0pre2-3 0.79.9999+0.80.0pre2-2
+        0.77.2-1 0.77.1-1 0.77.0-1
+        """
+
+    @pytest.mark.parametrize(
+        ("lower", "upper"),
+        [
+            ('2.1', '2.1.1'),
+            ('2a1', '2b0'),
+            ('2a1', '2.1'),
+            ('2.3a1', '2.3'),
+            ('2.1-1', '2.1-2'),
+            ('2.1-1', '2.1.1'),
+            ('2.1', '2.1post4'),
+            ('2.1a0-20040501', '2.1'),
+            ('1.1', '02.1'),
+            ('3.2', '3.2.post0'),
+            ('3.2post1', '3.2post2'),
+            ('0.4', '4.0'),
+            ('0.0.4', '0.4.0'),
+            ('0post1', '0.4post1'),
+            ('2.1.0-rc1', '2.1.0'),
+            ('2.1dev', '2.1a0'),
+        ]
+        + list(pairwise(reversed(torture.split()))),
+    )
+    def testVersionOrdering(self, lower, upper):
+        assert parse_version(lower) < parse_version(upper)
+
+    def testVersionHashable(self):
+        """
+        Ensure that our versions stay hashable even though we've subclassed
+        them and added some shim code to them.
+        """
+        assert hash(parse_version("1.0")) == hash(parse_version("1.0"))
+
+
+class TestNamespaces:
+    ns_str = "__import__('pkg_resources').declare_namespace(__name__)\n"
+
+    @pytest.fixture
+    def symlinked_tmpdir(self, tmpdir):
+        """
+        Where available, return the tempdir as a symlink,
+        which as revealed in #231 is more fragile than
+        a natural tempdir.
+        """
+        if not hasattr(os, 'symlink'):
+            yield str(tmpdir)
+            return
+
+        link_name = str(tmpdir) + '-linked'
+        os.symlink(str(tmpdir), link_name)
+        try:
+            yield type(tmpdir)(link_name)
+        finally:
+            os.unlink(link_name)
+
+    @pytest.fixture(autouse=True)
+    def patched_path(self, tmpdir):
+        """
+        Patch sys.path to include the 'site-pkgs' dir. Also
+        restore pkg_resources._namespace_packages to its
+        former state.
+        """
+        saved_ns_pkgs = pkg_resources._namespace_packages.copy()
+        saved_sys_path = sys.path[:]
+        site_pkgs = tmpdir.mkdir('site-pkgs')
+        sys.path.append(str(site_pkgs))
+        try:
+            yield
+        finally:
+            pkg_resources._namespace_packages = saved_ns_pkgs
+            sys.path = saved_sys_path
+
+    issue591 = pytest.mark.xfail(platform.system() == 'Windows', reason="#591")
+
+    @issue591
+    def test_two_levels_deep(self, symlinked_tmpdir):
+        """
+        Test nested namespace packages
+        Create namespace packages in the following tree :
+            site-packages-1/pkg1/pkg2
+            site-packages-2/pkg1/pkg2
+        Check both are in the _namespace_packages dict and that their __path__
+        is correct
+        """
+        real_tmpdir = symlinked_tmpdir.realpath()
+        tmpdir = symlinked_tmpdir
+        sys.path.append(str(tmpdir / 'site-pkgs2'))
+        site_dirs = tmpdir / 'site-pkgs', tmpdir / 'site-pkgs2'
+        for site in site_dirs:
+            pkg1 = site / 'pkg1'
+            pkg2 = pkg1 / 'pkg2'
+            pkg2.ensure_dir()
+            (pkg1 / '__init__.py').write_text(self.ns_str, encoding='utf-8')
+            (pkg2 / '__init__.py').write_text(self.ns_str, encoding='utf-8')
+        with pytest.warns(DeprecationWarning, match="pkg_resources.declare_namespace"):
+            import pkg1  # pyright: ignore[reportMissingImports] # Temporary package for test
+        assert "pkg1" in pkg_resources._namespace_packages
+        # attempt to import pkg2 from site-pkgs2
+        with pytest.warns(DeprecationWarning, match="pkg_resources.declare_namespace"):
+            import pkg1.pkg2  # pyright: ignore[reportMissingImports] # Temporary package for test
+        # check the _namespace_packages dict
+        assert "pkg1.pkg2" in pkg_resources._namespace_packages
+        assert pkg_resources._namespace_packages["pkg1"] == ["pkg1.pkg2"]
+        # check the __path__ attribute contains both paths
+        expected = [
+            str(real_tmpdir / "site-pkgs" / "pkg1" / "pkg2"),
+            str(real_tmpdir / "site-pkgs2" / "pkg1" / "pkg2"),
+        ]
+        assert pkg1.pkg2.__path__ == expected
+
+    @issue591
+    def test_path_order(self, symlinked_tmpdir):
+        """
+        Test that if multiple versions of the same namespace package subpackage
+        are on different sys.path entries, that only the one earliest on
+        sys.path is imported, and that the namespace package's __path__ is in
+        the correct order.
+
+        Regression test for https://github.com/pypa/setuptools/issues/207
+        """
+
+        tmpdir = symlinked_tmpdir
+        site_dirs = (
+            tmpdir / "site-pkgs",
+            tmpdir / "site-pkgs2",
+            tmpdir / "site-pkgs3",
+        )
+
+        vers_str = "__version__ = %r"
+
+        for number, site in enumerate(site_dirs, 1):
+            if number > 1:
+                sys.path.append(str(site))
+            nspkg = site / 'nspkg'
+            subpkg = nspkg / 'subpkg'
+            subpkg.ensure_dir()
+            (nspkg / '__init__.py').write_text(self.ns_str, encoding='utf-8')
+            (subpkg / '__init__.py').write_text(vers_str % number, encoding='utf-8')
+
+        with pytest.warns(DeprecationWarning, match="pkg_resources.declare_namespace"):
+            import nspkg  # pyright: ignore[reportMissingImports] # Temporary package for test
+            import nspkg.subpkg  # pyright: ignore[reportMissingImports] # Temporary package for test
+        expected = [str(site.realpath() / 'nspkg') for site in site_dirs]
+        assert nspkg.__path__ == expected
+        assert nspkg.subpkg.__version__ == 1
diff --git a/tool_server/.venv/lib/python3.12/site-packages/pkg_resources/tests/test_working_set.py b/tool_server/.venv/lib/python3.12/site-packages/pkg_resources/tests/test_working_set.py
new file mode 100644
index 0000000000000000000000000000000000000000..ed20c59dd3bb100b69f323e3ef66bd037ac3804c
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/pkg_resources/tests/test_working_set.py
@@ -0,0 +1,505 @@
+import functools
+import inspect
+import re
+import textwrap
+
+import pytest
+
+import pkg_resources
+
+from .test_resources import Metadata
+
+
+def strip_comments(s):
+    return '\n'.join(
+        line
+        for line in s.split('\n')
+        if line.strip() and not line.strip().startswith('#')
+    )
+
+
+def parse_distributions(s):
+    """
+    Parse a series of distribution specs of the form:
+    {project_name}-{version}
+       [optional, indented requirements specification]
+
+    Example:
+
+        foo-0.2
+        bar-1.0
+          foo>=3.0
+          [feature]
+          baz
+
+    yield 2 distributions:
+        - project_name=foo, version=0.2
+        - project_name=bar, version=1.0,
+          requires=['foo>=3.0', 'baz; extra=="feature"']
+    """
+    s = s.strip()
+    for spec in re.split(r'\n(?=[^\s])', s):
+        if not spec:
+            continue
+        fields = spec.split('\n', 1)
+        assert 1 <= len(fields) <= 2
+        name, version = fields.pop(0).rsplit('-', 1)
+        if fields:
+            requires = textwrap.dedent(fields.pop(0))
+            metadata = Metadata(('requires.txt', requires))
+        else:
+            metadata = None
+        dist = pkg_resources.Distribution(
+            project_name=name, version=version, metadata=metadata
+        )
+        yield dist
+
+
+class FakeInstaller:
+    def __init__(self, installable_dists) -> None:
+        self._installable_dists = installable_dists
+
+    def __call__(self, req):
+        return next(
+            iter(filter(lambda dist: dist in req, self._installable_dists)), None
+        )
+
+
+def parametrize_test_working_set_resolve(*test_list):
+    idlist = []
+    argvalues = []
+    for test in test_list:
+        (
+            name,
+            installed_dists,
+            installable_dists,
+            requirements,
+            expected1,
+            expected2,
+        ) = (
+            strip_comments(s.lstrip())
+            for s in textwrap.dedent(test).lstrip().split('\n\n', 5)
+        )
+        installed_dists = list(parse_distributions(installed_dists))
+        installable_dists = list(parse_distributions(installable_dists))
+        requirements = list(pkg_resources.parse_requirements(requirements))
+        for id_, replace_conflicting, expected in (
+            (name, False, expected1),
+            (name + '_replace_conflicting', True, expected2),
+        ):
+            idlist.append(id_)
+            expected = strip_comments(expected.strip())
+            if re.match(r'\w+$', expected):
+                expected = getattr(pkg_resources, expected)
+                assert issubclass(expected, Exception)
+            else:
+                expected = list(parse_distributions(expected))
+            argvalues.append(
+                pytest.param(
+                    installed_dists,
+                    installable_dists,
+                    requirements,
+                    replace_conflicting,
+                    expected,
+                )
+            )
+    return pytest.mark.parametrize(
+        (
+            "installed_dists",
+            "installable_dists",
+            "requirements",
+            "replace_conflicting",
+            "resolved_dists_or_exception",
+        ),
+        argvalues,
+        ids=idlist,
+    )
+
+
+@parametrize_test_working_set_resolve(
+    """
+    # id
+    noop
+
+    # installed
+
+    # installable
+
+    # wanted
+
+    # resolved
+
+    # resolved [replace conflicting]
+    """,
+    """
+    # id
+    already_installed
+
+    # installed
+    foo-3.0
+
+    # installable
+
+    # wanted
+    foo>=2.1,!=3.1,<4
+
+    # resolved
+    foo-3.0
+
+    # resolved [replace conflicting]
+    foo-3.0
+    """,
+    """
+    # id
+    installable_not_installed
+
+    # installed
+
+    # installable
+    foo-3.0
+    foo-4.0
+
+    # wanted
+    foo>=2.1,!=3.1,<4
+
+    # resolved
+    foo-3.0
+
+    # resolved [replace conflicting]
+    foo-3.0
+    """,
+    """
+    # id
+    not_installable
+
+    # installed
+
+    # installable
+
+    # wanted
+    foo>=2.1,!=3.1,<4
+
+    # resolved
+    DistributionNotFound
+
+    # resolved [replace conflicting]
+    DistributionNotFound
+    """,
+    """
+    # id
+    no_matching_version
+
+    # installed
+
+    # installable
+    foo-3.1
+
+    # wanted
+    foo>=2.1,!=3.1,<4
+
+    # resolved
+    DistributionNotFound
+
+    # resolved [replace conflicting]
+    DistributionNotFound
+    """,
+    """
+    # id
+    installable_with_installed_conflict
+
+    # installed
+    foo-3.1
+
+    # installable
+    foo-3.5
+
+    # wanted
+    foo>=2.1,!=3.1,<4
+
+    # resolved
+    VersionConflict
+
+    # resolved [replace conflicting]
+    foo-3.5
+    """,
+    """
+    # id
+    not_installable_with_installed_conflict
+
+    # installed
+    foo-3.1
+
+    # installable
+
+    # wanted
+    foo>=2.1,!=3.1,<4
+
+    # resolved
+    VersionConflict
+
+    # resolved [replace conflicting]
+    DistributionNotFound
+    """,
+    """
+    # id
+    installed_with_installed_require
+
+    # installed
+    foo-3.9
+    baz-0.1
+        foo>=2.1,!=3.1,<4
+
+    # installable
+
+    # wanted
+    baz
+
+    # resolved
+    foo-3.9
+    baz-0.1
+
+    # resolved [replace conflicting]
+    foo-3.9
+    baz-0.1
+    """,
+    """
+    # id
+    installed_with_conflicting_installed_require
+
+    # installed
+    foo-5
+    baz-0.1
+        foo>=2.1,!=3.1,<4
+
+    # installable
+
+    # wanted
+    baz
+
+    # resolved
+    VersionConflict
+
+    # resolved [replace conflicting]
+    DistributionNotFound
+    """,
+    """
+    # id
+    installed_with_installable_conflicting_require
+
+    # installed
+    foo-5
+    baz-0.1
+        foo>=2.1,!=3.1,<4
+
+    # installable
+    foo-2.9
+
+    # wanted
+    baz
+
+    # resolved
+    VersionConflict
+
+    # resolved [replace conflicting]
+    baz-0.1
+    foo-2.9
+    """,
+    """
+    # id
+    installed_with_installable_require
+
+    # installed
+    baz-0.1
+        foo>=2.1,!=3.1,<4
+
+    # installable
+    foo-3.9
+
+    # wanted
+    baz
+
+    # resolved
+    foo-3.9
+    baz-0.1
+
+    # resolved [replace conflicting]
+    foo-3.9
+    baz-0.1
+    """,
+    """
+    # id
+    installable_with_installed_require
+
+    # installed
+    foo-3.9
+
+    # installable
+    baz-0.1
+        foo>=2.1,!=3.1,<4
+
+    # wanted
+    baz
+
+    # resolved
+    foo-3.9
+    baz-0.1
+
+    # resolved [replace conflicting]
+    foo-3.9
+    baz-0.1
+    """,
+    """
+    # id
+    installable_with_installable_require
+
+    # installed
+
+    # installable
+    foo-3.9
+    baz-0.1
+        foo>=2.1,!=3.1,<4
+
+    # wanted
+    baz
+
+    # resolved
+    foo-3.9
+    baz-0.1
+
+    # resolved [replace conflicting]
+    foo-3.9
+    baz-0.1
+    """,
+    """
+    # id
+    installable_with_conflicting_installable_require
+
+    # installed
+    foo-5
+
+    # installable
+    foo-2.9
+    baz-0.1
+        foo>=2.1,!=3.1,<4
+
+    # wanted
+    baz
+
+    # resolved
+    VersionConflict
+
+    # resolved [replace conflicting]
+    baz-0.1
+    foo-2.9
+    """,
+    """
+    # id
+    conflicting_installables
+
+    # installed
+
+    # installable
+    foo-2.9
+    foo-5.0
+
+    # wanted
+    foo>=2.1,!=3.1,<4
+    foo>=4
+
+    # resolved
+    VersionConflict
+
+    # resolved [replace conflicting]
+    VersionConflict
+    """,
+    """
+    # id
+    installables_with_conflicting_requires
+
+    # installed
+
+    # installable
+    foo-2.9
+        dep==1.0
+    baz-5.0
+        dep==2.0
+    dep-1.0
+    dep-2.0
+
+    # wanted
+    foo
+    baz
+
+    # resolved
+    VersionConflict
+
+    # resolved [replace conflicting]
+    VersionConflict
+    """,
+    """
+    # id
+    installables_with_conflicting_nested_requires
+
+    # installed
+
+    # installable
+    foo-2.9
+        dep1
+    dep1-1.0
+        subdep<1.0
+    baz-5.0
+        dep2
+    dep2-1.0
+        subdep>1.0
+    subdep-0.9
+    subdep-1.1
+
+    # wanted
+    foo
+    baz
+
+    # resolved
+    VersionConflict
+
+    # resolved [replace conflicting]
+    VersionConflict
+    """,
+    """
+    # id
+    wanted_normalized_name_installed_canonical
+
+    # installed
+    foo.bar-3.6
+
+    # installable
+
+    # wanted
+    foo-bar==3.6
+
+    # resolved
+    foo.bar-3.6
+
+    # resolved [replace conflicting]
+    foo.bar-3.6
+    """,
+)
+def test_working_set_resolve(
+    installed_dists,
+    installable_dists,
+    requirements,
+    replace_conflicting,
+    resolved_dists_or_exception,
+):
+    ws = pkg_resources.WorkingSet([])
+    list(map(ws.add, installed_dists))
+    resolve_call = functools.partial(
+        ws.resolve,
+        requirements,
+        installer=FakeInstaller(installable_dists),
+        replace_conflicting=replace_conflicting,
+    )
+    if inspect.isclass(resolved_dists_or_exception):
+        with pytest.raises(resolved_dists_or_exception):
+            resolve_call()
+    else:
+        assert sorted(resolve_call()) == sorted(resolved_dists_or_exception)
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/__pycache__/__init__.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/setuptools/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..e5aca739ce76637092bc49c0d9479ddecef8d6a7
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/setuptools/__pycache__/__init__.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/__pycache__/_core_metadata.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/setuptools/__pycache__/_core_metadata.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b80201e16b63fd16320fad261502184642d64560
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/setuptools/__pycache__/_core_metadata.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/__pycache__/_entry_points.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/setuptools/__pycache__/_entry_points.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..4a92c7a47bd7703b43e29910fe8c6cf9d8b5ddbe
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/setuptools/__pycache__/_entry_points.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/__pycache__/_imp.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/setuptools/__pycache__/_imp.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..cc2ffbc61b2b7ed3a06a6c5f883973a100acac2a
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/setuptools/__pycache__/_imp.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/__pycache__/_importlib.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/setuptools/__pycache__/_importlib.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f352d0cc9c98f6617f0495d7d4cb4052f3c05207
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/setuptools/__pycache__/_importlib.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/__pycache__/_itertools.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/setuptools/__pycache__/_itertools.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..225b9b013a52f0cc13b052987b0eb4b0f979d167
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/setuptools/__pycache__/_itertools.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/__pycache__/_normalization.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/setuptools/__pycache__/_normalization.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..75d13f88793f69fd67f795b07d924e30a42b4ce9
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/setuptools/__pycache__/_normalization.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/__pycache__/_path.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/setuptools/__pycache__/_path.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a1f80c61988d40f537629a3d83a3ef71848b40be
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/setuptools/__pycache__/_path.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/__pycache__/_reqs.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/setuptools/__pycache__/_reqs.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..25490c58c45dd9c79d610df55cd675aa2a475672
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/setuptools/__pycache__/_reqs.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/__pycache__/_shutil.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/setuptools/__pycache__/_shutil.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b3cae329909b7a2309596006780f097e75313b56
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/setuptools/__pycache__/_shutil.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/__pycache__/_static.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/setuptools/__pycache__/_static.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b2a2067f9891661ecee6e9abbac9fc81b2d62e9b
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/setuptools/__pycache__/_static.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/__pycache__/archive_util.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/setuptools/__pycache__/archive_util.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..6cfd6526a736b77f4a0b42c3354d27b76229f8fd
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/setuptools/__pycache__/archive_util.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/__pycache__/build_meta.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/setuptools/__pycache__/build_meta.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..0a1fb4d9dd1745ac64abadc705608e9add0ae5a7
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/setuptools/__pycache__/build_meta.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/__pycache__/depends.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/setuptools/__pycache__/depends.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5eed492293ec28a071b84d5010c383484a37210b
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/setuptools/__pycache__/depends.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/__pycache__/discovery.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/setuptools/__pycache__/discovery.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5cd5db70d12be279095aec20f7b50aadcef8c3c5
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/setuptools/__pycache__/discovery.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/__pycache__/dist.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/setuptools/__pycache__/dist.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f7ee8662b702694d2329e2365e20f8893a55b030
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/setuptools/__pycache__/dist.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/__pycache__/errors.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/setuptools/__pycache__/errors.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c1b8e34a8c67a18944357b34dd2c074f921499ff
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/setuptools/__pycache__/errors.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/__pycache__/extension.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/setuptools/__pycache__/extension.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..aa0a62b5651315e602dd09f18f18766f0526b4ad
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/setuptools/__pycache__/extension.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/__pycache__/glob.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/setuptools/__pycache__/glob.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..e9ec4458b86ffb80c6d9dcbb4f65bb10aacee6af
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/setuptools/__pycache__/glob.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/__pycache__/installer.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/setuptools/__pycache__/installer.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..1ae334068aac6384b21577b8ddc5c9d7bd605bea
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/setuptools/__pycache__/installer.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/__pycache__/launch.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/setuptools/__pycache__/launch.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b0c3935648571e7508aa8ae66e0a3775f648f171
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/setuptools/__pycache__/launch.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/__pycache__/logging.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/setuptools/__pycache__/logging.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..0ee44b1515f8b3ee6bcb00af87d0aecf71511753
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/setuptools/__pycache__/logging.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/__pycache__/modified.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/setuptools/__pycache__/modified.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..53bca4ab7f9282ddde8cb788787379be0912c44b
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/setuptools/__pycache__/modified.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/__pycache__/monkey.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/setuptools/__pycache__/monkey.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..7b1a9daa2a46c5ff27d9a340d99f115fcb10bf47
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/setuptools/__pycache__/monkey.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/__pycache__/msvc.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/setuptools/__pycache__/msvc.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..95a17ecc031ca688eacf9f4438b82f13e48eb354
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/setuptools/__pycache__/msvc.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/__pycache__/namespaces.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/setuptools/__pycache__/namespaces.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..1c53f769effaaf988109eccad614eb928785c79b
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/setuptools/__pycache__/namespaces.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/__pycache__/package_index.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/setuptools/__pycache__/package_index.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..056bfc99c3a48a9a4ea72bb30f7a78e02f8feb6a
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/setuptools/__pycache__/package_index.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/__pycache__/sandbox.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/setuptools/__pycache__/sandbox.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..78288e6dec3eb40fcdacf34e5aa87fe67224e88d
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/setuptools/__pycache__/sandbox.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/__pycache__/unicode_utils.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/setuptools/__pycache__/unicode_utils.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..0485b79f7e41c2b07405cb4c1e5f3d20d62a4019
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/setuptools/__pycache__/unicode_utils.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/__pycache__/version.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/setuptools/__pycache__/version.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..7afe2dbdeb17de4881b404f4643e1ecb06ca55f9
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/setuptools/__pycache__/version.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/__pycache__/warnings.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/setuptools/__pycache__/warnings.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..73382f20e267f5d0cd41056fff316299ec50133f
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/setuptools/__pycache__/warnings.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/__pycache__/wheel.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/setuptools/__pycache__/wheel.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..251b757c29c7b5df6ab77b86de04e1d17ad2b0e6
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/setuptools/__pycache__/wheel.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/__pycache__/windows_support.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/setuptools/__pycache__/windows_support.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..6a561de2b6a867cbd78f65bc5b08d0e202973eb4
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/setuptools/__pycache__/windows_support.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/__init__.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e374d5c5604d0eeed555e68b7523bfac72fd9101
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/__init__.py
@@ -0,0 +1,14 @@
+import importlib
+import sys
+
+__version__, _, _ = sys.version.partition(' ')
+
+
+try:
+    # Allow Debian and pkgsrc (only) to customize system
+    # behavior. Ref pypa/distutils#2 and pypa/distutils#16.
+    # This hook is deprecated and no other environments
+    # should use it.
+    importlib.import_module('_distutils_system_mod')
+except ImportError:
+    pass
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/__init__.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..3485a193fcecdab6bcc2f8c9743947b9f25336d6
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/__init__.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/_log.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/_log.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..413152c2b1243e6f95b07d60273f7752469ef8ea
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/_log.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/_macos_compat.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/_macos_compat.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..6151393e60c8b723f7c5a7432f39eef9d758f671
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/_macos_compat.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/_modified.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/_modified.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a2ddcaebb944c7b7432d098c08409a92f9f08964
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/_modified.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/_msvccompiler.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/_msvccompiler.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..8cef81c2d3f6f9c194805438851be0b903fe3bd9
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/_msvccompiler.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/archive_util.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/archive_util.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..9116560bbc51e3a20418a048e463e955b3d2ed68
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/archive_util.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/ccompiler.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/ccompiler.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..981e07eaa6e02692b152a9927db8076f535def9d
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/ccompiler.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/cmd.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/cmd.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..2ece9c9e26b35d4e0654a58c2a17b6d6e891ce58
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/cmd.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/core.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/core.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..7ed4b292c6ded6a17693a2de06756ad868f50a9e
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/core.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/cygwinccompiler.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/cygwinccompiler.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ccfb71bf0b2f0c195357f9ab44cbf40d6989cb72
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/cygwinccompiler.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/debug.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/debug.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..030cc24c6bd10ce87fb21f036cd0aaba26b8c564
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/debug.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/dep_util.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/dep_util.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..2f04240036d41a4a080424b20ecbd86646f3f9c9
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/dep_util.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/dir_util.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/dir_util.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..2c345a782c9b09db4cfdaea26a38dc3c081ac531
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/dir_util.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/dist.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/dist.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..3bed9a337470d88f0b0a3212b6fd895d6400087f
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/dist.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/errors.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/errors.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..632ac8613c4ec78ebfbd981f3abe1934003b512d
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/errors.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/extension.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/extension.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..83aa2e2441d22ed5b4dfd08fcbc531e7de7e21f3
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/extension.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/fancy_getopt.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/fancy_getopt.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..93c2637f8f8b67d89f49d709d5f22a35d5fd24a1
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/fancy_getopt.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/file_util.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/file_util.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..8ba19b465d54c4c5af971e6ea86788aa83c94407
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/file_util.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/filelist.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/filelist.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..4930a47303a2d4a2d1aad30ddc1f9c26a555ce74
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/filelist.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/log.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/log.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..0bce8f23a1dbecc6319f0a8fa4dfb510a683fa4c
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/log.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/spawn.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/spawn.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5f818b597614ef88428077ded4ea4009bd2b26c4
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/spawn.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/sysconfig.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/sysconfig.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f7ab54b6192ed0e878f6d05169ce05ef1c6353e9
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/sysconfig.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/text_file.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/text_file.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..63d23bb149fad9e87641a60fcb91d9ad0a1471af
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/text_file.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/unixccompiler.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/unixccompiler.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..58f4222e6ed1dc03428caceaaede1bd696ababd1
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/unixccompiler.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/util.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/util.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..461bc74045f3a296e5ce28b92df2de13de6a05e9
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/util.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/version.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/version.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..6741dcaa2ded8ed1b7951b4cf7f0f85593e4ea73
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/version.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/versionpredicate.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/versionpredicate.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f1dd4515623bd0d4a1ee29e76b5e4edfbfde7ac8
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/versionpredicate.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/zosccompiler.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/zosccompiler.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..42dc8132d2263284f5ac1724528c0036efa2f149
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/__pycache__/zosccompiler.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/_log.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/_log.py
new file mode 100644
index 0000000000000000000000000000000000000000..0148f157ff3bf8bd728c82f49cd3d1cd9cb5a43e
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/_log.py
@@ -0,0 +1,3 @@
+import logging
+
+log = logging.getLogger()
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/_macos_compat.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/_macos_compat.py
new file mode 100644
index 0000000000000000000000000000000000000000..76ecb96abe478313ce7d09342b2643bf4a765331
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/_macos_compat.py
@@ -0,0 +1,12 @@
+import importlib
+import sys
+
+
+def bypass_compiler_fixup(cmd, args):
+    return cmd
+
+
+if sys.platform == 'darwin':
+    compiler_fixup = importlib.import_module('_osx_support').compiler_fixup
+else:
+    compiler_fixup = bypass_compiler_fixup
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/_modified.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/_modified.py
new file mode 100644
index 0000000000000000000000000000000000000000..f64cab7d61ae20dd0c425b8843b068f39faa6961
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/_modified.py
@@ -0,0 +1,95 @@
+"""Timestamp comparison of files and groups of files."""
+
+from __future__ import annotations
+
+import functools
+import os.path
+from collections.abc import Callable, Iterable
+from typing import Literal, TypeVar
+
+from jaraco.functools import splat
+
+from .compat.py39 import zip_strict
+from .errors import DistutilsFileError
+
+_SourcesT = TypeVar(
+    "_SourcesT", bound="str | bytes | os.PathLike[str] | os.PathLike[bytes]"
+)
+_TargetsT = TypeVar(
+    "_TargetsT", bound="str | bytes | os.PathLike[str] | os.PathLike[bytes]"
+)
+
+
+def _newer(source, target):
+    return not os.path.exists(target) or (
+        os.path.getmtime(source) > os.path.getmtime(target)
+    )
+
+
+def newer(
+    source: str | bytes | os.PathLike[str] | os.PathLike[bytes],
+    target: str | bytes | os.PathLike[str] | os.PathLike[bytes],
+) -> bool:
+    """
+    Is source modified more recently than target.
+
+    Returns True if 'source' is modified more recently than
+    'target' or if 'target' does not exist.
+
+    Raises DistutilsFileError if 'source' does not exist.
+    """
+    if not os.path.exists(source):
+        raise DistutilsFileError(f"file {os.path.abspath(source)!r} does not exist")
+
+    return _newer(source, target)
+
+
+def newer_pairwise(
+    sources: Iterable[_SourcesT],
+    targets: Iterable[_TargetsT],
+    newer: Callable[[_SourcesT, _TargetsT], bool] = newer,
+) -> tuple[list[_SourcesT], list[_TargetsT]]:
+    """
+    Filter filenames where sources are newer than targets.
+
+    Walk two filename iterables in parallel, testing if each source is newer
+    than its corresponding target.  Returns a pair of lists (sources,
+    targets) where source is newer than target, according to the semantics
+    of 'newer()'.
+    """
+    newer_pairs = filter(splat(newer), zip_strict(sources, targets))
+    return tuple(map(list, zip(*newer_pairs))) or ([], [])
+
+
+def newer_group(
+    sources: Iterable[str | bytes | os.PathLike[str] | os.PathLike[bytes]],
+    target: str | bytes | os.PathLike[str] | os.PathLike[bytes],
+    missing: Literal["error", "ignore", "newer"] = "error",
+) -> bool:
+    """
+    Is target out-of-date with respect to any file in sources.
+
+    Return True if 'target' is out-of-date with respect to any file
+    listed in 'sources'. In other words, if 'target' exists and is newer
+    than every file in 'sources', return False; otherwise return True.
+    ``missing`` controls how to handle a missing source file:
+
+    - error (default): allow the ``stat()`` call to fail.
+    - ignore: silently disregard any missing source files.
+    - newer: treat missing source files as "target out of date". This
+      mode is handy in "dry-run" mode: it will pretend to carry out
+      commands that wouldn't work because inputs are missing, but
+      that doesn't matter because dry-run won't run the commands.
+    """
+
+    def missing_as_newer(source):
+        return missing == 'newer' and not os.path.exists(source)
+
+    ignored = os.path.exists if missing == 'ignore' else None
+    return not os.path.exists(target) or any(
+        missing_as_newer(source) or _newer(source, target)
+        for source in filter(ignored, sources)
+    )
+
+
+newer_pairwise_group = functools.partial(newer_pairwise, newer=newer_group)
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/_msvccompiler.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/_msvccompiler.py
new file mode 100644
index 0000000000000000000000000000000000000000..d07c86ef8e41fc31357c989133d51e9618c3e43d
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/_msvccompiler.py
@@ -0,0 +1,16 @@
+import warnings
+
+from .compilers.C import msvc
+
+__all__ = ["MSVCCompiler"]
+
+MSVCCompiler = msvc.Compiler
+
+
+def __getattr__(name):
+    if name == '_get_vc_env':
+        warnings.warn(
+            "_get_vc_env is private; find an alternative (pypa/distutils#340)"
+        )
+        return msvc._get_vc_env
+    raise AttributeError(name)
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/archive_util.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/archive_util.py
new file mode 100644
index 0000000000000000000000000000000000000000..d860f5527234567a0b726ea07116ae2c8e6bc3d2
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/archive_util.py
@@ -0,0 +1,294 @@
+"""distutils.archive_util
+
+Utility functions for creating archive files (tarballs, zip files,
+that sort of thing)."""
+
+from __future__ import annotations
+
+import os
+from typing import Literal, overload
+
+try:
+    import zipfile
+except ImportError:
+    zipfile = None
+
+
+from ._log import log
+from .dir_util import mkpath
+from .errors import DistutilsExecError
+from .spawn import spawn
+
+try:
+    from pwd import getpwnam
+except ImportError:
+    getpwnam = None
+
+try:
+    from grp import getgrnam
+except ImportError:
+    getgrnam = None
+
+
+def _get_gid(name):
+    """Returns a gid, given a group name."""
+    if getgrnam is None or name is None:
+        return None
+    try:
+        result = getgrnam(name)
+    except KeyError:
+        result = None
+    if result is not None:
+        return result[2]
+    return None
+
+
+def _get_uid(name):
+    """Returns an uid, given a user name."""
+    if getpwnam is None or name is None:
+        return None
+    try:
+        result = getpwnam(name)
+    except KeyError:
+        result = None
+    if result is not None:
+        return result[2]
+    return None
+
+
+def make_tarball(
+    base_name: str,
+    base_dir: str | os.PathLike[str],
+    compress: Literal["gzip", "bzip2", "xz"] | None = "gzip",
+    verbose: bool = False,
+    dry_run: bool = False,
+    owner: str | None = None,
+    group: str | None = None,
+) -> str:
+    """Create a (possibly compressed) tar file from all the files under
+    'base_dir'.
+
+    'compress' must be "gzip" (the default), "bzip2", "xz", or None.
+
+    'owner' and 'group' can be used to define an owner and a group for the
+    archive that is being built. If not provided, the current owner and group
+    will be used.
+
+    The output tar file will be named 'base_dir' +  ".tar", possibly plus
+    the appropriate compression extension (".gz", ".bz2", ".xz" or ".Z").
+
+    Returns the output filename.
+    """
+    tar_compression = {
+        'gzip': 'gz',
+        'bzip2': 'bz2',
+        'xz': 'xz',
+        None: '',
+    }
+    compress_ext = {'gzip': '.gz', 'bzip2': '.bz2', 'xz': '.xz'}
+
+    # flags for compression program, each element of list will be an argument
+    if compress is not None and compress not in compress_ext.keys():
+        raise ValueError(
+            "bad value for 'compress': must be None, 'gzip', 'bzip2', 'xz'"
+        )
+
+    archive_name = base_name + '.tar'
+    archive_name += compress_ext.get(compress, '')
+
+    mkpath(os.path.dirname(archive_name), dry_run=dry_run)
+
+    # creating the tarball
+    import tarfile  # late import so Python build itself doesn't break
+
+    log.info('Creating tar archive')
+
+    uid = _get_uid(owner)
+    gid = _get_gid(group)
+
+    def _set_uid_gid(tarinfo):
+        if gid is not None:
+            tarinfo.gid = gid
+            tarinfo.gname = group
+        if uid is not None:
+            tarinfo.uid = uid
+            tarinfo.uname = owner
+        return tarinfo
+
+    if not dry_run:
+        tar = tarfile.open(archive_name, f'w|{tar_compression[compress]}')
+        try:
+            tar.add(base_dir, filter=_set_uid_gid)
+        finally:
+            tar.close()
+
+    return archive_name
+
+
+def make_zipfile(  # noqa: C901
+    base_name: str,
+    base_dir: str | os.PathLike[str],
+    verbose: bool = False,
+    dry_run: bool = False,
+) -> str:
+    """Create a zip file from all the files under 'base_dir'.
+
+    The output zip file will be named 'base_name' + ".zip".  Uses either the
+    "zipfile" Python module (if available) or the InfoZIP "zip" utility
+    (if installed and found on the default search path).  If neither tool is
+    available, raises DistutilsExecError.  Returns the name of the output zip
+    file.
+    """
+    zip_filename = base_name + ".zip"
+    mkpath(os.path.dirname(zip_filename), dry_run=dry_run)
+
+    # If zipfile module is not available, try spawning an external
+    # 'zip' command.
+    if zipfile is None:
+        if verbose:
+            zipoptions = "-r"
+        else:
+            zipoptions = "-rq"
+
+        try:
+            spawn(["zip", zipoptions, zip_filename, base_dir], dry_run=dry_run)
+        except DistutilsExecError:
+            # XXX really should distinguish between "couldn't find
+            # external 'zip' command" and "zip failed".
+            raise DistutilsExecError(
+                f"unable to create zip file '{zip_filename}': "
+                "could neither import the 'zipfile' module nor "
+                "find a standalone zip utility"
+            )
+
+    else:
+        log.info("creating '%s' and adding '%s' to it", zip_filename, base_dir)
+
+        if not dry_run:
+            try:
+                zip = zipfile.ZipFile(
+                    zip_filename, "w", compression=zipfile.ZIP_DEFLATED
+                )
+            except RuntimeError:
+                zip = zipfile.ZipFile(zip_filename, "w", compression=zipfile.ZIP_STORED)
+
+            with zip:
+                if base_dir != os.curdir:
+                    path = os.path.normpath(os.path.join(base_dir, ''))
+                    zip.write(path, path)
+                    log.info("adding '%s'", path)
+                for dirpath, dirnames, filenames in os.walk(base_dir):
+                    for name in dirnames:
+                        path = os.path.normpath(os.path.join(dirpath, name, ''))
+                        zip.write(path, path)
+                        log.info("adding '%s'", path)
+                    for name in filenames:
+                        path = os.path.normpath(os.path.join(dirpath, name))
+                        if os.path.isfile(path):
+                            zip.write(path, path)
+                            log.info("adding '%s'", path)
+
+    return zip_filename
+
+
+ARCHIVE_FORMATS = {
+    'gztar': (make_tarball, [('compress', 'gzip')], "gzip'ed tar-file"),
+    'bztar': (make_tarball, [('compress', 'bzip2')], "bzip2'ed tar-file"),
+    'xztar': (make_tarball, [('compress', 'xz')], "xz'ed tar-file"),
+    'ztar': (make_tarball, [('compress', 'compress')], "compressed tar file"),
+    'tar': (make_tarball, [('compress', None)], "uncompressed tar file"),
+    'zip': (make_zipfile, [], "ZIP file"),
+}
+
+
+def check_archive_formats(formats):
+    """Returns the first format from the 'format' list that is unknown.
+
+    If all formats are known, returns None
+    """
+    for format in formats:
+        if format not in ARCHIVE_FORMATS:
+            return format
+    return None
+
+
+@overload
+def make_archive(
+    base_name: str,
+    format: str,
+    root_dir: str | os.PathLike[str] | bytes | os.PathLike[bytes] | None = None,
+    base_dir: str | None = None,
+    verbose: bool = False,
+    dry_run: bool = False,
+    owner: str | None = None,
+    group: str | None = None,
+) -> str: ...
+@overload
+def make_archive(
+    base_name: str | os.PathLike[str],
+    format: str,
+    root_dir: str | os.PathLike[str] | bytes | os.PathLike[bytes],
+    base_dir: str | None = None,
+    verbose: bool = False,
+    dry_run: bool = False,
+    owner: str | None = None,
+    group: str | None = None,
+) -> str: ...
+def make_archive(
+    base_name: str | os.PathLike[str],
+    format: str,
+    root_dir: str | os.PathLike[str] | bytes | os.PathLike[bytes] | None = None,
+    base_dir: str | None = None,
+    verbose: bool = False,
+    dry_run: bool = False,
+    owner: str | None = None,
+    group: str | None = None,
+) -> str:
+    """Create an archive file (eg. zip or tar).
+
+    'base_name' is the name of the file to create, minus any format-specific
+    extension; 'format' is the archive format: one of "zip", "tar", "gztar",
+    "bztar", "xztar", or "ztar".
+
+    'root_dir' is a directory that will be the root directory of the
+    archive; ie. we typically chdir into 'root_dir' before creating the
+    archive.  'base_dir' is the directory where we start archiving from;
+    ie. 'base_dir' will be the common prefix of all files and
+    directories in the archive.  'root_dir' and 'base_dir' both default
+    to the current directory.  Returns the name of the archive file.
+
+    'owner' and 'group' are used when creating a tar archive. By default,
+    uses the current owner and group.
+    """
+    save_cwd = os.getcwd()
+    if root_dir is not None:
+        log.debug("changing into '%s'", root_dir)
+        base_name = os.path.abspath(base_name)
+        if not dry_run:
+            os.chdir(root_dir)
+
+    if base_dir is None:
+        base_dir = os.curdir
+
+    kwargs = {'dry_run': dry_run}
+
+    try:
+        format_info = ARCHIVE_FORMATS[format]
+    except KeyError:
+        raise ValueError(f"unknown archive format '{format}'")
+
+    func = format_info[0]
+    kwargs.update(format_info[1])
+
+    if format != 'zip':
+        kwargs['owner'] = owner
+        kwargs['group'] = group
+
+    try:
+        filename = func(base_name, base_dir, **kwargs)
+    finally:
+        if root_dir is not None:
+            log.debug("changing back to '%s'", save_cwd)
+            os.chdir(save_cwd)
+
+    return filename
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/ccompiler.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/ccompiler.py
new file mode 100644
index 0000000000000000000000000000000000000000..58bc6a55e24fd2b0b170e4499c6095e934313827
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/ccompiler.py
@@ -0,0 +1,26 @@
+from .compat.numpy import (  # noqa: F401
+    _default_compilers,
+    compiler_class,
+)
+from .compilers.C import base
+from .compilers.C.base import (
+    gen_lib_options,
+    gen_preprocess_options,
+    get_default_compiler,
+    new_compiler,
+    show_compilers,
+)
+from .compilers.C.errors import CompileError, LinkError
+
+__all__ = [
+    'CompileError',
+    'LinkError',
+    'gen_lib_options',
+    'gen_preprocess_options',
+    'get_default_compiler',
+    'new_compiler',
+    'show_compilers',
+]
+
+
+CCompiler = base.Compiler
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/cmd.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/cmd.py
new file mode 100644
index 0000000000000000000000000000000000000000..241621bd51340819c5216883a0e73929c9fd20b0
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/cmd.py
@@ -0,0 +1,554 @@
+"""distutils.cmd
+
+Provides the Command class, the base class for the command classes
+in the distutils.command package.
+"""
+
+from __future__ import annotations
+
+import logging
+import os
+import re
+import sys
+from abc import abstractmethod
+from collections.abc import Callable, MutableSequence
+from typing import TYPE_CHECKING, Any, ClassVar, TypeVar, overload
+
+from . import _modified, archive_util, dir_util, file_util, util
+from ._log import log
+from .errors import DistutilsOptionError
+
+if TYPE_CHECKING:
+    # type-only import because of mutual dependence between these classes
+    from distutils.dist import Distribution
+
+    from typing_extensions import TypeVarTuple, Unpack
+
+    _Ts = TypeVarTuple("_Ts")
+
+_StrPathT = TypeVar("_StrPathT", bound="str | os.PathLike[str]")
+_BytesPathT = TypeVar("_BytesPathT", bound="bytes | os.PathLike[bytes]")
+_CommandT = TypeVar("_CommandT", bound="Command")
+
+
+class Command:
+    """Abstract base class for defining command classes, the "worker bees"
+    of the Distutils.  A useful analogy for command classes is to think of
+    them as subroutines with local variables called "options".  The options
+    are "declared" in 'initialize_options()' and "defined" (given their
+    final values, aka "finalized") in 'finalize_options()', both of which
+    must be defined by every command class.  The distinction between the
+    two is necessary because option values might come from the outside
+    world (command line, config file, ...), and any options dependent on
+    other options must be computed *after* these outside influences have
+    been processed -- hence 'finalize_options()'.  The "body" of the
+    subroutine, where it does all its work based on the values of its
+    options, is the 'run()' method, which must also be implemented by every
+    command class.
+    """
+
+    # 'sub_commands' formalizes the notion of a "family" of commands,
+    # eg. "install" as the parent with sub-commands "install_lib",
+    # "install_headers", etc.  The parent of a family of commands
+    # defines 'sub_commands' as a class attribute; it's a list of
+    #    (command_name : string, predicate : unbound_method | string | None)
+    # tuples, where 'predicate' is a method of the parent command that
+    # determines whether the corresponding command is applicable in the
+    # current situation.  (Eg. we "install_headers" is only applicable if
+    # we have any C header files to install.)  If 'predicate' is None,
+    # that command is always applicable.
+    #
+    # 'sub_commands' is usually defined at the *end* of a class, because
+    # predicates can be unbound methods, so they must already have been
+    # defined.  The canonical example is the "install" command.
+    sub_commands: ClassVar[  # Any to work around variance issues
+        list[tuple[str, Callable[[Any], bool] | None]]
+    ] = []
+
+    user_options: ClassVar[
+        # Specifying both because list is invariant. Avoids mypy override assignment issues
+        list[tuple[str, str, str]] | list[tuple[str, str | None, str]]
+    ] = []
+
+    # -- Creation/initialization methods -------------------------------
+
+    def __init__(self, dist: Distribution) -> None:
+        """Create and initialize a new Command object.  Most importantly,
+        invokes the 'initialize_options()' method, which is the real
+        initializer and depends on the actual command being
+        instantiated.
+        """
+        # late import because of mutual dependence between these classes
+        from distutils.dist import Distribution
+
+        if not isinstance(dist, Distribution):
+            raise TypeError("dist must be a Distribution instance")
+        if self.__class__ is Command:
+            raise RuntimeError("Command is an abstract class")
+
+        self.distribution = dist
+        self.initialize_options()
+
+        # Per-command versions of the global flags, so that the user can
+        # customize Distutils' behaviour command-by-command and let some
+        # commands fall back on the Distribution's behaviour.  None means
+        # "not defined, check self.distribution's copy", while 0 or 1 mean
+        # false and true (duh).  Note that this means figuring out the real
+        # value of each flag is a touch complicated -- hence "self._dry_run"
+        # will be handled by __getattr__, below.
+        # XXX This needs to be fixed.
+        self._dry_run = None
+
+        # verbose is largely ignored, but needs to be set for
+        # backwards compatibility (I think)?
+        self.verbose = dist.verbose
+
+        # Some commands define a 'self.force' option to ignore file
+        # timestamps, but methods defined *here* assume that
+        # 'self.force' exists for all commands.  So define it here
+        # just to be safe.
+        self.force = None
+
+        # The 'help' flag is just used for command-line parsing, so
+        # none of that complicated bureaucracy is needed.
+        self.help = False
+
+        # 'finalized' records whether or not 'finalize_options()' has been
+        # called.  'finalize_options()' itself should not pay attention to
+        # this flag: it is the business of 'ensure_finalized()', which
+        # always calls 'finalize_options()', to respect/update it.
+        self.finalized = False
+
+    # XXX A more explicit way to customize dry_run would be better.
+    def __getattr__(self, attr):
+        if attr == 'dry_run':
+            myval = getattr(self, "_" + attr)
+            if myval is None:
+                return getattr(self.distribution, attr)
+            else:
+                return myval
+        else:
+            raise AttributeError(attr)
+
+    def ensure_finalized(self) -> None:
+        if not self.finalized:
+            self.finalize_options()
+        self.finalized = True
+
+    # Subclasses must define:
+    #   initialize_options()
+    #     provide default values for all options; may be customized by
+    #     setup script, by options from config file(s), or by command-line
+    #     options
+    #   finalize_options()
+    #     decide on the final values for all options; this is called
+    #     after all possible intervention from the outside world
+    #     (command-line, option file, etc.) has been processed
+    #   run()
+    #     run the command: do whatever it is we're here to do,
+    #     controlled by the command's various option values
+
+    @abstractmethod
+    def initialize_options(self) -> None:
+        """Set default values for all the options that this command
+        supports.  Note that these defaults may be overridden by other
+        commands, by the setup script, by config files, or by the
+        command-line.  Thus, this is not the place to code dependencies
+        between options; generally, 'initialize_options()' implementations
+        are just a bunch of "self.foo = None" assignments.
+
+        This method must be implemented by all command classes.
+        """
+        raise RuntimeError(
+            f"abstract method -- subclass {self.__class__} must override"
+        )
+
+    @abstractmethod
+    def finalize_options(self) -> None:
+        """Set final values for all the options that this command supports.
+        This is always called as late as possible, ie.  after any option
+        assignments from the command-line or from other commands have been
+        done.  Thus, this is the place to code option dependencies: if
+        'foo' depends on 'bar', then it is safe to set 'foo' from 'bar' as
+        long as 'foo' still has the same value it was assigned in
+        'initialize_options()'.
+
+        This method must be implemented by all command classes.
+        """
+        raise RuntimeError(
+            f"abstract method -- subclass {self.__class__} must override"
+        )
+
+    def dump_options(self, header=None, indent=""):
+        from distutils.fancy_getopt import longopt_xlate
+
+        if header is None:
+            header = f"command options for '{self.get_command_name()}':"
+        self.announce(indent + header, level=logging.INFO)
+        indent = indent + "  "
+        for option, _, _ in self.user_options:
+            option = option.translate(longopt_xlate)
+            if option[-1] == "=":
+                option = option[:-1]
+            value = getattr(self, option)
+            self.announce(indent + f"{option} = {value}", level=logging.INFO)
+
+    @abstractmethod
+    def run(self) -> None:
+        """A command's raison d'etre: carry out the action it exists to
+        perform, controlled by the options initialized in
+        'initialize_options()', customized by other commands, the setup
+        script, the command-line, and config files, and finalized in
+        'finalize_options()'.  All terminal output and filesystem
+        interaction should be done by 'run()'.
+
+        This method must be implemented by all command classes.
+        """
+        raise RuntimeError(
+            f"abstract method -- subclass {self.__class__} must override"
+        )
+
+    def announce(self, msg: object, level: int = logging.DEBUG) -> None:
+        log.log(level, msg)
+
+    def debug_print(self, msg: object) -> None:
+        """Print 'msg' to stdout if the global DEBUG (taken from the
+        DISTUTILS_DEBUG environment variable) flag is true.
+        """
+        from distutils.debug import DEBUG
+
+        if DEBUG:
+            print(msg)
+            sys.stdout.flush()
+
+    # -- Option validation methods -------------------------------------
+    # (these are very handy in writing the 'finalize_options()' method)
+    #
+    # NB. the general philosophy here is to ensure that a particular option
+    # value meets certain type and value constraints.  If not, we try to
+    # force it into conformance (eg. if we expect a list but have a string,
+    # split the string on comma and/or whitespace).  If we can't force the
+    # option into conformance, raise DistutilsOptionError.  Thus, command
+    # classes need do nothing more than (eg.)
+    #   self.ensure_string_list('foo')
+    # and they can be guaranteed that thereafter, self.foo will be
+    # a list of strings.
+
+    def _ensure_stringlike(self, option, what, default=None):
+        val = getattr(self, option)
+        if val is None:
+            setattr(self, option, default)
+            return default
+        elif not isinstance(val, str):
+            raise DistutilsOptionError(f"'{option}' must be a {what} (got `{val}`)")
+        return val
+
+    def ensure_string(self, option: str, default: str | None = None) -> None:
+        """Ensure that 'option' is a string; if not defined, set it to
+        'default'.
+        """
+        self._ensure_stringlike(option, "string", default)
+
+    def ensure_string_list(self, option: str) -> None:
+        r"""Ensure that 'option' is a list of strings.  If 'option' is
+        currently a string, we split it either on /,\s*/ or /\s+/, so
+        "foo bar baz", "foo,bar,baz", and "foo,   bar baz" all become
+        ["foo", "bar", "baz"].
+        """
+        val = getattr(self, option)
+        if val is None:
+            return
+        elif isinstance(val, str):
+            setattr(self, option, re.split(r',\s*|\s+', val))
+        else:
+            if isinstance(val, list):
+                ok = all(isinstance(v, str) for v in val)
+            else:
+                ok = False
+            if not ok:
+                raise DistutilsOptionError(
+                    f"'{option}' must be a list of strings (got {val!r})"
+                )
+
+    def _ensure_tested_string(self, option, tester, what, error_fmt, default=None):
+        val = self._ensure_stringlike(option, what, default)
+        if val is not None and not tester(val):
+            raise DistutilsOptionError(
+                ("error in '%s' option: " + error_fmt) % (option, val)
+            )
+
+    def ensure_filename(self, option: str) -> None:
+        """Ensure that 'option' is the name of an existing file."""
+        self._ensure_tested_string(
+            option, os.path.isfile, "filename", "'%s' does not exist or is not a file"
+        )
+
+    def ensure_dirname(self, option: str) -> None:
+        self._ensure_tested_string(
+            option,
+            os.path.isdir,
+            "directory name",
+            "'%s' does not exist or is not a directory",
+        )
+
+    # -- Convenience methods for commands ------------------------------
+
+    def get_command_name(self) -> str:
+        if hasattr(self, 'command_name'):
+            return self.command_name
+        else:
+            return self.__class__.__name__
+
+    def set_undefined_options(
+        self, src_cmd: str, *option_pairs: tuple[str, str]
+    ) -> None:
+        """Set the values of any "undefined" options from corresponding
+        option values in some other command object.  "Undefined" here means
+        "is None", which is the convention used to indicate that an option
+        has not been changed between 'initialize_options()' and
+        'finalize_options()'.  Usually called from 'finalize_options()' for
+        options that depend on some other command rather than another
+        option of the same command.  'src_cmd' is the other command from
+        which option values will be taken (a command object will be created
+        for it if necessary); the remaining arguments are
+        '(src_option,dst_option)' tuples which mean "take the value of
+        'src_option' in the 'src_cmd' command object, and copy it to
+        'dst_option' in the current command object".
+        """
+        # Option_pairs: list of (src_option, dst_option) tuples
+        src_cmd_obj = self.distribution.get_command_obj(src_cmd)
+        src_cmd_obj.ensure_finalized()
+        for src_option, dst_option in option_pairs:
+            if getattr(self, dst_option) is None:
+                setattr(self, dst_option, getattr(src_cmd_obj, src_option))
+
+    # NOTE: Because distutils is private to Setuptools and not all commands are exposed here,
+    # not every possible command is enumerated in the signature.
+    def get_finalized_command(self, command: str, create: bool = True) -> Command:
+        """Wrapper around Distribution's 'get_command_obj()' method: find
+        (create if necessary and 'create' is true) the command object for
+        'command', call its 'ensure_finalized()' method, and return the
+        finalized command object.
+        """
+        cmd_obj = self.distribution.get_command_obj(command, create)
+        cmd_obj.ensure_finalized()
+        return cmd_obj
+
+    # XXX rename to 'get_reinitialized_command()'? (should do the
+    # same in dist.py, if so)
+    @overload
+    def reinitialize_command(
+        self, command: str, reinit_subcommands: bool = False
+    ) -> Command: ...
+    @overload
+    def reinitialize_command(
+        self, command: _CommandT, reinit_subcommands: bool = False
+    ) -> _CommandT: ...
+    def reinitialize_command(
+        self, command: str | Command, reinit_subcommands=False
+    ) -> Command:
+        return self.distribution.reinitialize_command(command, reinit_subcommands)
+
+    def run_command(self, command: str) -> None:
+        """Run some other command: uses the 'run_command()' method of
+        Distribution, which creates and finalizes the command object if
+        necessary and then invokes its 'run()' method.
+        """
+        self.distribution.run_command(command)
+
+    def get_sub_commands(self) -> list[str]:
+        """Determine the sub-commands that are relevant in the current
+        distribution (ie., that need to be run).  This is based on the
+        'sub_commands' class attribute: each tuple in that list may include
+        a method that we call to determine if the subcommand needs to be
+        run for the current distribution.  Return a list of command names.
+        """
+        commands = []
+        for cmd_name, method in self.sub_commands:
+            if method is None or method(self):
+                commands.append(cmd_name)
+        return commands
+
+    # -- External world manipulation -----------------------------------
+
+    def warn(self, msg: object) -> None:
+        log.warning("warning: %s: %s\n", self.get_command_name(), msg)
+
+    def execute(
+        self,
+        func: Callable[[Unpack[_Ts]], object],
+        args: tuple[Unpack[_Ts]],
+        msg: object = None,
+        level: int = 1,
+    ) -> None:
+        util.execute(func, args, msg, dry_run=self.dry_run)
+
+    def mkpath(self, name: str, mode: int = 0o777) -> None:
+        dir_util.mkpath(name, mode, dry_run=self.dry_run)
+
+    @overload
+    def copy_file(
+        self,
+        infile: str | os.PathLike[str],
+        outfile: _StrPathT,
+        preserve_mode: bool = True,
+        preserve_times: bool = True,
+        link: str | None = None,
+        level: int = 1,
+    ) -> tuple[_StrPathT | str, bool]: ...
+    @overload
+    def copy_file(
+        self,
+        infile: bytes | os.PathLike[bytes],
+        outfile: _BytesPathT,
+        preserve_mode: bool = True,
+        preserve_times: bool = True,
+        link: str | None = None,
+        level: int = 1,
+    ) -> tuple[_BytesPathT | bytes, bool]: ...
+    def copy_file(
+        self,
+        infile: str | os.PathLike[str] | bytes | os.PathLike[bytes],
+        outfile: str | os.PathLike[str] | bytes | os.PathLike[bytes],
+        preserve_mode: bool = True,
+        preserve_times: bool = True,
+        link: str | None = None,
+        level: int = 1,
+    ) -> tuple[str | os.PathLike[str] | bytes | os.PathLike[bytes], bool]:
+        """Copy a file respecting verbose, dry-run and force flags.  (The
+        former two default to whatever is in the Distribution object, and
+        the latter defaults to false for commands that don't define it.)"""
+        return file_util.copy_file(
+            infile,
+            outfile,
+            preserve_mode,
+            preserve_times,
+            not self.force,
+            link,
+            dry_run=self.dry_run,
+        )
+
+    def copy_tree(
+        self,
+        infile: str | os.PathLike[str],
+        outfile: str,
+        preserve_mode: bool = True,
+        preserve_times: bool = True,
+        preserve_symlinks: bool = False,
+        level: int = 1,
+    ) -> list[str]:
+        """Copy an entire directory tree respecting verbose, dry-run,
+        and force flags.
+        """
+        return dir_util.copy_tree(
+            infile,
+            outfile,
+            preserve_mode,
+            preserve_times,
+            preserve_symlinks,
+            not self.force,
+            dry_run=self.dry_run,
+        )
+
+    @overload
+    def move_file(
+        self, src: str | os.PathLike[str], dst: _StrPathT, level: int = 1
+    ) -> _StrPathT | str: ...
+    @overload
+    def move_file(
+        self, src: bytes | os.PathLike[bytes], dst: _BytesPathT, level: int = 1
+    ) -> _BytesPathT | bytes: ...
+    def move_file(
+        self,
+        src: str | os.PathLike[str] | bytes | os.PathLike[bytes],
+        dst: str | os.PathLike[str] | bytes | os.PathLike[bytes],
+        level: int = 1,
+    ) -> str | os.PathLike[str] | bytes | os.PathLike[bytes]:
+        """Move a file respecting dry-run flag."""
+        return file_util.move_file(src, dst, dry_run=self.dry_run)
+
+    def spawn(
+        self, cmd: MutableSequence[str], search_path: bool = True, level: int = 1
+    ) -> None:
+        """Spawn an external command respecting dry-run flag."""
+        from distutils.spawn import spawn
+
+        spawn(cmd, search_path, dry_run=self.dry_run)
+
+    @overload
+    def make_archive(
+        self,
+        base_name: str,
+        format: str,
+        root_dir: str | os.PathLike[str] | bytes | os.PathLike[bytes] | None = None,
+        base_dir: str | None = None,
+        owner: str | None = None,
+        group: str | None = None,
+    ) -> str: ...
+    @overload
+    def make_archive(
+        self,
+        base_name: str | os.PathLike[str],
+        format: str,
+        root_dir: str | os.PathLike[str] | bytes | os.PathLike[bytes],
+        base_dir: str | None = None,
+        owner: str | None = None,
+        group: str | None = None,
+    ) -> str: ...
+    def make_archive(
+        self,
+        base_name: str | os.PathLike[str],
+        format: str,
+        root_dir: str | os.PathLike[str] | bytes | os.PathLike[bytes] | None = None,
+        base_dir: str | None = None,
+        owner: str | None = None,
+        group: str | None = None,
+    ) -> str:
+        return archive_util.make_archive(
+            base_name,
+            format,
+            root_dir,
+            base_dir,
+            dry_run=self.dry_run,
+            owner=owner,
+            group=group,
+        )
+
+    def make_file(
+        self,
+        infiles: str | list[str] | tuple[str, ...],
+        outfile: str | os.PathLike[str] | bytes | os.PathLike[bytes],
+        func: Callable[[Unpack[_Ts]], object],
+        args: tuple[Unpack[_Ts]],
+        exec_msg: object = None,
+        skip_msg: object = None,
+        level: int = 1,
+    ) -> None:
+        """Special case of 'execute()' for operations that process one or
+        more input files and generate one output file.  Works just like
+        'execute()', except the operation is skipped and a different
+        message printed if 'outfile' already exists and is newer than all
+        files listed in 'infiles'.  If the command defined 'self.force',
+        and it is true, then the command is unconditionally run -- does no
+        timestamp checks.
+        """
+        if skip_msg is None:
+            skip_msg = f"skipping {outfile} (inputs unchanged)"
+
+        # Allow 'infiles' to be a single string
+        if isinstance(infiles, str):
+            infiles = (infiles,)
+        elif not isinstance(infiles, (list, tuple)):
+            raise TypeError("'infiles' must be a string, or a list or tuple of strings")
+
+        if exec_msg is None:
+            exec_msg = "generating {} from {}".format(outfile, ', '.join(infiles))
+
+        # If 'outfile' must be regenerated (either because it doesn't
+        # exist, is out-of-date, or the 'force' flag is true) then
+        # perform the action that presumably regenerates it
+        if self.force or _modified.newer_group(infiles, outfile):
+            self.execute(func, args, exec_msg, level)
+        # Otherwise, print the "skip" message
+        else:
+            log.debug(skip_msg)
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/command/__init__.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/command/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..0f8a1692ba96f5e03167e7307c1c2ff5776b74d6
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/command/__init__.py
@@ -0,0 +1,23 @@
+"""distutils.command
+
+Package containing implementation of all the standard Distutils
+commands."""
+
+__all__ = [
+    'build',
+    'build_py',
+    'build_ext',
+    'build_clib',
+    'build_scripts',
+    'clean',
+    'install',
+    'install_lib',
+    'install_headers',
+    'install_scripts',
+    'install_data',
+    'sdist',
+    'bdist',
+    'bdist_dumb',
+    'bdist_rpm',
+    'check',
+]
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/command/__pycache__/__init__.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/command/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..8de0a2ca83f9950b72b4f7eee7051d7a1befa4f1
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/command/__pycache__/__init__.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/command/__pycache__/_framework_compat.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/command/__pycache__/_framework_compat.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5bbd8c5ba6a8d991c0202c4e908a331f31da5111
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/command/__pycache__/_framework_compat.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/command/__pycache__/bdist.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/command/__pycache__/bdist.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..bbe98480ce1ba849cfe5d1397d3d99c58f95e885
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/command/__pycache__/bdist.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/command/__pycache__/bdist_dumb.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/command/__pycache__/bdist_dumb.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..9ae70393ffbd846e242cd28f2f21086010798285
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/command/__pycache__/bdist_dumb.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/command/__pycache__/bdist_rpm.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/command/__pycache__/bdist_rpm.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..9ad4cab91dd1c1345f303eb690ae1260911ed4a2
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/command/__pycache__/bdist_rpm.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/command/__pycache__/build.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/command/__pycache__/build.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..2c1c6ea9d0f1c55668cec9e6aa7646dd3a1dcaf4
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/command/__pycache__/build.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/command/__pycache__/build_clib.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/command/__pycache__/build_clib.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ea257359be4b0bcd349b212f0e14301ed49d1f34
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/command/__pycache__/build_clib.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/command/__pycache__/build_ext.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/command/__pycache__/build_ext.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..9b567f82f7fbba960b9941191c5b3a4e8301cf2f
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/command/__pycache__/build_ext.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/command/__pycache__/build_py.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/command/__pycache__/build_py.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..26010feb1ea6856beb6104d66eb22086b235287e
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/command/__pycache__/build_py.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/command/__pycache__/build_scripts.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/command/__pycache__/build_scripts.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..4f025aac7bb65abfe6eeafe86686eb272e490526
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/command/__pycache__/build_scripts.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/command/__pycache__/check.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/command/__pycache__/check.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..9a1383bd5789789ba75151664c4e2831f7d2296c
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/command/__pycache__/check.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/command/__pycache__/clean.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/command/__pycache__/clean.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..4f4e531ba2966986788f551f165fb82df6c84183
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/command/__pycache__/clean.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/command/__pycache__/config.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/command/__pycache__/config.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..bec7abfb6a9cb18a6c4429b6093d7c347b8ecdf1
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/command/__pycache__/config.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/command/__pycache__/install.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/command/__pycache__/install.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d64a16f6a286927a52a0507ad6266b8e0100e692
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/command/__pycache__/install.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/command/__pycache__/install_data.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/command/__pycache__/install_data.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..74661cf62b5bb2f3269f56b860b9bc76a8a9ea48
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/command/__pycache__/install_data.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/command/__pycache__/install_egg_info.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/command/__pycache__/install_egg_info.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a91543b7581d0c50d4450e857dec1a5e67dc6ac1
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/command/__pycache__/install_egg_info.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/command/__pycache__/install_headers.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/command/__pycache__/install_headers.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..95f27f03e948ac201dec0b527ad6d9250517bd95
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/command/__pycache__/install_headers.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/command/__pycache__/install_lib.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/command/__pycache__/install_lib.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..825b2df1e34c5d2b43a194a4890515b3a32585ec
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/command/__pycache__/install_lib.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/command/__pycache__/install_scripts.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/command/__pycache__/install_scripts.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..441a8ad7f58544161c18dfa96000e12da973f35f
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/command/__pycache__/install_scripts.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/command/__pycache__/sdist.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/command/__pycache__/sdist.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..8d80448acba21239e2438eb259f97cfb6e7a7731
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/command/__pycache__/sdist.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/command/_framework_compat.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/command/_framework_compat.py
new file mode 100644
index 0000000000000000000000000000000000000000..00d34bc7d8c85126dbae716ebfa48e35b0833222
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/command/_framework_compat.py
@@ -0,0 +1,54 @@
+"""
+Backward compatibility for homebrew builds on macOS.
+"""
+
+import functools
+import os
+import subprocess
+import sys
+import sysconfig
+
+
+@functools.lru_cache
+def enabled():
+    """
+    Only enabled for Python 3.9 framework homebrew builds
+    except ensurepip and venv.
+    """
+    PY39 = (3, 9) < sys.version_info < (3, 10)
+    framework = sys.platform == 'darwin' and sys._framework
+    homebrew = "Cellar" in sysconfig.get_config_var('projectbase')
+    venv = sys.prefix != sys.base_prefix
+    ensurepip = os.environ.get("ENSUREPIP_OPTIONS")
+    return PY39 and framework and homebrew and not venv and not ensurepip
+
+
+schemes = dict(
+    osx_framework_library=dict(
+        stdlib='{installed_base}/{platlibdir}/python{py_version_short}',
+        platstdlib='{platbase}/{platlibdir}/python{py_version_short}',
+        purelib='{homebrew_prefix}/lib/python{py_version_short}/site-packages',
+        platlib='{homebrew_prefix}/{platlibdir}/python{py_version_short}/site-packages',
+        include='{installed_base}/include/python{py_version_short}{abiflags}',
+        platinclude='{installed_platbase}/include/python{py_version_short}{abiflags}',
+        scripts='{homebrew_prefix}/bin',
+        data='{homebrew_prefix}',
+    )
+)
+
+
+@functools.lru_cache
+def vars():
+    if not enabled():
+        return {}
+    homebrew_prefix = subprocess.check_output(['brew', '--prefix'], text=True).strip()
+    return locals()
+
+
+def scheme(name):
+    """
+    Override the selected scheme for posix_prefix.
+    """
+    if not enabled() or not name.endswith('_prefix'):
+        return name
+    return 'osx_framework_library'
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/command/bdist.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/command/bdist.py
new file mode 100644
index 0000000000000000000000000000000000000000..07811aab27ad7fcd2303883024243e2f52c2bbcb
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/command/bdist.py
@@ -0,0 +1,167 @@
+"""distutils.command.bdist
+
+Implements the Distutils 'bdist' command (create a built [binary]
+distribution)."""
+
+from __future__ import annotations
+
+import os
+import warnings
+from collections.abc import Callable
+from typing import TYPE_CHECKING, ClassVar
+
+from ..core import Command
+from ..errors import DistutilsOptionError, DistutilsPlatformError
+from ..util import get_platform
+
+if TYPE_CHECKING:
+    from typing_extensions import deprecated
+else:
+
+    def deprecated(message):
+        return lambda fn: fn
+
+
+def show_formats():
+    """Print list of available formats (arguments to "--format" option)."""
+    from ..fancy_getopt import FancyGetopt
+
+    formats = [
+        ("formats=" + format, None, bdist.format_commands[format][1])
+        for format in bdist.format_commands
+    ]
+    pretty_printer = FancyGetopt(formats)
+    pretty_printer.print_help("List of available distribution formats:")
+
+
+class ListCompat(dict[str, tuple[str, str]]):
+    # adapter to allow for Setuptools compatibility in format_commands
+    @deprecated("format_commands is now a dict. append is deprecated.")
+    def append(self, item: object) -> None:
+        warnings.warn(
+            "format_commands is now a dict. append is deprecated.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+
+
+class bdist(Command):
+    description = "create a built (binary) distribution"
+
+    user_options = [
+        ('bdist-base=', 'b', "temporary directory for creating built distributions"),
+        (
+            'plat-name=',
+            'p',
+            "platform name to embed in generated filenames "
+            f"[default: {get_platform()}]",
+        ),
+        ('formats=', None, "formats for distribution (comma-separated list)"),
+        (
+            'dist-dir=',
+            'd',
+            "directory to put final built distributions in [default: dist]",
+        ),
+        ('skip-build', None, "skip rebuilding everything (for testing/debugging)"),
+        (
+            'owner=',
+            'u',
+            "Owner name used when creating a tar file [default: current user]",
+        ),
+        (
+            'group=',
+            'g',
+            "Group name used when creating a tar file [default: current group]",
+        ),
+    ]
+
+    boolean_options: ClassVar[list[str]] = ['skip-build']
+
+    help_options: ClassVar[list[tuple[str, str | None, str, Callable[[], object]]]] = [
+        ('help-formats', None, "lists available distribution formats", show_formats),
+    ]
+
+    # The following commands do not take a format option from bdist
+    no_format_option: ClassVar[tuple[str, ...]] = ('bdist_rpm',)
+
+    # This won't do in reality: will need to distinguish RPM-ish Linux,
+    # Debian-ish Linux, Solaris, FreeBSD, ..., Windows, Mac OS.
+    default_format: ClassVar[dict[str, str]] = {'posix': 'gztar', 'nt': 'zip'}
+
+    # Define commands in preferred order for the --help-formats option
+    format_commands = ListCompat({
+        'rpm': ('bdist_rpm', "RPM distribution"),
+        'gztar': ('bdist_dumb', "gzip'ed tar file"),
+        'bztar': ('bdist_dumb', "bzip2'ed tar file"),
+        'xztar': ('bdist_dumb', "xz'ed tar file"),
+        'ztar': ('bdist_dumb', "compressed tar file"),
+        'tar': ('bdist_dumb', "tar file"),
+        'zip': ('bdist_dumb', "ZIP file"),
+    })
+
+    # for compatibility until consumers only reference format_commands
+    format_command = format_commands
+
+    def initialize_options(self):
+        self.bdist_base = None
+        self.plat_name = None
+        self.formats = None
+        self.dist_dir = None
+        self.skip_build = False
+        self.group = None
+        self.owner = None
+
+    def finalize_options(self) -> None:
+        # have to finalize 'plat_name' before 'bdist_base'
+        if self.plat_name is None:
+            if self.skip_build:
+                self.plat_name = get_platform()
+            else:
+                self.plat_name = self.get_finalized_command('build').plat_name
+
+        # 'bdist_base' -- parent of per-built-distribution-format
+        # temporary directories (eg. we'll probably have
+        # "build/bdist.<plat>/dumb", "build/bdist.<plat>/rpm", etc.)
+        if self.bdist_base is None:
+            build_base = self.get_finalized_command('build').build_base
+            self.bdist_base = os.path.join(build_base, 'bdist.' + self.plat_name)
+
+        self.ensure_string_list('formats')
+        if self.formats is None:
+            try:
+                self.formats = [self.default_format[os.name]]
+            except KeyError:
+                raise DistutilsPlatformError(
+                    "don't know how to create built distributions "
+                    f"on platform {os.name}"
+                )
+
+        if self.dist_dir is None:
+            self.dist_dir = "dist"
+
+    def run(self) -> None:
+        # Figure out which sub-commands we need to run.
+        commands = []
+        for format in self.formats:
+            try:
+                commands.append(self.format_commands[format][0])
+            except KeyError:
+                raise DistutilsOptionError(f"invalid format '{format}'")
+
+        # Reinitialize and run each command.
+        for i in range(len(self.formats)):
+            cmd_name = commands[i]
+            sub_cmd = self.reinitialize_command(cmd_name)
+            if cmd_name not in self.no_format_option:
+                sub_cmd.format = self.formats[i]
+
+            # passing the owner and group names for tar archiving
+            if cmd_name == 'bdist_dumb':
+                sub_cmd.owner = self.owner
+                sub_cmd.group = self.group
+
+            # If we're going to need to run this command again, tell it to
+            # keep its temporary files around so subsequent runs go faster.
+            if cmd_name in commands[i + 1 :]:
+                sub_cmd.keep_temp = True
+            self.run_command(cmd_name)
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/command/bdist_dumb.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/command/bdist_dumb.py
new file mode 100644
index 0000000000000000000000000000000000000000..ccad66f43127cb18b8e592810995a7092f843041
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/command/bdist_dumb.py
@@ -0,0 +1,141 @@
+"""distutils.command.bdist_dumb
+
+Implements the Distutils 'bdist_dumb' command (create a "dumb" built
+distribution -- i.e., just an archive to be unpacked under $prefix or
+$exec_prefix)."""
+
+import os
+from distutils._log import log
+from typing import ClassVar
+
+from ..core import Command
+from ..dir_util import ensure_relative, remove_tree
+from ..errors import DistutilsPlatformError
+from ..sysconfig import get_python_version
+from ..util import get_platform
+
+
+class bdist_dumb(Command):
+    description = "create a \"dumb\" built distribution"
+
+    user_options = [
+        ('bdist-dir=', 'd', "temporary directory for creating the distribution"),
+        (
+            'plat-name=',
+            'p',
+            "platform name to embed in generated filenames "
+            f"[default: {get_platform()}]",
+        ),
+        (
+            'format=',
+            'f',
+            "archive format to create (tar, gztar, bztar, xztar, ztar, zip)",
+        ),
+        (
+            'keep-temp',
+            'k',
+            "keep the pseudo-installation tree around after creating the distribution archive",
+        ),
+        ('dist-dir=', 'd', "directory to put final built distributions in"),
+        ('skip-build', None, "skip rebuilding everything (for testing/debugging)"),
+        (
+            'relative',
+            None,
+            "build the archive using relative paths [default: false]",
+        ),
+        (
+            'owner=',
+            'u',
+            "Owner name used when creating a tar file [default: current user]",
+        ),
+        (
+            'group=',
+            'g',
+            "Group name used when creating a tar file [default: current group]",
+        ),
+    ]
+
+    boolean_options: ClassVar[list[str]] = ['keep-temp', 'skip-build', 'relative']
+
+    default_format = {'posix': 'gztar', 'nt': 'zip'}
+
+    def initialize_options(self):
+        self.bdist_dir = None
+        self.plat_name = None
+        self.format = None
+        self.keep_temp = False
+        self.dist_dir = None
+        self.skip_build = None
+        self.relative = False
+        self.owner = None
+        self.group = None
+
+    def finalize_options(self):
+        if self.bdist_dir is None:
+            bdist_base = self.get_finalized_command('bdist').bdist_base
+            self.bdist_dir = os.path.join(bdist_base, 'dumb')
+
+        if self.format is None:
+            try:
+                self.format = self.default_format[os.name]
+            except KeyError:
+                raise DistutilsPlatformError(
+                    "don't know how to create dumb built distributions "
+                    f"on platform {os.name}"
+                )
+
+        self.set_undefined_options(
+            'bdist',
+            ('dist_dir', 'dist_dir'),
+            ('plat_name', 'plat_name'),
+            ('skip_build', 'skip_build'),
+        )
+
+    def run(self):
+        if not self.skip_build:
+            self.run_command('build')
+
+        install = self.reinitialize_command('install', reinit_subcommands=True)
+        install.root = self.bdist_dir
+        install.skip_build = self.skip_build
+        install.warn_dir = False
+
+        log.info("installing to %s", self.bdist_dir)
+        self.run_command('install')
+
+        # And make an archive relative to the root of the
+        # pseudo-installation tree.
+        archive_basename = f"{self.distribution.get_fullname()}.{self.plat_name}"
+
+        pseudoinstall_root = os.path.join(self.dist_dir, archive_basename)
+        if not self.relative:
+            archive_root = self.bdist_dir
+        else:
+            if self.distribution.has_ext_modules() and (
+                install.install_base != install.install_platbase
+            ):
+                raise DistutilsPlatformError(
+                    "can't make a dumb built distribution where "
+                    f"base and platbase are different ({install.install_base!r}, {install.install_platbase!r})"
+                )
+            else:
+                archive_root = os.path.join(
+                    self.bdist_dir, ensure_relative(install.install_base)
+                )
+
+        # Make the archive
+        filename = self.make_archive(
+            pseudoinstall_root,
+            self.format,
+            root_dir=archive_root,
+            owner=self.owner,
+            group=self.group,
+        )
+        if self.distribution.has_ext_modules():
+            pyversion = get_python_version()
+        else:
+            pyversion = 'any'
+        self.distribution.dist_files.append(('bdist_dumb', pyversion, filename))
+
+        if not self.keep_temp:
+            remove_tree(self.bdist_dir, dry_run=self.dry_run)
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/command/bdist_rpm.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/command/bdist_rpm.py
new file mode 100644
index 0000000000000000000000000000000000000000..357b4e861e2e0ec44a0bf1dda6c2dd35db8b9ca8
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/command/bdist_rpm.py
@@ -0,0 +1,598 @@
+"""distutils.command.bdist_rpm
+
+Implements the Distutils 'bdist_rpm' command (create RPM source and binary
+distributions)."""
+
+import os
+import subprocess
+import sys
+from distutils._log import log
+from typing import ClassVar
+
+from ..core import Command
+from ..debug import DEBUG
+from ..errors import (
+    DistutilsExecError,
+    DistutilsFileError,
+    DistutilsOptionError,
+    DistutilsPlatformError,
+)
+from ..file_util import write_file
+from ..sysconfig import get_python_version
+
+
+class bdist_rpm(Command):
+    description = "create an RPM distribution"
+
+    user_options = [
+        ('bdist-base=', None, "base directory for creating built distributions"),
+        (
+            'rpm-base=',
+            None,
+            "base directory for creating RPMs (defaults to \"rpm\" under "
+            "--bdist-base; must be specified for RPM 2)",
+        ),
+        (
+            'dist-dir=',
+            'd',
+            "directory to put final RPM files in (and .spec files if --spec-only)",
+        ),
+        (
+            'python=',
+            None,
+            "path to Python interpreter to hard-code in the .spec file "
+            "[default: \"python\"]",
+        ),
+        (
+            'fix-python',
+            None,
+            "hard-code the exact path to the current Python interpreter in "
+            "the .spec file",
+        ),
+        ('spec-only', None, "only regenerate spec file"),
+        ('source-only', None, "only generate source RPM"),
+        ('binary-only', None, "only generate binary RPM"),
+        ('use-bzip2', None, "use bzip2 instead of gzip to create source distribution"),
+        # More meta-data: too RPM-specific to put in the setup script,
+        # but needs to go in the .spec file -- so we make these options
+        # to "bdist_rpm".  The idea is that packagers would put this
+        # info in setup.cfg, although they are of course free to
+        # supply it on the command line.
+        (
+            'distribution-name=',
+            None,
+            "name of the (Linux) distribution to which this "
+            "RPM applies (*not* the name of the module distribution!)",
+        ),
+        ('group=', None, "package classification [default: \"Development/Libraries\"]"),
+        ('release=', None, "RPM release number"),
+        ('serial=', None, "RPM serial number"),
+        (
+            'vendor=',
+            None,
+            "RPM \"vendor\" (eg. \"Joe Blow <joe@example.com>\") "
+            "[default: maintainer or author from setup script]",
+        ),
+        (
+            'packager=',
+            None,
+            "RPM packager (eg. \"Jane Doe <jane@example.net>\") [default: vendor]",
+        ),
+        ('doc-files=', None, "list of documentation files (space or comma-separated)"),
+        ('changelog=', None, "RPM changelog"),
+        ('icon=', None, "name of icon file"),
+        ('provides=', None, "capabilities provided by this package"),
+        ('requires=', None, "capabilities required by this package"),
+        ('conflicts=', None, "capabilities which conflict with this package"),
+        ('build-requires=', None, "capabilities required to build this package"),
+        ('obsoletes=', None, "capabilities made obsolete by this package"),
+        ('no-autoreq', None, "do not automatically calculate dependencies"),
+        # Actions to take when building RPM
+        ('keep-temp', 'k', "don't clean up RPM build directory"),
+        ('no-keep-temp', None, "clean up RPM build directory [default]"),
+        (
+            'use-rpm-opt-flags',
+            None,
+            "compile with RPM_OPT_FLAGS when building from source RPM",
+        ),
+        ('no-rpm-opt-flags', None, "do not pass any RPM CFLAGS to compiler"),
+        ('rpm3-mode', None, "RPM 3 compatibility mode (default)"),
+        ('rpm2-mode', None, "RPM 2 compatibility mode"),
+        # Add the hooks necessary for specifying custom scripts
+        ('prep-script=', None, "Specify a script for the PREP phase of RPM building"),
+        ('build-script=', None, "Specify a script for the BUILD phase of RPM building"),
+        (
+            'pre-install=',
+            None,
+            "Specify a script for the pre-INSTALL phase of RPM building",
+        ),
+        (
+            'install-script=',
+            None,
+            "Specify a script for the INSTALL phase of RPM building",
+        ),
+        (
+            'post-install=',
+            None,
+            "Specify a script for the post-INSTALL phase of RPM building",
+        ),
+        (
+            'pre-uninstall=',
+            None,
+            "Specify a script for the pre-UNINSTALL phase of RPM building",
+        ),
+        (
+            'post-uninstall=',
+            None,
+            "Specify a script for the post-UNINSTALL phase of RPM building",
+        ),
+        ('clean-script=', None, "Specify a script for the CLEAN phase of RPM building"),
+        (
+            'verify-script=',
+            None,
+            "Specify a script for the VERIFY phase of the RPM build",
+        ),
+        # Allow a packager to explicitly force an architecture
+        ('force-arch=', None, "Force an architecture onto the RPM build process"),
+        ('quiet', 'q', "Run the INSTALL phase of RPM building in quiet mode"),
+    ]
+
+    boolean_options: ClassVar[list[str]] = [
+        'keep-temp',
+        'use-rpm-opt-flags',
+        'rpm3-mode',
+        'no-autoreq',
+        'quiet',
+    ]
+
+    negative_opt: ClassVar[dict[str, str]] = {
+        'no-keep-temp': 'keep-temp',
+        'no-rpm-opt-flags': 'use-rpm-opt-flags',
+        'rpm2-mode': 'rpm3-mode',
+    }
+
+    def initialize_options(self):
+        self.bdist_base = None
+        self.rpm_base = None
+        self.dist_dir = None
+        self.python = None
+        self.fix_python = None
+        self.spec_only = None
+        self.binary_only = None
+        self.source_only = None
+        self.use_bzip2 = None
+
+        self.distribution_name = None
+        self.group = None
+        self.release = None
+        self.serial = None
+        self.vendor = None
+        self.packager = None
+        self.doc_files = None
+        self.changelog = None
+        self.icon = None
+
+        self.prep_script = None
+        self.build_script = None
+        self.install_script = None
+        self.clean_script = None
+        self.verify_script = None
+        self.pre_install = None
+        self.post_install = None
+        self.pre_uninstall = None
+        self.post_uninstall = None
+        self.prep = None
+        self.provides = None
+        self.requires = None
+        self.conflicts = None
+        self.build_requires = None
+        self.obsoletes = None
+
+        self.keep_temp = False
+        self.use_rpm_opt_flags = True
+        self.rpm3_mode = True
+        self.no_autoreq = False
+
+        self.force_arch = None
+        self.quiet = False
+
+    def finalize_options(self) -> None:
+        self.set_undefined_options('bdist', ('bdist_base', 'bdist_base'))
+        if self.rpm_base is None:
+            if not self.rpm3_mode:
+                raise DistutilsOptionError("you must specify --rpm-base in RPM 2 mode")
+            self.rpm_base = os.path.join(self.bdist_base, "rpm")
+
+        if self.python is None:
+            if self.fix_python:
+                self.python = sys.executable
+            else:
+                self.python = "python3"
+        elif self.fix_python:
+            raise DistutilsOptionError(
+                "--python and --fix-python are mutually exclusive options"
+            )
+
+        if os.name != 'posix':
+            raise DistutilsPlatformError(
+                f"don't know how to create RPM distributions on platform {os.name}"
+            )
+        if self.binary_only and self.source_only:
+            raise DistutilsOptionError(
+                "cannot supply both '--source-only' and '--binary-only'"
+            )
+
+        # don't pass CFLAGS to pure python distributions
+        if not self.distribution.has_ext_modules():
+            self.use_rpm_opt_flags = False
+
+        self.set_undefined_options('bdist', ('dist_dir', 'dist_dir'))
+        self.finalize_package_data()
+
+    def finalize_package_data(self) -> None:
+        self.ensure_string('group', "Development/Libraries")
+        self.ensure_string(
+            'vendor',
+            f"{self.distribution.get_contact()} <{self.distribution.get_contact_email()}>",
+        )
+        self.ensure_string('packager')
+        self.ensure_string_list('doc_files')
+        if isinstance(self.doc_files, list):
+            for readme in ('README', 'README.txt'):
+                if os.path.exists(readme) and readme not in self.doc_files:
+                    self.doc_files.append(readme)
+
+        self.ensure_string('release', "1")
+        self.ensure_string('serial')  # should it be an int?
+
+        self.ensure_string('distribution_name')
+
+        self.ensure_string('changelog')
+        # Format changelog correctly
+        self.changelog = self._format_changelog(self.changelog)
+
+        self.ensure_filename('icon')
+
+        self.ensure_filename('prep_script')
+        self.ensure_filename('build_script')
+        self.ensure_filename('install_script')
+        self.ensure_filename('clean_script')
+        self.ensure_filename('verify_script')
+        self.ensure_filename('pre_install')
+        self.ensure_filename('post_install')
+        self.ensure_filename('pre_uninstall')
+        self.ensure_filename('post_uninstall')
+
+        # XXX don't forget we punted on summaries and descriptions -- they
+        # should be handled here eventually!
+
+        # Now *this* is some meta-data that belongs in the setup script...
+        self.ensure_string_list('provides')
+        self.ensure_string_list('requires')
+        self.ensure_string_list('conflicts')
+        self.ensure_string_list('build_requires')
+        self.ensure_string_list('obsoletes')
+
+        self.ensure_string('force_arch')
+
+    def run(self) -> None:  # noqa: C901
+        if DEBUG:
+            print("before _get_package_data():")
+            print("vendor =", self.vendor)
+            print("packager =", self.packager)
+            print("doc_files =", self.doc_files)
+            print("changelog =", self.changelog)
+
+        # make directories
+        if self.spec_only:
+            spec_dir = self.dist_dir
+            self.mkpath(spec_dir)
+        else:
+            rpm_dir = {}
+            for d in ('SOURCES', 'SPECS', 'BUILD', 'RPMS', 'SRPMS'):
+                rpm_dir[d] = os.path.join(self.rpm_base, d)
+                self.mkpath(rpm_dir[d])
+            spec_dir = rpm_dir['SPECS']
+
+        # Spec file goes into 'dist_dir' if '--spec-only specified',
+        # build/rpm.<plat> otherwise.
+        spec_path = os.path.join(spec_dir, f"{self.distribution.get_name()}.spec")
+        self.execute(
+            write_file, (spec_path, self._make_spec_file()), f"writing '{spec_path}'"
+        )
+
+        if self.spec_only:  # stop if requested
+            return
+
+        # Make a source distribution and copy to SOURCES directory with
+        # optional icon.
+        saved_dist_files = self.distribution.dist_files[:]
+        sdist = self.reinitialize_command('sdist')
+        if self.use_bzip2:
+            sdist.formats = ['bztar']
+        else:
+            sdist.formats = ['gztar']
+        self.run_command('sdist')
+        self.distribution.dist_files = saved_dist_files
+
+        source = sdist.get_archive_files()[0]
+        source_dir = rpm_dir['SOURCES']
+        self.copy_file(source, source_dir)
+
+        if self.icon:
+            if os.path.exists(self.icon):
+                self.copy_file(self.icon, source_dir)
+            else:
+                raise DistutilsFileError(f"icon file '{self.icon}' does not exist")
+
+        # build package
+        log.info("building RPMs")
+        rpm_cmd = ['rpmbuild']
+
+        if self.source_only:  # what kind of RPMs?
+            rpm_cmd.append('-bs')
+        elif self.binary_only:
+            rpm_cmd.append('-bb')
+        else:
+            rpm_cmd.append('-ba')
+        rpm_cmd.extend(['--define', f'__python {self.python}'])
+        if self.rpm3_mode:
+            rpm_cmd.extend(['--define', f'_topdir {os.path.abspath(self.rpm_base)}'])
+        if not self.keep_temp:
+            rpm_cmd.append('--clean')
+
+        if self.quiet:
+            rpm_cmd.append('--quiet')
+
+        rpm_cmd.append(spec_path)
+        # Determine the binary rpm names that should be built out of this spec
+        # file
+        # Note that some of these may not be really built (if the file
+        # list is empty)
+        nvr_string = "%{name}-%{version}-%{release}"
+        src_rpm = nvr_string + ".src.rpm"
+        non_src_rpm = "%{arch}/" + nvr_string + ".%{arch}.rpm"
+        q_cmd = rf"rpm -q --qf '{src_rpm} {non_src_rpm}\n' --specfile '{spec_path}'"
+
+        out = os.popen(q_cmd)
+        try:
+            binary_rpms = []
+            source_rpm = None
+            while True:
+                line = out.readline()
+                if not line:
+                    break
+                ell = line.strip().split()
+                assert len(ell) == 2
+                binary_rpms.append(ell[1])
+                # The source rpm is named after the first entry in the spec file
+                if source_rpm is None:
+                    source_rpm = ell[0]
+
+            status = out.close()
+            if status:
+                raise DistutilsExecError(f"Failed to execute: {q_cmd!r}")
+
+        finally:
+            out.close()
+
+        self.spawn(rpm_cmd)
+
+        if not self.dry_run:
+            if self.distribution.has_ext_modules():
+                pyversion = get_python_version()
+            else:
+                pyversion = 'any'
+
+            if not self.binary_only:
+                srpm = os.path.join(rpm_dir['SRPMS'], source_rpm)
+                assert os.path.exists(srpm)
+                self.move_file(srpm, self.dist_dir)
+                filename = os.path.join(self.dist_dir, source_rpm)
+                self.distribution.dist_files.append(('bdist_rpm', pyversion, filename))
+
+            if not self.source_only:
+                for rpm in binary_rpms:
+                    rpm = os.path.join(rpm_dir['RPMS'], rpm)
+                    if os.path.exists(rpm):
+                        self.move_file(rpm, self.dist_dir)
+                        filename = os.path.join(self.dist_dir, os.path.basename(rpm))
+                        self.distribution.dist_files.append((
+                            'bdist_rpm',
+                            pyversion,
+                            filename,
+                        ))
+
+    def _dist_path(self, path):
+        return os.path.join(self.dist_dir, os.path.basename(path))
+
+    def _make_spec_file(self):  # noqa: C901
+        """Generate the text of an RPM spec file and return it as a
+        list of strings (one per line).
+        """
+        # definitions and headers
+        spec_file = [
+            '%define name ' + self.distribution.get_name(),
+            '%define version ' + self.distribution.get_version().replace('-', '_'),
+            '%define unmangled_version ' + self.distribution.get_version(),
+            '%define release ' + self.release.replace('-', '_'),
+            '',
+            'Summary: ' + (self.distribution.get_description() or "UNKNOWN"),
+        ]
+
+        # Workaround for #14443 which affects some RPM based systems such as
+        # RHEL6 (and probably derivatives)
+        vendor_hook = subprocess.getoutput('rpm --eval %{__os_install_post}')
+        # Generate a potential replacement value for __os_install_post (whilst
+        # normalizing the whitespace to simplify the test for whether the
+        # invocation of brp-python-bytecompile passes in __python):
+        vendor_hook = '\n'.join([
+            f'  {line.strip()} \\' for line in vendor_hook.splitlines()
+        ])
+        problem = "brp-python-bytecompile \\\n"
+        fixed = "brp-python-bytecompile %{__python} \\\n"
+        fixed_hook = vendor_hook.replace(problem, fixed)
+        if fixed_hook != vendor_hook:
+            spec_file.append('# Workaround for https://bugs.python.org/issue14443')
+            spec_file.append('%define __os_install_post ' + fixed_hook + '\n')
+
+        # put locale summaries into spec file
+        # XXX not supported for now (hard to put a dictionary
+        # in a config file -- arg!)
+        # for locale in self.summaries.keys():
+        #    spec_file.append('Summary(%s): %s' % (locale,
+        #                                          self.summaries[locale]))
+
+        spec_file.extend([
+            'Name: %{name}',
+            'Version: %{version}',
+            'Release: %{release}',
+        ])
+
+        # XXX yuck! this filename is available from the "sdist" command,
+        # but only after it has run: and we create the spec file before
+        # running "sdist", in case of --spec-only.
+        if self.use_bzip2:
+            spec_file.append('Source0: %{name}-%{unmangled_version}.tar.bz2')
+        else:
+            spec_file.append('Source0: %{name}-%{unmangled_version}.tar.gz')
+
+        spec_file.extend([
+            'License: ' + (self.distribution.get_license() or "UNKNOWN"),
+            'Group: ' + self.group,
+            'BuildRoot: %{_tmppath}/%{name}-%{version}-%{release}-buildroot',
+            'Prefix: %{_prefix}',
+        ])
+
+        if not self.force_arch:
+            # noarch if no extension modules
+            if not self.distribution.has_ext_modules():
+                spec_file.append('BuildArch: noarch')
+        else:
+            spec_file.append(f'BuildArch: {self.force_arch}')
+
+        for field in (
+            'Vendor',
+            'Packager',
+            'Provides',
+            'Requires',
+            'Conflicts',
+            'Obsoletes',
+        ):
+            val = getattr(self, field.lower())
+            if isinstance(val, list):
+                spec_file.append('{}: {}'.format(field, ' '.join(val)))
+            elif val is not None:
+                spec_file.append(f'{field}: {val}')
+
+        if self.distribution.get_url():
+            spec_file.append('Url: ' + self.distribution.get_url())
+
+        if self.distribution_name:
+            spec_file.append('Distribution: ' + self.distribution_name)
+
+        if self.build_requires:
+            spec_file.append('BuildRequires: ' + ' '.join(self.build_requires))
+
+        if self.icon:
+            spec_file.append('Icon: ' + os.path.basename(self.icon))
+
+        if self.no_autoreq:
+            spec_file.append('AutoReq: 0')
+
+        spec_file.extend([
+            '',
+            '%description',
+            self.distribution.get_long_description() or "",
+        ])
+
+        # put locale descriptions into spec file
+        # XXX again, suppressed because config file syntax doesn't
+        # easily support this ;-(
+        # for locale in self.descriptions.keys():
+        #    spec_file.extend([
+        #        '',
+        #        '%description -l ' + locale,
+        #        self.descriptions[locale],
+        #        ])
+
+        # rpm scripts
+        # figure out default build script
+        def_setup_call = f"{self.python} {os.path.basename(sys.argv[0])}"
+        def_build = f"{def_setup_call} build"
+        if self.use_rpm_opt_flags:
+            def_build = 'env CFLAGS="$RPM_OPT_FLAGS" ' + def_build
+
+        # insert contents of files
+
+        # XXX this is kind of misleading: user-supplied options are files
+        # that we open and interpolate into the spec file, but the defaults
+        # are just text that we drop in as-is.  Hmmm.
+
+        install_cmd = f'{def_setup_call} install -O1 --root=$RPM_BUILD_ROOT --record=INSTALLED_FILES'
+
+        script_options = [
+            ('prep', 'prep_script', "%setup -n %{name}-%{unmangled_version}"),
+            ('build', 'build_script', def_build),
+            ('install', 'install_script', install_cmd),
+            ('clean', 'clean_script', "rm -rf $RPM_BUILD_ROOT"),
+            ('verifyscript', 'verify_script', None),
+            ('pre', 'pre_install', None),
+            ('post', 'post_install', None),
+            ('preun', 'pre_uninstall', None),
+            ('postun', 'post_uninstall', None),
+        ]
+
+        for rpm_opt, attr, default in script_options:
+            # Insert contents of file referred to, if no file is referred to
+            # use 'default' as contents of script
+            val = getattr(self, attr)
+            if val or default:
+                spec_file.extend([
+                    '',
+                    '%' + rpm_opt,
+                ])
+                if val:
+                    with open(val) as f:
+                        spec_file.extend(f.read().split('\n'))
+                else:
+                    spec_file.append(default)
+
+        # files section
+        spec_file.extend([
+            '',
+            '%files -f INSTALLED_FILES',
+            '%defattr(-,root,root)',
+        ])
+
+        if self.doc_files:
+            spec_file.append('%doc ' + ' '.join(self.doc_files))
+
+        if self.changelog:
+            spec_file.extend([
+                '',
+                '%changelog',
+            ])
+            spec_file.extend(self.changelog)
+
+        return spec_file
+
+    def _format_changelog(self, changelog):
+        """Format the changelog correctly and convert it to a list of strings"""
+        if not changelog:
+            return changelog
+        new_changelog = []
+        for line in changelog.strip().split('\n'):
+            line = line.strip()
+            if line[0] == '*':
+                new_changelog.extend(['', line])
+            elif line[0] == '-':
+                new_changelog.append(line)
+            else:
+                new_changelog.append('  ' + line)
+
+        # strip trailing newline inserted by first changelog entry
+        if not new_changelog[0]:
+            del new_changelog[0]
+
+        return new_changelog
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/command/build.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/command/build.py
new file mode 100644
index 0000000000000000000000000000000000000000..6a8303a954ea705c547e2014dc6b51d9d987a532
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/command/build.py
@@ -0,0 +1,156 @@
+"""distutils.command.build
+
+Implements the Distutils 'build' command."""
+
+from __future__ import annotations
+
+import os
+import sys
+import sysconfig
+from collections.abc import Callable
+from typing import ClassVar
+
+from ..ccompiler import show_compilers
+from ..core import Command
+from ..errors import DistutilsOptionError
+from ..util import get_platform
+
+
+class build(Command):
+    description = "build everything needed to install"
+
+    user_options = [
+        ('build-base=', 'b', "base directory for build library"),
+        ('build-purelib=', None, "build directory for platform-neutral distributions"),
+        ('build-platlib=', None, "build directory for platform-specific distributions"),
+        (
+            'build-lib=',
+            None,
+            "build directory for all distribution (defaults to either build-purelib or build-platlib",
+        ),
+        ('build-scripts=', None, "build directory for scripts"),
+        ('build-temp=', 't', "temporary build directory"),
+        (
+            'plat-name=',
+            'p',
+            f"platform name to build for, if supported [default: {get_platform()}]",
+        ),
+        ('compiler=', 'c', "specify the compiler type"),
+        ('parallel=', 'j', "number of parallel build jobs"),
+        ('debug', 'g', "compile extensions and libraries with debugging information"),
+        ('force', 'f', "forcibly build everything (ignore file timestamps)"),
+        ('executable=', 'e', "specify final destination interpreter path (build.py)"),
+    ]
+
+    boolean_options: ClassVar[list[str]] = ['debug', 'force']
+
+    help_options: ClassVar[list[tuple[str, str | None, str, Callable[[], object]]]] = [
+        ('help-compiler', None, "list available compilers", show_compilers),
+    ]
+
+    def initialize_options(self):
+        self.build_base = 'build'
+        # these are decided only after 'build_base' has its final value
+        # (unless overridden by the user or client)
+        self.build_purelib = None
+        self.build_platlib = None
+        self.build_lib = None
+        self.build_temp = None
+        self.build_scripts = None
+        self.compiler = None
+        self.plat_name = None
+        self.debug = None
+        self.force = False
+        self.executable = None
+        self.parallel = None
+
+    def finalize_options(self) -> None:  # noqa: C901
+        if self.plat_name is None:
+            self.plat_name = get_platform()
+        else:
+            # plat-name only supported for windows (other platforms are
+            # supported via ./configure flags, if at all).  Avoid misleading
+            # other platforms.
+            if os.name != 'nt':
+                raise DistutilsOptionError(
+                    "--plat-name only supported on Windows (try "
+                    "using './configure --help' on your platform)"
+                )
+
+        plat_specifier = f".{self.plat_name}-{sys.implementation.cache_tag}"
+
+        # Python 3.13+ with --disable-gil shouldn't share build directories
+        if sysconfig.get_config_var('Py_GIL_DISABLED'):
+            plat_specifier += 't'
+
+        # Make it so Python 2.x and Python 2.x with --with-pydebug don't
+        # share the same build directories. Doing so confuses the build
+        # process for C modules
+        if hasattr(sys, 'gettotalrefcount'):
+            plat_specifier += '-pydebug'
+
+        # 'build_purelib' and 'build_platlib' just default to 'lib' and
+        # 'lib.<plat>' under the base build directory.  We only use one of
+        # them for a given distribution, though --
+        if self.build_purelib is None:
+            self.build_purelib = os.path.join(self.build_base, 'lib')
+        if self.build_platlib is None:
+            self.build_platlib = os.path.join(self.build_base, 'lib' + plat_specifier)
+
+        # 'build_lib' is the actual directory that we will use for this
+        # particular module distribution -- if user didn't supply it, pick
+        # one of 'build_purelib' or 'build_platlib'.
+        if self.build_lib is None:
+            if self.distribution.has_ext_modules():
+                self.build_lib = self.build_platlib
+            else:
+                self.build_lib = self.build_purelib
+
+        # 'build_temp' -- temporary directory for compiler turds,
+        # "build/temp.<plat>"
+        if self.build_temp is None:
+            self.build_temp = os.path.join(self.build_base, 'temp' + plat_specifier)
+        if self.build_scripts is None:
+            self.build_scripts = os.path.join(
+                self.build_base,
+                f'scripts-{sys.version_info.major}.{sys.version_info.minor}',
+            )
+
+        if self.executable is None and sys.executable:
+            self.executable = os.path.normpath(sys.executable)
+
+        if isinstance(self.parallel, str):
+            try:
+                self.parallel = int(self.parallel)
+            except ValueError:
+                raise DistutilsOptionError("parallel should be an integer")
+
+    def run(self) -> None:
+        # Run all relevant sub-commands.  This will be some subset of:
+        #  - build_py      - pure Python modules
+        #  - build_clib    - standalone C libraries
+        #  - build_ext     - Python extensions
+        #  - build_scripts - (Python) scripts
+        for cmd_name in self.get_sub_commands():
+            self.run_command(cmd_name)
+
+    # -- Predicates for the sub-command list ---------------------------
+
+    def has_pure_modules(self):
+        return self.distribution.has_pure_modules()
+
+    def has_c_libraries(self):
+        return self.distribution.has_c_libraries()
+
+    def has_ext_modules(self):
+        return self.distribution.has_ext_modules()
+
+    def has_scripts(self):
+        return self.distribution.has_scripts()
+
+    sub_commands = [
+        ('build_py', has_pure_modules),
+        ('build_clib', has_c_libraries),
+        ('build_ext', has_ext_modules),
+        ('build_scripts', has_scripts),
+    ]
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/command/build_clib.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/command/build_clib.py
new file mode 100644
index 0000000000000000000000000000000000000000..8b65b3d8ece0253e0c80cfea33160c7741a2435f
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/command/build_clib.py
@@ -0,0 +1,201 @@
+"""distutils.command.build_clib
+
+Implements the Distutils 'build_clib' command, to build a C/C++ library
+that is included in the module distribution and needed by an extension
+module."""
+
+# XXX this module has *lots* of code ripped-off quite transparently from
+# build_ext.py -- not surprisingly really, as the work required to build
+# a static library from a collection of C source files is not really all
+# that different from what's required to build a shared object file from
+# a collection of C source files.  Nevertheless, I haven't done the
+# necessary refactoring to account for the overlap in code between the
+# two modules, mainly because a number of subtle details changed in the
+# cut 'n paste.  Sigh.
+from __future__ import annotations
+
+import os
+from collections.abc import Callable
+from distutils._log import log
+from typing import ClassVar
+
+from ..ccompiler import new_compiler, show_compilers
+from ..core import Command
+from ..errors import DistutilsSetupError
+from ..sysconfig import customize_compiler
+
+
+class build_clib(Command):
+    description = "build C/C++ libraries used by Python extensions"
+
+    user_options: ClassVar[list[tuple[str, str, str]]] = [
+        ('build-clib=', 'b', "directory to build C/C++ libraries to"),
+        ('build-temp=', 't', "directory to put temporary build by-products"),
+        ('debug', 'g', "compile with debugging information"),
+        ('force', 'f', "forcibly build everything (ignore file timestamps)"),
+        ('compiler=', 'c', "specify the compiler type"),
+    ]
+
+    boolean_options: ClassVar[list[str]] = ['debug', 'force']
+
+    help_options: ClassVar[list[tuple[str, str | None, str, Callable[[], object]]]] = [
+        ('help-compiler', None, "list available compilers", show_compilers),
+    ]
+
+    def initialize_options(self):
+        self.build_clib = None
+        self.build_temp = None
+
+        # List of libraries to build
+        self.libraries = None
+
+        # Compilation options for all libraries
+        self.include_dirs = None
+        self.define = None
+        self.undef = None
+        self.debug = None
+        self.force = False
+        self.compiler = None
+
+    def finalize_options(self) -> None:
+        # This might be confusing: both build-clib and build-temp default
+        # to build-temp as defined by the "build" command.  This is because
+        # I think that C libraries are really just temporary build
+        # by-products, at least from the point of view of building Python
+        # extensions -- but I want to keep my options open.
+        self.set_undefined_options(
+            'build',
+            ('build_temp', 'build_clib'),
+            ('build_temp', 'build_temp'),
+            ('compiler', 'compiler'),
+            ('debug', 'debug'),
+            ('force', 'force'),
+        )
+
+        self.libraries = self.distribution.libraries
+        if self.libraries:
+            self.check_library_list(self.libraries)
+
+        if self.include_dirs is None:
+            self.include_dirs = self.distribution.include_dirs or []
+        if isinstance(self.include_dirs, str):
+            self.include_dirs = self.include_dirs.split(os.pathsep)
+
+        # XXX same as for build_ext -- what about 'self.define' and
+        # 'self.undef' ?
+
+    def run(self) -> None:
+        if not self.libraries:
+            return
+
+        self.compiler = new_compiler(
+            compiler=self.compiler, dry_run=self.dry_run, force=self.force
+        )
+        customize_compiler(self.compiler)
+
+        if self.include_dirs is not None:
+            self.compiler.set_include_dirs(self.include_dirs)
+        if self.define is not None:
+            # 'define' option is a list of (name,value) tuples
+            for name, value in self.define:
+                self.compiler.define_macro(name, value)
+        if self.undef is not None:
+            for macro in self.undef:
+                self.compiler.undefine_macro(macro)
+
+        self.build_libraries(self.libraries)
+
+    def check_library_list(self, libraries) -> None:
+        """Ensure that the list of libraries is valid.
+
+        `library` is presumably provided as a command option 'libraries'.
+        This method checks that it is a list of 2-tuples, where the tuples
+        are (library_name, build_info_dict).
+
+        Raise DistutilsSetupError if the structure is invalid anywhere;
+        just returns otherwise.
+        """
+        if not isinstance(libraries, list):
+            raise DistutilsSetupError("'libraries' option must be a list of tuples")
+
+        for lib in libraries:
+            if not isinstance(lib, tuple) and len(lib) != 2:
+                raise DistutilsSetupError("each element of 'libraries' must a 2-tuple")
+
+            name, build_info = lib
+
+            if not isinstance(name, str):
+                raise DistutilsSetupError(
+                    "first element of each tuple in 'libraries' "
+                    "must be a string (the library name)"
+                )
+
+            if '/' in name or (os.sep != '/' and os.sep in name):
+                raise DistutilsSetupError(
+                    f"bad library name '{lib[0]}': may not contain directory separators"
+                )
+
+            if not isinstance(build_info, dict):
+                raise DistutilsSetupError(
+                    "second element of each tuple in 'libraries' "
+                    "must be a dictionary (build info)"
+                )
+
+    def get_library_names(self):
+        # Assume the library list is valid -- 'check_library_list()' is
+        # called from 'finalize_options()', so it should be!
+        if not self.libraries:
+            return None
+
+        lib_names = []
+        for lib_name, _build_info in self.libraries:
+            lib_names.append(lib_name)
+        return lib_names
+
+    def get_source_files(self):
+        self.check_library_list(self.libraries)
+        filenames = []
+        for lib_name, build_info in self.libraries:
+            sources = build_info.get('sources')
+            if sources is None or not isinstance(sources, (list, tuple)):
+                raise DistutilsSetupError(
+                    f"in 'libraries' option (library '{lib_name}'), "
+                    "'sources' must be present and must be "
+                    "a list of source filenames"
+                )
+
+            filenames.extend(sources)
+        return filenames
+
+    def build_libraries(self, libraries) -> None:
+        for lib_name, build_info in libraries:
+            sources = build_info.get('sources')
+            if sources is None or not isinstance(sources, (list, tuple)):
+                raise DistutilsSetupError(
+                    f"in 'libraries' option (library '{lib_name}'), "
+                    "'sources' must be present and must be "
+                    "a list of source filenames"
+                )
+            sources = list(sources)
+
+            log.info("building '%s' library", lib_name)
+
+            # First, compile the source code to object files in the library
+            # directory.  (This should probably change to putting object
+            # files in a temporary build directory.)
+            macros = build_info.get('macros')
+            include_dirs = build_info.get('include_dirs')
+            objects = self.compiler.compile(
+                sources,
+                output_dir=self.build_temp,
+                macros=macros,
+                include_dirs=include_dirs,
+                debug=self.debug,
+            )
+
+            # Now "link" the object files together into a static library.
+            # (On Unix at least, this isn't really linking -- it just
+            # builds an archive.  Whatever.)
+            self.compiler.create_static_lib(
+                objects, lib_name, output_dir=self.build_clib, debug=self.debug
+            )
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/command/build_ext.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/command/build_ext.py
new file mode 100644
index 0000000000000000000000000000000000000000..ec45b4403e54d3f58459a412746bc86e4135a756
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/command/build_ext.py
@@ -0,0 +1,812 @@
+"""distutils.command.build_ext
+
+Implements the Distutils 'build_ext' command, for building extension
+modules (currently limited to C extensions, should accommodate C++
+extensions ASAP)."""
+
+from __future__ import annotations
+
+import contextlib
+import os
+import re
+import sys
+from collections.abc import Callable
+from distutils._log import log
+from site import USER_BASE
+from typing import ClassVar
+
+from .._modified import newer_group
+from ..ccompiler import new_compiler, show_compilers
+from ..core import Command
+from ..errors import (
+    CCompilerError,
+    CompileError,
+    DistutilsError,
+    DistutilsOptionError,
+    DistutilsPlatformError,
+    DistutilsSetupError,
+)
+from ..extension import Extension
+from ..sysconfig import customize_compiler, get_config_h_filename, get_python_version
+from ..util import get_platform, is_freethreaded, is_mingw
+
+# An extension name is just a dot-separated list of Python NAMEs (ie.
+# the same as a fully-qualified module name).
+extension_name_re = re.compile(r'^[a-zA-Z_][a-zA-Z_0-9]*(\.[a-zA-Z_][a-zA-Z_0-9]*)*$')
+
+
+class build_ext(Command):
+    description = "build C/C++ extensions (compile/link to build directory)"
+
+    # XXX thoughts on how to deal with complex command-line options like
+    # these, i.e. how to make it so fancy_getopt can suck them off the
+    # command line and make it look like setup.py defined the appropriate
+    # lists of tuples of what-have-you.
+    #   - each command needs a callback to process its command-line options
+    #   - Command.__init__() needs access to its share of the whole
+    #     command line (must ultimately come from
+    #     Distribution.parse_command_line())
+    #   - it then calls the current command class' option-parsing
+    #     callback to deal with weird options like -D, which have to
+    #     parse the option text and churn out some custom data
+    #     structure
+    #   - that data structure (in this case, a list of 2-tuples)
+    #     will then be present in the command object by the time
+    #     we get to finalize_options() (i.e. the constructor
+    #     takes care of both command-line and client options
+    #     in between initialize_options() and finalize_options())
+
+    sep_by = f" (separated by '{os.pathsep}')"
+    user_options = [
+        ('build-lib=', 'b', "directory for compiled extension modules"),
+        ('build-temp=', 't', "directory for temporary files (build by-products)"),
+        (
+            'plat-name=',
+            'p',
+            "platform name to cross-compile for, if supported "
+            f"[default: {get_platform()}]",
+        ),
+        (
+            'inplace',
+            'i',
+            "ignore build-lib and put compiled extensions into the source "
+            "directory alongside your pure Python modules",
+        ),
+        (
+            'include-dirs=',
+            'I',
+            "list of directories to search for header files" + sep_by,
+        ),
+        ('define=', 'D', "C preprocessor macros to define"),
+        ('undef=', 'U', "C preprocessor macros to undefine"),
+        ('libraries=', 'l', "external C libraries to link with"),
+        (
+            'library-dirs=',
+            'L',
+            "directories to search for external C libraries" + sep_by,
+        ),
+        ('rpath=', 'R', "directories to search for shared C libraries at runtime"),
+        ('link-objects=', 'O', "extra explicit link objects to include in the link"),
+        ('debug', 'g', "compile/link with debugging information"),
+        ('force', 'f', "forcibly build everything (ignore file timestamps)"),
+        ('compiler=', 'c', "specify the compiler type"),
+        ('parallel=', 'j', "number of parallel build jobs"),
+        ('swig-cpp', None, "make SWIG create C++ files (default is C)"),
+        ('swig-opts=', None, "list of SWIG command line options"),
+        ('swig=', None, "path to the SWIG executable"),
+        ('user', None, "add user include, library and rpath"),
+    ]
+
+    boolean_options: ClassVar[list[str]] = [
+        'inplace',
+        'debug',
+        'force',
+        'swig-cpp',
+        'user',
+    ]
+
+    help_options: ClassVar[list[tuple[str, str | None, str, Callable[[], object]]]] = [
+        ('help-compiler', None, "list available compilers", show_compilers),
+    ]
+
+    def initialize_options(self):
+        self.extensions = None
+        self.build_lib = None
+        self.plat_name = None
+        self.build_temp = None
+        self.inplace = False
+        self.package = None
+
+        self.include_dirs = None
+        self.define = None
+        self.undef = None
+        self.libraries = None
+        self.library_dirs = None
+        self.rpath = None
+        self.link_objects = None
+        self.debug = None
+        self.force = None
+        self.compiler = None
+        self.swig = None
+        self.swig_cpp = None
+        self.swig_opts = None
+        self.user = None
+        self.parallel = None
+
+    @staticmethod
+    def _python_lib_dir(sysconfig):
+        """
+        Resolve Python's library directory for building extensions
+        that rely on a shared Python library.
+
+        See python/cpython#44264 and python/cpython#48686
+        """
+        if not sysconfig.get_config_var('Py_ENABLE_SHARED'):
+            return
+
+        if sysconfig.python_build:
+            yield '.'
+            return
+
+        if sys.platform == 'zos':
+            # On z/OS, a user is not required to install Python to
+            # a predetermined path, but can use Python portably
+            installed_dir = sysconfig.get_config_var('base')
+            lib_dir = sysconfig.get_config_var('platlibdir')
+            yield os.path.join(installed_dir, lib_dir)
+        else:
+            # building third party extensions
+            yield sysconfig.get_config_var('LIBDIR')
+
+    def finalize_options(self) -> None:  # noqa: C901
+        from distutils import sysconfig
+
+        self.set_undefined_options(
+            'build',
+            ('build_lib', 'build_lib'),
+            ('build_temp', 'build_temp'),
+            ('compiler', 'compiler'),
+            ('debug', 'debug'),
+            ('force', 'force'),
+            ('parallel', 'parallel'),
+            ('plat_name', 'plat_name'),
+        )
+
+        if self.package is None:
+            self.package = self.distribution.ext_package
+
+        self.extensions = self.distribution.ext_modules
+
+        # Make sure Python's include directories (for Python.h, pyconfig.h,
+        # etc.) are in the include search path.
+        py_include = sysconfig.get_python_inc()
+        plat_py_include = sysconfig.get_python_inc(plat_specific=True)
+        if self.include_dirs is None:
+            self.include_dirs = self.distribution.include_dirs or []
+        if isinstance(self.include_dirs, str):
+            self.include_dirs = self.include_dirs.split(os.pathsep)
+
+        # If in a virtualenv, add its include directory
+        # Issue 16116
+        if sys.exec_prefix != sys.base_exec_prefix:
+            self.include_dirs.append(os.path.join(sys.exec_prefix, 'include'))
+
+        # Put the Python "system" include dir at the end, so that
+        # any local include dirs take precedence.
+        self.include_dirs.extend(py_include.split(os.path.pathsep))
+        if plat_py_include != py_include:
+            self.include_dirs.extend(plat_py_include.split(os.path.pathsep))
+
+        self.ensure_string_list('libraries')
+        self.ensure_string_list('link_objects')
+
+        # Life is easier if we're not forever checking for None, so
+        # simplify these options to empty lists if unset
+        if self.libraries is None:
+            self.libraries = []
+        if self.library_dirs is None:
+            self.library_dirs = []
+        elif isinstance(self.library_dirs, str):
+            self.library_dirs = self.library_dirs.split(os.pathsep)
+
+        if self.rpath is None:
+            self.rpath = []
+        elif isinstance(self.rpath, str):
+            self.rpath = self.rpath.split(os.pathsep)
+
+        # for extensions under windows use different directories
+        # for Release and Debug builds.
+        # also Python's library directory must be appended to library_dirs
+        if os.name == 'nt' and not is_mingw():
+            # the 'libs' directory is for binary installs - we assume that
+            # must be the *native* platform.  But we don't really support
+            # cross-compiling via a binary install anyway, so we let it go.
+            self.library_dirs.append(os.path.join(sys.exec_prefix, 'libs'))
+            if sys.base_exec_prefix != sys.prefix:  # Issue 16116
+                self.library_dirs.append(os.path.join(sys.base_exec_prefix, 'libs'))
+            if self.debug:
+                self.build_temp = os.path.join(self.build_temp, "Debug")
+            else:
+                self.build_temp = os.path.join(self.build_temp, "Release")
+
+            # Append the source distribution include and library directories,
+            # this allows distutils on windows to work in the source tree
+            self.include_dirs.append(os.path.dirname(get_config_h_filename()))
+            self.library_dirs.append(sys.base_exec_prefix)
+
+            # Use the .lib files for the correct architecture
+            if self.plat_name == 'win32':
+                suffix = 'win32'
+            else:
+                # win-amd64
+                suffix = self.plat_name[4:]
+            new_lib = os.path.join(sys.exec_prefix, 'PCbuild')
+            if suffix:
+                new_lib = os.path.join(new_lib, suffix)
+            self.library_dirs.append(new_lib)
+
+        # For extensions under Cygwin, Python's library directory must be
+        # appended to library_dirs
+        if sys.platform[:6] == 'cygwin':
+            if not sysconfig.python_build:
+                # building third party extensions
+                self.library_dirs.append(
+                    os.path.join(
+                        sys.prefix, "lib", "python" + get_python_version(), "config"
+                    )
+                )
+            else:
+                # building python standard extensions
+                self.library_dirs.append('.')
+
+        self.library_dirs.extend(self._python_lib_dir(sysconfig))
+
+        # The argument parsing will result in self.define being a string, but
+        # it has to be a list of 2-tuples.  All the preprocessor symbols
+        # specified by the 'define' option will be set to '1'.  Multiple
+        # symbols can be separated with commas.
+
+        if self.define:
+            defines = self.define.split(',')
+            self.define = [(symbol, '1') for symbol in defines]
+
+        # The option for macros to undefine is also a string from the
+        # option parsing, but has to be a list.  Multiple symbols can also
+        # be separated with commas here.
+        if self.undef:
+            self.undef = self.undef.split(',')
+
+        if self.swig_opts is None:
+            self.swig_opts = []
+        else:
+            self.swig_opts = self.swig_opts.split(' ')
+
+        # Finally add the user include and library directories if requested
+        if self.user:
+            user_include = os.path.join(USER_BASE, "include")
+            user_lib = os.path.join(USER_BASE, "lib")
+            if os.path.isdir(user_include):
+                self.include_dirs.append(user_include)
+            if os.path.isdir(user_lib):
+                self.library_dirs.append(user_lib)
+                self.rpath.append(user_lib)
+
+        if isinstance(self.parallel, str):
+            try:
+                self.parallel = int(self.parallel)
+            except ValueError:
+                raise DistutilsOptionError("parallel should be an integer")
+
+    def run(self) -> None:  # noqa: C901
+        # 'self.extensions', as supplied by setup.py, is a list of
+        # Extension instances.  See the documentation for Extension (in
+        # distutils.extension) for details.
+        #
+        # For backwards compatibility with Distutils 0.8.2 and earlier, we
+        # also allow the 'extensions' list to be a list of tuples:
+        #    (ext_name, build_info)
+        # where build_info is a dictionary containing everything that
+        # Extension instances do except the name, with a few things being
+        # differently named.  We convert these 2-tuples to Extension
+        # instances as needed.
+
+        if not self.extensions:
+            return
+
+        # If we were asked to build any C/C++ libraries, make sure that the
+        # directory where we put them is in the library search path for
+        # linking extensions.
+        if self.distribution.has_c_libraries():
+            build_clib = self.get_finalized_command('build_clib')
+            self.libraries.extend(build_clib.get_library_names() or [])
+            self.library_dirs.append(build_clib.build_clib)
+
+        # Setup the CCompiler object that we'll use to do all the
+        # compiling and linking
+        self.compiler = new_compiler(
+            compiler=self.compiler,
+            verbose=self.verbose,
+            dry_run=self.dry_run,
+            force=self.force,
+        )
+        customize_compiler(self.compiler)
+        # If we are cross-compiling, init the compiler now (if we are not
+        # cross-compiling, init would not hurt, but people may rely on
+        # late initialization of compiler even if they shouldn't...)
+        if os.name == 'nt' and self.plat_name != get_platform():
+            self.compiler.initialize(self.plat_name)
+
+        # The official Windows free threaded Python installer doesn't set
+        # Py_GIL_DISABLED because its pyconfig.h is shared with the
+        # default build, so define it here (pypa/setuptools#4662).
+        if os.name == 'nt' and is_freethreaded():
+            self.compiler.define_macro('Py_GIL_DISABLED', '1')
+
+        # And make sure that any compile/link-related options (which might
+        # come from the command-line or from the setup script) are set in
+        # that CCompiler object -- that way, they automatically apply to
+        # all compiling and linking done here.
+        if self.include_dirs is not None:
+            self.compiler.set_include_dirs(self.include_dirs)
+        if self.define is not None:
+            # 'define' option is a list of (name,value) tuples
+            for name, value in self.define:
+                self.compiler.define_macro(name, value)
+        if self.undef is not None:
+            for macro in self.undef:
+                self.compiler.undefine_macro(macro)
+        if self.libraries is not None:
+            self.compiler.set_libraries(self.libraries)
+        if self.library_dirs is not None:
+            self.compiler.set_library_dirs(self.library_dirs)
+        if self.rpath is not None:
+            self.compiler.set_runtime_library_dirs(self.rpath)
+        if self.link_objects is not None:
+            self.compiler.set_link_objects(self.link_objects)
+
+        # Now actually compile and link everything.
+        self.build_extensions()
+
+    def check_extensions_list(self, extensions) -> None:  # noqa: C901
+        """Ensure that the list of extensions (presumably provided as a
+        command option 'extensions') is valid, i.e. it is a list of
+        Extension objects.  We also support the old-style list of 2-tuples,
+        where the tuples are (ext_name, build_info), which are converted to
+        Extension instances here.
+
+        Raise DistutilsSetupError if the structure is invalid anywhere;
+        just returns otherwise.
+        """
+        if not isinstance(extensions, list):
+            raise DistutilsSetupError(
+                "'ext_modules' option must be a list of Extension instances"
+            )
+
+        for i, ext in enumerate(extensions):
+            if isinstance(ext, Extension):
+                continue  # OK! (assume type-checking done
+                # by Extension constructor)
+
+            if not isinstance(ext, tuple) or len(ext) != 2:
+                raise DistutilsSetupError(
+                    "each element of 'ext_modules' option must be an "
+                    "Extension instance or 2-tuple"
+                )
+
+            ext_name, build_info = ext
+
+            log.warning(
+                "old-style (ext_name, build_info) tuple found in "
+                "ext_modules for extension '%s' "
+                "-- please convert to Extension instance",
+                ext_name,
+            )
+
+            if not (isinstance(ext_name, str) and extension_name_re.match(ext_name)):
+                raise DistutilsSetupError(
+                    "first element of each tuple in 'ext_modules' "
+                    "must be the extension name (a string)"
+                )
+
+            if not isinstance(build_info, dict):
+                raise DistutilsSetupError(
+                    "second element of each tuple in 'ext_modules' "
+                    "must be a dictionary (build info)"
+                )
+
+            # OK, the (ext_name, build_info) dict is type-safe: convert it
+            # to an Extension instance.
+            ext = Extension(ext_name, build_info['sources'])
+
+            # Easy stuff: one-to-one mapping from dict elements to
+            # instance attributes.
+            for key in (
+                'include_dirs',
+                'library_dirs',
+                'libraries',
+                'extra_objects',
+                'extra_compile_args',
+                'extra_link_args',
+            ):
+                val = build_info.get(key)
+                if val is not None:
+                    setattr(ext, key, val)
+
+            # Medium-easy stuff: same syntax/semantics, different names.
+            ext.runtime_library_dirs = build_info.get('rpath')
+            if 'def_file' in build_info:
+                log.warning("'def_file' element of build info dict no longer supported")
+
+            # Non-trivial stuff: 'macros' split into 'define_macros'
+            # and 'undef_macros'.
+            macros = build_info.get('macros')
+            if macros:
+                ext.define_macros = []
+                ext.undef_macros = []
+                for macro in macros:
+                    if not (isinstance(macro, tuple) and len(macro) in (1, 2)):
+                        raise DistutilsSetupError(
+                            "'macros' element of build info dict must be 1- or 2-tuple"
+                        )
+                    if len(macro) == 1:
+                        ext.undef_macros.append(macro[0])
+                    elif len(macro) == 2:
+                        ext.define_macros.append(macro)
+
+            extensions[i] = ext
+
+    def get_source_files(self):
+        self.check_extensions_list(self.extensions)
+        filenames = []
+
+        # Wouldn't it be neat if we knew the names of header files too...
+        for ext in self.extensions:
+            filenames.extend(ext.sources)
+        return filenames
+
+    def get_outputs(self):
+        # Sanity check the 'extensions' list -- can't assume this is being
+        # done in the same run as a 'build_extensions()' call (in fact, we
+        # can probably assume that it *isn't*!).
+        self.check_extensions_list(self.extensions)
+
+        # And build the list of output (built) filenames.  Note that this
+        # ignores the 'inplace' flag, and assumes everything goes in the
+        # "build" tree.
+        return [self.get_ext_fullpath(ext.name) for ext in self.extensions]
+
+    def build_extensions(self) -> None:
+        # First, sanity-check the 'extensions' list
+        self.check_extensions_list(self.extensions)
+        if self.parallel:
+            self._build_extensions_parallel()
+        else:
+            self._build_extensions_serial()
+
+    def _build_extensions_parallel(self):
+        workers = self.parallel
+        if self.parallel is True:
+            workers = os.cpu_count()  # may return None
+        try:
+            from concurrent.futures import ThreadPoolExecutor
+        except ImportError:
+            workers = None
+
+        if workers is None:
+            self._build_extensions_serial()
+            return
+
+        with ThreadPoolExecutor(max_workers=workers) as executor:
+            futures = [
+                executor.submit(self.build_extension, ext) for ext in self.extensions
+            ]
+            for ext, fut in zip(self.extensions, futures):
+                with self._filter_build_errors(ext):
+                    fut.result()
+
+    def _build_extensions_serial(self):
+        for ext in self.extensions:
+            with self._filter_build_errors(ext):
+                self.build_extension(ext)
+
+    @contextlib.contextmanager
+    def _filter_build_errors(self, ext):
+        try:
+            yield
+        except (CCompilerError, DistutilsError, CompileError) as e:
+            if not ext.optional:
+                raise
+            self.warn(f'building extension "{ext.name}" failed: {e}')
+
+    def build_extension(self, ext) -> None:
+        sources = ext.sources
+        if sources is None or not isinstance(sources, (list, tuple)):
+            raise DistutilsSetupError(
+                f"in 'ext_modules' option (extension '{ext.name}'), "
+                "'sources' must be present and must be "
+                "a list of source filenames"
+            )
+        # sort to make the resulting .so file build reproducible
+        sources = sorted(sources)
+
+        ext_path = self.get_ext_fullpath(ext.name)
+        depends = sources + ext.depends
+        if not (self.force or newer_group(depends, ext_path, 'newer')):
+            log.debug("skipping '%s' extension (up-to-date)", ext.name)
+            return
+        else:
+            log.info("building '%s' extension", ext.name)
+
+        # First, scan the sources for SWIG definition files (.i), run
+        # SWIG on 'em to create .c files, and modify the sources list
+        # accordingly.
+        sources = self.swig_sources(sources, ext)
+
+        # Next, compile the source code to object files.
+
+        # XXX not honouring 'define_macros' or 'undef_macros' -- the
+        # CCompiler API needs to change to accommodate this, and I
+        # want to do one thing at a time!
+
+        # Two possible sources for extra compiler arguments:
+        #   - 'extra_compile_args' in Extension object
+        #   - CFLAGS environment variable (not particularly
+        #     elegant, but people seem to expect it and I
+        #     guess it's useful)
+        # The environment variable should take precedence, and
+        # any sensible compiler will give precedence to later
+        # command line args.  Hence we combine them in order:
+        extra_args = ext.extra_compile_args or []
+
+        macros = ext.define_macros[:]
+        for undef in ext.undef_macros:
+            macros.append((undef,))
+
+        objects = self.compiler.compile(
+            sources,
+            output_dir=self.build_temp,
+            macros=macros,
+            include_dirs=ext.include_dirs,
+            debug=self.debug,
+            extra_postargs=extra_args,
+            depends=ext.depends,
+        )
+
+        # XXX outdated variable, kept here in case third-part code
+        # needs it.
+        self._built_objects = objects[:]
+
+        # Now link the object files together into a "shared object" --
+        # of course, first we have to figure out all the other things
+        # that go into the mix.
+        if ext.extra_objects:
+            objects.extend(ext.extra_objects)
+        extra_args = ext.extra_link_args or []
+
+        # Detect target language, if not provided
+        language = ext.language or self.compiler.detect_language(sources)
+
+        self.compiler.link_shared_object(
+            objects,
+            ext_path,
+            libraries=self.get_libraries(ext),
+            library_dirs=ext.library_dirs,
+            runtime_library_dirs=ext.runtime_library_dirs,
+            extra_postargs=extra_args,
+            export_symbols=self.get_export_symbols(ext),
+            debug=self.debug,
+            build_temp=self.build_temp,
+            target_lang=language,
+        )
+
+    def swig_sources(self, sources, extension):
+        """Walk the list of source files in 'sources', looking for SWIG
+        interface (.i) files.  Run SWIG on all that are found, and
+        return a modified 'sources' list with SWIG source files replaced
+        by the generated C (or C++) files.
+        """
+        new_sources = []
+        swig_sources = []
+        swig_targets = {}
+
+        # XXX this drops generated C/C++ files into the source tree, which
+        # is fine for developers who want to distribute the generated
+        # source -- but there should be an option to put SWIG output in
+        # the temp dir.
+
+        if self.swig_cpp:
+            log.warning("--swig-cpp is deprecated - use --swig-opts=-c++")
+
+        if (
+            self.swig_cpp
+            or ('-c++' in self.swig_opts)
+            or ('-c++' in extension.swig_opts)
+        ):
+            target_ext = '.cpp'
+        else:
+            target_ext = '.c'
+
+        for source in sources:
+            (base, ext) = os.path.splitext(source)
+            if ext == ".i":  # SWIG interface file
+                new_sources.append(base + '_wrap' + target_ext)
+                swig_sources.append(source)
+                swig_targets[source] = new_sources[-1]
+            else:
+                new_sources.append(source)
+
+        if not swig_sources:
+            return new_sources
+
+        swig = self.swig or self.find_swig()
+        swig_cmd = [swig, "-python"]
+        swig_cmd.extend(self.swig_opts)
+        if self.swig_cpp:
+            swig_cmd.append("-c++")
+
+        # Do not override commandline arguments
+        if not self.swig_opts:
+            swig_cmd.extend(extension.swig_opts)
+
+        for source in swig_sources:
+            target = swig_targets[source]
+            log.info("swigging %s to %s", source, target)
+            self.spawn(swig_cmd + ["-o", target, source])
+
+        return new_sources
+
+    def find_swig(self):
+        """Return the name of the SWIG executable.  On Unix, this is
+        just "swig" -- it should be in the PATH.  Tries a bit harder on
+        Windows.
+        """
+        if os.name == "posix":
+            return "swig"
+        elif os.name == "nt":
+            # Look for SWIG in its standard installation directory on
+            # Windows (or so I presume!).  If we find it there, great;
+            # if not, act like Unix and assume it's in the PATH.
+            for vers in ("1.3", "1.2", "1.1"):
+                fn = os.path.join(f"c:\\swig{vers}", "swig.exe")
+                if os.path.isfile(fn):
+                    return fn
+            else:
+                return "swig.exe"
+        else:
+            raise DistutilsPlatformError(
+                f"I don't know how to find (much less run) SWIG on platform '{os.name}'"
+            )
+
+    # -- Name generators -----------------------------------------------
+    # (extension names, filenames, whatever)
+    def get_ext_fullpath(self, ext_name: str) -> str:
+        """Returns the path of the filename for a given extension.
+
+        The file is located in `build_lib` or directly in the package
+        (inplace option).
+        """
+        fullname = self.get_ext_fullname(ext_name)
+        modpath = fullname.split('.')
+        filename = self.get_ext_filename(modpath[-1])
+
+        if not self.inplace:
+            # no further work needed
+            # returning :
+            #   build_dir/package/path/filename
+            filename = os.path.join(*modpath[:-1] + [filename])
+            return os.path.join(self.build_lib, filename)
+
+        # the inplace option requires to find the package directory
+        # using the build_py command for that
+        package = '.'.join(modpath[0:-1])
+        build_py = self.get_finalized_command('build_py')
+        package_dir = os.path.abspath(build_py.get_package_dir(package))
+
+        # returning
+        #   package_dir/filename
+        return os.path.join(package_dir, filename)
+
+    def get_ext_fullname(self, ext_name: str) -> str:
+        """Returns the fullname of a given extension name.
+
+        Adds the `package.` prefix"""
+        if self.package is None:
+            return ext_name
+        else:
+            return self.package + '.' + ext_name
+
+    def get_ext_filename(self, ext_name: str) -> str:
+        r"""Convert the name of an extension (eg. "foo.bar") into the name
+        of the file from which it will be loaded (eg. "foo/bar.so", or
+        "foo\bar.pyd").
+        """
+        from ..sysconfig import get_config_var
+
+        ext_path = ext_name.split('.')
+        ext_suffix = get_config_var('EXT_SUFFIX')
+        return os.path.join(*ext_path) + ext_suffix
+
+    def get_export_symbols(self, ext: Extension) -> list[str]:
+        """Return the list of symbols that a shared extension has to
+        export.  This either uses 'ext.export_symbols' or, if it's not
+        provided, "PyInit_" + module_name.  Only relevant on Windows, where
+        the .pyd file (DLL) must export the module "PyInit_" function.
+        """
+        name = self._get_module_name_for_symbol(ext)
+        try:
+            # Unicode module name support as defined in PEP-489
+            # https://peps.python.org/pep-0489/#export-hook-name
+            name.encode('ascii')
+        except UnicodeEncodeError:
+            suffix = 'U_' + name.encode('punycode').replace(b'-', b'_').decode('ascii')
+        else:
+            suffix = "_" + name
+
+        initfunc_name = "PyInit" + suffix
+        if initfunc_name not in ext.export_symbols:
+            ext.export_symbols.append(initfunc_name)
+        return ext.export_symbols
+
+    def _get_module_name_for_symbol(self, ext):
+        # Package name should be used for `__init__` modules
+        # https://github.com/python/cpython/issues/80074
+        # https://github.com/pypa/setuptools/issues/4826
+        parts = ext.name.split(".")
+        if parts[-1] == "__init__" and len(parts) >= 2:
+            return parts[-2]
+        return parts[-1]
+
+    def get_libraries(self, ext: Extension) -> list[str]:  # noqa: C901
+        """Return the list of libraries to link against when building a
+        shared extension.  On most platforms, this is just 'ext.libraries';
+        on Windows, we add the Python library (eg. python20.dll).
+        """
+        # The python library is always needed on Windows.  For MSVC, this
+        # is redundant, since the library is mentioned in a pragma in
+        # pyconfig.h that MSVC groks.  The other Windows compilers all seem
+        # to need it mentioned explicitly, though, so that's what we do.
+        # Append '_d' to the python import library on debug builds.
+        if sys.platform == "win32" and not is_mingw():
+            from .._msvccompiler import MSVCCompiler
+
+            if not isinstance(self.compiler, MSVCCompiler):
+                template = "python%d%d"
+                if self.debug:
+                    template = template + '_d'
+                pythonlib = template % (
+                    sys.hexversion >> 24,
+                    (sys.hexversion >> 16) & 0xFF,
+                )
+                # don't extend ext.libraries, it may be shared with other
+                # extensions, it is a reference to the original list
+                return ext.libraries + [pythonlib]
+        else:
+            # On Android only the main executable and LD_PRELOADs are considered
+            # to be RTLD_GLOBAL, all the dependencies of the main executable
+            # remain RTLD_LOCAL and so the shared libraries must be linked with
+            # libpython when python is built with a shared python library (issue
+            # bpo-21536).
+            # On Cygwin (and if required, other POSIX-like platforms based on
+            # Windows like MinGW) it is simply necessary that all symbols in
+            # shared libraries are resolved at link time.
+            from ..sysconfig import get_config_var
+
+            link_libpython = False
+            if get_config_var('Py_ENABLE_SHARED'):
+                # A native build on an Android device or on Cygwin
+                if hasattr(sys, 'getandroidapilevel'):
+                    link_libpython = True
+                elif sys.platform == 'cygwin' or is_mingw():
+                    link_libpython = True
+                elif '_PYTHON_HOST_PLATFORM' in os.environ:
+                    # We are cross-compiling for one of the relevant platforms
+                    if get_config_var('ANDROID_API_LEVEL') != 0:
+                        link_libpython = True
+                    elif get_config_var('MACHDEP') == 'cygwin':
+                        link_libpython = True
+
+            if link_libpython:
+                ldversion = get_config_var('LDVERSION')
+                return ext.libraries + ['python' + ldversion]
+
+        return ext.libraries
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/command/build_py.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/command/build_py.py
new file mode 100644
index 0000000000000000000000000000000000000000..a20b076fe7cca9140e05b1cf171b62155995f36e
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/command/build_py.py
@@ -0,0 +1,407 @@
+"""distutils.command.build_py
+
+Implements the Distutils 'build_py' command."""
+
+import glob
+import importlib.util
+import os
+import sys
+from distutils._log import log
+from typing import ClassVar
+
+from ..core import Command
+from ..errors import DistutilsFileError, DistutilsOptionError
+from ..util import convert_path
+
+
+class build_py(Command):
+    description = "\"build\" pure Python modules (copy to build directory)"
+
+    user_options = [
+        ('build-lib=', 'd', "directory to \"build\" (copy) to"),
+        ('compile', 'c', "compile .py to .pyc"),
+        ('no-compile', None, "don't compile .py files [default]"),
+        (
+            'optimize=',
+            'O',
+            "also compile with optimization: -O1 for \"python -O\", "
+            "-O2 for \"python -OO\", and -O0 to disable [default: -O0]",
+        ),
+        ('force', 'f', "forcibly build everything (ignore file timestamps)"),
+    ]
+
+    boolean_options: ClassVar[list[str]] = ['compile', 'force']
+    negative_opt: ClassVar[dict[str, str]] = {'no-compile': 'compile'}
+
+    def initialize_options(self):
+        self.build_lib = None
+        self.py_modules = None
+        self.package = None
+        self.package_data = None
+        self.package_dir = None
+        self.compile = False
+        self.optimize = 0
+        self.force = None
+
+    def finalize_options(self) -> None:
+        self.set_undefined_options(
+            'build', ('build_lib', 'build_lib'), ('force', 'force')
+        )
+
+        # Get the distribution options that are aliases for build_py
+        # options -- list of packages and list of modules.
+        self.packages = self.distribution.packages
+        self.py_modules = self.distribution.py_modules
+        self.package_data = self.distribution.package_data
+        self.package_dir = {}
+        if self.distribution.package_dir:
+            for name, path in self.distribution.package_dir.items():
+                self.package_dir[name] = convert_path(path)
+        self.data_files = self.get_data_files()
+
+        # Ick, copied straight from install_lib.py (fancy_getopt needs a
+        # type system!  Hell, *everything* needs a type system!!!)
+        if not isinstance(self.optimize, int):
+            try:
+                self.optimize = int(self.optimize)
+                assert 0 <= self.optimize <= 2
+            except (ValueError, AssertionError):
+                raise DistutilsOptionError("optimize must be 0, 1, or 2")
+
+    def run(self) -> None:
+        # XXX copy_file by default preserves atime and mtime.  IMHO this is
+        # the right thing to do, but perhaps it should be an option -- in
+        # particular, a site administrator might want installed files to
+        # reflect the time of installation rather than the last
+        # modification time before the installed release.
+
+        # XXX copy_file by default preserves mode, which appears to be the
+        # wrong thing to do: if a file is read-only in the working
+        # directory, we want it to be installed read/write so that the next
+        # installation of the same module distribution can overwrite it
+        # without problems.  (This might be a Unix-specific issue.)  Thus
+        # we turn off 'preserve_mode' when copying to the build directory,
+        # since the build directory is supposed to be exactly what the
+        # installation will look like (ie. we preserve mode when
+        # installing).
+
+        # Two options control which modules will be installed: 'packages'
+        # and 'py_modules'.  The former lets us work with whole packages, not
+        # specifying individual modules at all; the latter is for
+        # specifying modules one-at-a-time.
+
+        if self.py_modules:
+            self.build_modules()
+        if self.packages:
+            self.build_packages()
+            self.build_package_data()
+
+        self.byte_compile(self.get_outputs(include_bytecode=False))
+
+    def get_data_files(self):
+        """Generate list of '(package,src_dir,build_dir,filenames)' tuples"""
+        data = []
+        if not self.packages:
+            return data
+        for package in self.packages:
+            # Locate package source directory
+            src_dir = self.get_package_dir(package)
+
+            # Compute package build directory
+            build_dir = os.path.join(*([self.build_lib] + package.split('.')))
+
+            # Length of path to strip from found files
+            plen = 0
+            if src_dir:
+                plen = len(src_dir) + 1
+
+            # Strip directory from globbed filenames
+            filenames = [file[plen:] for file in self.find_data_files(package, src_dir)]
+            data.append((package, src_dir, build_dir, filenames))
+        return data
+
+    def find_data_files(self, package, src_dir):
+        """Return filenames for package's data files in 'src_dir'"""
+        globs = self.package_data.get('', []) + self.package_data.get(package, [])
+        files = []
+        for pattern in globs:
+            # Each pattern has to be converted to a platform-specific path
+            filelist = glob.glob(
+                os.path.join(glob.escape(src_dir), convert_path(pattern))
+            )
+            # Files that match more than one pattern are only added once
+            files.extend([
+                fn for fn in filelist if fn not in files and os.path.isfile(fn)
+            ])
+        return files
+
+    def build_package_data(self) -> None:
+        """Copy data files into build directory"""
+        for _package, src_dir, build_dir, filenames in self.data_files:
+            for filename in filenames:
+                target = os.path.join(build_dir, filename)
+                self.mkpath(os.path.dirname(target))
+                self.copy_file(
+                    os.path.join(src_dir, filename), target, preserve_mode=False
+                )
+
+    def get_package_dir(self, package):
+        """Return the directory, relative to the top of the source
+        distribution, where package 'package' should be found
+        (at least according to the 'package_dir' option, if any)."""
+        path = package.split('.')
+
+        if not self.package_dir:
+            if path:
+                return os.path.join(*path)
+            else:
+                return ''
+        else:
+            tail = []
+            while path:
+                try:
+                    pdir = self.package_dir['.'.join(path)]
+                except KeyError:
+                    tail.insert(0, path[-1])
+                    del path[-1]
+                else:
+                    tail.insert(0, pdir)
+                    return os.path.join(*tail)
+            else:
+                # Oops, got all the way through 'path' without finding a
+                # match in package_dir.  If package_dir defines a directory
+                # for the root (nameless) package, then fallback on it;
+                # otherwise, we might as well have not consulted
+                # package_dir at all, as we just use the directory implied
+                # by 'tail' (which should be the same as the original value
+                # of 'path' at this point).
+                pdir = self.package_dir.get('')
+                if pdir is not None:
+                    tail.insert(0, pdir)
+
+                if tail:
+                    return os.path.join(*tail)
+                else:
+                    return ''
+
+    def check_package(self, package, package_dir):
+        # Empty dir name means current directory, which we can probably
+        # assume exists.  Also, os.path.exists and isdir don't know about
+        # my "empty string means current dir" convention, so we have to
+        # circumvent them.
+        if package_dir != "":
+            if not os.path.exists(package_dir):
+                raise DistutilsFileError(
+                    f"package directory '{package_dir}' does not exist"
+                )
+            if not os.path.isdir(package_dir):
+                raise DistutilsFileError(
+                    f"supposed package directory '{package_dir}' exists, "
+                    "but is not a directory"
+                )
+
+        # Directories without __init__.py are namespace packages (PEP 420).
+        if package:
+            init_py = os.path.join(package_dir, "__init__.py")
+            if os.path.isfile(init_py):
+                return init_py
+
+        # Either not in a package at all (__init__.py not expected), or
+        # __init__.py doesn't exist -- so don't return the filename.
+        return None
+
+    def check_module(self, module, module_file):
+        if not os.path.isfile(module_file):
+            log.warning("file %s (for module %s) not found", module_file, module)
+            return False
+        else:
+            return True
+
+    def find_package_modules(self, package, package_dir):
+        self.check_package(package, package_dir)
+        module_files = glob.glob(os.path.join(glob.escape(package_dir), "*.py"))
+        modules = []
+        setup_script = os.path.abspath(self.distribution.script_name)
+
+        for f in module_files:
+            abs_f = os.path.abspath(f)
+            if abs_f != setup_script:
+                module = os.path.splitext(os.path.basename(f))[0]
+                modules.append((package, module, f))
+            else:
+                self.debug_print(f"excluding {setup_script}")
+        return modules
+
+    def find_modules(self):
+        """Finds individually-specified Python modules, ie. those listed by
+        module name in 'self.py_modules'.  Returns a list of tuples (package,
+        module_base, filename): 'package' is a tuple of the path through
+        package-space to the module; 'module_base' is the bare (no
+        packages, no dots) module name, and 'filename' is the path to the
+        ".py" file (relative to the distribution root) that implements the
+        module.
+        """
+        # Map package names to tuples of useful info about the package:
+        #    (package_dir, checked)
+        # package_dir - the directory where we'll find source files for
+        #   this package
+        # checked - true if we have checked that the package directory
+        #   is valid (exists, contains __init__.py, ... ?)
+        packages = {}
+
+        # List of (package, module, filename) tuples to return
+        modules = []
+
+        # We treat modules-in-packages almost the same as toplevel modules,
+        # just the "package" for a toplevel is empty (either an empty
+        # string or empty list, depending on context).  Differences:
+        #   - don't check for __init__.py in directory for empty package
+        for module in self.py_modules:
+            path = module.split('.')
+            package = '.'.join(path[0:-1])
+            module_base = path[-1]
+
+            try:
+                (package_dir, checked) = packages[package]
+            except KeyError:
+                package_dir = self.get_package_dir(package)
+                checked = False
+
+            if not checked:
+                init_py = self.check_package(package, package_dir)
+                packages[package] = (package_dir, 1)
+                if init_py:
+                    modules.append((package, "__init__", init_py))
+
+            # XXX perhaps we should also check for just .pyc files
+            # (so greedy closed-source bastards can distribute Python
+            # modules too)
+            module_file = os.path.join(package_dir, module_base + ".py")
+            if not self.check_module(module, module_file):
+                continue
+
+            modules.append((package, module_base, module_file))
+
+        return modules
+
+    def find_all_modules(self):
+        """Compute the list of all modules that will be built, whether
+        they are specified one-module-at-a-time ('self.py_modules') or
+        by whole packages ('self.packages').  Return a list of tuples
+        (package, module, module_file), just like 'find_modules()' and
+        'find_package_modules()' do."""
+        modules = []
+        if self.py_modules:
+            modules.extend(self.find_modules())
+        if self.packages:
+            for package in self.packages:
+                package_dir = self.get_package_dir(package)
+                m = self.find_package_modules(package, package_dir)
+                modules.extend(m)
+        return modules
+
+    def get_source_files(self):
+        return [module[-1] for module in self.find_all_modules()]
+
+    def get_module_outfile(self, build_dir, package, module):
+        outfile_path = [build_dir] + list(package) + [module + ".py"]
+        return os.path.join(*outfile_path)
+
+    def get_outputs(self, include_bytecode: bool = True) -> list[str]:
+        modules = self.find_all_modules()
+        outputs = []
+        for package, module, _module_file in modules:
+            package = package.split('.')
+            filename = self.get_module_outfile(self.build_lib, package, module)
+            outputs.append(filename)
+            if include_bytecode:
+                if self.compile:
+                    outputs.append(
+                        importlib.util.cache_from_source(filename, optimization='')
+                    )
+                if self.optimize > 0:
+                    outputs.append(
+                        importlib.util.cache_from_source(
+                            filename, optimization=self.optimize
+                        )
+                    )
+
+        outputs += [
+            os.path.join(build_dir, filename)
+            for package, src_dir, build_dir, filenames in self.data_files
+            for filename in filenames
+        ]
+
+        return outputs
+
+    def build_module(self, module, module_file, package):
+        if isinstance(package, str):
+            package = package.split('.')
+        elif not isinstance(package, (list, tuple)):
+            raise TypeError(
+                "'package' must be a string (dot-separated), list, or tuple"
+            )
+
+        # Now put the module source file into the "build" area -- this is
+        # easy, we just copy it somewhere under self.build_lib (the build
+        # directory for Python source).
+        outfile = self.get_module_outfile(self.build_lib, package, module)
+        dir = os.path.dirname(outfile)
+        self.mkpath(dir)
+        return self.copy_file(module_file, outfile, preserve_mode=False)
+
+    def build_modules(self) -> None:
+        modules = self.find_modules()
+        for package, module, module_file in modules:
+            # Now "build" the module -- ie. copy the source file to
+            # self.build_lib (the build directory for Python source).
+            # (Actually, it gets copied to the directory for this package
+            # under self.build_lib.)
+            self.build_module(module, module_file, package)
+
+    def build_packages(self) -> None:
+        for package in self.packages:
+            # Get list of (package, module, module_file) tuples based on
+            # scanning the package directory.  'package' is only included
+            # in the tuple so that 'find_modules()' and
+            # 'find_package_tuples()' have a consistent interface; it's
+            # ignored here (apart from a sanity check).  Also, 'module' is
+            # the *unqualified* module name (ie. no dots, no package -- we
+            # already know its package!), and 'module_file' is the path to
+            # the .py file, relative to the current directory
+            # (ie. including 'package_dir').
+            package_dir = self.get_package_dir(package)
+            modules = self.find_package_modules(package, package_dir)
+
+            # Now loop over the modules we found, "building" each one (just
+            # copy it to self.build_lib).
+            for package_, module, module_file in modules:
+                assert package == package_
+                self.build_module(module, module_file, package)
+
+    def byte_compile(self, files) -> None:
+        if sys.dont_write_bytecode:
+            self.warn('byte-compiling is disabled, skipping.')
+            return
+
+        from ..util import byte_compile
+
+        prefix = self.build_lib
+        if prefix[-1] != os.sep:
+            prefix = prefix + os.sep
+
+        # XXX this code is essentially the same as the 'byte_compile()
+        # method of the "install_lib" command, except for the determination
+        # of the 'prefix' string.  Hmmm.
+        if self.compile:
+            byte_compile(
+                files, optimize=0, force=self.force, prefix=prefix, dry_run=self.dry_run
+            )
+        if self.optimize > 0:
+            byte_compile(
+                files,
+                optimize=self.optimize,
+                force=self.force,
+                prefix=prefix,
+                dry_run=self.dry_run,
+            )
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/command/build_scripts.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/command/build_scripts.py
new file mode 100644
index 0000000000000000000000000000000000000000..127c51d8dc2ed5607cf5995ede05f9741c44d2c6
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/command/build_scripts.py
@@ -0,0 +1,160 @@
+"""distutils.command.build_scripts
+
+Implements the Distutils 'build_scripts' command."""
+
+import os
+import re
+import tokenize
+from distutils._log import log
+from stat import ST_MODE
+from typing import ClassVar
+
+from .._modified import newer
+from ..core import Command
+from ..util import convert_path
+
+shebang_pattern = re.compile('^#!.*python[0-9.]*([ \t].*)?$')
+"""
+Pattern matching a Python interpreter indicated in first line of a script.
+"""
+
+# for Setuptools compatibility
+first_line_re = shebang_pattern
+
+
+class build_scripts(Command):
+    description = "\"build\" scripts (copy and fixup #! line)"
+
+    user_options: ClassVar[list[tuple[str, str, str]]] = [
+        ('build-dir=', 'd', "directory to \"build\" (copy) to"),
+        ('force', 'f', "forcibly build everything (ignore file timestamps"),
+        ('executable=', 'e', "specify final destination interpreter path"),
+    ]
+
+    boolean_options: ClassVar[list[str]] = ['force']
+
+    def initialize_options(self):
+        self.build_dir = None
+        self.scripts = None
+        self.force = None
+        self.executable = None
+
+    def finalize_options(self):
+        self.set_undefined_options(
+            'build',
+            ('build_scripts', 'build_dir'),
+            ('force', 'force'),
+            ('executable', 'executable'),
+        )
+        self.scripts = self.distribution.scripts
+
+    def get_source_files(self):
+        return self.scripts
+
+    def run(self):
+        if not self.scripts:
+            return
+        self.copy_scripts()
+
+    def copy_scripts(self):
+        """
+        Copy each script listed in ``self.scripts``.
+
+        If a script is marked as a Python script (first line matches
+        'shebang_pattern', i.e. starts with ``#!`` and contains
+        "python"), then adjust in the copy the first line to refer to
+        the current Python interpreter.
+        """
+        self.mkpath(self.build_dir)
+        outfiles = []
+        updated_files = []
+        for script in self.scripts:
+            self._copy_script(script, outfiles, updated_files)
+
+        self._change_modes(outfiles)
+
+        return outfiles, updated_files
+
+    def _copy_script(self, script, outfiles, updated_files):
+        shebang_match = None
+        script = convert_path(script)
+        outfile = os.path.join(self.build_dir, os.path.basename(script))
+        outfiles.append(outfile)
+
+        if not self.force and not newer(script, outfile):
+            log.debug("not copying %s (up-to-date)", script)
+            return
+
+        # Always open the file, but ignore failures in dry-run mode
+        # in order to attempt to copy directly.
+        try:
+            f = tokenize.open(script)
+        except OSError:
+            if not self.dry_run:
+                raise
+            f = None
+        else:
+            first_line = f.readline()
+            if not first_line:
+                self.warn(f"{script} is an empty file (skipping)")
+                return
+
+            shebang_match = shebang_pattern.match(first_line)
+
+        updated_files.append(outfile)
+        if shebang_match:
+            log.info("copying and adjusting %s -> %s", script, self.build_dir)
+            if not self.dry_run:
+                post_interp = shebang_match.group(1) or ''
+                shebang = f"#!python{post_interp}\n"
+                self._validate_shebang(shebang, f.encoding)
+                with open(outfile, "w", encoding=f.encoding) as outf:
+                    outf.write(shebang)
+                    outf.writelines(f.readlines())
+            if f:
+                f.close()
+        else:
+            if f:
+                f.close()
+            self.copy_file(script, outfile)
+
+    def _change_modes(self, outfiles):
+        if os.name != 'posix':
+            return
+
+        for file in outfiles:
+            self._change_mode(file)
+
+    def _change_mode(self, file):
+        if self.dry_run:
+            log.info("changing mode of %s", file)
+            return
+
+        oldmode = os.stat(file)[ST_MODE] & 0o7777
+        newmode = (oldmode | 0o555) & 0o7777
+        if newmode != oldmode:
+            log.info("changing mode of %s from %o to %o", file, oldmode, newmode)
+            os.chmod(file, newmode)
+
+    @staticmethod
+    def _validate_shebang(shebang, encoding):
+        # Python parser starts to read a script using UTF-8 until
+        # it gets a #coding:xxx cookie. The shebang has to be the
+        # first line of a file, the #coding:xxx cookie cannot be
+        # written before. So the shebang has to be encodable to
+        # UTF-8.
+        try:
+            shebang.encode('utf-8')
+        except UnicodeEncodeError:
+            raise ValueError(f"The shebang ({shebang!r}) is not encodable to utf-8")
+
+        # If the script is encoded to a custom encoding (use a
+        # #coding:xxx cookie), the shebang has to be encodable to
+        # the script encoding too.
+        try:
+            shebang.encode(encoding)
+        except UnicodeEncodeError:
+            raise ValueError(
+                f"The shebang ({shebang!r}) is not encodable "
+                f"to the script encoding ({encoding})"
+            )
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/command/check.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/command/check.py
new file mode 100644
index 0000000000000000000000000000000000000000..58a823dd3904cf105ed432e458a45d94948fbb4c
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/command/check.py
@@ -0,0 +1,152 @@
+"""distutils.command.check
+
+Implements the Distutils 'check' command.
+"""
+
+import contextlib
+from typing import ClassVar
+
+from ..core import Command
+from ..errors import DistutilsSetupError
+
+with contextlib.suppress(ImportError):
+    import docutils.frontend
+    import docutils.nodes
+    import docutils.parsers.rst
+    import docutils.utils
+
+    class SilentReporter(docutils.utils.Reporter):
+        def __init__(
+            self,
+            source,
+            report_level,
+            halt_level,
+            stream=None,
+            debug=False,
+            encoding='ascii',
+            error_handler='replace',
+        ):
+            self.messages = []
+            super().__init__(
+                source, report_level, halt_level, stream, debug, encoding, error_handler
+            )
+
+        def system_message(self, level, message, *children, **kwargs):
+            self.messages.append((level, message, children, kwargs))
+            return docutils.nodes.system_message(
+                message, *children, level=level, type=self.levels[level], **kwargs
+            )
+
+
+class check(Command):
+    """This command checks the meta-data of the package."""
+
+    description = "perform some checks on the package"
+    user_options: ClassVar[list[tuple[str, str, str]]] = [
+        ('metadata', 'm', 'Verify meta-data'),
+        (
+            'restructuredtext',
+            'r',
+            'Checks if long string meta-data syntax are reStructuredText-compliant',
+        ),
+        ('strict', 's', 'Will exit with an error if a check fails'),
+    ]
+
+    boolean_options: ClassVar[list[str]] = ['metadata', 'restructuredtext', 'strict']
+
+    def initialize_options(self):
+        """Sets default values for options."""
+        self.restructuredtext = False
+        self.metadata = 1
+        self.strict = False
+        self._warnings = 0
+
+    def finalize_options(self):
+        pass
+
+    def warn(self, msg):
+        """Counts the number of warnings that occurs."""
+        self._warnings += 1
+        return Command.warn(self, msg)
+
+    def run(self):
+        """Runs the command."""
+        # perform the various tests
+        if self.metadata:
+            self.check_metadata()
+        if self.restructuredtext:
+            if 'docutils' in globals():
+                try:
+                    self.check_restructuredtext()
+                except TypeError as exc:
+                    raise DistutilsSetupError(str(exc))
+            elif self.strict:
+                raise DistutilsSetupError('The docutils package is needed.')
+
+        # let's raise an error in strict mode, if we have at least
+        # one warning
+        if self.strict and self._warnings > 0:
+            raise DistutilsSetupError('Please correct your package.')
+
+    def check_metadata(self):
+        """Ensures that all required elements of meta-data are supplied.
+
+        Required fields:
+            name, version
+
+        Warns if any are missing.
+        """
+        metadata = self.distribution.metadata
+
+        missing = [
+            attr for attr in ('name', 'version') if not getattr(metadata, attr, None)
+        ]
+
+        if missing:
+            self.warn("missing required meta-data: {}".format(', '.join(missing)))
+
+    def check_restructuredtext(self):
+        """Checks if the long string fields are reST-compliant."""
+        data = self.distribution.get_long_description()
+        for warning in self._check_rst_data(data):
+            line = warning[-1].get('line')
+            if line is None:
+                warning = warning[1]
+            else:
+                warning = f'{warning[1]} (line {line})'
+            self.warn(warning)
+
+    def _check_rst_data(self, data):
+        """Returns warnings when the provided data doesn't compile."""
+        # the include and csv_table directives need this to be a path
+        source_path = self.distribution.script_name or 'setup.py'
+        parser = docutils.parsers.rst.Parser()
+        settings = docutils.frontend.OptionParser(
+            components=(docutils.parsers.rst.Parser,)
+        ).get_default_values()
+        settings.tab_width = 4
+        settings.pep_references = None
+        settings.rfc_references = None
+        reporter = SilentReporter(
+            source_path,
+            settings.report_level,
+            settings.halt_level,
+            stream=settings.warning_stream,
+            debug=settings.debug,
+            encoding=settings.error_encoding,
+            error_handler=settings.error_encoding_error_handler,
+        )
+
+        document = docutils.nodes.document(settings, reporter, source=source_path)
+        document.note_source(source_path, -1)
+        try:
+            parser.parse(data, document)
+        except (AttributeError, TypeError) as e:
+            reporter.messages.append((
+                -1,
+                f'Could not finish the parsing: {e}.',
+                '',
+                {},
+            ))
+
+        return reporter.messages
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/command/clean.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/command/clean.py
new file mode 100644
index 0000000000000000000000000000000000000000..23427aba21132ec16122ec17b54794203b02baa5
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/command/clean.py
@@ -0,0 +1,77 @@
+"""distutils.command.clean
+
+Implements the Distutils 'clean' command."""
+
+# contributed by Bastian Kleineidam <calvin@cs.uni-sb.de>, added 2000-03-18
+
+import os
+from distutils._log import log
+from typing import ClassVar
+
+from ..core import Command
+from ..dir_util import remove_tree
+
+
+class clean(Command):
+    description = "clean up temporary files from 'build' command"
+    user_options = [
+        ('build-base=', 'b', "base build directory [default: 'build.build-base']"),
+        (
+            'build-lib=',
+            None,
+            "build directory for all modules [default: 'build.build-lib']",
+        ),
+        ('build-temp=', 't', "temporary build directory [default: 'build.build-temp']"),
+        (
+            'build-scripts=',
+            None,
+            "build directory for scripts [default: 'build.build-scripts']",
+        ),
+        ('bdist-base=', None, "temporary directory for built distributions"),
+        ('all', 'a', "remove all build output, not just temporary by-products"),
+    ]
+
+    boolean_options: ClassVar[list[str]] = ['all']
+
+    def initialize_options(self):
+        self.build_base = None
+        self.build_lib = None
+        self.build_temp = None
+        self.build_scripts = None
+        self.bdist_base = None
+        self.all = None
+
+    def finalize_options(self):
+        self.set_undefined_options(
+            'build',
+            ('build_base', 'build_base'),
+            ('build_lib', 'build_lib'),
+            ('build_scripts', 'build_scripts'),
+            ('build_temp', 'build_temp'),
+        )
+        self.set_undefined_options('bdist', ('bdist_base', 'bdist_base'))
+
+    def run(self):
+        # remove the build/temp.<plat> directory (unless it's already
+        # gone)
+        if os.path.exists(self.build_temp):
+            remove_tree(self.build_temp, dry_run=self.dry_run)
+        else:
+            log.debug("'%s' does not exist -- can't clean it", self.build_temp)
+
+        if self.all:
+            # remove build directories
+            for directory in (self.build_lib, self.bdist_base, self.build_scripts):
+                if os.path.exists(directory):
+                    remove_tree(directory, dry_run=self.dry_run)
+                else:
+                    log.warning("'%s' does not exist -- can't clean it", directory)
+
+        # just for the heck of it, try to remove the base build directory:
+        # we might have emptied it right now, but if not we don't care
+        if not self.dry_run:
+            try:
+                os.rmdir(self.build_base)
+                log.info("removing '%s'", self.build_base)
+            except OSError:
+                pass
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/command/config.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/command/config.py
new file mode 100644
index 0000000000000000000000000000000000000000..c825765c873f04e85b8c38869f0b3e5e416a2dad
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/command/config.py
@@ -0,0 +1,358 @@
+"""distutils.command.config
+
+Implements the Distutils 'config' command, a (mostly) empty command class
+that exists mainly to be sub-classed by specific module distributions and
+applications.  The idea is that while every "config" command is different,
+at least they're all named the same, and users always see "config" in the
+list of standard commands.  Also, this is a good place to put common
+configure-like tasks: "try to compile this C code", or "figure out where
+this header file lives".
+"""
+
+from __future__ import annotations
+
+import os
+import pathlib
+import re
+from collections.abc import Sequence
+from distutils._log import log
+
+from ..ccompiler import CCompiler, CompileError, LinkError, new_compiler
+from ..core import Command
+from ..errors import DistutilsExecError
+from ..sysconfig import customize_compiler
+
+LANG_EXT = {"c": ".c", "c++": ".cxx"}
+
+
+class config(Command):
+    description = "prepare to build"
+
+    user_options = [
+        ('compiler=', None, "specify the compiler type"),
+        ('cc=', None, "specify the compiler executable"),
+        ('include-dirs=', 'I', "list of directories to search for header files"),
+        ('define=', 'D', "C preprocessor macros to define"),
+        ('undef=', 'U', "C preprocessor macros to undefine"),
+        ('libraries=', 'l', "external C libraries to link with"),
+        ('library-dirs=', 'L', "directories to search for external C libraries"),
+        ('noisy', None, "show every action (compile, link, run, ...) taken"),
+        (
+            'dump-source',
+            None,
+            "dump generated source files before attempting to compile them",
+        ),
+    ]
+
+    # The three standard command methods: since the "config" command
+    # does nothing by default, these are empty.
+
+    def initialize_options(self):
+        self.compiler = None
+        self.cc = None
+        self.include_dirs = None
+        self.libraries = None
+        self.library_dirs = None
+
+        # maximal output for now
+        self.noisy = 1
+        self.dump_source = 1
+
+        # list of temporary files generated along-the-way that we have
+        # to clean at some point
+        self.temp_files = []
+
+    def finalize_options(self):
+        if self.include_dirs is None:
+            self.include_dirs = self.distribution.include_dirs or []
+        elif isinstance(self.include_dirs, str):
+            self.include_dirs = self.include_dirs.split(os.pathsep)
+
+        if self.libraries is None:
+            self.libraries = []
+        elif isinstance(self.libraries, str):
+            self.libraries = [self.libraries]
+
+        if self.library_dirs is None:
+            self.library_dirs = []
+        elif isinstance(self.library_dirs, str):
+            self.library_dirs = self.library_dirs.split(os.pathsep)
+
+    def run(self):
+        pass
+
+    # Utility methods for actual "config" commands.  The interfaces are
+    # loosely based on Autoconf macros of similar names.  Sub-classes
+    # may use these freely.
+
+    def _check_compiler(self):
+        """Check that 'self.compiler' really is a CCompiler object;
+        if not, make it one.
+        """
+        if not isinstance(self.compiler, CCompiler):
+            self.compiler = new_compiler(
+                compiler=self.compiler, dry_run=self.dry_run, force=True
+            )
+            customize_compiler(self.compiler)
+            if self.include_dirs:
+                self.compiler.set_include_dirs(self.include_dirs)
+            if self.libraries:
+                self.compiler.set_libraries(self.libraries)
+            if self.library_dirs:
+                self.compiler.set_library_dirs(self.library_dirs)
+
+    def _gen_temp_sourcefile(self, body, headers, lang):
+        filename = "_configtest" + LANG_EXT[lang]
+        with open(filename, "w", encoding='utf-8') as file:
+            if headers:
+                for header in headers:
+                    file.write(f"#include <{header}>\n")
+                file.write("\n")
+            file.write(body)
+            if body[-1] != "\n":
+                file.write("\n")
+        return filename
+
+    def _preprocess(self, body, headers, include_dirs, lang):
+        src = self._gen_temp_sourcefile(body, headers, lang)
+        out = "_configtest.i"
+        self.temp_files.extend([src, out])
+        self.compiler.preprocess(src, out, include_dirs=include_dirs)
+        return (src, out)
+
+    def _compile(self, body, headers, include_dirs, lang):
+        src = self._gen_temp_sourcefile(body, headers, lang)
+        if self.dump_source:
+            dump_file(src, f"compiling '{src}':")
+        (obj,) = self.compiler.object_filenames([src])
+        self.temp_files.extend([src, obj])
+        self.compiler.compile([src], include_dirs=include_dirs)
+        return (src, obj)
+
+    def _link(self, body, headers, include_dirs, libraries, library_dirs, lang):
+        (src, obj) = self._compile(body, headers, include_dirs, lang)
+        prog = os.path.splitext(os.path.basename(src))[0]
+        self.compiler.link_executable(
+            [obj],
+            prog,
+            libraries=libraries,
+            library_dirs=library_dirs,
+            target_lang=lang,
+        )
+
+        if self.compiler.exe_extension is not None:
+            prog = prog + self.compiler.exe_extension
+        self.temp_files.append(prog)
+
+        return (src, obj, prog)
+
+    def _clean(self, *filenames):
+        if not filenames:
+            filenames = self.temp_files
+            self.temp_files = []
+        log.info("removing: %s", ' '.join(filenames))
+        for filename in filenames:
+            try:
+                os.remove(filename)
+            except OSError:
+                pass
+
+    # XXX these ignore the dry-run flag: what to do, what to do? even if
+    # you want a dry-run build, you still need some sort of configuration
+    # info.  My inclination is to make it up to the real config command to
+    # consult 'dry_run', and assume a default (minimal) configuration if
+    # true.  The problem with trying to do it here is that you'd have to
+    # return either true or false from all the 'try' methods, neither of
+    # which is correct.
+
+    # XXX need access to the header search path and maybe default macros.
+
+    def try_cpp(self, body=None, headers=None, include_dirs=None, lang="c"):
+        """Construct a source file from 'body' (a string containing lines
+        of C/C++ code) and 'headers' (a list of header files to include)
+        and run it through the preprocessor.  Return true if the
+        preprocessor succeeded, false if there were any errors.
+        ('body' probably isn't of much use, but what the heck.)
+        """
+        self._check_compiler()
+        ok = True
+        try:
+            self._preprocess(body, headers, include_dirs, lang)
+        except CompileError:
+            ok = False
+
+        self._clean()
+        return ok
+
+    def search_cpp(self, pattern, body=None, headers=None, include_dirs=None, lang="c"):
+        """Construct a source file (just like 'try_cpp()'), run it through
+        the preprocessor, and return true if any line of the output matches
+        'pattern'.  'pattern' should either be a compiled regex object or a
+        string containing a regex.  If both 'body' and 'headers' are None,
+        preprocesses an empty file -- which can be useful to determine the
+        symbols the preprocessor and compiler set by default.
+        """
+        self._check_compiler()
+        src, out = self._preprocess(body, headers, include_dirs, lang)
+
+        if isinstance(pattern, str):
+            pattern = re.compile(pattern)
+
+        with open(out, encoding='utf-8') as file:
+            match = any(pattern.search(line) for line in file)
+
+        self._clean()
+        return match
+
+    def try_compile(self, body, headers=None, include_dirs=None, lang="c"):
+        """Try to compile a source file built from 'body' and 'headers'.
+        Return true on success, false otherwise.
+        """
+        self._check_compiler()
+        try:
+            self._compile(body, headers, include_dirs, lang)
+            ok = True
+        except CompileError:
+            ok = False
+
+        log.info(ok and "success!" or "failure.")
+        self._clean()
+        return ok
+
+    def try_link(
+        self,
+        body,
+        headers=None,
+        include_dirs=None,
+        libraries=None,
+        library_dirs=None,
+        lang="c",
+    ):
+        """Try to compile and link a source file, built from 'body' and
+        'headers', to executable form.  Return true on success, false
+        otherwise.
+        """
+        self._check_compiler()
+        try:
+            self._link(body, headers, include_dirs, libraries, library_dirs, lang)
+            ok = True
+        except (CompileError, LinkError):
+            ok = False
+
+        log.info(ok and "success!" or "failure.")
+        self._clean()
+        return ok
+
+    def try_run(
+        self,
+        body,
+        headers=None,
+        include_dirs=None,
+        libraries=None,
+        library_dirs=None,
+        lang="c",
+    ):
+        """Try to compile, link to an executable, and run a program
+        built from 'body' and 'headers'.  Return true on success, false
+        otherwise.
+        """
+        self._check_compiler()
+        try:
+            src, obj, exe = self._link(
+                body, headers, include_dirs, libraries, library_dirs, lang
+            )
+            self.spawn([exe])
+            ok = True
+        except (CompileError, LinkError, DistutilsExecError):
+            ok = False
+
+        log.info(ok and "success!" or "failure.")
+        self._clean()
+        return ok
+
+    # -- High-level methods --------------------------------------------
+    # (these are the ones that are actually likely to be useful
+    # when implementing a real-world config command!)
+
+    def check_func(
+        self,
+        func,
+        headers=None,
+        include_dirs=None,
+        libraries=None,
+        library_dirs=None,
+        decl=False,
+        call=False,
+    ):
+        """Determine if function 'func' is available by constructing a
+        source file that refers to 'func', and compiles and links it.
+        If everything succeeds, returns true; otherwise returns false.
+
+        The constructed source file starts out by including the header
+        files listed in 'headers'.  If 'decl' is true, it then declares
+        'func' (as "int func()"); you probably shouldn't supply 'headers'
+        and set 'decl' true in the same call, or you might get errors about
+        a conflicting declarations for 'func'.  Finally, the constructed
+        'main()' function either references 'func' or (if 'call' is true)
+        calls it.  'libraries' and 'library_dirs' are used when
+        linking.
+        """
+        self._check_compiler()
+        body = []
+        if decl:
+            body.append(f"int {func} ();")
+        body.append("int main () {")
+        if call:
+            body.append(f"  {func}();")
+        else:
+            body.append(f"  {func};")
+        body.append("}")
+        body = "\n".join(body) + "\n"
+
+        return self.try_link(body, headers, include_dirs, libraries, library_dirs)
+
+    def check_lib(
+        self,
+        library,
+        library_dirs=None,
+        headers=None,
+        include_dirs=None,
+        other_libraries: Sequence[str] = [],
+    ):
+        """Determine if 'library' is available to be linked against,
+        without actually checking that any particular symbols are provided
+        by it.  'headers' will be used in constructing the source file to
+        be compiled, but the only effect of this is to check if all the
+        header files listed are available.  Any libraries listed in
+        'other_libraries' will be included in the link, in case 'library'
+        has symbols that depend on other libraries.
+        """
+        self._check_compiler()
+        return self.try_link(
+            "int main (void) { }",
+            headers,
+            include_dirs,
+            [library] + list(other_libraries),
+            library_dirs,
+        )
+
+    def check_header(self, header, include_dirs=None, library_dirs=None, lang="c"):
+        """Determine if the system header file named by 'header_file'
+        exists and can be found by the preprocessor; return true if so,
+        false otherwise.
+        """
+        return self.try_cpp(
+            body="/* No body */", headers=[header], include_dirs=include_dirs
+        )
+
+
+def dump_file(filename, head=None):
+    """Dumps a file content into log.info.
+
+    If head is not None, will be dumped before the file content.
+    """
+    if head is None:
+        log.info('%s', filename)
+    else:
+        log.info(head)
+    log.info(pathlib.Path(filename).read_text(encoding='utf-8'))
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/command/install.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/command/install.py
new file mode 100644
index 0000000000000000000000000000000000000000..dc17e56a8070b26f0e3d09c82250e006f1aed826
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/command/install.py
@@ -0,0 +1,805 @@
+"""distutils.command.install
+
+Implements the Distutils 'install' command."""
+
+from __future__ import annotations
+
+import collections
+import contextlib
+import itertools
+import os
+import sys
+import sysconfig
+from distutils._log import log
+from site import USER_BASE, USER_SITE
+from typing import ClassVar
+
+from ..core import Command
+from ..debug import DEBUG
+from ..errors import DistutilsOptionError, DistutilsPlatformError
+from ..file_util import write_file
+from ..sysconfig import get_config_vars
+from ..util import change_root, convert_path, get_platform, subst_vars
+from . import _framework_compat as fw
+
+HAS_USER_SITE = True
+
+WINDOWS_SCHEME = {
+    'purelib': '{base}/Lib/site-packages',
+    'platlib': '{base}/Lib/site-packages',
+    'headers': '{base}/Include/{dist_name}',
+    'scripts': '{base}/Scripts',
+    'data': '{base}',
+}
+
+INSTALL_SCHEMES = {
+    'posix_prefix': {
+        'purelib': '{base}/lib/{implementation_lower}{py_version_short}/site-packages',
+        'platlib': '{platbase}/{platlibdir}/{implementation_lower}'
+        '{py_version_short}/site-packages',
+        'headers': '{base}/include/{implementation_lower}'
+        '{py_version_short}{abiflags}/{dist_name}',
+        'scripts': '{base}/bin',
+        'data': '{base}',
+    },
+    'posix_home': {
+        'purelib': '{base}/lib/{implementation_lower}',
+        'platlib': '{base}/{platlibdir}/{implementation_lower}',
+        'headers': '{base}/include/{implementation_lower}/{dist_name}',
+        'scripts': '{base}/bin',
+        'data': '{base}',
+    },
+    'nt': WINDOWS_SCHEME,
+    'pypy': {
+        'purelib': '{base}/site-packages',
+        'platlib': '{base}/site-packages',
+        'headers': '{base}/include/{dist_name}',
+        'scripts': '{base}/bin',
+        'data': '{base}',
+    },
+    'pypy_nt': {
+        'purelib': '{base}/site-packages',
+        'platlib': '{base}/site-packages',
+        'headers': '{base}/include/{dist_name}',
+        'scripts': '{base}/Scripts',
+        'data': '{base}',
+    },
+}
+
+# user site schemes
+if HAS_USER_SITE:
+    INSTALL_SCHEMES['nt_user'] = {
+        'purelib': '{usersite}',
+        'platlib': '{usersite}',
+        'headers': '{userbase}/{implementation}{py_version_nodot_plat}'
+        '/Include/{dist_name}',
+        'scripts': '{userbase}/{implementation}{py_version_nodot_plat}/Scripts',
+        'data': '{userbase}',
+    }
+
+    INSTALL_SCHEMES['posix_user'] = {
+        'purelib': '{usersite}',
+        'platlib': '{usersite}',
+        'headers': '{userbase}/include/{implementation_lower}'
+        '{py_version_short}{abiflags}/{dist_name}',
+        'scripts': '{userbase}/bin',
+        'data': '{userbase}',
+    }
+
+
+INSTALL_SCHEMES.update(fw.schemes)
+
+
+# The keys to an installation scheme; if any new types of files are to be
+# installed, be sure to add an entry to every installation scheme above,
+# and to SCHEME_KEYS here.
+SCHEME_KEYS = ('purelib', 'platlib', 'headers', 'scripts', 'data')
+
+
+def _load_sysconfig_schemes():
+    with contextlib.suppress(AttributeError):
+        return {
+            scheme: sysconfig.get_paths(scheme, expand=False)
+            for scheme in sysconfig.get_scheme_names()
+        }
+
+
+def _load_schemes():
+    """
+    Extend default schemes with schemes from sysconfig.
+    """
+
+    sysconfig_schemes = _load_sysconfig_schemes() or {}
+
+    return {
+        scheme: {
+            **INSTALL_SCHEMES.get(scheme, {}),
+            **sysconfig_schemes.get(scheme, {}),
+        }
+        for scheme in set(itertools.chain(INSTALL_SCHEMES, sysconfig_schemes))
+    }
+
+
+def _get_implementation():
+    if hasattr(sys, 'pypy_version_info'):
+        return 'PyPy'
+    else:
+        return 'Python'
+
+
+def _select_scheme(ob, name):
+    scheme = _inject_headers(name, _load_scheme(_resolve_scheme(name)))
+    vars(ob).update(_remove_set(ob, _scheme_attrs(scheme)))
+
+
+def _remove_set(ob, attrs):
+    """
+    Include only attrs that are None in ob.
+    """
+    return {key: value for key, value in attrs.items() if getattr(ob, key) is None}
+
+
+def _resolve_scheme(name):
+    os_name, sep, key = name.partition('_')
+    try:
+        resolved = sysconfig.get_preferred_scheme(key)
+    except Exception:
+        resolved = fw.scheme(name)
+    return resolved
+
+
+def _load_scheme(name):
+    return _load_schemes()[name]
+
+
+def _inject_headers(name, scheme):
+    """
+    Given a scheme name and the resolved scheme,
+    if the scheme does not include headers, resolve
+    the fallback scheme for the name and use headers
+    from it. pypa/distutils#88
+    """
+    # Bypass the preferred scheme, which may not
+    # have defined headers.
+    fallback = _load_scheme(name)
+    scheme.setdefault('headers', fallback['headers'])
+    return scheme
+
+
+def _scheme_attrs(scheme):
+    """Resolve install directories by applying the install schemes."""
+    return {f'install_{key}': scheme[key] for key in SCHEME_KEYS}
+
+
+class install(Command):
+    description = "install everything from build directory"
+
+    user_options = [
+        # Select installation scheme and set base director(y|ies)
+        ('prefix=', None, "installation prefix"),
+        ('exec-prefix=', None, "(Unix only) prefix for platform-specific files"),
+        ('home=', None, "(Unix only) home directory to install under"),
+        # Or, just set the base director(y|ies)
+        (
+            'install-base=',
+            None,
+            "base installation directory (instead of --prefix or --home)",
+        ),
+        (
+            'install-platbase=',
+            None,
+            "base installation directory for platform-specific files (instead of --exec-prefix or --home)",
+        ),
+        ('root=', None, "install everything relative to this alternate root directory"),
+        # Or, explicitly set the installation scheme
+        (
+            'install-purelib=',
+            None,
+            "installation directory for pure Python module distributions",
+        ),
+        (
+            'install-platlib=',
+            None,
+            "installation directory for non-pure module distributions",
+        ),
+        (
+            'install-lib=',
+            None,
+            "installation directory for all module distributions (overrides --install-purelib and --install-platlib)",
+        ),
+        ('install-headers=', None, "installation directory for C/C++ headers"),
+        ('install-scripts=', None, "installation directory for Python scripts"),
+        ('install-data=', None, "installation directory for data files"),
+        # Byte-compilation options -- see install_lib.py for details, as
+        # these are duplicated from there (but only install_lib does
+        # anything with them).
+        ('compile', 'c', "compile .py to .pyc [default]"),
+        ('no-compile', None, "don't compile .py files"),
+        (
+            'optimize=',
+            'O',
+            "also compile with optimization: -O1 for \"python -O\", "
+            "-O2 for \"python -OO\", and -O0 to disable [default: -O0]",
+        ),
+        # Miscellaneous control options
+        ('force', 'f', "force installation (overwrite any existing files)"),
+        ('skip-build', None, "skip rebuilding everything (for testing/debugging)"),
+        # Where to install documentation (eventually!)
+        # ('doc-format=', None, "format of documentation to generate"),
+        # ('install-man=', None, "directory for Unix man pages"),
+        # ('install-html=', None, "directory for HTML documentation"),
+        # ('install-info=', None, "directory for GNU info files"),
+        ('record=', None, "filename in which to record list of installed files"),
+    ]
+
+    boolean_options: ClassVar[list[str]] = ['compile', 'force', 'skip-build']
+
+    if HAS_USER_SITE:
+        user_options.append((
+            'user',
+            None,
+            f"install in user site-package '{USER_SITE}'",
+        ))
+        boolean_options.append('user')
+
+    negative_opt: ClassVar[dict[str, str]] = {'no-compile': 'compile'}
+
+    def initialize_options(self) -> None:
+        """Initializes options."""
+        # High-level options: these select both an installation base
+        # and scheme.
+        self.prefix: str | None = None
+        self.exec_prefix: str | None = None
+        self.home: str | None = None
+        self.user = False
+
+        # These select only the installation base; it's up to the user to
+        # specify the installation scheme (currently, that means supplying
+        # the --install-{platlib,purelib,scripts,data} options).
+        self.install_base = None
+        self.install_platbase = None
+        self.root: str | None = None
+
+        # These options are the actual installation directories; if not
+        # supplied by the user, they are filled in using the installation
+        # scheme implied by prefix/exec-prefix/home and the contents of
+        # that installation scheme.
+        self.install_purelib = None  # for pure module distributions
+        self.install_platlib = None  # non-pure (dists w/ extensions)
+        self.install_headers = None  # for C/C++ headers
+        self.install_lib: str | None = None  # set to either purelib or platlib
+        self.install_scripts = None
+        self.install_data = None
+        self.install_userbase = USER_BASE
+        self.install_usersite = USER_SITE
+
+        self.compile = None
+        self.optimize = None
+
+        # Deprecated
+        # These two are for putting non-packagized distributions into their
+        # own directory and creating a .pth file if it makes sense.
+        # 'extra_path' comes from the setup file; 'install_path_file' can
+        # be turned off if it makes no sense to install a .pth file.  (But
+        # better to install it uselessly than to guess wrong and not
+        # install it when it's necessary and would be used!)  Currently,
+        # 'install_path_file' is always true unless some outsider meddles
+        # with it.
+        self.extra_path = None
+        self.install_path_file = True
+
+        # 'force' forces installation, even if target files are not
+        # out-of-date.  'skip_build' skips running the "build" command,
+        # handy if you know it's not necessary.  'warn_dir' (which is *not*
+        # a user option, it's just there so the bdist_* commands can turn
+        # it off) determines whether we warn about installing to a
+        # directory not in sys.path.
+        self.force = False
+        self.skip_build = False
+        self.warn_dir = True
+
+        # These are only here as a conduit from the 'build' command to the
+        # 'install_*' commands that do the real work.  ('build_base' isn't
+        # actually used anywhere, but it might be useful in future.)  They
+        # are not user options, because if the user told the install
+        # command where the build directory is, that wouldn't affect the
+        # build command.
+        self.build_base = None
+        self.build_lib = None
+
+        # Not defined yet because we don't know anything about
+        # documentation yet.
+        # self.install_man = None
+        # self.install_html = None
+        # self.install_info = None
+
+        self.record = None
+
+    # -- Option finalizing methods -------------------------------------
+    # (This is rather more involved than for most commands,
+    # because this is where the policy for installing third-
+    # party Python modules on various platforms given a wide
+    # array of user input is decided.  Yes, it's quite complex!)
+
+    def finalize_options(self) -> None:  # noqa: C901
+        """Finalizes options."""
+        # This method (and its helpers, like 'finalize_unix()',
+        # 'finalize_other()', and 'select_scheme()') is where the default
+        # installation directories for modules, extension modules, and
+        # anything else we care to install from a Python module
+        # distribution.  Thus, this code makes a pretty important policy
+        # statement about how third-party stuff is added to a Python
+        # installation!  Note that the actual work of installation is done
+        # by the relatively simple 'install_*' commands; they just take
+        # their orders from the installation directory options determined
+        # here.
+
+        # Check for errors/inconsistencies in the options; first, stuff
+        # that's wrong on any platform.
+
+        if (self.prefix or self.exec_prefix or self.home) and (
+            self.install_base or self.install_platbase
+        ):
+            raise DistutilsOptionError(
+                "must supply either prefix/exec-prefix/home or install-base/install-platbase -- not both"
+            )
+
+        if self.home and (self.prefix or self.exec_prefix):
+            raise DistutilsOptionError(
+                "must supply either home or prefix/exec-prefix -- not both"
+            )
+
+        if self.user and (
+            self.prefix
+            or self.exec_prefix
+            or self.home
+            or self.install_base
+            or self.install_platbase
+        ):
+            raise DistutilsOptionError(
+                "can't combine user with prefix, "
+                "exec_prefix/home, or install_(plat)base"
+            )
+
+        # Next, stuff that's wrong (or dubious) only on certain platforms.
+        if os.name != "posix":
+            if self.exec_prefix:
+                self.warn("exec-prefix option ignored on this platform")
+                self.exec_prefix = None
+
+        # Now the interesting logic -- so interesting that we farm it out
+        # to other methods.  The goal of these methods is to set the final
+        # values for the install_{lib,scripts,data,...}  options, using as
+        # input a heady brew of prefix, exec_prefix, home, install_base,
+        # install_platbase, user-supplied versions of
+        # install_{purelib,platlib,lib,scripts,data,...}, and the
+        # install schemes.  Phew!
+
+        self.dump_dirs("pre-finalize_{unix,other}")
+
+        if os.name == 'posix':
+            self.finalize_unix()
+        else:
+            self.finalize_other()
+
+        self.dump_dirs("post-finalize_{unix,other}()")
+
+        # Expand configuration variables, tilde, etc. in self.install_base
+        # and self.install_platbase -- that way, we can use $base or
+        # $platbase in the other installation directories and not worry
+        # about needing recursive variable expansion (shudder).
+
+        py_version = sys.version.split()[0]
+        (prefix, exec_prefix) = get_config_vars('prefix', 'exec_prefix')
+        try:
+            abiflags = sys.abiflags
+        except AttributeError:
+            # sys.abiflags may not be defined on all platforms.
+            abiflags = ''
+        local_vars = {
+            'dist_name': self.distribution.get_name(),
+            'dist_version': self.distribution.get_version(),
+            'dist_fullname': self.distribution.get_fullname(),
+            'py_version': py_version,
+            'py_version_short': f'{sys.version_info.major}.{sys.version_info.minor}',
+            'py_version_nodot': f'{sys.version_info.major}{sys.version_info.minor}',
+            'sys_prefix': prefix,
+            'prefix': prefix,
+            'sys_exec_prefix': exec_prefix,
+            'exec_prefix': exec_prefix,
+            'abiflags': abiflags,
+            'platlibdir': getattr(sys, 'platlibdir', 'lib'),
+            'implementation_lower': _get_implementation().lower(),
+            'implementation': _get_implementation(),
+        }
+
+        # vars for compatibility on older Pythons
+        compat_vars = dict(
+            # Python 3.9 and earlier
+            py_version_nodot_plat=getattr(sys, 'winver', '').replace('.', ''),
+        )
+
+        if HAS_USER_SITE:
+            local_vars['userbase'] = self.install_userbase
+            local_vars['usersite'] = self.install_usersite
+
+        self.config_vars = collections.ChainMap(
+            local_vars,
+            sysconfig.get_config_vars(),
+            compat_vars,
+            fw.vars(),
+        )
+
+        self.expand_basedirs()
+
+        self.dump_dirs("post-expand_basedirs()")
+
+        # Now define config vars for the base directories so we can expand
+        # everything else.
+        local_vars['base'] = self.install_base
+        local_vars['platbase'] = self.install_platbase
+
+        if DEBUG:
+            from pprint import pprint
+
+            print("config vars:")
+            pprint(dict(self.config_vars))
+
+        # Expand "~" and configuration variables in the installation
+        # directories.
+        self.expand_dirs()
+
+        self.dump_dirs("post-expand_dirs()")
+
+        # Create directories in the home dir:
+        if self.user:
+            self.create_home_path()
+
+        # Pick the actual directory to install all modules to: either
+        # install_purelib or install_platlib, depending on whether this
+        # module distribution is pure or not.  Of course, if the user
+        # already specified install_lib, use their selection.
+        if self.install_lib is None:
+            if self.distribution.has_ext_modules():  # has extensions: non-pure
+                self.install_lib = self.install_platlib
+            else:
+                self.install_lib = self.install_purelib
+
+        # Convert directories from Unix /-separated syntax to the local
+        # convention.
+        self.convert_paths(
+            'lib',
+            'purelib',
+            'platlib',
+            'scripts',
+            'data',
+            'headers',
+            'userbase',
+            'usersite',
+        )
+
+        # Deprecated
+        # Well, we're not actually fully completely finalized yet: we still
+        # have to deal with 'extra_path', which is the hack for allowing
+        # non-packagized module distributions (hello, Numerical Python!) to
+        # get their own directories.
+        self.handle_extra_path()
+        self.install_libbase = self.install_lib  # needed for .pth file
+        self.install_lib = os.path.join(self.install_lib, self.extra_dirs)
+
+        # If a new root directory was supplied, make all the installation
+        # dirs relative to it.
+        if self.root is not None:
+            self.change_roots(
+                'libbase', 'lib', 'purelib', 'platlib', 'scripts', 'data', 'headers'
+            )
+
+        self.dump_dirs("after prepending root")
+
+        # Find out the build directories, ie. where to install from.
+        self.set_undefined_options(
+            'build', ('build_base', 'build_base'), ('build_lib', 'build_lib')
+        )
+
+        # Punt on doc directories for now -- after all, we're punting on
+        # documentation completely!
+
+    def dump_dirs(self, msg) -> None:
+        """Dumps the list of user options."""
+        if not DEBUG:
+            return
+        from ..fancy_getopt import longopt_xlate
+
+        log.debug(msg + ":")
+        for opt in self.user_options:
+            opt_name = opt[0]
+            if opt_name[-1] == "=":
+                opt_name = opt_name[0:-1]
+            if opt_name in self.negative_opt:
+                opt_name = self.negative_opt[opt_name]
+                opt_name = opt_name.translate(longopt_xlate)
+                val = not getattr(self, opt_name)
+            else:
+                opt_name = opt_name.translate(longopt_xlate)
+                val = getattr(self, opt_name)
+            log.debug("  %s: %s", opt_name, val)
+
+    def finalize_unix(self) -> None:
+        """Finalizes options for posix platforms."""
+        if self.install_base is not None or self.install_platbase is not None:
+            incomplete_scheme = (
+                (
+                    self.install_lib is None
+                    and self.install_purelib is None
+                    and self.install_platlib is None
+                )
+                or self.install_headers is None
+                or self.install_scripts is None
+                or self.install_data is None
+            )
+            if incomplete_scheme:
+                raise DistutilsOptionError(
+                    "install-base or install-platbase supplied, but "
+                    "installation scheme is incomplete"
+                )
+            return
+
+        if self.user:
+            if self.install_userbase is None:
+                raise DistutilsPlatformError("User base directory is not specified")
+            self.install_base = self.install_platbase = self.install_userbase
+            self.select_scheme("posix_user")
+        elif self.home is not None:
+            self.install_base = self.install_platbase = self.home
+            self.select_scheme("posix_home")
+        else:
+            if self.prefix is None:
+                if self.exec_prefix is not None:
+                    raise DistutilsOptionError(
+                        "must not supply exec-prefix without prefix"
+                    )
+
+                # Allow Fedora to add components to the prefix
+                _prefix_addition = getattr(sysconfig, '_prefix_addition', "")
+
+                self.prefix = os.path.normpath(sys.prefix) + _prefix_addition
+                self.exec_prefix = os.path.normpath(sys.exec_prefix) + _prefix_addition
+
+            else:
+                if self.exec_prefix is None:
+                    self.exec_prefix = self.prefix
+
+            self.install_base = self.prefix
+            self.install_platbase = self.exec_prefix
+            self.select_scheme("posix_prefix")
+
+    def finalize_other(self) -> None:
+        """Finalizes options for non-posix platforms"""
+        if self.user:
+            if self.install_userbase is None:
+                raise DistutilsPlatformError("User base directory is not specified")
+            self.install_base = self.install_platbase = self.install_userbase
+            self.select_scheme(os.name + "_user")
+        elif self.home is not None:
+            self.install_base = self.install_platbase = self.home
+            self.select_scheme("posix_home")
+        else:
+            if self.prefix is None:
+                self.prefix = os.path.normpath(sys.prefix)
+
+            self.install_base = self.install_platbase = self.prefix
+            try:
+                self.select_scheme(os.name)
+            except KeyError:
+                raise DistutilsPlatformError(
+                    f"I don't know how to install stuff on '{os.name}'"
+                )
+
+    def select_scheme(self, name) -> None:
+        _select_scheme(self, name)
+
+    def _expand_attrs(self, attrs):
+        for attr in attrs:
+            val = getattr(self, attr)
+            if val is not None:
+                if os.name in ('posix', 'nt'):
+                    val = os.path.expanduser(val)
+                val = subst_vars(val, self.config_vars)
+                setattr(self, attr, val)
+
+    def expand_basedirs(self) -> None:
+        """Calls `os.path.expanduser` on install_base, install_platbase and
+        root."""
+        self._expand_attrs(['install_base', 'install_platbase', 'root'])
+
+    def expand_dirs(self) -> None:
+        """Calls `os.path.expanduser` on install dirs."""
+        self._expand_attrs([
+            'install_purelib',
+            'install_platlib',
+            'install_lib',
+            'install_headers',
+            'install_scripts',
+            'install_data',
+        ])
+
+    def convert_paths(self, *names) -> None:
+        """Call `convert_path` over `names`."""
+        for name in names:
+            attr = "install_" + name
+            setattr(self, attr, convert_path(getattr(self, attr)))
+
+    def handle_extra_path(self) -> None:
+        """Set `path_file` and `extra_dirs` using `extra_path`."""
+        if self.extra_path is None:
+            self.extra_path = self.distribution.extra_path
+
+        if self.extra_path is not None:
+            log.warning(
+                "Distribution option extra_path is deprecated. "
+                "See issue27919 for details."
+            )
+            if isinstance(self.extra_path, str):
+                self.extra_path = self.extra_path.split(',')
+
+            if len(self.extra_path) == 1:
+                path_file = extra_dirs = self.extra_path[0]
+            elif len(self.extra_path) == 2:
+                path_file, extra_dirs = self.extra_path
+            else:
+                raise DistutilsOptionError(
+                    "'extra_path' option must be a list, tuple, or "
+                    "comma-separated string with 1 or 2 elements"
+                )
+
+            # convert to local form in case Unix notation used (as it
+            # should be in setup scripts)
+            extra_dirs = convert_path(extra_dirs)
+        else:
+            path_file = None
+            extra_dirs = ''
+
+        # XXX should we warn if path_file and not extra_dirs? (in which
+        # case the path file would be harmless but pointless)
+        self.path_file = path_file
+        self.extra_dirs = extra_dirs
+
+    def change_roots(self, *names) -> None:
+        """Change the install directories pointed by name using root."""
+        for name in names:
+            attr = "install_" + name
+            setattr(self, attr, change_root(self.root, getattr(self, attr)))
+
+    def create_home_path(self) -> None:
+        """Create directories under ~."""
+        if not self.user:
+            return
+        home = convert_path(os.path.expanduser("~"))
+        for path in self.config_vars.values():
+            if str(path).startswith(home) and not os.path.isdir(path):
+                self.debug_print(f"os.makedirs('{path}', 0o700)")
+                os.makedirs(path, 0o700)
+
+    # -- Command execution methods -------------------------------------
+
+    def run(self):
+        """Runs the command."""
+        # Obviously have to build before we can install
+        if not self.skip_build:
+            self.run_command('build')
+            # If we built for any other platform, we can't install.
+            build_plat = self.distribution.get_command_obj('build').plat_name
+            # check warn_dir - it is a clue that the 'install' is happening
+            # internally, and not to sys.path, so we don't check the platform
+            # matches what we are running.
+            if self.warn_dir and build_plat != get_platform():
+                raise DistutilsPlatformError("Can't install when cross-compiling")
+
+        # Run all sub-commands (at least those that need to be run)
+        for cmd_name in self.get_sub_commands():
+            self.run_command(cmd_name)
+
+        if self.path_file:
+            self.create_path_file()
+
+        # write list of installed files, if requested.
+        if self.record:
+            outputs = self.get_outputs()
+            if self.root:  # strip any package prefix
+                root_len = len(self.root)
+                for counter in range(len(outputs)):
+                    outputs[counter] = outputs[counter][root_len:]
+            self.execute(
+                write_file,
+                (self.record, outputs),
+                f"writing list of installed files to '{self.record}'",
+            )
+
+        sys_path = map(os.path.normpath, sys.path)
+        sys_path = map(os.path.normcase, sys_path)
+        install_lib = os.path.normcase(os.path.normpath(self.install_lib))
+        if (
+            self.warn_dir
+            and not (self.path_file and self.install_path_file)
+            and install_lib not in sys_path
+        ):
+            log.debug(
+                (
+                    "modules installed to '%s', which is not in "
+                    "Python's module search path (sys.path) -- "
+                    "you'll have to change the search path yourself"
+                ),
+                self.install_lib,
+            )
+
+    def create_path_file(self):
+        """Creates the .pth file"""
+        filename = os.path.join(self.install_libbase, self.path_file + ".pth")
+        if self.install_path_file:
+            self.execute(
+                write_file, (filename, [self.extra_dirs]), f"creating {filename}"
+            )
+        else:
+            self.warn(f"path file '{filename}' not created")
+
+    # -- Reporting methods ---------------------------------------------
+
+    def get_outputs(self):
+        """Assembles the outputs of all the sub-commands."""
+        outputs = []
+        for cmd_name in self.get_sub_commands():
+            cmd = self.get_finalized_command(cmd_name)
+            # Add the contents of cmd.get_outputs(), ensuring
+            # that outputs doesn't contain duplicate entries
+            for filename in cmd.get_outputs():
+                if filename not in outputs:
+                    outputs.append(filename)
+
+        if self.path_file and self.install_path_file:
+            outputs.append(os.path.join(self.install_libbase, self.path_file + ".pth"))
+
+        return outputs
+
+    def get_inputs(self):
+        """Returns the inputs of all the sub-commands"""
+        # XXX gee, this looks familiar ;-(
+        inputs = []
+        for cmd_name in self.get_sub_commands():
+            cmd = self.get_finalized_command(cmd_name)
+            inputs.extend(cmd.get_inputs())
+
+        return inputs
+
+    # -- Predicates for sub-command list -------------------------------
+
+    def has_lib(self):
+        """Returns true if the current distribution has any Python
+        modules to install."""
+        return (
+            self.distribution.has_pure_modules() or self.distribution.has_ext_modules()
+        )
+
+    def has_headers(self):
+        """Returns true if the current distribution has any headers to
+        install."""
+        return self.distribution.has_headers()
+
+    def has_scripts(self):
+        """Returns true if the current distribution has any scripts to.
+        install."""
+        return self.distribution.has_scripts()
+
+    def has_data(self):
+        """Returns true if the current distribution has any data to.
+        install."""
+        return self.distribution.has_data_files()
+
+    # 'sub_commands': a list of commands this command might have to run to
+    # get its work done.  See cmd.py for more info.
+    sub_commands = [
+        ('install_lib', has_lib),
+        ('install_headers', has_headers),
+        ('install_scripts', has_scripts),
+        ('install_data', has_data),
+        ('install_egg_info', lambda self: True),
+    ]
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/command/install_data.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/command/install_data.py
new file mode 100644
index 0000000000000000000000000000000000000000..4ad186e8ec61b92967ea1c12cdca51d00e82dd15
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/command/install_data.py
@@ -0,0 +1,94 @@
+"""distutils.command.install_data
+
+Implements the Distutils 'install_data' command, for installing
+platform-independent data files."""
+
+# contributed by Bastian Kleineidam
+
+from __future__ import annotations
+
+import functools
+import os
+from collections.abc import Iterable
+from typing import ClassVar
+
+from ..core import Command
+from ..util import change_root, convert_path
+
+
+class install_data(Command):
+    description = "install data files"
+
+    user_options = [
+        (
+            'install-dir=',
+            'd',
+            "base directory for installing data files [default: installation base dir]",
+        ),
+        ('root=', None, "install everything relative to this alternate root directory"),
+        ('force', 'f', "force installation (overwrite existing files)"),
+    ]
+
+    boolean_options: ClassVar[list[str]] = ['force']
+
+    def initialize_options(self):
+        self.install_dir = None
+        self.outfiles = []
+        self.root = None
+        self.force = False
+        self.data_files = self.distribution.data_files
+        self.warn_dir = True
+
+    def finalize_options(self) -> None:
+        self.set_undefined_options(
+            'install',
+            ('install_data', 'install_dir'),
+            ('root', 'root'),
+            ('force', 'force'),
+        )
+
+    def run(self) -> None:
+        self.mkpath(self.install_dir)
+        for f in self.data_files:
+            self._copy(f)
+
+    @functools.singledispatchmethod
+    def _copy(self, f: tuple[str | os.PathLike, Iterable[str | os.PathLike]]):
+        # it's a tuple with path to install to and a list of files
+        dir = convert_path(f[0])
+        if not os.path.isabs(dir):
+            dir = os.path.join(self.install_dir, dir)
+        elif self.root:
+            dir = change_root(self.root, dir)
+        self.mkpath(dir)
+
+        if f[1] == []:
+            # If there are no files listed, the user must be
+            # trying to create an empty directory, so add the
+            # directory to the list of output files.
+            self.outfiles.append(dir)
+        else:
+            # Copy files, adding them to the list of output files.
+            for data in f[1]:
+                data = convert_path(data)
+                (out, _) = self.copy_file(data, dir)
+                self.outfiles.append(out)
+
+    @_copy.register(str)
+    @_copy.register(os.PathLike)
+    def _(self, f: str | os.PathLike):
+        # it's a simple file, so copy it
+        f = convert_path(f)
+        if self.warn_dir:
+            self.warn(
+                "setup script did not provide a directory for "
+                f"'{f}' -- installing right in '{self.install_dir}'"
+            )
+        (out, _) = self.copy_file(f, self.install_dir)
+        self.outfiles.append(out)
+
+    def get_inputs(self):
+        return self.data_files or []
+
+    def get_outputs(self):
+        return self.outfiles
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/command/install_egg_info.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/command/install_egg_info.py
new file mode 100644
index 0000000000000000000000000000000000000000..230e94ab46f0c87f58428b456e9d2fe98eca27a4
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/command/install_egg_info.py
@@ -0,0 +1,91 @@
+"""
+distutils.command.install_egg_info
+
+Implements the Distutils 'install_egg_info' command, for installing
+a package's PKG-INFO metadata.
+"""
+
+import os
+import re
+import sys
+from typing import ClassVar
+
+from .. import dir_util
+from .._log import log
+from ..cmd import Command
+
+
+class install_egg_info(Command):
+    """Install an .egg-info file for the package"""
+
+    description = "Install package's PKG-INFO metadata as an .egg-info file"
+    user_options: ClassVar[list[tuple[str, str, str]]] = [
+        ('install-dir=', 'd', "directory to install to"),
+    ]
+
+    def initialize_options(self):
+        self.install_dir = None
+
+    @property
+    def basename(self):
+        """
+        Allow basename to be overridden by child class.
+        Ref pypa/distutils#2.
+        """
+        name = to_filename(safe_name(self.distribution.get_name()))
+        version = to_filename(safe_version(self.distribution.get_version()))
+        return f"{name}-{version}-py{sys.version_info.major}.{sys.version_info.minor}.egg-info"
+
+    def finalize_options(self):
+        self.set_undefined_options('install_lib', ('install_dir', 'install_dir'))
+        self.target = os.path.join(self.install_dir, self.basename)
+        self.outputs = [self.target]
+
+    def run(self):
+        target = self.target
+        if os.path.isdir(target) and not os.path.islink(target):
+            dir_util.remove_tree(target, dry_run=self.dry_run)
+        elif os.path.exists(target):
+            self.execute(os.unlink, (self.target,), "Removing " + target)
+        elif not os.path.isdir(self.install_dir):
+            self.execute(
+                os.makedirs, (self.install_dir,), "Creating " + self.install_dir
+            )
+        log.info("Writing %s", target)
+        if not self.dry_run:
+            with open(target, 'w', encoding='UTF-8') as f:
+                self.distribution.metadata.write_pkg_file(f)
+
+    def get_outputs(self):
+        return self.outputs
+
+
+# The following routines are taken from setuptools' pkg_resources module and
+# can be replaced by importing them from pkg_resources once it is included
+# in the stdlib.
+
+
+def safe_name(name):
+    """Convert an arbitrary string to a standard distribution name
+
+    Any runs of non-alphanumeric/. characters are replaced with a single '-'.
+    """
+    return re.sub('[^A-Za-z0-9.]+', '-', name)
+
+
+def safe_version(version):
+    """Convert an arbitrary string to a standard version string
+
+    Spaces become dots, and all other non-alphanumeric characters become
+    dashes, with runs of multiple dashes condensed to a single dash.
+    """
+    version = version.replace(' ', '.')
+    return re.sub('[^A-Za-z0-9.]+', '-', version)
+
+
+def to_filename(name):
+    """Convert a project or version name to its filename-escaped form
+
+    Any '-' characters are currently replaced with '_'.
+    """
+    return name.replace('-', '_')
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/command/install_headers.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/command/install_headers.py
new file mode 100644
index 0000000000000000000000000000000000000000..97af1371efcc73423e9b91d7b3ced684ff936377
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/command/install_headers.py
@@ -0,0 +1,46 @@
+"""distutils.command.install_headers
+
+Implements the Distutils 'install_headers' command, to install C/C++ header
+files to the Python include directory."""
+
+from typing import ClassVar
+
+from ..core import Command
+
+
+# XXX force is never used
+class install_headers(Command):
+    description = "install C/C++ header files"
+
+    user_options: ClassVar[list[tuple[str, str, str]]] = [
+        ('install-dir=', 'd', "directory to install header files to"),
+        ('force', 'f', "force installation (overwrite existing files)"),
+    ]
+
+    boolean_options: ClassVar[list[str]] = ['force']
+
+    def initialize_options(self):
+        self.install_dir = None
+        self.force = False
+        self.outfiles = []
+
+    def finalize_options(self):
+        self.set_undefined_options(
+            'install', ('install_headers', 'install_dir'), ('force', 'force')
+        )
+
+    def run(self):
+        headers = self.distribution.headers
+        if not headers:
+            return
+
+        self.mkpath(self.install_dir)
+        for header in headers:
+            (out, _) = self.copy_file(header, self.install_dir)
+            self.outfiles.append(out)
+
+    def get_inputs(self):
+        return self.distribution.headers or []
+
+    def get_outputs(self):
+        return self.outfiles
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/command/install_lib.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/command/install_lib.py
new file mode 100644
index 0000000000000000000000000000000000000000..2aababf8004d4636f039dd0609457387a0346ca0
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/command/install_lib.py
@@ -0,0 +1,238 @@
+"""distutils.command.install_lib
+
+Implements the Distutils 'install_lib' command
+(install all Python modules)."""
+
+from __future__ import annotations
+
+import importlib.util
+import os
+import sys
+from typing import Any, ClassVar
+
+from ..core import Command
+from ..errors import DistutilsOptionError
+
+# Extension for Python source files.
+PYTHON_SOURCE_EXTENSION = ".py"
+
+
+class install_lib(Command):
+    description = "install all Python modules (extensions and pure Python)"
+
+    # The byte-compilation options are a tad confusing.  Here are the
+    # possible scenarios:
+    #   1) no compilation at all (--no-compile --no-optimize)
+    #   2) compile .pyc only (--compile --no-optimize; default)
+    #   3) compile .pyc and "opt-1" .pyc (--compile --optimize)
+    #   4) compile "opt-1" .pyc only (--no-compile --optimize)
+    #   5) compile .pyc and "opt-2" .pyc (--compile --optimize-more)
+    #   6) compile "opt-2" .pyc only (--no-compile --optimize-more)
+    #
+    # The UI for this is two options, 'compile' and 'optimize'.
+    # 'compile' is strictly boolean, and only decides whether to
+    # generate .pyc files.  'optimize' is three-way (0, 1, or 2), and
+    # decides both whether to generate .pyc files and what level of
+    # optimization to use.
+
+    user_options = [
+        ('install-dir=', 'd', "directory to install to"),
+        ('build-dir=', 'b', "build directory (where to install from)"),
+        ('force', 'f', "force installation (overwrite existing files)"),
+        ('compile', 'c', "compile .py to .pyc [default]"),
+        ('no-compile', None, "don't compile .py files"),
+        (
+            'optimize=',
+            'O',
+            "also compile with optimization: -O1 for \"python -O\", "
+            "-O2 for \"python -OO\", and -O0 to disable [default: -O0]",
+        ),
+        ('skip-build', None, "skip the build steps"),
+    ]
+
+    boolean_options: ClassVar[list[str]] = ['force', 'compile', 'skip-build']
+    negative_opt: ClassVar[dict[str, str]] = {'no-compile': 'compile'}
+
+    def initialize_options(self):
+        # let the 'install' command dictate our installation directory
+        self.install_dir = None
+        self.build_dir = None
+        self.force = False
+        self.compile = None
+        self.optimize = None
+        self.skip_build = None
+
+    def finalize_options(self) -> None:
+        # Get all the information we need to install pure Python modules
+        # from the umbrella 'install' command -- build (source) directory,
+        # install (target) directory, and whether to compile .py files.
+        self.set_undefined_options(
+            'install',
+            ('build_lib', 'build_dir'),
+            ('install_lib', 'install_dir'),
+            ('force', 'force'),
+            ('compile', 'compile'),
+            ('optimize', 'optimize'),
+            ('skip_build', 'skip_build'),
+        )
+
+        if self.compile is None:
+            self.compile = True
+        if self.optimize is None:
+            self.optimize = False
+
+        if not isinstance(self.optimize, int):
+            try:
+                self.optimize = int(self.optimize)
+            except ValueError:
+                pass
+            if self.optimize not in (0, 1, 2):
+                raise DistutilsOptionError("optimize must be 0, 1, or 2")
+
+    def run(self) -> None:
+        # Make sure we have built everything we need first
+        self.build()
+
+        # Install everything: simply dump the entire contents of the build
+        # directory to the installation directory (that's the beauty of
+        # having a build directory!)
+        outfiles = self.install()
+
+        # (Optionally) compile .py to .pyc
+        if outfiles is not None and self.distribution.has_pure_modules():
+            self.byte_compile(outfiles)
+
+    # -- Top-level worker functions ------------------------------------
+    # (called from 'run()')
+
+    def build(self) -> None:
+        if not self.skip_build:
+            if self.distribution.has_pure_modules():
+                self.run_command('build_py')
+            if self.distribution.has_ext_modules():
+                self.run_command('build_ext')
+
+    # Any: https://typing.readthedocs.io/en/latest/guides/writing_stubs.html#the-any-trick
+    def install(self) -> list[str] | Any:
+        if os.path.isdir(self.build_dir):
+            outfiles = self.copy_tree(self.build_dir, self.install_dir)
+        else:
+            self.warn(
+                f"'{self.build_dir}' does not exist -- no Python modules to install"
+            )
+            return
+        return outfiles
+
+    def byte_compile(self, files) -> None:
+        if sys.dont_write_bytecode:
+            self.warn('byte-compiling is disabled, skipping.')
+            return
+
+        from ..util import byte_compile
+
+        # Get the "--root" directory supplied to the "install" command,
+        # and use it as a prefix to strip off the purported filename
+        # encoded in bytecode files.  This is far from complete, but it
+        # should at least generate usable bytecode in RPM distributions.
+        install_root = self.get_finalized_command('install').root
+
+        if self.compile:
+            byte_compile(
+                files,
+                optimize=0,
+                force=self.force,
+                prefix=install_root,
+                dry_run=self.dry_run,
+            )
+        if self.optimize > 0:
+            byte_compile(
+                files,
+                optimize=self.optimize,
+                force=self.force,
+                prefix=install_root,
+                verbose=self.verbose,
+                dry_run=self.dry_run,
+            )
+
+    # -- Utility methods -----------------------------------------------
+
+    def _mutate_outputs(self, has_any, build_cmd, cmd_option, output_dir):
+        if not has_any:
+            return []
+
+        build_cmd = self.get_finalized_command(build_cmd)
+        build_files = build_cmd.get_outputs()
+        build_dir = getattr(build_cmd, cmd_option)
+
+        prefix_len = len(build_dir) + len(os.sep)
+        outputs = [os.path.join(output_dir, file[prefix_len:]) for file in build_files]
+
+        return outputs
+
+    def _bytecode_filenames(self, py_filenames):
+        bytecode_files = []
+        for py_file in py_filenames:
+            # Since build_py handles package data installation, the
+            # list of outputs can contain more than just .py files.
+            # Make sure we only report bytecode for the .py files.
+            ext = os.path.splitext(os.path.normcase(py_file))[1]
+            if ext != PYTHON_SOURCE_EXTENSION:
+                continue
+            if self.compile:
+                bytecode_files.append(
+                    importlib.util.cache_from_source(py_file, optimization='')
+                )
+            if self.optimize > 0:
+                bytecode_files.append(
+                    importlib.util.cache_from_source(
+                        py_file, optimization=self.optimize
+                    )
+                )
+
+        return bytecode_files
+
+    # -- External interface --------------------------------------------
+    # (called by outsiders)
+
+    def get_outputs(self):
+        """Return the list of files that would be installed if this command
+        were actually run.  Not affected by the "dry-run" flag or whether
+        modules have actually been built yet.
+        """
+        pure_outputs = self._mutate_outputs(
+            self.distribution.has_pure_modules(),
+            'build_py',
+            'build_lib',
+            self.install_dir,
+        )
+        if self.compile:
+            bytecode_outputs = self._bytecode_filenames(pure_outputs)
+        else:
+            bytecode_outputs = []
+
+        ext_outputs = self._mutate_outputs(
+            self.distribution.has_ext_modules(),
+            'build_ext',
+            'build_lib',
+            self.install_dir,
+        )
+
+        return pure_outputs + bytecode_outputs + ext_outputs
+
+    def get_inputs(self):
+        """Get the list of files that are input to this command, ie. the
+        files that get installed as they are named in the build tree.
+        The files in this list correspond one-to-one to the output
+        filenames returned by 'get_outputs()'.
+        """
+        inputs = []
+
+        if self.distribution.has_pure_modules():
+            build_py = self.get_finalized_command('build_py')
+            inputs.extend(build_py.get_outputs())
+
+        if self.distribution.has_ext_modules():
+            build_ext = self.get_finalized_command('build_ext')
+            inputs.extend(build_ext.get_outputs())
+
+        return inputs
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/command/install_scripts.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/command/install_scripts.py
new file mode 100644
index 0000000000000000000000000000000000000000..92e8694111ee29bd82a33218e1c7f2a9ecbd3a4e
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/command/install_scripts.py
@@ -0,0 +1,62 @@
+"""distutils.command.install_scripts
+
+Implements the Distutils 'install_scripts' command, for installing
+Python scripts."""
+
+# contributed by Bastian Kleineidam
+
+import os
+from distutils._log import log
+from stat import ST_MODE
+from typing import ClassVar
+
+from ..core import Command
+
+
+class install_scripts(Command):
+    description = "install scripts (Python or otherwise)"
+
+    user_options = [
+        ('install-dir=', 'd', "directory to install scripts to"),
+        ('build-dir=', 'b', "build directory (where to install from)"),
+        ('force', 'f', "force installation (overwrite existing files)"),
+        ('skip-build', None, "skip the build steps"),
+    ]
+
+    boolean_options: ClassVar[list[str]] = ['force', 'skip-build']
+
+    def initialize_options(self):
+        self.install_dir = None
+        self.force = False
+        self.build_dir = None
+        self.skip_build = None
+
+    def finalize_options(self) -> None:
+        self.set_undefined_options('build', ('build_scripts', 'build_dir'))
+        self.set_undefined_options(
+            'install',
+            ('install_scripts', 'install_dir'),
+            ('force', 'force'),
+            ('skip_build', 'skip_build'),
+        )
+
+    def run(self) -> None:
+        if not self.skip_build:
+            self.run_command('build_scripts')
+        self.outfiles = self.copy_tree(self.build_dir, self.install_dir)
+        if os.name == 'posix':
+            # Set the executable bits (owner, group, and world) on
+            # all the scripts we just installed.
+            for file in self.get_outputs():
+                if self.dry_run:
+                    log.info("changing mode of %s", file)
+                else:
+                    mode = ((os.stat(file)[ST_MODE]) | 0o555) & 0o7777
+                    log.info("changing mode of %s to %o", file, mode)
+                    os.chmod(file, mode)
+
+    def get_inputs(self):
+        return self.distribution.scripts or []
+
+    def get_outputs(self):
+        return self.outfiles or []
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/command/sdist.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/command/sdist.py
new file mode 100644
index 0000000000000000000000000000000000000000..b3bf0c326aa04c00e8da0e82e8c74afa488be055
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/command/sdist.py
@@ -0,0 +1,521 @@
+"""distutils.command.sdist
+
+Implements the Distutils 'sdist' command (create a source distribution)."""
+
+from __future__ import annotations
+
+import os
+import sys
+from collections.abc import Callable
+from distutils import archive_util, dir_util, file_util
+from distutils._log import log
+from glob import glob
+from itertools import filterfalse
+from typing import ClassVar
+
+from ..core import Command
+from ..errors import DistutilsOptionError, DistutilsTemplateError
+from ..filelist import FileList
+from ..text_file import TextFile
+from ..util import convert_path
+
+
+def show_formats():
+    """Print all possible values for the 'formats' option (used by
+    the "--help-formats" command-line option).
+    """
+    from ..archive_util import ARCHIVE_FORMATS
+    from ..fancy_getopt import FancyGetopt
+
+    formats = sorted(
+        ("formats=" + format, None, ARCHIVE_FORMATS[format][2])
+        for format in ARCHIVE_FORMATS.keys()
+    )
+    FancyGetopt(formats).print_help("List of available source distribution formats:")
+
+
+class sdist(Command):
+    description = "create a source distribution (tarball, zip file, etc.)"
+
+    def checking_metadata(self) -> bool:
+        """Callable used for the check sub-command.
+
+        Placed here so user_options can view it"""
+        return self.metadata_check
+
+    user_options = [
+        ('template=', 't', "name of manifest template file [default: MANIFEST.in]"),
+        ('manifest=', 'm', "name of manifest file [default: MANIFEST]"),
+        (
+            'use-defaults',
+            None,
+            "include the default file set in the manifest "
+            "[default; disable with --no-defaults]",
+        ),
+        ('no-defaults', None, "don't include the default file set"),
+        (
+            'prune',
+            None,
+            "specifically exclude files/directories that should not be "
+            "distributed (build tree, RCS/CVS dirs, etc.) "
+            "[default; disable with --no-prune]",
+        ),
+        ('no-prune', None, "don't automatically exclude anything"),
+        (
+            'manifest-only',
+            'o',
+            "just regenerate the manifest and then stop (implies --force-manifest)",
+        ),
+        (
+            'force-manifest',
+            'f',
+            "forcibly regenerate the manifest and carry on as usual. "
+            "Deprecated: now the manifest is always regenerated.",
+        ),
+        ('formats=', None, "formats for source distribution (comma-separated list)"),
+        (
+            'keep-temp',
+            'k',
+            "keep the distribution tree around after creating " + "archive file(s)",
+        ),
+        (
+            'dist-dir=',
+            'd',
+            "directory to put the source distribution archive(s) in [default: dist]",
+        ),
+        (
+            'metadata-check',
+            None,
+            "Ensure that all required elements of meta-data "
+            "are supplied. Warn if any missing. [default]",
+        ),
+        (
+            'owner=',
+            'u',
+            "Owner name used when creating a tar file [default: current user]",
+        ),
+        (
+            'group=',
+            'g',
+            "Group name used when creating a tar file [default: current group]",
+        ),
+    ]
+
+    boolean_options: ClassVar[list[str]] = [
+        'use-defaults',
+        'prune',
+        'manifest-only',
+        'force-manifest',
+        'keep-temp',
+        'metadata-check',
+    ]
+
+    help_options: ClassVar[list[tuple[str, str | None, str, Callable[[], object]]]] = [
+        ('help-formats', None, "list available distribution formats", show_formats),
+    ]
+
+    negative_opt: ClassVar[dict[str, str]] = {
+        'no-defaults': 'use-defaults',
+        'no-prune': 'prune',
+    }
+
+    sub_commands = [('check', checking_metadata)]
+
+    READMES: ClassVar[tuple[str, ...]] = ('README', 'README.txt', 'README.rst')
+
+    def initialize_options(self):
+        # 'template' and 'manifest' are, respectively, the names of
+        # the manifest template and manifest file.
+        self.template = None
+        self.manifest = None
+
+        # 'use_defaults': if true, we will include the default file set
+        # in the manifest
+        self.use_defaults = True
+        self.prune = True
+
+        self.manifest_only = False
+        self.force_manifest = False
+
+        self.formats = ['gztar']
+        self.keep_temp = False
+        self.dist_dir = None
+
+        self.archive_files = None
+        self.metadata_check = True
+        self.owner = None
+        self.group = None
+
+    def finalize_options(self) -> None:
+        if self.manifest is None:
+            self.manifest = "MANIFEST"
+        if self.template is None:
+            self.template = "MANIFEST.in"
+
+        self.ensure_string_list('formats')
+
+        bad_format = archive_util.check_archive_formats(self.formats)
+        if bad_format:
+            raise DistutilsOptionError(f"unknown archive format '{bad_format}'")
+
+        if self.dist_dir is None:
+            self.dist_dir = "dist"
+
+    def run(self) -> None:
+        # 'filelist' contains the list of files that will make up the
+        # manifest
+        self.filelist = FileList()
+
+        # Run sub commands
+        for cmd_name in self.get_sub_commands():
+            self.run_command(cmd_name)
+
+        # Do whatever it takes to get the list of files to process
+        # (process the manifest template, read an existing manifest,
+        # whatever).  File list is accumulated in 'self.filelist'.
+        self.get_file_list()
+
+        # If user just wanted us to regenerate the manifest, stop now.
+        if self.manifest_only:
+            return
+
+        # Otherwise, go ahead and create the source distribution tarball,
+        # or zipfile, or whatever.
+        self.make_distribution()
+
+    def get_file_list(self) -> None:
+        """Figure out the list of files to include in the source
+        distribution, and put it in 'self.filelist'.  This might involve
+        reading the manifest template (and writing the manifest), or just
+        reading the manifest, or just using the default file set -- it all
+        depends on the user's options.
+        """
+        # new behavior when using a template:
+        # the file list is recalculated every time because
+        # even if MANIFEST.in or setup.py are not changed
+        # the user might have added some files in the tree that
+        # need to be included.
+        #
+        #  This makes --force the default and only behavior with templates.
+        template_exists = os.path.isfile(self.template)
+        if not template_exists and self._manifest_is_not_generated():
+            self.read_manifest()
+            self.filelist.sort()
+            self.filelist.remove_duplicates()
+            return
+
+        if not template_exists:
+            self.warn(
+                ("manifest template '%s' does not exist " + "(using default file list)")
+                % self.template
+            )
+        self.filelist.findall()
+
+        if self.use_defaults:
+            self.add_defaults()
+
+        if template_exists:
+            self.read_template()
+
+        if self.prune:
+            self.prune_file_list()
+
+        self.filelist.sort()
+        self.filelist.remove_duplicates()
+        self.write_manifest()
+
+    def add_defaults(self) -> None:
+        """Add all the default files to self.filelist:
+          - README or README.txt
+          - setup.py
+          - tests/test*.py and test/test*.py
+          - all pure Python modules mentioned in setup script
+          - all files pointed by package_data (build_py)
+          - all files defined in data_files.
+          - all files defined as scripts.
+          - all C sources listed as part of extensions or C libraries
+            in the setup script (doesn't catch C headers!)
+        Warns if (README or README.txt) or setup.py are missing; everything
+        else is optional.
+        """
+        self._add_defaults_standards()
+        self._add_defaults_optional()
+        self._add_defaults_python()
+        self._add_defaults_data_files()
+        self._add_defaults_ext()
+        self._add_defaults_c_libs()
+        self._add_defaults_scripts()
+
+    @staticmethod
+    def _cs_path_exists(fspath):
+        """
+        Case-sensitive path existence check
+
+        >>> sdist._cs_path_exists(__file__)
+        True
+        >>> sdist._cs_path_exists(__file__.upper())
+        False
+        """
+        if not os.path.exists(fspath):
+            return False
+        # make absolute so we always have a directory
+        abspath = os.path.abspath(fspath)
+        directory, filename = os.path.split(abspath)
+        return filename in os.listdir(directory)
+
+    def _add_defaults_standards(self):
+        standards = [self.READMES, self.distribution.script_name]
+        for fn in standards:
+            if isinstance(fn, tuple):
+                alts = fn
+                got_it = False
+                for fn in alts:
+                    if self._cs_path_exists(fn):
+                        got_it = True
+                        self.filelist.append(fn)
+                        break
+
+                if not got_it:
+                    self.warn(
+                        "standard file not found: should have one of " + ', '.join(alts)
+                    )
+            else:
+                if self._cs_path_exists(fn):
+                    self.filelist.append(fn)
+                else:
+                    self.warn(f"standard file '{fn}' not found")
+
+    def _add_defaults_optional(self):
+        optional = ['tests/test*.py', 'test/test*.py', 'setup.cfg']
+        for pattern in optional:
+            files = filter(os.path.isfile, glob(pattern))
+            self.filelist.extend(files)
+
+    def _add_defaults_python(self):
+        # build_py is used to get:
+        #  - python modules
+        #  - files defined in package_data
+        build_py = self.get_finalized_command('build_py')
+
+        # getting python files
+        if self.distribution.has_pure_modules():
+            self.filelist.extend(build_py.get_source_files())
+
+        # getting package_data files
+        # (computed in build_py.data_files by build_py.finalize_options)
+        for _pkg, src_dir, _build_dir, filenames in build_py.data_files:
+            for filename in filenames:
+                self.filelist.append(os.path.join(src_dir, filename))
+
+    def _add_defaults_data_files(self):
+        # getting distribution.data_files
+        if self.distribution.has_data_files():
+            for item in self.distribution.data_files:
+                if isinstance(item, str):
+                    # plain file
+                    item = convert_path(item)
+                    if os.path.isfile(item):
+                        self.filelist.append(item)
+                else:
+                    # a (dirname, filenames) tuple
+                    dirname, filenames = item
+                    for f in filenames:
+                        f = convert_path(f)
+                        if os.path.isfile(f):
+                            self.filelist.append(f)
+
+    def _add_defaults_ext(self):
+        if self.distribution.has_ext_modules():
+            build_ext = self.get_finalized_command('build_ext')
+            self.filelist.extend(build_ext.get_source_files())
+
+    def _add_defaults_c_libs(self):
+        if self.distribution.has_c_libraries():
+            build_clib = self.get_finalized_command('build_clib')
+            self.filelist.extend(build_clib.get_source_files())
+
+    def _add_defaults_scripts(self):
+        if self.distribution.has_scripts():
+            build_scripts = self.get_finalized_command('build_scripts')
+            self.filelist.extend(build_scripts.get_source_files())
+
+    def read_template(self) -> None:
+        """Read and parse manifest template file named by self.template.
+
+        (usually "MANIFEST.in") The parsing and processing is done by
+        'self.filelist', which updates itself accordingly.
+        """
+        log.info("reading manifest template '%s'", self.template)
+        template = TextFile(
+            self.template,
+            strip_comments=True,
+            skip_blanks=True,
+            join_lines=True,
+            lstrip_ws=True,
+            rstrip_ws=True,
+            collapse_join=True,
+        )
+
+        try:
+            while True:
+                line = template.readline()
+                if line is None:  # end of file
+                    break
+
+                try:
+                    self.filelist.process_template_line(line)
+                # the call above can raise a DistutilsTemplateError for
+                # malformed lines, or a ValueError from the lower-level
+                # convert_path function
+                except (DistutilsTemplateError, ValueError) as msg:
+                    self.warn(
+                        f"{template.filename}, line {int(template.current_line)}: {msg}"
+                    )
+        finally:
+            template.close()
+
+    def prune_file_list(self) -> None:
+        """Prune off branches that might slip into the file list as created
+        by 'read_template()', but really don't belong there:
+          * the build tree (typically "build")
+          * the release tree itself (only an issue if we ran "sdist"
+            previously with --keep-temp, or it aborted)
+          * any RCS, CVS, .svn, .hg, .git, .bzr, _darcs directories
+        """
+        build = self.get_finalized_command('build')
+        base_dir = self.distribution.get_fullname()
+
+        self.filelist.exclude_pattern(None, prefix=os.fspath(build.build_base))
+        self.filelist.exclude_pattern(None, prefix=base_dir)
+
+        if sys.platform == 'win32':
+            seps = r'/|\\'
+        else:
+            seps = '/'
+
+        vcs_dirs = ['RCS', 'CVS', r'\.svn', r'\.hg', r'\.git', r'\.bzr', '_darcs']
+        vcs_ptrn = r'(^|{})({})({}).*'.format(seps, '|'.join(vcs_dirs), seps)
+        self.filelist.exclude_pattern(vcs_ptrn, is_regex=True)
+
+    def write_manifest(self) -> None:
+        """Write the file list in 'self.filelist' (presumably as filled in
+        by 'add_defaults()' and 'read_template()') to the manifest file
+        named by 'self.manifest'.
+        """
+        if self._manifest_is_not_generated():
+            log.info(
+                f"not writing to manually maintained manifest file '{self.manifest}'"
+            )
+            return
+
+        content = self.filelist.files[:]
+        content.insert(0, '# file GENERATED by distutils, do NOT edit')
+        self.execute(
+            file_util.write_file,
+            (self.manifest, content),
+            f"writing manifest file '{self.manifest}'",
+        )
+
+    def _manifest_is_not_generated(self):
+        # check for special comment used in 3.1.3 and higher
+        if not os.path.isfile(self.manifest):
+            return False
+
+        with open(self.manifest, encoding='utf-8') as fp:
+            first_line = next(fp)
+        return first_line != '# file GENERATED by distutils, do NOT edit\n'
+
+    def read_manifest(self) -> None:
+        """Read the manifest file (named by 'self.manifest') and use it to
+        fill in 'self.filelist', the list of files to include in the source
+        distribution.
+        """
+        log.info("reading manifest file '%s'", self.manifest)
+        with open(self.manifest, encoding='utf-8') as lines:
+            self.filelist.extend(
+                # ignore comments and blank lines
+                filter(None, filterfalse(is_comment, map(str.strip, lines)))
+            )
+
+    def make_release_tree(self, base_dir, files) -> None:
+        """Create the directory tree that will become the source
+        distribution archive.  All directories implied by the filenames in
+        'files' are created under 'base_dir', and then we hard link or copy
+        (if hard linking is unavailable) those files into place.
+        Essentially, this duplicates the developer's source tree, but in a
+        directory named after the distribution, containing only the files
+        to be distributed.
+        """
+        # Create all the directories under 'base_dir' necessary to
+        # put 'files' there; the 'mkpath()' is just so we don't die
+        # if the manifest happens to be empty.
+        self.mkpath(base_dir)
+        dir_util.create_tree(base_dir, files, dry_run=self.dry_run)
+
+        # And walk over the list of files, either making a hard link (if
+        # os.link exists) to each one that doesn't already exist in its
+        # corresponding location under 'base_dir', or copying each file
+        # that's out-of-date in 'base_dir'.  (Usually, all files will be
+        # out-of-date, because by default we blow away 'base_dir' when
+        # we're done making the distribution archives.)
+
+        if hasattr(os, 'link'):  # can make hard links on this system
+            link = 'hard'
+            msg = f"making hard links in {base_dir}..."
+        else:  # nope, have to copy
+            link = None
+            msg = f"copying files to {base_dir}..."
+
+        if not files:
+            log.warning("no files to distribute -- empty manifest?")
+        else:
+            log.info(msg)
+        for file in files:
+            if not os.path.isfile(file):
+                log.warning("'%s' not a regular file -- skipping", file)
+            else:
+                dest = os.path.join(base_dir, file)
+                self.copy_file(file, dest, link=link)
+
+        self.distribution.metadata.write_pkg_info(base_dir)
+
+    def make_distribution(self) -> None:
+        """Create the source distribution(s).  First, we create the release
+        tree with 'make_release_tree()'; then, we create all required
+        archive files (according to 'self.formats') from the release tree.
+        Finally, we clean up by blowing away the release tree (unless
+        'self.keep_temp' is true).  The list of archive files created is
+        stored so it can be retrieved later by 'get_archive_files()'.
+        """
+        # Don't warn about missing meta-data here -- should be (and is!)
+        # done elsewhere.
+        base_dir = self.distribution.get_fullname()
+        base_name = os.path.join(self.dist_dir, base_dir)
+
+        self.make_release_tree(base_dir, self.filelist.files)
+        archive_files = []  # remember names of files we create
+        # tar archive must be created last to avoid overwrite and remove
+        if 'tar' in self.formats:
+            self.formats.append(self.formats.pop(self.formats.index('tar')))
+
+        for fmt in self.formats:
+            file = self.make_archive(
+                base_name, fmt, base_dir=base_dir, owner=self.owner, group=self.group
+            )
+            archive_files.append(file)
+            self.distribution.dist_files.append(('sdist', '', file))
+
+        self.archive_files = archive_files
+
+        if not self.keep_temp:
+            dir_util.remove_tree(base_dir, dry_run=self.dry_run)
+
+    def get_archive_files(self):
+        """Return the list of archive files created when the command
+        was run, or None if the command hasn't run yet.
+        """
+        return self.archive_files
+
+
+def is_comment(line: str) -> bool:
+    return line.startswith('#')
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/compat/__init__.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/compat/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..2c43729b09ea5e5bf9d8c0708e63c69b5114a279
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/compat/__init__.py
@@ -0,0 +1,18 @@
+from __future__ import annotations
+
+from collections.abc import Iterable
+from typing import TypeVar
+
+_IterableT = TypeVar("_IterableT", bound="Iterable[str]")
+
+
+def consolidate_linker_args(args: _IterableT) -> _IterableT | str:
+    """
+    Ensure the return value is a string for backward compatibility.
+
+    Retain until at least 2025-04-31. See pypa/distutils#246
+    """
+
+    if not all(arg.startswith('-Wl,') for arg in args):
+        return args
+    return '-Wl,' + ','.join(arg.removeprefix('-Wl,') for arg in args)
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/compat/__pycache__/__init__.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/compat/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..7ed3d51d4e2508ab31736656693cdcd9e60d345d
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/compat/__pycache__/__init__.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/compat/__pycache__/numpy.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/compat/__pycache__/numpy.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b756c44dbb0ccd5f9952d6bdffde24102cdf1a38
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/compat/__pycache__/numpy.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/compat/__pycache__/py39.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/compat/__pycache__/py39.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..bfded600564cfb8548a10553278690c8a7f32063
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/compat/__pycache__/py39.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/compat/numpy.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/compat/numpy.py
new file mode 100644
index 0000000000000000000000000000000000000000..73eca7acb103b7c7ca8e7a9f7f2d772a64aa344b
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/compat/numpy.py
@@ -0,0 +1,2 @@
+# required for older numpy versions on Pythons prior to 3.12; see pypa/setuptools#4876
+from ..compilers.C.base import _default_compilers, compiler_class  # noqa: F401
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/compat/py39.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/compat/py39.py
new file mode 100644
index 0000000000000000000000000000000000000000..1b436d76586cbcf38164548f3fc849ce1a3ff600
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/compat/py39.py
@@ -0,0 +1,66 @@
+import functools
+import itertools
+import platform
+import sys
+
+
+def add_ext_suffix_39(vars):
+    """
+    Ensure vars contains 'EXT_SUFFIX'. pypa/distutils#130
+    """
+    import _imp
+
+    ext_suffix = _imp.extension_suffixes()[0]
+    vars.update(
+        EXT_SUFFIX=ext_suffix,
+        # sysconfig sets SO to match EXT_SUFFIX, so maintain
+        # that expectation.
+        # https://github.com/python/cpython/blob/785cc6770588de087d09e89a69110af2542be208/Lib/sysconfig.py#L671-L673
+        SO=ext_suffix,
+    )
+
+
+needs_ext_suffix = sys.version_info < (3, 10) and platform.system() == 'Windows'
+add_ext_suffix = add_ext_suffix_39 if needs_ext_suffix else lambda vars: None
+
+
+# from more_itertools
+class UnequalIterablesError(ValueError):
+    def __init__(self, details=None):
+        msg = 'Iterables have different lengths'
+        if details is not None:
+            msg += (': index 0 has length {}; index {} has length {}').format(*details)
+
+        super().__init__(msg)
+
+
+# from more_itertools
+def _zip_equal_generator(iterables):
+    _marker = object()
+    for combo in itertools.zip_longest(*iterables, fillvalue=_marker):
+        for val in combo:
+            if val is _marker:
+                raise UnequalIterablesError()
+        yield combo
+
+
+# from more_itertools
+def _zip_equal(*iterables):
+    # Check whether the iterables are all the same size.
+    try:
+        first_size = len(iterables[0])
+        for i, it in enumerate(iterables[1:], 1):
+            size = len(it)
+            if size != first_size:
+                raise UnequalIterablesError(details=(first_size, i, size))
+        # All sizes are equal, we can use the built-in zip.
+        return zip(*iterables)
+    # If any one of the iterables didn't have a length, start reading
+    # them until one runs out.
+    except TypeError:
+        return _zip_equal_generator(iterables)
+
+
+zip_strict = (
+    _zip_equal if sys.version_info < (3, 10) else functools.partial(zip, strict=True)
+)
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/compilers/C/__pycache__/base.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/compilers/C/__pycache__/base.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..88570f2a52acbce02a21438c0c4d2aeec2f711f7
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/compilers/C/__pycache__/base.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/compilers/C/__pycache__/cygwin.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/compilers/C/__pycache__/cygwin.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..0cad1060c6ee20352531c8da2a44c879e7eb1aa0
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/compilers/C/__pycache__/cygwin.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/compilers/C/__pycache__/errors.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/compilers/C/__pycache__/errors.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a021a528e5f3315001bc5a670a9d096b0cccb1a4
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/compilers/C/__pycache__/errors.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/compilers/C/__pycache__/msvc.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/compilers/C/__pycache__/msvc.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..3197fb94bd8d19ff6ac92092b7ef220cd65cab51
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/compilers/C/__pycache__/msvc.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/compilers/C/__pycache__/unix.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/compilers/C/__pycache__/unix.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..75c0d1e30aa0bed547c30f132dd50606e776fec5
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/compilers/C/__pycache__/unix.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/compilers/C/__pycache__/zos.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/compilers/C/__pycache__/zos.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..e588a91dc7a154fece4c7b2fb3a8227d06dfc5d3
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/compilers/C/__pycache__/zos.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/compilers/C/base.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/compilers/C/base.py
new file mode 100644
index 0000000000000000000000000000000000000000..5efd2a39d6a8cd7a722b7aefc3de4f1def4e4788
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/compilers/C/base.py
@@ -0,0 +1,1394 @@
+"""distutils.ccompiler
+
+Contains Compiler, an abstract base class that defines the interface
+for the Distutils compiler abstraction model."""
+
+from __future__ import annotations
+
+import os
+import pathlib
+import re
+import sys
+import warnings
+from collections.abc import Callable, Iterable, MutableSequence, Sequence
+from typing import (
+    TYPE_CHECKING,
+    ClassVar,
+    Literal,
+    TypeVar,
+    Union,
+    overload,
+)
+
+from more_itertools import always_iterable
+
+from ..._log import log
+from ..._modified import newer_group
+from ...dir_util import mkpath
+from ...errors import (
+    DistutilsModuleError,
+    DistutilsPlatformError,
+)
+from ...file_util import move_file
+from ...spawn import spawn
+from ...util import execute, is_mingw, split_quoted
+from .errors import (
+    CompileError,
+    LinkError,
+    UnknownFileType,
+)
+
+if TYPE_CHECKING:
+    from typing_extensions import TypeAlias, TypeVarTuple, Unpack
+
+    _Ts = TypeVarTuple("_Ts")
+
+_Macro: TypeAlias = Union[tuple[str], tuple[str, Union[str, None]]]
+_StrPathT = TypeVar("_StrPathT", bound="str | os.PathLike[str]")
+_BytesPathT = TypeVar("_BytesPathT", bound="bytes | os.PathLike[bytes]")
+
+
+class Compiler:
+    """Abstract base class to define the interface that must be implemented
+    by real compiler classes.  Also has some utility methods used by
+    several compiler classes.
+
+    The basic idea behind a compiler abstraction class is that each
+    instance can be used for all the compile/link steps in building a
+    single project.  Thus, attributes common to all of those compile and
+    link steps -- include directories, macros to define, libraries to link
+    against, etc. -- are attributes of the compiler instance.  To allow for
+    variability in how individual files are treated, most of those
+    attributes may be varied on a per-compilation or per-link basis.
+    """
+
+    # 'compiler_type' is a class attribute that identifies this class.  It
+    # keeps code that wants to know what kind of compiler it's dealing with
+    # from having to import all possible compiler classes just to do an
+    # 'isinstance'.  In concrete CCompiler subclasses, 'compiler_type'
+    # should really, really be one of the keys of the 'compiler_class'
+    # dictionary (see below -- used by the 'new_compiler()' factory
+    # function) -- authors of new compiler interface classes are
+    # responsible for updating 'compiler_class'!
+    compiler_type: ClassVar[str] = None  # type: ignore[assignment]
+
+    # XXX things not handled by this compiler abstraction model:
+    #   * client can't provide additional options for a compiler,
+    #     e.g. warning, optimization, debugging flags.  Perhaps this
+    #     should be the domain of concrete compiler abstraction classes
+    #     (UnixCCompiler, MSVCCompiler, etc.) -- or perhaps the base
+    #     class should have methods for the common ones.
+    #   * can't completely override the include or library searchg
+    #     path, ie. no "cc -I -Idir1 -Idir2" or "cc -L -Ldir1 -Ldir2".
+    #     I'm not sure how widely supported this is even by Unix
+    #     compilers, much less on other platforms.  And I'm even less
+    #     sure how useful it is; maybe for cross-compiling, but
+    #     support for that is a ways off.  (And anyways, cross
+    #     compilers probably have a dedicated binary with the
+    #     right paths compiled in.  I hope.)
+    #   * can't do really freaky things with the library list/library
+    #     dirs, e.g. "-Ldir1 -lfoo -Ldir2 -lfoo" to link against
+    #     different versions of libfoo.a in different locations.  I
+    #     think this is useless without the ability to null out the
+    #     library search path anyways.
+
+    executables: ClassVar[dict]
+
+    # Subclasses that rely on the standard filename generation methods
+    # implemented below should override these; see the comment near
+    # those methods ('object_filenames()' et. al.) for details:
+    src_extensions: ClassVar[list[str] | None] = None
+    obj_extension: ClassVar[str | None] = None
+    static_lib_extension: ClassVar[str | None] = None
+    shared_lib_extension: ClassVar[str | None] = None
+    static_lib_format: ClassVar[str | None] = None  # format string
+    shared_lib_format: ClassVar[str | None] = None  # prob. same as static_lib_format
+    exe_extension: ClassVar[str | None] = None
+
+    # Default language settings. language_map is used to detect a source
+    # file or Extension target language, checking source filenames.
+    # language_order is used to detect the language precedence, when deciding
+    # what language to use when mixing source types. For example, if some
+    # extension has two files with ".c" extension, and one with ".cpp", it
+    # is still linked as c++.
+    language_map: ClassVar[dict[str, str]] = {
+        ".c": "c",
+        ".cc": "c++",
+        ".cpp": "c++",
+        ".cxx": "c++",
+        ".m": "objc",
+    }
+    language_order: ClassVar[list[str]] = ["c++", "objc", "c"]
+
+    include_dirs: list[str] = []
+    """
+    include dirs specific to this compiler class
+    """
+
+    library_dirs: list[str] = []
+    """
+    library dirs specific to this compiler class
+    """
+
+    def __init__(
+        self, verbose: bool = False, dry_run: bool = False, force: bool = False
+    ) -> None:
+        self.dry_run = dry_run
+        self.force = force
+        self.verbose = verbose
+
+        # 'output_dir': a common output directory for object, library,
+        # shared object, and shared library files
+        self.output_dir: str | None = None
+
+        # 'macros': a list of macro definitions (or undefinitions).  A
+        # macro definition is a 2-tuple (name, value), where the value is
+        # either a string or None (no explicit value).  A macro
+        # undefinition is a 1-tuple (name,).
+        self.macros: list[_Macro] = []
+
+        # 'include_dirs': a list of directories to search for include files
+        self.include_dirs = []
+
+        # 'libraries': a list of libraries to include in any link
+        # (library names, not filenames: eg. "foo" not "libfoo.a")
+        self.libraries: list[str] = []
+
+        # 'library_dirs': a list of directories to search for libraries
+        self.library_dirs = []
+
+        # 'runtime_library_dirs': a list of directories to search for
+        # shared libraries/objects at runtime
+        self.runtime_library_dirs: list[str] = []
+
+        # 'objects': a list of object files (or similar, such as explicitly
+        # named library files) to include on any link
+        self.objects: list[str] = []
+
+        for key in self.executables.keys():
+            self.set_executable(key, self.executables[key])
+
+    def set_executables(self, **kwargs: str) -> None:
+        """Define the executables (and options for them) that will be run
+        to perform the various stages of compilation.  The exact set of
+        executables that may be specified here depends on the compiler
+        class (via the 'executables' class attribute), but most will have:
+          compiler      the C/C++ compiler
+          linker_so     linker used to create shared objects and libraries
+          linker_exe    linker used to create binary executables
+          archiver      static library creator
+
+        On platforms with a command-line (Unix, DOS/Windows), each of these
+        is a string that will be split into executable name and (optional)
+        list of arguments.  (Splitting the string is done similarly to how
+        Unix shells operate: words are delimited by spaces, but quotes and
+        backslashes can override this.  See
+        'distutils.util.split_quoted()'.)
+        """
+
+        # Note that some CCompiler implementation classes will define class
+        # attributes 'cpp', 'cc', etc. with hard-coded executable names;
+        # this is appropriate when a compiler class is for exactly one
+        # compiler/OS combination (eg. MSVCCompiler).  Other compiler
+        # classes (UnixCCompiler, in particular) are driven by information
+        # discovered at run-time, since there are many different ways to do
+        # basically the same things with Unix C compilers.
+
+        for key in kwargs:
+            if key not in self.executables:
+                raise ValueError(
+                    f"unknown executable '{key}' for class {self.__class__.__name__}"
+                )
+            self.set_executable(key, kwargs[key])
+
+    def set_executable(self, key, value):
+        if isinstance(value, str):
+            setattr(self, key, split_quoted(value))
+        else:
+            setattr(self, key, value)
+
+    def _find_macro(self, name):
+        i = 0
+        for defn in self.macros:
+            if defn[0] == name:
+                return i
+            i += 1
+        return None
+
+    def _check_macro_definitions(self, definitions):
+        """Ensure that every element of 'definitions' is valid."""
+        for defn in definitions:
+            self._check_macro_definition(*defn)
+
+    def _check_macro_definition(self, defn):
+        """
+        Raise a TypeError if defn is not valid.
+
+        A valid definition is either a (name, value) 2-tuple or a (name,) tuple.
+        """
+        if not isinstance(defn, tuple) or not self._is_valid_macro(*defn):
+            raise TypeError(
+                f"invalid macro definition '{defn}': "
+                "must be tuple (string,), (string, string), or (string, None)"
+            )
+
+    @staticmethod
+    def _is_valid_macro(name, value=None):
+        """
+        A valid macro is a ``name : str`` and a ``value : str | None``.
+
+        >>> Compiler._is_valid_macro('foo', None)
+        True
+        """
+        return isinstance(name, str) and isinstance(value, (str, type(None)))
+
+    # -- Bookkeeping methods -------------------------------------------
+
+    def define_macro(self, name: str, value: str | None = None) -> None:
+        """Define a preprocessor macro for all compilations driven by this
+        compiler object.  The optional parameter 'value' should be a
+        string; if it is not supplied, then the macro will be defined
+        without an explicit value and the exact outcome depends on the
+        compiler used (XXX true? does ANSI say anything about this?)
+        """
+        # Delete from the list of macro definitions/undefinitions if
+        # already there (so that this one will take precedence).
+        i = self._find_macro(name)
+        if i is not None:
+            del self.macros[i]
+
+        self.macros.append((name, value))
+
+    def undefine_macro(self, name: str) -> None:
+        """Undefine a preprocessor macro for all compilations driven by
+        this compiler object.  If the same macro is defined by
+        'define_macro()' and undefined by 'undefine_macro()' the last call
+        takes precedence (including multiple redefinitions or
+        undefinitions).  If the macro is redefined/undefined on a
+        per-compilation basis (ie. in the call to 'compile()'), then that
+        takes precedence.
+        """
+        # Delete from the list of macro definitions/undefinitions if
+        # already there (so that this one will take precedence).
+        i = self._find_macro(name)
+        if i is not None:
+            del self.macros[i]
+
+        undefn = (name,)
+        self.macros.append(undefn)
+
+    def add_include_dir(self, dir: str) -> None:
+        """Add 'dir' to the list of directories that will be searched for
+        header files.  The compiler is instructed to search directories in
+        the order in which they are supplied by successive calls to
+        'add_include_dir()'.
+        """
+        self.include_dirs.append(dir)
+
+    def set_include_dirs(self, dirs: list[str]) -> None:
+        """Set the list of directories that will be searched to 'dirs' (a
+        list of strings).  Overrides any preceding calls to
+        'add_include_dir()'; subsequence calls to 'add_include_dir()' add
+        to the list passed to 'set_include_dirs()'.  This does not affect
+        any list of standard include directories that the compiler may
+        search by default.
+        """
+        self.include_dirs = dirs[:]
+
+    def add_library(self, libname: str) -> None:
+        """Add 'libname' to the list of libraries that will be included in
+        all links driven by this compiler object.  Note that 'libname'
+        should *not* be the name of a file containing a library, but the
+        name of the library itself: the actual filename will be inferred by
+        the linker, the compiler, or the compiler class (depending on the
+        platform).
+
+        The linker will be instructed to link against libraries in the
+        order they were supplied to 'add_library()' and/or
+        'set_libraries()'.  It is perfectly valid to duplicate library
+        names; the linker will be instructed to link against libraries as
+        many times as they are mentioned.
+        """
+        self.libraries.append(libname)
+
+    def set_libraries(self, libnames: list[str]) -> None:
+        """Set the list of libraries to be included in all links driven by
+        this compiler object to 'libnames' (a list of strings).  This does
+        not affect any standard system libraries that the linker may
+        include by default.
+        """
+        self.libraries = libnames[:]
+
+    def add_library_dir(self, dir: str) -> None:
+        """Add 'dir' to the list of directories that will be searched for
+        libraries specified to 'add_library()' and 'set_libraries()'.  The
+        linker will be instructed to search for libraries in the order they
+        are supplied to 'add_library_dir()' and/or 'set_library_dirs()'.
+        """
+        self.library_dirs.append(dir)
+
+    def set_library_dirs(self, dirs: list[str]) -> None:
+        """Set the list of library search directories to 'dirs' (a list of
+        strings).  This does not affect any standard library search path
+        that the linker may search by default.
+        """
+        self.library_dirs = dirs[:]
+
+    def add_runtime_library_dir(self, dir: str) -> None:
+        """Add 'dir' to the list of directories that will be searched for
+        shared libraries at runtime.
+        """
+        self.runtime_library_dirs.append(dir)
+
+    def set_runtime_library_dirs(self, dirs: list[str]) -> None:
+        """Set the list of directories to search for shared libraries at
+        runtime to 'dirs' (a list of strings).  This does not affect any
+        standard search path that the runtime linker may search by
+        default.
+        """
+        self.runtime_library_dirs = dirs[:]
+
+    def add_link_object(self, object: str) -> None:
+        """Add 'object' to the list of object files (or analogues, such as
+        explicitly named library files or the output of "resource
+        compilers") to be included in every link driven by this compiler
+        object.
+        """
+        self.objects.append(object)
+
+    def set_link_objects(self, objects: list[str]) -> None:
+        """Set the list of object files (or analogues) to be included in
+        every link to 'objects'.  This does not affect any standard object
+        files that the linker may include by default (such as system
+        libraries).
+        """
+        self.objects = objects[:]
+
+    # -- Private utility methods --------------------------------------
+    # (here for the convenience of subclasses)
+
+    # Helper method to prep compiler in subclass compile() methods
+
+    def _setup_compile(
+        self,
+        outdir: str | None,
+        macros: list[_Macro] | None,
+        incdirs: list[str] | tuple[str, ...] | None,
+        sources,
+        depends,
+        extra,
+    ):
+        """Process arguments and decide which source files to compile."""
+        outdir, macros, incdirs = self._fix_compile_args(outdir, macros, incdirs)
+
+        if extra is None:
+            extra = []
+
+        # Get the list of expected output (object) files
+        objects = self.object_filenames(sources, strip_dir=False, output_dir=outdir)
+        assert len(objects) == len(sources)
+
+        pp_opts = gen_preprocess_options(macros, incdirs)
+
+        build = {}
+        for i in range(len(sources)):
+            src = sources[i]
+            obj = objects[i]
+            ext = os.path.splitext(src)[1]
+            self.mkpath(os.path.dirname(obj))
+            build[obj] = (src, ext)
+
+        return macros, objects, extra, pp_opts, build
+
+    def _get_cc_args(self, pp_opts, debug, before):
+        # works for unixccompiler, cygwinccompiler
+        cc_args = pp_opts + ['-c']
+        if debug:
+            cc_args[:0] = ['-g']
+        if before:
+            cc_args[:0] = before
+        return cc_args
+
+    def _fix_compile_args(
+        self,
+        output_dir: str | None,
+        macros: list[_Macro] | None,
+        include_dirs: list[str] | tuple[str, ...] | None,
+    ) -> tuple[str, list[_Macro], list[str]]:
+        """Typecheck and fix-up some of the arguments to the 'compile()'
+        method, and return fixed-up values.  Specifically: if 'output_dir'
+        is None, replaces it with 'self.output_dir'; ensures that 'macros'
+        is a list, and augments it with 'self.macros'; ensures that
+        'include_dirs' is a list, and augments it with 'self.include_dirs'.
+        Guarantees that the returned values are of the correct type,
+        i.e. for 'output_dir' either string or None, and for 'macros' and
+        'include_dirs' either list or None.
+        """
+        if output_dir is None:
+            output_dir = self.output_dir
+        elif not isinstance(output_dir, str):
+            raise TypeError("'output_dir' must be a string or None")
+
+        if macros is None:
+            macros = list(self.macros)
+        elif isinstance(macros, list):
+            macros = macros + (self.macros or [])
+        else:
+            raise TypeError("'macros' (if supplied) must be a list of tuples")
+
+        if include_dirs is None:
+            include_dirs = list(self.include_dirs)
+        elif isinstance(include_dirs, (list, tuple)):
+            include_dirs = list(include_dirs) + (self.include_dirs or [])
+        else:
+            raise TypeError("'include_dirs' (if supplied) must be a list of strings")
+
+        # add include dirs for class
+        include_dirs += self.__class__.include_dirs
+
+        return output_dir, macros, include_dirs
+
+    def _prep_compile(self, sources, output_dir, depends=None):
+        """Decide which source files must be recompiled.
+
+        Determine the list of object files corresponding to 'sources',
+        and figure out which ones really need to be recompiled.
+        Return a list of all object files and a dictionary telling
+        which source files can be skipped.
+        """
+        # Get the list of expected output (object) files
+        objects = self.object_filenames(sources, output_dir=output_dir)
+        assert len(objects) == len(sources)
+
+        # Return an empty dict for the "which source files can be skipped"
+        # return value to preserve API compatibility.
+        return objects, {}
+
+    def _fix_object_args(
+        self, objects: list[str] | tuple[str, ...], output_dir: str | None
+    ) -> tuple[list[str], str]:
+        """Typecheck and fix up some arguments supplied to various methods.
+        Specifically: ensure that 'objects' is a list; if output_dir is
+        None, replace with self.output_dir.  Return fixed versions of
+        'objects' and 'output_dir'.
+        """
+        if not isinstance(objects, (list, tuple)):
+            raise TypeError("'objects' must be a list or tuple of strings")
+        objects = list(objects)
+
+        if output_dir is None:
+            output_dir = self.output_dir
+        elif not isinstance(output_dir, str):
+            raise TypeError("'output_dir' must be a string or None")
+
+        return (objects, output_dir)
+
+    def _fix_lib_args(
+        self,
+        libraries: list[str] | tuple[str, ...] | None,
+        library_dirs: list[str] | tuple[str, ...] | None,
+        runtime_library_dirs: list[str] | tuple[str, ...] | None,
+    ) -> tuple[list[str], list[str], list[str]]:
+        """Typecheck and fix up some of the arguments supplied to the
+        'link_*' methods.  Specifically: ensure that all arguments are
+        lists, and augment them with their permanent versions
+        (eg. 'self.libraries' augments 'libraries').  Return a tuple with
+        fixed versions of all arguments.
+        """
+        if libraries is None:
+            libraries = list(self.libraries)
+        elif isinstance(libraries, (list, tuple)):
+            libraries = list(libraries) + (self.libraries or [])
+        else:
+            raise TypeError("'libraries' (if supplied) must be a list of strings")
+
+        if library_dirs is None:
+            library_dirs = list(self.library_dirs)
+        elif isinstance(library_dirs, (list, tuple)):
+            library_dirs = list(library_dirs) + (self.library_dirs or [])
+        else:
+            raise TypeError("'library_dirs' (if supplied) must be a list of strings")
+
+        # add library dirs for class
+        library_dirs += self.__class__.library_dirs
+
+        if runtime_library_dirs is None:
+            runtime_library_dirs = list(self.runtime_library_dirs)
+        elif isinstance(runtime_library_dirs, (list, tuple)):
+            runtime_library_dirs = list(runtime_library_dirs) + (
+                self.runtime_library_dirs or []
+            )
+        else:
+            raise TypeError(
+                "'runtime_library_dirs' (if supplied) must be a list of strings"
+            )
+
+        return (libraries, library_dirs, runtime_library_dirs)
+
+    def _need_link(self, objects, output_file):
+        """Return true if we need to relink the files listed in 'objects'
+        to recreate 'output_file'.
+        """
+        if self.force:
+            return True
+        else:
+            if self.dry_run:
+                newer = newer_group(objects, output_file, missing='newer')
+            else:
+                newer = newer_group(objects, output_file)
+            return newer
+
+    def detect_language(self, sources: str | list[str]) -> str | None:
+        """Detect the language of a given file, or list of files. Uses
+        language_map, and language_order to do the job.
+        """
+        if not isinstance(sources, list):
+            sources = [sources]
+        lang = None
+        index = len(self.language_order)
+        for source in sources:
+            base, ext = os.path.splitext(source)
+            extlang = self.language_map.get(ext)
+            try:
+                extindex = self.language_order.index(extlang)
+                if extindex < index:
+                    lang = extlang
+                    index = extindex
+            except ValueError:
+                pass
+        return lang
+
+    # -- Worker methods ------------------------------------------------
+    # (must be implemented by subclasses)
+
+    def preprocess(
+        self,
+        source: str | os.PathLike[str],
+        output_file: str | os.PathLike[str] | None = None,
+        macros: list[_Macro] | None = None,
+        include_dirs: list[str] | tuple[str, ...] | None = None,
+        extra_preargs: list[str] | None = None,
+        extra_postargs: Iterable[str] | None = None,
+    ):
+        """Preprocess a single C/C++ source file, named in 'source'.
+        Output will be written to file named 'output_file', or stdout if
+        'output_file' not supplied.  'macros' is a list of macro
+        definitions as for 'compile()', which will augment the macros set
+        with 'define_macro()' and 'undefine_macro()'.  'include_dirs' is a
+        list of directory names that will be added to the default list.
+
+        Raises PreprocessError on failure.
+        """
+        pass
+
+    def compile(
+        self,
+        sources: Sequence[str | os.PathLike[str]],
+        output_dir: str | None = None,
+        macros: list[_Macro] | None = None,
+        include_dirs: list[str] | tuple[str, ...] | None = None,
+        debug: bool = False,
+        extra_preargs: list[str] | None = None,
+        extra_postargs: list[str] | None = None,
+        depends: list[str] | tuple[str, ...] | None = None,
+    ) -> list[str]:
+        """Compile one or more source files.
+
+        'sources' must be a list of filenames, most likely C/C++
+        files, but in reality anything that can be handled by a
+        particular compiler and compiler class (eg. MSVCCompiler can
+        handle resource files in 'sources').  Return a list of object
+        filenames, one per source filename in 'sources'.  Depending on
+        the implementation, not all source files will necessarily be
+        compiled, but all corresponding object filenames will be
+        returned.
+
+        If 'output_dir' is given, object files will be put under it, while
+        retaining their original path component.  That is, "foo/bar.c"
+        normally compiles to "foo/bar.o" (for a Unix implementation); if
+        'output_dir' is "build", then it would compile to
+        "build/foo/bar.o".
+
+        'macros', if given, must be a list of macro definitions.  A macro
+        definition is either a (name, value) 2-tuple or a (name,) 1-tuple.
+        The former defines a macro; if the value is None, the macro is
+        defined without an explicit value.  The 1-tuple case undefines a
+        macro.  Later definitions/redefinitions/ undefinitions take
+        precedence.
+
+        'include_dirs', if given, must be a list of strings, the
+        directories to add to the default include file search path for this
+        compilation only.
+
+        'debug' is a boolean; if true, the compiler will be instructed to
+        output debug symbols in (or alongside) the object file(s).
+
+        'extra_preargs' and 'extra_postargs' are implementation- dependent.
+        On platforms that have the notion of a command-line (e.g. Unix,
+        DOS/Windows), they are most likely lists of strings: extra
+        command-line arguments to prepend/append to the compiler command
+        line.  On other platforms, consult the implementation class
+        documentation.  In any event, they are intended as an escape hatch
+        for those occasions when the abstract compiler framework doesn't
+        cut the mustard.
+
+        'depends', if given, is a list of filenames that all targets
+        depend on.  If a source file is older than any file in
+        depends, then the source file will be recompiled.  This
+        supports dependency tracking, but only at a coarse
+        granularity.
+
+        Raises CompileError on failure.
+        """
+        # A concrete compiler class can either override this method
+        # entirely or implement _compile().
+        macros, objects, extra_postargs, pp_opts, build = self._setup_compile(
+            output_dir, macros, include_dirs, sources, depends, extra_postargs
+        )
+        cc_args = self._get_cc_args(pp_opts, debug, extra_preargs)
+
+        for obj in objects:
+            try:
+                src, ext = build[obj]
+            except KeyError:
+                continue
+            self._compile(obj, src, ext, cc_args, extra_postargs, pp_opts)
+
+        # Return *all* object filenames, not just the ones we just built.
+        return objects
+
+    def _compile(self, obj, src, ext, cc_args, extra_postargs, pp_opts):
+        """Compile 'src' to product 'obj'."""
+        # A concrete compiler class that does not override compile()
+        # should implement _compile().
+        pass
+
+    def create_static_lib(
+        self,
+        objects: list[str] | tuple[str, ...],
+        output_libname: str,
+        output_dir: str | None = None,
+        debug: bool = False,
+        target_lang: str | None = None,
+    ) -> None:
+        """Link a bunch of stuff together to create a static library file.
+        The "bunch of stuff" consists of the list of object files supplied
+        as 'objects', the extra object files supplied to
+        'add_link_object()' and/or 'set_link_objects()', the libraries
+        supplied to 'add_library()' and/or 'set_libraries()', and the
+        libraries supplied as 'libraries' (if any).
+
+        'output_libname' should be a library name, not a filename; the
+        filename will be inferred from the library name.  'output_dir' is
+        the directory where the library file will be put.
+
+        'debug' is a boolean; if true, debugging information will be
+        included in the library (note that on most platforms, it is the
+        compile step where this matters: the 'debug' flag is included here
+        just for consistency).
+
+        'target_lang' is the target language for which the given objects
+        are being compiled. This allows specific linkage time treatment of
+        certain languages.
+
+        Raises LibError on failure.
+        """
+        pass
+
+    # values for target_desc parameter in link()
+    SHARED_OBJECT = "shared_object"
+    SHARED_LIBRARY = "shared_library"
+    EXECUTABLE = "executable"
+
+    def link(
+        self,
+        target_desc: str,
+        objects: list[str] | tuple[str, ...],
+        output_filename: str,
+        output_dir: str | None = None,
+        libraries: list[str] | tuple[str, ...] | None = None,
+        library_dirs: list[str] | tuple[str, ...] | None = None,
+        runtime_library_dirs: list[str] | tuple[str, ...] | None = None,
+        export_symbols: Iterable[str] | None = None,
+        debug: bool = False,
+        extra_preargs: list[str] | None = None,
+        extra_postargs: list[str] | None = None,
+        build_temp: str | os.PathLike[str] | None = None,
+        target_lang: str | None = None,
+    ):
+        """Link a bunch of stuff together to create an executable or
+        shared library file.
+
+        The "bunch of stuff" consists of the list of object files supplied
+        as 'objects'.  'output_filename' should be a filename.  If
+        'output_dir' is supplied, 'output_filename' is relative to it
+        (i.e. 'output_filename' can provide directory components if
+        needed).
+
+        'libraries' is a list of libraries to link against.  These are
+        library names, not filenames, since they're translated into
+        filenames in a platform-specific way (eg. "foo" becomes "libfoo.a"
+        on Unix and "foo.lib" on DOS/Windows).  However, they can include a
+        directory component, which means the linker will look in that
+        specific directory rather than searching all the normal locations.
+
+        'library_dirs', if supplied, should be a list of directories to
+        search for libraries that were specified as bare library names
+        (ie. no directory component).  These are on top of the system
+        default and those supplied to 'add_library_dir()' and/or
+        'set_library_dirs()'.  'runtime_library_dirs' is a list of
+        directories that will be embedded into the shared library and used
+        to search for other shared libraries that *it* depends on at
+        run-time.  (This may only be relevant on Unix.)
+
+        'export_symbols' is a list of symbols that the shared library will
+        export.  (This appears to be relevant only on Windows.)
+
+        'debug' is as for 'compile()' and 'create_static_lib()', with the
+        slight distinction that it actually matters on most platforms (as
+        opposed to 'create_static_lib()', which includes a 'debug' flag
+        mostly for form's sake).
+
+        'extra_preargs' and 'extra_postargs' are as for 'compile()' (except
+        of course that they supply command-line arguments for the
+        particular linker being used).
+
+        'target_lang' is the target language for which the given objects
+        are being compiled. This allows specific linkage time treatment of
+        certain languages.
+
+        Raises LinkError on failure.
+        """
+        raise NotImplementedError
+
+    # Old 'link_*()' methods, rewritten to use the new 'link()' method.
+
+    def link_shared_lib(
+        self,
+        objects: list[str] | tuple[str, ...],
+        output_libname: str,
+        output_dir: str | None = None,
+        libraries: list[str] | tuple[str, ...] | None = None,
+        library_dirs: list[str] | tuple[str, ...] | None = None,
+        runtime_library_dirs: list[str] | tuple[str, ...] | None = None,
+        export_symbols: Iterable[str] | None = None,
+        debug: bool = False,
+        extra_preargs: list[str] | None = None,
+        extra_postargs: list[str] | None = None,
+        build_temp: str | os.PathLike[str] | None = None,
+        target_lang: str | None = None,
+    ):
+        self.link(
+            Compiler.SHARED_LIBRARY,
+            objects,
+            self.library_filename(output_libname, lib_type='shared'),
+            output_dir,
+            libraries,
+            library_dirs,
+            runtime_library_dirs,
+            export_symbols,
+            debug,
+            extra_preargs,
+            extra_postargs,
+            build_temp,
+            target_lang,
+        )
+
+    def link_shared_object(
+        self,
+        objects: list[str] | tuple[str, ...],
+        output_filename: str,
+        output_dir: str | None = None,
+        libraries: list[str] | tuple[str, ...] | None = None,
+        library_dirs: list[str] | tuple[str, ...] | None = None,
+        runtime_library_dirs: list[str] | tuple[str, ...] | None = None,
+        export_symbols: Iterable[str] | None = None,
+        debug: bool = False,
+        extra_preargs: list[str] | None = None,
+        extra_postargs: list[str] | None = None,
+        build_temp: str | os.PathLike[str] | None = None,
+        target_lang: str | None = None,
+    ):
+        self.link(
+            Compiler.SHARED_OBJECT,
+            objects,
+            output_filename,
+            output_dir,
+            libraries,
+            library_dirs,
+            runtime_library_dirs,
+            export_symbols,
+            debug,
+            extra_preargs,
+            extra_postargs,
+            build_temp,
+            target_lang,
+        )
+
+    def link_executable(
+        self,
+        objects: list[str] | tuple[str, ...],
+        output_progname: str,
+        output_dir: str | None = None,
+        libraries: list[str] | tuple[str, ...] | None = None,
+        library_dirs: list[str] | tuple[str, ...] | None = None,
+        runtime_library_dirs: list[str] | tuple[str, ...] | None = None,
+        debug: bool = False,
+        extra_preargs: list[str] | None = None,
+        extra_postargs: list[str] | None = None,
+        target_lang: str | None = None,
+    ):
+        self.link(
+            Compiler.EXECUTABLE,
+            objects,
+            self.executable_filename(output_progname),
+            output_dir,
+            libraries,
+            library_dirs,
+            runtime_library_dirs,
+            None,
+            debug,
+            extra_preargs,
+            extra_postargs,
+            None,
+            target_lang,
+        )
+
+    # -- Miscellaneous methods -----------------------------------------
+    # These are all used by the 'gen_lib_options() function; there is
+    # no appropriate default implementation so subclasses should
+    # implement all of these.
+
+    def library_dir_option(self, dir: str) -> str:
+        """Return the compiler option to add 'dir' to the list of
+        directories searched for libraries.
+        """
+        raise NotImplementedError
+
+    def runtime_library_dir_option(self, dir: str) -> str:
+        """Return the compiler option to add 'dir' to the list of
+        directories searched for runtime libraries.
+        """
+        raise NotImplementedError
+
+    def library_option(self, lib: str) -> str:
+        """Return the compiler option to add 'lib' to the list of libraries
+        linked into the shared library or executable.
+        """
+        raise NotImplementedError
+
+    def has_function(  # noqa: C901
+        self,
+        funcname: str,
+        includes: Iterable[str] | None = None,
+        include_dirs: list[str] | tuple[str, ...] | None = None,
+        libraries: list[str] | None = None,
+        library_dirs: list[str] | tuple[str, ...] | None = None,
+    ) -> bool:
+        """Return a boolean indicating whether funcname is provided as
+        a symbol on the current platform.  The optional arguments can
+        be used to augment the compilation environment.
+
+        The libraries argument is a list of flags to be passed to the
+        linker to make additional symbol definitions available for
+        linking.
+
+        The includes and include_dirs arguments are deprecated.
+        Usually, supplying include files with function declarations
+        will cause function detection to fail even in cases where the
+        symbol is available for linking.
+
+        """
+        # this can't be included at module scope because it tries to
+        # import math which might not be available at that point - maybe
+        # the necessary logic should just be inlined?
+        import tempfile
+
+        if includes is None:
+            includes = []
+        else:
+            warnings.warn("includes is deprecated", DeprecationWarning)
+        if include_dirs is None:
+            include_dirs = []
+        else:
+            warnings.warn("include_dirs is deprecated", DeprecationWarning)
+        if libraries is None:
+            libraries = []
+        if library_dirs is None:
+            library_dirs = []
+        fd, fname = tempfile.mkstemp(".c", funcname, text=True)
+        with os.fdopen(fd, "w", encoding='utf-8') as f:
+            for incl in includes:
+                f.write(f"""#include "{incl}"\n""")
+            if not includes:
+                # Use "char func(void);" as the prototype to follow
+                # what autoconf does.  This prototype does not match
+                # any well-known function the compiler might recognize
+                # as a builtin, so this ends up as a true link test.
+                # Without a fake prototype, the test would need to
+                # know the exact argument types, and the has_function
+                # interface does not provide that level of information.
+                f.write(
+                    f"""\
+#ifdef __cplusplus
+extern "C"
+#endif
+char {funcname}(void);
+"""
+                )
+            f.write(
+                f"""\
+int main (int argc, char **argv) {{
+    {funcname}();
+    return 0;
+}}
+"""
+            )
+
+        try:
+            objects = self.compile([fname], include_dirs=include_dirs)
+        except CompileError:
+            return False
+        finally:
+            os.remove(fname)
+
+        try:
+            self.link_executable(
+                objects, "a.out", libraries=libraries, library_dirs=library_dirs
+            )
+        except (LinkError, TypeError):
+            return False
+        else:
+            os.remove(
+                self.executable_filename("a.out", output_dir=self.output_dir or '')
+            )
+        finally:
+            for fn in objects:
+                os.remove(fn)
+        return True
+
+    def find_library_file(
+        self, dirs: Iterable[str], lib: str, debug: bool = False
+    ) -> str | None:
+        """Search the specified list of directories for a static or shared
+        library file 'lib' and return the full path to that file.  If
+        'debug' true, look for a debugging version (if that makes sense on
+        the current platform).  Return None if 'lib' wasn't found in any of
+        the specified directories.
+        """
+        raise NotImplementedError
+
+    # -- Filename generation methods -----------------------------------
+
+    # The default implementation of the filename generating methods are
+    # prejudiced towards the Unix/DOS/Windows view of the world:
+    #   * object files are named by replacing the source file extension
+    #     (eg. .c/.cpp -> .o/.obj)
+    #   * library files (shared or static) are named by plugging the
+    #     library name and extension into a format string, eg.
+    #     "lib%s.%s" % (lib_name, ".a") for Unix static libraries
+    #   * executables are named by appending an extension (possibly
+    #     empty) to the program name: eg. progname + ".exe" for
+    #     Windows
+    #
+    # To reduce redundant code, these methods expect to find
+    # several attributes in the current object (presumably defined
+    # as class attributes):
+    #   * src_extensions -
+    #     list of C/C++ source file extensions, eg. ['.c', '.cpp']
+    #   * obj_extension -
+    #     object file extension, eg. '.o' or '.obj'
+    #   * static_lib_extension -
+    #     extension for static library files, eg. '.a' or '.lib'
+    #   * shared_lib_extension -
+    #     extension for shared library/object files, eg. '.so', '.dll'
+    #   * static_lib_format -
+    #     format string for generating static library filenames,
+    #     eg. 'lib%s.%s' or '%s.%s'
+    #   * shared_lib_format
+    #     format string for generating shared library filenames
+    #     (probably same as static_lib_format, since the extension
+    #     is one of the intended parameters to the format string)
+    #   * exe_extension -
+    #     extension for executable files, eg. '' or '.exe'
+
+    def object_filenames(
+        self,
+        source_filenames: Iterable[str | os.PathLike[str]],
+        strip_dir: bool = False,
+        output_dir: str | os.PathLike[str] | None = '',
+    ) -> list[str]:
+        if output_dir is None:
+            output_dir = ''
+        return list(
+            self._make_out_path(output_dir, strip_dir, src_name)
+            for src_name in source_filenames
+        )
+
+    @property
+    def out_extensions(self):
+        return dict.fromkeys(self.src_extensions, self.obj_extension)
+
+    def _make_out_path(self, output_dir, strip_dir, src_name):
+        return self._make_out_path_exts(
+            output_dir, strip_dir, src_name, self.out_extensions
+        )
+
+    @classmethod
+    def _make_out_path_exts(cls, output_dir, strip_dir, src_name, extensions):
+        r"""
+        >>> exts = {'.c': '.o'}
+        >>> Compiler._make_out_path_exts('.', False, '/foo/bar.c', exts).replace('\\', '/')
+        './foo/bar.o'
+        >>> Compiler._make_out_path_exts('.', True, '/foo/bar.c', exts).replace('\\', '/')
+        './bar.o'
+        """
+        src = pathlib.PurePath(src_name)
+        # Ensure base is relative to honor output_dir (python/cpython#37775).
+        base = cls._make_relative(src)
+        try:
+            new_ext = extensions[src.suffix]
+        except LookupError:
+            raise UnknownFileType(f"unknown file type '{src.suffix}' (from '{src}')")
+        if strip_dir:
+            base = pathlib.PurePath(base.name)
+        return os.path.join(output_dir, base.with_suffix(new_ext))
+
+    @staticmethod
+    def _make_relative(base: pathlib.Path):
+        return base.relative_to(base.anchor)
+
+    @overload
+    def shared_object_filename(
+        self,
+        basename: str,
+        strip_dir: Literal[False] = False,
+        output_dir: str | os.PathLike[str] = "",
+    ) -> str: ...
+    @overload
+    def shared_object_filename(
+        self,
+        basename: str | os.PathLike[str],
+        strip_dir: Literal[True],
+        output_dir: str | os.PathLike[str] = "",
+    ) -> str: ...
+    def shared_object_filename(
+        self,
+        basename: str | os.PathLike[str],
+        strip_dir: bool = False,
+        output_dir: str | os.PathLike[str] = '',
+    ) -> str:
+        assert output_dir is not None
+        if strip_dir:
+            basename = os.path.basename(basename)
+        return os.path.join(output_dir, basename + self.shared_lib_extension)
+
+    @overload
+    def executable_filename(
+        self,
+        basename: str,
+        strip_dir: Literal[False] = False,
+        output_dir: str | os.PathLike[str] = "",
+    ) -> str: ...
+    @overload
+    def executable_filename(
+        self,
+        basename: str | os.PathLike[str],
+        strip_dir: Literal[True],
+        output_dir: str | os.PathLike[str] = "",
+    ) -> str: ...
+    def executable_filename(
+        self,
+        basename: str | os.PathLike[str],
+        strip_dir: bool = False,
+        output_dir: str | os.PathLike[str] = '',
+    ) -> str:
+        assert output_dir is not None
+        if strip_dir:
+            basename = os.path.basename(basename)
+        return os.path.join(output_dir, basename + (self.exe_extension or ''))
+
+    def library_filename(
+        self,
+        libname: str,
+        lib_type: str = "static",
+        strip_dir: bool = False,
+        output_dir: str | os.PathLike[str] = "",  # or 'shared'
+    ):
+        assert output_dir is not None
+        expected = '"static", "shared", "dylib", "xcode_stub"'
+        if lib_type not in eval(expected):
+            raise ValueError(f"'lib_type' must be {expected}")
+        fmt = getattr(self, lib_type + "_lib_format")
+        ext = getattr(self, lib_type + "_lib_extension")
+
+        dir, base = os.path.split(libname)
+        filename = fmt % (base, ext)
+        if strip_dir:
+            dir = ''
+
+        return os.path.join(output_dir, dir, filename)
+
+    # -- Utility methods -----------------------------------------------
+
+    def announce(self, msg: object, level: int = 1) -> None:
+        log.debug(msg)
+
+    def debug_print(self, msg: object) -> None:
+        from distutils.debug import DEBUG
+
+        if DEBUG:
+            print(msg)
+
+    def warn(self, msg: object) -> None:
+        sys.stderr.write(f"warning: {msg}\n")
+
+    def execute(
+        self,
+        func: Callable[[Unpack[_Ts]], object],
+        args: tuple[Unpack[_Ts]],
+        msg: object = None,
+        level: int = 1,
+    ) -> None:
+        execute(func, args, msg, self.dry_run)
+
+    def spawn(
+        self, cmd: MutableSequence[bytes | str | os.PathLike[str]], **kwargs
+    ) -> None:
+        spawn(cmd, dry_run=self.dry_run, **kwargs)
+
+    @overload
+    def move_file(
+        self, src: str | os.PathLike[str], dst: _StrPathT
+    ) -> _StrPathT | str: ...
+    @overload
+    def move_file(
+        self, src: bytes | os.PathLike[bytes], dst: _BytesPathT
+    ) -> _BytesPathT | bytes: ...
+    def move_file(
+        self,
+        src: str | os.PathLike[str] | bytes | os.PathLike[bytes],
+        dst: str | os.PathLike[str] | bytes | os.PathLike[bytes],
+    ) -> str | os.PathLike[str] | bytes | os.PathLike[bytes]:
+        return move_file(src, dst, dry_run=self.dry_run)
+
+    def mkpath(self, name, mode=0o777):
+        mkpath(name, mode, dry_run=self.dry_run)
+
+
+# Map a sys.platform/os.name ('posix', 'nt') to the default compiler
+# type for that platform. Keys are interpreted as re match
+# patterns. Order is important; platform mappings are preferred over
+# OS names.
+_default_compilers = (
+    # Platform string mappings
+    # on a cygwin built python we can use gcc like an ordinary UNIXish
+    # compiler
+    ('cygwin.*', 'unix'),
+    ('zos', 'zos'),
+    # OS name mappings
+    ('posix', 'unix'),
+    ('nt', 'msvc'),
+)
+
+
+def get_default_compiler(osname: str | None = None, platform: str | None = None) -> str:
+    """Determine the default compiler to use for the given platform.
+
+    osname should be one of the standard Python OS names (i.e. the
+    ones returned by os.name) and platform the common value
+    returned by sys.platform for the platform in question.
+
+    The default values are os.name and sys.platform in case the
+    parameters are not given.
+    """
+    if osname is None:
+        osname = os.name
+    if platform is None:
+        platform = sys.platform
+    # Mingw is a special case where sys.platform is 'win32' but we
+    # want to use the 'mingw32' compiler, so check it first
+    if is_mingw():
+        return 'mingw32'
+    for pattern, compiler in _default_compilers:
+        if (
+            re.match(pattern, platform) is not None
+            or re.match(pattern, osname) is not None
+        ):
+            return compiler
+    # Default to Unix compiler
+    return 'unix'
+
+
+# Map compiler types to (module_name, class_name) pairs -- ie. where to
+# find the code that implements an interface to this compiler.  (The module
+# is assumed to be in the 'distutils' package.)
+compiler_class = {
+    'unix': ('unixccompiler', 'UnixCCompiler', "standard UNIX-style compiler"),
+    'msvc': ('_msvccompiler', 'MSVCCompiler', "Microsoft Visual C++"),
+    'cygwin': (
+        'cygwinccompiler',
+        'CygwinCCompiler',
+        "Cygwin port of GNU C Compiler for Win32",
+    ),
+    'mingw32': (
+        'cygwinccompiler',
+        'Mingw32CCompiler',
+        "Mingw32 port of GNU C Compiler for Win32",
+    ),
+    'bcpp': ('bcppcompiler', 'BCPPCompiler', "Borland C++ Compiler"),
+    'zos': ('zosccompiler', 'zOSCCompiler', 'IBM XL C/C++ Compilers'),
+}
+
+
+def show_compilers() -> None:
+    """Print list of available compilers (used by the "--help-compiler"
+    options to "build", "build_ext", "build_clib").
+    """
+    # XXX this "knows" that the compiler option it's describing is
+    # "--compiler", which just happens to be the case for the three
+    # commands that use it.
+    from distutils.fancy_getopt import FancyGetopt
+
+    compilers = sorted(
+        ("compiler=" + compiler, None, compiler_class[compiler][2])
+        for compiler in compiler_class.keys()
+    )
+    pretty_printer = FancyGetopt(compilers)
+    pretty_printer.print_help("List of available compilers:")
+
+
+def new_compiler(
+    plat: str | None = None,
+    compiler: str | None = None,
+    verbose: bool = False,
+    dry_run: bool = False,
+    force: bool = False,
+) -> Compiler:
+    """Generate an instance of some CCompiler subclass for the supplied
+    platform/compiler combination.  'plat' defaults to 'os.name'
+    (eg. 'posix', 'nt'), and 'compiler' defaults to the default compiler
+    for that platform.  Currently only 'posix' and 'nt' are supported, and
+    the default compilers are "traditional Unix interface" (UnixCCompiler
+    class) and Visual C++ (MSVCCompiler class).  Note that it's perfectly
+    possible to ask for a Unix compiler object under Windows, and a
+    Microsoft compiler object under Unix -- if you supply a value for
+    'compiler', 'plat' is ignored.
+    """
+    if plat is None:
+        plat = os.name
+
+    try:
+        if compiler is None:
+            compiler = get_default_compiler(plat)
+
+        (module_name, class_name, long_description) = compiler_class[compiler]
+    except KeyError:
+        msg = f"don't know how to compile C/C++ code on platform '{plat}'"
+        if compiler is not None:
+            msg = msg + f" with '{compiler}' compiler"
+        raise DistutilsPlatformError(msg)
+
+    try:
+        module_name = "distutils." + module_name
+        __import__(module_name)
+        module = sys.modules[module_name]
+        klass = vars(module)[class_name]
+    except ImportError:
+        raise DistutilsModuleError(
+            f"can't compile C/C++ code: unable to load module '{module_name}'"
+        )
+    except KeyError:
+        raise DistutilsModuleError(
+            f"can't compile C/C++ code: unable to find class '{class_name}' "
+            f"in module '{module_name}'"
+        )
+
+    # XXX The None is necessary to preserve backwards compatibility
+    # with classes that expect verbose to be the first positional
+    # argument.
+    return klass(None, dry_run, force)
+
+
+def gen_preprocess_options(
+    macros: Iterable[_Macro], include_dirs: Iterable[str]
+) -> list[str]:
+    """Generate C pre-processor options (-D, -U, -I) as used by at least
+    two types of compilers: the typical Unix compiler and Visual C++.
+    'macros' is the usual thing, a list of 1- or 2-tuples, where (name,)
+    means undefine (-U) macro 'name', and (name,value) means define (-D)
+    macro 'name' to 'value'.  'include_dirs' is just a list of directory
+    names to be added to the header file search path (-I).  Returns a list
+    of command-line options suitable for either Unix compilers or Visual
+    C++.
+    """
+    # XXX it would be nice (mainly aesthetic, and so we don't generate
+    # stupid-looking command lines) to go over 'macros' and eliminate
+    # redundant definitions/undefinitions (ie. ensure that only the
+    # latest mention of a particular macro winds up on the command
+    # line).  I don't think it's essential, though, since most (all?)
+    # Unix C compilers only pay attention to the latest -D or -U
+    # mention of a macro on their command line.  Similar situation for
+    # 'include_dirs'.  I'm punting on both for now.  Anyways, weeding out
+    # redundancies like this should probably be the province of
+    # CCompiler, since the data structures used are inherited from it
+    # and therefore common to all CCompiler classes.
+    pp_opts = []
+    for macro in macros:
+        if not (isinstance(macro, tuple) and 1 <= len(macro) <= 2):
+            raise TypeError(
+                f"bad macro definition '{macro}': "
+                "each element of 'macros' list must be a 1- or 2-tuple"
+            )
+
+        if len(macro) == 1:  # undefine this macro
+            pp_opts.append(f"-U{macro[0]}")
+        elif len(macro) == 2:
+            if macro[1] is None:  # define with no explicit value
+                pp_opts.append(f"-D{macro[0]}")
+            else:
+                # XXX *don't* need to be clever about quoting the
+                # macro value here, because we're going to avoid the
+                # shell at all costs when we spawn the command!
+                pp_opts.append("-D{}={}".format(*macro))
+
+    pp_opts.extend(f"-I{dir}" for dir in include_dirs)
+    return pp_opts
+
+
+def gen_lib_options(
+    compiler: Compiler,
+    library_dirs: Iterable[str],
+    runtime_library_dirs: Iterable[str],
+    libraries: Iterable[str],
+) -> list[str]:
+    """Generate linker options for searching library directories and
+    linking with specific libraries.  'libraries' and 'library_dirs' are,
+    respectively, lists of library names (not filenames!) and search
+    directories.  Returns a list of command-line options suitable for use
+    with some compiler (depending on the two format strings passed in).
+    """
+    lib_opts = [compiler.library_dir_option(dir) for dir in library_dirs]
+
+    for dir in runtime_library_dirs:
+        lib_opts.extend(always_iterable(compiler.runtime_library_dir_option(dir)))
+
+    # XXX it's important that we *not* remove redundant library mentions!
+    # sometimes you really do have to say "-lfoo -lbar -lfoo" in order to
+    # resolve all symbols.  I just hope we never have to say "-lfoo obj.o
+    # -lbar" to get things to work -- that's certainly a possibility, but a
+    # pretty nasty way to arrange your C code.
+
+    for lib in libraries:
+        (lib_dir, lib_name) = os.path.split(lib)
+        if lib_dir:
+            lib_file = compiler.find_library_file([lib_dir], lib_name)
+            if lib_file:
+                lib_opts.append(lib_file)
+            else:
+                compiler.warn(
+                    f"no library file corresponding to '{lib}' found (skipping)"
+                )
+        else:
+            lib_opts.append(compiler.library_option(lib))
+    return lib_opts
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/compilers/C/cygwin.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/compilers/C/cygwin.py
new file mode 100644
index 0000000000000000000000000000000000000000..bfabbb306e7e44ed120d35f083304e65d7cecf83
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/compilers/C/cygwin.py
@@ -0,0 +1,340 @@
+"""distutils.cygwinccompiler
+
+Provides the CygwinCCompiler class, a subclass of UnixCCompiler that
+handles the Cygwin port of the GNU C compiler to Windows.  It also contains
+the Mingw32CCompiler class which handles the mingw32 port of GCC (same as
+cygwin in no-cygwin mode).
+"""
+
+import copy
+import os
+import pathlib
+import shlex
+import sys
+import warnings
+from subprocess import check_output
+
+from ...errors import (
+    DistutilsExecError,
+    DistutilsPlatformError,
+)
+from ...file_util import write_file
+from ...sysconfig import get_config_vars
+from ...version import LooseVersion, suppress_known_deprecation
+from . import unix
+from .errors import (
+    CompileError,
+    Error,
+)
+
+
+def get_msvcr():
+    """No longer needed, but kept for backward compatibility."""
+    return []
+
+
+_runtime_library_dirs_msg = (
+    "Unable to set runtime library search path on Windows, "
+    "usually indicated by `runtime_library_dirs` parameter to Extension"
+)
+
+
+class Compiler(unix.Compiler):
+    """Handles the Cygwin port of the GNU C compiler to Windows."""
+
+    compiler_type = 'cygwin'
+    obj_extension = ".o"
+    static_lib_extension = ".a"
+    shared_lib_extension = ".dll.a"
+    dylib_lib_extension = ".dll"
+    static_lib_format = "lib%s%s"
+    shared_lib_format = "lib%s%s"
+    dylib_lib_format = "cyg%s%s"
+    exe_extension = ".exe"
+
+    def __init__(self, verbose=False, dry_run=False, force=False):
+        super().__init__(verbose, dry_run, force)
+
+        status, details = check_config_h()
+        self.debug_print(f"Python's GCC status: {status} (details: {details})")
+        if status is not CONFIG_H_OK:
+            self.warn(
+                "Python's pyconfig.h doesn't seem to support your compiler. "
+                f"Reason: {details}. "
+                "Compiling may fail because of undefined preprocessor macros."
+            )
+
+        self.cc, self.cxx = get_config_vars('CC', 'CXX')
+
+        # Override 'CC' and 'CXX' environment variables for
+        # building using MINGW compiler for MSVC python.
+        self.cc = os.environ.get('CC', self.cc or 'gcc')
+        self.cxx = os.environ.get('CXX', self.cxx or 'g++')
+
+        self.linker_dll = self.cc
+        self.linker_dll_cxx = self.cxx
+        shared_option = "-shared"
+
+        self.set_executables(
+            compiler=f'{self.cc} -mcygwin -O -Wall',
+            compiler_so=f'{self.cc} -mcygwin -mdll -O -Wall',
+            compiler_cxx=f'{self.cxx} -mcygwin -O -Wall',
+            compiler_so_cxx=f'{self.cxx} -mcygwin -mdll -O -Wall',
+            linker_exe=f'{self.cc} -mcygwin',
+            linker_so=f'{self.linker_dll} -mcygwin {shared_option}',
+            linker_exe_cxx=f'{self.cxx} -mcygwin',
+            linker_so_cxx=f'{self.linker_dll_cxx} -mcygwin {shared_option}',
+        )
+
+        self.dll_libraries = get_msvcr()
+
+    @property
+    def gcc_version(self):
+        # Older numpy depended on this existing to check for ancient
+        # gcc versions. This doesn't make much sense with clang etc so
+        # just hardcode to something recent.
+        # https://github.com/numpy/numpy/pull/20333
+        warnings.warn(
+            "gcc_version attribute of CygwinCCompiler is deprecated. "
+            "Instead of returning actual gcc version a fixed value 11.2.0 is returned.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        with suppress_known_deprecation():
+            return LooseVersion("11.2.0")
+
+    def _compile(self, obj, src, ext, cc_args, extra_postargs, pp_opts):
+        """Compiles the source by spawning GCC and windres if needed."""
+        if ext in ('.rc', '.res'):
+            # gcc needs '.res' and '.rc' compiled to object files !!!
+            try:
+                self.spawn(["windres", "-i", src, "-o", obj])
+            except DistutilsExecError as msg:
+                raise CompileError(msg)
+        else:  # for other files use the C-compiler
+            try:
+                if self.detect_language(src) == 'c++':
+                    self.spawn(
+                        self.compiler_so_cxx
+                        + cc_args
+                        + [src, '-o', obj]
+                        + extra_postargs
+                    )
+                else:
+                    self.spawn(
+                        self.compiler_so + cc_args + [src, '-o', obj] + extra_postargs
+                    )
+            except DistutilsExecError as msg:
+                raise CompileError(msg)
+
+    def link(
+        self,
+        target_desc,
+        objects,
+        output_filename,
+        output_dir=None,
+        libraries=None,
+        library_dirs=None,
+        runtime_library_dirs=None,
+        export_symbols=None,
+        debug=False,
+        extra_preargs=None,
+        extra_postargs=None,
+        build_temp=None,
+        target_lang=None,
+    ):
+        """Link the objects."""
+        # use separate copies, so we can modify the lists
+        extra_preargs = copy.copy(extra_preargs or [])
+        libraries = copy.copy(libraries or [])
+        objects = copy.copy(objects or [])
+
+        if runtime_library_dirs:
+            self.warn(_runtime_library_dirs_msg)
+
+        # Additional libraries
+        libraries.extend(self.dll_libraries)
+
+        # handle export symbols by creating a def-file
+        # with executables this only works with gcc/ld as linker
+        if (export_symbols is not None) and (
+            target_desc != self.EXECUTABLE or self.linker_dll == "gcc"
+        ):
+            # (The linker doesn't do anything if output is up-to-date.
+            # So it would probably better to check if we really need this,
+            # but for this we had to insert some unchanged parts of
+            # UnixCCompiler, and this is not what we want.)
+
+            # we want to put some files in the same directory as the
+            # object files are, build_temp doesn't help much
+            # where are the object files
+            temp_dir = os.path.dirname(objects[0])
+            # name of dll to give the helper files the same base name
+            (dll_name, dll_extension) = os.path.splitext(
+                os.path.basename(output_filename)
+            )
+
+            # generate the filenames for these files
+            def_file = os.path.join(temp_dir, dll_name + ".def")
+
+            # Generate .def file
+            contents = [f"LIBRARY {os.path.basename(output_filename)}", "EXPORTS"]
+            contents.extend(export_symbols)
+            self.execute(write_file, (def_file, contents), f"writing {def_file}")
+
+            # next add options for def-file
+
+            # for gcc/ld the def-file is specified as any object files
+            objects.append(def_file)
+
+        # end: if ((export_symbols is not None) and
+        #        (target_desc != self.EXECUTABLE or self.linker_dll == "gcc")):
+
+        # who wants symbols and a many times larger output file
+        # should explicitly switch the debug mode on
+        # otherwise we let ld strip the output file
+        # (On my machine: 10KiB < stripped_file < ??100KiB
+        #   unstripped_file = stripped_file + XXX KiB
+        #  ( XXX=254 for a typical python extension))
+        if not debug:
+            extra_preargs.append("-s")
+
+        super().link(
+            target_desc,
+            objects,
+            output_filename,
+            output_dir,
+            libraries,
+            library_dirs,
+            runtime_library_dirs,
+            None,  # export_symbols, we do this in our def-file
+            debug,
+            extra_preargs,
+            extra_postargs,
+            build_temp,
+            target_lang,
+        )
+
+    def runtime_library_dir_option(self, dir):
+        # cygwin doesn't support rpath. While in theory we could error
+        # out like MSVC does, code might expect it to work like on Unix, so
+        # just warn and hope for the best.
+        self.warn(_runtime_library_dirs_msg)
+        return []
+
+    # -- Miscellaneous methods -----------------------------------------
+
+    def _make_out_path(self, output_dir, strip_dir, src_name):
+        # use normcase to make sure '.rc' is really '.rc' and not '.RC'
+        norm_src_name = os.path.normcase(src_name)
+        return super()._make_out_path(output_dir, strip_dir, norm_src_name)
+
+    @property
+    def out_extensions(self):
+        """
+        Add support for rc and res files.
+        """
+        return {
+            **super().out_extensions,
+            **{ext: ext + self.obj_extension for ext in ('.res', '.rc')},
+        }
+
+
+# the same as cygwin plus some additional parameters
+class MinGW32Compiler(Compiler):
+    """Handles the Mingw32 port of the GNU C compiler to Windows."""
+
+    compiler_type = 'mingw32'
+
+    def __init__(self, verbose=False, dry_run=False, force=False):
+        super().__init__(verbose, dry_run, force)
+
+        shared_option = "-shared"
+
+        if is_cygwincc(self.cc):
+            raise Error('Cygwin gcc cannot be used with --compiler=mingw32')
+
+        self.set_executables(
+            compiler=f'{self.cc} -O -Wall',
+            compiler_so=f'{self.cc} -shared -O -Wall',
+            compiler_so_cxx=f'{self.cxx} -shared -O -Wall',
+            compiler_cxx=f'{self.cxx} -O -Wall',
+            linker_exe=f'{self.cc}',
+            linker_so=f'{self.linker_dll} {shared_option}',
+            linker_exe_cxx=f'{self.cxx}',
+            linker_so_cxx=f'{self.linker_dll_cxx} {shared_option}',
+        )
+
+    def runtime_library_dir_option(self, dir):
+        raise DistutilsPlatformError(_runtime_library_dirs_msg)
+
+
+# Because these compilers aren't configured in Python's pyconfig.h file by
+# default, we should at least warn the user if he is using an unmodified
+# version.
+
+CONFIG_H_OK = "ok"
+CONFIG_H_NOTOK = "not ok"
+CONFIG_H_UNCERTAIN = "uncertain"
+
+
+def check_config_h():
+    """Check if the current Python installation appears amenable to building
+    extensions with GCC.
+
+    Returns a tuple (status, details), where 'status' is one of the following
+    constants:
+
+    - CONFIG_H_OK: all is well, go ahead and compile
+    - CONFIG_H_NOTOK: doesn't look good
+    - CONFIG_H_UNCERTAIN: not sure -- unable to read pyconfig.h
+
+    'details' is a human-readable string explaining the situation.
+
+    Note there are two ways to conclude "OK": either 'sys.version' contains
+    the string "GCC" (implying that this Python was built with GCC), or the
+    installed "pyconfig.h" contains the string "__GNUC__".
+    """
+
+    # XXX since this function also checks sys.version, it's not strictly a
+    # "pyconfig.h" check -- should probably be renamed...
+
+    from distutils import sysconfig
+
+    # if sys.version contains GCC then python was compiled with GCC, and the
+    # pyconfig.h file should be OK
+    if "GCC" in sys.version:
+        return CONFIG_H_OK, "sys.version mentions 'GCC'"
+
+    # Clang would also work
+    if "Clang" in sys.version:
+        return CONFIG_H_OK, "sys.version mentions 'Clang'"
+
+    # let's see if __GNUC__ is mentioned in python.h
+    fn = sysconfig.get_config_h_filename()
+    try:
+        config_h = pathlib.Path(fn).read_text(encoding='utf-8')
+    except OSError as exc:
+        return (CONFIG_H_UNCERTAIN, f"couldn't read '{fn}': {exc.strerror}")
+    else:
+        substring = '__GNUC__'
+        if substring in config_h:
+            code = CONFIG_H_OK
+            mention_inflected = 'mentions'
+        else:
+            code = CONFIG_H_NOTOK
+            mention_inflected = 'does not mention'
+        return code, f"{fn!r} {mention_inflected} {substring!r}"
+
+
+def is_cygwincc(cc):
+    """Try to determine if the compiler that would be used is from cygwin."""
+    out_string = check_output(shlex.split(cc) + ['-dumpmachine'])
+    return out_string.strip().endswith(b'cygwin')
+
+
+get_versions = None
+"""
+A stand-in for the previous get_versions() function to prevent failures
+when monkeypatched. See pypa/setuptools#2969.
+"""
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/compilers/C/errors.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/compilers/C/errors.py
new file mode 100644
index 0000000000000000000000000000000000000000..01328592b2dad80f4d16c55cd9db9829b3c650f1
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/compilers/C/errors.py
@@ -0,0 +1,24 @@
+class Error(Exception):
+    """Some compile/link operation failed."""
+
+
+class PreprocessError(Error):
+    """Failure to preprocess one or more C/C++ files."""
+
+
+class CompileError(Error):
+    """Failure to compile one or more C/C++ source files."""
+
+
+class LibError(Error):
+    """Failure to create a static library from one or more C/C++ object
+    files."""
+
+
+class LinkError(Error):
+    """Failure to link one or more C/C++ object files into an executable
+    or shared library file."""
+
+
+class UnknownFileType(Error):
+    """Attempt to process an unknown file type."""
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/compilers/C/msvc.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/compilers/C/msvc.py
new file mode 100644
index 0000000000000000000000000000000000000000..6db062a9e714d0a95e1550d387abbffe5950547f
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/compilers/C/msvc.py
@@ -0,0 +1,614 @@
+"""distutils._msvccompiler
+
+Contains MSVCCompiler, an implementation of the abstract CCompiler class
+for Microsoft Visual Studio 2015.
+
+This module requires VS 2015 or later.
+"""
+
+# Written by Perry Stoll
+# hacked by Robin Becker and Thomas Heller to do a better job of
+#   finding DevStudio (through the registry)
+# ported to VS 2005 and VS 2008 by Christian Heimes
+# ported to VS 2015 by Steve Dower
+from __future__ import annotations
+
+import contextlib
+import os
+import subprocess
+import unittest.mock as mock
+import warnings
+from collections.abc import Iterable
+
+with contextlib.suppress(ImportError):
+    import winreg
+
+from itertools import count
+
+from ..._log import log
+from ...errors import (
+    DistutilsExecError,
+    DistutilsPlatformError,
+)
+from ...util import get_host_platform, get_platform
+from . import base
+from .base import gen_lib_options
+from .errors import (
+    CompileError,
+    LibError,
+    LinkError,
+)
+
+
+def _find_vc2015():
+    try:
+        key = winreg.OpenKeyEx(
+            winreg.HKEY_LOCAL_MACHINE,
+            r"Software\Microsoft\VisualStudio\SxS\VC7",
+            access=winreg.KEY_READ | winreg.KEY_WOW64_32KEY,
+        )
+    except OSError:
+        log.debug("Visual C++ is not registered")
+        return None, None
+
+    best_version = 0
+    best_dir = None
+    with key:
+        for i in count():
+            try:
+                v, vc_dir, vt = winreg.EnumValue(key, i)
+            except OSError:
+                break
+            if v and vt == winreg.REG_SZ and os.path.isdir(vc_dir):
+                try:
+                    version = int(float(v))
+                except (ValueError, TypeError):
+                    continue
+                if version >= 14 and version > best_version:
+                    best_version, best_dir = version, vc_dir
+    return best_version, best_dir
+
+
+def _find_vc2017():
+    """Returns "15, path" based on the result of invoking vswhere.exe
+    If no install is found, returns "None, None"
+
+    The version is returned to avoid unnecessarily changing the function
+    result. It may be ignored when the path is not None.
+
+    If vswhere.exe is not available, by definition, VS 2017 is not
+    installed.
+    """
+    root = os.environ.get("ProgramFiles(x86)") or os.environ.get("ProgramFiles")
+    if not root:
+        return None, None
+
+    variant = 'arm64' if get_platform() == 'win-arm64' else 'x86.x64'
+    suitable_components = (
+        f"Microsoft.VisualStudio.Component.VC.Tools.{variant}",
+        "Microsoft.VisualStudio.Workload.WDExpress",
+    )
+
+    for component in suitable_components:
+        # Workaround for `-requiresAny` (only available on VS 2017 > 15.6)
+        with contextlib.suppress(
+            subprocess.CalledProcessError, OSError, UnicodeDecodeError
+        ):
+            path = (
+                subprocess.check_output([
+                    os.path.join(
+                        root, "Microsoft Visual Studio", "Installer", "vswhere.exe"
+                    ),
+                    "-latest",
+                    "-prerelease",
+                    "-requires",
+                    component,
+                    "-property",
+                    "installationPath",
+                    "-products",
+                    "*",
+                ])
+                .decode(encoding="mbcs", errors="strict")
+                .strip()
+            )
+
+            path = os.path.join(path, "VC", "Auxiliary", "Build")
+            if os.path.isdir(path):
+                return 15, path
+
+    return None, None  # no suitable component found
+
+
+PLAT_SPEC_TO_RUNTIME = {
+    'x86': 'x86',
+    'x86_amd64': 'x64',
+    'x86_arm': 'arm',
+    'x86_arm64': 'arm64',
+}
+
+
+def _find_vcvarsall(plat_spec):
+    # bpo-38597: Removed vcruntime return value
+    _, best_dir = _find_vc2017()
+
+    if not best_dir:
+        best_version, best_dir = _find_vc2015()
+
+    if not best_dir:
+        log.debug("No suitable Visual C++ version found")
+        return None, None
+
+    vcvarsall = os.path.join(best_dir, "vcvarsall.bat")
+    if not os.path.isfile(vcvarsall):
+        log.debug("%s cannot be found", vcvarsall)
+        return None, None
+
+    return vcvarsall, None
+
+
+def _get_vc_env(plat_spec):
+    if os.getenv("DISTUTILS_USE_SDK"):
+        return {key.lower(): value for key, value in os.environ.items()}
+
+    vcvarsall, _ = _find_vcvarsall(plat_spec)
+    if not vcvarsall:
+        raise DistutilsPlatformError(
+            'Microsoft Visual C++ 14.0 or greater is required. '
+            'Get it with "Microsoft C++ Build Tools": '
+            'https://visualstudio.microsoft.com/visual-cpp-build-tools/'
+        )
+
+    try:
+        out = subprocess.check_output(
+            f'cmd /u /c "{vcvarsall}" {plat_spec} && set',
+            stderr=subprocess.STDOUT,
+        ).decode('utf-16le', errors='replace')
+    except subprocess.CalledProcessError as exc:
+        log.error(exc.output)
+        raise DistutilsPlatformError(f"Error executing {exc.cmd}")
+
+    env = {
+        key.lower(): value
+        for key, _, value in (line.partition('=') for line in out.splitlines())
+        if key and value
+    }
+
+    return env
+
+
+def _find_exe(exe, paths=None):
+    """Return path to an MSVC executable program.
+
+    Tries to find the program in several places: first, one of the
+    MSVC program search paths from the registry; next, the directories
+    in the PATH environment variable.  If any of those work, return an
+    absolute path that is known to exist.  If none of them work, just
+    return the original program name, 'exe'.
+    """
+    if not paths:
+        paths = os.getenv('path').split(os.pathsep)
+    for p in paths:
+        fn = os.path.join(os.path.abspath(p), exe)
+        if os.path.isfile(fn):
+            return fn
+    return exe
+
+
+_vcvars_names = {
+    'win32': 'x86',
+    'win-amd64': 'amd64',
+    'win-arm32': 'arm',
+    'win-arm64': 'arm64',
+}
+
+
+def _get_vcvars_spec(host_platform, platform):
+    """
+    Given a host platform and platform, determine the spec for vcvarsall.
+
+    Uses the native MSVC host if the host platform would need expensive
+    emulation for x86.
+
+    >>> _get_vcvars_spec('win-arm64', 'win32')
+    'arm64_x86'
+    >>> _get_vcvars_spec('win-arm64', 'win-amd64')
+    'arm64_amd64'
+
+    Otherwise, always cross-compile from x86 to work with the
+    lighter-weight MSVC installs that do not include native 64-bit tools.
+
+    >>> _get_vcvars_spec('win32', 'win32')
+    'x86'
+    >>> _get_vcvars_spec('win-arm32', 'win-arm32')
+    'x86_arm'
+    >>> _get_vcvars_spec('win-amd64', 'win-arm64')
+    'x86_arm64'
+    """
+    if host_platform != 'win-arm64':
+        host_platform = 'win32'
+    vc_hp = _vcvars_names[host_platform]
+    vc_plat = _vcvars_names[platform]
+    return vc_hp if vc_hp == vc_plat else f'{vc_hp}_{vc_plat}'
+
+
+class Compiler(base.Compiler):
+    """Concrete class that implements an interface to Microsoft Visual C++,
+    as defined by the CCompiler abstract class."""
+
+    compiler_type = 'msvc'
+
+    # Just set this so CCompiler's constructor doesn't barf.  We currently
+    # don't use the 'set_executables()' bureaucracy provided by CCompiler,
+    # as it really isn't necessary for this sort of single-compiler class.
+    # Would be nice to have a consistent interface with UnixCCompiler,
+    # though, so it's worth thinking about.
+    executables = {}
+
+    # Private class data (need to distinguish C from C++ source for compiler)
+    _c_extensions = ['.c']
+    _cpp_extensions = ['.cc', '.cpp', '.cxx']
+    _rc_extensions = ['.rc']
+    _mc_extensions = ['.mc']
+
+    # Needed for the filename generation methods provided by the
+    # base class, CCompiler.
+    src_extensions = _c_extensions + _cpp_extensions + _rc_extensions + _mc_extensions
+    res_extension = '.res'
+    obj_extension = '.obj'
+    static_lib_extension = '.lib'
+    shared_lib_extension = '.dll'
+    static_lib_format = shared_lib_format = '%s%s'
+    exe_extension = '.exe'
+
+    def __init__(self, verbose=False, dry_run=False, force=False) -> None:
+        super().__init__(verbose, dry_run, force)
+        # target platform (.plat_name is consistent with 'bdist')
+        self.plat_name = None
+        self.initialized = False
+
+    @classmethod
+    def _configure(cls, vc_env):
+        """
+        Set class-level include/lib dirs.
+        """
+        cls.include_dirs = cls._parse_path(vc_env.get('include', ''))
+        cls.library_dirs = cls._parse_path(vc_env.get('lib', ''))
+
+    @staticmethod
+    def _parse_path(val):
+        return [dir.rstrip(os.sep) for dir in val.split(os.pathsep) if dir]
+
+    def initialize(self, plat_name: str | None = None) -> None:
+        # multi-init means we would need to check platform same each time...
+        assert not self.initialized, "don't init multiple times"
+        if plat_name is None:
+            plat_name = get_platform()
+        # sanity check for platforms to prevent obscure errors later.
+        if plat_name not in _vcvars_names:
+            raise DistutilsPlatformError(
+                f"--plat-name must be one of {tuple(_vcvars_names)}"
+            )
+
+        plat_spec = _get_vcvars_spec(get_host_platform(), plat_name)
+
+        vc_env = _get_vc_env(plat_spec)
+        if not vc_env:
+            raise DistutilsPlatformError(
+                "Unable to find a compatible Visual Studio installation."
+            )
+        self._configure(vc_env)
+
+        self._paths = vc_env.get('path', '')
+        paths = self._paths.split(os.pathsep)
+        self.cc = _find_exe("cl.exe", paths)
+        self.linker = _find_exe("link.exe", paths)
+        self.lib = _find_exe("lib.exe", paths)
+        self.rc = _find_exe("rc.exe", paths)  # resource compiler
+        self.mc = _find_exe("mc.exe", paths)  # message compiler
+        self.mt = _find_exe("mt.exe", paths)  # message compiler
+
+        self.preprocess_options = None
+        # bpo-38597: Always compile with dynamic linking
+        # Future releases of Python 3.x will include all past
+        # versions of vcruntime*.dll for compatibility.
+        self.compile_options = ['/nologo', '/O2', '/W3', '/GL', '/DNDEBUG', '/MD']
+
+        self.compile_options_debug = [
+            '/nologo',
+            '/Od',
+            '/MDd',
+            '/Zi',
+            '/W3',
+            '/D_DEBUG',
+        ]
+
+        ldflags = ['/nologo', '/INCREMENTAL:NO', '/LTCG']
+
+        ldflags_debug = ['/nologo', '/INCREMENTAL:NO', '/LTCG', '/DEBUG:FULL']
+
+        self.ldflags_exe = [*ldflags, '/MANIFEST:EMBED,ID=1']
+        self.ldflags_exe_debug = [*ldflags_debug, '/MANIFEST:EMBED,ID=1']
+        self.ldflags_shared = [
+            *ldflags,
+            '/DLL',
+            '/MANIFEST:EMBED,ID=2',
+            '/MANIFESTUAC:NO',
+        ]
+        self.ldflags_shared_debug = [
+            *ldflags_debug,
+            '/DLL',
+            '/MANIFEST:EMBED,ID=2',
+            '/MANIFESTUAC:NO',
+        ]
+        self.ldflags_static = [*ldflags]
+        self.ldflags_static_debug = [*ldflags_debug]
+
+        self._ldflags = {
+            (base.Compiler.EXECUTABLE, None): self.ldflags_exe,
+            (base.Compiler.EXECUTABLE, False): self.ldflags_exe,
+            (base.Compiler.EXECUTABLE, True): self.ldflags_exe_debug,
+            (base.Compiler.SHARED_OBJECT, None): self.ldflags_shared,
+            (base.Compiler.SHARED_OBJECT, False): self.ldflags_shared,
+            (base.Compiler.SHARED_OBJECT, True): self.ldflags_shared_debug,
+            (base.Compiler.SHARED_LIBRARY, None): self.ldflags_static,
+            (base.Compiler.SHARED_LIBRARY, False): self.ldflags_static,
+            (base.Compiler.SHARED_LIBRARY, True): self.ldflags_static_debug,
+        }
+
+        self.initialized = True
+
+    # -- Worker methods ------------------------------------------------
+
+    @property
+    def out_extensions(self) -> dict[str, str]:
+        return {
+            **super().out_extensions,
+            **{
+                ext: self.res_extension
+                for ext in self._rc_extensions + self._mc_extensions
+            },
+        }
+
+    def compile(  # noqa: C901
+        self,
+        sources,
+        output_dir=None,
+        macros=None,
+        include_dirs=None,
+        debug=False,
+        extra_preargs=None,
+        extra_postargs=None,
+        depends=None,
+    ):
+        if not self.initialized:
+            self.initialize()
+        compile_info = self._setup_compile(
+            output_dir, macros, include_dirs, sources, depends, extra_postargs
+        )
+        macros, objects, extra_postargs, pp_opts, build = compile_info
+
+        compile_opts = extra_preargs or []
+        compile_opts.append('/c')
+        if debug:
+            compile_opts.extend(self.compile_options_debug)
+        else:
+            compile_opts.extend(self.compile_options)
+
+        add_cpp_opts = False
+
+        for obj in objects:
+            try:
+                src, ext = build[obj]
+            except KeyError:
+                continue
+            if debug:
+                # pass the full pathname to MSVC in debug mode,
+                # this allows the debugger to find the source file
+                # without asking the user to browse for it
+                src = os.path.abspath(src)
+
+            if ext in self._c_extensions:
+                input_opt = f"/Tc{src}"
+            elif ext in self._cpp_extensions:
+                input_opt = f"/Tp{src}"
+                add_cpp_opts = True
+            elif ext in self._rc_extensions:
+                # compile .RC to .RES file
+                input_opt = src
+                output_opt = "/fo" + obj
+                try:
+                    self.spawn([self.rc] + pp_opts + [output_opt, input_opt])
+                except DistutilsExecError as msg:
+                    raise CompileError(msg)
+                continue
+            elif ext in self._mc_extensions:
+                # Compile .MC to .RC file to .RES file.
+                #   * '-h dir' specifies the directory for the
+                #     generated include file
+                #   * '-r dir' specifies the target directory of the
+                #     generated RC file and the binary message resource
+                #     it includes
+                #
+                # For now (since there are no options to change this),
+                # we use the source-directory for the include file and
+                # the build directory for the RC file and message
+                # resources. This works at least for win32all.
+                h_dir = os.path.dirname(src)
+                rc_dir = os.path.dirname(obj)
+                try:
+                    # first compile .MC to .RC and .H file
+                    self.spawn([self.mc, '-h', h_dir, '-r', rc_dir, src])
+                    base, _ = os.path.splitext(os.path.basename(src))
+                    rc_file = os.path.join(rc_dir, base + '.rc')
+                    # then compile .RC to .RES file
+                    self.spawn([self.rc, "/fo" + obj, rc_file])
+
+                except DistutilsExecError as msg:
+                    raise CompileError(msg)
+                continue
+            else:
+                # how to handle this file?
+                raise CompileError(f"Don't know how to compile {src} to {obj}")
+
+            args = [self.cc] + compile_opts + pp_opts
+            if add_cpp_opts:
+                args.append('/EHsc')
+            args.extend((input_opt, "/Fo" + obj))
+            args.extend(extra_postargs)
+
+            try:
+                self.spawn(args)
+            except DistutilsExecError as msg:
+                raise CompileError(msg)
+
+        return objects
+
+    def create_static_lib(
+        self,
+        objects: list[str] | tuple[str, ...],
+        output_libname: str,
+        output_dir: str | None = None,
+        debug: bool = False,
+        target_lang: str | None = None,
+    ) -> None:
+        if not self.initialized:
+            self.initialize()
+        objects, output_dir = self._fix_object_args(objects, output_dir)
+        output_filename = self.library_filename(output_libname, output_dir=output_dir)
+
+        if self._need_link(objects, output_filename):
+            lib_args = objects + ['/OUT:' + output_filename]
+            if debug:
+                pass  # XXX what goes here?
+            try:
+                log.debug('Executing "%s" %s', self.lib, ' '.join(lib_args))
+                self.spawn([self.lib] + lib_args)
+            except DistutilsExecError as msg:
+                raise LibError(msg)
+        else:
+            log.debug("skipping %s (up-to-date)", output_filename)
+
+    def link(
+        self,
+        target_desc: str,
+        objects: list[str] | tuple[str, ...],
+        output_filename: str,
+        output_dir: str | None = None,
+        libraries: list[str] | tuple[str, ...] | None = None,
+        library_dirs: list[str] | tuple[str, ...] | None = None,
+        runtime_library_dirs: list[str] | tuple[str, ...] | None = None,
+        export_symbols: Iterable[str] | None = None,
+        debug: bool = False,
+        extra_preargs: list[str] | None = None,
+        extra_postargs: Iterable[str] | None = None,
+        build_temp: str | os.PathLike[str] | None = None,
+        target_lang: str | None = None,
+    ) -> None:
+        if not self.initialized:
+            self.initialize()
+        objects, output_dir = self._fix_object_args(objects, output_dir)
+        fixed_args = self._fix_lib_args(libraries, library_dirs, runtime_library_dirs)
+        libraries, library_dirs, runtime_library_dirs = fixed_args
+
+        if runtime_library_dirs:
+            self.warn(
+                "I don't know what to do with 'runtime_library_dirs': "
+                + str(runtime_library_dirs)
+            )
+
+        lib_opts = gen_lib_options(self, library_dirs, runtime_library_dirs, libraries)
+        if output_dir is not None:
+            output_filename = os.path.join(output_dir, output_filename)
+
+        if self._need_link(objects, output_filename):
+            ldflags = self._ldflags[target_desc, debug]
+
+            export_opts = ["/EXPORT:" + sym for sym in (export_symbols or [])]
+
+            ld_args = (
+                ldflags + lib_opts + export_opts + objects + ['/OUT:' + output_filename]
+            )
+
+            # The MSVC linker generates .lib and .exp files, which cannot be
+            # suppressed by any linker switches. The .lib files may even be
+            # needed! Make sure they are generated in the temporary build
+            # directory. Since they have different names for debug and release
+            # builds, they can go into the same directory.
+            build_temp = os.path.dirname(objects[0])
+            if export_symbols is not None:
+                (dll_name, dll_ext) = os.path.splitext(
+                    os.path.basename(output_filename)
+                )
+                implib_file = os.path.join(build_temp, self.library_filename(dll_name))
+                ld_args.append('/IMPLIB:' + implib_file)
+
+            if extra_preargs:
+                ld_args[:0] = extra_preargs
+            if extra_postargs:
+                ld_args.extend(extra_postargs)
+
+            output_dir = os.path.dirname(os.path.abspath(output_filename))
+            self.mkpath(output_dir)
+            try:
+                log.debug('Executing "%s" %s', self.linker, ' '.join(ld_args))
+                self.spawn([self.linker] + ld_args)
+            except DistutilsExecError as msg:
+                raise LinkError(msg)
+        else:
+            log.debug("skipping %s (up-to-date)", output_filename)
+
+    def spawn(self, cmd):
+        env = dict(os.environ, PATH=self._paths)
+        with self._fallback_spawn(cmd, env) as fallback:
+            return super().spawn(cmd, env=env)
+        return fallback.value
+
+    @contextlib.contextmanager
+    def _fallback_spawn(self, cmd, env):
+        """
+        Discovered in pypa/distutils#15, some tools monkeypatch the compiler,
+        so the 'env' kwarg causes a TypeError. Detect this condition and
+        restore the legacy, unsafe behavior.
+        """
+        bag = type('Bag', (), {})()
+        try:
+            yield bag
+        except TypeError as exc:
+            if "unexpected keyword argument 'env'" not in str(exc):
+                raise
+        else:
+            return
+        warnings.warn("Fallback spawn triggered. Please update distutils monkeypatch.")
+        with mock.patch.dict('os.environ', env):
+            bag.value = super().spawn(cmd)
+
+    # -- Miscellaneous methods -----------------------------------------
+    # These are all used by the 'gen_lib_options() function, in
+    # ccompiler.py.
+
+    def library_dir_option(self, dir):
+        return "/LIBPATH:" + dir
+
+    def runtime_library_dir_option(self, dir):
+        raise DistutilsPlatformError(
+            "don't know how to set runtime library search path for MSVC"
+        )
+
+    def library_option(self, lib):
+        return self.library_filename(lib)
+
+    def find_library_file(self, dirs, lib, debug=False):
+        # Prefer a debugging library if found (and requested), but deal
+        # with it if we don't have one.
+        if debug:
+            try_names = [lib + "_d", lib]
+        else:
+            try_names = [lib]
+        for dir in dirs:
+            for name in try_names:
+                libfile = os.path.join(dir, self.library_filename(name))
+                if os.path.isfile(libfile):
+                    return libfile
+        else:
+            # Oops, didn't find it in *any* of 'dirs'
+            return None
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/compilers/C/tests/__pycache__/test_base.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/compilers/C/tests/__pycache__/test_base.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..752a896c5dc8a459ba9cd40df90a3120294cd882
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/compilers/C/tests/__pycache__/test_base.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/compilers/C/tests/__pycache__/test_cygwin.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/compilers/C/tests/__pycache__/test_cygwin.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..3a499d57fe5f83b05d235e2461b6bbe236976fb0
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/compilers/C/tests/__pycache__/test_cygwin.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/compilers/C/tests/__pycache__/test_mingw.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/compilers/C/tests/__pycache__/test_mingw.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d3544723afe7322741a4fd4365a19bd7adc2304f
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/compilers/C/tests/__pycache__/test_mingw.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/compilers/C/tests/__pycache__/test_msvc.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/compilers/C/tests/__pycache__/test_msvc.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..3ba82e145c2d0a8e9b626b06f9727a981b3a09a8
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/compilers/C/tests/__pycache__/test_msvc.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/compilers/C/tests/__pycache__/test_unix.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/compilers/C/tests/__pycache__/test_unix.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..1bbc21aaac1110b6618d3df09b7056fcae876c68
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/compilers/C/tests/__pycache__/test_unix.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/compilers/C/tests/test_base.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/compilers/C/tests/test_base.py
new file mode 100644
index 0000000000000000000000000000000000000000..a762e2b649d7977ef42f4d35854eab26bd54e9e7
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/compilers/C/tests/test_base.py
@@ -0,0 +1,83 @@
+import platform
+import sysconfig
+import textwrap
+
+import pytest
+
+from .. import base
+
+pytestmark = pytest.mark.usefixtures('suppress_path_mangle')
+
+
+@pytest.fixture
+def c_file(tmp_path):
+    c_file = tmp_path / 'foo.c'
+    gen_headers = ('Python.h',)
+    is_windows = platform.system() == "Windows"
+    plat_headers = ('windows.h',) * is_windows
+    all_headers = gen_headers + plat_headers
+    headers = '\n'.join(f'#include <{header}>\n' for header in all_headers)
+    payload = (
+        textwrap.dedent(
+            """
+        #headers
+        void PyInit_foo(void) {}
+        """
+        )
+        .lstrip()
+        .replace('#headers', headers)
+    )
+    c_file.write_text(payload, encoding='utf-8')
+    return c_file
+
+
+def test_set_include_dirs(c_file):
+    """
+    Extensions should build even if set_include_dirs is invoked.
+    In particular, compiler-specific paths should not be overridden.
+    """
+    compiler = base.new_compiler()
+    python = sysconfig.get_paths()['include']
+    compiler.set_include_dirs([python])
+    compiler.compile([c_file])
+
+    # do it again, setting include dirs after any initialization
+    compiler.set_include_dirs([python])
+    compiler.compile([c_file])
+
+
+def test_has_function_prototype():
+    # Issue https://github.com/pypa/setuptools/issues/3648
+    # Test prototype-generating behavior.
+
+    compiler = base.new_compiler()
+
+    # Every C implementation should have these.
+    assert compiler.has_function('abort')
+    assert compiler.has_function('exit')
+    with pytest.deprecated_call(match='includes is deprecated'):
+        # abort() is a valid expression with the <stdlib.h> prototype.
+        assert compiler.has_function('abort', includes=['stdlib.h'])
+    with pytest.deprecated_call(match='includes is deprecated'):
+        # But exit() is not valid with the actual prototype in scope.
+        assert not compiler.has_function('exit', includes=['stdlib.h'])
+    # And setuptools_does_not_exist is not declared or defined at all.
+    assert not compiler.has_function('setuptools_does_not_exist')
+    with pytest.deprecated_call(match='includes is deprecated'):
+        assert not compiler.has_function(
+            'setuptools_does_not_exist', includes=['stdio.h']
+        )
+
+
+def test_include_dirs_after_multiple_compile_calls(c_file):
+    """
+    Calling compile multiple times should not change the include dirs
+    (regression test for setuptools issue #3591).
+    """
+    compiler = base.new_compiler()
+    python = sysconfig.get_paths()['include']
+    compiler.set_include_dirs([python])
+    compiler.compile([c_file])
+    assert compiler.include_dirs == [python]
+    compiler.compile([c_file])
+    assert compiler.include_dirs == [python]
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/compilers/C/tests/test_cygwin.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/compilers/C/tests/test_cygwin.py
new file mode 100644
index 0000000000000000000000000000000000000000..9adf6b8ebf165b4fe92a52d8a14aed21aebba539
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/compilers/C/tests/test_cygwin.py
@@ -0,0 +1,76 @@
+"""Tests for distutils.cygwinccompiler."""
+
+import os
+import sys
+from distutils import sysconfig
+from distutils.tests import support
+
+import pytest
+
+from .. import cygwin
+
+
+@pytest.fixture(autouse=True)
+def stuff(request, monkeypatch, distutils_managed_tempdir):
+    self = request.instance
+    self.python_h = os.path.join(self.mkdtemp(), 'python.h')
+    monkeypatch.setattr(sysconfig, 'get_config_h_filename', self._get_config_h_filename)
+    monkeypatch.setattr(sys, 'version', sys.version)
+
+
+class TestCygwinCCompiler(support.TempdirManager):
+    def _get_config_h_filename(self):
+        return self.python_h
+
+    @pytest.mark.skipif('sys.platform != "cygwin"')
+    @pytest.mark.skipif('not os.path.exists("/usr/lib/libbash.dll.a")')
+    def test_find_library_file(self):
+        from distutils.cygwinccompiler import CygwinCCompiler
+
+        compiler = CygwinCCompiler()
+        link_name = "bash"
+        linkable_file = compiler.find_library_file(["/usr/lib"], link_name)
+        assert linkable_file is not None
+        assert os.path.exists(linkable_file)
+        assert linkable_file == f"/usr/lib/lib{link_name:s}.dll.a"
+
+    @pytest.mark.skipif('sys.platform != "cygwin"')
+    def test_runtime_library_dir_option(self):
+        from distutils.cygwinccompiler import CygwinCCompiler
+
+        compiler = CygwinCCompiler()
+        assert compiler.runtime_library_dir_option('/foo') == []
+
+    def test_check_config_h(self):
+        # check_config_h looks for "GCC" in sys.version first
+        # returns CONFIG_H_OK if found
+        sys.version = (
+            '2.6.1 (r261:67515, Dec  6 2008, 16:42:21) \n[GCC '
+            '4.0.1 (Apple Computer, Inc. build 5370)]'
+        )
+
+        assert cygwin.check_config_h()[0] == cygwin.CONFIG_H_OK
+
+        # then it tries to see if it can find "__GNUC__" in pyconfig.h
+        sys.version = 'something without the *CC word'
+
+        # if the file doesn't exist it returns  CONFIG_H_UNCERTAIN
+        assert cygwin.check_config_h()[0] == cygwin.CONFIG_H_UNCERTAIN
+
+        # if it exists but does not contain __GNUC__, it returns CONFIG_H_NOTOK
+        self.write_file(self.python_h, 'xxx')
+        assert cygwin.check_config_h()[0] == cygwin.CONFIG_H_NOTOK
+
+        # and CONFIG_H_OK if __GNUC__ is found
+        self.write_file(self.python_h, 'xxx __GNUC__ xxx')
+        assert cygwin.check_config_h()[0] == cygwin.CONFIG_H_OK
+
+    def test_get_msvcr(self):
+        assert cygwin.get_msvcr() == []
+
+    @pytest.mark.skipif('sys.platform != "cygwin"')
+    def test_dll_libraries_not_none(self):
+        from distutils.cygwinccompiler import CygwinCCompiler
+
+        compiler = CygwinCCompiler()
+        assert compiler.dll_libraries is not None
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/compilers/C/tests/test_mingw.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/compilers/C/tests/test_mingw.py
new file mode 100644
index 0000000000000000000000000000000000000000..dc45687a917808edbf692ced18b0c99183d21e2d
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/compilers/C/tests/test_mingw.py
@@ -0,0 +1,48 @@
+from distutils import sysconfig
+from distutils.errors import DistutilsPlatformError
+from distutils.util import is_mingw, split_quoted
+
+import pytest
+
+from .. import cygwin, errors
+
+
+class TestMinGW32Compiler:
+    @pytest.mark.skipif(not is_mingw(), reason='not on mingw')
+    def test_compiler_type(self):
+        compiler = cygwin.MinGW32Compiler()
+        assert compiler.compiler_type == 'mingw32'
+
+    @pytest.mark.skipif(not is_mingw(), reason='not on mingw')
+    def test_set_executables(self, monkeypatch):
+        monkeypatch.setenv('CC', 'cc')
+        monkeypatch.setenv('CXX', 'c++')
+
+        compiler = cygwin.MinGW32Compiler()
+
+        assert compiler.compiler == split_quoted('cc -O -Wall')
+        assert compiler.compiler_so == split_quoted('cc -shared -O -Wall')
+        assert compiler.compiler_cxx == split_quoted('c++ -O -Wall')
+        assert compiler.linker_exe == split_quoted('cc')
+        assert compiler.linker_so == split_quoted('cc -shared')
+
+    @pytest.mark.skipif(not is_mingw(), reason='not on mingw')
+    def test_runtime_library_dir_option(self):
+        compiler = cygwin.MinGW32Compiler()
+        with pytest.raises(DistutilsPlatformError):
+            compiler.runtime_library_dir_option('/usr/lib')
+
+    @pytest.mark.skipif(not is_mingw(), reason='not on mingw')
+    def test_cygwincc_error(self, monkeypatch):
+        monkeypatch.setattr(cygwin, 'is_cygwincc', lambda _: True)
+
+        with pytest.raises(errors.Error):
+            cygwin.MinGW32Compiler()
+
+    @pytest.mark.skipif('sys.platform == "cygwin"')
+    def test_customize_compiler_with_msvc_python(self):
+        # In case we have an MSVC Python build, but still want to use
+        # MinGW32Compiler, then customize_compiler() shouldn't fail at least.
+        # https://github.com/pypa/setuptools/issues/4456
+        compiler = cygwin.MinGW32Compiler()
+        sysconfig.customize_compiler(compiler)
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/compilers/C/tests/test_msvc.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/compilers/C/tests/test_msvc.py
new file mode 100644
index 0000000000000000000000000000000000000000..eca831996adcb07f05560581fe4285cdb29392d3
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/compilers/C/tests/test_msvc.py
@@ -0,0 +1,136 @@
+import os
+import sys
+import sysconfig
+import threading
+import unittest.mock as mock
+from distutils.errors import DistutilsPlatformError
+from distutils.tests import support
+from distutils.util import get_platform
+
+import pytest
+
+from .. import msvc
+
+needs_winreg = pytest.mark.skipif('not hasattr(msvc, "winreg")')
+
+
+class Testmsvccompiler(support.TempdirManager):
+    def test_no_compiler(self, monkeypatch):
+        # makes sure query_vcvarsall raises
+        # a DistutilsPlatformError if the compiler
+        # is not found
+        def _find_vcvarsall(plat_spec):
+            return None, None
+
+        monkeypatch.setattr(msvc, '_find_vcvarsall', _find_vcvarsall)
+
+        with pytest.raises(DistutilsPlatformError):
+            msvc._get_vc_env(
+                'wont find this version',
+            )
+
+    @pytest.mark.skipif(
+        not sysconfig.get_platform().startswith("win"),
+        reason="Only run test for non-mingw Windows platforms",
+    )
+    @pytest.mark.parametrize(
+        "plat_name, expected",
+        [
+            ("win-arm64", "win-arm64"),
+            ("win-amd64", "win-amd64"),
+            (None, get_platform()),
+        ],
+    )
+    def test_cross_platform_compilation_paths(self, monkeypatch, plat_name, expected):
+        """
+        Ensure a specified target platform is passed to _get_vcvars_spec.
+        """
+        compiler = msvc.Compiler()
+
+        def _get_vcvars_spec(host_platform, platform):
+            assert platform == expected
+
+        monkeypatch.setattr(msvc, '_get_vcvars_spec', _get_vcvars_spec)
+        compiler.initialize(plat_name)
+
+    @needs_winreg
+    def test_get_vc_env_unicode(self):
+        test_var = 'ṰḖṤṪ┅ṼẨṜ'
+        test_value = '₃⁴₅'
+
+        # Ensure we don't early exit from _get_vc_env
+        old_distutils_use_sdk = os.environ.pop('DISTUTILS_USE_SDK', None)
+        os.environ[test_var] = test_value
+        try:
+            env = msvc._get_vc_env('x86')
+            assert test_var.lower() in env
+            assert test_value == env[test_var.lower()]
+        finally:
+            os.environ.pop(test_var)
+            if old_distutils_use_sdk:
+                os.environ['DISTUTILS_USE_SDK'] = old_distutils_use_sdk
+
+    @needs_winreg
+    @pytest.mark.parametrize('ver', (2015, 2017))
+    def test_get_vc(self, ver):
+        # This function cannot be mocked, so pass if VC is found
+        # and skip otherwise.
+        lookup = getattr(msvc, f'_find_vc{ver}')
+        expected_version = {2015: 14, 2017: 15}[ver]
+        version, path = lookup()
+        if not version:
+            pytest.skip(f"VS {ver} is not installed")
+        assert version >= expected_version
+        assert os.path.isdir(path)
+
+
+class CheckThread(threading.Thread):
+    exc_info = None
+
+    def run(self):
+        try:
+            super().run()
+        except Exception:
+            self.exc_info = sys.exc_info()
+
+    def __bool__(self):
+        return not self.exc_info
+
+
+class TestSpawn:
+    def test_concurrent_safe(self):
+        """
+        Concurrent calls to spawn should have consistent results.
+        """
+        compiler = msvc.Compiler()
+        compiler._paths = "expected"
+        inner_cmd = 'import os; assert os.environ["PATH"] == "expected"'
+        command = [sys.executable, '-c', inner_cmd]
+
+        threads = [
+            CheckThread(target=compiler.spawn, args=[command]) for n in range(100)
+        ]
+        for thread in threads:
+            thread.start()
+        for thread in threads:
+            thread.join()
+        assert all(threads)
+
+    def test_concurrent_safe_fallback(self):
+        """
+        If CCompiler.spawn has been monkey-patched without support
+        for an env, it should still execute.
+        """
+        from distutils import ccompiler
+
+        compiler = msvc.Compiler()
+        compiler._paths = "expected"
+
+        def CCompiler_spawn(self, cmd):
+            "A spawn without an env argument."
+            assert os.environ["PATH"] == "expected"
+
+        with mock.patch.object(ccompiler.CCompiler, 'spawn', CCompiler_spawn):
+            compiler.spawn(["n/a"])
+
+        assert os.environ.get("PATH") != "expected"
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/compilers/C/tests/test_unix.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/compilers/C/tests/test_unix.py
new file mode 100644
index 0000000000000000000000000000000000000000..35b6b0e050c654bd9eff711ec3b94bea9adff2af
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/compilers/C/tests/test_unix.py
@@ -0,0 +1,413 @@
+"""Tests for distutils.unixccompiler."""
+
+import os
+import sys
+import unittest.mock as mock
+from distutils import sysconfig
+from distutils.compat import consolidate_linker_args
+from distutils.errors import DistutilsPlatformError
+from distutils.tests import support
+from distutils.tests.compat.py39 import EnvironmentVarGuard
+from distutils.util import _clear_cached_macosx_ver
+
+import pytest
+
+from .. import unix
+
+
+@pytest.fixture(autouse=True)
+def save_values(monkeypatch):
+    monkeypatch.setattr(sys, 'platform', sys.platform)
+    monkeypatch.setattr(sysconfig, 'get_config_var', sysconfig.get_config_var)
+    monkeypatch.setattr(sysconfig, 'get_config_vars', sysconfig.get_config_vars)
+
+
+@pytest.fixture(autouse=True)
+def compiler_wrapper(request):
+    class CompilerWrapper(unix.Compiler):
+        def rpath_foo(self):
+            return self.runtime_library_dir_option('/foo')
+
+    request.instance.cc = CompilerWrapper()
+
+
+class TestUnixCCompiler(support.TempdirManager):
+    @pytest.mark.skipif('platform.system == "Windows"')
+    def test_runtime_libdir_option(self):  # noqa: C901
+        # Issue #5900; GitHub Issue #37
+        #
+        # Ensure RUNPATH is added to extension modules with RPATH if
+        # GNU ld is used
+
+        # darwin
+        sys.platform = 'darwin'
+        darwin_ver_var = 'MACOSX_DEPLOYMENT_TARGET'
+        darwin_rpath_flag = '-Wl,-rpath,/foo'
+        darwin_lib_flag = '-L/foo'
+
+        # (macOS version from syscfg, macOS version from env var) -> flag
+        # Version value of None generates two tests: as None and as empty string
+        # Expected flag value of None means an mismatch exception is expected
+        darwin_test_cases = [
+            ((None, None), darwin_lib_flag),
+            ((None, '11'), darwin_rpath_flag),
+            (('10', None), darwin_lib_flag),
+            (('10.3', None), darwin_lib_flag),
+            (('10.3.1', None), darwin_lib_flag),
+            (('10.5', None), darwin_rpath_flag),
+            (('10.5.1', None), darwin_rpath_flag),
+            (('10.3', '10.3'), darwin_lib_flag),
+            (('10.3', '10.5'), darwin_rpath_flag),
+            (('10.5', '10.3'), darwin_lib_flag),
+            (('10.5', '11'), darwin_rpath_flag),
+            (('10.4', '10'), None),
+        ]
+
+        def make_darwin_gcv(syscfg_macosx_ver):
+            def gcv(var):
+                if var == darwin_ver_var:
+                    return syscfg_macosx_ver
+                return "xxx"
+
+            return gcv
+
+        def do_darwin_test(syscfg_macosx_ver, env_macosx_ver, expected_flag):
+            env = os.environ
+            msg = f"macOS version = (sysconfig={syscfg_macosx_ver!r}, env={env_macosx_ver!r})"
+
+            # Save
+            old_gcv = sysconfig.get_config_var
+            old_env_macosx_ver = env.get(darwin_ver_var)
+
+            # Setup environment
+            _clear_cached_macosx_ver()
+            sysconfig.get_config_var = make_darwin_gcv(syscfg_macosx_ver)
+            if env_macosx_ver is not None:
+                env[darwin_ver_var] = env_macosx_ver
+            elif darwin_ver_var in env:
+                env.pop(darwin_ver_var)
+
+            # Run the test
+            if expected_flag is not None:
+                assert self.cc.rpath_foo() == expected_flag, msg
+            else:
+                with pytest.raises(
+                    DistutilsPlatformError, match=darwin_ver_var + r' mismatch'
+                ):
+                    self.cc.rpath_foo()
+
+            # Restore
+            if old_env_macosx_ver is not None:
+                env[darwin_ver_var] = old_env_macosx_ver
+            elif darwin_ver_var in env:
+                env.pop(darwin_ver_var)
+            sysconfig.get_config_var = old_gcv
+            _clear_cached_macosx_ver()
+
+        for macosx_vers, expected_flag in darwin_test_cases:
+            syscfg_macosx_ver, env_macosx_ver = macosx_vers
+            do_darwin_test(syscfg_macosx_ver, env_macosx_ver, expected_flag)
+            # Bonus test cases with None interpreted as empty string
+            if syscfg_macosx_ver is None:
+                do_darwin_test("", env_macosx_ver, expected_flag)
+            if env_macosx_ver is None:
+                do_darwin_test(syscfg_macosx_ver, "", expected_flag)
+            if syscfg_macosx_ver is None and env_macosx_ver is None:
+                do_darwin_test("", "", expected_flag)
+
+        old_gcv = sysconfig.get_config_var
+
+        # hp-ux
+        sys.platform = 'hp-ux'
+
+        def gcv(v):
+            return 'xxx'
+
+        sysconfig.get_config_var = gcv
+        assert self.cc.rpath_foo() == ['+s', '-L/foo']
+
+        def gcv(v):
+            return 'gcc'
+
+        sysconfig.get_config_var = gcv
+        assert self.cc.rpath_foo() == ['-Wl,+s', '-L/foo']
+
+        def gcv(v):
+            return 'g++'
+
+        sysconfig.get_config_var = gcv
+        assert self.cc.rpath_foo() == ['-Wl,+s', '-L/foo']
+
+        sysconfig.get_config_var = old_gcv
+
+        # GCC GNULD
+        sys.platform = 'bar'
+
+        def gcv(v):
+            if v == 'CC':
+                return 'gcc'
+            elif v == 'GNULD':
+                return 'yes'
+
+        sysconfig.get_config_var = gcv
+        assert self.cc.rpath_foo() == consolidate_linker_args([
+            '-Wl,--enable-new-dtags',
+            '-Wl,-rpath,/foo',
+        ])
+
+        def gcv(v):
+            if v == 'CC':
+                return 'gcc -pthread -B /bar'
+            elif v == 'GNULD':
+                return 'yes'
+
+        sysconfig.get_config_var = gcv
+        assert self.cc.rpath_foo() == consolidate_linker_args([
+            '-Wl,--enable-new-dtags',
+            '-Wl,-rpath,/foo',
+        ])
+
+        # GCC non-GNULD
+        sys.platform = 'bar'
+
+        def gcv(v):
+            if v == 'CC':
+                return 'gcc'
+            elif v == 'GNULD':
+                return 'no'
+
+        sysconfig.get_config_var = gcv
+        assert self.cc.rpath_foo() == '-Wl,-R/foo'
+
+        # GCC GNULD with fully qualified configuration prefix
+        # see #7617
+        sys.platform = 'bar'
+
+        def gcv(v):
+            if v == 'CC':
+                return 'x86_64-pc-linux-gnu-gcc-4.4.2'
+            elif v == 'GNULD':
+                return 'yes'
+
+        sysconfig.get_config_var = gcv
+        assert self.cc.rpath_foo() == consolidate_linker_args([
+            '-Wl,--enable-new-dtags',
+            '-Wl,-rpath,/foo',
+        ])
+
+        # non-GCC GNULD
+        sys.platform = 'bar'
+
+        def gcv(v):
+            if v == 'CC':
+                return 'cc'
+            elif v == 'GNULD':
+                return 'yes'
+
+        sysconfig.get_config_var = gcv
+        assert self.cc.rpath_foo() == consolidate_linker_args([
+            '-Wl,--enable-new-dtags',
+            '-Wl,-rpath,/foo',
+        ])
+
+        # non-GCC non-GNULD
+        sys.platform = 'bar'
+
+        def gcv(v):
+            if v == 'CC':
+                return 'cc'
+            elif v == 'GNULD':
+                return 'no'
+
+        sysconfig.get_config_var = gcv
+        assert self.cc.rpath_foo() == '-Wl,-R/foo'
+
+    @pytest.mark.skipif('platform.system == "Windows"')
+    def test_cc_overrides_ldshared(self):
+        # Issue #18080:
+        # ensure that setting CC env variable also changes default linker
+        def gcv(v):
+            if v == 'LDSHARED':
+                return 'gcc-4.2 -bundle -undefined dynamic_lookup '
+            return 'gcc-4.2'
+
+        def gcvs(*args, _orig=sysconfig.get_config_vars):
+            if args:
+                return list(map(sysconfig.get_config_var, args))
+            return _orig()
+
+        sysconfig.get_config_var = gcv
+        sysconfig.get_config_vars = gcvs
+        with EnvironmentVarGuard() as env:
+            env['CC'] = 'my_cc'
+            del env['LDSHARED']
+            sysconfig.customize_compiler(self.cc)
+        assert self.cc.linker_so[0] == 'my_cc'
+
+    @pytest.mark.skipif('platform.system == "Windows"')
+    def test_cxx_commands_used_are_correct(self):
+        def gcv(v):
+            if v == 'LDSHARED':
+                return 'ccache gcc-4.2 -bundle -undefined dynamic_lookup'
+            elif v == 'LDCXXSHARED':
+                return 'ccache g++-4.2 -bundle -undefined dynamic_lookup'
+            elif v == 'CXX':
+                return 'ccache g++-4.2'
+            elif v == 'CC':
+                return 'ccache gcc-4.2'
+            return ''
+
+        def gcvs(*args, _orig=sysconfig.get_config_vars):
+            if args:
+                return list(map(sysconfig.get_config_var, args))
+            return _orig()  # pragma: no cover
+
+        sysconfig.get_config_var = gcv
+        sysconfig.get_config_vars = gcvs
+        with (
+            mock.patch.object(self.cc, 'spawn', return_value=None) as mock_spawn,
+            mock.patch.object(self.cc, '_need_link', return_value=True),
+            mock.patch.object(self.cc, 'mkpath', return_value=None),
+            EnvironmentVarGuard() as env,
+        ):
+            # override environment overrides in case they're specified by CI
+            del env['CXX']
+            del env['LDCXXSHARED']
+
+            sysconfig.customize_compiler(self.cc)
+            assert self.cc.linker_so_cxx[0:2] == ['ccache', 'g++-4.2']
+            assert self.cc.linker_exe_cxx[0:2] == ['ccache', 'g++-4.2']
+            self.cc.link(None, [], 'a.out', target_lang='c++')
+            call_args = mock_spawn.call_args[0][0]
+            expected = ['ccache', 'g++-4.2', '-bundle', '-undefined', 'dynamic_lookup']
+            assert call_args[:5] == expected
+
+            self.cc.link_executable([], 'a.out', target_lang='c++')
+            call_args = mock_spawn.call_args[0][0]
+            expected = ['ccache', 'g++-4.2', '-o', self.cc.executable_filename('a.out')]
+            assert call_args[:4] == expected
+
+            env['LDCXXSHARED'] = 'wrapper g++-4.2 -bundle -undefined dynamic_lookup'
+            env['CXX'] = 'wrapper g++-4.2'
+            sysconfig.customize_compiler(self.cc)
+            assert self.cc.linker_so_cxx[0:2] == ['wrapper', 'g++-4.2']
+            assert self.cc.linker_exe_cxx[0:2] == ['wrapper', 'g++-4.2']
+            self.cc.link(None, [], 'a.out', target_lang='c++')
+            call_args = mock_spawn.call_args[0][0]
+            expected = ['wrapper', 'g++-4.2', '-bundle', '-undefined', 'dynamic_lookup']
+            assert call_args[:5] == expected
+
+            self.cc.link_executable([], 'a.out', target_lang='c++')
+            call_args = mock_spawn.call_args[0][0]
+            expected = [
+                'wrapper',
+                'g++-4.2',
+                '-o',
+                self.cc.executable_filename('a.out'),
+            ]
+            assert call_args[:4] == expected
+
+    @pytest.mark.skipif('platform.system == "Windows"')
+    @pytest.mark.usefixtures('disable_macos_customization')
+    def test_cc_overrides_ldshared_for_cxx_correctly(self):
+        """
+        Ensure that setting CC env variable also changes default linker
+        correctly when building C++ extensions.
+
+        pypa/distutils#126
+        """
+
+        def gcv(v):
+            if v == 'LDSHARED':
+                return 'gcc-4.2 -bundle -undefined dynamic_lookup '
+            elif v == 'LDCXXSHARED':
+                return 'g++-4.2 -bundle -undefined dynamic_lookup '
+            elif v == 'CXX':
+                return 'g++-4.2'
+            elif v == 'CC':
+                return 'gcc-4.2'
+            return ''
+
+        def gcvs(*args, _orig=sysconfig.get_config_vars):
+            if args:
+                return list(map(sysconfig.get_config_var, args))
+            return _orig()
+
+        sysconfig.get_config_var = gcv
+        sysconfig.get_config_vars = gcvs
+        with (
+            mock.patch.object(self.cc, 'spawn', return_value=None) as mock_spawn,
+            mock.patch.object(self.cc, '_need_link', return_value=True),
+            mock.patch.object(self.cc, 'mkpath', return_value=None),
+            EnvironmentVarGuard() as env,
+        ):
+            env['CC'] = 'ccache my_cc'
+            env['CXX'] = 'my_cxx'
+            del env['LDSHARED']
+            sysconfig.customize_compiler(self.cc)
+            assert self.cc.linker_so[0:2] == ['ccache', 'my_cc']
+            self.cc.link(None, [], 'a.out', target_lang='c++')
+            call_args = mock_spawn.call_args[0][0]
+            expected = ['my_cxx', '-bundle', '-undefined', 'dynamic_lookup']
+            assert call_args[:4] == expected
+
+    @pytest.mark.skipif('platform.system == "Windows"')
+    def test_explicit_ldshared(self):
+        # Issue #18080:
+        # ensure that setting CC env variable does not change
+        #   explicit LDSHARED setting for linker
+        def gcv(v):
+            if v == 'LDSHARED':
+                return 'gcc-4.2 -bundle -undefined dynamic_lookup '
+            return 'gcc-4.2'
+
+        def gcvs(*args, _orig=sysconfig.get_config_vars):
+            if args:
+                return list(map(sysconfig.get_config_var, args))
+            return _orig()
+
+        sysconfig.get_config_var = gcv
+        sysconfig.get_config_vars = gcvs
+        with EnvironmentVarGuard() as env:
+            env['CC'] = 'my_cc'
+            env['LDSHARED'] = 'my_ld -bundle -dynamic'
+            sysconfig.customize_compiler(self.cc)
+        assert self.cc.linker_so[0] == 'my_ld'
+
+    def test_has_function(self):
+        # Issue https://github.com/pypa/distutils/issues/64:
+        # ensure that setting output_dir does not raise
+        # FileNotFoundError: [Errno 2] No such file or directory: 'a.out'
+        self.cc.output_dir = 'scratch'
+        os.chdir(self.mkdtemp())
+        self.cc.has_function('abort')
+
+    def test_find_library_file(self, monkeypatch):
+        compiler = unix.Compiler()
+        compiler._library_root = lambda dir: dir
+        monkeypatch.setattr(os.path, 'exists', lambda d: 'existing' in d)
+
+        libname = 'libabc.dylib' if sys.platform != 'cygwin' else 'cygabc.dll'
+        dirs = ('/foo/bar/missing', '/foo/bar/existing')
+        assert (
+            compiler.find_library_file(dirs, 'abc').replace('\\', '/')
+            == f'/foo/bar/existing/{libname}'
+        )
+        assert (
+            compiler.find_library_file(reversed(dirs), 'abc').replace('\\', '/')
+            == f'/foo/bar/existing/{libname}'
+        )
+
+        monkeypatch.setattr(
+            os.path,
+            'exists',
+            lambda d: 'existing' in d and '.a' in d and '.dll.a' not in d,
+        )
+        assert (
+            compiler.find_library_file(dirs, 'abc').replace('\\', '/')
+            == '/foo/bar/existing/libabc.a'
+        )
+        assert (
+            compiler.find_library_file(reversed(dirs), 'abc').replace('\\', '/')
+            == '/foo/bar/existing/libabc.a'
+        )
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/compilers/C/unix.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/compilers/C/unix.py
new file mode 100644
index 0000000000000000000000000000000000000000..1231b32d20fc0524ea50f6a70d7e017211c69e9b
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/compilers/C/unix.py
@@ -0,0 +1,422 @@
+"""distutils.unixccompiler
+
+Contains the UnixCCompiler class, a subclass of CCompiler that handles
+the "typical" Unix-style command-line C compiler:
+  * macros defined with -Dname[=value]
+  * macros undefined with -Uname
+  * include search directories specified with -Idir
+  * libraries specified with -lllib
+  * library search directories specified with -Ldir
+  * compile handled by 'cc' (or similar) executable with -c option:
+    compiles .c to .o
+  * link static library handled by 'ar' command (possibly with 'ranlib')
+  * link shared library handled by 'cc -shared'
+"""
+
+from __future__ import annotations
+
+import itertools
+import os
+import re
+import shlex
+import sys
+from collections.abc import Iterable
+
+from ... import sysconfig
+from ..._log import log
+from ..._macos_compat import compiler_fixup
+from ..._modified import newer
+from ...compat import consolidate_linker_args
+from ...errors import DistutilsExecError
+from . import base
+from .base import _Macro, gen_lib_options, gen_preprocess_options
+from .errors import (
+    CompileError,
+    LibError,
+    LinkError,
+)
+
+# XXX Things not currently handled:
+#   * optimization/debug/warning flags; we just use whatever's in Python's
+#     Makefile and live with it.  Is this adequate?  If not, we might
+#     have to have a bunch of subclasses GNUCCompiler, SGICCompiler,
+#     SunCCompiler, and I suspect down that road lies madness.
+#   * even if we don't know a warning flag from an optimization flag,
+#     we need some way for outsiders to feed preprocessor/compiler/linker
+#     flags in to us -- eg. a sysadmin might want to mandate certain flags
+#     via a site config file, or a user might want to set something for
+#     compiling this module distribution only via the setup.py command
+#     line, whatever.  As long as these options come from something on the
+#     current system, they can be as system-dependent as they like, and we
+#     should just happily stuff them into the preprocessor/compiler/linker
+#     options and carry on.
+
+
+def _split_env(cmd):
+    """
+    For macOS, split command into 'env' portion (if any)
+    and the rest of the linker command.
+
+    >>> _split_env(['a', 'b', 'c'])
+    ([], ['a', 'b', 'c'])
+    >>> _split_env(['/usr/bin/env', 'A=3', 'gcc'])
+    (['/usr/bin/env', 'A=3'], ['gcc'])
+    """
+    pivot = 0
+    if os.path.basename(cmd[0]) == "env":
+        pivot = 1
+        while '=' in cmd[pivot]:
+            pivot += 1
+    return cmd[:pivot], cmd[pivot:]
+
+
+def _split_aix(cmd):
+    """
+    AIX platforms prefix the compiler with the ld_so_aix
+    script, so split that from the linker command.
+
+    >>> _split_aix(['a', 'b', 'c'])
+    ([], ['a', 'b', 'c'])
+    >>> _split_aix(['/bin/foo/ld_so_aix', 'gcc'])
+    (['/bin/foo/ld_so_aix'], ['gcc'])
+    """
+    pivot = os.path.basename(cmd[0]) == 'ld_so_aix'
+    return cmd[:pivot], cmd[pivot:]
+
+
+def _linker_params(linker_cmd, compiler_cmd):
+    """
+    The linker command usually begins with the compiler
+    command (possibly multiple elements), followed by zero or more
+    params for shared library building.
+
+    If the LDSHARED env variable overrides the linker command,
+    however, the commands may not match.
+
+    Return the best guess of the linker parameters by stripping
+    the linker command. If the compiler command does not
+    match the linker command, assume the linker command is
+    just the first element.
+
+    >>> _linker_params('gcc foo bar'.split(), ['gcc'])
+    ['foo', 'bar']
+    >>> _linker_params('gcc foo bar'.split(), ['other'])
+    ['foo', 'bar']
+    >>> _linker_params('ccache gcc foo bar'.split(), 'ccache gcc'.split())
+    ['foo', 'bar']
+    >>> _linker_params(['gcc'], ['gcc'])
+    []
+    """
+    c_len = len(compiler_cmd)
+    pivot = c_len if linker_cmd[:c_len] == compiler_cmd else 1
+    return linker_cmd[pivot:]
+
+
+class Compiler(base.Compiler):
+    compiler_type = 'unix'
+
+    # These are used by CCompiler in two places: the constructor sets
+    # instance attributes 'preprocessor', 'compiler', etc. from them, and
+    # 'set_executable()' allows any of these to be set.  The defaults here
+    # are pretty generic; they will probably have to be set by an outsider
+    # (eg. using information discovered by the sysconfig about building
+    # Python extensions).
+    executables = {
+        'preprocessor': None,
+        'compiler': ["cc"],
+        'compiler_so': ["cc"],
+        'compiler_cxx': ["c++"],
+        'compiler_so_cxx': ["c++"],
+        'linker_so': ["cc", "-shared"],
+        'linker_so_cxx': ["c++", "-shared"],
+        'linker_exe': ["cc"],
+        'linker_exe_cxx': ["c++", "-shared"],
+        'archiver': ["ar", "-cr"],
+        'ranlib': None,
+    }
+
+    if sys.platform[:6] == "darwin":
+        executables['ranlib'] = ["ranlib"]
+
+    # Needed for the filename generation methods provided by the base
+    # class, CCompiler.  NB. whoever instantiates/uses a particular
+    # UnixCCompiler instance should set 'shared_lib_ext' -- we set a
+    # reasonable common default here, but it's not necessarily used on all
+    # Unices!
+
+    src_extensions = [".c", ".C", ".cc", ".cxx", ".cpp", ".m"]
+    obj_extension = ".o"
+    static_lib_extension = ".a"
+    shared_lib_extension = ".so"
+    dylib_lib_extension = ".dylib"
+    xcode_stub_lib_extension = ".tbd"
+    static_lib_format = shared_lib_format = dylib_lib_format = "lib%s%s"
+    xcode_stub_lib_format = dylib_lib_format
+    if sys.platform == "cygwin":
+        exe_extension = ".exe"
+        shared_lib_extension = ".dll.a"
+        dylib_lib_extension = ".dll"
+        dylib_lib_format = "cyg%s%s"
+
+    def _fix_lib_args(self, libraries, library_dirs, runtime_library_dirs):
+        """Remove standard library path from rpath"""
+        libraries, library_dirs, runtime_library_dirs = super()._fix_lib_args(
+            libraries, library_dirs, runtime_library_dirs
+        )
+        libdir = sysconfig.get_config_var('LIBDIR')
+        if (
+            runtime_library_dirs
+            and libdir.startswith("/usr/lib")
+            and (libdir in runtime_library_dirs)
+        ):
+            runtime_library_dirs.remove(libdir)
+        return libraries, library_dirs, runtime_library_dirs
+
+    def preprocess(
+        self,
+        source: str | os.PathLike[str],
+        output_file: str | os.PathLike[str] | None = None,
+        macros: list[_Macro] | None = None,
+        include_dirs: list[str] | tuple[str, ...] | None = None,
+        extra_preargs: list[str] | None = None,
+        extra_postargs: Iterable[str] | None = None,
+    ):
+        fixed_args = self._fix_compile_args(None, macros, include_dirs)
+        ignore, macros, include_dirs = fixed_args
+        pp_opts = gen_preprocess_options(macros, include_dirs)
+        pp_args = self.preprocessor + pp_opts
+        if output_file:
+            pp_args.extend(['-o', output_file])
+        if extra_preargs:
+            pp_args[:0] = extra_preargs
+        if extra_postargs:
+            pp_args.extend(extra_postargs)
+        pp_args.append(source)
+
+        # reasons to preprocess:
+        # - force is indicated
+        # - output is directed to stdout
+        # - source file is newer than the target
+        preprocess = self.force or output_file is None or newer(source, output_file)
+        if not preprocess:
+            return
+
+        if output_file:
+            self.mkpath(os.path.dirname(output_file))
+
+        try:
+            self.spawn(pp_args)
+        except DistutilsExecError as msg:
+            raise CompileError(msg)
+
+    def _compile(self, obj, src, ext, cc_args, extra_postargs, pp_opts):
+        compiler_so = compiler_fixup(self.compiler_so, cc_args + extra_postargs)
+        compiler_so_cxx = compiler_fixup(self.compiler_so_cxx, cc_args + extra_postargs)
+        try:
+            if self.detect_language(src) == 'c++':
+                self.spawn(
+                    compiler_so_cxx + cc_args + [src, '-o', obj] + extra_postargs
+                )
+            else:
+                self.spawn(compiler_so + cc_args + [src, '-o', obj] + extra_postargs)
+        except DistutilsExecError as msg:
+            raise CompileError(msg)
+
+    def create_static_lib(
+        self, objects, output_libname, output_dir=None, debug=False, target_lang=None
+    ):
+        objects, output_dir = self._fix_object_args(objects, output_dir)
+
+        output_filename = self.library_filename(output_libname, output_dir=output_dir)
+
+        if self._need_link(objects, output_filename):
+            self.mkpath(os.path.dirname(output_filename))
+            self.spawn(self.archiver + [output_filename] + objects + self.objects)
+
+            # Not many Unices required ranlib anymore -- SunOS 4.x is, I
+            # think the only major Unix that does.  Maybe we need some
+            # platform intelligence here to skip ranlib if it's not
+            # needed -- or maybe Python's configure script took care of
+            # it for us, hence the check for leading colon.
+            if self.ranlib:
+                try:
+                    self.spawn(self.ranlib + [output_filename])
+                except DistutilsExecError as msg:
+                    raise LibError(msg)
+        else:
+            log.debug("skipping %s (up-to-date)", output_filename)
+
+    def link(
+        self,
+        target_desc,
+        objects: list[str] | tuple[str, ...],
+        output_filename,
+        output_dir: str | None = None,
+        libraries: list[str] | tuple[str, ...] | None = None,
+        library_dirs: list[str] | tuple[str, ...] | None = None,
+        runtime_library_dirs: list[str] | tuple[str, ...] | None = None,
+        export_symbols=None,
+        debug=False,
+        extra_preargs=None,
+        extra_postargs=None,
+        build_temp=None,
+        target_lang=None,
+    ):
+        objects, output_dir = self._fix_object_args(objects, output_dir)
+        fixed_args = self._fix_lib_args(libraries, library_dirs, runtime_library_dirs)
+        libraries, library_dirs, runtime_library_dirs = fixed_args
+
+        lib_opts = gen_lib_options(self, library_dirs, runtime_library_dirs, libraries)
+        if not isinstance(output_dir, (str, type(None))):
+            raise TypeError("'output_dir' must be a string or None")
+        if output_dir is not None:
+            output_filename = os.path.join(output_dir, output_filename)
+
+        if self._need_link(objects, output_filename):
+            ld_args = objects + self.objects + lib_opts + ['-o', output_filename]
+            if debug:
+                ld_args[:0] = ['-g']
+            if extra_preargs:
+                ld_args[:0] = extra_preargs
+            if extra_postargs:
+                ld_args.extend(extra_postargs)
+            self.mkpath(os.path.dirname(output_filename))
+            try:
+                # Select a linker based on context: linker_exe when
+                # building an executable or linker_so (with shared options)
+                # when building a shared library.
+                building_exe = target_desc == base.Compiler.EXECUTABLE
+                target_cxx = target_lang == "c++"
+                linker = (
+                    (self.linker_exe_cxx if target_cxx else self.linker_exe)
+                    if building_exe
+                    else (self.linker_so_cxx if target_cxx else self.linker_so)
+                )[:]
+
+                if target_cxx and self.compiler_cxx:
+                    env, linker_ne = _split_env(linker)
+                    aix, linker_na = _split_aix(linker_ne)
+                    _, compiler_cxx_ne = _split_env(self.compiler_cxx)
+                    _, linker_exe_ne = _split_env(self.linker_exe_cxx)
+
+                    params = _linker_params(linker_na, linker_exe_ne)
+                    linker = env + aix + compiler_cxx_ne + params
+
+                linker = compiler_fixup(linker, ld_args)
+
+                self.spawn(linker + ld_args)
+            except DistutilsExecError as msg:
+                raise LinkError(msg)
+        else:
+            log.debug("skipping %s (up-to-date)", output_filename)
+
+    # -- Miscellaneous methods -----------------------------------------
+    # These are all used by the 'gen_lib_options() function, in
+    # ccompiler.py.
+
+    def library_dir_option(self, dir):
+        return "-L" + dir
+
+    def _is_gcc(self):
+        cc_var = sysconfig.get_config_var("CC")
+        compiler = os.path.basename(shlex.split(cc_var)[0])
+        return "gcc" in compiler or "g++" in compiler
+
+    def runtime_library_dir_option(self, dir: str) -> str | list[str]:  # type: ignore[override] # Fixed in pypa/distutils#339
+        # XXX Hackish, at the very least.  See Python bug #445902:
+        # https://bugs.python.org/issue445902
+        # Linkers on different platforms need different options to
+        # specify that directories need to be added to the list of
+        # directories searched for dependencies when a dynamic library
+        # is sought.  GCC on GNU systems (Linux, FreeBSD, ...) has to
+        # be told to pass the -R option through to the linker, whereas
+        # other compilers and gcc on other systems just know this.
+        # Other compilers may need something slightly different.  At
+        # this time, there's no way to determine this information from
+        # the configuration data stored in the Python installation, so
+        # we use this hack.
+        if sys.platform[:6] == "darwin":
+            from distutils.util import get_macosx_target_ver, split_version
+
+            macosx_target_ver = get_macosx_target_ver()
+            if macosx_target_ver and split_version(macosx_target_ver) >= [10, 5]:
+                return "-Wl,-rpath," + dir
+            else:  # no support for -rpath on earlier macOS versions
+                return "-L" + dir
+        elif sys.platform[:7] == "freebsd":
+            return "-Wl,-rpath=" + dir
+        elif sys.platform[:5] == "hp-ux":
+            return [
+                "-Wl,+s" if self._is_gcc() else "+s",
+                "-L" + dir,
+            ]
+
+        # For all compilers, `-Wl` is the presumed way to pass a
+        # compiler option to the linker
+        if sysconfig.get_config_var("GNULD") == "yes":
+            return consolidate_linker_args([
+                # Force RUNPATH instead of RPATH
+                "-Wl,--enable-new-dtags",
+                "-Wl,-rpath," + dir,
+            ])
+        else:
+            return "-Wl,-R" + dir
+
+    def library_option(self, lib):
+        return "-l" + lib
+
+    @staticmethod
+    def _library_root(dir):
+        """
+        macOS users can specify an alternate SDK using'-isysroot'.
+        Calculate the SDK root if it is specified.
+
+        Note that, as of Xcode 7, Apple SDKs may contain textual stub
+        libraries with .tbd extensions rather than the normal .dylib
+        shared libraries installed in /.  The Apple compiler tool
+        chain handles this transparently but it can cause problems
+        for programs that are being built with an SDK and searching
+        for specific libraries.  Callers of find_library_file need to
+        keep in mind that the base filename of the returned SDK library
+        file might have a different extension from that of the library
+        file installed on the running system, for example:
+          /Applications/Xcode.app/Contents/Developer/Platforms/
+              MacOSX.platform/Developer/SDKs/MacOSX10.11.sdk/
+              usr/lib/libedit.tbd
+        vs
+          /usr/lib/libedit.dylib
+        """
+        cflags = sysconfig.get_config_var('CFLAGS')
+        match = re.search(r'-isysroot\s*(\S+)', cflags)
+
+        apply_root = (
+            sys.platform == 'darwin'
+            and match
+            and (
+                dir.startswith('/System/')
+                or (dir.startswith('/usr/') and not dir.startswith('/usr/local/'))
+            )
+        )
+
+        return os.path.join(match.group(1), dir[1:]) if apply_root else dir
+
+    def find_library_file(self, dirs, lib, debug=False):
+        """
+        Second-guess the linker with not much hard
+        data to go on: GCC seems to prefer the shared library, so
+        assume that *all* Unix C compilers do,
+        ignoring even GCC's "-static" option.
+        """
+        lib_names = (
+            self.library_filename(lib, lib_type=type)
+            for type in 'dylib xcode_stub shared static'.split()
+        )
+
+        roots = map(self._library_root, dirs)
+
+        searched = itertools.starmap(os.path.join, itertools.product(roots, lib_names))
+
+        found = filter(os.path.exists, searched)
+
+        # Return None if it could not be found in any dir.
+        return next(found, None)
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/compilers/C/zos.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/compilers/C/zos.py
new file mode 100644
index 0000000000000000000000000000000000000000..82d017fc90db55b8f7b2517ba6c8a8fd2082cb5e
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/compilers/C/zos.py
@@ -0,0 +1,230 @@
+"""distutils.zosccompiler
+
+Contains the selection of the c & c++ compilers on z/OS. There are several
+different c compilers on z/OS, all of them are optional, so the correct
+one needs to be chosen based on the users input. This is compatible with
+the following compilers:
+
+IBM C/C++ For Open Enterprise Languages on z/OS 2.0
+IBM Open XL C/C++ 1.1 for z/OS
+IBM XL C/C++ V2.4.1 for z/OS 2.4 and 2.5
+IBM z/OS XL C/C++
+"""
+
+import os
+
+from ... import sysconfig
+from ...errors import DistutilsExecError
+from . import unix
+from .errors import CompileError
+
+_cc_args = {
+    'ibm-openxl': [
+        '-m64',
+        '-fvisibility=default',
+        '-fzos-le-char-mode=ascii',
+        '-fno-short-enums',
+    ],
+    'ibm-xlclang': [
+        '-q64',
+        '-qexportall',
+        '-qascii',
+        '-qstrict',
+        '-qnocsect',
+        '-Wa,asa,goff',
+        '-Wa,xplink',
+        '-qgonumber',
+        '-qenum=int',
+        '-Wc,DLL',
+    ],
+    'ibm-xlc': [
+        '-q64',
+        '-qexportall',
+        '-qascii',
+        '-qstrict',
+        '-qnocsect',
+        '-Wa,asa,goff',
+        '-Wa,xplink',
+        '-qgonumber',
+        '-qenum=int',
+        '-Wc,DLL',
+        '-qlanglvl=extc99',
+    ],
+}
+
+_cxx_args = {
+    'ibm-openxl': [
+        '-m64',
+        '-fvisibility=default',
+        '-fzos-le-char-mode=ascii',
+        '-fno-short-enums',
+    ],
+    'ibm-xlclang': [
+        '-q64',
+        '-qexportall',
+        '-qascii',
+        '-qstrict',
+        '-qnocsect',
+        '-Wa,asa,goff',
+        '-Wa,xplink',
+        '-qgonumber',
+        '-qenum=int',
+        '-Wc,DLL',
+    ],
+    'ibm-xlc': [
+        '-q64',
+        '-qexportall',
+        '-qascii',
+        '-qstrict',
+        '-qnocsect',
+        '-Wa,asa,goff',
+        '-Wa,xplink',
+        '-qgonumber',
+        '-qenum=int',
+        '-Wc,DLL',
+        '-qlanglvl=extended0x',
+    ],
+}
+
+_asm_args = {
+    'ibm-openxl': ['-fasm', '-fno-integrated-as', '-Wa,--ASA', '-Wa,--GOFF'],
+    'ibm-xlclang': [],
+    'ibm-xlc': [],
+}
+
+_ld_args = {
+    'ibm-openxl': [],
+    'ibm-xlclang': ['-Wl,dll', '-q64'],
+    'ibm-xlc': ['-Wl,dll', '-q64'],
+}
+
+
+# Python on z/OS is built with no compiler specific options in it's CFLAGS.
+# But each compiler requires it's own specific options to build successfully,
+# though some of the options are common between them
+class Compiler(unix.Compiler):
+    src_extensions = ['.c', '.C', '.cc', '.cxx', '.cpp', '.m', '.s']
+    _cpp_extensions = ['.cc', '.cpp', '.cxx', '.C']
+    _asm_extensions = ['.s']
+
+    def _get_zos_compiler_name(self):
+        zos_compiler_names = [
+            os.path.basename(binary)
+            for envvar in ('CC', 'CXX', 'LDSHARED')
+            if (binary := os.environ.get(envvar, None))
+        ]
+        if len(zos_compiler_names) == 0:
+            return 'ibm-openxl'
+
+        zos_compilers = {}
+        for compiler in (
+            'ibm-clang',
+            'ibm-clang64',
+            'ibm-clang++',
+            'ibm-clang++64',
+            'clang',
+            'clang++',
+            'clang-14',
+        ):
+            zos_compilers[compiler] = 'ibm-openxl'
+
+        for compiler in ('xlclang', 'xlclang++', 'njsc', 'njsc++'):
+            zos_compilers[compiler] = 'ibm-xlclang'
+
+        for compiler in ('xlc', 'xlC', 'xlc++'):
+            zos_compilers[compiler] = 'ibm-xlc'
+
+        return zos_compilers.get(zos_compiler_names[0], 'ibm-openxl')
+
+    def __init__(self, verbose=False, dry_run=False, force=False):
+        super().__init__(verbose, dry_run, force)
+        self.zos_compiler = self._get_zos_compiler_name()
+        sysconfig.customize_compiler(self)
+
+    def _compile(self, obj, src, ext, cc_args, extra_postargs, pp_opts):
+        local_args = []
+        if ext in self._cpp_extensions:
+            compiler = self.compiler_cxx
+            local_args.extend(_cxx_args[self.zos_compiler])
+        elif ext in self._asm_extensions:
+            compiler = self.compiler_so
+            local_args.extend(_cc_args[self.zos_compiler])
+            local_args.extend(_asm_args[self.zos_compiler])
+        else:
+            compiler = self.compiler_so
+            local_args.extend(_cc_args[self.zos_compiler])
+        local_args.extend(cc_args)
+
+        try:
+            self.spawn(compiler + local_args + [src, '-o', obj] + extra_postargs)
+        except DistutilsExecError as msg:
+            raise CompileError(msg)
+
+    def runtime_library_dir_option(self, dir):
+        return '-L' + dir
+
+    def link(
+        self,
+        target_desc,
+        objects,
+        output_filename,
+        output_dir=None,
+        libraries=None,
+        library_dirs=None,
+        runtime_library_dirs=None,
+        export_symbols=None,
+        debug=False,
+        extra_preargs=None,
+        extra_postargs=None,
+        build_temp=None,
+        target_lang=None,
+    ):
+        # For a built module to use functions from cpython, it needs to use Pythons
+        # side deck file. The side deck is located beside the libpython3.xx.so
+        ldversion = sysconfig.get_config_var('LDVERSION')
+        if sysconfig.python_build:
+            side_deck_path = os.path.join(
+                sysconfig.get_config_var('abs_builddir'),
+                f'libpython{ldversion}.x',
+            )
+        else:
+            side_deck_path = os.path.join(
+                sysconfig.get_config_var('installed_base'),
+                sysconfig.get_config_var('platlibdir'),
+                f'libpython{ldversion}.x',
+            )
+
+        if os.path.exists(side_deck_path):
+            if extra_postargs:
+                extra_postargs.append(side_deck_path)
+            else:
+                extra_postargs = [side_deck_path]
+
+        # Check and replace libraries included side deck files
+        if runtime_library_dirs:
+            for dir in runtime_library_dirs:
+                for library in libraries[:]:
+                    library_side_deck = os.path.join(dir, f'{library}.x')
+                    if os.path.exists(library_side_deck):
+                        libraries.remove(library)
+                        extra_postargs.append(library_side_deck)
+                        break
+
+        # Any required ld args for the given compiler
+        extra_postargs.extend(_ld_args[self.zos_compiler])
+
+        super().link(
+            target_desc,
+            objects,
+            output_filename,
+            output_dir,
+            libraries,
+            library_dirs,
+            runtime_library_dirs,
+            export_symbols,
+            debug,
+            extra_preargs,
+            extra_postargs,
+            build_temp,
+            target_lang,
+        )
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/core.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/core.py
new file mode 100644
index 0000000000000000000000000000000000000000..bd62546bdd9d35dcc46e0b46a46b0c61a43fd0ba
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/core.py
@@ -0,0 +1,289 @@
+"""distutils.core
+
+The only module that needs to be imported to use the Distutils; provides
+the 'setup' function (which is to be called from the setup script).  Also
+indirectly provides the Distribution and Command classes, although they are
+really defined in distutils.dist and distutils.cmd.
+"""
+
+from __future__ import annotations
+
+import os
+import sys
+import tokenize
+from collections.abc import Iterable
+
+from .cmd import Command
+from .debug import DEBUG
+
+# Mainly import these so setup scripts can "from distutils.core import" them.
+from .dist import Distribution
+from .errors import (
+    CCompilerError,
+    DistutilsArgError,
+    DistutilsError,
+    DistutilsSetupError,
+)
+from .extension import Extension
+
+__all__ = ['Distribution', 'Command', 'Extension', 'setup']
+
+# This is a barebones help message generated displayed when the user
+# runs the setup script with no arguments at all.  More useful help
+# is generated with various --help options: global help, list commands,
+# and per-command help.
+USAGE = """\
+usage: %(script)s [global_opts] cmd1 [cmd1_opts] [cmd2 [cmd2_opts] ...]
+   or: %(script)s --help [cmd1 cmd2 ...]
+   or: %(script)s --help-commands
+   or: %(script)s cmd --help
+"""
+
+
+def gen_usage(script_name):
+    script = os.path.basename(script_name)
+    return USAGE % locals()
+
+
+# Some mild magic to control the behaviour of 'setup()' from 'run_setup()'.
+_setup_stop_after = None
+_setup_distribution = None
+
+# Legal keyword arguments for the setup() function
+setup_keywords = (
+    'distclass',
+    'script_name',
+    'script_args',
+    'options',
+    'name',
+    'version',
+    'author',
+    'author_email',
+    'maintainer',
+    'maintainer_email',
+    'url',
+    'license',
+    'description',
+    'long_description',
+    'keywords',
+    'platforms',
+    'classifiers',
+    'download_url',
+    'requires',
+    'provides',
+    'obsoletes',
+)
+
+# Legal keyword arguments for the Extension constructor
+extension_keywords = (
+    'name',
+    'sources',
+    'include_dirs',
+    'define_macros',
+    'undef_macros',
+    'library_dirs',
+    'libraries',
+    'runtime_library_dirs',
+    'extra_objects',
+    'extra_compile_args',
+    'extra_link_args',
+    'swig_opts',
+    'export_symbols',
+    'depends',
+    'language',
+)
+
+
+def setup(**attrs):  # noqa: C901
+    """The gateway to the Distutils: do everything your setup script needs
+    to do, in a highly flexible and user-driven way.  Briefly: create a
+    Distribution instance; find and parse config files; parse the command
+    line; run each Distutils command found there, customized by the options
+    supplied to 'setup()' (as keyword arguments), in config files, and on
+    the command line.
+
+    The Distribution instance might be an instance of a class supplied via
+    the 'distclass' keyword argument to 'setup'; if no such class is
+    supplied, then the Distribution class (in dist.py) is instantiated.
+    All other arguments to 'setup' (except for 'cmdclass') are used to set
+    attributes of the Distribution instance.
+
+    The 'cmdclass' argument, if supplied, is a dictionary mapping command
+    names to command classes.  Each command encountered on the command line
+    will be turned into a command class, which is in turn instantiated; any
+    class found in 'cmdclass' is used in place of the default, which is
+    (for command 'foo_bar') class 'foo_bar' in module
+    'distutils.command.foo_bar'.  The command class must provide a
+    'user_options' attribute which is a list of option specifiers for
+    'distutils.fancy_getopt'.  Any command-line options between the current
+    and the next command are used to set attributes of the current command
+    object.
+
+    When the entire command-line has been successfully parsed, calls the
+    'run()' method on each command object in turn.  This method will be
+    driven entirely by the Distribution object (which each command object
+    has a reference to, thanks to its constructor), and the
+    command-specific options that became attributes of each command
+    object.
+    """
+
+    global _setup_stop_after, _setup_distribution
+
+    # Determine the distribution class -- either caller-supplied or
+    # our Distribution (see below).
+    klass = attrs.get('distclass')
+    if klass:
+        attrs.pop('distclass')
+    else:
+        klass = Distribution
+
+    if 'script_name' not in attrs:
+        attrs['script_name'] = os.path.basename(sys.argv[0])
+    if 'script_args' not in attrs:
+        attrs['script_args'] = sys.argv[1:]
+
+    # Create the Distribution instance, using the remaining arguments
+    # (ie. everything except distclass) to initialize it
+    try:
+        _setup_distribution = dist = klass(attrs)
+    except DistutilsSetupError as msg:
+        if 'name' not in attrs:
+            raise SystemExit(f"error in setup command: {msg}")
+        else:
+            raise SystemExit("error in {} setup command: {}".format(attrs['name'], msg))
+
+    if _setup_stop_after == "init":
+        return dist
+
+    # Find and parse the config file(s): they will override options from
+    # the setup script, but be overridden by the command line.
+    dist.parse_config_files()
+
+    if DEBUG:
+        print("options (after parsing config files):")
+        dist.dump_option_dicts()
+
+    if _setup_stop_after == "config":
+        return dist
+
+    # Parse the command line and override config files; any
+    # command-line errors are the end user's fault, so turn them into
+    # SystemExit to suppress tracebacks.
+    try:
+        ok = dist.parse_command_line()
+    except DistutilsArgError as msg:
+        raise SystemExit(gen_usage(dist.script_name) + f"\nerror: {msg}")
+
+    if DEBUG:
+        print("options (after parsing command line):")
+        dist.dump_option_dicts()
+
+    if _setup_stop_after == "commandline":
+        return dist
+
+    # And finally, run all the commands found on the command line.
+    if ok:
+        return run_commands(dist)
+
+    return dist
+
+
+# setup ()
+
+
+def run_commands(dist):
+    """Given a Distribution object run all the commands,
+    raising ``SystemExit`` errors in the case of failure.
+
+    This function assumes that either ``sys.argv`` or ``dist.script_args``
+    is already set accordingly.
+    """
+    try:
+        dist.run_commands()
+    except KeyboardInterrupt:
+        raise SystemExit("interrupted")
+    except OSError as exc:
+        if DEBUG:
+            sys.stderr.write(f"error: {exc}\n")
+            raise
+        else:
+            raise SystemExit(f"error: {exc}")
+
+    except (DistutilsError, CCompilerError) as msg:
+        if DEBUG:
+            raise
+        else:
+            raise SystemExit("error: " + str(msg))
+
+    return dist
+
+
+def run_setup(script_name, script_args: Iterable[str] | None = None, stop_after="run"):
+    """Run a setup script in a somewhat controlled environment, and
+    return the Distribution instance that drives things.  This is useful
+    if you need to find out the distribution meta-data (passed as
+    keyword args from 'script' to 'setup()', or the contents of the
+    config files or command-line.
+
+    'script_name' is a file that will be read and run with 'exec()';
+    'sys.argv[0]' will be replaced with 'script' for the duration of the
+    call.  'script_args' is a list of strings; if supplied,
+    'sys.argv[1:]' will be replaced by 'script_args' for the duration of
+    the call.
+
+    'stop_after' tells 'setup()' when to stop processing; possible
+    values:
+      init
+        stop after the Distribution instance has been created and
+        populated with the keyword arguments to 'setup()'
+      config
+        stop after config files have been parsed (and their data
+        stored in the Distribution instance)
+      commandline
+        stop after the command-line ('sys.argv[1:]' or 'script_args')
+        have been parsed (and the data stored in the Distribution)
+      run [default]
+        stop after all commands have been run (the same as if 'setup()'
+        had been called in the usual way
+
+    Returns the Distribution instance, which provides all information
+    used to drive the Distutils.
+    """
+    if stop_after not in ('init', 'config', 'commandline', 'run'):
+        raise ValueError(f"invalid value for 'stop_after': {stop_after!r}")
+
+    global _setup_stop_after, _setup_distribution
+    _setup_stop_after = stop_after
+
+    save_argv = sys.argv.copy()
+    g = {'__file__': script_name, '__name__': '__main__'}
+    try:
+        try:
+            sys.argv[0] = script_name
+            if script_args is not None:
+                sys.argv[1:] = script_args
+            # tokenize.open supports automatic encoding detection
+            with tokenize.open(script_name) as f:
+                code = f.read().replace(r'\r\n', r'\n')
+                exec(code, g)
+        finally:
+            sys.argv = save_argv
+            _setup_stop_after = None
+    except SystemExit:
+        # Hmm, should we do something if exiting with a non-zero code
+        # (ie. error)?
+        pass
+
+    if _setup_distribution is None:
+        raise RuntimeError(
+            "'distutils.core.setup()' was never called -- "
+            f"perhaps '{script_name}' is not a Distutils setup script?"
+        )
+
+    # I wonder if the setup script's namespace -- g and l -- would be of
+    # any interest to callers?
+    # print "_setup_distribution:", _setup_distribution
+    return _setup_distribution
+
+
+# run_setup ()
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/cygwinccompiler.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/cygwinccompiler.py
new file mode 100644
index 0000000000000000000000000000000000000000..de89e3cd8402c9b7048c9e456ff67601934f972b
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/cygwinccompiler.py
@@ -0,0 +1,31 @@
+from .compilers.C import cygwin
+from .compilers.C.cygwin import (
+    CONFIG_H_NOTOK,
+    CONFIG_H_OK,
+    CONFIG_H_UNCERTAIN,
+    check_config_h,
+    get_msvcr,
+    is_cygwincc,
+)
+
+__all__ = [
+    'CONFIG_H_NOTOK',
+    'CONFIG_H_OK',
+    'CONFIG_H_UNCERTAIN',
+    'CygwinCCompiler',
+    'Mingw32CCompiler',
+    'check_config_h',
+    'get_msvcr',
+    'is_cygwincc',
+]
+
+
+CygwinCCompiler = cygwin.Compiler
+Mingw32CCompiler = cygwin.MinGW32Compiler
+
+
+get_versions = None
+"""
+A stand-in for the previous get_versions() function to prevent failures
+when monkeypatched. See pypa/setuptools#2969.
+"""
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/debug.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/debug.py
new file mode 100644
index 0000000000000000000000000000000000000000..daf1660f0d821143e388d37532a39ddfd2ca0347
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/debug.py
@@ -0,0 +1,5 @@
+import os
+
+# If DISTUTILS_DEBUG is anything other than the empty string, we run in
+# debug mode.
+DEBUG = os.environ.get('DISTUTILS_DEBUG')
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/dep_util.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/dep_util.py
new file mode 100644
index 0000000000000000000000000000000000000000..09a8a2e126c8bb009dbbe61c5c4bd5e358744996
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/dep_util.py
@@ -0,0 +1,14 @@
+import warnings
+
+from . import _modified
+
+
+def __getattr__(name):
+    if name not in ['newer', 'newer_group', 'newer_pairwise']:
+        raise AttributeError(name)
+    warnings.warn(
+        "dep_util is Deprecated. Use functions from setuptools instead.",
+        DeprecationWarning,
+        stacklevel=2,
+    )
+    return getattr(_modified, name)
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/dir_util.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/dir_util.py
new file mode 100644
index 0000000000000000000000000000000000000000..d9782602cfe78d4033fb43846965347de8ad9cdf
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/dir_util.py
@@ -0,0 +1,244 @@
+"""distutils.dir_util
+
+Utility functions for manipulating directories and directory trees."""
+
+import functools
+import itertools
+import os
+import pathlib
+
+from . import file_util
+from ._log import log
+from .errors import DistutilsFileError, DistutilsInternalError
+
+
+class SkipRepeatAbsolutePaths(set):
+    """
+    Cache for mkpath.
+
+    In addition to cheapening redundant calls, eliminates redundant
+    "creating /foo/bar/baz" messages in dry-run mode.
+    """
+
+    def __init__(self):
+        SkipRepeatAbsolutePaths.instance = self
+
+    @classmethod
+    def clear(cls):
+        super(cls, cls.instance).clear()
+
+    def wrap(self, func):
+        @functools.wraps(func)
+        def wrapper(path, *args, **kwargs):
+            if path.absolute() in self:
+                return
+            result = func(path, *args, **kwargs)
+            self.add(path.absolute())
+            return result
+
+        return wrapper
+
+
+# Python 3.8 compatibility
+wrapper = SkipRepeatAbsolutePaths().wrap
+
+
+@functools.singledispatch
+@wrapper
+def mkpath(name: pathlib.Path, mode=0o777, verbose=True, dry_run=False) -> None:
+    """Create a directory and any missing ancestor directories.
+
+    If the directory already exists (or if 'name' is the empty string, which
+    means the current directory, which of course exists), then do nothing.
+    Raise DistutilsFileError if unable to create some directory along the way
+    (eg. some sub-path exists, but is a file rather than a directory).
+    If 'verbose' is true, log the directory created.
+    """
+    if verbose and not name.is_dir():
+        log.info("creating %s", name)
+
+    try:
+        dry_run or name.mkdir(mode=mode, parents=True, exist_ok=True)
+    except OSError as exc:
+        raise DistutilsFileError(f"could not create '{name}': {exc.args[-1]}")
+
+
+@mkpath.register
+def _(name: str, *args, **kwargs):
+    return mkpath(pathlib.Path(name), *args, **kwargs)
+
+
+@mkpath.register
+def _(name: None, *args, **kwargs):
+    """
+    Detect a common bug -- name is None.
+    """
+    raise DistutilsInternalError(f"mkpath: 'name' must be a string (got {name!r})")
+
+
+def create_tree(base_dir, files, mode=0o777, verbose=True, dry_run=False):
+    """Create all the empty directories under 'base_dir' needed to put 'files'
+    there.
+
+    'base_dir' is just the name of a directory which doesn't necessarily
+    exist yet; 'files' is a list of filenames to be interpreted relative to
+    'base_dir'.  'base_dir' + the directory portion of every file in 'files'
+    will be created if it doesn't already exist.  'mode', 'verbose' and
+    'dry_run' flags are as for 'mkpath()'.
+    """
+    # First get the list of directories to create
+    need_dir = set(os.path.join(base_dir, os.path.dirname(file)) for file in files)
+
+    # Now create them
+    for dir in sorted(need_dir):
+        mkpath(dir, mode, verbose=verbose, dry_run=dry_run)
+
+
+def copy_tree(
+    src,
+    dst,
+    preserve_mode=True,
+    preserve_times=True,
+    preserve_symlinks=False,
+    update=False,
+    verbose=True,
+    dry_run=False,
+):
+    """Copy an entire directory tree 'src' to a new location 'dst'.
+
+    Both 'src' and 'dst' must be directory names.  If 'src' is not a
+    directory, raise DistutilsFileError.  If 'dst' does not exist, it is
+    created with 'mkpath()'.  The end result of the copy is that every
+    file in 'src' is copied to 'dst', and directories under 'src' are
+    recursively copied to 'dst'.  Return the list of files that were
+    copied or might have been copied, using their output name.  The
+    return value is unaffected by 'update' or 'dry_run': it is simply
+    the list of all files under 'src', with the names changed to be
+    under 'dst'.
+
+    'preserve_mode' and 'preserve_times' are the same as for
+    'copy_file'; note that they only apply to regular files, not to
+    directories.  If 'preserve_symlinks' is true, symlinks will be
+    copied as symlinks (on platforms that support them!); otherwise
+    (the default), the destination of the symlink will be copied.
+    'update' and 'verbose' are the same as for 'copy_file'.
+    """
+    if not dry_run and not os.path.isdir(src):
+        raise DistutilsFileError(f"cannot copy tree '{src}': not a directory")
+    try:
+        names = os.listdir(src)
+    except OSError as e:
+        if dry_run:
+            names = []
+        else:
+            raise DistutilsFileError(f"error listing files in '{src}': {e.strerror}")
+
+    if not dry_run:
+        mkpath(dst, verbose=verbose)
+
+    copy_one = functools.partial(
+        _copy_one,
+        src=src,
+        dst=dst,
+        preserve_symlinks=preserve_symlinks,
+        verbose=verbose,
+        dry_run=dry_run,
+        preserve_mode=preserve_mode,
+        preserve_times=preserve_times,
+        update=update,
+    )
+    return list(itertools.chain.from_iterable(map(copy_one, names)))
+
+
+def _copy_one(
+    name,
+    *,
+    src,
+    dst,
+    preserve_symlinks,
+    verbose,
+    dry_run,
+    preserve_mode,
+    preserve_times,
+    update,
+):
+    src_name = os.path.join(src, name)
+    dst_name = os.path.join(dst, name)
+
+    if name.startswith('.nfs'):
+        # skip NFS rename files
+        return
+
+    if preserve_symlinks and os.path.islink(src_name):
+        link_dest = os.readlink(src_name)
+        if verbose >= 1:
+            log.info("linking %s -> %s", dst_name, link_dest)
+        if not dry_run:
+            os.symlink(link_dest, dst_name)
+        yield dst_name
+
+    elif os.path.isdir(src_name):
+        yield from copy_tree(
+            src_name,
+            dst_name,
+            preserve_mode,
+            preserve_times,
+            preserve_symlinks,
+            update,
+            verbose=verbose,
+            dry_run=dry_run,
+        )
+    else:
+        file_util.copy_file(
+            src_name,
+            dst_name,
+            preserve_mode,
+            preserve_times,
+            update,
+            verbose=verbose,
+            dry_run=dry_run,
+        )
+        yield dst_name
+
+
+def _build_cmdtuple(path, cmdtuples):
+    """Helper for remove_tree()."""
+    for f in os.listdir(path):
+        real_f = os.path.join(path, f)
+        if os.path.isdir(real_f) and not os.path.islink(real_f):
+            _build_cmdtuple(real_f, cmdtuples)
+        else:
+            cmdtuples.append((os.remove, real_f))
+    cmdtuples.append((os.rmdir, path))
+
+
+def remove_tree(directory, verbose=True, dry_run=False):
+    """Recursively remove an entire directory tree.
+
+    Any errors are ignored (apart from being reported to stdout if 'verbose'
+    is true).
+    """
+    if verbose >= 1:
+        log.info("removing '%s' (and everything under it)", directory)
+    if dry_run:
+        return
+    cmdtuples = []
+    _build_cmdtuple(directory, cmdtuples)
+    for cmd in cmdtuples:
+        try:
+            cmd[0](cmd[1])
+            # Clear the cache
+            SkipRepeatAbsolutePaths.clear()
+        except OSError as exc:
+            log.warning("error removing %s: %s", directory, exc)
+
+
+def ensure_relative(path):
+    """Take the full path 'path', and make it a relative path.
+
+    This is useful to make 'path' the second argument to os.path.join().
+    """
+    drive, path = os.path.splitdrive(path)
+    if path[0:1] == os.sep:
+        path = drive + path[1:]
+    return path
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/dist.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/dist.py
new file mode 100644
index 0000000000000000000000000000000000000000..37b788df92549877684c2311ed1c71634f14dcd2
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/dist.py
@@ -0,0 +1,1386 @@
+"""distutils.dist
+
+Provides the Distribution class, which represents the module distribution
+being built/installed/distributed.
+"""
+
+from __future__ import annotations
+
+import contextlib
+import logging
+import os
+import pathlib
+import re
+import sys
+import warnings
+from collections.abc import Iterable, MutableMapping
+from email import message_from_file
+from typing import (
+    IO,
+    TYPE_CHECKING,
+    Any,
+    ClassVar,
+    Literal,
+    TypeVar,
+    Union,
+    overload,
+)
+
+from packaging.utils import canonicalize_name, canonicalize_version
+
+from ._log import log
+from .debug import DEBUG
+from .errors import (
+    DistutilsArgError,
+    DistutilsClassError,
+    DistutilsModuleError,
+    DistutilsOptionError,
+)
+from .fancy_getopt import FancyGetopt, translate_longopt
+from .util import check_environ, rfc822_escape, strtobool
+
+if TYPE_CHECKING:
+    from _typeshed import SupportsWrite
+    from typing_extensions import TypeAlias
+
+    # type-only import because of mutual dependence between these modules
+    from .cmd import Command
+
+_CommandT = TypeVar("_CommandT", bound="Command")
+_OptionsList: TypeAlias = list[
+    Union[tuple[str, Union[str, None], str, int], tuple[str, Union[str, None], str]]
+]
+
+
+# Regex to define acceptable Distutils command names.  This is not *quite*
+# the same as a Python NAME -- I don't allow leading underscores.  The fact
+# that they're very similar is no coincidence; the default naming scheme is
+# to look for a Python module named after the command.
+command_re = re.compile(r'^[a-zA-Z]([a-zA-Z0-9_]*)$')
+
+
+def _ensure_list(value: str | Iterable[str], fieldname) -> str | list[str]:
+    if isinstance(value, str):
+        # a string containing comma separated values is okay.  It will
+        # be converted to a list by Distribution.finalize_options().
+        pass
+    elif not isinstance(value, list):
+        # passing a tuple or an iterator perhaps, warn and convert
+        typename = type(value).__name__
+        msg = "Warning: '{fieldname}' should be a list, got type '{typename}'"
+        msg = msg.format(**locals())
+        log.warning(msg)
+        value = list(value)
+    return value
+
+
+class Distribution:
+    """The core of the Distutils.  Most of the work hiding behind 'setup'
+    is really done within a Distribution instance, which farms the work out
+    to the Distutils commands specified on the command line.
+
+    Setup scripts will almost never instantiate Distribution directly,
+    unless the 'setup()' function is totally inadequate to their needs.
+    However, it is conceivable that a setup script might wish to subclass
+    Distribution for some specialized purpose, and then pass the subclass
+    to 'setup()' as the 'distclass' keyword argument.  If so, it is
+    necessary to respect the expectations that 'setup' has of Distribution.
+    See the code for 'setup()', in core.py, for details.
+    """
+
+    # 'global_options' describes the command-line options that may be
+    # supplied to the setup script prior to any actual commands.
+    # Eg. "./setup.py -n" or "./setup.py --quiet" both take advantage of
+    # these global options.  This list should be kept to a bare minimum,
+    # since every global option is also valid as a command option -- and we
+    # don't want to pollute the commands with too many options that they
+    # have minimal control over.
+    # The fourth entry for verbose means that it can be repeated.
+    global_options: ClassVar[_OptionsList] = [
+        ('verbose', 'v', "run verbosely (default)", 1),
+        ('quiet', 'q', "run quietly (turns verbosity off)"),
+        ('dry-run', 'n', "don't actually do anything"),
+        ('help', 'h', "show detailed help message"),
+        ('no-user-cfg', None, 'ignore pydistutils.cfg in your home directory'),
+    ]
+
+    # 'common_usage' is a short (2-3 line) string describing the common
+    # usage of the setup script.
+    common_usage: ClassVar[str] = """\
+Common commands: (see '--help-commands' for more)
+
+  setup.py build      will build the package underneath 'build/'
+  setup.py install    will install the package
+"""
+
+    # options that are not propagated to the commands
+    display_options: ClassVar[_OptionsList] = [
+        ('help-commands', None, "list all available commands"),
+        ('name', None, "print package name"),
+        ('version', 'V', "print package version"),
+        ('fullname', None, "print <package name>-<version>"),
+        ('author', None, "print the author's name"),
+        ('author-email', None, "print the author's email address"),
+        ('maintainer', None, "print the maintainer's name"),
+        ('maintainer-email', None, "print the maintainer's email address"),
+        ('contact', None, "print the maintainer's name if known, else the author's"),
+        (
+            'contact-email',
+            None,
+            "print the maintainer's email address if known, else the author's",
+        ),
+        ('url', None, "print the URL for this package"),
+        ('license', None, "print the license of the package"),
+        ('licence', None, "alias for --license"),
+        ('description', None, "print the package description"),
+        ('long-description', None, "print the long package description"),
+        ('platforms', None, "print the list of platforms"),
+        ('classifiers', None, "print the list of classifiers"),
+        ('keywords', None, "print the list of keywords"),
+        ('provides', None, "print the list of packages/modules provided"),
+        ('requires', None, "print the list of packages/modules required"),
+        ('obsoletes', None, "print the list of packages/modules made obsolete"),
+    ]
+    display_option_names: ClassVar[list[str]] = [
+        translate_longopt(x[0]) for x in display_options
+    ]
+
+    # negative options are options that exclude other options
+    negative_opt: ClassVar[dict[str, str]] = {'quiet': 'verbose'}
+
+    # -- Creation/initialization methods -------------------------------
+
+    # Can't Unpack a TypedDict with optional properties, so using Any instead
+    def __init__(self, attrs: MutableMapping[str, Any] | None = None) -> None:  # noqa: C901
+        """Construct a new Distribution instance: initialize all the
+        attributes of a Distribution, and then use 'attrs' (a dictionary
+        mapping attribute names to values) to assign some of those
+        attributes their "real" values.  (Any attributes not mentioned in
+        'attrs' will be assigned to some null value: 0, None, an empty list
+        or dictionary, etc.)  Most importantly, initialize the
+        'command_obj' attribute to the empty dictionary; this will be
+        filled in with real command objects by 'parse_command_line()'.
+        """
+
+        # Default values for our command-line options
+        self.verbose = True
+        self.dry_run = False
+        self.help = False
+        for attr in self.display_option_names:
+            setattr(self, attr, False)
+
+        # Store the distribution meta-data (name, version, author, and so
+        # forth) in a separate object -- we're getting to have enough
+        # information here (and enough command-line options) that it's
+        # worth it.  Also delegate 'get_XXX()' methods to the 'metadata'
+        # object in a sneaky and underhanded (but efficient!) way.
+        self.metadata = DistributionMetadata()
+        for basename in self.metadata._METHOD_BASENAMES:
+            method_name = "get_" + basename
+            setattr(self, method_name, getattr(self.metadata, method_name))
+
+        # 'cmdclass' maps command names to class objects, so we
+        # can 1) quickly figure out which class to instantiate when
+        # we need to create a new command object, and 2) have a way
+        # for the setup script to override command classes
+        self.cmdclass: dict[str, type[Command]] = {}
+
+        # 'command_packages' is a list of packages in which commands
+        # are searched for.  The factory for command 'foo' is expected
+        # to be named 'foo' in the module 'foo' in one of the packages
+        # named here.  This list is searched from the left; an error
+        # is raised if no named package provides the command being
+        # searched for.  (Always access using get_command_packages().)
+        self.command_packages: str | list[str] | None = None
+
+        # 'script_name' and 'script_args' are usually set to sys.argv[0]
+        # and sys.argv[1:], but they can be overridden when the caller is
+        # not necessarily a setup script run from the command-line.
+        self.script_name: str | os.PathLike[str] | None = None
+        self.script_args: list[str] | None = None
+
+        # 'command_options' is where we store command options between
+        # parsing them (from config files, the command-line, etc.) and when
+        # they are actually needed -- ie. when the command in question is
+        # instantiated.  It is a dictionary of dictionaries of 2-tuples:
+        #   command_options = { command_name : { option : (source, value) } }
+        self.command_options: dict[str, dict[str, tuple[str, str]]] = {}
+
+        # 'dist_files' is the list of (command, pyversion, file) that
+        # have been created by any dist commands run so far. This is
+        # filled regardless of whether the run is dry or not. pyversion
+        # gives sysconfig.get_python_version() if the dist file is
+        # specific to a Python version, 'any' if it is good for all
+        # Python versions on the target platform, and '' for a source
+        # file. pyversion should not be used to specify minimum or
+        # maximum required Python versions; use the metainfo for that
+        # instead.
+        self.dist_files: list[tuple[str, str, str]] = []
+
+        # These options are really the business of various commands, rather
+        # than of the Distribution itself.  We provide aliases for them in
+        # Distribution as a convenience to the developer.
+        self.packages = None
+        self.package_data: dict[str, list[str]] = {}
+        self.package_dir = None
+        self.py_modules = None
+        self.libraries = None
+        self.headers = None
+        self.ext_modules = None
+        self.ext_package = None
+        self.include_dirs = None
+        self.extra_path = None
+        self.scripts = None
+        self.data_files = None
+        self.password = ''
+
+        # And now initialize bookkeeping stuff that can't be supplied by
+        # the caller at all.  'command_obj' maps command names to
+        # Command instances -- that's how we enforce that every command
+        # class is a singleton.
+        self.command_obj: dict[str, Command] = {}
+
+        # 'have_run' maps command names to boolean values; it keeps track
+        # of whether we have actually run a particular command, to make it
+        # cheap to "run" a command whenever we think we might need to -- if
+        # it's already been done, no need for expensive filesystem
+        # operations, we just check the 'have_run' dictionary and carry on.
+        # It's only safe to query 'have_run' for a command class that has
+        # been instantiated -- a false value will be inserted when the
+        # command object is created, and replaced with a true value when
+        # the command is successfully run.  Thus it's probably best to use
+        # '.get()' rather than a straight lookup.
+        self.have_run: dict[str, bool] = {}
+
+        # Now we'll use the attrs dictionary (ultimately, keyword args from
+        # the setup script) to possibly override any or all of these
+        # distribution options.
+
+        if attrs:
+            # Pull out the set of command options and work on them
+            # specifically.  Note that this order guarantees that aliased
+            # command options will override any supplied redundantly
+            # through the general options dictionary.
+            options = attrs.get('options')
+            if options is not None:
+                del attrs['options']
+                for command, cmd_options in options.items():
+                    opt_dict = self.get_option_dict(command)
+                    for opt, val in cmd_options.items():
+                        opt_dict[opt] = ("setup script", val)
+
+            if 'licence' in attrs:
+                attrs['license'] = attrs['licence']
+                del attrs['licence']
+                msg = "'licence' distribution option is deprecated; use 'license'"
+                warnings.warn(msg)
+
+            # Now work on the rest of the attributes.  Any attribute that's
+            # not already defined is invalid!
+            for key, val in attrs.items():
+                if hasattr(self.metadata, "set_" + key):
+                    getattr(self.metadata, "set_" + key)(val)
+                elif hasattr(self.metadata, key):
+                    setattr(self.metadata, key, val)
+                elif hasattr(self, key):
+                    setattr(self, key, val)
+                else:
+                    msg = f"Unknown distribution option: {key!r}"
+                    warnings.warn(msg)
+
+        # no-user-cfg is handled before other command line args
+        # because other args override the config files, and this
+        # one is needed before we can load the config files.
+        # If attrs['script_args'] wasn't passed, assume false.
+        #
+        # This also make sure we just look at the global options
+        self.want_user_cfg = True
+
+        if self.script_args is not None:
+            # Coerce any possible iterable from attrs into a list
+            self.script_args = list(self.script_args)
+            for arg in self.script_args:
+                if not arg.startswith('-'):
+                    break
+                if arg == '--no-user-cfg':
+                    self.want_user_cfg = False
+                    break
+
+        self.finalize_options()
+
+    def get_option_dict(self, command):
+        """Get the option dictionary for a given command.  If that
+        command's option dictionary hasn't been created yet, then create it
+        and return the new dictionary; otherwise, return the existing
+        option dictionary.
+        """
+        dict = self.command_options.get(command)
+        if dict is None:
+            dict = self.command_options[command] = {}
+        return dict
+
+    def dump_option_dicts(self, header=None, commands=None, indent: str = "") -> None:
+        from pprint import pformat
+
+        if commands is None:  # dump all command option dicts
+            commands = sorted(self.command_options.keys())
+
+        if header is not None:
+            self.announce(indent + header)
+            indent = indent + "  "
+
+        if not commands:
+            self.announce(indent + "no commands known yet")
+            return
+
+        for cmd_name in commands:
+            opt_dict = self.command_options.get(cmd_name)
+            if opt_dict is None:
+                self.announce(indent + f"no option dict for '{cmd_name}' command")
+            else:
+                self.announce(indent + f"option dict for '{cmd_name}' command:")
+                out = pformat(opt_dict)
+                for line in out.split('\n'):
+                    self.announce(indent + "  " + line)
+
+    # -- Config file finding/parsing methods ---------------------------
+
+    def find_config_files(self):
+        """Find as many configuration files as should be processed for this
+        platform, and return a list of filenames in the order in which they
+        should be parsed.  The filenames returned are guaranteed to exist
+        (modulo nasty race conditions).
+
+        There are multiple possible config files:
+        - distutils.cfg in the Distutils installation directory (i.e.
+          where the top-level Distutils __inst__.py file lives)
+        - a file in the user's home directory named .pydistutils.cfg
+          on Unix and pydistutils.cfg on Windows/Mac; may be disabled
+          with the ``--no-user-cfg`` option
+        - setup.cfg in the current directory
+        - a file named by an environment variable
+        """
+        check_environ()
+        files = [str(path) for path in self._gen_paths() if os.path.isfile(path)]
+
+        if DEBUG:
+            self.announce("using config files: {}".format(', '.join(files)))
+
+        return files
+
+    def _gen_paths(self):
+        # The system-wide Distutils config file
+        sys_dir = pathlib.Path(sys.modules['distutils'].__file__).parent
+        yield sys_dir / "distutils.cfg"
+
+        # The per-user config file
+        prefix = '.' * (os.name == 'posix')
+        filename = prefix + 'pydistutils.cfg'
+        if self.want_user_cfg:
+            with contextlib.suppress(RuntimeError):
+                yield pathlib.Path('~').expanduser() / filename
+
+        # All platforms support local setup.cfg
+        yield pathlib.Path('setup.cfg')
+
+        # Additional config indicated in the environment
+        with contextlib.suppress(TypeError):
+            yield pathlib.Path(os.getenv("DIST_EXTRA_CONFIG"))
+
+    def parse_config_files(self, filenames=None):  # noqa: C901
+        from configparser import ConfigParser
+
+        # Ignore install directory options if we have a venv
+        if sys.prefix != sys.base_prefix:
+            ignore_options = [
+                'install-base',
+                'install-platbase',
+                'install-lib',
+                'install-platlib',
+                'install-purelib',
+                'install-headers',
+                'install-scripts',
+                'install-data',
+                'prefix',
+                'exec-prefix',
+                'home',
+                'user',
+                'root',
+            ]
+        else:
+            ignore_options = []
+
+        ignore_options = frozenset(ignore_options)
+
+        if filenames is None:
+            filenames = self.find_config_files()
+
+        if DEBUG:
+            self.announce("Distribution.parse_config_files():")
+
+        parser = ConfigParser()
+        for filename in filenames:
+            if DEBUG:
+                self.announce(f"  reading {filename}")
+            parser.read(filename, encoding='utf-8')
+            for section in parser.sections():
+                options = parser.options(section)
+                opt_dict = self.get_option_dict(section)
+
+                for opt in options:
+                    if opt != '__name__' and opt not in ignore_options:
+                        val = parser.get(section, opt)
+                        opt = opt.replace('-', '_')
+                        opt_dict[opt] = (filename, val)
+
+            # Make the ConfigParser forget everything (so we retain
+            # the original filenames that options come from)
+            parser.__init__()
+
+        # If there was a "global" section in the config file, use it
+        # to set Distribution options.
+
+        if 'global' in self.command_options:
+            for opt, (_src, val) in self.command_options['global'].items():
+                alias = self.negative_opt.get(opt)
+                try:
+                    if alias:
+                        setattr(self, alias, not strtobool(val))
+                    elif opt in ('verbose', 'dry_run'):  # ugh!
+                        setattr(self, opt, strtobool(val))
+                    else:
+                        setattr(self, opt, val)
+                except ValueError as msg:
+                    raise DistutilsOptionError(msg)
+
+    # -- Command-line parsing methods ----------------------------------
+
+    def parse_command_line(self):
+        """Parse the setup script's command line, taken from the
+        'script_args' instance attribute (which defaults to 'sys.argv[1:]'
+        -- see 'setup()' in core.py).  This list is first processed for
+        "global options" -- options that set attributes of the Distribution
+        instance.  Then, it is alternately scanned for Distutils commands
+        and options for that command.  Each new command terminates the
+        options for the previous command.  The allowed options for a
+        command are determined by the 'user_options' attribute of the
+        command class -- thus, we have to be able to load command classes
+        in order to parse the command line.  Any error in that 'options'
+        attribute raises DistutilsGetoptError; any error on the
+        command-line raises DistutilsArgError.  If no Distutils commands
+        were found on the command line, raises DistutilsArgError.  Return
+        true if command-line was successfully parsed and we should carry
+        on with executing commands; false if no errors but we shouldn't
+        execute commands (currently, this only happens if user asks for
+        help).
+        """
+        #
+        # We now have enough information to show the Macintosh dialog
+        # that allows the user to interactively specify the "command line".
+        #
+        toplevel_options = self._get_toplevel_options()
+
+        # We have to parse the command line a bit at a time -- global
+        # options, then the first command, then its options, and so on --
+        # because each command will be handled by a different class, and
+        # the options that are valid for a particular class aren't known
+        # until we have loaded the command class, which doesn't happen
+        # until we know what the command is.
+
+        self.commands = []
+        parser = FancyGetopt(toplevel_options + self.display_options)
+        parser.set_negative_aliases(self.negative_opt)
+        parser.set_aliases({'licence': 'license'})
+        args = parser.getopt(args=self.script_args, object=self)
+        option_order = parser.get_option_order()
+        logging.getLogger().setLevel(logging.WARN - 10 * self.verbose)
+
+        # for display options we return immediately
+        if self.handle_display_options(option_order):
+            return
+        while args:
+            args = self._parse_command_opts(parser, args)
+            if args is None:  # user asked for help (and got it)
+                return
+
+        # Handle the cases of --help as a "global" option, ie.
+        # "setup.py --help" and "setup.py --help command ...".  For the
+        # former, we show global options (--verbose, --dry-run, etc.)
+        # and display-only options (--name, --version, etc.); for the
+        # latter, we omit the display-only options and show help for
+        # each command listed on the command line.
+        if self.help:
+            self._show_help(
+                parser, display_options=len(self.commands) == 0, commands=self.commands
+            )
+            return
+
+        # Oops, no commands found -- an end-user error
+        if not self.commands:
+            raise DistutilsArgError("no commands supplied")
+
+        # All is well: return true
+        return True
+
+    def _get_toplevel_options(self):
+        """Return the non-display options recognized at the top level.
+
+        This includes options that are recognized *only* at the top
+        level as well as options recognized for commands.
+        """
+        return self.global_options + [
+            (
+                "command-packages=",
+                None,
+                "list of packages that provide distutils commands",
+            ),
+        ]
+
+    def _parse_command_opts(self, parser, args):  # noqa: C901
+        """Parse the command-line options for a single command.
+        'parser' must be a FancyGetopt instance; 'args' must be the list
+        of arguments, starting with the current command (whose options
+        we are about to parse).  Returns a new version of 'args' with
+        the next command at the front of the list; will be the empty
+        list if there are no more commands on the command line.  Returns
+        None if the user asked for help on this command.
+        """
+        # late import because of mutual dependence between these modules
+        from distutils.cmd import Command
+
+        # Pull the current command from the head of the command line
+        command = args[0]
+        if not command_re.match(command):
+            raise SystemExit(f"invalid command name '{command}'")
+        self.commands.append(command)
+
+        # Dig up the command class that implements this command, so we
+        # 1) know that it's a valid command, and 2) know which options
+        # it takes.
+        try:
+            cmd_class = self.get_command_class(command)
+        except DistutilsModuleError as msg:
+            raise DistutilsArgError(msg)
+
+        # Require that the command class be derived from Command -- want
+        # to be sure that the basic "command" interface is implemented.
+        if not issubclass(cmd_class, Command):
+            raise DistutilsClassError(
+                f"command class {cmd_class} must subclass Command"
+            )
+
+        # Also make sure that the command object provides a list of its
+        # known options.
+        if not (
+            hasattr(cmd_class, 'user_options')
+            and isinstance(cmd_class.user_options, list)
+        ):
+            msg = (
+                "command class %s must provide "
+                "'user_options' attribute (a list of tuples)"
+            )
+            raise DistutilsClassError(msg % cmd_class)
+
+        # If the command class has a list of negative alias options,
+        # merge it in with the global negative aliases.
+        negative_opt = self.negative_opt
+        if hasattr(cmd_class, 'negative_opt'):
+            negative_opt = negative_opt.copy()
+            negative_opt.update(cmd_class.negative_opt)
+
+        # Check for help_options in command class.  They have a different
+        # format (tuple of four) so we need to preprocess them here.
+        if hasattr(cmd_class, 'help_options') and isinstance(
+            cmd_class.help_options, list
+        ):
+            help_options = fix_help_options(cmd_class.help_options)
+        else:
+            help_options = []
+
+        # All commands support the global options too, just by adding
+        # in 'global_options'.
+        parser.set_option_table(
+            self.global_options + cmd_class.user_options + help_options
+        )
+        parser.set_negative_aliases(negative_opt)
+        (args, opts) = parser.getopt(args[1:])
+        if hasattr(opts, 'help') and opts.help:
+            self._show_help(parser, display_options=False, commands=[cmd_class])
+            return
+
+        if hasattr(cmd_class, 'help_options') and isinstance(
+            cmd_class.help_options, list
+        ):
+            help_option_found = 0
+            for help_option, _short, _desc, func in cmd_class.help_options:
+                if hasattr(opts, parser.get_attr_name(help_option)):
+                    help_option_found = 1
+                    if callable(func):
+                        func()
+                    else:
+                        raise DistutilsClassError(
+                            f"invalid help function {func!r} for help option '{help_option}': "
+                            "must be a callable object (function, etc.)"
+                        )
+
+            if help_option_found:
+                return
+
+        # Put the options from the command-line into their official
+        # holding pen, the 'command_options' dictionary.
+        opt_dict = self.get_option_dict(command)
+        for name, value in vars(opts).items():
+            opt_dict[name] = ("command line", value)
+
+        return args
+
+    def finalize_options(self) -> None:
+        """Set final values for all the options on the Distribution
+        instance, analogous to the .finalize_options() method of Command
+        objects.
+        """
+        for attr in ('keywords', 'platforms'):
+            value = getattr(self.metadata, attr)
+            if value is None:
+                continue
+            if isinstance(value, str):
+                value = [elm.strip() for elm in value.split(',')]
+                setattr(self.metadata, attr, value)
+
+    def _show_help(
+        self, parser, global_options=True, display_options=True, commands: Iterable = ()
+    ):
+        """Show help for the setup script command-line in the form of
+        several lists of command-line options.  'parser' should be a
+        FancyGetopt instance; do not expect it to be returned in the
+        same state, as its option table will be reset to make it
+        generate the correct help text.
+
+        If 'global_options' is true, lists the global options:
+        --verbose, --dry-run, etc.  If 'display_options' is true, lists
+        the "display-only" options: --name, --version, etc.  Finally,
+        lists per-command help for every command name or command class
+        in 'commands'.
+        """
+        # late import because of mutual dependence between these modules
+        from distutils.cmd import Command
+        from distutils.core import gen_usage
+
+        if global_options:
+            if display_options:
+                options = self._get_toplevel_options()
+            else:
+                options = self.global_options
+            parser.set_option_table(options)
+            parser.print_help(self.common_usage + "\nGlobal options:")
+            print()
+
+        if display_options:
+            parser.set_option_table(self.display_options)
+            parser.print_help(
+                "Information display options (just display information, ignore any commands)"
+            )
+            print()
+
+        for command in commands:
+            if isinstance(command, type) and issubclass(command, Command):
+                klass = command
+            else:
+                klass = self.get_command_class(command)
+            if hasattr(klass, 'help_options') and isinstance(klass.help_options, list):
+                parser.set_option_table(
+                    klass.user_options + fix_help_options(klass.help_options)
+                )
+            else:
+                parser.set_option_table(klass.user_options)
+            parser.print_help(f"Options for '{klass.__name__}' command:")
+            print()
+
+        print(gen_usage(self.script_name))
+
+    def handle_display_options(self, option_order):
+        """If there were any non-global "display-only" options
+        (--help-commands or the metadata display options) on the command
+        line, display the requested info and return true; else return
+        false.
+        """
+        from distutils.core import gen_usage
+
+        # User just wants a list of commands -- we'll print it out and stop
+        # processing now (ie. if they ran "setup --help-commands foo bar",
+        # we ignore "foo bar").
+        if self.help_commands:
+            self.print_commands()
+            print()
+            print(gen_usage(self.script_name))
+            return 1
+
+        # If user supplied any of the "display metadata" options, then
+        # display that metadata in the order in which the user supplied the
+        # metadata options.
+        any_display_options = 0
+        is_display_option = set()
+        for option in self.display_options:
+            is_display_option.add(option[0])
+
+        for opt, val in option_order:
+            if val and opt in is_display_option:
+                opt = translate_longopt(opt)
+                value = getattr(self.metadata, "get_" + opt)()
+                if opt in ('keywords', 'platforms'):
+                    print(','.join(value))
+                elif opt in ('classifiers', 'provides', 'requires', 'obsoletes'):
+                    print('\n'.join(value))
+                else:
+                    print(value)
+                any_display_options = 1
+
+        return any_display_options
+
+    def print_command_list(self, commands, header, max_length) -> None:
+        """Print a subset of the list of all commands -- used by
+        'print_commands()'.
+        """
+        print(header + ":")
+
+        for cmd in commands:
+            klass = self.cmdclass.get(cmd)
+            if not klass:
+                klass = self.get_command_class(cmd)
+            try:
+                description = klass.description
+            except AttributeError:
+                description = "(no description available)"
+
+            print(f"  {cmd:<{max_length}}  {description}")
+
+    def print_commands(self) -> None:
+        """Print out a help message listing all available commands with a
+        description of each.  The list is divided into "standard commands"
+        (listed in distutils.command.__all__) and "extra commands"
+        (mentioned in self.cmdclass, but not a standard command).  The
+        descriptions come from the command class attribute
+        'description'.
+        """
+        import distutils.command
+
+        std_commands = distutils.command.__all__
+        is_std = set(std_commands)
+
+        extra_commands = [cmd for cmd in self.cmdclass.keys() if cmd not in is_std]
+
+        max_length = 0
+        for cmd in std_commands + extra_commands:
+            if len(cmd) > max_length:
+                max_length = len(cmd)
+
+        self.print_command_list(std_commands, "Standard commands", max_length)
+        if extra_commands:
+            print()
+            self.print_command_list(extra_commands, "Extra commands", max_length)
+
+    def get_command_list(self):
+        """Get a list of (command, description) tuples.
+        The list is divided into "standard commands" (listed in
+        distutils.command.__all__) and "extra commands" (mentioned in
+        self.cmdclass, but not a standard command).  The descriptions come
+        from the command class attribute 'description'.
+        """
+        # Currently this is only used on Mac OS, for the Mac-only GUI
+        # Distutils interface (by Jack Jansen)
+        import distutils.command
+
+        std_commands = distutils.command.__all__
+        is_std = set(std_commands)
+
+        extra_commands = [cmd for cmd in self.cmdclass.keys() if cmd not in is_std]
+
+        rv = []
+        for cmd in std_commands + extra_commands:
+            klass = self.cmdclass.get(cmd)
+            if not klass:
+                klass = self.get_command_class(cmd)
+            try:
+                description = klass.description
+            except AttributeError:
+                description = "(no description available)"
+            rv.append((cmd, description))
+        return rv
+
+    # -- Command class/object methods ----------------------------------
+
+    def get_command_packages(self):
+        """Return a list of packages from which commands are loaded."""
+        pkgs = self.command_packages
+        if not isinstance(pkgs, list):
+            if pkgs is None:
+                pkgs = ''
+            pkgs = [pkg.strip() for pkg in pkgs.split(',') if pkg != '']
+            if "distutils.command" not in pkgs:
+                pkgs.insert(0, "distutils.command")
+            self.command_packages = pkgs
+        return pkgs
+
+    def get_command_class(self, command: str) -> type[Command]:
+        """Return the class that implements the Distutils command named by
+        'command'.  First we check the 'cmdclass' dictionary; if the
+        command is mentioned there, we fetch the class object from the
+        dictionary and return it.  Otherwise we load the command module
+        ("distutils.command." + command) and fetch the command class from
+        the module.  The loaded class is also stored in 'cmdclass'
+        to speed future calls to 'get_command_class()'.
+
+        Raises DistutilsModuleError if the expected module could not be
+        found, or if that module does not define the expected class.
+        """
+        klass = self.cmdclass.get(command)
+        if klass:
+            return klass
+
+        for pkgname in self.get_command_packages():
+            module_name = f"{pkgname}.{command}"
+            klass_name = command
+
+            try:
+                __import__(module_name)
+                module = sys.modules[module_name]
+            except ImportError:
+                continue
+
+            try:
+                klass = getattr(module, klass_name)
+            except AttributeError:
+                raise DistutilsModuleError(
+                    f"invalid command '{command}' (no class '{klass_name}' in module '{module_name}')"
+                )
+
+            self.cmdclass[command] = klass
+            return klass
+
+        raise DistutilsModuleError(f"invalid command '{command}'")
+
+    @overload
+    def get_command_obj(
+        self, command: str, create: Literal[True] = True
+    ) -> Command: ...
+    @overload
+    def get_command_obj(
+        self, command: str, create: Literal[False]
+    ) -> Command | None: ...
+    def get_command_obj(self, command: str, create: bool = True) -> Command | None:
+        """Return the command object for 'command'.  Normally this object
+        is cached on a previous call to 'get_command_obj()'; if no command
+        object for 'command' is in the cache, then we either create and
+        return it (if 'create' is true) or return None.
+        """
+        cmd_obj = self.command_obj.get(command)
+        if not cmd_obj and create:
+            if DEBUG:
+                self.announce(
+                    "Distribution.get_command_obj(): "
+                    f"creating '{command}' command object"
+                )
+
+            klass = self.get_command_class(command)
+            cmd_obj = self.command_obj[command] = klass(self)
+            self.have_run[command] = False
+
+            # Set any options that were supplied in config files
+            # or on the command line.  (NB. support for error
+            # reporting is lame here: any errors aren't reported
+            # until 'finalize_options()' is called, which means
+            # we won't report the source of the error.)
+            options = self.command_options.get(command)
+            if options:
+                self._set_command_options(cmd_obj, options)
+
+        return cmd_obj
+
+    def _set_command_options(self, command_obj, option_dict=None):  # noqa: C901
+        """Set the options for 'command_obj' from 'option_dict'.  Basically
+        this means copying elements of a dictionary ('option_dict') to
+        attributes of an instance ('command').
+
+        'command_obj' must be a Command instance.  If 'option_dict' is not
+        supplied, uses the standard option dictionary for this command
+        (from 'self.command_options').
+        """
+        command_name = command_obj.get_command_name()
+        if option_dict is None:
+            option_dict = self.get_option_dict(command_name)
+
+        if DEBUG:
+            self.announce(f"  setting options for '{command_name}' command:")
+        for option, (source, value) in option_dict.items():
+            if DEBUG:
+                self.announce(f"    {option} = {value} (from {source})")
+            try:
+                bool_opts = [translate_longopt(o) for o in command_obj.boolean_options]
+            except AttributeError:
+                bool_opts = []
+            try:
+                neg_opt = command_obj.negative_opt
+            except AttributeError:
+                neg_opt = {}
+
+            try:
+                is_string = isinstance(value, str)
+                if option in neg_opt and is_string:
+                    setattr(command_obj, neg_opt[option], not strtobool(value))
+                elif option in bool_opts and is_string:
+                    setattr(command_obj, option, strtobool(value))
+                elif hasattr(command_obj, option):
+                    setattr(command_obj, option, value)
+                else:
+                    raise DistutilsOptionError(
+                        f"error in {source}: command '{command_name}' has no such option '{option}'"
+                    )
+            except ValueError as msg:
+                raise DistutilsOptionError(msg)
+
+    @overload
+    def reinitialize_command(
+        self, command: str, reinit_subcommands: bool = False
+    ) -> Command: ...
+    @overload
+    def reinitialize_command(
+        self, command: _CommandT, reinit_subcommands: bool = False
+    ) -> _CommandT: ...
+    def reinitialize_command(
+        self, command: str | Command, reinit_subcommands=False
+    ) -> Command:
+        """Reinitializes a command to the state it was in when first
+        returned by 'get_command_obj()': ie., initialized but not yet
+        finalized.  This provides the opportunity to sneak option
+        values in programmatically, overriding or supplementing
+        user-supplied values from the config files and command line.
+        You'll have to re-finalize the command object (by calling
+        'finalize_options()' or 'ensure_finalized()') before using it for
+        real.
+
+        'command' should be a command name (string) or command object.  If
+        'reinit_subcommands' is true, also reinitializes the command's
+        sub-commands, as declared by the 'sub_commands' class attribute (if
+        it has one).  See the "install" command for an example.  Only
+        reinitializes the sub-commands that actually matter, ie. those
+        whose test predicates return true.
+
+        Returns the reinitialized command object.
+        """
+        from distutils.cmd import Command
+
+        if not isinstance(command, Command):
+            command_name = command
+            command = self.get_command_obj(command_name)
+        else:
+            command_name = command.get_command_name()
+
+        if not command.finalized:
+            return command
+        command.initialize_options()
+        command.finalized = False
+        self.have_run[command_name] = False
+        self._set_command_options(command)
+
+        if reinit_subcommands:
+            for sub in command.get_sub_commands():
+                self.reinitialize_command(sub, reinit_subcommands)
+
+        return command
+
+    # -- Methods that operate on the Distribution ----------------------
+
+    def announce(self, msg, level: int = logging.INFO) -> None:
+        log.log(level, msg)
+
+    def run_commands(self) -> None:
+        """Run each command that was seen on the setup script command line.
+        Uses the list of commands found and cache of command objects
+        created by 'get_command_obj()'.
+        """
+        for cmd in self.commands:
+            self.run_command(cmd)
+
+    # -- Methods that operate on its Commands --------------------------
+
+    def run_command(self, command: str) -> None:
+        """Do whatever it takes to run a command (including nothing at all,
+        if the command has already been run).  Specifically: if we have
+        already created and run the command named by 'command', return
+        silently without doing anything.  If the command named by 'command'
+        doesn't even have a command object yet, create one.  Then invoke
+        'run()' on that command object (or an existing one).
+        """
+        # Already been here, done that? then return silently.
+        if self.have_run.get(command):
+            return
+
+        log.info("running %s", command)
+        cmd_obj = self.get_command_obj(command)
+        cmd_obj.ensure_finalized()
+        cmd_obj.run()
+        self.have_run[command] = True
+
+    # -- Distribution query methods ------------------------------------
+
+    def has_pure_modules(self) -> bool:
+        return len(self.packages or self.py_modules or []) > 0
+
+    def has_ext_modules(self) -> bool:
+        return self.ext_modules and len(self.ext_modules) > 0
+
+    def has_c_libraries(self) -> bool:
+        return self.libraries and len(self.libraries) > 0
+
+    def has_modules(self) -> bool:
+        return self.has_pure_modules() or self.has_ext_modules()
+
+    def has_headers(self) -> bool:
+        return self.headers and len(self.headers) > 0
+
+    def has_scripts(self) -> bool:
+        return self.scripts and len(self.scripts) > 0
+
+    def has_data_files(self) -> bool:
+        return self.data_files and len(self.data_files) > 0
+
+    def is_pure(self) -> bool:
+        return (
+            self.has_pure_modules()
+            and not self.has_ext_modules()
+            and not self.has_c_libraries()
+        )
+
+    # -- Metadata query methods ----------------------------------------
+
+    # If you're looking for 'get_name()', 'get_version()', and so forth,
+    # they are defined in a sneaky way: the constructor binds self.get_XXX
+    # to self.metadata.get_XXX.  The actual code is in the
+    # DistributionMetadata class, below.
+    if TYPE_CHECKING:
+        # Unfortunately this means we need to specify them manually or not expose statically
+        def _(self) -> None:
+            self.get_name = self.metadata.get_name
+            self.get_version = self.metadata.get_version
+            self.get_fullname = self.metadata.get_fullname
+            self.get_author = self.metadata.get_author
+            self.get_author_email = self.metadata.get_author_email
+            self.get_maintainer = self.metadata.get_maintainer
+            self.get_maintainer_email = self.metadata.get_maintainer_email
+            self.get_contact = self.metadata.get_contact
+            self.get_contact_email = self.metadata.get_contact_email
+            self.get_url = self.metadata.get_url
+            self.get_license = self.metadata.get_license
+            self.get_licence = self.metadata.get_licence
+            self.get_description = self.metadata.get_description
+            self.get_long_description = self.metadata.get_long_description
+            self.get_keywords = self.metadata.get_keywords
+            self.get_platforms = self.metadata.get_platforms
+            self.get_classifiers = self.metadata.get_classifiers
+            self.get_download_url = self.metadata.get_download_url
+            self.get_requires = self.metadata.get_requires
+            self.get_provides = self.metadata.get_provides
+            self.get_obsoletes = self.metadata.get_obsoletes
+
+        # Default attributes generated in __init__ from self.display_option_names
+        help_commands: bool
+        name: str | Literal[False]
+        version: str | Literal[False]
+        fullname: str | Literal[False]
+        author: str | Literal[False]
+        author_email: str | Literal[False]
+        maintainer: str | Literal[False]
+        maintainer_email: str | Literal[False]
+        contact: str | Literal[False]
+        contact_email: str | Literal[False]
+        url: str | Literal[False]
+        license: str | Literal[False]
+        licence: str | Literal[False]
+        description: str | Literal[False]
+        long_description: str | Literal[False]
+        platforms: str | list[str] | Literal[False]
+        classifiers: str | list[str] | Literal[False]
+        keywords: str | list[str] | Literal[False]
+        provides: list[str] | Literal[False]
+        requires: list[str] | Literal[False]
+        obsoletes: list[str] | Literal[False]
+
+
+class DistributionMetadata:
+    """Dummy class to hold the distribution meta-data: name, version,
+    author, and so forth.
+    """
+
+    _METHOD_BASENAMES = (
+        "name",
+        "version",
+        "author",
+        "author_email",
+        "maintainer",
+        "maintainer_email",
+        "url",
+        "license",
+        "description",
+        "long_description",
+        "keywords",
+        "platforms",
+        "fullname",
+        "contact",
+        "contact_email",
+        "classifiers",
+        "download_url",
+        # PEP 314
+        "provides",
+        "requires",
+        "obsoletes",
+    )
+
+    def __init__(
+        self, path: str | bytes | os.PathLike[str] | os.PathLike[bytes] | None = None
+    ) -> None:
+        if path is not None:
+            self.read_pkg_file(open(path))
+        else:
+            self.name: str | None = None
+            self.version: str | None = None
+            self.author: str | None = None
+            self.author_email: str | None = None
+            self.maintainer: str | None = None
+            self.maintainer_email: str | None = None
+            self.url: str | None = None
+            self.license: str | None = None
+            self.description: str | None = None
+            self.long_description: str | None = None
+            self.keywords: str | list[str] | None = None
+            self.platforms: str | list[str] | None = None
+            self.classifiers: str | list[str] | None = None
+            self.download_url: str | None = None
+            # PEP 314
+            self.provides: str | list[str] | None = None
+            self.requires: str | list[str] | None = None
+            self.obsoletes: str | list[str] | None = None
+
+    def read_pkg_file(self, file: IO[str]) -> None:
+        """Reads the metadata values from a file object."""
+        msg = message_from_file(file)
+
+        def _read_field(name: str) -> str | None:
+            value = msg[name]
+            if value and value != "UNKNOWN":
+                return value
+            return None
+
+        def _read_list(name):
+            values = msg.get_all(name, None)
+            if values == []:
+                return None
+            return values
+
+        metadata_version = msg['metadata-version']
+        self.name = _read_field('name')
+        self.version = _read_field('version')
+        self.description = _read_field('summary')
+        # we are filling author only.
+        self.author = _read_field('author')
+        self.maintainer = None
+        self.author_email = _read_field('author-email')
+        self.maintainer_email = None
+        self.url = _read_field('home-page')
+        self.license = _read_field('license')
+
+        if 'download-url' in msg:
+            self.download_url = _read_field('download-url')
+        else:
+            self.download_url = None
+
+        self.long_description = _read_field('description')
+        self.description = _read_field('summary')
+
+        if 'keywords' in msg:
+            self.keywords = _read_field('keywords').split(',')
+
+        self.platforms = _read_list('platform')
+        self.classifiers = _read_list('classifier')
+
+        # PEP 314 - these fields only exist in 1.1
+        if metadata_version == '1.1':
+            self.requires = _read_list('requires')
+            self.provides = _read_list('provides')
+            self.obsoletes = _read_list('obsoletes')
+        else:
+            self.requires = None
+            self.provides = None
+            self.obsoletes = None
+
+    def write_pkg_info(self, base_dir: str | os.PathLike[str]) -> None:
+        """Write the PKG-INFO file into the release tree."""
+        with open(
+            os.path.join(base_dir, 'PKG-INFO'), 'w', encoding='UTF-8'
+        ) as pkg_info:
+            self.write_pkg_file(pkg_info)
+
+    def write_pkg_file(self, file: SupportsWrite[str]) -> None:
+        """Write the PKG-INFO format data to a file object."""
+        version = '1.0'
+        if (
+            self.provides
+            or self.requires
+            or self.obsoletes
+            or self.classifiers
+            or self.download_url
+        ):
+            version = '1.1'
+
+        # required fields
+        file.write(f'Metadata-Version: {version}\n')
+        file.write(f'Name: {self.get_name()}\n')
+        file.write(f'Version: {self.get_version()}\n')
+
+        def maybe_write(header, val):
+            if val:
+                file.write(f"{header}: {val}\n")
+
+        # optional fields
+        maybe_write("Summary", self.get_description())
+        maybe_write("Home-page", self.get_url())
+        maybe_write("Author", self.get_contact())
+        maybe_write("Author-email", self.get_contact_email())
+        maybe_write("License", self.get_license())
+        maybe_write("Download-URL", self.download_url)
+        maybe_write("Description", rfc822_escape(self.get_long_description() or ""))
+        maybe_write("Keywords", ",".join(self.get_keywords()))
+
+        self._write_list(file, 'Platform', self.get_platforms())
+        self._write_list(file, 'Classifier', self.get_classifiers())
+
+        # PEP 314
+        self._write_list(file, 'Requires', self.get_requires())
+        self._write_list(file, 'Provides', self.get_provides())
+        self._write_list(file, 'Obsoletes', self.get_obsoletes())
+
+    def _write_list(self, file, name, values):
+        values = values or []
+        for value in values:
+            file.write(f'{name}: {value}\n')
+
+    # -- Metadata query methods ----------------------------------------
+
+    def get_name(self) -> str:
+        return self.name or "UNKNOWN"
+
+    def get_version(self) -> str:
+        return self.version or "0.0.0"
+
+    def get_fullname(self) -> str:
+        return self._fullname(self.get_name(), self.get_version())
+
+    @staticmethod
+    def _fullname(name: str, version: str) -> str:
+        """
+        >>> DistributionMetadata._fullname('setup.tools', '1.0-2')
+        'setup_tools-1.0.post2'
+        >>> DistributionMetadata._fullname('setup-tools', '1.2post2')
+        'setup_tools-1.2.post2'
+        >>> DistributionMetadata._fullname('setup-tools', '1.0-r2')
+        'setup_tools-1.0.post2'
+        >>> DistributionMetadata._fullname('setup.tools', '1.0.post')
+        'setup_tools-1.0.post0'
+        >>> DistributionMetadata._fullname('setup.tools', '1.0+ubuntu-1')
+        'setup_tools-1.0+ubuntu.1'
+        """
+        return "{}-{}".format(
+            canonicalize_name(name).replace('-', '_'),
+            canonicalize_version(version, strip_trailing_zero=False),
+        )
+
+    def get_author(self) -> str | None:
+        return self.author
+
+    def get_author_email(self) -> str | None:
+        return self.author_email
+
+    def get_maintainer(self) -> str | None:
+        return self.maintainer
+
+    def get_maintainer_email(self) -> str | None:
+        return self.maintainer_email
+
+    def get_contact(self) -> str | None:
+        return self.maintainer or self.author
+
+    def get_contact_email(self) -> str | None:
+        return self.maintainer_email or self.author_email
+
+    def get_url(self) -> str | None:
+        return self.url
+
+    def get_license(self) -> str | None:
+        return self.license
+
+    get_licence = get_license
+
+    def get_description(self) -> str | None:
+        return self.description
+
+    def get_long_description(self) -> str | None:
+        return self.long_description
+
+    def get_keywords(self) -> str | list[str]:
+        return self.keywords or []
+
+    def set_keywords(self, value: str | Iterable[str]) -> None:
+        self.keywords = _ensure_list(value, 'keywords')
+
+    def get_platforms(self) -> str | list[str] | None:
+        return self.platforms
+
+    def set_platforms(self, value: str | Iterable[str]) -> None:
+        self.platforms = _ensure_list(value, 'platforms')
+
+    def get_classifiers(self) -> str | list[str]:
+        return self.classifiers or []
+
+    def set_classifiers(self, value: str | Iterable[str]) -> None:
+        self.classifiers = _ensure_list(value, 'classifiers')
+
+    def get_download_url(self) -> str | None:
+        return self.download_url
+
+    # PEP 314
+    def get_requires(self) -> str | list[str]:
+        return self.requires or []
+
+    def set_requires(self, value: Iterable[str]) -> None:
+        import distutils.versionpredicate
+
+        for v in value:
+            distutils.versionpredicate.VersionPredicate(v)
+        self.requires = list(value)
+
+    def get_provides(self) -> str | list[str]:
+        return self.provides or []
+
+    def set_provides(self, value: Iterable[str]) -> None:
+        value = [v.strip() for v in value]
+        for v in value:
+            import distutils.versionpredicate
+
+            distutils.versionpredicate.split_provision(v)
+        self.provides = value
+
+    def get_obsoletes(self) -> str | list[str]:
+        return self.obsoletes or []
+
+    def set_obsoletes(self, value: Iterable[str]) -> None:
+        import distutils.versionpredicate
+
+        for v in value:
+            distutils.versionpredicate.VersionPredicate(v)
+        self.obsoletes = list(value)
+
+
+def fix_help_options(options):
+    """Convert a 4-tuple 'help_options' list as found in various command
+    classes to the 3-tuple form required by FancyGetopt.
+    """
+    return [opt[0:3] for opt in options]
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/errors.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/errors.py
new file mode 100644
index 0000000000000000000000000000000000000000..409d21faa2caeb8a53fed10e4266f7cccc764d23
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/errors.py
@@ -0,0 +1,108 @@
+"""
+Exceptions used by the Distutils modules.
+
+Distutils modules may raise these or standard exceptions,
+including :exc:`SystemExit`.
+"""
+
+# compiler exceptions aliased for compatibility
+from .compilers.C.errors import CompileError as CompileError
+from .compilers.C.errors import Error as _Error
+from .compilers.C.errors import LibError as LibError
+from .compilers.C.errors import LinkError as LinkError
+from .compilers.C.errors import PreprocessError as PreprocessError
+from .compilers.C.errors import UnknownFileType as _UnknownFileType
+
+CCompilerError = _Error
+UnknownFileError = _UnknownFileType
+
+
+class DistutilsError(Exception):
+    """The root of all Distutils evil."""
+
+    pass
+
+
+class DistutilsModuleError(DistutilsError):
+    """Unable to load an expected module, or to find an expected class
+    within some module (in particular, command modules and classes)."""
+
+    pass
+
+
+class DistutilsClassError(DistutilsError):
+    """Some command class (or possibly distribution class, if anyone
+    feels a need to subclass Distribution) is found not to be holding
+    up its end of the bargain, ie. implementing some part of the
+    "command "interface."""
+
+    pass
+
+
+class DistutilsGetoptError(DistutilsError):
+    """The option table provided to 'fancy_getopt()' is bogus."""
+
+    pass
+
+
+class DistutilsArgError(DistutilsError):
+    """Raised by fancy_getopt in response to getopt.error -- ie. an
+    error in the command line usage."""
+
+    pass
+
+
+class DistutilsFileError(DistutilsError):
+    """Any problems in the filesystem: expected file not found, etc.
+    Typically this is for problems that we detect before OSError
+    could be raised."""
+
+    pass
+
+
+class DistutilsOptionError(DistutilsError):
+    """Syntactic/semantic errors in command options, such as use of
+    mutually conflicting options, or inconsistent options,
+    badly-spelled values, etc.  No distinction is made between option
+    values originating in the setup script, the command line, config
+    files, or what-have-you -- but if we *know* something originated in
+    the setup script, we'll raise DistutilsSetupError instead."""
+
+    pass
+
+
+class DistutilsSetupError(DistutilsError):
+    """For errors that can be definitely blamed on the setup script,
+    such as invalid keyword arguments to 'setup()'."""
+
+    pass
+
+
+class DistutilsPlatformError(DistutilsError):
+    """We don't know how to do something on the current platform (but
+    we do know how to do it on some platform) -- eg. trying to compile
+    C files on a platform not supported by a CCompiler subclass."""
+
+    pass
+
+
+class DistutilsExecError(DistutilsError):
+    """Any problems executing an external program (such as the C
+    compiler, when compiling C files)."""
+
+    pass
+
+
+class DistutilsInternalError(DistutilsError):
+    """Internal inconsistencies or impossibilities (obviously, this
+    should never be seen if the code is working!)."""
+
+    pass
+
+
+class DistutilsTemplateError(DistutilsError):
+    """Syntax error in a file list template."""
+
+
+class DistutilsByteCompileError(DistutilsError):
+    """Byte compile error."""
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/extension.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/extension.py
new file mode 100644
index 0000000000000000000000000000000000000000..f51411266e4047275280d883b75e7103af21faef
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/extension.py
@@ -0,0 +1,258 @@
+"""distutils.extension
+
+Provides the Extension class, used to describe C/C++ extension
+modules in setup scripts."""
+
+from __future__ import annotations
+
+import os
+import warnings
+from collections.abc import Iterable
+
+# This class is really only used by the "build_ext" command, so it might
+# make sense to put it in distutils.command.build_ext.  However, that
+# module is already big enough, and I want to make this class a bit more
+# complex to simplify some common cases ("foo" module in "foo.c") and do
+# better error-checking ("foo.c" actually exists).
+#
+# Also, putting this in build_ext.py means every setup script would have to
+# import that large-ish module (indirectly, through distutils.core) in
+# order to do anything.
+
+
+class Extension:
+    """Just a collection of attributes that describes an extension
+    module and everything needed to build it (hopefully in a portable
+    way, but there are hooks that let you be as unportable as you need).
+
+    Instance attributes:
+      name : string
+        the full name of the extension, including any packages -- ie.
+        *not* a filename or pathname, but Python dotted name
+      sources : Iterable[string | os.PathLike]
+        iterable of source filenames (except strings, which could be misinterpreted
+        as a single filename), relative to the distribution root (where the setup
+        script lives), in Unix form (slash-separated) for portability. Can be any
+        non-string iterable (list, tuple, set, etc.) containing strings or
+        PathLike objects. Source files may be C, C++, SWIG (.i), platform-specific
+        resource files, or whatever else is recognized by the "build_ext" command
+        as source for a Python extension.
+      include_dirs : [string]
+        list of directories to search for C/C++ header files (in Unix
+        form for portability)
+      define_macros : [(name : string, value : string|None)]
+        list of macros to define; each macro is defined using a 2-tuple,
+        where 'value' is either the string to define it to or None to
+        define it without a particular value (equivalent of "#define
+        FOO" in source or -DFOO on Unix C compiler command line)
+      undef_macros : [string]
+        list of macros to undefine explicitly
+      library_dirs : [string]
+        list of directories to search for C/C++ libraries at link time
+      libraries : [string]
+        list of library names (not filenames or paths) to link against
+      runtime_library_dirs : [string]
+        list of directories to search for C/C++ libraries at run time
+        (for shared extensions, this is when the extension is loaded)
+      extra_objects : [string]
+        list of extra files to link with (eg. object files not implied
+        by 'sources', static library that must be explicitly specified,
+        binary resource files, etc.)
+      extra_compile_args : [string]
+        any extra platform- and compiler-specific information to use
+        when compiling the source files in 'sources'.  For platforms and
+        compilers where "command line" makes sense, this is typically a
+        list of command-line arguments, but for other platforms it could
+        be anything.
+      extra_link_args : [string]
+        any extra platform- and compiler-specific information to use
+        when linking object files together to create the extension (or
+        to create a new static Python interpreter).  Similar
+        interpretation as for 'extra_compile_args'.
+      export_symbols : [string]
+        list of symbols to be exported from a shared extension.  Not
+        used on all platforms, and not generally necessary for Python
+        extensions, which typically export exactly one symbol: "init" +
+        extension_name.
+      swig_opts : [string]
+        any extra options to pass to SWIG if a source file has the .i
+        extension.
+      depends : [string]
+        list of files that the extension depends on
+      language : string
+        extension language (i.e. "c", "c++", "objc"). Will be detected
+        from the source extensions if not provided.
+      optional : boolean
+        specifies that a build failure in the extension should not abort the
+        build process, but simply not install the failing extension.
+    """
+
+    # When adding arguments to this constructor, be sure to update
+    # setup_keywords in core.py.
+    def __init__(
+        self,
+        name: str,
+        sources: Iterable[str | os.PathLike[str]],
+        include_dirs: list[str] | None = None,
+        define_macros: list[tuple[str, str | None]] | None = None,
+        undef_macros: list[str] | None = None,
+        library_dirs: list[str] | None = None,
+        libraries: list[str] | None = None,
+        runtime_library_dirs: list[str] | None = None,
+        extra_objects: list[str] | None = None,
+        extra_compile_args: list[str] | None = None,
+        extra_link_args: list[str] | None = None,
+        export_symbols: list[str] | None = None,
+        swig_opts: list[str] | None = None,
+        depends: list[str] | None = None,
+        language: str | None = None,
+        optional: bool | None = None,
+        **kw,  # To catch unknown keywords
+    ):
+        if not isinstance(name, str):
+            raise TypeError("'name' must be a string")
+
+        # handle the string case first; since strings are iterable, disallow them
+        if isinstance(sources, str):
+            raise TypeError(
+                "'sources' must be an iterable of strings or PathLike objects, not a string"
+            )
+
+        # now we check if it's iterable and contains valid types
+        try:
+            self.sources = list(map(os.fspath, sources))
+        except TypeError:
+            raise TypeError(
+                "'sources' must be an iterable of strings or PathLike objects"
+            )
+
+        self.name = name
+        self.include_dirs = include_dirs or []
+        self.define_macros = define_macros or []
+        self.undef_macros = undef_macros or []
+        self.library_dirs = library_dirs or []
+        self.libraries = libraries or []
+        self.runtime_library_dirs = runtime_library_dirs or []
+        self.extra_objects = extra_objects or []
+        self.extra_compile_args = extra_compile_args or []
+        self.extra_link_args = extra_link_args or []
+        self.export_symbols = export_symbols or []
+        self.swig_opts = swig_opts or []
+        self.depends = depends or []
+        self.language = language
+        self.optional = optional
+
+        # If there are unknown keyword options, warn about them
+        if len(kw) > 0:
+            options = [repr(option) for option in kw]
+            options = ', '.join(sorted(options))
+            msg = f"Unknown Extension options: {options}"
+            warnings.warn(msg)
+
+    def __repr__(self):
+        return f'<{self.__class__.__module__}.{self.__class__.__qualname__}({self.name!r}) at {id(self):#x}>'
+
+
+def read_setup_file(filename):  # noqa: C901
+    """Reads a Setup file and returns Extension instances."""
+    from distutils.sysconfig import _variable_rx, expand_makefile_vars, parse_makefile
+    from distutils.text_file import TextFile
+    from distutils.util import split_quoted
+
+    # First pass over the file to gather "VAR = VALUE" assignments.
+    vars = parse_makefile(filename)
+
+    # Second pass to gobble up the real content: lines of the form
+    #   <module> ... [<sourcefile> ...] [<cpparg> ...] [<library> ...]
+    file = TextFile(
+        filename,
+        strip_comments=True,
+        skip_blanks=True,
+        join_lines=True,
+        lstrip_ws=True,
+        rstrip_ws=True,
+    )
+    try:
+        extensions = []
+
+        while True:
+            line = file.readline()
+            if line is None:  # eof
+                break
+            if _variable_rx.match(line):  # VAR=VALUE, handled in first pass
+                continue
+
+            if line[0] == line[-1] == "*":
+                file.warn(f"'{line}' lines not handled yet")
+                continue
+
+            line = expand_makefile_vars(line, vars)
+            words = split_quoted(line)
+
+            # NB. this parses a slightly different syntax than the old
+            # makesetup script: here, there must be exactly one extension per
+            # line, and it must be the first word of the line.  I have no idea
+            # why the old syntax supported multiple extensions per line, as
+            # they all wind up being the same.
+
+            module = words[0]
+            ext = Extension(module, [])
+            append_next_word = None
+
+            for word in words[1:]:
+                if append_next_word is not None:
+                    append_next_word.append(word)
+                    append_next_word = None
+                    continue
+
+                suffix = os.path.splitext(word)[1]
+                switch = word[0:2]
+                value = word[2:]
+
+                if suffix in (".c", ".cc", ".cpp", ".cxx", ".c++", ".m", ".mm"):
+                    # hmm, should we do something about C vs. C++ sources?
+                    # or leave it up to the CCompiler implementation to
+                    # worry about?
+                    ext.sources.append(word)
+                elif switch == "-I":
+                    ext.include_dirs.append(value)
+                elif switch == "-D":
+                    equals = value.find("=")
+                    if equals == -1:  # bare "-DFOO" -- no value
+                        ext.define_macros.append((value, None))
+                    else:  # "-DFOO=blah"
+                        ext.define_macros.append((value[0:equals], value[equals + 2 :]))
+                elif switch == "-U":
+                    ext.undef_macros.append(value)
+                elif switch == "-C":  # only here 'cause makesetup has it!
+                    ext.extra_compile_args.append(word)
+                elif switch == "-l":
+                    ext.libraries.append(value)
+                elif switch == "-L":
+                    ext.library_dirs.append(value)
+                elif switch == "-R":
+                    ext.runtime_library_dirs.append(value)
+                elif word == "-rpath":
+                    append_next_word = ext.runtime_library_dirs
+                elif word == "-Xlinker":
+                    append_next_word = ext.extra_link_args
+                elif word == "-Xcompiler":
+                    append_next_word = ext.extra_compile_args
+                elif switch == "-u":
+                    ext.extra_link_args.append(word)
+                    if not value:
+                        append_next_word = ext.extra_link_args
+                elif suffix in (".a", ".so", ".sl", ".o", ".dylib"):
+                    # NB. a really faithful emulation of makesetup would
+                    # append a .o file to extra_objects only if it
+                    # had a slash in it; otherwise, it would s/.o/.c/
+                    # and append it to sources.  Hmmmm.
+                    ext.extra_objects.append(word)
+                else:
+                    file.warn(f"unrecognized argument '{word}'")
+
+            extensions.append(ext)
+    finally:
+        file.close()
+
+    return extensions
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/fancy_getopt.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/fancy_getopt.py
new file mode 100644
index 0000000000000000000000000000000000000000..1a1d3a05da544b98ff84d03ecbee1185b2eb45f7
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/fancy_getopt.py
@@ -0,0 +1,471 @@
+"""distutils.fancy_getopt
+
+Wrapper around the standard getopt module that provides the following
+additional features:
+  * short and long options are tied together
+  * options have help strings, so fancy_getopt could potentially
+    create a complete usage summary
+  * options set attributes of a passed-in object
+"""
+
+from __future__ import annotations
+
+import getopt
+import re
+import string
+import sys
+from collections.abc import Sequence
+from typing import Any
+
+from .errors import DistutilsArgError, DistutilsGetoptError
+
+# Much like command_re in distutils.core, this is close to but not quite
+# the same as a Python NAME -- except, in the spirit of most GNU
+# utilities, we use '-' in place of '_'.  (The spirit of LISP lives on!)
+# The similarities to NAME are again not a coincidence...
+longopt_pat = r'[a-zA-Z](?:[a-zA-Z0-9-]*)'
+longopt_re = re.compile(rf'^{longopt_pat}$')
+
+# For recognizing "negative alias" options, eg. "quiet=!verbose"
+neg_alias_re = re.compile(f"^({longopt_pat})=!({longopt_pat})$")
+
+# This is used to translate long options to legitimate Python identifiers
+# (for use as attributes of some object).
+longopt_xlate = str.maketrans('-', '_')
+
+
+class FancyGetopt:
+    """Wrapper around the standard 'getopt()' module that provides some
+    handy extra functionality:
+      * short and long options are tied together
+      * options have help strings, and help text can be assembled
+        from them
+      * options set attributes of a passed-in object
+      * boolean options can have "negative aliases" -- eg. if
+        --quiet is the "negative alias" of --verbose, then "--quiet"
+        on the command line sets 'verbose' to false
+    """
+
+    def __init__(self, option_table=None):
+        # The option table is (currently) a list of tuples.  The
+        # tuples may have 3 or four values:
+        #   (long_option, short_option, help_string [, repeatable])
+        # if an option takes an argument, its long_option should have '='
+        # appended; short_option should just be a single character, no ':'
+        # in any case.  If a long_option doesn't have a corresponding
+        # short_option, short_option should be None.  All option tuples
+        # must have long options.
+        self.option_table = option_table
+
+        # 'option_index' maps long option names to entries in the option
+        # table (ie. those 3-tuples).
+        self.option_index = {}
+        if self.option_table:
+            self._build_index()
+
+        # 'alias' records (duh) alias options; {'foo': 'bar'} means
+        # --foo is an alias for --bar
+        self.alias = {}
+
+        # 'negative_alias' keeps track of options that are the boolean
+        # opposite of some other option
+        self.negative_alias = {}
+
+        # These keep track of the information in the option table.  We
+        # don't actually populate these structures until we're ready to
+        # parse the command-line, since the 'option_table' passed in here
+        # isn't necessarily the final word.
+        self.short_opts = []
+        self.long_opts = []
+        self.short2long = {}
+        self.attr_name = {}
+        self.takes_arg = {}
+
+        # And 'option_order' is filled up in 'getopt()'; it records the
+        # original order of options (and their values) on the command-line,
+        # but expands short options, converts aliases, etc.
+        self.option_order = []
+
+    def _build_index(self):
+        self.option_index.clear()
+        for option in self.option_table:
+            self.option_index[option[0]] = option
+
+    def set_option_table(self, option_table):
+        self.option_table = option_table
+        self._build_index()
+
+    def add_option(self, long_option, short_option=None, help_string=None):
+        if long_option in self.option_index:
+            raise DistutilsGetoptError(
+                f"option conflict: already an option '{long_option}'"
+            )
+        else:
+            option = (long_option, short_option, help_string)
+            self.option_table.append(option)
+            self.option_index[long_option] = option
+
+    def has_option(self, long_option):
+        """Return true if the option table for this parser has an
+        option with long name 'long_option'."""
+        return long_option in self.option_index
+
+    def get_attr_name(self, long_option):
+        """Translate long option name 'long_option' to the form it
+        has as an attribute of some object: ie., translate hyphens
+        to underscores."""
+        return long_option.translate(longopt_xlate)
+
+    def _check_alias_dict(self, aliases, what):
+        assert isinstance(aliases, dict)
+        for alias, opt in aliases.items():
+            if alias not in self.option_index:
+                raise DistutilsGetoptError(
+                    f"invalid {what} '{alias}': option '{alias}' not defined"
+                )
+            if opt not in self.option_index:
+                raise DistutilsGetoptError(
+                    f"invalid {what} '{alias}': aliased option '{opt}' not defined"
+                )
+
+    def set_aliases(self, alias):
+        """Set the aliases for this option parser."""
+        self._check_alias_dict(alias, "alias")
+        self.alias = alias
+
+    def set_negative_aliases(self, negative_alias):
+        """Set the negative aliases for this option parser.
+        'negative_alias' should be a dictionary mapping option names to
+        option names, both the key and value must already be defined
+        in the option table."""
+        self._check_alias_dict(negative_alias, "negative alias")
+        self.negative_alias = negative_alias
+
+    def _grok_option_table(self):  # noqa: C901
+        """Populate the various data structures that keep tabs on the
+        option table.  Called by 'getopt()' before it can do anything
+        worthwhile.
+        """
+        self.long_opts = []
+        self.short_opts = []
+        self.short2long.clear()
+        self.repeat = {}
+
+        for option in self.option_table:
+            if len(option) == 3:
+                long, short, help = option
+                repeat = 0
+            elif len(option) == 4:
+                long, short, help, repeat = option
+            else:
+                # the option table is part of the code, so simply
+                # assert that it is correct
+                raise ValueError(f"invalid option tuple: {option!r}")
+
+            # Type- and value-check the option names
+            if not isinstance(long, str) or len(long) < 2:
+                raise DistutilsGetoptError(
+                    f"invalid long option '{long}': must be a string of length >= 2"
+                )
+
+            if not ((short is None) or (isinstance(short, str) and len(short) == 1)):
+                raise DistutilsGetoptError(
+                    f"invalid short option '{short}': must a single character or None"
+                )
+
+            self.repeat[long] = repeat
+            self.long_opts.append(long)
+
+            if long[-1] == '=':  # option takes an argument?
+                if short:
+                    short = short + ':'
+                long = long[0:-1]
+                self.takes_arg[long] = True
+            else:
+                # Is option is a "negative alias" for some other option (eg.
+                # "quiet" == "!verbose")?
+                alias_to = self.negative_alias.get(long)
+                if alias_to is not None:
+                    if self.takes_arg[alias_to]:
+                        raise DistutilsGetoptError(
+                            f"invalid negative alias '{long}': "
+                            f"aliased option '{alias_to}' takes a value"
+                        )
+
+                    self.long_opts[-1] = long  # XXX redundant?!
+                self.takes_arg[long] = False
+
+            # If this is an alias option, make sure its "takes arg" flag is
+            # the same as the option it's aliased to.
+            alias_to = self.alias.get(long)
+            if alias_to is not None:
+                if self.takes_arg[long] != self.takes_arg[alias_to]:
+                    raise DistutilsGetoptError(
+                        f"invalid alias '{long}': inconsistent with "
+                        f"aliased option '{alias_to}' (one of them takes a value, "
+                        "the other doesn't"
+                    )
+
+            # Now enforce some bondage on the long option name, so we can
+            # later translate it to an attribute name on some object.  Have
+            # to do this a bit late to make sure we've removed any trailing
+            # '='.
+            if not longopt_re.match(long):
+                raise DistutilsGetoptError(
+                    f"invalid long option name '{long}' "
+                    "(must be letters, numbers, hyphens only"
+                )
+
+            self.attr_name[long] = self.get_attr_name(long)
+            if short:
+                self.short_opts.append(short)
+                self.short2long[short[0]] = long
+
+    def getopt(self, args: Sequence[str] | None = None, object=None):  # noqa: C901
+        """Parse command-line options in args. Store as attributes on object.
+
+        If 'args' is None or not supplied, uses 'sys.argv[1:]'.  If
+        'object' is None or not supplied, creates a new OptionDummy
+        object, stores option values there, and returns a tuple (args,
+        object).  If 'object' is supplied, it is modified in place and
+        'getopt()' just returns 'args'; in both cases, the returned
+        'args' is a modified copy of the passed-in 'args' list, which
+        is left untouched.
+        """
+        if args is None:
+            args = sys.argv[1:]
+        if object is None:
+            object = OptionDummy()
+            created_object = True
+        else:
+            created_object = False
+
+        self._grok_option_table()
+
+        short_opts = ' '.join(self.short_opts)
+        try:
+            opts, args = getopt.getopt(args, short_opts, self.long_opts)
+        except getopt.error as msg:
+            raise DistutilsArgError(msg)
+
+        for opt, val in opts:
+            if len(opt) == 2 and opt[0] == '-':  # it's a short option
+                opt = self.short2long[opt[1]]
+            else:
+                assert len(opt) > 2 and opt[:2] == '--'
+                opt = opt[2:]
+
+            alias = self.alias.get(opt)
+            if alias:
+                opt = alias
+
+            if not self.takes_arg[opt]:  # boolean option?
+                assert val == '', "boolean option can't have value"
+                alias = self.negative_alias.get(opt)
+                if alias:
+                    opt = alias
+                    val = 0
+                else:
+                    val = 1
+
+            attr = self.attr_name[opt]
+            # The only repeating option at the moment is 'verbose'.
+            # It has a negative option -q quiet, which should set verbose = False.
+            if val and self.repeat.get(attr) is not None:
+                val = getattr(object, attr, 0) + 1
+            setattr(object, attr, val)
+            self.option_order.append((opt, val))
+
+        # for opts
+        if created_object:
+            return args, object
+        else:
+            return args
+
+    def get_option_order(self):
+        """Returns the list of (option, value) tuples processed by the
+        previous run of 'getopt()'.  Raises RuntimeError if
+        'getopt()' hasn't been called yet.
+        """
+        if self.option_order is None:
+            raise RuntimeError("'getopt()' hasn't been called yet")
+        else:
+            return self.option_order
+
+    def generate_help(self, header=None):  # noqa: C901
+        """Generate help text (a list of strings, one per suggested line of
+        output) from the option table for this FancyGetopt object.
+        """
+        # Blithely assume the option table is good: probably wouldn't call
+        # 'generate_help()' unless you've already called 'getopt()'.
+
+        # First pass: determine maximum length of long option names
+        max_opt = 0
+        for option in self.option_table:
+            long = option[0]
+            short = option[1]
+            ell = len(long)
+            if long[-1] == '=':
+                ell = ell - 1
+            if short is not None:
+                ell = ell + 5  # " (-x)" where short == 'x'
+            if ell > max_opt:
+                max_opt = ell
+
+        opt_width = max_opt + 2 + 2 + 2  # room for indent + dashes + gutter
+
+        # Typical help block looks like this:
+        #   --foo       controls foonabulation
+        # Help block for longest option looks like this:
+        #   --flimflam  set the flim-flam level
+        # and with wrapped text:
+        #   --flimflam  set the flim-flam level (must be between
+        #               0 and 100, except on Tuesdays)
+        # Options with short names will have the short name shown (but
+        # it doesn't contribute to max_opt):
+        #   --foo (-f)  controls foonabulation
+        # If adding the short option would make the left column too wide,
+        # we push the explanation off to the next line
+        #   --flimflam (-l)
+        #               set the flim-flam level
+        # Important parameters:
+        #   - 2 spaces before option block start lines
+        #   - 2 dashes for each long option name
+        #   - min. 2 spaces between option and explanation (gutter)
+        #   - 5 characters (incl. space) for short option name
+
+        # Now generate lines of help text.  (If 80 columns were good enough
+        # for Jesus, then 78 columns are good enough for me!)
+        line_width = 78
+        text_width = line_width - opt_width
+        big_indent = ' ' * opt_width
+        if header:
+            lines = [header]
+        else:
+            lines = ['Option summary:']
+
+        for option in self.option_table:
+            long, short, help = option[:3]
+            text = wrap_text(help, text_width)
+            if long[-1] == '=':
+                long = long[0:-1]
+
+            # Case 1: no short option at all (makes life easy)
+            if short is None:
+                if text:
+                    lines.append(f"  --{long:<{max_opt}}  {text[0]}")
+                else:
+                    lines.append(f"  --{long:<{max_opt}}")
+
+            # Case 2: we have a short option, so we have to include it
+            # just after the long option
+            else:
+                opt_names = f"{long} (-{short})"
+                if text:
+                    lines.append(f"  --{opt_names:<{max_opt}}  {text[0]}")
+                else:
+                    lines.append(f"  --{opt_names:<{max_opt}}")
+
+            for ell in text[1:]:
+                lines.append(big_indent + ell)
+        return lines
+
+    def print_help(self, header=None, file=None):
+        if file is None:
+            file = sys.stdout
+        for line in self.generate_help(header):
+            file.write(line + "\n")
+
+
+def fancy_getopt(options, negative_opt, object, args: Sequence[str] | None):
+    parser = FancyGetopt(options)
+    parser.set_negative_aliases(negative_opt)
+    return parser.getopt(args, object)
+
+
+WS_TRANS = {ord(_wschar): ' ' for _wschar in string.whitespace}
+
+
+def wrap_text(text, width):
+    """wrap_text(text : string, width : int) -> [string]
+
+    Split 'text' into multiple lines of no more than 'width' characters
+    each, and return the list of strings that results.
+    """
+    if text is None:
+        return []
+    if len(text) <= width:
+        return [text]
+
+    text = text.expandtabs()
+    text = text.translate(WS_TRANS)
+    chunks = re.split(r'( +|-+)', text)
+    chunks = [ch for ch in chunks if ch]  # ' - ' results in empty strings
+    lines = []
+
+    while chunks:
+        cur_line = []  # list of chunks (to-be-joined)
+        cur_len = 0  # length of current line
+
+        while chunks:
+            ell = len(chunks[0])
+            if cur_len + ell <= width:  # can squeeze (at least) this chunk in
+                cur_line.append(chunks[0])
+                del chunks[0]
+                cur_len = cur_len + ell
+            else:  # this line is full
+                # drop last chunk if all space
+                if cur_line and cur_line[-1][0] == ' ':
+                    del cur_line[-1]
+                break
+
+        if chunks:  # any chunks left to process?
+            # if the current line is still empty, then we had a single
+            # chunk that's too big too fit on a line -- so we break
+            # down and break it up at the line width
+            if cur_len == 0:
+                cur_line.append(chunks[0][0:width])
+                chunks[0] = chunks[0][width:]
+
+            # all-whitespace chunks at the end of a line can be discarded
+            # (and we know from the re.split above that if a chunk has
+            # *any* whitespace, it is *all* whitespace)
+            if chunks[0][0] == ' ':
+                del chunks[0]
+
+        # and store this line in the list-of-all-lines -- as a single
+        # string, of course!
+        lines.append(''.join(cur_line))
+
+    return lines
+
+
+def translate_longopt(opt):
+    """Convert a long option name to a valid Python identifier by
+    changing "-" to "_".
+    """
+    return opt.translate(longopt_xlate)
+
+
+class OptionDummy:
+    """Dummy class just used as a place to hold command-line option
+    values as instance attributes."""
+
+    def __init__(self, options: Sequence[Any] = []):
+        """Create a new OptionDummy instance.  The attributes listed in
+        'options' will be initialized to None."""
+        for opt in options:
+            setattr(self, opt, None)
+
+
+if __name__ == "__main__":
+    text = """\
+Tra-la-la, supercalifragilisticexpialidocious.
+How *do* you spell that odd word, anyways?
+(Someone ask Mary -- she'll know [or she'll
+say, "How should I know?"].)"""
+
+    for w in (10, 20, 30, 40):
+        print(f"width: {w}")
+        print("\n".join(wrap_text(text, w)))
+        print()
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/file_util.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/file_util.py
new file mode 100644
index 0000000000000000000000000000000000000000..0acc8cb84bd4d28363c4e33e7ff18d691bebfa48
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/file_util.py
@@ -0,0 +1,236 @@
+"""distutils.file_util
+
+Utility functions for operating on single files.
+"""
+
+import os
+
+from ._log import log
+from .errors import DistutilsFileError
+
+# for generating verbose output in 'copy_file()'
+_copy_action = {None: 'copying', 'hard': 'hard linking', 'sym': 'symbolically linking'}
+
+
+def _copy_file_contents(src, dst, buffer_size=16 * 1024):  # noqa: C901
+    """Copy the file 'src' to 'dst'; both must be filenames.  Any error
+    opening either file, reading from 'src', or writing to 'dst', raises
+    DistutilsFileError.  Data is read/written in chunks of 'buffer_size'
+    bytes (default 16k).  No attempt is made to handle anything apart from
+    regular files.
+    """
+    # Stolen from shutil module in the standard library, but with
+    # custom error-handling added.
+    fsrc = None
+    fdst = None
+    try:
+        try:
+            fsrc = open(src, 'rb')
+        except OSError as e:
+            raise DistutilsFileError(f"could not open '{src}': {e.strerror}")
+
+        if os.path.exists(dst):
+            try:
+                os.unlink(dst)
+            except OSError as e:
+                raise DistutilsFileError(f"could not delete '{dst}': {e.strerror}")
+
+        try:
+            fdst = open(dst, 'wb')
+        except OSError as e:
+            raise DistutilsFileError(f"could not create '{dst}': {e.strerror}")
+
+        while True:
+            try:
+                buf = fsrc.read(buffer_size)
+            except OSError as e:
+                raise DistutilsFileError(f"could not read from '{src}': {e.strerror}")
+
+            if not buf:
+                break
+
+            try:
+                fdst.write(buf)
+            except OSError as e:
+                raise DistutilsFileError(f"could not write to '{dst}': {e.strerror}")
+    finally:
+        if fdst:
+            fdst.close()
+        if fsrc:
+            fsrc.close()
+
+
+def copy_file(  # noqa: C901
+    src,
+    dst,
+    preserve_mode=True,
+    preserve_times=True,
+    update=False,
+    link=None,
+    verbose=True,
+    dry_run=False,
+):
+    """Copy a file 'src' to 'dst'.  If 'dst' is a directory, then 'src' is
+    copied there with the same name; otherwise, it must be a filename.  (If
+    the file exists, it will be ruthlessly clobbered.)  If 'preserve_mode'
+    is true (the default), the file's mode (type and permission bits, or
+    whatever is analogous on the current platform) is copied.  If
+    'preserve_times' is true (the default), the last-modified and
+    last-access times are copied as well.  If 'update' is true, 'src' will
+    only be copied if 'dst' does not exist, or if 'dst' does exist but is
+    older than 'src'.
+
+    'link' allows you to make hard links (os.link) or symbolic links
+    (os.symlink) instead of copying: set it to "hard" or "sym"; if it is
+    None (the default), files are copied.  Don't set 'link' on systems that
+    don't support it: 'copy_file()' doesn't check if hard or symbolic
+    linking is available. If hardlink fails, falls back to
+    _copy_file_contents().
+
+    Under Mac OS, uses the native file copy function in macostools; on
+    other systems, uses '_copy_file_contents()' to copy file contents.
+
+    Return a tuple (dest_name, copied): 'dest_name' is the actual name of
+    the output file, and 'copied' is true if the file was copied (or would
+    have been copied, if 'dry_run' true).
+    """
+    # XXX if the destination file already exists, we clobber it if
+    # copying, but blow up if linking.  Hmmm.  And I don't know what
+    # macostools.copyfile() does.  Should definitely be consistent, and
+    # should probably blow up if destination exists and we would be
+    # changing it (ie. it's not already a hard/soft link to src OR
+    # (not update) and (src newer than dst).
+
+    from distutils._modified import newer
+    from stat import S_IMODE, ST_ATIME, ST_MODE, ST_MTIME
+
+    if not os.path.isfile(src):
+        raise DistutilsFileError(
+            f"can't copy '{src}': doesn't exist or not a regular file"
+        )
+
+    if os.path.isdir(dst):
+        dir = dst
+        dst = os.path.join(dst, os.path.basename(src))
+    else:
+        dir = os.path.dirname(dst)
+
+    if update and not newer(src, dst):
+        if verbose >= 1:
+            log.debug("not copying %s (output up-to-date)", src)
+        return (dst, False)
+
+    try:
+        action = _copy_action[link]
+    except KeyError:
+        raise ValueError(f"invalid value '{link}' for 'link' argument")
+
+    if verbose >= 1:
+        if os.path.basename(dst) == os.path.basename(src):
+            log.info("%s %s -> %s", action, src, dir)
+        else:
+            log.info("%s %s -> %s", action, src, dst)
+
+    if dry_run:
+        return (dst, True)
+
+    # If linking (hard or symbolic), use the appropriate system call
+    # (Unix only, of course, but that's the caller's responsibility)
+    elif link == 'hard':
+        if not (os.path.exists(dst) and os.path.samefile(src, dst)):
+            try:
+                os.link(src, dst)
+            except OSError:
+                # If hard linking fails, fall back on copying file
+                # (some special filesystems don't support hard linking
+                #  even under Unix, see issue #8876).
+                pass
+            else:
+                return (dst, True)
+    elif link == 'sym':
+        if not (os.path.exists(dst) and os.path.samefile(src, dst)):
+            os.symlink(src, dst)
+            return (dst, True)
+
+    # Otherwise (non-Mac, not linking), copy the file contents and
+    # (optionally) copy the times and mode.
+    _copy_file_contents(src, dst)
+    if preserve_mode or preserve_times:
+        st = os.stat(src)
+
+        # According to David Ascher <da@ski.org>, utime() should be done
+        # before chmod() (at least under NT).
+        if preserve_times:
+            os.utime(dst, (st[ST_ATIME], st[ST_MTIME]))
+        if preserve_mode:
+            os.chmod(dst, S_IMODE(st[ST_MODE]))
+
+    return (dst, True)
+
+
+# XXX I suspect this is Unix-specific -- need porting help!
+def move_file(src, dst, verbose=True, dry_run=False):  # noqa: C901
+    """Move a file 'src' to 'dst'.  If 'dst' is a directory, the file will
+    be moved into it with the same name; otherwise, 'src' is just renamed
+    to 'dst'.  Return the new full name of the file.
+
+    Handles cross-device moves on Unix using 'copy_file()'.  What about
+    other systems???
+    """
+    import errno
+    from os.path import basename, dirname, exists, isdir, isfile
+
+    if verbose >= 1:
+        log.info("moving %s -> %s", src, dst)
+
+    if dry_run:
+        return dst
+
+    if not isfile(src):
+        raise DistutilsFileError(f"can't move '{src}': not a regular file")
+
+    if isdir(dst):
+        dst = os.path.join(dst, basename(src))
+    elif exists(dst):
+        raise DistutilsFileError(
+            f"can't move '{src}': destination '{dst}' already exists"
+        )
+
+    if not isdir(dirname(dst)):
+        raise DistutilsFileError(
+            f"can't move '{src}': destination '{dst}' not a valid path"
+        )
+
+    copy_it = False
+    try:
+        os.rename(src, dst)
+    except OSError as e:
+        (num, msg) = e.args
+        if num == errno.EXDEV:
+            copy_it = True
+        else:
+            raise DistutilsFileError(f"couldn't move '{src}' to '{dst}': {msg}")
+
+    if copy_it:
+        copy_file(src, dst, verbose=verbose)
+        try:
+            os.unlink(src)
+        except OSError as e:
+            (num, msg) = e.args
+            try:
+                os.unlink(dst)
+            except OSError:
+                pass
+            raise DistutilsFileError(
+                f"couldn't move '{src}' to '{dst}' by copy/delete: "
+                f"delete '{src}' failed: {msg}"
+            )
+    return dst
+
+
+def write_file(filename, contents):
+    """Create a file with the specified name and write 'contents' (a
+    sequence of strings without line terminators) to it.
+    """
+    with open(filename, 'w', encoding='utf-8') as f:
+        f.writelines(line + '\n' for line in contents)
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/filelist.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/filelist.py
new file mode 100644
index 0000000000000000000000000000000000000000..70dc0fdebc3f4200245aa1c6280ab39861dcf8b0
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/filelist.py
@@ -0,0 +1,431 @@
+"""distutils.filelist
+
+Provides the FileList class, used for poking about the filesystem
+and building lists of files.
+"""
+
+from __future__ import annotations
+
+import fnmatch
+import functools
+import os
+import re
+from collections.abc import Iterable
+from typing import Literal, overload
+
+from ._log import log
+from .errors import DistutilsInternalError, DistutilsTemplateError
+from .util import convert_path
+
+
+class FileList:
+    """A list of files built by on exploring the filesystem and filtered by
+    applying various patterns to what we find there.
+
+    Instance attributes:
+      dir
+        directory from which files will be taken -- only used if
+        'allfiles' not supplied to constructor
+      files
+        list of filenames currently being built/filtered/manipulated
+      allfiles
+        complete list of files under consideration (ie. without any
+        filtering applied)
+    """
+
+    def __init__(self, warn: object = None, debug_print: object = None) -> None:
+        # ignore argument to FileList, but keep them for backwards
+        # compatibility
+        self.allfiles: Iterable[str] | None = None
+        self.files: list[str] = []
+
+    def set_allfiles(self, allfiles: Iterable[str]) -> None:
+        self.allfiles = allfiles
+
+    def findall(self, dir: str | os.PathLike[str] = os.curdir) -> None:
+        self.allfiles = findall(dir)
+
+    def debug_print(self, msg: object) -> None:
+        """Print 'msg' to stdout if the global DEBUG (taken from the
+        DISTUTILS_DEBUG environment variable) flag is true.
+        """
+        from distutils.debug import DEBUG
+
+        if DEBUG:
+            print(msg)
+
+    # Collection methods
+
+    def append(self, item: str) -> None:
+        self.files.append(item)
+
+    def extend(self, items: Iterable[str]) -> None:
+        self.files.extend(items)
+
+    def sort(self) -> None:
+        # Not a strict lexical sort!
+        sortable_files = sorted(map(os.path.split, self.files))
+        self.files = []
+        for sort_tuple in sortable_files:
+            self.files.append(os.path.join(*sort_tuple))
+
+    # Other miscellaneous utility methods
+
+    def remove_duplicates(self) -> None:
+        # Assumes list has been sorted!
+        for i in range(len(self.files) - 1, 0, -1):
+            if self.files[i] == self.files[i - 1]:
+                del self.files[i]
+
+    # "File template" methods
+
+    def _parse_template_line(self, line):
+        words = line.split()
+        action = words[0]
+
+        patterns = dir = dir_pattern = None
+
+        if action in ('include', 'exclude', 'global-include', 'global-exclude'):
+            if len(words) < 2:
+                raise DistutilsTemplateError(
+                    f"'{action}' expects <pattern1> <pattern2> ..."
+                )
+            patterns = [convert_path(w) for w in words[1:]]
+        elif action in ('recursive-include', 'recursive-exclude'):
+            if len(words) < 3:
+                raise DistutilsTemplateError(
+                    f"'{action}' expects <dir> <pattern1> <pattern2> ..."
+                )
+            dir = convert_path(words[1])
+            patterns = [convert_path(w) for w in words[2:]]
+        elif action in ('graft', 'prune'):
+            if len(words) != 2:
+                raise DistutilsTemplateError(
+                    f"'{action}' expects a single <dir_pattern>"
+                )
+            dir_pattern = convert_path(words[1])
+        else:
+            raise DistutilsTemplateError(f"unknown action '{action}'")
+
+        return (action, patterns, dir, dir_pattern)
+
+    def process_template_line(self, line: str) -> None:  # noqa: C901
+        # Parse the line: split it up, make sure the right number of words
+        # is there, and return the relevant words.  'action' is always
+        # defined: it's the first word of the line.  Which of the other
+        # three are defined depends on the action; it'll be either
+        # patterns, (dir and patterns), or (dir_pattern).
+        (action, patterns, dir, dir_pattern) = self._parse_template_line(line)
+
+        # OK, now we know that the action is valid and we have the
+        # right number of words on the line for that action -- so we
+        # can proceed with minimal error-checking.
+        if action == 'include':
+            self.debug_print("include " + ' '.join(patterns))
+            for pattern in patterns:
+                if not self.include_pattern(pattern, anchor=True):
+                    log.warning("warning: no files found matching '%s'", pattern)
+
+        elif action == 'exclude':
+            self.debug_print("exclude " + ' '.join(patterns))
+            for pattern in patterns:
+                if not self.exclude_pattern(pattern, anchor=True):
+                    log.warning(
+                        "warning: no previously-included files found matching '%s'",
+                        pattern,
+                    )
+
+        elif action == 'global-include':
+            self.debug_print("global-include " + ' '.join(patterns))
+            for pattern in patterns:
+                if not self.include_pattern(pattern, anchor=False):
+                    log.warning(
+                        (
+                            "warning: no files found matching '%s' "
+                            "anywhere in distribution"
+                        ),
+                        pattern,
+                    )
+
+        elif action == 'global-exclude':
+            self.debug_print("global-exclude " + ' '.join(patterns))
+            for pattern in patterns:
+                if not self.exclude_pattern(pattern, anchor=False):
+                    log.warning(
+                        (
+                            "warning: no previously-included files matching "
+                            "'%s' found anywhere in distribution"
+                        ),
+                        pattern,
+                    )
+
+        elif action == 'recursive-include':
+            self.debug_print("recursive-include {} {}".format(dir, ' '.join(patterns)))
+            for pattern in patterns:
+                if not self.include_pattern(pattern, prefix=dir):
+                    msg = "warning: no files found matching '%s' under directory '%s'"
+                    log.warning(msg, pattern, dir)
+
+        elif action == 'recursive-exclude':
+            self.debug_print("recursive-exclude {} {}".format(dir, ' '.join(patterns)))
+            for pattern in patterns:
+                if not self.exclude_pattern(pattern, prefix=dir):
+                    log.warning(
+                        (
+                            "warning: no previously-included files matching "
+                            "'%s' found under directory '%s'"
+                        ),
+                        pattern,
+                        dir,
+                    )
+
+        elif action == 'graft':
+            self.debug_print("graft " + dir_pattern)
+            if not self.include_pattern(None, prefix=dir_pattern):
+                log.warning("warning: no directories found matching '%s'", dir_pattern)
+
+        elif action == 'prune':
+            self.debug_print("prune " + dir_pattern)
+            if not self.exclude_pattern(None, prefix=dir_pattern):
+                log.warning(
+                    ("no previously-included directories found matching '%s'"),
+                    dir_pattern,
+                )
+        else:
+            raise DistutilsInternalError(
+                f"this cannot happen: invalid action '{action}'"
+            )
+
+    # Filtering/selection methods
+    @overload
+    def include_pattern(
+        self,
+        pattern: str,
+        anchor: bool = True,
+        prefix: str | None = None,
+        is_regex: Literal[False] = False,
+    ) -> bool: ...
+    @overload
+    def include_pattern(
+        self,
+        pattern: str | re.Pattern[str],
+        anchor: bool = True,
+        prefix: str | None = None,
+        *,
+        is_regex: Literal[True],
+    ) -> bool: ...
+    @overload
+    def include_pattern(
+        self,
+        pattern: str | re.Pattern[str],
+        anchor: bool,
+        prefix: str | None,
+        is_regex: Literal[True],
+    ) -> bool: ...
+    def include_pattern(
+        self,
+        pattern: str | re.Pattern,
+        anchor: bool = True,
+        prefix: str | None = None,
+        is_regex: bool = False,
+    ) -> bool:
+        """Select strings (presumably filenames) from 'self.files' that
+        match 'pattern', a Unix-style wildcard (glob) pattern.  Patterns
+        are not quite the same as implemented by the 'fnmatch' module: '*'
+        and '?'  match non-special characters, where "special" is platform-
+        dependent: slash on Unix; colon, slash, and backslash on
+        DOS/Windows; and colon on Mac OS.
+
+        If 'anchor' is true (the default), then the pattern match is more
+        stringent: "*.py" will match "foo.py" but not "foo/bar.py".  If
+        'anchor' is false, both of these will match.
+
+        If 'prefix' is supplied, then only filenames starting with 'prefix'
+        (itself a pattern) and ending with 'pattern', with anything in between
+        them, will match.  'anchor' is ignored in this case.
+
+        If 'is_regex' is true, 'anchor' and 'prefix' are ignored, and
+        'pattern' is assumed to be either a string containing a regex or a
+        regex object -- no translation is done, the regex is just compiled
+        and used as-is.
+
+        Selected strings will be added to self.files.
+
+        Return True if files are found, False otherwise.
+        """
+        # XXX docstring lying about what the special chars are?
+        files_found = False
+        pattern_re = translate_pattern(pattern, anchor, prefix, is_regex)
+        self.debug_print(f"include_pattern: applying regex r'{pattern_re.pattern}'")
+
+        # delayed loading of allfiles list
+        if self.allfiles is None:
+            self.findall()
+
+        for name in self.allfiles:
+            if pattern_re.search(name):
+                self.debug_print(" adding " + name)
+                self.files.append(name)
+                files_found = True
+        return files_found
+
+    @overload
+    def exclude_pattern(
+        self,
+        pattern: str,
+        anchor: bool = True,
+        prefix: str | None = None,
+        is_regex: Literal[False] = False,
+    ) -> bool: ...
+    @overload
+    def exclude_pattern(
+        self,
+        pattern: str | re.Pattern[str],
+        anchor: bool = True,
+        prefix: str | None = None,
+        *,
+        is_regex: Literal[True],
+    ) -> bool: ...
+    @overload
+    def exclude_pattern(
+        self,
+        pattern: str | re.Pattern[str],
+        anchor: bool,
+        prefix: str | None,
+        is_regex: Literal[True],
+    ) -> bool: ...
+    def exclude_pattern(
+        self,
+        pattern: str | re.Pattern,
+        anchor: bool = True,
+        prefix: str | None = None,
+        is_regex: bool = False,
+    ) -> bool:
+        """Remove strings (presumably filenames) from 'files' that match
+        'pattern'.  Other parameters are the same as for
+        'include_pattern()', above.
+        The list 'self.files' is modified in place.
+        Return True if files are found, False otherwise.
+        """
+        files_found = False
+        pattern_re = translate_pattern(pattern, anchor, prefix, is_regex)
+        self.debug_print(f"exclude_pattern: applying regex r'{pattern_re.pattern}'")
+        for i in range(len(self.files) - 1, -1, -1):
+            if pattern_re.search(self.files[i]):
+                self.debug_print(" removing " + self.files[i])
+                del self.files[i]
+                files_found = True
+        return files_found
+
+
+# Utility functions
+
+
+def _find_all_simple(path):
+    """
+    Find all files under 'path'
+    """
+    all_unique = _UniqueDirs.filter(os.walk(path, followlinks=True))
+    results = (
+        os.path.join(base, file) for base, dirs, files in all_unique for file in files
+    )
+    return filter(os.path.isfile, results)
+
+
+class _UniqueDirs(set):
+    """
+    Exclude previously-seen dirs from walk results,
+    avoiding infinite recursion.
+    Ref https://bugs.python.org/issue44497.
+    """
+
+    def __call__(self, walk_item):
+        """
+        Given an item from an os.walk result, determine
+        if the item represents a unique dir for this instance
+        and if not, prevent further traversal.
+        """
+        base, dirs, files = walk_item
+        stat = os.stat(base)
+        candidate = stat.st_dev, stat.st_ino
+        found = candidate in self
+        if found:
+            del dirs[:]
+        self.add(candidate)
+        return not found
+
+    @classmethod
+    def filter(cls, items):
+        return filter(cls(), items)
+
+
+def findall(dir: str | os.PathLike[str] = os.curdir):
+    """
+    Find all files under 'dir' and return the list of full filenames.
+    Unless dir is '.', return full filenames with dir prepended.
+    """
+    files = _find_all_simple(dir)
+    if dir == os.curdir:
+        make_rel = functools.partial(os.path.relpath, start=dir)
+        files = map(make_rel, files)
+    return list(files)
+
+
+def glob_to_re(pattern):
+    """Translate a shell-like glob pattern to a regular expression; return
+    a string containing the regex.  Differs from 'fnmatch.translate()' in
+    that '*' does not match "special characters" (which are
+    platform-specific).
+    """
+    pattern_re = fnmatch.translate(pattern)
+
+    # '?' and '*' in the glob pattern become '.' and '.*' in the RE, which
+    # IMHO is wrong -- '?' and '*' aren't supposed to match slash in Unix,
+    # and by extension they shouldn't match such "special characters" under
+    # any OS.  So change all non-escaped dots in the RE to match any
+    # character except the special characters (currently: just os.sep).
+    sep = os.sep
+    if os.sep == '\\':
+        # we're using a regex to manipulate a regex, so we need
+        # to escape the backslash twice
+        sep = r'\\\\'
+    escaped = rf'\1[^{sep}]'
+    pattern_re = re.sub(r'((?<!\\)(\\\\)*)\.', escaped, pattern_re)
+    return pattern_re
+
+
+def translate_pattern(pattern, anchor=True, prefix=None, is_regex=False):
+    """Translate a shell-like wildcard pattern to a compiled regular
+    expression.  Return the compiled regex.  If 'is_regex' true,
+    then 'pattern' is directly compiled to a regex (if it's a string)
+    or just returned as-is (assumes it's a regex object).
+    """
+    if is_regex:
+        if isinstance(pattern, str):
+            return re.compile(pattern)
+        else:
+            return pattern
+
+    # ditch start and end characters
+    start, _, end = glob_to_re('_').partition('_')
+
+    if pattern:
+        pattern_re = glob_to_re(pattern)
+        assert pattern_re.startswith(start) and pattern_re.endswith(end)
+    else:
+        pattern_re = ''
+
+    if prefix is not None:
+        prefix_re = glob_to_re(prefix)
+        assert prefix_re.startswith(start) and prefix_re.endswith(end)
+        prefix_re = prefix_re[len(start) : len(prefix_re) - len(end)]
+        sep = os.sep
+        if os.sep == '\\':
+            sep = r'\\'
+        pattern_re = pattern_re[len(start) : len(pattern_re) - len(end)]
+        pattern_re = rf'{start}\A{prefix_re}{sep}.*{pattern_re}{end}'
+    else:  # no prefix -- respect anchor flag
+        if anchor:
+            pattern_re = rf'{start}\A{pattern_re[len(start) :]}'
+
+    return re.compile(pattern_re)
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/log.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/log.py
new file mode 100644
index 0000000000000000000000000000000000000000..8abb09cfa2b8ed70cf67ecd80414dc3a9fd4a158
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/log.py
@@ -0,0 +1,56 @@
+"""
+A simple log mechanism styled after PEP 282.
+
+Retained for compatibility and should not be used.
+"""
+
+import logging
+import warnings
+
+from ._log import log as _global_log
+
+DEBUG = logging.DEBUG
+INFO = logging.INFO
+WARN = logging.WARN
+ERROR = logging.ERROR
+FATAL = logging.FATAL
+
+log = _global_log.log
+debug = _global_log.debug
+info = _global_log.info
+warn = _global_log.warning
+error = _global_log.error
+fatal = _global_log.fatal
+
+
+def set_threshold(level):
+    orig = _global_log.level
+    _global_log.setLevel(level)
+    return orig
+
+
+def set_verbosity(v):
+    if v <= 0:
+        set_threshold(logging.WARN)
+    elif v == 1:
+        set_threshold(logging.INFO)
+    elif v >= 2:
+        set_threshold(logging.DEBUG)
+
+
+class Log(logging.Logger):
+    """distutils.log.Log is deprecated, please use an alternative from `logging`."""
+
+    def __init__(self, threshold=WARN):
+        warnings.warn(Log.__doc__)  # avoid DeprecationWarning to ensure warn is shown
+        super().__init__(__name__, level=threshold)
+
+    @property
+    def threshold(self):
+        return self.level
+
+    @threshold.setter
+    def threshold(self, level):
+        self.setLevel(level)
+
+    warn = logging.Logger.warning
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/spawn.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/spawn.py
new file mode 100644
index 0000000000000000000000000000000000000000..973668f2684054741b109bd8bbb573611309cc2f
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/spawn.py
@@ -0,0 +1,134 @@
+"""distutils.spawn
+
+Provides the 'spawn()' function, a front-end to various platform-
+specific functions for launching another program in a sub-process.
+"""
+
+from __future__ import annotations
+
+import os
+import platform
+import shutil
+import subprocess
+import sys
+import warnings
+from collections.abc import Mapping, MutableSequence
+from typing import TYPE_CHECKING, TypeVar, overload
+
+from ._log import log
+from .debug import DEBUG
+from .errors import DistutilsExecError
+
+if TYPE_CHECKING:
+    from subprocess import _ENV
+
+
+_MappingT = TypeVar("_MappingT", bound=Mapping)
+
+
+def _debug(cmd):
+    """
+    Render a subprocess command differently depending on DEBUG.
+    """
+    return cmd if DEBUG else cmd[0]
+
+
+def _inject_macos_ver(env: _MappingT | None) -> _MappingT | dict[str, str | int] | None:
+    if platform.system() != 'Darwin':
+        return env
+
+    from .util import MACOSX_VERSION_VAR, get_macosx_target_ver
+
+    target_ver = get_macosx_target_ver()
+    update = {MACOSX_VERSION_VAR: target_ver} if target_ver else {}
+    return {**_resolve(env), **update}
+
+
+@overload
+def _resolve(env: None) -> os._Environ[str]: ...
+@overload
+def _resolve(env: _MappingT) -> _MappingT: ...
+def _resolve(env: _MappingT | None) -> _MappingT | os._Environ[str]:
+    return os.environ if env is None else env
+
+
+def spawn(
+    cmd: MutableSequence[bytes | str | os.PathLike[str]],
+    search_path: bool = True,
+    verbose: bool = False,
+    dry_run: bool = False,
+    env: _ENV | None = None,
+) -> None:
+    """Run another program, specified as a command list 'cmd', in a new process.
+
+    'cmd' is just the argument list for the new process, ie.
+    cmd[0] is the program to run and cmd[1:] are the rest of its arguments.
+    There is no way to run a program with a name different from that of its
+    executable.
+
+    If 'search_path' is true (the default), the system's executable
+    search path will be used to find the program; otherwise, cmd[0]
+    must be the exact path to the executable.  If 'dry_run' is true,
+    the command will not actually be run.
+
+    Raise DistutilsExecError if running the program fails in any way; just
+    return on success.
+    """
+    log.info(subprocess.list2cmdline(cmd))
+    if dry_run:
+        return
+
+    if search_path:
+        executable = shutil.which(cmd[0])
+        if executable is not None:
+            cmd[0] = executable
+
+    try:
+        subprocess.check_call(cmd, env=_inject_macos_ver(env))
+    except OSError as exc:
+        raise DistutilsExecError(
+            f"command {_debug(cmd)!r} failed: {exc.args[-1]}"
+        ) from exc
+    except subprocess.CalledProcessError as err:
+        raise DistutilsExecError(
+            f"command {_debug(cmd)!r} failed with exit code {err.returncode}"
+        ) from err
+
+
+def find_executable(executable: str, path: str | None = None) -> str | None:
+    """Tries to find 'executable' in the directories listed in 'path'.
+
+    A string listing directories separated by 'os.pathsep'; defaults to
+    os.environ['PATH'].  Returns the complete filename or None if not found.
+    """
+    warnings.warn(
+        'Use shutil.which instead of find_executable', DeprecationWarning, stacklevel=2
+    )
+    _, ext = os.path.splitext(executable)
+    if (sys.platform == 'win32') and (ext != '.exe'):
+        executable = executable + '.exe'
+
+    if os.path.isfile(executable):
+        return executable
+
+    if path is None:
+        path = os.environ.get('PATH', None)
+        # bpo-35755: Don't fall through if PATH is the empty string
+        if path is None:
+            try:
+                path = os.confstr("CS_PATH")
+            except (AttributeError, ValueError):
+                # os.confstr() or CS_PATH is not available
+                path = os.defpath
+
+    # PATH='' doesn't match, whereas PATH=':' looks in the current directory
+    if not path:
+        return None
+
+    paths = path.split(os.pathsep)
+    for p in paths:
+        f = os.path.join(p, executable)
+        if os.path.isfile(f):
+            # the file exists, we have a shot at spawn working
+            return f
+    return None
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/sysconfig.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/sysconfig.py
new file mode 100644
index 0000000000000000000000000000000000000000..7ddc869ab5603d691a8863988da89ec84689de84
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/sysconfig.py
@@ -0,0 +1,598 @@
+"""Provide access to Python's configuration information.  The specific
+configuration variables available depend heavily on the platform and
+configuration.  The values may be retrieved using
+get_config_var(name), and the list of variables is available via
+get_config_vars().keys().  Additional convenience functions are also
+available.
+
+Written by:   Fred L. Drake, Jr.
+Email:        <fdrake@acm.org>
+"""
+
+from __future__ import annotations
+
+import functools
+import os
+import pathlib
+import re
+import sys
+import sysconfig
+from typing import TYPE_CHECKING, Literal, overload
+
+from jaraco.functools import pass_none
+
+from .ccompiler import CCompiler
+from .compat import py39
+from .errors import DistutilsPlatformError
+from .util import is_mingw
+
+if TYPE_CHECKING:
+    from typing_extensions import deprecated
+else:
+
+    def deprecated(message):
+        return lambda fn: fn
+
+
+IS_PYPY = '__pypy__' in sys.builtin_module_names
+
+# These are needed in a couple of spots, so just compute them once.
+PREFIX = os.path.normpath(sys.prefix)
+EXEC_PREFIX = os.path.normpath(sys.exec_prefix)
+BASE_PREFIX = os.path.normpath(sys.base_prefix)
+BASE_EXEC_PREFIX = os.path.normpath(sys.base_exec_prefix)
+
+# Path to the base directory of the project. On Windows the binary may
+# live in project/PCbuild/win32 or project/PCbuild/amd64.
+# set for cross builds
+if "_PYTHON_PROJECT_BASE" in os.environ:
+    project_base = os.path.abspath(os.environ["_PYTHON_PROJECT_BASE"])
+else:
+    if sys.executable:
+        project_base = os.path.dirname(os.path.abspath(sys.executable))
+    else:
+        # sys.executable can be empty if argv[0] has been changed and Python is
+        # unable to retrieve the real program name
+        project_base = os.getcwd()
+
+
+def _is_python_source_dir(d):
+    """
+    Return True if the target directory appears to point to an
+    un-installed Python.
+    """
+    modules = pathlib.Path(d).joinpath('Modules')
+    return any(modules.joinpath(fn).is_file() for fn in ('Setup', 'Setup.local'))
+
+
+_sys_home = getattr(sys, '_home', None)
+
+
+def _is_parent(dir_a, dir_b):
+    """
+    Return True if a is a parent of b.
+    """
+    return os.path.normcase(dir_a).startswith(os.path.normcase(dir_b))
+
+
+if os.name == 'nt':
+
+    @pass_none
+    def _fix_pcbuild(d):
+        # In a venv, sys._home will be inside BASE_PREFIX rather than PREFIX.
+        prefixes = PREFIX, BASE_PREFIX
+        matched = (
+            prefix
+            for prefix in prefixes
+            if _is_parent(d, os.path.join(prefix, "PCbuild"))
+        )
+        return next(matched, d)
+
+    project_base = _fix_pcbuild(project_base)
+    _sys_home = _fix_pcbuild(_sys_home)
+
+
+def _python_build():
+    if _sys_home:
+        return _is_python_source_dir(_sys_home)
+    return _is_python_source_dir(project_base)
+
+
+python_build = _python_build()
+
+
+# Calculate the build qualifier flags if they are defined.  Adding the flags
+# to the include and lib directories only makes sense for an installation, not
+# an in-source build.
+build_flags = ''
+try:
+    if not python_build:
+        build_flags = sys.abiflags
+except AttributeError:
+    # It's not a configure-based build, so the sys module doesn't have
+    # this attribute, which is fine.
+    pass
+
+
+def get_python_version():
+    """Return a string containing the major and minor Python version,
+    leaving off the patchlevel.  Sample return values could be '1.5'
+    or '2.2'.
+    """
+    return f'{sys.version_info.major}.{sys.version_info.minor}'
+
+
+def get_python_inc(plat_specific: bool = False, prefix: str | None = None) -> str:
+    """Return the directory containing installed Python header files.
+
+    If 'plat_specific' is false (the default), this is the path to the
+    non-platform-specific header files, i.e. Python.h and so on;
+    otherwise, this is the path to platform-specific header files
+    (namely pyconfig.h).
+
+    If 'prefix' is supplied, use it instead of sys.base_prefix or
+    sys.base_exec_prefix -- i.e., ignore 'plat_specific'.
+    """
+    default_prefix = BASE_EXEC_PREFIX if plat_specific else BASE_PREFIX
+    resolved_prefix = prefix if prefix is not None else default_prefix
+    # MinGW imitates posix like layout, but os.name != posix
+    os_name = "posix" if is_mingw() else os.name
+    try:
+        getter = globals()[f'_get_python_inc_{os_name}']
+    except KeyError:
+        raise DistutilsPlatformError(
+            "I don't know where Python installs its C header files "
+            f"on platform '{os.name}'"
+        )
+    return getter(resolved_prefix, prefix, plat_specific)
+
+
+@pass_none
+def _extant(path):
+    """
+    Replace path with None if it doesn't exist.
+    """
+    return path if os.path.exists(path) else None
+
+
+def _get_python_inc_posix(prefix, spec_prefix, plat_specific):
+    return (
+        _get_python_inc_posix_python(plat_specific)
+        or _extant(_get_python_inc_from_config(plat_specific, spec_prefix))
+        or _get_python_inc_posix_prefix(prefix)
+    )
+
+
+def _get_python_inc_posix_python(plat_specific):
+    """
+    Assume the executable is in the build directory. The
+    pyconfig.h file should be in the same directory. Since
+    the build directory may not be the source directory,
+    use "srcdir" from the makefile to find the "Include"
+    directory.
+    """
+    if not python_build:
+        return
+    if plat_specific:
+        return _sys_home or project_base
+    incdir = os.path.join(get_config_var('srcdir'), 'Include')
+    return os.path.normpath(incdir)
+
+
+def _get_python_inc_from_config(plat_specific, spec_prefix):
+    """
+    If no prefix was explicitly specified, provide the include
+    directory from the config vars. Useful when
+    cross-compiling, since the config vars may come from
+    the host
+    platform Python installation, while the current Python
+    executable is from the build platform installation.
+
+    >>> monkeypatch = getfixture('monkeypatch')
+    >>> gpifc = _get_python_inc_from_config
+    >>> monkeypatch.setitem(gpifc.__globals__, 'get_config_var', str.lower)
+    >>> gpifc(False, '/usr/bin/')
+    >>> gpifc(False, '')
+    >>> gpifc(False, None)
+    'includepy'
+    >>> gpifc(True, None)
+    'confincludepy'
+    """
+    if spec_prefix is None:
+        return get_config_var('CONF' * plat_specific + 'INCLUDEPY')
+
+
+def _get_python_inc_posix_prefix(prefix):
+    implementation = 'pypy' if IS_PYPY else 'python'
+    python_dir = implementation + get_python_version() + build_flags
+    return os.path.join(prefix, "include", python_dir)
+
+
+def _get_python_inc_nt(prefix, spec_prefix, plat_specific):
+    if python_build:
+        # Include both include dirs to ensure we can find pyconfig.h
+        return (
+            os.path.join(prefix, "include")
+            + os.path.pathsep
+            + os.path.dirname(sysconfig.get_config_h_filename())
+        )
+    return os.path.join(prefix, "include")
+
+
+# allow this behavior to be monkey-patched. Ref pypa/distutils#2.
+def _posix_lib(standard_lib, libpython, early_prefix, prefix):
+    if standard_lib:
+        return libpython
+    else:
+        return os.path.join(libpython, "site-packages")
+
+
+def get_python_lib(
+    plat_specific: bool = False, standard_lib: bool = False, prefix: str | None = None
+) -> str:
+    """Return the directory containing the Python library (standard or
+    site additions).
+
+    If 'plat_specific' is true, return the directory containing
+    platform-specific modules, i.e. any module from a non-pure-Python
+    module distribution; otherwise, return the platform-shared library
+    directory.  If 'standard_lib' is true, return the directory
+    containing standard Python library modules; otherwise, return the
+    directory for site-specific modules.
+
+    If 'prefix' is supplied, use it instead of sys.base_prefix or
+    sys.base_exec_prefix -- i.e., ignore 'plat_specific'.
+    """
+
+    early_prefix = prefix
+
+    if prefix is None:
+        if standard_lib:
+            prefix = plat_specific and BASE_EXEC_PREFIX or BASE_PREFIX
+        else:
+            prefix = plat_specific and EXEC_PREFIX or PREFIX
+
+    if os.name == "posix" or is_mingw():
+        if plat_specific or standard_lib:
+            # Platform-specific modules (any module from a non-pure-Python
+            # module distribution) or standard Python library modules.
+            libdir = getattr(sys, "platlibdir", "lib")
+        else:
+            # Pure Python
+            libdir = "lib"
+        implementation = 'pypy' if IS_PYPY else 'python'
+        libpython = os.path.join(prefix, libdir, implementation + get_python_version())
+        return _posix_lib(standard_lib, libpython, early_prefix, prefix)
+    elif os.name == "nt":
+        if standard_lib:
+            return os.path.join(prefix, "Lib")
+        else:
+            return os.path.join(prefix, "Lib", "site-packages")
+    else:
+        raise DistutilsPlatformError(
+            f"I don't know where Python installs its library on platform '{os.name}'"
+        )
+
+
+@functools.lru_cache
+def _customize_macos():
+    """
+    Perform first-time customization of compiler-related
+    config vars on macOS. Use after a compiler is known
+    to be needed. This customization exists primarily to support Pythons
+    from binary installers. The kind and paths to build tools on
+    the user system may vary significantly from the system
+    that Python itself was built on.  Also the user OS
+    version and build tools may not support the same set
+    of CPU architectures for universal builds.
+    """
+
+    sys.platform == "darwin" and __import__('_osx_support').customize_compiler(
+        get_config_vars()
+    )
+
+
+def customize_compiler(compiler: CCompiler) -> None:
+    """Do any platform-specific customization of a CCompiler instance.
+
+    Mainly needed on Unix, so we can plug in the information that
+    varies across Unices and is stored in Python's Makefile.
+    """
+    if compiler.compiler_type in ["unix", "cygwin"] or (
+        compiler.compiler_type == "mingw32" and is_mingw()
+    ):
+        _customize_macos()
+
+        (
+            cc,
+            cxx,
+            cflags,
+            ccshared,
+            ldshared,
+            ldcxxshared,
+            shlib_suffix,
+            ar,
+            ar_flags,
+        ) = get_config_vars(
+            'CC',
+            'CXX',
+            'CFLAGS',
+            'CCSHARED',
+            'LDSHARED',
+            'LDCXXSHARED',
+            'SHLIB_SUFFIX',
+            'AR',
+            'ARFLAGS',
+        )
+
+        cxxflags = cflags
+
+        if 'CC' in os.environ:
+            newcc = os.environ['CC']
+            if 'LDSHARED' not in os.environ and ldshared.startswith(cc):
+                # If CC is overridden, use that as the default
+                #       command for LDSHARED as well
+                ldshared = newcc + ldshared[len(cc) :]
+            cc = newcc
+        cxx = os.environ.get('CXX', cxx)
+        ldshared = os.environ.get('LDSHARED', ldshared)
+        ldcxxshared = os.environ.get('LDCXXSHARED', ldcxxshared)
+        cpp = os.environ.get(
+            'CPP',
+            cc + " -E",  # not always
+        )
+
+        ldshared = _add_flags(ldshared, 'LD')
+        ldcxxshared = _add_flags(ldcxxshared, 'LD')
+        cflags = os.environ.get('CFLAGS', cflags)
+        ldshared = _add_flags(ldshared, 'C')
+        cxxflags = os.environ.get('CXXFLAGS', cxxflags)
+        ldcxxshared = _add_flags(ldcxxshared, 'CXX')
+        cpp = _add_flags(cpp, 'CPP')
+        cflags = _add_flags(cflags, 'CPP')
+        cxxflags = _add_flags(cxxflags, 'CPP')
+        ldshared = _add_flags(ldshared, 'CPP')
+        ldcxxshared = _add_flags(ldcxxshared, 'CPP')
+
+        ar = os.environ.get('AR', ar)
+
+        archiver = ar + ' ' + os.environ.get('ARFLAGS', ar_flags)
+        cc_cmd = cc + ' ' + cflags
+        cxx_cmd = cxx + ' ' + cxxflags
+
+        compiler.set_executables(
+            preprocessor=cpp,
+            compiler=cc_cmd,
+            compiler_so=cc_cmd + ' ' + ccshared,
+            compiler_cxx=cxx_cmd,
+            compiler_so_cxx=cxx_cmd + ' ' + ccshared,
+            linker_so=ldshared,
+            linker_so_cxx=ldcxxshared,
+            linker_exe=cc,
+            linker_exe_cxx=cxx,
+            archiver=archiver,
+        )
+
+        if 'RANLIB' in os.environ and compiler.executables.get('ranlib', None):
+            compiler.set_executables(ranlib=os.environ['RANLIB'])
+
+        compiler.shared_lib_extension = shlib_suffix
+
+
+def get_config_h_filename() -> str:
+    """Return full pathname of installed pyconfig.h file."""
+    return sysconfig.get_config_h_filename()
+
+
+def get_makefile_filename() -> str:
+    """Return full pathname of installed Makefile from the Python build."""
+    return sysconfig.get_makefile_filename()
+
+
+def parse_config_h(fp, g=None):
+    """Parse a config.h-style file.
+
+    A dictionary containing name/value pairs is returned.  If an
+    optional dictionary is passed in as the second argument, it is
+    used instead of a new dictionary.
+    """
+    return sysconfig.parse_config_h(fp, vars=g)
+
+
+# Regexes needed for parsing Makefile (and similar syntaxes,
+# like old-style Setup files).
+_variable_rx = re.compile(r"([a-zA-Z][a-zA-Z0-9_]+)\s*=\s*(.*)")
+_findvar1_rx = re.compile(r"\$\(([A-Za-z][A-Za-z0-9_]*)\)")
+_findvar2_rx = re.compile(r"\${([A-Za-z][A-Za-z0-9_]*)}")
+
+
+def parse_makefile(fn, g=None):  # noqa: C901
+    """Parse a Makefile-style file.
+
+    A dictionary containing name/value pairs is returned.  If an
+    optional dictionary is passed in as the second argument, it is
+    used instead of a new dictionary.
+    """
+    from distutils.text_file import TextFile
+
+    fp = TextFile(
+        fn,
+        strip_comments=True,
+        skip_blanks=True,
+        join_lines=True,
+        errors="surrogateescape",
+    )
+
+    if g is None:
+        g = {}
+    done = {}
+    notdone = {}
+
+    while True:
+        line = fp.readline()
+        if line is None:  # eof
+            break
+        m = _variable_rx.match(line)
+        if m:
+            n, v = m.group(1, 2)
+            v = v.strip()
+            # `$$' is a literal `$' in make
+            tmpv = v.replace('$$', '')
+
+            if "$" in tmpv:
+                notdone[n] = v
+            else:
+                try:
+                    v = int(v)
+                except ValueError:
+                    # insert literal `$'
+                    done[n] = v.replace('$$', '$')
+                else:
+                    done[n] = v
+
+    # Variables with a 'PY_' prefix in the makefile. These need to
+    # be made available without that prefix through sysconfig.
+    # Special care is needed to ensure that variable expansion works, even
+    # if the expansion uses the name without a prefix.
+    renamed_variables = ('CFLAGS', 'LDFLAGS', 'CPPFLAGS')
+
+    # do variable interpolation here
+    while notdone:
+        for name in list(notdone):
+            value = notdone[name]
+            m = _findvar1_rx.search(value) or _findvar2_rx.search(value)
+            if m:
+                n = m.group(1)
+                found = True
+                if n in done:
+                    item = str(done[n])
+                elif n in notdone:
+                    # get it on a subsequent round
+                    found = False
+                elif n in os.environ:
+                    # do it like make: fall back to environment
+                    item = os.environ[n]
+
+                elif n in renamed_variables:
+                    if name.startswith('PY_') and name[3:] in renamed_variables:
+                        item = ""
+
+                    elif 'PY_' + n in notdone:
+                        found = False
+
+                    else:
+                        item = str(done['PY_' + n])
+                else:
+                    done[n] = item = ""
+                if found:
+                    after = value[m.end() :]
+                    value = value[: m.start()] + item + after
+                    if "$" in after:
+                        notdone[name] = value
+                    else:
+                        try:
+                            value = int(value)
+                        except ValueError:
+                            done[name] = value.strip()
+                        else:
+                            done[name] = value
+                        del notdone[name]
+
+                        if name.startswith('PY_') and name[3:] in renamed_variables:
+                            name = name[3:]
+                            if name not in done:
+                                done[name] = value
+            else:
+                # bogus variable reference; just drop it since we can't deal
+                del notdone[name]
+
+    fp.close()
+
+    # strip spurious spaces
+    for k, v in done.items():
+        if isinstance(v, str):
+            done[k] = v.strip()
+
+    # save the results in the global dictionary
+    g.update(done)
+    return g
+
+
+def expand_makefile_vars(s, vars):
+    """Expand Makefile-style variables -- "${foo}" or "$(foo)" -- in
+    'string' according to 'vars' (a dictionary mapping variable names to
+    values).  Variables not present in 'vars' are silently expanded to the
+    empty string.  The variable values in 'vars' should not contain further
+    variable expansions; if 'vars' is the output of 'parse_makefile()',
+    you're fine.  Returns a variable-expanded version of 's'.
+    """
+
+    # This algorithm does multiple expansion, so if vars['foo'] contains
+    # "${bar}", it will expand ${foo} to ${bar}, and then expand
+    # ${bar}... and so forth.  This is fine as long as 'vars' comes from
+    # 'parse_makefile()', which takes care of such expansions eagerly,
+    # according to make's variable expansion semantics.
+
+    while True:
+        m = _findvar1_rx.search(s) or _findvar2_rx.search(s)
+        if m:
+            (beg, end) = m.span()
+            s = s[0:beg] + vars.get(m.group(1)) + s[end:]
+        else:
+            break
+    return s
+
+
+_config_vars = None
+
+
+@overload
+def get_config_vars() -> dict[str, str | int]: ...
+@overload
+def get_config_vars(arg: str, /, *args: str) -> list[str | int]: ...
+def get_config_vars(*args: str) -> list[str | int] | dict[str, str | int]:
+    """With no arguments, return a dictionary of all configuration
+    variables relevant for the current platform.  Generally this includes
+    everything needed to build extensions and install both pure modules and
+    extensions.  On Unix, this means every variable defined in Python's
+    installed Makefile; on Windows it's a much smaller set.
+
+    With arguments, return a list of values that result from looking up
+    each argument in the configuration variable dictionary.
+    """
+    global _config_vars
+    if _config_vars is None:
+        _config_vars = sysconfig.get_config_vars().copy()
+        py39.add_ext_suffix(_config_vars)
+
+    return [_config_vars.get(name) for name in args] if args else _config_vars
+
+
+@overload
+@deprecated(
+    "SO is deprecated, use EXT_SUFFIX. Support will be removed when this module is synchronized with stdlib Python 3.11"
+)
+def get_config_var(name: Literal["SO"]) -> int | str | None: ...
+@overload
+def get_config_var(name: str) -> int | str | None: ...
+def get_config_var(name: str) -> int | str | None:
+    """Return the value of a single variable using the dictionary
+    returned by 'get_config_vars()'.  Equivalent to
+    get_config_vars().get(name)
+    """
+    if name == 'SO':
+        import warnings
+
+        warnings.warn('SO is deprecated, use EXT_SUFFIX', DeprecationWarning, 2)
+    return get_config_vars().get(name)
+
+
+@pass_none
+def _add_flags(value: str, type: str) -> str:
+    """
+    Add any flags from the environment for the given type.
+
+    type is the prefix to FLAGS in the environment key (e.g. "C" for "CFLAGS").
+    """
+    flags = os.environ.get(f'{type}FLAGS')
+    return f'{value} {flags}' if flags else value
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/__init__.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..5a8ab061009f1cd87a53ce51eff3bc9e9a632273
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/__init__.py
@@ -0,0 +1,42 @@
+"""
+Test suite for distutils.
+
+Tests for the command classes in the distutils.command package are
+included in distutils.tests as well, instead of using a separate
+distutils.command.tests package, since command identification is done
+by import rather than matching pre-defined names.
+"""
+
+import shutil
+from collections.abc import Sequence
+
+
+def missing_compiler_executable(cmd_names: Sequence[str] = []):  # pragma: no cover
+    """Check if the compiler components used to build the interpreter exist.
+
+    Check for the existence of the compiler executables whose names are listed
+    in 'cmd_names' or all the compiler executables when 'cmd_names' is empty
+    and return the first missing executable or None when none is found
+    missing.
+
+    """
+    from distutils import ccompiler, errors, sysconfig
+
+    compiler = ccompiler.new_compiler()
+    sysconfig.customize_compiler(compiler)
+    if compiler.compiler_type == "msvc":
+        # MSVC has no executables, so check whether initialization succeeds
+        try:
+            compiler.initialize()
+        except errors.DistutilsPlatformError:
+            return "msvc"
+    for name in compiler.executables:
+        if cmd_names and name not in cmd_names:
+            continue
+        cmd = getattr(compiler, name)
+        if cmd_names:
+            assert cmd is not None, f"the '{name}' executable is not configured"
+        elif not cmd:
+            continue
+        if shutil.which(cmd[0]) is None:
+            return cmd[0]
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/__pycache__/__init__.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..3c9f2e11776fed97dbd0059fd4e6cd565a3bbbd7
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/__pycache__/__init__.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/__pycache__/support.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/__pycache__/support.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..adf1a4fff0a314948518d742ce550fe607498574
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/__pycache__/support.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/__pycache__/test_archive_util.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/__pycache__/test_archive_util.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..67b9837250d8d0aad11bd4d430a7457760cb6100
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/__pycache__/test_archive_util.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/__pycache__/test_bdist.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/__pycache__/test_bdist.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..66683d9ea1d8f11745e627e998c6a9ee04e323ea
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/__pycache__/test_bdist.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/__pycache__/test_bdist_dumb.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/__pycache__/test_bdist_dumb.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..8ac31b8bc04a532f99a2613bf801539779506def
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/__pycache__/test_bdist_dumb.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/__pycache__/test_bdist_rpm.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/__pycache__/test_bdist_rpm.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..97c7232ed688779987a14cddf09d36cb286cb0da
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/__pycache__/test_bdist_rpm.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/__pycache__/test_build.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/__pycache__/test_build.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..90e36eac7a8cd8798be35ce5d47652a1a4d9c872
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/__pycache__/test_build.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/__pycache__/test_build_clib.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/__pycache__/test_build_clib.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..949f3a4e35525cb60b73250c767f4309cd037a04
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/__pycache__/test_build_clib.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/__pycache__/test_build_ext.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/__pycache__/test_build_ext.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..1b97a2dc9adb997eb27923ee398ccac7d0c55f3f
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/__pycache__/test_build_ext.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/__pycache__/test_build_py.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/__pycache__/test_build_py.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d723afa6753188a13b2594b321312bc68a78d59b
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/__pycache__/test_build_py.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/__pycache__/test_versionpredicate.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/__pycache__/test_versionpredicate.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..8648393d33e823ce3f897034723d86116953d6ab
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/__pycache__/test_versionpredicate.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/__pycache__/unix_compat.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/__pycache__/unix_compat.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..828732be613023760b38aa134f3fa7418597b18e
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/__pycache__/unix_compat.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/compat/__init__.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/compat/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/compat/py39.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/compat/py39.py
new file mode 100644
index 0000000000000000000000000000000000000000..aca3939a0cea90dd0a90d7f36fcf83a5167cbfc4
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/compat/py39.py
@@ -0,0 +1,40 @@
+import sys
+
+if sys.version_info >= (3, 10):
+    from test.support.import_helper import (
+        CleanImport as CleanImport,
+    )
+    from test.support.import_helper import (
+        DirsOnSysPath as DirsOnSysPath,
+    )
+    from test.support.os_helper import (
+        EnvironmentVarGuard as EnvironmentVarGuard,
+    )
+    from test.support.os_helper import (
+        rmtree as rmtree,
+    )
+    from test.support.os_helper import (
+        skip_unless_symlink as skip_unless_symlink,
+    )
+    from test.support.os_helper import (
+        unlink as unlink,
+    )
+else:
+    from test.support import (
+        CleanImport as CleanImport,
+    )
+    from test.support import (
+        DirsOnSysPath as DirsOnSysPath,
+    )
+    from test.support import (
+        EnvironmentVarGuard as EnvironmentVarGuard,
+    )
+    from test.support import (
+        rmtree as rmtree,
+    )
+    from test.support import (
+        skip_unless_symlink as skip_unless_symlink,
+    )
+    from test.support import (
+        unlink as unlink,
+    )
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/support.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/support.py
new file mode 100644
index 0000000000000000000000000000000000000000..9cd2b8a9eedbb9f11a3ed793af57b3290c5febef
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/support.py
@@ -0,0 +1,134 @@
+"""Support code for distutils test cases."""
+
+import itertools
+import os
+import pathlib
+import shutil
+import sys
+import sysconfig
+import tempfile
+from distutils.core import Distribution
+
+import pytest
+from more_itertools import always_iterable
+
+
+@pytest.mark.usefixtures('distutils_managed_tempdir')
+class TempdirManager:
+    """
+    Mix-in class that handles temporary directories for test cases.
+    """
+
+    def mkdtemp(self):
+        """Create a temporary directory that will be cleaned up.
+
+        Returns the path of the directory.
+        """
+        d = tempfile.mkdtemp()
+        self.tempdirs.append(d)
+        return d
+
+    def write_file(self, path, content='xxx'):
+        """Writes a file in the given path.
+
+        path can be a string or a sequence.
+        """
+        pathlib.Path(*always_iterable(path)).write_text(content, encoding='utf-8')
+
+    def create_dist(self, pkg_name='foo', **kw):
+        """Will generate a test environment.
+
+        This function creates:
+         - a Distribution instance using keywords
+         - a temporary directory with a package structure
+
+        It returns the package directory and the distribution
+        instance.
+        """
+        tmp_dir = self.mkdtemp()
+        pkg_dir = os.path.join(tmp_dir, pkg_name)
+        os.mkdir(pkg_dir)
+        dist = Distribution(attrs=kw)
+
+        return pkg_dir, dist
+
+
+class DummyCommand:
+    """Class to store options for retrieval via set_undefined_options()."""
+
+    def __init__(self, **kwargs):
+        vars(self).update(kwargs)
+
+    def ensure_finalized(self):
+        pass
+
+
+def copy_xxmodule_c(directory):
+    """Helper for tests that need the xxmodule.c source file.
+
+    Example use:
+
+        def test_compile(self):
+            copy_xxmodule_c(self.tmpdir)
+            self.assertIn('xxmodule.c', os.listdir(self.tmpdir))
+
+    If the source file can be found, it will be copied to *directory*.  If not,
+    the test will be skipped.  Errors during copy are not caught.
+    """
+    shutil.copy(_get_xxmodule_path(), os.path.join(directory, 'xxmodule.c'))
+
+
+def _get_xxmodule_path():
+    source_name = 'xxmodule.c' if sys.version_info > (3, 9) else 'xxmodule-3.8.c'
+    return os.path.join(os.path.dirname(__file__), source_name)
+
+
+def fixup_build_ext(cmd):
+    """Function needed to make build_ext tests pass.
+
+    When Python was built with --enable-shared on Unix, -L. is not enough to
+    find libpython<blah>.so, because regrtest runs in a tempdir, not in the
+    source directory where the .so lives.
+
+    When Python was built with in debug mode on Windows, build_ext commands
+    need their debug attribute set, and it is not done automatically for
+    some reason.
+
+    This function handles both of these things.  Example use:
+
+        cmd = build_ext(dist)
+        support.fixup_build_ext(cmd)
+        cmd.ensure_finalized()
+
+    Unlike most other Unix platforms, Mac OS X embeds absolute paths
+    to shared libraries into executables, so the fixup is not needed there.
+    """
+    if os.name == 'nt':
+        cmd.debug = sys.executable.endswith('_d.exe')
+    elif sysconfig.get_config_var('Py_ENABLE_SHARED'):
+        # To further add to the shared builds fun on Unix, we can't just add
+        # library_dirs to the Extension() instance because that doesn't get
+        # plumbed through to the final compiler command.
+        runshared = sysconfig.get_config_var('RUNSHARED')
+        if runshared is None:
+            cmd.library_dirs = ['.']
+        else:
+            if sys.platform == 'darwin':
+                cmd.library_dirs = []
+            else:
+                name, equals, value = runshared.partition('=')
+                cmd.library_dirs = [d for d in value.split(os.pathsep) if d]
+
+
+def combine_markers(cls):
+    """
+    pytest will honor markers as found on the class, but when
+    markers are on multiple subclasses, only one appears. Use
+    this decorator to combine those markers.
+    """
+    cls.pytestmark = [
+        mark
+        for base in itertools.chain([cls], cls.__bases__)
+        for mark in getattr(base, 'pytestmark', [])
+    ]
+    return cls
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/test_archive_util.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/test_archive_util.py
new file mode 100644
index 0000000000000000000000000000000000000000..3e4ed75a761dc26fc7dc29066138a02531c6e9c3
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/test_archive_util.py
@@ -0,0 +1,353 @@
+"""Tests for distutils.archive_util."""
+
+import functools
+import operator
+import os
+import pathlib
+import sys
+import tarfile
+from distutils import archive_util
+from distutils.archive_util import (
+    ARCHIVE_FORMATS,
+    check_archive_formats,
+    make_archive,
+    make_tarball,
+    make_zipfile,
+)
+from distutils.spawn import spawn
+from distutils.tests import support
+from os.path import splitdrive
+
+import path
+import pytest
+from test.support import patch
+
+from .unix_compat import UID_0_SUPPORT, grp, pwd, require_uid_0, require_unix_id
+
+
+def can_fs_encode(filename):
+    """
+    Return True if the filename can be saved in the file system.
+    """
+    if os.path.supports_unicode_filenames:
+        return True
+    try:
+        filename.encode(sys.getfilesystemencoding())
+    except UnicodeEncodeError:
+        return False
+    return True
+
+
+def all_equal(values):
+    return functools.reduce(operator.eq, values)
+
+
+def same_drive(*paths):
+    return all_equal(pathlib.Path(path).drive for path in paths)
+
+
+class ArchiveUtilTestCase(support.TempdirManager):
+    @pytest.mark.usefixtures('needs_zlib')
+    def test_make_tarball(self, name='archive'):
+        # creating something to tar
+        tmpdir = self._create_files()
+        self._make_tarball(tmpdir, name, '.tar.gz')
+        # trying an uncompressed one
+        self._make_tarball(tmpdir, name, '.tar', compress=None)
+
+    @pytest.mark.usefixtures('needs_zlib')
+    def test_make_tarball_gzip(self):
+        tmpdir = self._create_files()
+        self._make_tarball(tmpdir, 'archive', '.tar.gz', compress='gzip')
+
+    def test_make_tarball_bzip2(self):
+        pytest.importorskip('bz2')
+        tmpdir = self._create_files()
+        self._make_tarball(tmpdir, 'archive', '.tar.bz2', compress='bzip2')
+
+    def test_make_tarball_xz(self):
+        pytest.importorskip('lzma')
+        tmpdir = self._create_files()
+        self._make_tarball(tmpdir, 'archive', '.tar.xz', compress='xz')
+
+    @pytest.mark.skipif("not can_fs_encode('årchiv')")
+    def test_make_tarball_latin1(self):
+        """
+        Mirror test_make_tarball, except filename contains latin characters.
+        """
+        self.test_make_tarball('årchiv')  # note this isn't a real word
+
+    @pytest.mark.skipif("not can_fs_encode('のアーカイブ')")
+    def test_make_tarball_extended(self):
+        """
+        Mirror test_make_tarball, except filename contains extended
+        characters outside the latin charset.
+        """
+        self.test_make_tarball('のアーカイブ')  # japanese for archive
+
+    def _make_tarball(self, tmpdir, target_name, suffix, **kwargs):
+        tmpdir2 = self.mkdtemp()
+        if same_drive(tmpdir, tmpdir2):
+            pytest.skip("source and target should be on same drive")
+
+        base_name = os.path.join(tmpdir2, target_name)
+
+        # working with relative paths to avoid tar warnings
+        with path.Path(tmpdir):
+            make_tarball(splitdrive(base_name)[1], 'dist', **kwargs)
+
+        # check if the compressed tarball was created
+        tarball = base_name + suffix
+        assert os.path.exists(tarball)
+        assert self._tarinfo(tarball) == self._created_files
+
+    def _tarinfo(self, path):
+        tar = tarfile.open(path)
+        try:
+            names = tar.getnames()
+            names.sort()
+            return names
+        finally:
+            tar.close()
+
+    _zip_created_files = [
+        'dist/',
+        'dist/file1',
+        'dist/file2',
+        'dist/sub/',
+        'dist/sub/file3',
+        'dist/sub2/',
+    ]
+    _created_files = [p.rstrip('/') for p in _zip_created_files]
+
+    def _create_files(self):
+        # creating something to tar
+        tmpdir = self.mkdtemp()
+        dist = os.path.join(tmpdir, 'dist')
+        os.mkdir(dist)
+        self.write_file([dist, 'file1'], 'xxx')
+        self.write_file([dist, 'file2'], 'xxx')
+        os.mkdir(os.path.join(dist, 'sub'))
+        self.write_file([dist, 'sub', 'file3'], 'xxx')
+        os.mkdir(os.path.join(dist, 'sub2'))
+        return tmpdir
+
+    @pytest.mark.usefixtures('needs_zlib')
+    @pytest.mark.skipif("not (shutil.which('tar') and shutil.which('gzip'))")
+    def test_tarfile_vs_tar(self):
+        tmpdir = self._create_files()
+        tmpdir2 = self.mkdtemp()
+        base_name = os.path.join(tmpdir2, 'archive')
+        old_dir = os.getcwd()
+        os.chdir(tmpdir)
+        try:
+            make_tarball(base_name, 'dist')
+        finally:
+            os.chdir(old_dir)
+
+        # check if the compressed tarball was created
+        tarball = base_name + '.tar.gz'
+        assert os.path.exists(tarball)
+
+        # now create another tarball using `tar`
+        tarball2 = os.path.join(tmpdir, 'archive2.tar.gz')
+        tar_cmd = ['tar', '-cf', 'archive2.tar', 'dist']
+        gzip_cmd = ['gzip', '-f', '-9', 'archive2.tar']
+        old_dir = os.getcwd()
+        os.chdir(tmpdir)
+        try:
+            spawn(tar_cmd)
+            spawn(gzip_cmd)
+        finally:
+            os.chdir(old_dir)
+
+        assert os.path.exists(tarball2)
+        # let's compare both tarballs
+        assert self._tarinfo(tarball) == self._created_files
+        assert self._tarinfo(tarball2) == self._created_files
+
+        # trying an uncompressed one
+        base_name = os.path.join(tmpdir2, 'archive')
+        old_dir = os.getcwd()
+        os.chdir(tmpdir)
+        try:
+            make_tarball(base_name, 'dist', compress=None)
+        finally:
+            os.chdir(old_dir)
+        tarball = base_name + '.tar'
+        assert os.path.exists(tarball)
+
+        # now for a dry_run
+        base_name = os.path.join(tmpdir2, 'archive')
+        old_dir = os.getcwd()
+        os.chdir(tmpdir)
+        try:
+            make_tarball(base_name, 'dist', compress=None, dry_run=True)
+        finally:
+            os.chdir(old_dir)
+        tarball = base_name + '.tar'
+        assert os.path.exists(tarball)
+
+    @pytest.mark.usefixtures('needs_zlib')
+    def test_make_zipfile(self):
+        zipfile = pytest.importorskip('zipfile')
+        # creating something to tar
+        tmpdir = self._create_files()
+        base_name = os.path.join(self.mkdtemp(), 'archive')
+        with path.Path(tmpdir):
+            make_zipfile(base_name, 'dist')
+
+        # check if the compressed tarball was created
+        tarball = base_name + '.zip'
+        assert os.path.exists(tarball)
+        with zipfile.ZipFile(tarball) as zf:
+            assert sorted(zf.namelist()) == self._zip_created_files
+
+    def test_make_zipfile_no_zlib(self):
+        zipfile = pytest.importorskip('zipfile')
+        patch(self, archive_util.zipfile, 'zlib', None)  # force zlib ImportError
+
+        called = []
+        zipfile_class = zipfile.ZipFile
+
+        def fake_zipfile(*a, **kw):
+            if kw.get('compression', None) == zipfile.ZIP_STORED:
+                called.append((a, kw))
+            return zipfile_class(*a, **kw)
+
+        patch(self, archive_util.zipfile, 'ZipFile', fake_zipfile)
+
+        # create something to tar and compress
+        tmpdir = self._create_files()
+        base_name = os.path.join(self.mkdtemp(), 'archive')
+        with path.Path(tmpdir):
+            make_zipfile(base_name, 'dist')
+
+        tarball = base_name + '.zip'
+        assert called == [((tarball, "w"), {'compression': zipfile.ZIP_STORED})]
+        assert os.path.exists(tarball)
+        with zipfile.ZipFile(tarball) as zf:
+            assert sorted(zf.namelist()) == self._zip_created_files
+
+    def test_check_archive_formats(self):
+        assert check_archive_formats(['gztar', 'xxx', 'zip']) == 'xxx'
+        assert (
+            check_archive_formats(['gztar', 'bztar', 'xztar', 'ztar', 'tar', 'zip'])
+            is None
+        )
+
+    def test_make_archive(self):
+        tmpdir = self.mkdtemp()
+        base_name = os.path.join(tmpdir, 'archive')
+        with pytest.raises(ValueError):
+            make_archive(base_name, 'xxx')
+
+    def test_make_archive_cwd(self):
+        current_dir = os.getcwd()
+
+        def _breaks(*args, **kw):
+            raise RuntimeError()
+
+        ARCHIVE_FORMATS['xxx'] = (_breaks, [], 'xxx file')
+        try:
+            try:
+                make_archive('xxx', 'xxx', root_dir=self.mkdtemp())
+            except Exception:
+                pass
+            assert os.getcwd() == current_dir
+        finally:
+            ARCHIVE_FORMATS.pop('xxx')
+
+    def test_make_archive_tar(self):
+        base_dir = self._create_files()
+        base_name = os.path.join(self.mkdtemp(), 'archive')
+        res = make_archive(base_name, 'tar', base_dir, 'dist')
+        assert os.path.exists(res)
+        assert os.path.basename(res) == 'archive.tar'
+        assert self._tarinfo(res) == self._created_files
+
+    @pytest.mark.usefixtures('needs_zlib')
+    def test_make_archive_gztar(self):
+        base_dir = self._create_files()
+        base_name = os.path.join(self.mkdtemp(), 'archive')
+        res = make_archive(base_name, 'gztar', base_dir, 'dist')
+        assert os.path.exists(res)
+        assert os.path.basename(res) == 'archive.tar.gz'
+        assert self._tarinfo(res) == self._created_files
+
+    def test_make_archive_bztar(self):
+        pytest.importorskip('bz2')
+        base_dir = self._create_files()
+        base_name = os.path.join(self.mkdtemp(), 'archive')
+        res = make_archive(base_name, 'bztar', base_dir, 'dist')
+        assert os.path.exists(res)
+        assert os.path.basename(res) == 'archive.tar.bz2'
+        assert self._tarinfo(res) == self._created_files
+
+    def test_make_archive_xztar(self):
+        pytest.importorskip('lzma')
+        base_dir = self._create_files()
+        base_name = os.path.join(self.mkdtemp(), 'archive')
+        res = make_archive(base_name, 'xztar', base_dir, 'dist')
+        assert os.path.exists(res)
+        assert os.path.basename(res) == 'archive.tar.xz'
+        assert self._tarinfo(res) == self._created_files
+
+    def test_make_archive_owner_group(self):
+        # testing make_archive with owner and group, with various combinations
+        # this works even if there's not gid/uid support
+        if UID_0_SUPPORT:
+            group = grp.getgrgid(0)[0]
+            owner = pwd.getpwuid(0)[0]
+        else:
+            group = owner = 'root'
+
+        base_dir = self._create_files()
+        root_dir = self.mkdtemp()
+        base_name = os.path.join(self.mkdtemp(), 'archive')
+        res = make_archive(
+            base_name, 'zip', root_dir, base_dir, owner=owner, group=group
+        )
+        assert os.path.exists(res)
+
+        res = make_archive(base_name, 'zip', root_dir, base_dir)
+        assert os.path.exists(res)
+
+        res = make_archive(
+            base_name, 'tar', root_dir, base_dir, owner=owner, group=group
+        )
+        assert os.path.exists(res)
+
+        res = make_archive(
+            base_name, 'tar', root_dir, base_dir, owner='kjhkjhkjg', group='oihohoh'
+        )
+        assert os.path.exists(res)
+
+    @pytest.mark.usefixtures('needs_zlib')
+    @require_unix_id
+    @require_uid_0
+    def test_tarfile_root_owner(self):
+        tmpdir = self._create_files()
+        base_name = os.path.join(self.mkdtemp(), 'archive')
+        old_dir = os.getcwd()
+        os.chdir(tmpdir)
+        group = grp.getgrgid(0)[0]
+        owner = pwd.getpwuid(0)[0]
+        try:
+            archive_name = make_tarball(
+                base_name, 'dist', compress=None, owner=owner, group=group
+            )
+        finally:
+            os.chdir(old_dir)
+
+        # check if the compressed tarball was created
+        assert os.path.exists(archive_name)
+
+        # now checks the rights
+        archive = tarfile.open(archive_name)
+        try:
+            for member in archive.getmembers():
+                assert member.uid == 0
+                assert member.gid == 0
+        finally:
+            archive.close()
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/test_bdist.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/test_bdist.py
new file mode 100644
index 0000000000000000000000000000000000000000..d5696fc3dcd8081335606dc92badd73a69ceac69
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/test_bdist.py
@@ -0,0 +1,47 @@
+"""Tests for distutils.command.bdist."""
+
+from distutils.command.bdist import bdist
+from distutils.tests import support
+
+
+class TestBuild(support.TempdirManager):
+    def test_formats(self):
+        # let's create a command and make sure
+        # we can set the format
+        dist = self.create_dist()[1]
+        cmd = bdist(dist)
+        cmd.formats = ['gztar']
+        cmd.ensure_finalized()
+        assert cmd.formats == ['gztar']
+
+        # what formats does bdist offer?
+        formats = [
+            'bztar',
+            'gztar',
+            'rpm',
+            'tar',
+            'xztar',
+            'zip',
+            'ztar',
+        ]
+        found = sorted(cmd.format_commands)
+        assert found == formats
+
+    def test_skip_build(self):
+        # bug #10946: bdist --skip-build should trickle down to subcommands
+        dist = self.create_dist()[1]
+        cmd = bdist(dist)
+        cmd.skip_build = True
+        cmd.ensure_finalized()
+        dist.command_obj['bdist'] = cmd
+
+        names = [
+            'bdist_dumb',
+        ]  # bdist_rpm does not support --skip-build
+
+        for name in names:
+            subcmd = cmd.get_finalized_command(name)
+            if getattr(subcmd, '_unsupported', False):
+                # command is not supported on this build
+                continue
+            assert subcmd.skip_build, f'{name} should take --skip-build from bdist'
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/test_bdist_dumb.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/test_bdist_dumb.py
new file mode 100644
index 0000000000000000000000000000000000000000..1fc51d244a78058329c56a618b092e466715e565
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/test_bdist_dumb.py
@@ -0,0 +1,78 @@
+"""Tests for distutils.command.bdist_dumb."""
+
+import os
+import sys
+import zipfile
+from distutils.command.bdist_dumb import bdist_dumb
+from distutils.core import Distribution
+from distutils.tests import support
+
+import pytest
+
+SETUP_PY = """\
+from distutils.core import setup
+import foo
+
+setup(name='foo', version='0.1', py_modules=['foo'],
+      url='xxx', author='xxx', author_email='xxx')
+
+"""
+
+
+@support.combine_markers
+@pytest.mark.usefixtures('save_env')
+@pytest.mark.usefixtures('save_argv')
+@pytest.mark.usefixtures('save_cwd')
+class TestBuildDumb(
+    support.TempdirManager,
+):
+    @pytest.mark.usefixtures('needs_zlib')
+    def test_simple_built(self):
+        # let's create a simple package
+        tmp_dir = self.mkdtemp()
+        pkg_dir = os.path.join(tmp_dir, 'foo')
+        os.mkdir(pkg_dir)
+        self.write_file((pkg_dir, 'setup.py'), SETUP_PY)
+        self.write_file((pkg_dir, 'foo.py'), '#')
+        self.write_file((pkg_dir, 'MANIFEST.in'), 'include foo.py')
+        self.write_file((pkg_dir, 'README'), '')
+
+        dist = Distribution({
+            'name': 'foo',
+            'version': '0.1',
+            'py_modules': ['foo'],
+            'url': 'xxx',
+            'author': 'xxx',
+            'author_email': 'xxx',
+        })
+        dist.script_name = 'setup.py'
+        os.chdir(pkg_dir)
+
+        sys.argv = ['setup.py']
+        cmd = bdist_dumb(dist)
+
+        # so the output is the same no matter
+        # what is the platform
+        cmd.format = 'zip'
+
+        cmd.ensure_finalized()
+        cmd.run()
+
+        # see what we have
+        dist_created = os.listdir(os.path.join(pkg_dir, 'dist'))
+        base = f"{dist.get_fullname()}.{cmd.plat_name}.zip"
+
+        assert dist_created == [base]
+
+        # now let's check what we have in the zip file
+        fp = zipfile.ZipFile(os.path.join('dist', base))
+        try:
+            contents = fp.namelist()
+        finally:
+            fp.close()
+
+        contents = sorted(filter(None, map(os.path.basename, contents)))
+        wanted = ['foo-0.1-py{}.{}.egg-info'.format(*sys.version_info[:2]), 'foo.py']
+        if not sys.dont_write_bytecode:
+            wanted.append(f'foo.{sys.implementation.cache_tag}.pyc')
+        assert contents == sorted(wanted)
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/test_bdist_rpm.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/test_bdist_rpm.py
new file mode 100644
index 0000000000000000000000000000000000000000..75051430e224c8908e22601133a40f5f82ee455a
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/test_bdist_rpm.py
@@ -0,0 +1,127 @@
+"""Tests for distutils.command.bdist_rpm."""
+
+import os
+import shutil  # noqa: F401
+import sys
+from distutils.command.bdist_rpm import bdist_rpm
+from distutils.core import Distribution
+from distutils.tests import support
+
+import pytest
+from test.support import requires_zlib
+
+SETUP_PY = """\
+from distutils.core import setup
+import foo
+
+setup(name='foo', version='0.1', py_modules=['foo'],
+      url='xxx', author='xxx', author_email='xxx')
+
+"""
+
+
+@pytest.fixture(autouse=True)
+def sys_executable_encodable():
+    try:
+        sys.executable.encode('UTF-8')
+    except UnicodeEncodeError:
+        pytest.skip("sys.executable is not encodable to UTF-8")
+
+
+mac_woes = pytest.mark.skipif(
+    "not sys.platform.startswith('linux')",
+    reason='spurious sdtout/stderr output under macOS',
+)
+
+
+@pytest.mark.usefixtures('save_env')
+@pytest.mark.usefixtures('save_argv')
+@pytest.mark.usefixtures('save_cwd')
+class TestBuildRpm(
+    support.TempdirManager,
+):
+    @mac_woes
+    @requires_zlib()
+    @pytest.mark.skipif("not shutil.which('rpm')")
+    @pytest.mark.skipif("not shutil.which('rpmbuild')")
+    def test_quiet(self):
+        # let's create a package
+        tmp_dir = self.mkdtemp()
+        os.environ['HOME'] = tmp_dir  # to confine dir '.rpmdb' creation
+        pkg_dir = os.path.join(tmp_dir, 'foo')
+        os.mkdir(pkg_dir)
+        self.write_file((pkg_dir, 'setup.py'), SETUP_PY)
+        self.write_file((pkg_dir, 'foo.py'), '#')
+        self.write_file((pkg_dir, 'MANIFEST.in'), 'include foo.py')
+        self.write_file((pkg_dir, 'README'), '')
+
+        dist = Distribution({
+            'name': 'foo',
+            'version': '0.1',
+            'py_modules': ['foo'],
+            'url': 'xxx',
+            'author': 'xxx',
+            'author_email': 'xxx',
+        })
+        dist.script_name = 'setup.py'
+        os.chdir(pkg_dir)
+
+        sys.argv = ['setup.py']
+        cmd = bdist_rpm(dist)
+        cmd.fix_python = True
+
+        # running in quiet mode
+        cmd.quiet = True
+        cmd.ensure_finalized()
+        cmd.run()
+
+        dist_created = os.listdir(os.path.join(pkg_dir, 'dist'))
+        assert 'foo-0.1-1.noarch.rpm' in dist_created
+
+        # bug #2945: upload ignores bdist_rpm files
+        assert ('bdist_rpm', 'any', 'dist/foo-0.1-1.src.rpm') in dist.dist_files
+        assert ('bdist_rpm', 'any', 'dist/foo-0.1-1.noarch.rpm') in dist.dist_files
+
+    @mac_woes
+    @requires_zlib()
+    # https://bugs.python.org/issue1533164
+    @pytest.mark.skipif("not shutil.which('rpm')")
+    @pytest.mark.skipif("not shutil.which('rpmbuild')")
+    def test_no_optimize_flag(self):
+        # let's create a package that breaks bdist_rpm
+        tmp_dir = self.mkdtemp()
+        os.environ['HOME'] = tmp_dir  # to confine dir '.rpmdb' creation
+        pkg_dir = os.path.join(tmp_dir, 'foo')
+        os.mkdir(pkg_dir)
+        self.write_file((pkg_dir, 'setup.py'), SETUP_PY)
+        self.write_file((pkg_dir, 'foo.py'), '#')
+        self.write_file((pkg_dir, 'MANIFEST.in'), 'include foo.py')
+        self.write_file((pkg_dir, 'README'), '')
+
+        dist = Distribution({
+            'name': 'foo',
+            'version': '0.1',
+            'py_modules': ['foo'],
+            'url': 'xxx',
+            'author': 'xxx',
+            'author_email': 'xxx',
+        })
+        dist.script_name = 'setup.py'
+        os.chdir(pkg_dir)
+
+        sys.argv = ['setup.py']
+        cmd = bdist_rpm(dist)
+        cmd.fix_python = True
+
+        cmd.quiet = True
+        cmd.ensure_finalized()
+        cmd.run()
+
+        dist_created = os.listdir(os.path.join(pkg_dir, 'dist'))
+        assert 'foo-0.1-1.noarch.rpm' in dist_created
+
+        # bug #2945: upload ignores bdist_rpm files
+        assert ('bdist_rpm', 'any', 'dist/foo-0.1-1.src.rpm') in dist.dist_files
+        assert ('bdist_rpm', 'any', 'dist/foo-0.1-1.noarch.rpm') in dist.dist_files
+
+        os.remove(os.path.join(pkg_dir, 'dist', 'foo-0.1-1.noarch.rpm'))
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/test_build.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/test_build.py
new file mode 100644
index 0000000000000000000000000000000000000000..f7fe69acd1ad39cf40d277afd6409648b18df146
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/test_build.py
@@ -0,0 +1,49 @@
+"""Tests for distutils.command.build."""
+
+import os
+import sys
+from distutils.command.build import build
+from distutils.tests import support
+from sysconfig import get_config_var, get_platform
+
+
+class TestBuild(support.TempdirManager):
+    def test_finalize_options(self):
+        pkg_dir, dist = self.create_dist()
+        cmd = build(dist)
+        cmd.finalize_options()
+
+        # if not specified, plat_name gets the current platform
+        assert cmd.plat_name == get_platform()
+
+        # build_purelib is build + lib
+        wanted = os.path.join(cmd.build_base, 'lib')
+        assert cmd.build_purelib == wanted
+
+        # build_platlib is 'build/lib.platform-cache_tag[-pydebug]'
+        # examples:
+        #   build/lib.macosx-10.3-i386-cpython39
+        plat_spec = f'.{cmd.plat_name}-{sys.implementation.cache_tag}'
+        if get_config_var('Py_GIL_DISABLED'):
+            plat_spec += 't'
+        if hasattr(sys, 'gettotalrefcount'):
+            assert cmd.build_platlib.endswith('-pydebug')
+            plat_spec += '-pydebug'
+        wanted = os.path.join(cmd.build_base, 'lib' + plat_spec)
+        assert cmd.build_platlib == wanted
+
+        # by default, build_lib = build_purelib
+        assert cmd.build_lib == cmd.build_purelib
+
+        # build_temp is build/temp.<plat>
+        wanted = os.path.join(cmd.build_base, 'temp' + plat_spec)
+        assert cmd.build_temp == wanted
+
+        # build_scripts is build/scripts-x.x
+        wanted = os.path.join(
+            cmd.build_base, f'scripts-{sys.version_info.major}.{sys.version_info.minor}'
+        )
+        assert cmd.build_scripts == wanted
+
+        # executable is os.path.normpath(sys.executable)
+        assert cmd.executable == os.path.normpath(sys.executable)
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/test_build_clib.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/test_build_clib.py
new file mode 100644
index 0000000000000000000000000000000000000000..f76f26bcea04ebeaeba20d3c65881198f841c9b5
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/test_build_clib.py
@@ -0,0 +1,134 @@
+"""Tests for distutils.command.build_clib."""
+
+import os
+from distutils.command.build_clib import build_clib
+from distutils.errors import DistutilsSetupError
+from distutils.tests import missing_compiler_executable, support
+
+import pytest
+
+
+class TestBuildCLib(support.TempdirManager):
+    def test_check_library_dist(self):
+        pkg_dir, dist = self.create_dist()
+        cmd = build_clib(dist)
+
+        # 'libraries' option must be a list
+        with pytest.raises(DistutilsSetupError):
+            cmd.check_library_list('foo')
+
+        # each element of 'libraries' must a 2-tuple
+        with pytest.raises(DistutilsSetupError):
+            cmd.check_library_list(['foo1', 'foo2'])
+
+        # first element of each tuple in 'libraries'
+        # must be a string (the library name)
+        with pytest.raises(DistutilsSetupError):
+            cmd.check_library_list([(1, 'foo1'), ('name', 'foo2')])
+
+        # library name may not contain directory separators
+        with pytest.raises(DistutilsSetupError):
+            cmd.check_library_list(
+                [('name', 'foo1'), ('another/name', 'foo2')],
+            )
+
+        # second element of each tuple must be a dictionary (build info)
+        with pytest.raises(DistutilsSetupError):
+            cmd.check_library_list(
+                [('name', {}), ('another', 'foo2')],
+            )
+
+        # those work
+        libs = [('name', {}), ('name', {'ok': 'good'})]
+        cmd.check_library_list(libs)
+
+    def test_get_source_files(self):
+        pkg_dir, dist = self.create_dist()
+        cmd = build_clib(dist)
+
+        # "in 'libraries' option 'sources' must be present and must be
+        # a list of source filenames
+        cmd.libraries = [('name', {})]
+        with pytest.raises(DistutilsSetupError):
+            cmd.get_source_files()
+
+        cmd.libraries = [('name', {'sources': 1})]
+        with pytest.raises(DistutilsSetupError):
+            cmd.get_source_files()
+
+        cmd.libraries = [('name', {'sources': ['a', 'b']})]
+        assert cmd.get_source_files() == ['a', 'b']
+
+        cmd.libraries = [('name', {'sources': ('a', 'b')})]
+        assert cmd.get_source_files() == ['a', 'b']
+
+        cmd.libraries = [
+            ('name', {'sources': ('a', 'b')}),
+            ('name2', {'sources': ['c', 'd']}),
+        ]
+        assert cmd.get_source_files() == ['a', 'b', 'c', 'd']
+
+    def test_build_libraries(self):
+        pkg_dir, dist = self.create_dist()
+        cmd = build_clib(dist)
+
+        class FakeCompiler:
+            def compile(*args, **kw):
+                pass
+
+            create_static_lib = compile
+
+        cmd.compiler = FakeCompiler()
+
+        # build_libraries is also doing a bit of typo checking
+        lib = [('name', {'sources': 'notvalid'})]
+        with pytest.raises(DistutilsSetupError):
+            cmd.build_libraries(lib)
+
+        lib = [('name', {'sources': list()})]
+        cmd.build_libraries(lib)
+
+        lib = [('name', {'sources': tuple()})]
+        cmd.build_libraries(lib)
+
+    def test_finalize_options(self):
+        pkg_dir, dist = self.create_dist()
+        cmd = build_clib(dist)
+
+        cmd.include_dirs = 'one-dir'
+        cmd.finalize_options()
+        assert cmd.include_dirs == ['one-dir']
+
+        cmd.include_dirs = None
+        cmd.finalize_options()
+        assert cmd.include_dirs == []
+
+        cmd.distribution.libraries = 'WONTWORK'
+        with pytest.raises(DistutilsSetupError):
+            cmd.finalize_options()
+
+    @pytest.mark.skipif('platform.system() == "Windows"')
+    def test_run(self):
+        pkg_dir, dist = self.create_dist()
+        cmd = build_clib(dist)
+
+        foo_c = os.path.join(pkg_dir, 'foo.c')
+        self.write_file(foo_c, 'int main(void) { return 1;}\n')
+        cmd.libraries = [('foo', {'sources': [foo_c]})]
+
+        build_temp = os.path.join(pkg_dir, 'build')
+        os.mkdir(build_temp)
+        cmd.build_temp = build_temp
+        cmd.build_clib = build_temp
+
+        # Before we run the command, we want to make sure
+        # all commands are present on the system.
+        ccmd = missing_compiler_executable()
+        if ccmd is not None:
+            self.skipTest(f'The {ccmd!r} command is not found')
+
+        # this should work
+        cmd.run()
+
+        # let's check the result
+        assert 'libfoo.a' in os.listdir(build_temp)
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/test_build_ext.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/test_build_ext.py
new file mode 100644
index 0000000000000000000000000000000000000000..dab0507f3d3ec104fb4acfe5b15f92661ff33a37
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/test_build_ext.py
@@ -0,0 +1,628 @@
+import contextlib
+import glob
+import importlib
+import os.path
+import platform
+import re
+import shutil
+import site
+import subprocess
+import sys
+import tempfile
+import textwrap
+import time
+from distutils import sysconfig
+from distutils.command.build_ext import build_ext
+from distutils.core import Distribution
+from distutils.errors import (
+    CompileError,
+    DistutilsPlatformError,
+    DistutilsSetupError,
+    UnknownFileError,
+)
+from distutils.extension import Extension
+from distutils.tests import missing_compiler_executable
+from distutils.tests.support import TempdirManager, copy_xxmodule_c, fixup_build_ext
+from io import StringIO
+
+import jaraco.path
+import path
+import pytest
+from test import support
+
+from .compat import py39 as import_helper
+
+
+@pytest.fixture()
+def user_site_dir(request):
+    self = request.instance
+    self.tmp_dir = self.mkdtemp()
+    self.tmp_path = path.Path(self.tmp_dir)
+    from distutils.command import build_ext
+
+    orig_user_base = site.USER_BASE
+
+    site.USER_BASE = self.mkdtemp()
+    build_ext.USER_BASE = site.USER_BASE
+
+    # bpo-30132: On Windows, a .pdb file may be created in the current
+    # working directory. Create a temporary working directory to cleanup
+    # everything at the end of the test.
+    with self.tmp_path:
+        yield
+
+    site.USER_BASE = orig_user_base
+    build_ext.USER_BASE = orig_user_base
+
+    if sys.platform == 'cygwin':
+        time.sleep(1)
+
+
+@contextlib.contextmanager
+def safe_extension_import(name, path):
+    with import_helper.CleanImport(name):
+        with extension_redirect(name, path) as new_path:
+            with import_helper.DirsOnSysPath(new_path):
+                yield
+
+
+@contextlib.contextmanager
+def extension_redirect(mod, path):
+    """
+    Tests will fail to tear down an extension module if it's been imported.
+
+    Before importing, copy the file to a temporary directory that won't
+    be cleaned up. Yield the new path.
+    """
+    if platform.system() != "Windows" and sys.platform != "cygwin":
+        yield path
+        return
+    with import_helper.DirsOnSysPath(path):
+        spec = importlib.util.find_spec(mod)
+    filename = os.path.basename(spec.origin)
+    trash_dir = tempfile.mkdtemp(prefix='deleteme')
+    dest = os.path.join(trash_dir, os.path.basename(filename))
+    shutil.copy(spec.origin, dest)
+    yield trash_dir
+    # TODO: can the file be scheduled for deletion?
+
+
+@pytest.mark.usefixtures('user_site_dir')
+class TestBuildExt(TempdirManager):
+    def build_ext(self, *args, **kwargs):
+        return build_ext(*args, **kwargs)
+
+    @pytest.mark.parametrize("copy_so", [False])
+    def test_build_ext(self, copy_so):
+        missing_compiler_executable()
+        copy_xxmodule_c(self.tmp_dir)
+        xx_c = os.path.join(self.tmp_dir, 'xxmodule.c')
+        xx_ext = Extension('xx', [xx_c])
+        if sys.platform != "win32":
+            if not copy_so:
+                xx_ext = Extension(
+                    'xx',
+                    [xx_c],
+                    library_dirs=['/usr/lib'],
+                    libraries=['z'],
+                    runtime_library_dirs=['/usr/lib'],
+                )
+            elif sys.platform == 'linux':
+                libz_so = {
+                    os.path.realpath(name) for name in glob.iglob('/usr/lib*/libz.so*')
+                }
+                libz_so = sorted(libz_so, key=lambda lib_path: len(lib_path))
+                shutil.copyfile(libz_so[-1], '/tmp/libxx_z.so')
+
+                xx_ext = Extension(
+                    'xx',
+                    [xx_c],
+                    library_dirs=['/tmp'],
+                    libraries=['xx_z'],
+                    runtime_library_dirs=['/tmp'],
+                )
+        dist = Distribution({'name': 'xx', 'ext_modules': [xx_ext]})
+        dist.package_dir = self.tmp_dir
+        cmd = self.build_ext(dist)
+        fixup_build_ext(cmd)
+        cmd.build_lib = self.tmp_dir
+        cmd.build_temp = self.tmp_dir
+
+        old_stdout = sys.stdout
+        if not support.verbose:
+            # silence compiler output
+            sys.stdout = StringIO()
+        try:
+            cmd.ensure_finalized()
+            cmd.run()
+        finally:
+            sys.stdout = old_stdout
+
+        with safe_extension_import('xx', self.tmp_dir):
+            self._test_xx(copy_so)
+
+        if sys.platform == 'linux' and copy_so:
+            os.unlink('/tmp/libxx_z.so')
+
+    @staticmethod
+    def _test_xx(copy_so):
+        import xx  # type: ignore[import-not-found] # Module generated for tests
+
+        for attr in ('error', 'foo', 'new', 'roj'):
+            assert hasattr(xx, attr)
+
+        assert xx.foo(2, 5) == 7
+        assert xx.foo(13, 15) == 28
+        assert xx.new().demo() is None
+        if support.HAVE_DOCSTRINGS:
+            doc = 'This is a template module just for instruction.'
+            assert xx.__doc__ == doc
+        assert isinstance(xx.Null(), xx.Null)
+        assert isinstance(xx.Str(), xx.Str)
+
+        if sys.platform == 'linux':
+            so_headers = subprocess.check_output(
+                ["readelf", "-d", xx.__file__], universal_newlines=True
+            )
+            import pprint
+
+            pprint.pprint(so_headers)
+            rpaths = [
+                rpath
+                for line in so_headers.split("\n")
+                if "RPATH" in line or "RUNPATH" in line
+                for rpath in line.split()[2][1:-1].split(":")
+            ]
+            if not copy_so:
+                pprint.pprint(rpaths)
+                # Linked against a library in /usr/lib{,64}
+                assert "/usr/lib" not in rpaths and "/usr/lib64" not in rpaths
+            else:
+                # Linked against a library in /tmp
+                assert "/tmp" in rpaths
+                # The import is the real test here
+
+    def test_solaris_enable_shared(self):
+        dist = Distribution({'name': 'xx'})
+        cmd = self.build_ext(dist)
+        old = sys.platform
+
+        sys.platform = 'sunos'  # fooling finalize_options
+        from distutils.sysconfig import _config_vars
+
+        old_var = _config_vars.get('Py_ENABLE_SHARED')
+        _config_vars['Py_ENABLE_SHARED'] = True
+        try:
+            cmd.ensure_finalized()
+        finally:
+            sys.platform = old
+            if old_var is None:
+                del _config_vars['Py_ENABLE_SHARED']
+            else:
+                _config_vars['Py_ENABLE_SHARED'] = old_var
+
+        # make sure we get some library dirs under solaris
+        assert len(cmd.library_dirs) > 0
+
+    def test_user_site(self):
+        import site
+
+        dist = Distribution({'name': 'xx'})
+        cmd = self.build_ext(dist)
+
+        # making sure the user option is there
+        options = [name for name, short, label in cmd.user_options]
+        assert 'user' in options
+
+        # setting a value
+        cmd.user = True
+
+        # setting user based lib and include
+        lib = os.path.join(site.USER_BASE, 'lib')
+        incl = os.path.join(site.USER_BASE, 'include')
+        os.mkdir(lib)
+        os.mkdir(incl)
+
+        # let's run finalize
+        cmd.ensure_finalized()
+
+        # see if include_dirs and library_dirs
+        # were set
+        assert lib in cmd.library_dirs
+        assert lib in cmd.rpath
+        assert incl in cmd.include_dirs
+
+    def test_optional_extension(self):
+        # this extension will fail, but let's ignore this failure
+        # with the optional argument.
+        modules = [Extension('foo', ['xxx'], optional=False)]
+        dist = Distribution({'name': 'xx', 'ext_modules': modules})
+        cmd = self.build_ext(dist)
+        cmd.ensure_finalized()
+        with pytest.raises((UnknownFileError, CompileError)):
+            cmd.run()  # should raise an error
+
+        modules = [Extension('foo', ['xxx'], optional=True)]
+        dist = Distribution({'name': 'xx', 'ext_modules': modules})
+        cmd = self.build_ext(dist)
+        cmd.ensure_finalized()
+        cmd.run()  # should pass
+
+    def test_finalize_options(self):
+        # Make sure Python's include directories (for Python.h, pyconfig.h,
+        # etc.) are in the include search path.
+        modules = [Extension('foo', ['xxx'], optional=False)]
+        dist = Distribution({'name': 'xx', 'ext_modules': modules})
+        cmd = self.build_ext(dist)
+        cmd.finalize_options()
+
+        py_include = sysconfig.get_python_inc()
+        for p in py_include.split(os.path.pathsep):
+            assert p in cmd.include_dirs
+
+        plat_py_include = sysconfig.get_python_inc(plat_specific=True)
+        for p in plat_py_include.split(os.path.pathsep):
+            assert p in cmd.include_dirs
+
+        # make sure cmd.libraries is turned into a list
+        # if it's a string
+        cmd = self.build_ext(dist)
+        cmd.libraries = 'my_lib, other_lib lastlib'
+        cmd.finalize_options()
+        assert cmd.libraries == ['my_lib', 'other_lib', 'lastlib']
+
+        # make sure cmd.library_dirs is turned into a list
+        # if it's a string
+        cmd = self.build_ext(dist)
+        cmd.library_dirs = f'my_lib_dir{os.pathsep}other_lib_dir'
+        cmd.finalize_options()
+        assert 'my_lib_dir' in cmd.library_dirs
+        assert 'other_lib_dir' in cmd.library_dirs
+
+        # make sure rpath is turned into a list
+        # if it's a string
+        cmd = self.build_ext(dist)
+        cmd.rpath = f'one{os.pathsep}two'
+        cmd.finalize_options()
+        assert cmd.rpath == ['one', 'two']
+
+        # make sure cmd.link_objects is turned into a list
+        # if it's a string
+        cmd = build_ext(dist)
+        cmd.link_objects = 'one two,three'
+        cmd.finalize_options()
+        assert cmd.link_objects == ['one', 'two', 'three']
+
+        # XXX more tests to perform for win32
+
+        # make sure define is turned into 2-tuples
+        # strings if they are ','-separated strings
+        cmd = self.build_ext(dist)
+        cmd.define = 'one,two'
+        cmd.finalize_options()
+        assert cmd.define == [('one', '1'), ('two', '1')]
+
+        # make sure undef is turned into a list of
+        # strings if they are ','-separated strings
+        cmd = self.build_ext(dist)
+        cmd.undef = 'one,two'
+        cmd.finalize_options()
+        assert cmd.undef == ['one', 'two']
+
+        # make sure swig_opts is turned into a list
+        cmd = self.build_ext(dist)
+        cmd.swig_opts = None
+        cmd.finalize_options()
+        assert cmd.swig_opts == []
+
+        cmd = self.build_ext(dist)
+        cmd.swig_opts = '1 2'
+        cmd.finalize_options()
+        assert cmd.swig_opts == ['1', '2']
+
+    def test_check_extensions_list(self):
+        dist = Distribution()
+        cmd = self.build_ext(dist)
+        cmd.finalize_options()
+
+        # 'extensions' option must be a list of Extension instances
+        with pytest.raises(DistutilsSetupError):
+            cmd.check_extensions_list('foo')
+
+        # each element of 'ext_modules' option must be an
+        # Extension instance or 2-tuple
+        exts = [('bar', 'foo', 'bar'), 'foo']
+        with pytest.raises(DistutilsSetupError):
+            cmd.check_extensions_list(exts)
+
+        # first element of each tuple in 'ext_modules'
+        # must be the extension name (a string) and match
+        # a python dotted-separated name
+        exts = [('foo-bar', '')]
+        with pytest.raises(DistutilsSetupError):
+            cmd.check_extensions_list(exts)
+
+        # second element of each tuple in 'ext_modules'
+        # must be a dictionary (build info)
+        exts = [('foo.bar', '')]
+        with pytest.raises(DistutilsSetupError):
+            cmd.check_extensions_list(exts)
+
+        # ok this one should pass
+        exts = [('foo.bar', {'sources': [''], 'libraries': 'foo', 'some': 'bar'})]
+        cmd.check_extensions_list(exts)
+        ext = exts[0]
+        assert isinstance(ext, Extension)
+
+        # check_extensions_list adds in ext the values passed
+        # when they are in ('include_dirs', 'library_dirs', 'libraries'
+        # 'extra_objects', 'extra_compile_args', 'extra_link_args')
+        assert ext.libraries == 'foo'
+        assert not hasattr(ext, 'some')
+
+        # 'macros' element of build info dict must be 1- or 2-tuple
+        exts = [
+            (
+                'foo.bar',
+                {
+                    'sources': [''],
+                    'libraries': 'foo',
+                    'some': 'bar',
+                    'macros': [('1', '2', '3'), 'foo'],
+                },
+            )
+        ]
+        with pytest.raises(DistutilsSetupError):
+            cmd.check_extensions_list(exts)
+
+        exts[0][1]['macros'] = [('1', '2'), ('3',)]
+        cmd.check_extensions_list(exts)
+        assert exts[0].undef_macros == ['3']
+        assert exts[0].define_macros == [('1', '2')]
+
+    def test_get_source_files(self):
+        modules = [Extension('foo', ['xxx'], optional=False)]
+        dist = Distribution({'name': 'xx', 'ext_modules': modules})
+        cmd = self.build_ext(dist)
+        cmd.ensure_finalized()
+        assert cmd.get_source_files() == ['xxx']
+
+    def test_unicode_module_names(self):
+        modules = [
+            Extension('foo', ['aaa'], optional=False),
+            Extension('föö', ['uuu'], optional=False),
+        ]
+        dist = Distribution({'name': 'xx', 'ext_modules': modules})
+        cmd = self.build_ext(dist)
+        cmd.ensure_finalized()
+        assert re.search(r'foo(_d)?\..*', cmd.get_ext_filename(modules[0].name))
+        assert re.search(r'föö(_d)?\..*', cmd.get_ext_filename(modules[1].name))
+        assert cmd.get_export_symbols(modules[0]) == ['PyInit_foo']
+        assert cmd.get_export_symbols(modules[1]) == ['PyInitU_f_1gaa']
+
+    def test_export_symbols__init__(self):
+        # https://github.com/python/cpython/issues/80074
+        # https://github.com/pypa/setuptools/issues/4826
+        modules = [
+            Extension('foo.__init__', ['aaa']),
+            Extension('föö.__init__', ['uuu']),
+        ]
+        dist = Distribution({'name': 'xx', 'ext_modules': modules})
+        cmd = self.build_ext(dist)
+        cmd.ensure_finalized()
+        assert cmd.get_export_symbols(modules[0]) == ['PyInit_foo']
+        assert cmd.get_export_symbols(modules[1]) == ['PyInitU_f_1gaa']
+
+    def test_compiler_option(self):
+        # cmd.compiler is an option and
+        # should not be overridden by a compiler instance
+        # when the command is run
+        dist = Distribution()
+        cmd = self.build_ext(dist)
+        cmd.compiler = 'unix'
+        cmd.ensure_finalized()
+        cmd.run()
+        assert cmd.compiler == 'unix'
+
+    def test_get_outputs(self):
+        missing_compiler_executable()
+        tmp_dir = self.mkdtemp()
+        c_file = os.path.join(tmp_dir, 'foo.c')
+        self.write_file(c_file, 'void PyInit_foo(void) {}\n')
+        ext = Extension('foo', [c_file], optional=False)
+        dist = Distribution({'name': 'xx', 'ext_modules': [ext]})
+        cmd = self.build_ext(dist)
+        fixup_build_ext(cmd)
+        cmd.ensure_finalized()
+        assert len(cmd.get_outputs()) == 1
+
+        cmd.build_lib = os.path.join(self.tmp_dir, 'build')
+        cmd.build_temp = os.path.join(self.tmp_dir, 'tempt')
+
+        # issue #5977 : distutils build_ext.get_outputs
+        # returns wrong result with --inplace
+        other_tmp_dir = os.path.realpath(self.mkdtemp())
+        old_wd = os.getcwd()
+        os.chdir(other_tmp_dir)
+        try:
+            cmd.inplace = True
+            cmd.run()
+            so_file = cmd.get_outputs()[0]
+        finally:
+            os.chdir(old_wd)
+        assert os.path.exists(so_file)
+        ext_suffix = sysconfig.get_config_var('EXT_SUFFIX')
+        assert so_file.endswith(ext_suffix)
+        so_dir = os.path.dirname(so_file)
+        assert so_dir == other_tmp_dir
+
+        cmd.inplace = False
+        cmd.compiler = None
+        cmd.run()
+        so_file = cmd.get_outputs()[0]
+        assert os.path.exists(so_file)
+        assert so_file.endswith(ext_suffix)
+        so_dir = os.path.dirname(so_file)
+        assert so_dir == cmd.build_lib
+
+        # inplace = False, cmd.package = 'bar'
+        build_py = cmd.get_finalized_command('build_py')
+        build_py.package_dir = {'': 'bar'}
+        path = cmd.get_ext_fullpath('foo')
+        # checking that the last directory is the build_dir
+        path = os.path.split(path)[0]
+        assert path == cmd.build_lib
+
+        # inplace = True, cmd.package = 'bar'
+        cmd.inplace = True
+        other_tmp_dir = os.path.realpath(self.mkdtemp())
+        old_wd = os.getcwd()
+        os.chdir(other_tmp_dir)
+        try:
+            path = cmd.get_ext_fullpath('foo')
+        finally:
+            os.chdir(old_wd)
+        # checking that the last directory is bar
+        path = os.path.split(path)[0]
+        lastdir = os.path.split(path)[-1]
+        assert lastdir == 'bar'
+
+    def test_ext_fullpath(self):
+        ext = sysconfig.get_config_var('EXT_SUFFIX')
+        # building lxml.etree inplace
+        # etree_c = os.path.join(self.tmp_dir, 'lxml.etree.c')
+        # etree_ext = Extension('lxml.etree', [etree_c])
+        # dist = Distribution({'name': 'lxml', 'ext_modules': [etree_ext]})
+        dist = Distribution()
+        cmd = self.build_ext(dist)
+        cmd.inplace = True
+        cmd.distribution.package_dir = {'': 'src'}
+        cmd.distribution.packages = ['lxml', 'lxml.html']
+        curdir = os.getcwd()
+        wanted = os.path.join(curdir, 'src', 'lxml', 'etree' + ext)
+        path = cmd.get_ext_fullpath('lxml.etree')
+        assert wanted == path
+
+        # building lxml.etree not inplace
+        cmd.inplace = False
+        cmd.build_lib = os.path.join(curdir, 'tmpdir')
+        wanted = os.path.join(curdir, 'tmpdir', 'lxml', 'etree' + ext)
+        path = cmd.get_ext_fullpath('lxml.etree')
+        assert wanted == path
+
+        # building twisted.runner.portmap not inplace
+        build_py = cmd.get_finalized_command('build_py')
+        build_py.package_dir = {}
+        cmd.distribution.packages = ['twisted', 'twisted.runner.portmap']
+        path = cmd.get_ext_fullpath('twisted.runner.portmap')
+        wanted = os.path.join(curdir, 'tmpdir', 'twisted', 'runner', 'portmap' + ext)
+        assert wanted == path
+
+        # building twisted.runner.portmap inplace
+        cmd.inplace = True
+        path = cmd.get_ext_fullpath('twisted.runner.portmap')
+        wanted = os.path.join(curdir, 'twisted', 'runner', 'portmap' + ext)
+        assert wanted == path
+
+    @pytest.mark.skipif('platform.system() != "Darwin"')
+    @pytest.mark.usefixtures('save_env')
+    def test_deployment_target_default(self):
+        # Issue 9516: Test that, in the absence of the environment variable,
+        # an extension module is compiled with the same deployment target as
+        #  the interpreter.
+        self._try_compile_deployment_target('==', None)
+
+    @pytest.mark.skipif('platform.system() != "Darwin"')
+    @pytest.mark.usefixtures('save_env')
+    def test_deployment_target_too_low(self):
+        # Issue 9516: Test that an extension module is not allowed to be
+        # compiled with a deployment target less than that of the interpreter.
+        with pytest.raises(DistutilsPlatformError):
+            self._try_compile_deployment_target('>', '10.1')
+
+    @pytest.mark.skipif('platform.system() != "Darwin"')
+    @pytest.mark.usefixtures('save_env')
+    def test_deployment_target_higher_ok(self):  # pragma: no cover
+        # Issue 9516: Test that an extension module can be compiled with a
+        # deployment target higher than that of the interpreter: the ext
+        # module may depend on some newer OS feature.
+        deptarget = sysconfig.get_config_var('MACOSX_DEPLOYMENT_TARGET')
+        if deptarget:
+            # increment the minor version number (i.e. 10.6 -> 10.7)
+            deptarget = [int(x) for x in deptarget.split('.')]
+            deptarget[-1] += 1
+            deptarget = '.'.join(str(i) for i in deptarget)
+            self._try_compile_deployment_target('<', deptarget)
+
+    def _try_compile_deployment_target(self, operator, target):  # pragma: no cover
+        if target is None:
+            if os.environ.get('MACOSX_DEPLOYMENT_TARGET'):
+                del os.environ['MACOSX_DEPLOYMENT_TARGET']
+        else:
+            os.environ['MACOSX_DEPLOYMENT_TARGET'] = target
+
+        jaraco.path.build(
+            {
+                'deptargetmodule.c': textwrap.dedent(f"""\
+                    #include <AvailabilityMacros.h>
+
+                    int dummy;
+
+                    #if TARGET {operator} MAC_OS_X_VERSION_MIN_REQUIRED
+                    #else
+                    #error "Unexpected target"
+                    #endif
+
+                    """),
+            },
+            self.tmp_path,
+        )
+
+        # get the deployment target that the interpreter was built with
+        target = sysconfig.get_config_var('MACOSX_DEPLOYMENT_TARGET')
+        target = tuple(map(int, target.split('.')[0:2]))
+        # format the target value as defined in the Apple
+        # Availability Macros.  We can't use the macro names since
+        # at least one value we test with will not exist yet.
+        if target[:2] < (10, 10):
+            # for 10.1 through 10.9.x -> "10n0"
+            tmpl = '{:02}{:01}0'
+        else:
+            # for 10.10 and beyond -> "10nn00"
+            if len(target) >= 2:
+                tmpl = '{:02}{:02}00'
+            else:
+                # 11 and later can have no minor version (11 instead of 11.0)
+                tmpl = '{:02}0000'
+        target = tmpl.format(*target)
+        deptarget_ext = Extension(
+            'deptarget',
+            [self.tmp_path / 'deptargetmodule.c'],
+            extra_compile_args=[f'-DTARGET={target}'],
+        )
+        dist = Distribution({'name': 'deptarget', 'ext_modules': [deptarget_ext]})
+        dist.package_dir = self.tmp_dir
+        cmd = self.build_ext(dist)
+        cmd.build_lib = self.tmp_dir
+        cmd.build_temp = self.tmp_dir
+
+        try:
+            old_stdout = sys.stdout
+            if not support.verbose:
+                # silence compiler output
+                sys.stdout = StringIO()
+            try:
+                cmd.ensure_finalized()
+                cmd.run()
+            finally:
+                sys.stdout = old_stdout
+
+        except CompileError:
+            self.fail("Wrong deployment target during compilation")
+
+
+class TestParallelBuildExt(TestBuildExt):
+    def build_ext(self, *args, **kwargs):
+        build_ext = super().build_ext(*args, **kwargs)
+        build_ext.parallel = True
+        return build_ext
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/test_build_py.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/test_build_py.py
new file mode 100644
index 0000000000000000000000000000000000000000..b316ed43a11836210caeb7177bd8890a1f61d1bb
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/test_build_py.py
@@ -0,0 +1,196 @@
+"""Tests for distutils.command.build_py."""
+
+import os
+import sys
+from distutils.command.build_py import build_py
+from distutils.core import Distribution
+from distutils.errors import DistutilsFileError
+from distutils.tests import support
+
+import jaraco.path
+import pytest
+
+
+@support.combine_markers
+class TestBuildPy(support.TempdirManager):
+    def test_package_data(self):
+        sources = self.mkdtemp()
+        jaraco.path.build(
+            {
+                '__init__.py': "# Pretend this is a package.",
+                'README.txt': 'Info about this package',
+            },
+            sources,
+        )
+
+        destination = self.mkdtemp()
+
+        dist = Distribution({"packages": ["pkg"], "package_dir": {"pkg": sources}})
+        # script_name need not exist, it just need to be initialized
+        dist.script_name = os.path.join(sources, "setup.py")
+        dist.command_obj["build"] = support.DummyCommand(
+            force=False, build_lib=destination
+        )
+        dist.packages = ["pkg"]
+        dist.package_data = {"pkg": ["README.txt"]}
+        dist.package_dir = {"pkg": sources}
+
+        cmd = build_py(dist)
+        cmd.compile = True
+        cmd.ensure_finalized()
+        assert cmd.package_data == dist.package_data
+
+        cmd.run()
+
+        # This makes sure the list of outputs includes byte-compiled
+        # files for Python modules but not for package data files
+        # (there shouldn't *be* byte-code files for those!).
+        assert len(cmd.get_outputs()) == 3
+        pkgdest = os.path.join(destination, "pkg")
+        files = os.listdir(pkgdest)
+        pycache_dir = os.path.join(pkgdest, "__pycache__")
+        assert "__init__.py" in files
+        assert "README.txt" in files
+        if sys.dont_write_bytecode:
+            assert not os.path.exists(pycache_dir)
+        else:
+            pyc_files = os.listdir(pycache_dir)
+            assert f"__init__.{sys.implementation.cache_tag}.pyc" in pyc_files
+
+    def test_empty_package_dir(self):
+        # See bugs #1668596/#1720897
+        sources = self.mkdtemp()
+        jaraco.path.build({'__init__.py': '', 'doc': {'testfile': ''}}, sources)
+
+        os.chdir(sources)
+        dist = Distribution({
+            "packages": ["pkg"],
+            "package_dir": {"pkg": ""},
+            "package_data": {"pkg": ["doc/*"]},
+        })
+        # script_name need not exist, it just need to be initialized
+        dist.script_name = os.path.join(sources, "setup.py")
+        dist.script_args = ["build"]
+        dist.parse_command_line()
+
+        try:
+            dist.run_commands()
+        except DistutilsFileError:
+            self.fail("failed package_data test when package_dir is ''")
+
+    @pytest.mark.skipif('sys.dont_write_bytecode')
+    def test_byte_compile(self):
+        project_dir, dist = self.create_dist(py_modules=['boiledeggs'])
+        os.chdir(project_dir)
+        self.write_file('boiledeggs.py', 'import antigravity')
+        cmd = build_py(dist)
+        cmd.compile = True
+        cmd.build_lib = 'here'
+        cmd.finalize_options()
+        cmd.run()
+
+        found = os.listdir(cmd.build_lib)
+        assert sorted(found) == ['__pycache__', 'boiledeggs.py']
+        found = os.listdir(os.path.join(cmd.build_lib, '__pycache__'))
+        assert found == [f'boiledeggs.{sys.implementation.cache_tag}.pyc']
+
+    @pytest.mark.skipif('sys.dont_write_bytecode')
+    def test_byte_compile_optimized(self):
+        project_dir, dist = self.create_dist(py_modules=['boiledeggs'])
+        os.chdir(project_dir)
+        self.write_file('boiledeggs.py', 'import antigravity')
+        cmd = build_py(dist)
+        cmd.compile = False
+        cmd.optimize = 1
+        cmd.build_lib = 'here'
+        cmd.finalize_options()
+        cmd.run()
+
+        found = os.listdir(cmd.build_lib)
+        assert sorted(found) == ['__pycache__', 'boiledeggs.py']
+        found = os.listdir(os.path.join(cmd.build_lib, '__pycache__'))
+        expect = f'boiledeggs.{sys.implementation.cache_tag}.opt-1.pyc'
+        assert sorted(found) == [expect]
+
+    def test_dir_in_package_data(self):
+        """
+        A directory in package_data should not be added to the filelist.
+        """
+        # See bug 19286
+        sources = self.mkdtemp()
+        jaraco.path.build(
+            {
+                'pkg': {
+                    '__init__.py': '',
+                    'doc': {
+                        'testfile': '',
+                        # create a directory that could be incorrectly detected as a file
+                        'otherdir': {},
+                    },
+                }
+            },
+            sources,
+        )
+
+        os.chdir(sources)
+        dist = Distribution({"packages": ["pkg"], "package_data": {"pkg": ["doc/*"]}})
+        # script_name need not exist, it just need to be initialized
+        dist.script_name = os.path.join(sources, "setup.py")
+        dist.script_args = ["build"]
+        dist.parse_command_line()
+
+        try:
+            dist.run_commands()
+        except DistutilsFileError:
+            self.fail("failed package_data when data dir includes a dir")
+
+    def test_dont_write_bytecode(self, caplog):
+        # makes sure byte_compile is not used
+        dist = self.create_dist()[1]
+        cmd = build_py(dist)
+        cmd.compile = True
+        cmd.optimize = 1
+
+        old_dont_write_bytecode = sys.dont_write_bytecode
+        sys.dont_write_bytecode = True
+        try:
+            cmd.byte_compile([])
+        finally:
+            sys.dont_write_bytecode = old_dont_write_bytecode
+
+        assert 'byte-compiling is disabled' in caplog.records[0].message
+
+    def test_namespace_package_does_not_warn(self, caplog):
+        """
+        Originally distutils implementation did not account for PEP 420
+        and included warns for package directories that did not contain
+        ``__init__.py`` files.
+        After the acceptance of PEP 420, these warnings don't make more sense
+        so we want to ensure there are not displayed to not confuse the users.
+        """
+        # Create a fake project structure with a package namespace:
+        tmp = self.mkdtemp()
+        jaraco.path.build({'ns': {'pkg': {'module.py': ''}}}, tmp)
+        os.chdir(tmp)
+
+        # Configure the package:
+        attrs = {
+            "name": "ns.pkg",
+            "packages": ["ns", "ns.pkg"],
+            "script_name": "setup.py",
+        }
+        dist = Distribution(attrs)
+
+        # Run code paths that would trigger the trap:
+        cmd = dist.get_command_obj("build_py")
+        cmd.finalize_options()
+        modules = cmd.find_all_modules()
+        assert len(modules) == 1
+        module_path = modules[0][-1]
+        assert module_path.replace(os.sep, "/") == "ns/pkg/module.py"
+
+        cmd.run()
+
+        assert not any(
+            "package init file" in msg and "not found" in msg for msg in caplog.messages
+        )
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/test_build_scripts.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/test_build_scripts.py
new file mode 100644
index 0000000000000000000000000000000000000000..3582f691ef578a419555c6ffbba6a619310517a6
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/test_build_scripts.py
@@ -0,0 +1,96 @@
+"""Tests for distutils.command.build_scripts."""
+
+import os
+import textwrap
+from distutils import sysconfig
+from distutils.command.build_scripts import build_scripts
+from distutils.core import Distribution
+from distutils.tests import support
+
+import jaraco.path
+
+
+class TestBuildScripts(support.TempdirManager):
+    def test_default_settings(self):
+        cmd = self.get_build_scripts_cmd("/foo/bar", [])
+        assert not cmd.force
+        assert cmd.build_dir is None
+
+        cmd.finalize_options()
+
+        assert cmd.force
+        assert cmd.build_dir == "/foo/bar"
+
+    def test_build(self):
+        source = self.mkdtemp()
+        target = self.mkdtemp()
+        expected = self.write_sample_scripts(source)
+
+        cmd = self.get_build_scripts_cmd(
+            target, [os.path.join(source, fn) for fn in expected]
+        )
+        cmd.finalize_options()
+        cmd.run()
+
+        built = os.listdir(target)
+        for name in expected:
+            assert name in built
+
+    def get_build_scripts_cmd(self, target, scripts):
+        import sys
+
+        dist = Distribution()
+        dist.scripts = scripts
+        dist.command_obj["build"] = support.DummyCommand(
+            build_scripts=target, force=True, executable=sys.executable
+        )
+        return build_scripts(dist)
+
+    @staticmethod
+    def write_sample_scripts(dir):
+        spec = {
+            'script1.py': textwrap.dedent("""
+                #! /usr/bin/env python2.3
+                # bogus script w/ Python sh-bang
+                pass
+                """).lstrip(),
+            'script2.py': textwrap.dedent("""
+                #!/usr/bin/python
+                # bogus script w/ Python sh-bang
+                pass
+                """).lstrip(),
+            'shell.sh': textwrap.dedent("""
+                #!/bin/sh
+                # bogus shell script w/ sh-bang
+                exit 0
+                """).lstrip(),
+        }
+        jaraco.path.build(spec, dir)
+        return list(spec)
+
+    def test_version_int(self):
+        source = self.mkdtemp()
+        target = self.mkdtemp()
+        expected = self.write_sample_scripts(source)
+
+        cmd = self.get_build_scripts_cmd(
+            target, [os.path.join(source, fn) for fn in expected]
+        )
+        cmd.finalize_options()
+
+        # https://bugs.python.org/issue4524
+        #
+        # On linux-g++-32 with command line `./configure --enable-ipv6
+        # --with-suffix=3`, python is compiled okay but the build scripts
+        # failed when writing the name of the executable
+        old = sysconfig.get_config_vars().get('VERSION')
+        sysconfig._config_vars['VERSION'] = 4
+        try:
+            cmd.run()
+        finally:
+            if old is not None:
+                sysconfig._config_vars['VERSION'] = old
+
+        built = os.listdir(target)
+        for name in expected:
+            assert name in built
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/test_check.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/test_check.py
new file mode 100644
index 0000000000000000000000000000000000000000..b672b1f972b46f399eb5b2ef263da2548d52ef89
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/test_check.py
@@ -0,0 +1,194 @@
+"""Tests for distutils.command.check."""
+
+import os
+import textwrap
+from distutils.command.check import check
+from distutils.errors import DistutilsSetupError
+from distutils.tests import support
+
+import pytest
+
+try:
+    import pygments
+except ImportError:
+    pygments = None
+
+
+HERE = os.path.dirname(__file__)
+
+
+@support.combine_markers
+class TestCheck(support.TempdirManager):
+    def _run(self, metadata=None, cwd=None, **options):
+        if metadata is None:
+            metadata = {}
+        if cwd is not None:
+            old_dir = os.getcwd()
+            os.chdir(cwd)
+        pkg_info, dist = self.create_dist(**metadata)
+        cmd = check(dist)
+        cmd.initialize_options()
+        for name, value in options.items():
+            setattr(cmd, name, value)
+        cmd.ensure_finalized()
+        cmd.run()
+        if cwd is not None:
+            os.chdir(old_dir)
+        return cmd
+
+    def test_check_metadata(self):
+        # let's run the command with no metadata at all
+        # by default, check is checking the metadata
+        # should have some warnings
+        cmd = self._run()
+        assert cmd._warnings == 1
+
+        # now let's add the required fields
+        # and run it again, to make sure we don't get
+        # any warning anymore
+        metadata = {
+            'url': 'xxx',
+            'author': 'xxx',
+            'author_email': 'xxx',
+            'name': 'xxx',
+            'version': 'xxx',
+        }
+        cmd = self._run(metadata)
+        assert cmd._warnings == 0
+
+        # now with the strict mode, we should
+        # get an error if there are missing metadata
+        with pytest.raises(DistutilsSetupError):
+            self._run({}, **{'strict': 1})
+
+        # and of course, no error when all metadata are present
+        cmd = self._run(metadata, strict=True)
+        assert cmd._warnings == 0
+
+        # now a test with non-ASCII characters
+        metadata = {
+            'url': 'xxx',
+            'author': '\u00c9ric',
+            'author_email': 'xxx',
+            'name': 'xxx',
+            'version': 'xxx',
+            'description': 'Something about esszet \u00df',
+            'long_description': 'More things about esszet \u00df',
+        }
+        cmd = self._run(metadata)
+        assert cmd._warnings == 0
+
+    def test_check_author_maintainer(self):
+        for kind in ("author", "maintainer"):
+            # ensure no warning when author_email or maintainer_email is given
+            # (the spec allows these fields to take the form "Name <email>")
+            metadata = {
+                'url': 'xxx',
+                kind + '_email': 'Name <name@email.com>',
+                'name': 'xxx',
+                'version': 'xxx',
+            }
+            cmd = self._run(metadata)
+            assert cmd._warnings == 0
+
+            # the check should not warn if only email is given
+            metadata[kind + '_email'] = 'name@email.com'
+            cmd = self._run(metadata)
+            assert cmd._warnings == 0
+
+            # the check should not warn if only the name is given
+            metadata[kind] = "Name"
+            del metadata[kind + '_email']
+            cmd = self._run(metadata)
+            assert cmd._warnings == 0
+
+    def test_check_document(self):
+        pytest.importorskip('docutils')
+        pkg_info, dist = self.create_dist()
+        cmd = check(dist)
+
+        # let's see if it detects broken rest
+        broken_rest = 'title\n===\n\ntest'
+        msgs = cmd._check_rst_data(broken_rest)
+        assert len(msgs) == 1
+
+        # and non-broken rest
+        rest = 'title\n=====\n\ntest'
+        msgs = cmd._check_rst_data(rest)
+        assert len(msgs) == 0
+
+    def test_check_restructuredtext(self):
+        pytest.importorskip('docutils')
+        # let's see if it detects broken rest in long_description
+        broken_rest = 'title\n===\n\ntest'
+        pkg_info, dist = self.create_dist(long_description=broken_rest)
+        cmd = check(dist)
+        cmd.check_restructuredtext()
+        assert cmd._warnings == 1
+
+        # let's see if we have an error with strict=True
+        metadata = {
+            'url': 'xxx',
+            'author': 'xxx',
+            'author_email': 'xxx',
+            'name': 'xxx',
+            'version': 'xxx',
+            'long_description': broken_rest,
+        }
+        with pytest.raises(DistutilsSetupError):
+            self._run(metadata, **{'strict': 1, 'restructuredtext': 1})
+
+        # and non-broken rest, including a non-ASCII character to test #12114
+        metadata['long_description'] = 'title\n=====\n\ntest \u00df'
+        cmd = self._run(metadata, strict=True, restructuredtext=True)
+        assert cmd._warnings == 0
+
+        # check that includes work to test #31292
+        metadata['long_description'] = 'title\n=====\n\n.. include:: includetest.rst'
+        cmd = self._run(metadata, cwd=HERE, strict=True, restructuredtext=True)
+        assert cmd._warnings == 0
+
+    def test_check_restructuredtext_with_syntax_highlight(self):
+        pytest.importorskip('docutils')
+        # Don't fail if there is a `code` or `code-block` directive
+
+        example_rst_docs = [
+            textwrap.dedent(
+                """\
+            Here's some code:
+
+            .. code:: python
+
+                def foo():
+                    pass
+            """
+            ),
+            textwrap.dedent(
+                """\
+            Here's some code:
+
+            .. code-block:: python
+
+                def foo():
+                    pass
+            """
+            ),
+        ]
+
+        for rest_with_code in example_rst_docs:
+            pkg_info, dist = self.create_dist(long_description=rest_with_code)
+            cmd = check(dist)
+            cmd.check_restructuredtext()
+            msgs = cmd._check_rst_data(rest_with_code)
+            if pygments is not None:
+                assert len(msgs) == 0
+            else:
+                assert len(msgs) == 1
+                assert (
+                    str(msgs[0][1])
+                    == 'Cannot analyze code. Pygments package not found.'
+                )
+
+    def test_check_all(self):
+        with pytest.raises(DistutilsSetupError):
+            self._run({}, **{'strict': 1, 'restructuredtext': 1})
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/test_clean.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/test_clean.py
new file mode 100644
index 0000000000000000000000000000000000000000..cc78f30f34b323845b977b9147c2153390774bd3
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/test_clean.py
@@ -0,0 +1,45 @@
+"""Tests for distutils.command.clean."""
+
+import os
+from distutils.command.clean import clean
+from distutils.tests import support
+
+
+class TestClean(support.TempdirManager):
+    def test_simple_run(self):
+        pkg_dir, dist = self.create_dist()
+        cmd = clean(dist)
+
+        # let's add some elements clean should remove
+        dirs = [
+            (d, os.path.join(pkg_dir, d))
+            for d in (
+                'build_temp',
+                'build_lib',
+                'bdist_base',
+                'build_scripts',
+                'build_base',
+            )
+        ]
+
+        for name, path in dirs:
+            os.mkdir(path)
+            setattr(cmd, name, path)
+            if name == 'build_base':
+                continue
+            for f in ('one', 'two', 'three'):
+                self.write_file(os.path.join(path, f))
+
+        # let's run the command
+        cmd.all = 1
+        cmd.ensure_finalized()
+        cmd.run()
+
+        # make sure the files where removed
+        for _name, path in dirs:
+            assert not os.path.exists(path), f'{path} was not removed'
+
+        # let's run the command again (should spit warnings but succeed)
+        cmd.all = 1
+        cmd.ensure_finalized()
+        cmd.run()
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/test_cmd.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/test_cmd.py
new file mode 100644
index 0000000000000000000000000000000000000000..76e8f5989b3b102a32239436ff3b65f26e09e029
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/test_cmd.py
@@ -0,0 +1,107 @@
+"""Tests for distutils.cmd."""
+
+import os
+from distutils import debug
+from distutils.cmd import Command
+from distutils.dist import Distribution
+from distutils.errors import DistutilsOptionError
+
+import pytest
+
+
+class MyCmd(Command):
+    def initialize_options(self):
+        pass
+
+
+@pytest.fixture
+def cmd(request):
+    return MyCmd(Distribution())
+
+
+class TestCommand:
+    def test_ensure_string_list(self, cmd):
+        cmd.not_string_list = ['one', 2, 'three']
+        cmd.yes_string_list = ['one', 'two', 'three']
+        cmd.not_string_list2 = object()
+        cmd.yes_string_list2 = 'ok'
+        cmd.ensure_string_list('yes_string_list')
+        cmd.ensure_string_list('yes_string_list2')
+
+        with pytest.raises(DistutilsOptionError):
+            cmd.ensure_string_list('not_string_list')
+
+        with pytest.raises(DistutilsOptionError):
+            cmd.ensure_string_list('not_string_list2')
+
+        cmd.option1 = 'ok,dok'
+        cmd.ensure_string_list('option1')
+        assert cmd.option1 == ['ok', 'dok']
+
+        cmd.option2 = ['xxx', 'www']
+        cmd.ensure_string_list('option2')
+
+        cmd.option3 = ['ok', 2]
+        with pytest.raises(DistutilsOptionError):
+            cmd.ensure_string_list('option3')
+
+    def test_make_file(self, cmd):
+        # making sure it raises when infiles is not a string or a list/tuple
+        with pytest.raises(TypeError):
+            cmd.make_file(infiles=True, outfile='', func='func', args=())
+
+        # making sure execute gets called properly
+        def _execute(func, args, exec_msg, level):
+            assert exec_msg == 'generating out from in'
+
+        cmd.force = True
+        cmd.execute = _execute
+        cmd.make_file(infiles='in', outfile='out', func='func', args=())
+
+    def test_dump_options(self, cmd):
+        msgs = []
+
+        def _announce(msg, level):
+            msgs.append(msg)
+
+        cmd.announce = _announce
+        cmd.option1 = 1
+        cmd.option2 = 1
+        cmd.user_options = [('option1', '', ''), ('option2', '', '')]
+        cmd.dump_options()
+
+        wanted = ["command options for 'MyCmd':", '  option1 = 1', '  option2 = 1']
+        assert msgs == wanted
+
+    def test_ensure_string(self, cmd):
+        cmd.option1 = 'ok'
+        cmd.ensure_string('option1')
+
+        cmd.option2 = None
+        cmd.ensure_string('option2', 'xxx')
+        assert hasattr(cmd, 'option2')
+
+        cmd.option3 = 1
+        with pytest.raises(DistutilsOptionError):
+            cmd.ensure_string('option3')
+
+    def test_ensure_filename(self, cmd):
+        cmd.option1 = __file__
+        cmd.ensure_filename('option1')
+        cmd.option2 = 'xxx'
+        with pytest.raises(DistutilsOptionError):
+            cmd.ensure_filename('option2')
+
+    def test_ensure_dirname(self, cmd):
+        cmd.option1 = os.path.dirname(__file__) or os.curdir
+        cmd.ensure_dirname('option1')
+        cmd.option2 = 'xxx'
+        with pytest.raises(DistutilsOptionError):
+            cmd.ensure_dirname('option2')
+
+    def test_debug_print(self, cmd, capsys, monkeypatch):
+        cmd.debug_print('xxx')
+        assert capsys.readouterr().out == ''
+        monkeypatch.setattr(debug, 'DEBUG', True)
+        cmd.debug_print('xxx')
+        assert capsys.readouterr().out == 'xxx\n'
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/test_config_cmd.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/test_config_cmd.py
new file mode 100644
index 0000000000000000000000000000000000000000..ebee2ef93f0bc9d422984e2e4872665b1be3a1de
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/test_config_cmd.py
@@ -0,0 +1,87 @@
+"""Tests for distutils.command.config."""
+
+import os
+import sys
+from distutils._log import log
+from distutils.command.config import config, dump_file
+from distutils.tests import missing_compiler_executable, support
+
+import more_itertools
+import path
+import pytest
+
+
+@pytest.fixture(autouse=True)
+def info_log(request, monkeypatch):
+    self = request.instance
+    self._logs = []
+    monkeypatch.setattr(log, 'info', self._info)
+
+
+@support.combine_markers
+class TestConfig(support.TempdirManager):
+    def _info(self, msg, *args):
+        for line in msg.splitlines():
+            self._logs.append(line)
+
+    def test_dump_file(self):
+        this_file = path.Path(__file__).with_suffix('.py')
+        with this_file.open(encoding='utf-8') as f:
+            numlines = more_itertools.ilen(f)
+
+        dump_file(this_file, 'I am the header')
+        assert len(self._logs) == numlines + 1
+
+    @pytest.mark.skipif('platform.system() == "Windows"')
+    def test_search_cpp(self):
+        cmd = missing_compiler_executable(['preprocessor'])
+        if cmd is not None:
+            self.skipTest(f'The {cmd!r} command is not found')
+        pkg_dir, dist = self.create_dist()
+        cmd = config(dist)
+        cmd._check_compiler()
+        compiler = cmd.compiler
+        if sys.platform[:3] == "aix" and "xlc" in compiler.preprocessor[0].lower():
+            self.skipTest(
+                'xlc: The -E option overrides the -P, -o, and -qsyntaxonly options'
+            )
+
+        # simple pattern searches
+        match = cmd.search_cpp(pattern='xxx', body='/* xxx */')
+        assert match == 0
+
+        match = cmd.search_cpp(pattern='_configtest', body='/* xxx */')
+        assert match == 1
+
+    def test_finalize_options(self):
+        # finalize_options does a bit of transformation
+        # on options
+        pkg_dir, dist = self.create_dist()
+        cmd = config(dist)
+        cmd.include_dirs = f'one{os.pathsep}two'
+        cmd.libraries = 'one'
+        cmd.library_dirs = f'three{os.pathsep}four'
+        cmd.ensure_finalized()
+
+        assert cmd.include_dirs == ['one', 'two']
+        assert cmd.libraries == ['one']
+        assert cmd.library_dirs == ['three', 'four']
+
+    def test_clean(self):
+        # _clean removes files
+        tmp_dir = self.mkdtemp()
+        f1 = os.path.join(tmp_dir, 'one')
+        f2 = os.path.join(tmp_dir, 'two')
+
+        self.write_file(f1, 'xxx')
+        self.write_file(f2, 'xxx')
+
+        for f in (f1, f2):
+            assert os.path.exists(f)
+
+        pkg_dir, dist = self.create_dist()
+        cmd = config(dist)
+        cmd._clean(f1, f2)
+
+        for f in (f1, f2):
+            assert not os.path.exists(f)
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/test_core.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/test_core.py
new file mode 100644
index 0000000000000000000000000000000000000000..bad3fb7e8318d3ee73ecabe20ed98c279f606a77
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/test_core.py
@@ -0,0 +1,130 @@
+"""Tests for distutils.core."""
+
+import distutils.core
+import io
+import os
+import sys
+from distutils.dist import Distribution
+
+import pytest
+
+# setup script that uses __file__
+setup_using___file__ = """\
+
+__file__
+
+from distutils.core import setup
+setup()
+"""
+
+setup_prints_cwd = """\
+
+import os
+print(os.getcwd())
+
+from distutils.core import setup
+setup()
+"""
+
+setup_does_nothing = """\
+from distutils.core import setup
+setup()
+"""
+
+
+setup_defines_subclass = """\
+from distutils.core import setup
+from distutils.command.install import install as _install
+
+class install(_install):
+    sub_commands = _install.sub_commands + ['cmd']
+
+setup(cmdclass={'install': install})
+"""
+
+setup_within_if_main = """\
+from distutils.core import setup
+
+def main():
+    return setup(name="setup_within_if_main")
+
+if __name__ == "__main__":
+    main()
+"""
+
+
+@pytest.fixture(autouse=True)
+def save_stdout(monkeypatch):
+    monkeypatch.setattr(sys, 'stdout', sys.stdout)
+
+
+@pytest.fixture
+def temp_file(tmp_path):
+    return tmp_path / 'file'
+
+
+@pytest.mark.usefixtures('save_env')
+@pytest.mark.usefixtures('save_argv')
+class TestCore:
+    def test_run_setup_provides_file(self, temp_file):
+        # Make sure the script can use __file__; if that's missing, the test
+        # setup.py script will raise NameError.
+        temp_file.write_text(setup_using___file__, encoding='utf-8')
+        distutils.core.run_setup(temp_file)
+
+    def test_run_setup_preserves_sys_argv(self, temp_file):
+        # Make sure run_setup does not clobber sys.argv
+        argv_copy = sys.argv.copy()
+        temp_file.write_text(setup_does_nothing, encoding='utf-8')
+        distutils.core.run_setup(temp_file)
+        assert sys.argv == argv_copy
+
+    def test_run_setup_defines_subclass(self, temp_file):
+        # Make sure the script can use __file__; if that's missing, the test
+        # setup.py script will raise NameError.
+        temp_file.write_text(setup_defines_subclass, encoding='utf-8')
+        dist = distutils.core.run_setup(temp_file)
+        install = dist.get_command_obj('install')
+        assert 'cmd' in install.sub_commands
+
+    def test_run_setup_uses_current_dir(self, tmp_path):
+        """
+        Test that the setup script is run with the current directory
+        as its own current directory.
+        """
+        sys.stdout = io.StringIO()
+        cwd = os.getcwd()
+
+        # Create a directory and write the setup.py file there:
+        setup_py = tmp_path / 'setup.py'
+        setup_py.write_text(setup_prints_cwd, encoding='utf-8')
+        distutils.core.run_setup(setup_py)
+
+        output = sys.stdout.getvalue()
+        if output.endswith("\n"):
+            output = output[:-1]
+        assert cwd == output
+
+    def test_run_setup_within_if_main(self, temp_file):
+        temp_file.write_text(setup_within_if_main, encoding='utf-8')
+        dist = distutils.core.run_setup(temp_file, stop_after="config")
+        assert isinstance(dist, Distribution)
+        assert dist.get_name() == "setup_within_if_main"
+
+    def test_run_commands(self, temp_file):
+        sys.argv = ['setup.py', 'build']
+        temp_file.write_text(setup_within_if_main, encoding='utf-8')
+        dist = distutils.core.run_setup(temp_file, stop_after="commandline")
+        assert 'build' not in dist.have_run
+        distutils.core.run_commands(dist)
+        assert 'build' in dist.have_run
+
+    def test_debug_mode(self, capsys, monkeypatch):
+        # this covers the code called when DEBUG is set
+        sys.argv = ['setup.py', '--name']
+        distutils.core.setup(name='bar')
+        assert capsys.readouterr().out == 'bar\n'
+        monkeypatch.setattr(distutils.core, 'DEBUG', True)
+        distutils.core.setup(name='bar')
+        wanted = "options (after parsing config files):\n"
+        assert capsys.readouterr().out.startswith(wanted)
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/test_dir_util.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/test_dir_util.py
new file mode 100644
index 0000000000000000000000000000000000000000..326cb346145ec7e3a1dd0384c33d4125131feaae
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/test_dir_util.py
@@ -0,0 +1,139 @@
+"""Tests for distutils.dir_util."""
+
+import os
+import pathlib
+import stat
+import sys
+import unittest.mock as mock
+from distutils import dir_util, errors
+from distutils.dir_util import (
+    copy_tree,
+    create_tree,
+    ensure_relative,
+    mkpath,
+    remove_tree,
+)
+from distutils.tests import support
+
+import jaraco.path
+import path
+import pytest
+
+
+@pytest.fixture(autouse=True)
+def stuff(request, monkeypatch, distutils_managed_tempdir):
+    self = request.instance
+    tmp_dir = self.mkdtemp()
+    self.root_target = os.path.join(tmp_dir, 'deep')
+    self.target = os.path.join(self.root_target, 'here')
+    self.target2 = os.path.join(tmp_dir, 'deep2')
+
+
+class TestDirUtil(support.TempdirManager):
+    def test_mkpath_remove_tree_verbosity(self, caplog):
+        mkpath(self.target, verbose=False)
+        assert not caplog.records
+        remove_tree(self.root_target, verbose=False)
+
+        mkpath(self.target, verbose=True)
+        wanted = [f'creating {self.target}']
+        assert caplog.messages == wanted
+        caplog.clear()
+
+        remove_tree(self.root_target, verbose=True)
+        wanted = [f"removing '{self.root_target}' (and everything under it)"]
+        assert caplog.messages == wanted
+
+    @pytest.mark.skipif("platform.system() == 'Windows'")
+    def test_mkpath_with_custom_mode(self):
+        # Get and set the current umask value for testing mode bits.
+        umask = os.umask(0o002)
+        os.umask(umask)
+        mkpath(self.target, 0o700)
+        assert stat.S_IMODE(os.stat(self.target).st_mode) == 0o700 & ~umask
+        mkpath(self.target2, 0o555)
+        assert stat.S_IMODE(os.stat(self.target2).st_mode) == 0o555 & ~umask
+
+    def test_create_tree_verbosity(self, caplog):
+        create_tree(self.root_target, ['one', 'two', 'three'], verbose=False)
+        assert caplog.messages == []
+        remove_tree(self.root_target, verbose=False)
+
+        wanted = [f'creating {self.root_target}']
+        create_tree(self.root_target, ['one', 'two', 'three'], verbose=True)
+        assert caplog.messages == wanted
+
+        remove_tree(self.root_target, verbose=False)
+
+    def test_copy_tree_verbosity(self, caplog):
+        mkpath(self.target, verbose=False)
+
+        copy_tree(self.target, self.target2, verbose=False)
+        assert caplog.messages == []
+
+        remove_tree(self.root_target, verbose=False)
+
+        mkpath(self.target, verbose=False)
+        a_file = path.Path(self.target) / 'ok.txt'
+        jaraco.path.build({'ok.txt': 'some content'}, self.target)
+
+        wanted = [f'copying {a_file} -> {self.target2}']
+        copy_tree(self.target, self.target2, verbose=True)
+        assert caplog.messages == wanted
+
+        remove_tree(self.root_target, verbose=False)
+        remove_tree(self.target2, verbose=False)
+
+    def test_copy_tree_skips_nfs_temp_files(self):
+        mkpath(self.target, verbose=False)
+
+        jaraco.path.build({'ok.txt': 'some content', '.nfs123abc': ''}, self.target)
+
+        copy_tree(self.target, self.target2)
+        assert os.listdir(self.target2) == ['ok.txt']
+
+        remove_tree(self.root_target, verbose=False)
+        remove_tree(self.target2, verbose=False)
+
+    def test_ensure_relative(self):
+        if os.sep == '/':
+            assert ensure_relative('/home/foo') == 'home/foo'
+            assert ensure_relative('some/path') == 'some/path'
+        else:  # \\
+            assert ensure_relative('c:\\home\\foo') == 'c:home\\foo'
+            assert ensure_relative('home\\foo') == 'home\\foo'
+
+    def test_copy_tree_exception_in_listdir(self):
+        """
+        An exception in listdir should raise a DistutilsFileError
+        """
+        with (
+            mock.patch("os.listdir", side_effect=OSError()),
+            pytest.raises(errors.DistutilsFileError),
+        ):
+            src = self.tempdirs[-1]
+            dir_util.copy_tree(src, None)
+
+    def test_mkpath_exception_uncached(self, monkeypatch, tmp_path):
+        """
+        Caching should not remember failed attempts.
+
+        pypa/distutils#304
+        """
+
+        class FailPath(pathlib.Path):
+            def mkdir(self, *args, **kwargs):
+                raise OSError("Failed to create directory")
+
+            if sys.version_info < (3, 12):
+                _flavour = pathlib.Path()._flavour
+
+        target = tmp_path / 'foodir'
+
+        with pytest.raises(errors.DistutilsFileError):
+            mkpath(FailPath(target))
+
+        assert not target.exists()
+
+        mkpath(target)
+        assert target.exists()
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/test_dist.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/test_dist.py
new file mode 100644
index 0000000000000000000000000000000000000000..2c5beebe64eb9d747088cf117082a546330b29f3
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/test_dist.py
@@ -0,0 +1,552 @@
+"""Tests for distutils.dist."""
+
+import email
+import email.generator
+import email.policy
+import functools
+import io
+import os
+import sys
+import textwrap
+import unittest.mock as mock
+import warnings
+from distutils.cmd import Command
+from distutils.dist import Distribution, fix_help_options
+from distutils.tests import support
+from typing import ClassVar
+
+import jaraco.path
+import pytest
+
+pydistutils_cfg = '.' * (os.name == 'posix') + 'pydistutils.cfg'
+
+
+class test_dist(Command):
+    """Sample distutils extension command."""
+
+    user_options: ClassVar[list[tuple[str, str, str]]] = [
+        ("sample-option=", "S", "help text"),
+    ]
+
+    def initialize_options(self):
+        self.sample_option = None
+
+
+class TestDistribution(Distribution):
+    """Distribution subclasses that avoids the default search for
+    configuration files.
+
+    The ._config_files attribute must be set before
+    .parse_config_files() is called.
+    """
+
+    def find_config_files(self):
+        return self._config_files
+
+
+@pytest.fixture
+def clear_argv():
+    del sys.argv[1:]
+
+
+@support.combine_markers
+@pytest.mark.usefixtures('save_env')
+@pytest.mark.usefixtures('save_argv')
+class TestDistributionBehavior(support.TempdirManager):
+    def create_distribution(self, configfiles=()):
+        d = TestDistribution()
+        d._config_files = configfiles
+        d.parse_config_files()
+        d.parse_command_line()
+        return d
+
+    def test_command_packages_unspecified(self, clear_argv):
+        sys.argv.append("build")
+        d = self.create_distribution()
+        assert d.get_command_packages() == ["distutils.command"]
+
+    def test_command_packages_cmdline(self, clear_argv):
+        from distutils.tests.test_dist import test_dist
+
+        sys.argv.extend([
+            "--command-packages",
+            "foo.bar,distutils.tests",
+            "test_dist",
+            "-Ssometext",
+        ])
+        d = self.create_distribution()
+        # let's actually try to load our test command:
+        assert d.get_command_packages() == [
+            "distutils.command",
+            "foo.bar",
+            "distutils.tests",
+        ]
+        cmd = d.get_command_obj("test_dist")
+        assert isinstance(cmd, test_dist)
+        assert cmd.sample_option == "sometext"
+
+    @pytest.mark.skipif(
+        'distutils' not in Distribution.parse_config_files.__module__,
+        reason='Cannot test when virtualenv has monkey-patched Distribution',
+    )
+    def test_venv_install_options(self, tmp_path, clear_argv):
+        sys.argv.append("install")
+        file = str(tmp_path / 'file')
+
+        fakepath = '/somedir'
+
+        jaraco.path.build({
+            file: f"""
+                    [install]
+                    install-base = {fakepath}
+                    install-platbase = {fakepath}
+                    install-lib = {fakepath}
+                    install-platlib = {fakepath}
+                    install-purelib = {fakepath}
+                    install-headers = {fakepath}
+                    install-scripts = {fakepath}
+                    install-data = {fakepath}
+                    prefix = {fakepath}
+                    exec-prefix = {fakepath}
+                    home = {fakepath}
+                    user = {fakepath}
+                    root = {fakepath}
+                    """,
+        })
+
+        # Base case: Not in a Virtual Environment
+        with mock.patch.multiple(sys, prefix='/a', base_prefix='/a'):
+            d = self.create_distribution([file])
+
+        option_tuple = (file, fakepath)
+
+        result_dict = {
+            'install_base': option_tuple,
+            'install_platbase': option_tuple,
+            'install_lib': option_tuple,
+            'install_platlib': option_tuple,
+            'install_purelib': option_tuple,
+            'install_headers': option_tuple,
+            'install_scripts': option_tuple,
+            'install_data': option_tuple,
+            'prefix': option_tuple,
+            'exec_prefix': option_tuple,
+            'home': option_tuple,
+            'user': option_tuple,
+            'root': option_tuple,
+        }
+
+        assert sorted(d.command_options.get('install').keys()) == sorted(
+            result_dict.keys()
+        )
+
+        for key, value in d.command_options.get('install').items():
+            assert value == result_dict[key]
+
+        # Test case: In a Virtual Environment
+        with mock.patch.multiple(sys, prefix='/a', base_prefix='/b'):
+            d = self.create_distribution([file])
+
+        for key in result_dict.keys():
+            assert key not in d.command_options.get('install', {})
+
+    def test_command_packages_configfile(self, tmp_path, clear_argv):
+        sys.argv.append("build")
+        file = str(tmp_path / "file")
+        jaraco.path.build({
+            file: """
+                    [global]
+                    command_packages = foo.bar, splat
+                    """,
+        })
+
+        d = self.create_distribution([file])
+        assert d.get_command_packages() == ["distutils.command", "foo.bar", "splat"]
+
+        # ensure command line overrides config:
+        sys.argv[1:] = ["--command-packages", "spork", "build"]
+        d = self.create_distribution([file])
+        assert d.get_command_packages() == ["distutils.command", "spork"]
+
+        # Setting --command-packages to '' should cause the default to
+        # be used even if a config file specified something else:
+        sys.argv[1:] = ["--command-packages", "", "build"]
+        d = self.create_distribution([file])
+        assert d.get_command_packages() == ["distutils.command"]
+
+    def test_empty_options(self, request):
+        # an empty options dictionary should not stay in the
+        # list of attributes
+
+        # catching warnings
+        warns = []
+
+        def _warn(msg):
+            warns.append(msg)
+
+        request.addfinalizer(
+            functools.partial(setattr, warnings, 'warn', warnings.warn)
+        )
+        warnings.warn = _warn
+        dist = Distribution(
+            attrs={
+                'author': 'xxx',
+                'name': 'xxx',
+                'version': 'xxx',
+                'url': 'xxxx',
+                'options': {},
+            }
+        )
+
+        assert len(warns) == 0
+        assert 'options' not in dir(dist)
+
+    def test_finalize_options(self):
+        attrs = {'keywords': 'one,two', 'platforms': 'one,two'}
+
+        dist = Distribution(attrs=attrs)
+        dist.finalize_options()
+
+        # finalize_option splits platforms and keywords
+        assert dist.metadata.platforms == ['one', 'two']
+        assert dist.metadata.keywords == ['one', 'two']
+
+        attrs = {'keywords': 'foo bar', 'platforms': 'foo bar'}
+        dist = Distribution(attrs=attrs)
+        dist.finalize_options()
+        assert dist.metadata.platforms == ['foo bar']
+        assert dist.metadata.keywords == ['foo bar']
+
+    def test_get_command_packages(self):
+        dist = Distribution()
+        assert dist.command_packages is None
+        cmds = dist.get_command_packages()
+        assert cmds == ['distutils.command']
+        assert dist.command_packages == ['distutils.command']
+
+        dist.command_packages = 'one,two'
+        cmds = dist.get_command_packages()
+        assert cmds == ['distutils.command', 'one', 'two']
+
+    def test_announce(self):
+        # make sure the level is known
+        dist = Distribution()
+        with pytest.raises(TypeError):
+            dist.announce('ok', level='ok2')
+
+    def test_find_config_files_disable(self, temp_home):
+        # Ticket #1180: Allow user to disable their home config file.
+        jaraco.path.build({pydistutils_cfg: '[distutils]\n'}, temp_home)
+
+        d = Distribution()
+        all_files = d.find_config_files()
+
+        d = Distribution(attrs={'script_args': ['--no-user-cfg']})
+        files = d.find_config_files()
+
+        # make sure --no-user-cfg disables the user cfg file
+        assert len(all_files) - 1 == len(files)
+
+    def test_script_args_list_coercion(self):
+        d = Distribution(attrs={'script_args': ('build', '--no-user-cfg')})
+
+        # make sure script_args is a list even if it started as a different iterable
+        assert d.script_args == ['build', '--no-user-cfg']
+
+    @pytest.mark.skipif(
+        'platform.system() == "Windows"',
+        reason='Windows does not honor chmod 000',
+    )
+    def test_find_config_files_permission_error(self, fake_home):
+        """
+        Finding config files should not fail when directory is inaccessible.
+        """
+        fake_home.joinpath(pydistutils_cfg).write_text('', encoding='utf-8')
+        fake_home.chmod(0o000)
+        Distribution().find_config_files()
+
+
+@pytest.mark.usefixtures('save_env')
+@pytest.mark.usefixtures('save_argv')
+class TestMetadata(support.TempdirManager):
+    def format_metadata(self, dist):
+        sio = io.StringIO()
+        dist.metadata.write_pkg_file(sio)
+        return sio.getvalue()
+
+    def test_simple_metadata(self):
+        attrs = {"name": "package", "version": "1.0"}
+        dist = Distribution(attrs)
+        meta = self.format_metadata(dist)
+        assert "Metadata-Version: 1.0" in meta
+        assert "provides:" not in meta.lower()
+        assert "requires:" not in meta.lower()
+        assert "obsoletes:" not in meta.lower()
+
+    def test_provides(self):
+        attrs = {
+            "name": "package",
+            "version": "1.0",
+            "provides": ["package", "package.sub"],
+        }
+        dist = Distribution(attrs)
+        assert dist.metadata.get_provides() == ["package", "package.sub"]
+        assert dist.get_provides() == ["package", "package.sub"]
+        meta = self.format_metadata(dist)
+        assert "Metadata-Version: 1.1" in meta
+        assert "requires:" not in meta.lower()
+        assert "obsoletes:" not in meta.lower()
+
+    def test_provides_illegal(self):
+        with pytest.raises(ValueError):
+            Distribution(
+                {"name": "package", "version": "1.0", "provides": ["my.pkg (splat)"]},
+            )
+
+    def test_requires(self):
+        attrs = {
+            "name": "package",
+            "version": "1.0",
+            "requires": ["other", "another (==1.0)"],
+        }
+        dist = Distribution(attrs)
+        assert dist.metadata.get_requires() == ["other", "another (==1.0)"]
+        assert dist.get_requires() == ["other", "another (==1.0)"]
+        meta = self.format_metadata(dist)
+        assert "Metadata-Version: 1.1" in meta
+        assert "provides:" not in meta.lower()
+        assert "Requires: other" in meta
+        assert "Requires: another (==1.0)" in meta
+        assert "obsoletes:" not in meta.lower()
+
+    def test_requires_illegal(self):
+        with pytest.raises(ValueError):
+            Distribution(
+                {"name": "package", "version": "1.0", "requires": ["my.pkg (splat)"]},
+            )
+
+    def test_requires_to_list(self):
+        attrs = {"name": "package", "requires": iter(["other"])}
+        dist = Distribution(attrs)
+        assert isinstance(dist.metadata.requires, list)
+
+    def test_obsoletes(self):
+        attrs = {
+            "name": "package",
+            "version": "1.0",
+            "obsoletes": ["other", "another (<1.0)"],
+        }
+        dist = Distribution(attrs)
+        assert dist.metadata.get_obsoletes() == ["other", "another (<1.0)"]
+        assert dist.get_obsoletes() == ["other", "another (<1.0)"]
+        meta = self.format_metadata(dist)
+        assert "Metadata-Version: 1.1" in meta
+        assert "provides:" not in meta.lower()
+        assert "requires:" not in meta.lower()
+        assert "Obsoletes: other" in meta
+        assert "Obsoletes: another (<1.0)" in meta
+
+    def test_obsoletes_illegal(self):
+        with pytest.raises(ValueError):
+            Distribution(
+                {"name": "package", "version": "1.0", "obsoletes": ["my.pkg (splat)"]},
+            )
+
+    def test_obsoletes_to_list(self):
+        attrs = {"name": "package", "obsoletes": iter(["other"])}
+        dist = Distribution(attrs)
+        assert isinstance(dist.metadata.obsoletes, list)
+
+    def test_classifier(self):
+        attrs = {
+            'name': 'Boa',
+            'version': '3.0',
+            'classifiers': ['Programming Language :: Python :: 3'],
+        }
+        dist = Distribution(attrs)
+        assert dist.get_classifiers() == ['Programming Language :: Python :: 3']
+        meta = self.format_metadata(dist)
+        assert 'Metadata-Version: 1.1' in meta
+
+    def test_classifier_invalid_type(self, caplog):
+        attrs = {
+            'name': 'Boa',
+            'version': '3.0',
+            'classifiers': ('Programming Language :: Python :: 3',),
+        }
+        d = Distribution(attrs)
+        # should have warning about passing a non-list
+        assert 'should be a list' in caplog.messages[0]
+        # should be converted to a list
+        assert isinstance(d.metadata.classifiers, list)
+        assert d.metadata.classifiers == list(attrs['classifiers'])
+
+    def test_keywords(self):
+        attrs = {
+            'name': 'Monty',
+            'version': '1.0',
+            'keywords': ['spam', 'eggs', 'life of brian'],
+        }
+        dist = Distribution(attrs)
+        assert dist.get_keywords() == ['spam', 'eggs', 'life of brian']
+
+    def test_keywords_invalid_type(self, caplog):
+        attrs = {
+            'name': 'Monty',
+            'version': '1.0',
+            'keywords': ('spam', 'eggs', 'life of brian'),
+        }
+        d = Distribution(attrs)
+        # should have warning about passing a non-list
+        assert 'should be a list' in caplog.messages[0]
+        # should be converted to a list
+        assert isinstance(d.metadata.keywords, list)
+        assert d.metadata.keywords == list(attrs['keywords'])
+
+    def test_platforms(self):
+        attrs = {
+            'name': 'Monty',
+            'version': '1.0',
+            'platforms': ['GNU/Linux', 'Some Evil Platform'],
+        }
+        dist = Distribution(attrs)
+        assert dist.get_platforms() == ['GNU/Linux', 'Some Evil Platform']
+
+    def test_platforms_invalid_types(self, caplog):
+        attrs = {
+            'name': 'Monty',
+            'version': '1.0',
+            'platforms': ('GNU/Linux', 'Some Evil Platform'),
+        }
+        d = Distribution(attrs)
+        # should have warning about passing a non-list
+        assert 'should be a list' in caplog.messages[0]
+        # should be converted to a list
+        assert isinstance(d.metadata.platforms, list)
+        assert d.metadata.platforms == list(attrs['platforms'])
+
+    def test_download_url(self):
+        attrs = {
+            'name': 'Boa',
+            'version': '3.0',
+            'download_url': 'http://example.org/boa',
+        }
+        dist = Distribution(attrs)
+        meta = self.format_metadata(dist)
+        assert 'Metadata-Version: 1.1' in meta
+
+    def test_long_description(self):
+        long_desc = textwrap.dedent(
+            """\
+        example::
+              We start here
+            and continue here
+          and end here."""
+        )
+        attrs = {"name": "package", "version": "1.0", "long_description": long_desc}
+
+        dist = Distribution(attrs)
+        meta = self.format_metadata(dist)
+        meta = meta.replace('\n' + 8 * ' ', '\n')
+        assert long_desc in meta
+
+    def test_custom_pydistutils(self, temp_home):
+        """
+        pydistutils.cfg is found
+        """
+        jaraco.path.build({pydistutils_cfg: ''}, temp_home)
+        config_path = temp_home / pydistutils_cfg
+
+        assert str(config_path) in Distribution().find_config_files()
+
+    def test_extra_pydistutils(self, monkeypatch, tmp_path):
+        jaraco.path.build({'overrides.cfg': ''}, tmp_path)
+        filename = tmp_path / 'overrides.cfg'
+        monkeypatch.setenv('DIST_EXTRA_CONFIG', str(filename))
+        assert str(filename) in Distribution().find_config_files()
+
+    def test_fix_help_options(self):
+        help_tuples = [('a', 'b', 'c', 'd'), (1, 2, 3, 4)]
+        fancy_options = fix_help_options(help_tuples)
+        assert fancy_options[0] == ('a', 'b', 'c')
+        assert fancy_options[1] == (1, 2, 3)
+
+    def test_show_help(self, request, capsys):
+        # smoke test, just makes sure some help is displayed
+        dist = Distribution()
+        sys.argv = []
+        dist.help = True
+        dist.script_name = 'setup.py'
+        dist.parse_command_line()
+
+        output = [
+            line for line in capsys.readouterr().out.split('\n') if line.strip() != ''
+        ]
+        assert output
+
+    def test_read_metadata(self):
+        attrs = {
+            "name": "package",
+            "version": "1.0",
+            "long_description": "desc",
+            "description": "xxx",
+            "download_url": "http://example.com",
+            "keywords": ['one', 'two'],
+            "requires": ['foo'],
+        }
+
+        dist = Distribution(attrs)
+        metadata = dist.metadata
+
+        # write it then reloads it
+        PKG_INFO = io.StringIO()
+        metadata.write_pkg_file(PKG_INFO)
+        PKG_INFO.seek(0)
+        metadata.read_pkg_file(PKG_INFO)
+
+        assert metadata.name == "package"
+        assert metadata.version == "1.0"
+        assert metadata.description == "xxx"
+        assert metadata.download_url == 'http://example.com'
+        assert metadata.keywords == ['one', 'two']
+        assert metadata.platforms is None
+        assert metadata.obsoletes is None
+        assert metadata.requires == ['foo']
+
+    def test_round_trip_through_email_generator(self):
+        """
+        In pypa/setuptools#4033, it was shown that once PKG-INFO is
+        re-generated using ``email.generator.Generator``, some control
+        characters might cause problems.
+        """
+        # Given a PKG-INFO file ...
+        attrs = {
+            "name": "package",
+            "version": "1.0",
+            "long_description": "hello\x0b\nworld\n",
+        }
+        dist = Distribution(attrs)
+        metadata = dist.metadata
+
+        with io.StringIO() as buffer:
+            metadata.write_pkg_file(buffer)
+            msg = buffer.getvalue()
+
+        # ... when it is read and re-written using stdlib's email library,
+        orig = email.message_from_string(msg)
+        policy = email.policy.EmailPolicy(
+            utf8=True,
+            mangle_from_=False,
+            max_line_length=0,
+        )
+        with io.StringIO() as buffer:
+            email.generator.Generator(buffer, policy=policy).flatten(orig)
+
+            buffer.seek(0)
+            regen = email.message_from_file(buffer)
+
+        # ... then it should be the same as the original
+        # (except for the specific line break characters)
+        orig_desc = set(orig["Description"].splitlines())
+        regen_desc = set(regen["Description"].splitlines())
+        assert regen_desc == orig_desc
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/test_extension.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/test_extension.py
new file mode 100644
index 0000000000000000000000000000000000000000..5e8e768223ea40d7a629111db181a946cf8ca5b0
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/test_extension.py
@@ -0,0 +1,117 @@
+"""Tests for distutils.extension."""
+
+import os
+import pathlib
+import warnings
+from distutils.extension import Extension, read_setup_file
+
+import pytest
+from test.support.warnings_helper import check_warnings
+
+
+class TestExtension:
+    def test_read_setup_file(self):
+        # trying to read a Setup file
+        # (sample extracted from the PyGame project)
+        setup = os.path.join(os.path.dirname(__file__), 'Setup.sample')
+
+        exts = read_setup_file(setup)
+        names = [ext.name for ext in exts]
+        names.sort()
+
+        # here are the extensions read_setup_file should have created
+        # out of the file
+        wanted = [
+            '_arraysurfarray',
+            '_camera',
+            '_numericsndarray',
+            '_numericsurfarray',
+            'base',
+            'bufferproxy',
+            'cdrom',
+            'color',
+            'constants',
+            'display',
+            'draw',
+            'event',
+            'fastevent',
+            'font',
+            'gfxdraw',
+            'image',
+            'imageext',
+            'joystick',
+            'key',
+            'mask',
+            'mixer',
+            'mixer_music',
+            'mouse',
+            'movie',
+            'overlay',
+            'pixelarray',
+            'pypm',
+            'rect',
+            'rwobject',
+            'scrap',
+            'surface',
+            'surflock',
+            'time',
+            'transform',
+        ]
+
+        assert names == wanted
+
+    def test_extension_init(self):
+        # the first argument, which is the name, must be a string
+        with pytest.raises(TypeError):
+            Extension(1, [])
+        ext = Extension('name', [])
+        assert ext.name == 'name'
+
+        # the second argument, which is the list of files, must
+        # be an iterable of strings or PathLike objects, and not a string
+        with pytest.raises(TypeError):
+            Extension('name', 'file')
+        with pytest.raises(TypeError):
+            Extension('name', ['file', 1])
+        ext = Extension('name', ['file1', 'file2'])
+        assert ext.sources == ['file1', 'file2']
+        ext = Extension('name', [pathlib.Path('file1'), pathlib.Path('file2')])
+        assert ext.sources == ['file1', 'file2']
+
+        # any non-string iterable of strings or PathLike objects should work
+        ext = Extension('name', ('file1', 'file2'))  # tuple
+        assert ext.sources == ['file1', 'file2']
+        ext = Extension('name', {'file1', 'file2'})  # set
+        assert sorted(ext.sources) == ['file1', 'file2']
+        ext = Extension('name', iter(['file1', 'file2']))  # iterator
+        assert ext.sources == ['file1', 'file2']
+        ext = Extension('name', [pathlib.Path('file1'), 'file2'])  # mixed types
+        assert ext.sources == ['file1', 'file2']
+
+        # others arguments have defaults
+        for attr in (
+            'include_dirs',
+            'define_macros',
+            'undef_macros',
+            'library_dirs',
+            'libraries',
+            'runtime_library_dirs',
+            'extra_objects',
+            'extra_compile_args',
+            'extra_link_args',
+            'export_symbols',
+            'swig_opts',
+            'depends',
+        ):
+            assert getattr(ext, attr) == []
+
+        assert ext.language is None
+        assert ext.optional is None
+
+        # if there are unknown keyword options, warn about them
+        with check_warnings() as w:
+            warnings.simplefilter('always')
+            ext = Extension('name', ['file1', 'file2'], chic=True)
+
+        assert len(w.warnings) == 1
+        assert str(w.warnings[0].message) == "Unknown Extension options: 'chic'"
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/test_file_util.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/test_file_util.py
new file mode 100644
index 0000000000000000000000000000000000000000..a75d4a0317dc717c24f67127370aa87089eeba1a
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/test_file_util.py
@@ -0,0 +1,95 @@
+"""Tests for distutils.file_util."""
+
+import errno
+import os
+import unittest.mock as mock
+from distutils.errors import DistutilsFileError
+from distutils.file_util import copy_file, move_file
+
+import jaraco.path
+import pytest
+
+
+@pytest.fixture(autouse=True)
+def stuff(request, tmp_path):
+    self = request.instance
+    self.source = tmp_path / 'f1'
+    self.target = tmp_path / 'f2'
+    self.target_dir = tmp_path / 'd1'
+
+
+class TestFileUtil:
+    def test_move_file_verbosity(self, caplog):
+        jaraco.path.build({self.source: 'some content'})
+
+        move_file(self.source, self.target, verbose=False)
+        assert not caplog.messages
+
+        # back to original state
+        move_file(self.target, self.source, verbose=False)
+
+        move_file(self.source, self.target, verbose=True)
+        wanted = [f'moving {self.source} -> {self.target}']
+        assert caplog.messages == wanted
+
+        # back to original state
+        move_file(self.target, self.source, verbose=False)
+
+        caplog.clear()
+        # now the target is a dir
+        os.mkdir(self.target_dir)
+        move_file(self.source, self.target_dir, verbose=True)
+        wanted = [f'moving {self.source} -> {self.target_dir}']
+        assert caplog.messages == wanted
+
+    def test_move_file_exception_unpacking_rename(self):
+        # see issue 22182
+        with (
+            mock.patch("os.rename", side_effect=OSError("wrong", 1)),
+            pytest.raises(DistutilsFileError),
+        ):
+            jaraco.path.build({self.source: 'spam eggs'})
+            move_file(self.source, self.target, verbose=False)
+
+    def test_move_file_exception_unpacking_unlink(self):
+        # see issue 22182
+        with (
+            mock.patch("os.rename", side_effect=OSError(errno.EXDEV, "wrong")),
+            mock.patch("os.unlink", side_effect=OSError("wrong", 1)),
+            pytest.raises(DistutilsFileError),
+        ):
+            jaraco.path.build({self.source: 'spam eggs'})
+            move_file(self.source, self.target, verbose=False)
+
+    def test_copy_file_hard_link(self):
+        jaraco.path.build({self.source: 'some content'})
+        # Check first that copy_file() will not fall back on copying the file
+        # instead of creating the hard link.
+        try:
+            os.link(self.source, self.target)
+        except OSError as e:
+            self.skipTest(f'os.link: {e}')
+        else:
+            self.target.unlink()
+        st = os.stat(self.source)
+        copy_file(self.source, self.target, link='hard')
+        st2 = os.stat(self.source)
+        st3 = os.stat(self.target)
+        assert os.path.samestat(st, st2), (st, st2)
+        assert os.path.samestat(st2, st3), (st2, st3)
+        assert self.source.read_text(encoding='utf-8') == 'some content'
+
+    def test_copy_file_hard_link_failure(self):
+        # If hard linking fails, copy_file() falls back on copying file
+        # (some special filesystems don't support hard linking even under
+        #  Unix, see issue #8876).
+        jaraco.path.build({self.source: 'some content'})
+        st = os.stat(self.source)
+        with mock.patch("os.link", side_effect=OSError(0, "linking unsupported")):
+            copy_file(self.source, self.target, link='hard')
+        st2 = os.stat(self.source)
+        st3 = os.stat(self.target)
+        assert os.path.samestat(st, st2), (st, st2)
+        assert not os.path.samestat(st2, st3), (st2, st3)
+        for fn in (self.source, self.target):
+            assert fn.read_text(encoding='utf-8') == 'some content'
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/test_filelist.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/test_filelist.py
new file mode 100644
index 0000000000000000000000000000000000000000..130e6fb53b0bd9670bdcfe6d4bc7fcf8fd90416e
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/test_filelist.py
@@ -0,0 +1,336 @@
+"""Tests for distutils.filelist."""
+
+import logging
+import os
+import re
+from distutils import debug, filelist
+from distutils.errors import DistutilsTemplateError
+from distutils.filelist import FileList, glob_to_re, translate_pattern
+
+import jaraco.path
+import pytest
+
+from .compat import py39 as os_helper
+
+MANIFEST_IN = """\
+include ok
+include xo
+exclude xo
+include foo.tmp
+include buildout.cfg
+global-include *.x
+global-include *.txt
+global-exclude *.tmp
+recursive-include f *.oo
+recursive-exclude global *.x
+graft dir
+prune dir3
+"""
+
+
+def make_local_path(s):
+    """Converts '/' in a string to os.sep"""
+    return s.replace('/', os.sep)
+
+
+class TestFileList:
+    def assertNoWarnings(self, caplog):
+        warnings = [rec for rec in caplog.records if rec.levelno == logging.WARNING]
+        assert not warnings
+        caplog.clear()
+
+    def assertWarnings(self, caplog):
+        warnings = [rec for rec in caplog.records if rec.levelno == logging.WARNING]
+        assert warnings
+        caplog.clear()
+
+    def test_glob_to_re(self):
+        sep = os.sep
+        if os.sep == '\\':
+            sep = re.escape(os.sep)
+
+        for glob, regex in (
+            # simple cases
+            ('foo*', r'(?s:foo[^%(sep)s]*)\Z'),
+            ('foo?', r'(?s:foo[^%(sep)s])\Z'),
+            ('foo??', r'(?s:foo[^%(sep)s][^%(sep)s])\Z'),
+            # special cases
+            (r'foo\\*', r'(?s:foo\\\\[^%(sep)s]*)\Z'),
+            (r'foo\\\*', r'(?s:foo\\\\\\[^%(sep)s]*)\Z'),
+            ('foo????', r'(?s:foo[^%(sep)s][^%(sep)s][^%(sep)s][^%(sep)s])\Z'),
+            (r'foo\\??', r'(?s:foo\\\\[^%(sep)s][^%(sep)s])\Z'),
+        ):
+            regex = regex % {'sep': sep}
+            assert glob_to_re(glob) == regex
+
+    def test_process_template_line(self):
+        # testing  all MANIFEST.in template patterns
+        file_list = FileList()
+        mlp = make_local_path
+
+        # simulated file list
+        file_list.allfiles = [
+            'foo.tmp',
+            'ok',
+            'xo',
+            'four.txt',
+            'buildout.cfg',
+            # filelist does not filter out VCS directories,
+            # it's sdist that does
+            mlp('.hg/last-message.txt'),
+            mlp('global/one.txt'),
+            mlp('global/two.txt'),
+            mlp('global/files.x'),
+            mlp('global/here.tmp'),
+            mlp('f/o/f.oo'),
+            mlp('dir/graft-one'),
+            mlp('dir/dir2/graft2'),
+            mlp('dir3/ok'),
+            mlp('dir3/sub/ok.txt'),
+        ]
+
+        for line in MANIFEST_IN.split('\n'):
+            if line.strip() == '':
+                continue
+            file_list.process_template_line(line)
+
+        wanted = [
+            'ok',
+            'buildout.cfg',
+            'four.txt',
+            mlp('.hg/last-message.txt'),
+            mlp('global/one.txt'),
+            mlp('global/two.txt'),
+            mlp('f/o/f.oo'),
+            mlp('dir/graft-one'),
+            mlp('dir/dir2/graft2'),
+        ]
+
+        assert file_list.files == wanted
+
+    def test_debug_print(self, capsys, monkeypatch):
+        file_list = FileList()
+        file_list.debug_print('xxx')
+        assert capsys.readouterr().out == ''
+
+        monkeypatch.setattr(debug, 'DEBUG', True)
+        file_list.debug_print('xxx')
+        assert capsys.readouterr().out == 'xxx\n'
+
+    def test_set_allfiles(self):
+        file_list = FileList()
+        files = ['a', 'b', 'c']
+        file_list.set_allfiles(files)
+        assert file_list.allfiles == files
+
+    def test_remove_duplicates(self):
+        file_list = FileList()
+        file_list.files = ['a', 'b', 'a', 'g', 'c', 'g']
+        # files must be sorted beforehand (sdist does it)
+        file_list.sort()
+        file_list.remove_duplicates()
+        assert file_list.files == ['a', 'b', 'c', 'g']
+
+    def test_translate_pattern(self):
+        # not regex
+        assert hasattr(translate_pattern('a', anchor=True, is_regex=False), 'search')
+
+        # is a regex
+        regex = re.compile('a')
+        assert translate_pattern(regex, anchor=True, is_regex=True) == regex
+
+        # plain string flagged as regex
+        assert hasattr(translate_pattern('a', anchor=True, is_regex=True), 'search')
+
+        # glob support
+        assert translate_pattern('*.py', anchor=True, is_regex=False).search(
+            'filelist.py'
+        )
+
+    def test_exclude_pattern(self):
+        # return False if no match
+        file_list = FileList()
+        assert not file_list.exclude_pattern('*.py')
+
+        # return True if files match
+        file_list = FileList()
+        file_list.files = ['a.py', 'b.py']
+        assert file_list.exclude_pattern('*.py')
+
+        # test excludes
+        file_list = FileList()
+        file_list.files = ['a.py', 'a.txt']
+        file_list.exclude_pattern('*.py')
+        assert file_list.files == ['a.txt']
+
+    def test_include_pattern(self):
+        # return False if no match
+        file_list = FileList()
+        file_list.set_allfiles([])
+        assert not file_list.include_pattern('*.py')
+
+        # return True if files match
+        file_list = FileList()
+        file_list.set_allfiles(['a.py', 'b.txt'])
+        assert file_list.include_pattern('*.py')
+
+        # test * matches all files
+        file_list = FileList()
+        assert file_list.allfiles is None
+        file_list.set_allfiles(['a.py', 'b.txt'])
+        file_list.include_pattern('*')
+        assert file_list.allfiles == ['a.py', 'b.txt']
+
+    def test_process_template(self, caplog):
+        mlp = make_local_path
+        # invalid lines
+        file_list = FileList()
+        for action in (
+            'include',
+            'exclude',
+            'global-include',
+            'global-exclude',
+            'recursive-include',
+            'recursive-exclude',
+            'graft',
+            'prune',
+            'blarg',
+        ):
+            with pytest.raises(DistutilsTemplateError):
+                file_list.process_template_line(action)
+
+        # include
+        file_list = FileList()
+        file_list.set_allfiles(['a.py', 'b.txt', mlp('d/c.py')])
+
+        file_list.process_template_line('include *.py')
+        assert file_list.files == ['a.py']
+        self.assertNoWarnings(caplog)
+
+        file_list.process_template_line('include *.rb')
+        assert file_list.files == ['a.py']
+        self.assertWarnings(caplog)
+
+        # exclude
+        file_list = FileList()
+        file_list.files = ['a.py', 'b.txt', mlp('d/c.py')]
+
+        file_list.process_template_line('exclude *.py')
+        assert file_list.files == ['b.txt', mlp('d/c.py')]
+        self.assertNoWarnings(caplog)
+
+        file_list.process_template_line('exclude *.rb')
+        assert file_list.files == ['b.txt', mlp('d/c.py')]
+        self.assertWarnings(caplog)
+
+        # global-include
+        file_list = FileList()
+        file_list.set_allfiles(['a.py', 'b.txt', mlp('d/c.py')])
+
+        file_list.process_template_line('global-include *.py')
+        assert file_list.files == ['a.py', mlp('d/c.py')]
+        self.assertNoWarnings(caplog)
+
+        file_list.process_template_line('global-include *.rb')
+        assert file_list.files == ['a.py', mlp('d/c.py')]
+        self.assertWarnings(caplog)
+
+        # global-exclude
+        file_list = FileList()
+        file_list.files = ['a.py', 'b.txt', mlp('d/c.py')]
+
+        file_list.process_template_line('global-exclude *.py')
+        assert file_list.files == ['b.txt']
+        self.assertNoWarnings(caplog)
+
+        file_list.process_template_line('global-exclude *.rb')
+        assert file_list.files == ['b.txt']
+        self.assertWarnings(caplog)
+
+        # recursive-include
+        file_list = FileList()
+        file_list.set_allfiles(['a.py', mlp('d/b.py'), mlp('d/c.txt'), mlp('d/d/e.py')])
+
+        file_list.process_template_line('recursive-include d *.py')
+        assert file_list.files == [mlp('d/b.py'), mlp('d/d/e.py')]
+        self.assertNoWarnings(caplog)
+
+        file_list.process_template_line('recursive-include e *.py')
+        assert file_list.files == [mlp('d/b.py'), mlp('d/d/e.py')]
+        self.assertWarnings(caplog)
+
+        # recursive-exclude
+        file_list = FileList()
+        file_list.files = ['a.py', mlp('d/b.py'), mlp('d/c.txt'), mlp('d/d/e.py')]
+
+        file_list.process_template_line('recursive-exclude d *.py')
+        assert file_list.files == ['a.py', mlp('d/c.txt')]
+        self.assertNoWarnings(caplog)
+
+        file_list.process_template_line('recursive-exclude e *.py')
+        assert file_list.files == ['a.py', mlp('d/c.txt')]
+        self.assertWarnings(caplog)
+
+        # graft
+        file_list = FileList()
+        file_list.set_allfiles(['a.py', mlp('d/b.py'), mlp('d/d/e.py'), mlp('f/f.py')])
+
+        file_list.process_template_line('graft d')
+        assert file_list.files == [mlp('d/b.py'), mlp('d/d/e.py')]
+        self.assertNoWarnings(caplog)
+
+        file_list.process_template_line('graft e')
+        assert file_list.files == [mlp('d/b.py'), mlp('d/d/e.py')]
+        self.assertWarnings(caplog)
+
+        # prune
+        file_list = FileList()
+        file_list.files = ['a.py', mlp('d/b.py'), mlp('d/d/e.py'), mlp('f/f.py')]
+
+        file_list.process_template_line('prune d')
+        assert file_list.files == ['a.py', mlp('f/f.py')]
+        self.assertNoWarnings(caplog)
+
+        file_list.process_template_line('prune e')
+        assert file_list.files == ['a.py', mlp('f/f.py')]
+        self.assertWarnings(caplog)
+
+
+class TestFindAll:
+    @os_helper.skip_unless_symlink
+    def test_missing_symlink(self, temp_cwd):
+        os.symlink('foo', 'bar')
+        assert filelist.findall() == []
+
+    def test_basic_discovery(self, temp_cwd):
+        """
+        When findall is called with no parameters or with
+        '.' as the parameter, the dot should be omitted from
+        the results.
+        """
+        jaraco.path.build({'foo': {'file1.txt': ''}, 'bar': {'file2.txt': ''}})
+        file1 = os.path.join('foo', 'file1.txt')
+        file2 = os.path.join('bar', 'file2.txt')
+        expected = [file2, file1]
+        assert sorted(filelist.findall()) == expected
+
+    def test_non_local_discovery(self, tmp_path):
+        """
+        When findall is called with another path, the full
+        path name should be returned.
+        """
+        jaraco.path.build({'file1.txt': ''}, tmp_path)
+        expected = [str(tmp_path / 'file1.txt')]
+        assert filelist.findall(tmp_path) == expected
+
+    @os_helper.skip_unless_symlink
+    def test_symlink_loop(self, tmp_path):
+        jaraco.path.build(
+            {
+                'link-to-parent': jaraco.path.Symlink('.'),
+                'somefile': '',
+            },
+            tmp_path,
+        )
+        files = filelist.findall(tmp_path)
+        assert len(files) == 1
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/test_install.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/test_install.py
new file mode 100644
index 0000000000000000000000000000000000000000..b3ffb2e668ac5a042c5a2889d7b51b5755b73157
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/test_install.py
@@ -0,0 +1,245 @@
+"""Tests for distutils.command.install."""
+
+import logging
+import os
+import pathlib
+import site
+import sys
+from distutils import sysconfig
+from distutils.command import install as install_module
+from distutils.command.build_ext import build_ext
+from distutils.command.install import INSTALL_SCHEMES, install
+from distutils.core import Distribution
+from distutils.errors import DistutilsOptionError
+from distutils.extension import Extension
+from distutils.tests import missing_compiler_executable, support
+from distutils.util import is_mingw
+
+import pytest
+
+
+def _make_ext_name(modname):
+    return modname + sysconfig.get_config_var('EXT_SUFFIX')
+
+
+@support.combine_markers
+@pytest.mark.usefixtures('save_env')
+class TestInstall(
+    support.TempdirManager,
+):
+    @pytest.mark.xfail(
+        'platform.system() == "Windows" and sys.version_info > (3, 11)',
+        reason="pypa/distutils#148",
+    )
+    def test_home_installation_scheme(self):
+        # This ensure two things:
+        # - that --home generates the desired set of directory names
+        # - test --home is supported on all platforms
+        builddir = self.mkdtemp()
+        destination = os.path.join(builddir, "installation")
+
+        dist = Distribution({"name": "foopkg"})
+        # script_name need not exist, it just need to be initialized
+        dist.script_name = os.path.join(builddir, "setup.py")
+        dist.command_obj["build"] = support.DummyCommand(
+            build_base=builddir,
+            build_lib=os.path.join(builddir, "lib"),
+        )
+
+        cmd = install(dist)
+        cmd.home = destination
+        cmd.ensure_finalized()
+
+        assert cmd.install_base == destination
+        assert cmd.install_platbase == destination
+
+        def check_path(got, expected):
+            got = os.path.normpath(got)
+            expected = os.path.normpath(expected)
+            assert got == expected
+
+        impl_name = sys.implementation.name.replace("cpython", "python")
+        libdir = os.path.join(destination, "lib", impl_name)
+        check_path(cmd.install_lib, libdir)
+        _platlibdir = getattr(sys, "platlibdir", "lib")
+        platlibdir = os.path.join(destination, _platlibdir, impl_name)
+        check_path(cmd.install_platlib, platlibdir)
+        check_path(cmd.install_purelib, libdir)
+        check_path(
+            cmd.install_headers,
+            os.path.join(destination, "include", impl_name, "foopkg"),
+        )
+        check_path(cmd.install_scripts, os.path.join(destination, "bin"))
+        check_path(cmd.install_data, destination)
+
+    def test_user_site(self, monkeypatch):
+        # test install with --user
+        # preparing the environment for the test
+        self.tmpdir = self.mkdtemp()
+        orig_site = site.USER_SITE
+        orig_base = site.USER_BASE
+        monkeypatch.setattr(site, 'USER_BASE', os.path.join(self.tmpdir, 'B'))
+        monkeypatch.setattr(site, 'USER_SITE', os.path.join(self.tmpdir, 'S'))
+        monkeypatch.setattr(install_module, 'USER_BASE', site.USER_BASE)
+        monkeypatch.setattr(install_module, 'USER_SITE', site.USER_SITE)
+
+        def _expanduser(path):
+            if path.startswith('~'):
+                return os.path.normpath(self.tmpdir + path[1:])
+            return path
+
+        monkeypatch.setattr(os.path, 'expanduser', _expanduser)
+
+        for key in ('nt_user', 'posix_user'):
+            assert key in INSTALL_SCHEMES
+
+        dist = Distribution({'name': 'xx'})
+        cmd = install(dist)
+
+        # making sure the user option is there
+        options = [name for name, short, label in cmd.user_options]
+        assert 'user' in options
+
+        # setting a value
+        cmd.user = True
+
+        # user base and site shouldn't be created yet
+        assert not os.path.exists(site.USER_BASE)
+        assert not os.path.exists(site.USER_SITE)
+
+        # let's run finalize
+        cmd.ensure_finalized()
+
+        # now they should
+        assert os.path.exists(site.USER_BASE)
+        assert os.path.exists(site.USER_SITE)
+
+        assert 'userbase' in cmd.config_vars
+        assert 'usersite' in cmd.config_vars
+
+        actual_headers = os.path.relpath(cmd.install_headers, site.USER_BASE)
+        if os.name == 'nt' and not is_mingw():
+            site_path = os.path.relpath(os.path.dirname(orig_site), orig_base)
+            include = os.path.join(site_path, 'Include')
+        else:
+            include = sysconfig.get_python_inc(0, '')
+        expect_headers = os.path.join(include, 'xx')
+
+        assert os.path.normcase(actual_headers) == os.path.normcase(expect_headers)
+
+    def test_handle_extra_path(self):
+        dist = Distribution({'name': 'xx', 'extra_path': 'path,dirs'})
+        cmd = install(dist)
+
+        # two elements
+        cmd.handle_extra_path()
+        assert cmd.extra_path == ['path', 'dirs']
+        assert cmd.extra_dirs == 'dirs'
+        assert cmd.path_file == 'path'
+
+        # one element
+        cmd.extra_path = ['path']
+        cmd.handle_extra_path()
+        assert cmd.extra_path == ['path']
+        assert cmd.extra_dirs == 'path'
+        assert cmd.path_file == 'path'
+
+        # none
+        dist.extra_path = cmd.extra_path = None
+        cmd.handle_extra_path()
+        assert cmd.extra_path is None
+        assert cmd.extra_dirs == ''
+        assert cmd.path_file is None
+
+        # three elements (no way !)
+        cmd.extra_path = 'path,dirs,again'
+        with pytest.raises(DistutilsOptionError):
+            cmd.handle_extra_path()
+
+    def test_finalize_options(self):
+        dist = Distribution({'name': 'xx'})
+        cmd = install(dist)
+
+        # must supply either prefix/exec-prefix/home or
+        # install-base/install-platbase -- not both
+        cmd.prefix = 'prefix'
+        cmd.install_base = 'base'
+        with pytest.raises(DistutilsOptionError):
+            cmd.finalize_options()
+
+        # must supply either home or prefix/exec-prefix -- not both
+        cmd.install_base = None
+        cmd.home = 'home'
+        with pytest.raises(DistutilsOptionError):
+            cmd.finalize_options()
+
+        # can't combine user with prefix/exec_prefix/home or
+        # install_(plat)base
+        cmd.prefix = None
+        cmd.user = 'user'
+        with pytest.raises(DistutilsOptionError):
+            cmd.finalize_options()
+
+    def test_record(self):
+        install_dir = self.mkdtemp()
+        project_dir, dist = self.create_dist(py_modules=['hello'], scripts=['sayhi'])
+        os.chdir(project_dir)
+        self.write_file('hello.py', "def main(): print('o hai')")
+        self.write_file('sayhi', 'from hello import main; main()')
+
+        cmd = install(dist)
+        dist.command_obj['install'] = cmd
+        cmd.root = install_dir
+        cmd.record = os.path.join(project_dir, 'filelist')
+        cmd.ensure_finalized()
+        cmd.run()
+
+        content = pathlib.Path(cmd.record).read_text(encoding='utf-8')
+
+        found = [pathlib.Path(line).name for line in content.splitlines()]
+        expected = [
+            'hello.py',
+            f'hello.{sys.implementation.cache_tag}.pyc',
+            'sayhi',
+            'UNKNOWN-0.0.0-py{}.{}.egg-info'.format(*sys.version_info[:2]),
+        ]
+        assert found == expected
+
+    def test_record_extensions(self):
+        cmd = missing_compiler_executable()
+        if cmd is not None:
+            pytest.skip(f'The {cmd!r} command is not found')
+        install_dir = self.mkdtemp()
+        project_dir, dist = self.create_dist(
+            ext_modules=[Extension('xx', ['xxmodule.c'])]
+        )
+        os.chdir(project_dir)
+        support.copy_xxmodule_c(project_dir)
+
+        buildextcmd = build_ext(dist)
+        support.fixup_build_ext(buildextcmd)
+        buildextcmd.ensure_finalized()
+
+        cmd = install(dist)
+        dist.command_obj['install'] = cmd
+        dist.command_obj['build_ext'] = buildextcmd
+        cmd.root = install_dir
+        cmd.record = os.path.join(project_dir, 'filelist')
+        cmd.ensure_finalized()
+        cmd.run()
+
+        content = pathlib.Path(cmd.record).read_text(encoding='utf-8')
+
+        found = [pathlib.Path(line).name for line in content.splitlines()]
+        expected = [
+            _make_ext_name('xx'),
+            'UNKNOWN-0.0.0-py{}.{}.egg-info'.format(*sys.version_info[:2]),
+        ]
+        assert found == expected
+
+    def test_debug_mode(self, caplog, monkeypatch):
+        # this covers the code called when DEBUG is set
+        monkeypatch.setattr(install_module, 'DEBUG', True)
+        caplog.set_level(logging.DEBUG)
+        self.test_record()
+        assert any(rec for rec in caplog.records if rec.levelno == logging.DEBUG)
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/test_install_data.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/test_install_data.py
new file mode 100644
index 0000000000000000000000000000000000000000..c800f86c645d86fcb11aa3bef1513325ef163132
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/test_install_data.py
@@ -0,0 +1,74 @@
+"""Tests for distutils.command.install_data."""
+
+import os
+import pathlib
+from distutils.command.install_data import install_data
+from distutils.tests import support
+
+import pytest
+
+
+@pytest.mark.usefixtures('save_env')
+class TestInstallData(
+    support.TempdirManager,
+):
+    def test_simple_run(self):
+        pkg_dir, dist = self.create_dist()
+        cmd = install_data(dist)
+        cmd.install_dir = inst = os.path.join(pkg_dir, 'inst')
+
+        # data_files can contain
+        #  - simple files
+        #  - a Path object
+        #  - a tuple with a path, and a list of file
+        one = os.path.join(pkg_dir, 'one')
+        self.write_file(one, 'xxx')
+        inst2 = os.path.join(pkg_dir, 'inst2')
+        two = os.path.join(pkg_dir, 'two')
+        self.write_file(two, 'xxx')
+        three = pathlib.Path(pkg_dir) / 'three'
+        self.write_file(three, 'xxx')
+
+        cmd.data_files = [one, (inst2, [two]), three]
+        assert cmd.get_inputs() == [one, (inst2, [two]), three]
+
+        # let's run the command
+        cmd.ensure_finalized()
+        cmd.run()
+
+        # let's check the result
+        assert len(cmd.get_outputs()) == 3
+        rthree = os.path.split(one)[-1]
+        assert os.path.exists(os.path.join(inst, rthree))
+        rtwo = os.path.split(two)[-1]
+        assert os.path.exists(os.path.join(inst2, rtwo))
+        rone = os.path.split(one)[-1]
+        assert os.path.exists(os.path.join(inst, rone))
+        cmd.outfiles = []
+
+        # let's try with warn_dir one
+        cmd.warn_dir = True
+        cmd.ensure_finalized()
+        cmd.run()
+
+        # let's check the result
+        assert len(cmd.get_outputs()) == 3
+        assert os.path.exists(os.path.join(inst, rthree))
+        assert os.path.exists(os.path.join(inst2, rtwo))
+        assert os.path.exists(os.path.join(inst, rone))
+        cmd.outfiles = []
+
+        # now using root and empty dir
+        cmd.root = os.path.join(pkg_dir, 'root')
+        inst5 = os.path.join(pkg_dir, 'inst5')
+        four = os.path.join(cmd.install_dir, 'four')
+        self.write_file(four, 'xx')
+        cmd.data_files = [one, (inst2, [two]), three, ('inst5', [four]), (inst5, [])]
+        cmd.ensure_finalized()
+        cmd.run()
+
+        # let's check the result
+        assert len(cmd.get_outputs()) == 5
+        assert os.path.exists(os.path.join(inst, rthree))
+        assert os.path.exists(os.path.join(inst2, rtwo))
+        assert os.path.exists(os.path.join(inst, rone))
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/test_install_headers.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/test_install_headers.py
new file mode 100644
index 0000000000000000000000000000000000000000..2c74f06b976f3c3ea977667a5c16c0e7f201a558
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/test_install_headers.py
@@ -0,0 +1,33 @@
+"""Tests for distutils.command.install_headers."""
+
+import os
+from distutils.command.install_headers import install_headers
+from distutils.tests import support
+
+import pytest
+
+
+@pytest.mark.usefixtures('save_env')
+class TestInstallHeaders(
+    support.TempdirManager,
+):
+    def test_simple_run(self):
+        # we have two headers
+        header_list = self.mkdtemp()
+        header1 = os.path.join(header_list, 'header1')
+        header2 = os.path.join(header_list, 'header2')
+        self.write_file(header1)
+        self.write_file(header2)
+        headers = [header1, header2]
+
+        pkg_dir, dist = self.create_dist(headers=headers)
+        cmd = install_headers(dist)
+        assert cmd.get_inputs() == headers
+
+        # let's run the command
+        cmd.install_dir = os.path.join(pkg_dir, 'inst')
+        cmd.ensure_finalized()
+        cmd.run()
+
+        # let's check the results
+        assert len(cmd.get_outputs()) == 2
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/test_install_lib.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/test_install_lib.py
new file mode 100644
index 0000000000000000000000000000000000000000..f685a579560ea70bceea221de0e54485975ce180
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/test_install_lib.py
@@ -0,0 +1,110 @@
+"""Tests for distutils.command.install_data."""
+
+import importlib.util
+import os
+import sys
+from distutils.command.install_lib import install_lib
+from distutils.errors import DistutilsOptionError
+from distutils.extension import Extension
+from distutils.tests import support
+
+import pytest
+
+
+@support.combine_markers
+@pytest.mark.usefixtures('save_env')
+class TestInstallLib(
+    support.TempdirManager,
+):
+    def test_finalize_options(self):
+        dist = self.create_dist()[1]
+        cmd = install_lib(dist)
+
+        cmd.finalize_options()
+        assert cmd.compile == 1
+        assert cmd.optimize == 0
+
+        # optimize must be 0, 1, or 2
+        cmd.optimize = 'foo'
+        with pytest.raises(DistutilsOptionError):
+            cmd.finalize_options()
+        cmd.optimize = '4'
+        with pytest.raises(DistutilsOptionError):
+            cmd.finalize_options()
+
+        cmd.optimize = '2'
+        cmd.finalize_options()
+        assert cmd.optimize == 2
+
+    @pytest.mark.skipif('sys.dont_write_bytecode')
+    def test_byte_compile(self):
+        project_dir, dist = self.create_dist()
+        os.chdir(project_dir)
+        cmd = install_lib(dist)
+        cmd.compile = cmd.optimize = 1
+
+        f = os.path.join(project_dir, 'foo.py')
+        self.write_file(f, '# python file')
+        cmd.byte_compile([f])
+        pyc_file = importlib.util.cache_from_source('foo.py', optimization='')
+        pyc_opt_file = importlib.util.cache_from_source(
+            'foo.py', optimization=cmd.optimize
+        )
+        assert os.path.exists(pyc_file)
+        assert os.path.exists(pyc_opt_file)
+
+    def test_get_outputs(self):
+        project_dir, dist = self.create_dist()
+        os.chdir(project_dir)
+        os.mkdir('spam')
+        cmd = install_lib(dist)
+
+        # setting up a dist environment
+        cmd.compile = cmd.optimize = 1
+        cmd.install_dir = self.mkdtemp()
+        f = os.path.join(project_dir, 'spam', '__init__.py')
+        self.write_file(f, '# python package')
+        cmd.distribution.ext_modules = [Extension('foo', ['xxx'])]
+        cmd.distribution.packages = ['spam']
+        cmd.distribution.script_name = 'setup.py'
+
+        # get_outputs should return 4 elements: spam/__init__.py and .pyc,
+        # foo.import-tag-abiflags.so / foo.pyd
+        outputs = cmd.get_outputs()
+        assert len(outputs) == 4, outputs
+
+    def test_get_inputs(self):
+        project_dir, dist = self.create_dist()
+        os.chdir(project_dir)
+        os.mkdir('spam')
+        cmd = install_lib(dist)
+
+        # setting up a dist environment
+        cmd.compile = cmd.optimize = 1
+        cmd.install_dir = self.mkdtemp()
+        f = os.path.join(project_dir, 'spam', '__init__.py')
+        self.write_file(f, '# python package')
+        cmd.distribution.ext_modules = [Extension('foo', ['xxx'])]
+        cmd.distribution.packages = ['spam']
+        cmd.distribution.script_name = 'setup.py'
+
+        # get_inputs should return 2 elements: spam/__init__.py and
+        # foo.import-tag-abiflags.so / foo.pyd
+        inputs = cmd.get_inputs()
+        assert len(inputs) == 2, inputs
+
+    def test_dont_write_bytecode(self, caplog):
+        # makes sure byte_compile is not used
+        dist = self.create_dist()[1]
+        cmd = install_lib(dist)
+        cmd.compile = True
+        cmd.optimize = 1
+
+        old_dont_write_bytecode = sys.dont_write_bytecode
+        sys.dont_write_bytecode = True
+        try:
+            cmd.byte_compile([])
+        finally:
+            sys.dont_write_bytecode = old_dont_write_bytecode
+
+        assert 'byte-compiling is disabled' in caplog.messages[0]
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/test_install_scripts.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/test_install_scripts.py
new file mode 100644
index 0000000000000000000000000000000000000000..868b1c22521f23a5dd398e4636c94330d4c238ac
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/test_install_scripts.py
@@ -0,0 +1,52 @@
+"""Tests for distutils.command.install_scripts."""
+
+import os
+from distutils.command.install_scripts import install_scripts
+from distutils.core import Distribution
+from distutils.tests import support
+
+from . import test_build_scripts
+
+
+class TestInstallScripts(support.TempdirManager):
+    def test_default_settings(self):
+        dist = Distribution()
+        dist.command_obj["build"] = support.DummyCommand(build_scripts="/foo/bar")
+        dist.command_obj["install"] = support.DummyCommand(
+            install_scripts="/splat/funk",
+            force=True,
+            skip_build=True,
+        )
+        cmd = install_scripts(dist)
+        assert not cmd.force
+        assert not cmd.skip_build
+        assert cmd.build_dir is None
+        assert cmd.install_dir is None
+
+        cmd.finalize_options()
+
+        assert cmd.force
+        assert cmd.skip_build
+        assert cmd.build_dir == "/foo/bar"
+        assert cmd.install_dir == "/splat/funk"
+
+    def test_installation(self):
+        source = self.mkdtemp()
+
+        expected = test_build_scripts.TestBuildScripts.write_sample_scripts(source)
+
+        target = self.mkdtemp()
+        dist = Distribution()
+        dist.command_obj["build"] = support.DummyCommand(build_scripts=source)
+        dist.command_obj["install"] = support.DummyCommand(
+            install_scripts=target,
+            force=True,
+            skip_build=True,
+        )
+        cmd = install_scripts(dist)
+        cmd.finalize_options()
+        cmd.run()
+
+        installed = os.listdir(target)
+        for name in expected:
+            assert name in installed
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/test_log.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/test_log.py
new file mode 100644
index 0000000000000000000000000000000000000000..d67779fc9fa0f58a010929d5a456890c6dde3376
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/test_log.py
@@ -0,0 +1,12 @@
+"""Tests for distutils.log"""
+
+import logging
+from distutils._log import log
+
+
+class TestLog:
+    def test_non_ascii(self, caplog):
+        caplog.set_level(logging.DEBUG)
+        log.debug('Dεbug\tMėssãge')
+        log.fatal('Fαtal\tÈrrōr')
+        assert caplog.messages == ['Dεbug\tMėssãge', 'Fαtal\tÈrrōr']
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/test_modified.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/test_modified.py
new file mode 100644
index 0000000000000000000000000000000000000000..e35cec2d6f1a8d27619e33c253f0a83f0f72a75d
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/test_modified.py
@@ -0,0 +1,126 @@
+"""Tests for distutils._modified."""
+
+import os
+import types
+from distutils._modified import newer, newer_group, newer_pairwise, newer_pairwise_group
+from distutils.errors import DistutilsFileError
+from distutils.tests import support
+
+import pytest
+
+
+class TestDepUtil(support.TempdirManager):
+    def test_newer(self):
+        tmpdir = self.mkdtemp()
+        new_file = os.path.join(tmpdir, 'new')
+        old_file = os.path.abspath(__file__)
+
+        # Raise DistutilsFileError if 'new_file' does not exist.
+        with pytest.raises(DistutilsFileError):
+            newer(new_file, old_file)
+
+        # Return true if 'new_file' exists and is more recently modified than
+        # 'old_file', or if 'new_file' exists and 'old_file' doesn't.
+        self.write_file(new_file)
+        assert newer(new_file, 'I_dont_exist')
+        assert newer(new_file, old_file)
+
+        # Return false if both exist and 'old_file' is the same age or younger
+        # than 'new_file'.
+        assert not newer(old_file, new_file)
+
+    def _setup_1234(self):
+        tmpdir = self.mkdtemp()
+        sources = os.path.join(tmpdir, 'sources')
+        targets = os.path.join(tmpdir, 'targets')
+        os.mkdir(sources)
+        os.mkdir(targets)
+        one = os.path.join(sources, 'one')
+        two = os.path.join(sources, 'two')
+        three = os.path.abspath(__file__)  # I am the old file
+        four = os.path.join(targets, 'four')
+        self.write_file(one)
+        self.write_file(two)
+        self.write_file(four)
+        return one, two, three, four
+
+    def test_newer_pairwise(self):
+        one, two, three, four = self._setup_1234()
+
+        assert newer_pairwise([one, two], [three, four]) == ([one], [three])
+
+    def test_newer_pairwise_mismatch(self):
+        one, two, three, four = self._setup_1234()
+
+        with pytest.raises(ValueError):
+            newer_pairwise([one], [three, four])
+
+        with pytest.raises(ValueError):
+            newer_pairwise([one, two], [three])
+
+    def test_newer_pairwise_empty(self):
+        assert newer_pairwise([], []) == ([], [])
+
+    def test_newer_pairwise_fresh(self):
+        one, two, three, four = self._setup_1234()
+
+        assert newer_pairwise([one, three], [two, four]) == ([], [])
+
+    def test_newer_group(self):
+        tmpdir = self.mkdtemp()
+        sources = os.path.join(tmpdir, 'sources')
+        os.mkdir(sources)
+        one = os.path.join(sources, 'one')
+        two = os.path.join(sources, 'two')
+        three = os.path.join(sources, 'three')
+        old_file = os.path.abspath(__file__)
+
+        # return true if 'old_file' is out-of-date with respect to any file
+        # listed in 'sources'.
+        self.write_file(one)
+        self.write_file(two)
+        self.write_file(three)
+        assert newer_group([one, two, three], old_file)
+        assert not newer_group([one, two, old_file], three)
+
+        # missing handling
+        os.remove(one)
+        with pytest.raises(OSError):
+            newer_group([one, two, old_file], three)
+
+        assert not newer_group([one, two, old_file], three, missing='ignore')
+
+        assert newer_group([one, two, old_file], three, missing='newer')
+
+
+@pytest.fixture
+def groups_target(tmp_path):
+    """
+    Set up some older sources, a target, and newer sources.
+
+    Returns a simple namespace with these values.
+    """
+    filenames = ['older.c', 'older.h', 'target.o', 'newer.c', 'newer.h']
+    paths = [tmp_path / name for name in filenames]
+
+    for mtime, path in enumerate(paths):
+        path.write_text('', encoding='utf-8')
+
+        # make sure modification times are sequential
+        os.utime(path, (mtime, mtime))
+
+    return types.SimpleNamespace(older=paths[:2], target=paths[2], newer=paths[3:])
+
+
+def test_newer_pairwise_group(groups_target):
+    older = newer_pairwise_group([groups_target.older], [groups_target.target])
+    newer = newer_pairwise_group([groups_target.newer], [groups_target.target])
+    assert older == ([], [])
+    assert newer == ([groups_target.newer], [groups_target.target])
+
+
+def test_newer_group_no_sources_no_target(tmp_path):
+    """
+    Consider no sources and no target "newer".
+    """
+    assert newer_group([], str(tmp_path / 'does-not-exist'))
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/test_sdist.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/test_sdist.py
new file mode 100644
index 0000000000000000000000000000000000000000..6b1a376b262162aa7c8d3d989709c05b38563d6c
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/test_sdist.py
@@ -0,0 +1,470 @@
+"""Tests for distutils.command.sdist."""
+
+import os
+import pathlib
+import shutil  # noqa: F401
+import tarfile
+import zipfile
+from distutils.archive_util import ARCHIVE_FORMATS
+from distutils.command.sdist import sdist, show_formats
+from distutils.core import Distribution
+from distutils.errors import DistutilsOptionError
+from distutils.filelist import FileList
+from os.path import join
+from textwrap import dedent
+
+import jaraco.path
+import path
+import pytest
+from more_itertools import ilen
+
+from . import support
+from .unix_compat import grp, pwd, require_uid_0, require_unix_id
+
+SETUP_PY = """
+from distutils.core import setup
+import somecode
+
+setup(name='fake')
+"""
+
+MANIFEST = """\
+# file GENERATED by distutils, do NOT edit
+README
+buildout.cfg
+inroot.txt
+setup.py
+data%(sep)sdata.dt
+scripts%(sep)sscript.py
+some%(sep)sfile.txt
+some%(sep)sother_file.txt
+somecode%(sep)s__init__.py
+somecode%(sep)sdoc.dat
+somecode%(sep)sdoc.txt
+"""
+
+
+@pytest.fixture(autouse=True)
+def project_dir(request, distutils_managed_tempdir):
+    self = request.instance
+    self.tmp_dir = self.mkdtemp()
+    jaraco.path.build(
+        {
+            'somecode': {
+                '__init__.py': '#',
+            },
+            'README': 'xxx',
+            'setup.py': SETUP_PY,
+        },
+        self.tmp_dir,
+    )
+    with path.Path(self.tmp_dir):
+        yield
+
+
+def clean_lines(filepath):
+    with pathlib.Path(filepath).open(encoding='utf-8') as f:
+        yield from filter(None, map(str.strip, f))
+
+
+class TestSDist(support.TempdirManager):
+    def get_cmd(self, metadata=None):
+        """Returns a cmd"""
+        if metadata is None:
+            metadata = {
+                'name': 'ns.fake--pkg',
+                'version': '1.0',
+                'url': 'xxx',
+                'author': 'xxx',
+                'author_email': 'xxx',
+            }
+        dist = Distribution(metadata)
+        dist.script_name = 'setup.py'
+        dist.packages = ['somecode']
+        dist.include_package_data = True
+        cmd = sdist(dist)
+        cmd.dist_dir = 'dist'
+        return dist, cmd
+
+    @pytest.mark.usefixtures('needs_zlib')
+    def test_prune_file_list(self):
+        # this test creates a project with some VCS dirs and an NFS rename
+        # file, then launches sdist to check they get pruned on all systems
+
+        # creating VCS directories with some files in them
+        os.mkdir(join(self.tmp_dir, 'somecode', '.svn'))
+        self.write_file((self.tmp_dir, 'somecode', '.svn', 'ok.py'), 'xxx')
+
+        os.mkdir(join(self.tmp_dir, 'somecode', '.hg'))
+        self.write_file((self.tmp_dir, 'somecode', '.hg', 'ok'), 'xxx')
+
+        os.mkdir(join(self.tmp_dir, 'somecode', '.git'))
+        self.write_file((self.tmp_dir, 'somecode', '.git', 'ok'), 'xxx')
+
+        self.write_file((self.tmp_dir, 'somecode', '.nfs0001'), 'xxx')
+
+        # now building a sdist
+        dist, cmd = self.get_cmd()
+
+        # zip is available universally
+        # (tar might not be installed under win32)
+        cmd.formats = ['zip']
+
+        cmd.ensure_finalized()
+        cmd.run()
+
+        # now let's check what we have
+        dist_folder = join(self.tmp_dir, 'dist')
+        files = os.listdir(dist_folder)
+        assert files == ['ns_fake_pkg-1.0.zip']
+
+        zip_file = zipfile.ZipFile(join(dist_folder, 'ns_fake_pkg-1.0.zip'))
+        try:
+            content = zip_file.namelist()
+        finally:
+            zip_file.close()
+
+        # making sure everything has been pruned correctly
+        expected = [
+            '',
+            'PKG-INFO',
+            'README',
+            'setup.py',
+            'somecode/',
+            'somecode/__init__.py',
+        ]
+        assert sorted(content) == ['ns_fake_pkg-1.0/' + x for x in expected]
+
+    @pytest.mark.usefixtures('needs_zlib')
+    @pytest.mark.skipif("not shutil.which('tar')")
+    @pytest.mark.skipif("not shutil.which('gzip')")
+    def test_make_distribution(self):
+        # now building a sdist
+        dist, cmd = self.get_cmd()
+
+        # creating a gztar then a tar
+        cmd.formats = ['gztar', 'tar']
+        cmd.ensure_finalized()
+        cmd.run()
+
+        # making sure we have two files
+        dist_folder = join(self.tmp_dir, 'dist')
+        result = os.listdir(dist_folder)
+        result.sort()
+        assert result == ['ns_fake_pkg-1.0.tar', 'ns_fake_pkg-1.0.tar.gz']
+
+        os.remove(join(dist_folder, 'ns_fake_pkg-1.0.tar'))
+        os.remove(join(dist_folder, 'ns_fake_pkg-1.0.tar.gz'))
+
+        # now trying a tar then a gztar
+        cmd.formats = ['tar', 'gztar']
+
+        cmd.ensure_finalized()
+        cmd.run()
+
+        result = os.listdir(dist_folder)
+        result.sort()
+        assert result == ['ns_fake_pkg-1.0.tar', 'ns_fake_pkg-1.0.tar.gz']
+
+    @pytest.mark.usefixtures('needs_zlib')
+    def test_add_defaults(self):
+        # https://bugs.python.org/issue2279
+
+        # add_default should also include
+        # data_files and package_data
+        dist, cmd = self.get_cmd()
+
+        # filling data_files by pointing files
+        # in package_data
+        dist.package_data = {'': ['*.cfg', '*.dat'], 'somecode': ['*.txt']}
+        self.write_file((self.tmp_dir, 'somecode', 'doc.txt'), '#')
+        self.write_file((self.tmp_dir, 'somecode', 'doc.dat'), '#')
+
+        # adding some data in data_files
+        data_dir = join(self.tmp_dir, 'data')
+        os.mkdir(data_dir)
+        self.write_file((data_dir, 'data.dt'), '#')
+        some_dir = join(self.tmp_dir, 'some')
+        os.mkdir(some_dir)
+        # make sure VCS directories are pruned (#14004)
+        hg_dir = join(self.tmp_dir, '.hg')
+        os.mkdir(hg_dir)
+        self.write_file((hg_dir, 'last-message.txt'), '#')
+        # a buggy regex used to prevent this from working on windows (#6884)
+        self.write_file((self.tmp_dir, 'buildout.cfg'), '#')
+        self.write_file((self.tmp_dir, 'inroot.txt'), '#')
+        self.write_file((some_dir, 'file.txt'), '#')
+        self.write_file((some_dir, 'other_file.txt'), '#')
+
+        dist.data_files = [
+            ('data', ['data/data.dt', 'buildout.cfg', 'inroot.txt', 'notexisting']),
+            'some/file.txt',
+            'some/other_file.txt',
+        ]
+
+        # adding a script
+        script_dir = join(self.tmp_dir, 'scripts')
+        os.mkdir(script_dir)
+        self.write_file((script_dir, 'script.py'), '#')
+        dist.scripts = [join('scripts', 'script.py')]
+
+        cmd.formats = ['zip']
+        cmd.use_defaults = True
+
+        cmd.ensure_finalized()
+        cmd.run()
+
+        # now let's check what we have
+        dist_folder = join(self.tmp_dir, 'dist')
+        files = os.listdir(dist_folder)
+        assert files == ['ns_fake_pkg-1.0.zip']
+
+        zip_file = zipfile.ZipFile(join(dist_folder, 'ns_fake_pkg-1.0.zip'))
+        try:
+            content = zip_file.namelist()
+        finally:
+            zip_file.close()
+
+        # making sure everything was added
+        expected = [
+            '',
+            'PKG-INFO',
+            'README',
+            'buildout.cfg',
+            'data/',
+            'data/data.dt',
+            'inroot.txt',
+            'scripts/',
+            'scripts/script.py',
+            'setup.py',
+            'some/',
+            'some/file.txt',
+            'some/other_file.txt',
+            'somecode/',
+            'somecode/__init__.py',
+            'somecode/doc.dat',
+            'somecode/doc.txt',
+        ]
+        assert sorted(content) == ['ns_fake_pkg-1.0/' + x for x in expected]
+
+        # checking the MANIFEST
+        manifest = pathlib.Path(self.tmp_dir, 'MANIFEST').read_text(encoding='utf-8')
+        assert manifest == MANIFEST % {'sep': os.sep}
+
+    @staticmethod
+    def warnings(messages, prefix='warning: '):
+        return [msg for msg in messages if msg.startswith(prefix)]
+
+    @pytest.mark.usefixtures('needs_zlib')
+    def test_metadata_check_option(self, caplog):
+        # testing the `medata-check` option
+        dist, cmd = self.get_cmd(metadata={})
+
+        # this should raise some warnings !
+        # with the `check` subcommand
+        cmd.ensure_finalized()
+        cmd.run()
+        assert len(self.warnings(caplog.messages, 'warning: check: ')) == 1
+
+        # trying with a complete set of metadata
+        caplog.clear()
+        dist, cmd = self.get_cmd()
+        cmd.ensure_finalized()
+        cmd.metadata_check = False
+        cmd.run()
+        assert len(self.warnings(caplog.messages, 'warning: check: ')) == 0
+
+    def test_show_formats(self, capsys):
+        show_formats()
+
+        # the output should be a header line + one line per format
+        num_formats = len(ARCHIVE_FORMATS.keys())
+        output = [
+            line
+            for line in capsys.readouterr().out.split('\n')
+            if line.strip().startswith('--formats=')
+        ]
+        assert len(output) == num_formats
+
+    def test_finalize_options(self):
+        dist, cmd = self.get_cmd()
+        cmd.finalize_options()
+
+        # default options set by finalize
+        assert cmd.manifest == 'MANIFEST'
+        assert cmd.template == 'MANIFEST.in'
+        assert cmd.dist_dir == 'dist'
+
+        # formats has to be a string splitable on (' ', ',') or
+        # a stringlist
+        cmd.formats = 1
+        with pytest.raises(DistutilsOptionError):
+            cmd.finalize_options()
+        cmd.formats = ['zip']
+        cmd.finalize_options()
+
+        # formats has to be known
+        cmd.formats = 'supazipa'
+        with pytest.raises(DistutilsOptionError):
+            cmd.finalize_options()
+
+    # the following tests make sure there is a nice error message instead
+    # of a traceback when parsing an invalid manifest template
+
+    def _check_template(self, content, caplog):
+        dist, cmd = self.get_cmd()
+        os.chdir(self.tmp_dir)
+        self.write_file('MANIFEST.in', content)
+        cmd.ensure_finalized()
+        cmd.filelist = FileList()
+        cmd.read_template()
+        assert len(self.warnings(caplog.messages)) == 1
+
+    def test_invalid_template_unknown_command(self, caplog):
+        self._check_template('taunt knights *', caplog)
+
+    def test_invalid_template_wrong_arguments(self, caplog):
+        # this manifest command takes one argument
+        self._check_template('prune', caplog)
+
+    @pytest.mark.skipif("platform.system() != 'Windows'")
+    def test_invalid_template_wrong_path(self, caplog):
+        # on Windows, trailing slashes are not allowed
+        # this used to crash instead of raising a warning: #8286
+        self._check_template('include examples/', caplog)
+
+    @pytest.mark.usefixtures('needs_zlib')
+    def test_get_file_list(self):
+        # make sure MANIFEST is recalculated
+        dist, cmd = self.get_cmd()
+
+        # filling data_files by pointing files in package_data
+        dist.package_data = {'somecode': ['*.txt']}
+        self.write_file((self.tmp_dir, 'somecode', 'doc.txt'), '#')
+        cmd.formats = ['gztar']
+        cmd.ensure_finalized()
+        cmd.run()
+
+        assert ilen(clean_lines(cmd.manifest)) == 5
+
+        # adding a file
+        self.write_file((self.tmp_dir, 'somecode', 'doc2.txt'), '#')
+
+        # make sure build_py is reinitialized, like a fresh run
+        build_py = dist.get_command_obj('build_py')
+        build_py.finalized = False
+        build_py.ensure_finalized()
+
+        cmd.run()
+
+        manifest2 = list(clean_lines(cmd.manifest))
+
+        # do we have the new file in MANIFEST ?
+        assert len(manifest2) == 6
+        assert 'doc2.txt' in manifest2[-1]
+
+    @pytest.mark.usefixtures('needs_zlib')
+    def test_manifest_marker(self):
+        # check that autogenerated MANIFESTs have a marker
+        dist, cmd = self.get_cmd()
+        cmd.ensure_finalized()
+        cmd.run()
+
+        assert (
+            next(clean_lines(cmd.manifest))
+            == '# file GENERATED by distutils, do NOT edit'
+        )
+
+    @pytest.mark.usefixtures('needs_zlib')
+    def test_manifest_comments(self):
+        # make sure comments don't cause exceptions or wrong includes
+        contents = dedent(
+            """\
+            # bad.py
+            #bad.py
+            good.py
+            """
+        )
+        dist, cmd = self.get_cmd()
+        cmd.ensure_finalized()
+        self.write_file((self.tmp_dir, cmd.manifest), contents)
+        self.write_file((self.tmp_dir, 'good.py'), '# pick me!')
+        self.write_file((self.tmp_dir, 'bad.py'), "# don't pick me!")
+        self.write_file((self.tmp_dir, '#bad.py'), "# don't pick me!")
+        cmd.run()
+        assert cmd.filelist.files == ['good.py']
+
+    @pytest.mark.usefixtures('needs_zlib')
+    def test_manual_manifest(self):
+        # check that a MANIFEST without a marker is left alone
+        dist, cmd = self.get_cmd()
+        cmd.formats = ['gztar']
+        cmd.ensure_finalized()
+        self.write_file((self.tmp_dir, cmd.manifest), 'README.manual')
+        self.write_file(
+            (self.tmp_dir, 'README.manual'),
+            'This project maintains its MANIFEST file itself.',
+        )
+        cmd.run()
+        assert cmd.filelist.files == ['README.manual']
+
+        assert list(clean_lines(cmd.manifest)) == ['README.manual']
+
+        archive_name = join(self.tmp_dir, 'dist', 'ns_fake_pkg-1.0.tar.gz')
+        archive = tarfile.open(archive_name)
+        try:
+            filenames = [tarinfo.name for tarinfo in archive]
+        finally:
+            archive.close()
+        assert sorted(filenames) == [
+            'ns_fake_pkg-1.0',
+            'ns_fake_pkg-1.0/PKG-INFO',
+            'ns_fake_pkg-1.0/README.manual',
+        ]
+
+    @pytest.mark.usefixtures('needs_zlib')
+    @require_unix_id
+    @require_uid_0
+    @pytest.mark.skipif("not shutil.which('tar')")
+    @pytest.mark.skipif("not shutil.which('gzip')")
+    def test_make_distribution_owner_group(self):
+        # now building a sdist
+        dist, cmd = self.get_cmd()
+
+        # creating a gztar and specifying the owner+group
+        cmd.formats = ['gztar']
+        cmd.owner = pwd.getpwuid(0)[0]
+        cmd.group = grp.getgrgid(0)[0]
+        cmd.ensure_finalized()
+        cmd.run()
+
+        # making sure we have the good rights
+        archive_name = join(self.tmp_dir, 'dist', 'ns_fake_pkg-1.0.tar.gz')
+        archive = tarfile.open(archive_name)
+        try:
+            for member in archive.getmembers():
+                assert member.uid == 0
+                assert member.gid == 0
+        finally:
+            archive.close()
+
+        # building a sdist again
+        dist, cmd = self.get_cmd()
+
+        # creating a gztar
+        cmd.formats = ['gztar']
+        cmd.ensure_finalized()
+        cmd.run()
+
+        # making sure we have the good rights
+        archive_name = join(self.tmp_dir, 'dist', 'ns_fake_pkg-1.0.tar.gz')
+        archive = tarfile.open(archive_name)
+
+        # note that we are not testing the group ownership here
+        # because, depending on the platforms and the container
+        # rights (see #7408)
+        try:
+            for member in archive.getmembers():
+                assert member.uid == os.getuid()
+        finally:
+            archive.close()
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/test_spawn.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/test_spawn.py
new file mode 100644
index 0000000000000000000000000000000000000000..3b9fc926f6ffc41673630fbf5775e6f4ad638b18
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/test_spawn.py
@@ -0,0 +1,141 @@
+"""Tests for distutils.spawn."""
+
+import os
+import stat
+import sys
+import unittest.mock as mock
+from distutils.errors import DistutilsExecError
+from distutils.spawn import find_executable, spawn
+from distutils.tests import support
+
+import path
+import pytest
+from test.support import unix_shell
+
+from .compat import py39 as os_helper
+
+
+class TestSpawn(support.TempdirManager):
+    @pytest.mark.skipif("os.name not in ('nt', 'posix')")
+    def test_spawn(self):
+        tmpdir = self.mkdtemp()
+
+        # creating something executable
+        # through the shell that returns 1
+        if sys.platform != 'win32':
+            exe = os.path.join(tmpdir, 'foo.sh')
+            self.write_file(exe, f'#!{unix_shell}\nexit 1')
+        else:
+            exe = os.path.join(tmpdir, 'foo.bat')
+            self.write_file(exe, 'exit 1')
+
+        os.chmod(exe, 0o777)
+        with pytest.raises(DistutilsExecError):
+            spawn([exe])
+
+        # now something that works
+        if sys.platform != 'win32':
+            exe = os.path.join(tmpdir, 'foo.sh')
+            self.write_file(exe, f'#!{unix_shell}\nexit 0')
+        else:
+            exe = os.path.join(tmpdir, 'foo.bat')
+            self.write_file(exe, 'exit 0')
+
+        os.chmod(exe, 0o777)
+        spawn([exe])  # should work without any error
+
+    def test_find_executable(self, tmp_path):
+        program_path = self._make_executable(tmp_path, '.exe')
+        program = program_path.name
+        program_noeext = program_path.with_suffix('').name
+        filename = str(program_path)
+        tmp_dir = path.Path(tmp_path)
+
+        # test path parameter
+        rv = find_executable(program, path=tmp_dir)
+        assert rv == filename
+
+        if sys.platform == 'win32':
+            # test without ".exe" extension
+            rv = find_executable(program_noeext, path=tmp_dir)
+            assert rv == filename
+
+        # test find in the current directory
+        with tmp_dir:
+            rv = find_executable(program)
+            assert rv == program
+
+        # test non-existent program
+        dont_exist_program = "dontexist_" + program
+        rv = find_executable(dont_exist_program, path=tmp_dir)
+        assert rv is None
+
+        # PATH='': no match, except in the current directory
+        with os_helper.EnvironmentVarGuard() as env:
+            env['PATH'] = ''
+            with (
+                mock.patch(
+                    'distutils.spawn.os.confstr', return_value=tmp_dir, create=True
+                ),
+                mock.patch('distutils.spawn.os.defpath', tmp_dir),
+            ):
+                rv = find_executable(program)
+                assert rv is None
+
+                # look in current directory
+                with tmp_dir:
+                    rv = find_executable(program)
+                    assert rv == program
+
+        # PATH=':': explicitly looks in the current directory
+        with os_helper.EnvironmentVarGuard() as env:
+            env['PATH'] = os.pathsep
+            with (
+                mock.patch('distutils.spawn.os.confstr', return_value='', create=True),
+                mock.patch('distutils.spawn.os.defpath', ''),
+            ):
+                rv = find_executable(program)
+                assert rv is None
+
+                # look in current directory
+                with tmp_dir:
+                    rv = find_executable(program)
+                    assert rv == program
+
+        # missing PATH: test os.confstr("CS_PATH") and os.defpath
+        with os_helper.EnvironmentVarGuard() as env:
+            env.pop('PATH', None)
+
+            # without confstr
+            with (
+                mock.patch(
+                    'distutils.spawn.os.confstr', side_effect=ValueError, create=True
+                ),
+                mock.patch('distutils.spawn.os.defpath', tmp_dir),
+            ):
+                rv = find_executable(program)
+                assert rv == filename
+
+            # with confstr
+            with (
+                mock.patch(
+                    'distutils.spawn.os.confstr', return_value=tmp_dir, create=True
+                ),
+                mock.patch('distutils.spawn.os.defpath', ''),
+            ):
+                rv = find_executable(program)
+                assert rv == filename
+
+    @staticmethod
+    def _make_executable(tmp_path, ext):
+        # Give the temporary program a suffix regardless of platform.
+        # It's needed on Windows and not harmful on others.
+        program = tmp_path.joinpath('program').with_suffix(ext)
+        program.write_text("", encoding='utf-8')
+        program.chmod(stat.S_IXUSR)
+        return program
+
+    def test_spawn_missing_exe(self):
+        with pytest.raises(DistutilsExecError) as ctx:
+            spawn(['does-not-exist'])
+        assert "command 'does-not-exist' failed" in str(ctx.value)
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/test_sysconfig.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/test_sysconfig.py
new file mode 100644
index 0000000000000000000000000000000000000000..43d77c23fad426be237b9f91a6d98d7c36233d84
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/test_sysconfig.py
@@ -0,0 +1,319 @@
+"""Tests for distutils.sysconfig."""
+
+import contextlib
+import distutils
+import os
+import pathlib
+import subprocess
+import sys
+from distutils import sysconfig
+from distutils.ccompiler import new_compiler  # noqa: F401
+from distutils.unixccompiler import UnixCCompiler
+
+import jaraco.envs
+import path
+import pytest
+from jaraco.text import trim
+from test.support import swap_item
+
+
+def _gen_makefile(root, contents):
+    jaraco.path.build({'Makefile': trim(contents)}, root)
+    return root / 'Makefile'
+
+
+@pytest.mark.usefixtures('save_env')
+class TestSysconfig:
+    def test_get_config_h_filename(self):
+        config_h = sysconfig.get_config_h_filename()
+        assert os.path.isfile(config_h)
+
+    @pytest.mark.skipif("platform.system() == 'Windows'")
+    @pytest.mark.skipif("sys.implementation.name != 'cpython'")
+    def test_get_makefile_filename(self):
+        makefile = sysconfig.get_makefile_filename()
+        assert os.path.isfile(makefile)
+
+    def test_get_python_lib(self, tmp_path):
+        assert sysconfig.get_python_lib() != sysconfig.get_python_lib(prefix=tmp_path)
+
+    def test_get_config_vars(self):
+        cvars = sysconfig.get_config_vars()
+        assert isinstance(cvars, dict)
+        assert cvars
+
+    @pytest.mark.skipif('sysconfig.IS_PYPY')
+    @pytest.mark.skipif('sysconfig.python_build')
+    @pytest.mark.xfail('platform.system() == "Windows"')
+    def test_srcdir_simple(self):
+        # See #15364.
+        srcdir = pathlib.Path(sysconfig.get_config_var('srcdir'))
+
+        assert srcdir.absolute()
+        assert srcdir.is_dir()
+
+        makefile = pathlib.Path(sysconfig.get_makefile_filename())
+        assert makefile.parent.samefile(srcdir)
+
+    @pytest.mark.skipif('sysconfig.IS_PYPY')
+    @pytest.mark.skipif('not sysconfig.python_build')
+    def test_srcdir_python_build(self):
+        # See #15364.
+        srcdir = pathlib.Path(sysconfig.get_config_var('srcdir'))
+
+        # The python executable has not been installed so srcdir
+        # should be a full source checkout.
+        Python_h = srcdir.joinpath('Include', 'Python.h')
+        assert Python_h.is_file()
+        assert sysconfig._is_python_source_dir(srcdir)
+        assert sysconfig._is_python_source_dir(str(srcdir))
+
+    def test_srcdir_independent_of_cwd(self):
+        """
+        srcdir should be independent of the current working directory
+        """
+        # See #15364.
+        srcdir = sysconfig.get_config_var('srcdir')
+        with path.Path('..'):
+            srcdir2 = sysconfig.get_config_var('srcdir')
+        assert srcdir == srcdir2
+
+    def customize_compiler(self):
+        # make sure AR gets caught
+        class compiler:
+            compiler_type = 'unix'
+            executables = UnixCCompiler.executables
+
+            def __init__(self):
+                self.exes = {}
+
+            def set_executables(self, **kw):
+                for k, v in kw.items():
+                    self.exes[k] = v
+
+        sysconfig_vars = {
+            'AR': 'sc_ar',
+            'CC': 'sc_cc',
+            'CXX': 'sc_cxx',
+            'ARFLAGS': '--sc-arflags',
+            'CFLAGS': '--sc-cflags',
+            'CCSHARED': '--sc-ccshared',
+            'LDSHARED': 'sc_ldshared',
+            'SHLIB_SUFFIX': 'sc_shutil_suffix',
+        }
+
+        comp = compiler()
+        with contextlib.ExitStack() as cm:
+            for key, value in sysconfig_vars.items():
+                cm.enter_context(swap_item(sysconfig._config_vars, key, value))
+            sysconfig.customize_compiler(comp)
+
+        return comp
+
+    @pytest.mark.skipif("not isinstance(new_compiler(), UnixCCompiler)")
+    @pytest.mark.usefixtures('disable_macos_customization')
+    def test_customize_compiler(self):
+        # Make sure that sysconfig._config_vars is initialized
+        sysconfig.get_config_vars()
+
+        os.environ['AR'] = 'env_ar'
+        os.environ['CC'] = 'env_cc'
+        os.environ['CPP'] = 'env_cpp'
+        os.environ['CXX'] = 'env_cxx --env-cxx-flags'
+        os.environ['LDSHARED'] = 'env_ldshared'
+        os.environ['LDFLAGS'] = '--env-ldflags'
+        os.environ['ARFLAGS'] = '--env-arflags'
+        os.environ['CFLAGS'] = '--env-cflags'
+        os.environ['CPPFLAGS'] = '--env-cppflags'
+        os.environ['RANLIB'] = 'env_ranlib'
+
+        comp = self.customize_compiler()
+        assert comp.exes['archiver'] == 'env_ar --env-arflags'
+        assert comp.exes['preprocessor'] == 'env_cpp --env-cppflags'
+        assert comp.exes['compiler'] == 'env_cc --env-cflags --env-cppflags'
+        assert comp.exes['compiler_so'] == (
+            'env_cc --env-cflags --env-cppflags --sc-ccshared'
+        )
+        assert (
+            comp.exes['compiler_cxx']
+            == 'env_cxx --env-cxx-flags --sc-cflags --env-cppflags'
+        )
+        assert comp.exes['linker_exe'] == 'env_cc'
+        assert comp.exes['linker_so'] == (
+            'env_ldshared --env-ldflags --env-cflags --env-cppflags'
+        )
+        assert comp.shared_lib_extension == 'sc_shutil_suffix'
+
+        if sys.platform == "darwin":
+            assert comp.exes['ranlib'] == 'env_ranlib'
+        else:
+            assert 'ranlib' not in comp.exes
+
+        del os.environ['AR']
+        del os.environ['CC']
+        del os.environ['CPP']
+        del os.environ['CXX']
+        del os.environ['LDSHARED']
+        del os.environ['LDFLAGS']
+        del os.environ['ARFLAGS']
+        del os.environ['CFLAGS']
+        del os.environ['CPPFLAGS']
+        del os.environ['RANLIB']
+
+        comp = self.customize_compiler()
+        assert comp.exes['archiver'] == 'sc_ar --sc-arflags'
+        assert comp.exes['preprocessor'] == 'sc_cc -E'
+        assert comp.exes['compiler'] == 'sc_cc --sc-cflags'
+        assert comp.exes['compiler_so'] == 'sc_cc --sc-cflags --sc-ccshared'
+        assert comp.exes['compiler_cxx'] == 'sc_cxx --sc-cflags'
+        assert comp.exes['linker_exe'] == 'sc_cc'
+        assert comp.exes['linker_so'] == 'sc_ldshared'
+        assert comp.shared_lib_extension == 'sc_shutil_suffix'
+        assert 'ranlib' not in comp.exes
+
+    def test_parse_makefile_base(self, tmp_path):
+        makefile = _gen_makefile(
+            tmp_path,
+            """
+            CONFIG_ARGS=  '--arg1=optarg1' 'ENV=LIB'
+            VAR=$OTHER
+            OTHER=foo
+            """,
+        )
+        d = sysconfig.parse_makefile(makefile)
+        assert d == {'CONFIG_ARGS': "'--arg1=optarg1' 'ENV=LIB'", 'OTHER': 'foo'}
+
+    def test_parse_makefile_literal_dollar(self, tmp_path):
+        makefile = _gen_makefile(
+            tmp_path,
+            """
+            CONFIG_ARGS=  '--arg1=optarg1' 'ENV=\\$$LIB'
+            VAR=$OTHER
+            OTHER=foo
+            """,
+        )
+        d = sysconfig.parse_makefile(makefile)
+        assert d == {'CONFIG_ARGS': r"'--arg1=optarg1' 'ENV=\$LIB'", 'OTHER': 'foo'}
+
+    def test_sysconfig_module(self):
+        import sysconfig as global_sysconfig
+
+        assert global_sysconfig.get_config_var('CFLAGS') == sysconfig.get_config_var(
+            'CFLAGS'
+        )
+        assert global_sysconfig.get_config_var('LDFLAGS') == sysconfig.get_config_var(
+            'LDFLAGS'
+        )
+
+    # On macOS, binary installers support extension module building on
+    # various levels of the operating system with differing Xcode
+    # configurations, requiring customization of some of the
+    # compiler configuration directives to suit the environment on
+    # the installed machine. Some of these customizations may require
+    # running external programs and are thus deferred until needed by
+    # the first extension module build. Only
+    # the Distutils version of sysconfig is used for extension module
+    # builds, which happens earlier in the Distutils tests. This may
+    # cause the following tests to fail since no tests have caused
+    # the global version of sysconfig to call the customization yet.
+    # The solution for now is to simply skip this test in this case.
+    # The longer-term solution is to only have one version of sysconfig.
+    @pytest.mark.skipif("sysconfig.get_config_var('CUSTOMIZED_OSX_COMPILER')")
+    def test_sysconfig_compiler_vars(self):
+        import sysconfig as global_sysconfig
+
+        if sysconfig.get_config_var('CUSTOMIZED_OSX_COMPILER'):
+            pytest.skip('compiler flags customized')
+        assert global_sysconfig.get_config_var('LDSHARED') == sysconfig.get_config_var(
+            'LDSHARED'
+        )
+        assert global_sysconfig.get_config_var('CC') == sysconfig.get_config_var('CC')
+
+    @pytest.mark.skipif("not sysconfig.get_config_var('EXT_SUFFIX')")
+    def test_SO_deprecation(self):
+        with pytest.warns(DeprecationWarning):
+            sysconfig.get_config_var('SO')
+
+    def test_customize_compiler_before_get_config_vars(self, tmp_path):
+        # Issue #21923: test that a Distribution compiler
+        # instance can be called without an explicit call to
+        # get_config_vars().
+        jaraco.path.build(
+            {
+                'file': trim("""
+                    from distutils.core import Distribution
+                    config = Distribution().get_command_obj('config')
+                    # try_compile may pass or it may fail if no compiler
+                    # is found but it should not raise an exception.
+                    rc = config.try_compile('int x;')
+                    """)
+            },
+            tmp_path,
+        )
+        p = subprocess.Popen(
+            [sys.executable, tmp_path / 'file'],
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT,
+            universal_newlines=True,
+            encoding='utf-8',
+        )
+        outs, errs = p.communicate()
+        assert 0 == p.returncode, "Subprocess failed: " + outs
+
+    def test_parse_config_h(self):
+        config_h = sysconfig.get_config_h_filename()
+        input = {}
+        with open(config_h, encoding="utf-8") as f:
+            result = sysconfig.parse_config_h(f, g=input)
+        assert input is result
+        with open(config_h, encoding="utf-8") as f:
+            result = sysconfig.parse_config_h(f)
+        assert isinstance(result, dict)
+
+    @pytest.mark.skipif("platform.system() != 'Windows'")
+    @pytest.mark.skipif("sys.implementation.name != 'cpython'")
+    def test_win_ext_suffix(self):
+        assert sysconfig.get_config_var("EXT_SUFFIX").endswith(".pyd")
+        assert sysconfig.get_config_var("EXT_SUFFIX") != ".pyd"
+
+    @pytest.mark.skipif("platform.system() != 'Windows'")
+    @pytest.mark.skipif("sys.implementation.name != 'cpython'")
+    @pytest.mark.skipif(
+        '\\PCbuild\\'.casefold() not in sys.executable.casefold(),
+        reason='Need sys.executable to be in a source tree',
+    )
+    def test_win_build_venv_from_source_tree(self, tmp_path):
+        """Ensure distutils.sysconfig detects venvs from source tree builds."""
+        env = jaraco.envs.VEnv()
+        env.create_opts = env.clean_opts
+        env.root = tmp_path
+        env.ensure_env()
+        cmd = [
+            env.exe(),
+            "-c",
+            "import distutils.sysconfig; print(distutils.sysconfig.python_build)",
+        ]
+        distutils_path = os.path.dirname(os.path.dirname(distutils.__file__))
+        out = subprocess.check_output(
+            cmd, env={**os.environ, "PYTHONPATH": distutils_path}
+        )
+        assert out == "True"
+
+    def test_get_python_inc_missing_config_dir(self, monkeypatch):
+        """
+        In portable Python installations, the sysconfig will be broken,
+        pointing to the directories where the installation was built and
+        not where it currently is. In this case, ensure that the missing
+        directory isn't used for get_python_inc.
+
+        See pypa/distutils#178.
+        """
+
+        def override(name):
+            if name == 'INCLUDEPY':
+                return '/does-not-exist'
+            return sysconfig.get_config_var(name)
+
+        monkeypatch.setattr(sysconfig, 'get_config_var', override)
+
+        assert os.path.exists(sysconfig.get_python_inc())
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/test_text_file.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/test_text_file.py
new file mode 100644
index 0000000000000000000000000000000000000000..f51115656135cd3f348a45d4a14f97eeee47fb98
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/test_text_file.py
@@ -0,0 +1,127 @@
+"""Tests for distutils.text_file."""
+
+from distutils.tests import support
+from distutils.text_file import TextFile
+
+import jaraco.path
+import path
+
+TEST_DATA = """# test file
+
+line 3 \\
+# intervening comment
+  continues on next line
+"""
+
+
+class TestTextFile(support.TempdirManager):
+    def test_class(self):
+        # old tests moved from text_file.__main__
+        # so they are really called by the buildbots
+
+        # result 1: no fancy options
+        result1 = [
+            '# test file\n',
+            '\n',
+            'line 3 \\\n',
+            '# intervening comment\n',
+            '  continues on next line\n',
+        ]
+
+        # result 2: just strip comments
+        result2 = ["\n", "line 3 \\\n", "  continues on next line\n"]
+
+        # result 3: just strip blank lines
+        result3 = [
+            "# test file\n",
+            "line 3 \\\n",
+            "# intervening comment\n",
+            "  continues on next line\n",
+        ]
+
+        # result 4: default, strip comments, blank lines,
+        # and trailing whitespace
+        result4 = ["line 3 \\", "  continues on next line"]
+
+        # result 5: strip comments and blanks, plus join lines (but don't
+        # "collapse" joined lines
+        result5 = ["line 3   continues on next line"]
+
+        # result 6: strip comments and blanks, plus join lines (and
+        # "collapse" joined lines
+        result6 = ["line 3 continues on next line"]
+
+        def test_input(count, description, file, expected_result):
+            result = file.readlines()
+            assert result == expected_result
+
+        tmp_path = path.Path(self.mkdtemp())
+        filename = tmp_path / 'test.txt'
+        jaraco.path.build({filename.name: TEST_DATA}, tmp_path)
+
+        in_file = TextFile(
+            filename,
+            strip_comments=False,
+            skip_blanks=False,
+            lstrip_ws=False,
+            rstrip_ws=False,
+        )
+        try:
+            test_input(1, "no processing", in_file, result1)
+        finally:
+            in_file.close()
+
+        in_file = TextFile(
+            filename,
+            strip_comments=True,
+            skip_blanks=False,
+            lstrip_ws=False,
+            rstrip_ws=False,
+        )
+        try:
+            test_input(2, "strip comments", in_file, result2)
+        finally:
+            in_file.close()
+
+        in_file = TextFile(
+            filename,
+            strip_comments=False,
+            skip_blanks=True,
+            lstrip_ws=False,
+            rstrip_ws=False,
+        )
+        try:
+            test_input(3, "strip blanks", in_file, result3)
+        finally:
+            in_file.close()
+
+        in_file = TextFile(filename)
+        try:
+            test_input(4, "default processing", in_file, result4)
+        finally:
+            in_file.close()
+
+        in_file = TextFile(
+            filename,
+            strip_comments=True,
+            skip_blanks=True,
+            join_lines=True,
+            rstrip_ws=True,
+        )
+        try:
+            test_input(5, "join lines without collapsing", in_file, result5)
+        finally:
+            in_file.close()
+
+        in_file = TextFile(
+            filename,
+            strip_comments=True,
+            skip_blanks=True,
+            join_lines=True,
+            rstrip_ws=True,
+            collapse_join=True,
+        )
+        try:
+            test_input(6, "join lines with collapsing", in_file, result6)
+        finally:
+            in_file.close()
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/test_util.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/test_util.py
new file mode 100644
index 0000000000000000000000000000000000000000..00c9743ed0a2664039060ef149d30f165bf2f465
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/test_util.py
@@ -0,0 +1,243 @@
+"""Tests for distutils.util."""
+
+import email
+import email.generator
+import email.policy
+import io
+import os
+import pathlib
+import sys
+import sysconfig as stdlib_sysconfig
+import unittest.mock as mock
+from copy import copy
+from distutils import sysconfig, util
+from distutils.errors import DistutilsByteCompileError, DistutilsPlatformError
+from distutils.util import (
+    byte_compile,
+    change_root,
+    check_environ,
+    convert_path,
+    get_host_platform,
+    get_platform,
+    grok_environment_error,
+    rfc822_escape,
+    split_quoted,
+    strtobool,
+)
+
+import pytest
+
+
+@pytest.fixture(autouse=True)
+def environment(monkeypatch):
+    monkeypatch.setattr(os, 'name', os.name)
+    monkeypatch.setattr(sys, 'platform', sys.platform)
+    monkeypatch.setattr(sys, 'version', sys.version)
+    monkeypatch.setattr(os, 'sep', os.sep)
+    monkeypatch.setattr(os.path, 'join', os.path.join)
+    monkeypatch.setattr(os.path, 'isabs', os.path.isabs)
+    monkeypatch.setattr(os.path, 'splitdrive', os.path.splitdrive)
+    monkeypatch.setattr(sysconfig, '_config_vars', copy(sysconfig._config_vars))
+
+
+@pytest.mark.usefixtures('save_env')
+class TestUtil:
+    def test_get_host_platform(self):
+        with mock.patch('os.name', 'nt'):
+            with mock.patch('sys.version', '... [... (ARM64)]'):
+                assert get_host_platform() == 'win-arm64'
+            with mock.patch('sys.version', '... [... (ARM)]'):
+                assert get_host_platform() == 'win-arm32'
+
+        with mock.patch('sys.version_info', (3, 9, 0, 'final', 0)):
+            assert get_host_platform() == stdlib_sysconfig.get_platform()
+
+    def test_get_platform(self):
+        with mock.patch('os.name', 'nt'):
+            with mock.patch.dict('os.environ', {'VSCMD_ARG_TGT_ARCH': 'x86'}):
+                assert get_platform() == 'win32'
+            with mock.patch.dict('os.environ', {'VSCMD_ARG_TGT_ARCH': 'x64'}):
+                assert get_platform() == 'win-amd64'
+            with mock.patch.dict('os.environ', {'VSCMD_ARG_TGT_ARCH': 'arm'}):
+                assert get_platform() == 'win-arm32'
+            with mock.patch.dict('os.environ', {'VSCMD_ARG_TGT_ARCH': 'arm64'}):
+                assert get_platform() == 'win-arm64'
+
+    def test_convert_path(self):
+        expected = os.sep.join(('', 'home', 'to', 'my', 'stuff'))
+        assert convert_path('/home/to/my/stuff') == expected
+        assert convert_path(pathlib.Path('/home/to/my/stuff')) == expected
+        assert convert_path('.') == os.curdir
+
+    def test_change_root(self):
+        # linux/mac
+        os.name = 'posix'
+
+        def _isabs(path):
+            return path[0] == '/'
+
+        os.path.isabs = _isabs
+
+        def _join(*path):
+            return '/'.join(path)
+
+        os.path.join = _join
+
+        assert change_root('/root', '/old/its/here') == '/root/old/its/here'
+        assert change_root('/root', 'its/here') == '/root/its/here'
+
+        # windows
+        os.name = 'nt'
+        os.sep = '\\'
+
+        def _isabs(path):
+            return path.startswith('c:\\')
+
+        os.path.isabs = _isabs
+
+        def _splitdrive(path):
+            if path.startswith('c:'):
+                return ('', path.replace('c:', ''))
+            return ('', path)
+
+        os.path.splitdrive = _splitdrive
+
+        def _join(*path):
+            return '\\'.join(path)
+
+        os.path.join = _join
+
+        assert (
+            change_root('c:\\root', 'c:\\old\\its\\here') == 'c:\\root\\old\\its\\here'
+        )
+        assert change_root('c:\\root', 'its\\here') == 'c:\\root\\its\\here'
+
+        # BugsBunny os (it's a great os)
+        os.name = 'BugsBunny'
+        with pytest.raises(DistutilsPlatformError):
+            change_root('c:\\root', 'its\\here')
+
+        # XXX platforms to be covered: mac
+
+    def test_check_environ(self):
+        util.check_environ.cache_clear()
+        os.environ.pop('HOME', None)
+
+        check_environ()
+
+        assert os.environ['PLAT'] == get_platform()
+
+    @pytest.mark.skipif("os.name != 'posix'")
+    def test_check_environ_getpwuid(self):
+        util.check_environ.cache_clear()
+        os.environ.pop('HOME', None)
+
+        import pwd
+
+        # only set pw_dir field, other fields are not used
+        result = pwd.struct_passwd((
+            None,
+            None,
+            None,
+            None,
+            None,
+            '/home/distutils',
+            None,
+        ))
+        with mock.patch.object(pwd, 'getpwuid', return_value=result):
+            check_environ()
+            assert os.environ['HOME'] == '/home/distutils'
+
+        util.check_environ.cache_clear()
+        os.environ.pop('HOME', None)
+
+        # bpo-10496: Catch pwd.getpwuid() error
+        with mock.patch.object(pwd, 'getpwuid', side_effect=KeyError):
+            check_environ()
+            assert 'HOME' not in os.environ
+
+    def test_split_quoted(self):
+        assert split_quoted('""one"" "two" \'three\' \\four') == [
+            'one',
+            'two',
+            'three',
+            'four',
+        ]
+
+    def test_strtobool(self):
+        yes = ('y', 'Y', 'yes', 'True', 't', 'true', 'True', 'On', 'on', '1')
+        no = ('n', 'no', 'f', 'false', 'off', '0', 'Off', 'No', 'N')
+
+        for y in yes:
+            assert strtobool(y)
+
+        for n in no:
+            assert not strtobool(n)
+
+    indent = 8 * ' '
+
+    @pytest.mark.parametrize(
+        "given,wanted",
+        [
+            # 0x0b, 0x0c, ..., etc are also considered a line break by Python
+            ("hello\x0b\nworld\n", f"hello\x0b{indent}\n{indent}world\n{indent}"),
+            ("hello\x1eworld", f"hello\x1e{indent}world"),
+            ("", ""),
+            (
+                "I am a\npoor\nlonesome\nheader\n",
+                f"I am a\n{indent}poor\n{indent}lonesome\n{indent}header\n{indent}",
+            ),
+        ],
+    )
+    def test_rfc822_escape(self, given, wanted):
+        """
+        We want to ensure a multi-line header parses correctly.
+
+        For interoperability, the escaped value should also "round-trip" over
+        `email.generator.Generator.flatten` and `email.message_from_*`
+        (see pypa/setuptools#4033).
+
+        The main issue is that internally `email.policy.EmailPolicy` uses
+        `splitlines` which will split on some control chars. If all the new lines
+        are not prefixed with spaces, the parser will interrupt reading
+        the current header and produce an incomplete value, while
+        incorrectly interpreting the rest of the headers as part of the payload.
+        """
+        res = rfc822_escape(given)
+
+        policy = email.policy.EmailPolicy(
+            utf8=True,
+            mangle_from_=False,
+            max_line_length=0,
+        )
+        with io.StringIO() as buffer:
+            raw = f"header: {res}\nother-header: 42\n\npayload\n"
+            orig = email.message_from_string(raw)
+            email.generator.Generator(buffer, policy=policy).flatten(orig)
+            buffer.seek(0)
+            regen = email.message_from_file(buffer)
+
+        for msg in (orig, regen):
+            assert msg.get_payload() == "payload\n"
+            assert msg["other-header"] == "42"
+            # Generator may replace control chars with `\n`
+            assert set(msg["header"].splitlines()) == set(res.splitlines())
+
+        assert res == wanted
+
+    def test_dont_write_bytecode(self):
+        # makes sure byte_compile raise a DistutilsError
+        # if sys.dont_write_bytecode is True
+        old_dont_write_bytecode = sys.dont_write_bytecode
+        sys.dont_write_bytecode = True
+        try:
+            with pytest.raises(DistutilsByteCompileError):
+                byte_compile([])
+        finally:
+            sys.dont_write_bytecode = old_dont_write_bytecode
+
+    def test_grok_environment_error(self):
+        # test obsolete function to ensure backward compat (#4931)
+        exc = OSError("Unable to find batch file")
+        msg = grok_environment_error(exc)
+        assert msg == "error: Unable to find batch file"
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/test_version.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/test_version.py
new file mode 100644
index 0000000000000000000000000000000000000000..b68f0977249aa23aafbf31cf74a0e4127f777d05
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/test_version.py
@@ -0,0 +1,80 @@
+"""Tests for distutils.version."""
+
+import distutils
+from distutils.version import LooseVersion, StrictVersion
+
+import pytest
+
+
+@pytest.fixture(autouse=True)
+def suppress_deprecation():
+    with distutils.version.suppress_known_deprecation():
+        yield
+
+
+class TestVersion:
+    def test_prerelease(self):
+        version = StrictVersion('1.2.3a1')
+        assert version.version == (1, 2, 3)
+        assert version.prerelease == ('a', 1)
+        assert str(version) == '1.2.3a1'
+
+        version = StrictVersion('1.2.0')
+        assert str(version) == '1.2'
+
+    def test_cmp_strict(self):
+        versions = (
+            ('1.5.1', '1.5.2b2', -1),
+            ('161', '3.10a', ValueError),
+            ('8.02', '8.02', 0),
+            ('3.4j', '1996.07.12', ValueError),
+            ('3.2.pl0', '3.1.1.6', ValueError),
+            ('2g6', '11g', ValueError),
+            ('0.9', '2.2', -1),
+            ('1.2.1', '1.2', 1),
+            ('1.1', '1.2.2', -1),
+            ('1.2', '1.1', 1),
+            ('1.2.1', '1.2.2', -1),
+            ('1.2.2', '1.2', 1),
+            ('1.2', '1.2.2', -1),
+            ('0.4.0', '0.4', 0),
+            ('1.13++', '5.5.kw', ValueError),
+        )
+
+        for v1, v2, wanted in versions:
+            try:
+                res = StrictVersion(v1)._cmp(StrictVersion(v2))
+            except ValueError:
+                if wanted is ValueError:
+                    continue
+                else:
+                    raise AssertionError(f"cmp({v1}, {v2}) shouldn't raise ValueError")
+            assert res == wanted, f'cmp({v1}, {v2}) should be {wanted}, got {res}'
+            res = StrictVersion(v1)._cmp(v2)
+            assert res == wanted, f'cmp({v1}, {v2}) should be {wanted}, got {res}'
+            res = StrictVersion(v1)._cmp(object())
+            assert res is NotImplemented, (
+                f'cmp({v1}, {v2}) should be NotImplemented, got {res}'
+            )
+
+    def test_cmp(self):
+        versions = (
+            ('1.5.1', '1.5.2b2', -1),
+            ('161', '3.10a', 1),
+            ('8.02', '8.02', 0),
+            ('3.4j', '1996.07.12', -1),
+            ('3.2.pl0', '3.1.1.6', 1),
+            ('2g6', '11g', -1),
+            ('0.960923', '2.2beta29', -1),
+            ('1.13++', '5.5.kw', -1),
+        )
+
+        for v1, v2, wanted in versions:
+            res = LooseVersion(v1)._cmp(LooseVersion(v2))
+            assert res == wanted, f'cmp({v1}, {v2}) should be {wanted}, got {res}'
+            res = LooseVersion(v1)._cmp(v2)
+            assert res == wanted, f'cmp({v1}, {v2}) should be {wanted}, got {res}'
+            res = LooseVersion(v1)._cmp(object())
+            assert res is NotImplemented, (
+                f'cmp({v1}, {v2}) should be NotImplemented, got {res}'
+            )
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/test_versionpredicate.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/test_versionpredicate.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/unix_compat.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/unix_compat.py
new file mode 100644
index 0000000000000000000000000000000000000000..a5d9ee45ccc639794d29ba0a5fd24f781ee5ecf5
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/tests/unix_compat.py
@@ -0,0 +1,17 @@
+import sys
+
+try:
+    import grp
+    import pwd
+except ImportError:
+    grp = pwd = None
+
+import pytest
+
+UNIX_ID_SUPPORT = grp and pwd
+UID_0_SUPPORT = UNIX_ID_SUPPORT and sys.platform != "cygwin"
+
+require_unix_id = pytest.mark.skipif(
+    not UNIX_ID_SUPPORT, reason="Requires grp and pwd support"
+)
+require_uid_0 = pytest.mark.skipif(not UID_0_SUPPORT, reason="Requires UID 0 support")
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/text_file.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/text_file.py
new file mode 100644
index 0000000000000000000000000000000000000000..89d9048d5902950516c3541ad212bff7b6cb2045
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/text_file.py
@@ -0,0 +1,286 @@
+"""text_file
+
+provides the TextFile class, which gives an interface to text files
+that (optionally) takes care of stripping comments, ignoring blank
+lines, and joining lines with backslashes."""
+
+import sys
+
+
+class TextFile:
+    """Provides a file-like object that takes care of all the things you
+    commonly want to do when processing a text file that has some
+    line-by-line syntax: strip comments (as long as "#" is your
+    comment character), skip blank lines, join adjacent lines by
+    escaping the newline (ie. backslash at end of line), strip
+    leading and/or trailing whitespace.  All of these are optional
+    and independently controllable.
+
+    Provides a 'warn()' method so you can generate warning messages that
+    report physical line number, even if the logical line in question
+    spans multiple physical lines.  Also provides 'unreadline()' for
+    implementing line-at-a-time lookahead.
+
+    Constructor is called as:
+
+        TextFile (filename=None, file=None, **options)
+
+    It bombs (RuntimeError) if both 'filename' and 'file' are None;
+    'filename' should be a string, and 'file' a file object (or
+    something that provides 'readline()' and 'close()' methods).  It is
+    recommended that you supply at least 'filename', so that TextFile
+    can include it in warning messages.  If 'file' is not supplied,
+    TextFile creates its own using 'io.open()'.
+
+    The options are all boolean, and affect the value returned by
+    'readline()':
+      strip_comments [default: true]
+        strip from "#" to end-of-line, as well as any whitespace
+        leading up to the "#" -- unless it is escaped by a backslash
+      lstrip_ws [default: false]
+        strip leading whitespace from each line before returning it
+      rstrip_ws [default: true]
+        strip trailing whitespace (including line terminator!) from
+        each line before returning it
+      skip_blanks [default: true}
+        skip lines that are empty *after* stripping comments and
+        whitespace.  (If both lstrip_ws and rstrip_ws are false,
+        then some lines may consist of solely whitespace: these will
+        *not* be skipped, even if 'skip_blanks' is true.)
+      join_lines [default: false]
+        if a backslash is the last non-newline character on a line
+        after stripping comments and whitespace, join the following line
+        to it to form one "logical line"; if N consecutive lines end
+        with a backslash, then N+1 physical lines will be joined to
+        form one logical line.
+      collapse_join [default: false]
+        strip leading whitespace from lines that are joined to their
+        predecessor; only matters if (join_lines and not lstrip_ws)
+      errors [default: 'strict']
+        error handler used to decode the file content
+
+    Note that since 'rstrip_ws' can strip the trailing newline, the
+    semantics of 'readline()' must differ from those of the builtin file
+    object's 'readline()' method!  In particular, 'readline()' returns
+    None for end-of-file: an empty string might just be a blank line (or
+    an all-whitespace line), if 'rstrip_ws' is true but 'skip_blanks' is
+    not."""
+
+    default_options = {
+        'strip_comments': 1,
+        'skip_blanks': 1,
+        'lstrip_ws': 0,
+        'rstrip_ws': 1,
+        'join_lines': 0,
+        'collapse_join': 0,
+        'errors': 'strict',
+    }
+
+    def __init__(self, filename=None, file=None, **options):
+        """Construct a new TextFile object.  At least one of 'filename'
+        (a string) and 'file' (a file-like object) must be supplied.
+        They keyword argument options are described above and affect
+        the values returned by 'readline()'."""
+        if filename is None and file is None:
+            raise RuntimeError(
+                "you must supply either or both of 'filename' and 'file'"
+            )
+
+        # set values for all options -- either from client option hash
+        # or fallback to default_options
+        for opt in self.default_options.keys():
+            if opt in options:
+                setattr(self, opt, options[opt])
+            else:
+                setattr(self, opt, self.default_options[opt])
+
+        # sanity check client option hash
+        for opt in options.keys():
+            if opt not in self.default_options:
+                raise KeyError(f"invalid TextFile option '{opt}'")
+
+        if file is None:
+            self.open(filename)
+        else:
+            self.filename = filename
+            self.file = file
+            self.current_line = 0  # assuming that file is at BOF!
+
+        # 'linebuf' is a stack of lines that will be emptied before we
+        # actually read from the file; it's only populated by an
+        # 'unreadline()' operation
+        self.linebuf = []
+
+    def open(self, filename):
+        """Open a new file named 'filename'.  This overrides both the
+        'filename' and 'file' arguments to the constructor."""
+        self.filename = filename
+        self.file = open(self.filename, errors=self.errors, encoding='utf-8')
+        self.current_line = 0
+
+    def close(self):
+        """Close the current file and forget everything we know about it
+        (filename, current line number)."""
+        file = self.file
+        self.file = None
+        self.filename = None
+        self.current_line = None
+        file.close()
+
+    def gen_error(self, msg, line=None):
+        outmsg = []
+        if line is None:
+            line = self.current_line
+        outmsg.append(self.filename + ", ")
+        if isinstance(line, (list, tuple)):
+            outmsg.append("lines {}-{}: ".format(*line))
+        else:
+            outmsg.append(f"line {int(line)}: ")
+        outmsg.append(str(msg))
+        return "".join(outmsg)
+
+    def error(self, msg, line=None):
+        raise ValueError("error: " + self.gen_error(msg, line))
+
+    def warn(self, msg, line=None):
+        """Print (to stderr) a warning message tied to the current logical
+        line in the current file.  If the current logical line in the
+        file spans multiple physical lines, the warning refers to the
+        whole range, eg. "lines 3-5".  If 'line' supplied, it overrides
+        the current line number; it may be a list or tuple to indicate a
+        range of physical lines, or an integer for a single physical
+        line."""
+        sys.stderr.write("warning: " + self.gen_error(msg, line) + "\n")
+
+    def readline(self):  # noqa: C901
+        """Read and return a single logical line from the current file (or
+        from an internal buffer if lines have previously been "unread"
+        with 'unreadline()').  If the 'join_lines' option is true, this
+        may involve reading multiple physical lines concatenated into a
+        single string.  Updates the current line number, so calling
+        'warn()' after 'readline()' emits a warning about the physical
+        line(s) just read.  Returns None on end-of-file, since the empty
+        string can occur if 'rstrip_ws' is true but 'strip_blanks' is
+        not."""
+        # If any "unread" lines waiting in 'linebuf', return the top
+        # one.  (We don't actually buffer read-ahead data -- lines only
+        # get put in 'linebuf' if the client explicitly does an
+        # 'unreadline()'.
+        if self.linebuf:
+            line = self.linebuf[-1]
+            del self.linebuf[-1]
+            return line
+
+        buildup_line = ''
+
+        while True:
+            # read the line, make it None if EOF
+            line = self.file.readline()
+            if line == '':
+                line = None
+
+            if self.strip_comments and line:
+                # Look for the first "#" in the line.  If none, never
+                # mind.  If we find one and it's the first character, or
+                # is not preceded by "\", then it starts a comment --
+                # strip the comment, strip whitespace before it, and
+                # carry on.  Otherwise, it's just an escaped "#", so
+                # unescape it (and any other escaped "#"'s that might be
+                # lurking in there) and otherwise leave the line alone.
+
+                pos = line.find("#")
+                if pos == -1:  # no "#" -- no comments
+                    pass
+
+                # It's definitely a comment -- either "#" is the first
+                # character, or it's elsewhere and unescaped.
+                elif pos == 0 or line[pos - 1] != "\\":
+                    # Have to preserve the trailing newline, because it's
+                    # the job of a later step (rstrip_ws) to remove it --
+                    # and if rstrip_ws is false, we'd better preserve it!
+                    # (NB. this means that if the final line is all comment
+                    # and has no trailing newline, we will think that it's
+                    # EOF; I think that's OK.)
+                    eol = (line[-1] == '\n') and '\n' or ''
+                    line = line[0:pos] + eol
+
+                    # If all that's left is whitespace, then skip line
+                    # *now*, before we try to join it to 'buildup_line' --
+                    # that way constructs like
+                    #   hello \\
+                    #   # comment that should be ignored
+                    #   there
+                    # result in "hello there".
+                    if line.strip() == "":
+                        continue
+                else:  # it's an escaped "#"
+                    line = line.replace("\\#", "#")
+
+            # did previous line end with a backslash? then accumulate
+            if self.join_lines and buildup_line:
+                # oops: end of file
+                if line is None:
+                    self.warn("continuation line immediately precedes end-of-file")
+                    return buildup_line
+
+                if self.collapse_join:
+                    line = line.lstrip()
+                line = buildup_line + line
+
+                # careful: pay attention to line number when incrementing it
+                if isinstance(self.current_line, list):
+                    self.current_line[1] = self.current_line[1] + 1
+                else:
+                    self.current_line = [self.current_line, self.current_line + 1]
+            # just an ordinary line, read it as usual
+            else:
+                if line is None:  # eof
+                    return None
+
+                # still have to be careful about incrementing the line number!
+                if isinstance(self.current_line, list):
+                    self.current_line = self.current_line[1] + 1
+                else:
+                    self.current_line = self.current_line + 1
+
+            # strip whitespace however the client wants (leading and
+            # trailing, or one or the other, or neither)
+            if self.lstrip_ws and self.rstrip_ws:
+                line = line.strip()
+            elif self.lstrip_ws:
+                line = line.lstrip()
+            elif self.rstrip_ws:
+                line = line.rstrip()
+
+            # blank line (whether we rstrip'ed or not)? skip to next line
+            # if appropriate
+            if line in ('', '\n') and self.skip_blanks:
+                continue
+
+            if self.join_lines:
+                if line[-1] == '\\':
+                    buildup_line = line[:-1]
+                    continue
+
+                if line[-2:] == '\\\n':
+                    buildup_line = line[0:-2] + '\n'
+                    continue
+
+            # well, I guess there's some actual content there: return it
+            return line
+
+    def readlines(self):
+        """Read and return the list of all logical lines remaining in the
+        current file."""
+        lines = []
+        while True:
+            line = self.readline()
+            if line is None:
+                return lines
+            lines.append(line)
+
+    def unreadline(self, line):
+        """Push 'line' (a string) onto an internal buffer that will be
+        checked by future 'readline()' calls.  Handy for implementing
+        a parser with line-at-a-time lookahead."""
+        self.linebuf.append(line)
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/unixccompiler.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/unixccompiler.py
new file mode 100644
index 0000000000000000000000000000000000000000..20b8ce6b9bba21bd709b77249bdcae5b4119e9ca
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/unixccompiler.py
@@ -0,0 +1,9 @@
+import importlib
+
+from .compilers.C import unix
+
+UnixCCompiler = unix.Compiler
+
+# ensure import of unixccompiler implies ccompiler imported
+# (pypa/setuptools#4871)
+importlib.import_module('distutils.ccompiler')
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/util.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/util.py
new file mode 100644
index 0000000000000000000000000000000000000000..6dbe049f4274f7177295491d7f433e8ca303df48
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/util.py
@@ -0,0 +1,518 @@
+"""distutils.util
+
+Miscellaneous utility functions -- anything that doesn't fit into
+one of the other *util.py modules.
+"""
+
+from __future__ import annotations
+
+import functools
+import importlib.util
+import os
+import pathlib
+import re
+import string
+import subprocess
+import sys
+import sysconfig
+import tempfile
+from collections.abc import Callable, Iterable, Mapping
+from typing import TYPE_CHECKING, AnyStr
+
+from jaraco.functools import pass_none
+
+from ._log import log
+from ._modified import newer
+from .errors import DistutilsByteCompileError, DistutilsPlatformError
+from .spawn import spawn
+
+if TYPE_CHECKING:
+    from typing_extensions import TypeVarTuple, Unpack
+
+    _Ts = TypeVarTuple("_Ts")
+
+
+def get_host_platform() -> str:
+    """
+    Return a string that identifies the current platform. Use this
+    function to distinguish platform-specific build directories and
+    platform-specific built distributions.
+    """
+
+    # This function initially exposed platforms as defined in Python 3.9
+    # even with older Python versions when distutils was split out.
+    # Now it delegates to stdlib sysconfig.
+
+    return sysconfig.get_platform()
+
+
+def get_platform() -> str:
+    if os.name == 'nt':
+        TARGET_TO_PLAT = {
+            'x86': 'win32',
+            'x64': 'win-amd64',
+            'arm': 'win-arm32',
+            'arm64': 'win-arm64',
+        }
+        target = os.environ.get('VSCMD_ARG_TGT_ARCH')
+        return TARGET_TO_PLAT.get(target) or get_host_platform()
+    return get_host_platform()
+
+
+if sys.platform == 'darwin':
+    _syscfg_macosx_ver = None  # cache the version pulled from sysconfig
+MACOSX_VERSION_VAR = 'MACOSX_DEPLOYMENT_TARGET'
+
+
+def _clear_cached_macosx_ver():
+    """For testing only. Do not call."""
+    global _syscfg_macosx_ver
+    _syscfg_macosx_ver = None
+
+
+def get_macosx_target_ver_from_syscfg():
+    """Get the version of macOS latched in the Python interpreter configuration.
+    Returns the version as a string or None if can't obtain one. Cached."""
+    global _syscfg_macosx_ver
+    if _syscfg_macosx_ver is None:
+        from distutils import sysconfig
+
+        ver = sysconfig.get_config_var(MACOSX_VERSION_VAR) or ''
+        if ver:
+            _syscfg_macosx_ver = ver
+    return _syscfg_macosx_ver
+
+
+def get_macosx_target_ver():
+    """Return the version of macOS for which we are building.
+
+    The target version defaults to the version in sysconfig latched at time
+    the Python interpreter was built, unless overridden by an environment
+    variable. If neither source has a value, then None is returned"""
+
+    syscfg_ver = get_macosx_target_ver_from_syscfg()
+    env_ver = os.environ.get(MACOSX_VERSION_VAR)
+
+    if env_ver:
+        # Validate overridden version against sysconfig version, if have both.
+        # Ensure that the deployment target of the build process is not less
+        # than 10.3 if the interpreter was built for 10.3 or later.  This
+        # ensures extension modules are built with correct compatibility
+        # values, specifically LDSHARED which can use
+        # '-undefined dynamic_lookup' which only works on >= 10.3.
+        if (
+            syscfg_ver
+            and split_version(syscfg_ver) >= [10, 3]
+            and split_version(env_ver) < [10, 3]
+        ):
+            my_msg = (
+                '$' + MACOSX_VERSION_VAR + ' mismatch: '
+                f'now "{env_ver}" but "{syscfg_ver}" during configure; '
+                'must use 10.3 or later'
+            )
+            raise DistutilsPlatformError(my_msg)
+        return env_ver
+    return syscfg_ver
+
+
+def split_version(s: str) -> list[int]:
+    """Convert a dot-separated string into a list of numbers for comparisons"""
+    return [int(n) for n in s.split('.')]
+
+
+@pass_none
+def convert_path(pathname: str | os.PathLike[str]) -> str:
+    r"""
+    Allow for pathlib.Path inputs, coax to a native path string.
+
+    If None is passed, will just pass it through as
+    Setuptools relies on this behavior.
+
+    >>> convert_path(None) is None
+    True
+
+    Removes empty paths.
+
+    >>> convert_path('foo/./bar').replace('\\', '/')
+    'foo/bar'
+    """
+    return os.fspath(pathlib.PurePath(pathname))
+
+
+def change_root(
+    new_root: AnyStr | os.PathLike[AnyStr], pathname: AnyStr | os.PathLike[AnyStr]
+) -> AnyStr:
+    """Return 'pathname' with 'new_root' prepended.  If 'pathname' is
+    relative, this is equivalent to "os.path.join(new_root,pathname)".
+    Otherwise, it requires making 'pathname' relative and then joining the
+    two, which is tricky on DOS/Windows and Mac OS.
+    """
+    if os.name == 'posix':
+        if not os.path.isabs(pathname):
+            return os.path.join(new_root, pathname)
+        else:
+            return os.path.join(new_root, pathname[1:])
+
+    elif os.name == 'nt':
+        (drive, path) = os.path.splitdrive(pathname)
+        if path[0] == os.sep:
+            path = path[1:]
+        return os.path.join(new_root, path)
+
+    raise DistutilsPlatformError(f"nothing known about platform '{os.name}'")
+
+
+@functools.lru_cache
+def check_environ() -> None:
+    """Ensure that 'os.environ' has all the environment variables we
+    guarantee that users can use in config files, command-line options,
+    etc.  Currently this includes:
+      HOME - user's home directory (Unix only)
+      PLAT - description of the current platform, including hardware
+             and OS (see 'get_platform()')
+    """
+    if os.name == 'posix' and 'HOME' not in os.environ:
+        try:
+            import pwd
+
+            os.environ['HOME'] = pwd.getpwuid(os.getuid())[5]
+        except (ImportError, KeyError):
+            # bpo-10496: if the current user identifier doesn't exist in the
+            # password database, do nothing
+            pass
+
+    if 'PLAT' not in os.environ:
+        os.environ['PLAT'] = get_platform()
+
+
+def subst_vars(s, local_vars: Mapping[str, object]) -> str:
+    """
+    Perform variable substitution on 'string'.
+    Variables are indicated by format-style braces ("{var}").
+    Variable is substituted by the value found in the 'local_vars'
+    dictionary or in 'os.environ' if it's not in 'local_vars'.
+    'os.environ' is first checked/augmented to guarantee that it contains
+    certain values: see 'check_environ()'.  Raise ValueError for any
+    variables not found in either 'local_vars' or 'os.environ'.
+    """
+    check_environ()
+    lookup = dict(os.environ)
+    lookup.update((name, str(value)) for name, value in local_vars.items())
+    try:
+        return _subst_compat(s).format_map(lookup)
+    except KeyError as var:
+        raise ValueError(f"invalid variable {var}")
+
+
+def _subst_compat(s):
+    """
+    Replace shell/Perl-style variable substitution with
+    format-style. For compatibility.
+    """
+
+    def _subst(match):
+        return f'{{{match.group(1)}}}'
+
+    repl = re.sub(r'\$([a-zA-Z_][a-zA-Z_0-9]*)', _subst, s)
+    if repl != s:
+        import warnings
+
+        warnings.warn(
+            "shell/Perl-style substitutions are deprecated",
+            DeprecationWarning,
+        )
+    return repl
+
+
+def grok_environment_error(exc: object, prefix: str = "error: ") -> str:
+    # Function kept for backward compatibility.
+    # Used to try clever things with EnvironmentErrors,
+    # but nowadays str(exception) produces good messages.
+    return prefix + str(exc)
+
+
+# Needed by 'split_quoted()'
+_wordchars_re = _squote_re = _dquote_re = None
+
+
+def _init_regex():
+    global _wordchars_re, _squote_re, _dquote_re
+    _wordchars_re = re.compile(rf'[^\\\'\"{string.whitespace} ]*')
+    _squote_re = re.compile(r"'(?:[^'\\]|\\.)*'")
+    _dquote_re = re.compile(r'"(?:[^"\\]|\\.)*"')
+
+
+def split_quoted(s: str) -> list[str]:
+    """Split a string up according to Unix shell-like rules for quotes and
+    backslashes.  In short: words are delimited by spaces, as long as those
+    spaces are not escaped by a backslash, or inside a quoted string.
+    Single and double quotes are equivalent, and the quote characters can
+    be backslash-escaped.  The backslash is stripped from any two-character
+    escape sequence, leaving only the escaped character.  The quote
+    characters are stripped from any quoted string.  Returns a list of
+    words.
+    """
+
+    # This is a nice algorithm for splitting up a single string, since it
+    # doesn't require character-by-character examination.  It was a little
+    # bit of a brain-bender to get it working right, though...
+    if _wordchars_re is None:
+        _init_regex()
+
+    s = s.strip()
+    words = []
+    pos = 0
+
+    while s:
+        m = _wordchars_re.match(s, pos)
+        end = m.end()
+        if end == len(s):
+            words.append(s[:end])
+            break
+
+        if s[end] in string.whitespace:
+            # unescaped, unquoted whitespace: now
+            # we definitely have a word delimiter
+            words.append(s[:end])
+            s = s[end:].lstrip()
+            pos = 0
+
+        elif s[end] == '\\':
+            # preserve whatever is being escaped;
+            # will become part of the current word
+            s = s[:end] + s[end + 1 :]
+            pos = end + 1
+
+        else:
+            if s[end] == "'":  # slurp singly-quoted string
+                m = _squote_re.match(s, end)
+            elif s[end] == '"':  # slurp doubly-quoted string
+                m = _dquote_re.match(s, end)
+            else:
+                raise RuntimeError(f"this can't happen (bad char '{s[end]}')")
+
+            if m is None:
+                raise ValueError(f"bad string (mismatched {s[end]} quotes?)")
+
+            (beg, end) = m.span()
+            s = s[:beg] + s[beg + 1 : end - 1] + s[end:]
+            pos = m.end() - 2
+
+        if pos >= len(s):
+            words.append(s)
+            break
+
+    return words
+
+
+# split_quoted ()
+
+
+def execute(
+    func: Callable[[Unpack[_Ts]], object],
+    args: tuple[Unpack[_Ts]],
+    msg: object = None,
+    verbose: bool = False,
+    dry_run: bool = False,
+) -> None:
+    """
+    Perform some action that affects the outside world (e.g. by
+    writing to the filesystem). Such actions are special because they
+    are disabled by the 'dry_run' flag. This method handles that
+    complication; simply supply the
+    function to call and an argument tuple for it (to embody the
+    "external action" being performed) and an optional message to
+    emit.
+    """
+    if msg is None:
+        msg = f"{func.__name__}{args!r}"
+        if msg[-2:] == ',)':  # correct for singleton tuple
+            msg = msg[0:-2] + ')'
+
+    log.info(msg)
+    if not dry_run:
+        func(*args)
+
+
+def strtobool(val: str) -> bool:
+    """Convert a string representation of truth to true (1) or false (0).
+
+    True values are 'y', 'yes', 't', 'true', 'on', and '1'; false values
+    are 'n', 'no', 'f', 'false', 'off', and '0'.  Raises ValueError if
+    'val' is anything else.
+    """
+    val = val.lower()
+    if val in ('y', 'yes', 't', 'true', 'on', '1'):
+        return True
+    elif val in ('n', 'no', 'f', 'false', 'off', '0'):
+        return False
+    else:
+        raise ValueError(f"invalid truth value {val!r}")
+
+
+def byte_compile(  # noqa: C901
+    py_files: Iterable[str],
+    optimize: int = 0,
+    force: bool = False,
+    prefix: str | None = None,
+    base_dir: str | None = None,
+    verbose: bool = True,
+    dry_run: bool = False,
+    direct: bool | None = None,
+) -> None:
+    """Byte-compile a collection of Python source files to .pyc
+    files in a __pycache__ subdirectory.  'py_files' is a list
+    of files to compile; any files that don't end in ".py" are silently
+    skipped.  'optimize' must be one of the following:
+      0 - don't optimize
+      1 - normal optimization (like "python -O")
+      2 - extra optimization (like "python -OO")
+    If 'force' is true, all files are recompiled regardless of
+    timestamps.
+
+    The source filename encoded in each bytecode file defaults to the
+    filenames listed in 'py_files'; you can modify these with 'prefix' and
+    'basedir'.  'prefix' is a string that will be stripped off of each
+    source filename, and 'base_dir' is a directory name that will be
+    prepended (after 'prefix' is stripped).  You can supply either or both
+    (or neither) of 'prefix' and 'base_dir', as you wish.
+
+    If 'dry_run' is true, doesn't actually do anything that would
+    affect the filesystem.
+
+    Byte-compilation is either done directly in this interpreter process
+    with the standard py_compile module, or indirectly by writing a
+    temporary script and executing it.  Normally, you should let
+    'byte_compile()' figure out to use direct compilation or not (see
+    the source for details).  The 'direct' flag is used by the script
+    generated in indirect mode; unless you know what you're doing, leave
+    it set to None.
+    """
+
+    # nothing is done if sys.dont_write_bytecode is True
+    if sys.dont_write_bytecode:
+        raise DistutilsByteCompileError('byte-compiling is disabled.')
+
+    # First, if the caller didn't force us into direct or indirect mode,
+    # figure out which mode we should be in.  We take a conservative
+    # approach: choose direct mode *only* if the current interpreter is
+    # in debug mode and optimize is 0.  If we're not in debug mode (-O
+    # or -OO), we don't know which level of optimization this
+    # interpreter is running with, so we can't do direct
+    # byte-compilation and be certain that it's the right thing.  Thus,
+    # always compile indirectly if the current interpreter is in either
+    # optimize mode, or if either optimization level was requested by
+    # the caller.
+    if direct is None:
+        direct = __debug__ and optimize == 0
+
+    # "Indirect" byte-compilation: write a temporary script and then
+    # run it with the appropriate flags.
+    if not direct:
+        (script_fd, script_name) = tempfile.mkstemp(".py")
+        log.info("writing byte-compilation script '%s'", script_name)
+        if not dry_run:
+            script = os.fdopen(script_fd, "w", encoding='utf-8')
+
+            with script:
+                script.write(
+                    """\
+from distutils.util import byte_compile
+files = [
+"""
+                )
+
+                # XXX would be nice to write absolute filenames, just for
+                # safety's sake (script should be more robust in the face of
+                # chdir'ing before running it).  But this requires abspath'ing
+                # 'prefix' as well, and that breaks the hack in build_lib's
+                # 'byte_compile()' method that carefully tacks on a trailing
+                # slash (os.sep really) to make sure the prefix here is "just
+                # right".  This whole prefix business is rather delicate -- the
+                # problem is that it's really a directory, but I'm treating it
+                # as a dumb string, so trailing slashes and so forth matter.
+
+                script.write(",\n".join(map(repr, py_files)) + "]\n")
+                script.write(
+                    f"""
+byte_compile(files, optimize={optimize!r}, force={force!r},
+             prefix={prefix!r}, base_dir={base_dir!r},
+             verbose={verbose!r}, dry_run=False,
+             direct=True)
+"""
+                )
+
+        cmd = [sys.executable]
+        cmd.extend(subprocess._optim_args_from_interpreter_flags())
+        cmd.append(script_name)
+        spawn(cmd, dry_run=dry_run)
+        execute(os.remove, (script_name,), f"removing {script_name}", dry_run=dry_run)
+
+    # "Direct" byte-compilation: use the py_compile module to compile
+    # right here, right now.  Note that the script generated in indirect
+    # mode simply calls 'byte_compile()' in direct mode, a weird sort of
+    # cross-process recursion.  Hey, it works!
+    else:
+        from py_compile import compile
+
+        for file in py_files:
+            if file[-3:] != ".py":
+                # This lets us be lazy and not filter filenames in
+                # the "install_lib" command.
+                continue
+
+            # Terminology from the py_compile module:
+            #   cfile - byte-compiled file
+            #   dfile - purported source filename (same as 'file' by default)
+            if optimize >= 0:
+                opt = '' if optimize == 0 else optimize
+                cfile = importlib.util.cache_from_source(file, optimization=opt)
+            else:
+                cfile = importlib.util.cache_from_source(file)
+            dfile = file
+            if prefix:
+                if file[: len(prefix)] != prefix:
+                    raise ValueError(
+                        f"invalid prefix: filename {file!r} doesn't start with {prefix!r}"
+                    )
+                dfile = dfile[len(prefix) :]
+            if base_dir:
+                dfile = os.path.join(base_dir, dfile)
+
+            cfile_base = os.path.basename(cfile)
+            if direct:
+                if force or newer(file, cfile):
+                    log.info("byte-compiling %s to %s", file, cfile_base)
+                    if not dry_run:
+                        compile(file, cfile, dfile)
+                else:
+                    log.debug("skipping byte-compilation of %s to %s", file, cfile_base)
+
+
+def rfc822_escape(header: str) -> str:
+    """Return a version of the string escaped for inclusion in an
+    RFC-822 header, by ensuring there are 8 spaces space after each newline.
+    """
+    indent = 8 * " "
+    lines = header.splitlines(keepends=True)
+
+    # Emulate the behaviour of `str.split`
+    # (the terminal line break in `splitlines` does not result in an extra line):
+    ends_in_newline = lines and lines[-1].splitlines()[0] != lines[-1]
+    suffix = indent if ends_in_newline else ""
+
+    return indent.join(lines) + suffix
+
+
+def is_mingw() -> bool:
+    """Returns True if the current platform is mingw.
+
+    Python compiled with Mingw-w64 has sys.platform == 'win32' and
+    get_platform() starts with 'mingw'.
+    """
+    return sys.platform == 'win32' and get_platform().startswith('mingw')
+
+
+def is_freethreaded():
+    """Return True if the Python interpreter is built with free threading support."""
+    return bool(sysconfig.get_config_var('Py_GIL_DISABLED'))
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/version.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/version.py
new file mode 100644
index 0000000000000000000000000000000000000000..2223ee9c8cab2495034a57d4585625feb81a8330
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/version.py
@@ -0,0 +1,348 @@
+#
+# distutils/version.py
+#
+# Implements multiple version numbering conventions for the
+# Python Module Distribution Utilities.
+#
+# $Id$
+#
+
+"""Provides classes to represent module version numbers (one class for
+each style of version numbering).  There are currently two such classes
+implemented: StrictVersion and LooseVersion.
+
+Every version number class implements the following interface:
+  * the 'parse' method takes a string and parses it to some internal
+    representation; if the string is an invalid version number,
+    'parse' raises a ValueError exception
+  * the class constructor takes an optional string argument which,
+    if supplied, is passed to 'parse'
+  * __str__ reconstructs the string that was passed to 'parse' (or
+    an equivalent string -- ie. one that will generate an equivalent
+    version number instance)
+  * __repr__ generates Python code to recreate the version number instance
+  * _cmp compares the current instance with either another instance
+    of the same class or a string (which will be parsed to an instance
+    of the same class, thus must follow the same rules)
+"""
+
+import contextlib
+import re
+import warnings
+
+
+@contextlib.contextmanager
+def suppress_known_deprecation():
+    with warnings.catch_warnings(record=True) as ctx:
+        warnings.filterwarnings(
+            action='default',
+            category=DeprecationWarning,
+            message="distutils Version classes are deprecated.",
+        )
+        yield ctx
+
+
+class Version:
+    """Abstract base class for version numbering classes.  Just provides
+    constructor (__init__) and reproducer (__repr__), because those
+    seem to be the same for all version numbering classes; and route
+    rich comparisons to _cmp.
+    """
+
+    def __init__(self, vstring=None):
+        if vstring:
+            self.parse(vstring)
+        warnings.warn(
+            "distutils Version classes are deprecated. Use packaging.version instead.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+
+    def __repr__(self):
+        return f"{self.__class__.__name__} ('{self}')"
+
+    def __eq__(self, other):
+        c = self._cmp(other)
+        if c is NotImplemented:
+            return c
+        return c == 0
+
+    def __lt__(self, other):
+        c = self._cmp(other)
+        if c is NotImplemented:
+            return c
+        return c < 0
+
+    def __le__(self, other):
+        c = self._cmp(other)
+        if c is NotImplemented:
+            return c
+        return c <= 0
+
+    def __gt__(self, other):
+        c = self._cmp(other)
+        if c is NotImplemented:
+            return c
+        return c > 0
+
+    def __ge__(self, other):
+        c = self._cmp(other)
+        if c is NotImplemented:
+            return c
+        return c >= 0
+
+
+# Interface for version-number classes -- must be implemented
+# by the following classes (the concrete ones -- Version should
+# be treated as an abstract class).
+#    __init__ (string) - create and take same action as 'parse'
+#                        (string parameter is optional)
+#    parse (string)    - convert a string representation to whatever
+#                        internal representation is appropriate for
+#                        this style of version numbering
+#    __str__ (self)    - convert back to a string; should be very similar
+#                        (if not identical to) the string supplied to parse
+#    __repr__ (self)   - generate Python code to recreate
+#                        the instance
+#    _cmp (self, other) - compare two version numbers ('other' may
+#                        be an unparsed version string, or another
+#                        instance of your version class)
+
+
+class StrictVersion(Version):
+    """Version numbering for anal retentives and software idealists.
+    Implements the standard interface for version number classes as
+    described above.  A version number consists of two or three
+    dot-separated numeric components, with an optional "pre-release" tag
+    on the end.  The pre-release tag consists of the letter 'a' or 'b'
+    followed by a number.  If the numeric components of two version
+    numbers are equal, then one with a pre-release tag will always
+    be deemed earlier (lesser) than one without.
+
+    The following are valid version numbers (shown in the order that
+    would be obtained by sorting according to the supplied cmp function):
+
+        0.4       0.4.0  (these two are equivalent)
+        0.4.1
+        0.5a1
+        0.5b3
+        0.5
+        0.9.6
+        1.0
+        1.0.4a3
+        1.0.4b1
+        1.0.4
+
+    The following are examples of invalid version numbers:
+
+        1
+        2.7.2.2
+        1.3.a4
+        1.3pl1
+        1.3c4
+
+    The rationale for this version numbering system will be explained
+    in the distutils documentation.
+    """
+
+    version_re = re.compile(
+        r'^(\d+) \. (\d+) (\. (\d+))? ([ab](\d+))?$', re.VERBOSE | re.ASCII
+    )
+
+    def parse(self, vstring):
+        match = self.version_re.match(vstring)
+        if not match:
+            raise ValueError(f"invalid version number '{vstring}'")
+
+        (major, minor, patch, prerelease, prerelease_num) = match.group(1, 2, 4, 5, 6)
+
+        if patch:
+            self.version = tuple(map(int, [major, minor, patch]))
+        else:
+            self.version = tuple(map(int, [major, minor])) + (0,)
+
+        if prerelease:
+            self.prerelease = (prerelease[0], int(prerelease_num))
+        else:
+            self.prerelease = None
+
+    def __str__(self):
+        if self.version[2] == 0:
+            vstring = '.'.join(map(str, self.version[0:2]))
+        else:
+            vstring = '.'.join(map(str, self.version))
+
+        if self.prerelease:
+            vstring = vstring + self.prerelease[0] + str(self.prerelease[1])
+
+        return vstring
+
+    def _cmp(self, other):
+        if isinstance(other, str):
+            with suppress_known_deprecation():
+                other = StrictVersion(other)
+        elif not isinstance(other, StrictVersion):
+            return NotImplemented
+
+        if self.version == other.version:
+            # versions match; pre-release drives the comparison
+            return self._cmp_prerelease(other)
+
+        return -1 if self.version < other.version else 1
+
+    def _cmp_prerelease(self, other):
+        """
+        case 1: self has prerelease, other doesn't; other is greater
+        case 2: self doesn't have prerelease, other does: self is greater
+        case 3: both or neither have prerelease: compare them!
+        """
+        if self.prerelease and not other.prerelease:
+            return -1
+        elif not self.prerelease and other.prerelease:
+            return 1
+
+        if self.prerelease == other.prerelease:
+            return 0
+        elif self.prerelease < other.prerelease:
+            return -1
+        else:
+            return 1
+
+
+# end class StrictVersion
+
+
+# The rules according to Greg Stein:
+# 1) a version number has 1 or more numbers separated by a period or by
+#    sequences of letters. If only periods, then these are compared
+#    left-to-right to determine an ordering.
+# 2) sequences of letters are part of the tuple for comparison and are
+#    compared lexicographically
+# 3) recognize the numeric components may have leading zeroes
+#
+# The LooseVersion class below implements these rules: a version number
+# string is split up into a tuple of integer and string components, and
+# comparison is a simple tuple comparison.  This means that version
+# numbers behave in a predictable and obvious way, but a way that might
+# not necessarily be how people *want* version numbers to behave.  There
+# wouldn't be a problem if people could stick to purely numeric version
+# numbers: just split on period and compare the numbers as tuples.
+# However, people insist on putting letters into their version numbers;
+# the most common purpose seems to be:
+#   - indicating a "pre-release" version
+#     ('alpha', 'beta', 'a', 'b', 'pre', 'p')
+#   - indicating a post-release patch ('p', 'pl', 'patch')
+# but of course this can't cover all version number schemes, and there's
+# no way to know what a programmer means without asking him.
+#
+# The problem is what to do with letters (and other non-numeric
+# characters) in a version number.  The current implementation does the
+# obvious and predictable thing: keep them as strings and compare
+# lexically within a tuple comparison.  This has the desired effect if
+# an appended letter sequence implies something "post-release":
+# eg. "0.99" < "0.99pl14" < "1.0", and "5.001" < "5.001m" < "5.002".
+#
+# However, if letters in a version number imply a pre-release version,
+# the "obvious" thing isn't correct.  Eg. you would expect that
+# "1.5.1" < "1.5.2a2" < "1.5.2", but under the tuple/lexical comparison
+# implemented here, this just isn't so.
+#
+# Two possible solutions come to mind.  The first is to tie the
+# comparison algorithm to a particular set of semantic rules, as has
+# been done in the StrictVersion class above.  This works great as long
+# as everyone can go along with bondage and discipline.  Hopefully a
+# (large) subset of Python module programmers will agree that the
+# particular flavour of bondage and discipline provided by StrictVersion
+# provides enough benefit to be worth using, and will submit their
+# version numbering scheme to its domination.  The free-thinking
+# anarchists in the lot will never give in, though, and something needs
+# to be done to accommodate them.
+#
+# Perhaps a "moderately strict" version class could be implemented that
+# lets almost anything slide (syntactically), and makes some heuristic
+# assumptions about non-digits in version number strings.  This could
+# sink into special-case-hell, though; if I was as talented and
+# idiosyncratic as Larry Wall, I'd go ahead and implement a class that
+# somehow knows that "1.2.1" < "1.2.2a2" < "1.2.2" < "1.2.2pl3", and is
+# just as happy dealing with things like "2g6" and "1.13++".  I don't
+# think I'm smart enough to do it right though.
+#
+# In any case, I've coded the test suite for this module (see
+# ../test/test_version.py) specifically to fail on things like comparing
+# "1.2a2" and "1.2".  That's not because the *code* is doing anything
+# wrong, it's because the simple, obvious design doesn't match my
+# complicated, hairy expectations for real-world version numbers.  It
+# would be a snap to fix the test suite to say, "Yep, LooseVersion does
+# the Right Thing" (ie. the code matches the conception).  But I'd rather
+# have a conception that matches common notions about version numbers.
+
+
+class LooseVersion(Version):
+    """Version numbering for anarchists and software realists.
+    Implements the standard interface for version number classes as
+    described above.  A version number consists of a series of numbers,
+    separated by either periods or strings of letters.  When comparing
+    version numbers, the numeric components will be compared
+    numerically, and the alphabetic components lexically.  The following
+    are all valid version numbers, in no particular order:
+
+        1.5.1
+        1.5.2b2
+        161
+        3.10a
+        8.02
+        3.4j
+        1996.07.12
+        3.2.pl0
+        3.1.1.6
+        2g6
+        11g
+        0.960923
+        2.2beta29
+        1.13++
+        5.5.kw
+        2.0b1pl0
+
+    In fact, there is no such thing as an invalid version number under
+    this scheme; the rules for comparison are simple and predictable,
+    but may not always give the results you want (for some definition
+    of "want").
+    """
+
+    component_re = re.compile(r'(\d+ | [a-z]+ | \.)', re.VERBOSE)
+
+    def parse(self, vstring):
+        # I've given up on thinking I can reconstruct the version string
+        # from the parsed tuple -- so I just store the string here for
+        # use by __str__
+        self.vstring = vstring
+        components = [x for x in self.component_re.split(vstring) if x and x != '.']
+        for i, obj in enumerate(components):
+            try:
+                components[i] = int(obj)
+            except ValueError:
+                pass
+
+        self.version = components
+
+    def __str__(self):
+        return self.vstring
+
+    def __repr__(self):
+        return f"LooseVersion ('{self}')"
+
+    def _cmp(self, other):
+        if isinstance(other, str):
+            other = LooseVersion(other)
+        elif not isinstance(other, LooseVersion):
+            return NotImplemented
+
+        if self.version == other.version:
+            return 0
+        if self.version < other.version:
+            return -1
+        if self.version > other.version:
+            return 1
+
+
+# end class LooseVersion
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/versionpredicate.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/versionpredicate.py
new file mode 100644
index 0000000000000000000000000000000000000000..fe31b0ed8ef843080ea64df9f58a398d317434ad
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/versionpredicate.py
@@ -0,0 +1,175 @@
+"""Module for parsing and testing package version predicate strings."""
+
+import operator
+import re
+
+from . import version
+
+re_validPackage = re.compile(r"(?i)^\s*([a-z_]\w*(?:\.[a-z_]\w*)*)(.*)", re.ASCII)
+# (package) (rest)
+
+re_paren = re.compile(r"^\s*\((.*)\)\s*$")  # (list) inside of parentheses
+re_splitComparison = re.compile(r"^\s*(<=|>=|<|>|!=|==)\s*([^\s,]+)\s*$")
+# (comp) (version)
+
+
+def splitUp(pred):
+    """Parse a single version comparison.
+
+    Return (comparison string, StrictVersion)
+    """
+    res = re_splitComparison.match(pred)
+    if not res:
+        raise ValueError(f"bad package restriction syntax: {pred!r}")
+    comp, verStr = res.groups()
+    with version.suppress_known_deprecation():
+        other = version.StrictVersion(verStr)
+    return (comp, other)
+
+
+compmap = {
+    "<": operator.lt,
+    "<=": operator.le,
+    "==": operator.eq,
+    ">": operator.gt,
+    ">=": operator.ge,
+    "!=": operator.ne,
+}
+
+
+class VersionPredicate:
+    """Parse and test package version predicates.
+
+    >>> v = VersionPredicate('pyepat.abc (>1.0, <3333.3a1, !=1555.1b3)')
+
+    The `name` attribute provides the full dotted name that is given::
+
+    >>> v.name
+    'pyepat.abc'
+
+    The str() of a `VersionPredicate` provides a normalized
+    human-readable version of the expression::
+
+    >>> print(v)
+    pyepat.abc (> 1.0, < 3333.3a1, != 1555.1b3)
+
+    The `satisfied_by()` method can be used to determine with a given
+    version number is included in the set described by the version
+    restrictions::
+
+    >>> v.satisfied_by('1.1')
+    True
+    >>> v.satisfied_by('1.4')
+    True
+    >>> v.satisfied_by('1.0')
+    False
+    >>> v.satisfied_by('4444.4')
+    False
+    >>> v.satisfied_by('1555.1b3')
+    False
+
+    `VersionPredicate` is flexible in accepting extra whitespace::
+
+    >>> v = VersionPredicate(' pat( ==  0.1  )  ')
+    >>> v.name
+    'pat'
+    >>> v.satisfied_by('0.1')
+    True
+    >>> v.satisfied_by('0.2')
+    False
+
+    If any version numbers passed in do not conform to the
+    restrictions of `StrictVersion`, a `ValueError` is raised::
+
+    >>> v = VersionPredicate('p1.p2.p3.p4(>=1.0, <=1.3a1, !=1.2zb3)')
+    Traceback (most recent call last):
+      ...
+    ValueError: invalid version number '1.2zb3'
+
+    It the module or package name given does not conform to what's
+    allowed as a legal module or package name, `ValueError` is
+    raised::
+
+    >>> v = VersionPredicate('foo-bar')
+    Traceback (most recent call last):
+      ...
+    ValueError: expected parenthesized list: '-bar'
+
+    >>> v = VersionPredicate('foo bar (12.21)')
+    Traceback (most recent call last):
+      ...
+    ValueError: expected parenthesized list: 'bar (12.21)'
+
+    """
+
+    def __init__(self, versionPredicateStr):
+        """Parse a version predicate string."""
+        # Fields:
+        #    name:  package name
+        #    pred:  list of (comparison string, StrictVersion)
+
+        versionPredicateStr = versionPredicateStr.strip()
+        if not versionPredicateStr:
+            raise ValueError("empty package restriction")
+        match = re_validPackage.match(versionPredicateStr)
+        if not match:
+            raise ValueError(f"bad package name in {versionPredicateStr!r}")
+        self.name, paren = match.groups()
+        paren = paren.strip()
+        if paren:
+            match = re_paren.match(paren)
+            if not match:
+                raise ValueError(f"expected parenthesized list: {paren!r}")
+            str = match.groups()[0]
+            self.pred = [splitUp(aPred) for aPred in str.split(",")]
+            if not self.pred:
+                raise ValueError(f"empty parenthesized list in {versionPredicateStr!r}")
+        else:
+            self.pred = []
+
+    def __str__(self):
+        if self.pred:
+            seq = [cond + " " + str(ver) for cond, ver in self.pred]
+            return self.name + " (" + ", ".join(seq) + ")"
+        else:
+            return self.name
+
+    def satisfied_by(self, version):
+        """True if version is compatible with all the predicates in self.
+        The parameter version must be acceptable to the StrictVersion
+        constructor.  It may be either a string or StrictVersion.
+        """
+        for cond, ver in self.pred:
+            if not compmap[cond](version, ver):
+                return False
+        return True
+
+
+_provision_rx = None
+
+
+def split_provision(value):
+    """Return the name and optional version number of a provision.
+
+    The version number, if given, will be returned as a `StrictVersion`
+    instance, otherwise it will be `None`.
+
+    >>> split_provision('mypkg')
+    ('mypkg', None)
+    >>> split_provision(' mypkg( 1.2 ) ')
+    ('mypkg', StrictVersion ('1.2'))
+    """
+    global _provision_rx
+    if _provision_rx is None:
+        _provision_rx = re.compile(
+            r"([a-zA-Z_]\w*(?:\.[a-zA-Z_]\w*)*)(?:\s*\(\s*([^)\s]+)\s*\))?$", re.ASCII
+        )
+    value = value.strip()
+    m = _provision_rx.match(value)
+    if not m:
+        raise ValueError(f"illegal provides specification: {value!r}")
+    ver = m.group(2) or None
+    if ver:
+        with version.suppress_known_deprecation():
+            ver = version.StrictVersion(ver)
+    return m.group(1), ver
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/zosccompiler.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/zosccompiler.py
new file mode 100644
index 0000000000000000000000000000000000000000..e49630ac6ed8cad62c4d2ff8361758519e6dc83b
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_distutils/zosccompiler.py
@@ -0,0 +1,3 @@
+from .compilers.C import zos
+
+zOSCCompiler = zos.Compiler
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/_vendor/typing_extensions.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_vendor/typing_extensions.py
new file mode 100644
index 0000000000000000000000000000000000000000..dec429ca8723950097217d2140dd8daccb064e2d
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/_vendor/typing_extensions.py
@@ -0,0 +1,3641 @@
+import abc
+import collections
+import collections.abc
+import contextlib
+import functools
+import inspect
+import operator
+import sys
+import types as _types
+import typing
+import warnings
+
+__all__ = [
+    # Super-special typing primitives.
+    'Any',
+    'ClassVar',
+    'Concatenate',
+    'Final',
+    'LiteralString',
+    'ParamSpec',
+    'ParamSpecArgs',
+    'ParamSpecKwargs',
+    'Self',
+    'Type',
+    'TypeVar',
+    'TypeVarTuple',
+    'Unpack',
+
+    # ABCs (from collections.abc).
+    'Awaitable',
+    'AsyncIterator',
+    'AsyncIterable',
+    'Coroutine',
+    'AsyncGenerator',
+    'AsyncContextManager',
+    'Buffer',
+    'ChainMap',
+
+    # Concrete collection types.
+    'ContextManager',
+    'Counter',
+    'Deque',
+    'DefaultDict',
+    'NamedTuple',
+    'OrderedDict',
+    'TypedDict',
+
+    # Structural checks, a.k.a. protocols.
+    'SupportsAbs',
+    'SupportsBytes',
+    'SupportsComplex',
+    'SupportsFloat',
+    'SupportsIndex',
+    'SupportsInt',
+    'SupportsRound',
+
+    # One-off things.
+    'Annotated',
+    'assert_never',
+    'assert_type',
+    'clear_overloads',
+    'dataclass_transform',
+    'deprecated',
+    'Doc',
+    'get_overloads',
+    'final',
+    'get_args',
+    'get_origin',
+    'get_original_bases',
+    'get_protocol_members',
+    'get_type_hints',
+    'IntVar',
+    'is_protocol',
+    'is_typeddict',
+    'Literal',
+    'NewType',
+    'overload',
+    'override',
+    'Protocol',
+    'reveal_type',
+    'runtime',
+    'runtime_checkable',
+    'Text',
+    'TypeAlias',
+    'TypeAliasType',
+    'TypeGuard',
+    'TypeIs',
+    'TYPE_CHECKING',
+    'Never',
+    'NoReturn',
+    'ReadOnly',
+    'Required',
+    'NotRequired',
+
+    # Pure aliases, have always been in typing
+    'AbstractSet',
+    'AnyStr',
+    'BinaryIO',
+    'Callable',
+    'Collection',
+    'Container',
+    'Dict',
+    'ForwardRef',
+    'FrozenSet',
+    'Generator',
+    'Generic',
+    'Hashable',
+    'IO',
+    'ItemsView',
+    'Iterable',
+    'Iterator',
+    'KeysView',
+    'List',
+    'Mapping',
+    'MappingView',
+    'Match',
+    'MutableMapping',
+    'MutableSequence',
+    'MutableSet',
+    'NoDefault',
+    'Optional',
+    'Pattern',
+    'Reversible',
+    'Sequence',
+    'Set',
+    'Sized',
+    'TextIO',
+    'Tuple',
+    'Union',
+    'ValuesView',
+    'cast',
+    'no_type_check',
+    'no_type_check_decorator',
+]
+
+# for backward compatibility
+PEP_560 = True
+GenericMeta = type
+_PEP_696_IMPLEMENTED = sys.version_info >= (3, 13, 0, "beta")
+
+# The functions below are modified copies of typing internal helpers.
+# They are needed by _ProtocolMeta and they provide support for PEP 646.
+
+
+class _Sentinel:
+    def __repr__(self):
+        return "<sentinel>"
+
+
+_marker = _Sentinel()
+
+
+if sys.version_info >= (3, 10):
+    def _should_collect_from_parameters(t):
+        return isinstance(
+            t, (typing._GenericAlias, _types.GenericAlias, _types.UnionType)
+        )
+elif sys.version_info >= (3, 9):
+    def _should_collect_from_parameters(t):
+        return isinstance(t, (typing._GenericAlias, _types.GenericAlias))
+else:
+    def _should_collect_from_parameters(t):
+        return isinstance(t, typing._GenericAlias) and not t._special
+
+
+NoReturn = typing.NoReturn
+
+# Some unconstrained type variables.  These are used by the container types.
+# (These are not for export.)
+T = typing.TypeVar('T')  # Any type.
+KT = typing.TypeVar('KT')  # Key type.
+VT = typing.TypeVar('VT')  # Value type.
+T_co = typing.TypeVar('T_co', covariant=True)  # Any type covariant containers.
+T_contra = typing.TypeVar('T_contra', contravariant=True)  # Ditto contravariant.
+
+
+if sys.version_info >= (3, 11):
+    from typing import Any
+else:
+
+    class _AnyMeta(type):
+        def __instancecheck__(self, obj):
+            if self is Any:
+                raise TypeError("typing_extensions.Any cannot be used with isinstance()")
+            return super().__instancecheck__(obj)
+
+        def __repr__(self):
+            if self is Any:
+                return "typing_extensions.Any"
+            return super().__repr__()
+
+    class Any(metaclass=_AnyMeta):
+        """Special type indicating an unconstrained type.
+        - Any is compatible with every type.
+        - Any assumed to have all methods.
+        - All values assumed to be instances of Any.
+        Note that all the above statements are true from the point of view of
+        static type checkers. At runtime, Any should not be used with instance
+        checks.
+        """
+        def __new__(cls, *args, **kwargs):
+            if cls is Any:
+                raise TypeError("Any cannot be instantiated")
+            return super().__new__(cls, *args, **kwargs)
+
+
+ClassVar = typing.ClassVar
+
+
+class _ExtensionsSpecialForm(typing._SpecialForm, _root=True):
+    def __repr__(self):
+        return 'typing_extensions.' + self._name
+
+
+Final = typing.Final
+
+if sys.version_info >= (3, 11):
+    final = typing.final
+else:
+    # @final exists in 3.8+, but we backport it for all versions
+    # before 3.11 to keep support for the __final__ attribute.
+    # See https://bugs.python.org/issue46342
+    def final(f):
+        """This decorator can be used to indicate to type checkers that
+        the decorated method cannot be overridden, and decorated class
+        cannot be subclassed. For example:
+
+            class Base:
+                @final
+                def done(self) -> None:
+                    ...
+            class Sub(Base):
+                def done(self) -> None:  # Error reported by type checker
+                    ...
+            @final
+            class Leaf:
+                ...
+            class Other(Leaf):  # Error reported by type checker
+                ...
+
+        There is no runtime checking of these properties. The decorator
+        sets the ``__final__`` attribute to ``True`` on the decorated object
+        to allow runtime introspection.
+        """
+        try:
+            f.__final__ = True
+        except (AttributeError, TypeError):
+            # Skip the attribute silently if it is not writable.
+            # AttributeError happens if the object has __slots__ or a
+            # read-only property, TypeError if it's a builtin class.
+            pass
+        return f
+
+
+def IntVar(name):
+    return typing.TypeVar(name)
+
+
+# A Literal bug was fixed in 3.11.0, 3.10.1 and 3.9.8
+if sys.version_info >= (3, 10, 1):
+    Literal = typing.Literal
+else:
+    def _flatten_literal_params(parameters):
+        """An internal helper for Literal creation: flatten Literals among parameters"""
+        params = []
+        for p in parameters:
+            if isinstance(p, _LiteralGenericAlias):
+                params.extend(p.__args__)
+            else:
+                params.append(p)
+        return tuple(params)
+
+    def _value_and_type_iter(params):
+        for p in params:
+            yield p, type(p)
+
+    class _LiteralGenericAlias(typing._GenericAlias, _root=True):
+        def __eq__(self, other):
+            if not isinstance(other, _LiteralGenericAlias):
+                return NotImplemented
+            these_args_deduped = set(_value_and_type_iter(self.__args__))
+            other_args_deduped = set(_value_and_type_iter(other.__args__))
+            return these_args_deduped == other_args_deduped
+
+        def __hash__(self):
+            return hash(frozenset(_value_and_type_iter(self.__args__)))
+
+    class _LiteralForm(_ExtensionsSpecialForm, _root=True):
+        def __init__(self, doc: str):
+            self._name = 'Literal'
+            self._doc = self.__doc__ = doc
+
+        def __getitem__(self, parameters):
+            if not isinstance(parameters, tuple):
+                parameters = (parameters,)
+
+            parameters = _flatten_literal_params(parameters)
+
+            val_type_pairs = list(_value_and_type_iter(parameters))
+            try:
+                deduped_pairs = set(val_type_pairs)
+            except TypeError:
+                # unhashable parameters
+                pass
+            else:
+                # similar logic to typing._deduplicate on Python 3.9+
+                if len(deduped_pairs) < len(val_type_pairs):
+                    new_parameters = []
+                    for pair in val_type_pairs:
+                        if pair in deduped_pairs:
+                            new_parameters.append(pair[0])
+                            deduped_pairs.remove(pair)
+                    assert not deduped_pairs, deduped_pairs
+                    parameters = tuple(new_parameters)
+
+            return _LiteralGenericAlias(self, parameters)
+
+    Literal = _LiteralForm(doc="""\
+                           A type that can be used to indicate to type checkers
+                           that the corresponding value has a value literally equivalent
+                           to the provided parameter. For example:
+
+                               var: Literal[4] = 4
+
+                           The type checker understands that 'var' is literally equal to
+                           the value 4 and no other value.
+
+                           Literal[...] cannot be subclassed. There is no runtime
+                           checking verifying that the parameter is actually a value
+                           instead of a type.""")
+
+
+_overload_dummy = typing._overload_dummy
+
+
+if hasattr(typing, "get_overloads"):  # 3.11+
+    overload = typing.overload
+    get_overloads = typing.get_overloads
+    clear_overloads = typing.clear_overloads
+else:
+    # {module: {qualname: {firstlineno: func}}}
+    _overload_registry = collections.defaultdict(
+        functools.partial(collections.defaultdict, dict)
+    )
+
+    def overload(func):
+        """Decorator for overloaded functions/methods.
+
+        In a stub file, place two or more stub definitions for the same
+        function in a row, each decorated with @overload.  For example:
+
+        @overload
+        def utf8(value: None) -> None: ...
+        @overload
+        def utf8(value: bytes) -> bytes: ...
+        @overload
+        def utf8(value: str) -> bytes: ...
+
+        In a non-stub file (i.e. a regular .py file), do the same but
+        follow it with an implementation.  The implementation should *not*
+        be decorated with @overload.  For example:
+
+        @overload
+        def utf8(value: None) -> None: ...
+        @overload
+        def utf8(value: bytes) -> bytes: ...
+        @overload
+        def utf8(value: str) -> bytes: ...
+        def utf8(value):
+            # implementation goes here
+
+        The overloads for a function can be retrieved at runtime using the
+        get_overloads() function.
+        """
+        # classmethod and staticmethod
+        f = getattr(func, "__func__", func)
+        try:
+            _overload_registry[f.__module__][f.__qualname__][
+                f.__code__.co_firstlineno
+            ] = func
+        except AttributeError:
+            # Not a normal function; ignore.
+            pass
+        return _overload_dummy
+
+    def get_overloads(func):
+        """Return all defined overloads for *func* as a sequence."""
+        # classmethod and staticmethod
+        f = getattr(func, "__func__", func)
+        if f.__module__ not in _overload_registry:
+            return []
+        mod_dict = _overload_registry[f.__module__]
+        if f.__qualname__ not in mod_dict:
+            return []
+        return list(mod_dict[f.__qualname__].values())
+
+    def clear_overloads():
+        """Clear all overloads in the registry."""
+        _overload_registry.clear()
+
+
+# This is not a real generic class.  Don't use outside annotations.
+Type = typing.Type
+
+# Various ABCs mimicking those in collections.abc.
+# A few are simply re-exported for completeness.
+Awaitable = typing.Awaitable
+Coroutine = typing.Coroutine
+AsyncIterable = typing.AsyncIterable
+AsyncIterator = typing.AsyncIterator
+Deque = typing.Deque
+DefaultDict = typing.DefaultDict
+OrderedDict = typing.OrderedDict
+Counter = typing.Counter
+ChainMap = typing.ChainMap
+Text = typing.Text
+TYPE_CHECKING = typing.TYPE_CHECKING
+
+
+if sys.version_info >= (3, 13, 0, "beta"):
+    from typing import AsyncContextManager, AsyncGenerator, ContextManager, Generator
+else:
+    def _is_dunder(attr):
+        return attr.startswith('__') and attr.endswith('__')
+
+    # Python <3.9 doesn't have typing._SpecialGenericAlias
+    _special_generic_alias_base = getattr(
+        typing, "_SpecialGenericAlias", typing._GenericAlias
+    )
+
+    class _SpecialGenericAlias(_special_generic_alias_base, _root=True):
+        def __init__(self, origin, nparams, *, inst=True, name=None, defaults=()):
+            if _special_generic_alias_base is typing._GenericAlias:
+                # Python <3.9
+                self.__origin__ = origin
+                self._nparams = nparams
+                super().__init__(origin, nparams, special=True, inst=inst, name=name)
+            else:
+                # Python >= 3.9
+                super().__init__(origin, nparams, inst=inst, name=name)
+            self._defaults = defaults
+
+        def __setattr__(self, attr, val):
+            allowed_attrs = {'_name', '_inst', '_nparams', '_defaults'}
+            if _special_generic_alias_base is typing._GenericAlias:
+                # Python <3.9
+                allowed_attrs.add("__origin__")
+            if _is_dunder(attr) or attr in allowed_attrs:
+                object.__setattr__(self, attr, val)
+            else:
+                setattr(self.__origin__, attr, val)
+
+        @typing._tp_cache
+        def __getitem__(self, params):
+            if not isinstance(params, tuple):
+                params = (params,)
+            msg = "Parameters to generic types must be types."
+            params = tuple(typing._type_check(p, msg) for p in params)
+            if (
+                self._defaults
+                and len(params) < self._nparams
+                and len(params) + len(self._defaults) >= self._nparams
+            ):
+                params = (*params, *self._defaults[len(params) - self._nparams:])
+            actual_len = len(params)
+
+            if actual_len != self._nparams:
+                if self._defaults:
+                    expected = f"at least {self._nparams - len(self._defaults)}"
+                else:
+                    expected = str(self._nparams)
+                if not self._nparams:
+                    raise TypeError(f"{self} is not a generic class")
+                raise TypeError(
+                    f"Too {'many' if actual_len > self._nparams else 'few'}"
+                    f" arguments for {self};"
+                    f" actual {actual_len}, expected {expected}"
+                )
+            return self.copy_with(params)
+
+    _NoneType = type(None)
+    Generator = _SpecialGenericAlias(
+        collections.abc.Generator, 3, defaults=(_NoneType, _NoneType)
+    )
+    AsyncGenerator = _SpecialGenericAlias(
+        collections.abc.AsyncGenerator, 2, defaults=(_NoneType,)
+    )
+    ContextManager = _SpecialGenericAlias(
+        contextlib.AbstractContextManager,
+        2,
+        name="ContextManager",
+        defaults=(typing.Optional[bool],)
+    )
+    AsyncContextManager = _SpecialGenericAlias(
+        contextlib.AbstractAsyncContextManager,
+        2,
+        name="AsyncContextManager",
+        defaults=(typing.Optional[bool],)
+    )
+
+
+_PROTO_ALLOWLIST = {
+    'collections.abc': [
+        'Callable', 'Awaitable', 'Iterable', 'Iterator', 'AsyncIterable',
+        'Hashable', 'Sized', 'Container', 'Collection', 'Reversible', 'Buffer',
+    ],
+    'contextlib': ['AbstractContextManager', 'AbstractAsyncContextManager'],
+    'typing_extensions': ['Buffer'],
+}
+
+
+_EXCLUDED_ATTRS = frozenset(typing.EXCLUDED_ATTRIBUTES) | {
+    "__match_args__", "__protocol_attrs__", "__non_callable_proto_members__",
+    "__final__",
+}
+
+
+def _get_protocol_attrs(cls):
+    attrs = set()
+    for base in cls.__mro__[:-1]:  # without object
+        if base.__name__ in {'Protocol', 'Generic'}:
+            continue
+        annotations = getattr(base, '__annotations__', {})
+        for attr in (*base.__dict__, *annotations):
+            if (not attr.startswith('_abc_') and attr not in _EXCLUDED_ATTRS):
+                attrs.add(attr)
+    return attrs
+
+
+def _caller(depth=2):
+    try:
+        return sys._getframe(depth).f_globals.get('__name__', '__main__')
+    except (AttributeError, ValueError):  # For platforms without _getframe()
+        return None
+
+
+# `__match_args__` attribute was removed from protocol members in 3.13,
+# we want to backport this change to older Python versions.
+if sys.version_info >= (3, 13):
+    Protocol = typing.Protocol
+else:
+    def _allow_reckless_class_checks(depth=3):
+        """Allow instance and class checks for special stdlib modules.
+        The abc and functools modules indiscriminately call isinstance() and
+        issubclass() on the whole MRO of a user class, which may contain protocols.
+        """
+        return _caller(depth) in {'abc', 'functools', None}
+
+    def _no_init(self, *args, **kwargs):
+        if type(self)._is_protocol:
+            raise TypeError('Protocols cannot be instantiated')
+
+    def _type_check_issubclass_arg_1(arg):
+        """Raise TypeError if `arg` is not an instance of `type`
+        in `issubclass(arg, <protocol>)`.
+
+        In most cases, this is verified by type.__subclasscheck__.
+        Checking it again unnecessarily would slow down issubclass() checks,
+        so, we don't perform this check unless we absolutely have to.
+
+        For various error paths, however,
+        we want to ensure that *this* error message is shown to the user
+        where relevant, rather than a typing.py-specific error message.
+        """
+        if not isinstance(arg, type):
+            # Same error message as for issubclass(1, int).
+            raise TypeError('issubclass() arg 1 must be a class')
+
+    # Inheriting from typing._ProtocolMeta isn't actually desirable,
+    # but is necessary to allow typing.Protocol and typing_extensions.Protocol
+    # to mix without getting TypeErrors about "metaclass conflict"
+    class _ProtocolMeta(type(typing.Protocol)):
+        # This metaclass is somewhat unfortunate,
+        # but is necessary for several reasons...
+        #
+        # NOTE: DO NOT call super() in any methods in this class
+        # That would call the methods on typing._ProtocolMeta on Python 3.8-3.11
+        # and those are slow
+        def __new__(mcls, name, bases, namespace, **kwargs):
+            if name == "Protocol" and len(bases) < 2:
+                pass
+            elif {Protocol, typing.Protocol} & set(bases):
+                for base in bases:
+                    if not (
+                        base in {object, typing.Generic, Protocol, typing.Protocol}
+                        or base.__name__ in _PROTO_ALLOWLIST.get(base.__module__, [])
+                        or is_protocol(base)
+                    ):
+                        raise TypeError(
+                            f"Protocols can only inherit from other protocols, "
+                            f"got {base!r}"
+                        )
+            return abc.ABCMeta.__new__(mcls, name, bases, namespace, **kwargs)
+
+        def __init__(cls, *args, **kwargs):
+            abc.ABCMeta.__init__(cls, *args, **kwargs)
+            if getattr(cls, "_is_protocol", False):
+                cls.__protocol_attrs__ = _get_protocol_attrs(cls)
+
+        def __subclasscheck__(cls, other):
+            if cls is Protocol:
+                return type.__subclasscheck__(cls, other)
+            if (
+                getattr(cls, '_is_protocol', False)
+                and not _allow_reckless_class_checks()
+            ):
+                if not getattr(cls, '_is_runtime_protocol', False):
+                    _type_check_issubclass_arg_1(other)
+                    raise TypeError(
+                        "Instance and class checks can only be used with "
+                        "@runtime_checkable protocols"
+                    )
+                if (
+                    # this attribute is set by @runtime_checkable:
+                    cls.__non_callable_proto_members__
+                    and cls.__dict__.get("__subclasshook__") is _proto_hook
+                ):
+                    _type_check_issubclass_arg_1(other)
+                    non_method_attrs = sorted(cls.__non_callable_proto_members__)
+                    raise TypeError(
+                        "Protocols with non-method members don't support issubclass()."
+                        f" Non-method members: {str(non_method_attrs)[1:-1]}."
+                    )
+            return abc.ABCMeta.__subclasscheck__(cls, other)
+
+        def __instancecheck__(cls, instance):
+            # We need this method for situations where attributes are
+            # assigned in __init__.
+            if cls is Protocol:
+                return type.__instancecheck__(cls, instance)
+            if not getattr(cls, "_is_protocol", False):
+                # i.e., it's a concrete subclass of a protocol
+                return abc.ABCMeta.__instancecheck__(cls, instance)
+
+            if (
+                not getattr(cls, '_is_runtime_protocol', False) and
+                not _allow_reckless_class_checks()
+            ):
+                raise TypeError("Instance and class checks can only be used with"
+                                " @runtime_checkable protocols")
+
+            if abc.ABCMeta.__instancecheck__(cls, instance):
+                return True
+
+            for attr in cls.__protocol_attrs__:
+                try:
+                    val = inspect.getattr_static(instance, attr)
+                except AttributeError:
+                    break
+                # this attribute is set by @runtime_checkable:
+                if val is None and attr not in cls.__non_callable_proto_members__:
+                    break
+            else:
+                return True
+
+            return False
+
+        def __eq__(cls, other):
+            # Hack so that typing.Generic.__class_getitem__
+            # treats typing_extensions.Protocol
+            # as equivalent to typing.Protocol
+            if abc.ABCMeta.__eq__(cls, other) is True:
+                return True
+            return cls is Protocol and other is typing.Protocol
+
+        # This has to be defined, or the abc-module cache
+        # complains about classes with this metaclass being unhashable,
+        # if we define only __eq__!
+        def __hash__(cls) -> int:
+            return type.__hash__(cls)
+
+    @classmethod
+    def _proto_hook(cls, other):
+        if not cls.__dict__.get('_is_protocol', False):
+            return NotImplemented
+
+        for attr in cls.__protocol_attrs__:
+            for base in other.__mro__:
+                # Check if the members appears in the class dictionary...
+                if attr in base.__dict__:
+                    if base.__dict__[attr] is None:
+                        return NotImplemented
+                    break
+
+                # ...or in annotations, if it is a sub-protocol.
+                annotations = getattr(base, '__annotations__', {})
+                if (
+                    isinstance(annotations, collections.abc.Mapping)
+                    and attr in annotations
+                    and is_protocol(other)
+                ):
+                    break
+            else:
+                return NotImplemented
+        return True
+
+    class Protocol(typing.Generic, metaclass=_ProtocolMeta):
+        __doc__ = typing.Protocol.__doc__
+        __slots__ = ()
+        _is_protocol = True
+        _is_runtime_protocol = False
+
+        def __init_subclass__(cls, *args, **kwargs):
+            super().__init_subclass__(*args, **kwargs)
+
+            # Determine if this is a protocol or a concrete subclass.
+            if not cls.__dict__.get('_is_protocol', False):
+                cls._is_protocol = any(b is Protocol for b in cls.__bases__)
+
+            # Set (or override) the protocol subclass hook.
+            if '__subclasshook__' not in cls.__dict__:
+                cls.__subclasshook__ = _proto_hook
+
+            # Prohibit instantiation for protocol classes
+            if cls._is_protocol and cls.__init__ is Protocol.__init__:
+                cls.__init__ = _no_init
+
+
+if sys.version_info >= (3, 13):
+    runtime_checkable = typing.runtime_checkable
+else:
+    def runtime_checkable(cls):
+        """Mark a protocol class as a runtime protocol.
+
+        Such protocol can be used with isinstance() and issubclass().
+        Raise TypeError if applied to a non-protocol class.
+        This allows a simple-minded structural check very similar to
+        one trick ponies in collections.abc such as Iterable.
+
+        For example::
+
+            @runtime_checkable
+            class Closable(Protocol):
+                def close(self): ...
+
+            assert isinstance(open('/some/file'), Closable)
+
+        Warning: this will check only the presence of the required methods,
+        not their type signatures!
+        """
+        if not issubclass(cls, typing.Generic) or not getattr(cls, '_is_protocol', False):
+            raise TypeError(f'@runtime_checkable can be only applied to protocol classes,'
+                            f' got {cls!r}')
+        cls._is_runtime_protocol = True
+
+        # typing.Protocol classes on <=3.11 break if we execute this block,
+        # because typing.Protocol classes on <=3.11 don't have a
+        # `__protocol_attrs__` attribute, and this block relies on the
+        # `__protocol_attrs__` attribute. Meanwhile, typing.Protocol classes on 3.12.2+
+        # break if we *don't* execute this block, because *they* assume that all
+        # protocol classes have a `__non_callable_proto_members__` attribute
+        # (which this block sets)
+        if isinstance(cls, _ProtocolMeta) or sys.version_info >= (3, 12, 2):
+            # PEP 544 prohibits using issubclass()
+            # with protocols that have non-method members.
+            # See gh-113320 for why we compute this attribute here,
+            # rather than in `_ProtocolMeta.__init__`
+            cls.__non_callable_proto_members__ = set()
+            for attr in cls.__protocol_attrs__:
+                try:
+                    is_callable = callable(getattr(cls, attr, None))
+                except Exception as e:
+                    raise TypeError(
+                        f"Failed to determine whether protocol member {attr!r} "
+                        "is a method member"
+                    ) from e
+                else:
+                    if not is_callable:
+                        cls.__non_callable_proto_members__.add(attr)
+
+        return cls
+
+
+# The "runtime" alias exists for backwards compatibility.
+runtime = runtime_checkable
+
+
+# Our version of runtime-checkable protocols is faster on Python 3.8-3.11
+if sys.version_info >= (3, 12):
+    SupportsInt = typing.SupportsInt
+    SupportsFloat = typing.SupportsFloat
+    SupportsComplex = typing.SupportsComplex
+    SupportsBytes = typing.SupportsBytes
+    SupportsIndex = typing.SupportsIndex
+    SupportsAbs = typing.SupportsAbs
+    SupportsRound = typing.SupportsRound
+else:
+    @runtime_checkable
+    class SupportsInt(Protocol):
+        """An ABC with one abstract method __int__."""
+        __slots__ = ()
+
+        @abc.abstractmethod
+        def __int__(self) -> int:
+            pass
+
+    @runtime_checkable
+    class SupportsFloat(Protocol):
+        """An ABC with one abstract method __float__."""
+        __slots__ = ()
+
+        @abc.abstractmethod
+        def __float__(self) -> float:
+            pass
+
+    @runtime_checkable
+    class SupportsComplex(Protocol):
+        """An ABC with one abstract method __complex__."""
+        __slots__ = ()
+
+        @abc.abstractmethod
+        def __complex__(self) -> complex:
+            pass
+
+    @runtime_checkable
+    class SupportsBytes(Protocol):
+        """An ABC with one abstract method __bytes__."""
+        __slots__ = ()
+
+        @abc.abstractmethod
+        def __bytes__(self) -> bytes:
+            pass
+
+    @runtime_checkable
+    class SupportsIndex(Protocol):
+        __slots__ = ()
+
+        @abc.abstractmethod
+        def __index__(self) -> int:
+            pass
+
+    @runtime_checkable
+    class SupportsAbs(Protocol[T_co]):
+        """
+        An ABC with one abstract method __abs__ that is covariant in its return type.
+        """
+        __slots__ = ()
+
+        @abc.abstractmethod
+        def __abs__(self) -> T_co:
+            pass
+
+    @runtime_checkable
+    class SupportsRound(Protocol[T_co]):
+        """
+        An ABC with one abstract method __round__ that is covariant in its return type.
+        """
+        __slots__ = ()
+
+        @abc.abstractmethod
+        def __round__(self, ndigits: int = 0) -> T_co:
+            pass
+
+
+def _ensure_subclassable(mro_entries):
+    def inner(func):
+        if sys.implementation.name == "pypy" and sys.version_info < (3, 9):
+            cls_dict = {
+                "__call__": staticmethod(func),
+                "__mro_entries__": staticmethod(mro_entries)
+            }
+            t = type(func.__name__, (), cls_dict)
+            return functools.update_wrapper(t(), func)
+        else:
+            func.__mro_entries__ = mro_entries
+            return func
+    return inner
+
+
+# Update this to something like >=3.13.0b1 if and when
+# PEP 728 is implemented in CPython
+_PEP_728_IMPLEMENTED = False
+
+if _PEP_728_IMPLEMENTED:
+    # The standard library TypedDict in Python 3.8 does not store runtime information
+    # about which (if any) keys are optional.  See https://bugs.python.org/issue38834
+    # The standard library TypedDict in Python 3.9.0/1 does not honour the "total"
+    # keyword with old-style TypedDict().  See https://bugs.python.org/issue42059
+    # The standard library TypedDict below Python 3.11 does not store runtime
+    # information about optional and required keys when using Required or NotRequired.
+    # Generic TypedDicts are also impossible using typing.TypedDict on Python <3.11.
+    # Aaaand on 3.12 we add __orig_bases__ to TypedDict
+    # to enable better runtime introspection.
+    # On 3.13 we deprecate some odd ways of creating TypedDicts.
+    # Also on 3.13, PEP 705 adds the ReadOnly[] qualifier.
+    # PEP 728 (still pending) makes more changes.
+    TypedDict = typing.TypedDict
+    _TypedDictMeta = typing._TypedDictMeta
+    is_typeddict = typing.is_typeddict
+else:
+    # 3.10.0 and later
+    _TAKES_MODULE = "module" in inspect.signature(typing._type_check).parameters
+
+    def _get_typeddict_qualifiers(annotation_type):
+        while True:
+            annotation_origin = get_origin(annotation_type)
+            if annotation_origin is Annotated:
+                annotation_args = get_args(annotation_type)
+                if annotation_args:
+                    annotation_type = annotation_args[0]
+                else:
+                    break
+            elif annotation_origin is Required:
+                yield Required
+                annotation_type, = get_args(annotation_type)
+            elif annotation_origin is NotRequired:
+                yield NotRequired
+                annotation_type, = get_args(annotation_type)
+            elif annotation_origin is ReadOnly:
+                yield ReadOnly
+                annotation_type, = get_args(annotation_type)
+            else:
+                break
+
+    class _TypedDictMeta(type):
+        def __new__(cls, name, bases, ns, *, total=True, closed=False):
+            """Create new typed dict class object.
+
+            This method is called when TypedDict is subclassed,
+            or when TypedDict is instantiated. This way
+            TypedDict supports all three syntax forms described in its docstring.
+            Subclasses and instances of TypedDict return actual dictionaries.
+            """
+            for base in bases:
+                if type(base) is not _TypedDictMeta and base is not typing.Generic:
+                    raise TypeError('cannot inherit from both a TypedDict type '
+                                    'and a non-TypedDict base class')
+
+            if any(issubclass(b, typing.Generic) for b in bases):
+                generic_base = (typing.Generic,)
+            else:
+                generic_base = ()
+
+            # typing.py generally doesn't let you inherit from plain Generic, unless
+            # the name of the class happens to be "Protocol"
+            tp_dict = type.__new__(_TypedDictMeta, "Protocol", (*generic_base, dict), ns)
+            tp_dict.__name__ = name
+            if tp_dict.__qualname__ == "Protocol":
+                tp_dict.__qualname__ = name
+
+            if not hasattr(tp_dict, '__orig_bases__'):
+                tp_dict.__orig_bases__ = bases
+
+            annotations = {}
+            if "__annotations__" in ns:
+                own_annotations = ns["__annotations__"]
+            elif "__annotate__" in ns:
+                # TODO: Use inspect.VALUE here, and make the annotations lazily evaluated
+                own_annotations = ns["__annotate__"](1)
+            else:
+                own_annotations = {}
+            msg = "TypedDict('Name', {f0: t0, f1: t1, ...}); each t must be a type"
+            if _TAKES_MODULE:
+                own_annotations = {
+                    n: typing._type_check(tp, msg, module=tp_dict.__module__)
+                    for n, tp in own_annotations.items()
+                }
+            else:
+                own_annotations = {
+                    n: typing._type_check(tp, msg)
+                    for n, tp in own_annotations.items()
+                }
+            required_keys = set()
+            optional_keys = set()
+            readonly_keys = set()
+            mutable_keys = set()
+            extra_items_type = None
+
+            for base in bases:
+                base_dict = base.__dict__
+
+                annotations.update(base_dict.get('__annotations__', {}))
+                required_keys.update(base_dict.get('__required_keys__', ()))
+                optional_keys.update(base_dict.get('__optional_keys__', ()))
+                readonly_keys.update(base_dict.get('__readonly_keys__', ()))
+                mutable_keys.update(base_dict.get('__mutable_keys__', ()))
+                base_extra_items_type = base_dict.get('__extra_items__', None)
+                if base_extra_items_type is not None:
+                    extra_items_type = base_extra_items_type
+
+            if closed and extra_items_type is None:
+                extra_items_type = Never
+            if closed and "__extra_items__" in own_annotations:
+                annotation_type = own_annotations.pop("__extra_items__")
+                qualifiers = set(_get_typeddict_qualifiers(annotation_type))
+                if Required in qualifiers:
+                    raise TypeError(
+                        "Special key __extra_items__ does not support "
+                        "Required"
+                    )
+                if NotRequired in qualifiers:
+                    raise TypeError(
+                        "Special key __extra_items__ does not support "
+                        "NotRequired"
+                    )
+                extra_items_type = annotation_type
+
+            annotations.update(own_annotations)
+            for annotation_key, annotation_type in own_annotations.items():
+                qualifiers = set(_get_typeddict_qualifiers(annotation_type))
+
+                if Required in qualifiers:
+                    required_keys.add(annotation_key)
+                elif NotRequired in qualifiers:
+                    optional_keys.add(annotation_key)
+                elif total:
+                    required_keys.add(annotation_key)
+                else:
+                    optional_keys.add(annotation_key)
+                if ReadOnly in qualifiers:
+                    mutable_keys.discard(annotation_key)
+                    readonly_keys.add(annotation_key)
+                else:
+                    mutable_keys.add(annotation_key)
+                    readonly_keys.discard(annotation_key)
+
+            tp_dict.__annotations__ = annotations
+            tp_dict.__required_keys__ = frozenset(required_keys)
+            tp_dict.__optional_keys__ = frozenset(optional_keys)
+            tp_dict.__readonly_keys__ = frozenset(readonly_keys)
+            tp_dict.__mutable_keys__ = frozenset(mutable_keys)
+            if not hasattr(tp_dict, '__total__'):
+                tp_dict.__total__ = total
+            tp_dict.__closed__ = closed
+            tp_dict.__extra_items__ = extra_items_type
+            return tp_dict
+
+        __call__ = dict  # static method
+
+        def __subclasscheck__(cls, other):
+            # Typed dicts are only for static structural subtyping.
+            raise TypeError('TypedDict does not support instance and class checks')
+
+        __instancecheck__ = __subclasscheck__
+
+    _TypedDict = type.__new__(_TypedDictMeta, 'TypedDict', (), {})
+
+    @_ensure_subclassable(lambda bases: (_TypedDict,))
+    def TypedDict(typename, fields=_marker, /, *, total=True, closed=False, **kwargs):
+        """A simple typed namespace. At runtime it is equivalent to a plain dict.
+
+        TypedDict creates a dictionary type such that a type checker will expect all
+        instances to have a certain set of keys, where each key is
+        associated with a value of a consistent type. This expectation
+        is not checked at runtime.
+
+        Usage::
+
+            class Point2D(TypedDict):
+                x: int
+                y: int
+                label: str
+
+            a: Point2D = {'x': 1, 'y': 2, 'label': 'good'}  # OK
+            b: Point2D = {'z': 3, 'label': 'bad'}           # Fails type check
+
+            assert Point2D(x=1, y=2, label='first') == dict(x=1, y=2, label='first')
+
+        The type info can be accessed via the Point2D.__annotations__ dict, and
+        the Point2D.__required_keys__ and Point2D.__optional_keys__ frozensets.
+        TypedDict supports an additional equivalent form::
+
+            Point2D = TypedDict('Point2D', {'x': int, 'y': int, 'label': str})
+
+        By default, all keys must be present in a TypedDict. It is possible
+        to override this by specifying totality::
+
+            class Point2D(TypedDict, total=False):
+                x: int
+                y: int
+
+        This means that a Point2D TypedDict can have any of the keys omitted. A type
+        checker is only expected to support a literal False or True as the value of
+        the total argument. True is the default, and makes all items defined in the
+        class body be required.
+
+        The Required and NotRequired special forms can also be used to mark
+        individual keys as being required or not required::
+
+            class Point2D(TypedDict):
+                x: int  # the "x" key must always be present (Required is the default)
+                y: NotRequired[int]  # the "y" key can be omitted
+
+        See PEP 655 for more details on Required and NotRequired.
+        """
+        if fields is _marker or fields is None:
+            if fields is _marker:
+                deprecated_thing = "Failing to pass a value for the 'fields' parameter"
+            else:
+                deprecated_thing = "Passing `None` as the 'fields' parameter"
+
+            example = f"`{typename} = TypedDict({typename!r}, {{}})`"
+            deprecation_msg = (
+                f"{deprecated_thing} is deprecated and will be disallowed in "
+                "Python 3.15. To create a TypedDict class with 0 fields "
+                "using the functional syntax, pass an empty dictionary, e.g. "
+            ) + example + "."
+            warnings.warn(deprecation_msg, DeprecationWarning, stacklevel=2)
+            if closed is not False and closed is not True:
+                kwargs["closed"] = closed
+                closed = False
+            fields = kwargs
+        elif kwargs:
+            raise TypeError("TypedDict takes either a dict or keyword arguments,"
+                            " but not both")
+        if kwargs:
+            if sys.version_info >= (3, 13):
+                raise TypeError("TypedDict takes no keyword arguments")
+            warnings.warn(
+                "The kwargs-based syntax for TypedDict definitions is deprecated "
+                "in Python 3.11, will be removed in Python 3.13, and may not be "
+                "understood by third-party type checkers.",
+                DeprecationWarning,
+                stacklevel=2,
+            )
+
+        ns = {'__annotations__': dict(fields)}
+        module = _caller()
+        if module is not None:
+            # Setting correct module is necessary to make typed dict classes pickleable.
+            ns['__module__'] = module
+
+        td = _TypedDictMeta(typename, (), ns, total=total, closed=closed)
+        td.__orig_bases__ = (TypedDict,)
+        return td
+
+    if hasattr(typing, "_TypedDictMeta"):
+        _TYPEDDICT_TYPES = (typing._TypedDictMeta, _TypedDictMeta)
+    else:
+        _TYPEDDICT_TYPES = (_TypedDictMeta,)
+
+    def is_typeddict(tp):
+        """Check if an annotation is a TypedDict class
+
+        For example::
+            class Film(TypedDict):
+                title: str
+                year: int
+
+            is_typeddict(Film)  # => True
+            is_typeddict(Union[list, str])  # => False
+        """
+        # On 3.8, this would otherwise return True
+        if hasattr(typing, "TypedDict") and tp is typing.TypedDict:
+            return False
+        return isinstance(tp, _TYPEDDICT_TYPES)
+
+
+if hasattr(typing, "assert_type"):
+    assert_type = typing.assert_type
+
+else:
+    def assert_type(val, typ, /):
+        """Assert (to the type checker) that the value is of the given type.
+
+        When the type checker encounters a call to assert_type(), it
+        emits an error if the value is not of the specified type::
+
+            def greet(name: str) -> None:
+                assert_type(name, str)  # ok
+                assert_type(name, int)  # type checker error
+
+        At runtime this returns the first argument unchanged and otherwise
+        does nothing.
+        """
+        return val
+
+
+if hasattr(typing, "ReadOnly"):  # 3.13+
+    get_type_hints = typing.get_type_hints
+else:  # <=3.13
+    # replaces _strip_annotations()
+    def _strip_extras(t):
+        """Strips Annotated, Required and NotRequired from a given type."""
+        if isinstance(t, _AnnotatedAlias):
+            return _strip_extras(t.__origin__)
+        if hasattr(t, "__origin__") and t.__origin__ in (Required, NotRequired, ReadOnly):
+            return _strip_extras(t.__args__[0])
+        if isinstance(t, typing._GenericAlias):
+            stripped_args = tuple(_strip_extras(a) for a in t.__args__)
+            if stripped_args == t.__args__:
+                return t
+            return t.copy_with(stripped_args)
+        if hasattr(_types, "GenericAlias") and isinstance(t, _types.GenericAlias):
+            stripped_args = tuple(_strip_extras(a) for a in t.__args__)
+            if stripped_args == t.__args__:
+                return t
+            return _types.GenericAlias(t.__origin__, stripped_args)
+        if hasattr(_types, "UnionType") and isinstance(t, _types.UnionType):
+            stripped_args = tuple(_strip_extras(a) for a in t.__args__)
+            if stripped_args == t.__args__:
+                return t
+            return functools.reduce(operator.or_, stripped_args)
+
+        return t
+
+    def get_type_hints(obj, globalns=None, localns=None, include_extras=False):
+        """Return type hints for an object.
+
+        This is often the same as obj.__annotations__, but it handles
+        forward references encoded as string literals, adds Optional[t] if a
+        default value equal to None is set and recursively replaces all
+        'Annotated[T, ...]', 'Required[T]' or 'NotRequired[T]' with 'T'
+        (unless 'include_extras=True').
+
+        The argument may be a module, class, method, or function. The annotations
+        are returned as a dictionary. For classes, annotations include also
+        inherited members.
+
+        TypeError is raised if the argument is not of a type that can contain
+        annotations, and an empty dictionary is returned if no annotations are
+        present.
+
+        BEWARE -- the behavior of globalns and localns is counterintuitive
+        (unless you are familiar with how eval() and exec() work).  The
+        search order is locals first, then globals.
+
+        - If no dict arguments are passed, an attempt is made to use the
+          globals from obj (or the respective module's globals for classes),
+          and these are also used as the locals.  If the object does not appear
+          to have globals, an empty dictionary is used.
+
+        - If one dict argument is passed, it is used for both globals and
+          locals.
+
+        - If two dict arguments are passed, they specify globals and
+          locals, respectively.
+        """
+        if hasattr(typing, "Annotated"):  # 3.9+
+            hint = typing.get_type_hints(
+                obj, globalns=globalns, localns=localns, include_extras=True
+            )
+        else:  # 3.8
+            hint = typing.get_type_hints(obj, globalns=globalns, localns=localns)
+        if include_extras:
+            return hint
+        return {k: _strip_extras(t) for k, t in hint.items()}
+
+
+# Python 3.9+ has PEP 593 (Annotated)
+if hasattr(typing, 'Annotated'):
+    Annotated = typing.Annotated
+    # Not exported and not a public API, but needed for get_origin() and get_args()
+    # to work.
+    _AnnotatedAlias = typing._AnnotatedAlias
+# 3.8
+else:
+    class _AnnotatedAlias(typing._GenericAlias, _root=True):
+        """Runtime representation of an annotated type.
+
+        At its core 'Annotated[t, dec1, dec2, ...]' is an alias for the type 't'
+        with extra annotations. The alias behaves like a normal typing alias,
+        instantiating is the same as instantiating the underlying type, binding
+        it to types is also the same.
+        """
+        def __init__(self, origin, metadata):
+            if isinstance(origin, _AnnotatedAlias):
+                metadata = origin.__metadata__ + metadata
+                origin = origin.__origin__
+            super().__init__(origin, origin)
+            self.__metadata__ = metadata
+
+        def copy_with(self, params):
+            assert len(params) == 1
+            new_type = params[0]
+            return _AnnotatedAlias(new_type, self.__metadata__)
+
+        def __repr__(self):
+            return (f"typing_extensions.Annotated[{typing._type_repr(self.__origin__)}, "
+                    f"{', '.join(repr(a) for a in self.__metadata__)}]")
+
+        def __reduce__(self):
+            return operator.getitem, (
+                Annotated, (self.__origin__, *self.__metadata__)
+            )
+
+        def __eq__(self, other):
+            if not isinstance(other, _AnnotatedAlias):
+                return NotImplemented
+            if self.__origin__ != other.__origin__:
+                return False
+            return self.__metadata__ == other.__metadata__
+
+        def __hash__(self):
+            return hash((self.__origin__, self.__metadata__))
+
+    class Annotated:
+        """Add context specific metadata to a type.
+
+        Example: Annotated[int, runtime_check.Unsigned] indicates to the
+        hypothetical runtime_check module that this type is an unsigned int.
+        Every other consumer of this type can ignore this metadata and treat
+        this type as int.
+
+        The first argument to Annotated must be a valid type (and will be in
+        the __origin__ field), the remaining arguments are kept as a tuple in
+        the __extra__ field.
+
+        Details:
+
+        - It's an error to call `Annotated` with less than two arguments.
+        - Nested Annotated are flattened::
+
+            Annotated[Annotated[T, Ann1, Ann2], Ann3] == Annotated[T, Ann1, Ann2, Ann3]
+
+        - Instantiating an annotated type is equivalent to instantiating the
+        underlying type::
+
+            Annotated[C, Ann1](5) == C(5)
+
+        - Annotated can be used as a generic type alias::
+
+            Optimized = Annotated[T, runtime.Optimize()]
+            Optimized[int] == Annotated[int, runtime.Optimize()]
+
+            OptimizedList = Annotated[List[T], runtime.Optimize()]
+            OptimizedList[int] == Annotated[List[int], runtime.Optimize()]
+        """
+
+        __slots__ = ()
+
+        def __new__(cls, *args, **kwargs):
+            raise TypeError("Type Annotated cannot be instantiated.")
+
+        @typing._tp_cache
+        def __class_getitem__(cls, params):
+            if not isinstance(params, tuple) or len(params) < 2:
+                raise TypeError("Annotated[...] should be used "
+                                "with at least two arguments (a type and an "
+                                "annotation).")
+            allowed_special_forms = (ClassVar, Final)
+            if get_origin(params[0]) in allowed_special_forms:
+                origin = params[0]
+            else:
+                msg = "Annotated[t, ...]: t must be a type."
+                origin = typing._type_check(params[0], msg)
+            metadata = tuple(params[1:])
+            return _AnnotatedAlias(origin, metadata)
+
+        def __init_subclass__(cls, *args, **kwargs):
+            raise TypeError(
+                f"Cannot subclass {cls.__module__}.Annotated"
+            )
+
+# Python 3.8 has get_origin() and get_args() but those implementations aren't
+# Annotated-aware, so we can't use those. Python 3.9's versions don't support
+# ParamSpecArgs and ParamSpecKwargs, so only Python 3.10's versions will do.
+if sys.version_info[:2] >= (3, 10):
+    get_origin = typing.get_origin
+    get_args = typing.get_args
+# 3.8-3.9
+else:
+    try:
+        # 3.9+
+        from typing import _BaseGenericAlias
+    except ImportError:
+        _BaseGenericAlias = typing._GenericAlias
+    try:
+        # 3.9+
+        from typing import GenericAlias as _typing_GenericAlias
+    except ImportError:
+        _typing_GenericAlias = typing._GenericAlias
+
+    def get_origin(tp):
+        """Get the unsubscripted version of a type.
+
+        This supports generic types, Callable, Tuple, Union, Literal, Final, ClassVar
+        and Annotated. Return None for unsupported types. Examples::
+
+            get_origin(Literal[42]) is Literal
+            get_origin(int) is None
+            get_origin(ClassVar[int]) is ClassVar
+            get_origin(Generic) is Generic
+            get_origin(Generic[T]) is Generic
+            get_origin(Union[T, int]) is Union
+            get_origin(List[Tuple[T, T]][int]) == list
+            get_origin(P.args) is P
+        """
+        if isinstance(tp, _AnnotatedAlias):
+            return Annotated
+        if isinstance(tp, (typing._GenericAlias, _typing_GenericAlias, _BaseGenericAlias,
+                           ParamSpecArgs, ParamSpecKwargs)):
+            return tp.__origin__
+        if tp is typing.Generic:
+            return typing.Generic
+        return None
+
+    def get_args(tp):
+        """Get type arguments with all substitutions performed.
+
+        For unions, basic simplifications used by Union constructor are performed.
+        Examples::
+            get_args(Dict[str, int]) == (str, int)
+            get_args(int) == ()
+            get_args(Union[int, Union[T, int], str][int]) == (int, str)
+            get_args(Union[int, Tuple[T, int]][str]) == (int, Tuple[str, int])
+            get_args(Callable[[], T][int]) == ([], int)
+        """
+        if isinstance(tp, _AnnotatedAlias):
+            return (tp.__origin__, *tp.__metadata__)
+        if isinstance(tp, (typing._GenericAlias, _typing_GenericAlias)):
+            if getattr(tp, "_special", False):
+                return ()
+            res = tp.__args__
+            if get_origin(tp) is collections.abc.Callable and res[0] is not Ellipsis:
+                res = (list(res[:-1]), res[-1])
+            return res
+        return ()
+
+
+# 3.10+
+if hasattr(typing, 'TypeAlias'):
+    TypeAlias = typing.TypeAlias
+# 3.9
+elif sys.version_info[:2] >= (3, 9):
+    @_ExtensionsSpecialForm
+    def TypeAlias(self, parameters):
+        """Special marker indicating that an assignment should
+        be recognized as a proper type alias definition by type
+        checkers.
+
+        For example::
+
+            Predicate: TypeAlias = Callable[..., bool]
+
+        It's invalid when used anywhere except as in the example above.
+        """
+        raise TypeError(f"{self} is not subscriptable")
+# 3.8
+else:
+    TypeAlias = _ExtensionsSpecialForm(
+        'TypeAlias',
+        doc="""Special marker indicating that an assignment should
+        be recognized as a proper type alias definition by type
+        checkers.
+
+        For example::
+
+            Predicate: TypeAlias = Callable[..., bool]
+
+        It's invalid when used anywhere except as in the example
+        above."""
+    )
+
+
+if hasattr(typing, "NoDefault"):
+    NoDefault = typing.NoDefault
+else:
+    class NoDefaultTypeMeta(type):
+        def __setattr__(cls, attr, value):
+            # TypeError is consistent with the behavior of NoneType
+            raise TypeError(
+                f"cannot set {attr!r} attribute of immutable type {cls.__name__!r}"
+            )
+
+    class NoDefaultType(metaclass=NoDefaultTypeMeta):
+        """The type of the NoDefault singleton."""
+
+        __slots__ = ()
+
+        def __new__(cls):
+            return globals().get("NoDefault") or object.__new__(cls)
+
+        def __repr__(self):
+            return "typing_extensions.NoDefault"
+
+        def __reduce__(self):
+            return "NoDefault"
+
+    NoDefault = NoDefaultType()
+    del NoDefaultType, NoDefaultTypeMeta
+
+
+def _set_default(type_param, default):
+    type_param.has_default = lambda: default is not NoDefault
+    type_param.__default__ = default
+
+
+def _set_module(typevarlike):
+    # for pickling:
+    def_mod = _caller(depth=3)
+    if def_mod != 'typing_extensions':
+        typevarlike.__module__ = def_mod
+
+
+class _DefaultMixin:
+    """Mixin for TypeVarLike defaults."""
+
+    __slots__ = ()
+    __init__ = _set_default
+
+
+# Classes using this metaclass must provide a _backported_typevarlike ClassVar
+class _TypeVarLikeMeta(type):
+    def __instancecheck__(cls, __instance: Any) -> bool:
+        return isinstance(__instance, cls._backported_typevarlike)
+
+
+if _PEP_696_IMPLEMENTED:
+    from typing import TypeVar
+else:
+    # Add default and infer_variance parameters from PEP 696 and 695
+    class TypeVar(metaclass=_TypeVarLikeMeta):
+        """Type variable."""
+
+        _backported_typevarlike = typing.TypeVar
+
+        def __new__(cls, name, *constraints, bound=None,
+                    covariant=False, contravariant=False,
+                    default=NoDefault, infer_variance=False):
+            if hasattr(typing, "TypeAliasType"):
+                # PEP 695 implemented (3.12+), can pass infer_variance to typing.TypeVar
+                typevar = typing.TypeVar(name, *constraints, bound=bound,
+                                         covariant=covariant, contravariant=contravariant,
+                                         infer_variance=infer_variance)
+            else:
+                typevar = typing.TypeVar(name, *constraints, bound=bound,
+                                         covariant=covariant, contravariant=contravariant)
+                if infer_variance and (covariant or contravariant):
+                    raise ValueError("Variance cannot be specified with infer_variance.")
+                typevar.__infer_variance__ = infer_variance
+
+            _set_default(typevar, default)
+            _set_module(typevar)
+
+            def _tvar_prepare_subst(alias, args):
+                if (
+                    typevar.has_default()
+                    and alias.__parameters__.index(typevar) == len(args)
+                ):
+                    args += (typevar.__default__,)
+                return args
+
+            typevar.__typing_prepare_subst__ = _tvar_prepare_subst
+            return typevar
+
+        def __init_subclass__(cls) -> None:
+            raise TypeError(f"type '{__name__}.TypeVar' is not an acceptable base type")
+
+
+# Python 3.10+ has PEP 612
+if hasattr(typing, 'ParamSpecArgs'):
+    ParamSpecArgs = typing.ParamSpecArgs
+    ParamSpecKwargs = typing.ParamSpecKwargs
+# 3.8-3.9
+else:
+    class _Immutable:
+        """Mixin to indicate that object should not be copied."""
+        __slots__ = ()
+
+        def __copy__(self):
+            return self
+
+        def __deepcopy__(self, memo):
+            return self
+
+    class ParamSpecArgs(_Immutable):
+        """The args for a ParamSpec object.
+
+        Given a ParamSpec object P, P.args is an instance of ParamSpecArgs.
+
+        ParamSpecArgs objects have a reference back to their ParamSpec:
+
+        P.args.__origin__ is P
+
+        This type is meant for runtime introspection and has no special meaning to
+        static type checkers.
+        """
+        def __init__(self, origin):
+            self.__origin__ = origin
+
+        def __repr__(self):
+            return f"{self.__origin__.__name__}.args"
+
+        def __eq__(self, other):
+            if not isinstance(other, ParamSpecArgs):
+                return NotImplemented
+            return self.__origin__ == other.__origin__
+
+    class ParamSpecKwargs(_Immutable):
+        """The kwargs for a ParamSpec object.
+
+        Given a ParamSpec object P, P.kwargs is an instance of ParamSpecKwargs.
+
+        ParamSpecKwargs objects have a reference back to their ParamSpec:
+
+        P.kwargs.__origin__ is P
+
+        This type is meant for runtime introspection and has no special meaning to
+        static type checkers.
+        """
+        def __init__(self, origin):
+            self.__origin__ = origin
+
+        def __repr__(self):
+            return f"{self.__origin__.__name__}.kwargs"
+
+        def __eq__(self, other):
+            if not isinstance(other, ParamSpecKwargs):
+                return NotImplemented
+            return self.__origin__ == other.__origin__
+
+
+if _PEP_696_IMPLEMENTED:
+    from typing import ParamSpec
+
+# 3.10+
+elif hasattr(typing, 'ParamSpec'):
+
+    # Add default parameter - PEP 696
+    class ParamSpec(metaclass=_TypeVarLikeMeta):
+        """Parameter specification."""
+
+        _backported_typevarlike = typing.ParamSpec
+
+        def __new__(cls, name, *, bound=None,
+                    covariant=False, contravariant=False,
+                    infer_variance=False, default=NoDefault):
+            if hasattr(typing, "TypeAliasType"):
+                # PEP 695 implemented, can pass infer_variance to typing.TypeVar
+                paramspec = typing.ParamSpec(name, bound=bound,
+                                             covariant=covariant,
+                                             contravariant=contravariant,
+                                             infer_variance=infer_variance)
+            else:
+                paramspec = typing.ParamSpec(name, bound=bound,
+                                             covariant=covariant,
+                                             contravariant=contravariant)
+                paramspec.__infer_variance__ = infer_variance
+
+            _set_default(paramspec, default)
+            _set_module(paramspec)
+
+            def _paramspec_prepare_subst(alias, args):
+                params = alias.__parameters__
+                i = params.index(paramspec)
+                if i == len(args) and paramspec.has_default():
+                    args = [*args, paramspec.__default__]
+                if i >= len(args):
+                    raise TypeError(f"Too few arguments for {alias}")
+                # Special case where Z[[int, str, bool]] == Z[int, str, bool] in PEP 612.
+                if len(params) == 1 and not typing._is_param_expr(args[0]):
+                    assert i == 0
+                    args = (args,)
+                # Convert lists to tuples to help other libraries cache the results.
+                elif isinstance(args[i], list):
+                    args = (*args[:i], tuple(args[i]), *args[i + 1:])
+                return args
+
+            paramspec.__typing_prepare_subst__ = _paramspec_prepare_subst
+            return paramspec
+
+        def __init_subclass__(cls) -> None:
+            raise TypeError(f"type '{__name__}.ParamSpec' is not an acceptable base type")
+
+# 3.8-3.9
+else:
+
+    # Inherits from list as a workaround for Callable checks in Python < 3.9.2.
+    class ParamSpec(list, _DefaultMixin):
+        """Parameter specification variable.
+
+        Usage::
+
+           P = ParamSpec('P')
+
+        Parameter specification variables exist primarily for the benefit of static
+        type checkers.  They are used to forward the parameter types of one
+        callable to another callable, a pattern commonly found in higher order
+        functions and decorators.  They are only valid when used in ``Concatenate``,
+        or s the first argument to ``Callable``. In Python 3.10 and higher,
+        they are also supported in user-defined Generics at runtime.
+        See class Generic for more information on generic types.  An
+        example for annotating a decorator::
+
+           T = TypeVar('T')
+           P = ParamSpec('P')
+
+           def add_logging(f: Callable[P, T]) -> Callable[P, T]:
+               '''A type-safe decorator to add logging to a function.'''
+               def inner(*args: P.args, **kwargs: P.kwargs) -> T:
+                   logging.info(f'{f.__name__} was called')
+                   return f(*args, **kwargs)
+               return inner
+
+           @add_logging
+           def add_two(x: float, y: float) -> float:
+               '''Add two numbers together.'''
+               return x + y
+
+        Parameter specification variables defined with covariant=True or
+        contravariant=True can be used to declare covariant or contravariant
+        generic types.  These keyword arguments are valid, but their actual semantics
+        are yet to be decided.  See PEP 612 for details.
+
+        Parameter specification variables can be introspected. e.g.:
+
+           P.__name__ == 'T'
+           P.__bound__ == None
+           P.__covariant__ == False
+           P.__contravariant__ == False
+
+        Note that only parameter specification variables defined in global scope can
+        be pickled.
+        """
+
+        # Trick Generic __parameters__.
+        __class__ = typing.TypeVar
+
+        @property
+        def args(self):
+            return ParamSpecArgs(self)
+
+        @property
+        def kwargs(self):
+            return ParamSpecKwargs(self)
+
+        def __init__(self, name, *, bound=None, covariant=False, contravariant=False,
+                     infer_variance=False, default=NoDefault):
+            list.__init__(self, [self])
+            self.__name__ = name
+            self.__covariant__ = bool(covariant)
+            self.__contravariant__ = bool(contravariant)
+            self.__infer_variance__ = bool(infer_variance)
+            if bound:
+                self.__bound__ = typing._type_check(bound, 'Bound must be a type.')
+            else:
+                self.__bound__ = None
+            _DefaultMixin.__init__(self, default)
+
+            # for pickling:
+            def_mod = _caller()
+            if def_mod != 'typing_extensions':
+                self.__module__ = def_mod
+
+        def __repr__(self):
+            if self.__infer_variance__:
+                prefix = ''
+            elif self.__covariant__:
+                prefix = '+'
+            elif self.__contravariant__:
+                prefix = '-'
+            else:
+                prefix = '~'
+            return prefix + self.__name__
+
+        def __hash__(self):
+            return object.__hash__(self)
+
+        def __eq__(self, other):
+            return self is other
+
+        def __reduce__(self):
+            return self.__name__
+
+        # Hack to get typing._type_check to pass.
+        def __call__(self, *args, **kwargs):
+            pass
+
+
+# 3.8-3.9
+if not hasattr(typing, 'Concatenate'):
+    # Inherits from list as a workaround for Callable checks in Python < 3.9.2.
+    class _ConcatenateGenericAlias(list):
+
+        # Trick Generic into looking into this for __parameters__.
+        __class__ = typing._GenericAlias
+
+        # Flag in 3.8.
+        _special = False
+
+        def __init__(self, origin, args):
+            super().__init__(args)
+            self.__origin__ = origin
+            self.__args__ = args
+
+        def __repr__(self):
+            _type_repr = typing._type_repr
+            return (f'{_type_repr(self.__origin__)}'
+                    f'[{", ".join(_type_repr(arg) for arg in self.__args__)}]')
+
+        def __hash__(self):
+            return hash((self.__origin__, self.__args__))
+
+        # Hack to get typing._type_check to pass in Generic.
+        def __call__(self, *args, **kwargs):
+            pass
+
+        @property
+        def __parameters__(self):
+            return tuple(
+                tp for tp in self.__args__ if isinstance(tp, (typing.TypeVar, ParamSpec))
+            )
+
+
+# 3.8-3.9
+@typing._tp_cache
+def _concatenate_getitem(self, parameters):
+    if parameters == ():
+        raise TypeError("Cannot take a Concatenate of no types.")
+    if not isinstance(parameters, tuple):
+        parameters = (parameters,)
+    if not isinstance(parameters[-1], ParamSpec):
+        raise TypeError("The last parameter to Concatenate should be a "
+                        "ParamSpec variable.")
+    msg = "Concatenate[arg, ...]: each arg must be a type."
+    parameters = tuple(typing._type_check(p, msg) for p in parameters)
+    return _ConcatenateGenericAlias(self, parameters)
+
+
+# 3.10+
+if hasattr(typing, 'Concatenate'):
+    Concatenate = typing.Concatenate
+    _ConcatenateGenericAlias = typing._ConcatenateGenericAlias
+# 3.9
+elif sys.version_info[:2] >= (3, 9):
+    @_ExtensionsSpecialForm
+    def Concatenate(self, parameters):
+        """Used in conjunction with ``ParamSpec`` and ``Callable`` to represent a
+        higher order function which adds, removes or transforms parameters of a
+        callable.
+
+        For example::
+
+           Callable[Concatenate[int, P], int]
+
+        See PEP 612 for detailed information.
+        """
+        return _concatenate_getitem(self, parameters)
+# 3.8
+else:
+    class _ConcatenateForm(_ExtensionsSpecialForm, _root=True):
+        def __getitem__(self, parameters):
+            return _concatenate_getitem(self, parameters)
+
+    Concatenate = _ConcatenateForm(
+        'Concatenate',
+        doc="""Used in conjunction with ``ParamSpec`` and ``Callable`` to represent a
+        higher order function which adds, removes or transforms parameters of a
+        callable.
+
+        For example::
+
+           Callable[Concatenate[int, P], int]
+
+        See PEP 612 for detailed information.
+        """)
+
+# 3.10+
+if hasattr(typing, 'TypeGuard'):
+    TypeGuard = typing.TypeGuard
+# 3.9
+elif sys.version_info[:2] >= (3, 9):
+    @_ExtensionsSpecialForm
+    def TypeGuard(self, parameters):
+        """Special typing form used to annotate the return type of a user-defined
+        type guard function.  ``TypeGuard`` only accepts a single type argument.
+        At runtime, functions marked this way should return a boolean.
+
+        ``TypeGuard`` aims to benefit *type narrowing* -- a technique used by static
+        type checkers to determine a more precise type of an expression within a
+        program's code flow.  Usually type narrowing is done by analyzing
+        conditional code flow and applying the narrowing to a block of code.  The
+        conditional expression here is sometimes referred to as a "type guard".
+
+        Sometimes it would be convenient to use a user-defined boolean function
+        as a type guard.  Such a function should use ``TypeGuard[...]`` as its
+        return type to alert static type checkers to this intention.
+
+        Using  ``-> TypeGuard`` tells the static type checker that for a given
+        function:
+
+        1. The return value is a boolean.
+        2. If the return value is ``True``, the type of its argument
+        is the type inside ``TypeGuard``.
+
+        For example::
+
+            def is_str(val: Union[str, float]):
+                # "isinstance" type guard
+                if isinstance(val, str):
+                    # Type of ``val`` is narrowed to ``str``
+                    ...
+                else:
+                    # Else, type of ``val`` is narrowed to ``float``.
+                    ...
+
+        Strict type narrowing is not enforced -- ``TypeB`` need not be a narrower
+        form of ``TypeA`` (it can even be a wider form) and this may lead to
+        type-unsafe results.  The main reason is to allow for things like
+        narrowing ``List[object]`` to ``List[str]`` even though the latter is not
+        a subtype of the former, since ``List`` is invariant.  The responsibility of
+        writing type-safe type guards is left to the user.
+
+        ``TypeGuard`` also works with type variables.  For more information, see
+        PEP 647 (User-Defined Type Guards).
+        """
+        item = typing._type_check(parameters, f'{self} accepts only a single type.')
+        return typing._GenericAlias(self, (item,))
+# 3.8
+else:
+    class _TypeGuardForm(_ExtensionsSpecialForm, _root=True):
+        def __getitem__(self, parameters):
+            item = typing._type_check(parameters,
+                                      f'{self._name} accepts only a single type')
+            return typing._GenericAlias(self, (item,))
+
+    TypeGuard = _TypeGuardForm(
+        'TypeGuard',
+        doc="""Special typing form used to annotate the return type of a user-defined
+        type guard function.  ``TypeGuard`` only accepts a single type argument.
+        At runtime, functions marked this way should return a boolean.
+
+        ``TypeGuard`` aims to benefit *type narrowing* -- a technique used by static
+        type checkers to determine a more precise type of an expression within a
+        program's code flow.  Usually type narrowing is done by analyzing
+        conditional code flow and applying the narrowing to a block of code.  The
+        conditional expression here is sometimes referred to as a "type guard".
+
+        Sometimes it would be convenient to use a user-defined boolean function
+        as a type guard.  Such a function should use ``TypeGuard[...]`` as its
+        return type to alert static type checkers to this intention.
+
+        Using  ``-> TypeGuard`` tells the static type checker that for a given
+        function:
+
+        1. The return value is a boolean.
+        2. If the return value is ``True``, the type of its argument
+        is the type inside ``TypeGuard``.
+
+        For example::
+
+            def is_str(val: Union[str, float]):
+                # "isinstance" type guard
+                if isinstance(val, str):
+                    # Type of ``val`` is narrowed to ``str``
+                    ...
+                else:
+                    # Else, type of ``val`` is narrowed to ``float``.
+                    ...
+
+        Strict type narrowing is not enforced -- ``TypeB`` need not be a narrower
+        form of ``TypeA`` (it can even be a wider form) and this may lead to
+        type-unsafe results.  The main reason is to allow for things like
+        narrowing ``List[object]`` to ``List[str]`` even though the latter is not
+        a subtype of the former, since ``List`` is invariant.  The responsibility of
+        writing type-safe type guards is left to the user.
+
+        ``TypeGuard`` also works with type variables.  For more information, see
+        PEP 647 (User-Defined Type Guards).
+        """)
+
+# 3.13+
+if hasattr(typing, 'TypeIs'):
+    TypeIs = typing.TypeIs
+# 3.9
+elif sys.version_info[:2] >= (3, 9):
+    @_ExtensionsSpecialForm
+    def TypeIs(self, parameters):
+        """Special typing form used to annotate the return type of a user-defined
+        type narrower function.  ``TypeIs`` only accepts a single type argument.
+        At runtime, functions marked this way should return a boolean.
+
+        ``TypeIs`` aims to benefit *type narrowing* -- a technique used by static
+        type checkers to determine a more precise type of an expression within a
+        program's code flow.  Usually type narrowing is done by analyzing
+        conditional code flow and applying the narrowing to a block of code.  The
+        conditional expression here is sometimes referred to as a "type guard".
+
+        Sometimes it would be convenient to use a user-defined boolean function
+        as a type guard.  Such a function should use ``TypeIs[...]`` as its
+        return type to alert static type checkers to this intention.
+
+        Using  ``-> TypeIs`` tells the static type checker that for a given
+        function:
+
+        1. The return value is a boolean.
+        2. If the return value is ``True``, the type of its argument
+        is the intersection of the type inside ``TypeGuard`` and the argument's
+        previously known type.
+
+        For example::
+
+            def is_awaitable(val: object) -> TypeIs[Awaitable[Any]]:
+                return hasattr(val, '__await__')
+
+            def f(val: Union[int, Awaitable[int]]) -> int:
+                if is_awaitable(val):
+                    assert_type(val, Awaitable[int])
+                else:
+                    assert_type(val, int)
+
+        ``TypeIs`` also works with type variables.  For more information, see
+        PEP 742 (Narrowing types with TypeIs).
+        """
+        item = typing._type_check(parameters, f'{self} accepts only a single type.')
+        return typing._GenericAlias(self, (item,))
+# 3.8
+else:
+    class _TypeIsForm(_ExtensionsSpecialForm, _root=True):
+        def __getitem__(self, parameters):
+            item = typing._type_check(parameters,
+                                      f'{self._name} accepts only a single type')
+            return typing._GenericAlias(self, (item,))
+
+    TypeIs = _TypeIsForm(
+        'TypeIs',
+        doc="""Special typing form used to annotate the return type of a user-defined
+        type narrower function.  ``TypeIs`` only accepts a single type argument.
+        At runtime, functions marked this way should return a boolean.
+
+        ``TypeIs`` aims to benefit *type narrowing* -- a technique used by static
+        type checkers to determine a more precise type of an expression within a
+        program's code flow.  Usually type narrowing is done by analyzing
+        conditional code flow and applying the narrowing to a block of code.  The
+        conditional expression here is sometimes referred to as a "type guard".
+
+        Sometimes it would be convenient to use a user-defined boolean function
+        as a type guard.  Such a function should use ``TypeIs[...]`` as its
+        return type to alert static type checkers to this intention.
+
+        Using  ``-> TypeIs`` tells the static type checker that for a given
+        function:
+
+        1. The return value is a boolean.
+        2. If the return value is ``True``, the type of its argument
+        is the intersection of the type inside ``TypeGuard`` and the argument's
+        previously known type.
+
+        For example::
+
+            def is_awaitable(val: object) -> TypeIs[Awaitable[Any]]:
+                return hasattr(val, '__await__')
+
+            def f(val: Union[int, Awaitable[int]]) -> int:
+                if is_awaitable(val):
+                    assert_type(val, Awaitable[int])
+                else:
+                    assert_type(val, int)
+
+        ``TypeIs`` also works with type variables.  For more information, see
+        PEP 742 (Narrowing types with TypeIs).
+        """)
+
+
+# Vendored from cpython typing._SpecialFrom
+class _SpecialForm(typing._Final, _root=True):
+    __slots__ = ('_name', '__doc__', '_getitem')
+
+    def __init__(self, getitem):
+        self._getitem = getitem
+        self._name = getitem.__name__
+        self.__doc__ = getitem.__doc__
+
+    def __getattr__(self, item):
+        if item in {'__name__', '__qualname__'}:
+            return self._name
+
+        raise AttributeError(item)
+
+    def __mro_entries__(self, bases):
+        raise TypeError(f"Cannot subclass {self!r}")
+
+    def __repr__(self):
+        return f'typing_extensions.{self._name}'
+
+    def __reduce__(self):
+        return self._name
+
+    def __call__(self, *args, **kwds):
+        raise TypeError(f"Cannot instantiate {self!r}")
+
+    def __or__(self, other):
+        return typing.Union[self, other]
+
+    def __ror__(self, other):
+        return typing.Union[other, self]
+
+    def __instancecheck__(self, obj):
+        raise TypeError(f"{self} cannot be used with isinstance()")
+
+    def __subclasscheck__(self, cls):
+        raise TypeError(f"{self} cannot be used with issubclass()")
+
+    @typing._tp_cache
+    def __getitem__(self, parameters):
+        return self._getitem(self, parameters)
+
+
+if hasattr(typing, "LiteralString"):  # 3.11+
+    LiteralString = typing.LiteralString
+else:
+    @_SpecialForm
+    def LiteralString(self, params):
+        """Represents an arbitrary literal string.
+
+        Example::
+
+          from typing_extensions import LiteralString
+
+          def query(sql: LiteralString) -> ...:
+              ...
+
+          query("SELECT * FROM table")  # ok
+          query(f"SELECT * FROM {input()}")  # not ok
+
+        See PEP 675 for details.
+
+        """
+        raise TypeError(f"{self} is not subscriptable")
+
+
+if hasattr(typing, "Self"):  # 3.11+
+    Self = typing.Self
+else:
+    @_SpecialForm
+    def Self(self, params):
+        """Used to spell the type of "self" in classes.
+
+        Example::
+
+          from typing import Self
+
+          class ReturnsSelf:
+              def parse(self, data: bytes) -> Self:
+                  ...
+                  return self
+
+        """
+
+        raise TypeError(f"{self} is not subscriptable")
+
+
+if hasattr(typing, "Never"):  # 3.11+
+    Never = typing.Never
+else:
+    @_SpecialForm
+    def Never(self, params):
+        """The bottom type, a type that has no members.
+
+        This can be used to define a function that should never be
+        called, or a function that never returns::
+
+            from typing_extensions import Never
+
+            def never_call_me(arg: Never) -> None:
+                pass
+
+            def int_or_str(arg: int | str) -> None:
+                never_call_me(arg)  # type checker error
+                match arg:
+                    case int():
+                        print("It's an int")
+                    case str():
+                        print("It's a str")
+                    case _:
+                        never_call_me(arg)  # ok, arg is of type Never
+
+        """
+
+        raise TypeError(f"{self} is not subscriptable")
+
+
+if hasattr(typing, 'Required'):  # 3.11+
+    Required = typing.Required
+    NotRequired = typing.NotRequired
+elif sys.version_info[:2] >= (3, 9):  # 3.9-3.10
+    @_ExtensionsSpecialForm
+    def Required(self, parameters):
+        """A special typing construct to mark a key of a total=False TypedDict
+        as required. For example:
+
+            class Movie(TypedDict, total=False):
+                title: Required[str]
+                year: int
+
+            m = Movie(
+                title='The Matrix',  # typechecker error if key is omitted
+                year=1999,
+            )
+
+        There is no runtime checking that a required key is actually provided
+        when instantiating a related TypedDict.
+        """
+        item = typing._type_check(parameters, f'{self._name} accepts only a single type.')
+        return typing._GenericAlias(self, (item,))
+
+    @_ExtensionsSpecialForm
+    def NotRequired(self, parameters):
+        """A special typing construct to mark a key of a TypedDict as
+        potentially missing. For example:
+
+            class Movie(TypedDict):
+                title: str
+                year: NotRequired[int]
+
+            m = Movie(
+                title='The Matrix',  # typechecker error if key is omitted
+                year=1999,
+            )
+        """
+        item = typing._type_check(parameters, f'{self._name} accepts only a single type.')
+        return typing._GenericAlias(self, (item,))
+
+else:  # 3.8
+    class _RequiredForm(_ExtensionsSpecialForm, _root=True):
+        def __getitem__(self, parameters):
+            item = typing._type_check(parameters,
+                                      f'{self._name} accepts only a single type.')
+            return typing._GenericAlias(self, (item,))
+
+    Required = _RequiredForm(
+        'Required',
+        doc="""A special typing construct to mark a key of a total=False TypedDict
+        as required. For example:
+
+            class Movie(TypedDict, total=False):
+                title: Required[str]
+                year: int
+
+            m = Movie(
+                title='The Matrix',  # typechecker error if key is omitted
+                year=1999,
+            )
+
+        There is no runtime checking that a required key is actually provided
+        when instantiating a related TypedDict.
+        """)
+    NotRequired = _RequiredForm(
+        'NotRequired',
+        doc="""A special typing construct to mark a key of a TypedDict as
+        potentially missing. For example:
+
+            class Movie(TypedDict):
+                title: str
+                year: NotRequired[int]
+
+            m = Movie(
+                title='The Matrix',  # typechecker error if key is omitted
+                year=1999,
+            )
+        """)
+
+
+if hasattr(typing, 'ReadOnly'):
+    ReadOnly = typing.ReadOnly
+elif sys.version_info[:2] >= (3, 9):  # 3.9-3.12
+    @_ExtensionsSpecialForm
+    def ReadOnly(self, parameters):
+        """A special typing construct to mark an item of a TypedDict as read-only.
+
+        For example:
+
+            class Movie(TypedDict):
+                title: ReadOnly[str]
+                year: int
+
+            def mutate_movie(m: Movie) -> None:
+                m["year"] = 1992  # allowed
+                m["title"] = "The Matrix"  # typechecker error
+
+        There is no runtime checking for this property.
+        """
+        item = typing._type_check(parameters, f'{self._name} accepts only a single type.')
+        return typing._GenericAlias(self, (item,))
+
+else:  # 3.8
+    class _ReadOnlyForm(_ExtensionsSpecialForm, _root=True):
+        def __getitem__(self, parameters):
+            item = typing._type_check(parameters,
+                                      f'{self._name} accepts only a single type.')
+            return typing._GenericAlias(self, (item,))
+
+    ReadOnly = _ReadOnlyForm(
+        'ReadOnly',
+        doc="""A special typing construct to mark a key of a TypedDict as read-only.
+
+        For example:
+
+            class Movie(TypedDict):
+                title: ReadOnly[str]
+                year: int
+
+            def mutate_movie(m: Movie) -> None:
+                m["year"] = 1992  # allowed
+                m["title"] = "The Matrix"  # typechecker error
+
+        There is no runtime checking for this propery.
+        """)
+
+
+_UNPACK_DOC = """\
+Type unpack operator.
+
+The type unpack operator takes the child types from some container type,
+such as `tuple[int, str]` or a `TypeVarTuple`, and 'pulls them out'. For
+example:
+
+  # For some generic class `Foo`:
+  Foo[Unpack[tuple[int, str]]]  # Equivalent to Foo[int, str]
+
+  Ts = TypeVarTuple('Ts')
+  # Specifies that `Bar` is generic in an arbitrary number of types.
+  # (Think of `Ts` as a tuple of an arbitrary number of individual
+  #  `TypeVar`s, which the `Unpack` is 'pulling out' directly into the
+  #  `Generic[]`.)
+  class Bar(Generic[Unpack[Ts]]): ...
+  Bar[int]  # Valid
+  Bar[int, str]  # Also valid
+
+From Python 3.11, this can also be done using the `*` operator:
+
+    Foo[*tuple[int, str]]
+    class Bar(Generic[*Ts]): ...
+
+The operator can also be used along with a `TypedDict` to annotate
+`**kwargs` in a function signature. For instance:
+
+  class Movie(TypedDict):
+    name: str
+    year: int
+
+  # This function expects two keyword arguments - *name* of type `str` and
+  # *year* of type `int`.
+  def foo(**kwargs: Unpack[Movie]): ...
+
+Note that there is only some runtime checking of this operator. Not
+everything the runtime allows may be accepted by static type checkers.
+
+For more information, see PEP 646 and PEP 692.
+"""
+
+
+if sys.version_info >= (3, 12):  # PEP 692 changed the repr of Unpack[]
+    Unpack = typing.Unpack
+
+    def _is_unpack(obj):
+        return get_origin(obj) is Unpack
+
+elif sys.version_info[:2] >= (3, 9):  # 3.9+
+    class _UnpackSpecialForm(_ExtensionsSpecialForm, _root=True):
+        def __init__(self, getitem):
+            super().__init__(getitem)
+            self.__doc__ = _UNPACK_DOC
+
+    class _UnpackAlias(typing._GenericAlias, _root=True):
+        __class__ = typing.TypeVar
+
+        @property
+        def __typing_unpacked_tuple_args__(self):
+            assert self.__origin__ is Unpack
+            assert len(self.__args__) == 1
+            arg, = self.__args__
+            if isinstance(arg, (typing._GenericAlias, _types.GenericAlias)):
+                if arg.__origin__ is not tuple:
+                    raise TypeError("Unpack[...] must be used with a tuple type")
+                return arg.__args__
+            return None
+
+    @_UnpackSpecialForm
+    def Unpack(self, parameters):
+        item = typing._type_check(parameters, f'{self._name} accepts only a single type.')
+        return _UnpackAlias(self, (item,))
+
+    def _is_unpack(obj):
+        return isinstance(obj, _UnpackAlias)
+
+else:  # 3.8
+    class _UnpackAlias(typing._GenericAlias, _root=True):
+        __class__ = typing.TypeVar
+
+    class _UnpackForm(_ExtensionsSpecialForm, _root=True):
+        def __getitem__(self, parameters):
+            item = typing._type_check(parameters,
+                                      f'{self._name} accepts only a single type.')
+            return _UnpackAlias(self, (item,))
+
+    Unpack = _UnpackForm('Unpack', doc=_UNPACK_DOC)
+
+    def _is_unpack(obj):
+        return isinstance(obj, _UnpackAlias)
+
+
+if _PEP_696_IMPLEMENTED:
+    from typing import TypeVarTuple
+
+elif hasattr(typing, "TypeVarTuple"):  # 3.11+
+
+    def _unpack_args(*args):
+        newargs = []
+        for arg in args:
+            subargs = getattr(arg, '__typing_unpacked_tuple_args__', None)
+            if subargs is not None and not (subargs and subargs[-1] is ...):
+                newargs.extend(subargs)
+            else:
+                newargs.append(arg)
+        return newargs
+
+    # Add default parameter - PEP 696
+    class TypeVarTuple(metaclass=_TypeVarLikeMeta):
+        """Type variable tuple."""
+
+        _backported_typevarlike = typing.TypeVarTuple
+
+        def __new__(cls, name, *, default=NoDefault):
+            tvt = typing.TypeVarTuple(name)
+            _set_default(tvt, default)
+            _set_module(tvt)
+
+            def _typevartuple_prepare_subst(alias, args):
+                params = alias.__parameters__
+                typevartuple_index = params.index(tvt)
+                for param in params[typevartuple_index + 1:]:
+                    if isinstance(param, TypeVarTuple):
+                        raise TypeError(
+                            f"More than one TypeVarTuple parameter in {alias}"
+                        )
+
+                alen = len(args)
+                plen = len(params)
+                left = typevartuple_index
+                right = plen - typevartuple_index - 1
+                var_tuple_index = None
+                fillarg = None
+                for k, arg in enumerate(args):
+                    if not isinstance(arg, type):
+                        subargs = getattr(arg, '__typing_unpacked_tuple_args__', None)
+                        if subargs and len(subargs) == 2 and subargs[-1] is ...:
+                            if var_tuple_index is not None:
+                                raise TypeError(
+                                    "More than one unpacked "
+                                    "arbitrary-length tuple argument"
+                                )
+                            var_tuple_index = k
+                            fillarg = subargs[0]
+                if var_tuple_index is not None:
+                    left = min(left, var_tuple_index)
+                    right = min(right, alen - var_tuple_index - 1)
+                elif left + right > alen:
+                    raise TypeError(f"Too few arguments for {alias};"
+                                    f" actual {alen}, expected at least {plen - 1}")
+                if left == alen - right and tvt.has_default():
+                    replacement = _unpack_args(tvt.__default__)
+                else:
+                    replacement = args[left: alen - right]
+
+                return (
+                    *args[:left],
+                    *([fillarg] * (typevartuple_index - left)),
+                    replacement,
+                    *([fillarg] * (plen - right - left - typevartuple_index - 1)),
+                    *args[alen - right:],
+                )
+
+            tvt.__typing_prepare_subst__ = _typevartuple_prepare_subst
+            return tvt
+
+        def __init_subclass__(self, *args, **kwds):
+            raise TypeError("Cannot subclass special typing classes")
+
+else:  # <=3.10
+    class TypeVarTuple(_DefaultMixin):
+        """Type variable tuple.
+
+        Usage::
+
+            Ts = TypeVarTuple('Ts')
+
+        In the same way that a normal type variable is a stand-in for a single
+        type such as ``int``, a type variable *tuple* is a stand-in for a *tuple*
+        type such as ``Tuple[int, str]``.
+
+        Type variable tuples can be used in ``Generic`` declarations.
+        Consider the following example::
+
+            class Array(Generic[*Ts]): ...
+
+        The ``Ts`` type variable tuple here behaves like ``tuple[T1, T2]``,
+        where ``T1`` and ``T2`` are type variables. To use these type variables
+        as type parameters of ``Array``, we must *unpack* the type variable tuple using
+        the star operator: ``*Ts``. The signature of ``Array`` then behaves
+        as if we had simply written ``class Array(Generic[T1, T2]): ...``.
+        In contrast to ``Generic[T1, T2]``, however, ``Generic[*Shape]`` allows
+        us to parameterise the class with an *arbitrary* number of type parameters.
+
+        Type variable tuples can be used anywhere a normal ``TypeVar`` can.
+        This includes class definitions, as shown above, as well as function
+        signatures and variable annotations::
+
+            class Array(Generic[*Ts]):
+
+                def __init__(self, shape: Tuple[*Ts]):
+                    self._shape: Tuple[*Ts] = shape
+
+                def get_shape(self) -> Tuple[*Ts]:
+                    return self._shape
+
+            shape = (Height(480), Width(640))
+            x: Array[Height, Width] = Array(shape)
+            y = abs(x)  # Inferred type is Array[Height, Width]
+            z = x + x   #        ...    is Array[Height, Width]
+            x.get_shape()  #     ...    is tuple[Height, Width]
+
+        """
+
+        # Trick Generic __parameters__.
+        __class__ = typing.TypeVar
+
+        def __iter__(self):
+            yield self.__unpacked__
+
+        def __init__(self, name, *, default=NoDefault):
+            self.__name__ = name
+            _DefaultMixin.__init__(self, default)
+
+            # for pickling:
+            def_mod = _caller()
+            if def_mod != 'typing_extensions':
+                self.__module__ = def_mod
+
+            self.__unpacked__ = Unpack[self]
+
+        def __repr__(self):
+            return self.__name__
+
+        def __hash__(self):
+            return object.__hash__(self)
+
+        def __eq__(self, other):
+            return self is other
+
+        def __reduce__(self):
+            return self.__name__
+
+        def __init_subclass__(self, *args, **kwds):
+            if '_root' not in kwds:
+                raise TypeError("Cannot subclass special typing classes")
+
+
+if hasattr(typing, "reveal_type"):  # 3.11+
+    reveal_type = typing.reveal_type
+else:  # <=3.10
+    def reveal_type(obj: T, /) -> T:
+        """Reveal the inferred type of a variable.
+
+        When a static type checker encounters a call to ``reveal_type()``,
+        it will emit the inferred type of the argument::
+
+            x: int = 1
+            reveal_type(x)
+
+        Running a static type checker (e.g., ``mypy``) on this example
+        will produce output similar to 'Revealed type is "builtins.int"'.
+
+        At runtime, the function prints the runtime type of the
+        argument and returns it unchanged.
+
+        """
+        print(f"Runtime type is {type(obj).__name__!r}", file=sys.stderr)
+        return obj
+
+
+if hasattr(typing, "_ASSERT_NEVER_REPR_MAX_LENGTH"):  # 3.11+
+    _ASSERT_NEVER_REPR_MAX_LENGTH = typing._ASSERT_NEVER_REPR_MAX_LENGTH
+else:  # <=3.10
+    _ASSERT_NEVER_REPR_MAX_LENGTH = 100
+
+
+if hasattr(typing, "assert_never"):  # 3.11+
+    assert_never = typing.assert_never
+else:  # <=3.10
+    def assert_never(arg: Never, /) -> Never:
+        """Assert to the type checker that a line of code is unreachable.
+
+        Example::
+
+            def int_or_str(arg: int | str) -> None:
+                match arg:
+                    case int():
+                        print("It's an int")
+                    case str():
+                        print("It's a str")
+                    case _:
+                        assert_never(arg)
+
+        If a type checker finds that a call to assert_never() is
+        reachable, it will emit an error.
+
+        At runtime, this throws an exception when called.
+
+        """
+        value = repr(arg)
+        if len(value) > _ASSERT_NEVER_REPR_MAX_LENGTH:
+            value = value[:_ASSERT_NEVER_REPR_MAX_LENGTH] + '...'
+        raise AssertionError(f"Expected code to be unreachable, but got: {value}")
+
+
+if sys.version_info >= (3, 12):  # 3.12+
+    # dataclass_transform exists in 3.11 but lacks the frozen_default parameter
+    dataclass_transform = typing.dataclass_transform
+else:  # <=3.11
+    def dataclass_transform(
+        *,
+        eq_default: bool = True,
+        order_default: bool = False,
+        kw_only_default: bool = False,
+        frozen_default: bool = False,
+        field_specifiers: typing.Tuple[
+            typing.Union[typing.Type[typing.Any], typing.Callable[..., typing.Any]],
+            ...
+        ] = (),
+        **kwargs: typing.Any,
+    ) -> typing.Callable[[T], T]:
+        """Decorator that marks a function, class, or metaclass as providing
+        dataclass-like behavior.
+
+        Example:
+
+            from typing_extensions import dataclass_transform
+
+            _T = TypeVar("_T")
+
+            # Used on a decorator function
+            @dataclass_transform()
+            def create_model(cls: type[_T]) -> type[_T]:
+                ...
+                return cls
+
+            @create_model
+            class CustomerModel:
+                id: int
+                name: str
+
+            # Used on a base class
+            @dataclass_transform()
+            class ModelBase: ...
+
+            class CustomerModel(ModelBase):
+                id: int
+                name: str
+
+            # Used on a metaclass
+            @dataclass_transform()
+            class ModelMeta(type): ...
+
+            class ModelBase(metaclass=ModelMeta): ...
+
+            class CustomerModel(ModelBase):
+                id: int
+                name: str
+
+        Each of the ``CustomerModel`` classes defined in this example will now
+        behave similarly to a dataclass created with the ``@dataclasses.dataclass``
+        decorator. For example, the type checker will synthesize an ``__init__``
+        method.
+
+        The arguments to this decorator can be used to customize this behavior:
+        - ``eq_default`` indicates whether the ``eq`` parameter is assumed to be
+          True or False if it is omitted by the caller.
+        - ``order_default`` indicates whether the ``order`` parameter is
+          assumed to be True or False if it is omitted by the caller.
+        - ``kw_only_default`` indicates whether the ``kw_only`` parameter is
+          assumed to be True or False if it is omitted by the caller.
+        - ``frozen_default`` indicates whether the ``frozen`` parameter is
+          assumed to be True or False if it is omitted by the caller.
+        - ``field_specifiers`` specifies a static list of supported classes
+          or functions that describe fields, similar to ``dataclasses.field()``.
+
+        At runtime, this decorator records its arguments in the
+        ``__dataclass_transform__`` attribute on the decorated object.
+
+        See PEP 681 for details.
+
+        """
+        def decorator(cls_or_fn):
+            cls_or_fn.__dataclass_transform__ = {
+                "eq_default": eq_default,
+                "order_default": order_default,
+                "kw_only_default": kw_only_default,
+                "frozen_default": frozen_default,
+                "field_specifiers": field_specifiers,
+                "kwargs": kwargs,
+            }
+            return cls_or_fn
+        return decorator
+
+
+if hasattr(typing, "override"):  # 3.12+
+    override = typing.override
+else:  # <=3.11
+    _F = typing.TypeVar("_F", bound=typing.Callable[..., typing.Any])
+
+    def override(arg: _F, /) -> _F:
+        """Indicate that a method is intended to override a method in a base class.
+
+        Usage:
+
+            class Base:
+                def method(self) -> None:
+                    pass
+
+            class Child(Base):
+                @override
+                def method(self) -> None:
+                    super().method()
+
+        When this decorator is applied to a method, the type checker will
+        validate that it overrides a method with the same name on a base class.
+        This helps prevent bugs that may occur when a base class is changed
+        without an equivalent change to a child class.
+
+        There is no runtime checking of these properties. The decorator
+        sets the ``__override__`` attribute to ``True`` on the decorated object
+        to allow runtime introspection.
+
+        See PEP 698 for details.
+
+        """
+        try:
+            arg.__override__ = True
+        except (AttributeError, TypeError):
+            # Skip the attribute silently if it is not writable.
+            # AttributeError happens if the object has __slots__ or a
+            # read-only property, TypeError if it's a builtin class.
+            pass
+        return arg
+
+
+if hasattr(warnings, "deprecated"):
+    deprecated = warnings.deprecated
+else:
+    _T = typing.TypeVar("_T")
+
+    class deprecated:
+        """Indicate that a class, function or overload is deprecated.
+
+        When this decorator is applied to an object, the type checker
+        will generate a diagnostic on usage of the deprecated object.
+
+        Usage:
+
+            @deprecated("Use B instead")
+            class A:
+                pass
+
+            @deprecated("Use g instead")
+            def f():
+                pass
+
+            @overload
+            @deprecated("int support is deprecated")
+            def g(x: int) -> int: ...
+            @overload
+            def g(x: str) -> int: ...
+
+        The warning specified by *category* will be emitted at runtime
+        on use of deprecated objects. For functions, that happens on calls;
+        for classes, on instantiation and on creation of subclasses.
+        If the *category* is ``None``, no warning is emitted at runtime.
+        The *stacklevel* determines where the
+        warning is emitted. If it is ``1`` (the default), the warning
+        is emitted at the direct caller of the deprecated object; if it
+        is higher, it is emitted further up the stack.
+        Static type checker behavior is not affected by the *category*
+        and *stacklevel* arguments.
+
+        The deprecation message passed to the decorator is saved in the
+        ``__deprecated__`` attribute on the decorated object.
+        If applied to an overload, the decorator
+        must be after the ``@overload`` decorator for the attribute to
+        exist on the overload as returned by ``get_overloads()``.
+
+        See PEP 702 for details.
+
+        """
+        def __init__(
+            self,
+            message: str,
+            /,
+            *,
+            category: typing.Optional[typing.Type[Warning]] = DeprecationWarning,
+            stacklevel: int = 1,
+        ) -> None:
+            if not isinstance(message, str):
+                raise TypeError(
+                    "Expected an object of type str for 'message', not "
+                    f"{type(message).__name__!r}"
+                )
+            self.message = message
+            self.category = category
+            self.stacklevel = stacklevel
+
+        def __call__(self, arg: _T, /) -> _T:
+            # Make sure the inner functions created below don't
+            # retain a reference to self.
+            msg = self.message
+            category = self.category
+            stacklevel = self.stacklevel
+            if category is None:
+                arg.__deprecated__ = msg
+                return arg
+            elif isinstance(arg, type):
+                import functools
+                from types import MethodType
+
+                original_new = arg.__new__
+
+                @functools.wraps(original_new)
+                def __new__(cls, *args, **kwargs):
+                    if cls is arg:
+                        warnings.warn(msg, category=category, stacklevel=stacklevel + 1)
+                    if original_new is not object.__new__:
+                        return original_new(cls, *args, **kwargs)
+                    # Mirrors a similar check in object.__new__.
+                    elif cls.__init__ is object.__init__ and (args or kwargs):
+                        raise TypeError(f"{cls.__name__}() takes no arguments")
+                    else:
+                        return original_new(cls)
+
+                arg.__new__ = staticmethod(__new__)
+
+                original_init_subclass = arg.__init_subclass__
+                # We need slightly different behavior if __init_subclass__
+                # is a bound method (likely if it was implemented in Python)
+                if isinstance(original_init_subclass, MethodType):
+                    original_init_subclass = original_init_subclass.__func__
+
+                    @functools.wraps(original_init_subclass)
+                    def __init_subclass__(*args, **kwargs):
+                        warnings.warn(msg, category=category, stacklevel=stacklevel + 1)
+                        return original_init_subclass(*args, **kwargs)
+
+                    arg.__init_subclass__ = classmethod(__init_subclass__)
+                # Or otherwise, which likely means it's a builtin such as
+                # object's implementation of __init_subclass__.
+                else:
+                    @functools.wraps(original_init_subclass)
+                    def __init_subclass__(*args, **kwargs):
+                        warnings.warn(msg, category=category, stacklevel=stacklevel + 1)
+                        return original_init_subclass(*args, **kwargs)
+
+                    arg.__init_subclass__ = __init_subclass__
+
+                arg.__deprecated__ = __new__.__deprecated__ = msg
+                __init_subclass__.__deprecated__ = msg
+                return arg
+            elif callable(arg):
+                import functools
+
+                @functools.wraps(arg)
+                def wrapper(*args, **kwargs):
+                    warnings.warn(msg, category=category, stacklevel=stacklevel + 1)
+                    return arg(*args, **kwargs)
+
+                arg.__deprecated__ = wrapper.__deprecated__ = msg
+                return wrapper
+            else:
+                raise TypeError(
+                    "@deprecated decorator with non-None category must be applied to "
+                    f"a class or callable, not {arg!r}"
+                )
+
+
+# We have to do some monkey patching to deal with the dual nature of
+# Unpack/TypeVarTuple:
+# - We want Unpack to be a kind of TypeVar so it gets accepted in
+#   Generic[Unpack[Ts]]
+# - We want it to *not* be treated as a TypeVar for the purposes of
+#   counting generic parameters, so that when we subscript a generic,
+#   the runtime doesn't try to substitute the Unpack with the subscripted type.
+if not hasattr(typing, "TypeVarTuple"):
+    def _check_generic(cls, parameters, elen=_marker):
+        """Check correct count for parameters of a generic cls (internal helper).
+
+        This gives a nice error message in case of count mismatch.
+        """
+        if not elen:
+            raise TypeError(f"{cls} is not a generic class")
+        if elen is _marker:
+            if not hasattr(cls, "__parameters__") or not cls.__parameters__:
+                raise TypeError(f"{cls} is not a generic class")
+            elen = len(cls.__parameters__)
+        alen = len(parameters)
+        if alen != elen:
+            expect_val = elen
+            if hasattr(cls, "__parameters__"):
+                parameters = [p for p in cls.__parameters__ if not _is_unpack(p)]
+                num_tv_tuples = sum(isinstance(p, TypeVarTuple) for p in parameters)
+                if (num_tv_tuples > 0) and (alen >= elen - num_tv_tuples):
+                    return
+
+                # deal with TypeVarLike defaults
+                # required TypeVarLikes cannot appear after a defaulted one.
+                if alen < elen:
+                    # since we validate TypeVarLike default in _collect_type_vars
+                    # or _collect_parameters we can safely check parameters[alen]
+                    if (
+                        getattr(parameters[alen], '__default__', NoDefault)
+                        is not NoDefault
+                    ):
+                        return
+
+                    num_default_tv = sum(getattr(p, '__default__', NoDefault)
+                                         is not NoDefault for p in parameters)
+
+                    elen -= num_default_tv
+
+                    expect_val = f"at least {elen}"
+
+            things = "arguments" if sys.version_info >= (3, 10) else "parameters"
+            raise TypeError(f"Too {'many' if alen > elen else 'few'} {things}"
+                            f" for {cls}; actual {alen}, expected {expect_val}")
+else:
+    # Python 3.11+
+
+    def _check_generic(cls, parameters, elen):
+        """Check correct count for parameters of a generic cls (internal helper).
+
+        This gives a nice error message in case of count mismatch.
+        """
+        if not elen:
+            raise TypeError(f"{cls} is not a generic class")
+        alen = len(parameters)
+        if alen != elen:
+            expect_val = elen
+            if hasattr(cls, "__parameters__"):
+                parameters = [p for p in cls.__parameters__ if not _is_unpack(p)]
+
+                # deal with TypeVarLike defaults
+                # required TypeVarLikes cannot appear after a defaulted one.
+                if alen < elen:
+                    # since we validate TypeVarLike default in _collect_type_vars
+                    # or _collect_parameters we can safely check parameters[alen]
+                    if (
+                        getattr(parameters[alen], '__default__', NoDefault)
+                        is not NoDefault
+                    ):
+                        return
+
+                    num_default_tv = sum(getattr(p, '__default__', NoDefault)
+                                         is not NoDefault for p in parameters)
+
+                    elen -= num_default_tv
+
+                    expect_val = f"at least {elen}"
+
+            raise TypeError(f"Too {'many' if alen > elen else 'few'} arguments"
+                            f" for {cls}; actual {alen}, expected {expect_val}")
+
+if not _PEP_696_IMPLEMENTED:
+    typing._check_generic = _check_generic
+
+
+def _has_generic_or_protocol_as_origin() -> bool:
+    try:
+        frame = sys._getframe(2)
+    # - Catch AttributeError: not all Python implementations have sys._getframe()
+    # - Catch ValueError: maybe we're called from an unexpected module
+    #   and the call stack isn't deep enough
+    except (AttributeError, ValueError):
+        return False  # err on the side of leniency
+    else:
+        # If we somehow get invoked from outside typing.py,
+        # also err on the side of leniency
+        if frame.f_globals.get("__name__") != "typing":
+            return False
+        origin = frame.f_locals.get("origin")
+        # Cannot use "in" because origin may be an object with a buggy __eq__ that
+        # throws an error.
+        return origin is typing.Generic or origin is Protocol or origin is typing.Protocol
+
+
+_TYPEVARTUPLE_TYPES = {TypeVarTuple, getattr(typing, "TypeVarTuple", None)}
+
+
+def _is_unpacked_typevartuple(x) -> bool:
+    if get_origin(x) is not Unpack:
+        return False
+    args = get_args(x)
+    return (
+        bool(args)
+        and len(args) == 1
+        and type(args[0]) in _TYPEVARTUPLE_TYPES
+    )
+
+
+# Python 3.11+ _collect_type_vars was renamed to _collect_parameters
+if hasattr(typing, '_collect_type_vars'):
+    def _collect_type_vars(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)
+        """
+        if typevar_types is None:
+            typevar_types = typing.TypeVar
+        tvars = []
+
+        # A required TypeVarLike cannot appear after a TypeVarLike with a default
+        # if it was a direct call to `Generic[]` or `Protocol[]`
+        enforce_default_ordering = _has_generic_or_protocol_as_origin()
+        default_encountered = False
+
+        # Also, a TypeVarLike with a default cannot appear after a TypeVarTuple
+        type_var_tuple_encountered = False
+
+        for t in types:
+            if _is_unpacked_typevartuple(t):
+                type_var_tuple_encountered = True
+            elif isinstance(t, typevar_types) and t not in tvars:
+                if enforce_default_ordering:
+                    has_default = getattr(t, '__default__', NoDefault) is not NoDefault
+                    if has_default:
+                        if type_var_tuple_encountered:
+                            raise TypeError('Type parameter with a default'
+                                            ' follows TypeVarTuple')
+                        default_encountered = True
+                    elif default_encountered:
+                        raise TypeError(f'Type parameter {t!r} without a default'
+                                        ' follows type parameter with a default')
+
+                tvars.append(t)
+            if _should_collect_from_parameters(t):
+                tvars.extend([t for t in t.__parameters__ if t not in tvars])
+        return tuple(tvars)
+
+    typing._collect_type_vars = _collect_type_vars
+else:
+    def _collect_parameters(args):
+        """Collect all type variables and parameter specifications in args
+        in order of first appearance (lexicographic order).
+
+        For example::
+
+            assert _collect_parameters((T, Callable[P, T])) == (T, P)
+        """
+        parameters = []
+
+        # A required TypeVarLike cannot appear after a TypeVarLike with default
+        # if it was a direct call to `Generic[]` or `Protocol[]`
+        enforce_default_ordering = _has_generic_or_protocol_as_origin()
+        default_encountered = False
+
+        # Also, a TypeVarLike with a default cannot appear after a TypeVarTuple
+        type_var_tuple_encountered = False
+
+        for t in args:
+            if isinstance(t, type):
+                # We don't want __parameters__ descriptor of a bare Python class.
+                pass
+            elif isinstance(t, tuple):
+                # `t` might be a tuple, when `ParamSpec` is substituted with
+                # `[T, int]`, or `[int, *Ts]`, etc.
+                for x in t:
+                    for collected in _collect_parameters([x]):
+                        if collected not in parameters:
+                            parameters.append(collected)
+            elif hasattr(t, '__typing_subst__'):
+                if t not in parameters:
+                    if enforce_default_ordering:
+                        has_default = (
+                            getattr(t, '__default__', NoDefault) is not NoDefault
+                        )
+
+                        if type_var_tuple_encountered and has_default:
+                            raise TypeError('Type parameter with a default'
+                                            ' follows TypeVarTuple')
+
+                        if has_default:
+                            default_encountered = True
+                        elif default_encountered:
+                            raise TypeError(f'Type parameter {t!r} without a default'
+                                            ' follows type parameter with a default')
+
+                    parameters.append(t)
+            else:
+                if _is_unpacked_typevartuple(t):
+                    type_var_tuple_encountered = True
+                for x in getattr(t, '__parameters__', ()):
+                    if x not in parameters:
+                        parameters.append(x)
+
+        return tuple(parameters)
+
+    if not _PEP_696_IMPLEMENTED:
+        typing._collect_parameters = _collect_parameters
+
+# Backport typing.NamedTuple as it exists in Python 3.13.
+# In 3.11, the ability to define generic `NamedTuple`s was supported.
+# This was explicitly disallowed in 3.9-3.10, and only half-worked in <=3.8.
+# On 3.12, we added __orig_bases__ to call-based NamedTuples
+# On 3.13, we deprecated kwargs-based NamedTuples
+if sys.version_info >= (3, 13):
+    NamedTuple = typing.NamedTuple
+else:
+    def _make_nmtuple(name, types, module, defaults=()):
+        fields = [n for n, t in types]
+        annotations = {n: typing._type_check(t, f"field {n} annotation must be a type")
+                       for n, t in types}
+        nm_tpl = collections.namedtuple(name, fields,
+                                        defaults=defaults, module=module)
+        nm_tpl.__annotations__ = nm_tpl.__new__.__annotations__ = annotations
+        # The `_field_types` attribute was removed in 3.9;
+        # in earlier versions, it is the same as the `__annotations__` attribute
+        if sys.version_info < (3, 9):
+            nm_tpl._field_types = annotations
+        return nm_tpl
+
+    _prohibited_namedtuple_fields = typing._prohibited
+    _special_namedtuple_fields = frozenset({'__module__', '__name__', '__annotations__'})
+
+    class _NamedTupleMeta(type):
+        def __new__(cls, typename, bases, ns):
+            assert _NamedTuple in bases
+            for base in bases:
+                if base is not _NamedTuple and base is not typing.Generic:
+                    raise TypeError(
+                        'can only inherit from a NamedTuple type and Generic')
+            bases = tuple(tuple if base is _NamedTuple else base for base in bases)
+            if "__annotations__" in ns:
+                types = ns["__annotations__"]
+            elif "__annotate__" in ns:
+                # TODO: Use inspect.VALUE here, and make the annotations lazily evaluated
+                types = ns["__annotate__"](1)
+            else:
+                types = {}
+            default_names = []
+            for field_name in types:
+                if field_name in ns:
+                    default_names.append(field_name)
+                elif default_names:
+                    raise TypeError(f"Non-default namedtuple field {field_name} "
+                                    f"cannot follow default field"
+                                    f"{'s' if len(default_names) > 1 else ''} "
+                                    f"{', '.join(default_names)}")
+            nm_tpl = _make_nmtuple(
+                typename, types.items(),
+                defaults=[ns[n] for n in default_names],
+                module=ns['__module__']
+            )
+            nm_tpl.__bases__ = bases
+            if typing.Generic in bases:
+                if hasattr(typing, '_generic_class_getitem'):  # 3.12+
+                    nm_tpl.__class_getitem__ = classmethod(typing._generic_class_getitem)
+                else:
+                    class_getitem = typing.Generic.__class_getitem__.__func__
+                    nm_tpl.__class_getitem__ = classmethod(class_getitem)
+            # update from user namespace without overriding special namedtuple attributes
+            for key, val in ns.items():
+                if key in _prohibited_namedtuple_fields:
+                    raise AttributeError("Cannot overwrite NamedTuple attribute " + key)
+                elif key not in _special_namedtuple_fields:
+                    if key not in nm_tpl._fields:
+                        setattr(nm_tpl, key, ns[key])
+                    try:
+                        set_name = type(val).__set_name__
+                    except AttributeError:
+                        pass
+                    else:
+                        try:
+                            set_name(val, nm_tpl, key)
+                        except BaseException as e:
+                            msg = (
+                                f"Error calling __set_name__ on {type(val).__name__!r} "
+                                f"instance {key!r} in {typename!r}"
+                            )
+                            # BaseException.add_note() existed on py311,
+                            # but the __set_name__ machinery didn't start
+                            # using add_note() until py312.
+                            # Making sure exceptions are raised in the same way
+                            # as in "normal" classes seems most important here.
+                            if sys.version_info >= (3, 12):
+                                e.add_note(msg)
+                                raise
+                            else:
+                                raise RuntimeError(msg) from e
+
+            if typing.Generic in bases:
+                nm_tpl.__init_subclass__()
+            return nm_tpl
+
+    _NamedTuple = type.__new__(_NamedTupleMeta, 'NamedTuple', (), {})
+
+    def _namedtuple_mro_entries(bases):
+        assert NamedTuple in bases
+        return (_NamedTuple,)
+
+    @_ensure_subclassable(_namedtuple_mro_entries)
+    def NamedTuple(typename, fields=_marker, /, **kwargs):
+        """Typed version of namedtuple.
+
+        Usage::
+
+            class Employee(NamedTuple):
+                name: str
+                id: int
+
+        This is equivalent to::
+
+            Employee = collections.namedtuple('Employee', ['name', 'id'])
+
+        The resulting class has an extra __annotations__ attribute, giving a
+        dict that maps field names to types.  (The field names are also in
+        the _fields attribute, which is part of the namedtuple API.)
+        An alternative equivalent functional syntax is also accepted::
+
+            Employee = NamedTuple('Employee', [('name', str), ('id', int)])
+        """
+        if fields is _marker:
+            if kwargs:
+                deprecated_thing = "Creating NamedTuple classes using keyword arguments"
+                deprecation_msg = (
+                    "{name} is deprecated and will be disallowed in Python {remove}. "
+                    "Use the class-based or functional syntax instead."
+                )
+            else:
+                deprecated_thing = "Failing to pass a value for the 'fields' parameter"
+                example = f"`{typename} = NamedTuple({typename!r}, [])`"
+                deprecation_msg = (
+                    "{name} is deprecated and will be disallowed in Python {remove}. "
+                    "To create a NamedTuple class with 0 fields "
+                    "using the functional syntax, "
+                    "pass an empty list, e.g. "
+                ) + example + "."
+        elif fields is None:
+            if kwargs:
+                raise TypeError(
+                    "Cannot pass `None` as the 'fields' parameter "
+                    "and also specify fields using keyword arguments"
+                )
+            else:
+                deprecated_thing = "Passing `None` as the 'fields' parameter"
+                example = f"`{typename} = NamedTuple({typename!r}, [])`"
+                deprecation_msg = (
+                    "{name} is deprecated and will be disallowed in Python {remove}. "
+                    "To create a NamedTuple class with 0 fields "
+                    "using the functional syntax, "
+                    "pass an empty list, e.g. "
+                ) + example + "."
+        elif kwargs:
+            raise TypeError("Either list of fields or keywords"
+                            " can be provided to NamedTuple, not both")
+        if fields is _marker or fields is None:
+            warnings.warn(
+                deprecation_msg.format(name=deprecated_thing, remove="3.15"),
+                DeprecationWarning,
+                stacklevel=2,
+            )
+            fields = kwargs.items()
+        nt = _make_nmtuple(typename, fields, module=_caller())
+        nt.__orig_bases__ = (NamedTuple,)
+        return nt
+
+
+if hasattr(collections.abc, "Buffer"):
+    Buffer = collections.abc.Buffer
+else:
+    class Buffer(abc.ABC):  # noqa: B024
+        """Base class for classes that implement the buffer protocol.
+
+        The buffer protocol allows Python objects to expose a low-level
+        memory buffer interface. Before Python 3.12, it is not possible
+        to implement the buffer protocol in pure Python code, or even
+        to check whether a class implements the buffer protocol. In
+        Python 3.12 and higher, the ``__buffer__`` method allows access
+        to the buffer protocol from Python code, and the
+        ``collections.abc.Buffer`` ABC allows checking whether a class
+        implements the buffer protocol.
+
+        To indicate support for the buffer protocol in earlier versions,
+        inherit from this ABC, either in a stub file or at runtime,
+        or use ABC registration. This ABC provides no methods, because
+        there is no Python-accessible methods shared by pre-3.12 buffer
+        classes. It is useful primarily for static checks.
+
+        """
+
+    # As a courtesy, register the most common stdlib buffer classes.
+    Buffer.register(memoryview)
+    Buffer.register(bytearray)
+    Buffer.register(bytes)
+
+
+# Backport of types.get_original_bases, available on 3.12+ in CPython
+if hasattr(_types, "get_original_bases"):
+    get_original_bases = _types.get_original_bases
+else:
+    def get_original_bases(cls, /):
+        """Return the class's "original" bases prior to modification by `__mro_entries__`.
+
+        Examples::
+
+            from typing import TypeVar, Generic
+            from typing_extensions import NamedTuple, TypedDict
+
+            T = TypeVar("T")
+            class Foo(Generic[T]): ...
+            class Bar(Foo[int], float): ...
+            class Baz(list[str]): ...
+            Eggs = NamedTuple("Eggs", [("a", int), ("b", str)])
+            Spam = TypedDict("Spam", {"a": int, "b": str})
+
+            assert get_original_bases(Bar) == (Foo[int], float)
+            assert get_original_bases(Baz) == (list[str],)
+            assert get_original_bases(Eggs) == (NamedTuple,)
+            assert get_original_bases(Spam) == (TypedDict,)
+            assert get_original_bases(int) == (object,)
+        """
+        try:
+            return cls.__dict__.get("__orig_bases__", cls.__bases__)
+        except AttributeError:
+            raise TypeError(
+                f'Expected an instance of type, not {type(cls).__name__!r}'
+            ) from None
+
+
+# NewType is a class on Python 3.10+, making it pickleable
+# The error message for subclassing instances of NewType was improved on 3.11+
+if sys.version_info >= (3, 11):
+    NewType = typing.NewType
+else:
+    class NewType:
+        """NewType creates simple unique types with almost zero
+        runtime overhead. NewType(name, tp) is considered a subtype of tp
+        by static type checkers. At runtime, NewType(name, tp) returns
+        a dummy callable that simply returns its argument. Usage::
+            UserId = NewType('UserId', int)
+            def name_by_id(user_id: UserId) -> str:
+                ...
+            UserId('user')          # Fails type check
+            name_by_id(42)          # Fails type check
+            name_by_id(UserId(42))  # OK
+            num = UserId(5) + 1     # type: int
+        """
+
+        def __call__(self, obj, /):
+            return obj
+
+        def __init__(self, name, tp):
+            self.__qualname__ = name
+            if '.' in name:
+                name = name.rpartition('.')[-1]
+            self.__name__ = name
+            self.__supertype__ = tp
+            def_mod = _caller()
+            if def_mod != 'typing_extensions':
+                self.__module__ = def_mod
+
+        def __mro_entries__(self, bases):
+            # We defined __mro_entries__ to get a better error message
+            # if a user attempts to subclass a NewType instance. bpo-46170
+            supercls_name = self.__name__
+
+            class Dummy:
+                def __init_subclass__(cls):
+                    subcls_name = cls.__name__
+                    raise TypeError(
+                        f"Cannot subclass an instance of NewType. "
+                        f"Perhaps you were looking for: "
+                        f"`{subcls_name} = NewType({subcls_name!r}, {supercls_name})`"
+                    )
+
+            return (Dummy,)
+
+        def __repr__(self):
+            return f'{self.__module__}.{self.__qualname__}'
+
+        def __reduce__(self):
+            return self.__qualname__
+
+        if sys.version_info >= (3, 10):
+            # PEP 604 methods
+            # It doesn't make sense to have these methods on Python <3.10
+
+            def __or__(self, other):
+                return typing.Union[self, other]
+
+            def __ror__(self, other):
+                return typing.Union[other, self]
+
+
+if hasattr(typing, "TypeAliasType"):
+    TypeAliasType = typing.TypeAliasType
+else:
+    def _is_unionable(obj):
+        """Corresponds to is_unionable() in unionobject.c in CPython."""
+        return obj is None or isinstance(obj, (
+            type,
+            _types.GenericAlias,
+            _types.UnionType,
+            TypeAliasType,
+        ))
+
+    class TypeAliasType:
+        """Create named, parameterized type aliases.
+
+        This provides a backport of the new `type` statement in Python 3.12:
+
+            type ListOrSet[T] = list[T] | set[T]
+
+        is equivalent to:
+
+            T = TypeVar("T")
+            ListOrSet = TypeAliasType("ListOrSet", list[T] | set[T], type_params=(T,))
+
+        The name ListOrSet can then be used as an alias for the type it refers to.
+
+        The type_params argument should contain all the type parameters used
+        in the value of the type alias. If the alias is not generic, this
+        argument is omitted.
+
+        Static type checkers should only support type aliases declared using
+        TypeAliasType that follow these rules:
+
+        - The first argument (the name) must be a string literal.
+        - The TypeAliasType instance must be immediately assigned to a variable
+          of the same name. (For example, 'X = TypeAliasType("Y", int)' is invalid,
+          as is 'X, Y = TypeAliasType("X", int), TypeAliasType("Y", int)').
+
+        """
+
+        def __init__(self, name: str, value, *, type_params=()):
+            if not isinstance(name, str):
+                raise TypeError("TypeAliasType name must be a string")
+            self.__value__ = value
+            self.__type_params__ = type_params
+
+            parameters = []
+            for type_param in type_params:
+                if isinstance(type_param, TypeVarTuple):
+                    parameters.extend(type_param)
+                else:
+                    parameters.append(type_param)
+            self.__parameters__ = tuple(parameters)
+            def_mod = _caller()
+            if def_mod != 'typing_extensions':
+                self.__module__ = def_mod
+            # Setting this attribute closes the TypeAliasType from further modification
+            self.__name__ = name
+
+        def __setattr__(self, name: str, value: object, /) -> None:
+            if hasattr(self, "__name__"):
+                self._raise_attribute_error(name)
+            super().__setattr__(name, value)
+
+        def __delattr__(self, name: str, /) -> Never:
+            self._raise_attribute_error(name)
+
+        def _raise_attribute_error(self, name: str) -> Never:
+            # Match the Python 3.12 error messages exactly
+            if name == "__name__":
+                raise AttributeError("readonly attribute")
+            elif name in {"__value__", "__type_params__", "__parameters__", "__module__"}:
+                raise AttributeError(
+                    f"attribute '{name}' of 'typing.TypeAliasType' objects "
+                    "is not writable"
+                )
+            else:
+                raise AttributeError(
+                    f"'typing.TypeAliasType' object has no attribute '{name}'"
+                )
+
+        def __repr__(self) -> str:
+            return self.__name__
+
+        def __getitem__(self, parameters):
+            if not isinstance(parameters, tuple):
+                parameters = (parameters,)
+            parameters = [
+                typing._type_check(
+                    item, f'Subscripting {self.__name__} requires a type.'
+                )
+                for item in parameters
+            ]
+            return typing._GenericAlias(self, tuple(parameters))
+
+        def __reduce__(self):
+            return self.__name__
+
+        def __init_subclass__(cls, *args, **kwargs):
+            raise TypeError(
+                "type 'typing_extensions.TypeAliasType' is not an acceptable base type"
+            )
+
+        # The presence of this method convinces typing._type_check
+        # that TypeAliasTypes are types.
+        def __call__(self):
+            raise TypeError("Type alias is not callable")
+
+        if sys.version_info >= (3, 10):
+            def __or__(self, right):
+                # For forward compatibility with 3.12, reject Unions
+                # that are not accepted by the built-in Union.
+                if not _is_unionable(right):
+                    return NotImplemented
+                return typing.Union[self, right]
+
+            def __ror__(self, left):
+                if not _is_unionable(left):
+                    return NotImplemented
+                return typing.Union[left, self]
+
+
+if hasattr(typing, "is_protocol"):
+    is_protocol = typing.is_protocol
+    get_protocol_members = typing.get_protocol_members
+else:
+    def is_protocol(tp: type, /) -> bool:
+        """Return True if the given type is a Protocol.
+
+        Example::
+
+            >>> from typing_extensions import Protocol, is_protocol
+            >>> class P(Protocol):
+            ...     def a(self) -> str: ...
+            ...     b: int
+            >>> is_protocol(P)
+            True
+            >>> is_protocol(int)
+            False
+        """
+        return (
+            isinstance(tp, type)
+            and getattr(tp, '_is_protocol', False)
+            and tp is not Protocol
+            and tp is not typing.Protocol
+        )
+
+    def get_protocol_members(tp: type, /) -> typing.FrozenSet[str]:
+        """Return the set of members defined in a Protocol.
+
+        Example::
+
+            >>> from typing_extensions import Protocol, get_protocol_members
+            >>> class P(Protocol):
+            ...     def a(self) -> str: ...
+            ...     b: int
+            >>> get_protocol_members(P)
+            frozenset({'a', 'b'})
+
+        Raise a TypeError for arguments that are not Protocols.
+        """
+        if not is_protocol(tp):
+            raise TypeError(f'{tp!r} is not a Protocol')
+        if hasattr(tp, '__protocol_attrs__'):
+            return frozenset(tp.__protocol_attrs__)
+        return frozenset(_get_protocol_attrs(tp))
+
+
+if hasattr(typing, "Doc"):
+    Doc = typing.Doc
+else:
+    class Doc:
+        """Define the documentation of a type annotation using ``Annotated``, to be
+         used in class attributes, function and method parameters, return values,
+         and variables.
+
+        The value should be a positional-only string literal to allow static tools
+        like editors and documentation generators to use it.
+
+        This complements docstrings.
+
+        The string value passed is available in the attribute ``documentation``.
+
+        Example::
+
+            >>> from typing_extensions import Annotated, Doc
+            >>> def hi(to: Annotated[str, Doc("Who to say hi to")]) -> None: ...
+        """
+        def __init__(self, documentation: str, /) -> None:
+            self.documentation = documentation
+
+        def __repr__(self) -> str:
+            return f"Doc({self.documentation!r})"
+
+        def __hash__(self) -> int:
+            return hash(self.documentation)
+
+        def __eq__(self, other: object) -> bool:
+            if not isinstance(other, Doc):
+                return NotImplemented
+            return self.documentation == other.documentation
+
+
+_CapsuleType = getattr(_types, "CapsuleType", None)
+
+if _CapsuleType is None:
+    try:
+        import _socket
+    except ImportError:
+        pass
+    else:
+        _CAPI = getattr(_socket, "CAPI", None)
+        if _CAPI is not None:
+            _CapsuleType = type(_CAPI)
+
+if _CapsuleType is not None:
+    CapsuleType = _CapsuleType
+    __all__.append("CapsuleType")
+
+
+# Aliases for items that have always been in typing.
+# Explicitly assign these (rather than using `from typing import *` at the top),
+# so that we get a CI error if one of these is deleted from typing.py
+# in a future version of Python
+AbstractSet = typing.AbstractSet
+AnyStr = typing.AnyStr
+BinaryIO = typing.BinaryIO
+Callable = typing.Callable
+Collection = typing.Collection
+Container = typing.Container
+Dict = typing.Dict
+ForwardRef = typing.ForwardRef
+FrozenSet = typing.FrozenSet
+Generic = typing.Generic
+Hashable = typing.Hashable
+IO = typing.IO
+ItemsView = typing.ItemsView
+Iterable = typing.Iterable
+Iterator = typing.Iterator
+KeysView = typing.KeysView
+List = typing.List
+Mapping = typing.Mapping
+MappingView = typing.MappingView
+Match = typing.Match
+MutableMapping = typing.MutableMapping
+MutableSequence = typing.MutableSequence
+MutableSet = typing.MutableSet
+Optional = typing.Optional
+Pattern = typing.Pattern
+Reversible = typing.Reversible
+Sequence = typing.Sequence
+Set = typing.Set
+Sized = typing.Sized
+TextIO = typing.TextIO
+Tuple = typing.Tuple
+Union = typing.Union
+ValuesView = typing.ValuesView
+cast = typing.cast
+no_type_check = typing.no_type_check
+no_type_check_decorator = typing.no_type_check_decorator
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/command/__init__.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/command/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..50e6c2f54f38db5bf5175a7a4db219815785f1bc
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/command/__init__.py
@@ -0,0 +1,21 @@
+# mypy: disable_error_code=call-overload
+# pyright: reportCallIssue=false, reportArgumentType=false
+# Can't disable on the exact line because distutils doesn't exists on Python 3.12
+# and type-checkers aren't aware of distutils_hack,
+# causing distutils.command.bdist.bdist.format_commands to be Any.
+
+import sys
+
+from distutils.command.bdist import bdist
+
+if 'egg' not in bdist.format_commands:
+    try:
+        # format_commands is a dict in vendored distutils
+        # It used to be a list in older (stdlib) distutils
+        # We support both for backwards compatibility
+        bdist.format_commands['egg'] = ('bdist_egg', "Python .egg file")
+    except TypeError:
+        bdist.format_command['egg'] = ('bdist_egg', "Python .egg file")
+        bdist.format_commands.append('egg')
+
+del bdist, sys
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/command/_requirestxt.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/command/_requirestxt.py
new file mode 100644
index 0000000000000000000000000000000000000000..9029b125141158d4b12de1db8215819ce6ccf437
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/command/_requirestxt.py
@@ -0,0 +1,131 @@
+"""Helper code used to generate ``requires.txt`` files in the egg-info directory.
+
+The ``requires.txt`` file has an specific format:
+    - Environment markers need to be part of the section headers and
+      should not be part of the requirement spec itself.
+
+See https://setuptools.pypa.io/en/latest/deprecated/python_eggs.html#requires-txt
+"""
+
+from __future__ import annotations
+
+import io
+from collections import defaultdict
+from collections.abc import Mapping
+from itertools import filterfalse
+from typing import TypeVar
+
+from jaraco.text import yield_lines
+from packaging.requirements import Requirement
+
+from .. import _reqs
+from .._reqs import _StrOrIter
+
+# dict can work as an ordered set
+_T = TypeVar("_T")
+_Ordered = dict[_T, None]
+
+
+def _prepare(
+    install_requires: _StrOrIter, extras_require: Mapping[str, _StrOrIter]
+) -> tuple[list[str], dict[str, list[str]]]:
+    """Given values for ``install_requires`` and ``extras_require``
+    create modified versions in a way that can be written in ``requires.txt``
+    """
+    extras = _convert_extras_requirements(extras_require)
+    return _move_install_requirements_markers(install_requires, extras)
+
+
+def _convert_extras_requirements(
+    extras_require: Mapping[str, _StrOrIter],
+) -> defaultdict[str, _Ordered[Requirement]]:
+    """
+    Convert requirements in `extras_require` of the form
+    `"extra": ["barbazquux; {marker}"]` to
+    `"extra:{marker}": ["barbazquux"]`.
+    """
+    output = defaultdict[str, _Ordered[Requirement]](dict)
+    for section, v in extras_require.items():
+        # Do not strip empty sections.
+        output[section]
+        for r in _reqs.parse(v):
+            output[section + _suffix_for(r)].setdefault(r)
+
+    return output
+
+
+def _move_install_requirements_markers(
+    install_requires: _StrOrIter, extras_require: Mapping[str, _Ordered[Requirement]]
+) -> tuple[list[str], dict[str, list[str]]]:
+    """
+    The ``requires.txt`` file has an specific format:
+        - Environment markers need to be part of the section headers and
+          should not be part of the requirement spec itself.
+
+    Move requirements in ``install_requires`` that are using environment
+    markers ``extras_require``.
+    """
+
+    # divide the install_requires into two sets, simple ones still
+    # handled by install_requires and more complex ones handled by extras_require.
+
+    inst_reqs = list(_reqs.parse(install_requires))
+    simple_reqs = filter(_no_marker, inst_reqs)
+    complex_reqs = filterfalse(_no_marker, inst_reqs)
+    simple_install_requires = list(map(str, simple_reqs))
+
+    for r in complex_reqs:
+        extras_require[':' + str(r.marker)].setdefault(r)
+
+    expanded_extras = dict(
+        # list(dict.fromkeys(...))  ensures a list of unique strings
+        (k, list(dict.fromkeys(str(r) for r in map(_clean_req, v))))
+        for k, v in extras_require.items()
+    )
+
+    return simple_install_requires, expanded_extras
+
+
+def _suffix_for(req):
+    """Return the 'extras_require' suffix for a given requirement."""
+    return ':' + str(req.marker) if req.marker else ''
+
+
+def _clean_req(req):
+    """Given a Requirement, remove environment markers and return it"""
+    r = Requirement(str(req))  # create a copy before modifying
+    r.marker = None
+    return r
+
+
+def _no_marker(req):
+    return not req.marker
+
+
+def _write_requirements(stream, reqs):
+    lines = yield_lines(reqs or ())
+
+    def append_cr(line):
+        return line + '\n'
+
+    lines = map(append_cr, lines)
+    stream.writelines(lines)
+
+
+def write_requirements(cmd, basename, filename):
+    dist = cmd.distribution
+    data = io.StringIO()
+    install_requires, extras_require = _prepare(
+        dist.install_requires or (), dist.extras_require or {}
+    )
+    _write_requirements(data, install_requires)
+    for extra in sorted(extras_require):
+        data.write('\n[{extra}]\n'.format(**vars()))
+        _write_requirements(data, extras_require[extra])
+    cmd.write_or_delete_file("requirements", filename, data.getvalue())
+
+
+def write_setup_requirements(cmd, basename, filename):
+    data = io.StringIO()
+    _write_requirements(data, cmd.distribution.setup_requires)
+    cmd.write_or_delete_file("setup-requirements", filename, data.getvalue())
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/command/alias.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/command/alias.py
new file mode 100644
index 0000000000000000000000000000000000000000..b8d74af71d4464abf899b9f872b5741f23167165
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/command/alias.py
@@ -0,0 +1,77 @@
+from setuptools.command.setopt import config_file, edit_config, option_base
+
+from distutils.errors import DistutilsOptionError
+
+
+def shquote(arg):
+    """Quote an argument for later parsing by shlex.split()"""
+    for c in '"', "'", "\\", "#":
+        if c in arg:
+            return repr(arg)
+    if arg.split() != [arg]:
+        return repr(arg)
+    return arg
+
+
+class alias(option_base):
+    """Define a shortcut that invokes one or more commands"""
+
+    description = "define a shortcut to invoke one or more commands"
+    command_consumes_arguments = True
+
+    user_options = [
+        ('remove', 'r', 'remove (unset) the alias'),
+    ] + option_base.user_options
+
+    boolean_options = option_base.boolean_options + ['remove']
+
+    def initialize_options(self):
+        option_base.initialize_options(self)
+        self.args = None
+        self.remove = None
+
+    def finalize_options(self) -> None:
+        option_base.finalize_options(self)
+        if self.remove and len(self.args) != 1:
+            raise DistutilsOptionError(
+                "Must specify exactly one argument (the alias name) when using --remove"
+            )
+
+    def run(self) -> None:
+        aliases = self.distribution.get_option_dict('aliases')
+
+        if not self.args:
+            print("Command Aliases")
+            print("---------------")
+            for alias in aliases:
+                print("setup.py alias", format_alias(alias, aliases))
+            return
+
+        elif len(self.args) == 1:
+            (alias,) = self.args
+            if self.remove:
+                command = None
+            elif alias in aliases:
+                print("setup.py alias", format_alias(alias, aliases))
+                return
+            else:
+                print(f"No alias definition found for {alias!r}")
+                return
+        else:
+            alias = self.args[0]
+            command = ' '.join(map(shquote, self.args[1:]))
+
+        edit_config(self.filename, {'aliases': {alias: command}}, self.dry_run)
+
+
+def format_alias(name, aliases):
+    source, command = aliases[name]
+    if source == config_file('global'):
+        source = '--global-config '
+    elif source == config_file('user'):
+        source = '--user-config '
+    elif source == config_file('local'):
+        source = ''
+    else:
+        source = f'--filename={source!r}'
+    return source + name + ' ' + command
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/command/bdist_egg.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/command/bdist_egg.py
new file mode 100644
index 0000000000000000000000000000000000000000..7f66c3ba6a7f554e910800a21c5ccc3733abf07d
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/command/bdist_egg.py
@@ -0,0 +1,479 @@
+"""setuptools.command.bdist_egg
+
+Build .egg distributions"""
+
+from __future__ import annotations
+
+import marshal
+import os
+import re
+import sys
+import textwrap
+from sysconfig import get_path, get_python_version
+from types import CodeType
+from typing import TYPE_CHECKING, Literal
+
+from setuptools import Command
+from setuptools.extension import Library
+
+from .._path import StrPathT, ensure_directory
+
+from distutils import log
+from distutils.dir_util import mkpath, remove_tree
+
+if TYPE_CHECKING:
+    from typing_extensions import TypeAlias
+
+# Same as zipfile._ZipFileMode from typeshed
+_ZipFileMode: TypeAlias = Literal["r", "w", "x", "a"]
+
+
+def _get_purelib():
+    return get_path("purelib")
+
+
+def strip_module(filename):
+    if '.' in filename:
+        filename = os.path.splitext(filename)[0]
+    if filename.endswith('module'):
+        filename = filename[:-6]
+    return filename
+
+
+def sorted_walk(dir):
+    """Do os.walk in a reproducible way,
+    independent of indeterministic filesystem readdir order
+    """
+    for base, dirs, files in os.walk(dir):
+        dirs.sort()
+        files.sort()
+        yield base, dirs, files
+
+
+def write_stub(resource, pyfile) -> None:
+    _stub_template = textwrap.dedent(
+        """
+        def __bootstrap__():
+            global __bootstrap__, __loader__, __file__
+            import sys, pkg_resources, importlib.util
+            __file__ = pkg_resources.resource_filename(__name__, %r)
+            __loader__ = None; del __bootstrap__, __loader__
+            spec = importlib.util.spec_from_file_location(__name__,__file__)
+            mod = importlib.util.module_from_spec(spec)
+            spec.loader.exec_module(mod)
+        __bootstrap__()
+        """
+    ).lstrip()
+    with open(pyfile, 'w', encoding="utf-8") as f:
+        f.write(_stub_template % resource)
+
+
+class bdist_egg(Command):
+    description = 'create an "egg" distribution'
+
+    user_options = [
+        ('bdist-dir=', 'b', "temporary directory for creating the distribution"),
+        (
+            'plat-name=',
+            'p',
+            "platform name to embed in generated filenames "
+            "(by default uses `pkg_resources.get_build_platform()`)",
+        ),
+        ('exclude-source-files', None, "remove all .py files from the generated egg"),
+        (
+            'keep-temp',
+            'k',
+            "keep the pseudo-installation tree around after "
+            "creating the distribution archive",
+        ),
+        ('dist-dir=', 'd', "directory to put final built distributions in"),
+        ('skip-build', None, "skip rebuilding everything (for testing/debugging)"),
+    ]
+
+    boolean_options = ['keep-temp', 'skip-build', 'exclude-source-files']
+
+    def initialize_options(self):
+        self.bdist_dir = None
+        self.plat_name = None
+        self.keep_temp = False
+        self.dist_dir = None
+        self.skip_build = False
+        self.egg_output = None
+        self.exclude_source_files = None
+
+    def finalize_options(self) -> None:
+        ei_cmd = self.ei_cmd = self.get_finalized_command("egg_info")
+        self.egg_info = ei_cmd.egg_info
+
+        if self.bdist_dir is None:
+            bdist_base = self.get_finalized_command('bdist').bdist_base
+            self.bdist_dir = os.path.join(bdist_base, 'egg')
+
+        if self.plat_name is None:
+            from pkg_resources import get_build_platform
+
+            self.plat_name = get_build_platform()
+
+        self.set_undefined_options('bdist', ('dist_dir', 'dist_dir'))
+
+        if self.egg_output is None:
+            # Compute filename of the output egg
+            basename = ei_cmd._get_egg_basename(
+                py_version=get_python_version(),
+                platform=self.distribution.has_ext_modules() and self.plat_name,
+            )
+
+            self.egg_output = os.path.join(self.dist_dir, basename + '.egg')
+
+    def do_install_data(self) -> None:
+        # Hack for packages that install data to install's --install-lib
+        self.get_finalized_command('install').install_lib = self.bdist_dir
+
+        site_packages = os.path.normcase(os.path.realpath(_get_purelib()))
+        old, self.distribution.data_files = self.distribution.data_files, []
+
+        for item in old:
+            if isinstance(item, tuple) and len(item) == 2:
+                if os.path.isabs(item[0]):
+                    realpath = os.path.realpath(item[0])
+                    normalized = os.path.normcase(realpath)
+                    if normalized == site_packages or normalized.startswith(
+                        site_packages + os.sep
+                    ):
+                        item = realpath[len(site_packages) + 1 :], item[1]
+                        # XXX else: raise ???
+            self.distribution.data_files.append(item)
+
+        try:
+            log.info("installing package data to %s", self.bdist_dir)
+            self.call_command('install_data', force=False, root=None)
+        finally:
+            self.distribution.data_files = old
+
+    def get_outputs(self):
+        return [self.egg_output]
+
+    def call_command(self, cmdname, **kw):
+        """Invoke reinitialized command `cmdname` with keyword args"""
+        for dirname in INSTALL_DIRECTORY_ATTRS:
+            kw.setdefault(dirname, self.bdist_dir)
+        kw.setdefault('skip_build', self.skip_build)
+        kw.setdefault('dry_run', self.dry_run)
+        cmd = self.reinitialize_command(cmdname, **kw)
+        self.run_command(cmdname)
+        return cmd
+
+    def run(self):  # noqa: C901  # is too complex (14)  # FIXME
+        # Generate metadata first
+        self.run_command("egg_info")
+        # We run install_lib before install_data, because some data hacks
+        # pull their data path from the install_lib command.
+        log.info("installing library code to %s", self.bdist_dir)
+        instcmd = self.get_finalized_command('install')
+        old_root = instcmd.root
+        instcmd.root = None
+        if self.distribution.has_c_libraries() and not self.skip_build:
+            self.run_command('build_clib')
+        cmd = self.call_command('install_lib', warn_dir=False)
+        instcmd.root = old_root
+
+        all_outputs, ext_outputs = self.get_ext_outputs()
+        self.stubs = []
+        to_compile = []
+        for p, ext_name in enumerate(ext_outputs):
+            filename, _ext = os.path.splitext(ext_name)
+            pyfile = os.path.join(self.bdist_dir, strip_module(filename) + '.py')
+            self.stubs.append(pyfile)
+            log.info("creating stub loader for %s", ext_name)
+            if not self.dry_run:
+                write_stub(os.path.basename(ext_name), pyfile)
+            to_compile.append(pyfile)
+            ext_outputs[p] = ext_name.replace(os.sep, '/')
+
+        if to_compile:
+            cmd.byte_compile(to_compile)
+        if self.distribution.data_files:
+            self.do_install_data()
+
+        # Make the EGG-INFO directory
+        archive_root = self.bdist_dir
+        egg_info = os.path.join(archive_root, 'EGG-INFO')
+        self.mkpath(egg_info)
+        if self.distribution.scripts:
+            script_dir = os.path.join(egg_info, 'scripts')
+            log.info("installing scripts to %s", script_dir)
+            self.call_command('install_scripts', install_dir=script_dir, no_ep=True)
+
+        self.copy_metadata_to(egg_info)
+        native_libs = os.path.join(egg_info, "native_libs.txt")
+        if all_outputs:
+            log.info("writing %s", native_libs)
+            if not self.dry_run:
+                ensure_directory(native_libs)
+                with open(native_libs, 'wt', encoding="utf-8") as libs_file:
+                    libs_file.write('\n'.join(all_outputs))
+                    libs_file.write('\n')
+        elif os.path.isfile(native_libs):
+            log.info("removing %s", native_libs)
+            if not self.dry_run:
+                os.unlink(native_libs)
+
+        write_safety_flag(os.path.join(archive_root, 'EGG-INFO'), self.zip_safe())
+
+        if os.path.exists(os.path.join(self.egg_info, 'depends.txt')):
+            log.warn(
+                "WARNING: 'depends.txt' will not be used by setuptools 0.6!\n"
+                "Use the install_requires/extras_require setup() args instead."
+            )
+
+        if self.exclude_source_files:
+            self.zap_pyfiles()
+
+        # Make the archive
+        make_zipfile(
+            self.egg_output,
+            archive_root,
+            verbose=self.verbose,
+            dry_run=self.dry_run,
+            mode=self.gen_header(),
+        )
+        if not self.keep_temp:
+            remove_tree(self.bdist_dir, dry_run=self.dry_run)
+
+        # Add to 'Distribution.dist_files' so that the "upload" command works
+        getattr(self.distribution, 'dist_files', []).append((
+            'bdist_egg',
+            get_python_version(),
+            self.egg_output,
+        ))
+
+    def zap_pyfiles(self):
+        log.info("Removing .py files from temporary directory")
+        for base, dirs, files in walk_egg(self.bdist_dir):
+            for name in files:
+                path = os.path.join(base, name)
+
+                if name.endswith('.py'):
+                    log.debug("Deleting %s", path)
+                    os.unlink(path)
+
+                if base.endswith('__pycache__'):
+                    path_old = path
+
+                    pattern = r'(?P<name>.+)\.(?P<magic>[^.]+)\.pyc'
+                    m = re.match(pattern, name)
+                    path_new = os.path.join(base, os.pardir, m.group('name') + '.pyc')
+                    log.info(f"Renaming file from [{path_old}] to [{path_new}]")
+                    try:
+                        os.remove(path_new)
+                    except OSError:
+                        pass
+                    os.rename(path_old, path_new)
+
+    def zip_safe(self):
+        safe = getattr(self.distribution, 'zip_safe', None)
+        if safe is not None:
+            return safe
+        log.warn("zip_safe flag not set; analyzing archive contents...")
+        return analyze_egg(self.bdist_dir, self.stubs)
+
+    def gen_header(self) -> Literal["w"]:
+        return 'w'
+
+    def copy_metadata_to(self, target_dir) -> None:
+        "Copy metadata (egg info) to the target_dir"
+        # normalize the path (so that a forward-slash in egg_info will
+        # match using startswith below)
+        norm_egg_info = os.path.normpath(self.egg_info)
+        prefix = os.path.join(norm_egg_info, '')
+        for path in self.ei_cmd.filelist.files:
+            if path.startswith(prefix):
+                target = os.path.join(target_dir, path[len(prefix) :])
+                ensure_directory(target)
+                self.copy_file(path, target)
+
+    def get_ext_outputs(self):
+        """Get a list of relative paths to C extensions in the output distro"""
+
+        all_outputs = []
+        ext_outputs = []
+
+        paths = {self.bdist_dir: ''}
+        for base, dirs, files in sorted_walk(self.bdist_dir):
+            all_outputs.extend(
+                paths[base] + filename
+                for filename in files
+                if os.path.splitext(filename)[1].lower() in NATIVE_EXTENSIONS
+            )
+            for filename in dirs:
+                paths[os.path.join(base, filename)] = paths[base] + filename + '/'
+
+        if self.distribution.has_ext_modules():
+            build_cmd = self.get_finalized_command('build_ext')
+            for ext in build_cmd.extensions:
+                if isinstance(ext, Library):
+                    continue
+                fullname = build_cmd.get_ext_fullname(ext.name)
+                filename = build_cmd.get_ext_filename(fullname)
+                if not os.path.basename(filename).startswith('dl-'):
+                    if os.path.exists(os.path.join(self.bdist_dir, filename)):
+                        ext_outputs.append(filename)
+
+        return all_outputs, ext_outputs
+
+
+NATIVE_EXTENSIONS: dict[str, None] = dict.fromkeys('.dll .so .dylib .pyd'.split())
+
+
+def walk_egg(egg_dir):
+    """Walk an unpacked egg's contents, skipping the metadata directory"""
+    walker = sorted_walk(egg_dir)
+    base, dirs, files = next(walker)
+    if 'EGG-INFO' in dirs:
+        dirs.remove('EGG-INFO')
+    yield base, dirs, files
+    yield from walker
+
+
+def analyze_egg(egg_dir, stubs):
+    # check for existing flag in EGG-INFO
+    for flag, fn in safety_flags.items():
+        if os.path.exists(os.path.join(egg_dir, 'EGG-INFO', fn)):
+            return flag
+    if not can_scan():
+        return False
+    safe = True
+    for base, dirs, files in walk_egg(egg_dir):
+        for name in files:
+            if name.endswith('.py') or name.endswith('.pyw'):
+                continue
+            elif name.endswith('.pyc') or name.endswith('.pyo'):
+                # always scan, even if we already know we're not safe
+                safe = scan_module(egg_dir, base, name, stubs) and safe
+    return safe
+
+
+def write_safety_flag(egg_dir, safe) -> None:
+    # Write or remove zip safety flag file(s)
+    for flag, fn in safety_flags.items():
+        fn = os.path.join(egg_dir, fn)
+        if os.path.exists(fn):
+            if safe is None or bool(safe) != flag:
+                os.unlink(fn)
+        elif safe is not None and bool(safe) == flag:
+            with open(fn, 'wt', encoding="utf-8") as f:
+                f.write('\n')
+
+
+safety_flags = {
+    True: 'zip-safe',
+    False: 'not-zip-safe',
+}
+
+
+def scan_module(egg_dir, base, name, stubs):
+    """Check whether module possibly uses unsafe-for-zipfile stuff"""
+
+    filename = os.path.join(base, name)
+    if filename[:-1] in stubs:
+        return True  # Extension module
+    pkg = base[len(egg_dir) + 1 :].replace(os.sep, '.')
+    module = pkg + (pkg and '.' or '') + os.path.splitext(name)[0]
+    skip = 16  # skip magic & reserved? & date & file size
+    f = open(filename, 'rb')
+    f.read(skip)
+    code = marshal.load(f)
+    f.close()
+    safe = True
+    symbols = dict.fromkeys(iter_symbols(code))
+    for bad in ['__file__', '__path__']:
+        if bad in symbols:
+            log.warn("%s: module references %s", module, bad)
+            safe = False
+    if 'inspect' in symbols:
+        for bad in [
+            'getsource',
+            'getabsfile',
+            'getfile',
+            'getsourcefile',
+            'getsourcelines',
+            'findsource',
+            'getcomments',
+            'getframeinfo',
+            'getinnerframes',
+            'getouterframes',
+            'stack',
+            'trace',
+        ]:
+            if bad in symbols:
+                log.warn("%s: module MAY be using inspect.%s", module, bad)
+                safe = False
+    return safe
+
+
+def iter_symbols(code):
+    """Yield names and strings used by `code` and its nested code objects"""
+    yield from code.co_names
+    for const in code.co_consts:
+        if isinstance(const, str):
+            yield const
+        elif isinstance(const, CodeType):
+            yield from iter_symbols(const)
+
+
+def can_scan() -> bool:
+    if not sys.platform.startswith('java') and sys.platform != 'cli':
+        # CPython, PyPy, etc.
+        return True
+    log.warn("Unable to analyze compiled code on this platform.")
+    log.warn(
+        "Please ask the author to include a 'zip_safe'"
+        " setting (either True or False) in the package's setup.py"
+    )
+    return False
+
+
+# Attribute names of options for commands that might need to be convinced to
+# install to the egg build directory
+
+INSTALL_DIRECTORY_ATTRS = ['install_lib', 'install_dir', 'install_data', 'install_base']
+
+
+def make_zipfile(
+    zip_filename: StrPathT,
+    base_dir,
+    verbose: bool = False,
+    dry_run: bool = False,
+    compress=True,
+    mode: _ZipFileMode = 'w',
+) -> StrPathT:
+    """Create a zip file from all the files under 'base_dir'.  The output
+    zip file will be named 'base_dir' + ".zip".  Uses either the "zipfile"
+    Python module (if available) or the InfoZIP "zip" utility (if installed
+    and found on the default search path).  If neither tool is available,
+    raises DistutilsExecError.  Returns the name of the output zip file.
+    """
+    import zipfile
+
+    mkpath(os.path.dirname(zip_filename), dry_run=dry_run)  # type: ignore[arg-type] # python/mypy#18075
+    log.info("creating '%s' and adding '%s' to it", zip_filename, base_dir)
+
+    def visit(z, dirname, names):
+        for name in names:
+            path = os.path.normpath(os.path.join(dirname, name))
+            if os.path.isfile(path):
+                p = path[len(base_dir) + 1 :]
+                if not dry_run:
+                    z.write(path, p)
+                log.debug("adding '%s'", p)
+
+    compression = zipfile.ZIP_DEFLATED if compress else zipfile.ZIP_STORED
+    if not dry_run:
+        z = zipfile.ZipFile(zip_filename, mode, compression=compression)
+        for dirname, dirs, files in sorted_walk(base_dir):
+            visit(z, dirname, files)
+        z.close()
+    else:
+        for dirname, dirs, files in sorted_walk(base_dir):
+            visit(None, dirname, files)
+    return zip_filename
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/command/bdist_rpm.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/command/bdist_rpm.py
new file mode 100644
index 0000000000000000000000000000000000000000..6dbb27002a8cc7f1cafd4f5cbb75ba39aa7430e2
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/command/bdist_rpm.py
@@ -0,0 +1,42 @@
+from ..dist import Distribution
+from ..warnings import SetuptoolsDeprecationWarning
+
+import distutils.command.bdist_rpm as orig
+
+
+class bdist_rpm(orig.bdist_rpm):
+    """
+    Override the default bdist_rpm behavior to do the following:
+
+    1. Run egg_info to ensure the name and version are properly calculated.
+    2. Always run 'install' using --single-version-externally-managed to
+       disable eggs in RPM distributions.
+    """
+
+    distribution: Distribution  # override distutils.dist.Distribution with setuptools.dist.Distribution
+
+    def run(self) -> None:
+        SetuptoolsDeprecationWarning.emit(
+            "Deprecated command",
+            """
+            bdist_rpm is deprecated and will be removed in a future version.
+            Use bdist_wheel (wheel packages) instead.
+            """,
+            see_url="https://github.com/pypa/setuptools/issues/1988",
+            due_date=(2023, 10, 30),  # Deprecation introduced in 22 Oct 2021.
+        )
+
+        # ensure distro name is up-to-date
+        self.run_command('egg_info')
+
+        orig.bdist_rpm.run(self)
+
+    def _make_spec_file(self):
+        spec = orig.bdist_rpm._make_spec_file(self)
+        return [
+            line.replace(
+                "setup.py install ",
+                "setup.py install --single-version-externally-managed ",
+            ).replace("%setup", "%setup -n %{name}-%{unmangled_version}")
+            for line in spec
+        ]
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/command/bdist_wheel.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/command/bdist_wheel.py
new file mode 100644
index 0000000000000000000000000000000000000000..1e3f637bcc31e6b49f2f9415934f553e9cf55c4a
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/command/bdist_wheel.py
@@ -0,0 +1,604 @@
+"""
+Create a wheel (.whl) distribution.
+
+A wheel is a built archive format.
+"""
+
+from __future__ import annotations
+
+import os
+import re
+import shutil
+import struct
+import sys
+import sysconfig
+import warnings
+from collections.abc import Iterable, Sequence
+from email.generator import BytesGenerator
+from glob import iglob
+from typing import Literal, cast
+from zipfile import ZIP_DEFLATED, ZIP_STORED
+
+from packaging import tags, version as _packaging_version
+from wheel.wheelfile import WheelFile
+
+from .. import Command, __version__, _shutil
+from .._core_metadata import _safe_license_file
+from .._normalization import safer_name
+from ..warnings import SetuptoolsDeprecationWarning
+from .egg_info import egg_info as egg_info_cls
+
+from distutils import log
+
+
+def safe_version(version: str) -> str:
+    """
+    Convert an arbitrary string to a standard version string
+    """
+    try:
+        # normalize the version
+        return str(_packaging_version.Version(version))
+    except _packaging_version.InvalidVersion:
+        version = version.replace(" ", ".")
+        return re.sub("[^A-Za-z0-9.]+", "-", version)
+
+
+setuptools_major_version = int(__version__.split(".")[0])
+
+PY_LIMITED_API_PATTERN = r"cp3\d"
+
+
+def _is_32bit_interpreter() -> bool:
+    return struct.calcsize("P") == 4
+
+
+def python_tag() -> str:
+    return f"py{sys.version_info.major}"
+
+
+def get_platform(archive_root: str | None) -> str:
+    """Return our platform name 'win32', 'linux_x86_64'"""
+    result = sysconfig.get_platform()
+    if result.startswith("macosx") and archive_root is not None:  # pragma: no cover
+        from wheel.macosx_libfile import calculate_macosx_platform_tag
+
+        result = calculate_macosx_platform_tag(archive_root, result)
+    elif _is_32bit_interpreter():
+        if result == "linux-x86_64":
+            # pip pull request #3497
+            result = "linux-i686"
+        elif result == "linux-aarch64":
+            # packaging pull request #234
+            # TODO armv8l, packaging pull request #690 => this did not land
+            # in pip/packaging yet
+            result = "linux-armv7l"
+
+    return result.replace("-", "_")
+
+
+def get_flag(
+    var: str, fallback: bool, expected: bool = True, warn: bool = True
+) -> bool:
+    """Use a fallback value for determining SOABI flags if the needed config
+    var is unset or unavailable."""
+    val = sysconfig.get_config_var(var)
+    if val is None:
+        if warn:
+            warnings.warn(
+                f"Config variable '{var}' is unset, Python ABI tag may be incorrect",
+                RuntimeWarning,
+                stacklevel=2,
+            )
+        return fallback
+    return val == expected
+
+
+def get_abi_tag() -> str | None:
+    """Return the ABI tag based on SOABI (if available) or emulate SOABI (PyPy2)."""
+    soabi: str = sysconfig.get_config_var("SOABI")
+    impl = tags.interpreter_name()
+    if not soabi and impl in ("cp", "pp") and hasattr(sys, "maxunicode"):
+        d = ""
+        u = ""
+        if get_flag("Py_DEBUG", hasattr(sys, "gettotalrefcount"), warn=(impl == "cp")):
+            d = "d"
+
+        abi = f"{impl}{tags.interpreter_version()}{d}{u}"
+    elif soabi and impl == "cp" and soabi.startswith("cpython"):
+        # non-Windows
+        abi = "cp" + soabi.split("-")[1]
+    elif soabi and impl == "cp" and soabi.startswith("cp"):
+        # Windows
+        abi = soabi.split("-")[0]
+        if hasattr(sys, "gettotalrefcount"):
+            # using debug build; append "d" flag
+            abi += "d"
+    elif soabi and impl == "pp":
+        # we want something like pypy36-pp73
+        abi = "-".join(soabi.split("-")[:2])
+        abi = abi.replace(".", "_").replace("-", "_")
+    elif soabi and impl == "graalpy":
+        abi = "-".join(soabi.split("-")[:3])
+        abi = abi.replace(".", "_").replace("-", "_")
+    elif soabi:
+        abi = soabi.replace(".", "_").replace("-", "_")
+    else:
+        abi = None
+
+    return abi
+
+
+def safer_version(version: str) -> str:
+    return safe_version(version).replace("-", "_")
+
+
+class bdist_wheel(Command):
+    description = "create a wheel distribution"
+
+    supported_compressions = {
+        "stored": ZIP_STORED,
+        "deflated": ZIP_DEFLATED,
+    }
+
+    user_options = [
+        ("bdist-dir=", "b", "temporary directory for creating the distribution"),
+        (
+            "plat-name=",
+            "p",
+            "platform name to embed in generated filenames "
+            f"[default: {get_platform(None)}]",
+        ),
+        (
+            "keep-temp",
+            "k",
+            "keep the pseudo-installation tree around after "
+            "creating the distribution archive",
+        ),
+        ("dist-dir=", "d", "directory to put final built distributions in"),
+        ("skip-build", None, "skip rebuilding everything (for testing/debugging)"),
+        (
+            "relative",
+            None,
+            "build the archive using relative paths [default: false]",
+        ),
+        (
+            "owner=",
+            "u",
+            "Owner name used when creating a tar file [default: current user]",
+        ),
+        (
+            "group=",
+            "g",
+            "Group name used when creating a tar file [default: current group]",
+        ),
+        ("universal", None, "*DEPRECATED* make a universal wheel [default: false]"),
+        (
+            "compression=",
+            None,
+            f"zipfile compression (one of: {', '.join(supported_compressions)}) [default: 'deflated']",
+        ),
+        (
+            "python-tag=",
+            None,
+            f"Python implementation compatibility tag [default: '{python_tag()}']",
+        ),
+        (
+            "build-number=",
+            None,
+            "Build number for this particular version. "
+            "As specified in PEP-0427, this must start with a digit. "
+            "[default: None]",
+        ),
+        (
+            "py-limited-api=",
+            None,
+            "Python tag (cp32|cp33|cpNN) for abi3 wheel tag [default: false]",
+        ),
+        (
+            "dist-info-dir=",
+            None,
+            "directory where a pre-generated dist-info can be found (e.g. as a "
+            "result of calling the PEP517 'prepare_metadata_for_build_wheel' "
+            "method)",
+        ),
+    ]
+
+    boolean_options = ["keep-temp", "skip-build", "relative", "universal"]
+
+    def initialize_options(self) -> None:
+        self.bdist_dir: str | None = None
+        self.data_dir = ""
+        self.plat_name: str | None = None
+        self.plat_tag: str | None = None
+        self.format = "zip"
+        self.keep_temp = False
+        self.dist_dir: str | None = None
+        self.dist_info_dir = None
+        self.egginfo_dir: str | None = None
+        self.root_is_pure: bool | None = None
+        self.skip_build = False
+        self.relative = False
+        self.owner = None
+        self.group = None
+        self.universal = False
+        self.compression: str | int = "deflated"
+        self.python_tag = python_tag()
+        self.build_number: str | None = None
+        self.py_limited_api: str | Literal[False] = False
+        self.plat_name_supplied = False
+
+    def finalize_options(self) -> None:
+        if not self.bdist_dir:
+            bdist_base = self.get_finalized_command("bdist").bdist_base
+            self.bdist_dir = os.path.join(bdist_base, "wheel")
+
+        if self.dist_info_dir is None:
+            egg_info = cast(egg_info_cls, self.distribution.get_command_obj("egg_info"))
+            egg_info.ensure_finalized()  # needed for correct `wheel_dist_name`
+
+        self.data_dir = self.wheel_dist_name + ".data"
+        self.plat_name_supplied = bool(self.plat_name)
+
+        need_options = ("dist_dir", "plat_name", "skip_build")
+
+        self.set_undefined_options("bdist", *zip(need_options, need_options))
+
+        self.root_is_pure = not (
+            self.distribution.has_ext_modules() or self.distribution.has_c_libraries()
+        )
+
+        self._validate_py_limited_api()
+
+        # Support legacy [wheel] section for setting universal
+        wheel = self.distribution.get_option_dict("wheel")
+        if "universal" in wheel:  # pragma: no cover
+            # please don't define this in your global configs
+            log.warn("The [wheel] section is deprecated. Use [bdist_wheel] instead.")
+            val = wheel["universal"][1].strip()
+            if val.lower() in ("1", "true", "yes"):
+                self.universal = True
+
+        if self.universal:
+            SetuptoolsDeprecationWarning.emit(
+                "bdist_wheel.universal is deprecated",
+                """
+                With Python 2.7 end-of-life, support for building universal wheels
+                (i.e., wheels that support both Python 2 and Python 3)
+                is being obviated.
+                Please discontinue using this option, or if you still need it,
+                file an issue with pypa/setuptools describing your use case.
+                """,
+                due_date=(2025, 8, 30),  # Introduced in 2024-08-30
+            )
+
+        if self.build_number is not None and not self.build_number[:1].isdigit():
+            raise ValueError("Build tag (build-number) must start with a digit.")
+
+    def _validate_py_limited_api(self) -> None:
+        if not self.py_limited_api:
+            return
+
+        if not re.match(PY_LIMITED_API_PATTERN, self.py_limited_api):
+            raise ValueError(f"py-limited-api must match '{PY_LIMITED_API_PATTERN}'")
+
+        if sysconfig.get_config_var("Py_GIL_DISABLED"):
+            raise ValueError(
+                f"`py_limited_api={self.py_limited_api!r}` not supported. "
+                "`Py_LIMITED_API` is currently incompatible with "
+                "`Py_GIL_DISABLED`."
+                "See https://github.com/python/cpython/issues/111506."
+            )
+
+    @property
+    def wheel_dist_name(self) -> str:
+        """Return distribution full name with - replaced with _"""
+        components = [
+            safer_name(self.distribution.get_name()),
+            safer_version(self.distribution.get_version()),
+        ]
+        if self.build_number:
+            components.append(self.build_number)
+        return "-".join(components)
+
+    def get_tag(self) -> tuple[str, str, str]:
+        # bdist sets self.plat_name if unset, we should only use it for purepy
+        # wheels if the user supplied it.
+        if self.plat_name_supplied and self.plat_name:
+            plat_name = self.plat_name
+        elif self.root_is_pure:
+            plat_name = "any"
+        else:
+            # macosx contains system version in platform name so need special handle
+            if self.plat_name and not self.plat_name.startswith("macosx"):
+                plat_name = self.plat_name
+            else:
+                # on macosx always limit the platform name to comply with any
+                # c-extension modules in bdist_dir, since the user can specify
+                # a higher MACOSX_DEPLOYMENT_TARGET via tools like CMake
+
+                # on other platforms, and on macosx if there are no c-extension
+                # modules, use the default platform name.
+                plat_name = get_platform(self.bdist_dir)
+
+            if _is_32bit_interpreter():
+                if plat_name in ("linux-x86_64", "linux_x86_64"):
+                    plat_name = "linux_i686"
+                if plat_name in ("linux-aarch64", "linux_aarch64"):
+                    # TODO armv8l, packaging pull request #690 => this did not land
+                    # in pip/packaging yet
+                    plat_name = "linux_armv7l"
+
+        plat_name = (
+            plat_name.lower().replace("-", "_").replace(".", "_").replace(" ", "_")
+        )
+
+        if self.root_is_pure:
+            if self.universal:
+                impl = "py2.py3"
+            else:
+                impl = self.python_tag
+            tag = (impl, "none", plat_name)
+        else:
+            impl_name = tags.interpreter_name()
+            impl_ver = tags.interpreter_version()
+            impl = impl_name + impl_ver
+            # We don't work on CPython 3.1, 3.0.
+            if self.py_limited_api and (impl_name + impl_ver).startswith("cp3"):
+                impl = self.py_limited_api
+                abi_tag = "abi3"
+            else:
+                abi_tag = str(get_abi_tag()).lower()
+            tag = (impl, abi_tag, plat_name)
+            # issue gh-374: allow overriding plat_name
+            supported_tags = [
+                (t.interpreter, t.abi, plat_name) for t in tags.sys_tags()
+            ]
+            assert tag in supported_tags, (
+                f"would build wheel with unsupported tag {tag}"
+            )
+        return tag
+
+    def run(self):
+        build_scripts = self.reinitialize_command("build_scripts")
+        build_scripts.executable = "python"
+        build_scripts.force = True
+
+        build_ext = self.reinitialize_command("build_ext")
+        build_ext.inplace = False
+
+        if not self.skip_build:
+            self.run_command("build")
+
+        install = self.reinitialize_command("install", reinit_subcommands=True)
+        install.root = self.bdist_dir
+        install.compile = False
+        install.skip_build = self.skip_build
+        install.warn_dir = False
+
+        # A wheel without setuptools scripts is more cross-platform.
+        # Use the (undocumented) `no_ep` option to setuptools'
+        # install_scripts command to avoid creating entry point scripts.
+        install_scripts = self.reinitialize_command("install_scripts")
+        install_scripts.no_ep = True
+
+        # Use a custom scheme for the archive, because we have to decide
+        # at installation time which scheme to use.
+        for key in ("headers", "scripts", "data", "purelib", "platlib"):
+            setattr(install, "install_" + key, os.path.join(self.data_dir, key))
+
+        basedir_observed = ""
+
+        if os.name == "nt":
+            # win32 barfs if any of these are ''; could be '.'?
+            # (distutils.command.install:change_roots bug)
+            basedir_observed = os.path.normpath(os.path.join(self.data_dir, ".."))
+            self.install_libbase = self.install_lib = basedir_observed
+
+        setattr(
+            install,
+            "install_purelib" if self.root_is_pure else "install_platlib",
+            basedir_observed,
+        )
+
+        log.info(f"installing to {self.bdist_dir}")
+
+        self.run_command("install")
+
+        impl_tag, abi_tag, plat_tag = self.get_tag()
+        archive_basename = f"{self.wheel_dist_name}-{impl_tag}-{abi_tag}-{plat_tag}"
+        if not self.relative:
+            archive_root = self.bdist_dir
+        else:
+            archive_root = os.path.join(
+                self.bdist_dir, self._ensure_relative(install.install_base)
+            )
+
+        self.set_undefined_options("install_egg_info", ("target", "egginfo_dir"))
+        distinfo_dirname = (
+            f"{safer_name(self.distribution.get_name())}-"
+            f"{safer_version(self.distribution.get_version())}.dist-info"
+        )
+        distinfo_dir = os.path.join(self.bdist_dir, distinfo_dirname)
+        if self.dist_info_dir:
+            # Use the given dist-info directly.
+            log.debug(f"reusing {self.dist_info_dir}")
+            shutil.copytree(self.dist_info_dir, distinfo_dir)
+            # Egg info is still generated, so remove it now to avoid it getting
+            # copied into the wheel.
+            _shutil.rmtree(self.egginfo_dir)
+        else:
+            # Convert the generated egg-info into dist-info.
+            self.egg2dist(self.egginfo_dir, distinfo_dir)
+
+        self.write_wheelfile(distinfo_dir)
+
+        # Make the archive
+        if not os.path.exists(self.dist_dir):
+            os.makedirs(self.dist_dir)
+
+        wheel_path = os.path.join(self.dist_dir, archive_basename + ".whl")
+        with WheelFile(wheel_path, "w", self._zip_compression()) as wf:
+            wf.write_files(archive_root)
+
+        # Add to 'Distribution.dist_files' so that the "upload" command works
+        getattr(self.distribution, "dist_files", []).append((
+            "bdist_wheel",
+            f"{sys.version_info.major}.{sys.version_info.minor}",
+            wheel_path,
+        ))
+
+        if not self.keep_temp:
+            log.info(f"removing {self.bdist_dir}")
+            if not self.dry_run:
+                _shutil.rmtree(self.bdist_dir)
+
+    def write_wheelfile(
+        self, wheelfile_base: str, generator: str = f"setuptools ({__version__})"
+    ) -> None:
+        from email.message import Message
+
+        msg = Message()
+        msg["Wheel-Version"] = "1.0"  # of the spec
+        msg["Generator"] = generator
+        msg["Root-Is-Purelib"] = str(self.root_is_pure).lower()
+        if self.build_number is not None:
+            msg["Build"] = self.build_number
+
+        # Doesn't work for bdist_wininst
+        impl_tag, abi_tag, plat_tag = self.get_tag()
+        for impl in impl_tag.split("."):
+            for abi in abi_tag.split("."):
+                for plat in plat_tag.split("."):
+                    msg["Tag"] = "-".join((impl, abi, plat))
+
+        wheelfile_path = os.path.join(wheelfile_base, "WHEEL")
+        log.info(f"creating {wheelfile_path}")
+        with open(wheelfile_path, "wb") as f:
+            BytesGenerator(f, maxheaderlen=0).flatten(msg)
+
+    def _ensure_relative(self, path: str) -> str:
+        # copied from dir_util, deleted
+        drive, path = os.path.splitdrive(path)
+        if path[0:1] == os.sep:
+            path = drive + path[1:]
+        return path
+
+    @property
+    def license_paths(self) -> Iterable[str]:
+        if setuptools_major_version >= 57:
+            # Setuptools has resolved any patterns to actual file names
+            return self.distribution.metadata.license_files or ()
+
+        files = set[str]()
+        metadata = self.distribution.get_option_dict("metadata")
+        if setuptools_major_version >= 42:
+            # Setuptools recognizes the license_files option but does not do globbing
+            patterns = cast(Sequence[str], self.distribution.metadata.license_files)
+        else:
+            # Prior to those, wheel is entirely responsible for handling license files
+            if "license_files" in metadata:
+                patterns = metadata["license_files"][1].split()
+            else:
+                patterns = ()
+
+        if "license_file" in metadata:
+            warnings.warn(
+                'The "license_file" option is deprecated. Use "license_files" instead.',
+                DeprecationWarning,
+                stacklevel=2,
+            )
+            files.add(metadata["license_file"][1])
+
+        if not files and not patterns and not isinstance(patterns, list):
+            patterns = ("LICEN[CS]E*", "COPYING*", "NOTICE*", "AUTHORS*")
+
+        for pattern in patterns:
+            for path in iglob(pattern):
+                if path.endswith("~"):
+                    log.debug(
+                        f'ignoring license file "{path}" as it looks like a backup'
+                    )
+                    continue
+
+                if path not in files and os.path.isfile(path):
+                    log.info(
+                        f'adding license file "{path}" (matched pattern "{pattern}")'
+                    )
+                    files.add(path)
+
+        return files
+
+    def egg2dist(self, egginfo_path: str, distinfo_path: str) -> None:
+        """Convert an .egg-info directory into a .dist-info directory"""
+
+        def adios(p: str) -> None:
+            """Appropriately delete directory, file or link."""
+            if os.path.exists(p) and not os.path.islink(p) and os.path.isdir(p):
+                _shutil.rmtree(p)
+            elif os.path.exists(p):
+                os.unlink(p)
+
+        adios(distinfo_path)
+
+        if not os.path.exists(egginfo_path):
+            # There is no egg-info. This is probably because the egg-info
+            # file/directory is not named matching the distribution name used
+            # to name the archive file. Check for this case and report
+            # accordingly.
+            import glob
+
+            pat = os.path.join(os.path.dirname(egginfo_path), "*.egg-info")
+            possible = glob.glob(pat)
+            err = f"Egg metadata expected at {egginfo_path} but not found"
+            if possible:
+                alt = os.path.basename(possible[0])
+                err += f" ({alt} found - possible misnamed archive file?)"
+
+            raise ValueError(err)
+
+        # .egg-info is a directory
+        pkginfo_path = os.path.join(egginfo_path, "PKG-INFO")
+
+        # ignore common egg metadata that is useless to wheel
+        shutil.copytree(
+            egginfo_path,
+            distinfo_path,
+            ignore=lambda x, y: {
+                "PKG-INFO",
+                "requires.txt",
+                "SOURCES.txt",
+                "not-zip-safe",
+            },
+        )
+
+        # delete dependency_links if it is only whitespace
+        dependency_links_path = os.path.join(distinfo_path, "dependency_links.txt")
+        with open(dependency_links_path, encoding="utf-8") as dependency_links_file:
+            dependency_links = dependency_links_file.read().strip()
+        if not dependency_links:
+            adios(dependency_links_path)
+
+        metadata_path = os.path.join(distinfo_path, "METADATA")
+        shutil.copy(pkginfo_path, metadata_path)
+
+        licenses_folder_path = os.path.join(distinfo_path, "licenses")
+        for license_path in self.license_paths:
+            safe_path = _safe_license_file(license_path)
+            dist_info_license_path = os.path.join(licenses_folder_path, safe_path)
+            os.makedirs(os.path.dirname(dist_info_license_path), exist_ok=True)
+            shutil.copy(license_path, dist_info_license_path)
+
+        adios(egginfo_path)
+
+    def _zip_compression(self) -> int:
+        if (
+            isinstance(self.compression, int)
+            and self.compression in self.supported_compressions.values()
+        ):
+            return self.compression
+
+        compression = self.supported_compressions.get(str(self.compression))
+        if compression is not None:
+            return compression
+
+        raise ValueError(f"Unsupported compression: {self.compression!r}")
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/command/build.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/command/build.py
new file mode 100644
index 0000000000000000000000000000000000000000..54cbb8d2e7bf41de4e187613718879f2a4c3d8d3
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/command/build.py
@@ -0,0 +1,135 @@
+from __future__ import annotations
+
+from typing import Protocol
+
+from ..dist import Distribution
+
+from distutils.command.build import build as _build
+
+_ORIGINAL_SUBCOMMANDS = {"build_py", "build_clib", "build_ext", "build_scripts"}
+
+
+class build(_build):
+    distribution: Distribution  # override distutils.dist.Distribution with setuptools.dist.Distribution
+
+    # copy to avoid sharing the object with parent class
+    sub_commands = _build.sub_commands[:]
+
+
+class SubCommand(Protocol):
+    """In order to support editable installations (see :pep:`660`) all
+    build subcommands **SHOULD** implement this protocol. They also **MUST** inherit
+    from ``setuptools.Command``.
+
+    When creating an :pep:`editable wheel <660>`, ``setuptools`` will try to evaluate
+    custom ``build`` subcommands using the following procedure:
+
+    1. ``setuptools`` will set the ``editable_mode`` attribute to ``True``
+    2. ``setuptools`` will execute the ``run()`` command.
+
+       .. important::
+          Subcommands **SHOULD** take advantage of ``editable_mode=True`` to adequate
+          its behaviour or perform optimisations.
+
+          For example, if a subcommand doesn't need to generate an extra file and
+          all it does is to copy a source file into the build directory,
+          ``run()`` **SHOULD** simply "early return".
+
+          Similarly, if the subcommand creates files that would be placed alongside
+          Python files in the final distribution, during an editable install
+          the command **SHOULD** generate these files "in place" (i.e. write them to
+          the original source directory, instead of using the build directory).
+          Note that ``get_output_mapping()`` should reflect that and include mappings
+          for "in place" builds accordingly.
+
+    3. ``setuptools`` use any knowledge it can derive from the return values of
+       ``get_outputs()`` and ``get_output_mapping()`` to create an editable wheel.
+       When relevant ``setuptools`` **MAY** attempt to use file links based on the value
+       of ``get_output_mapping()``. Alternatively, ``setuptools`` **MAY** attempt to use
+       :doc:`import hooks <python:reference/import>` to redirect any attempt to import
+       to the directory with the original source code and other files built in place.
+
+    Please note that custom sub-commands **SHOULD NOT** rely on ``run()`` being
+    executed (or not) to provide correct return values for ``get_outputs()``,
+    ``get_output_mapping()`` or ``get_source_files()``. The ``get_*`` methods should
+    work independently of ``run()``.
+    """
+
+    editable_mode: bool = False
+    """Boolean flag that will be set to ``True`` when setuptools is used for an
+    editable installation (see :pep:`660`).
+    Implementations **SHOULD** explicitly set the default value of this attribute to
+    ``False``.
+    When subcommands run, they can use this flag to perform optimizations or change
+    their behaviour accordingly.
+    """
+
+    build_lib: str
+    """String representing the directory where the build artifacts should be stored,
+    e.g. ``build/lib``.
+    For example, if a distribution wants to provide a Python module named ``pkg.mod``,
+    then a corresponding file should be written to ``{build_lib}/package/module.py``.
+    A way of thinking about this is that the files saved under ``build_lib``
+    would be eventually copied to one of the directories in :obj:`site.PREFIXES`
+    upon installation.
+
+    A command that produces platform-independent files (e.g. compiling text templates
+    into Python functions), **CAN** initialize ``build_lib`` by copying its value from
+    the ``build_py`` command. On the other hand, a command that produces
+    platform-specific files **CAN** initialize ``build_lib`` by copying its value from
+    the ``build_ext`` command. In general this is done inside the ``finalize_options``
+    method with the help of the ``set_undefined_options`` command::
+
+        def finalize_options(self):
+            self.set_undefined_options("build_py", ("build_lib", "build_lib"))
+            ...
+    """
+
+    def initialize_options(self) -> None:
+        """(Required by the original :class:`setuptools.Command` interface)"""
+        ...
+
+    def finalize_options(self) -> None:
+        """(Required by the original :class:`setuptools.Command` interface)"""
+        ...
+
+    def run(self) -> None:
+        """(Required by the original :class:`setuptools.Command` interface)"""
+        ...
+
+    def get_source_files(self) -> list[str]:
+        """
+        Return a list of all files that are used by the command to create the expected
+        outputs.
+        For example, if your build command transpiles Java files into Python, you should
+        list here all the Java files.
+        The primary purpose of this function is to help populating the ``sdist``
+        with all the files necessary to build the distribution.
+        All files should be strings relative to the project root directory.
+        """
+        ...
+
+    def get_outputs(self) -> list[str]:
+        """
+        Return a list of files intended for distribution as they would have been
+        produced by the build.
+        These files should be strings in the form of
+        ``"{build_lib}/destination/file/path"``.
+
+        .. note::
+           The return value of ``get_output()`` should include all files used as keys
+           in ``get_output_mapping()`` plus files that are generated during the build
+           and don't correspond to any source file already present in the project.
+        """
+        ...
+
+    def get_output_mapping(self) -> dict[str, str]:
+        """
+        Return a mapping between destination files as they would be produced by the
+        build (dict keys) into the respective existing (source) files (dict values).
+        Existing (source) files should be represented as strings relative to the project
+        root directory.
+        Destination files should be strings in the form of
+        ``"{build_lib}/destination/file/path"``.
+        """
+        ...
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/command/build_clib.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/command/build_clib.py
new file mode 100644
index 0000000000000000000000000000000000000000..f376f4ce4d2afc4a58f1fa0e85624136edc93835
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/command/build_clib.py
@@ -0,0 +1,103 @@
+from ..dist import Distribution
+from ..modified import newer_pairwise_group
+
+import distutils.command.build_clib as orig
+from distutils import log
+from distutils.errors import DistutilsSetupError
+
+
+class build_clib(orig.build_clib):
+    """
+    Override the default build_clib behaviour to do the following:
+
+    1. Implement a rudimentary timestamp-based dependency system
+       so 'compile()' doesn't run every time.
+    2. Add more keys to the 'build_info' dictionary:
+        * obj_deps - specify dependencies for each object compiled.
+                     this should be a dictionary mapping a key
+                     with the source filename to a list of
+                     dependencies. Use an empty string for global
+                     dependencies.
+        * cflags   - specify a list of additional flags to pass to
+                     the compiler.
+    """
+
+    distribution: Distribution  # override distutils.dist.Distribution with setuptools.dist.Distribution
+
+    def build_libraries(self, libraries) -> None:
+        for lib_name, build_info in libraries:
+            sources = build_info.get('sources')
+            if sources is None or not isinstance(sources, (list, tuple)):
+                raise DistutilsSetupError(
+                    f"in 'libraries' option (library '{lib_name}'), "
+                    "'sources' must be present and must be "
+                    "a list of source filenames"
+                )
+            sources = sorted(list(sources))
+
+            log.info("building '%s' library", lib_name)
+
+            # Make sure everything is the correct type.
+            # obj_deps should be a dictionary of keys as sources
+            # and a list/tuple of files that are its dependencies.
+            obj_deps = build_info.get('obj_deps', dict())
+            if not isinstance(obj_deps, dict):
+                raise DistutilsSetupError(
+                    f"in 'libraries' option (library '{lib_name}'), "
+                    "'obj_deps' must be a dictionary of "
+                    "type 'source: list'"
+                )
+            dependencies = []
+
+            # Get the global dependencies that are specified by the '' key.
+            # These will go into every source's dependency list.
+            global_deps = obj_deps.get('', list())
+            if not isinstance(global_deps, (list, tuple)):
+                raise DistutilsSetupError(
+                    f"in 'libraries' option (library '{lib_name}'), "
+                    "'obj_deps' must be a dictionary of "
+                    "type 'source: list'"
+                )
+
+            # Build the list to be used by newer_pairwise_group
+            # each source will be auto-added to its dependencies.
+            for source in sources:
+                src_deps = [source]
+                src_deps.extend(global_deps)
+                extra_deps = obj_deps.get(source, list())
+                if not isinstance(extra_deps, (list, tuple)):
+                    raise DistutilsSetupError(
+                        f"in 'libraries' option (library '{lib_name}'), "
+                        "'obj_deps' must be a dictionary of "
+                        "type 'source: list'"
+                    )
+                src_deps.extend(extra_deps)
+                dependencies.append(src_deps)
+
+            expected_objects = self.compiler.object_filenames(
+                sources,
+                output_dir=self.build_temp,
+            )
+
+            if newer_pairwise_group(dependencies, expected_objects) != ([], []):
+                # First, compile the source code to object files in the library
+                # directory.  (This should probably change to putting object
+                # files in a temporary build directory.)
+                macros = build_info.get('macros')
+                include_dirs = build_info.get('include_dirs')
+                cflags = build_info.get('cflags')
+                self.compiler.compile(
+                    sources,
+                    output_dir=self.build_temp,
+                    macros=macros,
+                    include_dirs=include_dirs,
+                    extra_postargs=cflags,
+                    debug=self.debug,
+                )
+
+            # Now "link" the object files together into a static library.
+            # (On Unix at least, this isn't really linking -- it just
+            # builds an archive.  Whatever.)
+            self.compiler.create_static_lib(
+                expected_objects, lib_name, output_dir=self.build_clib, debug=self.debug
+            )
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/command/build_ext.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/command/build_ext.py
new file mode 100644
index 0000000000000000000000000000000000000000..be833a379c71c3a6b1a85a89f8e9703c66d79824
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/command/build_ext.py
@@ -0,0 +1,469 @@
+from __future__ import annotations
+
+import itertools
+import os
+import sys
+from collections.abc import Iterator
+from importlib.machinery import EXTENSION_SUFFIXES
+from importlib.util import cache_from_source as _compiled_file_name
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from setuptools.dist import Distribution
+from setuptools.errors import BaseError
+from setuptools.extension import Extension, Library
+
+from distutils import log
+from distutils.ccompiler import new_compiler
+from distutils.sysconfig import customize_compiler, get_config_var
+
+if TYPE_CHECKING:
+    # Cython not installed on CI tests, causing _build_ext to be `Any`
+    from distutils.command.build_ext import build_ext as _build_ext
+else:
+    try:
+        # Attempt to use Cython for building extensions, if available
+        from Cython.Distutils.build_ext import build_ext as _build_ext
+
+        # Additionally, assert that the compiler module will load
+        # also. Ref #1229.
+        __import__('Cython.Compiler.Main')
+    except ImportError:
+        from distutils.command.build_ext import build_ext as _build_ext
+
+# make sure _config_vars is initialized
+get_config_var("LDSHARED")
+# Not publicly exposed in typeshed distutils stubs, but this is done on purpose
+# See https://github.com/pypa/setuptools/pull/4228#issuecomment-1959856400
+from distutils.sysconfig import _config_vars as _CONFIG_VARS  # noqa: E402
+
+
+def _customize_compiler_for_shlib(compiler):
+    if sys.platform == "darwin":
+        # building .dylib requires additional compiler flags on OSX; here we
+        # temporarily substitute the pyconfig.h variables so that distutils'
+        # 'customize_compiler' uses them before we build the shared libraries.
+        tmp = _CONFIG_VARS.copy()
+        try:
+            # XXX Help!  I don't have any idea whether these are right...
+            _CONFIG_VARS['LDSHARED'] = (
+                "gcc -Wl,-x -dynamiclib -undefined dynamic_lookup"
+            )
+            _CONFIG_VARS['CCSHARED'] = " -dynamiclib"
+            _CONFIG_VARS['SO'] = ".dylib"
+            customize_compiler(compiler)
+        finally:
+            _CONFIG_VARS.clear()
+            _CONFIG_VARS.update(tmp)
+    else:
+        customize_compiler(compiler)
+
+
+have_rtld = False
+use_stubs = False
+libtype = 'shared'
+
+if sys.platform == "darwin":
+    use_stubs = True
+elif os.name != 'nt':
+    try:
+        import dl  # type: ignore[import-not-found] # https://github.com/python/mypy/issues/13002
+
+        use_stubs = have_rtld = hasattr(dl, 'RTLD_NOW')
+    except ImportError:
+        pass
+
+
+def if_dl(s):
+    return s if have_rtld else ''
+
+
+def get_abi3_suffix():
+    """Return the file extension for an abi3-compliant Extension()"""
+    for suffix in EXTENSION_SUFFIXES:
+        if '.abi3' in suffix:  # Unix
+            return suffix
+        elif suffix == '.pyd':  # Windows
+            return suffix
+    return None
+
+
+class build_ext(_build_ext):
+    distribution: Distribution  # override distutils.dist.Distribution with setuptools.dist.Distribution
+    editable_mode = False
+    inplace = False
+
+    def run(self):
+        """Build extensions in build directory, then copy if --inplace"""
+        old_inplace, self.inplace = self.inplace, False
+        _build_ext.run(self)
+        self.inplace = old_inplace
+        if old_inplace:
+            self.copy_extensions_to_source()
+
+    def _get_inplace_equivalent(self, build_py, ext: Extension) -> tuple[str, str]:
+        fullname = self.get_ext_fullname(ext.name)
+        filename = self.get_ext_filename(fullname)
+        modpath = fullname.split('.')
+        package = '.'.join(modpath[:-1])
+        package_dir = build_py.get_package_dir(package)
+        inplace_file = os.path.join(package_dir, os.path.basename(filename))
+        regular_file = os.path.join(self.build_lib, filename)
+        return (inplace_file, regular_file)
+
+    def copy_extensions_to_source(self) -> None:
+        build_py = self.get_finalized_command('build_py')
+        for ext in self.extensions:
+            inplace_file, regular_file = self._get_inplace_equivalent(build_py, ext)
+
+            # Always copy, even if source is older than destination, to ensure
+            # that the right extensions for the current Python/platform are
+            # used.
+            if os.path.exists(regular_file) or not ext.optional:
+                self.copy_file(regular_file, inplace_file, level=self.verbose)
+
+            if ext._needs_stub:
+                inplace_stub = self._get_equivalent_stub(ext, inplace_file)
+                self._write_stub_file(inplace_stub, ext, compile=True)
+                # Always compile stub and remove the original (leave the cache behind)
+                # (this behaviour was observed in previous iterations of the code)
+
+    def _get_equivalent_stub(self, ext: Extension, output_file: str) -> str:
+        dir_ = os.path.dirname(output_file)
+        _, _, name = ext.name.rpartition(".")
+        return f"{os.path.join(dir_, name)}.py"
+
+    def _get_output_mapping(self) -> Iterator[tuple[str, str]]:
+        if not self.inplace:
+            return
+
+        build_py = self.get_finalized_command('build_py')
+        opt = self.get_finalized_command('install_lib').optimize or ""
+
+        for ext in self.extensions:
+            inplace_file, regular_file = self._get_inplace_equivalent(build_py, ext)
+            yield (regular_file, inplace_file)
+
+            if ext._needs_stub:
+                # This version of `build_ext` always builds artifacts in another dir,
+                # when "inplace=True" is given it just copies them back.
+                # This is done in the `copy_extensions_to_source` function, which
+                # always compile stub files via `_compile_and_remove_stub`.
+                # At the end of the process, a `.pyc` stub file is created without the
+                # corresponding `.py`.
+
+                inplace_stub = self._get_equivalent_stub(ext, inplace_file)
+                regular_stub = self._get_equivalent_stub(ext, regular_file)
+                inplace_cache = _compiled_file_name(inplace_stub, optimization=opt)
+                output_cache = _compiled_file_name(regular_stub, optimization=opt)
+                yield (output_cache, inplace_cache)
+
+    def get_ext_filename(self, fullname: str) -> str:
+        so_ext = os.getenv('SETUPTOOLS_EXT_SUFFIX')
+        if so_ext:
+            filename = os.path.join(*fullname.split('.')) + so_ext
+        else:
+            filename = _build_ext.get_ext_filename(self, fullname)
+            ext_suffix = get_config_var('EXT_SUFFIX')
+            if not isinstance(ext_suffix, str):
+                raise OSError(
+                    "Configuration variable EXT_SUFFIX not found for this platform "
+                    "and environment variable SETUPTOOLS_EXT_SUFFIX is missing"
+                )
+            so_ext = ext_suffix
+
+        if fullname in self.ext_map:
+            ext = self.ext_map[fullname]
+            abi3_suffix = get_abi3_suffix()
+            if ext.py_limited_api and abi3_suffix:  # Use abi3
+                filename = filename[: -len(so_ext)] + abi3_suffix
+            if isinstance(ext, Library):
+                fn, ext = os.path.splitext(filename)
+                return self.shlib_compiler.library_filename(fn, libtype)
+            elif use_stubs and ext._links_to_dynamic:
+                d, fn = os.path.split(filename)
+                return os.path.join(d, 'dl-' + fn)
+        return filename
+
+    def initialize_options(self):
+        _build_ext.initialize_options(self)
+        self.shlib_compiler = None
+        self.shlibs = []
+        self.ext_map = {}
+        self.editable_mode = False
+
+    def finalize_options(self) -> None:
+        _build_ext.finalize_options(self)
+        self.extensions = self.extensions or []
+        self.check_extensions_list(self.extensions)
+        self.shlibs = [ext for ext in self.extensions if isinstance(ext, Library)]
+        if self.shlibs:
+            self.setup_shlib_compiler()
+        for ext in self.extensions:
+            ext._full_name = self.get_ext_fullname(ext.name)
+        for ext in self.extensions:
+            fullname = ext._full_name
+            self.ext_map[fullname] = ext
+
+            # distutils 3.1 will also ask for module names
+            # XXX what to do with conflicts?
+            self.ext_map[fullname.split('.')[-1]] = ext
+
+            ltd = self.shlibs and self.links_to_dynamic(ext) or False
+            ns = ltd and use_stubs and not isinstance(ext, Library)
+            ext._links_to_dynamic = ltd
+            ext._needs_stub = ns
+            filename = ext._file_name = self.get_ext_filename(fullname)
+            libdir = os.path.dirname(os.path.join(self.build_lib, filename))
+            if ltd and libdir not in ext.library_dirs:
+                ext.library_dirs.append(libdir)
+            if ltd and use_stubs and os.curdir not in ext.runtime_library_dirs:
+                ext.runtime_library_dirs.append(os.curdir)
+
+        if self.editable_mode:
+            self.inplace = True
+
+    def setup_shlib_compiler(self):
+        compiler = self.shlib_compiler = new_compiler(
+            compiler=self.compiler, dry_run=self.dry_run, force=self.force
+        )
+        _customize_compiler_for_shlib(compiler)
+
+        if self.include_dirs is not None:
+            compiler.set_include_dirs(self.include_dirs)
+        if self.define is not None:
+            # 'define' option is a list of (name,value) tuples
+            for name, value in self.define:
+                compiler.define_macro(name, value)
+        if self.undef is not None:
+            for macro in self.undef:
+                compiler.undefine_macro(macro)
+        if self.libraries is not None:
+            compiler.set_libraries(self.libraries)
+        if self.library_dirs is not None:
+            compiler.set_library_dirs(self.library_dirs)
+        if self.rpath is not None:
+            compiler.set_runtime_library_dirs(self.rpath)
+        if self.link_objects is not None:
+            compiler.set_link_objects(self.link_objects)
+
+        # hack so distutils' build_extension() builds a library instead
+        compiler.link_shared_object = link_shared_object.__get__(compiler)  # type: ignore[method-assign]
+
+    def get_export_symbols(self, ext):
+        if isinstance(ext, Library):
+            return ext.export_symbols
+        return _build_ext.get_export_symbols(self, ext)
+
+    def build_extension(self, ext) -> None:
+        ext._convert_pyx_sources_to_lang()
+        _compiler = self.compiler
+        try:
+            if isinstance(ext, Library):
+                self.compiler = self.shlib_compiler
+            _build_ext.build_extension(self, ext)
+            if ext._needs_stub:
+                build_lib = self.get_finalized_command('build_py').build_lib
+                self.write_stub(build_lib, ext)
+        finally:
+            self.compiler = _compiler
+
+    def links_to_dynamic(self, ext):
+        """Return true if 'ext' links to a dynamic lib in the same package"""
+        # XXX this should check to ensure the lib is actually being built
+        # XXX as dynamic, and not just using a locally-found version or a
+        # XXX static-compiled version
+        libnames = dict.fromkeys([lib._full_name for lib in self.shlibs])
+        pkg = '.'.join(ext._full_name.split('.')[:-1] + [''])
+        return any(pkg + libname in libnames for libname in ext.libraries)
+
+    def get_source_files(self) -> list[str]:
+        return [*_build_ext.get_source_files(self), *self._get_internal_depends()]
+
+    def _get_internal_depends(self) -> Iterator[str]:
+        """Yield ``ext.depends`` that are contained by the project directory"""
+        project_root = Path(self.distribution.src_root or os.curdir).resolve()
+        depends = (dep for ext in self.extensions for dep in ext.depends)
+
+        def skip(orig_path: str, reason: str) -> None:
+            log.info(
+                "dependency %s won't be automatically "
+                "included in the manifest: the path %s",
+                orig_path,
+                reason,
+            )
+
+        for dep in depends:
+            path = Path(dep)
+
+            if path.is_absolute():
+                skip(dep, "must be relative")
+                continue
+
+            if ".." in path.parts:
+                skip(dep, "can't have `..` segments")
+                continue
+
+            try:
+                resolved = (project_root / path).resolve(strict=True)
+            except OSError:
+                skip(dep, "doesn't exist")
+                continue
+
+            try:
+                resolved.relative_to(project_root)
+            except ValueError:
+                skip(dep, "must be inside the project root")
+                continue
+
+            yield path.as_posix()
+
+    def get_outputs(self) -> list[str]:
+        if self.inplace:
+            return list(self.get_output_mapping().keys())
+        return sorted(_build_ext.get_outputs(self) + self.__get_stubs_outputs())
+
+    def get_output_mapping(self) -> dict[str, str]:
+        """See :class:`setuptools.commands.build.SubCommand`"""
+        mapping = self._get_output_mapping()
+        return dict(sorted(mapping, key=lambda x: x[0]))
+
+    def __get_stubs_outputs(self):
+        # assemble the base name for each extension that needs a stub
+        ns_ext_bases = (
+            os.path.join(self.build_lib, *ext._full_name.split('.'))
+            for ext in self.extensions
+            if ext._needs_stub
+        )
+        # pair each base with the extension
+        pairs = itertools.product(ns_ext_bases, self.__get_output_extensions())
+        return list(base + fnext for base, fnext in pairs)
+
+    def __get_output_extensions(self):
+        yield '.py'
+        yield '.pyc'
+        if self.get_finalized_command('build_py').optimize:
+            yield '.pyo'
+
+    def write_stub(self, output_dir, ext, compile=False) -> None:
+        stub_file = os.path.join(output_dir, *ext._full_name.split('.')) + '.py'
+        self._write_stub_file(stub_file, ext, compile)
+
+    def _write_stub_file(self, stub_file: str, ext: Extension, compile=False):
+        log.info("writing stub loader for %s to %s", ext._full_name, stub_file)
+        if compile and os.path.exists(stub_file):
+            raise BaseError(stub_file + " already exists! Please delete.")
+        if not self.dry_run:
+            with open(stub_file, 'w', encoding="utf-8") as f:
+                content = '\n'.join([
+                    "def __bootstrap__():",
+                    "   global __bootstrap__, __file__, __loader__",
+                    "   import sys, os, pkg_resources, importlib.util" + if_dl(", dl"),
+                    "   __file__ = pkg_resources.resource_filename"
+                    f"(__name__,{os.path.basename(ext._file_name)!r})",
+                    "   del __bootstrap__",
+                    "   if '__loader__' in globals():",
+                    "       del __loader__",
+                    if_dl("   old_flags = sys.getdlopenflags()"),
+                    "   old_dir = os.getcwd()",
+                    "   try:",
+                    "     os.chdir(os.path.dirname(__file__))",
+                    if_dl("     sys.setdlopenflags(dl.RTLD_NOW)"),
+                    "     spec = importlib.util.spec_from_file_location(",
+                    "                __name__, __file__)",
+                    "     mod = importlib.util.module_from_spec(spec)",
+                    "     spec.loader.exec_module(mod)",
+                    "   finally:",
+                    if_dl("     sys.setdlopenflags(old_flags)"),
+                    "     os.chdir(old_dir)",
+                    "__bootstrap__()",
+                    "",  # terminal \n
+                ])
+                f.write(content)
+        if compile:
+            self._compile_and_remove_stub(stub_file)
+
+    def _compile_and_remove_stub(self, stub_file: str):
+        from distutils.util import byte_compile
+
+        byte_compile([stub_file], optimize=0, force=True, dry_run=self.dry_run)
+        optimize = self.get_finalized_command('install_lib').optimize
+        if optimize > 0:
+            byte_compile(
+                [stub_file],
+                optimize=optimize,
+                force=True,
+                dry_run=self.dry_run,
+            )
+        if os.path.exists(stub_file) and not self.dry_run:
+            os.unlink(stub_file)
+
+
+if use_stubs or os.name == 'nt':
+    # Build shared libraries
+    #
+    def link_shared_object(
+        self,
+        objects,
+        output_libname,
+        output_dir=None,
+        libraries=None,
+        library_dirs=None,
+        runtime_library_dirs=None,
+        export_symbols=None,
+        debug: bool = False,
+        extra_preargs=None,
+        extra_postargs=None,
+        build_temp=None,
+        target_lang=None,
+    ) -> None:
+        self.link(
+            self.SHARED_LIBRARY,
+            objects,
+            output_libname,
+            output_dir,
+            libraries,
+            library_dirs,
+            runtime_library_dirs,
+            export_symbols,
+            debug,
+            extra_preargs,
+            extra_postargs,
+            build_temp,
+            target_lang,
+        )
+
+else:
+    # Build static libraries everywhere else
+    libtype = 'static'
+
+    def link_shared_object(
+        self,
+        objects,
+        output_libname,
+        output_dir=None,
+        libraries=None,
+        library_dirs=None,
+        runtime_library_dirs=None,
+        export_symbols=None,
+        debug: bool = False,
+        extra_preargs=None,
+        extra_postargs=None,
+        build_temp=None,
+        target_lang=None,
+    ) -> None:
+        # XXX we need to either disallow these attrs on Library instances,
+        # or warn/abort here if set, or something...
+        # libraries=None, library_dirs=None, runtime_library_dirs=None,
+        # export_symbols=None, extra_preargs=None, extra_postargs=None,
+        # build_temp=None
+
+        assert output_dir is None  # distutils build_ext doesn't pass this
+        output_dir, filename = os.path.split(output_libname)
+        basename, _ext = os.path.splitext(filename)
+        if self.library_filename("x").startswith('lib'):
+            # strip 'lib' prefix; this is kludgy if some platform uses
+            # a different prefix
+            basename = basename[3:]
+
+        self.create_static_lib(objects, basename, output_dir, debug, target_lang)
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/command/build_py.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/command/build_py.py
new file mode 100644
index 0000000000000000000000000000000000000000..2f6fcb7cdcb39a61007acbb399c84125cce93c9f
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/command/build_py.py
@@ -0,0 +1,400 @@
+from __future__ import annotations
+
+import fnmatch
+import itertools
+import os
+import stat
+import textwrap
+from collections.abc import Iterable, Iterator
+from functools import partial
+from glob import glob
+from pathlib import Path
+
+from more_itertools import unique_everseen
+
+from .._path import StrPath, StrPathT
+from ..dist import Distribution
+from ..warnings import SetuptoolsDeprecationWarning
+
+import distutils.command.build_py as orig
+import distutils.errors
+from distutils.util import convert_path
+
+_IMPLICIT_DATA_FILES = ('*.pyi', 'py.typed')
+
+
+def make_writable(target) -> None:
+    os.chmod(target, os.stat(target).st_mode | stat.S_IWRITE)
+
+
+class build_py(orig.build_py):
+    """Enhanced 'build_py' command that includes data files with packages
+
+    The data files are specified via a 'package_data' argument to 'setup()'.
+    See 'setuptools.dist.Distribution' for more details.
+
+    Also, this version of the 'build_py' command allows you to specify both
+    'py_modules' and 'packages' in the same setup operation.
+    """
+
+    distribution: Distribution  # override distutils.dist.Distribution with setuptools.dist.Distribution
+    editable_mode: bool = False
+    existing_egg_info_dir: StrPath | None = None  #: Private API, internal use only.
+
+    def finalize_options(self):
+        orig.build_py.finalize_options(self)
+        self.package_data = self.distribution.package_data
+        self.exclude_package_data = self.distribution.exclude_package_data or {}
+        if 'data_files' in self.__dict__:
+            del self.__dict__['data_files']
+
+    def copy_file(  # type: ignore[override] # No overload, no bytes support
+        self,
+        infile: StrPath,
+        outfile: StrPathT,
+        preserve_mode: bool = True,
+        preserve_times: bool = True,
+        link: str | None = None,
+        level: object = 1,
+    ) -> tuple[StrPathT | str, bool]:
+        # Overwrite base class to allow using links
+        if link:
+            infile = str(Path(infile).resolve())
+            outfile = str(Path(outfile).resolve())  # type: ignore[assignment] # Re-assigning a str when outfile is StrPath is ok
+        return super().copy_file(  # pyright: ignore[reportReturnType] # pypa/distutils#309
+            infile, outfile, preserve_mode, preserve_times, link, level
+        )
+
+    def run(self) -> None:
+        """Build modules, packages, and copy data files to build directory"""
+        if not (self.py_modules or self.packages) or self.editable_mode:
+            return
+
+        if self.py_modules:
+            self.build_modules()
+
+        if self.packages:
+            self.build_packages()
+            self.build_package_data()
+
+        # Only compile actual .py files, using our base class' idea of what our
+        # output files are.
+        self.byte_compile(orig.build_py.get_outputs(self, include_bytecode=False))
+
+    def __getattr__(self, attr: str):
+        "lazily compute data files"
+        if attr == 'data_files':
+            self.data_files = self._get_data_files()
+            return self.data_files
+        return orig.build_py.__getattr__(self, attr)
+
+    def _get_data_files(self):
+        """Generate list of '(package,src_dir,build_dir,filenames)' tuples"""
+        self.analyze_manifest()
+        return list(map(self._get_pkg_data_files, self.packages or ()))
+
+    def get_data_files_without_manifest(self):
+        """
+        Generate list of ``(package,src_dir,build_dir,filenames)`` tuples,
+        but without triggering any attempt to analyze or build the manifest.
+        """
+        # Prevent eventual errors from unset `manifest_files`
+        # (that would otherwise be set by `analyze_manifest`)
+        self.__dict__.setdefault('manifest_files', {})
+        return list(map(self._get_pkg_data_files, self.packages or ()))
+
+    def _get_pkg_data_files(self, package):
+        # Locate package source directory
+        src_dir = self.get_package_dir(package)
+
+        # Compute package build directory
+        build_dir = os.path.join(*([self.build_lib] + package.split('.')))
+
+        # Strip directory from globbed filenames
+        filenames = [
+            os.path.relpath(file, src_dir)
+            for file in self.find_data_files(package, src_dir)
+        ]
+        return package, src_dir, build_dir, filenames
+
+    def find_data_files(self, package, src_dir):
+        """Return filenames for package's data files in 'src_dir'"""
+        patterns = self._get_platform_patterns(
+            self.package_data,
+            package,
+            src_dir,
+            extra_patterns=_IMPLICIT_DATA_FILES,
+        )
+        globs_expanded = map(partial(glob, recursive=True), patterns)
+        # flatten the expanded globs into an iterable of matches
+        globs_matches = itertools.chain.from_iterable(globs_expanded)
+        glob_files = filter(os.path.isfile, globs_matches)
+        files = itertools.chain(
+            self.manifest_files.get(package, []),
+            glob_files,
+        )
+        return self.exclude_data_files(package, src_dir, files)
+
+    def get_outputs(self, include_bytecode: bool = True) -> list[str]:  # type: ignore[override] # Using a real boolean instead of 0|1
+        """See :class:`setuptools.commands.build.SubCommand`"""
+        if self.editable_mode:
+            return list(self.get_output_mapping().keys())
+        return super().get_outputs(include_bytecode)
+
+    def get_output_mapping(self) -> dict[str, str]:
+        """See :class:`setuptools.commands.build.SubCommand`"""
+        mapping = itertools.chain(
+            self._get_package_data_output_mapping(),
+            self._get_module_mapping(),
+        )
+        return dict(sorted(mapping, key=lambda x: x[0]))
+
+    def _get_module_mapping(self) -> Iterator[tuple[str, str]]:
+        """Iterate over all modules producing (dest, src) pairs."""
+        for package, module, module_file in self.find_all_modules():
+            package = package.split('.')
+            filename = self.get_module_outfile(self.build_lib, package, module)
+            yield (filename, module_file)
+
+    def _get_package_data_output_mapping(self) -> Iterator[tuple[str, str]]:
+        """Iterate over package data producing (dest, src) pairs."""
+        for package, src_dir, build_dir, filenames in self.data_files:
+            for filename in filenames:
+                target = os.path.join(build_dir, filename)
+                srcfile = os.path.join(src_dir, filename)
+                yield (target, srcfile)
+
+    def build_package_data(self) -> None:
+        """Copy data files into build directory"""
+        for target, srcfile in self._get_package_data_output_mapping():
+            self.mkpath(os.path.dirname(target))
+            _outf, _copied = self.copy_file(srcfile, target)
+            make_writable(target)
+
+    def analyze_manifest(self) -> None:
+        self.manifest_files: dict[str, list[str]] = {}
+        if not self.distribution.include_package_data:
+            return
+        src_dirs: dict[str, str] = {}
+        for package in self.packages or ():
+            # Locate package source directory
+            src_dirs[assert_relative(self.get_package_dir(package))] = package
+
+        if (
+            self.existing_egg_info_dir
+            and Path(self.existing_egg_info_dir, "SOURCES.txt").exists()
+        ):
+            egg_info_dir = self.existing_egg_info_dir
+            manifest = Path(egg_info_dir, "SOURCES.txt")
+            files = manifest.read_text(encoding="utf-8").splitlines()
+        else:
+            self.run_command('egg_info')
+            ei_cmd = self.get_finalized_command('egg_info')
+            egg_info_dir = ei_cmd.egg_info
+            files = ei_cmd.filelist.files
+
+        check = _IncludePackageDataAbuse()
+        for path in self._filter_build_files(files, egg_info_dir):
+            d, f = os.path.split(assert_relative(path))
+            prev = None
+            oldf = f
+            while d and d != prev and d not in src_dirs:
+                prev = d
+                d, df = os.path.split(d)
+                f = os.path.join(df, f)
+            if d in src_dirs:
+                if f == oldf:
+                    if check.is_module(f):
+                        continue  # it's a module, not data
+                else:
+                    importable = check.importable_subpackage(src_dirs[d], f)
+                    if importable:
+                        check.warn(importable)
+                self.manifest_files.setdefault(src_dirs[d], []).append(path)
+
+    def _filter_build_files(
+        self, files: Iterable[str], egg_info: StrPath
+    ) -> Iterator[str]:
+        """
+        ``build_meta`` may try to create egg_info outside of the project directory,
+        and this can be problematic for certain plugins (reported in issue #3500).
+
+        Extensions might also include between their sources files created on the
+        ``build_lib`` and ``build_temp`` directories.
+
+        This function should filter this case of invalid files out.
+        """
+        build = self.get_finalized_command("build")
+        build_dirs = (egg_info, self.build_lib, build.build_temp, build.build_base)
+        norm_dirs = [os.path.normpath(p) for p in build_dirs if p]
+
+        for file in files:
+            norm_path = os.path.normpath(file)
+            if not os.path.isabs(file) or all(d not in norm_path for d in norm_dirs):
+                yield file
+
+    def get_data_files(self) -> None:
+        pass  # Lazily compute data files in _get_data_files() function.
+
+    def check_package(self, package, package_dir):
+        """Check namespace packages' __init__ for declare_namespace"""
+        try:
+            return self.packages_checked[package]
+        except KeyError:
+            pass
+
+        init_py = orig.build_py.check_package(self, package, package_dir)
+        self.packages_checked[package] = init_py
+
+        if not init_py or not self.distribution.namespace_packages:
+            return init_py
+
+        for pkg in self.distribution.namespace_packages:
+            if pkg == package or pkg.startswith(package + '.'):
+                break
+        else:
+            return init_py
+
+        with open(init_py, 'rb') as f:
+            contents = f.read()
+        if b'declare_namespace' not in contents:
+            raise distutils.errors.DistutilsError(
+                f"Namespace package problem: {package} is a namespace package, but "
+                "its\n__init__.py does not call declare_namespace()! Please "
+                'fix it.\n(See the setuptools manual under '
+                '"Namespace Packages" for details.)\n"'
+            )
+        return init_py
+
+    def initialize_options(self):
+        self.packages_checked = {}
+        orig.build_py.initialize_options(self)
+        self.editable_mode = False
+        self.existing_egg_info_dir = None
+
+    def get_package_dir(self, package):
+        res = orig.build_py.get_package_dir(self, package)
+        if self.distribution.src_root is not None:
+            return os.path.join(self.distribution.src_root, res)
+        return res
+
+    def exclude_data_files(self, package, src_dir, files):
+        """Filter filenames for package's data files in 'src_dir'"""
+        files = list(files)
+        patterns = self._get_platform_patterns(
+            self.exclude_package_data,
+            package,
+            src_dir,
+        )
+        match_groups = (fnmatch.filter(files, pattern) for pattern in patterns)
+        # flatten the groups of matches into an iterable of matches
+        matches = itertools.chain.from_iterable(match_groups)
+        bad = set(matches)
+        keepers = (fn for fn in files if fn not in bad)
+        # ditch dupes
+        return list(unique_everseen(keepers))
+
+    @staticmethod
+    def _get_platform_patterns(spec, package, src_dir, extra_patterns=()):
+        """
+        yield platform-specific path patterns (suitable for glob
+        or fn_match) from a glob-based spec (such as
+        self.package_data or self.exclude_package_data)
+        matching package in src_dir.
+        """
+        raw_patterns = itertools.chain(
+            extra_patterns,
+            spec.get('', []),
+            spec.get(package, []),
+        )
+        return (
+            # Each pattern has to be converted to a platform-specific path
+            os.path.join(src_dir, convert_path(pattern))
+            for pattern in raw_patterns
+        )
+
+
+def assert_relative(path):
+    if not os.path.isabs(path):
+        return path
+    from distutils.errors import DistutilsSetupError
+
+    msg = (
+        textwrap.dedent(
+            """
+        Error: setup script specifies an absolute path:
+
+            %s
+
+        setup() arguments must *always* be /-separated paths relative to the
+        setup.py directory, *never* absolute paths.
+        """
+        ).lstrip()
+        % path
+    )
+    raise DistutilsSetupError(msg)
+
+
+class _IncludePackageDataAbuse:
+    """Inform users that package or module is included as 'data file'"""
+
+    class _Warning(SetuptoolsDeprecationWarning):
+        _SUMMARY = """
+        Package {importable!r} is absent from the `packages` configuration.
+        """
+
+        _DETAILS = """
+        ############################
+        # Package would be ignored #
+        ############################
+        Python recognizes {importable!r} as an importable package[^1],
+        but it is absent from setuptools' `packages` configuration.
+
+        This leads to an ambiguous overall configuration. If you want to distribute this
+        package, please make sure that {importable!r} is explicitly added
+        to the `packages` configuration field.
+
+        Alternatively, you can also rely on setuptools' discovery methods
+        (for example by using `find_namespace_packages(...)`/`find_namespace:`
+        instead of `find_packages(...)`/`find:`).
+
+        You can read more about "package discovery" on setuptools documentation page:
+
+        - https://setuptools.pypa.io/en/latest/userguide/package_discovery.html
+
+        If you don't want {importable!r} to be distributed and are
+        already explicitly excluding {importable!r} via
+        `find_namespace_packages(...)/find_namespace` or `find_packages(...)/find`,
+        you can try to use `exclude_package_data`, or `include-package-data=False` in
+        combination with a more fine grained `package-data` configuration.
+
+        You can read more about "package data files" on setuptools documentation page:
+
+        - https://setuptools.pypa.io/en/latest/userguide/datafiles.html
+
+
+        [^1]: For Python, any directory (with suitable naming) can be imported,
+              even if it does not contain any `.py` files.
+              On the other hand, currently there is no concept of package data
+              directory, all directories are treated like packages.
+        """
+        # _DUE_DATE: still not defined as this is particularly controversial.
+        # Warning initially introduced in May 2022. See issue #3340 for discussion.
+
+    def __init__(self):
+        self._already_warned = set()
+
+    def is_module(self, file):
+        return file.endswith(".py") and file[: -len(".py")].isidentifier()
+
+    def importable_subpackage(self, parent, file):
+        pkg = Path(file).parent
+        parts = list(itertools.takewhile(str.isidentifier, pkg.parts))
+        if parts:
+            return ".".join([parent, *parts])
+        return None
+
+    def warn(self, importable):
+        if importable not in self._already_warned:
+            self._Warning.emit(importable=importable)
+            self._already_warned.add(importable)
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/command/develop.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/command/develop.py
new file mode 100644
index 0000000000000000000000000000000000000000..7eee29d491f72d8b0869493013a781d88c0aa3cd
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/command/develop.py
@@ -0,0 +1,195 @@
+import glob
+import os
+
+import setuptools
+from setuptools import _normalization, _path, namespaces
+from setuptools.command.easy_install import easy_install
+
+from ..unicode_utils import _read_utf8_with_fallback
+
+from distutils import log
+from distutils.errors import DistutilsOptionError
+from distutils.util import convert_path
+
+
+class develop(namespaces.DevelopInstaller, easy_install):
+    """Set up package for development"""
+
+    description = "install package in 'development mode'"
+
+    user_options = easy_install.user_options + [
+        ("uninstall", "u", "Uninstall this source package"),
+        ("egg-path=", None, "Set the path to be used in the .egg-link file"),
+    ]
+
+    boolean_options = easy_install.boolean_options + ['uninstall']
+
+    command_consumes_arguments = False  # override base
+
+    def run(self):
+        if self.uninstall:
+            self.multi_version = True
+            self.uninstall_link()
+            self.uninstall_namespaces()
+        else:
+            self.install_for_development()
+        self.warn_deprecated_options()
+
+    def initialize_options(self):
+        self.uninstall = None
+        self.egg_path = None
+        easy_install.initialize_options(self)
+        self.setup_path = None
+        self.always_copy_from = '.'  # always copy eggs installed in curdir
+
+    def finalize_options(self) -> None:
+        import pkg_resources
+
+        ei = self.get_finalized_command("egg_info")
+        self.args = [ei.egg_name]
+
+        easy_install.finalize_options(self)
+        self.expand_basedirs()
+        self.expand_dirs()
+        # pick up setup-dir .egg files only: no .egg-info
+        self.package_index.scan(glob.glob('*.egg'))
+
+        egg_link_fn = (
+            _normalization.filename_component_broken(ei.egg_name) + '.egg-link'
+        )
+        self.egg_link = os.path.join(self.install_dir, egg_link_fn)
+        self.egg_base = ei.egg_base
+        if self.egg_path is None:
+            self.egg_path = os.path.abspath(ei.egg_base)
+
+        target = _path.normpath(self.egg_base)
+        egg_path = _path.normpath(os.path.join(self.install_dir, self.egg_path))
+        if egg_path != target:
+            raise DistutilsOptionError(
+                "--egg-path must be a relative path from the install"
+                " directory to " + target
+            )
+
+        # Make a distribution for the package's source
+        self.dist = pkg_resources.Distribution(
+            target,
+            pkg_resources.PathMetadata(target, os.path.abspath(ei.egg_info)),
+            project_name=ei.egg_name,
+        )
+
+        self.setup_path = self._resolve_setup_path(
+            self.egg_base,
+            self.install_dir,
+            self.egg_path,
+        )
+
+    @staticmethod
+    def _resolve_setup_path(egg_base, install_dir, egg_path):
+        """
+        Generate a path from egg_base back to '.' where the
+        setup script resides and ensure that path points to the
+        setup path from $install_dir/$egg_path.
+        """
+        path_to_setup = egg_base.replace(os.sep, '/').rstrip('/')
+        if path_to_setup != os.curdir:
+            path_to_setup = '../' * (path_to_setup.count('/') + 1)
+        resolved = _path.normpath(os.path.join(install_dir, egg_path, path_to_setup))
+        curdir = _path.normpath(os.curdir)
+        if resolved != curdir:
+            raise DistutilsOptionError(
+                "Can't get a consistent path to setup script from"
+                " installation directory",
+                resolved,
+                curdir,
+            )
+        return path_to_setup
+
+    def install_for_development(self) -> None:
+        self.run_command('egg_info')
+
+        # Build extensions in-place
+        self.reinitialize_command('build_ext', inplace=True)
+        self.run_command('build_ext')
+
+        if setuptools.bootstrap_install_from:
+            self.easy_install(setuptools.bootstrap_install_from)
+            setuptools.bootstrap_install_from = None
+
+        self.install_namespaces()
+
+        # create an .egg-link in the installation dir, pointing to our egg
+        log.info("Creating %s (link to %s)", self.egg_link, self.egg_base)
+        if not self.dry_run:
+            with open(self.egg_link, "w", encoding="utf-8") as f:
+                f.write(self.egg_path + "\n" + self.setup_path)
+        # postprocess the installed distro, fixing up .pth, installing scripts,
+        # and handling requirements
+        self.process_distribution(None, self.dist, not self.no_deps)
+
+    def uninstall_link(self) -> None:
+        if os.path.exists(self.egg_link):
+            log.info("Removing %s (link to %s)", self.egg_link, self.egg_base)
+
+            contents = [
+                line.rstrip()
+                for line in _read_utf8_with_fallback(self.egg_link).splitlines()
+            ]
+
+            if contents not in ([self.egg_path], [self.egg_path, self.setup_path]):
+                log.warn("Link points to %s: uninstall aborted", contents)
+                return
+            if not self.dry_run:
+                os.unlink(self.egg_link)
+        if not self.dry_run:
+            self.update_pth(self.dist)  # remove any .pth link to us
+        if self.distribution.scripts:
+            # XXX should also check for entry point scripts!
+            log.warn("Note: you must uninstall or replace scripts manually!")
+
+    def install_egg_scripts(self, dist):
+        if dist is not self.dist:
+            # Installing a dependency, so fall back to normal behavior
+            return easy_install.install_egg_scripts(self, dist)
+
+        # create wrapper scripts in the script dir, pointing to dist.scripts
+
+        # new-style...
+        self.install_wrapper_scripts(dist)
+
+        # ...and old-style
+        for script_name in self.distribution.scripts or []:
+            script_path = os.path.abspath(convert_path(script_name))
+            script_name = os.path.basename(script_path)
+            script_text = _read_utf8_with_fallback(script_path)
+            self.install_script(dist, script_name, script_text, script_path)
+
+        return None
+
+    def install_wrapper_scripts(self, dist):
+        dist = VersionlessRequirement(dist)
+        return easy_install.install_wrapper_scripts(self, dist)
+
+
+class VersionlessRequirement:
+    """
+    Adapt a pkg_resources.Distribution to simply return the project
+    name as the 'requirement' so that scripts will work across
+    multiple versions.
+
+    >>> from pkg_resources import Distribution
+    >>> dist = Distribution(project_name='foo', version='1.0')
+    >>> str(dist.as_requirement())
+    'foo==1.0'
+    >>> adapted_dist = VersionlessRequirement(dist)
+    >>> str(adapted_dist.as_requirement())
+    'foo'
+    """
+
+    def __init__(self, dist) -> None:
+        self.__dist = dist
+
+    def __getattr__(self, name: str):
+        return getattr(self.__dist, name)
+
+    def as_requirement(self):
+        return self.project_name
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/command/dist_info.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/command/dist_info.py
new file mode 100644
index 0000000000000000000000000000000000000000..dca01ff0ce355dfd375512e4a06b05b909ee41b6
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/command/dist_info.py
@@ -0,0 +1,103 @@
+"""
+Create a dist_info directory
+As defined in the wheel specification
+"""
+
+import os
+import shutil
+from contextlib import contextmanager
+from pathlib import Path
+from typing import cast
+
+from .. import _normalization
+from .._shutil import rmdir as _rm
+from .egg_info import egg_info as egg_info_cls
+
+from distutils import log
+from distutils.core import Command
+
+
+class dist_info(Command):
+    """
+    This command is private and reserved for internal use of setuptools,
+    users should rely on ``setuptools.build_meta`` APIs.
+    """
+
+    description = "DO NOT CALL DIRECTLY, INTERNAL ONLY: create .dist-info directory"
+
+    user_options = [
+        (
+            'output-dir=',
+            'o',
+            "directory inside of which the .dist-info will be"
+            "created [default: top of the source tree]",
+        ),
+        ('tag-date', 'd', "Add date stamp (e.g. 20050528) to version number"),
+        ('tag-build=', 'b', "Specify explicit tag to add to version number"),
+        ('no-date', 'D', "Don't include date stamp [default]"),
+        ('keep-egg-info', None, "*TRANSITIONAL* will be removed in the future"),
+    ]
+
+    boolean_options = ['tag-date', 'keep-egg-info']
+    negative_opt = {'no-date': 'tag-date'}
+
+    def initialize_options(self):
+        self.output_dir = None
+        self.name = None
+        self.dist_info_dir = None
+        self.tag_date = None
+        self.tag_build = None
+        self.keep_egg_info = False
+
+    def finalize_options(self) -> None:
+        dist = self.distribution
+        project_dir = dist.src_root or os.curdir
+        self.output_dir = Path(self.output_dir or project_dir)
+
+        egg_info = cast(egg_info_cls, self.reinitialize_command("egg_info"))
+        egg_info.egg_base = str(self.output_dir)
+
+        if self.tag_date:
+            egg_info.tag_date = self.tag_date
+        else:
+            self.tag_date = egg_info.tag_date
+
+        if self.tag_build:
+            egg_info.tag_build = self.tag_build
+        else:
+            self.tag_build = egg_info.tag_build
+
+        egg_info.finalize_options()
+        self.egg_info = egg_info
+
+        name = _normalization.safer_name(dist.get_name())
+        version = _normalization.safer_best_effort_version(dist.get_version())
+        self.name = f"{name}-{version}"
+        self.dist_info_dir = os.path.join(self.output_dir, f"{self.name}.dist-info")
+
+    @contextmanager
+    def _maybe_bkp_dir(self, dir_path: str, requires_bkp: bool):
+        if requires_bkp:
+            bkp_name = f"{dir_path}.__bkp__"
+            _rm(bkp_name, ignore_errors=True)
+            shutil.copytree(dir_path, bkp_name, dirs_exist_ok=True, symlinks=True)
+            try:
+                yield
+            finally:
+                _rm(dir_path, ignore_errors=True)
+                shutil.move(bkp_name, dir_path)
+        else:
+            yield
+
+    def run(self) -> None:
+        self.output_dir.mkdir(parents=True, exist_ok=True)
+        self.egg_info.run()
+        egg_info_dir = self.egg_info.egg_info
+        assert os.path.isdir(egg_info_dir), ".egg-info dir should have been created"
+
+        log.info(f"creating '{os.path.abspath(self.dist_info_dir)}'")
+        bdist_wheel = self.get_finalized_command('bdist_wheel')
+
+        # TODO: if bdist_wheel if merged into setuptools, just add "keep_egg_info" there
+        with self._maybe_bkp_dir(egg_info_dir, self.keep_egg_info):
+            bdist_wheel.egg2dist(egg_info_dir, self.dist_info_dir)
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/command/easy_install.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/command/easy_install.py
new file mode 100644
index 0000000000000000000000000000000000000000..eb1b4c1fcc21dbebf23b5669913a59aaf3ce104a
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/command/easy_install.py
@@ -0,0 +1,2365 @@
+"""
+Easy Install
+------------
+
+A tool for doing automatic download/extract/build of distutils-based Python
+packages.  For detailed documentation, see the accompanying EasyInstall.txt
+file, or visit the `EasyInstall home page`__.
+
+__ https://setuptools.pypa.io/en/latest/deprecated/easy_install.html
+
+"""
+
+from __future__ import annotations
+
+import configparser
+import contextlib
+import io
+import os
+import random
+import re
+import shlex
+import shutil
+import site
+import stat
+import struct
+import subprocess
+import sys
+import sysconfig
+import tempfile
+import textwrap
+import warnings
+import zipfile
+import zipimport
+from collections.abc import Iterable
+from glob import glob
+from sysconfig import get_path
+from typing import TYPE_CHECKING, NoReturn, TypedDict
+
+from jaraco.text import yield_lines
+
+import pkg_resources
+from pkg_resources import (
+    DEVELOP_DIST,
+    Distribution,
+    DistributionNotFound,
+    EggMetadata,
+    Environment,
+    PathMetadata,
+    Requirement,
+    VersionConflict,
+    WorkingSet,
+    find_distributions,
+    get_distribution,
+    normalize_path,
+    resource_string,
+)
+from setuptools import Command
+from setuptools.archive_util import unpack_archive
+from setuptools.command import bdist_egg, egg_info, setopt
+from setuptools.package_index import URL_SCHEME, PackageIndex, parse_requirement_arg
+from setuptools.sandbox import run_setup
+from setuptools.warnings import SetuptoolsDeprecationWarning, SetuptoolsWarning
+from setuptools.wheel import Wheel
+
+from .._path import ensure_directory
+from .._shutil import attempt_chmod_verbose as chmod, rmtree as _rmtree
+from ..compat import py39, py312
+
+from distutils import dir_util, log
+from distutils.command import install
+from distutils.command.build_scripts import first_line_re
+from distutils.errors import (
+    DistutilsArgError,
+    DistutilsError,
+    DistutilsOptionError,
+    DistutilsPlatformError,
+)
+from distutils.util import convert_path, get_platform, subst_vars
+
+if TYPE_CHECKING:
+    from typing_extensions import Self
+
+# Turn on PEP440Warnings
+warnings.filterwarnings("default", category=pkg_resources.PEP440Warning)
+
+__all__ = [
+    'easy_install',
+    'PthDistributions',
+    'extract_wininst_cfg',
+    'get_exe_prefixes',
+]
+
+
+def is_64bit():
+    return struct.calcsize("P") == 8
+
+
+def _to_bytes(s):
+    return s.encode('utf8')
+
+
+def isascii(s):
+    try:
+        s.encode('ascii')
+    except UnicodeError:
+        return False
+    return True
+
+
+def _one_liner(text):
+    return textwrap.dedent(text).strip().replace('\n', '; ')
+
+
+class easy_install(Command):
+    """Manage a download/build/install process"""
+
+    description = "Find/get/install Python packages"
+    command_consumes_arguments = True
+
+    user_options = [
+        ('prefix=', None, "installation prefix"),
+        ("zip-ok", "z", "install package as a zipfile"),
+        ("multi-version", "m", "make apps have to require() a version"),
+        ("upgrade", "U", "force upgrade (searches PyPI for latest versions)"),
+        ("install-dir=", "d", "install package to DIR"),
+        ("script-dir=", "s", "install scripts to DIR"),
+        ("exclude-scripts", "x", "Don't install scripts"),
+        ("always-copy", "a", "Copy all needed packages to install dir"),
+        ("index-url=", "i", "base URL of Python Package Index"),
+        ("find-links=", "f", "additional URL(s) to search for packages"),
+        ("build-directory=", "b", "download/extract/build in DIR; keep the results"),
+        (
+            'optimize=',
+            'O',
+            'also compile with optimization: -O1 for "python -O", '
+            '-O2 for "python -OO", and -O0 to disable [default: -O0]',
+        ),
+        ('record=', None, "filename in which to record list of installed files"),
+        ('always-unzip', 'Z', "don't install as a zipfile, no matter what"),
+        ('site-dirs=', 'S', "list of directories where .pth files work"),
+        ('editable', 'e', "Install specified packages in editable form"),
+        ('no-deps', 'N', "don't install dependencies"),
+        ('allow-hosts=', 'H', "pattern(s) that hostnames must match"),
+        ('local-snapshots-ok', 'l', "allow building eggs from local checkouts"),
+        ('version', None, "print version information and exit"),
+        (
+            'no-find-links',
+            None,
+            "Don't load find-links defined in packages being installed",
+        ),
+        ('user', None, f"install in user site-package '{site.USER_SITE}'"),
+    ]
+    boolean_options = [
+        'zip-ok',
+        'multi-version',
+        'exclude-scripts',
+        'upgrade',
+        'always-copy',
+        'editable',
+        'no-deps',
+        'local-snapshots-ok',
+        'version',
+        'user',
+    ]
+
+    negative_opt = {'always-unzip': 'zip-ok'}
+    create_index = PackageIndex
+
+    def initialize_options(self):
+        EasyInstallDeprecationWarning.emit()
+
+        # the --user option seems to be an opt-in one,
+        # so the default should be False.
+        self.user = False
+        self.zip_ok = self.local_snapshots_ok = None
+        self.install_dir = self.script_dir = self.exclude_scripts = None
+        self.index_url = None
+        self.find_links = None
+        self.build_directory = None
+        self.args = None
+        self.optimize = self.record = None
+        self.upgrade = self.always_copy = self.multi_version = None
+        self.editable = self.no_deps = self.allow_hosts = None
+        self.root = self.prefix = self.no_report = None
+        self.version = None
+        self.install_purelib = None  # for pure module distributions
+        self.install_platlib = None  # non-pure (dists w/ extensions)
+        self.install_headers = None  # for C/C++ headers
+        self.install_lib = None  # set to either purelib or platlib
+        self.install_scripts = None
+        self.install_data = None
+        self.install_base = None
+        self.install_platbase = None
+        self.install_userbase = site.USER_BASE
+        self.install_usersite = site.USER_SITE
+        self.no_find_links = None
+
+        # Options not specifiable via command line
+        self.package_index = None
+        self.pth_file = self.always_copy_from = None
+        self.site_dirs = None
+        self.installed_projects = {}
+        # Always read easy_install options, even if we are subclassed, or have
+        # an independent instance created.  This ensures that defaults will
+        # always come from the standard configuration file(s)' "easy_install"
+        # section, even if this is a "develop" or "install" command, or some
+        # other embedding.
+        self._dry_run = None
+        self.verbose = self.distribution.verbose
+        self.distribution._set_command_options(
+            self, self.distribution.get_option_dict('easy_install')
+        )
+
+    def delete_blockers(self, blockers) -> None:
+        extant_blockers = (
+            filename
+            for filename in blockers
+            if os.path.exists(filename) or os.path.islink(filename)
+        )
+        list(map(self._delete_path, extant_blockers))
+
+    def _delete_path(self, path):
+        log.info("Deleting %s", path)
+        if self.dry_run:
+            return
+
+        is_tree = os.path.isdir(path) and not os.path.islink(path)
+        remover = _rmtree if is_tree else os.unlink
+        remover(path)
+
+    @staticmethod
+    def _render_version():
+        """
+        Render the Setuptools version and installation details, then exit.
+        """
+        ver = f'{sys.version_info.major}.{sys.version_info.minor}'
+        dist = get_distribution('setuptools')
+        print(f'setuptools {dist.version} from {dist.location} (Python {ver})')
+        raise SystemExit
+
+    def finalize_options(self) -> None:  # noqa: C901  # is too complex (25)  # FIXME
+        self.version and self._render_version()
+
+        py_version = sys.version.split()[0]
+
+        self.config_vars = dict(sysconfig.get_config_vars())
+
+        self.config_vars.update({
+            'dist_name': self.distribution.get_name(),
+            'dist_version': self.distribution.get_version(),
+            'dist_fullname': self.distribution.get_fullname(),
+            'py_version': py_version,
+            'py_version_short': f'{sys.version_info.major}.{sys.version_info.minor}',
+            'py_version_nodot': f'{sys.version_info.major}{sys.version_info.minor}',
+            'sys_prefix': self.config_vars['prefix'],
+            'sys_exec_prefix': self.config_vars['exec_prefix'],
+            # Only POSIX systems have abiflags
+            'abiflags': getattr(sys, 'abiflags', ''),
+            # Only python 3.9+ has platlibdir
+            'platlibdir': getattr(sys, 'platlibdir', 'lib'),
+        })
+        with contextlib.suppress(AttributeError):
+            # only for distutils outside stdlib
+            self.config_vars.update({
+                'implementation_lower': install._get_implementation().lower(),
+                'implementation': install._get_implementation(),
+            })
+
+        # pypa/distutils#113 Python 3.9 compat
+        self.config_vars.setdefault(
+            'py_version_nodot_plat',
+            getattr(sys, 'windir', '').replace('.', ''),
+        )
+
+        self.config_vars['userbase'] = self.install_userbase
+        self.config_vars['usersite'] = self.install_usersite
+        if self.user and not site.ENABLE_USER_SITE:
+            log.warn("WARNING: The user site-packages directory is disabled.")
+
+        self._fix_install_dir_for_user_site()
+
+        self.expand_basedirs()
+        self.expand_dirs()
+
+        self._expand(
+            'install_dir',
+            'script_dir',
+            'build_directory',
+            'site_dirs',
+        )
+        # If a non-default installation directory was specified, default the
+        # script directory to match it.
+        if self.script_dir is None:
+            self.script_dir = self.install_dir
+
+        if self.no_find_links is None:
+            self.no_find_links = False
+
+        # Let install_dir get set by install_lib command, which in turn
+        # gets its info from the install command, and takes into account
+        # --prefix and --home and all that other crud.
+        self.set_undefined_options('install_lib', ('install_dir', 'install_dir'))
+        # Likewise, set default script_dir from 'install_scripts.install_dir'
+        self.set_undefined_options('install_scripts', ('install_dir', 'script_dir'))
+
+        if self.user and self.install_purelib:
+            self.install_dir = self.install_purelib
+            self.script_dir = self.install_scripts
+        # default --record from the install command
+        self.set_undefined_options('install', ('record', 'record'))
+        self.all_site_dirs = get_site_dirs()
+        self.all_site_dirs.extend(self._process_site_dirs(self.site_dirs))
+
+        if not self.editable:
+            self.check_site_dir()
+        default_index = os.getenv("__EASYINSTALL_INDEX", "https://pypi.org/simple/")
+        # ^ Private API for testing purposes only
+        self.index_url = self.index_url or default_index
+        self.shadow_path = self.all_site_dirs[:]
+        for path_item in self.install_dir, normalize_path(self.script_dir):
+            if path_item not in self.shadow_path:
+                self.shadow_path.insert(0, path_item)
+
+        if self.allow_hosts is not None:
+            hosts = [s.strip() for s in self.allow_hosts.split(',')]
+        else:
+            hosts = ['*']
+        if self.package_index is None:
+            self.package_index = self.create_index(
+                self.index_url,
+                search_path=self.shadow_path,
+                hosts=hosts,
+            )
+        self.local_index = Environment(self.shadow_path + sys.path)
+
+        if self.find_links is not None:
+            if isinstance(self.find_links, str):
+                self.find_links = self.find_links.split()
+        else:
+            self.find_links = []
+        if self.local_snapshots_ok:
+            self.package_index.scan_egg_links(self.shadow_path + sys.path)
+        if not self.no_find_links:
+            self.package_index.add_find_links(self.find_links)
+        self.set_undefined_options('install_lib', ('optimize', 'optimize'))
+        self.optimize = self._validate_optimize(self.optimize)
+
+        if self.editable and not self.build_directory:
+            raise DistutilsArgError(
+                "Must specify a build directory (-b) when using --editable"
+            )
+        if not self.args:
+            raise DistutilsArgError(
+                "No urls, filenames, or requirements specified (see --help)"
+            )
+
+        self.outputs: list[str] = []
+
+    @staticmethod
+    def _process_site_dirs(site_dirs):
+        if site_dirs is None:
+            return
+
+        normpath = map(normalize_path, sys.path)
+        site_dirs = [os.path.expanduser(s.strip()) for s in site_dirs.split(',')]
+        for d in site_dirs:
+            if not os.path.isdir(d):
+                log.warn("%s (in --site-dirs) does not exist", d)
+            elif normalize_path(d) not in normpath:
+                raise DistutilsOptionError(d + " (in --site-dirs) is not on sys.path")
+            else:
+                yield normalize_path(d)
+
+    @staticmethod
+    def _validate_optimize(value):
+        try:
+            value = int(value)
+            if value not in range(3):
+                raise ValueError
+        except ValueError as e:
+            raise DistutilsOptionError("--optimize must be 0, 1, or 2") from e
+
+        return value
+
+    def _fix_install_dir_for_user_site(self):
+        """
+        Fix the install_dir if "--user" was used.
+        """
+        if not self.user:
+            return
+
+        self.create_home_path()
+        if self.install_userbase is None:
+            msg = "User base directory is not specified"
+            raise DistutilsPlatformError(msg)
+        self.install_base = self.install_platbase = self.install_userbase
+        scheme_name = f'{os.name}_user'
+        self.select_scheme(scheme_name)
+
+    def _expand_attrs(self, attrs):
+        for attr in attrs:
+            val = getattr(self, attr)
+            if val is not None:
+                if os.name == 'posix' or os.name == 'nt':
+                    val = os.path.expanduser(val)
+                val = subst_vars(val, self.config_vars)
+                setattr(self, attr, val)
+
+    def expand_basedirs(self) -> None:
+        """Calls `os.path.expanduser` on install_base, install_platbase and
+        root."""
+        self._expand_attrs(['install_base', 'install_platbase', 'root'])
+
+    def expand_dirs(self) -> None:
+        """Calls `os.path.expanduser` on install dirs."""
+        dirs = [
+            'install_purelib',
+            'install_platlib',
+            'install_lib',
+            'install_headers',
+            'install_scripts',
+            'install_data',
+        ]
+        self._expand_attrs(dirs)
+
+    def run(self, show_deprecation: bool = True) -> None:
+        if show_deprecation:
+            self.announce(
+                "WARNING: The easy_install command is deprecated "
+                "and will be removed in a future version.",
+                log.WARN,
+            )
+        if self.verbose != self.distribution.verbose:
+            log.set_verbosity(self.verbose)
+        try:
+            for spec in self.args:
+                self.easy_install(spec, not self.no_deps)
+            if self.record:
+                outputs = self.outputs
+                if self.root:  # strip any package prefix
+                    root_len = len(self.root)
+                    for counter in range(len(outputs)):
+                        outputs[counter] = outputs[counter][root_len:]
+                from distutils import file_util
+
+                self.execute(
+                    file_util.write_file,
+                    (self.record, outputs),
+                    f"writing list of installed files to '{self.record}'",
+                )
+            self.warn_deprecated_options()
+        finally:
+            log.set_verbosity(self.distribution.verbose)
+
+    def pseudo_tempname(self):
+        """Return a pseudo-tempname base in the install directory.
+        This code is intentionally naive; if a malicious party can write to
+        the target directory you're already in deep doodoo.
+        """
+        try:
+            pid = os.getpid()
+        except Exception:
+            pid = random.randint(0, sys.maxsize)
+        return os.path.join(self.install_dir, f"test-easy-install-{pid}")
+
+    def warn_deprecated_options(self) -> None:
+        pass
+
+    def check_site_dir(self) -> None:  # is too complex (12)  # FIXME
+        """Verify that self.install_dir is .pth-capable dir, if needed"""
+
+        instdir = normalize_path(self.install_dir)
+        pth_file = os.path.join(instdir, 'easy-install.pth')
+
+        if not os.path.exists(instdir):
+            try:
+                os.makedirs(instdir)
+            except OSError:
+                self.cant_write_to_target()
+
+        # Is it a configured, PYTHONPATH, implicit, or explicit site dir?
+        is_site_dir = instdir in self.all_site_dirs
+
+        if not is_site_dir and not self.multi_version:
+            # No?  Then directly test whether it does .pth file processing
+            is_site_dir = self.check_pth_processing()
+        else:
+            # make sure we can write to target dir
+            testfile = self.pseudo_tempname() + '.write-test'
+            test_exists = os.path.exists(testfile)
+            try:
+                if test_exists:
+                    os.unlink(testfile)
+                open(testfile, 'wb').close()
+                os.unlink(testfile)
+            except OSError:
+                self.cant_write_to_target()
+
+        if not is_site_dir and not self.multi_version:
+            # Can't install non-multi to non-site dir with easy_install
+            pythonpath = os.environ.get('PYTHONPATH', '')
+            log.warn(self.__no_default_msg, self.install_dir, pythonpath)
+
+        if is_site_dir:
+            if self.pth_file is None:
+                self.pth_file = PthDistributions(pth_file, self.all_site_dirs)
+        else:
+            self.pth_file = None
+
+        if self.multi_version and not os.path.exists(pth_file):
+            self.pth_file = None  # don't create a .pth file
+        self.install_dir = instdir
+
+    __cant_write_msg = textwrap.dedent(
+        """
+        can't create or remove files in install directory
+
+        The following error occurred while trying to add or remove files in the
+        installation directory:
+
+            %s
+
+        The installation directory you specified (via --install-dir, --prefix, or
+        the distutils default setting) was:
+
+            %s
+        """
+    ).lstrip()
+
+    __not_exists_id = textwrap.dedent(
+        """
+        This directory does not currently exist.  Please create it and try again, or
+        choose a different installation directory (using the -d or --install-dir
+        option).
+        """
+    ).lstrip()
+
+    __access_msg = textwrap.dedent(
+        """
+        Perhaps your account does not have write access to this directory?  If the
+        installation directory is a system-owned directory, you may need to sign in
+        as the administrator or "root" account.  If you do not have administrative
+        access to this machine, you may wish to choose a different installation
+        directory, preferably one that is listed in your PYTHONPATH environment
+        variable.
+
+        For information on other options, you may wish to consult the
+        documentation at:
+
+          https://setuptools.pypa.io/en/latest/deprecated/easy_install.html
+
+        Please make the appropriate changes for your system and try again.
+        """
+    ).lstrip()
+
+    def cant_write_to_target(self) -> NoReturn:
+        msg = self.__cant_write_msg % (
+            sys.exc_info()[1],
+            self.install_dir,
+        )
+
+        if not os.path.exists(self.install_dir):
+            msg += '\n' + self.__not_exists_id
+        else:
+            msg += '\n' + self.__access_msg
+        raise DistutilsError(msg)
+
+    def check_pth_processing(self):  # noqa: C901
+        """Empirically verify whether .pth files are supported in inst. dir"""
+        instdir = self.install_dir
+        log.info("Checking .pth file support in %s", instdir)
+        pth_file = self.pseudo_tempname() + ".pth"
+        ok_file = pth_file + '.ok'
+        ok_exists = os.path.exists(ok_file)
+        tmpl = (
+            _one_liner(
+                """
+            import os
+            f = open({ok_file!r}, 'w', encoding="utf-8")
+            f.write('OK')
+            f.close()
+            """
+            )
+            + '\n'
+        )
+        try:
+            if ok_exists:
+                os.unlink(ok_file)
+            dirname = os.path.dirname(ok_file)
+            os.makedirs(dirname, exist_ok=True)
+            f = open(pth_file, 'w', encoding=py312.PTH_ENCODING)
+            # ^-- Python<3.13 require encoding="locale" instead of "utf-8",
+            #     see python/cpython#77102.
+        except OSError:
+            self.cant_write_to_target()
+        else:
+            try:
+                f.write(tmpl.format(**locals()))
+                f.close()
+                f = None
+                executable = sys.executable
+                if os.name == 'nt':
+                    dirname, basename = os.path.split(executable)
+                    alt = os.path.join(dirname, 'pythonw.exe')
+                    use_alt = basename.lower() == 'python.exe' and os.path.exists(alt)
+                    if use_alt:
+                        # use pythonw.exe to avoid opening a console window
+                        executable = alt
+
+                from distutils.spawn import spawn
+
+                spawn([executable, '-E', '-c', 'pass'], 0)
+
+                if os.path.exists(ok_file):
+                    log.info("TEST PASSED: %s appears to support .pth files", instdir)
+                    return True
+            finally:
+                if f:
+                    f.close()
+                if os.path.exists(ok_file):
+                    os.unlink(ok_file)
+                if os.path.exists(pth_file):
+                    os.unlink(pth_file)
+        if not self.multi_version:
+            log.warn("TEST FAILED: %s does NOT support .pth files", instdir)
+        return False
+
+    def install_egg_scripts(self, dist) -> None:
+        """Write all the scripts for `dist`, unless scripts are excluded"""
+        if not self.exclude_scripts and dist.metadata_isdir('scripts'):
+            for script_name in dist.metadata_listdir('scripts'):
+                if dist.metadata_isdir('scripts/' + script_name):
+                    # The "script" is a directory, likely a Python 3
+                    # __pycache__ directory, so skip it.
+                    continue
+                self.install_script(
+                    dist, script_name, dist.get_metadata('scripts/' + script_name)
+                )
+        self.install_wrapper_scripts(dist)
+
+    def add_output(self, path) -> None:
+        if os.path.isdir(path):
+            for base, dirs, files in os.walk(path):
+                for filename in files:
+                    self.outputs.append(os.path.join(base, filename))
+        else:
+            self.outputs.append(path)
+
+    def not_editable(self, spec) -> None:
+        if self.editable:
+            raise DistutilsArgError(
+                f"Invalid argument {spec!r}: you can't use filenames or URLs "
+                "with --editable (except via the --find-links option)."
+            )
+
+    def check_editable(self, spec) -> None:
+        if not self.editable:
+            return
+
+        if os.path.exists(os.path.join(self.build_directory, spec.key)):
+            raise DistutilsArgError(
+                f"{spec.key!r} already exists in {self.build_directory}; can't do a checkout there"
+            )
+
+    @contextlib.contextmanager
+    def _tmpdir(self):
+        tmpdir = tempfile.mkdtemp(prefix="easy_install-")
+        try:
+            # cast to str as workaround for #709 and #710 and #712
+            yield str(tmpdir)
+        finally:
+            os.path.exists(tmpdir) and _rmtree(tmpdir)
+
+    def easy_install(self, spec, deps: bool = False) -> Distribution | None:
+        with self._tmpdir() as tmpdir:
+            if not isinstance(spec, Requirement):
+                if URL_SCHEME(spec):
+                    # It's a url, download it to tmpdir and process
+                    self.not_editable(spec)
+                    dl = self.package_index.download(spec, tmpdir)
+                    return self.install_item(None, dl, tmpdir, deps, True)
+
+                elif os.path.exists(spec):
+                    # Existing file or directory, just process it directly
+                    self.not_editable(spec)
+                    return self.install_item(None, spec, tmpdir, deps, True)
+                else:
+                    spec = parse_requirement_arg(spec)
+
+            self.check_editable(spec)
+            dist = self.package_index.fetch_distribution(
+                spec,
+                tmpdir,
+                self.upgrade,
+                self.editable,
+                not self.always_copy,
+                self.local_index,
+            )
+            if dist is None:
+                msg = f"Could not find suitable distribution for {spec!r}"
+                if self.always_copy:
+                    msg += " (--always-copy skips system and development eggs)"
+                raise DistutilsError(msg)
+            elif dist.precedence == DEVELOP_DIST:
+                # .egg-info dists don't need installing, just process deps
+                self.process_distribution(spec, dist, deps, "Using")
+                return dist
+            else:
+                return self.install_item(spec, dist.location, tmpdir, deps)
+
+    def install_item(
+        self, spec, download, tmpdir, deps, install_needed: bool = False
+    ) -> Distribution | None:
+        # Installation is also needed if file in tmpdir or is not an egg
+        install_needed = install_needed or bool(self.always_copy)
+        install_needed = install_needed or os.path.dirname(download) == tmpdir
+        install_needed = install_needed or not download.endswith('.egg')
+        install_needed = install_needed or (
+            self.always_copy_from is not None
+            and os.path.dirname(normalize_path(download))
+            == normalize_path(self.always_copy_from)
+        )
+
+        if spec and not install_needed:
+            # at this point, we know it's a local .egg, we just don't know if
+            # it's already installed.
+            for dist in self.local_index[spec.project_name]:
+                if dist.location == download:
+                    break
+            else:
+                install_needed = True  # it's not in the local index
+
+        log.info("Processing %s", os.path.basename(download))
+
+        if install_needed:
+            dists = self.install_eggs(spec, download, tmpdir)
+            for dist in dists:
+                self.process_distribution(spec, dist, deps)
+        else:
+            dists = [self.egg_distribution(download)]
+            self.process_distribution(spec, dists[0], deps, "Using")
+
+        if spec is not None:
+            for dist in dists:
+                if dist in spec:
+                    return dist
+        return None
+
+    def select_scheme(self, name):
+        try:
+            install._select_scheme(self, name)
+        except AttributeError:
+            # stdlib distutils
+            install.install.select_scheme(self, name.replace('posix', 'unix'))
+
+    # FIXME: 'easy_install.process_distribution' is too complex (12)
+    def process_distribution(  # noqa: C901
+        self,
+        requirement,
+        dist,
+        deps: bool = True,
+        *info,
+    ) -> None:
+        self.update_pth(dist)
+        self.package_index.add(dist)
+        if dist in self.local_index[dist.key]:
+            self.local_index.remove(dist)
+        self.local_index.add(dist)
+        self.install_egg_scripts(dist)
+        self.installed_projects[dist.key] = dist
+        log.info(self.installation_report(requirement, dist, *info))
+        if dist.has_metadata('dependency_links.txt') and not self.no_find_links:
+            self.package_index.add_find_links(
+                dist.get_metadata_lines('dependency_links.txt')
+            )
+        if not deps and not self.always_copy:
+            return
+        elif requirement is not None and dist.key != requirement.key:
+            log.warn("Skipping dependencies for %s", dist)
+            return  # XXX this is not the distribution we were looking for
+        elif requirement is None or dist not in requirement:
+            # if we wound up with a different version, resolve what we've got
+            distreq = dist.as_requirement()
+            requirement = Requirement(str(distreq))
+        log.info("Processing dependencies for %s", requirement)
+        try:
+            distros = WorkingSet([]).resolve(
+                [requirement], self.local_index, self.easy_install
+            )
+        except DistributionNotFound as e:
+            raise DistutilsError(str(e)) from e
+        except VersionConflict as e:
+            raise DistutilsError(e.report()) from e
+        if self.always_copy or self.always_copy_from:
+            # Force all the relevant distros to be copied or activated
+            for dist in distros:
+                if dist.key not in self.installed_projects:
+                    self.easy_install(dist.as_requirement())
+        log.info("Finished processing dependencies for %s", requirement)
+
+    def should_unzip(self, dist) -> bool:
+        if self.zip_ok is not None:
+            return not self.zip_ok
+        if dist.has_metadata('not-zip-safe'):
+            return True
+        if not dist.has_metadata('zip-safe'):
+            return True
+        return False
+
+    def maybe_move(self, spec, dist_filename, setup_base):
+        dst = os.path.join(self.build_directory, spec.key)
+        if os.path.exists(dst):
+            msg = "%r already exists in %s; build directory %s will not be kept"
+            log.warn(msg, spec.key, self.build_directory, setup_base)
+            return setup_base
+        if os.path.isdir(dist_filename):
+            setup_base = dist_filename
+        else:
+            if os.path.dirname(dist_filename) == setup_base:
+                os.unlink(dist_filename)  # get it out of the tmp dir
+            contents = os.listdir(setup_base)
+            if len(contents) == 1:
+                dist_filename = os.path.join(setup_base, contents[0])
+                if os.path.isdir(dist_filename):
+                    # if the only thing there is a directory, move it instead
+                    setup_base = dist_filename
+        ensure_directory(dst)
+        shutil.move(setup_base, dst)
+        return dst
+
+    def install_wrapper_scripts(self, dist) -> None:
+        if self.exclude_scripts:
+            return
+        for args in ScriptWriter.best().get_args(dist):
+            self.write_script(*args)
+
+    def install_script(self, dist, script_name, script_text, dev_path=None) -> None:
+        """Generate a legacy script wrapper and install it"""
+        spec = str(dist.as_requirement())
+        is_script = is_python_script(script_text, script_name)
+
+        if is_script:
+            body = self._load_template(dev_path) % locals()
+            script_text = ScriptWriter.get_header(script_text) + body
+        self.write_script(script_name, _to_bytes(script_text), 'b')
+
+    @staticmethod
+    def _load_template(dev_path):
+        """
+        There are a couple of template scripts in the package. This
+        function loads one of them and prepares it for use.
+        """
+        # See https://github.com/pypa/setuptools/issues/134 for info
+        # on script file naming and downstream issues with SVR4
+        name = 'script.tmpl'
+        if dev_path:
+            name = name.replace('.tmpl', ' (dev).tmpl')
+
+        raw_bytes = resource_string('setuptools', name)
+        return raw_bytes.decode('utf-8')
+
+    def write_script(self, script_name, contents, mode: str = "t", blockers=()) -> None:
+        """Write an executable file to the scripts directory"""
+        self.delete_blockers(  # clean up old .py/.pyw w/o a script
+            [os.path.join(self.script_dir, x) for x in blockers]
+        )
+        log.info("Installing %s script to %s", script_name, self.script_dir)
+        target = os.path.join(self.script_dir, script_name)
+        self.add_output(target)
+
+        if self.dry_run:
+            return
+
+        mask = current_umask()
+        ensure_directory(target)
+        if os.path.exists(target):
+            os.unlink(target)
+
+        encoding = None if "b" in mode else "utf-8"
+        with open(target, "w" + mode, encoding=encoding) as f:
+            f.write(contents)
+        chmod(target, 0o777 - mask)
+
+    def install_eggs(self, spec, dist_filename, tmpdir) -> list[Distribution]:
+        # .egg dirs or files are already built, so just return them
+        installer_map = {
+            '.egg': self.install_egg,
+            '.exe': self.install_exe,
+            '.whl': self.install_wheel,
+        }
+        try:
+            install_dist = installer_map[dist_filename.lower()[-4:]]
+        except KeyError:
+            pass
+        else:
+            return [install_dist(dist_filename, tmpdir)]
+
+        # Anything else, try to extract and build
+        setup_base = tmpdir
+        if os.path.isfile(dist_filename) and not dist_filename.endswith('.py'):
+            unpack_archive(dist_filename, tmpdir, self.unpack_progress)
+        elif os.path.isdir(dist_filename):
+            setup_base = os.path.abspath(dist_filename)
+
+        if (
+            setup_base.startswith(tmpdir)  # something we downloaded
+            and self.build_directory
+            and spec is not None
+        ):
+            setup_base = self.maybe_move(spec, dist_filename, setup_base)
+
+        # Find the setup.py file
+        setup_script = os.path.join(setup_base, 'setup.py')
+
+        if not os.path.exists(setup_script):
+            setups = glob(os.path.join(setup_base, '*', 'setup.py'))
+            if not setups:
+                raise DistutilsError(
+                    f"Couldn't find a setup script in {os.path.abspath(dist_filename)}"
+                )
+            if len(setups) > 1:
+                raise DistutilsError(
+                    f"Multiple setup scripts in {os.path.abspath(dist_filename)}"
+                )
+            setup_script = setups[0]
+
+        # Now run it, and return the result
+        if self.editable:
+            log.info(self.report_editable(spec, setup_script))
+            return []
+        else:
+            return self.build_and_install(setup_script, setup_base)
+
+    def egg_distribution(self, egg_path):
+        if os.path.isdir(egg_path):
+            metadata = PathMetadata(egg_path, os.path.join(egg_path, 'EGG-INFO'))
+        else:
+            metadata = EggMetadata(zipimport.zipimporter(egg_path))
+        return Distribution.from_filename(egg_path, metadata=metadata)
+
+    # FIXME: 'easy_install.install_egg' is too complex (11)
+    def install_egg(self, egg_path, tmpdir):
+        destination = os.path.join(
+            self.install_dir,
+            os.path.basename(egg_path),
+        )
+        destination = os.path.abspath(destination)
+        if not self.dry_run:
+            ensure_directory(destination)
+
+        dist = self.egg_distribution(egg_path)
+        if not (
+            os.path.exists(destination) and os.path.samefile(egg_path, destination)
+        ):
+            if os.path.isdir(destination) and not os.path.islink(destination):
+                dir_util.remove_tree(destination, dry_run=self.dry_run)
+            elif os.path.exists(destination):
+                self.execute(
+                    os.unlink,
+                    (destination,),
+                    "Removing " + destination,
+                )
+            try:
+                new_dist_is_zipped = False
+                if os.path.isdir(egg_path):
+                    if egg_path.startswith(tmpdir):
+                        f, m = shutil.move, "Moving"
+                    else:
+                        f, m = shutil.copytree, "Copying"
+                elif self.should_unzip(dist):
+                    self.mkpath(destination)
+                    f, m = self.unpack_and_compile, "Extracting"
+                else:
+                    new_dist_is_zipped = True
+                    if egg_path.startswith(tmpdir):
+                        f, m = shutil.move, "Moving"
+                    else:
+                        f, m = shutil.copy2, "Copying"
+                self.execute(
+                    f,
+                    (egg_path, destination),
+                    (m + " %s to %s")
+                    % (os.path.basename(egg_path), os.path.dirname(destination)),
+                )
+                update_dist_caches(
+                    destination,
+                    fix_zipimporter_caches=new_dist_is_zipped,
+                )
+            except Exception:
+                update_dist_caches(destination, fix_zipimporter_caches=False)
+                raise
+
+        self.add_output(destination)
+        return self.egg_distribution(destination)
+
+    def install_exe(self, dist_filename, tmpdir):
+        # See if it's valid, get data
+        cfg = extract_wininst_cfg(dist_filename)
+        if cfg is None:
+            raise DistutilsError(
+                f"{dist_filename} is not a valid distutils Windows .exe"
+            )
+        # Create a dummy distribution object until we build the real distro
+        dist = Distribution(
+            None,
+            project_name=cfg.get('metadata', 'name'),
+            version=cfg.get('metadata', 'version'),
+            platform=get_platform(),
+        )
+
+        # Convert the .exe to an unpacked egg
+        egg_path = os.path.join(tmpdir, dist.egg_name() + '.egg')
+        dist.location = egg_path
+        egg_tmp = egg_path + '.tmp'
+        _egg_info = os.path.join(egg_tmp, 'EGG-INFO')
+        pkg_inf = os.path.join(_egg_info, 'PKG-INFO')
+        ensure_directory(pkg_inf)  # make sure EGG-INFO dir exists
+        dist._provider = PathMetadata(egg_tmp, _egg_info)  # XXX
+        self.exe_to_egg(dist_filename, egg_tmp)
+
+        # Write EGG-INFO/PKG-INFO
+        if not os.path.exists(pkg_inf):
+            with open(pkg_inf, 'w', encoding="utf-8") as f:
+                f.write('Metadata-Version: 1.0\n')
+                for k, v in cfg.items('metadata'):
+                    if k != 'target_version':
+                        k = k.replace('_', '-').title()
+                        f.write(f'{k}: {v}\n')
+        script_dir = os.path.join(_egg_info, 'scripts')
+        # delete entry-point scripts to avoid duping
+        self.delete_blockers([
+            os.path.join(script_dir, args[0]) for args in ScriptWriter.get_args(dist)
+        ])
+        # Build .egg file from tmpdir
+        bdist_egg.make_zipfile(
+            egg_path,
+            egg_tmp,
+            verbose=self.verbose,
+            dry_run=self.dry_run,
+        )
+        # install the .egg
+        return self.install_egg(egg_path, tmpdir)
+
+    # FIXME: 'easy_install.exe_to_egg' is too complex (12)
+    def exe_to_egg(self, dist_filename, egg_tmp) -> None:  # noqa: C901
+        """Extract a bdist_wininst to the directories an egg would use"""
+        # Check for .pth file and set up prefix translations
+        prefixes = get_exe_prefixes(dist_filename)
+        to_compile = []
+        native_libs = []
+        top_level = set()
+
+        def process(src, dst):
+            s = src.lower()
+            for old, new in prefixes:
+                if s.startswith(old):
+                    src = new + src[len(old) :]
+                    parts = src.split('/')
+                    dst = os.path.join(egg_tmp, *parts)
+                    dl = dst.lower()
+                    if dl.endswith('.pyd') or dl.endswith('.dll'):
+                        parts[-1] = bdist_egg.strip_module(parts[-1])
+                        top_level.add([os.path.splitext(parts[0])[0]])
+                        native_libs.append(src)
+                    elif dl.endswith('.py') and old != 'SCRIPTS/':
+                        top_level.add([os.path.splitext(parts[0])[0]])
+                        to_compile.append(dst)
+                    return dst
+            if not src.endswith('.pth'):
+                log.warn("WARNING: can't process %s", src)
+            return None
+
+        # extract, tracking .pyd/.dll->native_libs and .py -> to_compile
+        unpack_archive(dist_filename, egg_tmp, process)
+        stubs = []
+        for res in native_libs:
+            if res.lower().endswith('.pyd'):  # create stubs for .pyd's
+                parts = res.split('/')
+                resource = parts[-1]
+                parts[-1] = bdist_egg.strip_module(parts[-1]) + '.py'
+                pyfile = os.path.join(egg_tmp, *parts)
+                to_compile.append(pyfile)
+                stubs.append(pyfile)
+                bdist_egg.write_stub(resource, pyfile)
+        self.byte_compile(to_compile)  # compile .py's
+        bdist_egg.write_safety_flag(
+            os.path.join(egg_tmp, 'EGG-INFO'), bdist_egg.analyze_egg(egg_tmp, stubs)
+        )  # write zip-safety flag
+
+        for name in 'top_level', 'native_libs':
+            if locals()[name]:
+                txt = os.path.join(egg_tmp, 'EGG-INFO', name + '.txt')
+                if not os.path.exists(txt):
+                    with open(txt, 'w', encoding="utf-8") as f:
+                        f.write('\n'.join(locals()[name]) + '\n')
+
+    def install_wheel(self, wheel_path, tmpdir):
+        wheel = Wheel(wheel_path)
+        assert wheel.is_compatible()
+        destination = os.path.join(self.install_dir, wheel.egg_name())
+        destination = os.path.abspath(destination)
+        if not self.dry_run:
+            ensure_directory(destination)
+        if os.path.isdir(destination) and not os.path.islink(destination):
+            dir_util.remove_tree(destination, dry_run=self.dry_run)
+        elif os.path.exists(destination):
+            self.execute(
+                os.unlink,
+                (destination,),
+                "Removing " + destination,
+            )
+        try:
+            self.execute(
+                wheel.install_as_egg,
+                (destination,),
+                (
+                    f"Installing {os.path.basename(wheel_path)} to {os.path.dirname(destination)}"
+                ),
+            )
+        finally:
+            update_dist_caches(destination, fix_zipimporter_caches=False)
+        self.add_output(destination)
+        return self.egg_distribution(destination)
+
+    __mv_warning = textwrap.dedent(
+        """
+        Because this distribution was installed --multi-version, before you can
+        import modules from this package in an application, you will need to
+        'import pkg_resources' and then use a 'require()' call similar to one of
+        these examples, in order to select the desired version:
+
+            pkg_resources.require("%(name)s")  # latest installed version
+            pkg_resources.require("%(name)s==%(version)s")  # this exact version
+            pkg_resources.require("%(name)s>=%(version)s")  # this version or higher
+        """
+    ).lstrip()
+
+    __id_warning = textwrap.dedent(
+        """
+        Note also that the installation directory must be on sys.path at runtime for
+        this to work.  (e.g. by being the application's script directory, by being on
+        PYTHONPATH, or by being added to sys.path by your code.)
+        """
+    )
+
+    def installation_report(self, req, dist, what: str = "Installed") -> str:
+        """Helpful installation message for display to package users"""
+        msg = "\n%(what)s %(eggloc)s%(extras)s"
+        if self.multi_version and not self.no_report:
+            msg += '\n' + self.__mv_warning
+            if self.install_dir not in map(normalize_path, sys.path):
+                msg += '\n' + self.__id_warning
+
+        eggloc = dist.location
+        name = dist.project_name
+        version = dist.version
+        extras = ''  # TODO: self.report_extras(req, dist)
+        return msg % locals()
+
+    __editable_msg = textwrap.dedent(
+        """
+        Extracted editable version of %(spec)s to %(dirname)s
+
+        If it uses setuptools in its setup script, you can activate it in
+        "development" mode by going to that directory and running::
+
+            %(python)s setup.py develop
+
+        See the setuptools documentation for the "develop" command for more info.
+        """
+    ).lstrip()
+
+    def report_editable(self, spec, setup_script):
+        dirname = os.path.dirname(setup_script)
+        python = sys.executable
+        return '\n' + self.__editable_msg % locals()
+
+    def run_setup(self, setup_script, setup_base, args) -> None:
+        sys.modules.setdefault('distutils.command.bdist_egg', bdist_egg)
+        sys.modules.setdefault('distutils.command.egg_info', egg_info)
+
+        args = list(args)
+        if self.verbose > 2:
+            v = 'v' * (self.verbose - 1)
+            args.insert(0, '-' + v)
+        elif self.verbose < 2:
+            args.insert(0, '-q')
+        if self.dry_run:
+            args.insert(0, '-n')
+        log.info("Running %s %s", setup_script[len(setup_base) + 1 :], ' '.join(args))
+        try:
+            run_setup(setup_script, args)
+        except SystemExit as v:
+            raise DistutilsError(f"Setup script exited with {v.args[0]}") from v
+
+    def build_and_install(self, setup_script, setup_base):
+        args = ['bdist_egg', '--dist-dir']
+
+        dist_dir = tempfile.mkdtemp(
+            prefix='egg-dist-tmp-', dir=os.path.dirname(setup_script)
+        )
+        try:
+            self._set_fetcher_options(os.path.dirname(setup_script))
+            args.append(dist_dir)
+
+            self.run_setup(setup_script, setup_base, args)
+            all_eggs = Environment([dist_dir])
+            eggs = [
+                self.install_egg(dist.location, setup_base)
+                for key in all_eggs
+                for dist in all_eggs[key]
+            ]
+            if not eggs and not self.dry_run:
+                log.warn("No eggs found in %s (setup script problem?)", dist_dir)
+            return eggs
+        finally:
+            _rmtree(dist_dir)
+            log.set_verbosity(self.verbose)  # restore our log verbosity
+
+    def _set_fetcher_options(self, base):
+        """
+        When easy_install is about to run bdist_egg on a source dist, that
+        source dist might have 'setup_requires' directives, requiring
+        additional fetching. Ensure the fetcher options given to easy_install
+        are available to that command as well.
+        """
+        # find the fetch options from easy_install and write them out
+        # to the setup.cfg file.
+        ei_opts = self.distribution.get_option_dict('easy_install').copy()
+        fetch_directives = (
+            'find_links',
+            'site_dirs',
+            'index_url',
+            'optimize',
+            'allow_hosts',
+        )
+        fetch_options = {}
+        for key, val in ei_opts.items():
+            if key not in fetch_directives:
+                continue
+            fetch_options[key] = val[1]
+        # create a settings dictionary suitable for `edit_config`
+        settings = dict(easy_install=fetch_options)
+        cfg_filename = os.path.join(base, 'setup.cfg')
+        setopt.edit_config(cfg_filename, settings)
+
+    def update_pth(self, dist) -> None:  # noqa: C901  # is too complex (11)  # FIXME
+        if self.pth_file is None:
+            return
+
+        for d in self.pth_file[dist.key]:  # drop old entries
+            if not self.multi_version and d.location == dist.location:
+                continue
+
+            log.info("Removing %s from easy-install.pth file", d)
+            self.pth_file.remove(d)
+            if d.location in self.shadow_path:
+                self.shadow_path.remove(d.location)
+
+        if not self.multi_version:
+            if dist.location in self.pth_file.paths:
+                log.info(
+                    "%s is already the active version in easy-install.pth",
+                    dist,
+                )
+            else:
+                log.info("Adding %s to easy-install.pth file", dist)
+                self.pth_file.add(dist)  # add new entry
+                if dist.location not in self.shadow_path:
+                    self.shadow_path.append(dist.location)
+
+        if self.dry_run:
+            return
+
+        self.pth_file.save()
+
+        if dist.key != 'setuptools':
+            return
+
+        # Ensure that setuptools itself never becomes unavailable!
+        # XXX should this check for latest version?
+        filename = os.path.join(self.install_dir, 'setuptools.pth')
+        if os.path.islink(filename):
+            os.unlink(filename)
+
+        with open(filename, 'wt', encoding=py312.PTH_ENCODING) as f:
+            # ^-- Python<3.13 require encoding="locale" instead of "utf-8",
+            #     see python/cpython#77102.
+            f.write(self.pth_file.make_relative(dist.location) + '\n')
+
+    def unpack_progress(self, src, dst):
+        # Progress filter for unpacking
+        log.debug("Unpacking %s to %s", src, dst)
+        return dst  # only unpack-and-compile skips files for dry run
+
+    def unpack_and_compile(self, egg_path, destination) -> None:
+        to_compile = []
+        to_chmod = []
+
+        def pf(src, dst):
+            if dst.endswith('.py') and not src.startswith('EGG-INFO/'):
+                to_compile.append(dst)
+            elif dst.endswith('.dll') or dst.endswith('.so'):
+                to_chmod.append(dst)
+            self.unpack_progress(src, dst)
+            return not self.dry_run and dst or None
+
+        unpack_archive(egg_path, destination, pf)
+        self.byte_compile(to_compile)
+        if not self.dry_run:
+            for f in to_chmod:
+                mode = ((os.stat(f)[stat.ST_MODE]) | 0o555) & 0o7755
+                chmod(f, mode)
+
+    def byte_compile(self, to_compile) -> None:
+        if sys.dont_write_bytecode:
+            return
+
+        from distutils.util import byte_compile
+
+        try:
+            # try to make the byte compile messages quieter
+            log.set_verbosity(self.verbose - 1)
+
+            byte_compile(to_compile, optimize=0, force=True, dry_run=self.dry_run)
+            if self.optimize:
+                byte_compile(
+                    to_compile,
+                    optimize=self.optimize,
+                    force=True,
+                    dry_run=self.dry_run,
+                )
+        finally:
+            log.set_verbosity(self.verbose)  # restore original verbosity
+
+    __no_default_msg = textwrap.dedent(
+        """
+        bad install directory or PYTHONPATH
+
+        You are attempting to install a package to a directory that is not
+        on PYTHONPATH and which Python does not read ".pth" files from.  The
+        installation directory you specified (via --install-dir, --prefix, or
+        the distutils default setting) was:
+
+            %s
+
+        and your PYTHONPATH environment variable currently contains:
+
+            %r
+
+        Here are some of your options for correcting the problem:
+
+        * You can choose a different installation directory, i.e., one that is
+          on PYTHONPATH or supports .pth files
+
+        * You can add the installation directory to the PYTHONPATH environment
+          variable.  (It must then also be on PYTHONPATH whenever you run
+          Python and want to use the package(s) you are installing.)
+
+        * You can set up the installation directory to support ".pth" files by
+          using one of the approaches described here:
+
+          https://setuptools.pypa.io/en/latest/deprecated/easy_install.html#custom-installation-locations
+
+
+        Please make the appropriate changes for your system and try again.
+        """
+    ).strip()
+
+    def create_home_path(self) -> None:
+        """Create directories under ~."""
+        if not self.user:
+            return
+        home = convert_path(os.path.expanduser("~"))
+        for path in only_strs(self.config_vars.values()):
+            if path.startswith(home) and not os.path.isdir(path):
+                self.debug_print(f"os.makedirs('{path}', 0o700)")
+                os.makedirs(path, 0o700)
+
+    INSTALL_SCHEMES = dict(
+        posix=dict(
+            install_dir='$base/lib/python$py_version_short/site-packages',
+            script_dir='$base/bin',
+        ),
+    )
+
+    DEFAULT_SCHEME = dict(
+        install_dir='$base/Lib/site-packages',
+        script_dir='$base/Scripts',
+    )
+
+    def _expand(self, *attrs):
+        config_vars = self.get_finalized_command('install').config_vars
+
+        if self.prefix:
+            # Set default install_dir/scripts from --prefix
+            config_vars = dict(config_vars)
+            config_vars['base'] = self.prefix
+            scheme = self.INSTALL_SCHEMES.get(os.name, self.DEFAULT_SCHEME)
+            for attr, val in scheme.items():
+                if getattr(self, attr, None) is None:
+                    setattr(self, attr, val)
+
+        from distutils.util import subst_vars
+
+        for attr in attrs:
+            val = getattr(self, attr)
+            if val is not None:
+                val = subst_vars(val, config_vars)
+                if os.name == 'posix':
+                    val = os.path.expanduser(val)
+                setattr(self, attr, val)
+
+
+def _pythonpath():
+    items = os.environ.get('PYTHONPATH', '').split(os.pathsep)
+    return filter(None, items)
+
+
+def get_site_dirs():
+    """
+    Return a list of 'site' dirs
+    """
+
+    sitedirs = []
+
+    # start with PYTHONPATH
+    sitedirs.extend(_pythonpath())
+
+    prefixes = [sys.prefix]
+    if sys.exec_prefix != sys.prefix:
+        prefixes.append(sys.exec_prefix)
+    for prefix in prefixes:
+        if not prefix:
+            continue
+
+        if sys.platform in ('os2emx', 'riscos'):
+            sitedirs.append(os.path.join(prefix, "Lib", "site-packages"))
+        elif os.sep == '/':
+            sitedirs.extend([
+                os.path.join(
+                    prefix,
+                    "lib",
+                    f"python{sys.version_info.major}.{sys.version_info.minor}",
+                    "site-packages",
+                ),
+                os.path.join(prefix, "lib", "site-python"),
+            ])
+        else:
+            sitedirs.extend([
+                prefix,
+                os.path.join(prefix, "lib", "site-packages"),
+            ])
+        if sys.platform != 'darwin':
+            continue
+
+        # for framework builds *only* we add the standard Apple
+        # locations. Currently only per-user, but /Library and
+        # /Network/Library could be added too
+        if 'Python.framework' not in prefix:
+            continue
+
+        home = os.environ.get('HOME')
+        if not home:
+            continue
+
+        home_sp = os.path.join(
+            home,
+            'Library',
+            'Python',
+            f'{sys.version_info.major}.{sys.version_info.minor}',
+            'site-packages',
+        )
+        sitedirs.append(home_sp)
+    lib_paths = get_path('purelib'), get_path('platlib')
+
+    sitedirs.extend(s for s in lib_paths if s not in sitedirs)
+
+    if site.ENABLE_USER_SITE:
+        sitedirs.append(site.USER_SITE)
+
+    with contextlib.suppress(AttributeError):
+        sitedirs.extend(site.getsitepackages())
+
+    return list(map(normalize_path, sitedirs))
+
+
+def expand_paths(inputs):  # noqa: C901  # is too complex (11)  # FIXME
+    """Yield sys.path directories that might contain "old-style" packages"""
+
+    seen = set()
+
+    for dirname in inputs:
+        dirname = normalize_path(dirname)
+        if dirname in seen:
+            continue
+
+        seen.add(dirname)
+        if not os.path.isdir(dirname):
+            continue
+
+        files = os.listdir(dirname)
+        yield dirname, files
+
+        for name in files:
+            if not name.endswith('.pth'):
+                # We only care about the .pth files
+                continue
+            if name in ('easy-install.pth', 'setuptools.pth'):
+                # Ignore .pth files that we control
+                continue
+
+            # Read the .pth file
+            content = _read_pth(os.path.join(dirname, name))
+            lines = list(yield_lines(content))
+
+            # Yield existing non-dupe, non-import directory lines from it
+            for line in lines:
+                if line.startswith("import"):
+                    continue
+
+                line = normalize_path(line.rstrip())
+                if line in seen:
+                    continue
+
+                seen.add(line)
+                if not os.path.isdir(line):
+                    continue
+
+                yield line, os.listdir(line)
+
+
+def extract_wininst_cfg(dist_filename):
+    """Extract configuration data from a bdist_wininst .exe
+
+    Returns a configparser.RawConfigParser, or None
+    """
+    f = open(dist_filename, 'rb')
+    try:
+        endrec = zipfile._EndRecData(f)
+        if endrec is None:
+            return None
+
+        prepended = (endrec[9] - endrec[5]) - endrec[6]
+        if prepended < 12:  # no wininst data here
+            return None
+        f.seek(prepended - 12)
+
+        tag, cfglen, _bmlen = struct.unpack("<iii", f.read(12))
+        if tag not in (0x1234567A, 0x1234567B):
+            return None  # not a valid tag
+
+        f.seek(prepended - (12 + cfglen))
+        init = {'version': '', 'target_version': ''}
+        cfg = configparser.RawConfigParser(init)
+        try:
+            part = f.read(cfglen)
+            # Read up to the first null byte.
+            config = part.split(b'\0', 1)[0]
+            # Now the config is in bytes, but for RawConfigParser, it should
+            #  be text, so decode it.
+            config = config.decode(sys.getfilesystemencoding())
+            cfg.read_file(io.StringIO(config))
+        except configparser.Error:
+            return None
+        if not cfg.has_section('metadata') or not cfg.has_section('Setup'):
+            return None
+        return cfg
+
+    finally:
+        f.close()
+
+
+def get_exe_prefixes(exe_filename):
+    """Get exe->egg path translations for a given .exe file"""
+
+    prefixes = [
+        ('PURELIB/', ''),
+        ('PLATLIB/pywin32_system32', ''),
+        ('PLATLIB/', ''),
+        ('SCRIPTS/', 'EGG-INFO/scripts/'),
+        ('DATA/lib/site-packages', ''),
+    ]
+    z = zipfile.ZipFile(exe_filename)
+    try:
+        for info in z.infolist():
+            name = info.filename
+            parts = name.split('/')
+            if len(parts) == 3 and parts[2] == 'PKG-INFO':
+                if parts[1].endswith('.egg-info'):
+                    prefixes.insert(0, ('/'.join(parts[:2]), 'EGG-INFO/'))
+                    break
+            if len(parts) != 2 or not name.endswith('.pth'):
+                continue
+            if name.endswith('-nspkg.pth'):
+                continue
+            if parts[0].upper() in ('PURELIB', 'PLATLIB'):
+                contents = z.read(name).decode()
+                for pth in yield_lines(contents):
+                    pth = pth.strip().replace('\\', '/')
+                    if not pth.startswith('import'):
+                        prefixes.append(((f'{parts[0]}/{pth}/'), ''))
+    finally:
+        z.close()
+    prefixes = [(x.lower(), y) for x, y in prefixes]
+    prefixes.sort()
+    prefixes.reverse()
+    return prefixes
+
+
+class PthDistributions(Environment):
+    """A .pth file with Distribution paths in it"""
+
+    def __init__(self, filename, sitedirs=()) -> None:
+        self.filename = filename
+        self.sitedirs = list(map(normalize_path, sitedirs))
+        self.basedir = normalize_path(os.path.dirname(self.filename))
+        self.paths, self.dirty = self._load()
+        # keep a copy if someone manually updates the paths attribute on the instance
+        self._init_paths = self.paths[:]
+        super().__init__([], None, None)
+        for path in yield_lines(self.paths):
+            list(map(self.add, find_distributions(path, True)))
+
+    def _load_raw(self):
+        paths = []
+        dirty = saw_import = False
+        seen = set(self.sitedirs)
+        content = _read_pth(self.filename)
+        for line in content.splitlines():
+            path = line.rstrip()
+            # still keep imports and empty/commented lines for formatting
+            paths.append(path)
+            if line.startswith(('import ', 'from ')):
+                saw_import = True
+                continue
+            stripped_path = path.strip()
+            if not stripped_path or stripped_path.startswith('#'):
+                continue
+            # skip non-existent paths, in case somebody deleted a package
+            # manually, and duplicate paths as well
+            normalized_path = normalize_path(os.path.join(self.basedir, path))
+            if normalized_path in seen or not os.path.exists(normalized_path):
+                log.debug("cleaned up dirty or duplicated %r", path)
+                dirty = True
+                paths.pop()
+                continue
+            seen.add(normalized_path)
+        # remove any trailing empty/blank line
+        while paths and not paths[-1].strip():
+            paths.pop()
+            dirty = True
+        return paths, dirty or (paths and saw_import)
+
+    def _load(self):
+        if os.path.isfile(self.filename):
+            return self._load_raw()
+        return [], False
+
+    def save(self) -> None:
+        """Write changed .pth file back to disk"""
+        # first reload the file
+        last_paths, last_dirty = self._load()
+        # and check that there are no difference with what we have.
+        # there can be difference if someone else has written to the file
+        # since we first loaded it.
+        # we don't want to lose the eventual new paths added since then.
+        for path in last_paths[:]:
+            if path not in self.paths:
+                self.paths.append(path)
+                log.info("detected new path %r", path)
+                last_dirty = True
+            else:
+                last_paths.remove(path)
+        # also, re-check that all paths are still valid before saving them
+        for path in self.paths[:]:
+            if path not in last_paths and not path.startswith((
+                'import ',
+                'from ',
+                '#',
+            )):
+                absolute_path = os.path.join(self.basedir, path)
+                if not os.path.exists(absolute_path):
+                    self.paths.remove(path)
+                    log.info("removing now non-existent path %r", path)
+                    last_dirty = True
+
+        self.dirty |= last_dirty or self.paths != self._init_paths
+        if not self.dirty:
+            return
+
+        rel_paths = list(map(self.make_relative, self.paths))
+        if rel_paths:
+            log.debug("Saving %s", self.filename)
+            lines = self._wrap_lines(rel_paths)
+            data = '\n'.join(lines) + '\n'
+            if os.path.islink(self.filename):
+                os.unlink(self.filename)
+            with open(self.filename, 'wt', encoding=py312.PTH_ENCODING) as f:
+                # ^-- Python<3.13 require encoding="locale" instead of "utf-8",
+                #     see python/cpython#77102.
+                f.write(data)
+        elif os.path.exists(self.filename):
+            log.debug("Deleting empty %s", self.filename)
+            os.unlink(self.filename)
+
+        self.dirty = False
+        self._init_paths[:] = self.paths[:]
+
+    @staticmethod
+    def _wrap_lines(lines):
+        return lines
+
+    def add(self, dist) -> None:
+        """Add `dist` to the distribution map"""
+        new_path = dist.location not in self.paths and (
+            dist.location not in self.sitedirs
+            or
+            # account for '.' being in PYTHONPATH
+            dist.location == os.getcwd()
+        )
+        if new_path:
+            self.paths.append(dist.location)
+            self.dirty = True
+        super().add(dist)
+
+    def remove(self, dist) -> None:
+        """Remove `dist` from the distribution map"""
+        while dist.location in self.paths:
+            self.paths.remove(dist.location)
+            self.dirty = True
+        super().remove(dist)
+
+    def make_relative(self, path):
+        npath, last = os.path.split(normalize_path(path))
+        baselen = len(self.basedir)
+        parts = [last]
+        sep = os.altsep == '/' and '/' or os.sep
+        while len(npath) >= baselen:
+            if npath == self.basedir:
+                parts.append(os.curdir)
+                parts.reverse()
+                return sep.join(parts)
+            npath, last = os.path.split(npath)
+            parts.append(last)
+        else:
+            return path
+
+
+class RewritePthDistributions(PthDistributions):
+    @classmethod
+    def _wrap_lines(cls, lines):
+        yield cls.prelude
+        yield from lines
+        yield cls.postlude
+
+    prelude = _one_liner(
+        """
+        import sys
+        sys.__plen = len(sys.path)
+        """
+    )
+    postlude = _one_liner(
+        """
+        import sys
+        new = sys.path[sys.__plen:]
+        del sys.path[sys.__plen:]
+        p = getattr(sys, '__egginsert', 0)
+        sys.path[p:p] = new
+        sys.__egginsert = p + len(new)
+        """
+    )
+
+
+if os.environ.get('SETUPTOOLS_SYS_PATH_TECHNIQUE', 'raw') == 'rewrite':
+    PthDistributions = RewritePthDistributions  # type: ignore[misc]  # Overwriting type
+
+
+def _first_line_re():
+    """
+    Return a regular expression based on first_line_re suitable for matching
+    strings.
+    """
+    if isinstance(first_line_re.pattern, str):
+        return first_line_re
+
+    # first_line_re in Python >=3.1.4 and >=3.2.1 is a bytes pattern.
+    return re.compile(first_line_re.pattern.decode())
+
+
+def update_dist_caches(dist_path, fix_zipimporter_caches):
+    """
+    Fix any globally cached `dist_path` related data
+
+    `dist_path` should be a path of a newly installed egg distribution (zipped
+    or unzipped).
+
+    sys.path_importer_cache contains finder objects that have been cached when
+    importing data from the original distribution. Any such finders need to be
+    cleared since the replacement distribution might be packaged differently,
+    e.g. a zipped egg distribution might get replaced with an unzipped egg
+    folder or vice versa. Having the old finders cached may then cause Python
+    to attempt loading modules from the replacement distribution using an
+    incorrect loader.
+
+    zipimport.zipimporter objects are Python loaders charged with importing
+    data packaged inside zip archives. If stale loaders referencing the
+    original distribution, are left behind, they can fail to load modules from
+    the replacement distribution. E.g. if an old zipimport.zipimporter instance
+    is used to load data from a new zipped egg archive, it may cause the
+    operation to attempt to locate the requested data in the wrong location -
+    one indicated by the original distribution's zip archive directory
+    information. Such an operation may then fail outright, e.g. report having
+    read a 'bad local file header', or even worse, it may fail silently &
+    return invalid data.
+
+    zipimport._zip_directory_cache contains cached zip archive directory
+    information for all existing zipimport.zipimporter instances and all such
+    instances connected to the same archive share the same cached directory
+    information.
+
+    If asked, and the underlying Python implementation allows it, we can fix
+    all existing zipimport.zipimporter instances instead of having to track
+    them down and remove them one by one, by updating their shared cached zip
+    archive directory information. This, of course, assumes that the
+    replacement distribution is packaged as a zipped egg.
+
+    If not asked to fix existing zipimport.zipimporter instances, we still do
+    our best to clear any remaining zipimport.zipimporter related cached data
+    that might somehow later get used when attempting to load data from the new
+    distribution and thus cause such load operations to fail. Note that when
+    tracking down such remaining stale data, we can not catch every conceivable
+    usage from here, and we clear only those that we know of and have found to
+    cause problems if left alive. Any remaining caches should be updated by
+    whomever is in charge of maintaining them, i.e. they should be ready to
+    handle us replacing their zip archives with new distributions at runtime.
+
+    """
+    # There are several other known sources of stale zipimport.zipimporter
+    # instances that we do not clear here, but might if ever given a reason to
+    # do so:
+    # * Global setuptools pkg_resources.working_set (a.k.a. 'master working
+    # set') may contain distributions which may in turn contain their
+    #   zipimport.zipimporter loaders.
+    # * Several zipimport.zipimporter loaders held by local variables further
+    #   up the function call stack when running the setuptools installation.
+    # * Already loaded modules may have their __loader__ attribute set to the
+    #   exact loader instance used when importing them. Python 3.4 docs state
+    #   that this information is intended mostly for introspection and so is
+    #   not expected to cause us problems.
+    normalized_path = normalize_path(dist_path)
+    _uncache(normalized_path, sys.path_importer_cache)
+    if fix_zipimporter_caches:
+        _replace_zip_directory_cache_data(normalized_path)
+    else:
+        # Here, even though we do not want to fix existing and now stale
+        # zipimporter cache information, we still want to remove it. Related to
+        # Python's zip archive directory information cache, we clear each of
+        # its stale entries in two phases:
+        #   1. Clear the entry so attempting to access zip archive information
+        #      via any existing stale zipimport.zipimporter instances fails.
+        #   2. Remove the entry from the cache so any newly constructed
+        #      zipimport.zipimporter instances do not end up using old stale
+        #      zip archive directory information.
+        # This whole stale data removal step does not seem strictly necessary,
+        # but has been left in because it was done before we started replacing
+        # the zip archive directory information cache content if possible, and
+        # there are no relevant unit tests that we can depend on to tell us if
+        # this is really needed.
+        _remove_and_clear_zip_directory_cache_data(normalized_path)
+
+
+def _collect_zipimporter_cache_entries(normalized_path, cache):
+    """
+    Return zipimporter cache entry keys related to a given normalized path.
+
+    Alternative path spellings (e.g. those using different character case or
+    those using alternative path separators) related to the same path are
+    included. Any sub-path entries are included as well, i.e. those
+    corresponding to zip archives embedded in other zip archives.
+
+    """
+    result = []
+    prefix_len = len(normalized_path)
+    for p in cache:
+        np = normalize_path(p)
+        if np.startswith(normalized_path) and np[prefix_len : prefix_len + 1] in (
+            os.sep,
+            '',
+        ):
+            result.append(p)
+    return result
+
+
+def _update_zipimporter_cache(normalized_path, cache, updater=None):
+    """
+    Update zipimporter cache data for a given normalized path.
+
+    Any sub-path entries are processed as well, i.e. those corresponding to zip
+    archives embedded in other zip archives.
+
+    Given updater is a callable taking a cache entry key and the original entry
+    (after already removing the entry from the cache), and expected to update
+    the entry and possibly return a new one to be inserted in its place.
+    Returning None indicates that the entry should not be replaced with a new
+    one. If no updater is given, the cache entries are simply removed without
+    any additional processing, the same as if the updater simply returned None.
+
+    """
+    for p in _collect_zipimporter_cache_entries(normalized_path, cache):
+        # N.B. pypy's custom zipimport._zip_directory_cache implementation does
+        # not support the complete dict interface:
+        # * Does not support item assignment, thus not allowing this function
+        #    to be used only for removing existing cache entries.
+        #  * Does not support the dict.pop() method, forcing us to use the
+        #    get/del patterns instead. For more detailed information see the
+        #    following links:
+        #      https://github.com/pypa/setuptools/issues/202#issuecomment-202913420
+        #      https://foss.heptapod.net/pypy/pypy/-/blob/144c4e65cb6accb8e592f3a7584ea38265d1873c/pypy/module/zipimport/interp_zipimport.py
+        old_entry = cache[p]
+        del cache[p]
+        new_entry = updater and updater(p, old_entry)
+        if new_entry is not None:
+            cache[p] = new_entry
+
+
+def _uncache(normalized_path, cache):
+    _update_zipimporter_cache(normalized_path, cache)
+
+
+def _remove_and_clear_zip_directory_cache_data(normalized_path):
+    def clear_and_remove_cached_zip_archive_directory_data(path, old_entry):
+        old_entry.clear()
+
+    _update_zipimporter_cache(
+        normalized_path,
+        zipimport._zip_directory_cache,
+        updater=clear_and_remove_cached_zip_archive_directory_data,
+    )
+
+
+# PyPy Python implementation does not allow directly writing to the
+# zipimport._zip_directory_cache and so prevents us from attempting to correct
+# its content. The best we can do there is clear the problematic cache content
+# and have PyPy repopulate it as needed. The downside is that if there are any
+# stale zipimport.zipimporter instances laying around, attempting to use them
+# will fail due to not having its zip archive directory information available
+# instead of being automatically corrected to use the new correct zip archive
+# directory information.
+if '__pypy__' in sys.builtin_module_names:
+    _replace_zip_directory_cache_data = _remove_and_clear_zip_directory_cache_data
+else:
+
+    def _replace_zip_directory_cache_data(normalized_path):
+        def replace_cached_zip_archive_directory_data(path, old_entry):
+            # N.B. In theory, we could load the zip directory information just
+            # once for all updated path spellings, and then copy it locally and
+            # update its contained path strings to contain the correct
+            # spelling, but that seems like a way too invasive move (this cache
+            # structure is not officially documented anywhere and could in
+            # theory change with new Python releases) for no significant
+            # benefit.
+            old_entry.clear()
+            zipimport.zipimporter(path)
+            old_entry.update(zipimport._zip_directory_cache[path])
+            return old_entry
+
+        _update_zipimporter_cache(
+            normalized_path,
+            zipimport._zip_directory_cache,
+            updater=replace_cached_zip_archive_directory_data,
+        )
+
+
+def is_python(text, filename='<string>'):
+    "Is this string a valid Python script?"
+    try:
+        compile(text, filename, 'exec')
+    except (SyntaxError, TypeError):
+        return False
+    else:
+        return True
+
+
+def is_sh(executable):
+    """Determine if the specified executable is a .sh (contains a #! line)"""
+    try:
+        with open(executable, encoding='latin-1') as fp:
+            magic = fp.read(2)
+    except OSError:
+        return executable
+    return magic == '#!'
+
+
+def nt_quote_arg(arg):
+    """Quote a command line argument according to Windows parsing rules"""
+    return subprocess.list2cmdline([arg])
+
+
+def is_python_script(script_text, filename):
+    """Is this text, as a whole, a Python script? (as opposed to shell/bat/etc."""
+    if filename.endswith('.py') or filename.endswith('.pyw'):
+        return True  # extension says it's Python
+    if is_python(script_text, filename):
+        return True  # it's syntactically valid Python
+    if script_text.startswith('#!'):
+        # It begins with a '#!' line, so check if 'python' is in it somewhere
+        return 'python' in script_text.splitlines()[0].lower()
+
+    return False  # Not any Python I can recognize
+
+
+class _SplitArgs(TypedDict, total=False):
+    comments: bool
+    posix: bool
+
+
+class CommandSpec(list):
+    """
+    A command spec for a #! header, specified as a list of arguments akin to
+    those passed to Popen.
+    """
+
+    options: list[str] = []
+    split_args = _SplitArgs()
+
+    @classmethod
+    def best(cls):
+        """
+        Choose the best CommandSpec class based on environmental conditions.
+        """
+        return cls
+
+    @classmethod
+    def _sys_executable(cls):
+        _default = os.path.normpath(sys.executable)
+        return os.environ.get('__PYVENV_LAUNCHER__', _default)
+
+    @classmethod
+    def from_param(cls, param: Self | str | Iterable[str] | None) -> Self:
+        """
+        Construct a CommandSpec from a parameter to build_scripts, which may
+        be None.
+        """
+        if isinstance(param, cls):
+            return param
+        if isinstance(param, str):
+            return cls.from_string(param)
+        if isinstance(param, Iterable):
+            return cls(param)
+        if param is None:
+            return cls.from_environment()
+        raise TypeError(f"Argument has an unsupported type {type(param)}")
+
+    @classmethod
+    def from_environment(cls):
+        return cls([cls._sys_executable()])
+
+    @classmethod
+    def from_string(cls, string: str) -> Self:
+        """
+        Construct a command spec from a simple string representing a command
+        line parseable by shlex.split.
+        """
+        items = shlex.split(string, **cls.split_args)
+        return cls(items)
+
+    def install_options(self, script_text: str):
+        self.options = shlex.split(self._extract_options(script_text))
+        cmdline = subprocess.list2cmdline(self)
+        if not isascii(cmdline):
+            self.options[:0] = ['-x']
+
+    @staticmethod
+    def _extract_options(orig_script):
+        """
+        Extract any options from the first line of the script.
+        """
+        first = (orig_script + '\n').splitlines()[0]
+        match = _first_line_re().match(first)
+        options = match.group(1) or '' if match else ''
+        return options.strip()
+
+    def as_header(self):
+        return self._render(self + list(self.options))
+
+    @staticmethod
+    def _strip_quotes(item):
+        _QUOTES = '"\''
+        for q in _QUOTES:
+            if item.startswith(q) and item.endswith(q):
+                return item[1:-1]
+        return item
+
+    @staticmethod
+    def _render(items):
+        cmdline = subprocess.list2cmdline(
+            CommandSpec._strip_quotes(item.strip()) for item in items
+        )
+        return '#!' + cmdline + '\n'
+
+
+# For pbr compat; will be removed in a future version.
+sys_executable = CommandSpec._sys_executable()
+
+
+class WindowsCommandSpec(CommandSpec):
+    split_args = _SplitArgs(posix=False)
+
+
+class ScriptWriter:
+    """
+    Encapsulates behavior around writing entry point scripts for console and
+    gui apps.
+    """
+
+    template = textwrap.dedent(
+        r"""
+        # EASY-INSTALL-ENTRY-SCRIPT: %(spec)r,%(group)r,%(name)r
+        import re
+        import sys
+
+        # for compatibility with easy_install; see #2198
+        __requires__ = %(spec)r
+
+        try:
+            from importlib.metadata import distribution
+        except ImportError:
+            try:
+                from importlib_metadata import distribution
+            except ImportError:
+                from pkg_resources import load_entry_point
+
+
+        def importlib_load_entry_point(spec, group, name):
+            dist_name, _, _ = spec.partition('==')
+            matches = (
+                entry_point
+                for entry_point in distribution(dist_name).entry_points
+                if entry_point.group == group and entry_point.name == name
+            )
+            return next(matches).load()
+
+
+        globals().setdefault('load_entry_point', importlib_load_entry_point)
+
+
+        if __name__ == '__main__':
+            sys.argv[0] = re.sub(r'(-script\.pyw?|\.exe)?$', '', sys.argv[0])
+            sys.exit(load_entry_point(%(spec)r, %(group)r, %(name)r)())
+        """
+    ).lstrip()
+
+    command_spec_class = CommandSpec
+
+    @classmethod
+    def get_args(cls, dist, header=None):
+        """
+        Yield write_script() argument tuples for a distribution's
+        console_scripts and gui_scripts entry points.
+        """
+        if header is None:
+            header = cls.get_header()
+        spec = str(dist.as_requirement())
+        for type_ in 'console', 'gui':
+            group = type_ + '_scripts'
+            for name in dist.get_entry_map(group).keys():
+                cls._ensure_safe_name(name)
+                script_text = cls.template % locals()
+                args = cls._get_script_args(type_, name, header, script_text)
+                yield from args
+
+    @staticmethod
+    def _ensure_safe_name(name):
+        """
+        Prevent paths in *_scripts entry point names.
+        """
+        has_path_sep = re.search(r'[\\/]', name)
+        if has_path_sep:
+            raise ValueError("Path separators not allowed in script names")
+
+    @classmethod
+    def best(cls):
+        """
+        Select the best ScriptWriter for this environment.
+        """
+        if sys.platform == 'win32' or (os.name == 'java' and os._name == 'nt'):
+            return WindowsScriptWriter.best()
+        else:
+            return cls
+
+    @classmethod
+    def _get_script_args(cls, type_, name, header, script_text):
+        # Simply write the stub with no extension.
+        yield (name, header + script_text)
+
+    @classmethod
+    def get_header(
+        cls,
+        script_text: str = "",
+        executable: str | CommandSpec | Iterable[str] | None = None,
+    ) -> str:
+        """Create a #! line, getting options (if any) from script_text"""
+        cmd = cls.command_spec_class.best().from_param(executable)
+        cmd.install_options(script_text)
+        return cmd.as_header()
+
+
+class WindowsScriptWriter(ScriptWriter):
+    command_spec_class = WindowsCommandSpec
+
+    @classmethod
+    def best(cls):
+        """
+        Select the best ScriptWriter suitable for Windows
+        """
+        writer_lookup = dict(
+            executable=WindowsExecutableLauncherWriter,
+            natural=cls,
+        )
+        # for compatibility, use the executable launcher by default
+        launcher = os.environ.get('SETUPTOOLS_LAUNCHER', 'executable')
+        return writer_lookup[launcher]
+
+    @classmethod
+    def _get_script_args(cls, type_, name, header, script_text):
+        "For Windows, add a .py extension"
+        ext = dict(console='.pya', gui='.pyw')[type_]
+        if ext not in os.environ['PATHEXT'].lower().split(';'):
+            msg = (
+                "{ext} not listed in PATHEXT; scripts will not be "
+                "recognized as executables."
+            ).format(**locals())
+            SetuptoolsWarning.emit(msg)
+        old = ['.pya', '.py', '-script.py', '.pyc', '.pyo', '.pyw', '.exe']
+        old.remove(ext)
+        header = cls._adjust_header(type_, header)
+        blockers = [name + x for x in old]
+        yield name + ext, header + script_text, 't', blockers
+
+    @classmethod
+    def _adjust_header(cls, type_, orig_header):
+        """
+        Make sure 'pythonw' is used for gui and 'python' is used for
+        console (regardless of what sys.executable is).
+        """
+        pattern = 'pythonw.exe'
+        repl = 'python.exe'
+        if type_ == 'gui':
+            pattern, repl = repl, pattern
+        pattern_ob = re.compile(re.escape(pattern), re.IGNORECASE)
+        new_header = pattern_ob.sub(string=orig_header, repl=repl)
+        return new_header if cls._use_header(new_header) else orig_header
+
+    @staticmethod
+    def _use_header(new_header):
+        """
+        Should _adjust_header use the replaced header?
+
+        On non-windows systems, always use. On
+        Windows systems, only use the replaced header if it resolves
+        to an executable on the system.
+        """
+        clean_header = new_header[2:-1].strip('"')
+        return sys.platform != 'win32' or shutil.which(clean_header)
+
+
+class WindowsExecutableLauncherWriter(WindowsScriptWriter):
+    @classmethod
+    def _get_script_args(cls, type_, name, header, script_text):
+        """
+        For Windows, add a .py extension and an .exe launcher
+        """
+        if type_ == 'gui':
+            launcher_type = 'gui'
+            ext = '-script.pyw'
+            old = ['.pyw']
+        else:
+            launcher_type = 'cli'
+            ext = '-script.py'
+            old = ['.py', '.pyc', '.pyo']
+        hdr = cls._adjust_header(type_, header)
+        blockers = [name + x for x in old]
+        yield (name + ext, hdr + script_text, 't', blockers)
+        yield (
+            name + '.exe',
+            get_win_launcher(launcher_type),
+            'b',  # write in binary mode
+        )
+        if not is_64bit():
+            # install a manifest for the launcher to prevent Windows
+            # from detecting it as an installer (which it will for
+            #  launchers like easy_install.exe). Consider only
+            #  adding a manifest for launchers detected as installers.
+            #  See Distribute #143 for details.
+            m_name = name + '.exe.manifest'
+            yield (m_name, load_launcher_manifest(name), 't')
+
+
+def get_win_launcher(type):
+    """
+    Load the Windows launcher (executable) suitable for launching a script.
+
+    `type` should be either 'cli' or 'gui'
+
+    Returns the executable as a byte string.
+    """
+    launcher_fn = f'{type}.exe'
+    if is_64bit():
+        if get_platform() == "win-arm64":
+            launcher_fn = launcher_fn.replace(".", "-arm64.")
+        else:
+            launcher_fn = launcher_fn.replace(".", "-64.")
+    else:
+        launcher_fn = launcher_fn.replace(".", "-32.")
+    return resource_string('setuptools', launcher_fn)
+
+
+def load_launcher_manifest(name):
+    manifest = pkg_resources.resource_string(__name__, 'launcher manifest.xml')
+    return manifest.decode('utf-8') % vars()
+
+
+def current_umask():
+    tmp = os.umask(0o022)
+    os.umask(tmp)
+    return tmp
+
+
+def only_strs(values):
+    """
+    Exclude non-str values. Ref #3063.
+    """
+    return filter(lambda val: isinstance(val, str), values)
+
+
+def _read_pth(fullname: str) -> str:
+    # Python<3.13 require encoding="locale" instead of "utf-8", see python/cpython#77102
+    # In the case old versions of setuptools are producing `pth` files with
+    # different encodings that might be problematic... So we fallback to "locale".
+
+    try:
+        with open(fullname, encoding=py312.PTH_ENCODING) as f:
+            return f.read()
+    except UnicodeDecodeError:  # pragma: no cover
+        # This error may only happen for Python >= 3.13
+        # TODO: Possible deprecation warnings to be added in the future:
+        #       ``.pth file {fullname!r} is not UTF-8.``
+        #       Your environment contain {fullname!r} that cannot be read as UTF-8.
+        #       This is likely to have been produced with an old version of setuptools.
+        #       Please be mindful that this is deprecated and in the future, non-utf8
+        #       .pth files may cause setuptools to fail.
+        with open(fullname, encoding=py39.LOCALE_ENCODING) as f:
+            return f.read()
+
+
+class EasyInstallDeprecationWarning(SetuptoolsDeprecationWarning):
+    _SUMMARY = "easy_install command is deprecated."
+    _DETAILS = """
+    Please avoid running ``setup.py`` and ``easy_install``.
+    Instead, use pypa/build, pypa/installer or other
+    standards-based tools.
+    """
+    _SEE_URL = "https://github.com/pypa/setuptools/issues/917"
+    # _DUE_DATE not defined yet
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/command/editable_wheel.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/command/editable_wheel.py
new file mode 100644
index 0000000000000000000000000000000000000000..1a544ec258196616a4242b679c20b061c1c4010d
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/command/editable_wheel.py
@@ -0,0 +1,925 @@
+"""
+Create a wheel that, when installed, will make the source package 'editable'
+(add it to the interpreter's path, including metadata) per PEP 660. Replaces
+'setup.py develop'.
+
+.. note::
+   One of the mechanisms briefly mentioned in PEP 660 to implement editable installs is
+   to create a separated directory inside ``build`` and use a .pth file to point to that
+   directory. In the context of this file such directory is referred as
+   *auxiliary build directory* or ``auxiliary_dir``.
+"""
+
+from __future__ import annotations
+
+import io
+import logging
+import os
+import shutil
+import traceback
+from collections.abc import Iterable, Iterator, Mapping
+from contextlib import suppress
+from enum import Enum
+from inspect import cleandoc
+from itertools import chain, starmap
+from pathlib import Path
+from tempfile import TemporaryDirectory
+from types import TracebackType
+from typing import TYPE_CHECKING, Protocol, TypeVar, cast
+
+from .. import Command, _normalization, _path, _shutil, errors, namespaces
+from .._path import StrPath
+from ..compat import py312
+from ..discovery import find_package_path
+from ..dist import Distribution
+from ..warnings import InformationOnly, SetuptoolsDeprecationWarning, SetuptoolsWarning
+from .build import build as build_cls
+from .build_py import build_py as build_py_cls
+from .dist_info import dist_info as dist_info_cls
+from .egg_info import egg_info as egg_info_cls
+from .install import install as install_cls
+from .install_scripts import install_scripts as install_scripts_cls
+
+if TYPE_CHECKING:
+    from typing_extensions import Self
+
+    from .._vendor.wheel.wheelfile import WheelFile
+
+_P = TypeVar("_P", bound=StrPath)
+_logger = logging.getLogger(__name__)
+
+
+class _EditableMode(Enum):
+    """
+    Possible editable installation modes:
+    `lenient` (new files automatically added to the package - DEFAULT);
+    `strict` (requires a new installation when files are added/removed); or
+    `compat` (attempts to emulate `python setup.py develop` - DEPRECATED).
+    """
+
+    STRICT = "strict"
+    LENIENT = "lenient"
+    COMPAT = "compat"  # TODO: Remove `compat` after Dec/2022.
+
+    @classmethod
+    def convert(cls, mode: str | None) -> _EditableMode:
+        if not mode:
+            return _EditableMode.LENIENT  # default
+
+        _mode = mode.upper()
+        if _mode not in _EditableMode.__members__:
+            raise errors.OptionError(f"Invalid editable mode: {mode!r}. Try: 'strict'.")
+
+        if _mode == "COMPAT":
+            SetuptoolsDeprecationWarning.emit(
+                "Compat editable installs",
+                """
+                The 'compat' editable mode is transitional and will be removed
+                in future versions of `setuptools`.
+                Please adapt your code accordingly to use either the 'strict' or the
+                'lenient' modes.
+                """,
+                see_docs="userguide/development_mode.html",
+                # TODO: define due_date
+                # There is a series of shortcomings with the available editable install
+                # methods, and they are very controversial. This is something that still
+                # needs work.
+                # Moreover, `pip` is still hiding this warning, so users are not aware.
+            )
+
+        return _EditableMode[_mode]
+
+
+_STRICT_WARNING = """
+New or renamed files may not be automatically picked up without a new installation.
+"""
+
+_LENIENT_WARNING = """
+Options like `package-data`, `include/exclude-package-data` or
+`packages.find.exclude/include` may have no effect.
+"""
+
+
+class editable_wheel(Command):
+    """Build 'editable' wheel for development.
+    This command is private and reserved for internal use of setuptools,
+    users should rely on ``setuptools.build_meta`` APIs.
+    """
+
+    description = "DO NOT CALL DIRECTLY, INTERNAL ONLY: create PEP 660 editable wheel"
+
+    user_options = [
+        ("dist-dir=", "d", "directory to put final built distributions in"),
+        ("dist-info-dir=", "I", "path to a pre-build .dist-info directory"),
+        ("mode=", None, cleandoc(_EditableMode.__doc__ or "")),
+    ]
+
+    def initialize_options(self):
+        self.dist_dir = None
+        self.dist_info_dir = None
+        self.project_dir = None
+        self.mode = None
+
+    def finalize_options(self) -> None:
+        dist = self.distribution
+        self.project_dir = dist.src_root or os.curdir
+        self.package_dir = dist.package_dir or {}
+        self.dist_dir = Path(self.dist_dir or os.path.join(self.project_dir, "dist"))
+
+    def run(self) -> None:
+        try:
+            self.dist_dir.mkdir(exist_ok=True)
+            self._ensure_dist_info()
+
+            # Add missing dist_info files
+            self.reinitialize_command("bdist_wheel")
+            bdist_wheel = self.get_finalized_command("bdist_wheel")
+            bdist_wheel.write_wheelfile(self.dist_info_dir)
+
+            self._create_wheel_file(bdist_wheel)
+        except Exception:
+            traceback.print_exc()
+            project = self.distribution.name or self.distribution.get_name()
+            _DebuggingTips.emit(project=project)
+            raise
+
+    def _ensure_dist_info(self):
+        if self.dist_info_dir is None:
+            dist_info = cast(dist_info_cls, self.reinitialize_command("dist_info"))
+            dist_info.output_dir = self.dist_dir
+            dist_info.ensure_finalized()
+            dist_info.run()
+            self.dist_info_dir = dist_info.dist_info_dir
+        else:
+            assert str(self.dist_info_dir).endswith(".dist-info")
+            assert Path(self.dist_info_dir, "METADATA").exists()
+
+    def _install_namespaces(self, installation_dir, pth_prefix):
+        # XXX: Only required to support the deprecated namespace practice
+        dist = self.distribution
+        if not dist.namespace_packages:
+            return
+
+        src_root = Path(self.project_dir, self.package_dir.get("", ".")).resolve()
+        installer = _NamespaceInstaller(dist, installation_dir, pth_prefix, src_root)
+        installer.install_namespaces()
+
+    def _find_egg_info_dir(self) -> str | None:
+        parent_dir = Path(self.dist_info_dir).parent if self.dist_info_dir else Path()
+        candidates = map(str, parent_dir.glob("*.egg-info"))
+        return next(candidates, None)
+
+    def _configure_build(
+        self, name: str, unpacked_wheel: StrPath, build_lib: StrPath, tmp_dir: StrPath
+    ):
+        """Configure commands to behave in the following ways:
+
+        - Build commands can write to ``build_lib`` if they really want to...
+          (but this folder is expected to be ignored and modules are expected to live
+          in the project directory...)
+        - Binary extensions should be built in-place (editable_mode = True)
+        - Data/header/script files are not part of the "editable" specification
+          so they are written directly to the unpacked_wheel directory.
+        """
+        # Non-editable files (data, headers, scripts) are written directly to the
+        # unpacked_wheel
+
+        dist = self.distribution
+        wheel = str(unpacked_wheel)
+        build_lib = str(build_lib)
+        data = str(Path(unpacked_wheel, f"{name}.data", "data"))
+        headers = str(Path(unpacked_wheel, f"{name}.data", "headers"))
+        scripts = str(Path(unpacked_wheel, f"{name}.data", "scripts"))
+
+        # egg-info may be generated again to create a manifest (used for package data)
+        egg_info = cast(
+            egg_info_cls, dist.reinitialize_command("egg_info", reinit_subcommands=True)
+        )
+        egg_info.egg_base = str(tmp_dir)
+        egg_info.ignore_egg_info_in_manifest = True
+
+        build = cast(
+            build_cls, dist.reinitialize_command("build", reinit_subcommands=True)
+        )
+        install = cast(
+            install_cls, dist.reinitialize_command("install", reinit_subcommands=True)
+        )
+
+        build.build_platlib = build.build_purelib = build.build_lib = build_lib
+        install.install_purelib = install.install_platlib = install.install_lib = wheel
+        install.install_scripts = build.build_scripts = scripts
+        install.install_headers = headers
+        install.install_data = data
+
+        install_scripts = cast(
+            install_scripts_cls, dist.get_command_obj("install_scripts")
+        )
+        install_scripts.no_ep = True
+
+        build.build_temp = str(tmp_dir)
+
+        build_py = cast(build_py_cls, dist.get_command_obj("build_py"))
+        build_py.compile = False
+        build_py.existing_egg_info_dir = self._find_egg_info_dir()
+
+        self._set_editable_mode()
+
+        build.ensure_finalized()
+        install.ensure_finalized()
+
+    def _set_editable_mode(self):
+        """Set the ``editable_mode`` flag in the build sub-commands"""
+        dist = self.distribution
+        build = dist.get_command_obj("build")
+        for cmd_name in build.get_sub_commands():
+            cmd = dist.get_command_obj(cmd_name)
+            if hasattr(cmd, "editable_mode"):
+                cmd.editable_mode = True
+            elif hasattr(cmd, "inplace"):
+                cmd.inplace = True  # backward compatibility with distutils
+
+    def _collect_build_outputs(self) -> tuple[list[str], dict[str, str]]:
+        files: list[str] = []
+        mapping: dict[str, str] = {}
+        build = self.get_finalized_command("build")
+
+        for cmd_name in build.get_sub_commands():
+            cmd = self.get_finalized_command(cmd_name)
+            if hasattr(cmd, "get_outputs"):
+                files.extend(cmd.get_outputs() or [])
+            if hasattr(cmd, "get_output_mapping"):
+                mapping.update(cmd.get_output_mapping() or {})
+
+        return files, mapping
+
+    def _run_build_commands(
+        self,
+        dist_name: str,
+        unpacked_wheel: StrPath,
+        build_lib: StrPath,
+        tmp_dir: StrPath,
+    ) -> tuple[list[str], dict[str, str]]:
+        self._configure_build(dist_name, unpacked_wheel, build_lib, tmp_dir)
+        self._run_build_subcommands()
+        files, mapping = self._collect_build_outputs()
+        self._run_install("headers")
+        self._run_install("scripts")
+        self._run_install("data")
+        return files, mapping
+
+    def _run_build_subcommands(self) -> None:
+        """
+        Issue #3501 indicates that some plugins/customizations might rely on:
+
+        1. ``build_py`` not running
+        2. ``build_py`` always copying files to ``build_lib``
+
+        However both these assumptions may be false in editable_wheel.
+        This method implements a temporary workaround to support the ecosystem
+        while the implementations catch up.
+        """
+        # TODO: Once plugins/customizations had the chance to catch up, replace
+        #       `self._run_build_subcommands()` with `self.run_command("build")`.
+        #       Also remove _safely_run, TestCustomBuildPy. Suggested date: Aug/2023.
+        build = self.get_finalized_command("build")
+        for name in build.get_sub_commands():
+            cmd = self.get_finalized_command(name)
+            if name == "build_py" and type(cmd) is not build_py_cls:
+                self._safely_run(name)
+            else:
+                self.run_command(name)
+
+    def _safely_run(self, cmd_name: str):
+        try:
+            return self.run_command(cmd_name)
+        except Exception:
+            SetuptoolsDeprecationWarning.emit(
+                "Customization incompatible with editable install",
+                f"""
+                {traceback.format_exc()}
+
+                If you are seeing this warning it is very likely that a setuptools
+                plugin or customization overrides the `{cmd_name}` command, without
+                taking into consideration how editable installs run build steps
+                starting from setuptools v64.0.0.
+
+                Plugin authors and developers relying on custom build steps are
+                encouraged to update their `{cmd_name}` implementation considering the
+                information about editable installs in
+                https://setuptools.pypa.io/en/latest/userguide/extension.html.
+
+                For the time being `setuptools` will silence this error and ignore
+                the faulty command, but this behavior will change in future versions.
+                """,
+                # TODO: define due_date
+                # There is a series of shortcomings with the available editable install
+                # methods, and they are very controversial. This is something that still
+                # needs work.
+            )
+
+    def _create_wheel_file(self, bdist_wheel):
+        from wheel.wheelfile import WheelFile
+
+        dist_info = self.get_finalized_command("dist_info")
+        dist_name = dist_info.name
+        tag = "-".join(bdist_wheel.get_tag())
+        build_tag = "0.editable"  # According to PEP 427 needs to start with digit
+        archive_name = f"{dist_name}-{build_tag}-{tag}.whl"
+        wheel_path = Path(self.dist_dir, archive_name)
+        if wheel_path.exists():
+            wheel_path.unlink()
+
+        unpacked_wheel = TemporaryDirectory(suffix=archive_name)
+        build_lib = TemporaryDirectory(suffix=".build-lib")
+        build_tmp = TemporaryDirectory(suffix=".build-temp")
+
+        with unpacked_wheel as unpacked, build_lib as lib, build_tmp as tmp:
+            unpacked_dist_info = Path(unpacked, Path(self.dist_info_dir).name)
+            shutil.copytree(self.dist_info_dir, unpacked_dist_info)
+            self._install_namespaces(unpacked, dist_name)
+            files, mapping = self._run_build_commands(dist_name, unpacked, lib, tmp)
+            strategy = self._select_strategy(dist_name, tag, lib)
+            with strategy, WheelFile(wheel_path, "w") as wheel_obj:
+                strategy(wheel_obj, files, mapping)
+                wheel_obj.write_files(unpacked)
+
+        return wheel_path
+
+    def _run_install(self, category: str):
+        has_category = getattr(self.distribution, f"has_{category}", None)
+        if has_category and has_category():
+            _logger.info(f"Installing {category} as non editable")
+            self.run_command(f"install_{category}")
+
+    def _select_strategy(
+        self,
+        name: str,
+        tag: str,
+        build_lib: StrPath,
+    ) -> EditableStrategy:
+        """Decides which strategy to use to implement an editable installation."""
+        build_name = f"__editable__.{name}-{tag}"
+        project_dir = Path(self.project_dir)
+        mode = _EditableMode.convert(self.mode)
+
+        if mode is _EditableMode.STRICT:
+            auxiliary_dir = _empty_dir(Path(self.project_dir, "build", build_name))
+            return _LinkTree(self.distribution, name, auxiliary_dir, build_lib)
+
+        packages = _find_packages(self.distribution)
+        has_simple_layout = _simple_layout(packages, self.package_dir, project_dir)
+        is_compat_mode = mode is _EditableMode.COMPAT
+        if set(self.package_dir) == {""} and has_simple_layout or is_compat_mode:
+            # src-layout(ish) is relatively safe for a simple pth file
+            src_dir = self.package_dir.get("", ".")
+            return _StaticPth(self.distribution, name, [Path(project_dir, src_dir)])
+
+        # Use a MetaPathFinder to avoid adding accidental top-level packages/modules
+        return _TopLevelFinder(self.distribution, name)
+
+
+class EditableStrategy(Protocol):
+    def __call__(
+        self, wheel: WheelFile, files: list[str], mapping: Mapping[str, str]
+    ) -> object: ...
+    def __enter__(self) -> Self: ...
+    def __exit__(
+        self,
+        _exc_type: type[BaseException] | None,
+        _exc_value: BaseException | None,
+        _traceback: TracebackType | None,
+    ) -> object: ...
+
+
+class _StaticPth:
+    def __init__(self, dist: Distribution, name: str, path_entries: list[Path]) -> None:
+        self.dist = dist
+        self.name = name
+        self.path_entries = path_entries
+
+    def __call__(self, wheel: WheelFile, files: list[str], mapping: Mapping[str, str]):
+        entries = "\n".join(str(p.resolve()) for p in self.path_entries)
+        contents = _encode_pth(f"{entries}\n")
+        wheel.writestr(f"__editable__.{self.name}.pth", contents)
+
+    def __enter__(self) -> Self:
+        msg = f"""
+        Editable install will be performed using .pth file to extend `sys.path` with:
+        {list(map(os.fspath, self.path_entries))!r}
+        """
+        _logger.warning(msg + _LENIENT_WARNING)
+        return self
+
+    def __exit__(
+        self,
+        _exc_type: object,
+        _exc_value: object,
+        _traceback: object,
+    ) -> None:
+        pass
+
+
+class _LinkTree(_StaticPth):
+    """
+    Creates a ``.pth`` file that points to a link tree in the ``auxiliary_dir``.
+
+    This strategy will only link files (not dirs), so it can be implemented in
+    any OS, even if that means using hardlinks instead of symlinks.
+
+    By collocating ``auxiliary_dir`` and the original source code, limitations
+    with hardlinks should be avoided.
+    """
+
+    def __init__(
+        self,
+        dist: Distribution,
+        name: str,
+        auxiliary_dir: StrPath,
+        build_lib: StrPath,
+    ) -> None:
+        self.auxiliary_dir = Path(auxiliary_dir)
+        self.build_lib = Path(build_lib).resolve()
+        self._file = dist.get_command_obj("build_py").copy_file
+        super().__init__(dist, name, [self.auxiliary_dir])
+
+    def __call__(self, wheel: WheelFile, files: list[str], mapping: Mapping[str, str]):
+        self._create_links(files, mapping)
+        super().__call__(wheel, files, mapping)
+
+    def _normalize_output(self, file: str) -> str | None:
+        # Files relative to build_lib will be normalized to None
+        with suppress(ValueError):
+            path = Path(file).resolve().relative_to(self.build_lib)
+            return str(path).replace(os.sep, '/')
+        return None
+
+    def _create_file(self, relative_output: str, src_file: str, link=None):
+        dest = self.auxiliary_dir / relative_output
+        if not dest.parent.is_dir():
+            dest.parent.mkdir(parents=True)
+        self._file(src_file, dest, link=link)
+
+    def _create_links(self, outputs, output_mapping: Mapping[str, str]):
+        self.auxiliary_dir.mkdir(parents=True, exist_ok=True)
+        link_type = "sym" if _can_symlink_files(self.auxiliary_dir) else "hard"
+        normalised = ((self._normalize_output(k), v) for k, v in output_mapping.items())
+        # remove files that are not relative to build_lib
+        mappings = {k: v for k, v in normalised if k is not None}
+
+        for output in outputs:
+            relative = self._normalize_output(output)
+            if relative and relative not in mappings:
+                self._create_file(relative, output)
+
+        for relative, src in mappings.items():
+            self._create_file(relative, src, link=link_type)
+
+    def __enter__(self) -> Self:
+        msg = "Strict editable install will be performed using a link tree.\n"
+        _logger.warning(msg + _STRICT_WARNING)
+        return self
+
+    def __exit__(
+        self,
+        _exc_type: object,
+        _exc_value: object,
+        _traceback: object,
+    ) -> None:
+        msg = f"""\n
+        Strict editable installation performed using the auxiliary directory:
+            {self.auxiliary_dir}
+
+        Please be careful to not remove this directory, otherwise you might not be able
+        to import/use your package.
+        """
+        InformationOnly.emit("Editable installation.", msg)
+
+
+class _TopLevelFinder:
+    def __init__(self, dist: Distribution, name: str) -> None:
+        self.dist = dist
+        self.name = name
+
+    def template_vars(self) -> tuple[str, str, dict[str, str], dict[str, list[str]]]:
+        src_root = self.dist.src_root or os.curdir
+        top_level = chain(_find_packages(self.dist), _find_top_level_modules(self.dist))
+        package_dir = self.dist.package_dir or {}
+        roots = _find_package_roots(top_level, package_dir, src_root)
+
+        namespaces_ = dict(
+            chain(
+                _find_namespaces(self.dist.packages or [], roots),
+                ((ns, []) for ns in _find_virtual_namespaces(roots)),
+            )
+        )
+
+        legacy_namespaces = {
+            pkg: find_package_path(pkg, roots, self.dist.src_root or "")
+            for pkg in self.dist.namespace_packages or []
+        }
+
+        mapping = {**roots, **legacy_namespaces}
+        # ^-- We need to explicitly add the legacy_namespaces to the mapping to be
+        #     able to import their modules even if another package sharing the same
+        #     namespace is installed in a conventional (non-editable) way.
+
+        name = f"__editable__.{self.name}.finder"
+        finder = _normalization.safe_identifier(name)
+        return finder, name, mapping, namespaces_
+
+    def get_implementation(self) -> Iterator[tuple[str, bytes]]:
+        finder, name, mapping, namespaces_ = self.template_vars()
+
+        content = bytes(_finder_template(name, mapping, namespaces_), "utf-8")
+        yield (f"{finder}.py", content)
+
+        content = _encode_pth(f"import {finder}; {finder}.install()")
+        yield (f"__editable__.{self.name}.pth", content)
+
+    def __call__(self, wheel: WheelFile, files: list[str], mapping: Mapping[str, str]):
+        for file, content in self.get_implementation():
+            wheel.writestr(file, content)
+
+    def __enter__(self) -> Self:
+        msg = "Editable install will be performed using a meta path finder.\n"
+        _logger.warning(msg + _LENIENT_WARNING)
+        return self
+
+    def __exit__(
+        self,
+        _exc_type: object,
+        _exc_value: object,
+        _traceback: object,
+    ) -> None:
+        msg = """\n
+        Please be careful with folders in your working directory with the same
+        name as your package as they may take precedence during imports.
+        """
+        InformationOnly.emit("Editable installation.", msg)
+
+
+def _encode_pth(content: str) -> bytes:
+    """
+    Prior to Python 3.13 (see https://github.com/python/cpython/issues/77102),
+    .pth files are always read with 'locale' encoding, the recommendation
+    from the cpython core developers is to write them as ``open(path, "w")``
+    and ignore warnings (see python/cpython#77102, pypa/setuptools#3937).
+    This function tries to simulate this behavior without having to create an
+    actual file, in a way that supports a range of active Python versions.
+    (There seems to be some variety in the way different version of Python handle
+    ``encoding=None``, not all of them use ``locale.getpreferredencoding(False)``
+    or ``locale.getencoding()``).
+    """
+    with io.BytesIO() as buffer:
+        wrapper = io.TextIOWrapper(buffer, encoding=py312.PTH_ENCODING)
+        # TODO: Python 3.13 replace the whole function with `bytes(content, "utf-8")`
+        wrapper.write(content)
+        wrapper.flush()
+        buffer.seek(0)
+        return buffer.read()
+
+
+def _can_symlink_files(base_dir: Path) -> bool:
+    with TemporaryDirectory(dir=str(base_dir.resolve())) as tmp:
+        path1, path2 = Path(tmp, "file1.txt"), Path(tmp, "file2.txt")
+        path1.write_text("file1", encoding="utf-8")
+        with suppress(AttributeError, NotImplementedError, OSError):
+            os.symlink(path1, path2)
+            if path2.is_symlink() and path2.read_text(encoding="utf-8") == "file1":
+                return True
+
+        try:
+            os.link(path1, path2)  # Ensure hard links can be created
+        except Exception as ex:
+            msg = (
+                "File system does not seem to support either symlinks or hard links. "
+                "Strict editable installs require one of them to be supported."
+            )
+            raise LinksNotSupported(msg) from ex
+        return False
+
+
+def _simple_layout(
+    packages: Iterable[str], package_dir: dict[str, str], project_dir: StrPath
+) -> bool:
+    """Return ``True`` if:
+    - all packages are contained by the same parent directory, **and**
+    - all packages become importable if the parent directory is added to ``sys.path``.
+
+    >>> _simple_layout(['a'], {"": "src"}, "/tmp/myproj")
+    True
+    >>> _simple_layout(['a', 'a.b'], {"": "src"}, "/tmp/myproj")
+    True
+    >>> _simple_layout(['a', 'a.b'], {}, "/tmp/myproj")
+    True
+    >>> _simple_layout(['a', 'a.a1', 'a.a1.a2', 'b'], {"": "src"}, "/tmp/myproj")
+    True
+    >>> _simple_layout(['a', 'a.a1', 'a.a1.a2', 'b'], {"a": "a", "b": "b"}, ".")
+    True
+    >>> _simple_layout(['a', 'a.a1', 'a.a1.a2', 'b'], {"a": "_a", "b": "_b"}, ".")
+    False
+    >>> _simple_layout(['a', 'a.a1', 'a.a1.a2', 'b'], {"a": "_a"}, "/tmp/myproj")
+    False
+    >>> _simple_layout(['a', 'a.a1', 'a.a1.a2', 'b'], {"a.a1.a2": "_a2"}, ".")
+    False
+    >>> _simple_layout(['a', 'a.b'], {"": "src", "a.b": "_ab"}, "/tmp/myproj")
+    False
+    >>> # Special cases, no packages yet:
+    >>> _simple_layout([], {"": "src"}, "/tmp/myproj")
+    True
+    >>> _simple_layout([], {"a": "_a", "": "src"}, "/tmp/myproj")
+    False
+    """
+    layout = {pkg: find_package_path(pkg, package_dir, project_dir) for pkg in packages}
+    if not layout:
+        return set(package_dir) in ({}, {""})
+    parent = os.path.commonpath(starmap(_parent_path, layout.items()))
+    return all(
+        _path.same_path(Path(parent, *key.split('.')), value)
+        for key, value in layout.items()
+    )
+
+
+def _parent_path(pkg, pkg_path):
+    """Infer the parent path containing a package, that if added to ``sys.path`` would
+    allow importing that package.
+    When ``pkg`` is directly mapped into a directory with a different name, return its
+    own path.
+    >>> _parent_path("a", "src/a")
+    'src'
+    >>> _parent_path("b", "src/c")
+    'src/c'
+    """
+    parent = pkg_path[: -len(pkg)] if pkg_path.endswith(pkg) else pkg_path
+    return parent.rstrip("/" + os.sep)
+
+
+def _find_packages(dist: Distribution) -> Iterator[str]:
+    yield from iter(dist.packages or [])
+
+    py_modules = dist.py_modules or []
+    nested_modules = [mod for mod in py_modules if "." in mod]
+    if dist.ext_package:
+        yield dist.ext_package
+    else:
+        ext_modules = dist.ext_modules or []
+        nested_modules += [x.name for x in ext_modules if "." in x.name]
+
+    for module in nested_modules:
+        package, _, _ = module.rpartition(".")
+        yield package
+
+
+def _find_top_level_modules(dist: Distribution) -> Iterator[str]:
+    py_modules = dist.py_modules or []
+    yield from (mod for mod in py_modules if "." not in mod)
+
+    if not dist.ext_package:
+        ext_modules = dist.ext_modules or []
+        yield from (x.name for x in ext_modules if "." not in x.name)
+
+
+def _find_package_roots(
+    packages: Iterable[str],
+    package_dir: Mapping[str, str],
+    src_root: StrPath,
+) -> dict[str, str]:
+    pkg_roots: dict[str, str] = {
+        pkg: _absolute_root(find_package_path(pkg, package_dir, src_root))
+        for pkg in sorted(packages)
+    }
+
+    return _remove_nested(pkg_roots)
+
+
+def _absolute_root(path: StrPath) -> str:
+    """Works for packages and top-level modules"""
+    path_ = Path(path)
+    parent = path_.parent
+
+    if path_.exists():
+        return str(path_.resolve())
+    else:
+        return str(parent.resolve() / path_.name)
+
+
+def _find_virtual_namespaces(pkg_roots: dict[str, str]) -> Iterator[str]:
+    """By carefully designing ``package_dir``, it is possible to implement the logical
+    structure of PEP 420 in a package without the corresponding directories.
+
+    Moreover a parent package can be purposefully/accidentally skipped in the discovery
+    phase (e.g. ``find_packages(include=["mypkg.*"])``, when ``mypkg.foo`` is included
+    by ``mypkg`` itself is not).
+    We consider this case to also be a virtual namespace (ignoring the original
+    directory) to emulate a non-editable installation.
+
+    This function will try to find these kinds of namespaces.
+    """
+    for pkg in pkg_roots:
+        if "." not in pkg:
+            continue
+        parts = pkg.split(".")
+        for i in range(len(parts) - 1, 0, -1):
+            partial_name = ".".join(parts[:i])
+            path = Path(find_package_path(partial_name, pkg_roots, ""))
+            if not path.exists() or partial_name not in pkg_roots:
+                # partial_name not in pkg_roots ==> purposefully/accidentally skipped
+                yield partial_name
+
+
+def _find_namespaces(
+    packages: list[str], pkg_roots: dict[str, str]
+) -> Iterator[tuple[str, list[str]]]:
+    for pkg in packages:
+        path = find_package_path(pkg, pkg_roots, "")
+        if Path(path).exists() and not Path(path, "__init__.py").exists():
+            yield (pkg, [path])
+
+
+def _remove_nested(pkg_roots: dict[str, str]) -> dict[str, str]:
+    output = dict(pkg_roots.copy())
+
+    for pkg, path in reversed(list(pkg_roots.items())):
+        if any(
+            pkg != other and _is_nested(pkg, path, other, other_path)
+            for other, other_path in pkg_roots.items()
+        ):
+            output.pop(pkg)
+
+    return output
+
+
+def _is_nested(pkg: str, pkg_path: str, parent: str, parent_path: str) -> bool:
+    """
+    Return ``True`` if ``pkg`` is nested inside ``parent`` both logically and in the
+    file system.
+    >>> _is_nested("a.b", "path/a/b", "a", "path/a")
+    True
+    >>> _is_nested("a.b", "path/a/b", "a", "otherpath/a")
+    False
+    >>> _is_nested("a.b", "path/a/b", "c", "path/c")
+    False
+    >>> _is_nested("a.a", "path/a/a", "a", "path/a")
+    True
+    >>> _is_nested("b.a", "path/b/a", "a", "path/a")
+    False
+    """
+    norm_pkg_path = _path.normpath(pkg_path)
+    rest = pkg.replace(parent, "", 1).strip(".").split(".")
+    return pkg.startswith(parent) and norm_pkg_path == _path.normpath(
+        Path(parent_path, *rest)
+    )
+
+
+def _empty_dir(dir_: _P) -> _P:
+    """Create a directory ensured to be empty. Existing files may be removed."""
+    _shutil.rmtree(dir_, ignore_errors=True)
+    os.makedirs(dir_)
+    return dir_
+
+
+class _NamespaceInstaller(namespaces.Installer):
+    def __init__(self, distribution, installation_dir, editable_name, src_root) -> None:
+        self.distribution = distribution
+        self.src_root = src_root
+        self.installation_dir = installation_dir
+        self.editable_name = editable_name
+        self.outputs: list[str] = []
+        self.dry_run = False
+
+    def _get_nspkg_file(self):
+        """Installation target."""
+        return os.path.join(self.installation_dir, self.editable_name + self.nspkg_ext)
+
+    def _get_root(self):
+        """Where the modules/packages should be loaded from."""
+        return repr(str(self.src_root))
+
+
+_FINDER_TEMPLATE = """\
+from __future__ import annotations
+import sys
+from importlib.machinery import ModuleSpec, PathFinder
+from importlib.machinery import all_suffixes as module_suffixes
+from importlib.util import spec_from_file_location
+from itertools import chain
+from pathlib import Path
+
+MAPPING: dict[str, str] = {mapping!r}
+NAMESPACES: dict[str, list[str]] = {namespaces!r}
+PATH_PLACEHOLDER = {name!r} + ".__path_hook__"
+
+
+class _EditableFinder:  # MetaPathFinder
+    @classmethod
+    def find_spec(cls, fullname: str, path=None, target=None) -> ModuleSpec | None:  # type: ignore
+        # Top-level packages and modules (we know these exist in the FS)
+        if fullname in MAPPING:
+            pkg_path = MAPPING[fullname]
+            return cls._find_spec(fullname, Path(pkg_path))
+
+        # Handle immediate children modules (required for namespaces to work)
+        # To avoid problems with case sensitivity in the file system we delegate
+        # to the importlib.machinery implementation.
+        parent, _, child = fullname.rpartition(".")
+        if parent and parent in MAPPING:
+            return PathFinder.find_spec(fullname, path=[MAPPING[parent]])
+
+        # Other levels of nesting should be handled automatically by importlib
+        # using the parent path.
+        return None
+
+    @classmethod
+    def _find_spec(cls, fullname: str, candidate_path: Path) -> ModuleSpec | None:
+        init = candidate_path / "__init__.py"
+        candidates = (candidate_path.with_suffix(x) for x in module_suffixes())
+        for candidate in chain([init], candidates):
+            if candidate.exists():
+                return spec_from_file_location(fullname, candidate)
+        return None
+
+
+class _EditableNamespaceFinder:  # PathEntryFinder
+    @classmethod
+    def _path_hook(cls, path) -> type[_EditableNamespaceFinder]:
+        if path == PATH_PLACEHOLDER:
+            return cls
+        raise ImportError
+
+    @classmethod
+    def _paths(cls, fullname: str) -> list[str]:
+        paths = NAMESPACES[fullname]
+        if not paths and fullname in MAPPING:
+            paths = [MAPPING[fullname]]
+        # Always add placeholder, for 2 reasons:
+        # 1. __path__ cannot be empty for the spec to be considered namespace.
+        # 2. In the case of nested namespaces, we need to force
+        #    import machinery to query _EditableNamespaceFinder again.
+        return [*paths, PATH_PLACEHOLDER]
+
+    @classmethod
+    def find_spec(cls, fullname: str, target=None) -> ModuleSpec | None:  # type: ignore
+        if fullname in NAMESPACES:
+            spec = ModuleSpec(fullname, None, is_package=True)
+            spec.submodule_search_locations = cls._paths(fullname)
+            return spec
+        return None
+
+    @classmethod
+    def find_module(cls, _fullname) -> None:
+        return None
+
+
+def install():
+    if not any(finder == _EditableFinder for finder in sys.meta_path):
+        sys.meta_path.append(_EditableFinder)
+
+    if not NAMESPACES:
+        return
+
+    if not any(hook == _EditableNamespaceFinder._path_hook for hook in sys.path_hooks):
+        # PathEntryFinder is needed to create NamespaceSpec without private APIS
+        sys.path_hooks.append(_EditableNamespaceFinder._path_hook)
+    if PATH_PLACEHOLDER not in sys.path:
+        sys.path.append(PATH_PLACEHOLDER)  # Used just to trigger the path hook
+"""
+
+
+def _finder_template(
+    name: str, mapping: Mapping[str, str], namespaces: dict[str, list[str]]
+) -> str:
+    """Create a string containing the code for the``MetaPathFinder`` and
+    ``PathEntryFinder``.
+    """
+    mapping = dict(sorted(mapping.items(), key=lambda p: p[0]))
+    return _FINDER_TEMPLATE.format(name=name, mapping=mapping, namespaces=namespaces)
+
+
+class LinksNotSupported(errors.FileError):
+    """File system does not seem to support either symlinks or hard links."""
+
+
+class _DebuggingTips(SetuptoolsWarning):
+    _SUMMARY = "Problem in editable installation."
+    _DETAILS = """
+    An error happened while installing `{project}` in editable mode.
+
+    The following steps are recommended to help debug this problem:
+
+    - Try to install the project normally, without using the editable mode.
+      Does the error still persist?
+      (If it does, try fixing the problem before attempting the editable mode).
+    - If you are using binary extensions, make sure you have all OS-level
+      dependencies installed (e.g. compilers, toolchains, binary libraries, ...).
+    - Try the latest version of setuptools (maybe the error was already fixed).
+    - If you (or your project dependencies) are using any setuptools extension
+      or customization, make sure they support the editable mode.
+
+    After following the steps above, if the problem still persists and
+    you think this is related to how setuptools handles editable installations,
+    please submit a reproducible example
+    (see https://stackoverflow.com/help/minimal-reproducible-example) to:
+
+        https://github.com/pypa/setuptools/issues
+    """
+    _SEE_DOCS = "userguide/development_mode.html"
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/command/egg_info.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/command/egg_info.py
new file mode 100644
index 0000000000000000000000000000000000000000..f77631168fcdb60e14ddd757e18b4c301473aa82
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/command/egg_info.py
@@ -0,0 +1,720 @@
+"""setuptools.command.egg_info
+
+Create a distribution's .egg-info directory and contents"""
+
+import functools
+import os
+import re
+import sys
+import time
+from collections.abc import Callable
+
+import packaging
+import packaging.requirements
+import packaging.version
+
+import setuptools.unicode_utils as unicode_utils
+from setuptools import Command
+from setuptools.command import bdist_egg
+from setuptools.command.sdist import sdist, walk_revctrl
+from setuptools.command.setopt import edit_config
+from setuptools.glob import glob
+
+from .. import _entry_points, _normalization
+from .._importlib import metadata
+from ..warnings import SetuptoolsDeprecationWarning
+from . import _requirestxt
+
+import distutils.errors
+import distutils.filelist
+from distutils import log
+from distutils.errors import DistutilsInternalError
+from distutils.filelist import FileList as _FileList
+from distutils.util import convert_path
+
+PY_MAJOR = f'{sys.version_info.major}.{sys.version_info.minor}'
+
+
+def translate_pattern(glob):  # noqa: C901  # is too complex (14)  # FIXME
+    """
+    Translate a file path glob like '*.txt' in to a regular expression.
+    This differs from fnmatch.translate which allows wildcards to match
+    directory separators. It also knows about '**/' which matches any number of
+    directories.
+    """
+    pat = ''
+
+    # This will split on '/' within [character classes]. This is deliberate.
+    chunks = glob.split(os.path.sep)
+
+    sep = re.escape(os.sep)
+    valid_char = f'[^{sep}]'
+
+    for c, chunk in enumerate(chunks):
+        last_chunk = c == len(chunks) - 1
+
+        # Chunks that are a literal ** are globstars. They match anything.
+        if chunk == '**':
+            if last_chunk:
+                # Match anything if this is the last component
+                pat += '.*'
+            else:
+                # Match '(name/)*'
+                pat += f'(?:{valid_char}+{sep})*'
+            continue  # Break here as the whole path component has been handled
+
+        # Find any special characters in the remainder
+        i = 0
+        chunk_len = len(chunk)
+        while i < chunk_len:
+            char = chunk[i]
+            if char == '*':
+                # Match any number of name characters
+                pat += valid_char + '*'
+            elif char == '?':
+                # Match a name character
+                pat += valid_char
+            elif char == '[':
+                # Character class
+                inner_i = i + 1
+                # Skip initial !/] chars
+                if inner_i < chunk_len and chunk[inner_i] == '!':
+                    inner_i = inner_i + 1
+                if inner_i < chunk_len and chunk[inner_i] == ']':
+                    inner_i = inner_i + 1
+
+                # Loop till the closing ] is found
+                while inner_i < chunk_len and chunk[inner_i] != ']':
+                    inner_i = inner_i + 1
+
+                if inner_i >= chunk_len:
+                    # Got to the end of the string without finding a closing ]
+                    # Do not treat this as a matching group, but as a literal [
+                    pat += re.escape(char)
+                else:
+                    # Grab the insides of the [brackets]
+                    inner = chunk[i + 1 : inner_i]
+                    char_class = ''
+
+                    # Class negation
+                    if inner[0] == '!':
+                        char_class = '^'
+                        inner = inner[1:]
+
+                    char_class += re.escape(inner)
+                    pat += f'[{char_class}]'
+
+                    # Skip to the end ]
+                    i = inner_i
+            else:
+                pat += re.escape(char)
+            i += 1
+
+        # Join each chunk with the dir separator
+        if not last_chunk:
+            pat += sep
+
+    pat += r'\Z'
+    return re.compile(pat, flags=re.MULTILINE | re.DOTALL)
+
+
+class InfoCommon:
+    tag_build = None
+    tag_date = None
+
+    @property
+    def name(self):
+        return _normalization.safe_name(self.distribution.get_name())
+
+    def tagged_version(self):
+        tagged = self._maybe_tag(self.distribution.get_version())
+        return _normalization.safe_version(tagged)
+
+    def _maybe_tag(self, version):
+        """
+        egg_info may be called more than once for a distribution,
+        in which case the version string already contains all tags.
+        """
+        return (
+            version
+            if self.vtags and self._already_tagged(version)
+            else version + self.vtags
+        )
+
+    def _already_tagged(self, version: str) -> bool:
+        # Depending on their format, tags may change with version normalization.
+        # So in addition the regular tags, we have to search for the normalized ones.
+        return version.endswith(self.vtags) or version.endswith(self._safe_tags())
+
+    def _safe_tags(self) -> str:
+        # To implement this we can rely on `safe_version` pretending to be version 0
+        # followed by tags. Then we simply discard the starting 0 (fake version number)
+        try:
+            return _normalization.safe_version(f"0{self.vtags}")[1:]
+        except packaging.version.InvalidVersion:
+            return _normalization.safe_name(self.vtags.replace(' ', '.'))
+
+    def tags(self) -> str:
+        version = ''
+        if self.tag_build:
+            version += self.tag_build
+        if self.tag_date:
+            version += time.strftime("%Y%m%d")
+        return version
+
+    vtags = property(tags)
+
+
+class egg_info(InfoCommon, Command):
+    description = "create a distribution's .egg-info directory"
+
+    user_options = [
+        (
+            'egg-base=',
+            'e',
+            "directory containing .egg-info directories"
+            " [default: top of the source tree]",
+        ),
+        ('tag-date', 'd', "Add date stamp (e.g. 20050528) to version number"),
+        ('tag-build=', 'b', "Specify explicit tag to add to version number"),
+        ('no-date', 'D', "Don't include date stamp [default]"),
+    ]
+
+    boolean_options = ['tag-date']
+    negative_opt = {
+        'no-date': 'tag-date',
+    }
+
+    def initialize_options(self):
+        self.egg_base = None
+        self.egg_name = None
+        self.egg_info = None
+        self.egg_version = None
+        self.ignore_egg_info_in_manifest = False
+
+    ####################################
+    # allow the 'tag_svn_revision' to be detected and
+    # set, supporting sdists built on older Setuptools.
+    @property
+    def tag_svn_revision(self) -> None:
+        pass
+
+    @tag_svn_revision.setter
+    def tag_svn_revision(self, value):
+        pass
+
+    ####################################
+
+    def save_version_info(self, filename) -> None:
+        """
+        Materialize the value of date into the
+        build tag. Install build keys in a deterministic order
+        to avoid arbitrary reordering on subsequent builds.
+        """
+        # follow the order these keys would have been added
+        # when PYTHONHASHSEED=0
+        egg_info = dict(tag_build=self.tags(), tag_date=0)
+        edit_config(filename, dict(egg_info=egg_info))
+
+    def finalize_options(self) -> None:
+        # Note: we need to capture the current value returned
+        # by `self.tagged_version()`, so we can later update
+        # `self.distribution.metadata.version` without
+        # repercussions.
+        self.egg_name = self.name
+        self.egg_version = self.tagged_version()
+        parsed_version = packaging.version.Version(self.egg_version)
+
+        try:
+            is_version = isinstance(parsed_version, packaging.version.Version)
+            spec = "%s==%s" if is_version else "%s===%s"
+            packaging.requirements.Requirement(spec % (self.egg_name, self.egg_version))
+        except ValueError as e:
+            raise distutils.errors.DistutilsOptionError(
+                f"Invalid distribution name or version syntax: {self.egg_name}-{self.egg_version}"
+            ) from e
+
+        if self.egg_base is None:
+            dirs = self.distribution.package_dir
+            self.egg_base = (dirs or {}).get('', os.curdir)
+
+        self.ensure_dirname('egg_base')
+        self.egg_info = _normalization.filename_component(self.egg_name) + '.egg-info'
+        if self.egg_base != os.curdir:
+            self.egg_info = os.path.join(self.egg_base, self.egg_info)
+
+        # Set package version for the benefit of dumber commands
+        # (e.g. sdist, bdist_wininst, etc.)
+        #
+        self.distribution.metadata.version = self.egg_version
+
+    def _get_egg_basename(self, py_version=PY_MAJOR, platform=None):
+        """Compute filename of the output egg. Private API."""
+        return _egg_basename(self.egg_name, self.egg_version, py_version, platform)
+
+    def write_or_delete_file(self, what, filename, data, force: bool = False) -> None:
+        """Write `data` to `filename` or delete if empty
+
+        If `data` is non-empty, this routine is the same as ``write_file()``.
+        If `data` is empty but not ``None``, this is the same as calling
+        ``delete_file(filename)`.  If `data` is ``None``, then this is a no-op
+        unless `filename` exists, in which case a warning is issued about the
+        orphaned file (if `force` is false), or deleted (if `force` is true).
+        """
+        if data:
+            self.write_file(what, filename, data)
+        elif os.path.exists(filename):
+            if data is None and not force:
+                log.warn("%s not set in setup(), but %s exists", what, filename)
+                return
+            else:
+                self.delete_file(filename)
+
+    def write_file(self, what, filename, data) -> None:
+        """Write `data` to `filename` (if not a dry run) after announcing it
+
+        `what` is used in a log message to identify what is being written
+        to the file.
+        """
+        log.info("writing %s to %s", what, filename)
+        data = data.encode("utf-8")
+        if not self.dry_run:
+            f = open(filename, 'wb')
+            f.write(data)
+            f.close()
+
+    def delete_file(self, filename) -> None:
+        """Delete `filename` (if not a dry run) after announcing it"""
+        log.info("deleting %s", filename)
+        if not self.dry_run:
+            os.unlink(filename)
+
+    def run(self) -> None:
+        # Pre-load to avoid iterating over entry-points while an empty .egg-info
+        # exists in sys.path. See pypa/pyproject-hooks#206
+        writers = list(metadata.entry_points(group='egg_info.writers'))
+
+        self.mkpath(self.egg_info)
+        try:
+            os.utime(self.egg_info, None)
+        except OSError as e:
+            msg = f"Cannot update time stamp of directory '{self.egg_info}'"
+            raise distutils.errors.DistutilsFileError(msg) from e
+        for ep in writers:
+            writer = ep.load()
+            writer(self, ep.name, os.path.join(self.egg_info, ep.name))
+
+        # Get rid of native_libs.txt if it was put there by older bdist_egg
+        nl = os.path.join(self.egg_info, "native_libs.txt")
+        if os.path.exists(nl):
+            self.delete_file(nl)
+
+        self.find_sources()
+
+    def find_sources(self) -> None:
+        """Generate SOURCES.txt manifest file"""
+        manifest_filename = os.path.join(self.egg_info, "SOURCES.txt")
+        mm = manifest_maker(self.distribution)
+        mm.ignore_egg_info_dir = self.ignore_egg_info_in_manifest
+        mm.manifest = manifest_filename
+        mm.run()
+        self.filelist = mm.filelist
+
+
+class FileList(_FileList):
+    # Implementations of the various MANIFEST.in commands
+
+    def __init__(
+        self, warn=None, debug_print=None, ignore_egg_info_dir: bool = False
+    ) -> None:
+        super().__init__(warn, debug_print)
+        self.ignore_egg_info_dir = ignore_egg_info_dir
+
+    def process_template_line(self, line) -> None:
+        # Parse the line: split it up, make sure the right number of words
+        # is there, and return the relevant words.  'action' is always
+        # defined: it's the first word of the line.  Which of the other
+        # three are defined depends on the action; it'll be either
+        # patterns, (dir and patterns), or (dir_pattern).
+        (action, patterns, dir, dir_pattern) = self._parse_template_line(line)
+
+        action_map: dict[str, Callable] = {
+            'include': self.include,
+            'exclude': self.exclude,
+            'global-include': self.global_include,
+            'global-exclude': self.global_exclude,
+            'recursive-include': functools.partial(
+                self.recursive_include,
+                dir,
+            ),
+            'recursive-exclude': functools.partial(
+                self.recursive_exclude,
+                dir,
+            ),
+            'graft': self.graft,
+            'prune': self.prune,
+        }
+        log_map = {
+            'include': "warning: no files found matching '%s'",
+            'exclude': ("warning: no previously-included files found matching '%s'"),
+            'global-include': (
+                "warning: no files found matching '%s' anywhere in distribution"
+            ),
+            'global-exclude': (
+                "warning: no previously-included files matching "
+                "'%s' found anywhere in distribution"
+            ),
+            'recursive-include': (
+                "warning: no files found matching '%s' under directory '%s'"
+            ),
+            'recursive-exclude': (
+                "warning: no previously-included files matching "
+                "'%s' found under directory '%s'"
+            ),
+            'graft': "warning: no directories found matching '%s'",
+            'prune': "no previously-included directories found matching '%s'",
+        }
+
+        try:
+            process_action = action_map[action]
+        except KeyError:
+            msg = f"Invalid MANIFEST.in: unknown action {action!r} in {line!r}"
+            raise DistutilsInternalError(msg) from None
+
+        # OK, now we know that the action is valid and we have the
+        # right number of words on the line for that action -- so we
+        # can proceed with minimal error-checking.
+
+        action_is_recursive = action.startswith('recursive-')
+        if action in {'graft', 'prune'}:
+            patterns = [dir_pattern]
+        extra_log_args = (dir,) if action_is_recursive else ()
+        log_tmpl = log_map[action]
+
+        self.debug_print(
+            ' '.join(
+                [action] + ([dir] if action_is_recursive else []) + patterns,
+            )
+        )
+        for pattern in patterns:
+            if not process_action(pattern):
+                log.warn(log_tmpl, pattern, *extra_log_args)
+
+    def _remove_files(self, predicate):
+        """
+        Remove all files from the file list that match the predicate.
+        Return True if any matching files were removed
+        """
+        found = False
+        for i in range(len(self.files) - 1, -1, -1):
+            if predicate(self.files[i]):
+                self.debug_print(" removing " + self.files[i])
+                del self.files[i]
+                found = True
+        return found
+
+    def include(self, pattern):
+        """Include files that match 'pattern'."""
+        found = [f for f in glob(pattern) if not os.path.isdir(f)]
+        self.extend(found)
+        return bool(found)
+
+    def exclude(self, pattern):
+        """Exclude files that match 'pattern'."""
+        match = translate_pattern(pattern)
+        return self._remove_files(match.match)
+
+    def recursive_include(self, dir, pattern):
+        """
+        Include all files anywhere in 'dir/' that match the pattern.
+        """
+        full_pattern = os.path.join(dir, '**', pattern)
+        found = [f for f in glob(full_pattern, recursive=True) if not os.path.isdir(f)]
+        self.extend(found)
+        return bool(found)
+
+    def recursive_exclude(self, dir, pattern):
+        """
+        Exclude any file anywhere in 'dir/' that match the pattern.
+        """
+        match = translate_pattern(os.path.join(dir, '**', pattern))
+        return self._remove_files(match.match)
+
+    def graft(self, dir):
+        """Include all files from 'dir/'."""
+        found = [
+            item
+            for match_dir in glob(dir)
+            for item in distutils.filelist.findall(match_dir)
+        ]
+        self.extend(found)
+        return bool(found)
+
+    def prune(self, dir):
+        """Filter out files from 'dir/'."""
+        match = translate_pattern(os.path.join(dir, '**'))
+        return self._remove_files(match.match)
+
+    def global_include(self, pattern):
+        """
+        Include all files anywhere in the current directory that match the
+        pattern. This is very inefficient on large file trees.
+        """
+        if self.allfiles is None:
+            self.findall()
+        match = translate_pattern(os.path.join('**', pattern))
+        found = [f for f in self.allfiles if match.match(f)]
+        self.extend(found)
+        return bool(found)
+
+    def global_exclude(self, pattern):
+        """
+        Exclude all files anywhere that match the pattern.
+        """
+        match = translate_pattern(os.path.join('**', pattern))
+        return self._remove_files(match.match)
+
+    def append(self, item) -> None:
+        if item.endswith('\r'):  # Fix older sdists built on Windows
+            item = item[:-1]
+        path = convert_path(item)
+
+        if self._safe_path(path):
+            self.files.append(path)
+
+    def extend(self, paths) -> None:
+        self.files.extend(filter(self._safe_path, paths))
+
+    def _repair(self):
+        """
+        Replace self.files with only safe paths
+
+        Because some owners of FileList manipulate the underlying
+        ``files`` attribute directly, this method must be called to
+        repair those paths.
+        """
+        self.files = list(filter(self._safe_path, self.files))
+
+    def _safe_path(self, path):
+        enc_warn = "'%s' not %s encodable -- skipping"
+
+        # To avoid accidental trans-codings errors, first to unicode
+        u_path = unicode_utils.filesys_decode(path)
+        if u_path is None:
+            log.warn(f"'{path}' in unexpected encoding -- skipping")
+            return False
+
+        # Must ensure utf-8 encodability
+        utf8_path = unicode_utils.try_encode(u_path, "utf-8")
+        if utf8_path is None:
+            log.warn(enc_warn, path, 'utf-8')
+            return False
+
+        try:
+            # ignore egg-info paths
+            is_egg_info = ".egg-info" in u_path or b".egg-info" in utf8_path
+            if self.ignore_egg_info_dir and is_egg_info:
+                return False
+            # accept is either way checks out
+            if os.path.exists(u_path) or os.path.exists(utf8_path):
+                return True
+        # this will catch any encode errors decoding u_path
+        except UnicodeEncodeError:
+            log.warn(enc_warn, path, sys.getfilesystemencoding())
+
+
+class manifest_maker(sdist):
+    template = "MANIFEST.in"
+
+    def initialize_options(self) -> None:
+        self.use_defaults = True
+        self.prune = True
+        self.manifest_only = True
+        self.force_manifest = True
+        self.ignore_egg_info_dir = False
+
+    def finalize_options(self) -> None:
+        pass
+
+    def run(self) -> None:
+        self.filelist = FileList(ignore_egg_info_dir=self.ignore_egg_info_dir)
+        if not os.path.exists(self.manifest):
+            self.write_manifest()  # it must exist so it'll get in the list
+        self.add_defaults()
+        if os.path.exists(self.template):
+            self.read_template()
+        self.add_license_files()
+        self._add_referenced_files()
+        self.prune_file_list()
+        self.filelist.sort()
+        self.filelist.remove_duplicates()
+        self.write_manifest()
+
+    def _manifest_normalize(self, path):
+        path = unicode_utils.filesys_decode(path)
+        return path.replace(os.sep, '/')
+
+    def write_manifest(self) -> None:
+        """
+        Write the file list in 'self.filelist' to the manifest file
+        named by 'self.manifest'.
+        """
+        self.filelist._repair()
+
+        # Now _repairs should encodability, but not unicode
+        files = [self._manifest_normalize(f) for f in self.filelist.files]
+        msg = f"writing manifest file '{self.manifest}'"
+        self.execute(write_file, (self.manifest, files), msg)
+
+    def warn(self, msg) -> None:
+        if not self._should_suppress_warning(msg):
+            sdist.warn(self, msg)
+
+    @staticmethod
+    def _should_suppress_warning(msg):
+        """
+        suppress missing-file warnings from sdist
+        """
+        return re.match(r"standard file .*not found", msg)
+
+    def add_defaults(self) -> None:
+        sdist.add_defaults(self)
+        self.filelist.append(self.template)
+        self.filelist.append(self.manifest)
+        rcfiles = list(walk_revctrl())
+        if rcfiles:
+            self.filelist.extend(rcfiles)
+        elif os.path.exists(self.manifest):
+            self.read_manifest()
+
+        if os.path.exists("setup.py"):
+            # setup.py should be included by default, even if it's not
+            # the script called to create the sdist
+            self.filelist.append("setup.py")
+
+        ei_cmd = self.get_finalized_command('egg_info')
+        self.filelist.graft(ei_cmd.egg_info)
+
+    def add_license_files(self) -> None:
+        license_files = self.distribution.metadata.license_files or []
+        for lf in license_files:
+            log.info("adding license file '%s'", lf)
+        self.filelist.extend(license_files)
+
+    def _add_referenced_files(self):
+        """Add files referenced by the config (e.g. `file:` directive) to filelist"""
+        referenced = getattr(self.distribution, '_referenced_files', [])
+        # ^-- fallback if dist comes from distutils or is a custom class
+        for rf in referenced:
+            log.debug("adding file referenced by config '%s'", rf)
+        self.filelist.extend(referenced)
+
+    def _safe_data_files(self, build_py):
+        """
+        The parent class implementation of this method
+        (``sdist``) will try to include data files, which
+        might cause recursion problems when
+        ``include_package_data=True``.
+
+        Therefore, avoid triggering any attempt of
+        analyzing/building the manifest again.
+        """
+        if hasattr(build_py, 'get_data_files_without_manifest'):
+            return build_py.get_data_files_without_manifest()
+
+        SetuptoolsDeprecationWarning.emit(
+            "`build_py` command does not inherit from setuptools' `build_py`.",
+            """
+            Custom 'build_py' does not implement 'get_data_files_without_manifest'.
+            Please extend command classes from setuptools instead of distutils.
+            """,
+            see_url="https://peps.python.org/pep-0632/",
+            # due_date not defined yet, old projects might still do it?
+        )
+        return build_py.get_data_files()
+
+
+def write_file(filename, contents) -> None:
+    """Create a file with the specified name and write 'contents' (a
+    sequence of strings without line terminators) to it.
+    """
+    contents = "\n".join(contents)
+
+    # assuming the contents has been vetted for utf-8 encoding
+    contents = contents.encode("utf-8")
+
+    with open(filename, "wb") as f:  # always write POSIX-style manifest
+        f.write(contents)
+
+
+def write_pkg_info(cmd, basename, filename) -> None:
+    log.info("writing %s", filename)
+    if not cmd.dry_run:
+        metadata = cmd.distribution.metadata
+        metadata.version, oldver = cmd.egg_version, metadata.version
+        metadata.name, oldname = cmd.egg_name, metadata.name
+
+        try:
+            # write unescaped data to PKG-INFO, so older pkg_resources
+            # can still parse it
+            metadata.write_pkg_info(cmd.egg_info)
+        finally:
+            metadata.name, metadata.version = oldname, oldver
+
+        safe = getattr(cmd.distribution, 'zip_safe', None)
+
+        bdist_egg.write_safety_flag(cmd.egg_info, safe)
+
+
+def warn_depends_obsolete(cmd, basename, filename) -> None:
+    """
+    Unused: left to avoid errors when updating (from source) from <= 67.8.
+    Old installations have a .dist-info directory with the entry-point
+    ``depends.txt = setuptools.command.egg_info:warn_depends_obsolete``.
+    This may trigger errors when running the first egg_info in build_meta.
+    TODO: Remove this function in a version sufficiently > 68.
+    """
+
+
+# Export API used in entry_points
+write_requirements = _requirestxt.write_requirements
+write_setup_requirements = _requirestxt.write_setup_requirements
+
+
+def write_toplevel_names(cmd, basename, filename) -> None:
+    pkgs = dict.fromkeys([
+        k.split('.', 1)[0] for k in cmd.distribution.iter_distribution_names()
+    ])
+    cmd.write_file("top-level names", filename, '\n'.join(sorted(pkgs)) + '\n')
+
+
+def overwrite_arg(cmd, basename, filename) -> None:
+    write_arg(cmd, basename, filename, True)
+
+
+def write_arg(cmd, basename, filename, force: bool = False) -> None:
+    argname = os.path.splitext(basename)[0]
+    value = getattr(cmd.distribution, argname, None)
+    if value is not None:
+        value = '\n'.join(value) + '\n'
+    cmd.write_or_delete_file(argname, filename, value, force)
+
+
+def write_entries(cmd, basename, filename) -> None:
+    eps = _entry_points.load(cmd.distribution.entry_points)
+    defn = _entry_points.render(eps)
+    cmd.write_or_delete_file('entry points', filename, defn, True)
+
+
+def _egg_basename(egg_name, egg_version, py_version=None, platform=None):
+    """Compute filename of the output egg. Private API."""
+    name = _normalization.filename_component(egg_name)
+    version = _normalization.filename_component(egg_version)
+    egg = f"{name}-{version}-py{py_version or PY_MAJOR}"
+    if platform:
+        egg += f"-{platform}"
+    return egg
+
+
+class EggInfoDeprecationWarning(SetuptoolsDeprecationWarning):
+    """Deprecated behavior warning for EggInfo, bypassing suppression."""
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/command/install.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/command/install.py
new file mode 100644
index 0000000000000000000000000000000000000000..15ef36468889d55718711edbe9c4e061c48ee6e8
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/command/install.py
@@ -0,0 +1,183 @@
+from __future__ import annotations
+
+import glob
+import inspect
+import platform
+from collections.abc import Callable
+from typing import TYPE_CHECKING, Any, ClassVar, cast
+
+import setuptools
+
+from ..dist import Distribution
+from ..warnings import SetuptoolsDeprecationWarning, SetuptoolsWarning
+from .bdist_egg import bdist_egg as bdist_egg_cls
+
+import distutils.command.install as orig
+from distutils.errors import DistutilsArgError
+
+if TYPE_CHECKING:
+    # This is only used for a type-cast, don't import at runtime or it'll cause deprecation warnings
+    from .easy_install import easy_install as easy_install_cls
+else:
+    easy_install_cls = None
+
+
+def __getattr__(name: str):  # pragma: no cover
+    if name == "_install":
+        SetuptoolsDeprecationWarning.emit(
+            "`setuptools.command._install` was an internal implementation detail "
+            + "that was left in for numpy<1.9 support.",
+            due_date=(2025, 5, 2),  # Originally added on 2024-11-01
+        )
+        return orig.install
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+
+
+class install(orig.install):
+    """Use easy_install to install the package, w/dependencies"""
+
+    distribution: Distribution  # override distutils.dist.Distribution with setuptools.dist.Distribution
+
+    user_options = orig.install.user_options + [
+        ('old-and-unmanageable', None, "Try not to use this!"),
+        (
+            'single-version-externally-managed',
+            None,
+            "used by system package builders to create 'flat' eggs",
+        ),
+    ]
+    boolean_options = orig.install.boolean_options + [
+        'old-and-unmanageable',
+        'single-version-externally-managed',
+    ]
+    # Type the same as distutils.command.install.install.sub_commands
+    # Must keep the second tuple item potentially None due to invariance
+    new_commands: ClassVar[list[tuple[str, Callable[[Any], bool] | None]]] = [
+        ('install_egg_info', lambda self: True),
+        ('install_scripts', lambda self: True),
+    ]
+    _nc = dict(new_commands)
+
+    def initialize_options(self):
+        SetuptoolsDeprecationWarning.emit(
+            "setup.py install is deprecated.",
+            """
+            Please avoid running ``setup.py`` directly.
+            Instead, use pypa/build, pypa/installer or other
+            standards-based tools.
+            """,
+            see_url="https://blog.ganssle.io/articles/2021/10/setup-py-deprecated.html",
+            # TODO: Document how to bootstrap setuptools without install
+            #       (e.g. by unzipping the wheel file)
+            #       and then add a due_date to this warning.
+        )
+
+        super().initialize_options()
+        self.old_and_unmanageable = None
+        self.single_version_externally_managed = None
+
+    def finalize_options(self) -> None:
+        super().finalize_options()
+        if self.root:
+            self.single_version_externally_managed = True
+        elif self.single_version_externally_managed:
+            if not self.root and not self.record:
+                raise DistutilsArgError(
+                    "You must specify --record or --root when building system packages"
+                )
+
+    def handle_extra_path(self):
+        if self.root or self.single_version_externally_managed:
+            # explicit backward-compatibility mode, allow extra_path to work
+            return orig.install.handle_extra_path(self)
+
+        # Ignore extra_path when installing an egg (or being run by another
+        # command without --root or --single-version-externally-managed
+        self.path_file = None
+        self.extra_dirs = ''
+        return None
+
+    def run(self):
+        # Explicit request for old-style install?  Just do it
+        if self.old_and_unmanageable or self.single_version_externally_managed:
+            return super().run()
+
+        if not self._called_from_setup(inspect.currentframe()):
+            # Run in backward-compatibility mode to support bdist_* commands.
+            super().run()
+        else:
+            self.do_egg_install()
+
+        return None
+
+    @staticmethod
+    def _called_from_setup(run_frame):
+        """
+        Attempt to detect whether run() was called from setup() or by another
+        command.  If called by setup(), the parent caller will be the
+        'run_command' method in 'distutils.dist', and *its* caller will be
+        the 'run_commands' method.  If called any other way, the
+        immediate caller *might* be 'run_command', but it won't have been
+        called by 'run_commands'. Return True in that case or if a call stack
+        is unavailable. Return False otherwise.
+        """
+        if run_frame is None:
+            msg = "Call stack not available. bdist_* commands may fail."
+            SetuptoolsWarning.emit(msg)
+            if platform.python_implementation() == 'IronPython':
+                msg = "For best results, pass -X:Frames to enable call stack."
+                SetuptoolsWarning.emit(msg)
+            return True
+
+        frames = inspect.getouterframes(run_frame)
+        for frame in frames[2:4]:
+            (caller,) = frame[:1]
+            info = inspect.getframeinfo(caller)
+            caller_module = caller.f_globals.get('__name__', '')
+
+            if caller_module == "setuptools.dist" and info.function == "run_command":
+                # Starting from v61.0.0 setuptools overwrites dist.run_command
+                continue
+
+            return caller_module == 'distutils.dist' and info.function == 'run_commands'
+
+        return False
+
+    def do_egg_install(self) -> None:
+        easy_install = self.distribution.get_command_class('easy_install')
+
+        cmd = cast(
+            # We'd want to cast easy_install as type[easy_install_cls] but a bug in
+            # mypy makes it think easy_install() returns a Command on Python 3.12+
+            # https://github.com/python/mypy/issues/18088
+            easy_install_cls,
+            easy_install(  # type: ignore[call-arg]
+                self.distribution,
+                args="x",
+                root=self.root,
+                record=self.record,
+            ),
+        )
+        cmd.ensure_finalized()  # finalize before bdist_egg munges install cmd
+        cmd.always_copy_from = '.'  # make sure local-dir eggs get installed
+
+        # pick up setup-dir .egg files only: no .egg-info
+        cmd.package_index.scan(glob.glob('*.egg'))
+
+        self.run_command('bdist_egg')
+        bdist_egg = cast(bdist_egg_cls, self.distribution.get_command_obj('bdist_egg'))
+        args = [bdist_egg.egg_output]
+
+        if setuptools.bootstrap_install_from:
+            # Bootstrap self-installation of setuptools
+            args.insert(0, setuptools.bootstrap_install_from)
+
+        cmd.args = args
+        cmd.run(show_deprecation=False)
+        setuptools.bootstrap_install_from = None
+
+
+# XXX Python 3.1 doesn't see _nc if this is inside the class
+install.sub_commands = [
+    cmd for cmd in orig.install.sub_commands if cmd[0] not in install._nc
+] + install.new_commands
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/command/install_egg_info.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/command/install_egg_info.py
new file mode 100644
index 0000000000000000000000000000000000000000..44f22ccf51cc3fb1662b326c3150845356d77fc3
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/command/install_egg_info.py
@@ -0,0 +1,58 @@
+import os
+
+from setuptools import Command, namespaces
+from setuptools.archive_util import unpack_archive
+
+from .._path import ensure_directory
+
+from distutils import dir_util, log
+
+
+class install_egg_info(namespaces.Installer, Command):
+    """Install an .egg-info directory for the package"""
+
+    description = "Install an .egg-info directory for the package"
+
+    user_options = [
+        ('install-dir=', 'd', "directory to install to"),
+    ]
+
+    def initialize_options(self):
+        self.install_dir = None
+
+    def finalize_options(self) -> None:
+        self.set_undefined_options('install_lib', ('install_dir', 'install_dir'))
+        ei_cmd = self.get_finalized_command("egg_info")
+        basename = f"{ei_cmd._get_egg_basename()}.egg-info"
+        self.source = ei_cmd.egg_info
+        self.target = os.path.join(self.install_dir, basename)
+        self.outputs: list[str] = []
+
+    def run(self) -> None:
+        self.run_command('egg_info')
+        if os.path.isdir(self.target) and not os.path.islink(self.target):
+            dir_util.remove_tree(self.target, dry_run=self.dry_run)
+        elif os.path.exists(self.target):
+            self.execute(os.unlink, (self.target,), "Removing " + self.target)
+        if not self.dry_run:
+            ensure_directory(self.target)
+        self.execute(self.copytree, (), f"Copying {self.source} to {self.target}")
+        self.install_namespaces()
+
+    def get_outputs(self):
+        return self.outputs
+
+    def copytree(self) -> None:
+        # Copy the .egg-info tree to site-packages
+        def skimmer(src, dst):
+            # filter out source-control directories; note that 'src' is always
+            # a '/'-separated path, regardless of platform.  'dst' is a
+            # platform-specific path.
+            for skip in '.svn/', 'CVS/':
+                if src.startswith(skip) or '/' + skip in src:
+                    return None
+            self.outputs.append(dst)
+            log.debug("Copying %s to %s", src, dst)
+            return dst
+
+        unpack_archive(self.source, self.target, skimmer)
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/command/install_lib.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/command/install_lib.py
new file mode 100644
index 0000000000000000000000000000000000000000..8e1e07271028386e138585cac7619ab0338017cc
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/command/install_lib.py
@@ -0,0 +1,137 @@
+from __future__ import annotations
+
+import os
+import sys
+from itertools import product, starmap
+
+from .._path import StrPath
+from ..dist import Distribution
+
+import distutils.command.install_lib as orig
+
+
+class install_lib(orig.install_lib):
+    """Don't add compiled flags to filenames of non-Python files"""
+
+    distribution: Distribution  # override distutils.dist.Distribution with setuptools.dist.Distribution
+
+    def run(self) -> None:
+        self.build()
+        outfiles = self.install()
+        if outfiles is not None:
+            # always compile, in case we have any extension stubs to deal with
+            self.byte_compile(outfiles)
+
+    def get_exclusions(self):
+        """
+        Return a collections.Sized collections.Container of paths to be
+        excluded for single_version_externally_managed installations.
+        """
+        all_packages = (
+            pkg
+            for ns_pkg in self._get_SVEM_NSPs()
+            for pkg in self._all_packages(ns_pkg)
+        )
+
+        excl_specs = product(all_packages, self._gen_exclusion_paths())
+        return set(starmap(self._exclude_pkg_path, excl_specs))
+
+    def _exclude_pkg_path(self, pkg, exclusion_path):
+        """
+        Given a package name and exclusion path within that package,
+        compute the full exclusion path.
+        """
+        parts = pkg.split('.') + [exclusion_path]
+        return os.path.join(self.install_dir, *parts)
+
+    @staticmethod
+    def _all_packages(pkg_name):
+        """
+        >>> list(install_lib._all_packages('foo.bar.baz'))
+        ['foo.bar.baz', 'foo.bar', 'foo']
+        """
+        while pkg_name:
+            yield pkg_name
+            pkg_name, _sep, _child = pkg_name.rpartition('.')
+
+    def _get_SVEM_NSPs(self):
+        """
+        Get namespace packages (list) but only for
+        single_version_externally_managed installations and empty otherwise.
+        """
+        # TODO: is it necessary to short-circuit here? i.e. what's the cost
+        # if get_finalized_command is called even when namespace_packages is
+        # False?
+        if not self.distribution.namespace_packages:
+            return []
+
+        install_cmd = self.get_finalized_command('install')
+        svem = install_cmd.single_version_externally_managed
+
+        return self.distribution.namespace_packages if svem else []
+
+    @staticmethod
+    def _gen_exclusion_paths():
+        """
+        Generate file paths to be excluded for namespace packages (bytecode
+        cache files).
+        """
+        # always exclude the package module itself
+        yield '__init__.py'
+
+        yield '__init__.pyc'
+        yield '__init__.pyo'
+
+        if not hasattr(sys, 'implementation'):
+            return
+
+        base = os.path.join('__pycache__', '__init__.' + sys.implementation.cache_tag)
+        yield base + '.pyc'
+        yield base + '.pyo'
+        yield base + '.opt-1.pyc'
+        yield base + '.opt-2.pyc'
+
+    def copy_tree(
+        self,
+        infile: StrPath,
+        outfile: str,
+        # override: Using actual booleans
+        preserve_mode: bool = True,  # type: ignore[override]
+        preserve_times: bool = True,  # type: ignore[override]
+        preserve_symlinks: bool = False,  # type: ignore[override]
+        level: object = 1,
+    ) -> list[str]:
+        assert preserve_mode
+        assert preserve_times
+        assert not preserve_symlinks
+        exclude = self.get_exclusions()
+
+        if not exclude:
+            return orig.install_lib.copy_tree(self, infile, outfile)
+
+        # Exclude namespace package __init__.py* files from the output
+
+        from setuptools.archive_util import unpack_directory
+
+        from distutils import log
+
+        outfiles: list[str] = []
+
+        def pf(src: str, dst: str):
+            if dst in exclude:
+                log.warn("Skipping installation of %s (namespace package)", dst)
+                return False
+
+            log.info("copying %s -> %s", src, os.path.dirname(dst))
+            outfiles.append(dst)
+            return dst
+
+        unpack_directory(infile, outfile, pf)
+        return outfiles
+
+    def get_outputs(self):
+        outputs = orig.install_lib.get_outputs(self)
+        exclude = self.get_exclusions()
+        if exclude:
+            return [f for f in outputs if f not in exclude]
+        return outputs
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/command/install_scripts.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/command/install_scripts.py
new file mode 100644
index 0000000000000000000000000000000000000000..4401cf693d2642abce449dee238c037038633fec
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/command/install_scripts.py
@@ -0,0 +1,73 @@
+from __future__ import annotations
+
+import os
+import sys
+
+from .._path import ensure_directory
+from ..dist import Distribution
+
+import distutils.command.install_scripts as orig
+from distutils import log
+
+
+class install_scripts(orig.install_scripts):
+    """Do normal script install, plus any egg_info wrapper scripts"""
+
+    distribution: Distribution  # override distutils.dist.Distribution with setuptools.dist.Distribution
+
+    def initialize_options(self) -> None:
+        orig.install_scripts.initialize_options(self)
+        self.no_ep = False
+
+    def run(self) -> None:
+        self.run_command("egg_info")
+        if self.distribution.scripts:
+            orig.install_scripts.run(self)  # run first to set up self.outfiles
+        else:
+            self.outfiles: list[str] = []
+        if self.no_ep:
+            # don't install entry point scripts into .egg file!
+            return
+        self._install_ep_scripts()
+
+    def _install_ep_scripts(self):
+        # Delay import side-effects
+        from pkg_resources import Distribution, PathMetadata
+
+        from . import easy_install as ei
+
+        ei_cmd = self.get_finalized_command("egg_info")
+        dist = Distribution(
+            ei_cmd.egg_base,
+            PathMetadata(ei_cmd.egg_base, ei_cmd.egg_info),
+            ei_cmd.egg_name,
+            ei_cmd.egg_version,
+        )
+        bs_cmd = self.get_finalized_command('build_scripts')
+        exec_param = getattr(bs_cmd, 'executable', None)
+        writer = ei.ScriptWriter
+        if exec_param == sys.executable:
+            # In case the path to the Python executable contains a space, wrap
+            # it so it's not split up.
+            exec_param = [exec_param]
+        # resolve the writer to the environment
+        writer = writer.best()
+        cmd = writer.command_spec_class.best().from_param(exec_param)
+        for args in writer.get_args(dist, cmd.as_header()):
+            self.write_script(*args)
+
+    def write_script(self, script_name, contents, mode: str = "t", *ignored) -> None:
+        """Write an executable file to the scripts directory"""
+        from setuptools.command.easy_install import chmod, current_umask
+
+        log.info("Installing %s script to %s", script_name, self.install_dir)
+        target = os.path.join(self.install_dir, script_name)
+        self.outfiles.append(target)
+
+        encoding = None if "b" in mode else "utf-8"
+        mask = current_umask()
+        if not self.dry_run:
+            ensure_directory(target)
+            with open(target, "w" + mode, encoding=encoding) as f:
+                f.write(contents)
+            chmod(target, 0o777 - mask)
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/command/launcher manifest.xml b/tool_server/.venv/lib/python3.12/site-packages/setuptools/command/launcher manifest.xml
new file mode 100644
index 0000000000000000000000000000000000000000..5972a96d8ded85cc14147ffc1400ec67c3b5a578
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/command/launcher manifest.xml	
@@ -0,0 +1,15 @@
+<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0">
+    <assemblyIdentity version="1.0.0.0"
+                      processorArchitecture="X86"
+                      name="%(name)s"
+                      type="win32"/>
+    <!-- Identify the application security requirements. -->
+    <trustInfo xmlns="urn:schemas-microsoft-com:asm.v3">
+        <security>
+            <requestedPrivileges>
+                <requestedExecutionLevel level="asInvoker" uiAccess="false"/>
+            </requestedPrivileges>
+        </security>
+    </trustInfo>
+</assembly>
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/command/rotate.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/command/rotate.py
new file mode 100644
index 0000000000000000000000000000000000000000..acdce07baaf3e4fc87552c39d7ee6e0271fe2a72
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/command/rotate.py
@@ -0,0 +1,65 @@
+from __future__ import annotations
+
+import os
+from typing import ClassVar
+
+from .. import Command, _shutil
+
+from distutils import log
+from distutils.errors import DistutilsOptionError
+from distutils.util import convert_path
+
+
+class rotate(Command):
+    """Delete older distributions"""
+
+    description = "delete older distributions, keeping N newest files"
+    user_options = [
+        ('match=', 'm', "patterns to match (required)"),
+        ('dist-dir=', 'd', "directory where the distributions are"),
+        ('keep=', 'k', "number of matching distributions to keep"),
+    ]
+
+    boolean_options: ClassVar[list[str]] = []
+
+    def initialize_options(self):
+        self.match = None
+        self.dist_dir = None
+        self.keep = None
+
+    def finalize_options(self) -> None:
+        if self.match is None:
+            raise DistutilsOptionError(
+                "Must specify one or more (comma-separated) match patterns "
+                "(e.g. '.zip' or '.egg')"
+            )
+        if self.keep is None:
+            raise DistutilsOptionError("Must specify number of files to keep")
+        try:
+            self.keep = int(self.keep)
+        except ValueError as e:
+            raise DistutilsOptionError("--keep must be an integer") from e
+        if isinstance(self.match, str):
+            self.match = [convert_path(p.strip()) for p in self.match.split(',')]
+        self.set_undefined_options('bdist', ('dist_dir', 'dist_dir'))
+
+    def run(self) -> None:
+        self.run_command("egg_info")
+        from glob import glob
+
+        for pattern in self.match:
+            pattern = self.distribution.get_name() + '*' + pattern
+            files = glob(os.path.join(self.dist_dir, pattern))
+            files = [(os.path.getmtime(f), f) for f in files]
+            files.sort()
+            files.reverse()
+
+            log.info("%d file(s) matching %s", len(files), pattern)
+            files = files[self.keep :]
+            for t, f in files:
+                log.info("Deleting %s", f)
+                if not self.dry_run:
+                    if os.path.isdir(f):
+                        _shutil.rmtree(f)
+                    else:
+                        os.unlink(f)
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/command/saveopts.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/command/saveopts.py
new file mode 100644
index 0000000000000000000000000000000000000000..2a2cbce6e2aad396f4a5ee9788d53387237df96d
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/command/saveopts.py
@@ -0,0 +1,21 @@
+from setuptools.command.setopt import edit_config, option_base
+
+
+class saveopts(option_base):
+    """Save command-line options to a file"""
+
+    description = "save supplied options to setup.cfg or other config file"
+
+    def run(self) -> None:
+        dist = self.distribution
+        settings: dict[str, dict[str, str]] = {}
+
+        for cmd in dist.command_options:
+            if cmd == 'saveopts':
+                continue  # don't save our own options!
+
+            for opt, (src, val) in dist.get_option_dict(cmd).items():
+                if src == "command line":
+                    settings.setdefault(cmd, {})[opt] = val
+
+        edit_config(self.filename, settings, self.dry_run)
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/command/sdist.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/command/sdist.py
new file mode 100644
index 0000000000000000000000000000000000000000..9631cf3114778a8865917d02878525fc0127a253
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/command/sdist.py
@@ -0,0 +1,217 @@
+from __future__ import annotations
+
+import contextlib
+import os
+import re
+from itertools import chain
+from typing import ClassVar
+
+from .._importlib import metadata
+from ..dist import Distribution
+from .build import _ORIGINAL_SUBCOMMANDS
+
+import distutils.command.sdist as orig
+from distutils import log
+
+_default_revctrl = list
+
+
+def walk_revctrl(dirname=''):
+    """Find all files under revision control"""
+    for ep in metadata.entry_points(group='setuptools.file_finders'):
+        yield from ep.load()(dirname)
+
+
+class sdist(orig.sdist):
+    """Smart sdist that finds anything supported by revision control"""
+
+    user_options = [
+        ('formats=', None, "formats for source distribution (comma-separated list)"),
+        (
+            'keep-temp',
+            'k',
+            "keep the distribution tree around after creating " + "archive file(s)",
+        ),
+        (
+            'dist-dir=',
+            'd',
+            "directory to put the source distribution archive(s) in [default: dist]",
+        ),
+        (
+            'owner=',
+            'u',
+            "Owner name used when creating a tar file [default: current user]",
+        ),
+        (
+            'group=',
+            'g',
+            "Group name used when creating a tar file [default: current group]",
+        ),
+    ]
+
+    distribution: Distribution  # override distutils.dist.Distribution with setuptools.dist.Distribution
+    negative_opt: ClassVar[dict[str, str]] = {}
+
+    README_EXTENSIONS = ['', '.rst', '.txt', '.md']
+    READMES = tuple(f'README{ext}' for ext in README_EXTENSIONS)
+
+    def run(self) -> None:
+        self.run_command('egg_info')
+        ei_cmd = self.get_finalized_command('egg_info')
+        self.filelist = ei_cmd.filelist
+        self.filelist.append(os.path.join(ei_cmd.egg_info, 'SOURCES.txt'))
+        self.check_readme()
+
+        # Run sub commands
+        for cmd_name in self.get_sub_commands():
+            self.run_command(cmd_name)
+
+        self.make_distribution()
+
+        dist_files = getattr(self.distribution, 'dist_files', [])
+        for file in self.archive_files:
+            data = ('sdist', '', file)
+            if data not in dist_files:
+                dist_files.append(data)
+
+    def initialize_options(self) -> None:
+        orig.sdist.initialize_options(self)
+
+    def make_distribution(self) -> None:
+        """
+        Workaround for #516
+        """
+        with self._remove_os_link():
+            orig.sdist.make_distribution(self)
+
+    @staticmethod
+    @contextlib.contextmanager
+    def _remove_os_link():
+        """
+        In a context, remove and restore os.link if it exists
+        """
+
+        class NoValue:
+            pass
+
+        orig_val = getattr(os, 'link', NoValue)
+        try:
+            del os.link
+        except Exception:
+            pass
+        try:
+            yield
+        finally:
+            if orig_val is not NoValue:
+                os.link = orig_val
+
+    def add_defaults(self) -> None:
+        super().add_defaults()
+        self._add_defaults_build_sub_commands()
+
+    def _add_defaults_optional(self):
+        super()._add_defaults_optional()
+        if os.path.isfile('pyproject.toml'):
+            self.filelist.append('pyproject.toml')
+
+    def _add_defaults_python(self):
+        """getting python files"""
+        if self.distribution.has_pure_modules():
+            build_py = self.get_finalized_command('build_py')
+            self.filelist.extend(build_py.get_source_files())
+            self._add_data_files(self._safe_data_files(build_py))
+
+    def _add_defaults_build_sub_commands(self):
+        build = self.get_finalized_command("build")
+        missing_cmds = set(build.get_sub_commands()) - _ORIGINAL_SUBCOMMANDS
+        # ^-- the original built-in sub-commands are already handled by default.
+        cmds = (self.get_finalized_command(c) for c in missing_cmds)
+        files = (c.get_source_files() for c in cmds if hasattr(c, "get_source_files"))
+        self.filelist.extend(chain.from_iterable(files))
+
+    def _safe_data_files(self, build_py):
+        """
+        Since the ``sdist`` class is also used to compute the MANIFEST
+        (via :obj:`setuptools.command.egg_info.manifest_maker`),
+        there might be recursion problems when trying to obtain the list of
+        data_files and ``include_package_data=True`` (which in turn depends on
+        the files included in the MANIFEST).
+
+        To avoid that, ``manifest_maker`` should be able to overwrite this
+        method and avoid recursive attempts to build/analyze the MANIFEST.
+        """
+        return build_py.data_files
+
+    def _add_data_files(self, data_files):
+        """
+        Add data files as found in build_py.data_files.
+        """
+        self.filelist.extend(
+            os.path.join(src_dir, name)
+            for _, src_dir, _, filenames in data_files
+            for name in filenames
+        )
+
+    def _add_defaults_data_files(self):
+        try:
+            super()._add_defaults_data_files()
+        except TypeError:
+            log.warn("data_files contains unexpected objects")
+
+    def prune_file_list(self) -> None:
+        super().prune_file_list()
+        # Prevent accidental inclusion of test-related cache dirs at the project root
+        sep = re.escape(os.sep)
+        self.filelist.exclude_pattern(r"^(\.tox|\.nox|\.venv)" + sep, is_regex=True)
+
+    def check_readme(self) -> None:
+        for f in self.READMES:
+            if os.path.exists(f):
+                return
+        else:
+            self.warn(
+                "standard file not found: should have one of " + ', '.join(self.READMES)
+            )
+
+    def make_release_tree(self, base_dir, files) -> None:
+        orig.sdist.make_release_tree(self, base_dir, files)
+
+        # Save any egg_info command line options used to create this sdist
+        dest = os.path.join(base_dir, 'setup.cfg')
+        if hasattr(os, 'link') and os.path.exists(dest):
+            # unlink and re-copy, since it might be hard-linked, and
+            # we don't want to change the source version
+            os.unlink(dest)
+            self.copy_file('setup.cfg', dest)
+
+        self.get_finalized_command('egg_info').save_version_info(dest)
+
+    def _manifest_is_not_generated(self):
+        # check for special comment used in 2.7.1 and higher
+        if not os.path.isfile(self.manifest):
+            return False
+
+        with open(self.manifest, 'rb') as fp:
+            first_line = fp.readline()
+        return first_line != b'# file GENERATED by distutils, do NOT edit\n'
+
+    def read_manifest(self):
+        """Read the manifest file (named by 'self.manifest') and use it to
+        fill in 'self.filelist', the list of files to include in the source
+        distribution.
+        """
+        log.info("reading manifest file '%s'", self.manifest)
+        manifest = open(self.manifest, 'rb')
+        for bytes_line in manifest:
+            # The manifest must contain UTF-8. See #303.
+            try:
+                line = bytes_line.decode('UTF-8')
+            except UnicodeDecodeError:
+                log.warn(f"{line!r} not UTF-8 decodable -- skipping")
+                continue
+            # ignore comments and blank lines
+            line = line.strip()
+            if line.startswith('#') or not line:
+                continue
+            self.filelist.append(line)
+        manifest.close()
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/command/setopt.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/command/setopt.py
new file mode 100644
index 0000000000000000000000000000000000000000..678a0593d6739db316bd4008860a613b59892f1f
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/command/setopt.py
@@ -0,0 +1,141 @@
+import configparser
+import os
+
+from .. import Command
+from ..unicode_utils import _cfg_read_utf8_with_fallback
+
+import distutils
+from distutils import log
+from distutils.errors import DistutilsOptionError
+from distutils.util import convert_path
+
+__all__ = ['config_file', 'edit_config', 'option_base', 'setopt']
+
+
+def config_file(kind="local"):
+    """Get the filename of the distutils, local, global, or per-user config
+
+    `kind` must be one of "local", "global", or "user"
+    """
+    if kind == 'local':
+        return 'setup.cfg'
+    if kind == 'global':
+        return os.path.join(os.path.dirname(distutils.__file__), 'distutils.cfg')
+    if kind == 'user':
+        dot = os.name == 'posix' and '.' or ''
+        return os.path.expanduser(convert_path(f"~/{dot}pydistutils.cfg"))
+    raise ValueError("config_file() type must be 'local', 'global', or 'user'", kind)
+
+
+def edit_config(filename, settings, dry_run=False):
+    """Edit a configuration file to include `settings`
+
+    `settings` is a dictionary of dictionaries or ``None`` values, keyed by
+    command/section name.  A ``None`` value means to delete the entire section,
+    while a dictionary lists settings to be changed or deleted in that section.
+    A setting of ``None`` means to delete that setting.
+    """
+    log.debug("Reading configuration from %s", filename)
+    opts = configparser.RawConfigParser()
+    opts.optionxform = lambda optionstr: optionstr  # type: ignore[method-assign] # overriding method
+    _cfg_read_utf8_with_fallback(opts, filename)
+
+    for section, options in settings.items():
+        if options is None:
+            log.info("Deleting section [%s] from %s", section, filename)
+            opts.remove_section(section)
+        else:
+            if not opts.has_section(section):
+                log.debug("Adding new section [%s] to %s", section, filename)
+                opts.add_section(section)
+            for option, value in options.items():
+                if value is None:
+                    log.debug("Deleting %s.%s from %s", section, option, filename)
+                    opts.remove_option(section, option)
+                    if not opts.options(section):
+                        log.info(
+                            "Deleting empty [%s] section from %s", section, filename
+                        )
+                        opts.remove_section(section)
+                else:
+                    log.debug(
+                        "Setting %s.%s to %r in %s", section, option, value, filename
+                    )
+                    opts.set(section, option, value)
+
+    log.info("Writing %s", filename)
+    if not dry_run:
+        with open(filename, 'w', encoding="utf-8") as f:
+            opts.write(f)
+
+
+class option_base(Command):
+    """Abstract base class for commands that mess with config files"""
+
+    user_options = [
+        ('global-config', 'g', "save options to the site-wide distutils.cfg file"),
+        ('user-config', 'u', "save options to the current user's pydistutils.cfg file"),
+        ('filename=', 'f', "configuration file to use (default=setup.cfg)"),
+    ]
+
+    boolean_options = [
+        'global-config',
+        'user-config',
+    ]
+
+    def initialize_options(self):
+        self.global_config = None
+        self.user_config = None
+        self.filename = None
+
+    def finalize_options(self):
+        filenames = []
+        if self.global_config:
+            filenames.append(config_file('global'))
+        if self.user_config:
+            filenames.append(config_file('user'))
+        if self.filename is not None:
+            filenames.append(self.filename)
+        if not filenames:
+            filenames.append(config_file('local'))
+        if len(filenames) > 1:
+            raise DistutilsOptionError(
+                "Must specify only one configuration file option", filenames
+            )
+        (self.filename,) = filenames
+
+
+class setopt(option_base):
+    """Save command-line options to a file"""
+
+    description = "set an option in setup.cfg or another config file"
+
+    user_options = [
+        ('command=', 'c', 'command to set an option for'),
+        ('option=', 'o', 'option to set'),
+        ('set-value=', 's', 'value of the option'),
+        ('remove', 'r', 'remove (unset) the value'),
+    ] + option_base.user_options
+
+    boolean_options = option_base.boolean_options + ['remove']
+
+    def initialize_options(self):
+        option_base.initialize_options(self)
+        self.command = None
+        self.option = None
+        self.set_value = None
+        self.remove = None
+
+    def finalize_options(self) -> None:
+        option_base.finalize_options(self)
+        if self.command is None or self.option is None:
+            raise DistutilsOptionError("Must specify --command *and* --option")
+        if self.set_value is None and not self.remove:
+            raise DistutilsOptionError("Must specify --set-value or --remove")
+
+    def run(self) -> None:
+        edit_config(
+            self.filename,
+            {self.command: {self.option.replace('-', '_'): self.set_value}},
+            self.dry_run,
+        )
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/command/test.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/command/test.py
new file mode 100644
index 0000000000000000000000000000000000000000..341b11a20eb2cce98cdeeebea9ba2de0282d5d38
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/command/test.py
@@ -0,0 +1,45 @@
+from __future__ import annotations
+
+from setuptools import Command
+from setuptools.warnings import SetuptoolsDeprecationWarning
+
+
+# Would restrict to Literal["test"], but mypy doesn't support it: https://github.com/python/mypy/issues/8203
+def __getattr__(name: str) -> type[_test]:
+    if name == 'test':
+        SetuptoolsDeprecationWarning.emit(
+            "The test command is disabled and references to it are deprecated.",
+            "Please remove any references to `setuptools.command.test` in all "
+            "supported versions of the affected package.",
+            due_date=(2024, 11, 15),
+            stacklevel=2,
+        )
+        return _test
+    raise AttributeError(name)
+
+
+class _test(Command):
+    """
+    Stub to warn when test command is referenced or used.
+    """
+
+    description = "stub for old test command (do not use)"
+
+    user_options = [
+        ('test-module=', 'm', "Run 'test_suite' in specified module"),
+        (
+            'test-suite=',
+            's',
+            "Run single test, case or suite (e.g. 'module.test_suite')",
+        ),
+        ('test-runner=', 'r', "Test runner to use"),
+    ]
+
+    def initialize_options(self):
+        pass
+
+    def finalize_options(self):
+        pass
+
+    def run(self):
+        raise RuntimeError("Support for the test command was removed in Setuptools 72")
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/compat/__init__.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/compat/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/compat/py310.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/compat/py310.py
new file mode 100644
index 0000000000000000000000000000000000000000..b3912f8e02a57a5b9ba738673a21a596e94c1122
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/compat/py310.py
@@ -0,0 +1,9 @@
+import sys
+
+__all__ = ['tomllib']
+
+
+if sys.version_info >= (3, 11):
+    import tomllib
+else:  # pragma: no cover
+    import tomli as tomllib
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/compat/py311.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/compat/py311.py
new file mode 100644
index 0000000000000000000000000000000000000000..52b58af32a28817deeaf592cc795f311434e39e7
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/compat/py311.py
@@ -0,0 +1,27 @@
+from __future__ import annotations
+
+import shutil
+import sys
+from typing import TYPE_CHECKING, Any, Callable
+
+if TYPE_CHECKING:
+    from _typeshed import ExcInfo, StrOrBytesPath
+    from typing_extensions import TypeAlias
+
+# Same as shutil._OnExcCallback from typeshed
+_OnExcCallback: TypeAlias = Callable[[Callable[..., Any], str, BaseException], object]
+
+
+def shutil_rmtree(
+    path: StrOrBytesPath,
+    ignore_errors: bool = False,
+    onexc: _OnExcCallback | None = None,
+) -> None:
+    if sys.version_info >= (3, 12):
+        return shutil.rmtree(path, ignore_errors, onexc=onexc)
+
+    def _handler(fn: Callable[..., Any], path: str, excinfo: ExcInfo) -> None:
+        if onexc:
+            onexc(fn, path, excinfo[1])
+
+    return shutil.rmtree(path, ignore_errors, onerror=_handler)
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/compat/py312.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/compat/py312.py
new file mode 100644
index 0000000000000000000000000000000000000000..b20c5f697a861a680c4a747baf9ca9c901e72978
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/compat/py312.py
@@ -0,0 +1,13 @@
+from __future__ import annotations
+
+import sys
+
+if sys.version_info >= (3, 12, 4):
+    # Python 3.13 should support `.pth` files encoded in UTF-8
+    # See discussion in https://github.com/python/cpython/issues/77102
+    PTH_ENCODING: str | None = "utf-8"
+else:
+    from .py39 import LOCALE_ENCODING
+
+    # PTH_ENCODING = "locale"
+    PTH_ENCODING = LOCALE_ENCODING
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/compat/py39.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/compat/py39.py
new file mode 100644
index 0000000000000000000000000000000000000000..04a4abe5a9e61596f97dc3d1b0b3da93a558158f
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/compat/py39.py
@@ -0,0 +1,9 @@
+import sys
+
+# Explicitly use the ``"locale"`` encoding in versions that support it,
+# otherwise just rely on the implicit handling of ``encoding=None``.
+# Since all platforms that support ``EncodingWarning`` also support
+# ``encoding="locale"``, this can be used to suppress the warning.
+# However, please try to use UTF-8 when possible
+# (.pth files are the notorious exception: python/cpython#77102, pypa/setuptools#3937).
+LOCALE_ENCODING = "locale" if sys.version_info >= (3, 10) else None
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/config/NOTICE b/tool_server/.venv/lib/python3.12/site-packages/setuptools/config/NOTICE
new file mode 100644
index 0000000000000000000000000000000000000000..01864511b0f52a6bf944f70b5e15b75364791935
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/config/NOTICE
@@ -0,0 +1,10 @@
+The following files include code from opensource projects
+(either as direct copies or modified versions):
+
+- `setuptools.schema.json`, `distutils.schema.json`:
+    - project: `validate-pyproject` - licensed under MPL-2.0
+      (https://github.com/abravalheri/validate-pyproject):
+
+      This Source Code Form is subject to the terms of the Mozilla Public
+      License, v. 2.0. If a copy of the MPL was not distributed with this file,
+      You can obtain one at https://mozilla.org/MPL/2.0/.
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/config/__init__.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/config/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..fcc7d008d6c9b3ab2610f2a1b05c4c1eeb5e1416
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/config/__init__.py
@@ -0,0 +1,43 @@
+"""For backward compatibility, expose main functions from
+``setuptools.config.setupcfg``
+"""
+
+from functools import wraps
+from typing import Callable, TypeVar, cast
+
+from ..warnings import SetuptoolsDeprecationWarning
+from . import setupcfg
+
+Fn = TypeVar("Fn", bound=Callable)
+
+__all__ = ('parse_configuration', 'read_configuration')
+
+
+def _deprecation_notice(fn: Fn) -> Fn:
+    @wraps(fn)
+    def _wrapper(*args, **kwargs):
+        SetuptoolsDeprecationWarning.emit(
+            "Deprecated API usage.",
+            f"""
+            As setuptools moves its configuration towards `pyproject.toml`,
+            `{__name__}.{fn.__name__}` became deprecated.
+
+            For the time being, you can use the `{setupcfg.__name__}` module
+            to access a backward compatible API, but this module is provisional
+            and might be removed in the future.
+
+            To read project metadata, consider using
+            ``build.util.project_wheel_metadata`` (https://pypi.org/project/build/).
+            For simple scenarios, you can also try parsing the file directly
+            with the help of ``configparser``.
+            """,
+            # due_date not defined yet, because the community still heavily relies on it
+            # Warning introduced in 24 Mar 2022
+        )
+        return fn(*args, **kwargs)
+
+    return cast(Fn, _wrapper)
+
+
+read_configuration = _deprecation_notice(setupcfg.read_configuration)
+parse_configuration = _deprecation_notice(setupcfg.parse_configuration)
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/config/_apply_pyprojecttoml.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/config/_apply_pyprojecttoml.py
new file mode 100644
index 0000000000000000000000000000000000000000..9088bc1383c87d3ed62a5a4dc44481ffafa1e35e
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/config/_apply_pyprojecttoml.py
@@ -0,0 +1,526 @@
+"""Translation layer between pyproject config and setuptools distribution and
+metadata objects.
+
+The distribution and metadata objects are modeled after (an old version of)
+core metadata, therefore configs in the format specified for ``pyproject.toml``
+need to be processed before being applied.
+
+**PRIVATE MODULE**: API reserved for setuptools internal usage only.
+"""
+
+from __future__ import annotations
+
+import logging
+import os
+from collections.abc import Mapping
+from email.headerregistry import Address
+from functools import partial, reduce
+from inspect import cleandoc
+from itertools import chain
+from types import MappingProxyType
+from typing import TYPE_CHECKING, Any, Callable, TypeVar, Union
+
+from .. import _static
+from .._path import StrPath
+from ..errors import InvalidConfigError, RemovedConfigError
+from ..extension import Extension
+from ..warnings import SetuptoolsDeprecationWarning, SetuptoolsWarning
+
+if TYPE_CHECKING:
+    from typing_extensions import TypeAlias
+
+    from setuptools._importlib import metadata
+    from setuptools.dist import Distribution
+
+    from distutils.dist import _OptionsList  # Comes from typeshed
+
+
+EMPTY: Mapping = MappingProxyType({})  # Immutable dict-like
+_ProjectReadmeValue: TypeAlias = Union[str, dict[str, str]]
+_Correspondence: TypeAlias = Callable[["Distribution", Any, Union[StrPath, None]], None]
+_T = TypeVar("_T")
+
+_logger = logging.getLogger(__name__)
+
+
+def apply(dist: Distribution, config: dict, filename: StrPath) -> Distribution:
+    """Apply configuration dict read with :func:`read_configuration`"""
+
+    if not config:
+        return dist  # short-circuit unrelated pyproject.toml file
+
+    root_dir = os.path.dirname(filename) or "."
+
+    _apply_project_table(dist, config, root_dir)
+    _apply_tool_table(dist, config, filename)
+
+    current_directory = os.getcwd()
+    os.chdir(root_dir)
+    try:
+        dist._finalize_requires()
+        dist._finalize_license_expression()
+        dist._finalize_license_files()
+    finally:
+        os.chdir(current_directory)
+
+    return dist
+
+
+def _apply_project_table(dist: Distribution, config: dict, root_dir: StrPath):
+    orig_config = config.get("project", {})
+    if not orig_config:
+        return  # short-circuit
+
+    project_table = {k: _static.attempt_conversion(v) for k, v in orig_config.items()}
+    _handle_missing_dynamic(dist, project_table)
+    _unify_entry_points(project_table)
+
+    for field, value in project_table.items():
+        norm_key = json_compatible_key(field)
+        corresp = PYPROJECT_CORRESPONDENCE.get(norm_key, norm_key)
+        if callable(corresp):
+            corresp(dist, value, root_dir)
+        else:
+            _set_config(dist, corresp, value)
+
+
+def _apply_tool_table(dist: Distribution, config: dict, filename: StrPath):
+    tool_table = config.get("tool", {}).get("setuptools", {})
+    if not tool_table:
+        return  # short-circuit
+
+    if "license-files" in tool_table:
+        if "license-files" in config.get("project", {}):
+            # https://github.com/pypa/setuptools/pull/4837#discussion_r2004983349
+            raise InvalidConfigError(
+                "'project.license-files' is defined already. "
+                "Remove 'tool.setuptools.license-files'."
+            )
+
+        pypa_guides = "guides/writing-pyproject-toml/#license-files"
+        SetuptoolsDeprecationWarning.emit(
+            "'tool.setuptools.license-files' is deprecated in favor of "
+            "'project.license-files' (available on setuptools>=77.0.0).",
+            see_url=f"https://packaging.python.org/en/latest/{pypa_guides}",
+            due_date=(2026, 2, 18),  # Warning introduced on 2025-02-18
+        )
+
+    for field, value in tool_table.items():
+        norm_key = json_compatible_key(field)
+
+        if norm_key in TOOL_TABLE_REMOVALS:
+            suggestion = cleandoc(TOOL_TABLE_REMOVALS[norm_key])
+            msg = f"""
+            The parameter `tool.setuptools.{field}` was long deprecated
+            and has been removed from `pyproject.toml`.
+            """
+            raise RemovedConfigError("\n".join([cleandoc(msg), suggestion]))
+
+        norm_key = TOOL_TABLE_RENAMES.get(norm_key, norm_key)
+        corresp = TOOL_TABLE_CORRESPONDENCE.get(norm_key, norm_key)
+        if callable(corresp):
+            corresp(dist, value)
+        else:
+            _set_config(dist, corresp, value)
+
+    _copy_command_options(config, dist, filename)
+
+
+def _handle_missing_dynamic(dist: Distribution, project_table: dict):
+    """Be temporarily forgiving with ``dynamic`` fields not listed in ``dynamic``"""
+    dynamic = set(project_table.get("dynamic", []))
+    for field, getter in _PREVIOUSLY_DEFINED.items():
+        if not (field in project_table or field in dynamic):
+            value = getter(dist)
+            if value:
+                _MissingDynamic.emit(field=field, value=value)
+                project_table[field] = _RESET_PREVIOUSLY_DEFINED.get(field)
+
+
+def json_compatible_key(key: str) -> str:
+    """As defined in :pep:`566#json-compatible-metadata`"""
+    return key.lower().replace("-", "_")
+
+
+def _set_config(dist: Distribution, field: str, value: Any):
+    val = _PREPROCESS.get(field, _noop)(dist, value)
+    setter = getattr(dist.metadata, f"set_{field}", None)
+    if setter:
+        setter(val)
+    elif hasattr(dist.metadata, field) or field in SETUPTOOLS_PATCHES:
+        setattr(dist.metadata, field, val)
+    else:
+        setattr(dist, field, val)
+
+
+_CONTENT_TYPES = {
+    ".md": "text/markdown",
+    ".rst": "text/x-rst",
+    ".txt": "text/plain",
+}
+
+
+def _guess_content_type(file: str) -> str | None:
+    _, ext = os.path.splitext(file.lower())
+    if not ext:
+        return None
+
+    if ext in _CONTENT_TYPES:
+        return _static.Str(_CONTENT_TYPES[ext])
+
+    valid = ", ".join(f"{k} ({v})" for k, v in _CONTENT_TYPES.items())
+    msg = f"only the following file extensions are recognized: {valid}."
+    raise ValueError(f"Undefined content type for {file}, {msg}")
+
+
+def _long_description(
+    dist: Distribution, val: _ProjectReadmeValue, root_dir: StrPath | None
+):
+    from setuptools.config import expand
+
+    file: str | tuple[()]
+    if isinstance(val, str):
+        file = val
+        text = expand.read_files(file, root_dir)
+        ctype = _guess_content_type(file)
+    else:
+        file = val.get("file") or ()
+        text = val.get("text") or expand.read_files(file, root_dir)
+        ctype = val["content-type"]
+
+    # XXX: Is it completely safe to assume static?
+    _set_config(dist, "long_description", _static.Str(text))
+
+    if ctype:
+        _set_config(dist, "long_description_content_type", _static.Str(ctype))
+
+    if file:
+        dist._referenced_files.add(file)
+
+
+def _license(dist: Distribution, val: str | dict, root_dir: StrPath | None):
+    from setuptools.config import expand
+
+    if isinstance(val, str):
+        if getattr(dist.metadata, "license", None):
+            SetuptoolsWarning.emit("`license` overwritten by `pyproject.toml`")
+            dist.metadata.license = None
+        _set_config(dist, "license_expression", _static.Str(val))
+    else:
+        pypa_guides = "guides/writing-pyproject-toml/#license"
+        SetuptoolsDeprecationWarning.emit(
+            "`project.license` as a TOML table is deprecated",
+            "Please use a simple string containing a SPDX expression for "
+            "`project.license`. You can also use `project.license-files`. "
+            "(Both options available on setuptools>=77.0.0).",
+            see_url=f"https://packaging.python.org/en/latest/{pypa_guides}",
+            due_date=(2026, 2, 18),  # Introduced on 2025-02-18
+        )
+        if "file" in val:
+            # XXX: Is it completely safe to assume static?
+            value = expand.read_files([val["file"]], root_dir)
+            _set_config(dist, "license", _static.Str(value))
+            dist._referenced_files.add(val["file"])
+        else:
+            _set_config(dist, "license", _static.Str(val["text"]))
+
+
+def _people(dist: Distribution, val: list[dict], _root_dir: StrPath | None, kind: str):
+    field = []
+    email_field = []
+    for person in val:
+        if "name" not in person:
+            email_field.append(person["email"])
+        elif "email" not in person:
+            field.append(person["name"])
+        else:
+            addr = Address(display_name=person["name"], addr_spec=person["email"])
+            email_field.append(str(addr))
+
+    if field:
+        _set_config(dist, kind, _static.Str(", ".join(field)))
+    if email_field:
+        _set_config(dist, f"{kind}_email", _static.Str(", ".join(email_field)))
+
+
+def _project_urls(dist: Distribution, val: dict, _root_dir: StrPath | None):
+    _set_config(dist, "project_urls", val)
+
+
+def _python_requires(dist: Distribution, val: str, _root_dir: StrPath | None):
+    _set_config(dist, "python_requires", _static.SpecifierSet(val))
+
+
+def _dependencies(dist: Distribution, val: list, _root_dir: StrPath | None):
+    if getattr(dist, "install_requires", []):
+        msg = "`install_requires` overwritten in `pyproject.toml` (dependencies)"
+        SetuptoolsWarning.emit(msg)
+    dist.install_requires = val
+
+
+def _optional_dependencies(dist: Distribution, val: dict, _root_dir: StrPath | None):
+    if getattr(dist, "extras_require", None):
+        msg = "`extras_require` overwritten in `pyproject.toml` (optional-dependencies)"
+        SetuptoolsWarning.emit(msg)
+    dist.extras_require = val
+
+
+def _ext_modules(dist: Distribution, val: list[dict]) -> list[Extension]:
+    existing = dist.ext_modules or []
+    args = ({k.replace("-", "_"): v for k, v in x.items()} for x in val)
+    new = [Extension(**kw) for kw in args]
+    return [*existing, *new]
+
+
+def _noop(_dist: Distribution, val: _T) -> _T:
+    return val
+
+
+def _identity(val: _T) -> _T:
+    return val
+
+
+def _unify_entry_points(project_table: dict):
+    project = project_table
+    given = project.pop("entry-points", project.pop("entry_points", {}))
+    entry_points = dict(given)  # Avoid problems with static
+    renaming = {"scripts": "console_scripts", "gui_scripts": "gui_scripts"}
+    for key, value in list(project.items()):  # eager to allow modifications
+        norm_key = json_compatible_key(key)
+        if norm_key in renaming:
+            # Don't skip even if value is empty (reason: reset missing `dynamic`)
+            entry_points[renaming[norm_key]] = project.pop(key)
+
+    if entry_points:
+        project["entry-points"] = {
+            name: [f"{k} = {v}" for k, v in group.items()]
+            for name, group in entry_points.items()
+            if group  # now we can skip empty groups
+        }
+        # Sometimes this will set `project["entry-points"] = {}`, and that is
+        # intentional (for resetting configurations that are missing `dynamic`).
+
+
+def _copy_command_options(pyproject: dict, dist: Distribution, filename: StrPath):
+    tool_table = pyproject.get("tool", {})
+    cmdclass = tool_table.get("setuptools", {}).get("cmdclass", {})
+    valid_options = _valid_command_options(cmdclass)
+
+    cmd_opts = dist.command_options
+    for cmd, config in pyproject.get("tool", {}).get("distutils", {}).items():
+        cmd = json_compatible_key(cmd)
+        valid = valid_options.get(cmd, set())
+        cmd_opts.setdefault(cmd, {})
+        for key, value in config.items():
+            key = json_compatible_key(key)
+            cmd_opts[cmd][key] = (str(filename), value)
+            if key not in valid:
+                # To avoid removing options that are specified dynamically we
+                # just log a warn...
+                _logger.warning(f"Command option {cmd}.{key} is not defined")
+
+
+def _valid_command_options(cmdclass: Mapping = EMPTY) -> dict[str, set[str]]:
+    from setuptools.dist import Distribution
+
+    from .._importlib import metadata
+
+    valid_options = {"global": _normalise_cmd_options(Distribution.global_options)}
+
+    unloaded_entry_points = metadata.entry_points(group='distutils.commands')
+    loaded_entry_points = (_load_ep(ep) for ep in unloaded_entry_points)
+    entry_points = (ep for ep in loaded_entry_points if ep)
+    for cmd, cmd_class in chain(entry_points, cmdclass.items()):
+        opts = valid_options.get(cmd, set())
+        opts = opts | _normalise_cmd_options(getattr(cmd_class, "user_options", []))
+        valid_options[cmd] = opts
+
+    return valid_options
+
+
+def _load_ep(ep: metadata.EntryPoint) -> tuple[str, type] | None:
+    if ep.value.startswith("wheel.bdist_wheel"):
+        # Ignore deprecated entrypoint from wheel and avoid warning pypa/wheel#631
+        # TODO: remove check when `bdist_wheel` has been fully removed from pypa/wheel
+        return None
+
+    # Ignore all the errors
+    try:
+        return (ep.name, ep.load())
+    except Exception as ex:
+        msg = f"{ex.__class__.__name__} while trying to load entry-point {ep.name}"
+        _logger.warning(f"{msg}: {ex}")
+        return None
+
+
+def _normalise_cmd_option_key(name: str) -> str:
+    return json_compatible_key(name).strip("_=")
+
+
+def _normalise_cmd_options(desc: _OptionsList) -> set[str]:
+    return {_normalise_cmd_option_key(fancy_option[0]) for fancy_option in desc}
+
+
+def _get_previous_entrypoints(dist: Distribution) -> dict[str, list]:
+    ignore = ("console_scripts", "gui_scripts")
+    value = getattr(dist, "entry_points", None) or {}
+    return {k: v for k, v in value.items() if k not in ignore}
+
+
+def _get_previous_scripts(dist: Distribution) -> list | None:
+    value = getattr(dist, "entry_points", None) or {}
+    return value.get("console_scripts")
+
+
+def _get_previous_gui_scripts(dist: Distribution) -> list | None:
+    value = getattr(dist, "entry_points", None) or {}
+    return value.get("gui_scripts")
+
+
+def _set_static_list_metadata(attr: str, dist: Distribution, val: list) -> None:
+    """Apply distutils metadata validation but preserve "static" behaviour"""
+    meta = dist.metadata
+    setter, getter = getattr(meta, f"set_{attr}"), getattr(meta, f"get_{attr}")
+    setter(val)
+    setattr(meta, attr, _static.List(getter()))
+
+
+def _attrgetter(attr):
+    """
+    Similar to ``operator.attrgetter`` but returns None if ``attr`` is not found
+    >>> from types import SimpleNamespace
+    >>> obj = SimpleNamespace(a=42, b=SimpleNamespace(c=13))
+    >>> _attrgetter("a")(obj)
+    42
+    >>> _attrgetter("b.c")(obj)
+    13
+    >>> _attrgetter("d")(obj) is None
+    True
+    """
+    return partial(reduce, lambda acc, x: getattr(acc, x, None), attr.split("."))
+
+
+def _some_attrgetter(*items):
+    """
+    Return the first "truth-y" attribute or None
+    >>> from types import SimpleNamespace
+    >>> obj = SimpleNamespace(a=42, b=SimpleNamespace(c=13))
+    >>> _some_attrgetter("d", "a", "b.c")(obj)
+    42
+    >>> _some_attrgetter("d", "e", "b.c", "a")(obj)
+    13
+    >>> _some_attrgetter("d", "e", "f")(obj) is None
+    True
+    """
+
+    def _acessor(obj):
+        values = (_attrgetter(i)(obj) for i in items)
+        return next((i for i in values if i is not None), None)
+
+    return _acessor
+
+
+PYPROJECT_CORRESPONDENCE: dict[str, _Correspondence] = {
+    "readme": _long_description,
+    "license": _license,
+    "authors": partial(_people, kind="author"),
+    "maintainers": partial(_people, kind="maintainer"),
+    "urls": _project_urls,
+    "dependencies": _dependencies,
+    "optional_dependencies": _optional_dependencies,
+    "requires_python": _python_requires,
+}
+
+TOOL_TABLE_RENAMES = {"script_files": "scripts"}
+TOOL_TABLE_REMOVALS = {
+    "namespace_packages": """
+        Please migrate to implicit native namespaces instead.
+        See https://packaging.python.org/en/latest/guides/packaging-namespace-packages/.
+        """,
+}
+TOOL_TABLE_CORRESPONDENCE = {
+    # Fields with corresponding core metadata need to be marked as static:
+    "obsoletes": partial(_set_static_list_metadata, "obsoletes"),
+    "provides": partial(_set_static_list_metadata, "provides"),
+    "platforms": partial(_set_static_list_metadata, "platforms"),
+}
+
+SETUPTOOLS_PATCHES = {
+    "long_description_content_type",
+    "project_urls",
+    "provides_extras",
+    "license_file",
+    "license_files",
+    "license_expression",
+}
+
+_PREPROCESS = {
+    "ext_modules": _ext_modules,
+}
+
+_PREVIOUSLY_DEFINED = {
+    "name": _attrgetter("metadata.name"),
+    "version": _attrgetter("metadata.version"),
+    "description": _attrgetter("metadata.description"),
+    "readme": _attrgetter("metadata.long_description"),
+    "requires-python": _some_attrgetter("python_requires", "metadata.python_requires"),
+    "license": _some_attrgetter("metadata.license_expression", "metadata.license"),
+    # XXX: `license-file` is currently not considered in the context of `dynamic`.
+    #      See TestPresetField.test_license_files_exempt_from_dynamic
+    "authors": _some_attrgetter("metadata.author", "metadata.author_email"),
+    "maintainers": _some_attrgetter("metadata.maintainer", "metadata.maintainer_email"),
+    "keywords": _attrgetter("metadata.keywords"),
+    "classifiers": _attrgetter("metadata.classifiers"),
+    "urls": _attrgetter("metadata.project_urls"),
+    "entry-points": _get_previous_entrypoints,
+    "scripts": _get_previous_scripts,
+    "gui-scripts": _get_previous_gui_scripts,
+    "dependencies": _attrgetter("install_requires"),
+    "optional-dependencies": _attrgetter("extras_require"),
+}
+
+
+_RESET_PREVIOUSLY_DEFINED: dict = {
+    # Fix improper setting: given in `setup.py`, but not listed in `dynamic`
+    # Use "immutable" data structures to avoid in-place modification.
+    # dict: pyproject name => value to which reset
+    "license": "",
+    # XXX: `license-file` is currently not considered in the context of `dynamic`.
+    #      See TestPresetField.test_license_files_exempt_from_dynamic
+    "authors": _static.EMPTY_LIST,
+    "maintainers": _static.EMPTY_LIST,
+    "keywords": _static.EMPTY_LIST,
+    "classifiers": _static.EMPTY_LIST,
+    "urls": _static.EMPTY_DICT,
+    "entry-points": _static.EMPTY_DICT,
+    "scripts": _static.EMPTY_DICT,
+    "gui-scripts": _static.EMPTY_DICT,
+    "dependencies": _static.EMPTY_LIST,
+    "optional-dependencies": _static.EMPTY_DICT,
+}
+
+
+class _MissingDynamic(SetuptoolsWarning):
+    _SUMMARY = "`{field}` defined outside of `pyproject.toml` is ignored."
+
+    _DETAILS = """
+    The following seems to be defined outside of `pyproject.toml`:
+
+    `{field} = {value!r}`
+
+    According to the spec (see the link below), however, setuptools CANNOT
+    consider this value unless `{field}` is listed as `dynamic`.
+
+    https://packaging.python.org/en/latest/specifications/pyproject-toml/#declaring-project-metadata-the-project-table
+
+    To prevent this problem, you can list `{field}` under `dynamic` or alternatively
+    remove the `[project]` table from your file and rely entirely on other means of
+    configuration.
+    """
+    # TODO: Consider removing this check in the future?
+    #       There is a trade-off here between improving "debug-ability" and the cost
+    #       of running/testing/maintaining these unnecessary checks...
+
+    @classmethod
+    def details(cls, field: str, value: Any) -> str:
+        return cls._DETAILS.format(field=field, value=value)
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/config/distutils.schema.json b/tool_server/.venv/lib/python3.12/site-packages/setuptools/config/distutils.schema.json
new file mode 100644
index 0000000000000000000000000000000000000000..93cd2e868acdaf41bf8b1f77026e84c02a5af3f8
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/config/distutils.schema.json
@@ -0,0 +1,26 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+
+  "$id": "https://setuptools.pypa.io/en/latest/deprecated/distutils/configfile.html",
+  "title": "``tool.distutils`` table",
+  "$$description": [
+    "**EXPERIMENTAL** (NOT OFFICIALLY SUPPORTED): Use ``tool.distutils``",
+    "subtables to configure arguments for ``distutils`` commands.",
+    "Originally, ``distutils`` allowed developers to configure arguments for",
+    "``setup.py`` commands via `distutils configuration files",
+    "<https://setuptools.pypa.io/en/latest/deprecated/distutils/configfile.html>`_.",
+    "See also `the old Python docs <https://docs.python.org/3.11/install/>_`."
+  ],
+
+  "type": "object",
+  "properties": {
+    "global": {
+      "type": "object",
+      "description": "Global options applied to all ``distutils`` commands"
+    }
+  },
+  "patternProperties": {
+    ".+": {"type": "object"}
+  },
+  "$comment": "TODO: Is there a practical way of making this schema more specific?"
+}
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/config/expand.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/config/expand.py
new file mode 100644
index 0000000000000000000000000000000000000000..531f965013031a8c5159c8b8505c38cfb0a4302f
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/config/expand.py
@@ -0,0 +1,452 @@
+"""Utility functions to expand configuration directives or special values
+(such glob patterns).
+
+We can split the process of interpreting configuration files into 2 steps:
+
+1. The parsing the file contents from strings to value objects
+   that can be understand by Python (for example a string with a comma
+   separated list of keywords into an actual Python list of strings).
+
+2. The expansion (or post-processing) of these values according to the
+   semantics ``setuptools`` assign to them (for example a configuration field
+   with the ``file:`` directive should be expanded from a list of file paths to
+   a single string with the contents of those files concatenated)
+
+This module focus on the second step, and therefore allow sharing the expansion
+functions among several configuration file formats.
+
+**PRIVATE MODULE**: API reserved for setuptools internal usage only.
+"""
+
+from __future__ import annotations
+
+import ast
+import importlib
+import os
+import pathlib
+import sys
+from collections.abc import Iterable, Iterator, Mapping
+from configparser import ConfigParser
+from glob import iglob
+from importlib.machinery import ModuleSpec, all_suffixes
+from itertools import chain
+from pathlib import Path
+from types import ModuleType, TracebackType
+from typing import TYPE_CHECKING, Any, Callable, TypeVar
+
+from .. import _static
+from .._path import StrPath, same_path as _same_path
+from ..discovery import find_package_path
+from ..warnings import SetuptoolsWarning
+
+from distutils.errors import DistutilsOptionError
+
+if TYPE_CHECKING:
+    from typing_extensions import Self
+
+    from setuptools.dist import Distribution
+
+_K = TypeVar("_K")
+_V_co = TypeVar("_V_co", covariant=True)
+
+
+class StaticModule:
+    """Proxy to a module object that avoids executing arbitrary code."""
+
+    def __init__(self, name: str, spec: ModuleSpec) -> None:
+        module = ast.parse(pathlib.Path(spec.origin).read_bytes())  # type: ignore[arg-type] # Let it raise an error on None
+        vars(self).update(locals())
+        del self.self
+
+    def _find_assignments(self) -> Iterator[tuple[ast.AST, ast.AST]]:
+        for statement in self.module.body:
+            if isinstance(statement, ast.Assign):
+                yield from ((target, statement.value) for target in statement.targets)
+            elif isinstance(statement, ast.AnnAssign) and statement.value:
+                yield (statement.target, statement.value)
+
+    def __getattr__(self, attr: str):
+        """Attempt to load an attribute "statically", via :func:`ast.literal_eval`."""
+        try:
+            return next(
+                ast.literal_eval(value)
+                for target, value in self._find_assignments()
+                if isinstance(target, ast.Name) and target.id == attr
+            )
+        except Exception as e:
+            raise AttributeError(f"{self.name} has no attribute {attr}") from e
+
+
+def glob_relative(
+    patterns: Iterable[str], root_dir: StrPath | None = None
+) -> list[str]:
+    """Expand the list of glob patterns, but preserving relative paths.
+
+    :param list[str] patterns: List of glob patterns
+    :param str root_dir: Path to which globs should be relative
+                         (current directory by default)
+    :rtype: list
+    """
+    glob_characters = {'*', '?', '[', ']', '{', '}'}
+    expanded_values = []
+    root_dir = root_dir or os.getcwd()
+    for value in patterns:
+        # Has globby characters?
+        if any(char in value for char in glob_characters):
+            # then expand the glob pattern while keeping paths *relative*:
+            glob_path = os.path.abspath(os.path.join(root_dir, value))
+            expanded_values.extend(
+                sorted(
+                    os.path.relpath(path, root_dir).replace(os.sep, "/")
+                    for path in iglob(glob_path, recursive=True)
+                )
+            )
+
+        else:
+            # take the value as-is
+            path = os.path.relpath(value, root_dir).replace(os.sep, "/")
+            expanded_values.append(path)
+
+    return expanded_values
+
+
+def read_files(
+    filepaths: StrPath | Iterable[StrPath], root_dir: StrPath | None = None
+) -> str:
+    """Return the content of the files concatenated using ``\n`` as str
+
+    This function is sandboxed and won't reach anything outside ``root_dir``
+
+    (By default ``root_dir`` is the current directory).
+    """
+    from more_itertools import always_iterable
+
+    root_dir = os.path.abspath(root_dir or os.getcwd())
+    _filepaths = (os.path.join(root_dir, path) for path in always_iterable(filepaths))
+    return '\n'.join(
+        _read_file(path)
+        for path in _filter_existing_files(_filepaths)
+        if _assert_local(path, root_dir)
+    )
+
+
+def _filter_existing_files(filepaths: Iterable[StrPath]) -> Iterator[StrPath]:
+    for path in filepaths:
+        if os.path.isfile(path):
+            yield path
+        else:
+            SetuptoolsWarning.emit(f"File {path!r} cannot be found")
+
+
+def _read_file(filepath: bytes | StrPath) -> str:
+    with open(filepath, encoding='utf-8') as f:
+        return f.read()
+
+
+def _assert_local(filepath: StrPath, root_dir: str):
+    if Path(os.path.abspath(root_dir)) not in Path(os.path.abspath(filepath)).parents:
+        msg = f"Cannot access {filepath!r} (or anything outside {root_dir!r})"
+        raise DistutilsOptionError(msg)
+
+    return True
+
+
+def read_attr(
+    attr_desc: str,
+    package_dir: Mapping[str, str] | None = None,
+    root_dir: StrPath | None = None,
+) -> Any:
+    """Reads the value of an attribute from a module.
+
+    This function will try to read the attributed statically first
+    (via :func:`ast.literal_eval`), and only evaluate the module if it fails.
+
+    Examples:
+        read_attr("package.attr")
+        read_attr("package.module.attr")
+
+    :param str attr_desc: Dot-separated string describing how to reach the
+        attribute (see examples above)
+    :param dict[str, str] package_dir: Mapping of package names to their
+        location in disk (represented by paths relative to ``root_dir``).
+    :param str root_dir: Path to directory containing all the packages in
+        ``package_dir`` (current directory by default).
+    :rtype: str
+    """
+    root_dir = root_dir or os.getcwd()
+    attrs_path = attr_desc.strip().split('.')
+    attr_name = attrs_path.pop()
+    module_name = '.'.join(attrs_path)
+    module_name = module_name or '__init__'
+    path = _find_module(module_name, package_dir, root_dir)
+    spec = _find_spec(module_name, path)
+
+    try:
+        value = getattr(StaticModule(module_name, spec), attr_name)
+        # XXX: Is marking as static contents coming from modules too optimistic?
+        return _static.attempt_conversion(value)
+    except Exception:
+        # fallback to evaluate module
+        module = _load_spec(spec, module_name)
+        return getattr(module, attr_name)
+
+
+def _find_spec(module_name: str, module_path: StrPath | None) -> ModuleSpec:
+    spec = importlib.util.spec_from_file_location(module_name, module_path)
+    spec = spec or importlib.util.find_spec(module_name)
+
+    if spec is None:
+        raise ModuleNotFoundError(module_name)
+
+    return spec
+
+
+def _load_spec(spec: ModuleSpec, module_name: str) -> ModuleType:
+    name = getattr(spec, "__name__", module_name)
+    if name in sys.modules:
+        return sys.modules[name]
+    module = importlib.util.module_from_spec(spec)
+    sys.modules[name] = module  # cache (it also ensures `==` works on loaded items)
+    assert spec.loader is not None
+    spec.loader.exec_module(module)
+    return module
+
+
+def _find_module(
+    module_name: str, package_dir: Mapping[str, str] | None, root_dir: StrPath
+) -> str | None:
+    """Find the path to the module named ``module_name``,
+    considering the ``package_dir`` in the build configuration and ``root_dir``.
+
+    >>> tmp = getfixture('tmpdir')
+    >>> _ = tmp.ensure("a/b/c.py")
+    >>> _ = tmp.ensure("a/b/d/__init__.py")
+    >>> r = lambda x: x.replace(str(tmp), "tmp").replace(os.sep, "/")
+    >>> r(_find_module("a.b.c", None, tmp))
+    'tmp/a/b/c.py'
+    >>> r(_find_module("f.g.h", {"": "1", "f": "2", "f.g": "3", "f.g.h": "a/b/d"}, tmp))
+    'tmp/a/b/d/__init__.py'
+    """
+    path_start = find_package_path(module_name, package_dir or {}, root_dir)
+    candidates = chain.from_iterable(
+        (f"{path_start}{ext}", os.path.join(path_start, f"__init__{ext}"))
+        for ext in all_suffixes()
+    )
+    return next((x for x in candidates if os.path.isfile(x)), None)
+
+
+def resolve_class(
+    qualified_class_name: str,
+    package_dir: Mapping[str, str] | None = None,
+    root_dir: StrPath | None = None,
+) -> Callable:
+    """Given a qualified class name, return the associated class object"""
+    root_dir = root_dir or os.getcwd()
+    idx = qualified_class_name.rfind('.')
+    class_name = qualified_class_name[idx + 1 :]
+    pkg_name = qualified_class_name[:idx]
+
+    path = _find_module(pkg_name, package_dir, root_dir)
+    module = _load_spec(_find_spec(pkg_name, path), pkg_name)
+    return getattr(module, class_name)
+
+
+def cmdclass(
+    values: dict[str, str],
+    package_dir: Mapping[str, str] | None = None,
+    root_dir: StrPath | None = None,
+) -> dict[str, Callable]:
+    """Given a dictionary mapping command names to strings for qualified class
+    names, apply :func:`resolve_class` to the dict values.
+    """
+    return {k: resolve_class(v, package_dir, root_dir) for k, v in values.items()}
+
+
+def find_packages(
+    *,
+    namespaces=True,
+    fill_package_dir: dict[str, str] | None = None,
+    root_dir: StrPath | None = None,
+    **kwargs,
+) -> list[str]:
+    """Works similarly to :func:`setuptools.find_packages`, but with all
+    arguments given as keyword arguments. Moreover, ``where`` can be given
+    as a list (the results will be simply concatenated).
+
+    When the additional keyword argument ``namespaces`` is ``True``, it will
+    behave like :func:`setuptools.find_namespace_packages`` (i.e. include
+    implicit namespaces as per :pep:`420`).
+
+    The ``where`` argument will be considered relative to ``root_dir`` (or the current
+    working directory when ``root_dir`` is not given).
+
+    If the ``fill_package_dir`` argument is passed, this function will consider it as a
+    similar data structure to the ``package_dir`` configuration parameter add fill-in
+    any missing package location.
+
+    :rtype: list
+    """
+    from more_itertools import always_iterable, unique_everseen
+
+    from setuptools.discovery import construct_package_dir
+
+    # check "not namespaces" first due to python/mypy#6232
+    if not namespaces:
+        from setuptools.discovery import PackageFinder
+    else:
+        from setuptools.discovery import PEP420PackageFinder as PackageFinder
+
+    root_dir = root_dir or os.curdir
+    where = kwargs.pop('where', ['.'])
+    packages: list[str] = []
+    fill_package_dir = {} if fill_package_dir is None else fill_package_dir
+    search = list(unique_everseen(always_iterable(where)))
+
+    if len(search) == 1 and all(not _same_path(search[0], x) for x in (".", root_dir)):
+        fill_package_dir.setdefault("", search[0])
+
+    for path in search:
+        package_path = _nest_path(root_dir, path)
+        pkgs = PackageFinder.find(package_path, **kwargs)
+        packages.extend(pkgs)
+        if pkgs and not (
+            fill_package_dir.get("") == path or os.path.samefile(package_path, root_dir)
+        ):
+            fill_package_dir.update(construct_package_dir(pkgs, path))
+
+    return packages
+
+
+def _nest_path(parent: StrPath, path: StrPath) -> str:
+    path = parent if path in {".", ""} else os.path.join(parent, path)
+    return os.path.normpath(path)
+
+
+def version(value: Callable | Iterable[str | int] | str) -> str:
+    """When getting the version directly from an attribute,
+    it should be normalised to string.
+    """
+    _value = value() if callable(value) else value
+
+    if isinstance(_value, str):
+        return _value
+    if hasattr(_value, '__iter__'):
+        return '.'.join(map(str, _value))
+    return f'{_value}'
+
+
+def canonic_package_data(package_data: dict) -> dict:
+    if "*" in package_data:
+        package_data[""] = package_data.pop("*")
+    return package_data
+
+
+def canonic_data_files(
+    data_files: list | dict, root_dir: StrPath | None = None
+) -> list[tuple[str, list[str]]]:
+    """For compatibility with ``setup.py``, ``data_files`` should be a list
+    of pairs instead of a dict.
+
+    This function also expands glob patterns.
+    """
+    if isinstance(data_files, list):
+        return data_files
+
+    return [
+        (dest, glob_relative(patterns, root_dir))
+        for dest, patterns in data_files.items()
+    ]
+
+
+def entry_points(
+    text: str, text_source: str = "entry-points"
+) -> dict[str, dict[str, str]]:
+    """Given the contents of entry-points file,
+    process it into a 2-level dictionary (``dict[str, dict[str, str]]``).
+    The first level keys are entry-point groups, the second level keys are
+    entry-point names, and the second level values are references to objects
+    (that correspond to the entry-point value).
+    """
+    # Using undocumented behaviour, see python/typeshed#12700
+    parser = ConfigParser(default_section=None, delimiters=("=",))  # type: ignore[call-overload]
+    parser.optionxform = str  # case sensitive
+    parser.read_string(text, text_source)
+    groups = {k: dict(v.items()) for k, v in parser.items()}
+    groups.pop(parser.default_section, None)
+    return groups
+
+
+class EnsurePackagesDiscovered:
+    """Some expand functions require all the packages to already be discovered before
+    they run, e.g. :func:`read_attr`, :func:`resolve_class`, :func:`cmdclass`.
+
+    Therefore in some cases we will need to run autodiscovery during the evaluation of
+    the configuration. However, it is better to postpone calling package discovery as
+    much as possible, because some parameters can influence it (e.g. ``package_dir``),
+    and those might not have been processed yet.
+    """
+
+    def __init__(self, distribution: Distribution) -> None:
+        self._dist = distribution
+        self._called = False
+
+    def __call__(self):
+        """Trigger the automatic package discovery, if it is still necessary."""
+        if not self._called:
+            self._called = True
+            self._dist.set_defaults(name=False)  # Skip name, we can still be parsing
+
+    def __enter__(self) -> Self:
+        return self
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_value: BaseException | None,
+        traceback: TracebackType | None,
+    ):
+        if self._called:
+            self._dist.set_defaults.analyse_name()  # Now we can set a default name
+
+    def _get_package_dir(self) -> Mapping[str, str]:
+        self()
+        pkg_dir = self._dist.package_dir
+        return {} if pkg_dir is None else pkg_dir
+
+    @property
+    def package_dir(self) -> Mapping[str, str]:
+        """Proxy to ``package_dir`` that may trigger auto-discovery when used."""
+        return LazyMappingProxy(self._get_package_dir)
+
+
+class LazyMappingProxy(Mapping[_K, _V_co]):
+    """Mapping proxy that delays resolving the target object, until really needed.
+
+    >>> def obtain_mapping():
+    ...     print("Running expensive function!")
+    ...     return {"key": "value", "other key": "other value"}
+    >>> mapping = LazyMappingProxy(obtain_mapping)
+    >>> mapping["key"]
+    Running expensive function!
+    'value'
+    >>> mapping["other key"]
+    'other value'
+    """
+
+    def __init__(self, obtain_mapping_value: Callable[[], Mapping[_K, _V_co]]) -> None:
+        self._obtain = obtain_mapping_value
+        self._value: Mapping[_K, _V_co] | None = None
+
+    def _target(self) -> Mapping[_K, _V_co]:
+        if self._value is None:
+            self._value = self._obtain()
+        return self._value
+
+    def __getitem__(self, key: _K) -> _V_co:
+        return self._target()[key]
+
+    def __len__(self) -> int:
+        return len(self._target())
+
+    def __iter__(self) -> Iterator[_K]:
+        return iter(self._target())
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/config/pyprojecttoml.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/config/pyprojecttoml.py
new file mode 100644
index 0000000000000000000000000000000000000000..fd6c5968c820435a0a8a82ecfacbe94abd7e8d3d
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/config/pyprojecttoml.py
@@ -0,0 +1,468 @@
+"""
+Load setuptools configuration from ``pyproject.toml`` files.
+
+**PRIVATE MODULE**: API reserved for setuptools internal usage only.
+
+To read project metadata, consider using
+``build.util.project_wheel_metadata`` (https://pypi.org/project/build/).
+For simple scenarios, you can also try parsing the file directly
+with the help of ``tomllib`` or ``tomli``.
+"""
+
+from __future__ import annotations
+
+import logging
+import os
+from collections.abc import Mapping
+from contextlib import contextmanager
+from functools import partial
+from types import TracebackType
+from typing import TYPE_CHECKING, Any, Callable
+
+from .._path import StrPath
+from ..errors import FileError, InvalidConfigError
+from ..warnings import SetuptoolsWarning
+from . import expand as _expand
+from ._apply_pyprojecttoml import _PREVIOUSLY_DEFINED, _MissingDynamic, apply as _apply
+
+if TYPE_CHECKING:
+    from typing_extensions import Self
+
+    from setuptools.dist import Distribution
+
+_logger = logging.getLogger(__name__)
+
+
+def load_file(filepath: StrPath) -> dict:
+    from ..compat.py310 import tomllib
+
+    with open(filepath, "rb") as file:
+        return tomllib.load(file)
+
+
+def validate(config: dict, filepath: StrPath) -> bool:
+    from . import _validate_pyproject as validator
+
+    trove_classifier = validator.FORMAT_FUNCTIONS.get("trove-classifier")
+    if hasattr(trove_classifier, "_disable_download"):
+        # Improve reproducibility by default. See abravalheri/validate-pyproject#31
+        trove_classifier._disable_download()  # type: ignore[union-attr]
+
+    try:
+        return validator.validate(config)
+    except validator.ValidationError as ex:
+        summary = f"configuration error: {ex.summary}"
+        if ex.name.strip("`") != "project":
+            # Probably it is just a field missing/misnamed, not worthy the verbosity...
+            _logger.debug(summary)
+            _logger.debug(ex.details)
+
+        error = f"invalid pyproject.toml config: {ex.name}."
+        raise ValueError(f"{error}\n{summary}") from None
+
+
+def apply_configuration(
+    dist: Distribution,
+    filepath: StrPath,
+    ignore_option_errors: bool = False,
+) -> Distribution:
+    """Apply the configuration from a ``pyproject.toml`` file into an existing
+    distribution object.
+    """
+    config = read_configuration(filepath, True, ignore_option_errors, dist)
+    return _apply(dist, config, filepath)
+
+
+def read_configuration(
+    filepath: StrPath,
+    expand: bool = True,
+    ignore_option_errors: bool = False,
+    dist: Distribution | None = None,
+) -> dict[str, Any]:
+    """Read given configuration file and returns options from it as a dict.
+
+    :param str|unicode filepath: Path to configuration file in the ``pyproject.toml``
+        format.
+
+    :param bool expand: Whether to expand directives and other computed values
+        (i.e. post-process the given configuration)
+
+    :param bool ignore_option_errors: Whether to silently ignore
+        options, values of which could not be resolved (e.g. due to exceptions
+        in directives such as file:, attr:, etc.).
+        If False exceptions are propagated as expected.
+
+    :param Distribution|None: Distribution object to which the configuration refers.
+        If not given a dummy object will be created and discarded after the
+        configuration is read. This is used for auto-discovery of packages and in the
+        case a dynamic configuration (e.g. ``attr`` or ``cmdclass``) is expanded.
+        When ``expand=False`` this object is simply ignored.
+
+    :rtype: dict
+    """
+    filepath = os.path.abspath(filepath)
+
+    if not os.path.isfile(filepath):
+        raise FileError(f"Configuration file {filepath!r} does not exist.")
+
+    asdict = load_file(filepath) or {}
+    project_table = asdict.get("project", {})
+    tool_table = asdict.get("tool", {})
+    setuptools_table = tool_table.get("setuptools", {})
+    if not asdict or not (project_table or setuptools_table):
+        return {}  # User is not using pyproject to configure setuptools
+
+    if "setuptools" in asdict.get("tools", {}):
+        # let the user know they probably have a typo in their metadata
+        _ToolsTypoInMetadata.emit()
+
+    if "distutils" in tool_table:
+        _ExperimentalConfiguration.emit(subject="[tool.distutils]")
+
+    # There is an overall sense in the community that making include_package_data=True
+    # the default would be an improvement.
+    # `ini2toml` backfills include_package_data=False when nothing is explicitly given,
+    # therefore setting a default here is backwards compatible.
+    if dist and dist.include_package_data is not None:
+        setuptools_table.setdefault("include-package-data", dist.include_package_data)
+    else:
+        setuptools_table.setdefault("include-package-data", True)
+    # Persist changes:
+    asdict["tool"] = tool_table
+    tool_table["setuptools"] = setuptools_table
+
+    if "ext-modules" in setuptools_table:
+        _ExperimentalConfiguration.emit(subject="[tool.setuptools.ext-modules]")
+
+    with _ignore_errors(ignore_option_errors):
+        # Don't complain about unrelated errors (e.g. tools not using the "tool" table)
+        subset = {"project": project_table, "tool": {"setuptools": setuptools_table}}
+        validate(subset, filepath)
+
+    if expand:
+        root_dir = os.path.dirname(filepath)
+        return expand_configuration(asdict, root_dir, ignore_option_errors, dist)
+
+    return asdict
+
+
+def expand_configuration(
+    config: dict,
+    root_dir: StrPath | None = None,
+    ignore_option_errors: bool = False,
+    dist: Distribution | None = None,
+) -> dict:
+    """Given a configuration with unresolved fields (e.g. dynamic, cmdclass, ...)
+    find their final values.
+
+    :param dict config: Dict containing the configuration for the distribution
+    :param str root_dir: Top-level directory for the distribution/project
+        (the same directory where ``pyproject.toml`` is place)
+    :param bool ignore_option_errors: see :func:`read_configuration`
+    :param Distribution|None: Distribution object to which the configuration refers.
+        If not given a dummy object will be created and discarded after the
+        configuration is read. Used in the case a dynamic configuration
+        (e.g. ``attr`` or ``cmdclass``).
+
+    :rtype: dict
+    """
+    return _ConfigExpander(config, root_dir, ignore_option_errors, dist).expand()
+
+
+class _ConfigExpander:
+    def __init__(
+        self,
+        config: dict,
+        root_dir: StrPath | None = None,
+        ignore_option_errors: bool = False,
+        dist: Distribution | None = None,
+    ) -> None:
+        self.config = config
+        self.root_dir = root_dir or os.getcwd()
+        self.project_cfg = config.get("project", {})
+        self.dynamic = self.project_cfg.get("dynamic", [])
+        self.setuptools_cfg = config.get("tool", {}).get("setuptools", {})
+        self.dynamic_cfg = self.setuptools_cfg.get("dynamic", {})
+        self.ignore_option_errors = ignore_option_errors
+        self._dist = dist
+        self._referenced_files = set[str]()
+
+    def _ensure_dist(self) -> Distribution:
+        from setuptools.dist import Distribution
+
+        attrs = {"src_root": self.root_dir, "name": self.project_cfg.get("name", None)}
+        return self._dist or Distribution(attrs)
+
+    def _process_field(self, container: dict, field: str, fn: Callable):
+        if field in container:
+            with _ignore_errors(self.ignore_option_errors):
+                container[field] = fn(container[field])
+
+    def _canonic_package_data(self, field="package-data"):
+        package_data = self.setuptools_cfg.get(field, {})
+        return _expand.canonic_package_data(package_data)
+
+    def expand(self):
+        self._expand_packages()
+        self._canonic_package_data()
+        self._canonic_package_data("exclude-package-data")
+
+        # A distribution object is required for discovering the correct package_dir
+        dist = self._ensure_dist()
+        ctx = _EnsurePackagesDiscovered(dist, self.project_cfg, self.setuptools_cfg)
+        with ctx as ensure_discovered:
+            package_dir = ensure_discovered.package_dir
+            self._expand_data_files()
+            self._expand_cmdclass(package_dir)
+            self._expand_all_dynamic(dist, package_dir)
+
+        dist._referenced_files.update(self._referenced_files)
+        return self.config
+
+    def _expand_packages(self):
+        packages = self.setuptools_cfg.get("packages")
+        if packages is None or isinstance(packages, (list, tuple)):
+            return
+
+        find = packages.get("find")
+        if isinstance(find, dict):
+            find["root_dir"] = self.root_dir
+            find["fill_package_dir"] = self.setuptools_cfg.setdefault("package-dir", {})
+            with _ignore_errors(self.ignore_option_errors):
+                self.setuptools_cfg["packages"] = _expand.find_packages(**find)
+
+    def _expand_data_files(self):
+        data_files = partial(_expand.canonic_data_files, root_dir=self.root_dir)
+        self._process_field(self.setuptools_cfg, "data-files", data_files)
+
+    def _expand_cmdclass(self, package_dir: Mapping[str, str]):
+        root_dir = self.root_dir
+        cmdclass = partial(_expand.cmdclass, package_dir=package_dir, root_dir=root_dir)
+        self._process_field(self.setuptools_cfg, "cmdclass", cmdclass)
+
+    def _expand_all_dynamic(self, dist: Distribution, package_dir: Mapping[str, str]):
+        special = (  # need special handling
+            "version",
+            "readme",
+            "entry-points",
+            "scripts",
+            "gui-scripts",
+            "classifiers",
+            "dependencies",
+            "optional-dependencies",
+        )
+        # `_obtain` functions are assumed to raise appropriate exceptions/warnings.
+        obtained_dynamic = {
+            field: self._obtain(dist, field, package_dir)
+            for field in self.dynamic
+            if field not in special
+        }
+        obtained_dynamic.update(
+            self._obtain_entry_points(dist, package_dir) or {},
+            version=self._obtain_version(dist, package_dir),
+            readme=self._obtain_readme(dist),
+            classifiers=self._obtain_classifiers(dist),
+            dependencies=self._obtain_dependencies(dist),
+            optional_dependencies=self._obtain_optional_dependencies(dist),
+        )
+        # `None` indicates there is nothing in `tool.setuptools.dynamic` but the value
+        # might have already been set by setup.py/extensions, so avoid overwriting.
+        updates = {k: v for k, v in obtained_dynamic.items() if v is not None}
+        self.project_cfg.update(updates)
+
+    def _ensure_previously_set(self, dist: Distribution, field: str):
+        previous = _PREVIOUSLY_DEFINED[field](dist)
+        if previous is None and not self.ignore_option_errors:
+            msg = (
+                f"No configuration found for dynamic {field!r}.\n"
+                "Some dynamic fields need to be specified via `tool.setuptools.dynamic`"
+                "\nothers must be specified via the equivalent attribute in `setup.py`."
+            )
+            raise InvalidConfigError(msg)
+
+    def _expand_directive(
+        self, specifier: str, directive, package_dir: Mapping[str, str]
+    ):
+        from more_itertools import always_iterable
+
+        with _ignore_errors(self.ignore_option_errors):
+            root_dir = self.root_dir
+            if "file" in directive:
+                self._referenced_files.update(always_iterable(directive["file"]))
+                return _expand.read_files(directive["file"], root_dir)
+            if "attr" in directive:
+                return _expand.read_attr(directive["attr"], package_dir, root_dir)
+            raise ValueError(f"invalid `{specifier}`: {directive!r}")
+        return None
+
+    def _obtain(self, dist: Distribution, field: str, package_dir: Mapping[str, str]):
+        if field in self.dynamic_cfg:
+            return self._expand_directive(
+                f"tool.setuptools.dynamic.{field}",
+                self.dynamic_cfg[field],
+                package_dir,
+            )
+        self._ensure_previously_set(dist, field)
+        return None
+
+    def _obtain_version(self, dist: Distribution, package_dir: Mapping[str, str]):
+        # Since plugins can set version, let's silently skip if it cannot be obtained
+        if "version" in self.dynamic and "version" in self.dynamic_cfg:
+            return _expand.version(
+                # We already do an early check for the presence of "version"
+                self._obtain(dist, "version", package_dir)  # pyright: ignore[reportArgumentType]
+            )
+        return None
+
+    def _obtain_readme(self, dist: Distribution) -> dict[str, str] | None:
+        if "readme" not in self.dynamic:
+            return None
+
+        dynamic_cfg = self.dynamic_cfg
+        if "readme" in dynamic_cfg:
+            return {
+                # We already do an early check for the presence of "readme"
+                "text": self._obtain(dist, "readme", {}),
+                "content-type": dynamic_cfg["readme"].get("content-type", "text/x-rst"),
+            }  # pyright: ignore[reportReturnType]
+
+        self._ensure_previously_set(dist, "readme")
+        return None
+
+    def _obtain_entry_points(
+        self, dist: Distribution, package_dir: Mapping[str, str]
+    ) -> dict[str, dict[str, Any]] | None:
+        fields = ("entry-points", "scripts", "gui-scripts")
+        if not any(field in self.dynamic for field in fields):
+            return None
+
+        text = self._obtain(dist, "entry-points", package_dir)
+        if text is None:
+            return None
+
+        groups = _expand.entry_points(text)
+        # Any is str | dict[str, str], but causes variance issues
+        expanded: dict[str, dict[str, Any]] = {"entry-points": groups}
+
+        def _set_scripts(field: str, group: str):
+            if group in groups:
+                value = groups.pop(group)
+                if field not in self.dynamic:
+                    raise InvalidConfigError(_MissingDynamic.details(field, value))
+                expanded[field] = value
+
+        _set_scripts("scripts", "console_scripts")
+        _set_scripts("gui-scripts", "gui_scripts")
+
+        return expanded
+
+    def _obtain_classifiers(self, dist: Distribution):
+        if "classifiers" in self.dynamic:
+            value = self._obtain(dist, "classifiers", {})
+            if value:
+                return value.splitlines()
+        return None
+
+    def _obtain_dependencies(self, dist: Distribution):
+        if "dependencies" in self.dynamic:
+            value = self._obtain(dist, "dependencies", {})
+            if value:
+                return _parse_requirements_list(value)
+        return None
+
+    def _obtain_optional_dependencies(self, dist: Distribution):
+        if "optional-dependencies" not in self.dynamic:
+            return None
+        if "optional-dependencies" in self.dynamic_cfg:
+            optional_dependencies_map = self.dynamic_cfg["optional-dependencies"]
+            assert isinstance(optional_dependencies_map, dict)
+            return {
+                group: _parse_requirements_list(
+                    self._expand_directive(
+                        f"tool.setuptools.dynamic.optional-dependencies.{group}",
+                        directive,
+                        {},
+                    )
+                )
+                for group, directive in optional_dependencies_map.items()
+            }
+        self._ensure_previously_set(dist, "optional-dependencies")
+        return None
+
+
+def _parse_requirements_list(value):
+    return [
+        line
+        for line in value.splitlines()
+        if line.strip() and not line.strip().startswith("#")
+    ]
+
+
+@contextmanager
+def _ignore_errors(ignore_option_errors: bool):
+    if not ignore_option_errors:
+        yield
+        return
+
+    try:
+        yield
+    except Exception as ex:
+        _logger.debug(f"ignored error: {ex.__class__.__name__} - {ex}")
+
+
+class _EnsurePackagesDiscovered(_expand.EnsurePackagesDiscovered):
+    def __init__(
+        self, distribution: Distribution, project_cfg: dict, setuptools_cfg: dict
+    ) -> None:
+        super().__init__(distribution)
+        self._project_cfg = project_cfg
+        self._setuptools_cfg = setuptools_cfg
+
+    def __enter__(self) -> Self:
+        """When entering the context, the values of ``packages``, ``py_modules`` and
+        ``package_dir`` that are missing in ``dist`` are copied from ``setuptools_cfg``.
+        """
+        dist, cfg = self._dist, self._setuptools_cfg
+        package_dir: dict[str, str] = cfg.setdefault("package-dir", {})
+        package_dir.update(dist.package_dir or {})
+        dist.package_dir = package_dir  # needs to be the same object
+
+        dist.set_defaults._ignore_ext_modules()  # pyproject.toml-specific behaviour
+
+        # Set `name`, `py_modules` and `packages` in dist to short-circuit
+        # auto-discovery, but avoid overwriting empty lists purposefully set by users.
+        if dist.metadata.name is None:
+            dist.metadata.name = self._project_cfg.get("name")
+        if dist.py_modules is None:
+            dist.py_modules = cfg.get("py-modules")
+        if dist.packages is None:
+            dist.packages = cfg.get("packages")
+
+        return super().__enter__()
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_value: BaseException | None,
+        traceback: TracebackType | None,
+    ) -> None:
+        """When exiting the context, if values of ``packages``, ``py_modules`` and
+        ``package_dir`` are missing in ``setuptools_cfg``, copy from ``dist``.
+        """
+        # If anything was discovered set them back, so they count in the final config.
+        self._setuptools_cfg.setdefault("packages", self._dist.packages)
+        self._setuptools_cfg.setdefault("py-modules", self._dist.py_modules)
+        return super().__exit__(exc_type, exc_value, traceback)
+
+
+class _ExperimentalConfiguration(SetuptoolsWarning):
+    _SUMMARY = (
+        "`{subject}` in `pyproject.toml` is still *experimental* "
+        "and likely to change in future releases."
+    )
+
+
+class _ToolsTypoInMetadata(SetuptoolsWarning):
+    _SUMMARY = (
+        "Ignoring [tools.setuptools] in pyproject.toml, did you mean [tool.setuptools]?"
+    )
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/config/setupcfg.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/config/setupcfg.py
new file mode 100644
index 0000000000000000000000000000000000000000..633aa9d45d086dd0290a2c38bee632ed7f9a63a4
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/config/setupcfg.py
@@ -0,0 +1,780 @@
+"""
+Load setuptools configuration from ``setup.cfg`` files.
+
+**API will be made private in the future**
+
+To read project metadata, consider using
+``build.util.project_wheel_metadata`` (https://pypi.org/project/build/).
+For simple scenarios, you can also try parsing the file directly
+with the help of ``configparser``.
+"""
+
+from __future__ import annotations
+
+import contextlib
+import functools
+import os
+from collections import defaultdict
+from collections.abc import Iterable, Iterator
+from functools import partial, wraps
+from typing import TYPE_CHECKING, Any, Callable, ClassVar, Generic, TypeVar, cast
+
+from packaging.markers import default_environment as marker_env
+from packaging.requirements import InvalidRequirement, Requirement
+from packaging.version import InvalidVersion, Version
+
+from .. import _static
+from .._path import StrPath
+from ..errors import FileError, OptionError
+from ..warnings import SetuptoolsDeprecationWarning
+from . import expand
+
+if TYPE_CHECKING:
+    from typing_extensions import TypeAlias
+
+    from setuptools.dist import Distribution
+
+    from distutils.dist import DistributionMetadata
+
+SingleCommandOptions: TypeAlias = dict[str, tuple[str, Any]]
+"""Dict that associate the name of the options of a particular command to a
+tuple. The first element of the tuple indicates the origin of the option value
+(e.g. the name of the configuration file where it was read from),
+while the second element of the tuple is the option value itself
+"""
+AllCommandOptions: TypeAlias = dict[str, SingleCommandOptions]
+"""cmd name => its options"""
+Target = TypeVar("Target", "Distribution", "DistributionMetadata")
+
+
+def read_configuration(
+    filepath: StrPath, find_others: bool = False, ignore_option_errors: bool = False
+) -> dict:
+    """Read given configuration file and returns options from it as a dict.
+
+    :param str|unicode filepath: Path to configuration file
+        to get options from.
+
+    :param bool find_others: Whether to search for other configuration files
+        which could be on in various places.
+
+    :param bool ignore_option_errors: Whether to silently ignore
+        options, values of which could not be resolved (e.g. due to exceptions
+        in directives such as file:, attr:, etc.).
+        If False exceptions are propagated as expected.
+
+    :rtype: dict
+    """
+    from setuptools.dist import Distribution
+
+    dist = Distribution()
+    filenames = dist.find_config_files() if find_others else []
+    handlers = _apply(dist, filepath, filenames, ignore_option_errors)
+    return configuration_to_dict(handlers)
+
+
+def apply_configuration(dist: Distribution, filepath: StrPath) -> Distribution:
+    """Apply the configuration from a ``setup.cfg`` file into an existing
+    distribution object.
+    """
+    _apply(dist, filepath)
+    dist._finalize_requires()
+    return dist
+
+
+def _apply(
+    dist: Distribution,
+    filepath: StrPath,
+    other_files: Iterable[StrPath] = (),
+    ignore_option_errors: bool = False,
+) -> tuple[ConfigMetadataHandler, ConfigOptionsHandler]:
+    """Read configuration from ``filepath`` and applies to the ``dist`` object."""
+    from setuptools.dist import _Distribution
+
+    filepath = os.path.abspath(filepath)
+
+    if not os.path.isfile(filepath):
+        raise FileError(f'Configuration file {filepath} does not exist.')
+
+    current_directory = os.getcwd()
+    os.chdir(os.path.dirname(filepath))
+    filenames = [*other_files, filepath]
+
+    try:
+        # TODO: Temporary cast until mypy 1.12 is released with upstream fixes from typeshed
+        _Distribution.parse_config_files(dist, filenames=cast(list[str], filenames))
+        handlers = parse_configuration(
+            dist, dist.command_options, ignore_option_errors=ignore_option_errors
+        )
+        dist._finalize_license_files()
+    finally:
+        os.chdir(current_directory)
+
+    return handlers
+
+
+def _get_option(target_obj: Distribution | DistributionMetadata, key: str):
+    """
+    Given a target object and option key, get that option from
+    the target object, either through a get_{key} method or
+    from an attribute directly.
+    """
+    getter_name = f'get_{key}'
+    by_attribute = functools.partial(getattr, target_obj, key)
+    getter = getattr(target_obj, getter_name, by_attribute)
+    return getter()
+
+
+def configuration_to_dict(
+    handlers: Iterable[
+        ConfigHandler[Distribution] | ConfigHandler[DistributionMetadata]
+    ],
+) -> dict:
+    """Returns configuration data gathered by given handlers as a dict.
+
+    :param Iterable[ConfigHandler] handlers: Handlers list,
+        usually from parse_configuration()
+
+    :rtype: dict
+    """
+    config_dict: dict = defaultdict(dict)
+
+    for handler in handlers:
+        for option in handler.set_options:
+            value = _get_option(handler.target_obj, option)
+            config_dict[handler.section_prefix][option] = value
+
+    return config_dict
+
+
+def parse_configuration(
+    distribution: Distribution,
+    command_options: AllCommandOptions,
+    ignore_option_errors: bool = False,
+) -> tuple[ConfigMetadataHandler, ConfigOptionsHandler]:
+    """Performs additional parsing of configuration options
+    for a distribution.
+
+    Returns a list of used option handlers.
+
+    :param Distribution distribution:
+    :param dict command_options:
+    :param bool ignore_option_errors: Whether to silently ignore
+        options, values of which could not be resolved (e.g. due to exceptions
+        in directives such as file:, attr:, etc.).
+        If False exceptions are propagated as expected.
+    :rtype: list
+    """
+    with expand.EnsurePackagesDiscovered(distribution) as ensure_discovered:
+        options = ConfigOptionsHandler(
+            distribution,
+            command_options,
+            ignore_option_errors,
+            ensure_discovered,
+        )
+
+        options.parse()
+        if not distribution.package_dir:
+            distribution.package_dir = options.package_dir  # Filled by `find_packages`
+
+        meta = ConfigMetadataHandler(
+            distribution.metadata,
+            command_options,
+            ignore_option_errors,
+            ensure_discovered,
+            distribution.package_dir,
+            distribution.src_root,
+        )
+        meta.parse()
+        distribution._referenced_files.update(
+            options._referenced_files, meta._referenced_files
+        )
+
+    return meta, options
+
+
+def _warn_accidental_env_marker_misconfig(label: str, orig_value: str, parsed: list):
+    """Because users sometimes misinterpret this configuration:
+
+    [options.extras_require]
+    foo = bar;python_version<"4"
+
+    It looks like one requirement with an environment marker
+    but because there is no newline, it's parsed as two requirements
+    with a semicolon as separator.
+
+    Therefore, if:
+        * input string does not contain a newline AND
+        * parsed result contains two requirements AND
+        * parsing of the two parts from the result ("<first>;<second>")
+        leads in a valid Requirement with a valid marker
+    a UserWarning is shown to inform the user about the possible problem.
+    """
+    if "\n" in orig_value or len(parsed) != 2:
+        return
+
+    markers = marker_env().keys()
+
+    try:
+        req = Requirement(parsed[1])
+        if req.name in markers:
+            _AmbiguousMarker.emit(field=label, req=parsed[1])
+    except InvalidRequirement as ex:
+        if any(parsed[1].startswith(marker) for marker in markers):
+            msg = _AmbiguousMarker.message(field=label, req=parsed[1])
+            raise InvalidRequirement(msg) from ex
+
+
+class ConfigHandler(Generic[Target]):
+    """Handles metadata supplied in configuration files."""
+
+    section_prefix: str
+    """Prefix for config sections handled by this handler.
+    Must be provided by class heirs.
+
+    """
+
+    aliases: ClassVar[dict[str, str]] = {}
+    """Options aliases.
+    For compatibility with various packages. E.g.: d2to1 and pbr.
+    Note: `-` in keys is replaced with `_` by config parser.
+
+    """
+
+    def __init__(
+        self,
+        target_obj: Target,
+        options: AllCommandOptions,
+        ignore_option_errors,
+        ensure_discovered: expand.EnsurePackagesDiscovered,
+    ) -> None:
+        self.ignore_option_errors = ignore_option_errors
+        self.target_obj: Target = target_obj
+        self.sections = dict(self._section_options(options))
+        self.set_options: list[str] = []
+        self.ensure_discovered = ensure_discovered
+        self._referenced_files = set[str]()
+        """After parsing configurations, this property will enumerate
+        all files referenced by the "file:" directive. Private API for setuptools only.
+        """
+
+    @classmethod
+    def _section_options(
+        cls, options: AllCommandOptions
+    ) -> Iterator[tuple[str, SingleCommandOptions]]:
+        for full_name, value in options.items():
+            pre, _sep, name = full_name.partition(cls.section_prefix)
+            if pre:
+                continue
+            yield name.lstrip('.'), value
+
+    @property
+    def parsers(self):
+        """Metadata item name to parser function mapping."""
+        raise NotImplementedError(
+            f'{self.__class__.__name__} must provide .parsers property'
+        )
+
+    def __setitem__(self, option_name, value) -> None:
+        target_obj = self.target_obj
+
+        # Translate alias into real name.
+        option_name = self.aliases.get(option_name, option_name)
+
+        try:
+            current_value = getattr(target_obj, option_name)
+        except AttributeError as e:
+            raise KeyError(option_name) from e
+
+        if current_value:
+            # Already inhabited. Skipping.
+            return
+
+        try:
+            parsed = self.parsers.get(option_name, lambda x: x)(value)
+        except (Exception,) * self.ignore_option_errors:
+            return
+
+        simple_setter = functools.partial(target_obj.__setattr__, option_name)
+        setter = getattr(target_obj, f"set_{option_name}", simple_setter)
+        setter(parsed)
+
+        self.set_options.append(option_name)
+
+    @classmethod
+    def _parse_list(cls, value, separator=','):
+        """Represents value as a list.
+
+        Value is split either by separator (defaults to comma) or by lines.
+
+        :param value:
+        :param separator: List items separator character.
+        :rtype: list
+        """
+        if isinstance(value, list):  # _get_parser_compound case
+            return value
+
+        if '\n' in value:
+            value = value.splitlines()
+        else:
+            value = value.split(separator)
+
+        return [chunk.strip() for chunk in value if chunk.strip()]
+
+    @classmethod
+    def _parse_dict(cls, value):
+        """Represents value as a dict.
+
+        :param value:
+        :rtype: dict
+        """
+        separator = '='
+        result = {}
+        for line in cls._parse_list(value):
+            key, sep, val = line.partition(separator)
+            if sep != separator:
+                raise OptionError(f"Unable to parse option value to dict: {value}")
+            result[key.strip()] = val.strip()
+
+        return result
+
+    @classmethod
+    def _parse_bool(cls, value):
+        """Represents value as boolean.
+
+        :param value:
+        :rtype: bool
+        """
+        value = value.lower()
+        return value in ('1', 'true', 'yes')
+
+    @classmethod
+    def _exclude_files_parser(cls, key):
+        """Returns a parser function to make sure field inputs
+        are not files.
+
+        Parses a value after getting the key so error messages are
+        more informative.
+
+        :param key:
+        :rtype: callable
+        """
+
+        def parser(value):
+            exclude_directive = 'file:'
+            if value.startswith(exclude_directive):
+                raise ValueError(
+                    f'Only strings are accepted for the {key} field, '
+                    'files are not accepted'
+                )
+            return _static.Str(value)
+
+        return parser
+
+    def _parse_file(self, value, root_dir: StrPath | None):
+        """Represents value as a string, allowing including text
+        from nearest files using `file:` directive.
+
+        Directive is sandboxed and won't reach anything outside
+        directory with setup.py.
+
+        Examples:
+            file: README.rst, CHANGELOG.md, src/file.txt
+
+        :param str value:
+        :rtype: str
+        """
+        include_directive = 'file:'
+
+        if not isinstance(value, str):
+            return value
+
+        if not value.startswith(include_directive):
+            return _static.Str(value)
+
+        spec = value[len(include_directive) :]
+        filepaths = [path.strip() for path in spec.split(',')]
+        self._referenced_files.update(filepaths)
+        # XXX: Is marking as static contents coming from files too optimistic?
+        return _static.Str(expand.read_files(filepaths, root_dir))
+
+    def _parse_attr(self, value, package_dir, root_dir: StrPath):
+        """Represents value as a module attribute.
+
+        Examples:
+            attr: package.attr
+            attr: package.module.attr
+
+        :param str value:
+        :rtype: str
+        """
+        attr_directive = 'attr:'
+        if not value.startswith(attr_directive):
+            return _static.Str(value)
+
+        attr_desc = value.replace(attr_directive, '')
+
+        # Make sure package_dir is populated correctly, so `attr:` directives can work
+        package_dir.update(self.ensure_discovered.package_dir)
+        return expand.read_attr(attr_desc, package_dir, root_dir)
+
+    @classmethod
+    def _get_parser_compound(cls, *parse_methods):
+        """Returns parser function to represents value as a list.
+
+        Parses a value applying given methods one after another.
+
+        :param parse_methods:
+        :rtype: callable
+        """
+
+        def parse(value):
+            parsed = value
+
+            for method in parse_methods:
+                parsed = method(parsed)
+
+            return parsed
+
+        return parse
+
+    @classmethod
+    def _parse_section_to_dict_with_key(cls, section_options, values_parser):
+        """Parses section options into a dictionary.
+
+        Applies a given parser to each option in a section.
+
+        :param dict section_options:
+        :param callable values_parser: function with 2 args corresponding to key, value
+        :rtype: dict
+        """
+        value = {}
+        for key, (_, val) in section_options.items():
+            value[key] = values_parser(key, val)
+        return value
+
+    @classmethod
+    def _parse_section_to_dict(cls, section_options, values_parser=None):
+        """Parses section options into a dictionary.
+
+        Optionally applies a given parser to each value.
+
+        :param dict section_options:
+        :param callable values_parser: function with 1 arg corresponding to option value
+        :rtype: dict
+        """
+        parser = (lambda _, v: values_parser(v)) if values_parser else (lambda _, v: v)
+        return cls._parse_section_to_dict_with_key(section_options, parser)
+
+    def parse_section(self, section_options) -> None:
+        """Parses configuration file section.
+
+        :param dict section_options:
+        """
+        for name, (_, value) in section_options.items():
+            with contextlib.suppress(KeyError):
+                # Keep silent for a new option may appear anytime.
+                self[name] = value
+
+    def parse(self) -> None:
+        """Parses configuration file items from one
+        or more related sections.
+
+        """
+        for section_name, section_options in self.sections.items():
+            method_postfix = ''
+            if section_name:  # [section.option] variant
+                method_postfix = f"_{section_name}"
+
+            section_parser_method: Callable | None = getattr(
+                self,
+                # Dots in section names are translated into dunderscores.
+                f'parse_section{method_postfix}'.replace('.', '__'),
+                None,
+            )
+
+            if section_parser_method is None:
+                raise OptionError(
+                    "Unsupported distribution option section: "
+                    f"[{self.section_prefix}.{section_name}]"
+                )
+
+            section_parser_method(section_options)
+
+    def _deprecated_config_handler(self, func, msg, **kw):
+        """this function will wrap around parameters that are deprecated
+
+        :param msg: deprecation message
+        :param func: function to be wrapped around
+        """
+
+        @wraps(func)
+        def config_handler(*args, **kwargs):
+            kw.setdefault("stacklevel", 2)
+            _DeprecatedConfig.emit("Deprecated config in `setup.cfg`", msg, **kw)
+            return func(*args, **kwargs)
+
+        return config_handler
+
+
+class ConfigMetadataHandler(ConfigHandler["DistributionMetadata"]):
+    section_prefix = 'metadata'
+
+    aliases = {
+        'home_page': 'url',
+        'summary': 'description',
+        'classifier': 'classifiers',
+        'platform': 'platforms',
+    }
+
+    strict_mode = False
+    """We need to keep it loose, to be partially compatible with
+    `pbr` and `d2to1` packages which also uses `metadata` section.
+
+    """
+
+    def __init__(
+        self,
+        target_obj: DistributionMetadata,
+        options: AllCommandOptions,
+        ignore_option_errors: bool,
+        ensure_discovered: expand.EnsurePackagesDiscovered,
+        package_dir: dict | None = None,
+        root_dir: StrPath | None = os.curdir,
+    ) -> None:
+        super().__init__(target_obj, options, ignore_option_errors, ensure_discovered)
+        self.package_dir = package_dir
+        self.root_dir = root_dir
+
+    @property
+    def parsers(self):
+        """Metadata item name to parser function mapping."""
+        parse_list_static = self._get_parser_compound(self._parse_list, _static.List)
+        parse_dict_static = self._get_parser_compound(self._parse_dict, _static.Dict)
+        parse_file = partial(self._parse_file, root_dir=self.root_dir)
+        exclude_files_parser = self._exclude_files_parser
+
+        return {
+            'author': _static.Str,
+            'author_email': _static.Str,
+            'maintainer': _static.Str,
+            'maintainer_email': _static.Str,
+            'platforms': parse_list_static,
+            'keywords': parse_list_static,
+            'provides': parse_list_static,
+            'obsoletes': parse_list_static,
+            'classifiers': self._get_parser_compound(parse_file, parse_list_static),
+            'license': exclude_files_parser('license'),
+            'license_files': parse_list_static,
+            'description': parse_file,
+            'long_description': parse_file,
+            'long_description_content_type': _static.Str,
+            'version': self._parse_version,  # Cannot be marked as dynamic
+            'url': _static.Str,
+            'project_urls': parse_dict_static,
+        }
+
+    def _parse_version(self, value):
+        """Parses `version` option value.
+
+        :param value:
+        :rtype: str
+
+        """
+        version = self._parse_file(value, self.root_dir)
+
+        if version != value:
+            version = version.strip()
+            # Be strict about versions loaded from file because it's easy to
+            # accidentally include newlines and other unintended content
+            try:
+                Version(version)
+            except InvalidVersion as e:
+                raise OptionError(
+                    f'Version loaded from {value} does not '
+                    f'comply with PEP 440: {version}'
+                ) from e
+
+            return version
+
+        return expand.version(self._parse_attr(value, self.package_dir, self.root_dir))
+
+
+class ConfigOptionsHandler(ConfigHandler["Distribution"]):
+    section_prefix = 'options'
+
+    def __init__(
+        self,
+        target_obj: Distribution,
+        options: AllCommandOptions,
+        ignore_option_errors: bool,
+        ensure_discovered: expand.EnsurePackagesDiscovered,
+    ) -> None:
+        super().__init__(target_obj, options, ignore_option_errors, ensure_discovered)
+        self.root_dir = target_obj.src_root
+        self.package_dir: dict[str, str] = {}  # To be filled by `find_packages`
+
+    @classmethod
+    def _parse_list_semicolon(cls, value):
+        return cls._parse_list(value, separator=';')
+
+    def _parse_file_in_root(self, value):
+        return self._parse_file(value, root_dir=self.root_dir)
+
+    def _parse_requirements_list(self, label: str, value: str):
+        # Parse a requirements list, either by reading in a `file:`, or a list.
+        parsed = self._parse_list_semicolon(self._parse_file_in_root(value))
+        _warn_accidental_env_marker_misconfig(label, value, parsed)
+        # Filter it to only include lines that are not comments. `parse_list`
+        # will have stripped each line and filtered out empties.
+        return _static.List(line for line in parsed if not line.startswith("#"))
+        # ^-- Use `_static.List` to mark a non-`Dynamic` Core Metadata
+
+    @property
+    def parsers(self):
+        """Metadata item name to parser function mapping."""
+        parse_list = self._parse_list
+        parse_bool = self._parse_bool
+        parse_cmdclass = self._parse_cmdclass
+
+        return {
+            'zip_safe': parse_bool,
+            'include_package_data': parse_bool,
+            'package_dir': self._parse_dict,
+            'scripts': parse_list,
+            'eager_resources': parse_list,
+            'dependency_links': parse_list,
+            'namespace_packages': self._deprecated_config_handler(
+                parse_list,
+                "The namespace_packages parameter is deprecated, "
+                "consider using implicit namespaces instead (PEP 420).",
+                # TODO: define due date, see setuptools.dist:check_nsp.
+            ),
+            'install_requires': partial(  # Core Metadata
+                self._parse_requirements_list, "install_requires"
+            ),
+            'setup_requires': self._parse_list_semicolon,
+            'packages': self._parse_packages,
+            'entry_points': self._parse_file_in_root,
+            'py_modules': parse_list,
+            'python_requires': _static.SpecifierSet,  # Core Metadata
+            'cmdclass': parse_cmdclass,
+        }
+
+    def _parse_cmdclass(self, value):
+        package_dir = self.ensure_discovered.package_dir
+        return expand.cmdclass(self._parse_dict(value), package_dir, self.root_dir)
+
+    def _parse_packages(self, value):
+        """Parses `packages` option value.
+
+        :param value:
+        :rtype: list
+        """
+        find_directives = ['find:', 'find_namespace:']
+        trimmed_value = value.strip()
+
+        if trimmed_value not in find_directives:
+            return self._parse_list(value)
+
+        # Read function arguments from a dedicated section.
+        find_kwargs = self.parse_section_packages__find(
+            self.sections.get('packages.find', {})
+        )
+
+        find_kwargs.update(
+            namespaces=(trimmed_value == find_directives[1]),
+            root_dir=self.root_dir,
+            fill_package_dir=self.package_dir,
+        )
+
+        return expand.find_packages(**find_kwargs)
+
+    def parse_section_packages__find(self, section_options):
+        """Parses `packages.find` configuration file section.
+
+        To be used in conjunction with _parse_packages().
+
+        :param dict section_options:
+        """
+        section_data = self._parse_section_to_dict(section_options, self._parse_list)
+
+        valid_keys = ['where', 'include', 'exclude']
+        find_kwargs = {k: v for k, v in section_data.items() if k in valid_keys and v}
+
+        where = find_kwargs.get('where')
+        if where is not None:
+            find_kwargs['where'] = where[0]  # cast list to single val
+
+        return find_kwargs
+
+    def parse_section_entry_points(self, section_options) -> None:
+        """Parses `entry_points` configuration file section.
+
+        :param dict section_options:
+        """
+        parsed = self._parse_section_to_dict(section_options, self._parse_list)
+        self['entry_points'] = parsed
+
+    def _parse_package_data(self, section_options):
+        package_data = self._parse_section_to_dict(section_options, self._parse_list)
+        return expand.canonic_package_data(package_data)
+
+    def parse_section_package_data(self, section_options) -> None:
+        """Parses `package_data` configuration file section.
+
+        :param dict section_options:
+        """
+        self['package_data'] = self._parse_package_data(section_options)
+
+    def parse_section_exclude_package_data(self, section_options) -> None:
+        """Parses `exclude_package_data` configuration file section.
+
+        :param dict section_options:
+        """
+        self['exclude_package_data'] = self._parse_package_data(section_options)
+
+    def parse_section_extras_require(self, section_options) -> None:  # Core Metadata
+        """Parses `extras_require` configuration file section.
+
+        :param dict section_options:
+        """
+        parsed = self._parse_section_to_dict_with_key(
+            section_options,
+            lambda k, v: self._parse_requirements_list(f"extras_require[{k}]", v),
+        )
+
+        self['extras_require'] = _static.Dict(parsed)
+        # ^-- Use `_static.Dict` to mark a non-`Dynamic` Core Metadata
+
+    def parse_section_data_files(self, section_options) -> None:
+        """Parses `data_files` configuration file section.
+
+        :param dict section_options:
+        """
+        parsed = self._parse_section_to_dict(section_options, self._parse_list)
+        self['data_files'] = expand.canonic_data_files(parsed, self.root_dir)
+
+
+class _AmbiguousMarker(SetuptoolsDeprecationWarning):
+    _SUMMARY = "Ambiguous requirement marker."
+    _DETAILS = """
+    One of the parsed requirements in `{field}` looks like a valid environment marker:
+
+        {req!r}
+
+    Please make sure that the configuration file is correct.
+    You can use dangling lines to avoid this problem.
+    """
+    _SEE_DOCS = "userguide/declarative_config.html#opt-2"
+    # TODO: should we include due_date here? Initially introduced in 6 Aug 2022.
+    # Does this make sense with latest version of packaging?
+
+    @classmethod
+    def message(cls, **kw):
+        docs = f"https://setuptools.pypa.io/en/latest/{cls._SEE_DOCS}"
+        return cls._format(cls._SUMMARY, cls._DETAILS, see_url=docs, format_args=kw)
+
+
+class _DeprecatedConfig(SetuptoolsDeprecationWarning):
+    _SEE_DOCS = "userguide/declarative_config.html"
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/config/setuptools.schema.json b/tool_server/.venv/lib/python3.12/site-packages/setuptools/config/setuptools.schema.json
new file mode 100644
index 0000000000000000000000000000000000000000..ec887b35736e4ede6265e95e3a9e2520b43cc40f
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/config/setuptools.schema.json
@@ -0,0 +1,433 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+
+  "$id": "https://setuptools.pypa.io/en/latest/userguide/pyproject_config.html",
+  "title": "``tool.setuptools`` table",
+  "$$description": [
+    "``setuptools``-specific configurations that can be set by users that require",
+    "customization.",
+    "These configurations are completely optional and probably can be skipped when",
+    "creating simple packages. They are equivalent to some of the `Keywords",
+    "<https://setuptools.pypa.io/en/latest/references/keywords.html>`_",
+    "used by the ``setup.py`` file, and can be set via the ``tool.setuptools`` table.",
+    "It considers only ``setuptools`` `parameters",
+    "<https://setuptools.pypa.io/en/latest/userguide/pyproject_config.html#setuptools-specific-configuration>`_",
+    "that are not covered by :pep:`621`; and intentionally excludes ``dependency_links``",
+    "and ``setup_requires`` (incompatible with modern workflows/standards)."
+  ],
+
+  "type": "object",
+  "additionalProperties": false,
+  "properties": {
+    "platforms": {
+      "type": "array",
+      "items": {"type": "string"}
+    },
+    "provides": {
+      "$$description": [
+        "Package and virtual package names contained within this package",
+        "**(not supported by pip)**"
+      ],
+      "type": "array",
+      "items": {"type": "string", "format": "pep508-identifier"}
+    },
+    "obsoletes": {
+      "$$description": [
+        "Packages which this package renders obsolete",
+        "**(not supported by pip)**"
+      ],
+      "type": "array",
+      "items": {"type": "string", "format": "pep508-identifier"}
+    },
+    "zip-safe": {
+      "$$description": [
+        "Whether the project can be safely installed and run from a zip file.",
+        "**OBSOLETE**: only relevant for ``pkg_resources``, ``easy_install`` and",
+        "``setup.py install`` in the context of ``eggs`` (**DEPRECATED**)."
+      ],
+      "type": "boolean"
+    },
+    "script-files": {
+      "$$description": [
+        "Legacy way of defining scripts (entry-points are preferred).",
+        "Equivalent to the ``script`` keyword in ``setup.py``",
+        "(it was renamed to avoid confusion with entry-point based ``project.scripts``",
+        "defined in :pep:`621`).",
+        "**DISCOURAGED**: generic script wrappers are tricky and may not work properly.",
+        "Whenever possible, please use ``project.scripts`` instead."
+      ],
+      "type": "array",
+      "items": {"type": "string"},
+      "$comment": "TODO: is this field deprecated/should be removed?"
+    },
+    "eager-resources": {
+      "$$description": [
+        "Resources that should be extracted together, if any of them is needed,",
+        "or if any C extensions included in the project are imported.",
+        "**OBSOLETE**: only relevant for ``pkg_resources``, ``easy_install`` and",
+        "``setup.py install`` in the context of ``eggs`` (**DEPRECATED**)."
+      ],
+      "type": "array",
+      "items": {"type": "string"}
+    },
+    "packages": {
+      "$$description": [
+        "Packages that should be included in the distribution.",
+        "It can be given either as a list of package identifiers",
+        "or as a ``dict``-like structure with a single key ``find``",
+        "which corresponds to a dynamic call to",
+        "``setuptools.config.expand.find_packages`` function.",
+        "The ``find`` key is associated with a nested ``dict``-like structure that can",
+        "contain ``where``, ``include``, ``exclude`` and ``namespaces`` keys,",
+        "mimicking the keyword arguments of the associated function."
+      ],
+      "oneOf": [
+        {
+          "title": "Array of Python package identifiers",
+          "type": "array",
+          "items": {"$ref": "#/definitions/package-name"}
+        },
+        {"$ref": "#/definitions/find-directive"}
+      ]
+    },
+    "package-dir": {
+      "$$description": [
+        ":class:`dict`-like structure mapping from package names to directories where their",
+        "code can be found.",
+        "The empty string (as key) means that all packages are contained inside",
+        "the given directory will be included in the distribution."
+      ],
+      "type": "object",
+      "additionalProperties": false,
+      "propertyNames": {
+        "anyOf": [{"const": ""}, {"$ref": "#/definitions/package-name"}]
+      },
+      "patternProperties": {
+        "^.*$": {"type": "string" }
+      }
+    },
+    "package-data": {
+      "$$description": [
+        "Mapping from package names to lists of glob patterns.",
+        "Usually this option is not needed when using ``include-package-data = true``",
+        "For more information on how to include data files, check ``setuptools`` `docs",
+        "<https://setuptools.pypa.io/en/latest/userguide/datafiles.html>`_."
+      ],
+      "type": "object",
+      "additionalProperties": false,
+      "propertyNames": {
+        "anyOf": [{"type": "string", "format": "python-module-name"}, {"const": "*"}]
+      },
+      "patternProperties": {
+        "^.*$": {"type": "array", "items": {"type": "string"}}
+      }
+    },
+    "include-package-data": {
+      "$$description": [
+        "Automatically include any data files inside the package directories",
+        "that are specified by ``MANIFEST.in``",
+        "For more information on how to include data files, check ``setuptools`` `docs",
+        "<https://setuptools.pypa.io/en/latest/userguide/datafiles.html>`_."
+      ],
+      "type": "boolean"
+    },
+    "exclude-package-data": {
+      "$$description": [
+        "Mapping from package names to lists of glob patterns that should be excluded",
+        "For more information on how to include data files, check ``setuptools`` `docs",
+        "<https://setuptools.pypa.io/en/latest/userguide/datafiles.html>`_."
+      ],
+      "type": "object",
+      "additionalProperties": false,
+      "propertyNames": {
+        "anyOf": [{"type": "string", "format": "python-module-name"}, {"const": "*"}]
+      },
+      "patternProperties": {
+          "^.*$": {"type": "array", "items": {"type": "string"}}
+      }
+    },
+    "namespace-packages": {
+      "type": "array",
+      "items": {"type": "string", "format": "python-module-name-relaxed"},
+      "$comment": "https://setuptools.pypa.io/en/latest/userguide/package_discovery.html",
+      "description": "**DEPRECATED**: use implicit namespaces instead (:pep:`420`)."
+    },
+    "py-modules": {
+      "description": "Modules that setuptools will manipulate",
+      "type": "array",
+      "items": {"type": "string", "format": "python-module-name-relaxed"},
+      "$comment": "TODO: clarify the relationship with ``packages``"
+    },
+    "ext-modules": {
+      "description": "Extension modules to be compiled by setuptools",
+      "type": "array",
+      "items": {"$ref": "#/definitions/ext-module"}
+    },
+    "data-files": {
+      "$$description": [
+        "``dict``-like structure where each key represents a directory and",
+        "the value is a list of glob patterns that should be installed in them.",
+        "**DISCOURAGED**: please notice this might not work as expected with wheels.",
+        "Whenever possible, consider using data files inside the package directories",
+        "(or create a new namespace package that only contains data files).",
+        "See `data files support",
+        "<https://setuptools.pypa.io/en/latest/userguide/datafiles.html>`_."
+      ],
+      "type": "object",
+      "patternProperties": {
+          "^.*$": {"type": "array", "items": {"type": "string"}}
+      }
+    },
+    "cmdclass": {
+      "$$description": [
+        "Mapping of distutils-style command names to ``setuptools.Command`` subclasses",
+        "which in turn should be represented by strings with a qualified class name",
+        "(i.e., \"dotted\" form with module), e.g.::\n\n",
+        "    cmdclass = {mycmd = \"pkg.subpkg.module.CommandClass\"}\n\n",
+        "The command class should be a directly defined at the top-level of the",
+        "containing module (no class nesting)."
+      ],
+      "type": "object",
+      "patternProperties": {
+          "^.*$": {"type": "string", "format": "python-qualified-identifier"}
+      }
+    },
+    "license-files": {
+      "type": "array",
+      "items": {"type": "string"},
+      "$$description": [
+        "**PROVISIONAL**: list of glob patterns for all license files being distributed.",
+        "(likely to become standard with :pep:`639`).",
+        "By default: ``['LICEN[CS]E*', 'COPYING*', 'NOTICE*', 'AUTHORS*']``"
+      ],
+      "$comment": "TODO: revise if PEP 639 is accepted. Probably ``project.license-files``?"
+    },
+    "dynamic": {
+      "type": "object",
+      "description": "Instructions for loading :pep:`621`-related metadata dynamically",
+      "additionalProperties": false,
+      "properties": {
+        "version": {
+          "$$description": [
+            "A version dynamically loaded via either the ``attr:`` or ``file:``",
+            "directives. Please make sure the given file or attribute respects :pep:`440`.",
+            "Also ensure to set ``project.dynamic`` accordingly."
+          ],
+          "oneOf": [
+            {"$ref": "#/definitions/attr-directive"},
+            {"$ref": "#/definitions/file-directive"}
+          ]
+        },
+        "classifiers": {"$ref": "#/definitions/file-directive"},
+        "description": {"$ref": "#/definitions/file-directive"},
+        "entry-points": {"$ref": "#/definitions/file-directive"},
+        "dependencies": {"$ref": "#/definitions/file-directive-for-dependencies"},
+        "optional-dependencies": {
+          "type": "object",
+          "propertyNames": {"type": "string", "format": "pep508-identifier"},
+          "additionalProperties": false,
+          "patternProperties": {
+            ".+": {"$ref": "#/definitions/file-directive-for-dependencies"}
+          }
+        },
+        "readme": {
+          "type": "object",
+          "anyOf": [
+            {"$ref": "#/definitions/file-directive"},
+            {
+              "type": "object",
+              "properties": {
+                "content-type": {"type": "string"},
+                "file": { "$ref": "#/definitions/file-directive/properties/file" }
+              },
+              "additionalProperties": false}
+          ],
+          "required": ["file"]
+        }
+      }
+    }
+  },
+
+  "definitions": {
+    "package-name": {
+      "$id": "#/definitions/package-name",
+      "title": "Valid package name",
+      "description": "Valid package name (importable or :pep:`561`).",
+      "type": "string",
+      "anyOf": [
+        {"type": "string", "format": "python-module-name-relaxed"},
+        {"type": "string", "format": "pep561-stub-name"}
+      ]
+    },
+    "ext-module": {
+      "$id": "#/definitions/ext-module",
+      "title": "Extension module",
+      "description": "Parameters to construct a :class:`setuptools.Extension` object",
+      "type": "object",
+      "required": ["name", "sources"],
+      "additionalProperties": false,
+      "properties": {
+        "name": {
+          "type": "string",
+          "format": "python-module-name-relaxed"
+        },
+        "sources": {
+          "type": "array",
+          "items": {"type": "string"}
+        },
+        "include-dirs":{
+          "type": "array",
+          "items": {"type": "string"}
+        },
+        "define-macros": {
+          "type": "array",
+          "items": {
+            "type": "array",
+            "items": [
+              {"description": "macro name", "type": "string"},
+              {"description": "macro value", "oneOf": [{"type": "string"}, {"type": "null"}]}
+            ],
+            "additionalItems": false
+          }
+        },
+        "undef-macros": {
+          "type": "array",
+          "items": {"type": "string"}
+        },
+        "library-dirs": {
+          "type": "array",
+          "items": {"type": "string"}
+        },
+        "libraries": {
+          "type": "array",
+          "items": {"type": "string"}
+        },
+        "runtime-library-dirs": {
+          "type": "array",
+          "items": {"type": "string"}
+        },
+        "extra-objects": {
+          "type": "array",
+          "items": {"type": "string"}
+        },
+        "extra-compile-args": {
+          "type": "array",
+          "items": {"type": "string"}
+        },
+        "extra-link-args": {
+          "type": "array",
+          "items": {"type": "string"}
+        },
+        "export-symbols": {
+          "type": "array",
+          "items": {"type": "string"}
+        },
+        "swig-opts": {
+          "type": "array",
+          "items": {"type": "string"}
+        },
+        "depends": {
+          "type": "array",
+          "items": {"type": "string"}
+        },
+        "language": {"type": "string"},
+        "optional": {"type": "boolean"},
+        "py-limited-api": {"type": "boolean"}
+      }
+    },
+    "file-directive": {
+      "$id": "#/definitions/file-directive",
+      "title": "'file:' directive",
+      "description":
+        "Value is read from a file (or list of files and then concatenated)",
+      "type": "object",
+      "additionalProperties": false,
+      "properties": {
+        "file": {
+          "oneOf": [
+            {"type": "string"},
+            {"type": "array", "items": {"type": "string"}}
+          ]
+        }
+      },
+      "required": ["file"]
+    },
+    "file-directive-for-dependencies": {
+      "title": "'file:' directive for dependencies",
+      "allOf": [
+        {
+          "$$description": [
+            "**BETA**: subset of the ``requirements.txt`` format",
+            "without ``pip`` flags and options",
+            "(one :pep:`508`-compliant string per line,",
+            "lines that are blank or start with ``#`` are excluded).",
+            "See `dynamic metadata",
+            "<https://setuptools.pypa.io/en/latest/userguide/pyproject_config.html#dynamic-metadata>`_."
+          ]
+        },
+        {"$ref": "#/definitions/file-directive"}
+      ]
+    },
+    "attr-directive": {
+      "title": "'attr:' directive",
+      "$id": "#/definitions/attr-directive",
+      "$$description": [
+        "Value is read from a module attribute. Supports callables and iterables;",
+        "unsupported types are cast via ``str()``"
+      ],
+      "type": "object",
+      "additionalProperties": false,
+      "properties": {
+        "attr": {"type": "string", "format": "python-qualified-identifier"}
+      },
+      "required": ["attr"]
+    },
+    "find-directive": {
+      "$id": "#/definitions/find-directive",
+      "title": "'find:' directive",
+      "type": "object",
+      "additionalProperties": false,
+      "properties": {
+        "find": {
+          "type": "object",
+          "$$description": [
+            "Dynamic `package discovery",
+            "<https://setuptools.pypa.io/en/latest/userguide/package_discovery.html>`_."
+          ],
+          "additionalProperties": false,
+          "properties": {
+            "where": {
+              "description":
+                "Directories to be searched for packages (Unix-style relative path)",
+              "type": "array",
+              "items": {"type": "string"}
+            },
+            "exclude": {
+              "type": "array",
+              "$$description": [
+                "Exclude packages that match the values listed in this field.",
+                "Can container shell-style wildcards (e.g. ``'pkg.*'``)"
+              ],
+              "items": {"type": "string"}
+            },
+            "include": {
+              "type": "array",
+              "$$description": [
+                "Restrict the found packages to just the ones listed in this field.",
+                "Can container shell-style wildcards (e.g. ``'pkg.*'``)"
+              ],
+              "items": {"type": "string"}
+            },
+            "namespaces": {
+              "type": "boolean",
+              "$$description": [
+                "When ``True``, directories without a ``__init__.py`` file will also",
+                "be scanned for :pep:`420`-style implicit namespaces"
+              ]
+            }
+          }
+        }
+      }
+    }
+  }
+}
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/tests/__init__.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/tests/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..eb70bfb7115a2a94a8b942b31cafc3a550f0c005
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/tests/__init__.py
@@ -0,0 +1,13 @@
+import locale
+import sys
+
+import pytest
+
+__all__ = ['fail_on_ascii']
+
+if sys.version_info >= (3, 11):
+    locale_encoding = locale.getencoding()
+else:
+    locale_encoding = locale.getpreferredencoding(False)
+is_ascii = locale_encoding == 'ANSI_X3.4-1968'
+fail_on_ascii = pytest.mark.xfail(is_ascii, reason="Test fails in this locale")
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/tests/contexts.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/tests/contexts.py
new file mode 100644
index 0000000000000000000000000000000000000000..97cceea0e7060c6e3568956e1ba20893301da387
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/tests/contexts.py
@@ -0,0 +1,145 @@
+import contextlib
+import io
+import os
+import shutil
+import site
+import sys
+import tempfile
+
+from filelock import FileLock
+
+
+@contextlib.contextmanager
+def tempdir(cd=lambda dir: None, **kwargs):
+    temp_dir = tempfile.mkdtemp(**kwargs)
+    orig_dir = os.getcwd()
+    try:
+        cd(temp_dir)
+        yield temp_dir
+    finally:
+        cd(orig_dir)
+        shutil.rmtree(temp_dir)
+
+
+@contextlib.contextmanager
+def environment(**replacements):
+    """
+    In a context, patch the environment with replacements. Pass None values
+    to clear the values.
+    """
+    saved = dict((key, os.environ[key]) for key in replacements if key in os.environ)
+
+    # remove values that are null
+    remove = (key for (key, value) in replacements.items() if value is None)
+    for key in list(remove):
+        os.environ.pop(key, None)
+        replacements.pop(key)
+
+    os.environ.update(replacements)
+
+    try:
+        yield saved
+    finally:
+        for key in replacements:
+            os.environ.pop(key, None)
+        os.environ.update(saved)
+
+
+@contextlib.contextmanager
+def quiet():
+    """
+    Redirect stdout/stderr to StringIO objects to prevent console output from
+    distutils commands.
+    """
+
+    old_stdout = sys.stdout
+    old_stderr = sys.stderr
+    new_stdout = sys.stdout = io.StringIO()
+    new_stderr = sys.stderr = io.StringIO()
+    try:
+        yield new_stdout, new_stderr
+    finally:
+        new_stdout.seek(0)
+        new_stderr.seek(0)
+        sys.stdout = old_stdout
+        sys.stderr = old_stderr
+
+
+@contextlib.contextmanager
+def save_user_site_setting():
+    saved = site.ENABLE_USER_SITE
+    try:
+        yield saved
+    finally:
+        site.ENABLE_USER_SITE = saved
+
+
+@contextlib.contextmanager
+def save_pkg_resources_state():
+    import pkg_resources
+
+    pr_state = pkg_resources.__getstate__()
+    # also save sys.path
+    sys_path = sys.path[:]
+    try:
+        yield pr_state, sys_path
+    finally:
+        sys.path[:] = sys_path
+        pkg_resources.__setstate__(pr_state)
+
+
+@contextlib.contextmanager
+def suppress_exceptions(*excs):
+    try:
+        yield
+    except excs:
+        pass
+
+
+def multiproc(request):
+    """
+    Return True if running under xdist and multiple
+    workers are used.
+    """
+    try:
+        worker_id = request.getfixturevalue('worker_id')
+    except Exception:
+        return False
+    return worker_id != 'master'
+
+
+@contextlib.contextmanager
+def session_locked_tmp_dir(request, tmp_path_factory, name):
+    """Uses a file lock to guarantee only one worker can access a temp dir"""
+    # get the temp directory shared by all workers
+    base = tmp_path_factory.getbasetemp()
+    shared_dir = base.parent if multiproc(request) else base
+
+    locked_dir = shared_dir / name
+    with FileLock(locked_dir.with_suffix(".lock")):
+        # ^-- prevent multiple workers to access the directory at once
+        locked_dir.mkdir(exist_ok=True, parents=True)
+        yield locked_dir
+
+
+@contextlib.contextmanager
+def save_paths():
+    """Make sure ``sys.path``, ``sys.meta_path`` and ``sys.path_hooks`` are preserved"""
+    prev = sys.path[:], sys.meta_path[:], sys.path_hooks[:]
+
+    try:
+        yield
+    finally:
+        sys.path, sys.meta_path, sys.path_hooks = prev
+
+
+@contextlib.contextmanager
+def save_sys_modules():
+    """Make sure initial ``sys.modules`` is preserved"""
+    prev_modules = sys.modules
+
+    try:
+        sys.modules = sys.modules.copy()
+        yield
+    finally:
+        sys.modules = prev_modules
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/tests/environment.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/tests/environment.py
new file mode 100644
index 0000000000000000000000000000000000000000..ed5499ef7d73762d033a4877bfe586d6c0b82235
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/tests/environment.py
@@ -0,0 +1,95 @@
+import os
+import subprocess
+import sys
+import unicodedata
+from subprocess import PIPE as _PIPE, Popen as _Popen
+
+import jaraco.envs
+
+
+class VirtualEnv(jaraco.envs.VirtualEnv):
+    name = '.env'
+    # Some version of PyPy will import distutils on startup, implicitly
+    # importing setuptools, and thus leading to BackendInvalid errors
+    # when upgrading Setuptools. Bypass this behavior by avoiding the
+    # early availability and need to upgrade.
+    create_opts = ['--no-setuptools']
+
+    def run(self, cmd, *args, **kwargs):
+        cmd = [self.exe(cmd[0])] + cmd[1:]
+        kwargs = {"cwd": self.root, "encoding": "utf-8", **kwargs}  # Allow overriding
+        # In some environments (eg. downstream distro packaging), where:
+        # - tox isn't used to run tests and
+        # - PYTHONPATH is set to point to a specific setuptools codebase and
+        # - no custom env is explicitly set by a test
+        # PYTHONPATH will leak into the spawned processes.
+        # In that case tests look for module in the wrong place (on PYTHONPATH).
+        # Unless the test sets its own special env, pass a copy of the existing
+        # environment with removed PYTHONPATH to the subprocesses.
+        if "env" not in kwargs:
+            env = dict(os.environ)
+            if "PYTHONPATH" in env:
+                del env["PYTHONPATH"]
+            kwargs["env"] = env
+        return subprocess.check_output(cmd, *args, **kwargs)
+
+
+def _which_dirs(cmd):
+    result = set()
+    for path in os.environ.get('PATH', '').split(os.pathsep):
+        filename = os.path.join(path, cmd)
+        if os.access(filename, os.X_OK):
+            result.add(path)
+    return result
+
+
+def run_setup_py(cmd, pypath=None, path=None, data_stream=0, env=None):
+    """
+    Execution command for tests, separate from those used by the
+    code directly to prevent accidental behavior issues
+    """
+    if env is None:
+        env = dict()
+        for envname in os.environ:
+            env[envname] = os.environ[envname]
+
+    # override the python path if needed
+    if pypath is not None:
+        env["PYTHONPATH"] = pypath
+
+    # override the execution path if needed
+    if path is not None:
+        env["PATH"] = path
+    if not env.get("PATH", ""):
+        env["PATH"] = _which_dirs("tar").union(_which_dirs("gzip"))
+        env["PATH"] = os.pathsep.join(env["PATH"])
+
+    cmd = [sys.executable, "setup.py"] + list(cmd)
+
+    # https://bugs.python.org/issue8557
+    shell = sys.platform == 'win32'
+
+    try:
+        proc = _Popen(
+            cmd,
+            stdout=_PIPE,
+            stderr=_PIPE,
+            shell=shell,
+            env=env,
+            encoding="utf-8",
+        )
+
+        if isinstance(data_stream, tuple):
+            data_stream = slice(*data_stream)
+        data = proc.communicate()[data_stream]
+    except OSError:
+        return 1, ''
+
+    # decode the console string if needed
+    if hasattr(data, "decode"):
+        # use the default encoding
+        data = data.decode()
+        data = unicodedata.normalize('NFC', data)
+
+    # communicate calls wait()
+    return proc.returncode, data
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/tests/fixtures.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/tests/fixtures.py
new file mode 100644
index 0000000000000000000000000000000000000000..a5472984b5690572285a84575f6c2d598f06dd11
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/tests/fixtures.py
@@ -0,0 +1,157 @@
+import contextlib
+import os
+import subprocess
+import sys
+from pathlib import Path
+
+import path
+import pytest
+
+from . import contexts, environment
+
+
+@pytest.fixture
+def user_override(monkeypatch):
+    """
+    Override site.USER_BASE and site.USER_SITE with temporary directories in
+    a context.
+    """
+    with contexts.tempdir() as user_base:
+        monkeypatch.setattr('site.USER_BASE', user_base)
+        with contexts.tempdir() as user_site:
+            monkeypatch.setattr('site.USER_SITE', user_site)
+            with contexts.save_user_site_setting():
+                yield
+
+
+@pytest.fixture
+def tmpdir_cwd(tmpdir):
+    with tmpdir.as_cwd() as orig:
+        yield orig
+
+
+@pytest.fixture(autouse=True, scope="session")
+def workaround_xdist_376(request):
+    """
+    Workaround pytest-dev/pytest-xdist#376
+
+    ``pytest-xdist`` tends to inject '' into ``sys.path``,
+    which may break certain isolation expectations.
+    Remove the entry so the import
+    machinery behaves the same irrespective of xdist.
+    """
+    if not request.config.pluginmanager.has_plugin('xdist'):
+        return
+
+    with contextlib.suppress(ValueError):
+        sys.path.remove('')
+
+
+@pytest.fixture
+def sample_project(tmp_path):
+    """
+    Clone the 'sampleproject' and return a path to it.
+    """
+    cmd = ['git', 'clone', 'https://github.com/pypa/sampleproject']
+    try:
+        subprocess.check_call(cmd, cwd=str(tmp_path))
+    except Exception:
+        pytest.skip("Unable to clone sampleproject")
+    return tmp_path / 'sampleproject'
+
+
+# sdist and wheel artifacts should be stable across a round of tests
+# so we can build them once per session and use the files as "readonly"
+
+# In the case of setuptools, building the wheel without sdist may cause
+# it to contain the `build` directory, and therefore create situations with
+# `setuptools/build/lib/build/lib/...`. To avoid that, build both artifacts at once.
+
+
+def _build_distributions(tmp_path_factory, request):
+    with contexts.session_locked_tmp_dir(
+        request, tmp_path_factory, "dist_build"
+    ) as tmp:  # pragma: no cover
+        sdist = next(tmp.glob("*.tar.gz"), None)
+        wheel = next(tmp.glob("*.whl"), None)
+        if sdist and wheel:
+            return (sdist, wheel)
+
+        # Sanity check: should not create recursive setuptools/build/lib/build/lib/...
+        assert not Path(request.config.rootdir, "build/lib/build").exists()
+
+        subprocess.check_output([
+            sys.executable,
+            "-m",
+            "build",
+            "--outdir",
+            str(tmp),
+            str(request.config.rootdir),
+        ])
+
+        # Sanity check: should not create recursive setuptools/build/lib/build/lib/...
+        assert not Path(request.config.rootdir, "build/lib/build").exists()
+
+        return next(tmp.glob("*.tar.gz")), next(tmp.glob("*.whl"))
+
+
+@pytest.fixture(scope="session")
+def setuptools_sdist(tmp_path_factory, request):
+    prebuilt = os.getenv("PRE_BUILT_SETUPTOOLS_SDIST")
+    if prebuilt and os.path.exists(prebuilt):  # pragma: no cover
+        return Path(prebuilt).resolve()
+
+    sdist, _ = _build_distributions(tmp_path_factory, request)
+    return sdist
+
+
+@pytest.fixture(scope="session")
+def setuptools_wheel(tmp_path_factory, request):
+    prebuilt = os.getenv("PRE_BUILT_SETUPTOOLS_WHEEL")
+    if prebuilt and os.path.exists(prebuilt):  # pragma: no cover
+        return Path(prebuilt).resolve()
+
+    _, wheel = _build_distributions(tmp_path_factory, request)
+    return wheel
+
+
+@pytest.fixture
+def venv(tmp_path, setuptools_wheel):
+    """Virtual env with the version of setuptools under test installed"""
+    env = environment.VirtualEnv()
+    env.root = path.Path(tmp_path / 'venv')
+    env.create_opts = ['--no-setuptools', '--wheel=bundle']
+    # TODO: Use `--no-wheel` when setuptools implements its own bdist_wheel
+    env.req = str(setuptools_wheel)
+    # In some environments (eg. downstream distro packaging),
+    # where tox isn't used to run tests and PYTHONPATH is set to point to
+    # a specific setuptools codebase, PYTHONPATH will leak into the spawned
+    # processes.
+    # env.create() should install the just created setuptools
+    # wheel, but it doesn't if it finds another existing matching setuptools
+    # installation present on PYTHONPATH:
+    # `setuptools is already installed with the same version as the provided
+    # wheel. Use --force-reinstall to force an installation of the wheel.`
+    # This prevents leaking PYTHONPATH to the created environment.
+    with contexts.environment(PYTHONPATH=None):
+        return env.create()
+
+
+@pytest.fixture
+def venv_without_setuptools(tmp_path):
+    """Virtual env without any version of setuptools installed"""
+    env = environment.VirtualEnv()
+    env.root = path.Path(tmp_path / 'venv_without_setuptools')
+    env.create_opts = ['--no-setuptools', '--no-wheel']
+    env.ensure_env()
+    return env
+
+
+@pytest.fixture
+def bare_venv(tmp_path):
+    """Virtual env without any common packages installed"""
+    env = environment.VirtualEnv()
+    env.root = path.Path(tmp_path / 'bare_venv')
+    env.create_opts = ['--no-setuptools', '--no-pip', '--no-wheel', '--no-seed']
+    env.ensure_env()
+    return env
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/tests/mod_with_constant.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/tests/mod_with_constant.py
new file mode 100644
index 0000000000000000000000000000000000000000..ef755dd1c7a8d1f116fe51f1b43315057f03379d
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/tests/mod_with_constant.py
@@ -0,0 +1 @@
+value = 'three, sir!'
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/tests/namespaces.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/tests/namespaces.py
new file mode 100644
index 0000000000000000000000000000000000000000..248db98f97951aeeee0222131417e73074cc72d2
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/tests/namespaces.py
@@ -0,0 +1,90 @@
+import ast
+import json
+import textwrap
+from pathlib import Path
+
+
+def iter_namespace_pkgs(namespace):
+    parts = namespace.split(".")
+    for i in range(len(parts)):
+        yield ".".join(parts[: i + 1])
+
+
+def build_namespace_package(tmpdir, name, version="1.0", impl="pkg_resources"):
+    src_dir = tmpdir / name
+    src_dir.mkdir()
+    setup_py = src_dir / 'setup.py'
+    namespace, _, rest = name.rpartition('.')
+    namespaces = list(iter_namespace_pkgs(namespace))
+    setup_args = {
+        "name": name,
+        "version": version,
+        "packages": namespaces,
+    }
+
+    if impl == "pkg_resources":
+        tmpl = '__import__("pkg_resources").declare_namespace(__name__)'
+        setup_args["namespace_packages"] = namespaces
+    elif impl == "pkgutil":
+        tmpl = '__path__ = __import__("pkgutil").extend_path(__path__, __name__)'
+    else:
+        raise ValueError(f"Cannot recognise {impl=} when creating namespaces")
+
+    args = json.dumps(setup_args, indent=4)
+    assert ast.literal_eval(args)  # ensure it is valid Python
+
+    script = textwrap.dedent(
+        """\
+        import setuptools
+        args = {args}
+        setuptools.setup(**args)
+        """
+    ).format(args=args)
+    setup_py.write_text(script, encoding='utf-8')
+
+    ns_pkg_dir = Path(src_dir, namespace.replace(".", "/"))
+    ns_pkg_dir.mkdir(parents=True)
+
+    for ns in namespaces:
+        pkg_init = src_dir / ns.replace(".", "/") / '__init__.py'
+        pkg_init.write_text(tmpl, encoding='utf-8')
+
+    pkg_mod = ns_pkg_dir / (rest + '.py')
+    some_functionality = 'name = {rest!r}'.format(**locals())
+    pkg_mod.write_text(some_functionality, encoding='utf-8')
+    return src_dir
+
+
+def build_pep420_namespace_package(tmpdir, name):
+    src_dir = tmpdir / name
+    src_dir.mkdir()
+    pyproject = src_dir / "pyproject.toml"
+    namespace, _, rest = name.rpartition(".")
+    script = f"""\
+        [build-system]
+        requires = ["setuptools"]
+        build-backend = "setuptools.build_meta"
+
+        [project]
+        name = "{name}"
+        version = "3.14159"
+        """
+    pyproject.write_text(textwrap.dedent(script), encoding='utf-8')
+    ns_pkg_dir = Path(src_dir, namespace.replace(".", "/"))
+    ns_pkg_dir.mkdir(parents=True)
+    pkg_mod = ns_pkg_dir / (rest + ".py")
+    some_functionality = f"name = {rest!r}"
+    pkg_mod.write_text(some_functionality, encoding='utf-8')
+    return src_dir
+
+
+def make_site_dir(target):
+    """
+    Add a sitecustomize.py module in target to cause
+    target to be added to site dirs such that .pth files
+    are processed there.
+    """
+    sc = target / 'sitecustomize.py'
+    target_str = str(target)
+    tmpl = '__import__("site").addsitedir({target_str!r})'
+    sc.write_text(tmpl.format(**locals()), encoding='utf-8')
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/tests/script-with-bom.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/tests/script-with-bom.py
new file mode 100644
index 0000000000000000000000000000000000000000..c074d263c45bcaebe32fdba328d975c73d1ad5ca
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/tests/script-with-bom.py
@@ -0,0 +1 @@
+result = 'passed'
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/tests/server.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/tests/server.py
new file mode 100644
index 0000000000000000000000000000000000000000..623a49a550f161f117d3af2173f91a2af260181d
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/tests/server.py
@@ -0,0 +1,86 @@
+"""Basic http server for tests to simulate PyPI or custom indexes"""
+
+import http.server
+import os
+import threading
+import time
+import urllib.parse
+import urllib.request
+
+
+class IndexServer(http.server.HTTPServer):
+    """Basic single-threaded http server simulating a package index
+
+    You can use this server in unittest like this::
+        s = IndexServer()
+        s.start()
+        index_url = s.base_url() + 'mytestindex'
+        # do some test requests to the index
+        # The index files should be located in setuptools/tests/indexes
+        s.stop()
+    """
+
+    def __init__(
+        self,
+        server_address=('', 0),
+        RequestHandlerClass=http.server.SimpleHTTPRequestHandler,
+    ):
+        http.server.HTTPServer.__init__(self, server_address, RequestHandlerClass)
+        self._run = True
+
+    def start(self):
+        self.thread = threading.Thread(target=self.serve_forever)
+        self.thread.start()
+
+    def stop(self):
+        "Stop the server"
+
+        # Let the server finish the last request and wait for a new one.
+        time.sleep(0.1)
+
+        self.shutdown()
+        self.thread.join()
+        self.socket.close()
+
+    def base_url(self):
+        port = self.server_port
+        return f'http://127.0.0.1:{port}/setuptools/tests/indexes/'
+
+
+class RequestRecorder(http.server.BaseHTTPRequestHandler):
+    def do_GET(self):
+        requests = vars(self.server).setdefault('requests', [])
+        requests.append(self)
+        self.send_response(200, 'OK')
+
+
+class MockServer(http.server.HTTPServer, threading.Thread):
+    """
+    A simple HTTP Server that records the requests made to it.
+    """
+
+    def __init__(self, server_address=('', 0), RequestHandlerClass=RequestRecorder):
+        http.server.HTTPServer.__init__(self, server_address, RequestHandlerClass)
+        threading.Thread.__init__(self)
+        self.daemon = True
+        self.requests = []
+
+    def run(self):
+        self.serve_forever()
+
+    @property
+    def netloc(self):
+        return f'localhost:{self.server_port}'
+
+    @property
+    def url(self):
+        return f'http://{self.netloc}/'
+
+
+def path_to_url(path, authority=None):
+    """Convert a path to a file: URL."""
+    path = os.path.normpath(os.path.abspath(path))
+    base = 'file:'
+    if authority is not None:
+        base += '//' + authority
+    return urllib.parse.urljoin(base, urllib.request.pathname2url(path))
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/tests/test_archive_util.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/tests/test_archive_util.py
new file mode 100644
index 0000000000000000000000000000000000000000..e3efc62889994fa68bc9170e8a0e403f48a204e1
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/tests/test_archive_util.py
@@ -0,0 +1,36 @@
+import io
+import tarfile
+
+import pytest
+
+from setuptools import archive_util
+
+
+@pytest.fixture
+def tarfile_with_unicode(tmpdir):
+    """
+    Create a tarfile containing only a file whose name is
+    a zero byte file called testimäge.png.
+    """
+    tarobj = io.BytesIO()
+
+    with tarfile.open(fileobj=tarobj, mode="w:gz") as tgz:
+        data = b""
+
+        filename = "testimäge.png"
+
+        t = tarfile.TarInfo(filename)
+        t.size = len(data)
+
+        tgz.addfile(t, io.BytesIO(data))
+
+    target = tmpdir / 'unicode-pkg-1.0.tar.gz'
+    with open(str(target), mode='wb') as tf:
+        tf.write(tarobj.getvalue())
+    return str(target)
+
+
+@pytest.mark.xfail(reason="#710 and #712")
+def test_unicode_files(tarfile_with_unicode, tmpdir):
+    target = tmpdir / 'out'
+    archive_util.unpack_archive(tarfile_with_unicode, str(target))
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/tests/test_bdist_deprecations.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/tests/test_bdist_deprecations.py
new file mode 100644
index 0000000000000000000000000000000000000000..d9d67b06161a2b36e7b15fab09f797c5c15575c2
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/tests/test_bdist_deprecations.py
@@ -0,0 +1,28 @@
+"""develop tests"""
+
+import sys
+from unittest import mock
+
+import pytest
+
+from setuptools import SetuptoolsDeprecationWarning
+from setuptools.dist import Distribution
+
+
+@pytest.mark.skipif(sys.platform == 'win32', reason='non-Windows only')
+@pytest.mark.xfail(reason="bdist_rpm is long deprecated, should we remove it? #1988")
+@mock.patch('distutils.command.bdist_rpm.bdist_rpm')
+def test_bdist_rpm_warning(distutils_cmd, tmpdir_cwd):
+    dist = Distribution(
+        dict(
+            script_name='setup.py',
+            script_args=['bdist_rpm'],
+            name='foo',
+            py_modules=['hi'],
+        )
+    )
+    dist.parse_command_line()
+    with pytest.warns(SetuptoolsDeprecationWarning):
+        dist.run_commands()
+
+    distutils_cmd.run.assert_called_once()
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/tests/test_bdist_egg.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/tests/test_bdist_egg.py
new file mode 100644
index 0000000000000000000000000000000000000000..036167dd951e70ad543775529d5ce3f6d6544c71
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/tests/test_bdist_egg.py
@@ -0,0 +1,73 @@
+"""develop tests"""
+
+import os
+import re
+import zipfile
+
+import pytest
+
+from setuptools.dist import Distribution
+
+from . import contexts
+
+SETUP_PY = """\
+from setuptools import setup
+
+setup(py_modules=['hi'])
+"""
+
+
+@pytest.fixture
+def setup_context(tmpdir):
+    with (tmpdir / 'setup.py').open('w') as f:
+        f.write(SETUP_PY)
+    with (tmpdir / 'hi.py').open('w') as f:
+        f.write('1\n')
+    with tmpdir.as_cwd():
+        yield tmpdir
+
+
+class Test:
+    @pytest.mark.usefixtures("user_override")
+    @pytest.mark.usefixtures("setup_context")
+    def test_bdist_egg(self):
+        dist = Distribution(
+            dict(
+                script_name='setup.py',
+                script_args=['bdist_egg'],
+                name='foo',
+                py_modules=['hi'],
+            )
+        )
+        os.makedirs(os.path.join('build', 'src'))
+        with contexts.quiet():
+            dist.parse_command_line()
+            dist.run_commands()
+
+        # let's see if we got our egg link at the right place
+        [content] = os.listdir('dist')
+        assert re.match(r'foo-0.0.0-py[23].\d+.egg$', content)
+
+    @pytest.mark.xfail(
+        os.environ.get('PYTHONDONTWRITEBYTECODE', False),
+        reason="Byte code disabled",
+    )
+    @pytest.mark.usefixtures("user_override")
+    @pytest.mark.usefixtures("setup_context")
+    def test_exclude_source_files(self):
+        dist = Distribution(
+            dict(
+                script_name='setup.py',
+                script_args=['bdist_egg', '--exclude-source-files'],
+                py_modules=['hi'],
+            )
+        )
+        with contexts.quiet():
+            dist.parse_command_line()
+            dist.run_commands()
+        [dist_name] = os.listdir('dist')
+        dist_filename = os.path.join('dist', dist_name)
+        zip = zipfile.ZipFile(dist_filename)
+        names = list(zi.filename for zi in zip.filelist)
+        assert 'hi.pyc' in names
+        assert 'hi.py' not in names
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/tests/test_bdist_wheel.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/tests/test_bdist_wheel.py
new file mode 100644
index 0000000000000000000000000000000000000000..2ab4e9cfc6cf0d930b3ceeececcce10cfe91a687
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/tests/test_bdist_wheel.py
@@ -0,0 +1,708 @@
+from __future__ import annotations
+
+import builtins
+import importlib
+import os.path
+import platform
+import shutil
+import stat
+import struct
+import sys
+import sysconfig
+from contextlib import suppress
+from inspect import cleandoc
+from zipfile import ZipFile
+
+import jaraco.path
+import pytest
+from packaging import tags
+
+import setuptools
+from setuptools.command.bdist_wheel import bdist_wheel, get_abi_tag
+from setuptools.dist import Distribution
+from setuptools.warnings import SetuptoolsDeprecationWarning
+
+from distutils.core import run_setup
+
+DEFAULT_FILES = {
+    "dummy_dist-1.0.dist-info/top_level.txt",
+    "dummy_dist-1.0.dist-info/METADATA",
+    "dummy_dist-1.0.dist-info/WHEEL",
+    "dummy_dist-1.0.dist-info/RECORD",
+}
+DEFAULT_LICENSE_FILES = {
+    "LICENSE",
+    "LICENSE.txt",
+    "LICENCE",
+    "LICENCE.txt",
+    "COPYING",
+    "COPYING.md",
+    "NOTICE",
+    "NOTICE.rst",
+    "AUTHORS",
+    "AUTHORS.txt",
+}
+OTHER_IGNORED_FILES = {
+    "LICENSE~",
+    "AUTHORS~",
+}
+SETUPPY_EXAMPLE = """\
+from setuptools import setup
+
+setup(
+    name='dummy_dist',
+    version='1.0',
+)
+"""
+
+
+EXAMPLES = {
+    "dummy-dist": {
+        "setup.py": SETUPPY_EXAMPLE,
+        "licenses_dir": {"DUMMYFILE": ""},
+        **dict.fromkeys(DEFAULT_LICENSE_FILES | OTHER_IGNORED_FILES, ""),
+    },
+    "simple-dist": {
+        "setup.py": cleandoc(
+            """
+            from setuptools import setup
+
+            setup(
+                name="simple.dist",
+                version="0.1",
+                description="A testing distribution \N{SNOWMAN}",
+                extras_require={"voting": ["beaglevote"]},
+            )
+            """
+        ),
+        "simpledist": "",
+    },
+    "complex-dist": {
+        "setup.py": cleandoc(
+            """
+            from setuptools import setup
+
+            setup(
+                name="complex-dist",
+                version="0.1",
+                description="Another testing distribution \N{SNOWMAN}",
+                long_description="Another testing distribution \N{SNOWMAN}",
+                author="Illustrious Author",
+                author_email="illustrious@example.org",
+                url="http://example.org/exemplary",
+                packages=["complexdist"],
+                setup_requires=["setuptools"],
+                install_requires=["quux", "splort"],
+                extras_require={"simple": ["simple.dist"]},
+                entry_points={
+                    "console_scripts": [
+                        "complex-dist=complexdist:main",
+                        "complex-dist2=complexdist:main",
+                    ],
+                },
+            )
+            """
+        ),
+        "complexdist": {"__init__.py": "def main(): return"},
+    },
+    "headers-dist": {
+        "setup.py": cleandoc(
+            """
+            from setuptools import setup
+
+            setup(
+                name="headers.dist",
+                version="0.1",
+                description="A distribution with headers",
+                headers=["header.h"],
+            )
+            """
+        ),
+        "headersdist.py": "",
+        "header.h": "",
+    },
+    "commasinfilenames-dist": {
+        "setup.py": cleandoc(
+            """
+            from setuptools import setup
+
+            setup(
+                name="testrepo",
+                version="0.1",
+                packages=["mypackage"],
+                description="A test package with commas in file names",
+                include_package_data=True,
+                package_data={"mypackage.data": ["*"]},
+            )
+            """
+        ),
+        "mypackage": {
+            "__init__.py": "",
+            "data": {"__init__.py": "", "1,2,3.txt": ""},
+        },
+        "testrepo-0.1.0": {
+            "mypackage": {"__init__.py": ""},
+        },
+    },
+    "unicode-dist": {
+        "setup.py": cleandoc(
+            """
+            from setuptools import setup
+
+            setup(
+                name="unicode.dist",
+                version="0.1",
+                description="A testing distribution \N{SNOWMAN}",
+                packages=["unicodedist"],
+                zip_safe=True,
+            )
+            """
+        ),
+        "unicodedist": {"__init__.py": "", "åäö_日本語.py": ""},
+    },
+    "utf8-metadata-dist": {
+        "setup.cfg": cleandoc(
+            """
+            [metadata]
+            name = utf8-metadata-dist
+            version = 42
+            author_email = "John X. Ãørçeč" <john@utf8.org>, Γαμα קּ 東 <gama@utf8.org>
+            long_description = file: README.rst
+            """
+        ),
+        "README.rst": "UTF-8 描述 説明",
+    },
+    "licenses-dist": {
+        "setup.cfg": cleandoc(
+            """
+            [metadata]
+            name = licenses-dist
+            version = 1.0
+            license_files = **/LICENSE
+            """
+        ),
+        "LICENSE": "",
+        "src": {
+            "vendor": {"LICENSE": ""},
+        },
+    },
+}
+
+
+if sys.platform != "win32":
+    # ABI3 extensions don't really work on Windows
+    EXAMPLES["abi3extension-dist"] = {
+        "setup.py": cleandoc(
+            """
+            from setuptools import Extension, setup
+
+            setup(
+                name="extension.dist",
+                version="0.1",
+                description="A testing distribution \N{SNOWMAN}",
+                ext_modules=[
+                    Extension(
+                        name="extension", sources=["extension.c"], py_limited_api=True
+                    )
+                ],
+            )
+            """
+        ),
+        "setup.cfg": "[bdist_wheel]\npy_limited_api=cp32",
+        "extension.c": "#define Py_LIMITED_API 0x03020000\n#include <Python.h>",
+    }
+
+
+def bdist_wheel_cmd(**kwargs):
+    """Run command in the same process so that it is easier to collect coverage"""
+    dist_obj = (
+        run_setup("setup.py", stop_after="init")
+        if os.path.exists("setup.py")
+        else Distribution({"script_name": "%%build_meta%%"})
+    )
+    dist_obj.parse_config_files()
+    cmd = bdist_wheel(dist_obj)
+    for attr, value in kwargs.items():
+        setattr(cmd, attr, value)
+    cmd.finalize_options()
+    return cmd
+
+
+def mkexample(tmp_path_factory, name):
+    basedir = tmp_path_factory.mktemp(name)
+    jaraco.path.build(EXAMPLES[name], prefix=str(basedir))
+    return basedir
+
+
+@pytest.fixture(scope="session")
+def wheel_paths(tmp_path_factory):
+    build_base = tmp_path_factory.mktemp("build")
+    dist_dir = tmp_path_factory.mktemp("dist")
+    for name in EXAMPLES:
+        example_dir = mkexample(tmp_path_factory, name)
+        build_dir = build_base / name
+        with jaraco.path.DirectoryStack().context(example_dir):
+            bdist_wheel_cmd(bdist_dir=str(build_dir), dist_dir=str(dist_dir)).run()
+
+    return sorted(str(fname) for fname in dist_dir.glob("*.whl"))
+
+
+@pytest.fixture
+def dummy_dist(tmp_path_factory):
+    return mkexample(tmp_path_factory, "dummy-dist")
+
+
+@pytest.fixture
+def licenses_dist(tmp_path_factory):
+    return mkexample(tmp_path_factory, "licenses-dist")
+
+
+def test_no_scripts(wheel_paths):
+    """Make sure entry point scripts are not generated."""
+    path = next(path for path in wheel_paths if "complex_dist" in path)
+    for entry in ZipFile(path).infolist():
+        assert ".data/scripts/" not in entry.filename
+
+
+def test_unicode_record(wheel_paths):
+    path = next(path for path in wheel_paths if "unicode_dist" in path)
+    with ZipFile(path) as zf:
+        record = zf.read("unicode_dist-0.1.dist-info/RECORD")
+
+    assert "åäö_日本語.py".encode() in record
+
+
+UTF8_PKG_INFO = """\
+Metadata-Version: 2.1
+Name: helloworld
+Version: 42
+Author-email: "John X. Ãørçeč" <john@utf8.org>, Γαμα קּ 東 <gama@utf8.org>
+
+
+UTF-8 描述 説明
+"""
+
+
+def test_preserve_unicode_metadata(monkeypatch, tmp_path):
+    monkeypatch.chdir(tmp_path)
+    egginfo = tmp_path / "dummy_dist.egg-info"
+    distinfo = tmp_path / "dummy_dist.dist-info"
+
+    egginfo.mkdir()
+    (egginfo / "PKG-INFO").write_text(UTF8_PKG_INFO, encoding="utf-8")
+    (egginfo / "dependency_links.txt").touch()
+
+    class simpler_bdist_wheel(bdist_wheel):
+        """Avoid messing with setuptools/distutils internals"""
+
+        def __init__(self):
+            pass
+
+        @property
+        def license_paths(self):
+            return []
+
+    cmd_obj = simpler_bdist_wheel()
+    cmd_obj.egg2dist(egginfo, distinfo)
+
+    metadata = (distinfo / "METADATA").read_text(encoding="utf-8")
+    assert 'Author-email: "John X. Ãørçeč"' in metadata
+    assert "Γαμα קּ 東 " in metadata
+    assert "UTF-8 描述 説明" in metadata
+
+
+def test_licenses_default(dummy_dist, monkeypatch, tmp_path):
+    monkeypatch.chdir(dummy_dist)
+    bdist_wheel_cmd(bdist_dir=str(tmp_path)).run()
+    with ZipFile("dist/dummy_dist-1.0-py3-none-any.whl") as wf:
+        license_files = {
+            "dummy_dist-1.0.dist-info/licenses/" + fname
+            for fname in DEFAULT_LICENSE_FILES
+        }
+        assert set(wf.namelist()) == DEFAULT_FILES | license_files
+
+
+def test_licenses_deprecated(dummy_dist, monkeypatch, tmp_path):
+    dummy_dist.joinpath("setup.cfg").write_text(
+        "[metadata]\nlicense_file=licenses_dir/DUMMYFILE", encoding="utf-8"
+    )
+    monkeypatch.chdir(dummy_dist)
+
+    bdist_wheel_cmd(bdist_dir=str(tmp_path)).run()
+
+    with ZipFile("dist/dummy_dist-1.0-py3-none-any.whl") as wf:
+        license_files = {"dummy_dist-1.0.dist-info/licenses/licenses_dir/DUMMYFILE"}
+        assert set(wf.namelist()) == DEFAULT_FILES | license_files
+
+
+@pytest.mark.parametrize(
+    ("config_file", "config"),
+    [
+        ("setup.cfg", "[metadata]\nlicense_files=licenses_dir/*\n  LICENSE"),
+        ("setup.cfg", "[metadata]\nlicense_files=licenses_dir/*, LICENSE"),
+        (
+            "setup.py",
+            SETUPPY_EXAMPLE.replace(
+                ")", "  license_files=['licenses_dir/DUMMYFILE', 'LICENSE'])"
+            ),
+        ),
+    ],
+)
+def test_licenses_override(dummy_dist, monkeypatch, tmp_path, config_file, config):
+    dummy_dist.joinpath(config_file).write_text(config, encoding="utf-8")
+    monkeypatch.chdir(dummy_dist)
+    bdist_wheel_cmd(bdist_dir=str(tmp_path)).run()
+    with ZipFile("dist/dummy_dist-1.0-py3-none-any.whl") as wf:
+        license_files = {
+            "dummy_dist-1.0.dist-info/licenses/" + fname
+            for fname in {"licenses_dir/DUMMYFILE", "LICENSE"}
+        }
+        assert set(wf.namelist()) == DEFAULT_FILES | license_files
+        metadata = wf.read("dummy_dist-1.0.dist-info/METADATA").decode("utf8")
+        assert "License-File: licenses_dir/DUMMYFILE" in metadata
+        assert "License-File: LICENSE" in metadata
+
+
+def test_licenses_preserve_folder_structure(licenses_dist, monkeypatch, tmp_path):
+    monkeypatch.chdir(licenses_dist)
+    bdist_wheel_cmd(bdist_dir=str(tmp_path)).run()
+    print(os.listdir("dist"))
+    with ZipFile("dist/licenses_dist-1.0-py3-none-any.whl") as wf:
+        default_files = {name.replace("dummy_", "licenses_") for name in DEFAULT_FILES}
+        license_files = {
+            "licenses_dist-1.0.dist-info/licenses/LICENSE",
+            "licenses_dist-1.0.dist-info/licenses/src/vendor/LICENSE",
+        }
+        assert set(wf.namelist()) == default_files | license_files
+        metadata = wf.read("licenses_dist-1.0.dist-info/METADATA").decode("utf8")
+        assert "License-File: src/vendor/LICENSE" in metadata
+        assert "License-File: LICENSE" in metadata
+
+
+def test_licenses_disabled(dummy_dist, monkeypatch, tmp_path):
+    dummy_dist.joinpath("setup.cfg").write_text(
+        "[metadata]\nlicense_files=\n", encoding="utf-8"
+    )
+    monkeypatch.chdir(dummy_dist)
+    bdist_wheel_cmd(bdist_dir=str(tmp_path)).run()
+    with ZipFile("dist/dummy_dist-1.0-py3-none-any.whl") as wf:
+        assert set(wf.namelist()) == DEFAULT_FILES
+
+
+def test_build_number(dummy_dist, monkeypatch, tmp_path):
+    monkeypatch.chdir(dummy_dist)
+    bdist_wheel_cmd(bdist_dir=str(tmp_path), build_number="2").run()
+    with ZipFile("dist/dummy_dist-1.0-2-py3-none-any.whl") as wf:
+        filenames = set(wf.namelist())
+        assert "dummy_dist-1.0.dist-info/RECORD" in filenames
+        assert "dummy_dist-1.0.dist-info/METADATA" in filenames
+
+
+def test_universal_deprecated(dummy_dist, monkeypatch, tmp_path):
+    monkeypatch.chdir(dummy_dist)
+    with pytest.warns(SetuptoolsDeprecationWarning, match=".*universal is deprecated"):
+        bdist_wheel_cmd(bdist_dir=str(tmp_path), universal=True).run()
+
+    # For now we still respect the option
+    assert os.path.exists("dist/dummy_dist-1.0-py2.py3-none-any.whl")
+
+
+EXTENSION_EXAMPLE = """\
+#include <Python.h>
+
+static PyMethodDef methods[] = {
+  { NULL, NULL, 0, NULL }
+};
+
+static struct PyModuleDef module_def = {
+  PyModuleDef_HEAD_INIT,
+  "extension",
+  "Dummy extension module",
+  -1,
+  methods
+};
+
+PyMODINIT_FUNC PyInit_extension(void) {
+  return PyModule_Create(&module_def);
+}
+"""
+EXTENSION_SETUPPY = """\
+from __future__ import annotations
+
+from setuptools import Extension, setup
+
+setup(
+    name="extension.dist",
+    version="0.1",
+    description="A testing distribution \N{SNOWMAN}",
+    ext_modules=[Extension(name="extension", sources=["extension.c"])],
+)
+"""
+
+
+@pytest.mark.filterwarnings(
+    "once:Config variable '.*' is unset.*, Python ABI tag may be incorrect"
+)
+def test_limited_abi(monkeypatch, tmp_path, tmp_path_factory):
+    """Test that building a binary wheel with the limited ABI works."""
+    source_dir = tmp_path_factory.mktemp("extension_dist")
+    (source_dir / "setup.py").write_text(EXTENSION_SETUPPY, encoding="utf-8")
+    (source_dir / "extension.c").write_text(EXTENSION_EXAMPLE, encoding="utf-8")
+    build_dir = tmp_path.joinpath("build")
+    dist_dir = tmp_path.joinpath("dist")
+    monkeypatch.chdir(source_dir)
+    bdist_wheel_cmd(bdist_dir=str(build_dir), dist_dir=str(dist_dir)).run()
+
+
+def test_build_from_readonly_tree(dummy_dist, monkeypatch, tmp_path):
+    basedir = str(tmp_path.joinpath("dummy"))
+    shutil.copytree(str(dummy_dist), basedir)
+    monkeypatch.chdir(basedir)
+
+    # Make the tree read-only
+    for root, _dirs, files in os.walk(basedir):
+        for fname in files:
+            os.chmod(os.path.join(root, fname), stat.S_IREAD)
+
+    bdist_wheel_cmd().run()
+
+
+@pytest.mark.parametrize(
+    ("option", "compress_type"),
+    list(bdist_wheel.supported_compressions.items()),
+    ids=list(bdist_wheel.supported_compressions),
+)
+def test_compression(dummy_dist, monkeypatch, tmp_path, option, compress_type):
+    monkeypatch.chdir(dummy_dist)
+    bdist_wheel_cmd(bdist_dir=str(tmp_path), compression=option).run()
+    with ZipFile("dist/dummy_dist-1.0-py3-none-any.whl") as wf:
+        filenames = set(wf.namelist())
+        assert "dummy_dist-1.0.dist-info/RECORD" in filenames
+        assert "dummy_dist-1.0.dist-info/METADATA" in filenames
+        for zinfo in wf.filelist:
+            assert zinfo.compress_type == compress_type
+
+
+def test_wheelfile_line_endings(wheel_paths):
+    for path in wheel_paths:
+        with ZipFile(path) as wf:
+            wheelfile = next(fn for fn in wf.filelist if fn.filename.endswith("WHEEL"))
+            wheelfile_contents = wf.read(wheelfile)
+            assert b"\r" not in wheelfile_contents
+
+
+def test_unix_epoch_timestamps(dummy_dist, monkeypatch, tmp_path):
+    monkeypatch.setenv("SOURCE_DATE_EPOCH", "0")
+    monkeypatch.chdir(dummy_dist)
+    bdist_wheel_cmd(bdist_dir=str(tmp_path), build_number="2a").run()
+    with ZipFile("dist/dummy_dist-1.0-2a-py3-none-any.whl") as wf:
+        for zinfo in wf.filelist:
+            assert zinfo.date_time >= (1980, 1, 1, 0, 0, 0)  # min epoch is used
+
+
+def test_get_abi_tag_windows(monkeypatch):
+    monkeypatch.setattr(tags, "interpreter_name", lambda: "cp")
+    monkeypatch.setattr(sysconfig, "get_config_var", lambda x: "cp313-win_amd64")
+    assert get_abi_tag() == "cp313"
+    monkeypatch.setattr(sys, "gettotalrefcount", lambda: 1, False)
+    assert get_abi_tag() == "cp313d"
+    monkeypatch.setattr(sysconfig, "get_config_var", lambda x: "cp313t-win_amd64")
+    assert get_abi_tag() == "cp313td"
+    monkeypatch.delattr(sys, "gettotalrefcount")
+    assert get_abi_tag() == "cp313t"
+
+
+def test_get_abi_tag_pypy_old(monkeypatch):
+    monkeypatch.setattr(tags, "interpreter_name", lambda: "pp")
+    monkeypatch.setattr(sysconfig, "get_config_var", lambda x: "pypy36-pp73")
+    assert get_abi_tag() == "pypy36_pp73"
+
+
+def test_get_abi_tag_pypy_new(monkeypatch):
+    monkeypatch.setattr(sysconfig, "get_config_var", lambda x: "pypy37-pp73-darwin")
+    monkeypatch.setattr(tags, "interpreter_name", lambda: "pp")
+    assert get_abi_tag() == "pypy37_pp73"
+
+
+def test_get_abi_tag_graalpy(monkeypatch):
+    monkeypatch.setattr(
+        sysconfig, "get_config_var", lambda x: "graalpy231-310-native-x86_64-linux"
+    )
+    monkeypatch.setattr(tags, "interpreter_name", lambda: "graalpy")
+    assert get_abi_tag() == "graalpy231_310_native"
+
+
+def test_get_abi_tag_fallback(monkeypatch):
+    monkeypatch.setattr(sysconfig, "get_config_var", lambda x: "unknown-python-310")
+    monkeypatch.setattr(tags, "interpreter_name", lambda: "unknown-python")
+    assert get_abi_tag() == "unknown_python_310"
+
+
+def test_platform_with_space(dummy_dist, monkeypatch):
+    """Ensure building on platforms with a space in the name succeed."""
+    monkeypatch.chdir(dummy_dist)
+    bdist_wheel_cmd(plat_name="isilon onefs").run()
+
+
+def test_data_dir_with_tag_build(monkeypatch, tmp_path):
+    """
+    Setuptools allow authors to set PEP 440's local version segments
+    using ``egg_info.tag_build``. This should be reflected not only in the
+    ``.whl`` file name, but also in the ``.dist-info`` and ``.data`` dirs.
+    See pypa/setuptools#3997.
+    """
+    monkeypatch.chdir(tmp_path)
+    files = {
+        "setup.py": """
+            from setuptools import setup
+            setup(headers=["hello.h"])
+            """,
+        "setup.cfg": """
+            [metadata]
+            name = test
+            version = 1.0
+
+            [options.data_files]
+            hello/world = file.txt
+
+            [egg_info]
+            tag_build = +what
+            tag_date = 0
+            """,
+        "file.txt": "",
+        "hello.h": "",
+    }
+    for file, content in files.items():
+        with open(file, "w", encoding="utf-8") as fh:
+            fh.write(cleandoc(content))
+
+    bdist_wheel_cmd().run()
+
+    # Ensure .whl, .dist-info and .data contain the local segment
+    wheel_path = "dist/test-1.0+what-py3-none-any.whl"
+    assert os.path.exists(wheel_path)
+    entries = set(ZipFile(wheel_path).namelist())
+    for expected in (
+        "test-1.0+what.data/headers/hello.h",
+        "test-1.0+what.data/data/hello/world/file.txt",
+        "test-1.0+what.dist-info/METADATA",
+        "test-1.0+what.dist-info/WHEEL",
+    ):
+        assert expected in entries
+
+    for not_expected in (
+        "test.data/headers/hello.h",
+        "test-1.0.data/data/hello/world/file.txt",
+        "test.dist-info/METADATA",
+        "test-1.0.dist-info/WHEEL",
+    ):
+        assert not_expected not in entries
+
+
+@pytest.mark.parametrize(
+    ("reported", "expected"),
+    [("linux-x86_64", "linux_i686"), ("linux-aarch64", "linux_armv7l")],
+)
+@pytest.mark.skipif(
+    platform.system() != "Linux", reason="Only makes sense to test on Linux"
+)
+def test_platform_linux32(reported, expected, monkeypatch):
+    monkeypatch.setattr(struct, "calcsize", lambda x: 4)
+    dist = setuptools.Distribution()
+    cmd = bdist_wheel(dist)
+    cmd.plat_name = reported
+    cmd.root_is_pure = False
+    _, _, actual = cmd.get_tag()
+    assert actual == expected
+
+
+def test_no_ctypes(monkeypatch) -> None:
+    def _fake_import(name: str, *args, **kwargs):
+        if name == "ctypes":
+            raise ModuleNotFoundError(f"No module named {name}")
+
+        return importlib.__import__(name, *args, **kwargs)
+
+    with suppress(KeyError):
+        monkeypatch.delitem(sys.modules, "wheel.macosx_libfile")
+
+    # Install an importer shim that refuses to load ctypes
+    monkeypatch.setattr(builtins, "__import__", _fake_import)
+    with pytest.raises(ModuleNotFoundError, match="No module named ctypes"):
+        import wheel.macosx_libfile  # noqa: F401
+
+    # Unload and reimport the bdist_wheel command module to make sure it won't try to
+    # import ctypes
+    monkeypatch.delitem(sys.modules, "setuptools.command.bdist_wheel")
+
+    import setuptools.command.bdist_wheel  # noqa: F401
+
+
+def test_dist_info_provided(dummy_dist, monkeypatch, tmp_path):
+    monkeypatch.chdir(dummy_dist)
+    distinfo = tmp_path / "dummy_dist.dist-info"
+
+    distinfo.mkdir()
+    (distinfo / "METADATA").write_text("name: helloworld", encoding="utf-8")
+
+    # We don't control the metadata. According to PEP-517, "The hook MAY also
+    # create other files inside this directory, and a build frontend MUST
+    # preserve".
+    (distinfo / "FOO").write_text("bar", encoding="utf-8")
+
+    bdist_wheel_cmd(bdist_dir=str(tmp_path), dist_info_dir=str(distinfo)).run()
+    expected = {
+        "dummy_dist-1.0.dist-info/FOO",
+        "dummy_dist-1.0.dist-info/RECORD",
+    }
+    with ZipFile("dist/dummy_dist-1.0-py3-none-any.whl") as wf:
+        files_found = set(wf.namelist())
+    # Check that all expected files are there.
+    assert expected - files_found == set()
+    # Make sure there is no accidental egg-info bleeding into the wheel.
+    assert not [path for path in files_found if 'egg-info' in str(path)]
+
+
+def test_allow_grace_period_parent_directory_license(monkeypatch, tmp_path):
+    # Motivation: https://github.com/pypa/setuptools/issues/4892
+    # TODO: Remove this test after deprecation period is over
+    files = {
+        "LICENSE.txt": "parent license",  # <---- the license files are outside
+        "NOTICE.txt": "parent notice",
+        "python": {
+            "pyproject.toml": cleandoc(
+                """
+                [project]
+                name = "test-proj"
+                dynamic = ["version"]      # <---- testing dynamic will not break
+                [tool.setuptools.dynamic]
+                version.file = "VERSION"
+                """
+            ),
+            "setup.cfg": cleandoc(
+                """
+                [metadata]
+                license_files =
+                  ../LICENSE.txt
+                  ../NOTICE.txt
+                """
+            ),
+            "VERSION": "42",
+        },
+    }
+    jaraco.path.build(files, prefix=str(tmp_path))
+    monkeypatch.chdir(tmp_path / "python")
+    msg = "Pattern '../.*.txt' cannot contain '..'"
+    with pytest.warns(SetuptoolsDeprecationWarning, match=msg):
+        bdist_wheel_cmd().run()
+    with ZipFile("dist/test_proj-42-py3-none-any.whl") as wf:
+        files_found = set(wf.namelist())
+        expected_files = {
+            "test_proj-42.dist-info/licenses/LICENSE.txt",
+            "test_proj-42.dist-info/licenses/NOTICE.txt",
+        }
+        assert expected_files <= files_found
+
+        metadata = wf.read("test_proj-42.dist-info/METADATA").decode("utf8")
+        assert "License-File: LICENSE.txt" in metadata
+        assert "License-File: NOTICE.txt" in metadata
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/tests/test_build.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/tests/test_build.py
new file mode 100644
index 0000000000000000000000000000000000000000..f0f1d9dcf21bafe9dc82a76d373b366ddeecfcec
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/tests/test_build.py
@@ -0,0 +1,33 @@
+from setuptools import Command
+from setuptools.command.build import build
+from setuptools.dist import Distribution
+
+
+def test_distribution_gives_setuptools_build_obj(tmpdir_cwd):
+    """
+    Check that the setuptools Distribution uses the
+    setuptools specific build object.
+    """
+
+    dist = Distribution(
+        dict(
+            script_name='setup.py',
+            script_args=['build'],
+            packages=[],
+            package_data={'': ['path/*']},
+        )
+    )
+    assert isinstance(dist.get_command_obj("build"), build)
+
+
+class Subcommand(Command):
+    """Dummy command to be used in tests"""
+
+    def initialize_options(self):
+        pass
+
+    def finalize_options(self):
+        pass
+
+    def run(self):
+        raise NotImplementedError("just to check if the command runs")
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/tests/test_build_clib.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/tests/test_build_clib.py
new file mode 100644
index 0000000000000000000000000000000000000000..b5315df4f6599cd376e628c0d74cb14129cd89b8
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/tests/test_build_clib.py
@@ -0,0 +1,84 @@
+import random
+from unittest import mock
+
+import pytest
+
+from setuptools.command.build_clib import build_clib
+from setuptools.dist import Distribution
+
+from distutils.errors import DistutilsSetupError
+
+
+class TestBuildCLib:
+    @mock.patch('setuptools.command.build_clib.newer_pairwise_group')
+    def test_build_libraries(self, mock_newer):
+        dist = Distribution()
+        cmd = build_clib(dist)
+
+        # this will be a long section, just making sure all
+        # exceptions are properly raised
+        libs = [('example', {'sources': 'broken.c'})]
+        with pytest.raises(DistutilsSetupError):
+            cmd.build_libraries(libs)
+
+        obj_deps = 'some_string'
+        libs = [('example', {'sources': ['source.c'], 'obj_deps': obj_deps})]
+        with pytest.raises(DistutilsSetupError):
+            cmd.build_libraries(libs)
+
+        obj_deps = {'': ''}
+        libs = [('example', {'sources': ['source.c'], 'obj_deps': obj_deps})]
+        with pytest.raises(DistutilsSetupError):
+            cmd.build_libraries(libs)
+
+        obj_deps = {'source.c': ''}
+        libs = [('example', {'sources': ['source.c'], 'obj_deps': obj_deps})]
+        with pytest.raises(DistutilsSetupError):
+            cmd.build_libraries(libs)
+
+        # with that out of the way, let's see if the crude dependency
+        # system works
+        cmd.compiler = mock.MagicMock(spec=cmd.compiler)
+        mock_newer.return_value = ([], [])
+
+        obj_deps = {'': ('global.h',), 'example.c': ('example.h',)}
+        libs = [('example', {'sources': ['example.c'], 'obj_deps': obj_deps})]
+
+        cmd.build_libraries(libs)
+        assert [['example.c', 'global.h', 'example.h']] in mock_newer.call_args[0]
+        assert not cmd.compiler.compile.called
+        assert cmd.compiler.create_static_lib.call_count == 1
+
+        # reset the call numbers so we can test again
+        cmd.compiler.reset_mock()
+
+        mock_newer.return_value = ''  # anything as long as it's not ([],[])
+        cmd.build_libraries(libs)
+        assert cmd.compiler.compile.call_count == 1
+        assert cmd.compiler.create_static_lib.call_count == 1
+
+    @mock.patch('setuptools.command.build_clib.newer_pairwise_group')
+    def test_build_libraries_reproducible(self, mock_newer):
+        dist = Distribution()
+        cmd = build_clib(dist)
+
+        # with that out of the way, let's see if the crude dependency
+        # system works
+        cmd.compiler = mock.MagicMock(spec=cmd.compiler)
+        mock_newer.return_value = ([], [])
+
+        original_sources = ['a-example.c', 'example.c']
+        sources = original_sources
+
+        obj_deps = {'': ('global.h',), 'example.c': ('example.h',)}
+        libs = [('example', {'sources': sources, 'obj_deps': obj_deps})]
+
+        cmd.build_libraries(libs)
+        computed_call_args = mock_newer.call_args[0]
+
+        while sources == original_sources:
+            sources = random.sample(original_sources, len(original_sources))
+        libs = [('example', {'sources': sources, 'obj_deps': obj_deps})]
+
+        cmd.build_libraries(libs)
+        assert computed_call_args == mock_newer.call_args[0]
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/tests/test_build_ext.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/tests/test_build_ext.py
new file mode 100644
index 0000000000000000000000000000000000000000..c7b60ac32fcd6628cf96396a7e5d8fdb50f67c19
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/tests/test_build_ext.py
@@ -0,0 +1,293 @@
+from __future__ import annotations
+
+import os
+import sys
+from importlib.util import cache_from_source as _compiled_file_name
+
+import pytest
+from jaraco import path
+
+from setuptools.command.build_ext import build_ext, get_abi3_suffix
+from setuptools.dist import Distribution
+from setuptools.errors import CompileError
+from setuptools.extension import Extension
+
+from . import environment
+from .textwrap import DALS
+
+import distutils.command.build_ext as orig
+from distutils.sysconfig import get_config_var
+
+IS_PYPY = '__pypy__' in sys.builtin_module_names
+
+
+class TestBuildExt:
+    def test_get_ext_filename(self):
+        """
+        Setuptools needs to give back the same
+        result as distutils, even if the fullname
+        is not in ext_map.
+        """
+        dist = Distribution()
+        cmd = build_ext(dist)
+        cmd.ext_map['foo/bar'] = ''
+        res = cmd.get_ext_filename('foo')
+        wanted = orig.build_ext.get_ext_filename(cmd, 'foo')
+        assert res == wanted
+
+    def test_abi3_filename(self):
+        """
+        Filename needs to be loadable by several versions
+        of Python 3 if 'is_abi3' is truthy on Extension()
+        """
+        print(get_abi3_suffix())
+
+        extension = Extension('spam.eggs', ['eggs.c'], py_limited_api=True)
+        dist = Distribution(dict(ext_modules=[extension]))
+        cmd = build_ext(dist)
+        cmd.finalize_options()
+        assert 'spam.eggs' in cmd.ext_map
+        res = cmd.get_ext_filename('spam.eggs')
+
+        if not get_abi3_suffix():
+            assert res.endswith(get_config_var('EXT_SUFFIX'))
+        elif sys.platform == 'win32':
+            assert res.endswith('eggs.pyd')
+        else:
+            assert 'abi3' in res
+
+    def test_ext_suffix_override(self):
+        """
+        SETUPTOOLS_EXT_SUFFIX variable always overrides
+        default extension options.
+        """
+        dist = Distribution()
+        cmd = build_ext(dist)
+        cmd.ext_map['for_abi3'] = ext = Extension(
+            'for_abi3',
+            ['s.c'],
+            # Override shouldn't affect abi3 modules
+            py_limited_api=True,
+        )
+        # Mock value needed to pass tests
+        ext._links_to_dynamic = False
+
+        if not IS_PYPY:
+            expect = cmd.get_ext_filename('for_abi3')
+        else:
+            # PyPy builds do not use ABI3 tag, so they will
+            # also get the overridden suffix.
+            expect = 'for_abi3.test-suffix'
+
+        try:
+            os.environ['SETUPTOOLS_EXT_SUFFIX'] = '.test-suffix'
+            res = cmd.get_ext_filename('normal')
+            assert 'normal.test-suffix' == res
+            res = cmd.get_ext_filename('for_abi3')
+            assert expect == res
+        finally:
+            del os.environ['SETUPTOOLS_EXT_SUFFIX']
+
+    def dist_with_example(self):
+        files = {
+            "src": {"mypkg": {"subpkg": {"ext2.c": ""}}},
+            "c-extensions": {"ext1": {"main.c": ""}},
+        }
+
+        ext1 = Extension("mypkg.ext1", ["c-extensions/ext1/main.c"])
+        ext2 = Extension("mypkg.subpkg.ext2", ["src/mypkg/subpkg/ext2.c"])
+        ext3 = Extension("ext3", ["c-extension/ext3.c"])
+
+        path.build(files)
+        return Distribution({
+            "script_name": "%test%",
+            "ext_modules": [ext1, ext2, ext3],
+            "package_dir": {"": "src"},
+        })
+
+    def test_get_outputs(self, tmpdir_cwd, monkeypatch):
+        monkeypatch.setenv('SETUPTOOLS_EXT_SUFFIX', '.mp3')  # make test OS-independent
+        monkeypatch.setattr('setuptools.command.build_ext.use_stubs', False)
+        dist = self.dist_with_example()
+
+        # Regular build: get_outputs not empty, but get_output_mappings is empty
+        build_ext = dist.get_command_obj("build_ext")
+        build_ext.editable_mode = False
+        build_ext.ensure_finalized()
+        build_lib = build_ext.build_lib.replace(os.sep, "/")
+        outputs = [x.replace(os.sep, "/") for x in build_ext.get_outputs()]
+        assert outputs == [
+            f"{build_lib}/ext3.mp3",
+            f"{build_lib}/mypkg/ext1.mp3",
+            f"{build_lib}/mypkg/subpkg/ext2.mp3",
+        ]
+        assert build_ext.get_output_mapping() == {}
+
+        # Editable build: get_output_mappings should contain everything in get_outputs
+        dist.reinitialize_command("build_ext")
+        build_ext.editable_mode = True
+        build_ext.ensure_finalized()
+        mapping = {
+            k.replace(os.sep, "/"): v.replace(os.sep, "/")
+            for k, v in build_ext.get_output_mapping().items()
+        }
+        assert mapping == {
+            f"{build_lib}/ext3.mp3": "src/ext3.mp3",
+            f"{build_lib}/mypkg/ext1.mp3": "src/mypkg/ext1.mp3",
+            f"{build_lib}/mypkg/subpkg/ext2.mp3": "src/mypkg/subpkg/ext2.mp3",
+        }
+
+    def test_get_output_mapping_with_stub(self, tmpdir_cwd, monkeypatch):
+        monkeypatch.setenv('SETUPTOOLS_EXT_SUFFIX', '.mp3')  # make test OS-independent
+        monkeypatch.setattr('setuptools.command.build_ext.use_stubs', True)
+        dist = self.dist_with_example()
+
+        # Editable build should create compiled stubs (.pyc files only, no .py)
+        build_ext = dist.get_command_obj("build_ext")
+        build_ext.editable_mode = True
+        build_ext.ensure_finalized()
+        for ext in build_ext.extensions:
+            monkeypatch.setattr(ext, "_needs_stub", True)
+
+        build_lib = build_ext.build_lib.replace(os.sep, "/")
+        mapping = {
+            k.replace(os.sep, "/"): v.replace(os.sep, "/")
+            for k, v in build_ext.get_output_mapping().items()
+        }
+
+        def C(file):
+            """Make it possible to do comparisons and tests in a OS-independent way"""
+            return _compiled_file_name(file).replace(os.sep, "/")
+
+        assert mapping == {
+            C(f"{build_lib}/ext3.py"): C("src/ext3.py"),
+            f"{build_lib}/ext3.mp3": "src/ext3.mp3",
+            C(f"{build_lib}/mypkg/ext1.py"): C("src/mypkg/ext1.py"),
+            f"{build_lib}/mypkg/ext1.mp3": "src/mypkg/ext1.mp3",
+            C(f"{build_lib}/mypkg/subpkg/ext2.py"): C("src/mypkg/subpkg/ext2.py"),
+            f"{build_lib}/mypkg/subpkg/ext2.mp3": "src/mypkg/subpkg/ext2.mp3",
+        }
+
+        # Ensure only the compiled stubs are present not the raw .py stub
+        assert f"{build_lib}/mypkg/ext1.py" not in mapping
+        assert f"{build_lib}/mypkg/subpkg/ext2.py" not in mapping
+
+        # Visualize what the cached stub files look like
+        example_stub = C(f"{build_lib}/mypkg/ext1.py")
+        assert example_stub in mapping
+        assert example_stub.startswith(f"{build_lib}/mypkg/__pycache__/ext1")
+        assert example_stub.endswith(".pyc")
+
+
+class TestBuildExtInplace:
+    def get_build_ext_cmd(self, optional: bool, **opts) -> build_ext:
+        files: dict[str, str | dict[str, dict[str, str]]] = {
+            "eggs.c": "#include missingheader.h\n",
+            ".build": {"lib": {}, "tmp": {}},
+        }
+        path.build(files)
+        extension = Extension('spam.eggs', ['eggs.c'], optional=optional)
+        dist = Distribution(dict(ext_modules=[extension]))
+        dist.script_name = 'setup.py'
+        cmd = build_ext(dist)
+        vars(cmd).update(build_lib=".build/lib", build_temp=".build/tmp", **opts)
+        cmd.ensure_finalized()
+        return cmd
+
+    def get_log_messages(self, caplog, capsys):
+        """
+        Historically, distutils "logged" by printing to sys.std*.
+        Later versions adopted the logging framework. Grab
+        messages regardless of how they were captured.
+        """
+        std = capsys.readouterr()
+        return std.out.splitlines() + std.err.splitlines() + caplog.messages
+
+    def test_optional(self, tmpdir_cwd, caplog, capsys):
+        """
+        If optional extensions fail to build, setuptools should show the error
+        in the logs but not fail to build
+        """
+        cmd = self.get_build_ext_cmd(optional=True, inplace=True)
+        cmd.run()
+        assert any(
+            'build_ext: building extension "spam.eggs" failed'
+            for msg in self.get_log_messages(caplog, capsys)
+        )
+        # No compile error exception should be raised
+
+    def test_non_optional(self, tmpdir_cwd):
+        # Non-optional extensions should raise an exception
+        cmd = self.get_build_ext_cmd(optional=False, inplace=True)
+        with pytest.raises(CompileError):
+            cmd.run()
+
+
+def test_build_ext_config_handling(tmpdir_cwd):
+    files = {
+        'setup.py': DALS(
+            """
+            from setuptools import Extension, setup
+            setup(
+                name='foo',
+                version='0.0.0',
+                ext_modules=[Extension('foo', ['foo.c'])],
+            )
+            """
+        ),
+        'foo.c': DALS(
+            """
+            #include "Python.h"
+
+            #if PY_MAJOR_VERSION >= 3
+
+            static struct PyModuleDef moduledef = {
+                    PyModuleDef_HEAD_INIT,
+                    "foo",
+                    NULL,
+                    0,
+                    NULL,
+                    NULL,
+                    NULL,
+                    NULL,
+                    NULL
+            };
+
+            #define INITERROR return NULL
+
+            PyMODINIT_FUNC PyInit_foo(void)
+
+            #else
+
+            #define INITERROR return
+
+            void initfoo(void)
+
+            #endif
+            {
+            #if PY_MAJOR_VERSION >= 3
+                PyObject *module = PyModule_Create(&moduledef);
+            #else
+                PyObject *module = Py_InitModule("extension", NULL);
+            #endif
+                if (module == NULL)
+                    INITERROR;
+            #if PY_MAJOR_VERSION >= 3
+                return module;
+            #endif
+            }
+            """
+        ),
+        'setup.cfg': DALS(
+            """
+            [build]
+            build_base = foo_build
+            """
+        ),
+    }
+    path.build(files)
+    code, (stdout, stderr) = environment.run_setup_py(
+        cmd=['build'],
+        data_stream=(0, 2),
+    )
+    assert code == 0, f'\nSTDOUT:\n{stdout}\nSTDERR:\n{stderr}'
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/tests/test_build_meta.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/tests/test_build_meta.py
new file mode 100644
index 0000000000000000000000000000000000000000..57162fd6afec0e3edd062232eec84b9bbb1fc26b
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/tests/test_build_meta.py
@@ -0,0 +1,959 @@
+import contextlib
+import importlib
+import os
+import re
+import shutil
+import signal
+import sys
+import tarfile
+import warnings
+from concurrent import futures
+from pathlib import Path
+from typing import Any, Callable
+from zipfile import ZipFile
+
+import pytest
+from jaraco import path
+from packaging.requirements import Requirement
+
+from setuptools.warnings import SetuptoolsDeprecationWarning
+
+from .textwrap import DALS
+
+SETUP_SCRIPT_STUB = "__import__('setuptools').setup()"
+
+
+TIMEOUT = int(os.getenv("TIMEOUT_BACKEND_TEST", "180"))  # in seconds
+IS_PYPY = '__pypy__' in sys.builtin_module_names
+
+
+pytestmark = pytest.mark.skipif(
+    sys.platform == "win32" and IS_PYPY,
+    reason="The combination of PyPy + Windows + pytest-xdist + ProcessPoolExecutor "
+    "is flaky and problematic",
+)
+
+
+class BuildBackendBase:
+    def __init__(self, cwd='.', env=None, backend_name='setuptools.build_meta'):
+        self.cwd = cwd
+        self.env = env or {}
+        self.backend_name = backend_name
+
+
+class BuildBackend(BuildBackendBase):
+    """PEP 517 Build Backend"""
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.pool = futures.ProcessPoolExecutor(max_workers=1)
+
+    def __getattr__(self, name: str) -> Callable[..., Any]:
+        """Handles arbitrary function invocations on the build backend."""
+
+        def method(*args, **kw):
+            root = os.path.abspath(self.cwd)
+            caller = BuildBackendCaller(root, self.env, self.backend_name)
+            pid = None
+            try:
+                pid = self.pool.submit(os.getpid).result(TIMEOUT)
+                return self.pool.submit(caller, name, *args, **kw).result(TIMEOUT)
+            except futures.TimeoutError:
+                self.pool.shutdown(wait=False)  # doesn't stop already running processes
+                self._kill(pid)
+                pytest.xfail(f"Backend did not respond before timeout ({TIMEOUT} s)")
+            except (futures.process.BrokenProcessPool, MemoryError, OSError):
+                if IS_PYPY:
+                    pytest.xfail("PyPy frequently fails tests with ProcessPoolExector")
+                raise
+
+        return method
+
+    def _kill(self, pid):
+        if pid is None:
+            return
+        with contextlib.suppress(ProcessLookupError, OSError):
+            os.kill(pid, signal.SIGTERM if os.name == "nt" else signal.SIGKILL)
+
+
+class BuildBackendCaller(BuildBackendBase):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+        (self.backend_name, _, self.backend_obj) = self.backend_name.partition(':')
+
+    def __call__(self, name, *args, **kw):
+        """Handles arbitrary function invocations on the build backend."""
+        os.chdir(self.cwd)
+        os.environ.update(self.env)
+        mod = importlib.import_module(self.backend_name)
+
+        if self.backend_obj:
+            backend = getattr(mod, self.backend_obj)
+        else:
+            backend = mod
+
+        return getattr(backend, name)(*args, **kw)
+
+
+defns = [
+    {  # simple setup.py script
+        'setup.py': DALS(
+            """
+            __import__('setuptools').setup(
+                name='foo',
+                version='0.0.0',
+                py_modules=['hello'],
+                setup_requires=['six'],
+            )
+            """
+        ),
+        'hello.py': DALS(
+            """
+            def run():
+                print('hello')
+            """
+        ),
+    },
+    {  # setup.py that relies on __name__
+        'setup.py': DALS(
+            """
+            assert __name__ == '__main__'
+            __import__('setuptools').setup(
+                name='foo',
+                version='0.0.0',
+                py_modules=['hello'],
+                setup_requires=['six'],
+            )
+            """
+        ),
+        'hello.py': DALS(
+            """
+            def run():
+                print('hello')
+            """
+        ),
+    },
+    {  # setup.py script that runs arbitrary code
+        'setup.py': DALS(
+            """
+            variable = True
+            def function():
+                return variable
+            assert variable
+            __import__('setuptools').setup(
+                name='foo',
+                version='0.0.0',
+                py_modules=['hello'],
+                setup_requires=['six'],
+            )
+            """
+        ),
+        'hello.py': DALS(
+            """
+            def run():
+                print('hello')
+            """
+        ),
+    },
+    {  # setup.py script that constructs temp files to be included in the distribution
+        'setup.py': DALS(
+            """
+            # Some packages construct files on the fly, include them in the package,
+            # and immediately remove them after `setup()` (e.g. pybind11==2.9.1).
+            # Therefore, we cannot use `distutils.core.run_setup(..., stop_after=...)`
+            # to obtain a distribution object first, and then run the distutils
+            # commands later, because these files will be removed in the meantime.
+
+            with open('world.py', 'w', encoding="utf-8") as f:
+                f.write('x = 42')
+
+            try:
+                __import__('setuptools').setup(
+                    name='foo',
+                    version='0.0.0',
+                    py_modules=['world'],
+                    setup_requires=['six'],
+                )
+            finally:
+                # Some packages will clean temporary files
+                __import__('os').unlink('world.py')
+            """
+        ),
+    },
+    {  # setup.cfg only
+        'setup.cfg': DALS(
+            """
+        [metadata]
+        name = foo
+        version = 0.0.0
+
+        [options]
+        py_modules=hello
+        setup_requires=six
+        """
+        ),
+        'hello.py': DALS(
+            """
+        def run():
+            print('hello')
+        """
+        ),
+    },
+    {  # setup.cfg and setup.py
+        'setup.cfg': DALS(
+            """
+        [metadata]
+        name = foo
+        version = 0.0.0
+
+        [options]
+        py_modules=hello
+        setup_requires=six
+        """
+        ),
+        'setup.py': "__import__('setuptools').setup()",
+        'hello.py': DALS(
+            """
+        def run():
+            print('hello')
+        """
+        ),
+    },
+]
+
+
+class TestBuildMetaBackend:
+    backend_name = 'setuptools.build_meta'
+
+    def get_build_backend(self):
+        return BuildBackend(backend_name=self.backend_name)
+
+    @pytest.fixture(params=defns)
+    def build_backend(self, tmpdir, request):
+        path.build(request.param, prefix=str(tmpdir))
+        with tmpdir.as_cwd():
+            yield self.get_build_backend()
+
+    def test_get_requires_for_build_wheel(self, build_backend):
+        actual = build_backend.get_requires_for_build_wheel()
+        expected = ['six']
+        assert sorted(actual) == sorted(expected)
+
+    def test_get_requires_for_build_sdist(self, build_backend):
+        actual = build_backend.get_requires_for_build_sdist()
+        expected = ['six']
+        assert sorted(actual) == sorted(expected)
+
+    def test_build_wheel(self, build_backend):
+        dist_dir = os.path.abspath('pip-wheel')
+        os.makedirs(dist_dir)
+        wheel_name = build_backend.build_wheel(dist_dir)
+
+        wheel_file = os.path.join(dist_dir, wheel_name)
+        assert os.path.isfile(wheel_file)
+
+        # Temporary files should be removed
+        assert not os.path.isfile('world.py')
+
+        with ZipFile(wheel_file) as zipfile:
+            wheel_contents = set(zipfile.namelist())
+
+        # Each one of the examples have a single module
+        # that should be included in the distribution
+        python_scripts = (f for f in wheel_contents if f.endswith('.py'))
+        modules = [f for f in python_scripts if not f.endswith('setup.py')]
+        assert len(modules) == 1
+
+    @pytest.mark.parametrize('build_type', ('wheel', 'sdist'))
+    def test_build_with_existing_file_present(self, build_type, tmpdir_cwd):
+        # Building a sdist/wheel should still succeed if there's
+        # already a sdist/wheel in the destination directory.
+        files = {
+            'setup.py': "from setuptools import setup\nsetup()",
+            'VERSION': "0.0.1",
+            'setup.cfg': DALS(
+                """
+                [metadata]
+                name = foo
+                version = file: VERSION
+                """
+            ),
+            'pyproject.toml': DALS(
+                """
+                [build-system]
+                requires = ["setuptools", "wheel"]
+                build-backend = "setuptools.build_meta"
+                """
+            ),
+        }
+
+        path.build(files)
+
+        dist_dir = os.path.abspath('preexisting-' + build_type)
+
+        build_backend = self.get_build_backend()
+        build_method = getattr(build_backend, 'build_' + build_type)
+
+        # Build a first sdist/wheel.
+        # Note: this also check the destination directory is
+        # successfully created if it does not exist already.
+        first_result = build_method(dist_dir)
+
+        # Change version.
+        with open("VERSION", "wt", encoding="utf-8") as version_file:
+            version_file.write("0.0.2")
+
+        # Build a *second* sdist/wheel.
+        second_result = build_method(dist_dir)
+
+        assert os.path.isfile(os.path.join(dist_dir, first_result))
+        assert first_result != second_result
+
+        # And if rebuilding the exact same sdist/wheel?
+        open(os.path.join(dist_dir, second_result), 'wb').close()
+        third_result = build_method(dist_dir)
+        assert third_result == second_result
+        assert os.path.getsize(os.path.join(dist_dir, third_result)) > 0
+
+    @pytest.mark.parametrize("setup_script", [None, SETUP_SCRIPT_STUB])
+    def test_build_with_pyproject_config(self, tmpdir, setup_script):
+        files = {
+            'pyproject.toml': DALS(
+                """
+                [build-system]
+                requires = ["setuptools", "wheel"]
+                build-backend = "setuptools.build_meta"
+
+                [project]
+                name = "foo"
+                license = {text = "MIT"}
+                description = "This is a Python package"
+                dynamic = ["version", "readme"]
+                classifiers = [
+                    "Development Status :: 5 - Production/Stable",
+                    "Intended Audience :: Developers"
+                ]
+                urls = {Homepage = "http://github.com"}
+                dependencies = [
+                    "appdirs",
+                ]
+
+                [project.optional-dependencies]
+                all = [
+                    "tomli>=1",
+                    "pyscaffold>=4,<5",
+                    'importlib; python_version == "2.6"',
+                ]
+
+                [project.scripts]
+                foo = "foo.cli:main"
+
+                [tool.setuptools]
+                zip-safe = false
+                package-dir = {"" = "src"}
+                packages = {find = {where = ["src"]}}
+                license-files = ["LICENSE*"]
+
+                [tool.setuptools.dynamic]
+                version = {attr = "foo.__version__"}
+                readme = {file = "README.rst"}
+
+                [tool.distutils.sdist]
+                formats = "gztar"
+                """
+            ),
+            "MANIFEST.in": DALS(
+                """
+                global-include *.py *.txt
+                global-exclude *.py[cod]
+                """
+            ),
+            "README.rst": "This is a ``README``",
+            "LICENSE.txt": "---- placeholder MIT license ----",
+            "src": {
+                "foo": {
+                    "__init__.py": "__version__ = '0.1'",
+                    "__init__.pyi": "__version__: str",
+                    "cli.py": "def main(): print('hello world')",
+                    "data.txt": "def main(): print('hello world')",
+                    "py.typed": "",
+                }
+            },
+        }
+        if setup_script:
+            files["setup.py"] = setup_script
+
+        build_backend = self.get_build_backend()
+        with tmpdir.as_cwd():
+            path.build(files)
+            msgs = [
+                "'tool.setuptools.license-files' is deprecated in favor of 'project.license-files'",
+                "`project.license` as a TOML table is deprecated",
+            ]
+            with warnings.catch_warnings():
+                for msg in msgs:
+                    warnings.filterwarnings("ignore", msg, SetuptoolsDeprecationWarning)
+                sdist_path = build_backend.build_sdist("temp")
+                wheel_file = build_backend.build_wheel("temp")
+
+        with tarfile.open(os.path.join(tmpdir, "temp", sdist_path)) as tar:
+            sdist_contents = set(tar.getnames())
+
+        with ZipFile(os.path.join(tmpdir, "temp", wheel_file)) as zipfile:
+            wheel_contents = set(zipfile.namelist())
+            metadata = str(zipfile.read("foo-0.1.dist-info/METADATA"), "utf-8")
+            license = str(
+                zipfile.read("foo-0.1.dist-info/licenses/LICENSE.txt"), "utf-8"
+            )
+            epoints = str(zipfile.read("foo-0.1.dist-info/entry_points.txt"), "utf-8")
+
+        assert sdist_contents - {"foo-0.1/setup.py"} == {
+            'foo-0.1',
+            'foo-0.1/LICENSE.txt',
+            'foo-0.1/MANIFEST.in',
+            'foo-0.1/PKG-INFO',
+            'foo-0.1/README.rst',
+            'foo-0.1/pyproject.toml',
+            'foo-0.1/setup.cfg',
+            'foo-0.1/src',
+            'foo-0.1/src/foo',
+            'foo-0.1/src/foo/__init__.py',
+            'foo-0.1/src/foo/__init__.pyi',
+            'foo-0.1/src/foo/cli.py',
+            'foo-0.1/src/foo/data.txt',
+            'foo-0.1/src/foo/py.typed',
+            'foo-0.1/src/foo.egg-info',
+            'foo-0.1/src/foo.egg-info/PKG-INFO',
+            'foo-0.1/src/foo.egg-info/SOURCES.txt',
+            'foo-0.1/src/foo.egg-info/dependency_links.txt',
+            'foo-0.1/src/foo.egg-info/entry_points.txt',
+            'foo-0.1/src/foo.egg-info/requires.txt',
+            'foo-0.1/src/foo.egg-info/top_level.txt',
+            'foo-0.1/src/foo.egg-info/not-zip-safe',
+        }
+        assert wheel_contents == {
+            "foo/__init__.py",
+            "foo/__init__.pyi",  # include type information by default
+            "foo/cli.py",
+            "foo/data.txt",  # include_package_data defaults to True
+            "foo/py.typed",  # include type information by default
+            "foo-0.1.dist-info/licenses/LICENSE.txt",
+            "foo-0.1.dist-info/METADATA",
+            "foo-0.1.dist-info/WHEEL",
+            "foo-0.1.dist-info/entry_points.txt",
+            "foo-0.1.dist-info/top_level.txt",
+            "foo-0.1.dist-info/RECORD",
+        }
+        assert license == "---- placeholder MIT license ----"
+
+        for line in (
+            "Summary: This is a Python package",
+            "License: MIT",
+            "License-File: LICENSE.txt",
+            "Classifier: Intended Audience :: Developers",
+            "Requires-Dist: appdirs",
+            "Requires-Dist: " + str(Requirement('tomli>=1 ; extra == "all"')),
+            "Requires-Dist: "
+            + str(Requirement('importlib; python_version=="2.6" and extra =="all"')),
+        ):
+            assert line in metadata, (line, metadata)
+
+        assert metadata.strip().endswith("This is a ``README``")
+        assert epoints.strip() == "[console_scripts]\nfoo = foo.cli:main"
+
+    def test_static_metadata_in_pyproject_config(self, tmpdir):
+        # Make sure static metadata in pyproject.toml is not overwritten by setup.py
+        # as required by PEP 621
+        files = {
+            'pyproject.toml': DALS(
+                """
+                [build-system]
+                requires = ["setuptools", "wheel"]
+                build-backend = "setuptools.build_meta"
+
+                [project]
+                name = "foo"
+                description = "This is a Python package"
+                version = "42"
+                dependencies = ["six"]
+                """
+            ),
+            'hello.py': DALS(
+                """
+                def run():
+                    print('hello')
+                """
+            ),
+            'setup.py': DALS(
+                """
+                __import__('setuptools').setup(
+                    name='bar',
+                    version='13',
+                )
+                """
+            ),
+        }
+        build_backend = self.get_build_backend()
+        with tmpdir.as_cwd():
+            path.build(files)
+            sdist_path = build_backend.build_sdist("temp")
+            wheel_file = build_backend.build_wheel("temp")
+
+        assert (tmpdir / "temp/foo-42.tar.gz").exists()
+        assert (tmpdir / "temp/foo-42-py3-none-any.whl").exists()
+        assert not (tmpdir / "temp/bar-13.tar.gz").exists()
+        assert not (tmpdir / "temp/bar-42.tar.gz").exists()
+        assert not (tmpdir / "temp/foo-13.tar.gz").exists()
+        assert not (tmpdir / "temp/bar-13-py3-none-any.whl").exists()
+        assert not (tmpdir / "temp/bar-42-py3-none-any.whl").exists()
+        assert not (tmpdir / "temp/foo-13-py3-none-any.whl").exists()
+
+        with tarfile.open(os.path.join(tmpdir, "temp", sdist_path)) as tar:
+            pkg_info = str(tar.extractfile('foo-42/PKG-INFO').read(), "utf-8")
+            members = tar.getnames()
+            assert "bar-13/PKG-INFO" not in members
+
+        with ZipFile(os.path.join(tmpdir, "temp", wheel_file)) as zipfile:
+            metadata = str(zipfile.read("foo-42.dist-info/METADATA"), "utf-8")
+            members = zipfile.namelist()
+            assert "bar-13.dist-info/METADATA" not in members
+
+        for file in pkg_info, metadata:
+            for line in ("Name: foo", "Version: 42"):
+                assert line in file
+            for line in ("Name: bar", "Version: 13"):
+                assert line not in file
+
+    def test_build_sdist(self, build_backend):
+        dist_dir = os.path.abspath('pip-sdist')
+        os.makedirs(dist_dir)
+        sdist_name = build_backend.build_sdist(dist_dir)
+
+        assert os.path.isfile(os.path.join(dist_dir, sdist_name))
+
+    def test_prepare_metadata_for_build_wheel(self, build_backend):
+        dist_dir = os.path.abspath('pip-dist-info')
+        os.makedirs(dist_dir)
+
+        dist_info = build_backend.prepare_metadata_for_build_wheel(dist_dir)
+
+        assert os.path.isfile(os.path.join(dist_dir, dist_info, 'METADATA'))
+
+    def test_prepare_metadata_inplace(self, build_backend):
+        """
+        Some users might pass metadata_directory pre-populated with `.tox` or `.venv`.
+        See issue #3523.
+        """
+        for pre_existing in [
+            ".tox/python/lib/python3.10/site-packages/attrs-22.1.0.dist-info",
+            ".tox/python/lib/python3.10/site-packages/autocommand-2.2.1.dist-info",
+            ".nox/python/lib/python3.10/site-packages/build-0.8.0.dist-info",
+            ".venv/python3.10/site-packages/click-8.1.3.dist-info",
+            "venv/python3.10/site-packages/distlib-0.3.5.dist-info",
+            "env/python3.10/site-packages/docutils-0.19.dist-info",
+        ]:
+            os.makedirs(pre_existing, exist_ok=True)
+        dist_info = build_backend.prepare_metadata_for_build_wheel(".")
+        assert os.path.isfile(os.path.join(dist_info, 'METADATA'))
+
+    def test_build_sdist_explicit_dist(self, build_backend):
+        # explicitly specifying the dist folder should work
+        # the folder sdist_directory and the ``--dist-dir`` can be the same
+        dist_dir = os.path.abspath('dist')
+        sdist_name = build_backend.build_sdist(dist_dir)
+        assert os.path.isfile(os.path.join(dist_dir, sdist_name))
+
+    def test_build_sdist_version_change(self, build_backend):
+        sdist_into_directory = os.path.abspath("out_sdist")
+        os.makedirs(sdist_into_directory)
+
+        sdist_name = build_backend.build_sdist(sdist_into_directory)
+        assert os.path.isfile(os.path.join(sdist_into_directory, sdist_name))
+
+        # if the setup.py changes subsequent call of the build meta
+        # should still succeed, given the
+        # sdist_directory the frontend specifies is empty
+        setup_loc = os.path.abspath("setup.py")
+        if not os.path.exists(setup_loc):
+            setup_loc = os.path.abspath("setup.cfg")
+
+        with open(setup_loc, 'rt', encoding="utf-8") as file_handler:
+            content = file_handler.read()
+        with open(setup_loc, 'wt', encoding="utf-8") as file_handler:
+            file_handler.write(content.replace("version='0.0.0'", "version='0.0.1'"))
+
+        shutil.rmtree(sdist_into_directory)
+        os.makedirs(sdist_into_directory)
+
+        sdist_name = build_backend.build_sdist("out_sdist")
+        assert os.path.isfile(os.path.join(os.path.abspath("out_sdist"), sdist_name))
+
+    def test_build_sdist_pyproject_toml_exists(self, tmpdir_cwd):
+        files = {
+            'setup.py': DALS(
+                """
+                __import__('setuptools').setup(
+                    name='foo',
+                    version='0.0.0',
+                    py_modules=['hello']
+                )"""
+            ),
+            'hello.py': '',
+            'pyproject.toml': DALS(
+                """
+                [build-system]
+                requires = ["setuptools", "wheel"]
+                build-backend = "setuptools.build_meta"
+                """
+            ),
+        }
+        path.build(files)
+        build_backend = self.get_build_backend()
+        targz_path = build_backend.build_sdist("temp")
+        with tarfile.open(os.path.join("temp", targz_path)) as tar:
+            assert any('pyproject.toml' in name for name in tar.getnames())
+
+    def test_build_sdist_setup_py_exists(self, tmpdir_cwd):
+        # If build_sdist is called from a script other than setup.py,
+        # ensure setup.py is included
+        path.build(defns[0])
+
+        build_backend = self.get_build_backend()
+        targz_path = build_backend.build_sdist("temp")
+        with tarfile.open(os.path.join("temp", targz_path)) as tar:
+            assert any('setup.py' in name for name in tar.getnames())
+
+    def test_build_sdist_setup_py_manifest_excluded(self, tmpdir_cwd):
+        # Ensure that MANIFEST.in can exclude setup.py
+        files = {
+            'setup.py': DALS(
+                """
+        __import__('setuptools').setup(
+            name='foo',
+            version='0.0.0',
+            py_modules=['hello']
+        )"""
+            ),
+            'hello.py': '',
+            'MANIFEST.in': DALS(
+                """
+        exclude setup.py
+        """
+            ),
+        }
+
+        path.build(files)
+
+        build_backend = self.get_build_backend()
+        targz_path = build_backend.build_sdist("temp")
+        with tarfile.open(os.path.join("temp", targz_path)) as tar:
+            assert not any('setup.py' in name for name in tar.getnames())
+
+    def test_build_sdist_builds_targz_even_if_zip_indicated(self, tmpdir_cwd):
+        files = {
+            'setup.py': DALS(
+                """
+                __import__('setuptools').setup(
+                    name='foo',
+                    version='0.0.0',
+                    py_modules=['hello']
+                )"""
+            ),
+            'hello.py': '',
+            'setup.cfg': DALS(
+                """
+                [sdist]
+                formats=zip
+                """
+            ),
+        }
+
+        path.build(files)
+
+        build_backend = self.get_build_backend()
+        build_backend.build_sdist("temp")
+
+    _relative_path_import_files = {
+        'setup.py': DALS(
+            """
+            __import__('setuptools').setup(
+                name='foo',
+                version=__import__('hello').__version__,
+                py_modules=['hello']
+            )"""
+        ),
+        'hello.py': '__version__ = "0.0.0"',
+        'setup.cfg': DALS(
+            """
+            [sdist]
+            formats=zip
+            """
+        ),
+    }
+
+    def test_build_sdist_relative_path_import(self, tmpdir_cwd):
+        path.build(self._relative_path_import_files)
+        build_backend = self.get_build_backend()
+        with pytest.raises(ImportError, match="^No module named 'hello'$"):
+            build_backend.build_sdist("temp")
+
+    _simple_pyproject_example = {
+        "pyproject.toml": DALS(
+            """
+            [project]
+            name = "proj"
+            version = "42"
+            """
+        ),
+        "src": {"proj": {"__init__.py": ""}},
+    }
+
+    def _assert_link_tree(self, parent_dir):
+        """All files in the directory should be either links or hard links"""
+        files = list(Path(parent_dir).glob("**/*"))
+        assert files  # Should not be empty
+        for file in files:
+            assert file.is_symlink() or os.stat(file).st_nlink > 0
+
+    def test_editable_without_config_settings(self, tmpdir_cwd):
+        """
+        Sanity check to ensure tests with --mode=strict are different from the ones
+        without --mode.
+
+        --mode=strict should create a local directory with a package tree.
+        The directory should not get created otherwise.
+        """
+        path.build(self._simple_pyproject_example)
+        build_backend = self.get_build_backend()
+        assert not Path("build").exists()
+        build_backend.build_editable("temp")
+        assert not Path("build").exists()
+
+    def test_build_wheel_inplace(self, tmpdir_cwd):
+        config_settings = {"--build-option": ["build_ext", "--inplace"]}
+        path.build(self._simple_pyproject_example)
+        build_backend = self.get_build_backend()
+        assert not Path("build").exists()
+        Path("build").mkdir()
+        build_backend.prepare_metadata_for_build_wheel("build", config_settings)
+        build_backend.build_wheel("build", config_settings)
+        assert Path("build/proj-42-py3-none-any.whl").exists()
+
+    @pytest.mark.parametrize("config_settings", [{"editable-mode": "strict"}])
+    def test_editable_with_config_settings(self, tmpdir_cwd, config_settings):
+        path.build({**self._simple_pyproject_example, '_meta': {}})
+        assert not Path("build").exists()
+        build_backend = self.get_build_backend()
+        build_backend.prepare_metadata_for_build_editable("_meta", config_settings)
+        build_backend.build_editable("temp", config_settings, "_meta")
+        self._assert_link_tree(next(Path("build").glob("__editable__.*")))
+
+    @pytest.mark.parametrize(
+        ("setup_literal", "requirements"),
+        [
+            ("'foo'", ['foo']),
+            ("['foo']", ['foo']),
+            (r"'foo\n'", ['foo']),
+            (r"'foo\n\n'", ['foo']),
+            ("['foo', 'bar']", ['foo', 'bar']),
+            (r"'# Has a comment line\nfoo'", ['foo']),
+            (r"'foo # Has an inline comment'", ['foo']),
+            (r"'foo \\\n >=3.0'", ['foo>=3.0']),
+            (r"'foo\nbar'", ['foo', 'bar']),
+            (r"'foo\nbar\n'", ['foo', 'bar']),
+            (r"['foo\n', 'bar\n']", ['foo', 'bar']),
+        ],
+    )
+    @pytest.mark.parametrize('use_wheel', [True, False])
+    def test_setup_requires(self, setup_literal, requirements, use_wheel, tmpdir_cwd):
+        files = {
+            'setup.py': DALS(
+                """
+                from setuptools import setup
+
+                setup(
+                    name="qux",
+                    version="0.0.0",
+                    py_modules=["hello"],
+                    setup_requires={setup_literal},
+                )
+            """
+            ).format(setup_literal=setup_literal),
+            'hello.py': DALS(
+                """
+            def run():
+                print('hello')
+            """
+            ),
+        }
+
+        path.build(files)
+
+        build_backend = self.get_build_backend()
+
+        if use_wheel:
+            get_requires = build_backend.get_requires_for_build_wheel
+        else:
+            get_requires = build_backend.get_requires_for_build_sdist
+
+        # Ensure that the build requirements are properly parsed
+        expected = sorted(requirements)
+        actual = get_requires()
+
+        assert expected == sorted(actual)
+
+    def test_setup_requires_with_auto_discovery(self, tmpdir_cwd):
+        # Make sure patches introduced to retrieve setup_requires don't accidentally
+        # activate auto-discovery and cause problems due to the incomplete set of
+        # attributes passed to MinimalDistribution
+        files = {
+            'pyproject.toml': DALS(
+                """
+                [project]
+                name = "proj"
+                version = "42"
+            """
+            ),
+            "setup.py": DALS(
+                """
+                __import__('setuptools').setup(
+                    setup_requires=["foo"],
+                    py_modules = ["hello", "world"]
+                )
+            """
+            ),
+            'hello.py': "'hello'",
+            'world.py': "'world'",
+        }
+        path.build(files)
+        build_backend = self.get_build_backend()
+        setup_requires = build_backend.get_requires_for_build_wheel()
+        assert setup_requires == ["foo"]
+
+    def test_dont_install_setup_requires(self, tmpdir_cwd):
+        files = {
+            'setup.py': DALS(
+                """
+                        from setuptools import setup
+
+                        setup(
+                            name="qux",
+                            version="0.0.0",
+                            py_modules=["hello"],
+                            setup_requires=["does-not-exist >99"],
+                        )
+                    """
+            ),
+            'hello.py': DALS(
+                """
+                    def run():
+                        print('hello')
+                    """
+            ),
+        }
+
+        path.build(files)
+
+        build_backend = self.get_build_backend()
+
+        dist_dir = os.path.abspath('pip-dist-info')
+        os.makedirs(dist_dir)
+
+        # does-not-exist can't be satisfied, so if it attempts to install
+        # setup_requires, it will fail.
+        build_backend.prepare_metadata_for_build_wheel(dist_dir)
+
+    _sys_argv_0_passthrough = {
+        'setup.py': DALS(
+            """
+            import os
+            import sys
+
+            __import__('setuptools').setup(
+                name='foo',
+                version='0.0.0',
+            )
+
+            sys_argv = os.path.abspath(sys.argv[0])
+            file_path = os.path.abspath('setup.py')
+            assert sys_argv == file_path
+            """
+        )
+    }
+
+    def test_sys_argv_passthrough(self, tmpdir_cwd):
+        path.build(self._sys_argv_0_passthrough)
+        build_backend = self.get_build_backend()
+        with pytest.raises(AssertionError):
+            build_backend.build_sdist("temp")
+
+    _setup_py_file_abspath = {
+        'setup.py': DALS(
+            """
+            import os
+            assert os.path.isabs(__file__)
+            __import__('setuptools').setup(
+                name='foo',
+                version='0.0.0',
+                py_modules=['hello'],
+                setup_requires=['six'],
+            )
+            """
+        )
+    }
+
+    def test_setup_py_file_abspath(self, tmpdir_cwd):
+        path.build(self._setup_py_file_abspath)
+        build_backend = self.get_build_backend()
+        build_backend.build_sdist("temp")
+
+    @pytest.mark.parametrize('build_hook', ('build_sdist', 'build_wheel'))
+    def test_build_with_empty_setuppy(self, build_backend, build_hook):
+        files = {'setup.py': ''}
+        path.build(files)
+
+        msg = re.escape('No distribution was found.')
+        with pytest.raises(ValueError, match=msg):
+            getattr(build_backend, build_hook)("temp")
+
+
+class TestBuildMetaLegacyBackend(TestBuildMetaBackend):
+    backend_name = 'setuptools.build_meta:__legacy__'
+
+    # build_meta_legacy-specific tests
+    def test_build_sdist_relative_path_import(self, tmpdir_cwd):
+        # This must fail in build_meta, but must pass in build_meta_legacy
+        path.build(self._relative_path_import_files)
+
+        build_backend = self.get_build_backend()
+        build_backend.build_sdist("temp")
+
+    def test_sys_argv_passthrough(self, tmpdir_cwd):
+        path.build(self._sys_argv_0_passthrough)
+
+        build_backend = self.get_build_backend()
+        build_backend.build_sdist("temp")
+
+
+@pytest.mark.filterwarnings("ignore::setuptools.SetuptoolsDeprecationWarning")
+def test_sys_exit_0_in_setuppy(monkeypatch, tmp_path):
+    """Setuptools should be resilient to setup.py with ``sys.exit(0)`` (#3973)."""
+    monkeypatch.chdir(tmp_path)
+    setuppy = """
+        import sys, setuptools
+        setuptools.setup(name='foo', version='0.0.0')
+        sys.exit(0)
+        """
+    (tmp_path / "setup.py").write_text(DALS(setuppy), encoding="utf-8")
+    backend = BuildBackend(backend_name="setuptools.build_meta")
+    assert backend.get_requires_for_build_wheel() == []
+
+
+def test_system_exit_in_setuppy(monkeypatch, tmp_path):
+    monkeypatch.chdir(tmp_path)
+    setuppy = "import sys; sys.exit('some error')"
+    (tmp_path / "setup.py").write_text(setuppy, encoding="utf-8")
+    with pytest.raises(SystemExit, match="some error"):
+        backend = BuildBackend(backend_name="setuptools.build_meta")
+        backend.get_requires_for_build_wheel()
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/tests/test_build_py.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/tests/test_build_py.py
new file mode 100644
index 0000000000000000000000000000000000000000..1e3a660833933717310de66978771c4e48b5b914
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/tests/test_build_py.py
@@ -0,0 +1,480 @@
+import os
+import shutil
+import stat
+import warnings
+from pathlib import Path
+from unittest.mock import Mock
+
+import jaraco.path
+import pytest
+
+from setuptools import SetuptoolsDeprecationWarning
+from setuptools.dist import Distribution
+
+from .textwrap import DALS
+
+
+def test_directories_in_package_data_glob(tmpdir_cwd):
+    """
+    Directories matching the glob in package_data should
+    not be included in the package data.
+
+    Regression test for #261.
+    """
+    dist = Distribution(
+        dict(
+            script_name='setup.py',
+            script_args=['build_py'],
+            packages=[''],
+            package_data={'': ['path/*']},
+        )
+    )
+    os.makedirs('path/subpath')
+    dist.parse_command_line()
+    dist.run_commands()
+
+
+def test_recursive_in_package_data_glob(tmpdir_cwd):
+    """
+    Files matching recursive globs (**) in package_data should
+    be included in the package data.
+
+    #1806
+    """
+    dist = Distribution(
+        dict(
+            script_name='setup.py',
+            script_args=['build_py'],
+            packages=[''],
+            package_data={'': ['path/**/data']},
+        )
+    )
+    os.makedirs('path/subpath/subsubpath')
+    open('path/subpath/subsubpath/data', 'wb').close()
+
+    dist.parse_command_line()
+    dist.run_commands()
+
+    assert stat.S_ISREG(os.stat('build/lib/path/subpath/subsubpath/data').st_mode), (
+        "File is not included"
+    )
+
+
+def test_read_only(tmpdir_cwd):
+    """
+    Ensure read-only flag is not preserved in copy
+    for package modules and package data, as that
+    causes problems with deleting read-only files on
+    Windows.
+
+    #1451
+    """
+    dist = Distribution(
+        dict(
+            script_name='setup.py',
+            script_args=['build_py'],
+            packages=['pkg'],
+            package_data={'pkg': ['data.dat']},
+        )
+    )
+    os.makedirs('pkg')
+    open('pkg/__init__.py', 'wb').close()
+    open('pkg/data.dat', 'wb').close()
+    os.chmod('pkg/__init__.py', stat.S_IREAD)
+    os.chmod('pkg/data.dat', stat.S_IREAD)
+    dist.parse_command_line()
+    dist.run_commands()
+    shutil.rmtree('build')
+
+
+@pytest.mark.xfail(
+    'platform.system() == "Windows"',
+    reason="On Windows, files do not have executable bits",
+    raises=AssertionError,
+    strict=True,
+)
+def test_executable_data(tmpdir_cwd):
+    """
+    Ensure executable bit is preserved in copy for
+    package data, as users rely on it for scripts.
+
+    #2041
+    """
+    dist = Distribution(
+        dict(
+            script_name='setup.py',
+            script_args=['build_py'],
+            packages=['pkg'],
+            package_data={'pkg': ['run-me']},
+        )
+    )
+    os.makedirs('pkg')
+    open('pkg/__init__.py', 'wb').close()
+    open('pkg/run-me', 'wb').close()
+    os.chmod('pkg/run-me', 0o700)
+
+    dist.parse_command_line()
+    dist.run_commands()
+
+    assert os.stat('build/lib/pkg/run-me').st_mode & stat.S_IEXEC, (
+        "Script is not executable"
+    )
+
+
+EXAMPLE_WITH_MANIFEST = {
+    "setup.cfg": DALS(
+        """
+        [metadata]
+        name = mypkg
+        version = 42
+
+        [options]
+        include_package_data = True
+        packages = find:
+
+        [options.packages.find]
+        exclude = *.tests*
+        """
+    ),
+    "mypkg": {
+        "__init__.py": "",
+        "resource_file.txt": "",
+        "tests": {
+            "__init__.py": "",
+            "test_mypkg.py": "",
+            "test_file.txt": "",
+        },
+    },
+    "MANIFEST.in": DALS(
+        """
+        global-include *.py *.txt
+        global-exclude *.py[cod]
+        prune dist
+        prune build
+        prune *.egg-info
+        """
+    ),
+}
+
+
+def test_excluded_subpackages(tmpdir_cwd):
+    jaraco.path.build(EXAMPLE_WITH_MANIFEST)
+    dist = Distribution({"script_name": "%PEP 517%"})
+    dist.parse_config_files()
+
+    build_py = dist.get_command_obj("build_py")
+
+    msg = r"Python recognizes 'mypkg\.tests' as an importable package"
+    with pytest.warns(SetuptoolsDeprecationWarning, match=msg):
+        # TODO: To fix #3260 we need some transition period to deprecate the
+        # existing behavior of `include_package_data`. After the transition, we
+        # should remove the warning and fix the behavior.
+
+        if os.getenv("SETUPTOOLS_USE_DISTUTILS") == "stdlib":
+            # pytest.warns reset the warning filter temporarily
+            # https://github.com/pytest-dev/pytest/issues/4011#issuecomment-423494810
+            warnings.filterwarnings(
+                "ignore",
+                "'encoding' argument not specified",
+                module="distutils.text_file",
+                # This warning is already fixed in pypa/distutils but not in stdlib
+            )
+
+        build_py.finalize_options()
+        build_py.run()
+
+    build_dir = Path(dist.get_command_obj("build_py").build_lib)
+    assert (build_dir / "mypkg/__init__.py").exists()
+    assert (build_dir / "mypkg/resource_file.txt").exists()
+
+    # Setuptools is configured to ignore `mypkg.tests`, therefore the following
+    # files/dirs should not be included in the distribution.
+    for f in [
+        "mypkg/tests/__init__.py",
+        "mypkg/tests/test_mypkg.py",
+        "mypkg/tests/test_file.txt",
+        "mypkg/tests",
+    ]:
+        with pytest.raises(AssertionError):
+            # TODO: Enforce the following assertion once #3260 is fixed
+            # (remove context manager and the following xfail).
+            assert not (build_dir / f).exists()
+
+    pytest.xfail("#3260")
+
+
+@pytest.mark.filterwarnings("ignore::setuptools.SetuptoolsDeprecationWarning")
+def test_existing_egg_info(tmpdir_cwd, monkeypatch):
+    """When provided with the ``existing_egg_info_dir`` attribute, build_py should not
+    attempt to run egg_info again.
+    """
+    # == Pre-condition ==
+    # Generate an egg-info dir
+    jaraco.path.build(EXAMPLE_WITH_MANIFEST)
+    dist = Distribution({"script_name": "%PEP 517%"})
+    dist.parse_config_files()
+    assert dist.include_package_data
+
+    egg_info = dist.get_command_obj("egg_info")
+    dist.run_command("egg_info")
+    egg_info_dir = next(Path(egg_info.egg_base).glob("*.egg-info"))
+    assert egg_info_dir.is_dir()
+
+    # == Setup ==
+    build_py = dist.get_command_obj("build_py")
+    build_py.finalize_options()
+    egg_info = dist.get_command_obj("egg_info")
+    egg_info_run = Mock(side_effect=egg_info.run)
+    monkeypatch.setattr(egg_info, "run", egg_info_run)
+
+    # == Remove caches ==
+    # egg_info is called when build_py looks for data_files, which gets cached.
+    # We need to ensure it is not cached yet, otherwise it may impact on the tests
+    build_py.__dict__.pop('data_files', None)
+    dist.reinitialize_command(egg_info)
+
+    # == Sanity check ==
+    # Ensure that if existing_egg_info is not given, build_py attempts to run egg_info
+    build_py.existing_egg_info_dir = None
+    build_py.run()
+    egg_info_run.assert_called()
+
+    # == Remove caches ==
+    egg_info_run.reset_mock()
+    build_py.__dict__.pop('data_files', None)
+    dist.reinitialize_command(egg_info)
+
+    # == Actual test ==
+    # Ensure that if existing_egg_info_dir is given, egg_info doesn't run
+    build_py.existing_egg_info_dir = egg_info_dir
+    build_py.run()
+    egg_info_run.assert_not_called()
+    assert build_py.data_files
+
+    # Make sure the list of outputs is actually OK
+    outputs = map(lambda x: x.replace(os.sep, "/"), build_py.get_outputs())
+    assert outputs
+    example = str(Path(build_py.build_lib, "mypkg/__init__.py")).replace(os.sep, "/")
+    assert example in outputs
+
+
+EXAMPLE_ARBITRARY_MAPPING = {
+    "pyproject.toml": DALS(
+        """
+        [project]
+        name = "mypkg"
+        version = "42"
+
+        [tool.setuptools]
+        packages = ["mypkg", "mypkg.sub1", "mypkg.sub2", "mypkg.sub2.nested"]
+
+        [tool.setuptools.package-dir]
+        "" = "src"
+        "mypkg.sub2" = "src/mypkg/_sub2"
+        "mypkg.sub2.nested" = "other"
+        """
+    ),
+    "src": {
+        "mypkg": {
+            "__init__.py": "",
+            "resource_file.txt": "",
+            "sub1": {
+                "__init__.py": "",
+                "mod1.py": "",
+            },
+            "_sub2": {
+                "mod2.py": "",
+            },
+        },
+    },
+    "other": {
+        "__init__.py": "",
+        "mod3.py": "",
+    },
+    "MANIFEST.in": DALS(
+        """
+        global-include *.py *.txt
+        global-exclude *.py[cod]
+        """
+    ),
+}
+
+
+def test_get_outputs(tmpdir_cwd):
+    jaraco.path.build(EXAMPLE_ARBITRARY_MAPPING)
+    dist = Distribution({"script_name": "%test%"})
+    dist.parse_config_files()
+
+    build_py = dist.get_command_obj("build_py")
+    build_py.editable_mode = True
+    build_py.ensure_finalized()
+    build_lib = build_py.build_lib.replace(os.sep, "/")
+    outputs = {x.replace(os.sep, "/") for x in build_py.get_outputs()}
+    assert outputs == {
+        f"{build_lib}/mypkg/__init__.py",
+        f"{build_lib}/mypkg/resource_file.txt",
+        f"{build_lib}/mypkg/sub1/__init__.py",
+        f"{build_lib}/mypkg/sub1/mod1.py",
+        f"{build_lib}/mypkg/sub2/mod2.py",
+        f"{build_lib}/mypkg/sub2/nested/__init__.py",
+        f"{build_lib}/mypkg/sub2/nested/mod3.py",
+    }
+    mapping = {
+        k.replace(os.sep, "/"): v.replace(os.sep, "/")
+        for k, v in build_py.get_output_mapping().items()
+    }
+    assert mapping == {
+        f"{build_lib}/mypkg/__init__.py": "src/mypkg/__init__.py",
+        f"{build_lib}/mypkg/resource_file.txt": "src/mypkg/resource_file.txt",
+        f"{build_lib}/mypkg/sub1/__init__.py": "src/mypkg/sub1/__init__.py",
+        f"{build_lib}/mypkg/sub1/mod1.py": "src/mypkg/sub1/mod1.py",
+        f"{build_lib}/mypkg/sub2/mod2.py": "src/mypkg/_sub2/mod2.py",
+        f"{build_lib}/mypkg/sub2/nested/__init__.py": "other/__init__.py",
+        f"{build_lib}/mypkg/sub2/nested/mod3.py": "other/mod3.py",
+    }
+
+
+class TestTypeInfoFiles:
+    PYPROJECTS = {
+        "default_pyproject": DALS(
+            """
+            [project]
+            name = "foo"
+            version = "1"
+            """
+        ),
+        "dont_include_package_data": DALS(
+            """
+            [project]
+            name = "foo"
+            version = "1"
+
+            [tool.setuptools]
+            include-package-data = false
+            """
+        ),
+        "exclude_type_info": DALS(
+            """
+            [project]
+            name = "foo"
+            version = "1"
+
+            [tool.setuptools]
+            include-package-data = false
+
+            [tool.setuptools.exclude-package-data]
+            "*" = ["py.typed", "*.pyi"]
+            """
+        ),
+    }
+
+    EXAMPLES = {
+        "simple_namespace": {
+            "directory_structure": {
+                "foo": {
+                    "bar.pyi": "",
+                    "py.typed": "",
+                    "__init__.py": "",
+                }
+            },
+            "expected_type_files": {"foo/bar.pyi", "foo/py.typed"},
+        },
+        "nested_inside_namespace": {
+            "directory_structure": {
+                "foo": {
+                    "bar": {
+                        "py.typed": "",
+                        "mod.pyi": "",
+                    }
+                }
+            },
+            "expected_type_files": {"foo/bar/mod.pyi", "foo/bar/py.typed"},
+        },
+        "namespace_nested_inside_regular": {
+            "directory_structure": {
+                "foo": {
+                    "namespace": {
+                        "foo.pyi": "",
+                    },
+                    "__init__.pyi": "",
+                    "py.typed": "",
+                }
+            },
+            "expected_type_files": {
+                "foo/namespace/foo.pyi",
+                "foo/__init__.pyi",
+                "foo/py.typed",
+            },
+        },
+    }
+
+    @pytest.mark.parametrize(
+        "pyproject",
+        [
+            "default_pyproject",
+            pytest.param(
+                "dont_include_package_data",
+                marks=pytest.mark.xfail(reason="pypa/setuptools#4350"),
+            ),
+        ],
+    )
+    @pytest.mark.parametrize("example", EXAMPLES.keys())
+    def test_type_files_included_by_default(self, tmpdir_cwd, pyproject, example):
+        structure = {
+            **self.EXAMPLES[example]["directory_structure"],
+            "pyproject.toml": self.PYPROJECTS[pyproject],
+        }
+        expected_type_files = self.EXAMPLES[example]["expected_type_files"]
+        jaraco.path.build(structure)
+
+        build_py = get_finalized_build_py()
+        outputs = get_outputs(build_py)
+        assert expected_type_files <= outputs
+
+    @pytest.mark.parametrize("pyproject", ["exclude_type_info"])
+    @pytest.mark.parametrize("example", EXAMPLES.keys())
+    def test_type_files_can_be_excluded(self, tmpdir_cwd, pyproject, example):
+        structure = {
+            **self.EXAMPLES[example]["directory_structure"],
+            "pyproject.toml": self.PYPROJECTS[pyproject],
+        }
+        expected_type_files = self.EXAMPLES[example]["expected_type_files"]
+        jaraco.path.build(structure)
+
+        build_py = get_finalized_build_py()
+        outputs = get_outputs(build_py)
+        assert expected_type_files.isdisjoint(outputs)
+
+    def test_stub_only_package(self, tmpdir_cwd):
+        structure = {
+            "pyproject.toml": DALS(
+                """
+                [project]
+                name = "foo-stubs"
+                version = "1"
+                """
+            ),
+            "foo-stubs": {"__init__.pyi": "", "bar.pyi": ""},
+        }
+        expected_type_files = {"foo-stubs/__init__.pyi", "foo-stubs/bar.pyi"}
+        jaraco.path.build(structure)
+
+        build_py = get_finalized_build_py()
+        outputs = get_outputs(build_py)
+        assert expected_type_files <= outputs
+
+
+def get_finalized_build_py(script_name="%build_py-test%"):
+    dist = Distribution({"script_name": script_name})
+    dist.parse_config_files()
+    build_py = dist.get_command_obj("build_py")
+    build_py.finalize_options()
+    return build_py
+
+
+def get_outputs(build_py):
+    build_dir = Path(build_py.build_lib)
+    return {
+        os.path.relpath(x, build_dir).replace(os.sep, "/")
+        for x in build_py.get_outputs()
+    }
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/tests/test_config_discovery.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/tests/test_config_discovery.py
new file mode 100644
index 0000000000000000000000000000000000000000..b5df8203cdb6f9129a65d0c503c4f51e21315b1f
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/tests/test_config_discovery.py
@@ -0,0 +1,647 @@
+import os
+import sys
+from configparser import ConfigParser
+from itertools import product
+from typing import cast
+
+import jaraco.path
+import pytest
+from path import Path
+
+import setuptools  # noqa: F401 # force distutils.core to be patched
+from setuptools.command.sdist import sdist
+from setuptools.discovery import find_package_path, find_parent_package
+from setuptools.dist import Distribution
+from setuptools.errors import PackageDiscoveryError
+
+from .contexts import quiet
+from .integration.helpers import get_sdist_members, get_wheel_members, run
+from .textwrap import DALS
+
+import distutils.core
+
+
+class TestFindParentPackage:
+    def test_single_package(self, tmp_path):
+        # find_parent_package should find a non-namespace parent package
+        (tmp_path / "src/namespace/pkg/nested").mkdir(exist_ok=True, parents=True)
+        (tmp_path / "src/namespace/pkg/nested/__init__.py").touch()
+        (tmp_path / "src/namespace/pkg/__init__.py").touch()
+        packages = ["namespace", "namespace.pkg", "namespace.pkg.nested"]
+        assert find_parent_package(packages, {"": "src"}, tmp_path) == "namespace.pkg"
+
+    def test_multiple_toplevel(self, tmp_path):
+        # find_parent_package should return null if the given list of packages does not
+        # have a single parent package
+        multiple = ["pkg", "pkg1", "pkg2"]
+        for name in multiple:
+            (tmp_path / f"src/{name}").mkdir(exist_ok=True, parents=True)
+            (tmp_path / f"src/{name}/__init__.py").touch()
+        assert find_parent_package(multiple, {"": "src"}, tmp_path) is None
+
+
+class TestDiscoverPackagesAndPyModules:
+    """Make sure discovered values for ``packages`` and ``py_modules`` work
+    similarly to explicit configuration for the simple scenarios.
+    """
+
+    OPTIONS = {
+        # Different options according to the circumstance being tested
+        "explicit-src": {"package_dir": {"": "src"}, "packages": ["pkg"]},
+        "variation-lib": {
+            "package_dir": {"": "lib"},  # variation of the source-layout
+        },
+        "explicit-flat": {"packages": ["pkg"]},
+        "explicit-single_module": {"py_modules": ["pkg"]},
+        "explicit-namespace": {"packages": ["ns", "ns.pkg"]},
+        "automatic-src": {},
+        "automatic-flat": {},
+        "automatic-single_module": {},
+        "automatic-namespace": {},
+    }
+    FILES = {
+        "src": ["src/pkg/__init__.py", "src/pkg/main.py"],
+        "lib": ["lib/pkg/__init__.py", "lib/pkg/main.py"],
+        "flat": ["pkg/__init__.py", "pkg/main.py"],
+        "single_module": ["pkg.py"],
+        "namespace": ["ns/pkg/__init__.py"],
+    }
+
+    def _get_info(self, circumstance):
+        _, _, layout = circumstance.partition("-")
+        files = self.FILES[layout]
+        options = self.OPTIONS[circumstance]
+        return files, options
+
+    @pytest.mark.parametrize("circumstance", OPTIONS.keys())
+    def test_sdist_filelist(self, tmp_path, circumstance):
+        files, options = self._get_info(circumstance)
+        _populate_project_dir(tmp_path, files, options)
+
+        _, cmd = _run_sdist_programatically(tmp_path, options)
+
+        manifest = [f.replace(os.sep, "/") for f in cmd.filelist.files]
+        for file in files:
+            assert any(f.endswith(file) for f in manifest)
+
+    @pytest.mark.parametrize("circumstance", OPTIONS.keys())
+    def test_project(self, tmp_path, circumstance):
+        files, options = self._get_info(circumstance)
+        _populate_project_dir(tmp_path, files, options)
+
+        # Simulate a pre-existing `build` directory
+        (tmp_path / "build").mkdir()
+        (tmp_path / "build/lib").mkdir()
+        (tmp_path / "build/bdist.linux-x86_64").mkdir()
+        (tmp_path / "build/bdist.linux-x86_64/file.py").touch()
+        (tmp_path / "build/lib/__init__.py").touch()
+        (tmp_path / "build/lib/file.py").touch()
+        (tmp_path / "dist").mkdir()
+        (tmp_path / "dist/file.py").touch()
+
+        _run_build(tmp_path)
+
+        sdist_files = get_sdist_members(next(tmp_path.glob("dist/*.tar.gz")))
+        print("~~~~~ sdist_members ~~~~~")
+        print('\n'.join(sdist_files))
+        assert sdist_files >= set(files)
+
+        wheel_files = get_wheel_members(next(tmp_path.glob("dist/*.whl")))
+        print("~~~~~ wheel_members ~~~~~")
+        print('\n'.join(wheel_files))
+        orig_files = {f.replace("src/", "").replace("lib/", "") for f in files}
+        assert wheel_files >= orig_files
+
+        # Make sure build files are not included by mistake
+        for file in wheel_files:
+            assert "build" not in files
+            assert "dist" not in files
+
+    PURPOSEFULLY_EMPY = {
+        "setup.cfg": DALS(
+            """
+            [metadata]
+            name = myproj
+            version = 0.0.0
+
+            [options]
+            {param} =
+            """
+        ),
+        "setup.py": DALS(
+            """
+            __import__('setuptools').setup(
+                name="myproj",
+                version="0.0.0",
+                {param}=[]
+            )
+            """
+        ),
+        "pyproject.toml": DALS(
+            """
+            [build-system]
+            requires = []
+            build-backend = 'setuptools.build_meta'
+
+            [project]
+            name = "myproj"
+            version = "0.0.0"
+
+            [tool.setuptools]
+            {param} = []
+            """
+        ),
+        "template-pyproject.toml": DALS(
+            """
+            [build-system]
+            requires = []
+            build-backend = 'setuptools.build_meta'
+            """
+        ),
+    }
+
+    @pytest.mark.parametrize(
+        ("config_file", "param", "circumstance"),
+        product(
+            ["setup.cfg", "setup.py", "pyproject.toml"],
+            ["packages", "py_modules"],
+            FILES.keys(),
+        ),
+    )
+    def test_purposefully_empty(self, tmp_path, config_file, param, circumstance):
+        files = self.FILES[circumstance] + ["mod.py", "other.py", "src/pkg/__init__.py"]
+        _populate_project_dir(tmp_path, files, {})
+
+        if config_file == "pyproject.toml":
+            template_param = param.replace("_", "-")
+        else:
+            # Make sure build works with or without setup.cfg
+            pyproject = self.PURPOSEFULLY_EMPY["template-pyproject.toml"]
+            (tmp_path / "pyproject.toml").write_text(pyproject, encoding="utf-8")
+            template_param = param
+
+        config = self.PURPOSEFULLY_EMPY[config_file].format(param=template_param)
+        (tmp_path / config_file).write_text(config, encoding="utf-8")
+
+        dist = _get_dist(tmp_path, {})
+        # When either parameter package or py_modules is an empty list,
+        # then there should be no discovery
+        assert getattr(dist, param) == []
+        other = {"py_modules": "packages", "packages": "py_modules"}[param]
+        assert getattr(dist, other) is None
+
+    @pytest.mark.parametrize(
+        ("extra_files", "pkgs"),
+        [
+            (["venv/bin/simulate_venv"], {"pkg"}),
+            (["pkg-stubs/__init__.pyi"], {"pkg", "pkg-stubs"}),
+            (["other-stubs/__init__.pyi"], {"pkg", "other-stubs"}),
+            (
+                # Type stubs can also be namespaced
+                ["namespace-stubs/pkg/__init__.pyi"],
+                {"pkg", "namespace-stubs", "namespace-stubs.pkg"},
+            ),
+            (
+                # Just the top-level package can have `-stubs`, ignore nested ones
+                ["namespace-stubs/pkg-stubs/__init__.pyi"],
+                {"pkg", "namespace-stubs"},
+            ),
+            (["_hidden/file.py"], {"pkg"}),
+            (["news/finalize.py"], {"pkg"}),
+        ],
+    )
+    def test_flat_layout_with_extra_files(self, tmp_path, extra_files, pkgs):
+        files = self.FILES["flat"] + extra_files
+        _populate_project_dir(tmp_path, files, {})
+        dist = _get_dist(tmp_path, {})
+        assert set(dist.packages) == pkgs
+
+    @pytest.mark.parametrize(
+        "extra_files",
+        [
+            ["other/__init__.py"],
+            ["other/finalize.py"],
+        ],
+    )
+    def test_flat_layout_with_dangerous_extra_files(self, tmp_path, extra_files):
+        files = self.FILES["flat"] + extra_files
+        _populate_project_dir(tmp_path, files, {})
+        with pytest.raises(PackageDiscoveryError, match="multiple (packages|modules)"):
+            _get_dist(tmp_path, {})
+
+    def test_flat_layout_with_single_module(self, tmp_path):
+        files = self.FILES["single_module"] + ["invalid-module-name.py"]
+        _populate_project_dir(tmp_path, files, {})
+        dist = _get_dist(tmp_path, {})
+        assert set(dist.py_modules) == {"pkg"}
+
+    def test_flat_layout_with_multiple_modules(self, tmp_path):
+        files = self.FILES["single_module"] + ["valid_module_name.py"]
+        _populate_project_dir(tmp_path, files, {})
+        with pytest.raises(PackageDiscoveryError, match="multiple (packages|modules)"):
+            _get_dist(tmp_path, {})
+
+    def test_py_modules_when_wheel_dir_is_cwd(self, tmp_path):
+        """Regression for issue 3692"""
+        from setuptools import build_meta
+
+        pyproject = '[project]\nname = "test"\nversion = "1"'
+        (tmp_path / "pyproject.toml").write_text(DALS(pyproject), encoding="utf-8")
+        (tmp_path / "foo.py").touch()
+        with jaraco.path.DirectoryStack().context(tmp_path):
+            build_meta.build_wheel(".")
+        # Ensure py_modules are found
+        wheel_files = get_wheel_members(next(tmp_path.glob("*.whl")))
+        assert "foo.py" in wheel_files
+
+
+class TestNoConfig:
+    DEFAULT_VERSION = "0.0.0"  # Default version given by setuptools
+
+    EXAMPLES = {
+        "pkg1": ["src/pkg1.py"],
+        "pkg2": ["src/pkg2/__init__.py"],
+        "pkg3": ["src/pkg3/__init__.py", "src/pkg3-stubs/__init__.py"],
+        "pkg4": ["pkg4/__init__.py", "pkg4-stubs/__init__.py"],
+        "ns.nested.pkg1": ["src/ns/nested/pkg1/__init__.py"],
+        "ns.nested.pkg2": ["ns/nested/pkg2/__init__.py"],
+    }
+
+    @pytest.mark.parametrize("example", EXAMPLES.keys())
+    def test_discover_name(self, tmp_path, example):
+        _populate_project_dir(tmp_path, self.EXAMPLES[example], {})
+        dist = _get_dist(tmp_path, {})
+        assert dist.get_name() == example
+
+    def test_build_with_discovered_name(self, tmp_path):
+        files = ["src/ns/nested/pkg/__init__.py"]
+        _populate_project_dir(tmp_path, files, {})
+        _run_build(tmp_path, "--sdist")
+        # Expected distribution file
+        dist_file = tmp_path / f"dist/ns_nested_pkg-{self.DEFAULT_VERSION}.tar.gz"
+        assert dist_file.is_file()
+
+
+class TestWithAttrDirective:
+    @pytest.mark.parametrize(
+        ("folder", "opts"),
+        [
+            ("src", {}),
+            ("lib", {"packages": "find:", "packages.find": {"where": "lib"}}),
+        ],
+    )
+    def test_setupcfg_metadata(self, tmp_path, folder, opts):
+        files = [f"{folder}/pkg/__init__.py", "setup.cfg"]
+        _populate_project_dir(tmp_path, files, opts)
+
+        config = (tmp_path / "setup.cfg").read_text(encoding="utf-8")
+        overwrite = {
+            folder: {"pkg": {"__init__.py": "version = 42"}},
+            "setup.cfg": "[metadata]\nversion = attr: pkg.version\n" + config,
+        }
+        jaraco.path.build(overwrite, prefix=tmp_path)
+
+        dist = _get_dist(tmp_path, {})
+        assert dist.get_name() == "pkg"
+        assert dist.get_version() == "42"
+        assert dist.package_dir
+        package_path = find_package_path("pkg", dist.package_dir, tmp_path)
+        assert os.path.exists(package_path)
+        assert folder in Path(package_path).parts()
+
+        _run_build(tmp_path, "--sdist")
+        dist_file = tmp_path / "dist/pkg-42.tar.gz"
+        assert dist_file.is_file()
+
+    def test_pyproject_metadata(self, tmp_path):
+        _populate_project_dir(tmp_path, ["src/pkg/__init__.py"], {})
+
+        overwrite = {
+            "src": {"pkg": {"__init__.py": "version = 42"}},
+            "pyproject.toml": (
+                "[project]\nname = 'pkg'\ndynamic = ['version']\n"
+                "[tool.setuptools.dynamic]\nversion = {attr = 'pkg.version'}\n"
+            ),
+        }
+        jaraco.path.build(overwrite, prefix=tmp_path)
+
+        dist = _get_dist(tmp_path, {})
+        assert dist.get_version() == "42"
+        assert dist.package_dir == {"": "src"}
+
+
+class TestWithCExtension:
+    def _simulate_package_with_extension(self, tmp_path):
+        # This example is based on: https://github.com/nucleic/kiwi/tree/1.4.0
+        files = [
+            "benchmarks/file.py",
+            "docs/Makefile",
+            "docs/requirements.txt",
+            "docs/source/conf.py",
+            "proj/header.h",
+            "proj/file.py",
+            "py/proj.cpp",
+            "py/other.cpp",
+            "py/file.py",
+            "py/py.typed",
+            "py/tests/test_proj.py",
+            "README.rst",
+        ]
+        _populate_project_dir(tmp_path, files, {})
+
+        setup_script = """
+            from setuptools import Extension, setup
+
+            ext_modules = [
+                Extension(
+                    "proj",
+                    ["py/proj.cpp", "py/other.cpp"],
+                    include_dirs=["."],
+                    language="c++",
+                ),
+            ]
+            setup(ext_modules=ext_modules)
+        """
+        (tmp_path / "setup.py").write_text(DALS(setup_script), encoding="utf-8")
+
+    def test_skip_discovery_with_setupcfg_metadata(self, tmp_path):
+        """Ensure that auto-discovery is not triggered when the project is based on
+        C-extensions only, for backward compatibility.
+        """
+        self._simulate_package_with_extension(tmp_path)
+
+        pyproject = """
+            [build-system]
+            requires = []
+            build-backend = 'setuptools.build_meta'
+        """
+        (tmp_path / "pyproject.toml").write_text(DALS(pyproject), encoding="utf-8")
+
+        setupcfg = """
+            [metadata]
+            name = proj
+            version = 42
+        """
+        (tmp_path / "setup.cfg").write_text(DALS(setupcfg), encoding="utf-8")
+
+        dist = _get_dist(tmp_path, {})
+        assert dist.get_name() == "proj"
+        assert dist.get_version() == "42"
+        assert dist.py_modules is None
+        assert dist.packages is None
+        assert len(dist.ext_modules) == 1
+        assert dist.ext_modules[0].name == "proj"
+
+    def test_dont_skip_discovery_with_pyproject_metadata(self, tmp_path):
+        """When opting-in to pyproject.toml metadata, auto-discovery will be active if
+        the package lists C-extensions, but does not configure py-modules or packages.
+
+        This way we ensure users with complex package layouts that would lead to the
+        discovery of multiple top-level modules/packages see errors and are forced to
+        explicitly set ``packages`` or ``py-modules``.
+        """
+        self._simulate_package_with_extension(tmp_path)
+
+        pyproject = """
+            [project]
+            name = 'proj'
+            version = '42'
+        """
+        (tmp_path / "pyproject.toml").write_text(DALS(pyproject), encoding="utf-8")
+        with pytest.raises(PackageDiscoveryError, match="multiple (packages|modules)"):
+            _get_dist(tmp_path, {})
+
+
+class TestWithPackageData:
+    def _simulate_package_with_data_files(self, tmp_path, src_root):
+        files = [
+            f"{src_root}/proj/__init__.py",
+            f"{src_root}/proj/file1.txt",
+            f"{src_root}/proj/nested/file2.txt",
+        ]
+        _populate_project_dir(tmp_path, files, {})
+
+        manifest = """
+            global-include *.py *.txt
+        """
+        (tmp_path / "MANIFEST.in").write_text(DALS(manifest), encoding="utf-8")
+
+    EXAMPLE_SETUPCFG = """
+    [metadata]
+    name = proj
+    version = 42
+
+    [options]
+    include_package_data = True
+    """
+    EXAMPLE_PYPROJECT = """
+    [project]
+    name = "proj"
+    version = "42"
+    """
+
+    PYPROJECT_PACKAGE_DIR = """
+    [tool.setuptools]
+    package-dir = {"" = "src"}
+    """
+
+    @pytest.mark.parametrize(
+        ("src_root", "files"),
+        [
+            (".", {"setup.cfg": DALS(EXAMPLE_SETUPCFG)}),
+            (".", {"pyproject.toml": DALS(EXAMPLE_PYPROJECT)}),
+            ("src", {"setup.cfg": DALS(EXAMPLE_SETUPCFG)}),
+            ("src", {"pyproject.toml": DALS(EXAMPLE_PYPROJECT)}),
+            (
+                "src",
+                {
+                    "setup.cfg": DALS(EXAMPLE_SETUPCFG)
+                    + DALS(
+                        """
+                        packages = find:
+                        package_dir =
+                            =src
+
+                        [options.packages.find]
+                        where = src
+                        """
+                    )
+                },
+            ),
+            (
+                "src",
+                {
+                    "pyproject.toml": DALS(EXAMPLE_PYPROJECT)
+                    + DALS(
+                        """
+                        [tool.setuptools]
+                        package-dir = {"" = "src"}
+                        """
+                    )
+                },
+            ),
+        ],
+    )
+    def test_include_package_data(self, tmp_path, src_root, files):
+        """
+        Make sure auto-discovery does not affect package include_package_data.
+        See issue #3196.
+        """
+        jaraco.path.build(files, prefix=str(tmp_path))
+        self._simulate_package_with_data_files(tmp_path, src_root)
+
+        expected = {
+            os.path.normpath(f"{src_root}/proj/file1.txt").replace(os.sep, "/"),
+            os.path.normpath(f"{src_root}/proj/nested/file2.txt").replace(os.sep, "/"),
+        }
+
+        _run_build(tmp_path)
+
+        sdist_files = get_sdist_members(next(tmp_path.glob("dist/*.tar.gz")))
+        print("~~~~~ sdist_members ~~~~~")
+        print('\n'.join(sdist_files))
+        assert sdist_files >= expected
+
+        wheel_files = get_wheel_members(next(tmp_path.glob("dist/*.whl")))
+        print("~~~~~ wheel_members ~~~~~")
+        print('\n'.join(wheel_files))
+        orig_files = {f.replace("src/", "").replace("lib/", "") for f in expected}
+        assert wheel_files >= orig_files
+
+
+def test_compatible_with_numpy_configuration(tmp_path):
+    files = [
+        "dir1/__init__.py",
+        "dir2/__init__.py",
+        "file.py",
+    ]
+    _populate_project_dir(tmp_path, files, {})
+    dist = Distribution({})
+    dist.configuration = object()
+    dist.set_defaults()
+    assert dist.py_modules is None
+    assert dist.packages is None
+
+
+def test_name_discovery_doesnt_break_cli(tmpdir_cwd):
+    jaraco.path.build({"pkg.py": ""})
+    dist = Distribution({})
+    dist.script_args = ["--name"]
+    dist.set_defaults()
+    dist.parse_command_line()  # <-- no exception should be raised here.
+    assert dist.get_name() == "pkg"
+
+
+def test_preserve_explicit_name_with_dynamic_version(tmpdir_cwd, monkeypatch):
+    """According to #3545 it seems that ``name`` discovery is running,
+    even when the project already explicitly sets it.
+    This seems to be related to parsing of dynamic versions (via ``attr`` directive),
+    which requires the auto-discovery of ``package_dir``.
+    """
+    files = {
+        "src": {
+            "pkg": {"__init__.py": "__version__ = 42\n"},
+        },
+        "pyproject.toml": DALS(
+            """
+            [project]
+            name = "myproj"  # purposefully different from package name
+            dynamic = ["version"]
+            [tool.setuptools.dynamic]
+            version = {"attr" = "pkg.__version__"}
+            """
+        ),
+    }
+    jaraco.path.build(files)
+    dist = Distribution({})
+    orig_analyse_name = dist.set_defaults.analyse_name
+
+    def spy_analyse_name():
+        # We can check if name discovery was triggered by ensuring the original
+        # name remains instead of the package name.
+        orig_analyse_name()
+        assert dist.get_name() == "myproj"
+
+    monkeypatch.setattr(dist.set_defaults, "analyse_name", spy_analyse_name)
+    dist.parse_config_files()
+    assert dist.get_version() == "42"
+    assert set(dist.packages) == {"pkg"}
+
+
+def _populate_project_dir(root, files, options):
+    # NOTE: Currently pypa/build will refuse to build the project if no
+    # `pyproject.toml` or `setup.py` is found. So it is impossible to do
+    # completely "config-less" projects.
+    basic = {
+        "setup.py": "import setuptools\nsetuptools.setup()",
+        "README.md": "# Example Package",
+        "LICENSE": "Copyright (c) 2018",
+    }
+    jaraco.path.build(basic, prefix=root)
+    _write_setupcfg(root, options)
+    paths = (root / f for f in files)
+    for path in paths:
+        path.parent.mkdir(exist_ok=True, parents=True)
+        path.touch()
+
+
+def _write_setupcfg(root, options):
+    if not options:
+        print("~~~~~ **NO** setup.cfg ~~~~~")
+        return
+    setupcfg = ConfigParser()
+    setupcfg.add_section("options")
+    for key, value in options.items():
+        if key == "packages.find":
+            setupcfg.add_section(f"options.{key}")
+            setupcfg[f"options.{key}"].update(value)
+        elif isinstance(value, list):
+            setupcfg["options"][key] = ", ".join(value)
+        elif isinstance(value, dict):
+            str_value = "\n".join(f"\t{k} = {v}" for k, v in value.items())
+            setupcfg["options"][key] = "\n" + str_value
+        else:
+            setupcfg["options"][key] = str(value)
+    with open(root / "setup.cfg", "w", encoding="utf-8") as f:
+        setupcfg.write(f)
+    print("~~~~~ setup.cfg ~~~~~")
+    print((root / "setup.cfg").read_text(encoding="utf-8"))
+
+
+def _run_build(path, *flags):
+    cmd = [sys.executable, "-m", "build", "--no-isolation", *flags, str(path)]
+    return run(cmd, env={'DISTUTILS_DEBUG': ''})
+
+
+def _get_dist(dist_path, attrs):
+    root = "/".join(os.path.split(dist_path))  # POSIX-style
+
+    script = dist_path / 'setup.py'
+    if script.exists():
+        with Path(dist_path):
+            dist = cast(
+                Distribution,
+                distutils.core.run_setup("setup.py", {}, stop_after="init"),
+            )
+    else:
+        dist = Distribution(attrs)
+
+    dist.src_root = root
+    dist.script_name = "setup.py"
+    with Path(dist_path):
+        dist.parse_config_files()
+
+    dist.set_defaults()
+    return dist
+
+
+def _run_sdist_programatically(dist_path, attrs):
+    dist = _get_dist(dist_path, attrs)
+    cmd = sdist(dist)
+    cmd.ensure_finalized()
+    assert cmd.distribution.packages or cmd.distribution.py_modules
+
+    with quiet(), Path(dist_path):
+        cmd.run()
+
+    return dist, cmd
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/tests/test_core_metadata.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/tests/test_core_metadata.py
new file mode 100644
index 0000000000000000000000000000000000000000..0d925111fa6e611ae919df8bb30bcda0f248c5b6
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/tests/test_core_metadata.py
@@ -0,0 +1,622 @@
+from __future__ import annotations
+
+import functools
+import importlib
+import io
+from email import message_from_string
+from email.generator import Generator
+from email.message import EmailMessage, Message
+from email.parser import Parser
+from email.policy import EmailPolicy
+from inspect import cleandoc
+from pathlib import Path
+from unittest.mock import Mock
+
+import jaraco.path
+import pytest
+from packaging.metadata import Metadata
+from packaging.requirements import Requirement
+
+from setuptools import _reqs, sic
+from setuptools._core_metadata import rfc822_escape, rfc822_unescape
+from setuptools.command.egg_info import egg_info, write_requirements
+from setuptools.config import expand, setupcfg
+from setuptools.dist import Distribution
+
+from .config.downloads import retrieve_file, urls_from_file
+
+EXAMPLE_BASE_INFO = dict(
+    name="package",
+    version="0.0.1",
+    author="Foo Bar",
+    author_email="foo@bar.net",
+    long_description="Long\ndescription",
+    description="Short description",
+    keywords=["one", "two"],
+)
+
+
+@pytest.mark.parametrize(
+    ("content", "result"),
+    (
+        pytest.param(
+            "Just a single line",
+            None,
+            id="single_line",
+        ),
+        pytest.param(
+            "Multiline\nText\nwithout\nextra indents\n",
+            None,
+            id="multiline",
+        ),
+        pytest.param(
+            "Multiline\n    With\n\nadditional\n  indentation",
+            None,
+            id="multiline_with_indentation",
+        ),
+        pytest.param(
+            "  Leading whitespace",
+            "Leading whitespace",
+            id="remove_leading_whitespace",
+        ),
+        pytest.param(
+            "  Leading whitespace\nIn\n    Multiline comment",
+            "Leading whitespace\nIn\n    Multiline comment",
+            id="remove_leading_whitespace_multiline",
+        ),
+    ),
+)
+def test_rfc822_unescape(content, result):
+    assert (result or content) == rfc822_unescape(rfc822_escape(content))
+
+
+def __read_test_cases():
+    base = EXAMPLE_BASE_INFO
+
+    params = functools.partial(dict, base)
+
+    return [
+        ('Metadata version 1.0', params()),
+        (
+            'Metadata Version 1.0: Short long description',
+            params(
+                long_description='Short long description',
+            ),
+        ),
+        (
+            'Metadata version 1.1: Classifiers',
+            params(
+                classifiers=[
+                    'Programming Language :: Python :: 3',
+                    'Programming Language :: Python :: 3.7',
+                    'License :: OSI Approved :: MIT License',
+                ],
+            ),
+        ),
+        (
+            'Metadata version 1.1: Download URL',
+            params(
+                download_url='https://example.com',
+            ),
+        ),
+        (
+            'Metadata Version 1.2: Requires-Python',
+            params(
+                python_requires='>=3.7',
+            ),
+        ),
+        pytest.param(
+            'Metadata Version 1.2: Project-Url',
+            params(project_urls=dict(Foo='https://example.bar')),
+            marks=pytest.mark.xfail(
+                reason="Issue #1578: project_urls not read",
+            ),
+        ),
+        (
+            'Metadata Version 2.1: Long Description Content Type',
+            params(
+                long_description_content_type='text/x-rst; charset=UTF-8',
+            ),
+        ),
+        (
+            'License',
+            params(
+                license='MIT',
+            ),
+        ),
+        (
+            'License multiline',
+            params(
+                license='This is a long license \nover multiple lines',
+            ),
+        ),
+        pytest.param(
+            'Metadata Version 2.1: Provides Extra',
+            params(provides_extras=['foo', 'bar']),
+            marks=pytest.mark.xfail(reason="provides_extras not read"),
+        ),
+        (
+            'Missing author',
+            dict(
+                name='foo',
+                version='1.0.0',
+                author_email='snorri@sturluson.name',
+            ),
+        ),
+        (
+            'Missing author e-mail',
+            dict(
+                name='foo',
+                version='1.0.0',
+                author='Snorri Sturluson',
+            ),
+        ),
+        (
+            'Missing author and e-mail',
+            dict(
+                name='foo',
+                version='1.0.0',
+            ),
+        ),
+        (
+            'Bypass normalized version',
+            dict(
+                name='foo',
+                version=sic('1.0.0a'),
+            ),
+        ),
+    ]
+
+
+@pytest.mark.parametrize(("name", "attrs"), __read_test_cases())
+def test_read_metadata(name, attrs):
+    dist = Distribution(attrs)
+    metadata_out = dist.metadata
+    dist_class = metadata_out.__class__
+
+    # Write to PKG_INFO and then load into a new metadata object
+    PKG_INFO = io.StringIO()
+
+    metadata_out.write_pkg_file(PKG_INFO)
+    PKG_INFO.seek(0)
+    pkg_info = PKG_INFO.read()
+    assert _valid_metadata(pkg_info)
+
+    PKG_INFO.seek(0)
+    metadata_in = dist_class()
+    metadata_in.read_pkg_file(PKG_INFO)
+
+    tested_attrs = [
+        ('name', dist_class.get_name),
+        ('version', dist_class.get_version),
+        ('author', dist_class.get_contact),
+        ('author_email', dist_class.get_contact_email),
+        ('metadata_version', dist_class.get_metadata_version),
+        ('provides', dist_class.get_provides),
+        ('description', dist_class.get_description),
+        ('long_description', dist_class.get_long_description),
+        ('download_url', dist_class.get_download_url),
+        ('keywords', dist_class.get_keywords),
+        ('platforms', dist_class.get_platforms),
+        ('obsoletes', dist_class.get_obsoletes),
+        ('requires', dist_class.get_requires),
+        ('classifiers', dist_class.get_classifiers),
+        ('project_urls', lambda s: getattr(s, 'project_urls', {})),
+        ('provides_extras', lambda s: getattr(s, 'provides_extras', {})),
+    ]
+
+    for attr, getter in tested_attrs:
+        assert getter(metadata_in) == getter(metadata_out)
+
+
+def __maintainer_test_cases():
+    attrs = {"name": "package", "version": "1.0", "description": "xxx"}
+
+    def merge_dicts(d1, d2):
+        d1 = d1.copy()
+        d1.update(d2)
+
+        return d1
+
+    return [
+        ('No author, no maintainer', attrs.copy()),
+        (
+            'Author (no e-mail), no maintainer',
+            merge_dicts(attrs, {'author': 'Author Name'}),
+        ),
+        (
+            'Author (e-mail), no maintainer',
+            merge_dicts(
+                attrs, {'author': 'Author Name', 'author_email': 'author@name.com'}
+            ),
+        ),
+        (
+            'No author, maintainer (no e-mail)',
+            merge_dicts(attrs, {'maintainer': 'Maintainer Name'}),
+        ),
+        (
+            'No author, maintainer (e-mail)',
+            merge_dicts(
+                attrs,
+                {
+                    'maintainer': 'Maintainer Name',
+                    'maintainer_email': 'maintainer@name.com',
+                },
+            ),
+        ),
+        (
+            'Author (no e-mail), Maintainer (no-email)',
+            merge_dicts(
+                attrs, {'author': 'Author Name', 'maintainer': 'Maintainer Name'}
+            ),
+        ),
+        (
+            'Author (e-mail), Maintainer (e-mail)',
+            merge_dicts(
+                attrs,
+                {
+                    'author': 'Author Name',
+                    'author_email': 'author@name.com',
+                    'maintainer': 'Maintainer Name',
+                    'maintainer_email': 'maintainer@name.com',
+                },
+            ),
+        ),
+        (
+            'No author (e-mail), no maintainer (e-mail)',
+            merge_dicts(
+                attrs,
+                {
+                    'author_email': 'author@name.com',
+                    'maintainer_email': 'maintainer@name.com',
+                },
+            ),
+        ),
+        ('Author unicode', merge_dicts(attrs, {'author': '鉄沢寛'})),
+        ('Maintainer unicode', merge_dicts(attrs, {'maintainer': 'Jan Łukasiewicz'})),
+    ]
+
+
+@pytest.mark.parametrize(("name", "attrs"), __maintainer_test_cases())
+def test_maintainer_author(name, attrs, tmpdir):
+    tested_keys = {
+        'author': 'Author',
+        'author_email': 'Author-email',
+        'maintainer': 'Maintainer',
+        'maintainer_email': 'Maintainer-email',
+    }
+
+    # Generate a PKG-INFO file
+    dist = Distribution(attrs)
+    fn = tmpdir.mkdir('pkg_info')
+    fn_s = str(fn)
+
+    dist.metadata.write_pkg_info(fn_s)
+
+    with open(str(fn.join('PKG-INFO')), 'r', encoding='utf-8') as f:
+        pkg_info = f.read()
+
+    assert _valid_metadata(pkg_info)
+
+    # Drop blank lines and strip lines from default description
+    raw_pkg_lines = pkg_info.splitlines()
+    pkg_lines = list(filter(None, raw_pkg_lines[:-2]))
+
+    pkg_lines_set = set(pkg_lines)
+
+    # Duplicate lines should not be generated
+    assert len(pkg_lines) == len(pkg_lines_set)
+
+    for fkey, dkey in tested_keys.items():
+        val = attrs.get(dkey, None)
+        if val is None:
+            for line in pkg_lines:
+                assert not line.startswith(fkey + ':')
+        else:
+            line = f'{fkey}: {val}'
+            assert line in pkg_lines_set
+
+
+class TestParityWithMetadataFromPyPaWheel:
+    def base_example(self):
+        attrs = dict(
+            **EXAMPLE_BASE_INFO,
+            # Example with complex requirement definition
+            python_requires=">=3.8",
+            install_requires="""
+            packaging==23.2
+            more-itertools==8.8.0; extra == "other"
+            jaraco.text==3.7.0
+            importlib-resources==5.10.2; python_version<"3.8"
+            importlib-metadata==6.0.0 ; python_version<"3.8"
+            colorama>=0.4.4; sys_platform == "win32"
+            """,
+            extras_require={
+                "testing": """
+                    pytest >= 6
+                    pytest-checkdocs >= 2.4
+                    tomli ; \\
+                            # Using stdlib when possible
+                            python_version < "3.11"
+                    ini2toml[lite]>=0.9
+                    """,
+                "other": [],
+            },
+        )
+        # Generate a PKG-INFO file using setuptools
+        return Distribution(attrs)
+
+    def test_requires_dist(self, tmp_path):
+        dist = self.base_example()
+        pkg_info = _get_pkginfo(dist)
+        assert _valid_metadata(pkg_info)
+
+        # Ensure Requires-Dist is present
+        expected = [
+            'Metadata-Version:',
+            'Requires-Python: >=3.8',
+            'Provides-Extra: other',
+            'Provides-Extra: testing',
+            'Requires-Dist: tomli; python_version < "3.11" and extra == "testing"',
+            'Requires-Dist: more-itertools==8.8.0; extra == "other"',
+            'Requires-Dist: ini2toml[lite]>=0.9; extra == "testing"',
+        ]
+        for line in expected:
+            assert line in pkg_info
+
+    HERE = Path(__file__).parent
+    EXAMPLES_FILE = HERE / "config/setupcfg_examples.txt"
+
+    @pytest.fixture(params=[None, *urls_from_file(EXAMPLES_FILE)])
+    def dist(self, request, monkeypatch, tmp_path):
+        """Example of distribution with arbitrary configuration"""
+        monkeypatch.chdir(tmp_path)
+        monkeypatch.setattr(expand, "read_attr", Mock(return_value="0.42"))
+        monkeypatch.setattr(expand, "read_files", Mock(return_value="hello world"))
+        monkeypatch.setattr(
+            Distribution, "_finalize_license_files", Mock(return_value=None)
+        )
+        if request.param is None:
+            yield self.base_example()
+        else:
+            # Real-world usage
+            config = retrieve_file(request.param)
+            yield setupcfg.apply_configuration(Distribution({}), config)
+
+    @pytest.mark.uses_network
+    def test_equivalent_output(self, tmp_path, dist):
+        """Ensure output from setuptools is equivalent to the one from `pypa/wheel`"""
+        # Generate a METADATA file using pypa/wheel for comparison
+        wheel_metadata = importlib.import_module("wheel.metadata")
+        pkginfo_to_metadata = getattr(wheel_metadata, "pkginfo_to_metadata", None)
+
+        if pkginfo_to_metadata is None:  # pragma: nocover
+            pytest.xfail(
+                "wheel.metadata.pkginfo_to_metadata is undefined, "
+                "(this is likely to be caused by API changes in pypa/wheel"
+            )
+
+        # Generate an simplified "egg-info" dir for pypa/wheel to convert
+        pkg_info = _get_pkginfo(dist)
+        egg_info_dir = tmp_path / "pkg.egg-info"
+        egg_info_dir.mkdir(parents=True)
+        (egg_info_dir / "PKG-INFO").write_text(pkg_info, encoding="utf-8")
+        write_requirements(egg_info(dist), egg_info_dir, egg_info_dir / "requires.txt")
+
+        # Get pypa/wheel generated METADATA but normalize requirements formatting
+        metadata_msg = pkginfo_to_metadata(egg_info_dir, egg_info_dir / "PKG-INFO")
+        metadata_str = _normalize_metadata(metadata_msg)
+        pkg_info_msg = message_from_string(pkg_info)
+        pkg_info_str = _normalize_metadata(pkg_info_msg)
+
+        # Compare setuptools PKG-INFO x pypa/wheel METADATA
+        assert metadata_str == pkg_info_str
+
+        # Make sure it parses/serializes well in pypa/wheel
+        _assert_roundtrip_message(pkg_info)
+
+
+class TestPEP643:
+    STATIC_CONFIG = {
+        "setup.cfg": cleandoc(
+            """
+            [metadata]
+            name = package
+            version = 0.0.1
+            author = Foo Bar
+            author_email = foo@bar.net
+            long_description = Long
+                               description
+            description = Short description
+            keywords = one, two
+            platforms = abcd
+            [options]
+            install_requires = requests
+            """
+        ),
+        "pyproject.toml": cleandoc(
+            """
+            [project]
+            name = "package"
+            version = "0.0.1"
+            authors = [
+              {name = "Foo Bar", email = "foo@bar.net"}
+            ]
+            description = "Short description"
+            readme = {text = "Long\\ndescription", content-type = "text/plain"}
+            keywords = ["one", "two"]
+            dependencies = ["requests"]
+            license = "AGPL-3.0-or-later"
+            [tool.setuptools]
+            provides = ["abcd"]
+            obsoletes = ["abcd"]
+            """
+        ),
+    }
+
+    @pytest.mark.parametrize("file", STATIC_CONFIG.keys())
+    def test_static_config_has_no_dynamic(self, file, tmpdir_cwd):
+        Path(file).write_text(self.STATIC_CONFIG[file], encoding="utf-8")
+        metadata = _get_metadata()
+        assert metadata.get_all("Dynamic") is None
+        assert metadata.get_all("dynamic") is None
+
+    @pytest.mark.parametrize("file", STATIC_CONFIG.keys())
+    @pytest.mark.parametrize(
+        "fields",
+        [
+            # Single dynamic field
+            {"requires-python": ("python_requires", ">=3.12")},
+            {"author-email": ("author_email", "snoopy@peanuts.com")},
+            {"keywords": ("keywords", ["hello", "world"])},
+            {"platform": ("platforms", ["abcd"])},
+            # Multiple dynamic fields
+            {
+                "summary": ("description", "hello world"),
+                "description": ("long_description", "bla bla bla bla"),
+                "requires-dist": ("install_requires", ["hello-world"]),
+            },
+        ],
+    )
+    def test_modified_fields_marked_as_dynamic(self, file, fields, tmpdir_cwd):
+        # We start with a static config
+        Path(file).write_text(self.STATIC_CONFIG[file], encoding="utf-8")
+        dist = _makedist()
+
+        # ... but then we simulate the effects of a plugin modifying the distribution
+        for attr, value in fields.values():
+            # `dist` and `dist.metadata` are complicated...
+            # Some attributes work when set on `dist`, others on `dist.metadata`...
+            # Here we set in both just in case (this also avoids calling `_finalize_*`)
+            setattr(dist, attr, value)
+            setattr(dist.metadata, attr, value)
+
+        # Then we should be able to list the modified fields as Dynamic
+        metadata = _get_metadata(dist)
+        assert set(metadata.get_all("Dynamic")) == set(fields)
+
+    @pytest.mark.parametrize(
+        "extra_toml",
+        [
+            "# Let setuptools autofill license-files",
+            "license-files = ['LICENSE*', 'AUTHORS*', 'NOTICE']",
+        ],
+    )
+    def test_license_files_dynamic(self, extra_toml, tmpdir_cwd):
+        # For simplicity (and for the time being) setuptools is not making
+        # any special handling to guarantee `License-File` is considered static.
+        # Instead we rely in the fact that, although suboptimal, it is OK to have
+        # it as dynamics, as per:
+        # https://github.com/pypa/setuptools/issues/4629#issuecomment-2331233677
+        files = {
+            "pyproject.toml": self.STATIC_CONFIG["pyproject.toml"].replace(
+                'license = "AGPL-3.0-or-later"',
+                f"dynamic = ['license']\n{extra_toml}",
+            ),
+            "LICENSE.md": "--- mock license ---",
+            "NOTICE": "--- mock notice ---",
+            "AUTHORS.txt": "--- me ---",
+        }
+        # Sanity checks:
+        assert extra_toml in files["pyproject.toml"]
+        assert 'license = "AGPL-3.0-or-later"' not in extra_toml
+
+        jaraco.path.build(files)
+        dist = _makedist(license_expression="AGPL-3.0-or-later")
+        metadata = _get_metadata(dist)
+        assert set(metadata.get_all("Dynamic")) == {
+            'license-file',
+            'license-expression',
+        }
+        assert metadata.get("License-Expression") == "AGPL-3.0-or-later"
+        assert set(metadata.get_all("License-File")) == {
+            "NOTICE",
+            "AUTHORS.txt",
+            "LICENSE.md",
+        }
+
+
+def _makedist(**attrs):
+    dist = Distribution(attrs)
+    dist.parse_config_files()
+    return dist
+
+
+def _assert_roundtrip_message(metadata: str) -> None:
+    """Emulate the way wheel.bdist_wheel parses and regenerates the message,
+    then ensures the metadata generated by setuptools is compatible.
+    """
+    with io.StringIO(metadata) as buffer:
+        msg = Parser(EmailMessage).parse(buffer)
+
+    serialization_policy = EmailPolicy(
+        utf8=True,
+        mangle_from_=False,
+        max_line_length=0,
+    )
+    with io.BytesIO() as buffer:
+        out = io.TextIOWrapper(buffer, encoding="utf-8")
+        Generator(out, policy=serialization_policy).flatten(msg)
+        out.flush()
+        regenerated = buffer.getvalue()
+
+    raw_metadata = bytes(metadata, "utf-8")
+    # Normalise newlines to avoid test errors on Windows:
+    raw_metadata = b"\n".join(raw_metadata.splitlines())
+    regenerated = b"\n".join(regenerated.splitlines())
+    assert regenerated == raw_metadata
+
+
+def _normalize_metadata(msg: Message) -> str:
+    """Allow equivalent metadata to be compared directly"""
+    # The main challenge regards the requirements and extras.
+    # Both setuptools and wheel already apply some level of normalization
+    # but they differ regarding which character is chosen, according to the
+    # following spec it should be "-":
+    # https://packaging.python.org/en/latest/specifications/name-normalization/
+
+    # Related issues:
+    # https://github.com/pypa/packaging/issues/845
+    # https://github.com/pypa/packaging/issues/644#issuecomment-2429813968
+
+    extras = {x.replace("_", "-"): x for x in msg.get_all("Provides-Extra", [])}
+    reqs = [
+        _normalize_req(req, extras)
+        for req in _reqs.parse(msg.get_all("Requires-Dist", []))
+    ]
+    del msg["Requires-Dist"]
+    del msg["Provides-Extra"]
+
+    # Ensure consistent ord
+    for req in sorted(reqs):
+        msg["Requires-Dist"] = req
+    for extra in sorted(extras):
+        msg["Provides-Extra"] = extra
+
+    # TODO: Handle lack of PEP 643 implementation in pypa/wheel?
+    del msg["Metadata-Version"]
+
+    return msg.as_string()
+
+
+def _normalize_req(req: Requirement, extras: dict[str, str]) -> str:
+    """Allow equivalent requirement objects to be compared directly"""
+    as_str = str(req).replace(req.name, req.name.replace("_", "-"))
+    for norm, orig in extras.items():
+        as_str = as_str.replace(orig, norm)
+    return as_str
+
+
+def _get_pkginfo(dist: Distribution):
+    with io.StringIO() as fp:
+        dist.metadata.write_pkg_file(fp)
+        return fp.getvalue()
+
+
+def _get_metadata(dist: Distribution | None = None):
+    return message_from_string(_get_pkginfo(dist or _makedist()))
+
+
+def _valid_metadata(text: str) -> bool:
+    metadata = Metadata.from_email(text, validate=True)  # can raise exceptions
+    return metadata is not None
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/tests/test_depends.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/tests/test_depends.py
new file mode 100644
index 0000000000000000000000000000000000000000..1714c041f7a23e1ecbfc3245bf964f75c13734ca
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/tests/test_depends.py
@@ -0,0 +1,15 @@
+import sys
+
+from setuptools import depends
+
+
+class TestGetModuleConstant:
+    def test_basic(self):
+        """
+        Invoke get_module_constant on a module in
+        the test package.
+        """
+        mod_name = 'setuptools.tests.mod_with_constant'
+        val = depends.get_module_constant(mod_name, 'value')
+        assert val == 'three, sir!'
+        assert 'setuptools.tests.mod_with_constant' not in sys.modules
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/tests/test_develop.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/tests/test_develop.py
new file mode 100644
index 0000000000000000000000000000000000000000..929fa9c285eb4d11e646dab2864be6d5fa023e2b
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/tests/test_develop.py
@@ -0,0 +1,175 @@
+"""develop tests"""
+
+import os
+import pathlib
+import platform
+import subprocess
+import sys
+
+import pytest
+
+from setuptools._path import paths_on_pythonpath
+from setuptools.command.develop import develop
+from setuptools.dist import Distribution
+
+from . import contexts, namespaces
+
+SETUP_PY = """\
+from setuptools import setup
+
+setup(name='foo',
+    packages=['foo'],
+)
+"""
+
+INIT_PY = """print "foo"
+"""
+
+
+@pytest.fixture
+def temp_user(monkeypatch):
+    with contexts.tempdir() as user_base:
+        with contexts.tempdir() as user_site:
+            monkeypatch.setattr('site.USER_BASE', user_base)
+            monkeypatch.setattr('site.USER_SITE', user_site)
+            yield
+
+
+@pytest.fixture
+def test_env(tmpdir, temp_user):
+    target = tmpdir
+    foo = target.mkdir('foo')
+    setup = target / 'setup.py'
+    if setup.isfile():
+        raise ValueError(dir(target))
+    with setup.open('w') as f:
+        f.write(SETUP_PY)
+    init = foo / '__init__.py'
+    with init.open('w') as f:
+        f.write(INIT_PY)
+    with target.as_cwd():
+        yield target
+
+
+class TestDevelop:
+    in_virtualenv = hasattr(sys, 'real_prefix')
+    in_venv = hasattr(sys, 'base_prefix') and sys.base_prefix != sys.prefix
+
+    def test_console_scripts(self, tmpdir):
+        """
+        Test that console scripts are installed and that they reference
+        only the project by name and not the current version.
+        """
+        pytest.skip(
+            "TODO: needs a fixture to cause 'develop' "
+            "to be invoked without mutating environment."
+        )
+        settings = dict(
+            name='foo',
+            packages=['foo'],
+            version='0.0',
+            entry_points={
+                'console_scripts': [
+                    'foocmd = foo:foo',
+                ],
+            },
+        )
+        dist = Distribution(settings)
+        dist.script_name = 'setup.py'
+        cmd = develop(dist)
+        cmd.ensure_finalized()
+        cmd.install_dir = tmpdir
+        cmd.run()
+        # assert '0.0' not in foocmd_text
+
+    @pytest.mark.xfail(reason="legacy behavior retained for compatibility #4167")
+    def test_egg_link_filename(self):
+        settings = dict(
+            name='Foo $$$ Bar_baz-bing',
+        )
+        dist = Distribution(settings)
+        cmd = develop(dist)
+        cmd.ensure_finalized()
+        link = pathlib.Path(cmd.egg_link)
+        assert link.suffix == '.egg-link'
+        assert link.stem == 'Foo_Bar_baz_bing'
+
+
+class TestResolver:
+    """
+    TODO: These tests were written with a minimal understanding
+    of what _resolve_setup_path is intending to do. Come up with
+    more meaningful cases that look like real-world scenarios.
+    """
+
+    def test_resolve_setup_path_cwd(self):
+        assert develop._resolve_setup_path('.', '.', '.') == '.'
+
+    def test_resolve_setup_path_one_dir(self):
+        assert develop._resolve_setup_path('pkgs', '.', 'pkgs') == '../'
+
+    def test_resolve_setup_path_one_dir_trailing_slash(self):
+        assert develop._resolve_setup_path('pkgs/', '.', 'pkgs') == '../'
+
+
+class TestNamespaces:
+    @staticmethod
+    def install_develop(src_dir, target):
+        develop_cmd = [
+            sys.executable,
+            'setup.py',
+            'develop',
+            '--install-dir',
+            str(target),
+        ]
+        with src_dir.as_cwd():
+            with paths_on_pythonpath([str(target)]):
+                subprocess.check_call(develop_cmd)
+
+    @pytest.mark.skipif(
+        bool(os.environ.get("APPVEYOR")),
+        reason="https://github.com/pypa/setuptools/issues/851",
+    )
+    @pytest.mark.skipif(
+        platform.python_implementation() == 'PyPy',
+        reason="https://github.com/pypa/setuptools/issues/1202",
+    )
+    def test_namespace_package_importable(self, tmpdir):
+        """
+        Installing two packages sharing the same namespace, one installed
+        naturally using pip or `--single-version-externally-managed`
+        and the other installed using `develop` should leave the namespace
+        in tact and both packages reachable by import.
+        """
+        pkg_A = namespaces.build_namespace_package(tmpdir, 'myns.pkgA')
+        pkg_B = namespaces.build_namespace_package(tmpdir, 'myns.pkgB')
+        target = tmpdir / 'packages'
+        # use pip to install to the target directory
+        install_cmd = [
+            sys.executable,
+            '-m',
+            'pip',
+            'install',
+            str(pkg_A),
+            '-t',
+            str(target),
+        ]
+        subprocess.check_call(install_cmd)
+        self.install_develop(pkg_B, target)
+        namespaces.make_site_dir(target)
+        try_import = [
+            sys.executable,
+            '-c',
+            'import myns.pkgA; import myns.pkgB',
+        ]
+        with paths_on_pythonpath([str(target)]):
+            subprocess.check_call(try_import)
+
+        # additionally ensure that pkg_resources import works
+        pkg_resources_imp = [
+            sys.executable,
+            '-c',
+            'import pkg_resources',
+        ]
+        with paths_on_pythonpath([str(target)]):
+            subprocess.check_call(pkg_resources_imp)
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/tests/test_dist.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/tests/test_dist.py
new file mode 100644
index 0000000000000000000000000000000000000000..e65ab310e7f2ad98b591affb352c855a2f86eda1
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/tests/test_dist.py
@@ -0,0 +1,278 @@
+import os
+import re
+import urllib.parse
+import urllib.request
+
+import pytest
+
+from setuptools import Distribution
+from setuptools.dist import check_package_data, check_specifier
+
+from .test_easy_install import make_trivial_sdist
+from .test_find_packages import ensure_files
+from .textwrap import DALS
+
+from distutils.errors import DistutilsSetupError
+
+
+def test_dist_fetch_build_egg(tmpdir):
+    """
+    Check multiple calls to `Distribution.fetch_build_egg` work as expected.
+    """
+    index = tmpdir.mkdir('index')
+    index_url = urllib.parse.urljoin('file://', urllib.request.pathname2url(str(index)))
+
+    def sdist_with_index(distname, version):
+        dist_dir = index.mkdir(distname)
+        dist_sdist = f'{distname}-{version}.tar.gz'
+        make_trivial_sdist(str(dist_dir.join(dist_sdist)), distname, version)
+        with dist_dir.join('index.html').open('w') as fp:
+            fp.write(
+                DALS(
+                    """
+                <!DOCTYPE html><html><body>
+                <a href="{dist_sdist}" rel="internal">{dist_sdist}</a><br/>
+                </body></html>
+                """
+                ).format(dist_sdist=dist_sdist)
+            )
+
+    sdist_with_index('barbazquux', '3.2.0')
+    sdist_with_index('barbazquux-runner', '2.11.1')
+    with tmpdir.join('setup.cfg').open('w') as fp:
+        fp.write(
+            DALS(
+                """
+            [easy_install]
+            index_url = {index_url}
+            """
+            ).format(index_url=index_url)
+        )
+    reqs = """
+    barbazquux-runner
+    barbazquux
+    """.split()
+    with tmpdir.as_cwd():
+        dist = Distribution()
+        dist.parse_config_files()
+        resolved_dists = [dist.fetch_build_egg(r) for r in reqs]
+    assert [dist.key for dist in resolved_dists if dist] == reqs
+
+
+EXAMPLE_BASE_INFO = dict(
+    name="package",
+    version="0.0.1",
+    author="Foo Bar",
+    author_email="foo@bar.net",
+    long_description="Long\ndescription",
+    description="Short description",
+    keywords=["one", "two"],
+)
+
+
+def test_provides_extras_deterministic_order():
+    attrs = dict(extras_require=dict(a=['foo'], b=['bar']))
+    dist = Distribution(attrs)
+    assert list(dist.metadata.provides_extras) == ['a', 'b']
+    attrs['extras_require'] = dict(reversed(attrs['extras_require'].items()))
+    dist = Distribution(attrs)
+    assert list(dist.metadata.provides_extras) == ['b', 'a']
+
+
+CHECK_PACKAGE_DATA_TESTS = (
+    # Valid.
+    (
+        {
+            '': ['*.txt', '*.rst'],
+            'hello': ['*.msg'],
+        },
+        None,
+    ),
+    # Not a dictionary.
+    (
+        (
+            ('', ['*.txt', '*.rst']),
+            ('hello', ['*.msg']),
+        ),
+        (
+            "'package_data' must be a dictionary mapping package"
+            " names to lists of string wildcard patterns"
+        ),
+    ),
+    # Invalid key type.
+    (
+        {
+            400: ['*.txt', '*.rst'],
+        },
+        ("keys of 'package_data' dict must be strings (got 400)"),
+    ),
+    # Invalid value type.
+    (
+        {
+            'hello': '*.msg',
+        },
+        (
+            "\"values of 'package_data' dict\" must be of type <tuple[str, ...] | list[str]>"
+            " (got '*.msg')"
+        ),
+    ),
+    # Invalid value type (generators are single use)
+    (
+        {
+            'hello': (x for x in "generator"),
+        },
+        (
+            "\"values of 'package_data' dict\" must be of type <tuple[str, ...] | list[str]>"
+            " (got <generator object"
+        ),
+    ),
+)
+
+
+@pytest.mark.parametrize(('package_data', 'expected_message'), CHECK_PACKAGE_DATA_TESTS)
+def test_check_package_data(package_data, expected_message):
+    if expected_message is None:
+        assert check_package_data(None, 'package_data', package_data) is None
+    else:
+        with pytest.raises(DistutilsSetupError, match=re.escape(expected_message)):
+            check_package_data(None, 'package_data', package_data)
+
+
+def test_check_specifier():
+    # valid specifier value
+    attrs = {'name': 'foo', 'python_requires': '>=3.0, !=3.1'}
+    dist = Distribution(attrs)
+    check_specifier(dist, attrs, attrs['python_requires'])
+
+    attrs = {'name': 'foo', 'python_requires': ['>=3.0', '!=3.1']}
+    dist = Distribution(attrs)
+    check_specifier(dist, attrs, attrs['python_requires'])
+
+    # invalid specifier value
+    attrs = {'name': 'foo', 'python_requires': '>=invalid-version'}
+    with pytest.raises(DistutilsSetupError):
+        dist = Distribution(attrs)
+
+
+def test_metadata_name():
+    with pytest.raises(DistutilsSetupError, match='missing.*name'):
+        Distribution()._validate_metadata()
+
+
+@pytest.mark.parametrize(
+    ('dist_name', 'py_module'),
+    [
+        ("my.pkg", "my_pkg"),
+        ("my-pkg", "my_pkg"),
+        ("my_pkg", "my_pkg"),
+        ("pkg", "pkg"),
+    ],
+)
+def test_dist_default_py_modules(tmp_path, dist_name, py_module):
+    (tmp_path / f"{py_module}.py").touch()
+
+    (tmp_path / "setup.py").touch()
+    (tmp_path / "noxfile.py").touch()
+    # ^-- make sure common tool files are ignored
+
+    attrs = {**EXAMPLE_BASE_INFO, "name": dist_name, "src_root": str(tmp_path)}
+    # Find `py_modules` corresponding to dist_name if not given
+    dist = Distribution(attrs)
+    dist.set_defaults()
+    assert dist.py_modules == [py_module]
+    # When `py_modules` is given, don't do anything
+    dist = Distribution({**attrs, "py_modules": ["explicity_py_module"]})
+    dist.set_defaults()
+    assert dist.py_modules == ["explicity_py_module"]
+    # When `packages` is given, don't do anything
+    dist = Distribution({**attrs, "packages": ["explicity_package"]})
+    dist.set_defaults()
+    assert not dist.py_modules
+
+
+@pytest.mark.parametrize(
+    ('dist_name', 'package_dir', 'package_files', 'packages'),
+    [
+        ("my.pkg", None, ["my_pkg/__init__.py", "my_pkg/mod.py"], ["my_pkg"]),
+        ("my-pkg", None, ["my_pkg/__init__.py", "my_pkg/mod.py"], ["my_pkg"]),
+        ("my_pkg", None, ["my_pkg/__init__.py", "my_pkg/mod.py"], ["my_pkg"]),
+        ("my.pkg", None, ["my/pkg/__init__.py"], ["my", "my.pkg"]),
+        (
+            "my_pkg",
+            None,
+            ["src/my_pkg/__init__.py", "src/my_pkg2/__init__.py"],
+            ["my_pkg", "my_pkg2"],
+        ),
+        (
+            "my_pkg",
+            {"pkg": "lib", "pkg2": "lib2"},
+            ["lib/__init__.py", "lib/nested/__init__.pyt", "lib2/__init__.py"],
+            ["pkg", "pkg.nested", "pkg2"],
+        ),
+    ],
+)
+def test_dist_default_packages(
+    tmp_path, dist_name, package_dir, package_files, packages
+):
+    ensure_files(tmp_path, package_files)
+
+    (tmp_path / "setup.py").touch()
+    (tmp_path / "noxfile.py").touch()
+    # ^-- should not be included by default
+
+    attrs = {
+        **EXAMPLE_BASE_INFO,
+        "name": dist_name,
+        "src_root": str(tmp_path),
+        "package_dir": package_dir,
+    }
+    # Find `packages` either corresponding to dist_name or inside src
+    dist = Distribution(attrs)
+    dist.set_defaults()
+    assert not dist.py_modules
+    assert not dist.py_modules
+    assert set(dist.packages) == set(packages)
+    # When `py_modules` is given, don't do anything
+    dist = Distribution({**attrs, "py_modules": ["explicit_py_module"]})
+    dist.set_defaults()
+    assert not dist.packages
+    assert set(dist.py_modules) == {"explicit_py_module"}
+    # When `packages` is given, don't do anything
+    dist = Distribution({**attrs, "packages": ["explicit_package"]})
+    dist.set_defaults()
+    assert not dist.py_modules
+    assert set(dist.packages) == {"explicit_package"}
+
+
+@pytest.mark.parametrize(
+    ('dist_name', 'package_dir', 'package_files'),
+    [
+        ("my.pkg.nested", None, ["my/pkg/nested/__init__.py"]),
+        ("my.pkg", None, ["my/pkg/__init__.py", "my/pkg/file.py"]),
+        ("my_pkg", None, ["my_pkg.py"]),
+        ("my_pkg", None, ["my_pkg/__init__.py", "my_pkg/nested/__init__.py"]),
+        ("my_pkg", None, ["src/my_pkg/__init__.py", "src/my_pkg/nested/__init__.py"]),
+        (
+            "my_pkg",
+            {"my_pkg": "lib", "my_pkg.lib2": "lib2"},
+            ["lib/__init__.py", "lib/nested/__init__.pyt", "lib2/__init__.py"],
+        ),
+        # Should not try to guess a name from multiple py_modules/packages
+        ("UNKNOWN", None, ["src/mod1.py", "src/mod2.py"]),
+        ("UNKNOWN", None, ["src/pkg1/__ini__.py", "src/pkg2/__init__.py"]),
+    ],
+)
+def test_dist_default_name(tmp_path, dist_name, package_dir, package_files):
+    """Make sure dist.name is discovered from packages/py_modules"""
+    ensure_files(tmp_path, package_files)
+    attrs = {
+        **EXAMPLE_BASE_INFO,
+        "src_root": "/".join(os.path.split(tmp_path)),  # POSIX-style
+        "package_dir": package_dir,
+    }
+    del attrs["name"]
+
+    dist = Distribution(attrs)
+    dist.set_defaults()
+    assert dist.py_modules or dist.packages
+    assert dist.get_name() == dist_name
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/tests/test_dist_info.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/tests/test_dist_info.py
new file mode 100644
index 0000000000000000000000000000000000000000..426694e0198fdbe6ee7466822bc7c15634e2b648
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/tests/test_dist_info.py
@@ -0,0 +1,210 @@
+"""Test .dist-info style distributions."""
+
+import pathlib
+import re
+import shutil
+import subprocess
+import sys
+from functools import partial
+
+import pytest
+
+import pkg_resources
+from setuptools.archive_util import unpack_archive
+
+from .textwrap import DALS
+
+read = partial(pathlib.Path.read_text, encoding="utf-8")
+
+
+class TestDistInfo:
+    metadata_base = DALS(
+        """
+        Metadata-Version: 1.2
+        Requires-Dist: splort (==4)
+        Provides-Extra: baz
+        Requires-Dist: quux (>=1.1); extra == 'baz'
+        """
+    )
+
+    @classmethod
+    def build_metadata(cls, **kwargs):
+        lines = ('{key}: {value}\n'.format(**locals()) for key, value in kwargs.items())
+        return cls.metadata_base + ''.join(lines)
+
+    @pytest.fixture
+    def metadata(self, tmpdir):
+        dist_info_name = 'VersionedDistribution-2.718.dist-info'
+        versioned = tmpdir / dist_info_name
+        versioned.mkdir()
+        filename = versioned / 'METADATA'
+        content = self.build_metadata(
+            Name='VersionedDistribution',
+        )
+        filename.write_text(content, encoding='utf-8')
+
+        dist_info_name = 'UnversionedDistribution.dist-info'
+        unversioned = tmpdir / dist_info_name
+        unversioned.mkdir()
+        filename = unversioned / 'METADATA'
+        content = self.build_metadata(
+            Name='UnversionedDistribution',
+            Version='0.3',
+        )
+        filename.write_text(content, encoding='utf-8')
+
+        return str(tmpdir)
+
+    def test_distinfo(self, metadata):
+        dists = dict(
+            (d.project_name, d) for d in pkg_resources.find_distributions(metadata)
+        )
+
+        assert len(dists) == 2, dists
+
+        unversioned = dists['UnversionedDistribution']
+        versioned = dists['VersionedDistribution']
+
+        assert versioned.version == '2.718'  # from filename
+        assert unversioned.version == '0.3'  # from METADATA
+
+    def test_conditional_dependencies(self, metadata):
+        specs = 'splort==4', 'quux>=1.1'
+        requires = list(map(pkg_resources.Requirement.parse, specs))
+
+        for d in pkg_resources.find_distributions(metadata):
+            assert d.requires() == requires[:1]
+            assert d.requires(extras=('baz',)) == [
+                requires[0],
+                pkg_resources.Requirement.parse('quux>=1.1;extra=="baz"'),
+            ]
+            assert d.extras == ['baz']
+
+    def test_invalid_version(self, tmp_path):
+        """
+        Supplying an invalid version crashes dist_info.
+        """
+        config = "[metadata]\nname=proj\nversion=42\n[egg_info]\ntag_build=invalid!!!\n"
+        (tmp_path / "setup.cfg").write_text(config, encoding="utf-8")
+        msg = re.compile("invalid version", re.M | re.I)
+        proc = run_command_inner("dist_info", cwd=tmp_path, check=False)
+        assert proc.returncode
+        assert msg.search(proc.stdout)
+        assert not list(tmp_path.glob("*.dist-info"))
+
+    def test_tag_arguments(self, tmp_path):
+        config = """
+        [metadata]
+        name=proj
+        version=42
+        [egg_info]
+        tag_date=1
+        tag_build=.post
+        """
+        (tmp_path / "setup.cfg").write_text(config, encoding="utf-8")
+
+        print(run_command("dist_info", "--no-date", cwd=tmp_path))
+        dist_info = next(tmp_path.glob("*.dist-info"))
+        assert dist_info.name.startswith("proj-42")
+        shutil.rmtree(dist_info)
+
+        print(run_command("dist_info", "--tag-build", ".a", cwd=tmp_path))
+        dist_info = next(tmp_path.glob("*.dist-info"))
+        assert dist_info.name.startswith("proj-42a")
+
+    @pytest.mark.parametrize("keep_egg_info", (False, True))
+    def test_output_dir(self, tmp_path, keep_egg_info):
+        config = "[metadata]\nname=proj\nversion=42\n"
+        (tmp_path / "setup.cfg").write_text(config, encoding="utf-8")
+        out = tmp_path / "__out"
+        out.mkdir()
+        opts = ["--keep-egg-info"] if keep_egg_info else []
+        run_command("dist_info", "--output-dir", out, *opts, cwd=tmp_path)
+        assert len(list(out.glob("*.dist-info"))) == 1
+        assert len(list(tmp_path.glob("*.dist-info"))) == 0
+        expected_egg_info = int(keep_egg_info)
+        assert len(list(out.glob("*.egg-info"))) == expected_egg_info
+        assert len(list(tmp_path.glob("*.egg-info"))) == 0
+        assert len(list(out.glob("*.__bkp__"))) == 0
+        assert len(list(tmp_path.glob("*.__bkp__"))) == 0
+
+
+class TestWheelCompatibility:
+    """Make sure the .dist-info directory produced with the ``dist_info`` command
+    is the same as the one produced by ``bdist_wheel``.
+    """
+
+    SETUPCFG = DALS(
+        """
+    [metadata]
+    name = {name}
+    version = {version}
+
+    [options]
+    install_requires =
+        foo>=12; sys_platform != "linux"
+
+    [options.extras_require]
+    test = pytest
+
+    [options.entry_points]
+    console_scripts =
+        executable-name = my_package.module:function
+    discover =
+        myproj = my_package.other_module:function
+    """
+    )
+
+    EGG_INFO_OPTS = [
+        # Related: #3088 #2872
+        ("", ""),
+        (".post", "[egg_info]\ntag_build = post\n"),
+        (".post", "[egg_info]\ntag_build = .post\n"),
+        (".post", "[egg_info]\ntag_build = post\ntag_date = 1\n"),
+        (".dev", "[egg_info]\ntag_build = .dev\n"),
+        (".dev", "[egg_info]\ntag_build = .dev\ntag_date = 1\n"),
+        ("a1", "[egg_info]\ntag_build = .a1\n"),
+        ("+local", "[egg_info]\ntag_build = +local\n"),
+    ]
+
+    @pytest.mark.parametrize("name", "my-proj my_proj my.proj My.Proj".split())
+    @pytest.mark.parametrize("version", ["0.42.13"])
+    @pytest.mark.parametrize(("suffix", "cfg"), EGG_INFO_OPTS)
+    def test_dist_info_is_the_same_as_in_wheel(
+        self, name, version, tmp_path, suffix, cfg
+    ):
+        config = self.SETUPCFG.format(name=name, version=version) + cfg
+
+        for i in "dir_wheel", "dir_dist":
+            (tmp_path / i).mkdir()
+            (tmp_path / i / "setup.cfg").write_text(config, encoding="utf-8")
+
+        run_command("bdist_wheel", cwd=tmp_path / "dir_wheel")
+        wheel = next(tmp_path.glob("dir_wheel/dist/*.whl"))
+        unpack_archive(wheel, tmp_path / "unpack")
+        wheel_dist_info = next(tmp_path.glob("unpack/*.dist-info"))
+
+        run_command("dist_info", cwd=tmp_path / "dir_dist")
+        dist_info = next(tmp_path.glob("dir_dist/*.dist-info"))
+
+        assert dist_info.name == wheel_dist_info.name
+        assert dist_info.name.startswith(f"my_proj-{version}{suffix}")
+        for file in "METADATA", "entry_points.txt":
+            assert read(dist_info / file) == read(wheel_dist_info / file)
+
+
+def run_command_inner(*cmd, **kwargs):
+    opts = {
+        "stderr": subprocess.STDOUT,
+        "stdout": subprocess.PIPE,
+        "text": True,
+        "encoding": "utf-8",
+        "check": True,
+        **kwargs,
+    }
+    cmd = [sys.executable, "-c", "__import__('setuptools').setup()", *map(str, cmd)]
+    return subprocess.run(cmd, **opts)
+
+
+def run_command(*args, **kwargs):
+    return run_command_inner(*args, **kwargs).stdout
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/tests/test_distutils_adoption.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/tests/test_distutils_adoption.py
new file mode 100644
index 0000000000000000000000000000000000000000..f99a58849950029f53322c19cde1c171fe26622c
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/tests/test_distutils_adoption.py
@@ -0,0 +1,198 @@
+import os
+import platform
+import sys
+import textwrap
+
+import pytest
+
+IS_PYPY = '__pypy__' in sys.builtin_module_names
+
+_TEXT_KWARGS = {"text": True, "encoding": "utf-8"}  # For subprocess.run
+
+
+def win_sr(env):
+    """
+    On Windows, SYSTEMROOT must be present to avoid
+
+    > Fatal Python error: _Py_HashRandomization_Init: failed to
+    > get random numbers to initialize Python
+    """
+    if env and platform.system() == 'Windows':
+        env['SYSTEMROOT'] = os.environ['SYSTEMROOT']
+    return env
+
+
+def find_distutils(venv, imports='distutils', env=None, **kwargs):
+    py_cmd = 'import {imports}; print(distutils.__file__)'.format(**locals())
+    cmd = ['python', '-c', py_cmd]
+    return venv.run(cmd, env=win_sr(env), **_TEXT_KWARGS, **kwargs)
+
+
+def count_meta_path(venv, env=None):
+    py_cmd = textwrap.dedent(
+        """
+        import sys
+        is_distutils = lambda finder: finder.__class__.__name__ == "DistutilsMetaFinder"
+        print(len(list(filter(is_distutils, sys.meta_path))))
+        """
+    )
+    cmd = ['python', '-c', py_cmd]
+    return int(venv.run(cmd, env=win_sr(env), **_TEXT_KWARGS))
+
+
+skip_without_stdlib_distutils = pytest.mark.skipif(
+    sys.version_info >= (3, 12),
+    reason='stdlib distutils is removed from Python 3.12+',
+)
+
+
+@skip_without_stdlib_distutils
+def test_distutils_stdlib(venv):
+    """
+    Ensure stdlib distutils is used when appropriate.
+    """
+    env = dict(SETUPTOOLS_USE_DISTUTILS='stdlib')
+    assert venv.name not in find_distutils(venv, env=env).split(os.sep)
+    assert count_meta_path(venv, env=env) == 0
+
+
+def test_distutils_local_with_setuptools(venv):
+    """
+    Ensure local distutils is used when appropriate.
+    """
+    env = dict(SETUPTOOLS_USE_DISTUTILS='local')
+    loc = find_distutils(venv, imports='setuptools, distutils', env=env)
+    assert venv.name in loc.split(os.sep)
+    assert count_meta_path(venv, env=env) <= 1
+
+
+@pytest.mark.xfail('IS_PYPY', reason='pypy imports distutils on startup')
+def test_distutils_local(venv):
+    """
+    Even without importing, the setuptools-local copy of distutils is
+    preferred.
+    """
+    env = dict(SETUPTOOLS_USE_DISTUTILS='local')
+    assert venv.name in find_distutils(venv, env=env).split(os.sep)
+    assert count_meta_path(venv, env=env) <= 1
+
+
+def test_pip_import(venv):
+    """
+    Ensure pip can be imported.
+    Regression test for #3002.
+    """
+    cmd = ['python', '-c', 'import pip']
+    venv.run(cmd, **_TEXT_KWARGS)
+
+
+def test_distutils_has_origin():
+    """
+    Distutils module spec should have an origin. #2990.
+    """
+    assert __import__('distutils').__spec__.origin
+
+
+ENSURE_IMPORTS_ARE_NOT_DUPLICATED = r"""
+# Depending on the importlib machinery and _distutils_hack, some imports are
+# duplicated resulting in different module objects being loaded, which prevents
+# patches as shown in #3042.
+# This script provides a way of verifying if this duplication is happening.
+
+from distutils import cmd
+import distutils.command.sdist as sdist
+
+# import last to prevent caching
+from distutils import {imported_module}
+
+for mod in (cmd, sdist):
+    assert mod.{imported_module} == {imported_module}, (
+        f"\n{{mod.dir_util}}\n!=\n{{{imported_module}}}"
+    )
+
+print("success")
+"""
+
+
+@pytest.mark.usefixtures("tmpdir_cwd")
+@pytest.mark.parametrize(
+    ('distutils_version', 'imported_module'),
+    [
+        pytest.param("stdlib", "dir_util", marks=skip_without_stdlib_distutils),
+        pytest.param("stdlib", "file_util", marks=skip_without_stdlib_distutils),
+        pytest.param("stdlib", "archive_util", marks=skip_without_stdlib_distutils),
+        ("local", "dir_util"),
+        ("local", "file_util"),
+        ("local", "archive_util"),
+    ],
+)
+def test_modules_are_not_duplicated_on_import(distutils_version, imported_module, venv):
+    env = dict(SETUPTOOLS_USE_DISTUTILS=distutils_version)
+    script = ENSURE_IMPORTS_ARE_NOT_DUPLICATED.format(imported_module=imported_module)
+    cmd = ['python', '-c', script]
+    output = venv.run(cmd, env=win_sr(env), **_TEXT_KWARGS).strip()
+    assert output == "success"
+
+
+ENSURE_LOG_IMPORT_IS_NOT_DUPLICATED = r"""
+import types
+import distutils.dist as dist
+from distutils import log
+if isinstance(dist.log, types.ModuleType):
+    assert dist.log == log, f"\n{dist.log}\n!=\n{log}"
+print("success")
+"""
+
+
+@pytest.mark.usefixtures("tmpdir_cwd")
+@pytest.mark.parametrize(
+    "distutils_version",
+    [
+        "local",
+        pytest.param("stdlib", marks=skip_without_stdlib_distutils),
+    ],
+)
+def test_log_module_is_not_duplicated_on_import(distutils_version, venv):
+    env = dict(SETUPTOOLS_USE_DISTUTILS=distutils_version)
+    cmd = ['python', '-c', ENSURE_LOG_IMPORT_IS_NOT_DUPLICATED]
+    output = venv.run(cmd, env=win_sr(env), **_TEXT_KWARGS).strip()
+    assert output == "success"
+
+
+ENSURE_CONSISTENT_ERROR_FROM_MODIFIED_PY = r"""
+from setuptools.modified import newer
+from {imported_module}.errors import DistutilsError
+
+# Can't use pytest.raises in this context
+try:
+    newer("", "")
+except DistutilsError:
+    print("success")
+else:
+    raise AssertionError("Expected to raise")
+"""
+
+
+@pytest.mark.usefixtures("tmpdir_cwd")
+@pytest.mark.parametrize(
+    ('distutils_version', 'imported_module'),
+    [
+        ("local", "distutils"),
+        # Unfortunately we still get ._distutils.errors.DistutilsError with SETUPTOOLS_USE_DISTUTILS=stdlib
+        # But that's a deprecated use-case we don't mind not fully supporting in newer code
+        pytest.param(
+            "stdlib", "setuptools._distutils", marks=skip_without_stdlib_distutils
+        ),
+    ],
+)
+def test_consistent_error_from_modified_py(distutils_version, imported_module, venv):
+    env = dict(SETUPTOOLS_USE_DISTUTILS=distutils_version)
+    cmd = [
+        'python',
+        '-c',
+        ENSURE_CONSISTENT_ERROR_FROM_MODIFIED_PY.format(
+            imported_module=imported_module
+        ),
+    ]
+    output = venv.run(cmd, env=win_sr(env), **_TEXT_KWARGS).strip()
+    assert output == "success"
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/tests/test_easy_install.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/tests/test_easy_install.py
new file mode 100644
index 0000000000000000000000000000000000000000..b58b0b66663e4bfb6e26bd730e62bff8267eeff5
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/tests/test_easy_install.py
@@ -0,0 +1,1476 @@
+"""Easy install Tests"""
+
+import contextlib
+import io
+import itertools
+import logging
+import os
+import pathlib
+import re
+import site
+import subprocess
+import sys
+import tarfile
+import tempfile
+import time
+import warnings
+import zipfile
+from pathlib import Path
+from typing import NamedTuple
+from unittest import mock
+
+import pytest
+from jaraco import path
+
+import pkg_resources
+import setuptools.command.easy_install as ei
+from pkg_resources import Distribution as PRDistribution, normalize_path, working_set
+from setuptools import sandbox
+from setuptools._normalization import safer_name
+from setuptools.command.easy_install import PthDistributions
+from setuptools.dist import Distribution
+from setuptools.sandbox import run_setup
+from setuptools.tests import fail_on_ascii
+from setuptools.tests.server import MockServer, path_to_url
+
+from . import contexts
+from .textwrap import DALS
+
+import distutils.errors
+
+
+@pytest.fixture(autouse=True)
+def pip_disable_index(monkeypatch):
+    """
+    Important: Disable the default index for pip to avoid
+    querying packages in the index and potentially resolving
+    and installing packages there.
+    """
+    monkeypatch.setenv('PIP_NO_INDEX', 'true')
+
+
+class FakeDist:
+    def get_entry_map(self, group):
+        if group != 'console_scripts':
+            return {}
+        return {'name': 'ep'}
+
+    def as_requirement(self):
+        return 'spec'
+
+
+SETUP_PY = DALS(
+    """
+    from setuptools import setup
+
+    setup()
+    """
+)
+
+
+class TestEasyInstallTest:
+    def test_get_script_args(self):
+        header = ei.CommandSpec.best().from_environment().as_header()
+        dist = FakeDist()
+        args = next(ei.ScriptWriter.get_args(dist))
+        _name, script = itertools.islice(args, 2)
+        assert script.startswith(header)
+        assert "'spec'" in script
+        assert "'console_scripts'" in script
+        assert "'name'" in script
+        assert re.search('^# EASY-INSTALL-ENTRY-SCRIPT', script, flags=re.MULTILINE)
+
+    def test_no_find_links(self):
+        # new option '--no-find-links', that blocks find-links added at
+        # the project level
+        dist = Distribution()
+        cmd = ei.easy_install(dist)
+        cmd.check_pth_processing = lambda: True
+        cmd.no_find_links = True
+        cmd.find_links = ['link1', 'link2']
+        cmd.install_dir = os.path.join(tempfile.mkdtemp(), 'ok')
+        cmd.args = ['ok']
+        cmd.ensure_finalized()
+        assert cmd.package_index.scanned_urls == {}
+
+        # let's try without it (default behavior)
+        cmd = ei.easy_install(dist)
+        cmd.check_pth_processing = lambda: True
+        cmd.find_links = ['link1', 'link2']
+        cmd.install_dir = os.path.join(tempfile.mkdtemp(), 'ok')
+        cmd.args = ['ok']
+        cmd.ensure_finalized()
+        keys = sorted(cmd.package_index.scanned_urls.keys())
+        assert keys == ['link1', 'link2']
+
+    def test_write_exception(self):
+        """
+        Test that `cant_write_to_target` is rendered as a DistutilsError.
+        """
+        dist = Distribution()
+        cmd = ei.easy_install(dist)
+        cmd.install_dir = os.getcwd()
+        with pytest.raises(distutils.errors.DistutilsError):
+            cmd.cant_write_to_target()
+
+    def test_all_site_dirs(self, monkeypatch):
+        """
+        get_site_dirs should always return site dirs reported by
+        site.getsitepackages.
+        """
+        path = normalize_path('/setuptools/test/site-packages')
+
+        def mock_gsp():
+            return [path]
+
+        monkeypatch.setattr(site, 'getsitepackages', mock_gsp, raising=False)
+        assert path in ei.get_site_dirs()
+
+    def test_all_site_dirs_works_without_getsitepackages(self, monkeypatch):
+        monkeypatch.delattr(site, 'getsitepackages', raising=False)
+        assert ei.get_site_dirs()
+
+    @pytest.fixture
+    def sdist_unicode(self, tmpdir):
+        files = [
+            (
+                'setup.py',
+                DALS(
+                    """
+                    import setuptools
+                    setuptools.setup(
+                        name="setuptools-test-unicode",
+                        version="1.0",
+                        packages=["mypkg"],
+                        include_package_data=True,
+                    )
+                    """
+                ),
+            ),
+            (
+                'mypkg/__init__.py',
+                "",
+            ),
+            (
+                'mypkg/☃.txt',
+                "",
+            ),
+        ]
+        sdist_name = 'setuptools-test-unicode-1.0.zip'
+        sdist = tmpdir / sdist_name
+        # can't use make_sdist, because the issue only occurs
+        #  with zip sdists.
+        sdist_zip = zipfile.ZipFile(str(sdist), 'w')
+        for filename, content in files:
+            sdist_zip.writestr(filename, content)
+        sdist_zip.close()
+        return str(sdist)
+
+    @fail_on_ascii
+    def test_unicode_filename_in_sdist(self, sdist_unicode, tmpdir, monkeypatch):
+        """
+        The install command should execute correctly even if
+        the package has unicode filenames.
+        """
+        dist = Distribution({'script_args': ['easy_install']})
+        target = (tmpdir / 'target').ensure_dir()
+        cmd = ei.easy_install(
+            dist,
+            install_dir=str(target),
+            args=['x'],
+        )
+        monkeypatch.setitem(os.environ, 'PYTHONPATH', str(target))
+        cmd.ensure_finalized()
+        cmd.easy_install(sdist_unicode)
+
+    @pytest.fixture
+    def sdist_unicode_in_script(self, tmpdir):
+        files = [
+            (
+                "setup.py",
+                DALS(
+                    """
+                    import setuptools
+                    setuptools.setup(
+                        name="setuptools-test-unicode",
+                        version="1.0",
+                        packages=["mypkg"],
+                        include_package_data=True,
+                        scripts=['mypkg/unicode_in_script'],
+                    )
+                    """
+                ),
+            ),
+            ("mypkg/__init__.py", ""),
+            (
+                "mypkg/unicode_in_script",
+                DALS(
+                    """
+                    #!/bin/sh
+                    # á
+
+                    non_python_fn() {
+                    }
+                """
+                ),
+            ),
+        ]
+        sdist_name = "setuptools-test-unicode-script-1.0.zip"
+        sdist = tmpdir / sdist_name
+        # can't use make_sdist, because the issue only occurs
+        #  with zip sdists.
+        sdist_zip = zipfile.ZipFile(str(sdist), "w")
+        for filename, content in files:
+            sdist_zip.writestr(filename, content.encode('utf-8'))
+        sdist_zip.close()
+        return str(sdist)
+
+    @fail_on_ascii
+    def test_unicode_content_in_sdist(
+        self, sdist_unicode_in_script, tmpdir, monkeypatch
+    ):
+        """
+        The install command should execute correctly even if
+        the package has unicode in scripts.
+        """
+        dist = Distribution({"script_args": ["easy_install"]})
+        target = (tmpdir / "target").ensure_dir()
+        cmd = ei.easy_install(dist, install_dir=str(target), args=["x"])
+        monkeypatch.setitem(os.environ, "PYTHONPATH", str(target))
+        cmd.ensure_finalized()
+        cmd.easy_install(sdist_unicode_in_script)
+
+    @pytest.fixture
+    def sdist_script(self, tmpdir):
+        files = [
+            (
+                'setup.py',
+                DALS(
+                    """
+                    import setuptools
+                    setuptools.setup(
+                        name="setuptools-test-script",
+                        version="1.0",
+                        scripts=["mypkg_script"],
+                    )
+                    """
+                ),
+            ),
+            (
+                'mypkg_script',
+                DALS(
+                    """
+                     #/usr/bin/python
+                     print('mypkg_script')
+                     """
+                ),
+            ),
+        ]
+        sdist_name = 'setuptools-test-script-1.0.zip'
+        sdist = str(tmpdir / sdist_name)
+        make_sdist(sdist, files)
+        return sdist
+
+    @pytest.mark.skipif(
+        not sys.platform.startswith('linux'), reason="Test can only be run on Linux"
+    )
+    def test_script_install(self, sdist_script, tmpdir, monkeypatch):
+        """
+        Check scripts are installed.
+        """
+        dist = Distribution({'script_args': ['easy_install']})
+        target = (tmpdir / 'target').ensure_dir()
+        cmd = ei.easy_install(
+            dist,
+            install_dir=str(target),
+            args=['x'],
+        )
+        monkeypatch.setitem(os.environ, 'PYTHONPATH', str(target))
+        cmd.ensure_finalized()
+        cmd.easy_install(sdist_script)
+        assert (target / 'mypkg_script').exists()
+
+
+@pytest.mark.filterwarnings('ignore:Unbuilt egg')
+class TestPTHFileWriter:
+    def test_add_from_cwd_site_sets_dirty(self):
+        """a pth file manager should set dirty
+        if a distribution is in site but also the cwd
+        """
+        pth = PthDistributions('does-not_exist', [os.getcwd()])
+        assert not pth.dirty
+        pth.add(PRDistribution(os.getcwd()))
+        assert pth.dirty
+
+    def test_add_from_site_is_ignored(self):
+        location = '/test/location/does-not-have-to-exist'
+        # PthDistributions expects all locations to be normalized
+        location = pkg_resources.normalize_path(location)
+        pth = PthDistributions(
+            'does-not_exist',
+            [
+                location,
+            ],
+        )
+        assert not pth.dirty
+        pth.add(PRDistribution(location))
+        assert not pth.dirty
+
+    def test_many_pth_distributions_merge_together(self, tmpdir):
+        """
+        If the pth file is modified under the hood, then PthDistribution
+        will refresh its content before saving, merging contents when
+        necessary.
+        """
+        # putting the pth file in a dedicated sub-folder,
+        pth_subdir = tmpdir.join("pth_subdir")
+        pth_subdir.mkdir()
+        pth_path = str(pth_subdir.join("file1.pth"))
+        pth1 = PthDistributions(pth_path)
+        pth2 = PthDistributions(pth_path)
+        assert pth1.paths == pth2.paths == [], (
+            "unless there would be some default added at some point"
+        )
+        # and so putting the src_subdir in folder distinct than the pth one,
+        # so to keep it absolute by PthDistributions
+        new_src_path = tmpdir.join("src_subdir")
+        new_src_path.mkdir()  # must exist to be accounted
+        new_src_path_str = str(new_src_path)
+        pth1.paths.append(new_src_path_str)
+        pth1.save()
+        assert pth1.paths, (
+            "the new_src_path added must still be present/valid in pth1 after save"
+        )
+        # now,
+        assert new_src_path_str not in pth2.paths, (
+            "right before we save the entry should still not be present"
+        )
+        pth2.save()
+        assert new_src_path_str in pth2.paths, (
+            "the new_src_path entry should have been added by pth2 with its save() call"
+        )
+        assert pth2.paths[-1] == new_src_path, (
+            "and it should match exactly on the last entry actually "
+            "given we append to it in save()"
+        )
+        # finally,
+        assert PthDistributions(pth_path).paths == pth2.paths, (
+            "and we should have the exact same list at the end "
+            "with a fresh PthDistributions instance"
+        )
+
+
+@pytest.fixture
+def setup_context(tmpdir):
+    with (tmpdir / 'setup.py').open('w', encoding="utf-8") as f:
+        f.write(SETUP_PY)
+    with tmpdir.as_cwd():
+        yield tmpdir
+
+
+@pytest.mark.usefixtures("user_override")
+@pytest.mark.usefixtures("setup_context")
+class TestUserInstallTest:
+    # prevent check that site-packages is writable. easy_install
+    # shouldn't be writing to system site-packages during finalize
+    # options, but while it does, bypass the behavior.
+    prev_sp_write = mock.patch(
+        'setuptools.command.easy_install.easy_install.check_site_dir',
+        mock.Mock(),
+    )
+
+    # simulate setuptools installed in user site packages
+    @mock.patch('setuptools.command.easy_install.__file__', site.USER_SITE)
+    @mock.patch('site.ENABLE_USER_SITE', True)
+    @prev_sp_write
+    def test_user_install_not_implied_user_site_enabled(self):
+        self.assert_not_user_site()
+
+    @mock.patch('site.ENABLE_USER_SITE', False)
+    @prev_sp_write
+    def test_user_install_not_implied_user_site_disabled(self):
+        self.assert_not_user_site()
+
+    @staticmethod
+    def assert_not_user_site():
+        # create a finalized easy_install command
+        dist = Distribution()
+        dist.script_name = 'setup.py'
+        cmd = ei.easy_install(dist)
+        cmd.args = ['py']
+        cmd.ensure_finalized()
+        assert not cmd.user, 'user should not be implied'
+
+    def test_multiproc_atexit(self):
+        pytest.importorskip('multiprocessing')
+
+        log = logging.getLogger('test_easy_install')
+        logging.basicConfig(level=logging.INFO, stream=sys.stderr)
+        log.info('this should not break')
+
+    @pytest.fixture
+    def foo_package(self, tmpdir):
+        egg_file = tmpdir / 'foo-1.0.egg-info'
+        with egg_file.open('w') as f:
+            f.write('Name: foo\n')
+        return str(tmpdir)
+
+    @pytest.fixture
+    def install_target(self, tmpdir):
+        target = str(tmpdir)
+        with mock.patch('sys.path', sys.path + [target]):
+            python_path = os.path.pathsep.join(sys.path)
+            with mock.patch.dict(os.environ, PYTHONPATH=python_path):
+                yield target
+
+    def test_local_index(self, foo_package, install_target):
+        """
+        The local index must be used when easy_install locates installed
+        packages.
+        """
+        dist = Distribution()
+        dist.script_name = 'setup.py'
+        cmd = ei.easy_install(dist)
+        cmd.install_dir = install_target
+        cmd.args = ['foo']
+        cmd.ensure_finalized()
+        cmd.local_index.scan([foo_package])
+        res = cmd.easy_install('foo')
+        actual = os.path.normcase(os.path.realpath(res.location))
+        expected = os.path.normcase(os.path.realpath(foo_package))
+        assert actual == expected
+
+    @contextlib.contextmanager
+    def user_install_setup_context(self, *args, **kwargs):
+        """
+        Wrap sandbox.setup_context to patch easy_install in that context to
+        appear as user-installed.
+        """
+        with self.orig_context(*args, **kwargs):
+            import setuptools.command.easy_install as ei
+
+            ei.__file__ = site.USER_SITE
+            yield
+
+    def patched_setup_context(self):
+        self.orig_context = sandbox.setup_context
+
+        return mock.patch(
+            'setuptools.sandbox.setup_context',
+            self.user_install_setup_context,
+        )
+
+
+@pytest.fixture
+def distutils_package():
+    distutils_setup_py = SETUP_PY.replace(
+        'from setuptools import setup',
+        'from distutils.core import setup',
+    )
+    with contexts.tempdir(cd=os.chdir):
+        with open('setup.py', 'w', encoding="utf-8") as f:
+            f.write(distutils_setup_py)
+        yield
+
+
+@pytest.mark.usefixtures("distutils_package")
+class TestDistutilsPackage:
+    def test_bdist_egg_available_on_distutils_pkg(self):
+        run_setup('setup.py', ['bdist_egg'])
+
+
+@pytest.fixture
+def mock_index():
+    # set up a server which will simulate an alternate package index.
+    p_index = MockServer()
+    if p_index.server_port == 0:
+        # Some platforms (Jython) don't find a port to which to bind,
+        # so skip test for them.
+        pytest.skip("could not find a valid port")
+    p_index.start()
+    return p_index
+
+
+class TestInstallRequires:
+    def test_setup_install_includes_dependencies(self, tmp_path, mock_index):
+        """
+        When ``python setup.py install`` is called directly, it will use easy_install
+        to fetch dependencies.
+        """
+        # TODO: Remove these tests once `setup.py install` is completely removed
+        project_root = tmp_path / "project"
+        project_root.mkdir(exist_ok=True)
+        install_root = tmp_path / "install"
+        install_root.mkdir(exist_ok=True)
+
+        self.create_project(project_root)
+        cmd = [
+            sys.executable,
+            '-c',
+            '__import__("setuptools").setup()',
+            'install',
+            '--install-base',
+            str(install_root),
+            '--install-lib',
+            str(install_root),
+            '--install-headers',
+            str(install_root),
+            '--install-scripts',
+            str(install_root),
+            '--install-data',
+            str(install_root),
+            '--install-purelib',
+            str(install_root),
+            '--install-platlib',
+            str(install_root),
+        ]
+        env = {**os.environ, "__EASYINSTALL_INDEX": mock_index.url}
+        cp = subprocess.run(
+            cmd,
+            cwd=str(project_root),
+            env=env,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT,
+            text=True,
+            encoding="utf-8",
+        )
+        assert cp.returncode != 0
+        try:
+            assert '/does-not-exist/' in {r.path for r in mock_index.requests}
+            assert next(
+                line
+                for line in cp.stdout.splitlines()
+                if "not find suitable distribution for" in line
+                and "does-not-exist" in line
+            )
+        except Exception:
+            if "failed to get random numbers" in cp.stdout:
+                pytest.xfail(f"{sys.platform} failure - {cp.stdout}")
+            raise
+
+    def create_project(self, root):
+        config = """
+        [metadata]
+        name = project
+        version = 42
+
+        [options]
+        install_requires = does-not-exist
+        py_modules = mod
+        """
+        (root / 'setup.cfg').write_text(DALS(config), encoding="utf-8")
+        (root / 'mod.py').touch()
+
+
+class TestSetupRequires:
+    def test_setup_requires_honors_fetch_params(self, mock_index, monkeypatch):
+        """
+        When easy_install installs a source distribution which specifies
+        setup_requires, it should honor the fetch parameters (such as
+        index-url, and find-links).
+        """
+        monkeypatch.setenv('PIP_RETRIES', '0')
+        monkeypatch.setenv('PIP_TIMEOUT', '0')
+        monkeypatch.setenv('PIP_NO_INDEX', 'false')
+        with contexts.quiet():
+            # create an sdist that has a build-time dependency.
+            with TestSetupRequires.create_sdist() as dist_file:
+                with contexts.tempdir() as temp_install_dir:
+                    with contexts.environment(PYTHONPATH=temp_install_dir):
+                        cmd = [
+                            sys.executable,
+                            '-c',
+                            '__import__("setuptools").setup()',
+                            'easy_install',
+                            '--index-url',
+                            mock_index.url,
+                            '--exclude-scripts',
+                            '--install-dir',
+                            temp_install_dir,
+                            dist_file,
+                        ]
+                        subprocess.Popen(cmd).wait()
+        # there should have been one requests to the server
+        assert [r.path for r in mock_index.requests] == ['/does-not-exist/']
+
+    @staticmethod
+    @contextlib.contextmanager
+    def create_sdist():
+        """
+        Return an sdist with a setup_requires dependency (of something that
+        doesn't exist)
+        """
+        with contexts.tempdir() as dir:
+            dist_path = os.path.join(dir, 'setuptools-test-fetcher-1.0.tar.gz')
+            make_sdist(
+                dist_path,
+                [
+                    (
+                        'setup.py',
+                        DALS(
+                            """
+                    import setuptools
+                    setuptools.setup(
+                        name="setuptools-test-fetcher",
+                        version="1.0",
+                        setup_requires = ['does-not-exist'],
+                    )
+                """
+                        ),
+                    ),
+                    ('setup.cfg', ''),
+                ],
+            )
+            yield dist_path
+
+    use_setup_cfg = (
+        (),
+        ('dependency_links',),
+        ('setup_requires',),
+        ('dependency_links', 'setup_requires'),
+    )
+
+    @pytest.mark.parametrize('use_setup_cfg', use_setup_cfg)
+    def test_setup_requires_overrides_version_conflict(self, use_setup_cfg):
+        """
+        Regression test for distribution issue 323:
+        https://bitbucket.org/tarek/distribute/issues/323
+
+        Ensures that a distribution's setup_requires requirements can still be
+        installed and used locally even if a conflicting version of that
+        requirement is already on the path.
+        """
+
+        fake_dist = PRDistribution(
+            'does-not-matter', project_name='foobar', version='0.0'
+        )
+        working_set.add(fake_dist)
+
+        with contexts.save_pkg_resources_state():
+            with contexts.tempdir() as temp_dir:
+                test_pkg = create_setup_requires_package(
+                    temp_dir, use_setup_cfg=use_setup_cfg
+                )
+                test_setup_py = os.path.join(test_pkg, 'setup.py')
+                with contexts.quiet() as (stdout, _stderr):
+                    # Don't even need to install the package, just
+                    # running the setup.py at all is sufficient
+                    run_setup(test_setup_py, ['--name'])
+
+                lines = stdout.readlines()
+                assert len(lines) > 0
+                assert lines[-1].strip() == 'test_pkg'
+
+    @pytest.mark.parametrize('use_setup_cfg', use_setup_cfg)
+    def test_setup_requires_override_nspkg(self, use_setup_cfg):
+        """
+        Like ``test_setup_requires_overrides_version_conflict`` but where the
+        ``setup_requires`` package is part of a namespace package that has
+        *already* been imported.
+        """
+
+        with contexts.save_pkg_resources_state():
+            with contexts.tempdir() as temp_dir:
+                foobar_1_archive = os.path.join(temp_dir, 'foo_bar-0.1.tar.gz')
+                make_nspkg_sdist(foobar_1_archive, 'foo.bar', '0.1')
+                # Now actually go ahead an extract to the temp dir and add the
+                # extracted path to sys.path so foo.bar v0.1 is importable
+                foobar_1_dir = os.path.join(temp_dir, 'foo_bar-0.1')
+                os.mkdir(foobar_1_dir)
+                with tarfile.open(foobar_1_archive) as tf:
+                    tf.extraction_filter = lambda member, path: member
+                    tf.extractall(foobar_1_dir)
+                sys.path.insert(1, foobar_1_dir)
+
+                dist = PRDistribution(
+                    foobar_1_dir, project_name='foo.bar', version='0.1'
+                )
+                working_set.add(dist)
+
+                template = DALS(
+                    """\
+                    import foo  # Even with foo imported first the
+                                # setup_requires package should override
+                    import setuptools
+                    setuptools.setup(**%r)
+
+                    if not (hasattr(foo, '__path__') and
+                            len(foo.__path__) == 2):
+                        print('FAIL')
+
+                    if 'foo_bar-0.2' not in foo.__path__[0]:
+                        print('FAIL')
+                """
+                )
+
+                test_pkg = create_setup_requires_package(
+                    temp_dir,
+                    'foo.bar',
+                    '0.2',
+                    make_nspkg_sdist,
+                    template,
+                    use_setup_cfg=use_setup_cfg,
+                )
+
+                test_setup_py = os.path.join(test_pkg, 'setup.py')
+
+                with contexts.quiet() as (stdout, _stderr):
+                    try:
+                        # Don't even need to install the package, just
+                        # running the setup.py at all is sufficient
+                        run_setup(test_setup_py, ['--name'])
+                    except pkg_resources.VersionConflict:  # pragma: nocover
+                        pytest.fail(
+                            'Installing setup.py requirements caused a VersionConflict'
+                        )
+
+                assert 'FAIL' not in stdout.getvalue()
+                lines = stdout.readlines()
+                assert len(lines) > 0
+                assert lines[-1].strip() == 'test_pkg'
+
+    @pytest.mark.parametrize('use_setup_cfg', use_setup_cfg)
+    def test_setup_requires_with_attr_version(self, use_setup_cfg):
+        def make_dependency_sdist(dist_path, distname, version):
+            files = [
+                (
+                    'setup.py',
+                    DALS(
+                        f"""
+                    import setuptools
+                    setuptools.setup(
+                        name={distname!r},
+                        version={version!r},
+                        py_modules=[{distname!r}],
+                    )
+                    """
+                    ),
+                ),
+                (
+                    distname + '.py',
+                    DALS(
+                        """
+                    version = 42
+                    """
+                    ),
+                ),
+            ]
+            make_sdist(dist_path, files)
+
+        with contexts.save_pkg_resources_state():
+            with contexts.tempdir() as temp_dir:
+                test_pkg = create_setup_requires_package(
+                    temp_dir,
+                    setup_attrs=dict(version='attr: foobar.version'),
+                    make_package=make_dependency_sdist,
+                    use_setup_cfg=use_setup_cfg + ('version',),
+                )
+                test_setup_py = os.path.join(test_pkg, 'setup.py')
+                with contexts.quiet() as (stdout, _stderr):
+                    run_setup(test_setup_py, ['--version'])
+                lines = stdout.readlines()
+                assert len(lines) > 0
+                assert lines[-1].strip() == '42'
+
+    def test_setup_requires_honors_pip_env(self, mock_index, monkeypatch):
+        monkeypatch.setenv('PIP_RETRIES', '0')
+        monkeypatch.setenv('PIP_TIMEOUT', '0')
+        monkeypatch.setenv('PIP_NO_INDEX', 'false')
+        monkeypatch.setenv('PIP_INDEX_URL', mock_index.url)
+        with contexts.save_pkg_resources_state():
+            with contexts.tempdir() as temp_dir:
+                test_pkg = create_setup_requires_package(
+                    temp_dir,
+                    'python-xlib',
+                    '0.19',
+                    setup_attrs=dict(dependency_links=[]),
+                )
+                test_setup_cfg = os.path.join(test_pkg, 'setup.cfg')
+                with open(test_setup_cfg, 'w', encoding="utf-8") as fp:
+                    fp.write(
+                        DALS(
+                            """
+                        [easy_install]
+                        index_url = https://pypi.org/legacy/
+                        """
+                        )
+                    )
+                test_setup_py = os.path.join(test_pkg, 'setup.py')
+                with pytest.raises(distutils.errors.DistutilsError):
+                    run_setup(test_setup_py, ['--version'])
+        assert len(mock_index.requests) == 1
+        assert mock_index.requests[0].path == '/python-xlib/'
+
+    def test_setup_requires_with_pep508_url(self, mock_index, monkeypatch):
+        monkeypatch.setenv('PIP_RETRIES', '0')
+        monkeypatch.setenv('PIP_TIMEOUT', '0')
+        monkeypatch.setenv('PIP_INDEX_URL', mock_index.url)
+        with contexts.save_pkg_resources_state():
+            with contexts.tempdir() as temp_dir:
+                dep_sdist = os.path.join(temp_dir, 'dep.tar.gz')
+                make_trivial_sdist(dep_sdist, 'dependency', '42')
+                dep_url = path_to_url(dep_sdist, authority='localhost')
+                test_pkg = create_setup_requires_package(
+                    temp_dir,
+                    # Ignored (overridden by setup_attrs)
+                    'python-xlib',
+                    '0.19',
+                    setup_attrs=dict(setup_requires=f'dependency @ {dep_url}'),
+                )
+                test_setup_py = os.path.join(test_pkg, 'setup.py')
+                run_setup(test_setup_py, ['--version'])
+        assert len(mock_index.requests) == 0
+
+    def test_setup_requires_with_allow_hosts(self, mock_index):
+        """The `allow-hosts` option in not supported anymore."""
+        files = {
+            'test_pkg': {
+                'setup.py': DALS(
+                    """
+                    from setuptools import setup
+                    setup(setup_requires='python-xlib')
+                    """
+                ),
+                'setup.cfg': DALS(
+                    """
+                    [easy_install]
+                    allow_hosts = *
+                    """
+                ),
+            }
+        }
+        with contexts.save_pkg_resources_state():
+            with contexts.tempdir() as temp_dir:
+                path.build(files, prefix=temp_dir)
+                setup_py = str(pathlib.Path(temp_dir, 'test_pkg', 'setup.py'))
+                with pytest.raises(distutils.errors.DistutilsError):
+                    run_setup(setup_py, ['--version'])
+        assert len(mock_index.requests) == 0
+
+    def test_setup_requires_with_python_requires(self, monkeypatch, tmpdir):
+        """Check `python_requires` is honored."""
+        monkeypatch.setenv('PIP_RETRIES', '0')
+        monkeypatch.setenv('PIP_TIMEOUT', '0')
+        monkeypatch.setenv('PIP_NO_INDEX', '1')
+        monkeypatch.setenv('PIP_VERBOSE', '1')
+        dep_1_0_sdist = 'dep-1.0.tar.gz'
+        dep_1_0_url = path_to_url(str(tmpdir / dep_1_0_sdist))
+        dep_1_0_python_requires = '>=2.7'
+        make_python_requires_sdist(
+            str(tmpdir / dep_1_0_sdist), 'dep', '1.0', dep_1_0_python_requires
+        )
+        dep_2_0_sdist = 'dep-2.0.tar.gz'
+        dep_2_0_url = path_to_url(str(tmpdir / dep_2_0_sdist))
+        dep_2_0_python_requires = (
+            f'!={sys.version_info.major}.{sys.version_info.minor}.*'
+        )
+        make_python_requires_sdist(
+            str(tmpdir / dep_2_0_sdist), 'dep', '2.0', dep_2_0_python_requires
+        )
+        index = tmpdir / 'index.html'
+        index.write_text(
+            DALS(
+                """
+            <!DOCTYPE html>
+            <html><head><title>Links for dep</title></head>
+            <body>
+                <h1>Links for dep</h1>
+                <a href="{dep_1_0_url}"\
+data-requires-python="{dep_1_0_python_requires}">{dep_1_0_sdist}</a><br/>
+                <a href="{dep_2_0_url}"\
+data-requires-python="{dep_2_0_python_requires}">{dep_2_0_sdist}</a><br/>
+            </body>
+            </html>
+            """
+            ).format(
+                dep_1_0_url=dep_1_0_url,
+                dep_1_0_sdist=dep_1_0_sdist,
+                dep_1_0_python_requires=dep_1_0_python_requires,
+                dep_2_0_url=dep_2_0_url,
+                dep_2_0_sdist=dep_2_0_sdist,
+                dep_2_0_python_requires=dep_2_0_python_requires,
+            ),
+            'utf-8',
+        )
+        index_url = path_to_url(str(index))
+        with contexts.save_pkg_resources_state():
+            test_pkg = create_setup_requires_package(
+                str(tmpdir),
+                'python-xlib',
+                '0.19',  # Ignored (overridden by setup_attrs).
+                setup_attrs=dict(setup_requires='dep', dependency_links=[index_url]),
+            )
+            test_setup_py = os.path.join(test_pkg, 'setup.py')
+            run_setup(test_setup_py, ['--version'])
+        eggs = list(
+            map(str, pkg_resources.find_distributions(os.path.join(test_pkg, '.eggs')))
+        )
+        assert eggs == ['dep 1.0']
+
+    @pytest.mark.parametrize('with_dependency_links_in_setup_py', (False, True))
+    def test_setup_requires_with_find_links_in_setup_cfg(
+        self, monkeypatch, with_dependency_links_in_setup_py
+    ):
+        monkeypatch.setenv('PIP_RETRIES', '0')
+        monkeypatch.setenv('PIP_TIMEOUT', '0')
+        with contexts.save_pkg_resources_state():
+            with contexts.tempdir() as temp_dir:
+                make_trivial_sdist(
+                    os.path.join(temp_dir, 'python-xlib-42.tar.gz'), 'python-xlib', '42'
+                )
+                test_pkg = os.path.join(temp_dir, 'test_pkg')
+                test_setup_py = os.path.join(test_pkg, 'setup.py')
+                test_setup_cfg = os.path.join(test_pkg, 'setup.cfg')
+                os.mkdir(test_pkg)
+                with open(test_setup_py, 'w', encoding="utf-8") as fp:
+                    if with_dependency_links_in_setup_py:
+                        dependency_links = [os.path.join(temp_dir, 'links')]
+                    else:
+                        dependency_links = []
+                    fp.write(
+                        DALS(
+                            """
+                        from setuptools import installer, setup
+                        setup(setup_requires='python-xlib==42',
+                        dependency_links={dependency_links!r})
+                        """
+                        ).format(dependency_links=dependency_links)
+                    )
+                with open(test_setup_cfg, 'w', encoding="utf-8") as fp:
+                    fp.write(
+                        DALS(
+                            """
+                        [easy_install]
+                        index_url = {index_url}
+                        find_links = {find_links}
+                        """
+                        ).format(
+                            index_url=os.path.join(temp_dir, 'index'),
+                            find_links=temp_dir,
+                        )
+                    )
+                run_setup(test_setup_py, ['--version'])
+
+    def test_setup_requires_with_transitive_extra_dependency(self, monkeypatch):
+        """
+        Use case: installing a package with a build dependency on
+        an already installed `dep[extra]`, which in turn depends
+        on `extra_dep` (whose is not already installed).
+        """
+        with contexts.save_pkg_resources_state():
+            with contexts.tempdir() as temp_dir:
+                # Create source distribution for `extra_dep`.
+                make_trivial_sdist(
+                    os.path.join(temp_dir, 'extra_dep-1.0.tar.gz'), 'extra_dep', '1.0'
+                )
+                # Create source tree for `dep`.
+                dep_pkg = os.path.join(temp_dir, 'dep')
+                os.mkdir(dep_pkg)
+                path.build(
+                    {
+                        'setup.py': DALS(
+                            """
+                          import setuptools
+                          setuptools.setup(
+                              name='dep', version='2.0',
+                              extras_require={'extra': ['extra_dep']},
+                          )
+                         """
+                        ),
+                        'setup.cfg': '',
+                    },
+                    prefix=dep_pkg,
+                )
+                # "Install" dep.
+                run_setup(os.path.join(dep_pkg, 'setup.py'), ['dist_info'])
+                working_set.add_entry(dep_pkg)
+                # Create source tree for test package.
+                test_pkg = os.path.join(temp_dir, 'test_pkg')
+                test_setup_py = os.path.join(test_pkg, 'setup.py')
+                os.mkdir(test_pkg)
+                with open(test_setup_py, 'w', encoding="utf-8") as fp:
+                    fp.write(
+                        DALS(
+                            """
+                        from setuptools import installer, setup
+                        setup(setup_requires='dep[extra]')
+                        """
+                        )
+                    )
+                # Check...
+                monkeypatch.setenv('PIP_FIND_LINKS', str(temp_dir))
+                monkeypatch.setenv('PIP_NO_INDEX', '1')
+                monkeypatch.setenv('PIP_RETRIES', '0')
+                monkeypatch.setenv('PIP_TIMEOUT', '0')
+                run_setup(test_setup_py, ['--version'])
+
+    def test_setup_requires_with_distutils_command_dep(self, monkeypatch):
+        """
+        Use case: ensure build requirements' extras
+        are properly installed and activated.
+        """
+        with contexts.save_pkg_resources_state():
+            with contexts.tempdir() as temp_dir:
+                # Create source distribution for `extra_dep`.
+                make_sdist(
+                    os.path.join(temp_dir, 'extra_dep-1.0.tar.gz'),
+                    [
+                        (
+                            'setup.py',
+                            DALS(
+                                """
+                          import setuptools
+                          setuptools.setup(
+                              name='extra_dep',
+                              version='1.0',
+                              py_modules=['extra_dep'],
+                          )
+                          """
+                            ),
+                        ),
+                        ('setup.cfg', ''),
+                        ('extra_dep.py', ''),
+                    ],
+                )
+                # Create source tree for `epdep`.
+                dep_pkg = os.path.join(temp_dir, 'epdep')
+                os.mkdir(dep_pkg)
+                path.build(
+                    {
+                        'setup.py': DALS(
+                            """
+                          import setuptools
+                          setuptools.setup(
+                              name='dep', version='2.0',
+                              py_modules=['epcmd'],
+                              extras_require={'extra': ['extra_dep']},
+                              entry_points='''
+                                           [distutils.commands]
+                                           epcmd = epcmd:epcmd [extra]
+                                           ''',
+                          )
+                         """
+                        ),
+                        'setup.cfg': '',
+                        'epcmd.py': DALS(
+                            """
+                                     from distutils.command.build_py import build_py
+
+                                     import extra_dep
+
+                                     class epcmd(build_py):
+                                         pass
+                                     """
+                        ),
+                    },
+                    prefix=dep_pkg,
+                )
+                # "Install" dep.
+                run_setup(os.path.join(dep_pkg, 'setup.py'), ['dist_info'])
+                working_set.add_entry(dep_pkg)
+                # Create source tree for test package.
+                test_pkg = os.path.join(temp_dir, 'test_pkg')
+                test_setup_py = os.path.join(test_pkg, 'setup.py')
+                os.mkdir(test_pkg)
+                with open(test_setup_py, 'w', encoding="utf-8") as fp:
+                    fp.write(
+                        DALS(
+                            """
+                        from setuptools import installer, setup
+                        setup(setup_requires='dep[extra]')
+                        """
+                        )
+                    )
+                # Check...
+                monkeypatch.setenv('PIP_FIND_LINKS', str(temp_dir))
+                monkeypatch.setenv('PIP_NO_INDEX', '1')
+                monkeypatch.setenv('PIP_RETRIES', '0')
+                monkeypatch.setenv('PIP_TIMEOUT', '0')
+                run_setup(test_setup_py, ['epcmd'])
+
+
+def make_trivial_sdist(dist_path, distname, version):
+    """
+    Create a simple sdist tarball at dist_path, containing just a simple
+    setup.py.
+    """
+
+    make_sdist(
+        dist_path,
+        [
+            (
+                'setup.py',
+                DALS(
+                    f"""\
+             import setuptools
+             setuptools.setup(
+                 name={distname!r},
+                 version={version!r}
+             )
+         """
+                ),
+            ),
+            ('setup.cfg', ''),
+        ],
+    )
+
+
+def make_nspkg_sdist(dist_path, distname, version):
+    """
+    Make an sdist tarball with distname and version which also contains one
+    package with the same name as distname.  The top-level package is
+    designated a namespace package).
+    """
+    # Assert that the distname contains at least one period
+    assert '.' in distname
+
+    parts = distname.split('.')
+    nspackage = parts[0]
+
+    packages = ['.'.join(parts[:idx]) for idx in range(1, len(parts) + 1)]
+
+    setup_py = DALS(
+        f"""\
+        import setuptools
+        setuptools.setup(
+            name={distname!r},
+            version={version!r},
+            packages={packages!r},
+            namespace_packages=[{nspackage!r}]
+        )
+    """
+    )
+
+    init = "__import__('pkg_resources').declare_namespace(__name__)"
+
+    files = [('setup.py', setup_py), (os.path.join(nspackage, '__init__.py'), init)]
+    for package in packages[1:]:
+        filename = os.path.join(*(package.split('.') + ['__init__.py']))
+        files.append((filename, ''))
+
+    make_sdist(dist_path, files)
+
+
+def make_python_requires_sdist(dist_path, distname, version, python_requires):
+    make_sdist(
+        dist_path,
+        [
+            (
+                'setup.py',
+                DALS(
+                    """\
+                import setuptools
+                setuptools.setup(
+                  name={name!r},
+                  version={version!r},
+                  python_requires={python_requires!r},
+                )
+                """
+                ).format(
+                    name=distname, version=version, python_requires=python_requires
+                ),
+            ),
+            ('setup.cfg', ''),
+        ],
+    )
+
+
+def make_sdist(dist_path, files):
+    """
+    Create a simple sdist tarball at dist_path, containing the files
+    listed in ``files`` as ``(filename, content)`` tuples.
+    """
+
+    # Distributions with only one file don't play well with pip.
+    assert len(files) > 1
+    with tarfile.open(dist_path, 'w:gz') as dist:
+        for filename, content in files:
+            file_bytes = io.BytesIO(content.encode('utf-8'))
+            file_info = tarfile.TarInfo(name=filename)
+            file_info.size = len(file_bytes.getvalue())
+            file_info.mtime = int(time.time())
+            dist.addfile(file_info, fileobj=file_bytes)
+
+
+def create_setup_requires_package(
+    path,
+    distname='foobar',
+    version='0.1',
+    make_package=make_trivial_sdist,
+    setup_py_template=None,
+    setup_attrs=None,
+    use_setup_cfg=(),
+):
+    """Creates a source tree under path for a trivial test package that has a
+    single requirement in setup_requires--a tarball for that requirement is
+    also created and added to the dependency_links argument.
+
+    ``distname`` and ``version`` refer to the name/version of the package that
+    the test package requires via ``setup_requires``.  The name of the test
+    package itself is just 'test_pkg'.
+    """
+
+    normalized_distname = safer_name(distname)
+    test_setup_attrs = {
+        'name': 'test_pkg',
+        'version': '0.0',
+        'setup_requires': [f'{normalized_distname}=={version}'],
+        'dependency_links': [os.path.abspath(path)],
+    }
+    if setup_attrs:
+        test_setup_attrs.update(setup_attrs)
+
+    test_pkg = os.path.join(path, 'test_pkg')
+    os.mkdir(test_pkg)
+
+    # setup.cfg
+    if use_setup_cfg:
+        options = []
+        metadata = []
+        for name in use_setup_cfg:
+            value = test_setup_attrs.pop(name)
+            if name in 'name version'.split():
+                section = metadata
+            else:
+                section = options
+            if isinstance(value, (tuple, list)):
+                value = ';'.join(value)
+            section.append(f'{name}: {value}')
+        test_setup_cfg_contents = DALS(
+            """
+            [metadata]
+            {metadata}
+            [options]
+            {options}
+            """
+        ).format(
+            options='\n'.join(options),
+            metadata='\n'.join(metadata),
+        )
+    else:
+        test_setup_cfg_contents = ''
+    with open(os.path.join(test_pkg, 'setup.cfg'), 'w', encoding="utf-8") as f:
+        f.write(test_setup_cfg_contents)
+
+    # setup.py
+    if setup_py_template is None:
+        setup_py_template = DALS(
+            """\
+            import setuptools
+            setuptools.setup(**%r)
+        """
+        )
+    with open(os.path.join(test_pkg, 'setup.py'), 'w', encoding="utf-8") as f:
+        f.write(setup_py_template % test_setup_attrs)
+
+    foobar_path = os.path.join(path, f'{normalized_distname}-{version}.tar.gz')
+    make_package(foobar_path, distname, version)
+
+    return test_pkg
+
+
+@pytest.mark.skipif(
+    sys.platform.startswith('java') and ei.is_sh(sys.executable),
+    reason="Test cannot run under java when executable is sh",
+)
+class TestScriptHeader:
+    non_ascii_exe = '/Users/José/bin/python'
+    exe_with_spaces = r'C:\Program Files\Python36\python.exe'
+
+    def test_get_script_header(self):
+        expected = f'#!{ei.nt_quote_arg(os.path.normpath(sys.executable))}\n'
+        actual = ei.ScriptWriter.get_header('#!/usr/local/bin/python')
+        assert actual == expected
+
+    def test_get_script_header_args(self):
+        expected = f'#!{ei.nt_quote_arg(os.path.normpath(sys.executable))} -x\n'
+        actual = ei.ScriptWriter.get_header('#!/usr/bin/python -x')
+        assert actual == expected
+
+    def test_get_script_header_non_ascii_exe(self):
+        actual = ei.ScriptWriter.get_header(
+            '#!/usr/bin/python', executable=self.non_ascii_exe
+        )
+        expected = f'#!{self.non_ascii_exe} -x\n'
+        assert actual == expected
+
+    def test_get_script_header_exe_with_spaces(self):
+        actual = ei.ScriptWriter.get_header(
+            '#!/usr/bin/python', executable='"' + self.exe_with_spaces + '"'
+        )
+        expected = f'#!"{self.exe_with_spaces}"\n'
+        assert actual == expected
+
+
+class TestCommandSpec:
+    def test_custom_launch_command(self):
+        """
+        Show how a custom CommandSpec could be used to specify a #! executable
+        which takes parameters.
+        """
+        cmd = ei.CommandSpec(['/usr/bin/env', 'python3'])
+        assert cmd.as_header() == '#!/usr/bin/env python3\n'
+
+    def test_from_param_for_CommandSpec_is_passthrough(self):
+        """
+        from_param should return an instance of a CommandSpec
+        """
+        cmd = ei.CommandSpec(['python'])
+        cmd_new = ei.CommandSpec.from_param(cmd)
+        assert cmd is cmd_new
+
+    @mock.patch('sys.executable', TestScriptHeader.exe_with_spaces)
+    @mock.patch.dict(os.environ)
+    def test_from_environment_with_spaces_in_executable(self):
+        os.environ.pop('__PYVENV_LAUNCHER__', None)
+        cmd = ei.CommandSpec.from_environment()
+        assert len(cmd) == 1
+        assert cmd.as_header().startswith('#!"')
+
+    def test_from_simple_string_uses_shlex(self):
+        """
+        In order to support `executable = /usr/bin/env my-python`, make sure
+        from_param invokes shlex on that input.
+        """
+        cmd = ei.CommandSpec.from_param('/usr/bin/env my-python')
+        assert len(cmd) == 2
+        assert '"' not in cmd.as_header()
+
+    def test_from_param_raises_expected_error(self) -> None:
+        """
+        from_param should raise its own TypeError when the argument's type is unsupported
+        """
+        with pytest.raises(TypeError) as exc_info:
+            ei.CommandSpec.from_param(object())  # type: ignore[arg-type] # We want a type error here
+        assert (
+            str(exc_info.value) == "Argument has an unsupported type <class 'object'>"
+        ), exc_info.value
+
+
+class TestWindowsScriptWriter:
+    def test_header(self):
+        hdr = ei.WindowsScriptWriter.get_header('')
+        assert hdr.startswith('#!')
+        assert hdr.endswith('\n')
+        hdr = hdr.lstrip('#!')
+        hdr = hdr.rstrip('\n')
+        # header should not start with an escaped quote
+        assert not hdr.startswith('\\"')
+
+
+class VersionStub(NamedTuple):
+    major: int
+    minor: int
+    micro: int
+    releaselevel: str
+    serial: int
+
+
+def test_use_correct_python_version_string(tmpdir, tmpdir_cwd, monkeypatch):
+    # In issue #3001, easy_install wrongly uses the `python3.1` directory
+    # when the interpreter is `python3.10` and the `--user` option is given.
+    # See pypa/setuptools#3001.
+    dist = Distribution()
+    cmd = dist.get_command_obj('easy_install')
+    cmd.args = ['ok']
+    cmd.optimize = 0
+    cmd.user = True
+    cmd.install_userbase = str(tmpdir)
+    cmd.install_usersite = None
+    install_cmd = dist.get_command_obj('install')
+    install_cmd.install_userbase = str(tmpdir)
+    install_cmd.install_usersite = None
+
+    with monkeypatch.context() as patch, warnings.catch_warnings():
+        warnings.simplefilter("ignore")
+        version = '3.10.1 (main, Dec 21 2021, 09:17:12) [GCC 10.2.1 20210110]'
+        info = VersionStub(3, 10, 1, "final", 0)
+        patch.setattr('site.ENABLE_USER_SITE', True)
+        patch.setattr('sys.version', version)
+        patch.setattr('sys.version_info', info)
+        patch.setattr(cmd, 'create_home_path', mock.Mock())
+        cmd.finalize_options()
+
+    name = "pypy" if hasattr(sys, 'pypy_version_info') else "python"
+    install_dir = cmd.install_dir.lower()
+
+    # In some platforms (e.g. Windows), install_dir is mostly determined
+    # via `sysconfig`, which define constants eagerly at module creation.
+    # This means that monkeypatching `sys.version` to emulate 3.10 for testing
+    # may have no effect.
+    # The safest test here is to rely on the fact that 3.1 is no longer
+    # supported/tested, and make sure that if 'python3.1' ever appears in the string
+    # it is followed by another digit (e.g. 'python3.10').
+    if re.search(name + r'3\.?1', install_dir):
+        assert re.search(name + r'3\.?1\d', install_dir)
+
+    # The following "variables" are used for interpolation in distutils
+    # installation schemes, so it should be fair to treat them as "semi-public",
+    # or at least public enough so we can have a test to make sure they are correct
+    assert cmd.config_vars['py_version'] == '3.10.1'
+    assert cmd.config_vars['py_version_short'] == '3.10'
+    assert cmd.config_vars['py_version_nodot'] == '310'
+
+
+@pytest.mark.xfail(
+    sys.platform == "darwin",
+    reason="https://github.com/pypa/setuptools/pull/4716#issuecomment-2447624418",
+)
+def test_editable_user_and_build_isolation(setup_context, monkeypatch, tmp_path):
+    """`setup.py develop` should honor `--user` even under build isolation"""
+
+    # == Arrange ==
+    # Pretend that build isolation was enabled
+    # e.g pip sets the environment variable PYTHONNOUSERSITE=1
+    monkeypatch.setattr('site.ENABLE_USER_SITE', False)
+
+    # Patching $HOME for 2 reasons:
+    # 1. setuptools/command/easy_install.py:create_home_path
+    #    tries creating directories in $HOME.
+    #    Given::
+    #        self.config_vars['DESTDIRS'] = (
+    #            "/home/user/.pyenv/versions/3.9.10 "
+    #            "/home/user/.pyenv/versions/3.9.10/lib "
+    #            "/home/user/.pyenv/versions/3.9.10/lib/python3.9 "
+    #            "/home/user/.pyenv/versions/3.9.10/lib/python3.9/lib-dynload")
+    #    `create_home_path` will::
+    #        makedirs(
+    #            "/home/user/.pyenv/versions/3.9.10 "
+    #            "/home/user/.pyenv/versions/3.9.10/lib "
+    #            "/home/user/.pyenv/versions/3.9.10/lib/python3.9 "
+    #            "/home/user/.pyenv/versions/3.9.10/lib/python3.9/lib-dynload")
+    #
+    # 2. We are going to force `site` to update site.USER_BASE and site.USER_SITE
+    #    To point inside our new home
+    monkeypatch.setenv('HOME', str(tmp_path / '.home'))
+    monkeypatch.setenv('USERPROFILE', str(tmp_path / '.home'))
+    monkeypatch.setenv('APPDATA', str(tmp_path / '.home'))
+    monkeypatch.setattr('site.USER_BASE', None)
+    monkeypatch.setattr('site.USER_SITE', None)
+    user_site = Path(site.getusersitepackages())
+    user_site.mkdir(parents=True, exist_ok=True)
+
+    sys_prefix = tmp_path / '.sys_prefix'
+    sys_prefix.mkdir(parents=True, exist_ok=True)
+    monkeypatch.setattr('sys.prefix', str(sys_prefix))
+
+    setup_script = (
+        "__import__('setuptools').setup(name='aproj', version=42, packages=[])\n"
+    )
+    (tmp_path / "setup.py").write_text(setup_script, encoding="utf-8")
+
+    # == Sanity check ==
+    assert list(sys_prefix.glob("*")) == []
+    assert list(user_site.glob("*")) == []
+
+    # == Act ==
+    run_setup('setup.py', ['develop', '--user'])
+
+    # == Assert ==
+    # Should not install to sys.prefix
+    assert list(sys_prefix.glob("*")) == []
+    # Should install to user site
+    installed = {f.name for f in user_site.glob("*")}
+    # sometimes easy-install.pth is created and sometimes not
+    installed = installed - {"easy-install.pth"}
+    assert installed == {'aproj.egg-link'}
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/tests/test_editable_install.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/tests/test_editable_install.py
new file mode 100644
index 0000000000000000000000000000000000000000..038dcadf934af20dbe11dcb13ba324ceb30bf90d
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/tests/test_editable_install.py
@@ -0,0 +1,1289 @@
+from __future__ import annotations
+
+import os
+import platform
+import stat
+import subprocess
+import sys
+from copy import deepcopy
+from importlib import import_module
+from importlib.machinery import EXTENSION_SUFFIXES
+from pathlib import Path
+from textwrap import dedent
+from typing import Any
+from unittest.mock import Mock
+from uuid import uuid4
+
+import jaraco.envs
+import jaraco.path
+import pytest
+from path import Path as _Path
+
+from setuptools._importlib import resources as importlib_resources
+from setuptools.command.editable_wheel import (
+    _DebuggingTips,
+    _encode_pth,
+    _find_namespaces,
+    _find_package_roots,
+    _find_virtual_namespaces,
+    _finder_template,
+    _LinkTree,
+    _TopLevelFinder,
+    editable_wheel,
+)
+from setuptools.dist import Distribution
+from setuptools.extension import Extension
+from setuptools.warnings import SetuptoolsDeprecationWarning
+
+from . import contexts, namespaces
+
+from distutils.core import run_setup
+
+
+@pytest.fixture(params=["strict", "lenient"])
+def editable_opts(request):
+    if request.param == "strict":
+        return ["--config-settings", "editable-mode=strict"]
+    return []
+
+
+EXAMPLE = {
+    'pyproject.toml': dedent(
+        """\
+        [build-system]
+        requires = ["setuptools"]
+        build-backend = "setuptools.build_meta"
+
+        [project]
+        name = "mypkg"
+        version = "3.14159"
+        license = {text = "MIT"}
+        description = "This is a Python package"
+        dynamic = ["readme"]
+        classifiers = [
+            "Development Status :: 5 - Production/Stable",
+            "Intended Audience :: Developers"
+        ]
+        urls = {Homepage = "https://github.com"}
+
+        [tool.setuptools]
+        package-dir = {"" = "src"}
+        packages = {find = {where = ["src"]}}
+        license-files = ["LICENSE*"]
+
+        [tool.setuptools.dynamic]
+        readme = {file = "README.rst"}
+
+        [tool.distutils.egg_info]
+        tag-build = ".post0"
+        """
+    ),
+    "MANIFEST.in": dedent(
+        """\
+        global-include *.py *.txt
+        global-exclude *.py[cod]
+        prune dist
+        prune build
+        """
+    ).strip(),
+    "README.rst": "This is a ``README``",
+    "LICENSE.txt": "---- placeholder MIT license ----",
+    "src": {
+        "mypkg": {
+            "__init__.py": dedent(
+                """\
+                import sys
+                from importlib.metadata import PackageNotFoundError, version
+
+                try:
+                    __version__ = version(__name__)
+                except PackageNotFoundError:
+                    __version__ = "unknown"
+                """
+            ),
+            "__main__.py": dedent(
+                """\
+                from importlib.resources import read_text
+                from . import __version__, __name__ as parent
+                from .mod import x
+
+                data = read_text(parent, "data.txt")
+                print(__version__, data, x)
+                """
+            ),
+            "mod.py": "x = ''",
+            "data.txt": "Hello World",
+        }
+    },
+}
+
+
+SETUP_SCRIPT_STUB = "__import__('setuptools').setup()"
+
+
+@pytest.mark.xfail(sys.platform == "darwin", reason="pypa/setuptools#4328")
+@pytest.mark.parametrize(
+    "files",
+    [
+        {**EXAMPLE, "setup.py": SETUP_SCRIPT_STUB},
+        EXAMPLE,  # No setup.py script
+    ],
+)
+def test_editable_with_pyproject(tmp_path, venv, files, editable_opts):
+    project = tmp_path / "mypkg"
+    project.mkdir()
+    jaraco.path.build(files, prefix=project)
+
+    cmd = [
+        "python",
+        "-m",
+        "pip",
+        "install",
+        "--no-build-isolation",  # required to force current version of setuptools
+        "-e",
+        str(project),
+        *editable_opts,
+    ]
+    print(venv.run(cmd))
+
+    cmd = ["python", "-m", "mypkg"]
+    assert venv.run(cmd).strip() == "3.14159.post0 Hello World"
+
+    (project / "src/mypkg/data.txt").write_text("foobar", encoding="utf-8")
+    (project / "src/mypkg/mod.py").write_text("x = 42", encoding="utf-8")
+    assert venv.run(cmd).strip() == "3.14159.post0 foobar 42"
+
+
+def test_editable_with_flat_layout(tmp_path, venv, editable_opts):
+    files = {
+        "mypkg": {
+            "pyproject.toml": dedent(
+                """\
+                [build-system]
+                requires = ["setuptools", "wheel"]
+                build-backend = "setuptools.build_meta"
+
+                [project]
+                name = "mypkg"
+                version = "3.14159"
+
+                [tool.setuptools]
+                packages = ["pkg"]
+                py-modules = ["mod"]
+                """
+            ),
+            "pkg": {"__init__.py": "a = 4"},
+            "mod.py": "b = 2",
+        },
+    }
+    jaraco.path.build(files, prefix=tmp_path)
+    project = tmp_path / "mypkg"
+
+    cmd = [
+        "python",
+        "-m",
+        "pip",
+        "install",
+        "--no-build-isolation",  # required to force current version of setuptools
+        "-e",
+        str(project),
+        *editable_opts,
+    ]
+    print(venv.run(cmd))
+    cmd = ["python", "-c", "import pkg, mod; print(pkg.a, mod.b)"]
+    assert venv.run(cmd).strip() == "4 2"
+
+
+def test_editable_with_single_module(tmp_path, venv, editable_opts):
+    files = {
+        "mypkg": {
+            "pyproject.toml": dedent(
+                """\
+                [build-system]
+                requires = ["setuptools", "wheel"]
+                build-backend = "setuptools.build_meta"
+
+                [project]
+                name = "mod"
+                version = "3.14159"
+
+                [tool.setuptools]
+                py-modules = ["mod"]
+                """
+            ),
+            "mod.py": "b = 2",
+        },
+    }
+    jaraco.path.build(files, prefix=tmp_path)
+    project = tmp_path / "mypkg"
+
+    cmd = [
+        "python",
+        "-m",
+        "pip",
+        "install",
+        "--no-build-isolation",  # required to force current version of setuptools
+        "-e",
+        str(project),
+        *editable_opts,
+    ]
+    print(venv.run(cmd))
+    cmd = ["python", "-c", "import mod; print(mod.b)"]
+    assert venv.run(cmd).strip() == "2"
+
+
+class TestLegacyNamespaces:
+    # legacy => pkg_resources.declare_namespace(...) + setup(namespace_packages=...)
+
+    def test_nspkg_file_is_unique(self, tmp_path, monkeypatch):
+        deprecation = pytest.warns(
+            SetuptoolsDeprecationWarning, match=".*namespace_packages parameter.*"
+        )
+        installation_dir = tmp_path / ".installation_dir"
+        installation_dir.mkdir()
+        examples = (
+            "myns.pkgA",
+            "myns.pkgB",
+            "myns.n.pkgA",
+            "myns.n.pkgB",
+        )
+
+        for name in examples:
+            pkg = namespaces.build_namespace_package(tmp_path, name, version="42")
+            with deprecation, monkeypatch.context() as ctx:
+                ctx.chdir(pkg)
+                dist = run_setup("setup.py", stop_after="config")
+                cmd = editable_wheel(dist)
+                cmd.finalize_options()
+                editable_name = cmd.get_finalized_command("dist_info").name
+                cmd._install_namespaces(installation_dir, editable_name)
+
+        files = list(installation_dir.glob("*-nspkg.pth"))
+        assert len(files) == len(examples)
+
+    @pytest.mark.parametrize(
+        "impl",
+        (
+            "pkg_resources",
+            #  "pkgutil",  => does not work
+        ),
+    )
+    @pytest.mark.parametrize("ns", ("myns.n",))
+    def test_namespace_package_importable(
+        self, venv, tmp_path, ns, impl, editable_opts
+    ):
+        """
+        Installing two packages sharing the same namespace, one installed
+        naturally using pip or `--single-version-externally-managed`
+        and the other installed in editable mode should leave the namespace
+        intact and both packages reachable by import.
+        (Ported from test_develop).
+        """
+        build_system = """\
+        [build-system]
+        requires = ["setuptools"]
+        build-backend = "setuptools.build_meta"
+        """
+        pkg_A = namespaces.build_namespace_package(tmp_path, f"{ns}.pkgA", impl=impl)
+        pkg_B = namespaces.build_namespace_package(tmp_path, f"{ns}.pkgB", impl=impl)
+        (pkg_A / "pyproject.toml").write_text(build_system, encoding="utf-8")
+        (pkg_B / "pyproject.toml").write_text(build_system, encoding="utf-8")
+        # use pip to install to the target directory
+        opts = editable_opts[:]
+        opts.append("--no-build-isolation")  # force current version of setuptools
+        venv.run(["python", "-m", "pip", "install", str(pkg_A), *opts])
+        venv.run(["python", "-m", "pip", "install", "-e", str(pkg_B), *opts])
+        venv.run(["python", "-c", f"import {ns}.pkgA; import {ns}.pkgB"])
+        # additionally ensure that pkg_resources import works
+        venv.run(["python", "-c", "import pkg_resources"])
+
+
+class TestPep420Namespaces:
+    def test_namespace_package_importable(self, venv, tmp_path, editable_opts):
+        """
+        Installing two packages sharing the same namespace, one installed
+        normally using pip and the other installed in editable mode
+        should allow importing both packages.
+        """
+        pkg_A = namespaces.build_pep420_namespace_package(tmp_path, 'myns.n.pkgA')
+        pkg_B = namespaces.build_pep420_namespace_package(tmp_path, 'myns.n.pkgB')
+        # use pip to install to the target directory
+        opts = editable_opts[:]
+        opts.append("--no-build-isolation")  # force current version of setuptools
+        venv.run(["python", "-m", "pip", "install", str(pkg_A), *opts])
+        venv.run(["python", "-m", "pip", "install", "-e", str(pkg_B), *opts])
+        venv.run(["python", "-c", "import myns.n.pkgA; import myns.n.pkgB"])
+
+    def test_namespace_created_via_package_dir(self, venv, tmp_path, editable_opts):
+        """Currently users can create a namespace by tweaking `package_dir`"""
+        files = {
+            "pkgA": {
+                "pyproject.toml": dedent(
+                    """\
+                    [build-system]
+                    requires = ["setuptools", "wheel"]
+                    build-backend = "setuptools.build_meta"
+
+                    [project]
+                    name = "pkgA"
+                    version = "3.14159"
+
+                    [tool.setuptools]
+                    package-dir = {"myns.n.pkgA" = "src"}
+                    """
+                ),
+                "src": {"__init__.py": "a = 1"},
+            },
+        }
+        jaraco.path.build(files, prefix=tmp_path)
+        pkg_A = tmp_path / "pkgA"
+        pkg_B = namespaces.build_pep420_namespace_package(tmp_path, 'myns.n.pkgB')
+        pkg_C = namespaces.build_pep420_namespace_package(tmp_path, 'myns.n.pkgC')
+
+        # use pip to install to the target directory
+        opts = editable_opts[:]
+        opts.append("--no-build-isolation")  # force current version of setuptools
+        venv.run(["python", "-m", "pip", "install", str(pkg_A), *opts])
+        venv.run(["python", "-m", "pip", "install", "-e", str(pkg_B), *opts])
+        venv.run(["python", "-m", "pip", "install", "-e", str(pkg_C), *opts])
+        venv.run(["python", "-c", "from myns.n import pkgA, pkgB, pkgC"])
+
+    def test_namespace_accidental_config_in_lenient_mode(self, venv, tmp_path):
+        """Sometimes users might specify an ``include`` pattern that ignores parent
+        packages. In a normal installation this would ignore all modules inside the
+        parent packages, and make them namespaces (reported in issue #3504),
+        so the editable mode should preserve this behaviour.
+        """
+        files = {
+            "pkgA": {
+                "pyproject.toml": dedent(
+                    """\
+                    [build-system]
+                    requires = ["setuptools", "wheel"]
+                    build-backend = "setuptools.build_meta"
+
+                    [project]
+                    name = "pkgA"
+                    version = "3.14159"
+
+                    [tool.setuptools]
+                    packages.find.include = ["mypkg.*"]
+                    """
+                ),
+                "mypkg": {
+                    "__init__.py": "",
+                    "other.py": "b = 1",
+                    "n": {
+                        "__init__.py": "",
+                        "pkgA.py": "a = 1",
+                    },
+                },
+                "MANIFEST.in": EXAMPLE["MANIFEST.in"],
+            },
+        }
+        jaraco.path.build(files, prefix=tmp_path)
+        pkg_A = tmp_path / "pkgA"
+
+        # use pip to install to the target directory
+        opts = ["--no-build-isolation"]  # force current version of setuptools
+        venv.run(["python", "-m", "pip", "-v", "install", "-e", str(pkg_A), *opts])
+        out = venv.run(["python", "-c", "from mypkg.n import pkgA; print(pkgA.a)"])
+        assert out.strip() == "1"
+        cmd = """\
+        try:
+            import mypkg.other
+        except ImportError:
+            print("mypkg.other not defined")
+        """
+        out = venv.run(["python", "-c", dedent(cmd)])
+        assert "mypkg.other not defined" in out
+
+
+def test_editable_with_prefix(tmp_path, sample_project, editable_opts):
+    """
+    Editable install to a prefix should be discoverable.
+    """
+    prefix = tmp_path / 'prefix'
+
+    # figure out where pip will likely install the package
+    site_packages_all = [
+        prefix / Path(path).relative_to(sys.prefix)
+        for path in sys.path
+        if 'site-packages' in path and path.startswith(sys.prefix)
+    ]
+
+    for sp in site_packages_all:
+        sp.mkdir(parents=True)
+
+    # install workaround
+    _addsitedirs(site_packages_all)
+
+    env = dict(os.environ, PYTHONPATH=os.pathsep.join(map(str, site_packages_all)))
+    cmd = [
+        sys.executable,
+        '-m',
+        'pip',
+        'install',
+        '--editable',
+        str(sample_project),
+        '--prefix',
+        str(prefix),
+        '--no-build-isolation',
+        *editable_opts,
+    ]
+    subprocess.check_call(cmd, env=env)
+
+    # now run 'sample' with the prefix on the PYTHONPATH
+    bin = 'Scripts' if platform.system() == 'Windows' else 'bin'
+    exe = prefix / bin / 'sample'
+    subprocess.check_call([exe], env=env)
+
+
+class TestFinderTemplate:
+    """This test focus in getting a particular implementation detail right.
+    If at some point in time the implementation is changed for something different,
+    this test can be modified or even excluded.
+    """
+
+    def install_finder(self, finder):
+        loc = {}
+        exec(finder, loc, loc)
+        loc["install"]()
+
+    def test_packages(self, tmp_path):
+        files = {
+            "src1": {
+                "pkg1": {
+                    "__init__.py": "",
+                    "subpkg": {"mod1.py": "a = 42"},
+                },
+            },
+            "src2": {"mod2.py": "a = 43"},
+        }
+        jaraco.path.build(files, prefix=tmp_path)
+
+        mapping = {
+            "pkg1": str(tmp_path / "src1/pkg1"),
+            "mod2": str(tmp_path / "src2/mod2"),
+        }
+        template = _finder_template(str(uuid4()), mapping, {})
+
+        with contexts.save_paths(), contexts.save_sys_modules():
+            for mod in ("pkg1", "pkg1.subpkg", "pkg1.subpkg.mod1", "mod2"):
+                sys.modules.pop(mod, None)
+
+            self.install_finder(template)
+            mod1 = import_module("pkg1.subpkg.mod1")
+            mod2 = import_module("mod2")
+            subpkg = import_module("pkg1.subpkg")
+
+            assert mod1.a == 42
+            assert mod2.a == 43
+            expected = str((tmp_path / "src1/pkg1/subpkg").resolve())
+            assert_path(subpkg, expected)
+
+    def test_namespace(self, tmp_path):
+        files = {"pkg": {"__init__.py": "a = 13", "text.txt": "abc"}}
+        jaraco.path.build(files, prefix=tmp_path)
+
+        mapping = {"ns.othername": str(tmp_path / "pkg")}
+        namespaces = {"ns": []}
+
+        template = _finder_template(str(uuid4()), mapping, namespaces)
+        with contexts.save_paths(), contexts.save_sys_modules():
+            for mod in ("ns", "ns.othername"):
+                sys.modules.pop(mod, None)
+
+            self.install_finder(template)
+            pkg = import_module("ns.othername")
+            text = importlib_resources.files(pkg) / "text.txt"
+
+            expected = str((tmp_path / "pkg").resolve())
+            assert_path(pkg, expected)
+            assert pkg.a == 13
+
+            # Make sure resources can also be found
+            assert text.read_text(encoding="utf-8") == "abc"
+
+    def test_combine_namespaces(self, tmp_path):
+        files = {
+            "src1": {"ns": {"pkg1": {"__init__.py": "a = 13"}}},
+            "src2": {"ns": {"mod2.py": "b = 37"}},
+        }
+        jaraco.path.build(files, prefix=tmp_path)
+
+        mapping = {
+            "ns.pkgA": str(tmp_path / "src1/ns/pkg1"),
+            "ns": str(tmp_path / "src2/ns"),
+        }
+        namespaces_ = {"ns": [str(tmp_path / "src1"), str(tmp_path / "src2")]}
+        template = _finder_template(str(uuid4()), mapping, namespaces_)
+
+        with contexts.save_paths(), contexts.save_sys_modules():
+            for mod in ("ns", "ns.pkgA", "ns.mod2"):
+                sys.modules.pop(mod, None)
+
+            self.install_finder(template)
+            pkgA = import_module("ns.pkgA")
+            mod2 = import_module("ns.mod2")
+
+            expected = str((tmp_path / "src1/ns/pkg1").resolve())
+            assert_path(pkgA, expected)
+            assert pkgA.a == 13
+            assert mod2.b == 37
+
+    def test_combine_namespaces_nested(self, tmp_path):
+        """
+        Users may attempt to combine namespace packages in a nested way via
+        ``package_dir`` as shown in pypa/setuptools#4248.
+        """
+
+        files = {
+            "src": {"my_package": {"my_module.py": "a = 13"}},
+            "src2": {"my_package2": {"my_module2.py": "b = 37"}},
+        }
+
+        stack = jaraco.path.DirectoryStack()
+        with stack.context(tmp_path):
+            jaraco.path.build(files)
+            attrs = {
+                "script_name": "%PEP 517%",
+                "package_dir": {
+                    "different_name": "src/my_package",
+                    "different_name.subpkg": "src2/my_package2",
+                },
+                "packages": ["different_name", "different_name.subpkg"],
+            }
+            dist = Distribution(attrs)
+            finder = _TopLevelFinder(dist, str(uuid4()))
+            code = next(v for k, v in finder.get_implementation() if k.endswith(".py"))
+
+        with contexts.save_paths(), contexts.save_sys_modules():
+            for mod in attrs["packages"]:
+                sys.modules.pop(mod, None)
+
+            self.install_finder(code)
+            mod1 = import_module("different_name.my_module")
+            mod2 = import_module("different_name.subpkg.my_module2")
+
+            expected = str((tmp_path / "src/my_package/my_module.py").resolve())
+            assert str(Path(mod1.__file__).resolve()) == expected
+
+            expected = str((tmp_path / "src2/my_package2/my_module2.py").resolve())
+            assert str(Path(mod2.__file__).resolve()) == expected
+
+            assert mod1.a == 13
+            assert mod2.b == 37
+
+    def test_dynamic_path_computation(self, tmp_path):
+        # Follows the example in PEP 420
+        files = {
+            "project1": {"parent": {"child": {"one.py": "x = 1"}}},
+            "project2": {"parent": {"child": {"two.py": "x = 2"}}},
+            "project3": {"parent": {"child": {"three.py": "x = 3"}}},
+        }
+        jaraco.path.build(files, prefix=tmp_path)
+        mapping = {}
+        namespaces_ = {"parent": [str(tmp_path / "project1/parent")]}
+        template = _finder_template(str(uuid4()), mapping, namespaces_)
+
+        mods = (f"parent.child.{name}" for name in ("one", "two", "three"))
+        with contexts.save_paths(), contexts.save_sys_modules():
+            for mod in ("parent", "parent.child", "parent.child", *mods):
+                sys.modules.pop(mod, None)
+
+            self.install_finder(template)
+
+            one = import_module("parent.child.one")
+            assert one.x == 1
+
+            with pytest.raises(ImportError):
+                import_module("parent.child.two")
+
+            sys.path.append(str(tmp_path / "project2"))
+            two = import_module("parent.child.two")
+            assert two.x == 2
+
+            with pytest.raises(ImportError):
+                import_module("parent.child.three")
+
+            sys.path.append(str(tmp_path / "project3"))
+            three = import_module("parent.child.three")
+            assert three.x == 3
+
+    def test_no_recursion(self, tmp_path):
+        # See issue #3550
+        files = {
+            "pkg": {
+                "__init__.py": "from . import pkg",
+            },
+        }
+        jaraco.path.build(files, prefix=tmp_path)
+
+        mapping = {
+            "pkg": str(tmp_path / "pkg"),
+        }
+        template = _finder_template(str(uuid4()), mapping, {})
+
+        with contexts.save_paths(), contexts.save_sys_modules():
+            sys.modules.pop("pkg", None)
+
+            self.install_finder(template)
+            with pytest.raises(ImportError, match="pkg"):
+                import_module("pkg")
+
+    def test_similar_name(self, tmp_path):
+        files = {
+            "foo": {
+                "__init__.py": "",
+                "bar": {
+                    "__init__.py": "",
+                },
+            },
+        }
+        jaraco.path.build(files, prefix=tmp_path)
+
+        mapping = {
+            "foo": str(tmp_path / "foo"),
+        }
+        template = _finder_template(str(uuid4()), mapping, {})
+
+        with contexts.save_paths(), contexts.save_sys_modules():
+            sys.modules.pop("foo", None)
+            sys.modules.pop("foo.bar", None)
+
+            self.install_finder(template)
+            with pytest.raises(ImportError, match="foobar"):
+                import_module("foobar")
+
+    def test_case_sensitivity(self, tmp_path):
+        files = {
+            "foo": {
+                "__init__.py": "",
+                "lowercase.py": "x = 1",
+                "bar": {
+                    "__init__.py": "",
+                    "lowercase.py": "x = 2",
+                },
+            },
+        }
+        jaraco.path.build(files, prefix=tmp_path)
+        mapping = {
+            "foo": str(tmp_path / "foo"),
+        }
+        template = _finder_template(str(uuid4()), mapping, {})
+        with contexts.save_paths(), contexts.save_sys_modules():
+            sys.modules.pop("foo", None)
+
+            self.install_finder(template)
+            with pytest.raises(ImportError, match="'FOO'"):
+                import_module("FOO")
+
+            with pytest.raises(ImportError, match="'foo\\.LOWERCASE'"):
+                import_module("foo.LOWERCASE")
+
+            with pytest.raises(ImportError, match="'foo\\.bar\\.Lowercase'"):
+                import_module("foo.bar.Lowercase")
+
+            with pytest.raises(ImportError, match="'foo\\.BAR'"):
+                import_module("foo.BAR.lowercase")
+
+            with pytest.raises(ImportError, match="'FOO'"):
+                import_module("FOO.bar.lowercase")
+
+            mod = import_module("foo.lowercase")
+            assert mod.x == 1
+
+            mod = import_module("foo.bar.lowercase")
+            assert mod.x == 2
+
+    def test_namespace_case_sensitivity(self, tmp_path):
+        files = {
+            "pkg": {
+                "__init__.py": "a = 13",
+                "foo": {
+                    "__init__.py": "b = 37",
+                    "bar.py": "c = 42",
+                },
+            },
+        }
+        jaraco.path.build(files, prefix=tmp_path)
+
+        mapping = {"ns.othername": str(tmp_path / "pkg")}
+        namespaces = {"ns": []}
+
+        template = _finder_template(str(uuid4()), mapping, namespaces)
+        with contexts.save_paths(), contexts.save_sys_modules():
+            for mod in ("ns", "ns.othername"):
+                sys.modules.pop(mod, None)
+
+            self.install_finder(template)
+            pkg = import_module("ns.othername")
+            expected = str((tmp_path / "pkg").resolve())
+            assert_path(pkg, expected)
+            assert pkg.a == 13
+
+            foo = import_module("ns.othername.foo")
+            assert foo.b == 37
+
+            bar = import_module("ns.othername.foo.bar")
+            assert bar.c == 42
+
+            with pytest.raises(ImportError, match="'NS'"):
+                import_module("NS.othername.foo")
+
+            with pytest.raises(ImportError, match="'ns\\.othername\\.FOO\\'"):
+                import_module("ns.othername.FOO")
+
+            with pytest.raises(ImportError, match="'ns\\.othername\\.foo\\.BAR\\'"):
+                import_module("ns.othername.foo.BAR")
+
+    def test_intermediate_packages(self, tmp_path):
+        """
+        The finder should not import ``fullname`` if the intermediate segments
+        don't exist (see pypa/setuptools#4019).
+        """
+        files = {
+            "src": {
+                "mypkg": {
+                    "__init__.py": "",
+                    "config.py": "a = 13",
+                    "helloworld.py": "b = 13",
+                    "components": {
+                        "config.py": "a = 37",
+                    },
+                },
+            }
+        }
+        jaraco.path.build(files, prefix=tmp_path)
+
+        mapping = {"mypkg": str(tmp_path / "src/mypkg")}
+        template = _finder_template(str(uuid4()), mapping, {})
+
+        with contexts.save_paths(), contexts.save_sys_modules():
+            for mod in (
+                "mypkg",
+                "mypkg.config",
+                "mypkg.helloworld",
+                "mypkg.components",
+                "mypkg.components.config",
+                "mypkg.components.helloworld",
+            ):
+                sys.modules.pop(mod, None)
+
+            self.install_finder(template)
+
+            config = import_module("mypkg.components.config")
+            assert config.a == 37
+
+            helloworld = import_module("mypkg.helloworld")
+            assert helloworld.b == 13
+
+            with pytest.raises(ImportError):
+                import_module("mypkg.components.helloworld")
+
+
+def test_pkg_roots(tmp_path):
+    """This test focus in getting a particular implementation detail right.
+    If at some point in time the implementation is changed for something different,
+    this test can be modified or even excluded.
+    """
+    files = {
+        "a": {"b": {"__init__.py": "ab = 1"}, "__init__.py": "a = 1"},
+        "d": {"__init__.py": "d = 1", "e": {"__init__.py": "de = 1"}},
+        "f": {"g": {"h": {"__init__.py": "fgh = 1"}}},
+        "other": {"__init__.py": "abc = 1"},
+        "another": {"__init__.py": "abcxyz = 1"},
+        "yet_another": {"__init__.py": "mnopq = 1"},
+    }
+    jaraco.path.build(files, prefix=tmp_path)
+    package_dir = {
+        "a.b.c": "other",
+        "a.b.c.x.y.z": "another",
+        "m.n.o.p.q": "yet_another",
+    }
+    packages = [
+        "a",
+        "a.b",
+        "a.b.c",
+        "a.b.c.x.y",
+        "a.b.c.x.y.z",
+        "d",
+        "d.e",
+        "f",
+        "f.g",
+        "f.g.h",
+        "m.n.o.p.q",
+    ]
+    roots = _find_package_roots(packages, package_dir, tmp_path)
+    assert roots == {
+        "a": str(tmp_path / "a"),
+        "a.b.c": str(tmp_path / "other"),
+        "a.b.c.x.y.z": str(tmp_path / "another"),
+        "d": str(tmp_path / "d"),
+        "f": str(tmp_path / "f"),
+        "m.n.o.p.q": str(tmp_path / "yet_another"),
+    }
+
+    ns = set(dict(_find_namespaces(packages, roots)))
+    assert ns == {"f", "f.g"}
+
+    ns = set(_find_virtual_namespaces(roots))
+    assert ns == {"a.b", "a.b.c.x", "a.b.c.x.y", "m", "m.n", "m.n.o", "m.n.o.p"}
+
+
+class TestOverallBehaviour:
+    PYPROJECT = """\
+        [build-system]
+        requires = ["setuptools"]
+        build-backend = "setuptools.build_meta"
+
+        [project]
+        name = "mypkg"
+        version = "3.14159"
+        """
+
+    # Any: Would need a TypedDict. Keep it simple for tests
+    FLAT_LAYOUT: dict[str, Any] = {
+        "pyproject.toml": dedent(PYPROJECT),
+        "MANIFEST.in": EXAMPLE["MANIFEST.in"],
+        "otherfile.py": "",
+        "mypkg": {
+            "__init__.py": "",
+            "mod1.py": "var = 42",
+            "subpackage": {
+                "__init__.py": "",
+                "mod2.py": "var = 13",
+                "resource_file.txt": "resource 39",
+            },
+        },
+    }
+
+    EXAMPLES = {
+        "flat-layout": FLAT_LAYOUT,
+        "src-layout": {
+            "pyproject.toml": dedent(PYPROJECT),
+            "MANIFEST.in": EXAMPLE["MANIFEST.in"],
+            "otherfile.py": "",
+            "src": {"mypkg": FLAT_LAYOUT["mypkg"]},
+        },
+        "custom-layout": {
+            "pyproject.toml": dedent(PYPROJECT)
+            + dedent(
+                """\
+                [tool.setuptools]
+                packages = ["mypkg", "mypkg.subpackage"]
+
+                [tool.setuptools.package-dir]
+                "mypkg.subpackage" = "other"
+                """
+            ),
+            "MANIFEST.in": EXAMPLE["MANIFEST.in"],
+            "otherfile.py": "",
+            "mypkg": {
+                "__init__.py": "",
+                "mod1.py": FLAT_LAYOUT["mypkg"]["mod1.py"],
+            },
+            "other": FLAT_LAYOUT["mypkg"]["subpackage"],
+        },
+        "namespace": {
+            "pyproject.toml": dedent(PYPROJECT),
+            "MANIFEST.in": EXAMPLE["MANIFEST.in"],
+            "otherfile.py": "",
+            "src": {
+                "mypkg": {
+                    "mod1.py": FLAT_LAYOUT["mypkg"]["mod1.py"],
+                    "subpackage": FLAT_LAYOUT["mypkg"]["subpackage"],
+                },
+            },
+        },
+    }
+
+    @pytest.mark.xfail(sys.platform == "darwin", reason="pypa/setuptools#4328")
+    @pytest.mark.parametrize("layout", EXAMPLES.keys())
+    def test_editable_install(self, tmp_path, venv, layout, editable_opts):
+        project, _ = install_project(
+            "mypkg", venv, tmp_path, self.EXAMPLES[layout], *editable_opts
+        )
+
+        # Ensure stray files are not importable
+        cmd_import_error = """\
+        try:
+            import otherfile
+        except ImportError as ex:
+            print(ex)
+        """
+        out = venv.run(["python", "-c", dedent(cmd_import_error)])
+        assert "No module named 'otherfile'" in out
+
+        # Ensure the modules are importable
+        cmd_get_vars = """\
+        import mypkg, mypkg.mod1, mypkg.subpackage.mod2
+        print(mypkg.mod1.var, mypkg.subpackage.mod2.var)
+        """
+        out = venv.run(["python", "-c", dedent(cmd_get_vars)])
+        assert "42 13" in out
+
+        # Ensure resources are reachable
+        cmd_get_resource = """\
+        import mypkg.subpackage
+        from setuptools._importlib import resources as importlib_resources
+        text = importlib_resources.files(mypkg.subpackage) / "resource_file.txt"
+        print(text.read_text(encoding="utf-8"))
+        """
+        out = venv.run(["python", "-c", dedent(cmd_get_resource)])
+        assert "resource 39" in out
+
+        # Ensure files are editable
+        mod1 = next(project.glob("**/mod1.py"))
+        mod2 = next(project.glob("**/mod2.py"))
+        resource_file = next(project.glob("**/resource_file.txt"))
+
+        mod1.write_text("var = 17", encoding="utf-8")
+        mod2.write_text("var = 781", encoding="utf-8")
+        resource_file.write_text("resource 374", encoding="utf-8")
+
+        out = venv.run(["python", "-c", dedent(cmd_get_vars)])
+        assert "42 13" not in out
+        assert "17 781" in out
+
+        out = venv.run(["python", "-c", dedent(cmd_get_resource)])
+        assert "resource 39" not in out
+        assert "resource 374" in out
+
+
+class TestLinkTree:
+    FILES = deepcopy(TestOverallBehaviour.EXAMPLES["src-layout"])
+    FILES["pyproject.toml"] += dedent(
+        """\
+        [tool.setuptools]
+        # Temporary workaround: both `include-package-data` and `package-data` configs
+        # can be removed after #3260 is fixed.
+        include-package-data = false
+        package-data = {"*" = ["*.txt"]}
+
+        [tool.setuptools.packages.find]
+        where = ["src"]
+        exclude = ["*.subpackage*"]
+        """
+    )
+    FILES["src"]["mypkg"]["resource.not_in_manifest"] = "abc"
+
+    def test_generated_tree(self, tmp_path):
+        jaraco.path.build(self.FILES, prefix=tmp_path)
+
+        with _Path(tmp_path):
+            name = "mypkg-3.14159"
+            dist = Distribution({"script_name": "%PEP 517%"})
+            dist.parse_config_files()
+
+            wheel = Mock()
+            aux = tmp_path / ".aux"
+            build = tmp_path / ".build"
+            aux.mkdir()
+            build.mkdir()
+
+            build_py = dist.get_command_obj("build_py")
+            build_py.editable_mode = True
+            build_py.build_lib = str(build)
+            build_py.ensure_finalized()
+            outputs = build_py.get_outputs()
+            output_mapping = build_py.get_output_mapping()
+
+            make_tree = _LinkTree(dist, name, aux, build)
+            make_tree(wheel, outputs, output_mapping)
+
+            mod1 = next(aux.glob("**/mod1.py"))
+            expected = tmp_path / "src/mypkg/mod1.py"
+            assert_link_to(mod1, expected)
+
+            assert next(aux.glob("**/subpackage"), None) is None
+            assert next(aux.glob("**/mod2.py"), None) is None
+            assert next(aux.glob("**/resource_file.txt"), None) is None
+
+            assert next(aux.glob("**/resource.not_in_manifest"), None) is None
+
+    def test_strict_install(self, tmp_path, venv):
+        opts = ["--config-settings", "editable-mode=strict"]
+        install_project("mypkg", venv, tmp_path, self.FILES, *opts)
+
+        out = venv.run(["python", "-c", "import mypkg.mod1; print(mypkg.mod1.var)"])
+        assert "42" in out
+
+        # Ensure packages excluded from distribution are not importable
+        cmd_import_error = """\
+        try:
+            from mypkg import subpackage
+        except ImportError as ex:
+            print(ex)
+        """
+        out = venv.run(["python", "-c", dedent(cmd_import_error)])
+        assert "cannot import name 'subpackage'" in out
+
+        # Ensure resource files excluded from distribution are not reachable
+        cmd_get_resource = """\
+        import mypkg
+        from setuptools._importlib import resources as importlib_resources
+        try:
+            text = importlib_resources.files(mypkg) / "resource.not_in_manifest"
+            print(text.read_text(encoding="utf-8"))
+        except FileNotFoundError as ex:
+            print(ex)
+        """
+        out = venv.run(["python", "-c", dedent(cmd_get_resource)])
+        assert "No such file or directory" in out
+        assert "resource.not_in_manifest" in out
+
+
+@pytest.mark.filterwarnings("ignore:.*compat.*:setuptools.SetuptoolsDeprecationWarning")
+def test_compat_install(tmp_path, venv):
+    # TODO: Remove `compat` after Dec/2022.
+    opts = ["--config-settings", "editable-mode=compat"]
+    files = TestOverallBehaviour.EXAMPLES["custom-layout"]
+    install_project("mypkg", venv, tmp_path, files, *opts)
+
+    out = venv.run(["python", "-c", "import mypkg.mod1; print(mypkg.mod1.var)"])
+    assert "42" in out
+
+    expected_path = comparable_path(str(tmp_path))
+
+    # Compatible behaviour will make spurious modules and excluded
+    # files importable directly from the original path
+    for cmd in (
+        "import otherfile; print(otherfile)",
+        "import other; print(other)",
+        "import mypkg; print(mypkg)",
+    ):
+        out = comparable_path(venv.run(["python", "-c", cmd]))
+        assert expected_path in out
+
+    # Compatible behaviour will not consider custom mappings
+    cmd = """\
+    try:
+        from mypkg import subpackage;
+    except ImportError as ex:
+        print(ex)
+    """
+    out = venv.run(["python", "-c", dedent(cmd)])
+    assert "cannot import name 'subpackage'" in out
+
+
+def test_pbr_integration(tmp_path, venv, editable_opts):
+    """Ensure editable installs work with pbr, issue #3500"""
+    files = {
+        "pyproject.toml": dedent(
+            """\
+            [build-system]
+            requires = ["setuptools"]
+            build-backend = "setuptools.build_meta"
+            """
+        ),
+        "setup.py": dedent(
+            """\
+            __import__('setuptools').setup(
+                pbr=True,
+                setup_requires=["pbr"],
+            )
+            """
+        ),
+        "setup.cfg": dedent(
+            """\
+            [metadata]
+            name = mypkg
+
+            [files]
+            packages =
+                mypkg
+            """
+        ),
+        "mypkg": {
+            "__init__.py": "",
+            "hello.py": "print('Hello world!')",
+        },
+        "other": {"test.txt": "Another file in here."},
+    }
+    venv.run(["python", "-m", "pip", "install", "pbr"])
+
+    with contexts.environment(PBR_VERSION="0.42"):
+        install_project("mypkg", venv, tmp_path, files, *editable_opts)
+
+    out = venv.run(["python", "-c", "import mypkg.hello"])
+    assert "Hello world!" in out
+
+
+class TestCustomBuildPy:
+    """
+    Issue #3501 indicates that some plugins/customizations might rely on:
+
+    1. ``build_py`` not running
+    2. ``build_py`` always copying files to ``build_lib``
+
+    During the transition period setuptools should prevent potential errors from
+    happening due to those assumptions.
+    """
+
+    # TODO: Remove tests after _run_build_steps is removed.
+
+    FILES = {
+        **TestOverallBehaviour.EXAMPLES["flat-layout"],
+        "setup.py": dedent(
+            """\
+            import pathlib
+            from setuptools import setup
+            from setuptools.command.build_py import build_py as orig
+
+            class my_build_py(orig):
+                def run(self):
+                    super().run()
+                    raise ValueError("TEST_RAISE")
+
+            setup(cmdclass={"build_py": my_build_py})
+            """
+        ),
+    }
+
+    def test_safeguarded_from_errors(self, tmp_path, venv):
+        """Ensure that errors in custom build_py are reported as warnings"""
+        # Warnings should show up
+        _, out = install_project("mypkg", venv, tmp_path, self.FILES)
+        assert "SetuptoolsDeprecationWarning" in out
+        assert "ValueError: TEST_RAISE" in out
+        # but installation should be successful
+        out = venv.run(["python", "-c", "import mypkg.mod1; print(mypkg.mod1.var)"])
+        assert "42" in out
+
+
+class TestCustomBuildWheel:
+    def install_custom_build_wheel(self, dist):
+        bdist_wheel_cls = dist.get_command_class("bdist_wheel")
+
+        class MyBdistWheel(bdist_wheel_cls):
+            def get_tag(self):
+                # In issue #3513, we can see that some extensions may try to access
+                # the `plat_name` property in bdist_wheel
+                if self.plat_name.startswith("macosx-"):
+                    _ = "macOS platform"
+                return super().get_tag()
+
+        dist.cmdclass["bdist_wheel"] = MyBdistWheel
+
+    def test_access_plat_name(self, tmpdir_cwd):
+        # Even when a custom bdist_wheel tries to access plat_name the build should
+        # be successful
+        jaraco.path.build({"module.py": "x = 42"})
+        dist = Distribution()
+        dist.script_name = "setup.py"
+        dist.set_defaults()
+        self.install_custom_build_wheel(dist)
+        cmd = editable_wheel(dist)
+        cmd.ensure_finalized()
+        cmd.run()
+        wheel_file = str(next(Path().glob('dist/*.whl')))
+        assert "editable" in wheel_file
+
+
+class TestCustomBuildExt:
+    def install_custom_build_ext_distutils(self, dist):
+        from distutils.command.build_ext import build_ext as build_ext_cls
+
+        class MyBuildExt(build_ext_cls):
+            pass
+
+        dist.cmdclass["build_ext"] = MyBuildExt
+
+    @pytest.mark.skipif(
+        sys.platform != "linux", reason="compilers may fail without correct setup"
+    )
+    def test_distutils_leave_inplace_files(self, tmpdir_cwd):
+        jaraco.path.build({"module.c": ""})
+        attrs = {
+            "ext_modules": [Extension("module", ["module.c"])],
+        }
+        dist = Distribution(attrs)
+        dist.script_name = "setup.py"
+        dist.set_defaults()
+        self.install_custom_build_ext_distutils(dist)
+        cmd = editable_wheel(dist)
+        cmd.ensure_finalized()
+        cmd.run()
+        wheel_file = str(next(Path().glob('dist/*.whl')))
+        assert "editable" in wheel_file
+        files = [p for p in Path().glob("module.*") if p.suffix != ".c"]
+        assert len(files) == 1
+        name = files[0].name
+        assert any(name.endswith(ext) for ext in EXTENSION_SUFFIXES)
+
+
+def test_debugging_tips(tmpdir_cwd, monkeypatch):
+    """Make sure to display useful debugging tips to the user."""
+    jaraco.path.build({"module.py": "x = 42"})
+    dist = Distribution()
+    dist.script_name = "setup.py"
+    dist.set_defaults()
+    cmd = editable_wheel(dist)
+    cmd.ensure_finalized()
+
+    SimulatedErr = type("SimulatedErr", (Exception,), {})
+    simulated_failure = Mock(side_effect=SimulatedErr())
+    monkeypatch.setattr(cmd, "get_finalized_command", simulated_failure)
+
+    expected_msg = "following steps are recommended to help debug"
+    with pytest.raises(SimulatedErr), pytest.warns(_DebuggingTips, match=expected_msg):
+        cmd.run()
+
+
+@pytest.mark.filterwarnings("error")
+def test_encode_pth():
+    """Ensure _encode_pth function does not produce encoding warnings"""
+    content = _encode_pth("tkmilan_ç_utf8")  # no warnings (would be turned into errors)
+    assert isinstance(content, bytes)
+
+
+def install_project(name, venv, tmp_path, files, *opts):
+    project = tmp_path / name
+    project.mkdir()
+    jaraco.path.build(files, prefix=project)
+    opts = [*opts, "--no-build-isolation"]  # force current version of setuptools
+    out = venv.run(
+        ["python", "-m", "pip", "-v", "install", "-e", str(project), *opts],
+        stderr=subprocess.STDOUT,
+    )
+    return project, out
+
+
+def _addsitedirs(new_dirs):
+    """To use this function, it is necessary to insert new_dir in front of sys.path.
+    The Python process will try to import a ``sitecustomize`` module on startup.
+    If we manipulate sys.path/PYTHONPATH, we can force it to run our code,
+    which invokes ``addsitedir`` and ensure ``.pth`` files are loaded.
+    """
+    content = '\n'.join(
+        ("import site",)
+        + tuple(f"site.addsitedir({os.fspath(new_dir)!r})" for new_dir in new_dirs)
+    )
+    (new_dirs[0] / "sitecustomize.py").write_text(content, encoding="utf-8")
+
+
+# ---- Assertion Helpers ----
+
+
+def assert_path(pkg, expected):
+    # __path__ is not guaranteed to exist, so we have to account for that
+    if pkg.__path__:
+        path = next(iter(pkg.__path__), None)
+        if path:
+            assert str(Path(path).resolve()) == expected
+
+
+def assert_link_to(file: Path, other: Path) -> None:
+    if file.is_symlink():
+        assert str(file.resolve()) == str(other.resolve())
+    else:
+        file_stat = file.stat()
+        other_stat = other.stat()
+        assert file_stat[stat.ST_INO] == other_stat[stat.ST_INO]
+        assert file_stat[stat.ST_DEV] == other_stat[stat.ST_DEV]
+
+
+def comparable_path(str_with_path: str) -> str:
+    return str_with_path.lower().replace(os.sep, "/").replace("//", "/")
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/tests/test_egg_info.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/tests/test_egg_info.py
new file mode 100644
index 0000000000000000000000000000000000000000..528e2c13d8513727794cf65272aa20ce33e87d9d
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/tests/test_egg_info.py
@@ -0,0 +1,1305 @@
+from __future__ import annotations
+
+import ast
+import glob
+import os
+import re
+import stat
+import sys
+import time
+from pathlib import Path
+from unittest import mock
+
+import pytest
+from jaraco import path
+
+from setuptools import errors
+from setuptools.command.egg_info import egg_info, manifest_maker, write_entries
+from setuptools.dist import Distribution
+
+from . import contexts, environment
+from .textwrap import DALS
+
+
+class Environment(str):
+    pass
+
+
+@pytest.fixture
+def env():
+    with contexts.tempdir(prefix='setuptools-test.') as env_dir:
+        env = Environment(env_dir)
+        os.chmod(env_dir, stat.S_IRWXU)
+        subs = 'home', 'lib', 'scripts', 'data', 'egg-base'
+        env.paths = dict((dirname, os.path.join(env_dir, dirname)) for dirname in subs)
+        list(map(os.mkdir, env.paths.values()))
+        path.build({
+            env.paths['home']: {
+                '.pydistutils.cfg': DALS(
+                    """
+                [egg_info]
+                egg-base = {egg-base}
+                """.format(**env.paths)
+                )
+            }
+        })
+        yield env
+
+
+class TestEggInfo:
+    setup_script = DALS(
+        """
+        from setuptools import setup
+
+        setup(
+            name='foo',
+            py_modules=['hello'],
+            entry_points={'console_scripts': ['hi = hello.run']},
+            zip_safe=False,
+        )
+        """
+    )
+
+    def _create_project(self):
+        path.build({
+            'setup.py': self.setup_script,
+            'hello.py': DALS(
+                """
+                def run():
+                    print('hello')
+                """
+            ),
+        })
+
+    @staticmethod
+    def _extract_mv_version(pkg_info_lines: list[str]) -> tuple[int, int]:
+        version_str = pkg_info_lines[0].split(' ')[1]
+        major, minor = map(int, version_str.split('.')[:2])
+        return major, minor
+
+    def test_egg_info_save_version_info_setup_empty(self, tmpdir_cwd, env):
+        """
+        When the egg_info section is empty or not present, running
+        save_version_info should add the settings to the setup.cfg
+        in a deterministic order.
+        """
+        setup_cfg = os.path.join(env.paths['home'], 'setup.cfg')
+        dist = Distribution()
+        ei = egg_info(dist)
+        ei.initialize_options()
+        ei.save_version_info(setup_cfg)
+
+        with open(setup_cfg, 'r', encoding="utf-8") as f:
+            content = f.read()
+
+        assert '[egg_info]' in content
+        assert 'tag_build =' in content
+        assert 'tag_date = 0' in content
+
+        expected_order = (
+            'tag_build',
+            'tag_date',
+        )
+
+        self._validate_content_order(content, expected_order)
+
+    @staticmethod
+    def _validate_content_order(content, expected):
+        """
+        Assert that the strings in expected appear in content
+        in order.
+        """
+        pattern = '.*'.join(expected)
+        flags = re.MULTILINE | re.DOTALL
+        assert re.search(pattern, content, flags)
+
+    def test_egg_info_save_version_info_setup_defaults(self, tmpdir_cwd, env):
+        """
+        When running save_version_info on an existing setup.cfg
+        with the 'default' values present from a previous run,
+        the file should remain unchanged.
+        """
+        setup_cfg = os.path.join(env.paths['home'], 'setup.cfg')
+        path.build({
+            setup_cfg: DALS(
+                """
+            [egg_info]
+            tag_build =
+            tag_date = 0
+            """
+            ),
+        })
+        dist = Distribution()
+        ei = egg_info(dist)
+        ei.initialize_options()
+        ei.save_version_info(setup_cfg)
+
+        with open(setup_cfg, 'r', encoding="utf-8") as f:
+            content = f.read()
+
+        assert '[egg_info]' in content
+        assert 'tag_build =' in content
+        assert 'tag_date = 0' in content
+
+        expected_order = (
+            'tag_build',
+            'tag_date',
+        )
+
+        self._validate_content_order(content, expected_order)
+
+    def test_expected_files_produced(self, tmpdir_cwd, env):
+        self._create_project()
+
+        self._run_egg_info_command(tmpdir_cwd, env)
+        actual = os.listdir('foo.egg-info')
+
+        expected = [
+            'PKG-INFO',
+            'SOURCES.txt',
+            'dependency_links.txt',
+            'entry_points.txt',
+            'not-zip-safe',
+            'top_level.txt',
+        ]
+        assert sorted(actual) == expected
+
+    def test_handling_utime_error(self, tmpdir_cwd, env):
+        dist = Distribution()
+        ei = egg_info(dist)
+        utime_patch = mock.patch('os.utime', side_effect=OSError("TEST"))
+        mkpath_patch = mock.patch(
+            'setuptools.command.egg_info.egg_info.mkpath', return_val=None
+        )
+
+        with utime_patch, mkpath_patch:
+            import distutils.errors
+
+            msg = r"Cannot update time stamp of directory 'None'"
+            with pytest.raises(distutils.errors.DistutilsFileError, match=msg):
+                ei.run()
+
+    def test_license_is_a_string(self, tmpdir_cwd, env):
+        setup_config = DALS(
+            """
+            [metadata]
+            name=foo
+            version=0.0.1
+            license=file:MIT
+            """
+        )
+
+        setup_script = DALS(
+            """
+            from setuptools import setup
+
+            setup()
+            """
+        )
+
+        path.build({
+            'setup.py': setup_script,
+            'setup.cfg': setup_config,
+        })
+
+        # This command should fail with a ValueError, but because it's
+        # currently configured to use a subprocess, the actual traceback
+        # object is lost and we need to parse it from stderr
+        with pytest.raises(AssertionError) as exc:
+            self._run_egg_info_command(tmpdir_cwd, env)
+
+        # The only argument to the assertion error should be a traceback
+        # containing a ValueError
+        assert 'ValueError' in exc.value.args[0]
+
+    def test_rebuilt(self, tmpdir_cwd, env):
+        """Ensure timestamps are updated when the command is re-run."""
+        self._create_project()
+
+        self._run_egg_info_command(tmpdir_cwd, env)
+        timestamp_a = os.path.getmtime('foo.egg-info')
+
+        # arbitrary sleep just to handle *really* fast systems
+        time.sleep(0.001)
+
+        self._run_egg_info_command(tmpdir_cwd, env)
+        timestamp_b = os.path.getmtime('foo.egg-info')
+
+        assert timestamp_a != timestamp_b
+
+    def test_manifest_template_is_read(self, tmpdir_cwd, env):
+        self._create_project()
+        path.build({
+            'MANIFEST.in': DALS(
+                """
+                recursive-include docs *.rst
+            """
+            ),
+            'docs': {
+                'usage.rst': "Run 'hi'",
+            },
+        })
+        self._run_egg_info_command(tmpdir_cwd, env)
+        egg_info_dir = os.path.join('.', 'foo.egg-info')
+        sources_txt = os.path.join(egg_info_dir, 'SOURCES.txt')
+        with open(sources_txt, encoding="utf-8") as f:
+            assert 'docs/usage.rst' in f.read().split('\n')
+
+    def _setup_script_with_requires(self, requires, use_setup_cfg=False):
+        setup_script = DALS(
+            """
+            from setuptools import setup
+
+            setup(name='foo', zip_safe=False, %s)
+            """
+        ) % ('' if use_setup_cfg else requires)
+        setup_config = requires if use_setup_cfg else ''
+        path.build({
+            'setup.py': setup_script,
+            'setup.cfg': setup_config,
+        })
+
+    mismatch_marker = f"python_version<'{sys.version_info[0]}'"
+    # Alternate equivalent syntax.
+    mismatch_marker_alternate = f'python_version < "{sys.version_info[0]}"'
+    invalid_marker = "<=>++"
+
+    class RequiresTestHelper:
+        @staticmethod
+        def parametrize(*test_list, **format_dict):
+            idlist = []
+            argvalues = []
+            for test in test_list:
+                test_params = test.lstrip().split('\n\n', 3)
+                name_kwargs = test_params.pop(0).split('\n')
+                if len(name_kwargs) > 1:
+                    val = name_kwargs[1].strip()
+                    install_cmd_kwargs = ast.literal_eval(val)
+                else:
+                    install_cmd_kwargs = {}
+                name = name_kwargs[0].strip()
+                setup_py_requires, setup_cfg_requires, expected_requires = [
+                    DALS(a).format(**format_dict) for a in test_params
+                ]
+                for id_, requires, use_cfg in (
+                    (name, setup_py_requires, False),
+                    (name + '_in_setup_cfg', setup_cfg_requires, True),
+                ):
+                    idlist.append(id_)
+                    marks = ()
+                    if requires.startswith('@xfail\n'):
+                        requires = requires[7:]
+                        marks = pytest.mark.xfail
+                    argvalues.append(
+                        pytest.param(
+                            requires,
+                            use_cfg,
+                            expected_requires,
+                            install_cmd_kwargs,
+                            marks=marks,
+                        )
+                    )
+            return pytest.mark.parametrize(
+                (
+                    "requires",
+                    "use_setup_cfg",
+                    "expected_requires",
+                    "install_cmd_kwargs",
+                ),
+                argvalues,
+                ids=idlist,
+            )
+
+    @RequiresTestHelper.parametrize(
+        # Format of a test:
+        #
+        # id
+        # install_cmd_kwargs [optional]
+        #
+        # requires block (when used in setup.py)
+        #
+        # requires block (when used in setup.cfg)
+        #
+        # expected contents of requires.txt
+        """
+        install_requires_deterministic
+
+        install_requires=["wheel>=0.5", "pytest"]
+
+        [options]
+        install_requires =
+            wheel>=0.5
+            pytest
+
+        wheel>=0.5
+        pytest
+        """,
+        """
+        install_requires_ordered
+
+        install_requires=["pytest>=3.0.2,!=10.9999"]
+
+        [options]
+        install_requires =
+            pytest>=3.0.2,!=10.9999
+
+        pytest!=10.9999,>=3.0.2
+        """,
+        """
+        install_requires_with_marker
+
+        install_requires=["barbazquux;{mismatch_marker}"],
+
+        [options]
+        install_requires =
+            barbazquux; {mismatch_marker}
+
+        [:{mismatch_marker_alternate}]
+        barbazquux
+        """,
+        """
+        install_requires_with_extra
+        {'cmd': ['egg_info']}
+
+        install_requires=["barbazquux [test]"],
+
+        [options]
+        install_requires =
+            barbazquux [test]
+
+        barbazquux[test]
+        """,
+        """
+        install_requires_with_extra_and_marker
+
+        install_requires=["barbazquux [test]; {mismatch_marker}"],
+
+        [options]
+        install_requires =
+            barbazquux [test]; {mismatch_marker}
+
+        [:{mismatch_marker_alternate}]
+        barbazquux[test]
+        """,
+        """
+        setup_requires_with_markers
+
+        setup_requires=["barbazquux;{mismatch_marker}"],
+
+        [options]
+        setup_requires =
+            barbazquux; {mismatch_marker}
+
+        """,
+        """
+        extras_require_with_extra
+        {'cmd': ['egg_info']}
+
+        extras_require={{"extra": ["barbazquux [test]"]}},
+
+        [options.extras_require]
+        extra = barbazquux [test]
+
+        [extra]
+        barbazquux[test]
+        """,
+        """
+        extras_require_with_extra_and_marker_in_req
+
+        extras_require={{"extra": ["barbazquux [test]; {mismatch_marker}"]}},
+
+        [options.extras_require]
+        extra =
+            barbazquux [test]; {mismatch_marker}
+
+        [extra]
+
+        [extra:{mismatch_marker_alternate}]
+        barbazquux[test]
+        """,
+        # FIXME: ConfigParser does not allow : in key names!
+        """
+        extras_require_with_marker
+
+        extras_require={{":{mismatch_marker}": ["barbazquux"]}},
+
+        @xfail
+        [options.extras_require]
+        :{mismatch_marker} = barbazquux
+
+        [:{mismatch_marker}]
+        barbazquux
+        """,
+        """
+        extras_require_with_marker_in_req
+
+        extras_require={{"extra": ["barbazquux; {mismatch_marker}"]}},
+
+        [options.extras_require]
+        extra =
+            barbazquux; {mismatch_marker}
+
+        [extra]
+
+        [extra:{mismatch_marker_alternate}]
+        barbazquux
+        """,
+        """
+        extras_require_with_empty_section
+
+        extras_require={{"empty": []}},
+
+        [options.extras_require]
+        empty =
+
+        [empty]
+        """,
+        # Format arguments.
+        invalid_marker=invalid_marker,
+        mismatch_marker=mismatch_marker,
+        mismatch_marker_alternate=mismatch_marker_alternate,
+    )
+    def test_requires(
+        self,
+        tmpdir_cwd,
+        env,
+        requires,
+        use_setup_cfg,
+        expected_requires,
+        install_cmd_kwargs,
+    ):
+        self._setup_script_with_requires(requires, use_setup_cfg)
+        self._run_egg_info_command(tmpdir_cwd, env, **install_cmd_kwargs)
+        egg_info_dir = os.path.join('.', 'foo.egg-info')
+        requires_txt = os.path.join(egg_info_dir, 'requires.txt')
+        if os.path.exists(requires_txt):
+            with open(requires_txt, encoding="utf-8") as fp:
+                install_requires = fp.read()
+        else:
+            install_requires = ''
+        assert install_requires.lstrip() == expected_requires
+        assert glob.glob(os.path.join(env.paths['lib'], 'barbazquux*')) == []
+
+    def test_install_requires_unordered_disallowed(self, tmpdir_cwd, env):
+        """
+        Packages that pass unordered install_requires sequences
+        should be rejected as they produce non-deterministic
+        builds. See #458.
+        """
+        req = 'install_requires={"fake-factory==0.5.2", "pytz"}'
+        self._setup_script_with_requires(req)
+        with pytest.raises(AssertionError):
+            self._run_egg_info_command(tmpdir_cwd, env)
+
+    def test_extras_require_with_invalid_marker(self, tmpdir_cwd, env):
+        tmpl = 'extras_require={{":{marker}": ["barbazquux"]}},'
+        req = tmpl.format(marker=self.invalid_marker)
+        self._setup_script_with_requires(req)
+        with pytest.raises(AssertionError):
+            self._run_egg_info_command(tmpdir_cwd, env)
+        assert glob.glob(os.path.join(env.paths['lib'], 'barbazquux*')) == []
+
+    def test_extras_require_with_invalid_marker_in_req(self, tmpdir_cwd, env):
+        tmpl = 'extras_require={{"extra": ["barbazquux; {marker}"]}},'
+        req = tmpl.format(marker=self.invalid_marker)
+        self._setup_script_with_requires(req)
+        with pytest.raises(AssertionError):
+            self._run_egg_info_command(tmpdir_cwd, env)
+        assert glob.glob(os.path.join(env.paths['lib'], 'barbazquux*')) == []
+
+    def test_provides_extra(self, tmpdir_cwd, env):
+        self._setup_script_with_requires('extras_require={"foobar": ["barbazquux"]},')
+        environ = os.environ.copy().update(
+            HOME=env.paths['home'],
+        )
+        environment.run_setup_py(
+            cmd=['egg_info'],
+            pypath=os.pathsep.join([env.paths['lib'], str(tmpdir_cwd)]),
+            data_stream=1,
+            env=environ,
+        )
+        egg_info_dir = os.path.join('.', 'foo.egg-info')
+        with open(os.path.join(egg_info_dir, 'PKG-INFO'), encoding="utf-8") as fp:
+            pkg_info_lines = fp.read().split('\n')
+        assert 'Provides-Extra: foobar' in pkg_info_lines
+        assert 'Metadata-Version: 2.4' in pkg_info_lines
+
+    def test_doesnt_provides_extra(self, tmpdir_cwd, env):
+        self._setup_script_with_requires(
+            """install_requires=["spam ; python_version<'3.6'"]"""
+        )
+        environ = os.environ.copy().update(
+            HOME=env.paths['home'],
+        )
+        environment.run_setup_py(
+            cmd=['egg_info'],
+            pypath=os.pathsep.join([env.paths['lib'], str(tmpdir_cwd)]),
+            data_stream=1,
+            env=environ,
+        )
+        egg_info_dir = os.path.join('.', 'foo.egg-info')
+        with open(os.path.join(egg_info_dir, 'PKG-INFO'), encoding="utf-8") as fp:
+            pkg_info_text = fp.read()
+        assert 'Provides-Extra:' not in pkg_info_text
+
+    @pytest.mark.parametrize(
+        ('files', 'license_in_sources'),
+        [
+            (
+                {
+                    'setup.cfg': DALS(
+                        """
+                              [metadata]
+                              license_file = LICENSE
+                              """
+                    ),
+                    'LICENSE': "Test license",
+                },
+                True,
+            ),  # with license
+            (
+                {
+                    'setup.cfg': DALS(
+                        """
+                              [metadata]
+                              license_file = INVALID_LICENSE
+                              """
+                    ),
+                    'LICENSE': "Test license",
+                },
+                False,
+            ),  # with an invalid license
+            (
+                {
+                    'setup.cfg': DALS(
+                        """
+                              """
+                    ),
+                    'LICENSE': "Test license",
+                },
+                True,
+            ),  # no license_file attribute, LICENSE auto-included
+            (
+                {
+                    'setup.cfg': DALS(
+                        """
+                              [metadata]
+                              license_file = LICENSE
+                              """
+                    ),
+                    'MANIFEST.in': "exclude LICENSE",
+                    'LICENSE': "Test license",
+                },
+                True,
+            ),  # manifest is overwritten by license_file
+            pytest.param(
+                {
+                    'setup.cfg': DALS(
+                        """
+                              [metadata]
+                              license_file = LICEN[CS]E*
+                              """
+                    ),
+                    'LICENSE': "Test license",
+                },
+                True,
+                id="glob_pattern",
+            ),
+        ],
+    )
+    def test_setup_cfg_license_file(self, tmpdir_cwd, env, files, license_in_sources):
+        self._create_project()
+        path.build(files)
+
+        environment.run_setup_py(
+            cmd=['egg_info'],
+            pypath=os.pathsep.join([env.paths['lib'], str(tmpdir_cwd)]),
+        )
+        egg_info_dir = os.path.join('.', 'foo.egg-info')
+
+        sources_text = Path(egg_info_dir, "SOURCES.txt").read_text(encoding="utf-8")
+
+        if license_in_sources:
+            assert 'LICENSE' in sources_text
+        else:
+            assert 'LICENSE' not in sources_text
+            # for invalid license test
+            assert 'INVALID_LICENSE' not in sources_text
+
+    @pytest.mark.parametrize(
+        ('files', 'incl_licenses', 'excl_licenses'),
+        [
+            (
+                {
+                    'setup.cfg': DALS(
+                        """
+                              [metadata]
+                              license_files =
+                                  LICENSE-ABC
+                                  LICENSE-XYZ
+                              """
+                    ),
+                    'LICENSE-ABC': "ABC license",
+                    'LICENSE-XYZ': "XYZ license",
+                },
+                ['LICENSE-ABC', 'LICENSE-XYZ'],
+                [],
+            ),  # with licenses
+            (
+                {
+                    'setup.cfg': DALS(
+                        """
+                              [metadata]
+                              license_files = LICENSE-ABC, LICENSE-XYZ
+                              """
+                    ),
+                    'LICENSE-ABC': "ABC license",
+                    'LICENSE-XYZ': "XYZ license",
+                },
+                ['LICENSE-ABC', 'LICENSE-XYZ'],
+                [],
+            ),  # with commas
+            (
+                {
+                    'setup.cfg': DALS(
+                        """
+                              [metadata]
+                              license_files =
+                                  LICENSE-ABC
+                              """
+                    ),
+                    'LICENSE-ABC': "ABC license",
+                    'LICENSE-XYZ': "XYZ license",
+                },
+                ['LICENSE-ABC'],
+                ['LICENSE-XYZ'],
+            ),  # with one license
+            (
+                {
+                    'setup.cfg': DALS(
+                        """
+                              [metadata]
+                              license_files =
+                              """
+                    ),
+                    'LICENSE-ABC': "ABC license",
+                    'LICENSE-XYZ': "XYZ license",
+                },
+                [],
+                ['LICENSE-ABC', 'LICENSE-XYZ'],
+            ),  # empty
+            (
+                {
+                    'setup.cfg': DALS(
+                        """
+                              [metadata]
+                              license_files = LICENSE-XYZ
+                              """
+                    ),
+                    'LICENSE-ABC': "ABC license",
+                    'LICENSE-XYZ': "XYZ license",
+                },
+                ['LICENSE-XYZ'],
+                ['LICENSE-ABC'],
+            ),  # on same line
+            (
+                {
+                    'setup.cfg': DALS(
+                        """
+                              [metadata]
+                              license_files =
+                                  LICENSE-ABC
+                                  INVALID_LICENSE
+                              """
+                    ),
+                    'LICENSE-ABC': "Test license",
+                },
+                ['LICENSE-ABC'],
+                ['INVALID_LICENSE'],
+            ),  # with an invalid license
+            (
+                {
+                    'setup.cfg': DALS(
+                        """
+                              """
+                    ),
+                    'LICENSE': "Test license",
+                },
+                ['LICENSE'],
+                [],
+            ),  # no license_files attribute, LICENSE auto-included
+            (
+                {
+                    'setup.cfg': DALS(
+                        """
+                              [metadata]
+                              license_files = LICENSE
+                              """
+                    ),
+                    'MANIFEST.in': "exclude LICENSE",
+                    'LICENSE': "Test license",
+                },
+                ['LICENSE'],
+                [],
+            ),  # manifest is overwritten by license_files
+            (
+                {
+                    'setup.cfg': DALS(
+                        """
+                              [metadata]
+                              license_files =
+                                  LICENSE-ABC
+                                  LICENSE-XYZ
+                              """
+                    ),
+                    'MANIFEST.in': "exclude LICENSE-XYZ",
+                    'LICENSE-ABC': "ABC license",
+                    'LICENSE-XYZ': "XYZ license",
+                    # manifest is overwritten by license_files
+                },
+                ['LICENSE-ABC', 'LICENSE-XYZ'],
+                [],
+            ),
+            pytest.param(
+                {
+                    'setup.cfg': "",
+                    'LICENSE-ABC': "ABC license",
+                    'COPYING-ABC': "ABC copying",
+                    'NOTICE-ABC': "ABC notice",
+                    'AUTHORS-ABC': "ABC authors",
+                    'LICENCE-XYZ': "XYZ license",
+                    'LICENSE': "License",
+                    'INVALID-LICENSE': "Invalid license",
+                },
+                [
+                    'LICENSE-ABC',
+                    'COPYING-ABC',
+                    'NOTICE-ABC',
+                    'AUTHORS-ABC',
+                    'LICENCE-XYZ',
+                    'LICENSE',
+                ],
+                ['INVALID-LICENSE'],
+                # ('LICEN[CS]E*', 'COPYING*', 'NOTICE*', 'AUTHORS*')
+                id="default_glob_patterns",
+            ),
+            pytest.param(
+                {
+                    'setup.cfg': DALS(
+                        """
+                              [metadata]
+                              license_files =
+                                  LICENSE*
+                              """
+                    ),
+                    'LICENSE-ABC': "ABC license",
+                    'NOTICE-XYZ': "XYZ notice",
+                },
+                ['LICENSE-ABC'],
+                ['NOTICE-XYZ'],
+                id="no_default_glob_patterns",
+            ),
+            pytest.param(
+                {
+                    'setup.cfg': DALS(
+                        """
+                              [metadata]
+                              license_files =
+                                  LICENSE-ABC
+                                  LICENSE*
+                              """
+                    ),
+                    'LICENSE-ABC': "ABC license",
+                },
+                ['LICENSE-ABC'],
+                [],
+                id="files_only_added_once",
+            ),
+            pytest.param(
+                {
+                    'setup.cfg': DALS(
+                        """
+                              [metadata]
+                              license_files = **/LICENSE
+                              """
+                    ),
+                    'LICENSE': "ABC license",
+                    'LICENSE-OTHER': "Don't include",
+                    'vendor': {'LICENSE': "Vendor license"},
+                },
+                ['LICENSE', 'vendor/LICENSE'],
+                ['LICENSE-OTHER'],
+                id="recursive_glob",
+            ),
+        ],
+    )
+    def test_setup_cfg_license_files(
+        self, tmpdir_cwd, env, files, incl_licenses, excl_licenses
+    ):
+        self._create_project()
+        path.build(files)
+
+        environment.run_setup_py(
+            cmd=['egg_info'],
+            pypath=os.pathsep.join([env.paths['lib'], str(tmpdir_cwd)]),
+        )
+        egg_info_dir = os.path.join('.', 'foo.egg-info')
+
+        sources_text = Path(egg_info_dir, "SOURCES.txt").read_text(encoding="utf-8")
+        sources_lines = [line.strip() for line in sources_text.splitlines()]
+
+        for lf in incl_licenses:
+            assert sources_lines.count(lf) == 1
+
+        for lf in excl_licenses:
+            assert sources_lines.count(lf) == 0
+
+    @pytest.mark.parametrize(
+        ('files', 'incl_licenses', 'excl_licenses'),
+        [
+            (
+                {
+                    'setup.cfg': DALS(
+                        """
+                              [metadata]
+                              license_file =
+                              license_files =
+                              """
+                    ),
+                    'LICENSE-ABC': "ABC license",
+                    'LICENSE-XYZ': "XYZ license",
+                },
+                [],
+                ['LICENSE-ABC', 'LICENSE-XYZ'],
+            ),  # both empty
+            (
+                {
+                    'setup.cfg': DALS(
+                        """
+                              [metadata]
+                              license_file =
+                                  LICENSE-ABC
+                                  LICENSE-XYZ
+                              """
+                    ),
+                    'LICENSE-ABC': "ABC license",
+                    'LICENSE-XYZ': "XYZ license",
+                    # license_file is still singular
+                },
+                [],
+                ['LICENSE-ABC', 'LICENSE-XYZ'],
+            ),
+            (
+                {
+                    'setup.cfg': DALS(
+                        """
+                              [metadata]
+                              license_file = LICENSE-ABC
+                              license_files =
+                                  LICENSE-XYZ
+                                  LICENSE-PQR
+                              """
+                    ),
+                    'LICENSE-ABC': "ABC license",
+                    'LICENSE-PQR': "PQR license",
+                    'LICENSE-XYZ': "XYZ license",
+                },
+                ['LICENSE-ABC', 'LICENSE-PQR', 'LICENSE-XYZ'],
+                [],
+            ),  # combined
+            (
+                {
+                    'setup.cfg': DALS(
+                        """
+                              [metadata]
+                              license_file = LICENSE-ABC
+                              license_files =
+                                  LICENSE-ABC
+                                  LICENSE-XYZ
+                                  LICENSE-PQR
+                              """
+                    ),
+                    'LICENSE-ABC': "ABC license",
+                    'LICENSE-PQR': "PQR license",
+                    'LICENSE-XYZ': "XYZ license",
+                    # duplicate license
+                },
+                ['LICENSE-ABC', 'LICENSE-PQR', 'LICENSE-XYZ'],
+                [],
+            ),
+            (
+                {
+                    'setup.cfg': DALS(
+                        """
+                              [metadata]
+                              license_file = LICENSE-ABC
+                              license_files =
+                                  LICENSE-XYZ
+                              """
+                    ),
+                    'LICENSE-ABC': "ABC license",
+                    'LICENSE-PQR': "PQR license",
+                    'LICENSE-XYZ': "XYZ license",
+                    # combined subset
+                },
+                ['LICENSE-ABC', 'LICENSE-XYZ'],
+                ['LICENSE-PQR'],
+            ),
+            (
+                {
+                    'setup.cfg': DALS(
+                        """
+                              [metadata]
+                              license_file = LICENSE-ABC
+                              license_files =
+                                  LICENSE-XYZ
+                                  LICENSE-PQR
+                              """
+                    ),
+                    'LICENSE-PQR': "Test license",
+                    # with invalid licenses
+                },
+                ['LICENSE-PQR'],
+                ['LICENSE-ABC', 'LICENSE-XYZ'],
+            ),
+            (
+                {
+                    'setup.cfg': DALS(
+                        """
+                              [metadata]
+                              license_file = LICENSE-ABC
+                              license_files =
+                                LICENSE-PQR
+                                LICENSE-XYZ
+                              """
+                    ),
+                    'MANIFEST.in': "exclude LICENSE-ABC\nexclude LICENSE-PQR",
+                    'LICENSE-ABC': "ABC license",
+                    'LICENSE-PQR': "PQR license",
+                    'LICENSE-XYZ': "XYZ license",
+                    # manifest is overwritten
+                },
+                ['LICENSE-ABC', 'LICENSE-PQR', 'LICENSE-XYZ'],
+                [],
+            ),
+            pytest.param(
+                {
+                    'setup.cfg': DALS(
+                        """
+                              [metadata]
+                              license_file = LICENSE*
+                              """
+                    ),
+                    'LICENSE-ABC': "ABC license",
+                    'NOTICE-XYZ': "XYZ notice",
+                },
+                ['LICENSE-ABC'],
+                ['NOTICE-XYZ'],
+                id="no_default_glob_patterns",
+            ),
+            pytest.param(
+                {
+                    'setup.cfg': DALS(
+                        """
+                              [metadata]
+                              license_file = LICENSE*
+                              license_files =
+                                NOTICE*
+                              """
+                    ),
+                    'LICENSE-ABC': "ABC license",
+                    'NOTICE-ABC': "ABC notice",
+                    'AUTHORS-ABC': "ABC authors",
+                },
+                ['LICENSE-ABC', 'NOTICE-ABC'],
+                ['AUTHORS-ABC'],
+                id="combined_glob_patterrns",
+            ),
+        ],
+    )
+    def test_setup_cfg_license_file_license_files(
+        self, tmpdir_cwd, env, files, incl_licenses, excl_licenses
+    ):
+        self._create_project()
+        path.build(files)
+
+        environment.run_setup_py(
+            cmd=['egg_info'],
+            pypath=os.pathsep.join([env.paths['lib'], str(tmpdir_cwd)]),
+        )
+        egg_info_dir = os.path.join('.', 'foo.egg-info')
+
+        sources_text = Path(egg_info_dir, "SOURCES.txt").read_text(encoding="utf-8")
+        sources_lines = [line.strip() for line in sources_text.splitlines()]
+
+        for lf in incl_licenses:
+            assert sources_lines.count(lf) == 1
+
+        for lf in excl_licenses:
+            assert sources_lines.count(lf) == 0
+
+    def test_license_file_attr_pkg_info(self, tmpdir_cwd, env):
+        """All matched license files should have a corresponding License-File."""
+        self._create_project()
+        path.build({
+            "setup.cfg": DALS(
+                """
+                              [metadata]
+                              license_files =
+                                  NOTICE*
+                                  LICENSE*
+                                  **/LICENSE
+                              """
+            ),
+            "LICENSE-ABC": "ABC license",
+            "LICENSE-XYZ": "XYZ license",
+            "NOTICE": "included",
+            "IGNORE": "not include",
+            "vendor": {'LICENSE': "Vendor license"},
+        })
+
+        environment.run_setup_py(
+            cmd=['egg_info'],
+            pypath=os.pathsep.join([env.paths['lib'], str(tmpdir_cwd)]),
+        )
+        egg_info_dir = os.path.join('.', 'foo.egg-info')
+        with open(os.path.join(egg_info_dir, 'PKG-INFO'), encoding="utf-8") as fp:
+            pkg_info_lines = fp.read().split('\n')
+        license_file_lines = [
+            line for line in pkg_info_lines if line.startswith('License-File:')
+        ]
+
+        # Only 'NOTICE', LICENSE-ABC', and 'LICENSE-XYZ' should have been matched
+        # Also assert that order from license_files is keeped
+        assert len(license_file_lines) == 4
+        assert "License-File: NOTICE" == license_file_lines[0]
+        assert "License-File: LICENSE-ABC" in license_file_lines[1:]
+        assert "License-File: LICENSE-XYZ" in license_file_lines[1:]
+        assert "License-File: vendor/LICENSE" in license_file_lines[3]
+
+    def test_metadata_version(self, tmpdir_cwd, env):
+        """Make sure latest metadata version is used by default."""
+        self._setup_script_with_requires("")
+        environment.run_setup_py(
+            cmd=['egg_info'],
+            pypath=os.pathsep.join([env.paths['lib'], str(tmpdir_cwd)]),
+            data_stream=1,
+        )
+        egg_info_dir = os.path.join('.', 'foo.egg-info')
+        with open(os.path.join(egg_info_dir, 'PKG-INFO'), encoding="utf-8") as fp:
+            pkg_info_lines = fp.read().split('\n')
+        # Update metadata version if changed
+        assert self._extract_mv_version(pkg_info_lines) == (2, 4)
+
+    def test_long_description_content_type(self, tmpdir_cwd, env):
+        # Test that specifying a `long_description_content_type` keyword arg to
+        # the `setup` function results in writing a `Description-Content-Type`
+        # line to the `PKG-INFO` file in the `<distribution>.egg-info`
+        # directory.
+        # `Description-Content-Type` is described at
+        # https://github.com/pypa/python-packaging-user-guide/pull/258
+
+        self._setup_script_with_requires(
+            """long_description_content_type='text/markdown',"""
+        )
+        environ = os.environ.copy().update(
+            HOME=env.paths['home'],
+        )
+        environment.run_setup_py(
+            cmd=['egg_info'],
+            pypath=os.pathsep.join([env.paths['lib'], str(tmpdir_cwd)]),
+            data_stream=1,
+            env=environ,
+        )
+        egg_info_dir = os.path.join('.', 'foo.egg-info')
+        with open(os.path.join(egg_info_dir, 'PKG-INFO'), encoding="utf-8") as fp:
+            pkg_info_lines = fp.read().split('\n')
+        expected_line = 'Description-Content-Type: text/markdown'
+        assert expected_line in pkg_info_lines
+        assert 'Metadata-Version: 2.4' in pkg_info_lines
+
+    def test_long_description(self, tmpdir_cwd, env):
+        # Test that specifying `long_description` and `long_description_content_type`
+        # keyword args to the `setup` function results in writing
+        # the description in the message payload of the `PKG-INFO` file
+        # in the `<distribution>.egg-info` directory.
+        self._setup_script_with_requires(
+            "long_description='This is a long description\\nover multiple lines',"
+            "long_description_content_type='text/markdown',"
+        )
+        environment.run_setup_py(
+            cmd=['egg_info'],
+            pypath=os.pathsep.join([env.paths['lib'], str(tmpdir_cwd)]),
+            data_stream=1,
+        )
+        egg_info_dir = os.path.join('.', 'foo.egg-info')
+        with open(os.path.join(egg_info_dir, 'PKG-INFO'), encoding="utf-8") as fp:
+            pkg_info_lines = fp.read().split('\n')
+        assert 'Metadata-Version: 2.4' in pkg_info_lines
+        assert '' == pkg_info_lines[-1]  # last line should be empty
+        long_desc_lines = pkg_info_lines[pkg_info_lines.index('') :]
+        assert 'This is a long description' in long_desc_lines
+        assert 'over multiple lines' in long_desc_lines
+
+    def test_project_urls(self, tmpdir_cwd, env):
+        # Test that specifying a `project_urls` dict to the `setup`
+        # function results in writing multiple `Project-URL` lines to
+        # the `PKG-INFO` file in the `<distribution>.egg-info`
+        # directory.
+        # `Project-URL` is described at https://packaging.python.org
+        #     /specifications/core-metadata/#project-url-multiple-use
+
+        self._setup_script_with_requires(
+            """project_urls={
+                'Link One': 'https://example.com/one/',
+                'Link Two': 'https://example.com/two/',
+                },"""
+        )
+        environ = os.environ.copy().update(
+            HOME=env.paths['home'],
+        )
+        environment.run_setup_py(
+            cmd=['egg_info'],
+            pypath=os.pathsep.join([env.paths['lib'], str(tmpdir_cwd)]),
+            data_stream=1,
+            env=environ,
+        )
+        egg_info_dir = os.path.join('.', 'foo.egg-info')
+        with open(os.path.join(egg_info_dir, 'PKG-INFO'), encoding="utf-8") as fp:
+            pkg_info_lines = fp.read().split('\n')
+        expected_line = 'Project-URL: Link One, https://example.com/one/'
+        assert expected_line in pkg_info_lines
+        expected_line = 'Project-URL: Link Two, https://example.com/two/'
+        assert expected_line in pkg_info_lines
+        assert self._extract_mv_version(pkg_info_lines) >= (1, 2)
+
+    def test_license(self, tmpdir_cwd, env):
+        """Test single line license."""
+        self._setup_script_with_requires("license='MIT',")
+        environment.run_setup_py(
+            cmd=['egg_info'],
+            pypath=os.pathsep.join([env.paths['lib'], str(tmpdir_cwd)]),
+            data_stream=1,
+        )
+        egg_info_dir = os.path.join('.', 'foo.egg-info')
+        with open(os.path.join(egg_info_dir, 'PKG-INFO'), encoding="utf-8") as fp:
+            pkg_info_lines = fp.read().split('\n')
+        assert 'License: MIT' in pkg_info_lines
+
+    def test_license_escape(self, tmpdir_cwd, env):
+        """Test license is escaped correctly if longer than one line."""
+        self._setup_script_with_requires(
+            "license='This is a long license text \\nover multiple lines',"
+        )
+        environment.run_setup_py(
+            cmd=['egg_info'],
+            pypath=os.pathsep.join([env.paths['lib'], str(tmpdir_cwd)]),
+            data_stream=1,
+        )
+        egg_info_dir = os.path.join('.', 'foo.egg-info')
+        with open(os.path.join(egg_info_dir, 'PKG-INFO'), encoding="utf-8") as fp:
+            pkg_info_lines = fp.read().split('\n')
+
+        assert 'License: This is a long license text ' in pkg_info_lines
+        assert '        over multiple lines' in pkg_info_lines
+        assert 'text \n        over multiple' in '\n'.join(pkg_info_lines)
+
+    def test_python_requires_egg_info(self, tmpdir_cwd, env):
+        self._setup_script_with_requires("""python_requires='>=2.7.12',""")
+        environ = os.environ.copy().update(
+            HOME=env.paths['home'],
+        )
+        environment.run_setup_py(
+            cmd=['egg_info'],
+            pypath=os.pathsep.join([env.paths['lib'], str(tmpdir_cwd)]),
+            data_stream=1,
+            env=environ,
+        )
+        egg_info_dir = os.path.join('.', 'foo.egg-info')
+        with open(os.path.join(egg_info_dir, 'PKG-INFO'), encoding="utf-8") as fp:
+            pkg_info_lines = fp.read().split('\n')
+        assert 'Requires-Python: >=2.7.12' in pkg_info_lines
+        assert self._extract_mv_version(pkg_info_lines) >= (1, 2)
+
+    def test_manifest_maker_warning_suppression(self):
+        fixtures = [
+            "standard file not found: should have one of foo.py, bar.py",
+            "standard file 'setup.py' not found",
+        ]
+
+        for msg in fixtures:
+            assert manifest_maker._should_suppress_warning(msg)
+
+    def test_egg_info_includes_setup_py(self, tmpdir_cwd):
+        self._create_project()
+        dist = Distribution({"name": "foo", "version": "0.0.1"})
+        dist.script_name = "non_setup.py"
+        egg_info_instance = egg_info(dist)
+        egg_info_instance.finalize_options()
+        egg_info_instance.run()
+
+        assert 'setup.py' in egg_info_instance.filelist.files
+
+        with open(egg_info_instance.egg_info + "/SOURCES.txt", encoding="utf-8") as f:
+            sources = f.read().split('\n')
+            assert 'setup.py' in sources
+
+    def _run_egg_info_command(self, tmpdir_cwd, env, cmd=None, output=None):
+        environ = os.environ.copy().update(
+            HOME=env.paths['home'],
+        )
+        if cmd is None:
+            cmd = [
+                'egg_info',
+            ]
+        code, data = environment.run_setup_py(
+            cmd=cmd,
+            pypath=os.pathsep.join([env.paths['lib'], str(tmpdir_cwd)]),
+            data_stream=1,
+            env=environ,
+        )
+        assert not code, data
+
+        if output:
+            assert output in data
+
+    def test_egg_info_tag_only_once(self, tmpdir_cwd, env):
+        self._create_project()
+        path.build({
+            'setup.cfg': DALS(
+                """
+                              [egg_info]
+                              tag_build = dev
+                              tag_date = 0
+                              tag_svn_revision = 0
+                              """
+            ),
+        })
+        self._run_egg_info_command(tmpdir_cwd, env)
+        egg_info_dir = os.path.join('.', 'foo.egg-info')
+        with open(os.path.join(egg_info_dir, 'PKG-INFO'), encoding="utf-8") as fp:
+            pkg_info_lines = fp.read().split('\n')
+        assert 'Version: 0.0.0.dev0' in pkg_info_lines
+
+
+class TestWriteEntries:
+    def test_invalid_entry_point(self, tmpdir_cwd, env):
+        dist = Distribution({"name": "foo", "version": "0.0.1"})
+        dist.entry_points = {"foo": "foo = invalid-identifier:foo"}
+        cmd = dist.get_command_obj("egg_info")
+        expected_msg = r"Problems to parse .*invalid-identifier.*"
+        with pytest.raises(errors.OptionError, match=expected_msg) as ex:
+            write_entries(cmd, "entry_points", "entry_points.txt")
+            assert "ensure entry-point follows the spec" in ex.value.args[0]
+
+    def test_valid_entry_point(self, tmpdir_cwd, env):
+        dist = Distribution({"name": "foo", "version": "0.0.1"})
+        dist.entry_points = {
+            "abc": "foo = bar:baz",
+            "def": ["faa = bor:boz"],
+        }
+        cmd = dist.get_command_obj("egg_info")
+        write_entries(cmd, "entry_points", "entry_points.txt")
+        content = Path("entry_points.txt").read_text(encoding="utf-8")
+        assert "[abc]\nfoo = bar:baz\n" in content
+        assert "[def]\nfaa = bor:boz\n" in content
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/tests/test_extern.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/tests/test_extern.py
new file mode 100644
index 0000000000000000000000000000000000000000..d7eb3c62c190dacdd4a054d2934962be2f4ee860
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/tests/test_extern.py
@@ -0,0 +1,15 @@
+import importlib
+import pickle
+
+import packaging
+
+from setuptools import Distribution
+
+
+def test_reimport_extern():
+    packaging2 = importlib.import_module(packaging.__name__)
+    assert packaging is packaging2
+
+
+def test_distribution_picklable():
+    pickle.loads(pickle.dumps(Distribution()))
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/tests/test_find_packages.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/tests/test_find_packages.py
new file mode 100644
index 0000000000000000000000000000000000000000..9fd9f8f6637d13cb898fcd446a6b090323d02014
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/tests/test_find_packages.py
@@ -0,0 +1,218 @@
+"""Tests for automatic package discovery"""
+
+import os
+import shutil
+import tempfile
+
+import pytest
+
+from setuptools import find_namespace_packages, find_packages
+from setuptools.discovery import FlatLayoutPackageFinder
+
+from .compat.py39 import os_helper
+
+
+class TestFindPackages:
+    def setup_method(self, method):
+        self.dist_dir = tempfile.mkdtemp()
+        self._make_pkg_structure()
+
+    def teardown_method(self, method):
+        shutil.rmtree(self.dist_dir)
+
+    def _make_pkg_structure(self):
+        """Make basic package structure.
+
+        dist/
+            docs/
+                conf.py
+            pkg/
+                __pycache__/
+                nspkg/
+                    mod.py
+                subpkg/
+                    assets/
+                        asset
+                    __init__.py
+            setup.py
+
+        """
+        self.docs_dir = self._mkdir('docs', self.dist_dir)
+        self._touch('conf.py', self.docs_dir)
+        self.pkg_dir = self._mkdir('pkg', self.dist_dir)
+        self._mkdir('__pycache__', self.pkg_dir)
+        self.ns_pkg_dir = self._mkdir('nspkg', self.pkg_dir)
+        self._touch('mod.py', self.ns_pkg_dir)
+        self.sub_pkg_dir = self._mkdir('subpkg', self.pkg_dir)
+        self.asset_dir = self._mkdir('assets', self.sub_pkg_dir)
+        self._touch('asset', self.asset_dir)
+        self._touch('__init__.py', self.sub_pkg_dir)
+        self._touch('setup.py', self.dist_dir)
+
+    def _mkdir(self, path, parent_dir=None):
+        if parent_dir:
+            path = os.path.join(parent_dir, path)
+        os.mkdir(path)
+        return path
+
+    def _touch(self, path, dir_=None):
+        if dir_:
+            path = os.path.join(dir_, path)
+        open(path, 'wb').close()
+        return path
+
+    def test_regular_package(self):
+        self._touch('__init__.py', self.pkg_dir)
+        packages = find_packages(self.dist_dir)
+        assert packages == ['pkg', 'pkg.subpkg']
+
+    def test_exclude(self):
+        self._touch('__init__.py', self.pkg_dir)
+        packages = find_packages(self.dist_dir, exclude=('pkg.*',))
+        assert packages == ['pkg']
+
+    def test_exclude_recursive(self):
+        """
+        Excluding a parent package should not exclude child packages as well.
+        """
+        self._touch('__init__.py', self.pkg_dir)
+        self._touch('__init__.py', self.sub_pkg_dir)
+        packages = find_packages(self.dist_dir, exclude=('pkg',))
+        assert packages == ['pkg.subpkg']
+
+    def test_include_excludes_other(self):
+        """
+        If include is specified, other packages should be excluded.
+        """
+        self._touch('__init__.py', self.pkg_dir)
+        alt_dir = self._mkdir('other_pkg', self.dist_dir)
+        self._touch('__init__.py', alt_dir)
+        packages = find_packages(self.dist_dir, include=['other_pkg'])
+        assert packages == ['other_pkg']
+
+    def test_dir_with_dot_is_skipped(self):
+        shutil.rmtree(os.path.join(self.dist_dir, 'pkg/subpkg/assets'))
+        data_dir = self._mkdir('some.data', self.pkg_dir)
+        self._touch('__init__.py', data_dir)
+        self._touch('file.dat', data_dir)
+        packages = find_packages(self.dist_dir)
+        assert 'pkg.some.data' not in packages
+
+    def test_dir_with_packages_in_subdir_is_excluded(self):
+        """
+        Ensure that a package in a non-package such as build/pkg/__init__.py
+        is excluded.
+        """
+        build_dir = self._mkdir('build', self.dist_dir)
+        build_pkg_dir = self._mkdir('pkg', build_dir)
+        self._touch('__init__.py', build_pkg_dir)
+        packages = find_packages(self.dist_dir)
+        assert 'build.pkg' not in packages
+
+    @pytest.mark.skipif(not os_helper.can_symlink(), reason='Symlink support required')
+    def test_symlinked_packages_are_included(self):
+        """
+        A symbolically-linked directory should be treated like any other
+        directory when matched as a package.
+
+        Create a link from lpkg -> pkg.
+        """
+        self._touch('__init__.py', self.pkg_dir)
+        linked_pkg = os.path.join(self.dist_dir, 'lpkg')
+        os.symlink('pkg', linked_pkg)
+        assert os.path.isdir(linked_pkg)
+        packages = find_packages(self.dist_dir)
+        assert 'lpkg' in packages
+
+    def _assert_packages(self, actual, expected):
+        assert set(actual) == set(expected)
+
+    def test_pep420_ns_package(self):
+        packages = find_namespace_packages(
+            self.dist_dir, include=['pkg*'], exclude=['pkg.subpkg.assets']
+        )
+        self._assert_packages(packages, ['pkg', 'pkg.nspkg', 'pkg.subpkg'])
+
+    def test_pep420_ns_package_no_includes(self):
+        packages = find_namespace_packages(self.dist_dir, exclude=['pkg.subpkg.assets'])
+        self._assert_packages(packages, ['docs', 'pkg', 'pkg.nspkg', 'pkg.subpkg'])
+
+    def test_pep420_ns_package_no_includes_or_excludes(self):
+        packages = find_namespace_packages(self.dist_dir)
+        expected = ['docs', 'pkg', 'pkg.nspkg', 'pkg.subpkg', 'pkg.subpkg.assets']
+        self._assert_packages(packages, expected)
+
+    def test_regular_package_with_nested_pep420_ns_packages(self):
+        self._touch('__init__.py', self.pkg_dir)
+        packages = find_namespace_packages(
+            self.dist_dir, exclude=['docs', 'pkg.subpkg.assets']
+        )
+        self._assert_packages(packages, ['pkg', 'pkg.nspkg', 'pkg.subpkg'])
+
+    def test_pep420_ns_package_no_non_package_dirs(self):
+        shutil.rmtree(self.docs_dir)
+        shutil.rmtree(os.path.join(self.dist_dir, 'pkg/subpkg/assets'))
+        packages = find_namespace_packages(self.dist_dir)
+        self._assert_packages(packages, ['pkg', 'pkg.nspkg', 'pkg.subpkg'])
+
+
+class TestFlatLayoutPackageFinder:
+    EXAMPLES = {
+        "hidden-folders": (
+            [".pkg/__init__.py", "pkg/__init__.py", "pkg/nested/file.txt"],
+            ["pkg", "pkg.nested"],
+        ),
+        "private-packages": (
+            ["_pkg/__init__.py", "pkg/_private/__init__.py"],
+            ["pkg", "pkg._private"],
+        ),
+        "invalid-name": (
+            ["invalid-pkg/__init__.py", "other.pkg/__init__.py", "yet,another/file.py"],
+            [],
+        ),
+        "docs": (["pkg/__init__.py", "docs/conf.py", "docs/readme.rst"], ["pkg"]),
+        "tests": (
+            ["pkg/__init__.py", "tests/test_pkg.py", "tests/__init__.py"],
+            ["pkg"],
+        ),
+        "examples": (
+            [
+                "pkg/__init__.py",
+                "examples/__init__.py",
+                "examples/file.py",
+                "example/other_file.py",
+                # Sub-packages should always be fine
+                "pkg/example/__init__.py",
+                "pkg/examples/__init__.py",
+            ],
+            ["pkg", "pkg.examples", "pkg.example"],
+        ),
+        "tool-specific": (
+            [
+                "htmlcov/index.html",
+                "pkg/__init__.py",
+                "tasks/__init__.py",
+                "tasks/subpackage/__init__.py",
+                "fabfile/__init__.py",
+                "fabfile/subpackage/__init__.py",
+                # Sub-packages should always be fine
+                "pkg/tasks/__init__.py",
+                "pkg/fabfile/__init__.py",
+            ],
+            ["pkg", "pkg.tasks", "pkg.fabfile"],
+        ),
+    }
+
+    @pytest.mark.parametrize("example", EXAMPLES.keys())
+    def test_unwanted_directories_not_included(self, tmp_path, example):
+        files, expected_packages = self.EXAMPLES[example]
+        ensure_files(tmp_path, files)
+        found_packages = FlatLayoutPackageFinder.find(str(tmp_path))
+        assert set(found_packages) == set(expected_packages)
+
+
+def ensure_files(root_path, files):
+    for file in files:
+        path = root_path / file
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.touch()
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/tests/test_find_py_modules.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/tests/test_find_py_modules.py
new file mode 100644
index 0000000000000000000000000000000000000000..8034b544294e5d30274bac82f24f93613120a0d4
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/tests/test_find_py_modules.py
@@ -0,0 +1,73 @@
+"""Tests for automatic discovery of modules"""
+
+import os
+
+import pytest
+
+from setuptools.discovery import FlatLayoutModuleFinder, ModuleFinder
+
+from .compat.py39 import os_helper
+from .test_find_packages import ensure_files
+
+
+class TestModuleFinder:
+    def find(self, path, *args, **kwargs):
+        return set(ModuleFinder.find(str(path), *args, **kwargs))
+
+    EXAMPLES = {
+        # circumstance: (files, kwargs, expected_modules)
+        "simple_folder": (
+            ["file.py", "other.py"],
+            {},  # kwargs
+            ["file", "other"],
+        ),
+        "exclude": (
+            ["file.py", "other.py"],
+            {"exclude": ["f*"]},
+            ["other"],
+        ),
+        "include": (
+            ["file.py", "fole.py", "other.py"],
+            {"include": ["f*"], "exclude": ["fo*"]},
+            ["file"],
+        ),
+        "invalid-name": (["my-file.py", "other.file.py"], {}, []),
+    }
+
+    @pytest.mark.parametrize("example", EXAMPLES.keys())
+    def test_finder(self, tmp_path, example):
+        files, kwargs, expected_modules = self.EXAMPLES[example]
+        ensure_files(tmp_path, files)
+        assert self.find(tmp_path, **kwargs) == set(expected_modules)
+
+    @pytest.mark.skipif(not os_helper.can_symlink(), reason='Symlink support required')
+    def test_symlinked_packages_are_included(self, tmp_path):
+        src = "_myfiles/file.py"
+        ensure_files(tmp_path, [src])
+        os.symlink(tmp_path / src, tmp_path / "link.py")
+        assert self.find(tmp_path) == {"link"}
+
+
+class TestFlatLayoutModuleFinder:
+    def find(self, path, *args, **kwargs):
+        return set(FlatLayoutModuleFinder.find(str(path)))
+
+    EXAMPLES = {
+        # circumstance: (files, expected_modules)
+        "hidden-files": ([".module.py"], []),
+        "private-modules": (["_module.py"], []),
+        "common-names": (
+            ["setup.py", "conftest.py", "test.py", "tests.py", "example.py", "mod.py"],
+            ["mod"],
+        ),
+        "tool-specific": (
+            ["tasks.py", "fabfile.py", "noxfile.py", "dodo.py", "manage.py", "mod.py"],
+            ["mod"],
+        ),
+    }
+
+    @pytest.mark.parametrize("example", EXAMPLES.keys())
+    def test_unwanted_files_not_included(self, tmp_path, example):
+        files, expected_modules = self.EXAMPLES[example]
+        ensure_files(tmp_path, files)
+        assert self.find(tmp_path) == set(expected_modules)
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/tests/test_glob.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/tests/test_glob.py
new file mode 100644
index 0000000000000000000000000000000000000000..8d225a44610163c7d56d65b07c06f0f598ccfe84
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/tests/test_glob.py
@@ -0,0 +1,45 @@
+import pytest
+from jaraco import path
+
+from setuptools.glob import glob
+
+
+@pytest.mark.parametrize(
+    ('tree', 'pattern', 'matches'),
+    (
+        ('', b'', []),
+        ('', '', []),
+        (
+            """
+     appveyor.yml
+     CHANGES.rst
+     LICENSE
+     MANIFEST.in
+     pyproject.toml
+     README.rst
+     setup.cfg
+     setup.py
+     """,
+            '*.rst',
+            ('CHANGES.rst', 'README.rst'),
+        ),
+        (
+            """
+     appveyor.yml
+     CHANGES.rst
+     LICENSE
+     MANIFEST.in
+     pyproject.toml
+     README.rst
+     setup.cfg
+     setup.py
+     """,
+            b'*.rst',
+            (b'CHANGES.rst', b'README.rst'),
+        ),
+    ),
+)
+def test_glob(monkeypatch, tmpdir, tree, pattern, matches):
+    monkeypatch.chdir(tmpdir)
+    path.build({name: '' for name in tree.split()})
+    assert list(sorted(glob(pattern))) == list(sorted(matches))
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/tests/test_install_scripts.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/tests/test_install_scripts.py
new file mode 100644
index 0000000000000000000000000000000000000000..e62a6b7f318df2da0cf29e53c41f74e5525e78ac
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/tests/test_install_scripts.py
@@ -0,0 +1,89 @@
+"""install_scripts tests"""
+
+import sys
+
+import pytest
+
+from setuptools.command.install_scripts import install_scripts
+from setuptools.dist import Distribution
+
+from . import contexts
+
+
+class TestInstallScripts:
+    settings = dict(
+        name='foo',
+        entry_points={'console_scripts': ['foo=foo:foo']},
+        version='0.0',
+    )
+    unix_exe = '/usr/dummy-test-path/local/bin/python'
+    unix_spaces_exe = '/usr/bin/env dummy-test-python'
+    win32_exe = 'C:\\Dummy Test Path\\Program Files\\Python 3.6\\python.exe'
+
+    def _run_install_scripts(self, install_dir, executable=None):
+        dist = Distribution(self.settings)
+        dist.script_name = 'setup.py'
+        cmd = install_scripts(dist)
+        cmd.install_dir = install_dir
+        if executable is not None:
+            bs = cmd.get_finalized_command('build_scripts')
+            bs.executable = executable
+        cmd.ensure_finalized()
+        with contexts.quiet():
+            cmd.run()
+
+    @pytest.mark.skipif(sys.platform == 'win32', reason='non-Windows only')
+    def test_sys_executable_escaping_unix(self, tmpdir, monkeypatch):
+        """
+        Ensure that shebang is not quoted on Unix when getting the Python exe
+        from sys.executable.
+        """
+        expected = f'#!{self.unix_exe}\n'
+        monkeypatch.setattr('sys.executable', self.unix_exe)
+        with tmpdir.as_cwd():
+            self._run_install_scripts(str(tmpdir))
+            with open(str(tmpdir.join('foo')), 'r', encoding="utf-8") as f:
+                actual = f.readline()
+        assert actual == expected
+
+    @pytest.mark.skipif(sys.platform != 'win32', reason='Windows only')
+    def test_sys_executable_escaping_win32(self, tmpdir, monkeypatch):
+        """
+        Ensure that shebang is quoted on Windows when getting the Python exe
+        from sys.executable and it contains a space.
+        """
+        expected = f'#!"{self.win32_exe}"\n'
+        monkeypatch.setattr('sys.executable', self.win32_exe)
+        with tmpdir.as_cwd():
+            self._run_install_scripts(str(tmpdir))
+            with open(str(tmpdir.join('foo-script.py')), 'r', encoding="utf-8") as f:
+                actual = f.readline()
+        assert actual == expected
+
+    @pytest.mark.skipif(sys.platform == 'win32', reason='non-Windows only')
+    def test_executable_with_spaces_escaping_unix(self, tmpdir):
+        """
+        Ensure that shebang on Unix is not quoted, even when
+        a value with spaces
+        is specified using --executable.
+        """
+        expected = f'#!{self.unix_spaces_exe}\n'
+        with tmpdir.as_cwd():
+            self._run_install_scripts(str(tmpdir), self.unix_spaces_exe)
+            with open(str(tmpdir.join('foo')), 'r', encoding="utf-8") as f:
+                actual = f.readline()
+        assert actual == expected
+
+    @pytest.mark.skipif(sys.platform != 'win32', reason='Windows only')
+    def test_executable_arg_escaping_win32(self, tmpdir):
+        """
+        Ensure that shebang on Windows is quoted when
+        getting a path with spaces
+        from --executable, that is itself properly quoted.
+        """
+        expected = f'#!"{self.win32_exe}"\n'
+        with tmpdir.as_cwd():
+            self._run_install_scripts(str(tmpdir), '"' + self.win32_exe + '"')
+            with open(str(tmpdir.join('foo-script.py')), 'r', encoding="utf-8") as f:
+                actual = f.readline()
+        assert actual == expected
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/tests/test_logging.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/tests/test_logging.py
new file mode 100644
index 0000000000000000000000000000000000000000..ea58001e93d8e4bcbd50bfd49303324d71858d16
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/tests/test_logging.py
@@ -0,0 +1,76 @@
+import functools
+import inspect
+import logging
+import sys
+
+import pytest
+
+IS_PYPY = '__pypy__' in sys.builtin_module_names
+
+
+setup_py = """\
+from setuptools import setup
+
+setup(
+    name="test_logging",
+    version="0.0"
+)
+"""
+
+
+@pytest.mark.parametrize(
+    ('flag', 'expected_level'), [("--dry-run", "INFO"), ("--verbose", "DEBUG")]
+)
+def test_verbosity_level(tmp_path, monkeypatch, flag, expected_level):
+    """Make sure the correct verbosity level is set (issue #3038)"""
+    import setuptools  # noqa: F401  # import setuptools to monkeypatch distutils
+
+    import distutils  # <- load distutils after all the patches take place
+
+    logger = logging.Logger(__name__)
+    monkeypatch.setattr(logging, "root", logger)
+    unset_log_level = logger.getEffectiveLevel()
+    assert logging.getLevelName(unset_log_level) == "NOTSET"
+
+    setup_script = tmp_path / "setup.py"
+    setup_script.write_text(setup_py, encoding="utf-8")
+    dist = distutils.core.run_setup(setup_script, stop_after="init")
+    dist.script_args = [flag, "sdist"]
+    dist.parse_command_line()  # <- where the log level is set
+    log_level = logger.getEffectiveLevel()
+    log_level_name = logging.getLevelName(log_level)
+    assert log_level_name == expected_level
+
+
+def flaky_on_pypy(func):
+    @functools.wraps(func)
+    def _func():
+        try:
+            func()
+        except AssertionError:  # pragma: no cover
+            if IS_PYPY:
+                msg = "Flaky monkeypatch on PyPy (#4124)"
+                pytest.xfail(f"{msg}. Original discussion in #3707, #3709.")
+            raise
+
+    return _func
+
+
+@flaky_on_pypy
+def test_patching_does_not_cause_problems():
+    # Ensure `dist.log` is only patched if necessary
+
+    import _distutils_hack
+
+    import setuptools.logging
+
+    from distutils import dist
+
+    setuptools.logging.configure()
+
+    if _distutils_hack.enabled():
+        # Modern logging infra, no problematic patching.
+        assert dist.__file__ is None or "setuptools" in dist.__file__
+        assert isinstance(dist.log, logging.Logger)
+    else:
+        assert inspect.ismodule(dist.log)
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/tests/test_manifest.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/tests/test_manifest.py
new file mode 100644
index 0000000000000000000000000000000000000000..903a528db0cc2bba27bbcef24aa1c59dc4156528
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/tests/test_manifest.py
@@ -0,0 +1,622 @@
+"""sdist tests"""
+
+from __future__ import annotations
+
+import contextlib
+import io
+import itertools
+import logging
+import os
+import shutil
+import sys
+import tempfile
+
+import pytest
+
+from setuptools.command.egg_info import FileList, egg_info, translate_pattern
+from setuptools.dist import Distribution
+from setuptools.tests.textwrap import DALS
+
+from distutils import log
+from distutils.errors import DistutilsTemplateError
+
+IS_PYPY = '__pypy__' in sys.builtin_module_names
+
+
+def make_local_path(s):
+    """Converts '/' in a string to os.sep"""
+    return s.replace('/', os.sep)
+
+
+SETUP_ATTRS = {
+    'name': 'app',
+    'version': '0.0',
+    'packages': ['app'],
+}
+
+SETUP_PY = f"""\
+from setuptools import setup
+
+setup(**{SETUP_ATTRS!r})
+"""
+
+
+@contextlib.contextmanager
+def quiet():
+    old_stdout, old_stderr = sys.stdout, sys.stderr
+    sys.stdout, sys.stderr = io.StringIO(), io.StringIO()
+    try:
+        yield
+    finally:
+        sys.stdout, sys.stderr = old_stdout, old_stderr
+
+
+def touch(filename):
+    open(filename, 'wb').close()
+
+
+# The set of files always in the manifest, including all files in the
+# .egg-info directory
+default_files = frozenset(
+    map(
+        make_local_path,
+        [
+            'README.rst',
+            'MANIFEST.in',
+            'setup.py',
+            'app.egg-info/PKG-INFO',
+            'app.egg-info/SOURCES.txt',
+            'app.egg-info/dependency_links.txt',
+            'app.egg-info/top_level.txt',
+            'app/__init__.py',
+        ],
+    )
+)
+
+
+translate_specs: list[tuple[str, list[str], list[str]]] = [
+    ('foo', ['foo'], ['bar', 'foobar']),
+    ('foo/bar', ['foo/bar'], ['foo/bar/baz', './foo/bar', 'foo']),
+    # Glob matching
+    ('*.txt', ['foo.txt', 'bar.txt'], ['foo/foo.txt']),
+    ('dir/*.txt', ['dir/foo.txt', 'dir/bar.txt', 'dir/.txt'], ['notdir/foo.txt']),
+    ('*/*.py', ['bin/start.py'], []),
+    ('docs/page-?.txt', ['docs/page-9.txt'], ['docs/page-10.txt']),
+    # Globstars change what they mean depending upon where they are
+    (
+        'foo/**/bar',
+        ['foo/bing/bar', 'foo/bing/bang/bar', 'foo/bar'],
+        ['foo/abar'],
+    ),
+    (
+        'foo/**',
+        ['foo/bar/bing.py', 'foo/x'],
+        ['/foo/x'],
+    ),
+    (
+        '**',
+        ['x', 'abc/xyz', '@nything'],
+        [],
+    ),
+    # Character classes
+    (
+        'pre[one]post',
+        ['preopost', 'prenpost', 'preepost'],
+        ['prepost', 'preonepost'],
+    ),
+    (
+        'hello[!one]world',
+        ['helloxworld', 'helloyworld'],
+        ['hellooworld', 'helloworld', 'hellooneworld'],
+    ),
+    (
+        '[]one].txt',
+        ['o.txt', '].txt', 'e.txt'],
+        ['one].txt'],
+    ),
+    (
+        'foo[!]one]bar',
+        ['fooybar'],
+        ['foo]bar', 'fooobar', 'fooebar'],
+    ),
+]
+"""
+A spec of inputs for 'translate_pattern' and matches and mismatches
+for that input.
+"""
+
+match_params = itertools.chain.from_iterable(
+    zip(itertools.repeat(pattern), matches)
+    for pattern, matches, mismatches in translate_specs
+)
+
+
+@pytest.fixture(params=match_params)
+def pattern_match(request):
+    return map(make_local_path, request.param)
+
+
+mismatch_params = itertools.chain.from_iterable(
+    zip(itertools.repeat(pattern), mismatches)
+    for pattern, matches, mismatches in translate_specs
+)
+
+
+@pytest.fixture(params=mismatch_params)
+def pattern_mismatch(request):
+    return map(make_local_path, request.param)
+
+
+def test_translated_pattern_match(pattern_match):
+    pattern, target = pattern_match
+    assert translate_pattern(pattern).match(target)
+
+
+def test_translated_pattern_mismatch(pattern_mismatch):
+    pattern, target = pattern_mismatch
+    assert not translate_pattern(pattern).match(target)
+
+
+class TempDirTestCase:
+    def setup_method(self, method):
+        self.temp_dir = tempfile.mkdtemp()
+        self.old_cwd = os.getcwd()
+        os.chdir(self.temp_dir)
+
+    def teardown_method(self, method):
+        os.chdir(self.old_cwd)
+        shutil.rmtree(self.temp_dir)
+
+
+class TestManifestTest(TempDirTestCase):
+    def setup_method(self, method):
+        super().setup_method(method)
+
+        f = open(os.path.join(self.temp_dir, 'setup.py'), 'w', encoding="utf-8")
+        f.write(SETUP_PY)
+        f.close()
+        """
+        Create a file tree like:
+        - LICENSE
+        - README.rst
+        - testing.rst
+        - .hidden.rst
+        - app/
+            - __init__.py
+            - a.txt
+            - b.txt
+            - c.rst
+            - static/
+                - app.js
+                - app.js.map
+                - app.css
+                - app.css.map
+        """
+
+        for fname in ['README.rst', '.hidden.rst', 'testing.rst', 'LICENSE']:
+            touch(os.path.join(self.temp_dir, fname))
+
+        # Set up the rest of the test package
+        test_pkg = os.path.join(self.temp_dir, 'app')
+        os.mkdir(test_pkg)
+        for fname in ['__init__.py', 'a.txt', 'b.txt', 'c.rst']:
+            touch(os.path.join(test_pkg, fname))
+
+        # Some compiled front-end assets to include
+        static = os.path.join(test_pkg, 'static')
+        os.mkdir(static)
+        for fname in ['app.js', 'app.js.map', 'app.css', 'app.css.map']:
+            touch(os.path.join(static, fname))
+
+    def make_manifest(self, contents):
+        """Write a MANIFEST.in."""
+        manifest = os.path.join(self.temp_dir, 'MANIFEST.in')
+        with open(manifest, 'w', encoding="utf-8") as f:
+            f.write(DALS(contents))
+
+    def get_files(self):
+        """Run egg_info and get all the files to include, as a set"""
+        dist = Distribution(SETUP_ATTRS)
+        dist.script_name = 'setup.py'
+        cmd = egg_info(dist)
+        cmd.ensure_finalized()
+
+        cmd.run()
+
+        return set(cmd.filelist.files)
+
+    def test_no_manifest(self):
+        """Check a missing MANIFEST.in includes only the standard files."""
+        assert (default_files - set(['MANIFEST.in'])) == self.get_files()
+
+    def test_empty_files(self):
+        """Check an empty MANIFEST.in includes only the standard files."""
+        self.make_manifest("")
+        assert default_files == self.get_files()
+
+    def test_include(self):
+        """Include extra rst files in the project root."""
+        self.make_manifest("include *.rst")
+        files = default_files | set(['testing.rst', '.hidden.rst'])
+        assert files == self.get_files()
+
+    def test_exclude(self):
+        """Include everything in app/ except the text files"""
+        ml = make_local_path
+        self.make_manifest(
+            """
+            include app/*
+            exclude app/*.txt
+            """
+        )
+        files = default_files | set([ml('app/c.rst')])
+        assert files == self.get_files()
+
+    def test_include_multiple(self):
+        """Include with multiple patterns."""
+        ml = make_local_path
+        self.make_manifest("include app/*.txt app/static/*")
+        files = default_files | set([
+            ml('app/a.txt'),
+            ml('app/b.txt'),
+            ml('app/static/app.js'),
+            ml('app/static/app.js.map'),
+            ml('app/static/app.css'),
+            ml('app/static/app.css.map'),
+        ])
+        assert files == self.get_files()
+
+    def test_graft(self):
+        """Include the whole app/static/ directory."""
+        ml = make_local_path
+        self.make_manifest("graft app/static")
+        files = default_files | set([
+            ml('app/static/app.js'),
+            ml('app/static/app.js.map'),
+            ml('app/static/app.css'),
+            ml('app/static/app.css.map'),
+        ])
+        assert files == self.get_files()
+
+    def test_graft_glob_syntax(self):
+        """Include the whole app/static/ directory."""
+        ml = make_local_path
+        self.make_manifest("graft */static")
+        files = default_files | set([
+            ml('app/static/app.js'),
+            ml('app/static/app.js.map'),
+            ml('app/static/app.css'),
+            ml('app/static/app.css.map'),
+        ])
+        assert files == self.get_files()
+
+    def test_graft_global_exclude(self):
+        """Exclude all *.map files in the project."""
+        ml = make_local_path
+        self.make_manifest(
+            """
+            graft app/static
+            global-exclude *.map
+            """
+        )
+        files = default_files | set([ml('app/static/app.js'), ml('app/static/app.css')])
+        assert files == self.get_files()
+
+    def test_global_include(self):
+        """Include all *.rst, *.js, and *.css files in the whole tree."""
+        ml = make_local_path
+        self.make_manifest(
+            """
+            global-include *.rst *.js *.css
+            """
+        )
+        files = default_files | set([
+            '.hidden.rst',
+            'testing.rst',
+            ml('app/c.rst'),
+            ml('app/static/app.js'),
+            ml('app/static/app.css'),
+        ])
+        assert files == self.get_files()
+
+    def test_graft_prune(self):
+        """Include all files in app/, except for the whole app/static/ dir."""
+        ml = make_local_path
+        self.make_manifest(
+            """
+            graft app
+            prune app/static
+            """
+        )
+        files = default_files | set([ml('app/a.txt'), ml('app/b.txt'), ml('app/c.rst')])
+        assert files == self.get_files()
+
+
+class TestFileListTest(TempDirTestCase):
+    """
+    A copy of the relevant bits of distutils/tests/test_filelist.py,
+    to ensure setuptools' version of FileList keeps parity with distutils.
+    """
+
+    @pytest.fixture(autouse=os.getenv("SETUPTOOLS_USE_DISTUTILS") == "stdlib")
+    def _compat_record_logs(self, monkeypatch, caplog):
+        """Account for stdlib compatibility"""
+
+        def _log(_logger, level, msg, args):
+            exc = sys.exc_info()
+            rec = logging.LogRecord("distutils", level, "", 0, msg, args, exc)
+            caplog.records.append(rec)
+
+        monkeypatch.setattr(log.Log, "_log", _log)
+
+    def get_records(self, caplog, *levels):
+        return [r for r in caplog.records if r.levelno in levels]
+
+    def assertNoWarnings(self, caplog):
+        assert self.get_records(caplog, log.WARN) == []
+        caplog.clear()
+
+    def assertWarnings(self, caplog):
+        if IS_PYPY and not caplog.records:
+            pytest.xfail("caplog checks may not work well in PyPy")
+        else:
+            assert len(self.get_records(caplog, log.WARN)) > 0
+            caplog.clear()
+
+    def make_files(self, files):
+        for file in files:
+            file = os.path.join(self.temp_dir, file)
+            dirname, _basename = os.path.split(file)
+            os.makedirs(dirname, exist_ok=True)
+            touch(file)
+
+    def test_process_template_line(self):
+        # testing  all MANIFEST.in template patterns
+        file_list = FileList()
+        ml = make_local_path
+
+        # simulated file list
+        self.make_files([
+            'foo.tmp',
+            'ok',
+            'xo',
+            'four.txt',
+            'buildout.cfg',
+            # filelist does not filter out VCS directories,
+            # it's sdist that does
+            ml('.hg/last-message.txt'),
+            ml('global/one.txt'),
+            ml('global/two.txt'),
+            ml('global/files.x'),
+            ml('global/here.tmp'),
+            ml('f/o/f.oo'),
+            ml('dir/graft-one'),
+            ml('dir/dir2/graft2'),
+            ml('dir3/ok'),
+            ml('dir3/sub/ok.txt'),
+        ])
+
+        MANIFEST_IN = DALS(
+            """\
+        include ok
+        include xo
+        exclude xo
+        include foo.tmp
+        include buildout.cfg
+        global-include *.x
+        global-include *.txt
+        global-exclude *.tmp
+        recursive-include f *.oo
+        recursive-exclude global *.x
+        graft dir
+        prune dir3
+        """
+        )
+
+        for line in MANIFEST_IN.split('\n'):
+            if not line:
+                continue
+            file_list.process_template_line(line)
+
+        wanted = [
+            'buildout.cfg',
+            'four.txt',
+            'ok',
+            ml('.hg/last-message.txt'),
+            ml('dir/graft-one'),
+            ml('dir/dir2/graft2'),
+            ml('f/o/f.oo'),
+            ml('global/one.txt'),
+            ml('global/two.txt'),
+        ]
+
+        file_list.sort()
+        assert file_list.files == wanted
+
+    def test_exclude_pattern(self):
+        # return False if no match
+        file_list = FileList()
+        assert not file_list.exclude_pattern('*.py')
+
+        # return True if files match
+        file_list = FileList()
+        file_list.files = ['a.py', 'b.py']
+        assert file_list.exclude_pattern('*.py')
+
+        # test excludes
+        file_list = FileList()
+        file_list.files = ['a.py', 'a.txt']
+        file_list.exclude_pattern('*.py')
+        file_list.sort()
+        assert file_list.files == ['a.txt']
+
+    def test_include_pattern(self):
+        # return False if no match
+        file_list = FileList()
+        self.make_files([])
+        assert not file_list.include_pattern('*.py')
+
+        # return True if files match
+        file_list = FileList()
+        self.make_files(['a.py', 'b.txt'])
+        assert file_list.include_pattern('*.py')
+
+        # test * matches all files
+        file_list = FileList()
+        self.make_files(['a.py', 'b.txt'])
+        file_list.include_pattern('*')
+        file_list.sort()
+        assert file_list.files == ['a.py', 'b.txt']
+
+    def test_process_template_line_invalid(self):
+        # invalid lines
+        file_list = FileList()
+        for action in (
+            'include',
+            'exclude',
+            'global-include',
+            'global-exclude',
+            'recursive-include',
+            'recursive-exclude',
+            'graft',
+            'prune',
+            'blarg',
+        ):
+            with pytest.raises(DistutilsTemplateError):
+                file_list.process_template_line(action)
+
+    def test_include(self, caplog):
+        caplog.set_level(logging.DEBUG)
+        ml = make_local_path
+        # include
+        file_list = FileList()
+        self.make_files(['a.py', 'b.txt', ml('d/c.py')])
+
+        file_list.process_template_line('include *.py')
+        file_list.sort()
+        assert file_list.files == ['a.py']
+        self.assertNoWarnings(caplog)
+
+        file_list.process_template_line('include *.rb')
+        file_list.sort()
+        assert file_list.files == ['a.py']
+        self.assertWarnings(caplog)
+
+    def test_exclude(self, caplog):
+        caplog.set_level(logging.DEBUG)
+        ml = make_local_path
+        # exclude
+        file_list = FileList()
+        file_list.files = ['a.py', 'b.txt', ml('d/c.py')]
+
+        file_list.process_template_line('exclude *.py')
+        file_list.sort()
+        assert file_list.files == ['b.txt', ml('d/c.py')]
+        self.assertNoWarnings(caplog)
+
+        file_list.process_template_line('exclude *.rb')
+        file_list.sort()
+        assert file_list.files == ['b.txt', ml('d/c.py')]
+        self.assertWarnings(caplog)
+
+    def test_global_include(self, caplog):
+        caplog.set_level(logging.DEBUG)
+        ml = make_local_path
+        # global-include
+        file_list = FileList()
+        self.make_files(['a.py', 'b.txt', ml('d/c.py')])
+
+        file_list.process_template_line('global-include *.py')
+        file_list.sort()
+        assert file_list.files == ['a.py', ml('d/c.py')]
+        self.assertNoWarnings(caplog)
+
+        file_list.process_template_line('global-include *.rb')
+        file_list.sort()
+        assert file_list.files == ['a.py', ml('d/c.py')]
+        self.assertWarnings(caplog)
+
+    def test_global_exclude(self, caplog):
+        caplog.set_level(logging.DEBUG)
+        ml = make_local_path
+        # global-exclude
+        file_list = FileList()
+        file_list.files = ['a.py', 'b.txt', ml('d/c.py')]
+
+        file_list.process_template_line('global-exclude *.py')
+        file_list.sort()
+        assert file_list.files == ['b.txt']
+        self.assertNoWarnings(caplog)
+
+        file_list.process_template_line('global-exclude *.rb')
+        file_list.sort()
+        assert file_list.files == ['b.txt']
+        self.assertWarnings(caplog)
+
+    def test_recursive_include(self, caplog):
+        caplog.set_level(logging.DEBUG)
+        ml = make_local_path
+        # recursive-include
+        file_list = FileList()
+        self.make_files(['a.py', ml('d/b.py'), ml('d/c.txt'), ml('d/d/e.py')])
+
+        file_list.process_template_line('recursive-include d *.py')
+        file_list.sort()
+        assert file_list.files == [ml('d/b.py'), ml('d/d/e.py')]
+        self.assertNoWarnings(caplog)
+
+        file_list.process_template_line('recursive-include e *.py')
+        file_list.sort()
+        assert file_list.files == [ml('d/b.py'), ml('d/d/e.py')]
+        self.assertWarnings(caplog)
+
+    def test_recursive_exclude(self, caplog):
+        caplog.set_level(logging.DEBUG)
+        ml = make_local_path
+        # recursive-exclude
+        file_list = FileList()
+        file_list.files = ['a.py', ml('d/b.py'), ml('d/c.txt'), ml('d/d/e.py')]
+
+        file_list.process_template_line('recursive-exclude d *.py')
+        file_list.sort()
+        assert file_list.files == ['a.py', ml('d/c.txt')]
+        self.assertNoWarnings(caplog)
+
+        file_list.process_template_line('recursive-exclude e *.py')
+        file_list.sort()
+        assert file_list.files == ['a.py', ml('d/c.txt')]
+        self.assertWarnings(caplog)
+
+    def test_graft(self, caplog):
+        caplog.set_level(logging.DEBUG)
+        ml = make_local_path
+        # graft
+        file_list = FileList()
+        self.make_files(['a.py', ml('d/b.py'), ml('d/d/e.py'), ml('f/f.py')])
+
+        file_list.process_template_line('graft d')
+        file_list.sort()
+        assert file_list.files == [ml('d/b.py'), ml('d/d/e.py')]
+        self.assertNoWarnings(caplog)
+
+        file_list.process_template_line('graft e')
+        file_list.sort()
+        assert file_list.files == [ml('d/b.py'), ml('d/d/e.py')]
+        self.assertWarnings(caplog)
+
+    def test_prune(self, caplog):
+        caplog.set_level(logging.DEBUG)
+        ml = make_local_path
+        # prune
+        file_list = FileList()
+        file_list.files = ['a.py', ml('d/b.py'), ml('d/d/e.py'), ml('f/f.py')]
+
+        file_list.process_template_line('prune d')
+        file_list.sort()
+        assert file_list.files == ['a.py', ml('f/f.py')]
+        self.assertNoWarnings(caplog)
+
+        file_list.process_template_line('prune e')
+        file_list.sort()
+        assert file_list.files == ['a.py', ml('f/f.py')]
+        self.assertWarnings(caplog)
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/tests/test_namespaces.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/tests/test_namespaces.py
new file mode 100644
index 0000000000000000000000000000000000000000..a0f4120bf7900b2118cc066034e036ab7af1798b
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/tests/test_namespaces.py
@@ -0,0 +1,138 @@
+import subprocess
+import sys
+
+from setuptools._path import paths_on_pythonpath
+
+from . import namespaces
+
+
+class TestNamespaces:
+    def test_mixed_site_and_non_site(self, tmpdir):
+        """
+        Installing two packages sharing the same namespace, one installed
+        to a site dir and the other installed just to a path on PYTHONPATH
+        should leave the namespace in tact and both packages reachable by
+        import.
+        """
+        pkg_A = namespaces.build_namespace_package(tmpdir, 'myns.pkgA')
+        pkg_B = namespaces.build_namespace_package(tmpdir, 'myns.pkgB')
+        site_packages = tmpdir / 'site-packages'
+        path_packages = tmpdir / 'path-packages'
+        targets = site_packages, path_packages
+        # use pip to install to the target directory
+        install_cmd = [
+            sys.executable,
+            '-m',
+            'pip.__main__',
+            'install',
+            str(pkg_A),
+            '-t',
+            str(site_packages),
+        ]
+        subprocess.check_call(install_cmd)
+        namespaces.make_site_dir(site_packages)
+        install_cmd = [
+            sys.executable,
+            '-m',
+            'pip.__main__',
+            'install',
+            str(pkg_B),
+            '-t',
+            str(path_packages),
+        ]
+        subprocess.check_call(install_cmd)
+        try_import = [
+            sys.executable,
+            '-c',
+            'import myns.pkgA; import myns.pkgB',
+        ]
+        with paths_on_pythonpath(map(str, targets)):
+            subprocess.check_call(try_import)
+
+    def test_pkg_resources_import(self, tmpdir):
+        """
+        Ensure that a namespace package doesn't break on import
+        of pkg_resources.
+        """
+        pkg = namespaces.build_namespace_package(tmpdir, 'myns.pkgA')
+        target = tmpdir / 'packages'
+        target.mkdir()
+        install_cmd = [
+            sys.executable,
+            '-m',
+            'pip',
+            'install',
+            '-t',
+            str(target),
+            str(pkg),
+        ]
+        with paths_on_pythonpath([str(target)]):
+            subprocess.check_call(install_cmd)
+        namespaces.make_site_dir(target)
+        try_import = [
+            sys.executable,
+            '-c',
+            'import pkg_resources',
+        ]
+        with paths_on_pythonpath([str(target)]):
+            subprocess.check_call(try_import)
+
+    def test_namespace_package_installed_and_cwd(self, tmpdir):
+        """
+        Installing a namespace packages but also having it in the current
+        working directory, only one version should take precedence.
+        """
+        pkg_A = namespaces.build_namespace_package(tmpdir, 'myns.pkgA')
+        target = tmpdir / 'packages'
+        # use pip to install to the target directory
+        install_cmd = [
+            sys.executable,
+            '-m',
+            'pip.__main__',
+            'install',
+            str(pkg_A),
+            '-t',
+            str(target),
+        ]
+        subprocess.check_call(install_cmd)
+        namespaces.make_site_dir(target)
+
+        # ensure that package imports and pkg_resources imports
+        pkg_resources_imp = [
+            sys.executable,
+            '-c',
+            'import pkg_resources; import myns.pkgA',
+        ]
+        with paths_on_pythonpath([str(target)]):
+            subprocess.check_call(pkg_resources_imp, cwd=str(pkg_A))
+
+    def test_packages_in_the_same_namespace_installed_and_cwd(self, tmpdir):
+        """
+        Installing one namespace package and also have another in the same
+        namespace in the current working directory, both of them must be
+        importable.
+        """
+        pkg_A = namespaces.build_namespace_package(tmpdir, 'myns.pkgA')
+        pkg_B = namespaces.build_namespace_package(tmpdir, 'myns.pkgB')
+        target = tmpdir / 'packages'
+        # use pip to install to the target directory
+        install_cmd = [
+            sys.executable,
+            '-m',
+            'pip.__main__',
+            'install',
+            str(pkg_A),
+            '-t',
+            str(target),
+        ]
+        subprocess.check_call(install_cmd)
+        namespaces.make_site_dir(target)
+
+        # ensure that all packages import and pkg_resources imports
+        pkg_resources_imp = [
+            sys.executable,
+            '-c',
+            'import pkg_resources; import myns.pkgA; import myns.pkgB',
+        ]
+        with paths_on_pythonpath([str(target)]):
+            subprocess.check_call(pkg_resources_imp, cwd=str(pkg_B))
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/tests/test_packageindex.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/tests/test_packageindex.py
new file mode 100644
index 0000000000000000000000000000000000000000..2a6e5917a8733c71a5d9b29d4bde6fc12cc1e183
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/tests/test_packageindex.py
@@ -0,0 +1,267 @@
+import http.client
+import re
+import urllib.error
+import urllib.request
+from inspect import cleandoc
+
+import pytest
+
+import setuptools.package_index
+
+import distutils.errors
+
+
+class TestPackageIndex:
+    def test_regex(self):
+        hash_url = 'http://other_url?:action=show_md5&amp;'
+        hash_url += 'digest=0123456789abcdef0123456789abcdef'
+        doc = """
+            <a href="http://some_url">Name</a>
+            (<a title="MD5 hash"
+            href="{hash_url}">md5</a>)
+        """.lstrip().format(**locals())
+        assert setuptools.package_index.PYPI_MD5.match(doc)
+
+    def test_bad_url_bad_port(self):
+        index = setuptools.package_index.PackageIndex()
+        url = 'http://127.0.0.1:0/nonesuch/test_package_index'
+        with pytest.raises(Exception, match=re.escape(url)):
+            v = index.open_url(url)
+            assert isinstance(v, urllib.error.HTTPError)
+
+    def test_bad_url_typo(self):
+        # issue 16
+        # easy_install inquant.contentmirror.plone breaks because of a typo
+        # in its home URL
+        index = setuptools.package_index.PackageIndex(hosts=('www.example.com',))
+
+        url = 'url:%20https://svn.plone.org/svn/collective/inquant.contentmirror.plone/trunk'
+
+        with pytest.raises(Exception, match=re.escape(url)):
+            v = index.open_url(url)
+            assert isinstance(v, urllib.error.HTTPError)
+
+    def test_bad_url_bad_status_line(self):
+        index = setuptools.package_index.PackageIndex(hosts=('www.example.com',))
+
+        def _urlopen(*args):
+            raise http.client.BadStatusLine('line')
+
+        index.opener = _urlopen
+        url = 'http://example.com'
+        with pytest.raises(Exception, match=r'line'):
+            index.open_url(url)
+
+    def test_bad_url_double_scheme(self):
+        """
+        A bad URL with a double scheme should raise a DistutilsError.
+        """
+        index = setuptools.package_index.PackageIndex(hosts=('www.example.com',))
+
+        # issue 20
+        url = 'http://http://svn.pythonpaste.org/Paste/wphp/trunk'
+        try:
+            index.open_url(url)
+        except distutils.errors.DistutilsError as error:
+            msg = str(error)
+            assert (
+                'nonnumeric port' in msg
+                or 'getaddrinfo failed' in msg
+                or 'Name or service not known' in msg
+            )
+            return
+        raise RuntimeError("Did not raise")
+
+    def test_url_ok(self):
+        index = setuptools.package_index.PackageIndex(hosts=('www.example.com',))
+        url = 'file:///tmp/test_package_index'
+        assert index.url_ok(url, True)
+
+    def test_parse_bdist_wininst(self):
+        parse = setuptools.package_index.parse_bdist_wininst
+
+        actual = parse('reportlab-2.5.win32-py2.4.exe')
+        expected = 'reportlab-2.5', '2.4', 'win32'
+        assert actual == expected
+
+        actual = parse('reportlab-2.5.win32.exe')
+        expected = 'reportlab-2.5', None, 'win32'
+        assert actual == expected
+
+        actual = parse('reportlab-2.5.win-amd64-py2.7.exe')
+        expected = 'reportlab-2.5', '2.7', 'win-amd64'
+        assert actual == expected
+
+        actual = parse('reportlab-2.5.win-amd64.exe')
+        expected = 'reportlab-2.5', None, 'win-amd64'
+        assert actual == expected
+
+    def test__vcs_split_rev_from_url(self):
+        """
+        Test the basic usage of _vcs_split_rev_from_url
+        """
+        vsrfu = setuptools.package_index.PackageIndex._vcs_split_rev_from_url
+        url, rev = vsrfu('https://example.com/bar@2995')
+        assert url == 'https://example.com/bar'
+        assert rev == '2995'
+
+    def test_local_index(self, tmpdir):
+        """
+        local_open should be able to read an index from the file system.
+        """
+        index_file = tmpdir / 'index.html'
+        with index_file.open('w') as f:
+            f.write('<div>content</div>')
+        url = 'file:' + urllib.request.pathname2url(str(tmpdir)) + '/'
+        res = setuptools.package_index.local_open(url)
+        assert 'content' in res.read()
+
+    def test_egg_fragment(self):
+        """
+        EGG fragments must comply to PEP 440
+        """
+        epoch = [
+            '',
+            '1!',
+        ]
+        releases = [
+            '0',
+            '0.0',
+            '0.0.0',
+        ]
+        pre = [
+            'a0',
+            'b0',
+            'rc0',
+        ]
+        post = ['.post0']
+        dev = [
+            '.dev0',
+        ]
+        local = [
+            ('', ''),
+            ('+ubuntu.0', '+ubuntu.0'),
+            ('+ubuntu-0', '+ubuntu.0'),
+            ('+ubuntu_0', '+ubuntu.0'),
+        ]
+        versions = [
+            [''.join([e, r, p, loc]) for loc in locs]
+            for e in epoch
+            for r in releases
+            for p in sum([pre, post, dev], [''])
+            for locs in local
+        ]
+        for v, vc in versions:
+            dists = list(
+                setuptools.package_index.distros_for_url(
+                    'http://example.com/example-foo.zip#egg=example-foo-' + v
+                )
+            )
+            assert dists[0].version == ''
+            assert dists[1].version == vc
+
+    def test_download_git_with_rev(self, tmp_path, fp):
+        url = 'git+https://github.example/group/project@master#egg=foo'
+        index = setuptools.package_index.PackageIndex()
+
+        expected_dir = tmp_path / 'project@master'
+        fp.register([
+            'git',
+            'clone',
+            '--quiet',
+            'https://github.example/group/project',
+            expected_dir,
+        ])
+        fp.register(['git', '-C', expected_dir, 'checkout', '--quiet', 'master'])
+
+        result = index.download(url, tmp_path)
+
+        assert result == str(expected_dir)
+        assert len(fp.calls) == 2
+
+    def test_download_git_no_rev(self, tmp_path, fp):
+        url = 'git+https://github.example/group/project#egg=foo'
+        index = setuptools.package_index.PackageIndex()
+
+        expected_dir = tmp_path / 'project'
+        fp.register([
+            'git',
+            'clone',
+            '--quiet',
+            'https://github.example/group/project',
+            expected_dir,
+        ])
+        index.download(url, tmp_path)
+
+    def test_download_svn(self, tmp_path):
+        url = 'svn+https://svn.example/project#egg=foo'
+        index = setuptools.package_index.PackageIndex()
+
+        msg = r".*SVN download is not supported.*"
+        with pytest.raises(distutils.errors.DistutilsError, match=msg):
+            index.download(url, tmp_path)
+
+
+class TestContentCheckers:
+    def test_md5(self):
+        checker = setuptools.package_index.HashChecker.from_url(
+            'http://foo/bar#md5=f12895fdffbd45007040d2e44df98478'
+        )
+        checker.feed('You should probably not be using MD5'.encode('ascii'))
+        assert checker.hash.hexdigest() == 'f12895fdffbd45007040d2e44df98478'
+        assert checker.is_valid()
+
+    def test_other_fragment(self):
+        "Content checks should succeed silently if no hash is present"
+        checker = setuptools.package_index.HashChecker.from_url(
+            'http://foo/bar#something%20completely%20different'
+        )
+        checker.feed('anything'.encode('ascii'))
+        assert checker.is_valid()
+
+    def test_blank_md5(self):
+        "Content checks should succeed if a hash is empty"
+        checker = setuptools.package_index.HashChecker.from_url('http://foo/bar#md5=')
+        checker.feed('anything'.encode('ascii'))
+        assert checker.is_valid()
+
+    def test_get_hash_name_md5(self):
+        checker = setuptools.package_index.HashChecker.from_url(
+            'http://foo/bar#md5=f12895fdffbd45007040d2e44df98478'
+        )
+        assert checker.hash_name == 'md5'
+
+    def test_report(self):
+        checker = setuptools.package_index.HashChecker.from_url(
+            'http://foo/bar#md5=f12895fdffbd45007040d2e44df98478'
+        )
+        rep = checker.report(lambda x: x, 'My message about %s')
+        assert rep == 'My message about md5'
+
+
+class TestPyPIConfig:
+    def test_percent_in_password(self, tmp_home_dir):
+        pypirc = tmp_home_dir / '.pypirc'
+        pypirc.write_text(
+            cleandoc(
+                """
+                [pypi]
+                repository=https://pypi.org
+                username=jaraco
+                password=pity%
+                """
+            ),
+            encoding="utf-8",
+        )
+        cfg = setuptools.package_index.PyPIConfig()
+        cred = cfg.creds_by_repository['https://pypi.org']
+        assert cred.username == 'jaraco'
+        assert cred.password == 'pity%'
+
+
+@pytest.mark.timeout(1)
+def test_REL_DoS():
+    """
+    REL should not hang on a contrived attack string.
+    """
+    setuptools.package_index.REL.search('< rel=' + ' ' * 2**12)
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/tests/test_sandbox.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/tests/test_sandbox.py
new file mode 100644
index 0000000000000000000000000000000000000000..a476b7c93d7441834f415223cb386859581724f8
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/tests/test_sandbox.py
@@ -0,0 +1,134 @@
+"""develop tests"""
+
+import os
+import types
+
+import pytest
+
+import pkg_resources
+import setuptools.sandbox
+
+
+class TestSandbox:
+    def test_devnull(self, tmpdir):
+        with setuptools.sandbox.DirectorySandbox(str(tmpdir)):
+            self._file_writer(os.devnull)
+
+    @staticmethod
+    def _file_writer(path):
+        def do_write():
+            with open(path, 'w', encoding="utf-8") as f:
+                f.write('xxx')
+
+        return do_write
+
+    def test_setup_py_with_BOM(self):
+        """
+        It should be possible to execute a setup.py with a Byte Order Mark
+        """
+        target = pkg_resources.resource_filename(__name__, 'script-with-bom.py')
+        namespace = types.ModuleType('namespace')
+        setuptools.sandbox._execfile(target, vars(namespace))
+        assert namespace.result == 'passed'
+
+    def test_setup_py_with_CRLF(self, tmpdir):
+        setup_py = tmpdir / 'setup.py'
+        with setup_py.open('wb') as stream:
+            stream.write(b'"degenerate script"\r\n')
+        setuptools.sandbox._execfile(str(setup_py), globals())
+
+
+class TestExceptionSaver:
+    def test_exception_trapped(self):
+        with setuptools.sandbox.ExceptionSaver():
+            raise ValueError("details")
+
+    def test_exception_resumed(self):
+        with setuptools.sandbox.ExceptionSaver() as saved_exc:
+            raise ValueError("details")
+
+        with pytest.raises(ValueError) as caught:
+            saved_exc.resume()
+
+        assert isinstance(caught.value, ValueError)
+        assert str(caught.value) == 'details'
+
+    def test_exception_reconstructed(self):
+        orig_exc = ValueError("details")
+
+        with setuptools.sandbox.ExceptionSaver() as saved_exc:
+            raise orig_exc
+
+        with pytest.raises(ValueError) as caught:
+            saved_exc.resume()
+
+        assert isinstance(caught.value, ValueError)
+        assert caught.value is not orig_exc
+
+    def test_no_exception_passes_quietly(self):
+        with setuptools.sandbox.ExceptionSaver() as saved_exc:
+            pass
+
+        saved_exc.resume()
+
+    def test_unpickleable_exception(self):
+        class CantPickleThis(Exception):
+            "This Exception is unpickleable because it's not in globals"
+
+            def __repr__(self) -> str:
+                return f'CantPickleThis{self.args!r}'
+
+        with setuptools.sandbox.ExceptionSaver() as saved_exc:
+            raise CantPickleThis('detail')
+
+        with pytest.raises(setuptools.sandbox.UnpickleableException) as caught:
+            saved_exc.resume()
+
+        assert str(caught.value) == "CantPickleThis('detail',)"
+
+    def test_unpickleable_exception_when_hiding_setuptools(self):
+        """
+        As revealed in #440, an infinite recursion can occur if an unpickleable
+        exception while setuptools is hidden. Ensure this doesn't happen.
+        """
+
+        class ExceptionUnderTest(Exception):
+            """
+            An unpickleable exception (not in globals).
+            """
+
+        with pytest.raises(setuptools.sandbox.UnpickleableException) as caught:
+            with setuptools.sandbox.save_modules():
+                setuptools.sandbox.hide_setuptools()
+                raise ExceptionUnderTest
+
+        (msg,) = caught.value.args
+        assert msg == 'ExceptionUnderTest()'
+
+    def test_sandbox_violation_raised_hiding_setuptools(self, tmpdir):
+        """
+        When in a sandbox with setuptools hidden, a SandboxViolation
+        should reflect a proper exception and not be wrapped in
+        an UnpickleableException.
+        """
+
+        def write_file():
+            "Trigger a SandboxViolation by writing outside the sandbox"
+            with open('/etc/foo', 'w', encoding="utf-8"):
+                pass
+
+        with pytest.raises(setuptools.sandbox.SandboxViolation) as caught:
+            with setuptools.sandbox.save_modules():
+                setuptools.sandbox.hide_setuptools()
+                with setuptools.sandbox.DirectorySandbox(str(tmpdir)):
+                    write_file()
+
+        cmd, args, kwargs = caught.value.args
+        assert cmd == 'open'
+        assert args == ('/etc/foo', 'w')
+        assert kwargs == {"encoding": "utf-8"}
+
+        msg = str(caught.value)
+        assert 'open' in msg
+        assert "('/etc/foo', 'w')" in msg
+        assert "{'encoding': 'utf-8'}" in msg
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/tests/test_sdist.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/tests/test_sdist.py
new file mode 100644
index 0000000000000000000000000000000000000000..19d8ddf6dafb0cacc044a6021f283d3e9faaf800
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/tests/test_sdist.py
@@ -0,0 +1,984 @@
+"""sdist tests"""
+
+import contextlib
+import io
+import logging
+import os
+import pathlib
+import sys
+import tarfile
+import tempfile
+import unicodedata
+from inspect import cleandoc
+from pathlib import Path
+from unittest import mock
+
+import jaraco.path
+import pytest
+
+from setuptools import Command, SetuptoolsDeprecationWarning
+from setuptools._importlib import metadata
+from setuptools.command.egg_info import manifest_maker
+from setuptools.command.sdist import sdist
+from setuptools.dist import Distribution
+from setuptools.extension import Extension
+from setuptools.tests import fail_on_ascii
+
+from .text import Filenames
+
+import distutils
+from distutils.core import run_setup
+
+SETUP_ATTRS = {
+    'name': 'sdist_test',
+    'version': '0.0',
+    'packages': ['sdist_test'],
+    'package_data': {'sdist_test': ['*.txt']},
+    'data_files': [("data", [os.path.join("d", "e.dat")])],
+}
+
+SETUP_PY = f"""\
+from setuptools import setup
+
+setup(**{SETUP_ATTRS!r})
+"""
+
+EXTENSION = Extension(
+    name="sdist_test.f",
+    sources=[os.path.join("sdist_test", "f.c")],
+    depends=[os.path.join("sdist_test", "f.h")],
+)
+EXTENSION_SOURCES = EXTENSION.sources + EXTENSION.depends
+
+
+@contextlib.contextmanager
+def quiet():
+    old_stdout, old_stderr = sys.stdout, sys.stderr
+    sys.stdout, sys.stderr = io.StringIO(), io.StringIO()
+    try:
+        yield
+    finally:
+        sys.stdout, sys.stderr = old_stdout, old_stderr
+
+
+# Convert to POSIX path
+def posix(path):
+    if not isinstance(path, str):
+        return path.replace(os.sep.encode('ascii'), b'/')
+    else:
+        return path.replace(os.sep, '/')
+
+
+# HFS Plus uses decomposed UTF-8
+def decompose(path):
+    if isinstance(path, str):
+        return unicodedata.normalize('NFD', path)
+    try:
+        path = path.decode('utf-8')
+        path = unicodedata.normalize('NFD', path)
+        path = path.encode('utf-8')
+    except UnicodeError:
+        pass  # Not UTF-8
+    return path
+
+
+def read_all_bytes(filename):
+    with open(filename, 'rb') as fp:
+        return fp.read()
+
+
+def latin1_fail():
+    try:
+        desc, filename = tempfile.mkstemp(suffix=Filenames.latin_1)
+        os.close(desc)
+        os.remove(filename)
+    except Exception:
+        return True
+
+
+fail_on_latin1_encoded_filenames = pytest.mark.xfail(
+    latin1_fail(),
+    reason="System does not support latin-1 filenames",
+)
+
+
+skip_under_xdist = pytest.mark.skipif(
+    "os.environ.get('PYTEST_XDIST_WORKER')",
+    reason="pytest-dev/pytest-xdist#843",
+)
+skip_under_stdlib_distutils = pytest.mark.skipif(
+    not distutils.__package__.startswith('setuptools'),
+    reason="the test is not supported with stdlib distutils",
+)
+
+
+def touch(path):
+    open(path, 'wb').close()
+    return path
+
+
+def symlink_or_skip_test(src, dst):
+    try:
+        os.symlink(src, dst)
+    except (OSError, NotImplementedError):
+        pytest.skip("symlink not supported in OS")
+        return None
+    return dst
+
+
+class TestSdistTest:
+    @pytest.fixture(autouse=True)
+    def source_dir(self, tmpdir):
+        tmpdir = tmpdir / "project_root"
+        tmpdir.mkdir()
+
+        (tmpdir / 'setup.py').write_text(SETUP_PY, encoding='utf-8')
+
+        # Set up the rest of the test package
+        test_pkg = tmpdir / 'sdist_test'
+        test_pkg.mkdir()
+        data_folder = tmpdir / 'd'
+        data_folder.mkdir()
+        # *.rst was not included in package_data, so c.rst should not be
+        # automatically added to the manifest when not under version control
+        for fname in ['__init__.py', 'a.txt', 'b.txt', 'c.rst']:
+            touch(test_pkg / fname)
+        touch(data_folder / 'e.dat')
+        # C sources are not included by default, but they will be,
+        # if an extension module uses them as sources or depends
+        for fname in EXTENSION_SOURCES:
+            touch(tmpdir / fname)
+
+        with tmpdir.as_cwd():
+            yield tmpdir
+
+    def assert_package_data_in_manifest(self, cmd):
+        manifest = cmd.filelist.files
+        assert os.path.join('sdist_test', 'a.txt') in manifest
+        assert os.path.join('sdist_test', 'b.txt') in manifest
+        assert os.path.join('sdist_test', 'c.rst') not in manifest
+        assert os.path.join('d', 'e.dat') in manifest
+
+    def setup_with_extension(self):
+        setup_attrs = {**SETUP_ATTRS, 'ext_modules': [EXTENSION]}
+
+        dist = Distribution(setup_attrs)
+        dist.script_name = 'setup.py'
+        cmd = sdist(dist)
+        cmd.ensure_finalized()
+
+        with quiet():
+            cmd.run()
+
+        return cmd
+
+    def test_package_data_in_sdist(self):
+        """Regression test for pull request #4: ensures that files listed in
+        package_data are included in the manifest even if they're not added to
+        version control.
+        """
+
+        dist = Distribution(SETUP_ATTRS)
+        dist.script_name = 'setup.py'
+        cmd = sdist(dist)
+        cmd.ensure_finalized()
+
+        with quiet():
+            cmd.run()
+
+        self.assert_package_data_in_manifest(cmd)
+
+    def test_package_data_and_include_package_data_in_sdist(self):
+        """
+        Ensure package_data and include_package_data work
+        together.
+        """
+        setup_attrs = {**SETUP_ATTRS, 'include_package_data': True}
+        assert setup_attrs['package_data']
+
+        dist = Distribution(setup_attrs)
+        dist.script_name = 'setup.py'
+        cmd = sdist(dist)
+        cmd.ensure_finalized()
+
+        with quiet():
+            cmd.run()
+
+        self.assert_package_data_in_manifest(cmd)
+
+    def test_extension_sources_in_sdist(self):
+        """
+        Ensure that the files listed in Extension.sources and Extension.depends
+        are automatically included in the manifest.
+        """
+        cmd = self.setup_with_extension()
+        self.assert_package_data_in_manifest(cmd)
+        manifest = cmd.filelist.files
+        for path in EXTENSION_SOURCES:
+            assert path in manifest
+
+    def test_missing_extension_sources(self):
+        """
+        Similar to test_extension_sources_in_sdist but the referenced files don't exist.
+        Missing files should not be included in distribution (with no error raised).
+        """
+        for path in EXTENSION_SOURCES:
+            os.remove(path)
+
+        cmd = self.setup_with_extension()
+        self.assert_package_data_in_manifest(cmd)
+        manifest = cmd.filelist.files
+        for path in EXTENSION_SOURCES:
+            assert path not in manifest
+
+    def test_symlinked_extension_sources(self):
+        """
+        Similar to test_extension_sources_in_sdist but the referenced files are
+        instead symbolic links to project-local files. Referenced file paths
+        should be included. Symlink targets themselves should NOT be included.
+        """
+        symlinked = []
+        for path in EXTENSION_SOURCES:
+            base, ext = os.path.splitext(path)
+            target = base + "_target." + ext
+
+            os.rename(path, target)
+            symlink_or_skip_test(os.path.basename(target), path)
+            symlinked.append(target)
+
+        cmd = self.setup_with_extension()
+        self.assert_package_data_in_manifest(cmd)
+        manifest = cmd.filelist.files
+        for path in EXTENSION_SOURCES:
+            assert path in manifest
+        for path in symlinked:
+            assert path not in manifest
+
+    _INVALID_PATHS = {
+        "must be relative": lambda: (
+            os.path.abspath(os.path.join("sdist_test", "f.h"))
+        ),
+        "can't have `..` segments": lambda: (
+            os.path.join("sdist_test", "..", "sdist_test", "f.h")
+        ),
+        "doesn't exist": lambda: (
+            os.path.join("sdist_test", "this_file_does_not_exist.h")
+        ),
+        "must be inside the project root": lambda: (
+            symlink_or_skip_test(
+                touch(os.path.join("..", "outside_of_project_root.h")),
+                "symlink.h",
+            )
+        ),
+    }
+
+    @skip_under_stdlib_distutils
+    @pytest.mark.parametrize("reason", _INVALID_PATHS.keys())
+    def test_invalid_extension_depends(self, reason, caplog):
+        """
+        Due to backwards compatibility reasons, `Extension.depends` should accept
+        invalid/weird paths, but then ignore them when building a sdist.
+
+        This test verifies that the source distribution is still built
+        successfully with such paths, but that instead of adding these paths to
+        the manifest, we emit an informational message, notifying the user that
+        the invalid path won't be automatically included.
+        """
+        invalid_path = self._INVALID_PATHS[reason]()
+        extension = Extension(
+            name="sdist_test.f",
+            sources=[],
+            depends=[invalid_path],
+        )
+        setup_attrs = {**SETUP_ATTRS, 'ext_modules': [extension]}
+
+        dist = Distribution(setup_attrs)
+        dist.script_name = 'setup.py'
+        cmd = sdist(dist)
+        cmd.ensure_finalized()
+
+        with quiet(), caplog.at_level(logging.INFO):
+            cmd.run()
+
+        self.assert_package_data_in_manifest(cmd)
+        manifest = cmd.filelist.files
+        assert invalid_path not in manifest
+
+        expected_message = [
+            message
+            for (logger, level, message) in caplog.record_tuples
+            if (
+                logger == "root"  #
+                and level == logging.INFO  #
+                and invalid_path in message  #
+            )
+        ]
+        assert len(expected_message) == 1
+        (expected_message,) = expected_message
+        assert reason in expected_message
+
+    def test_custom_build_py(self):
+        """
+        Ensure projects defining custom build_py don't break
+        when creating sdists (issue #2849)
+        """
+        from distutils.command.build_py import build_py as OrigBuildPy
+
+        using_custom_command_guard = mock.Mock()
+
+        class CustomBuildPy(OrigBuildPy):
+            """
+            Some projects have custom commands inheriting from `distutils`
+            """
+
+            def get_data_files(self):
+                using_custom_command_guard()
+                return super().get_data_files()
+
+        setup_attrs = {**SETUP_ATTRS, 'include_package_data': True}
+        assert setup_attrs['package_data']
+
+        dist = Distribution(setup_attrs)
+        dist.script_name = 'setup.py'
+        cmd = sdist(dist)
+        cmd.ensure_finalized()
+
+        # Make sure we use the custom command
+        cmd.cmdclass = {'build_py': CustomBuildPy}
+        cmd.distribution.cmdclass = {'build_py': CustomBuildPy}
+        assert cmd.distribution.get_command_class('build_py') == CustomBuildPy
+
+        msg = "setuptools instead of distutils"
+        with quiet(), pytest.warns(SetuptoolsDeprecationWarning, match=msg):
+            cmd.run()
+
+        using_custom_command_guard.assert_called()
+        self.assert_package_data_in_manifest(cmd)
+
+    def test_setup_py_exists(self):
+        dist = Distribution(SETUP_ATTRS)
+        dist.script_name = 'foo.py'
+        cmd = sdist(dist)
+        cmd.ensure_finalized()
+
+        with quiet():
+            cmd.run()
+
+        manifest = cmd.filelist.files
+        assert 'setup.py' in manifest
+
+    def test_setup_py_missing(self):
+        dist = Distribution(SETUP_ATTRS)
+        dist.script_name = 'foo.py'
+        cmd = sdist(dist)
+        cmd.ensure_finalized()
+
+        if os.path.exists("setup.py"):
+            os.remove("setup.py")
+        with quiet():
+            cmd.run()
+
+        manifest = cmd.filelist.files
+        assert 'setup.py' not in manifest
+
+    def test_setup_py_excluded(self):
+        with open("MANIFEST.in", "w", encoding="utf-8") as manifest_file:
+            manifest_file.write("exclude setup.py")
+
+        dist = Distribution(SETUP_ATTRS)
+        dist.script_name = 'foo.py'
+        cmd = sdist(dist)
+        cmd.ensure_finalized()
+
+        with quiet():
+            cmd.run()
+
+        manifest = cmd.filelist.files
+        assert 'setup.py' not in manifest
+
+    def test_defaults_case_sensitivity(self, source_dir):
+        """
+        Make sure default files (README.*, etc.) are added in a case-sensitive
+        way to avoid problems with packages built on Windows.
+        """
+
+        touch(source_dir / 'readme.rst')
+        touch(source_dir / 'SETUP.cfg')
+
+        dist = Distribution(SETUP_ATTRS)
+        # the extension deliberately capitalized for this test
+        # to make sure the actual filename (not capitalized) gets added
+        # to the manifest
+        dist.script_name = 'setup.PY'
+        cmd = sdist(dist)
+        cmd.ensure_finalized()
+
+        with quiet():
+            cmd.run()
+
+        # lowercase all names so we can test in a
+        # case-insensitive way to make sure the files
+        # are not included.
+        manifest = map(lambda x: x.lower(), cmd.filelist.files)
+        assert 'readme.rst' not in manifest, manifest
+        assert 'setup.py' not in manifest, manifest
+        assert 'setup.cfg' not in manifest, manifest
+
+    def test_exclude_dev_only_cache_folders(self, source_dir):
+        included = {
+            # Emulate problem in https://github.com/pypa/setuptools/issues/4601
+            "MANIFEST.in": (
+                "global-include LICEN[CS]E* COPYING* NOTICE* AUTHORS*\n"
+                "global-include *.txt\n"
+            ),
+            # For the sake of being conservative and limiting unforeseen side-effects
+            # we just exclude dev-only cache folders at the root of the repository:
+            "test/.venv/lib/python3.9/site-packages/bar-2.dist-info/AUTHORS.rst": "",
+            "src/.nox/py/lib/python3.12/site-packages/bar-2.dist-info/COPYING.txt": "",
+            "doc/.tox/default/lib/python3.11/site-packages/foo-4.dist-info/LICENSE": "",
+            # Let's test against false positives with similarly named files:
+            ".venv-requirements.txt": "",
+            ".tox-coveragerc.txt": "",
+            ".noxy/coveragerc.txt": "",
+        }
+
+        excluded = {
+            # .tox/.nox/.venv are well-know folders present at the root of Python repos
+            # and therefore should be excluded
+            ".tox/release/lib/python3.11/site-packages/foo-4.dist-info/LICENSE": "",
+            ".nox/py/lib/python3.12/site-packages/bar-2.dist-info/COPYING.txt": "",
+            ".venv/lib/python3.9/site-packages/bar-2.dist-info/AUTHORS.rst": "",
+        }
+
+        for file, content in {**excluded, **included}.items():
+            Path(source_dir, file).parent.mkdir(parents=True, exist_ok=True)
+            Path(source_dir, file).write_text(content, encoding="utf-8")
+
+        cmd = self.setup_with_extension()
+        self.assert_package_data_in_manifest(cmd)
+        manifest = {f.replace(os.sep, '/') for f in cmd.filelist.files}
+        for path in excluded:
+            assert os.path.exists(path)
+            assert path not in manifest, (path, manifest)
+        for path in included:
+            assert os.path.exists(path)
+            assert path in manifest, (path, manifest)
+
+    @fail_on_ascii
+    def test_manifest_is_written_with_utf8_encoding(self):
+        # Test for #303.
+        dist = Distribution(SETUP_ATTRS)
+        dist.script_name = 'setup.py'
+        mm = manifest_maker(dist)
+        mm.manifest = os.path.join('sdist_test.egg-info', 'SOURCES.txt')
+        os.mkdir('sdist_test.egg-info')
+
+        # UTF-8 filename
+        filename = os.path.join('sdist_test', 'smörbröd.py')
+
+        # Must create the file or it will get stripped.
+        touch(filename)
+
+        # Add UTF-8 filename and write manifest
+        with quiet():
+            mm.run()
+            mm.filelist.append(filename)
+            mm.write_manifest()
+
+        contents = read_all_bytes(mm.manifest)
+
+        # The manifest should be UTF-8 encoded
+        u_contents = contents.decode('UTF-8')
+
+        # The manifest should contain the UTF-8 filename
+        assert posix(filename) in u_contents
+
+    @fail_on_ascii
+    def test_write_manifest_allows_utf8_filenames(self):
+        # Test for #303.
+        dist = Distribution(SETUP_ATTRS)
+        dist.script_name = 'setup.py'
+        mm = manifest_maker(dist)
+        mm.manifest = os.path.join('sdist_test.egg-info', 'SOURCES.txt')
+        os.mkdir('sdist_test.egg-info')
+
+        filename = os.path.join(b'sdist_test', Filenames.utf_8)
+
+        # Must touch the file or risk removal
+        touch(filename)
+
+        # Add filename and write manifest
+        with quiet():
+            mm.run()
+            u_filename = filename.decode('utf-8')
+            mm.filelist.files.append(u_filename)
+            # Re-write manifest
+            mm.write_manifest()
+
+        contents = read_all_bytes(mm.manifest)
+
+        # The manifest should be UTF-8 encoded
+        contents.decode('UTF-8')
+
+        # The manifest should contain the UTF-8 filename
+        assert posix(filename) in contents
+
+        # The filelist should have been updated as well
+        assert u_filename in mm.filelist.files
+
+    @skip_under_xdist
+    def test_write_manifest_skips_non_utf8_filenames(self):
+        """
+        Files that cannot be encoded to UTF-8 (specifically, those that
+        weren't originally successfully decoded and have surrogate
+        escapes) should be omitted from the manifest.
+        See https://bitbucket.org/tarek/distribute/issue/303 for history.
+        """
+        dist = Distribution(SETUP_ATTRS)
+        dist.script_name = 'setup.py'
+        mm = manifest_maker(dist)
+        mm.manifest = os.path.join('sdist_test.egg-info', 'SOURCES.txt')
+        os.mkdir('sdist_test.egg-info')
+
+        # Latin-1 filename
+        filename = os.path.join(b'sdist_test', Filenames.latin_1)
+
+        # Add filename with surrogates and write manifest
+        with quiet():
+            mm.run()
+            u_filename = filename.decode('utf-8', 'surrogateescape')
+            mm.filelist.append(u_filename)
+            # Re-write manifest
+            mm.write_manifest()
+
+        contents = read_all_bytes(mm.manifest)
+
+        # The manifest should be UTF-8 encoded
+        contents.decode('UTF-8')
+
+        # The Latin-1 filename should have been skipped
+        assert posix(filename) not in contents
+
+        # The filelist should have been updated as well
+        assert u_filename not in mm.filelist.files
+
+    @fail_on_ascii
+    def test_manifest_is_read_with_utf8_encoding(self):
+        # Test for #303.
+        dist = Distribution(SETUP_ATTRS)
+        dist.script_name = 'setup.py'
+        cmd = sdist(dist)
+        cmd.ensure_finalized()
+
+        # Create manifest
+        with quiet():
+            cmd.run()
+
+        # Add UTF-8 filename to manifest
+        filename = os.path.join(b'sdist_test', Filenames.utf_8)
+        cmd.manifest = os.path.join('sdist_test.egg-info', 'SOURCES.txt')
+        manifest = open(cmd.manifest, 'ab')
+        manifest.write(b'\n' + filename)
+        manifest.close()
+
+        # The file must exist to be included in the filelist
+        touch(filename)
+
+        # Re-read manifest
+        cmd.filelist.files = []
+        with quiet():
+            cmd.read_manifest()
+
+        # The filelist should contain the UTF-8 filename
+        filename = filename.decode('utf-8')
+        assert filename in cmd.filelist.files
+
+    @fail_on_latin1_encoded_filenames
+    def test_read_manifest_skips_non_utf8_filenames(self):
+        # Test for #303.
+        dist = Distribution(SETUP_ATTRS)
+        dist.script_name = 'setup.py'
+        cmd = sdist(dist)
+        cmd.ensure_finalized()
+
+        # Create manifest
+        with quiet():
+            cmd.run()
+
+        # Add Latin-1 filename to manifest
+        filename = os.path.join(b'sdist_test', Filenames.latin_1)
+        cmd.manifest = os.path.join('sdist_test.egg-info', 'SOURCES.txt')
+        manifest = open(cmd.manifest, 'ab')
+        manifest.write(b'\n' + filename)
+        manifest.close()
+
+        # The file must exist to be included in the filelist
+        touch(filename)
+
+        # Re-read manifest
+        cmd.filelist.files = []
+        with quiet():
+            cmd.read_manifest()
+
+        # The Latin-1 filename should have been skipped
+        filename = filename.decode('latin-1')
+        assert filename not in cmd.filelist.files
+
+    @fail_on_ascii
+    @fail_on_latin1_encoded_filenames
+    def test_sdist_with_utf8_encoded_filename(self):
+        # Test for #303.
+        dist = Distribution(self.make_strings(SETUP_ATTRS))
+        dist.script_name = 'setup.py'
+        cmd = sdist(dist)
+        cmd.ensure_finalized()
+
+        filename = os.path.join(b'sdist_test', Filenames.utf_8)
+        touch(filename)
+
+        with quiet():
+            cmd.run()
+
+        if sys.platform == 'darwin':
+            filename = decompose(filename)
+
+        fs_enc = sys.getfilesystemencoding()
+
+        if sys.platform == 'win32':
+            if fs_enc == 'cp1252':
+                # Python mangles the UTF-8 filename
+                filename = filename.decode('cp1252')
+                assert filename in cmd.filelist.files
+            else:
+                filename = filename.decode('mbcs')
+                assert filename in cmd.filelist.files
+        else:
+            filename = filename.decode('utf-8')
+            assert filename in cmd.filelist.files
+
+    @classmethod
+    def make_strings(cls, item):
+        if isinstance(item, dict):
+            return {key: cls.make_strings(value) for key, value in item.items()}
+        if isinstance(item, list):
+            return list(map(cls.make_strings, item))
+        return str(item)
+
+    @fail_on_latin1_encoded_filenames
+    @skip_under_xdist
+    def test_sdist_with_latin1_encoded_filename(self):
+        # Test for #303.
+        dist = Distribution(self.make_strings(SETUP_ATTRS))
+        dist.script_name = 'setup.py'
+        cmd = sdist(dist)
+        cmd.ensure_finalized()
+
+        # Latin-1 filename
+        filename = os.path.join(b'sdist_test', Filenames.latin_1)
+        touch(filename)
+        assert os.path.isfile(filename)
+
+        with quiet():
+            cmd.run()
+
+        # not all windows systems have a default FS encoding of cp1252
+        if sys.platform == 'win32':
+            # Latin-1 is similar to Windows-1252 however
+            # on mbcs filesys it is not in latin-1 encoding
+            fs_enc = sys.getfilesystemencoding()
+            if fs_enc != 'mbcs':
+                fs_enc = 'latin-1'
+            filename = filename.decode(fs_enc)
+
+            assert filename in cmd.filelist.files
+        else:
+            # The Latin-1 filename should have been skipped
+            filename = filename.decode('latin-1')
+            assert filename not in cmd.filelist.files
+
+    _EXAMPLE_DIRECTIVES = {
+        "setup.cfg - long_description and version": """
+            [metadata]
+            name = testing
+            version = file: src/VERSION.txt
+            license_files = DOWHATYOUWANT
+            long_description = file: README.rst, USAGE.rst
+            """,
+        "pyproject.toml - static readme/license files and dynamic version": """
+            [project]
+            name = "testing"
+            readme = "USAGE.rst"
+            license-files = ["DOWHATYOUWANT"]
+            dynamic = ["version"]
+            [tool.setuptools.dynamic]
+            version = {file = ["src/VERSION.txt"]}
+            """,
+        "pyproject.toml - directive with str instead of list": """
+            [project]
+            name = "testing"
+            readme = "USAGE.rst"
+            license-files = ["DOWHATYOUWANT"]
+            dynamic = ["version"]
+            [tool.setuptools.dynamic]
+            version = {file = "src/VERSION.txt"}
+            """,
+        "pyproject.toml - deprecated license table with file entry": """
+            [project]
+            name = "testing"
+            readme = "USAGE.rst"
+            license = {file = "DOWHATYOUWANT"}
+            dynamic = ["version"]
+            [tool.setuptools.dynamic]
+            version = {file = "src/VERSION.txt"}
+            """,
+    }
+
+    @pytest.mark.parametrize("config", _EXAMPLE_DIRECTIVES.keys())
+    @pytest.mark.filterwarnings(
+        "ignore:.project.license. as a TOML table is deprecated"
+    )
+    def test_add_files_referenced_by_config_directives(self, source_dir, config):
+        config_file, _, _ = config.partition(" - ")
+        config_text = self._EXAMPLE_DIRECTIVES[config]
+        (source_dir / 'src').mkdir()
+        (source_dir / 'src/VERSION.txt').write_text("0.42", encoding="utf-8")
+        (source_dir / 'README.rst').write_text("hello world!", encoding="utf-8")
+        (source_dir / 'USAGE.rst').write_text("hello world!", encoding="utf-8")
+        (source_dir / 'DOWHATYOUWANT').write_text("hello world!", encoding="utf-8")
+        (source_dir / config_file).write_text(config_text, encoding="utf-8")
+
+        dist = Distribution({"packages": []})
+        dist.script_name = 'setup.py'
+        dist.parse_config_files()
+
+        cmd = sdist(dist)
+        cmd.ensure_finalized()
+        with quiet():
+            cmd.run()
+
+        assert (
+            'src/VERSION.txt' in cmd.filelist.files
+            or 'src\\VERSION.txt' in cmd.filelist.files
+        )
+        assert 'USAGE.rst' in cmd.filelist.files
+        assert 'DOWHATYOUWANT' in cmd.filelist.files
+        assert '/' not in cmd.filelist.files
+        assert '\\' not in cmd.filelist.files
+
+    def test_pyproject_toml_in_sdist(self, source_dir):
+        """
+        Check if pyproject.toml is included in source distribution if present
+        """
+        touch(source_dir / 'pyproject.toml')
+        dist = Distribution(SETUP_ATTRS)
+        dist.script_name = 'setup.py'
+        cmd = sdist(dist)
+        cmd.ensure_finalized()
+        with quiet():
+            cmd.run()
+        manifest = cmd.filelist.files
+        assert 'pyproject.toml' in manifest
+
+    def test_pyproject_toml_excluded(self, source_dir):
+        """
+        Check that pyproject.toml can excluded even if present
+        """
+        touch(source_dir / 'pyproject.toml')
+        with open('MANIFEST.in', 'w', encoding="utf-8") as mts:
+            print('exclude pyproject.toml', file=mts)
+        dist = Distribution(SETUP_ATTRS)
+        dist.script_name = 'setup.py'
+        cmd = sdist(dist)
+        cmd.ensure_finalized()
+        with quiet():
+            cmd.run()
+        manifest = cmd.filelist.files
+        assert 'pyproject.toml' not in manifest
+
+    def test_build_subcommand_source_files(self, source_dir):
+        touch(source_dir / '.myfile~')
+
+        # Sanity check: without custom commands file list should not be affected
+        dist = Distribution({**SETUP_ATTRS, "script_name": "setup.py"})
+        cmd = sdist(dist)
+        cmd.ensure_finalized()
+        with quiet():
+            cmd.run()
+        manifest = cmd.filelist.files
+        assert '.myfile~' not in manifest
+
+        # Test: custom command should be able to augment file list
+        dist = Distribution({**SETUP_ATTRS, "script_name": "setup.py"})
+        build = dist.get_command_obj("build")
+        build.sub_commands = [*build.sub_commands, ("build_custom", None)]
+
+        class build_custom(Command):
+            def initialize_options(self): ...
+
+            def finalize_options(self): ...
+
+            def run(self): ...
+
+            def get_source_files(self):
+                return ['.myfile~']
+
+        dist.cmdclass.update(build_custom=build_custom)
+
+        cmd = sdist(dist)
+        cmd.use_defaults = True
+        cmd.ensure_finalized()
+        with quiet():
+            cmd.run()
+        manifest = cmd.filelist.files
+        assert '.myfile~' in manifest
+
+    @pytest.mark.skipif("os.environ.get('SETUPTOOLS_USE_DISTUTILS') == 'stdlib'")
+    def test_build_base_pathlib(self, source_dir):
+        """
+        Ensure if build_base is a pathlib.Path, the build still succeeds.
+        """
+        dist = Distribution({
+            **SETUP_ATTRS,
+            "script_name": "setup.py",
+            "options": {"build": {"build_base": pathlib.Path('build')}},
+        })
+        cmd = sdist(dist)
+        cmd.ensure_finalized()
+        with quiet():
+            cmd.run()
+
+
+def test_default_revctrl():
+    """
+    When _default_revctrl was removed from the `setuptools.command.sdist`
+    module in 10.0, it broke some systems which keep an old install of
+    setuptools (Distribute) around. Those old versions require that the
+    setuptools package continue to implement that interface, so this
+    function provides that interface, stubbed. See #320 for details.
+
+    This interface must be maintained until Ubuntu 12.04 is no longer
+    supported (by Setuptools).
+    """
+    (ep,) = metadata.EntryPoints._from_text(
+        """
+        [setuptools.file_finders]
+        svn_cvs = setuptools.command.sdist:_default_revctrl
+        """
+    )
+    res = ep.load()
+    assert hasattr(res, '__iter__')
+
+
+class TestRegressions:
+    """
+    Can be removed/changed if the project decides to change how it handles symlinks
+    or external files.
+    """
+
+    @staticmethod
+    def files_for_symlink_in_extension_depends(tmp_path, dep_path):
+        return {
+            "external": {
+                "dir": {"file.h": ""},
+            },
+            "project": {
+                "setup.py": cleandoc(
+                    f"""
+                    from setuptools import Extension, setup
+                    setup(
+                        name="myproj",
+                        version="42",
+                        ext_modules=[
+                            Extension(
+                                "hello", sources=["hello.pyx"],
+                                depends=[{dep_path!r}]
+                            )
+                        ],
+                    )
+                    """
+                ),
+                "hello.pyx": "",
+                "MANIFEST.in": "global-include *.h",
+            },
+        }
+
+    @pytest.mark.parametrize(
+        "dep_path", ("myheaders/dir/file.h", "myheaders/dir/../dir/file.h")
+    )
+    def test_symlink_in_extension_depends(self, monkeypatch, tmp_path, dep_path):
+        # Given a project with a symlinked dir and a "depends" targeting that dir
+        files = self.files_for_symlink_in_extension_depends(tmp_path, dep_path)
+        jaraco.path.build(files, prefix=str(tmp_path))
+        symlink_or_skip_test(tmp_path / "external", tmp_path / "project/myheaders")
+
+        # When `sdist` runs, there should be no error
+        members = run_sdist(monkeypatch, tmp_path / "project")
+        # and the sdist should contain the symlinked files
+        for expected in (
+            "myproj-42/hello.pyx",
+            "myproj-42/myheaders/dir/file.h",
+        ):
+            assert expected in members
+
+    @staticmethod
+    def files_for_external_path_in_extension_depends(tmp_path, dep_path):
+        head, _, tail = dep_path.partition("$tmp_path$/")
+        dep_path = tmp_path / tail if tail else head
+
+        return {
+            "external": {
+                "dir": {"file.h": ""},
+            },
+            "project": {
+                "setup.py": cleandoc(
+                    f"""
+                    from setuptools import Extension, setup
+                    setup(
+                        name="myproj",
+                        version="42",
+                        ext_modules=[
+                            Extension(
+                                "hello", sources=["hello.pyx"],
+                                depends=[{str(dep_path)!r}]
+                            )
+                        ],
+                    )
+                    """
+                ),
+                "hello.pyx": "",
+                "MANIFEST.in": "global-include *.h",
+            },
+        }
+
+    @pytest.mark.parametrize(
+        "dep_path", ("$tmp_path$/external/dir/file.h", "../external/dir/file.h")
+    )
+    def test_external_path_in_extension_depends(self, monkeypatch, tmp_path, dep_path):
+        # Given a project with a "depends" targeting an external dir
+        files = self.files_for_external_path_in_extension_depends(tmp_path, dep_path)
+        jaraco.path.build(files, prefix=str(tmp_path))
+        # When `sdist` runs, there should be no error
+        members = run_sdist(monkeypatch, tmp_path / "project")
+        # and the sdist should not contain the external file
+        for name in members:
+            assert "file.h" not in name
+
+
+def run_sdist(monkeypatch, project):
+    """Given a project directory, run the sdist and return its contents"""
+    monkeypatch.chdir(project)
+    with quiet():
+        run_setup("setup.py", ["sdist"])
+
+    archive = next((project / "dist").glob("*.tar.gz"))
+    with tarfile.open(str(archive)) as tar:
+        return set(tar.getnames())
+
+
+def test_sanity_check_setuptools_own_sdist(setuptools_sdist):
+    with tarfile.open(setuptools_sdist) as tar:
+        files = tar.getnames()
+
+    # setuptools sdist should not include the .tox folder
+    tox_files = [name for name in files if ".tox" in name]
+    assert len(tox_files) == 0, f"not empty {tox_files}"
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/tests/test_setopt.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/tests/test_setopt.py
new file mode 100644
index 0000000000000000000000000000000000000000..ccf25618a5d6e255ad0be0fbed51fc29c179dcfe
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/tests/test_setopt.py
@@ -0,0 +1,40 @@
+import configparser
+
+from setuptools.command import setopt
+
+
+class TestEdit:
+    @staticmethod
+    def parse_config(filename):
+        parser = configparser.ConfigParser()
+        with open(filename, encoding='utf-8') as reader:
+            parser.read_file(reader)
+        return parser
+
+    @staticmethod
+    def write_text(file, content):
+        with open(file, 'wb') as strm:
+            strm.write(content.encode('utf-8'))
+
+    def test_utf8_encoding_retained(self, tmpdir):
+        """
+        When editing a file, non-ASCII characters encoded in
+        UTF-8 should be retained.
+        """
+        config = tmpdir.join('setup.cfg')
+        self.write_text(str(config), '[names]\njaraco=джарако')
+        setopt.edit_config(str(config), dict(names=dict(other='yes')))
+        parser = self.parse_config(str(config))
+        assert parser.get('names', 'jaraco') == 'джарако'
+        assert parser.get('names', 'other') == 'yes'
+
+    def test_case_retained(self, tmpdir):
+        """
+        When editing a file, case of keys should be retained.
+        """
+        config = tmpdir.join('setup.cfg')
+        self.write_text(str(config), '[names]\nFoO=bAr')
+        setopt.edit_config(str(config), dict(names=dict(oTher='yes')))
+        actual = config.read_text(encoding='ascii')
+        assert 'FoO' in actual
+        assert 'oTher' in actual
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/tests/test_setuptools.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/tests/test_setuptools.py
new file mode 100644
index 0000000000000000000000000000000000000000..1d56e1a8a4ebc5c7aaeb9902ef9972f7de97ecbf
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/tests/test_setuptools.py
@@ -0,0 +1,290 @@
+"""Tests for the 'setuptools' package"""
+
+import os
+import re
+import sys
+from zipfile import ZipFile
+
+import pytest
+from packaging.version import Version
+
+import setuptools
+import setuptools.depends as dep
+import setuptools.dist
+from setuptools.depends import Require
+
+import distutils.cmd
+import distutils.core
+from distutils.core import Extension
+from distutils.errors import DistutilsSetupError
+
+
+@pytest.fixture(autouse=True)
+def isolated_dir(tmpdir_cwd):
+    return
+
+
+def makeSetup(**args):
+    """Return distribution from 'setup(**args)', without executing commands"""
+
+    distutils.core._setup_stop_after = "commandline"
+
+    # Don't let system command line leak into tests!
+    args.setdefault('script_args', ['install'])
+
+    try:
+        return setuptools.setup(**args)
+    finally:
+        distutils.core._setup_stop_after = None
+
+
+needs_bytecode = pytest.mark.skipif(
+    not hasattr(dep, 'get_module_constant'),
+    reason="bytecode support not available",
+)
+
+
+class TestDepends:
+    def testExtractConst(self):
+        if not hasattr(dep, 'extract_constant'):
+            # skip on non-bytecode platforms
+            return
+
+        def f1():
+            global x, y, z
+            x = "test"
+            y = z  # pyright: ignore[reportUnboundVariable] # Explicitly testing for this runtime issue
+
+        fc = f1.__code__
+
+        # unrecognized name
+        assert dep.extract_constant(fc, 'q', -1) is None
+
+        # constant assigned
+        assert dep.extract_constant(fc, 'x', -1) == "test"
+
+        # expression assigned
+        assert dep.extract_constant(fc, 'y', -1) == -1
+
+        # recognized name, not assigned
+        assert dep.extract_constant(fc, 'z', -1) is None
+
+    def testFindModule(self):
+        with pytest.raises(ImportError):
+            dep.find_module('no-such.-thing')
+        with pytest.raises(ImportError):
+            dep.find_module('setuptools.non-existent')
+        f, _p, _i = dep.find_module('setuptools.tests')
+        f.close()
+
+    @needs_bytecode
+    def testModuleExtract(self):
+        from json import __version__
+
+        assert dep.get_module_constant('json', '__version__') == __version__
+        assert dep.get_module_constant('sys', 'version') == sys.version
+        assert (
+            dep.get_module_constant('setuptools.tests.test_setuptools', '__doc__')
+            == __doc__
+        )
+
+    @needs_bytecode
+    def testRequire(self):
+        req = Require('Json', '1.0.3', 'json')
+
+        assert req.name == 'Json'
+        assert req.module == 'json'
+        assert req.requested_version == Version('1.0.3')
+        assert req.attribute == '__version__'
+        assert req.full_name() == 'Json-1.0.3'
+
+        from json import __version__
+
+        assert str(req.get_version()) == __version__
+        assert req.version_ok('1.0.9')
+        assert not req.version_ok('0.9.1')
+        assert not req.version_ok('unknown')
+
+        assert req.is_present()
+        assert req.is_current()
+
+        req = Require('Do-what-I-mean', '1.0', 'd-w-i-m')
+        assert not req.is_present()
+        assert not req.is_current()
+
+    @needs_bytecode
+    def test_require_present(self):
+        # In #1896, this test was failing for months with the only
+        # complaint coming from test runners (not end users).
+        # TODO: Evaluate if this code is needed at all.
+        req = Require('Tests', None, 'tests', homepage="http://example.com")
+        assert req.format is None
+        assert req.attribute is None
+        assert req.requested_version is None
+        assert req.full_name() == 'Tests'
+        assert req.homepage == 'http://example.com'
+
+        from setuptools.tests import __path__
+
+        paths = [os.path.dirname(p) for p in __path__]
+        assert req.is_present(paths)
+        assert req.is_current(paths)
+
+
+class TestDistro:
+    def setup_method(self, method):
+        self.e1 = Extension('bar.ext', ['bar.c'])
+        self.e2 = Extension('c.y', ['y.c'])
+
+        self.dist = makeSetup(
+            packages=['a', 'a.b', 'a.b.c', 'b', 'c'],
+            py_modules=['b.d', 'x'],
+            ext_modules=(self.e1, self.e2),
+            package_dir={},
+        )
+
+    def testDistroType(self):
+        assert isinstance(self.dist, setuptools.dist.Distribution)
+
+    def testExcludePackage(self):
+        self.dist.exclude_package('a')
+        assert self.dist.packages == ['b', 'c']
+
+        self.dist.exclude_package('b')
+        assert self.dist.packages == ['c']
+        assert self.dist.py_modules == ['x']
+        assert self.dist.ext_modules == [self.e1, self.e2]
+
+        self.dist.exclude_package('c')
+        assert self.dist.packages == []
+        assert self.dist.py_modules == ['x']
+        assert self.dist.ext_modules == [self.e1]
+
+        # test removals from unspecified options
+        makeSetup().exclude_package('x')
+
+    def testIncludeExclude(self):
+        # remove an extension
+        self.dist.exclude(ext_modules=[self.e1])
+        assert self.dist.ext_modules == [self.e2]
+
+        # add it back in
+        self.dist.include(ext_modules=[self.e1])
+        assert self.dist.ext_modules == [self.e2, self.e1]
+
+        # should not add duplicate
+        self.dist.include(ext_modules=[self.e1])
+        assert self.dist.ext_modules == [self.e2, self.e1]
+
+    def testExcludePackages(self):
+        self.dist.exclude(packages=['c', 'b', 'a'])
+        assert self.dist.packages == []
+        assert self.dist.py_modules == ['x']
+        assert self.dist.ext_modules == [self.e1]
+
+    def testEmpty(self):
+        dist = makeSetup()
+        dist.include(packages=['a'], py_modules=['b'], ext_modules=[self.e2])
+        dist = makeSetup()
+        dist.exclude(packages=['a'], py_modules=['b'], ext_modules=[self.e2])
+
+    def testContents(self):
+        assert self.dist.has_contents_for('a')
+        self.dist.exclude_package('a')
+        assert not self.dist.has_contents_for('a')
+
+        assert self.dist.has_contents_for('b')
+        self.dist.exclude_package('b')
+        assert not self.dist.has_contents_for('b')
+
+        assert self.dist.has_contents_for('c')
+        self.dist.exclude_package('c')
+        assert not self.dist.has_contents_for('c')
+
+    def testInvalidIncludeExclude(self):
+        with pytest.raises(DistutilsSetupError):
+            self.dist.include(nonexistent_option='x')
+        with pytest.raises(DistutilsSetupError):
+            self.dist.exclude(nonexistent_option='x')
+        with pytest.raises(DistutilsSetupError):
+            self.dist.include(packages={'x': 'y'})
+        with pytest.raises(DistutilsSetupError):
+            self.dist.exclude(packages={'x': 'y'})
+        with pytest.raises(DistutilsSetupError):
+            self.dist.include(ext_modules={'x': 'y'})
+        with pytest.raises(DistutilsSetupError):
+            self.dist.exclude(ext_modules={'x': 'y'})
+
+        with pytest.raises(DistutilsSetupError):
+            self.dist.include(package_dir=['q'])
+        with pytest.raises(DistutilsSetupError):
+            self.dist.exclude(package_dir=['q'])
+
+
+@pytest.fixture
+def example_source(tmpdir):
+    tmpdir.mkdir('foo')
+    (tmpdir / 'foo/bar.py').write('')
+    (tmpdir / 'readme.txt').write('')
+    return tmpdir
+
+
+def test_findall(example_source):
+    found = list(setuptools.findall(str(example_source)))
+    expected = ['readme.txt', 'foo/bar.py']
+    expected = [example_source.join(fn) for fn in expected]
+    assert found == expected
+
+
+def test_findall_curdir(example_source):
+    with example_source.as_cwd():
+        found = list(setuptools.findall())
+    expected = ['readme.txt', os.path.join('foo', 'bar.py')]
+    assert found == expected
+
+
+@pytest.fixture
+def can_symlink(tmpdir):
+    """
+    Skip if cannot create a symbolic link
+    """
+    link_fn = 'link'
+    target_fn = 'target'
+    try:
+        os.symlink(target_fn, link_fn)
+    except (OSError, NotImplementedError, AttributeError):
+        pytest.skip("Cannot create symbolic links")
+    os.remove(link_fn)
+
+
+@pytest.mark.usefixtures("can_symlink")
+def test_findall_missing_symlink(tmpdir):
+    with tmpdir.as_cwd():
+        os.symlink('foo', 'bar')
+        found = list(setuptools.findall())
+        assert found == []
+
+
+@pytest.mark.xfail(reason="unable to exclude tests; #4475 #3260")
+def test_its_own_wheel_does_not_contain_tests(setuptools_wheel):
+    with ZipFile(setuptools_wheel) as zipfile:
+        contents = [f.replace(os.sep, '/') for f in zipfile.namelist()]
+
+    for member in contents:
+        assert '/tests/' not in member
+
+
+def test_wheel_includes_cli_scripts(setuptools_wheel):
+    with ZipFile(setuptools_wheel) as zipfile:
+        contents = [f.replace(os.sep, '/') for f in zipfile.namelist()]
+
+    assert any('cli-64.exe' in member for member in contents)
+
+
+def test_wheel_includes_vendored_metadata(setuptools_wheel):
+    with ZipFile(setuptools_wheel) as zipfile:
+        contents = [f.replace(os.sep, '/') for f in zipfile.namelist()]
+
+    assert any(
+        re.search(r'_vendor/.*\.dist-info/METADATA', member) for member in contents
+    )
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/tests/test_shutil_wrapper.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/tests/test_shutil_wrapper.py
new file mode 100644
index 0000000000000000000000000000000000000000..74ff7e9a896328a3d57ca3639658e3b9d538585f
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/tests/test_shutil_wrapper.py
@@ -0,0 +1,23 @@
+import stat
+import sys
+from unittest.mock import Mock
+
+from setuptools import _shutil
+
+
+def test_rmtree_readonly(monkeypatch, tmp_path):
+    """Verify onerr works as expected"""
+
+    tmp_dir = tmp_path / "with_readonly"
+    tmp_dir.mkdir()
+    some_file = tmp_dir.joinpath("file.txt")
+    some_file.touch()
+    some_file.chmod(stat.S_IREAD)
+
+    expected_count = 1 if sys.platform.startswith("win") else 0
+    chmod_fn = Mock(wraps=_shutil.attempt_chmod_verbose)
+    monkeypatch.setattr(_shutil, "attempt_chmod_verbose", chmod_fn)
+
+    _shutil.rmtree(tmp_dir)
+    assert chmod_fn.call_count == expected_count
+    assert not tmp_dir.is_dir()
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/tests/test_unicode_utils.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/tests/test_unicode_utils.py
new file mode 100644
index 0000000000000000000000000000000000000000..a24a9bd5305d1de7c1c925466bb7d222c85864a7
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/tests/test_unicode_utils.py
@@ -0,0 +1,10 @@
+from setuptools import unicode_utils
+
+
+def test_filesys_decode_fs_encoding_is_None(monkeypatch):
+    """
+    Test filesys_decode does not raise TypeError when
+    getfilesystemencoding returns None.
+    """
+    monkeypatch.setattr('sys.getfilesystemencoding', lambda: None)
+    unicode_utils.filesys_decode(b'test')
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/tests/test_virtualenv.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/tests/test_virtualenv.py
new file mode 100644
index 0000000000000000000000000000000000000000..b02949baf9cef8eb4df9c697add28f79a93b64d4
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/tests/test_virtualenv.py
@@ -0,0 +1,113 @@
+import os
+import subprocess
+import sys
+from urllib.error import URLError
+from urllib.request import urlopen
+
+import pytest
+
+
+@pytest.fixture(autouse=True)
+def pytest_virtualenv_works(venv):
+    """
+    pytest_virtualenv may not work. if it doesn't, skip these
+    tests. See #1284.
+    """
+    venv_prefix = venv.run(["python", "-c", "import sys; print(sys.prefix)"]).strip()
+    if venv_prefix == sys.prefix:
+        pytest.skip("virtualenv is broken (see pypa/setuptools#1284)")
+
+
+def test_clean_env_install(venv_without_setuptools, setuptools_wheel):
+    """
+    Check setuptools can be installed in a clean environment.
+    """
+    cmd = ["python", "-m", "pip", "install", str(setuptools_wheel)]
+    venv_without_setuptools.run(cmd)
+
+
+def access_pypi():
+    # Detect if tests are being run without connectivity
+    if not os.environ.get('NETWORK_REQUIRED', False):  # pragma: nocover
+        try:
+            urlopen('https://pypi.org', timeout=1)
+        except URLError:
+            # No network, disable most of these tests
+            return False
+
+    return True
+
+
+@pytest.mark.skipif(
+    'platform.python_implementation() == "PyPy"',
+    reason="https://github.com/pypa/setuptools/pull/2865#issuecomment-965834995",
+)
+@pytest.mark.skipif(not access_pypi(), reason="no network")
+# ^-- Even when it is not necessary to install a different version of `pip`
+#     the build process will still try to download `wheel`, see #3147 and #2986.
+@pytest.mark.parametrize(
+    'pip_version',
+    [
+        None,
+        pytest.param(
+            'pip<20.1',
+            marks=pytest.mark.xfail(
+                'sys.version_info >= (3, 12)',
+                reason="pip 23.1.2 required for Python 3.12 and later",
+            ),
+        ),
+        pytest.param(
+            'pip<21',
+            marks=pytest.mark.xfail(
+                'sys.version_info >= (3, 12)',
+                reason="pip 23.1.2 required for Python 3.12 and later",
+            ),
+        ),
+        pytest.param(
+            'pip<22',
+            marks=pytest.mark.xfail(
+                'sys.version_info >= (3, 12)',
+                reason="pip 23.1.2 required for Python 3.12 and later",
+            ),
+        ),
+        pytest.param(
+            'pip<23',
+            marks=pytest.mark.xfail(
+                'sys.version_info >= (3, 12)',
+                reason="pip 23.1.2 required for Python 3.12 and later",
+            ),
+        ),
+        pytest.param(
+            'https://github.com/pypa/pip/archive/main.zip',
+            marks=pytest.mark.xfail(reason='#2975'),
+        ),
+    ],
+)
+def test_pip_upgrade_from_source(
+    pip_version, venv_without_setuptools, setuptools_wheel, setuptools_sdist
+):
+    """
+    Check pip can upgrade setuptools from source.
+    """
+    # Install pip/wheel, in a venv without setuptools (as it
+    # should not be needed for bootstrapping from source)
+    venv = venv_without_setuptools
+    venv.run(["pip", "install", "-U", "wheel"])
+    if pip_version is not None:
+        venv.run(["python", "-m", "pip", "install", "-U", pip_version, "--retries=1"])
+    with pytest.raises(subprocess.CalledProcessError):
+        # Meta-test to make sure setuptools is not installed
+        venv.run(["python", "-c", "import setuptools"])
+
+    # Then install from wheel.
+    venv.run(["pip", "install", str(setuptools_wheel)])
+    # And finally try to upgrade from source.
+    venv.run(["pip", "install", "--no-cache-dir", "--upgrade", str(setuptools_sdist)])
+
+
+def test_no_missing_dependencies(bare_venv, request):
+    """
+    Quick and dirty test to ensure all external dependencies are vendored.
+    """
+    setuptools_dir = request.config.rootdir
+    bare_venv.run(['python', 'setup.py', '--help'], cwd=setuptools_dir)
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/tests/test_warnings.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/tests/test_warnings.py
new file mode 100644
index 0000000000000000000000000000000000000000..41193d4f717344546f8c70ad18b268a04740129b
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/tests/test_warnings.py
@@ -0,0 +1,106 @@
+from inspect import cleandoc
+
+import pytest
+
+from setuptools.warnings import SetuptoolsDeprecationWarning, SetuptoolsWarning
+
+_EXAMPLES = {
+    "default": dict(
+        args=("Hello {x}", "\n\t{target} {v:.1f}"),
+        kwargs={"x": 5, "v": 3, "target": "World"},
+        expected="""
+    Hello 5
+    !!
+
+            ********************************************************************************
+            World 3.0
+            ********************************************************************************
+
+    !!
+    """,
+    ),
+    "futue_due_date": dict(
+        args=("Summary", "Lorem ipsum"),
+        kwargs={"due_date": (9999, 11, 22)},
+        expected="""
+    Summary
+    !!
+
+            ********************************************************************************
+            Lorem ipsum
+
+            By 9999-Nov-22, you need to update your project and remove deprecated calls
+            or your builds will no longer be supported.
+            ********************************************************************************
+
+    !!
+    """,
+    ),
+    "past_due_date_with_docs": dict(
+        args=("Summary", "Lorem ipsum"),
+        kwargs={"due_date": (2000, 11, 22), "see_docs": "some_page.html"},
+        expected="""
+    Summary
+    !!
+
+            ********************************************************************************
+            Lorem ipsum
+
+            This deprecation is overdue, please update your project and remove deprecated
+            calls to avoid build errors in the future.
+
+            See https://setuptools.pypa.io/en/latest/some_page.html for details.
+            ********************************************************************************
+
+    !!
+    """,
+    ),
+}
+
+
+@pytest.mark.parametrize("example_name", _EXAMPLES.keys())
+def test_formatting(monkeypatch, example_name):
+    """
+    It should automatically handle indentation, interpolation and things like due date.
+    """
+    args = _EXAMPLES[example_name]["args"]
+    kwargs = _EXAMPLES[example_name]["kwargs"]
+    expected = _EXAMPLES[example_name]["expected"]
+
+    monkeypatch.setenv("SETUPTOOLS_ENFORCE_DEPRECATION", "false")
+    with pytest.warns(SetuptoolsWarning) as warn_info:
+        SetuptoolsWarning.emit(*args, **kwargs)
+    assert _get_message(warn_info) == cleandoc(expected)
+
+
+def test_due_date_enforcement(monkeypatch):
+    class _MyDeprecation(SetuptoolsDeprecationWarning):
+        _SUMMARY = "Summary"
+        _DETAILS = "Lorem ipsum"
+        _DUE_DATE = (2000, 11, 22)
+        _SEE_DOCS = "some_page.html"
+
+    monkeypatch.setenv("SETUPTOOLS_ENFORCE_DEPRECATION", "true")
+    with pytest.raises(SetuptoolsDeprecationWarning) as exc_info:
+        _MyDeprecation.emit()
+
+    expected = """
+    Summary
+    !!
+
+            ********************************************************************************
+            Lorem ipsum
+
+            This deprecation is overdue, please update your project and remove deprecated
+            calls to avoid build errors in the future.
+
+            See https://setuptools.pypa.io/en/latest/some_page.html for details.
+            ********************************************************************************
+
+    !!
+    """
+    assert str(exc_info.value) == cleandoc(expected)
+
+
+def _get_message(warn_info):
+    return next(warn.message.args[0] for warn in warn_info)
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/tests/test_wheel.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/tests/test_wheel.py
new file mode 100644
index 0000000000000000000000000000000000000000..70165c608b60bc70a908a8b56e1f1105feeb4712
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/tests/test_wheel.py
@@ -0,0 +1,714 @@
+"""wheel tests"""
+
+from __future__ import annotations
+
+import contextlib
+import glob
+import inspect
+import os
+import pathlib
+import shutil
+import stat
+import subprocess
+import sys
+import zipfile
+from typing import Any
+
+import pytest
+from jaraco import path
+from packaging.tags import parse_tag
+from packaging.utils import canonicalize_name
+
+from pkg_resources import PY_MAJOR, Distribution, PathMetadata
+from setuptools.wheel import Wheel
+
+from .contexts import tempdir
+from .textwrap import DALS
+
+from distutils.sysconfig import get_config_var
+from distutils.util import get_platform
+
+WHEEL_INFO_TESTS = (
+    ('invalid.whl', ValueError),
+    (
+        'simplewheel-2.0-1-py2.py3-none-any.whl',
+        {
+            'project_name': 'simplewheel',
+            'version': '2.0',
+            'build': '1',
+            'py_version': 'py2.py3',
+            'abi': 'none',
+            'platform': 'any',
+        },
+    ),
+    (
+        'simple.dist-0.1-py2.py3-none-any.whl',
+        {
+            'project_name': 'simple.dist',
+            'version': '0.1',
+            'build': None,
+            'py_version': 'py2.py3',
+            'abi': 'none',
+            'platform': 'any',
+        },
+    ),
+    (
+        'example_pkg_a-1-py3-none-any.whl',
+        {
+            'project_name': 'example_pkg_a',
+            'version': '1',
+            'build': None,
+            'py_version': 'py3',
+            'abi': 'none',
+            'platform': 'any',
+        },
+    ),
+    (
+        'PyQt5-5.9-5.9.1-cp35.cp36.cp37-abi3-manylinux1_x86_64.whl',
+        {
+            'project_name': 'PyQt5',
+            'version': '5.9',
+            'build': '5.9.1',
+            'py_version': 'cp35.cp36.cp37',
+            'abi': 'abi3',
+            'platform': 'manylinux1_x86_64',
+        },
+    ),
+)
+
+
+@pytest.mark.parametrize(
+    ('filename', 'info'), WHEEL_INFO_TESTS, ids=[t[0] for t in WHEEL_INFO_TESTS]
+)
+def test_wheel_info(filename, info):
+    if inspect.isclass(info):
+        with pytest.raises(info):
+            Wheel(filename)
+        return
+    w = Wheel(filename)
+    assert {k: getattr(w, k) for k in info.keys()} == info
+
+
+@contextlib.contextmanager
+def build_wheel(extra_file_defs=None, **kwargs):
+    file_defs = {
+        'setup.py': (
+            DALS(
+                """
+            # -*- coding: utf-8 -*-
+            from setuptools import setup
+            import setuptools
+            setup(**%r)
+            """
+            )
+            % kwargs
+        ).encode('utf-8'),
+    }
+    if extra_file_defs:
+        file_defs.update(extra_file_defs)
+    with tempdir() as source_dir:
+        path.build(file_defs, source_dir)
+        subprocess.check_call(
+            (sys.executable, 'setup.py', '-q', 'bdist_wheel'), cwd=source_dir
+        )
+        yield glob.glob(os.path.join(source_dir, 'dist', '*.whl'))[0]
+
+
+def tree_set(root):
+    contents = set()
+    for dirpath, dirnames, filenames in os.walk(root):
+        for filename in filenames:
+            contents.add(os.path.join(os.path.relpath(dirpath, root), filename))
+    return contents
+
+
+def flatten_tree(tree):
+    """Flatten nested dicts and lists into a full list of paths"""
+    output = set()
+    for node, contents in tree.items():
+        if isinstance(contents, dict):
+            contents = flatten_tree(contents)
+
+        for elem in contents:
+            if isinstance(elem, dict):
+                output |= {os.path.join(node, val) for val in flatten_tree(elem)}
+            else:
+                output.add(os.path.join(node, elem))
+    return output
+
+
+def format_install_tree(tree):
+    return {
+        x.format(
+            py_version=PY_MAJOR,
+            platform=get_platform(),
+            shlib_ext=get_config_var('EXT_SUFFIX') or get_config_var('SO'),
+        )
+        for x in tree
+    }
+
+
+def _check_wheel_install(
+    filename, install_dir, install_tree_includes, project_name, version, requires_txt
+):
+    w = Wheel(filename)
+    egg_path = os.path.join(install_dir, w.egg_name())
+    w.install_as_egg(egg_path)
+    if install_tree_includes is not None:
+        install_tree = format_install_tree(install_tree_includes)
+        exp = tree_set(install_dir)
+        assert install_tree.issubset(exp), install_tree - exp
+
+    metadata = PathMetadata(egg_path, os.path.join(egg_path, 'EGG-INFO'))
+    dist = Distribution.from_filename(egg_path, metadata=metadata)
+    assert dist.project_name == project_name
+    assert dist.version == version
+    if requires_txt is None:
+        assert not dist.has_metadata('requires.txt')
+    else:
+        # Order must match to ensure reproducibility.
+        assert requires_txt == dist.get_metadata('requires.txt').lstrip()
+
+
+class Record:
+    def __init__(self, id, **kwargs):
+        self._id = id
+        self._fields = kwargs
+
+    def __repr__(self) -> str:
+        return f'{self._id}(**{self._fields!r})'
+
+
+# Using Any to avoid possible type union issues later in test
+# making a TypedDict is not worth in a test and anonymous/inline TypedDict are experimental
+# https://github.com/python/mypy/issues/9884
+WHEEL_INSTALL_TESTS: tuple[dict[str, Any], ...] = (
+    dict(
+        id='basic',
+        file_defs={'foo': {'__init__.py': ''}},
+        setup_kwargs=dict(
+            packages=['foo'],
+        ),
+        install_tree=flatten_tree({
+            'foo-1.0-py{py_version}.egg': {
+                'EGG-INFO': ['PKG-INFO', 'RECORD', 'WHEEL', 'top_level.txt'],
+                'foo': ['__init__.py'],
+            }
+        }),
+    ),
+    dict(
+        id='utf-8',
+        setup_kwargs=dict(
+            description='Description accentuée',
+        ),
+    ),
+    dict(
+        id='data',
+        file_defs={
+            'data.txt': DALS(
+                """
+                Some data...
+                """
+            ),
+        },
+        setup_kwargs=dict(
+            data_files=[('data_dir', ['data.txt'])],
+        ),
+        install_tree=flatten_tree({
+            'foo-1.0-py{py_version}.egg': {
+                'EGG-INFO': ['PKG-INFO', 'RECORD', 'WHEEL', 'top_level.txt'],
+                'data_dir': ['data.txt'],
+            }
+        }),
+    ),
+    dict(
+        id='extension',
+        file_defs={
+            'extension.c': DALS(
+                """
+                #include "Python.h"
+
+                #if PY_MAJOR_VERSION >= 3
+
+                static struct PyModuleDef moduledef = {
+                        PyModuleDef_HEAD_INIT,
+                        "extension",
+                        NULL,
+                        0,
+                        NULL,
+                        NULL,
+                        NULL,
+                        NULL,
+                        NULL
+                };
+
+                #define INITERROR return NULL
+
+                PyMODINIT_FUNC PyInit_extension(void)
+
+                #else
+
+                #define INITERROR return
+
+                void initextension(void)
+
+                #endif
+                {
+                #if PY_MAJOR_VERSION >= 3
+                    PyObject *module = PyModule_Create(&moduledef);
+                #else
+                    PyObject *module = Py_InitModule("extension", NULL);
+                #endif
+                    if (module == NULL)
+                        INITERROR;
+                #if PY_MAJOR_VERSION >= 3
+                    return module;
+                #endif
+                }
+                """
+            ),
+        },
+        setup_kwargs=dict(
+            ext_modules=[
+                Record(
+                    'setuptools.Extension', name='extension', sources=['extension.c']
+                )
+            ],
+        ),
+        install_tree=flatten_tree({
+            'foo-1.0-py{py_version}-{platform}.egg': [
+                'extension{shlib_ext}',
+                {
+                    'EGG-INFO': [
+                        'PKG-INFO',
+                        'RECORD',
+                        'WHEEL',
+                        'top_level.txt',
+                    ]
+                },
+            ]
+        }),
+    ),
+    dict(
+        id='header',
+        file_defs={
+            'header.h': DALS(
+                """
+                """
+            ),
+        },
+        setup_kwargs=dict(
+            headers=['header.h'],
+        ),
+        install_tree=flatten_tree({
+            'foo-1.0-py{py_version}.egg': [
+                'header.h',
+                {
+                    'EGG-INFO': [
+                        'PKG-INFO',
+                        'RECORD',
+                        'WHEEL',
+                        'top_level.txt',
+                    ]
+                },
+            ]
+        }),
+    ),
+    dict(
+        id='script',
+        file_defs={
+            'script.py': DALS(
+                """
+                #/usr/bin/python
+                print('hello world!')
+                """
+            ),
+            'script.sh': DALS(
+                """
+                #/bin/sh
+                echo 'hello world!'
+                """
+            ),
+        },
+        setup_kwargs=dict(
+            scripts=['script.py', 'script.sh'],
+        ),
+        install_tree=flatten_tree({
+            'foo-1.0-py{py_version}.egg': {
+                'EGG-INFO': [
+                    'PKG-INFO',
+                    'RECORD',
+                    'WHEEL',
+                    'top_level.txt',
+                    {'scripts': ['script.py', 'script.sh']},
+                ]
+            }
+        }),
+    ),
+    dict(
+        id='requires1',
+        install_requires='foobar==2.0',
+        install_tree=flatten_tree({
+            'foo-1.0-py{py_version}.egg': {
+                'EGG-INFO': [
+                    'PKG-INFO',
+                    'RECORD',
+                    'WHEEL',
+                    'requires.txt',
+                    'top_level.txt',
+                ]
+            }
+        }),
+        requires_txt=DALS(
+            """
+            foobar==2.0
+            """
+        ),
+    ),
+    dict(
+        id='requires2',
+        install_requires=f"""
+        bar
+        foo<=2.0; {sys.platform!r} in sys_platform
+        """,
+        requires_txt=DALS(
+            """
+            bar
+            foo<=2.0
+            """
+        ),
+    ),
+    dict(
+        id='requires3',
+        install_requires=f"""
+        bar; {sys.platform!r} != sys_platform
+        """,
+    ),
+    dict(
+        id='requires4',
+        install_requires="""
+        foo
+        """,
+        extras_require={
+            'extra': 'foobar>3',
+        },
+        requires_txt=DALS(
+            """
+            foo
+
+            [extra]
+            foobar>3
+            """
+        ),
+    ),
+    dict(
+        id='requires5',
+        extras_require={
+            'extra': f'foobar; {sys.platform!r} != sys_platform',
+        },
+        requires_txt=DALS(
+            """
+            [extra]
+            """
+        ),
+    ),
+    dict(
+        id='requires_ensure_order',
+        install_requires="""
+        foo
+        bar
+        baz
+        qux
+        """,
+        extras_require={
+            'extra': """
+            foobar>3
+            barbaz>4
+            bazqux>5
+            quxzap>6
+            """,
+        },
+        requires_txt=DALS(
+            """
+            foo
+            bar
+            baz
+            qux
+
+            [extra]
+            foobar>3
+            barbaz>4
+            bazqux>5
+            quxzap>6
+            """
+        ),
+    ),
+    dict(
+        id='namespace_package',
+        file_defs={
+            'foo': {
+                'bar': {'__init__.py': ''},
+            },
+        },
+        setup_kwargs=dict(
+            namespace_packages=['foo'],
+            packages=['foo.bar'],
+        ),
+        install_tree=flatten_tree({
+            'foo-1.0-py{py_version}.egg': [
+                'foo-1.0-py{py_version}-nspkg.pth',
+                {
+                    'EGG-INFO': [
+                        'PKG-INFO',
+                        'RECORD',
+                        'WHEEL',
+                        'namespace_packages.txt',
+                        'top_level.txt',
+                    ]
+                },
+                {
+                    'foo': [
+                        '__init__.py',
+                        {'bar': ['__init__.py']},
+                    ]
+                },
+            ]
+        }),
+    ),
+    dict(
+        id='empty_namespace_package',
+        file_defs={
+            'foobar': {
+                '__init__.py': (
+                    "__import__('pkg_resources').declare_namespace(__name__)"
+                )
+            },
+        },
+        setup_kwargs=dict(
+            namespace_packages=['foobar'],
+            packages=['foobar'],
+        ),
+        install_tree=flatten_tree({
+            'foo-1.0-py{py_version}.egg': [
+                'foo-1.0-py{py_version}-nspkg.pth',
+                {
+                    'EGG-INFO': [
+                        'PKG-INFO',
+                        'RECORD',
+                        'WHEEL',
+                        'namespace_packages.txt',
+                        'top_level.txt',
+                    ]
+                },
+                {
+                    'foobar': [
+                        '__init__.py',
+                    ]
+                },
+            ]
+        }),
+    ),
+    dict(
+        id='data_in_package',
+        file_defs={
+            'foo': {
+                '__init__.py': '',
+                'data_dir': {
+                    'data.txt': DALS(
+                        """
+                        Some data...
+                        """
+                    ),
+                },
+            }
+        },
+        setup_kwargs=dict(
+            packages=['foo'],
+            data_files=[('foo/data_dir', ['foo/data_dir/data.txt'])],
+        ),
+        install_tree=flatten_tree({
+            'foo-1.0-py{py_version}.egg': {
+                'EGG-INFO': [
+                    'PKG-INFO',
+                    'RECORD',
+                    'WHEEL',
+                    'top_level.txt',
+                ],
+                'foo': [
+                    '__init__.py',
+                    {
+                        'data_dir': [
+                            'data.txt',
+                        ]
+                    },
+                ],
+            }
+        }),
+    ),
+)
+
+
+@pytest.mark.parametrize(
+    'params',
+    WHEEL_INSTALL_TESTS,
+    ids=[params['id'] for params in WHEEL_INSTALL_TESTS],
+)
+def test_wheel_install(params):
+    project_name = params.get('name', 'foo')
+    version = params.get('version', '1.0')
+    install_requires = params.get('install_requires', [])
+    extras_require = params.get('extras_require', {})
+    requires_txt = params.get('requires_txt', None)
+    install_tree = params.get('install_tree')
+    file_defs = params.get('file_defs', {})
+    setup_kwargs = params.get('setup_kwargs', {})
+    with (
+        build_wheel(
+            name=project_name,
+            version=version,
+            install_requires=install_requires,
+            extras_require=extras_require,
+            extra_file_defs=file_defs,
+            **setup_kwargs,
+        ) as filename,
+        tempdir() as install_dir,
+    ):
+        _check_wheel_install(
+            filename, install_dir, install_tree, project_name, version, requires_txt
+        )
+
+
+def test_wheel_install_pep_503():
+    project_name = 'Foo_Bar'  # PEP 503 canonicalized name is "foo-bar"
+    version = '1.0'
+    with (
+        build_wheel(
+            name=project_name,
+            version=version,
+        ) as filename,
+        tempdir() as install_dir,
+    ):
+        new_filename = filename.replace(project_name, canonicalize_name(project_name))
+        shutil.move(filename, new_filename)
+        _check_wheel_install(
+            new_filename,
+            install_dir,
+            None,
+            canonicalize_name(project_name),
+            version,
+            None,
+        )
+
+
+def test_wheel_no_dist_dir():
+    project_name = 'nodistinfo'
+    version = '1.0'
+    wheel_name = f'{project_name}-{version}-py2.py3-none-any.whl'
+    with tempdir() as source_dir:
+        wheel_path = os.path.join(source_dir, wheel_name)
+        # create an empty zip file
+        zipfile.ZipFile(wheel_path, 'w').close()
+        with tempdir() as install_dir:
+            with pytest.raises(ValueError):
+                _check_wheel_install(
+                    wheel_path, install_dir, None, project_name, version, None
+                )
+
+
+def test_wheel_is_compatible(monkeypatch):
+    def sys_tags():
+        return {
+            (t.interpreter, t.abi, t.platform)
+            for t in parse_tag('cp36-cp36m-manylinux1_x86_64')
+        }
+
+    monkeypatch.setattr('setuptools.wheel._get_supported_tags', sys_tags)
+    assert Wheel('onnxruntime-0.1.2-cp36-cp36m-manylinux1_x86_64.whl').is_compatible()
+
+
+def test_wheel_mode():
+    @contextlib.contextmanager
+    def build_wheel(extra_file_defs=None, **kwargs):
+        file_defs = {
+            'setup.py': (
+                DALS(
+                    """
+                # -*- coding: utf-8 -*-
+                from setuptools import setup
+                import setuptools
+                setup(**%r)
+                """
+                )
+                % kwargs
+            ).encode('utf-8'),
+        }
+        if extra_file_defs:
+            file_defs.update(extra_file_defs)
+        with tempdir() as source_dir:
+            path.build(file_defs, source_dir)
+            runsh = pathlib.Path(source_dir) / "script.sh"
+            os.chmod(runsh, 0o777)
+            subprocess.check_call(
+                (sys.executable, 'setup.py', '-q', 'bdist_wheel'), cwd=source_dir
+            )
+            yield glob.glob(os.path.join(source_dir, 'dist', '*.whl'))[0]
+
+    params = dict(
+        id='script',
+        file_defs={
+            'script.py': DALS(
+                """
+                #/usr/bin/python
+                print('hello world!')
+                """
+            ),
+            'script.sh': DALS(
+                """
+                #/bin/sh
+                echo 'hello world!'
+                """
+            ),
+        },
+        setup_kwargs=dict(
+            scripts=['script.py', 'script.sh'],
+        ),
+        install_tree=flatten_tree({
+            'foo-1.0-py{py_version}.egg': {
+                'EGG-INFO': [
+                    'PKG-INFO',
+                    'RECORD',
+                    'WHEEL',
+                    'top_level.txt',
+                    {'scripts': ['script.py', 'script.sh']},
+                ]
+            }
+        }),
+    )
+
+    project_name = params.get('name', 'foo')
+    version = params.get('version', '1.0')
+    install_tree = params.get('install_tree')
+    file_defs = params.get('file_defs', {})
+    setup_kwargs = params.get('setup_kwargs', {})
+
+    with (
+        build_wheel(
+            name=project_name,
+            version=version,
+            install_requires=[],
+            extras_require={},
+            extra_file_defs=file_defs,
+            **setup_kwargs,
+        ) as filename,
+        tempdir() as install_dir,
+    ):
+        _check_wheel_install(
+            filename, install_dir, install_tree, project_name, version, None
+        )
+        w = Wheel(filename)
+        base = pathlib.Path(install_dir) / w.egg_name()
+        script_sh = base / "EGG-INFO" / "scripts" / "script.sh"
+        assert script_sh.exists()
+        if sys.platform != 'win32':
+            # Editable file mode has no effect on Windows
+            assert oct(stat.S_IMODE(script_sh.stat().st_mode)) == "0o777"
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/tests/test_windows_wrappers.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/tests/test_windows_wrappers.py
new file mode 100644
index 0000000000000000000000000000000000000000..f895485387f2f9f673f96f7114629297a381e66c
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/tests/test_windows_wrappers.py
@@ -0,0 +1,259 @@
+"""
+Python Script Wrapper for Windows
+=================================
+
+setuptools includes wrappers for Python scripts that allows them to be
+executed like regular windows programs.  There are 2 wrappers, one
+for command-line programs, cli.exe, and one for graphical programs,
+gui.exe.  These programs are almost identical, function pretty much
+the same way, and are generated from the same source file.  The
+wrapper programs are used by copying them to the directory containing
+the script they are to wrap and with the same name as the script they
+are to wrap.
+"""
+
+import pathlib
+import platform
+import subprocess
+import sys
+import textwrap
+
+import pytest
+
+import pkg_resources
+from setuptools.command.easy_install import nt_quote_arg
+
+pytestmark = pytest.mark.skipif(sys.platform != 'win32', reason="Windows only")
+
+
+class WrapperTester:
+    @classmethod
+    def prep_script(cls, template):
+        python_exe = nt_quote_arg(sys.executable)
+        return template % locals()
+
+    @classmethod
+    def create_script(cls, tmpdir):
+        """
+        Create a simple script, foo-script.py
+
+        Note that the script starts with a Unix-style '#!' line saying which
+        Python executable to run.  The wrapper will use this line to find the
+        correct Python executable.
+        """
+
+        script = cls.prep_script(cls.script_tmpl)
+
+        with (tmpdir / cls.script_name).open('w') as f:
+            f.write(script)
+
+        # also copy cli.exe to the sample directory
+        with (tmpdir / cls.wrapper_name).open('wb') as f:
+            w = pkg_resources.resource_string('setuptools', cls.wrapper_source)
+            f.write(w)
+
+
+def win_launcher_exe(prefix):
+    """A simple routine to select launcher script based on platform."""
+    assert prefix in ('cli', 'gui')
+    if platform.machine() == "ARM64":
+        return f"{prefix}-arm64.exe"
+    else:
+        return f"{prefix}-32.exe"
+
+
+class TestCLI(WrapperTester):
+    script_name = 'foo-script.py'
+    wrapper_name = 'foo.exe'
+    wrapper_source = win_launcher_exe('cli')
+
+    script_tmpl = textwrap.dedent(
+        """
+        #!%(python_exe)s
+        import sys
+        input = repr(sys.stdin.read())
+        print(sys.argv[0][-14:])
+        print(sys.argv[1:])
+        print(input)
+        if __debug__:
+            print('non-optimized')
+        """
+    ).lstrip()
+
+    def test_basic(self, tmpdir):
+        """
+        When the copy of cli.exe, foo.exe in this example, runs, it examines
+        the path name it was run with and computes a Python script path name
+        by removing the '.exe' suffix and adding the '-script.py' suffix. (For
+        GUI programs, the suffix '-script.pyw' is added.)  This is why we
+        named out script the way we did.  Now we can run out script by running
+        the wrapper:
+
+        This example was a little pathological in that it exercised windows
+        (MS C runtime) quoting rules:
+
+        - Strings containing spaces are surrounded by double quotes.
+
+        - Double quotes in strings need to be escaped by preceding them with
+          back slashes.
+
+        - One or more backslashes preceding double quotes need to be escaped
+          by preceding each of them with back slashes.
+        """
+        self.create_script(tmpdir)
+        cmd = [
+            str(tmpdir / 'foo.exe'),
+            'arg1',
+            'arg 2',
+            'arg "2\\"',
+            'arg 4\\',
+            'arg5 a\\\\b',
+        ]
+        proc = subprocess.Popen(
+            cmd,
+            stdout=subprocess.PIPE,
+            stdin=subprocess.PIPE,
+            text=True,
+            encoding="utf-8",
+        )
+        stdout, _stderr = proc.communicate('hello\nworld\n')
+        actual = stdout.replace('\r\n', '\n')
+        expected = textwrap.dedent(
+            r"""
+            \foo-script.py
+            ['arg1', 'arg 2', 'arg "2\\"', 'arg 4\\', 'arg5 a\\\\b']
+            'hello\nworld\n'
+            non-optimized
+            """
+        ).lstrip()
+        assert actual == expected
+
+    def test_symlink(self, tmpdir):
+        """
+        Ensure that symlink for the foo.exe is working correctly.
+        """
+        script_dir = tmpdir / "script_dir"
+        script_dir.mkdir()
+        self.create_script(script_dir)
+        symlink = pathlib.Path(tmpdir / "foo.exe")
+        symlink.symlink_to(script_dir / "foo.exe")
+
+        cmd = [
+            str(tmpdir / 'foo.exe'),
+            'arg1',
+            'arg 2',
+            'arg "2\\"',
+            'arg 4\\',
+            'arg5 a\\\\b',
+        ]
+        proc = subprocess.Popen(
+            cmd,
+            stdout=subprocess.PIPE,
+            stdin=subprocess.PIPE,
+            text=True,
+            encoding="utf-8",
+        )
+        stdout, _stderr = proc.communicate('hello\nworld\n')
+        actual = stdout.replace('\r\n', '\n')
+        expected = textwrap.dedent(
+            r"""
+            \foo-script.py
+            ['arg1', 'arg 2', 'arg "2\\"', 'arg 4\\', 'arg5 a\\\\b']
+            'hello\nworld\n'
+            non-optimized
+            """
+        ).lstrip()
+        assert actual == expected
+
+    def test_with_options(self, tmpdir):
+        """
+        Specifying Python Command-line Options
+        --------------------------------------
+
+        You can specify a single argument on the '#!' line.  This can be used
+        to specify Python options like -O, to run in optimized mode or -i
+        to start the interactive interpreter.  You can combine multiple
+        options as usual. For example, to run in optimized mode and
+        enter the interpreter after running the script, you could use -Oi:
+        """
+        self.create_script(tmpdir)
+        tmpl = textwrap.dedent(
+            """
+            #!%(python_exe)s  -Oi
+            import sys
+            input = repr(sys.stdin.read())
+            print(sys.argv[0][-14:])
+            print(sys.argv[1:])
+            print(input)
+            if __debug__:
+                print('non-optimized')
+            sys.ps1 = '---'
+            """
+        ).lstrip()
+        with (tmpdir / 'foo-script.py').open('w') as f:
+            f.write(self.prep_script(tmpl))
+        cmd = [str(tmpdir / 'foo.exe')]
+        proc = subprocess.Popen(
+            cmd,
+            stdout=subprocess.PIPE,
+            stdin=subprocess.PIPE,
+            stderr=subprocess.STDOUT,
+            text=True,
+            encoding="utf-8",
+        )
+        stdout, _stderr = proc.communicate()
+        actual = stdout.replace('\r\n', '\n')
+        expected = textwrap.dedent(
+            r"""
+            \foo-script.py
+            []
+            ''
+            ---
+            """
+        ).lstrip()
+        assert actual == expected
+
+
+class TestGUI(WrapperTester):
+    """
+    Testing the GUI Version
+    -----------------------
+    """
+
+    script_name = 'bar-script.pyw'
+    wrapper_source = win_launcher_exe('gui')
+    wrapper_name = 'bar.exe'
+
+    script_tmpl = textwrap.dedent(
+        """
+        #!%(python_exe)s
+        import sys
+        f = open(sys.argv[1], 'wb')
+        bytes_written = f.write(repr(sys.argv[2]).encode('utf-8'))
+        f.close()
+        """
+    ).strip()
+
+    def test_basic(self, tmpdir):
+        """Test the GUI version with the simple script, bar-script.py"""
+        self.create_script(tmpdir)
+
+        cmd = [
+            str(tmpdir / 'bar.exe'),
+            str(tmpdir / 'test_output.txt'),
+            'Test Argument',
+        ]
+        proc = subprocess.Popen(
+            cmd,
+            stdout=subprocess.PIPE,
+            stdin=subprocess.PIPE,
+            stderr=subprocess.STDOUT,
+            text=True,
+            encoding="utf-8",
+        )
+        stdout, stderr = proc.communicate()
+        assert not stdout
+        assert not stderr
+        with (tmpdir / 'test_output.txt').open('rb') as f_out:
+            actual = f_out.read().decode('ascii')
+        assert actual == repr('Test Argument')
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/tests/text.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/tests/text.py
new file mode 100644
index 0000000000000000000000000000000000000000..e05cc633ede9e5ce4f74b66a7bf76327c2000caa
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/tests/text.py
@@ -0,0 +1,4 @@
+class Filenames:
+    unicode = 'smörbröd.py'
+    latin_1 = unicode.encode('latin-1')
+    utf_8 = unicode.encode('utf-8')
diff --git a/tool_server/.venv/lib/python3.12/site-packages/setuptools/tests/textwrap.py b/tool_server/.venv/lib/python3.12/site-packages/setuptools/tests/textwrap.py
new file mode 100644
index 0000000000000000000000000000000000000000..5e39618dca4ad6c3f0d4c8cb20af59ab85fb0eba
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/setuptools/tests/textwrap.py
@@ -0,0 +1,6 @@
+import textwrap
+
+
+def DALS(s):
+    "dedent and left-strip"
+    return textwrap.dedent(s).lstrip()
diff --git a/tool_server/.venv/lib/python3.12/site-packages/shellingham/__pycache__/__init__.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/shellingham/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..cb8bb5e345a0717331282c8b044c9a1d50f9d46c
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/shellingham/__pycache__/__init__.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/shellingham/__pycache__/_core.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/shellingham/__pycache__/_core.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..00e62b4bf76df3da98979f6c659d558da0ed5194
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/shellingham/__pycache__/_core.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/shellingham/__pycache__/nt.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/shellingham/__pycache__/nt.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..51bc47ee614f0398233f77bd4cd577440801cd1f
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/shellingham/__pycache__/nt.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/shellingham/posix/__init__.py b/tool_server/.venv/lib/python3.12/site-packages/shellingham/posix/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..5bd2070db27189e62a1867e4de49f16f8c8841ff
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/shellingham/posix/__init__.py
@@ -0,0 +1,112 @@
+import os
+import re
+
+from .._core import SHELL_NAMES, ShellDetectionFailure
+from . import proc, ps
+
+# Based on QEMU docs: https://www.qemu.org/docs/master/user/main.html
+QEMU_BIN_REGEX = re.compile(
+    r"""qemu-
+        (alpha
+        |armeb
+        |arm
+        |m68k
+        |cris
+        |i386
+        |x86_64
+        |microblaze
+        |mips
+        |mipsel
+        |mips64
+        |mips64el
+        |mipsn32
+        |mipsn32el
+        |nios2
+        |ppc64
+        |ppc
+        |sh4eb
+        |sh4
+        |sparc
+        |sparc32plus
+        |sparc64
+    )""",
+    re.VERBOSE,
+)
+
+
+def _iter_process_parents(pid, max_depth=10):
+    """Select a way to obtain process information from the system.
+
+    * `/proc` is used if supported.
+    * The system `ps` utility is used as a fallback option.
+    """
+    for impl in (proc, ps):
+        try:
+            iterator = impl.iter_process_parents(pid, max_depth)
+        except EnvironmentError:
+            continue
+        return iterator
+    raise ShellDetectionFailure("compatible proc fs or ps utility is required")
+
+
+def _get_login_shell(proc_cmd):
+    """Form shell information from SHELL environ if possible."""
+    login_shell = os.environ.get("SHELL", "")
+    if login_shell:
+        proc_cmd = login_shell
+    else:
+        proc_cmd = proc_cmd[1:]
+    return (os.path.basename(proc_cmd).lower(), proc_cmd)
+
+
+_INTERPRETER_SHELL_NAMES = [
+    (re.compile(r"^python(\d+(\.\d+)?)?$"), {"xonsh"}),
+]
+
+
+def _get_interpreter_shell(proc_name, proc_args):
+    """Get shell invoked via an interpreter.
+
+    Some shells are implemented on, and invoked with an interpreter, e.g. xonsh
+    is commonly executed with an executable Python script. This detects what
+    script the interpreter is actually running, and check whether that looks
+    like a shell.
+
+    See sarugaku/shellingham#26 for rational.
+    """
+    for pattern, shell_names in _INTERPRETER_SHELL_NAMES:
+        if not pattern.match(proc_name):
+            continue
+        for arg in proc_args:
+            name = os.path.basename(arg).lower()
+            if os.path.isfile(arg) and name in shell_names:
+                return (name, arg)
+    return None
+
+
+def _get_shell(cmd, *args):
+    if cmd.startswith("-"):  # Login shell! Let's use this.
+        return _get_login_shell(cmd)
+    name = os.path.basename(cmd).lower()
+    if name == "rosetta" or QEMU_BIN_REGEX.fullmatch(name):
+        # If the current process is Rosetta or QEMU, this likely is a
+        # containerized process. Parse out the actual command instead.
+        cmd = args[0]
+        args = args[1:]
+        name = os.path.basename(cmd).lower()
+    if name in SHELL_NAMES:  # Command looks like a shell.
+        return (name, cmd)
+    shell = _get_interpreter_shell(name, args)
+    if shell:
+        return shell
+    return None
+
+
+def get_shell(pid=None, max_depth=10):
+    """Get the shell that the supplied pid or os.getpid() is running in."""
+    pid = str(pid or os.getpid())
+    for proc_args, _, _ in _iter_process_parents(pid, max_depth):
+        shell = _get_shell(*proc_args)
+        if shell:
+            return shell
+    return None
diff --git a/tool_server/.venv/lib/python3.12/site-packages/shellingham/posix/__pycache__/__init__.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/shellingham/posix/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c2c73eeecb4b1fb7e7e713f23df9a3c1fe59ad61
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/shellingham/posix/__pycache__/__init__.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/shellingham/posix/__pycache__/_core.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/shellingham/posix/__pycache__/_core.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..8674b9065b7cfbf6f7a35173ea3cb05e924c13b0
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/shellingham/posix/__pycache__/_core.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/shellingham/posix/__pycache__/proc.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/shellingham/posix/__pycache__/proc.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..9562b3fb4c96fa7d6359c4b54085a86633a4ccb3
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/shellingham/posix/__pycache__/proc.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/shellingham/posix/__pycache__/ps.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/shellingham/posix/__pycache__/ps.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..0ca7fa3655252deae0356baf7ba76c416971b198
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/shellingham/posix/__pycache__/ps.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/shellingham/posix/_core.py b/tool_server/.venv/lib/python3.12/site-packages/shellingham/posix/_core.py
new file mode 100644
index 0000000000000000000000000000000000000000..adc49e6e7a9d3edf062c55e0078136899f78d30d
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/shellingham/posix/_core.py
@@ -0,0 +1,3 @@
+import collections
+
+Process = collections.namedtuple("Process", "args pid ppid")
diff --git a/tool_server/.venv/lib/python3.12/site-packages/shellingham/posix/proc.py b/tool_server/.venv/lib/python3.12/site-packages/shellingham/posix/proc.py
new file mode 100644
index 0000000000000000000000000000000000000000..950f63228e5b328f82b70da8851ec60c6a2ff029
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/shellingham/posix/proc.py
@@ -0,0 +1,83 @@
+import io
+import os
+import re
+import sys
+
+from ._core import Process
+
+# FreeBSD: https://www.freebsd.org/cgi/man.cgi?query=procfs
+# NetBSD: https://man.netbsd.org/NetBSD-9.3-STABLE/mount_procfs.8
+# DragonFlyBSD: https://www.dragonflybsd.org/cgi/web-man?command=procfs
+BSD_STAT_PPID = 2
+
+# See https://docs.kernel.org/filesystems/proc.html
+LINUX_STAT_PPID = 3
+
+STAT_PATTERN = re.compile(r"\(.+\)|\S+")
+
+
+def detect_proc():
+    """Detect /proc filesystem style.
+
+    This checks the /proc/{pid} directory for possible formats. Returns one of
+    the following as str:
+
+    * `stat`: Linux-style, i.e. ``/proc/{pid}/stat``.
+    * `status`: BSD-style, i.e. ``/proc/{pid}/status``.
+    """
+    pid = os.getpid()
+    for name in ("stat", "status"):
+        if os.path.exists(os.path.join("/proc", str(pid), name)):
+            return name
+    raise ProcFormatError("unsupported proc format")
+
+
+def _use_bsd_stat_format():
+    try:
+        return os.uname().sysname.lower() in ("freebsd", "netbsd", "dragonfly")
+    except Exception:
+        return False
+
+
+def _get_ppid(pid, name):
+    path = os.path.join("/proc", str(pid), name)
+    with io.open(path, encoding="ascii", errors="replace") as f:
+        parts = STAT_PATTERN.findall(f.read())
+    # We only care about TTY and PPID -- both are numbers.
+    if _use_bsd_stat_format():
+        return parts[BSD_STAT_PPID]
+    return parts[LINUX_STAT_PPID]
+
+
+def _get_cmdline(pid):
+    path = os.path.join("/proc", str(pid), "cmdline")
+    encoding = sys.getfilesystemencoding() or "utf-8"
+    with io.open(path, encoding=encoding, errors="replace") as f:
+        # XXX: Command line arguments can be arbitrary byte sequences, not
+        # necessarily decodable. For Shellingham's purpose, however, we don't
+        # care. (pypa/pipenv#2820)
+        # cmdline appends an extra NULL at the end, hence the [:-1].
+        return tuple(f.read().split("\0")[:-1])
+
+
+class ProcFormatError(EnvironmentError):
+    pass
+
+
+def iter_process_parents(pid, max_depth=10):
+    """Try to look up the process tree via the /proc interface."""
+    stat_name = detect_proc()
+
+    # Inner generator function so we correctly throw an error eagerly if proc
+    # is not supported, rather than on the first call to the iterator. This
+    # allows the call site detects the correct implementation.
+    def _iter_process_parents(pid, max_depth):
+        for _ in range(max_depth):
+            ppid = _get_ppid(pid, stat_name)
+            args = _get_cmdline(pid)
+            yield Process(args=args, pid=pid, ppid=ppid)
+            if ppid == "0":
+                break
+            pid = ppid
+
+    return _iter_process_parents(pid, max_depth)
diff --git a/tool_server/.venv/lib/python3.12/site-packages/shellingham/posix/ps.py b/tool_server/.venv/lib/python3.12/site-packages/shellingham/posix/ps.py
new file mode 100644
index 0000000000000000000000000000000000000000..3bc39a74a56390c263e63bfead028f6bce4df3cb
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/shellingham/posix/ps.py
@@ -0,0 +1,51 @@
+import errno
+import subprocess
+import sys
+
+from ._core import Process
+
+
+class PsNotAvailable(EnvironmentError):
+    pass
+
+
+def iter_process_parents(pid, max_depth=10):
+    """Try to look up the process tree via the output of `ps`."""
+    try:
+        cmd = ["ps", "-ww", "-o", "pid=", "-o", "ppid=", "-o", "args="]
+        output = subprocess.check_output(cmd)
+    except OSError as e:  # Python 2-compatible FileNotFoundError.
+        if e.errno != errno.ENOENT:
+            raise
+        raise PsNotAvailable("ps not found")
+    except subprocess.CalledProcessError as e:
+        # `ps` can return 1 if the process list is completely empty.
+        # (sarugaku/shellingham#15)
+        if not e.output.strip():
+            return
+        raise
+    if not isinstance(output, str):
+        encoding = sys.getfilesystemencoding() or sys.getdefaultencoding()
+        output = output.decode(encoding)
+
+    processes_mapping = {}
+    for line in output.split("\n"):
+        try:
+            _pid, ppid, args = line.strip().split(None, 2)
+            # XXX: This is not right, but we are really out of options.
+            # ps does not offer a sane way to decode the argument display,
+            # and this is "Good Enough" for obtaining shell names. Hopefully
+            # people don't name their shell with a space, or have something
+            # like "/usr/bin/xonsh is uber". (sarugaku/shellingham#14)
+            args = tuple(a.strip() for a in args.split(" "))
+        except ValueError:
+            continue
+        processes_mapping[_pid] = Process(args=args, pid=_pid, ppid=ppid)
+
+    for _ in range(max_depth):
+        try:
+            process = processes_mapping[pid]
+        except KeyError:
+            return
+        yield process
+        pid = process.ppid
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy-1.14.0.dist-info/licenses/AUTHORS b/tool_server/.venv/lib/python3.12/site-packages/sympy-1.14.0.dist-info/licenses/AUTHORS
new file mode 100644
index 0000000000000000000000000000000000000000..1062f3bf743c0a37bcde05b1afc1ba5e98a95822
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy-1.14.0.dist-info/licenses/AUTHORS
@@ -0,0 +1,1379 @@
+All people who contributed to SymPy by sending at least a patch or
+more (in the order of the date of their first contribution), except
+those who explicitly didn't want to be mentioned. People with a * next
+to their names are not found in the metadata of the git history. This
+file is generated automatically by running `./bin/authors_update.py`.
+
+There are a total of 1371 authors.
+
+Ondřej Čertík <ondrej@certik.cz>
+Fabian Pedregosa <fabian@fseoane.net>
+Jurjen N.E. Bos <jnebos@gmail.com>
+Mateusz Paprocki <mattpap@gmail.com>
+*Marc-Etienne M.Leveille <protonyc@gmail.com>
+Brian Jorgensen <brian.jorgensen@gmail.com>
+Jason Gedge <inferno1386@gmail.com>
+Robert Schwarz <lethargo@googlemail.com>
+Pearu Peterson <pearu.peterson@gmail.com>
+Fredrik Johansson <fredrik.johansson@gmail.com>
+Chris Wu <chris.wu@gmail.com>
+*Ulrich Hecht <ulrich.hecht@gmail.com>
+Goutham Lakshminarayan <dl.goutham@gmail.com>
+David Lawrence <dmlawrence@gmail.com>
+Jaroslaw Tworek <dev.jrx@gmail.com>
+David Marek <h4wk.cz@gmail.com>
+Bernhard R. Link <brlink@debian.org>
+Andrej Tokarčík <androsis@gmail.com>
+Or Dvory <gidesa@gmail.com>
+Saroj Adhikari <adh.saroj@gmail.com>
+Pauli Virtanen <pav@iki.fi>
+Robert Kern <robert.kern@gmail.com>
+James Aspnes <aspnes@cs.yale.edu>
+Nimish Telang <ntelang@gmail.com>
+Abderrahim Kitouni <a.kitouni@gmail.com>
+Pan Peng <pengpanster@gmail.com>
+Friedrich Hagedorn <friedrich_h@gmx.de>
+Elrond der Elbenfuerst <elrond+sympy.org@samba-tng.org>
+Rizgar Mella <rizgar.mella@gmail.com>
+Felix Kaiser <felix.kaiser@fxkr.net>
+Roberto Nobrega <rwnobrega@gmail.com>
+David Roberts <dvdr18@gmail.com>
+Sebastian Krämer <basti.kr@gmail.com>
+Vinzent Steinberg <vinzent.steinberg@gmail.com>
+Riccardo Gori <goriccardo@gmail.com>
+Case Van Horsen <casevh@gmail.com>
+Stepan Roucka <stepan@roucka.eu>
+Ali Raza Syed <arsyed@gmail.com>
+Stefano Maggiolo <s.maggiolo@gmail.com>
+Robert Cimrman <cimrman3@ntc.zcu.cz>
+Bastian Weber <bastian.weber@gmx-topmail.de>
+Sebastian Krause <sebastian.krause@gmx.de>
+Sebastian Kreft <skreft@gmail.com>
+*Dan <coolg49964@gmail.com>
+Alan Bromborsky <abrombo@verizon.net>
+Boris Timokhin <qoqenator@gmail.com>
+Robert <average.programmer@gmail.com>
+Andy R. Terrel <aterrel@uchicago.edu>
+Hubert Tsang <intsangity@gmail.com>
+Konrad Meyer <konrad.meyer@gmail.com>
+Henrik Johansson <henjo2006@gmail.com>
+Priit Laes <plaes@plaes.org>
+Freddie Witherden <freddie@witherden.org>
+Brian E. Granger <ellisonbg@gmail.com>
+Andrew Straw <strawman@astraw.com>
+Kaifeng Zhu <cafeeee@gmail.com>
+Ted Horst <ted.horst@earthlink.net>
+Andrew Docherty <andrewd@maths.usyd.edu.au>
+Akshay Srinivasan <akshaysrinivasan@gmail.com>
+Aaron Meurer <asmeurer@gmail.com>
+Barry Wardell <barry.wardell@gmail.com>
+Tomasz Buchert <thinred@gmail.com>
+Vinay Kumar <gnulinooks@gmail.com>
+Johann Cohen-Tanugi <johann.cohentanugi@gmail.com>
+Jochen Voss <voss@seehuhn.de>
+Luke Peterson <hazelnusse@gmail.com>
+Chris Smith <smichr@gmail.com>
+Thomas Sidoti <TSidoti@gmail.com>
+Florian Mickler <florian@mickler.org>
+Nicolas Pourcelot <nicolas.pourcelot@gmail.com>
+Ben Goodrich <goodrich.ben@gmail.com>
+Toon Verstraelen <Toon.Verstraelen@UGent.be>
+Ronan Lamy <ronan.lamy@gmail.com>
+James Abbatiello <abbeyj@gmail.com>
+Ryan Krauss <ryanlists@gmail.com>
+Bill Flynn <wflynny@gmail.com>
+Kevin Goodsell <kevin-opensource@omegacrash.net>
+Jorn Baayen <jorn.baayen@gmail.com>
+Eh Tan <tan2tan2@gmail.com>
+Renato Coutinho <renato.coutinho@gmail.com>
+Oscar Benjamin <oscar.j.benjamin@gmail.com>
+Øyvind Jensen <jensen.oyvind@gmail.com>
+Julio Idichekop Filho <idichekop@yahoo.com.br>
+Łukasz Pankowski <lukpank@o2.pl>
+*Chu-Ching Huang <cchuang@mail.cgu.edu.tw>
+Fernando Perez <Fernando.Perez@berkeley.edu>
+Raffaele De Feo <alberthilbert@gmail.com>
+Christian Muise <christian.muise@gmail.com>
+Matt Curry <mattjcurry@gmail.com>
+Kazuo Thow <kazuo.thow@gmail.com>
+Christian Schubert <chr.schubert@gmx.de>
+Jezreel Ng <jezreel@gmail.com>
+James Pearson <xiong.chiamiov@gmail.com>
+Matthew Brett <matthew.brett@gmail.com>
+Addison Cugini <ajcugini@gmail.com>
+Nicholas J.S. Kinar <n.kinar@usask.ca>
+Harold Erbin <harold.erbin@gmail.com>
+Thomas Dixon <thom@thomdixon.org>
+Cristóvão Sousa <crisjss@gmail.com>
+Andre de Fortier Smit <freevryheid@gmail.com>
+Mark Dewing <markdewing@gmail.com>
+Alexey U. Gudchenko <proga@goodok.ru>
+Gary Kerr <gary.kerr@blueyonder.co.uk>
+Sherjil Ozair <sherjilozair@gmail.com>
+Oleksandr Gituliar <gituliar@gmail.com>
+Sean Vig <sean.v.775@gmail.com>
+Prafullkumar P. Tale <hector1618@gmail.com>
+Vladimir Perić <vlada.peric@gmail.com>
+Tom Bachmann <e_mc_h2@web.de>
+Yuri Karadzhov <yuri.karadzhov@gmail.com>
+Vladimir Lagunov <werehuman@gmail.com>
+Matthew Rocklin <mrocklin@cs.uchicago.edu>
+Saptarshi Mandal <sapta.iitkgp@gmail.com>
+Gilbert Gede <gilbertgede@gmail.com>
+Anatolii Koval <weralwolf@gmail.com>
+Tomo Lazovich <lazovich@gmail.com>
+Pavel Fedotov <fedotovp@gmail.com>
+Jack McCaffery <jpmccaffery@gmail.com>
+Jeremias Yehdegho <j.yehdegho@gmail.com>
+Kibeom Kim <kk1674@nyu.edu>
+Gregory Ksionda <ksiondag846@gmail.com>
+Tomáš Bambas <tomas.bambas@gmail.com>
+Raymond Wong <rayman_407@yahoo.com>
+Luca Weihs <astronomicalcuriosity@gmail.com>
+Shai 'Deshe' Wyborski <shaide@cs.huji.ac.il>
+Thomas Wiecki <thomas.wiecki@gmail.com>
+Óscar Nájera <najera.oscar@gmail.com>
+Mario Pernici <mario.pernici@gmail.com>
+Benjamin McDonald <mcdonald.ben@gmail.com>
+Sam Magura <samtheman132@gmail.com>
+Stefan Krastanov <krastanov.stefan@gmail.com>
+Bradley Froehle <brad.froehle@gmail.com>
+Min Ragan-Kelley <benjaminrk@gmail.com>
+Emma Hogan <ehogan@gemini.edu>
+Nikhil Sarda <diff.operator@gmail.com>
+Julien Rioux <julien.rioux@gmail.com>
+Roberto Colistete, Jr. <roberto.colistete@gmail.com>
+Raoul Bourquin <raoulb@bluewin.ch>
+Gert-Ludwig Ingold <gert.ingold@physik.uni-augsburg.de>
+Srinivas Vasudevan <srvasude@gmail.com>
+Jason Moore <moorepants@gmail.com>
+Miha Marolt <tloramus@gmail.com>
+Tim Lahey <tim.lahey@gmail.com>
+Luis Garcia <ppn.online@me.com>
+Matt Rajca <matt.rajca@me.com>
+David Li <l33tnerd.li@gmail.com>
+Alexandr Gudulin <alexandr.gudulin@gmail.com>
+Bilal Akhtar <bilalakhtar@ubuntu.com>
+Grzegorz Świrski <sognat@gmail.com>
+Matt Habel <habelinc@gmail.com>
+David Ju <Sgtmook314@gmail.com>
+Nichita Utiu <nikita.utiu+github@gmail.com>
+Nikolay Lazarov <qwerqwerqwer@abv.bg>
+Steve Anton <anxuiz.nx@gmail.com>
+Imran Ahmed Manzoor <imran.manzoor31@gmail.com>
+Ljubiša Moćić <3rdslasher@gmail.com>
+Piotr Korgul <p.korgul@gmail.com>
+Jim Zhang <Hyriodula@gmail.com>
+Sam Sleight <samuel.sleight@gmail.com>
+tborisova <ts.borisova3@gmail.com>
+Chancellor Arkantos <Chancellor_Arkantos@hotmail.co.uk>
+Stepan Simsa <simsa.st@gmail.com>
+Tobias Lenz <t_lenz94@web.de>
+Siddhanathan Shanmugam <siddhanathan@gmail.com>
+Tiffany Zhu <bubble.wubble.303@gmail.com>
+Tristan Hume <tris.hume@gmail.com>
+Alexey Subach <alexey.subach@gmail.com>
+Joan Creus <joan.creus.c@gmail.com>
+Geoffry Song <goffrie@gmail.com>
+Puneeth Chaganti <punchagan@gmail.com>
+Marcin Kostrzewa <>
+Natalia Nawara <fankalemura@gmail.com>
+vishal <vishal.panjwani15@gmail.com>
+Shruti Mangipudi <shruti2395@gmail.com>
+Davy Mao <e_equals_mass_speed_light_squared@hotmail.com>
+Swapnil Agarwal <swapnilag29@gmail.com>
+Dhia Kennouche <kendhia@gmail.com>
+jerryma1121 <jerryma1121@gmail.com>
+Joachim Durchholz <jo@durchholz.org>
+Martin Povišer <martin.povik@gmail.com>
+Siddhant Jain <getsiddhant@gmail.com>
+Kevin Hunter <hunteke@earlham.edu>
+Michael Mayorov <marchael@kb.csu.ru>
+Nathan Alison <nathan.f.alison@gmail.com>
+Christian Bühler <christian@cbuehler.de>
+Carsten Knoll <CarstenKnoll@gmx.de>
+Bharath M R <catchmrbharath@gmail.com>
+Matthias Toews <mat.toews@googlemail.com>
+Sergiu Ivanov <unlimitedscolobb@gmail.com>
+Jorge E. Cardona <jorgeecardona@gmail.com>
+Sanket Agarwal <sanket@sanketagarwal.com>
+Manoj Babu K. <manoj.babu2378@gmail.com>
+Sai Nikhil <tsnlegend@gmail.com>
+Aleksandar Makelov <amakelov@college.harvard.edu>
+Sachin Irukula <sachin.irukula@gmail.com>
+Raphael Michel <webmaster@raphaelmichel.de>
+Ashwini Oruganti <ashwini.oruganti@gmail.com>
+Andreas Klöckner <inform@tiker.net>
+Prateek Papriwal <papriwalprateek@gmail.com>
+Arpit Goyal <agmps18@gmail.com>
+Angadh Nanjangud <angadh.n@gmail.com>
+Comer Duncan <comer.duncan@gmail.com>
+Jens H. Nielsen <jenshnielsen@gmail.com>
+Joseph Dougherty <Github@JWDougherty.com>
+Elliot Marshall <Marshall2389@gmail.com>
+Guru Devanla <grdvnl@gmail.com>
+George Waksman <waksman@gwax.com>
+Alexandr Popov <alexandr.s.popov@gmail.com>
+Tarun Gaba <tarun.gaba7@gmail.com>
+Takafumi Arakaki <aka.tkf@gmail.com>
+Saurabh Jha <saurabh.jhaa@gmail.com>
+Rom le Clair <jacen.guardian@gmail.com>
+Angus Griffith <16sn6uv@gmail.com>
+Timothy Reluga <treluga@math.psu.edu>
+Brian Stephanik <xoedusk@gmail.com>
+Alexander Eberspächer <alex.eberspaecher@gmail.com>
+Sachin Joglekar <srjoglekar246@gmail.com>
+Tyler Pirtle <teeler@gmail.com>
+Vasily Povalyaev <vapovalyaev@gmail.com>
+Colleen Lee <colleenclee@gmail.com>
+Matthew Hoff <mhoff14@gmail.com>
+Niklas Thörne <notrupertthorne@gmail.com>
+Huijun Mai <m.maihuijun@gmail.com>
+Marek Šuppa <mr@shu.io>
+Ramana Venkata <idlike2dream@gmail.com>
+Prasoon Shukla <prasoon92.iitr@gmail.com>
+Stefen Yin <zqyin@ucdavis.edu>
+Thomas Hisch <t.hisch@gmail.com>
+Madeleine Ball <mpball@gmail.com>
+Mary Clark <mary.spriteling@gmail.com>
+Rishabh Dixit <rishabhdixit11@gmail.com>
+Manoj Kumar <manojkumarsivaraj334@gmail.com>
+Akshit Agarwal <akshit.jiit@gmail.com>
+CJ Carey <perimosocordiae@gmail.com>
+Patrick Lacasse <patrick.m.lacasse@gmail.com>
+Ananya H <ananyaha93@gmail.com>
+Tarang Patel <tarangrockr@gmail.com>
+Christopher Dembia <cld72@cornell.edu>
+Benjamin Fishbein <fishbeinb@gmail.com>
+Sean Ge <seange727@gmail.com>
+Amit Jamadagni <bitsjamadagni@gmail.com>
+Ankit Agrawal <aaaagrawal@iitb.ac.in>
+Björn Dahlgren <bjodah@gmail.com>
+Christophe Saint-Jean <christophe.saint-jean@univ-lr.fr>
+Demian Wassermann <demian@bwh.harvard.edu>
+Khagesh Patel <khageshpatel93@gmail.com>
+Stephen Loo <shikil@yahoo.com>
+hm <hacman0@gmail.com>
+Patrick Poitras <acebulf@gmail.com>
+Katja Sophie Hotz <katja.sophie.hotz@student.tuwien.ac.at>
+Varun Joshi <joshi.142@osu.edu>
+Chetna Gupta <cheta.gup@gmail.com>
+Thilina Rathnayake <thilinarmtb@gmail.com>
+Max Hutchinson <maxhutch@gmail.com>
+Shravas K Rao <shravas@gmail.com>
+Matthew Tadd <matt.tadd@gmail.com>
+Alexander Hirzel <alex@hirzel.us>
+Randy Heydon <randy.heydon@clockworklab.net>
+Oliver Lee <oliverzlee@gmail.com>
+Seshagiri Prabhu <seshagiriprabhu@gmail.com>
+Pradyumna <pradyu1993@gmail.com>
+Erik Welch <erik.n.welch@gmail.com>
+Eric Nelson <eric.the.red.XLII@gmail.com>
+Roland Puntaier <roland.puntaier@chello.at>
+Chris Conley <chrisconley15@gmail.com>
+Tim Swast <tswast@gmail.com>
+Dmitry Batkovich <batya239@gmail.com>
+Francesco Bonazzi <franz.bonazzi@gmail.com>
+Yuriy Demidov <iurii.demidov@gmail.com>
+Rick Muller <rpmuller@gmail.com>
+Manish Gill <gill.manish90@gmail.com>
+Markus Müller <markus.mueller.1.g@googlemail.com>
+Amit Saha <amitsaha.in@gmail.com>
+Jeremy <twobitlogic@gmail.com>
+QuaBoo <kisonchristian@gmail.com>
+Stefan van der Walt <stefan@sun.ac.za>
+David Joyner <wdjoyner@gmail.com>
+Lars Buitinck <larsmans@gmail.com>
+Alkiviadis G. Akritas <akritas@uth.gr>
+Vinit Ravishankar <vinit.ravishankar@gmail.com>
+Michael Boyle <michael.oliver.boyle@gmail.com>
+Heiner Kirchhoffer <Heiner.Kirchhoffer@gmail.com>
+Pablo Puente <ppuedom@gmail.com>
+James Fiedler <jrfiedler@gmail.com>
+Harsh Gupta <mail@hargup.in>
+Tuomas Airaksinen <tuomas.airaksinen@gmail.com>
+Paul Strickland <p.e.strickland@gmail.com>
+James Goppert <james.goppert@gmail.com>
+rathmann <rathmann.os@gmail.com>
+Avichal Dayal <avichal.dayal@gmail.com>
+Paul Scott <paul.scott@nicta.com.au>
+Shipra Banga <bangashipra@gmail.com>
+Pramod Ch <pramodch14@gmail.com>
+Akshay <akshaynukala95@gmail.com>
+Buck Shlegeris <buck2@bruceh15.anu.edu.au>
+Jonathan Miller <jdmiller93@gmail.com>
+Edward Schembor <eschemb1@jhu.edu>
+Rajath Shashidhara <rajaths.rajaths@gmail.com>
+Zamrath Nizam <zamiguy_ni@yahoo.com>
+Aditya Shah <adityashah30@gmail.com>
+Rajat Aggarwal <rajataggarwal1975@gmail.com>
+Sambuddha Basu <sammygamer@live.com>
+Zeel Shah <kshah215@gmail.com>
+Abhinav Chanda <abhinavchanda01@gmail.com>
+Jim Crist <crist042@umn.edu>
+Sudhanshu Mishra <mrsud94@gmail.com>
+Anurag Sharma <anurags92@gmail.com>
+Soumya Dipta Biswas <sdb1323@gmail.com>
+Sushant Hiray <hiraysushant@gmail.com>
+Ben Lucato <ben.lucato@gmail.com>
+Kunal Arora <kunalarora.135@gmail.com>
+Henry Gebhardt <hsggebhardt@gmail.com>
+Dammina Sahabandu <dmsahabandu@gmail.com>
+Manish Shukla <manish.shukla393@gmail>
+Ralph Bean <rbean@redhat.com>
+richierichrawr <richierichrawr@users.noreply.github.com>
+John Connor <john.theman.connor@gmail.com>
+Juan Luis Cano Rodríguez <juanlu001@gmail.com>
+Sahil Shekhawat <sahilshekhawat01@gmail.com>
+Kundan Kumar <kundankumar18581@gmail.com>
+Stas Kelvich <stanconn@gmail.com>
+sevaader <sevaader@gmail.com>
+Dhruvesh Vijay Parikh <parikhdhruvesh1@gmail.com>
+Venkatesh Halli <venkatesh.fatality@gmail.com>
+Lennart Fricke <lennart@die-frickes.eu>
+Vlad Seghete <vlad.seghete@gmail.com>
+Shashank Agarwal <shashank.agarwal94@gmail.com>
+carstimon <carstimon@gmail.com>
+Pierre Haessig <pierre.haessig@crans.org>
+Maciej Baranski <getrox.sc@gmail.com>
+Benjamin Gudehus <hastebrot@gmail.com>
+Faisal Anees <faisal.iiit@gmail.com>
+Mark Shoulson <mark@kli.org>
+Robert Johansson <jrjohansson@gmail.com>
+Kalevi Suominen <jksuom@gmail.com>
+Kaushik Varanasi <kaushik.varanasi1@gmail.com>
+Fawaz Alazemi <Mba7eth@gmail.com>
+Ambar Mehrotra <mehrotraambar@gmail.com>
+David P. Sanders <dpsanders@gmail.com>
+Peter Brady <petertbrady@gmail.com>
+John V. Siratt <jvsiratt@gmail.com>
+Sarwar Chahal <chahal.sarwar98@gmail.com>
+Nathan Woods <charlesnwoods@gmail.com>
+Colin B. Macdonald <cbm@m.fsf.org>
+Marcus Näslund <naslundx@gmail.com>
+Clemens Novak <clemens@familie-novak.net>
+Mridul Seth <seth.mridul@gmail.com>
+Craig A. Stoudt <craig.stoudt@gmail.com>
+Raj <raj454raj@gmail.com>
+Mihai A. Ionescu <ionescu.a.mihai@gmail.com>
+immerrr <immerrr@gmail.com>
+Chai Wah Wu <cwwuieee@gmail.com>
+Leonid Blouvshtein <leonidbl91@gmail.com>
+Peleg Michaeli <freepeleg@gmail.com>
+ck Lux <lux.r.ck@gmail.com>
+zsc347 <zsc347@gmail.com>
+Hamish Dickson <hamish.dickson@gmail.com>
+Michael Gallaspy <gallaspy.michael@gmail.com>
+Roman Inflianskas <infroma@gmail.com>
+Duane Nykamp <nykamp@umn.edu>
+Ted Dokos <tdokos@gmail.com>
+Sunny Aggarwal <sunnyaggarwal1994@gmail.com>
+Victor Brebenar <v.brebenar@gmail.com>
+Akshat Jain <akshat.jain@students.iiit.ac.in>
+Shivam Vats <shivamvats.iitkgp@gmail.com>
+Longqi Wang <iqgnol@gmail.com>
+Juan Felipe Osorio <jfosorio@gmail.com>
+Ray Cathcart <github@cathcart.us>
+Lukas Zorich <lukas.zorich@gmail.com>
+Eric Miller <emiller42@gmail.com>
+Cody Herbst <cyherbst@gmail.com>
+Nishith Shah <nishithshah.2211@gmail.com>
+Amit Kumar <dtu.amit@gmail.com>
+Yury G. Kudryashov <urkud.urkud@gmail.com>
+Guillaume Gay <contact@damcb.com>
+Mihir Wadwekar <m.mihirw@gmail.com>
+Tuan Manh Lai <laituan245@gmail.com>
+Asish Panda <asishrocks95@gmail.com>
+Darshan Chaudhary <deathbullet@gmail.com>
+Alec Kalinin <alec.kalinin@gmail.com>
+Ralf Stephan <ralf@ark.in-berlin.de>
+Aaditya Nair <aadityanair6494@gmail.com>
+Jayesh Lahori <jlahori92@gmail.com>
+Harshil Goel <harshil158@gmail.com>
+Luv Agarwal <agarwal.iiit@gmail.com>
+Jason Ly <jason.ly@gmail.com>
+Lokesh Sharma <lokeshhsharma@gmail.com>
+Sartaj Singh <singhsartaj94@gmail.com>
+Chris Swierczewski <cswiercz@gmail.com>
+Konstantin Togoi <konstantin.togoi@gmail.com>
+Param Singh <paramsingh258@gmail.com>
+Sumith Kulal <sumith1896@gmail.com>
+Juha Remes <jremes@outlook.com>
+Philippe Bouafia <philippe.bouafia@ensea.fr>
+Peter Schmidt <peter@peterjs.com>
+Jiaxing Liang <liangjiaxing57@gmail.com>
+Lucas Jones <lucas@lucasjones.co.uk>
+Gregory Ashton <gash789@gmail.com>
+Jennifer White <jcrw122@googlemail.com>
+Renato Orsino <renato.orsino@gmail.com>
+Alistair Lynn <arplynn@gmail.com>
+Govind Sahai <gsiitbhu@gmail.com>
+Adam Bloomston <adam@glitterfram.es>
+Kyle McDaniel <mcdanie5@illinois.edu>
+Nguyen Truong Duy <truongduy134@yahoo.com>
+Alex Lindsay <adlinds3@ncsu.edu>
+Mathew Chong <mathewchong.dev@gmail.com>
+Jason Siefken <siefkenj@gmail.com>
+Gaurav Dhingra <gauravdhingra.gxyd@gmail.com>
+Gao, Xiang <qasdfgtyuiop@gmail.com>
+Kevin Ventullo <kevin.ventullo@gmail.com>
+mao8 <thisisma08@gmail.com>
+Isuru Fernando <isuruf@gmail.com>
+Shivam Tyagi <shivam.tyagi.apm13@itbhu.ac.in>
+Richard Otis <richard.otis@outlook.com>
+Rich LaSota <rjlasota@gmail.com>
+dustyrockpyle <dustyrockpyle@gmail.com>
+Anton Akhmerov <anton.akhmerov@gmail.com>
+Michael Zingale <michael.zingale@stonybrook.edu>
+Chak-Pong Chung <chakpongchung@gmail.com>
+David T <derDavidT@users.noreply.github.com>
+Phil Ruffwind <rf@rufflewind.com>
+Sebastian Koslowski <koslowski@kit.edu>
+Kumar Krishna Agrawal <kumar.1994.14@gmail.com>
+Dustin Gadal <Dustin.Gadal@gmail.com>
+João Moura <operte@gmail.com>
+Yu Kobayashi <yukoba@accelart.jp>
+Shashank Kumar <shashank.kumar.apc13@iitbhu.ac.in>
+Timothy Cyrus <tcyrus@users.noreply.github.com>
+Devyani Kota <devyanikota@gmail.com>
+Keval Shah <kevalshah_96@yahoo.co.in>
+Dzhelil Rufat <drufat@caltech.edu>
+Pastafarianist <mr.pastafarianist@gmail.com>
+Sourav Singh <souravsingh@users.noreply.github.com>
+Jacob Garber <jgarber1@ualberta.ca>
+Vinay Singh <csvinay.d@gmail.com>
+GolimarOurHero <metalera94@hotmail.com>
+Prashant Tyagi <prashanttyagi221295@gmail.com>
+Matthew Davis <davisml.md@gmail.com>
+Tschijnmo TSCHAU <tschijnmotschau@gmail.com>
+Alexander Bentkamp <bentkamp@gmail.com>
+Jack Kemp <metaknightdrake-git@yahoo.co.uk>
+Kshitij Saraogi <KshitijSaraogi@gmail.com>
+Thomas Baruchel <baruchel@gmx.com>
+Nicolás Guarín-Zapata <nicoguarin@gmail.com>
+Jens Jørgen Mortensen <jj@smoerhul.dk>
+Sampad Kumar Saha <sampadsaha5@gmail.com>
+Eva Charlotte Mayer <eva-charlotte.mayer@posteo.de>
+Laura Domine <temigo@gmx.com>
+Justin Blythe <jblythe29@gmail.com>
+Meghana Madhyastha <meghana.madhyastha@gmail.com>
+Tanu Hari Dixit <tokencolour@gmail.com>
+Shekhar Prasad Rajak <shekharrajak@live.com>
+Aqnouch Mohammed <aqnouch.mohammed@gmail.com>
+Arafat Dad Khan <arafat.da.khan@gmail.com>
+Boris Atamanovskiy <shaomoron@gmail.com>
+Sam Tygier <sam.tygier@hep.manchester.ac.uk>
+Jai Luthra <me@jailuthra.in>
+Guo Xingjian <Seeker1995@gmail.com>
+Sandeep Veethu <sandeep.veethu@gmail.com>
+Archit Verma <architv07@gmail.com>
+Shubham Tibra <shubh.tibra@gmail.com>
+Ashutosh Saboo <ashutosh.saboo96@gmail.com>
+Michael S. Hansen <michael.hansen@nih.gov>
+Anish Shah <shah.anish07@gmail.com>
+Guillaume Jacquenot <guillaume.jacquenot@gmail.com>
+Bhautik Mavani <mavanibhautik@gmail.com>
+Michał Radwański <enedil.isildur@gmail.com>
+Jerry Li <jerry@jerryli.ca>
+Pablo Zubieta <pabloferz@yahoo.com.mx>
+Shivam Agarwal <knowthyself2503@gmail.com>
+Chaitanya Sai Alaparthi <achaitanyasai@gmail.com>
+Arihant Parsoya <parsoyaarihant@gmail.com>
+Ruslan Pisarev <rpisarev@cloudlinux.com>
+Akash Trehan <akash.trehan123@gmail.com>
+Nishant Nikhil <nishantiam@gmail.com>
+Vladimir Poluhsin <vovapolu@gmail.com>
+Akshay Nagar <awesomeay13@yahoo.com>
+James Brandon Milam <jmilam343@gmail.com>
+Abhinav Agarwal <abhinavagarwal1996@gmail.com>
+Rishabh Daal <rishabhdaal@gmail.com>
+Sanya Khurana <sanya@monica.in>
+Aman Deep <amandeep1024@gmail.com>
+Aravind Reddy <aravindreddy255@gmail.com>
+Abhishek Verma <iamvermaabhishek@gmail.com>
+Matthew Parnell <matt@parnmatt.co.uk>
+Thomas Hickman <Thomas.Hickman42@gmail.com>
+Akshay Siramdas <akshaysiramdas@gmail.com>
+YiDing Jiang <yidinggjiangg@gmail.com>
+Jatin Yadav <jatinyadav25@gmail.com>
+Matthew Thomas <mnmt@users.noreply.github.com>
+Rehas Sachdeva <aquannie@gmail.com>
+Michael Mueller <michaeldmueller7@gmail.com>
+Srajan Garg <srajan.garg@gmail.com>
+Prabhjot Singh <prabhjot.nith@gmail.com>
+Haruki Moriguchi <harukimoriguchi@gmail.com>
+Tom Gijselinck <tomgijselinck@gmail.com>
+Nitin Chaudhary <nitinmax1000@gmail.com>
+Alex Argunov <sajkoooo@gmail.com>
+Nathan Musoke <nathan.musoke@gmail.com>
+Abhishek Garg <abhishekgarg119@gmail.com>
+Dana Jacobsen <dana@acm.org>
+Vasiliy Dommes <vasdommes@gmail.com>
+Phillip Berndt <phillip.berndt@googlemail.com>
+Haimo Zhang <zh.hammer.dev@gmail.com>
+Anthony Scopatz <scopatz@gmail.com>
+bluebrook <perl4logic@gmail.com>
+Leonid Kovalev <leonidvkovalev@gmail.com>
+Josh Burkart <jburkart@gmail.com>
+Dimitra Konomi <t8130064@dias.aueb.gr>
+Christina Zografou <t8130048@dias.aueb.gr>
+Fiach Antaw <fiach.antaw+github@gmail.com>
+Langston Barrett <langston.barrett@gmail.com>
+Krit Karan <kritkaran.b13@iiits.in>
+G. D. McBain <gdmcbain@protonmail.com>
+Prempal Singh <prempal.42@gmail.com>
+Gabriel Orisaka <orisaka@gmail.com>
+Matthias Bussonnier <bussonniermatthias@gmail.com>
+rahuldan <rahul02013@gmail.com>
+Colin Marquardt <github@marquardt-home.de>
+Andrew Taber <andrew.e.taber@gmail.com>
+Yash Reddy <write2yashreddy@gmail.com>
+Peter Stangl <peter.stangl@ph.tum.de>
+elvis-sik <e.sikora@grad.ufsc.br>
+Nikos Karagiannakis <nikoskaragiannakis@gmail.com>
+Jainul Vaghasia <jainulvaghasia@gmail.com>
+Dennis Meckel <meckel@datenschuppen.de>
+Harshil Meena <harshil.7535@gmail.com>
+Micky <mickydroch@gmail.com>
+Nick Curtis <nicholas.curtis@uconn.edu>
+Michele Zaffalon <michele.zaffalon@gmail.com>
+Martha Giannoudovardi <maapxa@gmail.com>
+Devang Kulshreshtha <devang.kulshreshtha.cse14@itbhu.ac.in>
+Steph Papanik <spapanik21@gmail.com>
+Mohammad Sadeq Dousti <msdousti@gmail.com>
+Arif Ahmed <arif.ahmed.5.10.1995@gmail.com>
+Abdullah Javed Nesar <abduljaved1994@gmail.com>
+Lakshya Agrawal <zeeshan.lakshya@gmail.com>
+shruti <shrutishrm512@gmail.com>
+Rohit Rango <rohit.rango@gmail.com>
+Hong Xu <hong@topbug.net>
+Ivan Petuhov <ivan@ostrovok.ru>
+Alsheh <alsheh@rpi.edu>
+Marcel Stimberg <marcel.stimberg@ens.fr>
+Alexey Pakhocmhik <cool.Bakov@yandex.ru>
+Tommy Olofsson <tommy.olofsson.90@gmail.com>
+Zulfikar <zulfikar97@gmail.com>
+Blair Azzopardi <blairuk@gmail.com>
+Danny Hermes <daniel.j.hermes@gmail.com>
+Sergey Pestov <pestov-sa@yandex.ru>
+Mohit Chandra <mohit.chandra@research.iiit.ac.in>
+Karthik Chintapalli <karthik.chintapalli@students.iiit.ac.in>
+Marcin Briański <marcin.brianski@student.uj.edu.pl>
+andreo <andrey.torba@gmail.com>
+Flamy Owl <flamyowl@protonmail.ch>
+Yicong Guo <guoyicong100@gmail.com>
+Varun Garg <varun.garg03@gmail.com>
+Rishabh Madan <rishabhmadan96@gmail.com>
+Aditya Kapoor <aditya.kapoor.apm12@itbhu.ac.in>
+Karan Sharma <karan1276@gmail.com>
+Vedant Rathore <vedantr1998@gmail.com>
+Johan Blåbäck <johan_bluecreek@riseup.net>
+Pranjal Tale <pranjaltale16@gmail.com>
+Jason Tokayer <jason.tokayer@gmail.com>
+Raghav Jajodia <jajodia.raghav@gmail.com>
+Rajat Thakur <rajatthakur1997@gmail.com>
+Dhruv Bhanushali <dhruv_b@live.com>
+Anjul Kumar Tyagi <anjul.ten@gmail.com>
+Barun Parruck <barun.parruck@gmail.com>
+Bao Chau <chauquocbao0907@gmail.com>
+Tanay Agrawal <tanay_agrawal@hotmail.com>
+Ranjith Kumar <ranjith.dakshana2015@gmail.com>
+Shikhar Makhija <shikharmakhija2@gmail.com>
+Yathartha Joshi <yathartha32@gmail.com>
+Valeriia Gladkova <valeriia.gladkova@gmail.com>
+Sagar Bharadwaj <sagarbharadwaj50@gmail.com>
+Daniel Mahler <dmahler@gmail.com>
+Ka Yi <chua.kayi@yahoo.com.sg>
+Rishat Iskhakov <iskhakov@frtk.ru>
+Szymon Mieszczak <szymon.mieszczak@gmail.com>
+Sachin Agarwal <sachinagarwal0499@gmail.com>
+Priyank Patel <pspbot7@gmail.com>
+Satya Prakash Dwibedi <akash581050@gmail.com>
+tools4origins <tools4origins@gmail.com>
+Nico Schlömer <nico.schloemer@gmail.com>
+Fermi Paradox <FermiParadox@users.noreply.github.com>
+Ekansh Purohit <purohit.e15@gmail.com>
+Vedarth Sharma <vedarth.sharma@gmail.com>
+Peeyush Kushwaha <peeyush.p97@gmail.com>
+Jayjayyy <vfhsln8s3l4b87t4c3@byom.de>
+Christopher J. Wright <cjwright4242gh@gmail.com>
+Jakub Wilk <jwilk@jwilk.net>
+Mauro Garavello <mauro.garavello@unimib.it>
+Chris Tefer <ctefer@gmail.com>
+Shikhar Jaiswal <jaiswalshikhar87@gmail.com>
+Chiu-Hsiang Hsu <wdv4758h@gmail.com>
+Carlos Cordoba <ccordoba12@gmail.com>
+Fabian Ball <fabian.ball@kit.edu>
+Yerniyaz <yerniyaz.nurgabylov@nu.edu.kz>
+Christiano Anderson <canderson@riseup.net>
+Robin Neatherway <robin.neatherway@gmail.com>
+Thomas Hunt <thomashunt13@gmail.com>
+Theodore Han <theodorehan@hotmail.com>
+Duc-Minh Phan <alephvn@gmail.com>
+Lejla Metohajrova <l.metohajrova@gmail.com>
+Samyak Jain <samyak.jain2016a@vitstudent.ac.in>
+Aditya Rohan <riyuzakiiitk@gmail.com>
+Vincent Delecroix <vincent.delecroix@labri.fr>
+Michael Sparapany <msparapa@purdue.edu>
+Harsh Jain <harshjniitr@gmail.com>
+Nathan Goldbaum <ngoldbau@illinois.edu>
+latot <felipematas@yahoo.com>
+Kenneth Lyons <ixjlyons@gmail.com>
+Stan Schymanski <stan.schymanski@env.ethz.ch>
+David Daly <david.daly12@kzoo.edu>
+Ayush Shridhar <ayush.shridhar1999@gmail.com>
+Javed Nissar <javednissar@gmail.com>
+Jiri Kuncar <jiri.kuncar@gmail.com>
+vedantc98 <vedantc98@gmail.com>
+Rupesh Harode <rupeshharode@gmail.com>
+Rob Zinkov <rob@zinkov.com>
+James Harrop <ebc121@gmail.com>
+James Taylor <user234683@tutanota.com>
+Ishan Joshi <ishanaj98@gmail.com>
+Marco Mancini <marco.mancini@obspm.fr>
+Boris Ettinger <ettinger.boris@gmail.com>
+Micah Fitch <micahscopes@gmail.com>
+Daniel Wennberg <daniel.wennberg@gmail.com>
+ylemkimon <ylemkimon@naver.com>
+Akash Vaish <akash.9712@gmail.com>
+Peter Enenkel <peter.enenkel+git@gmail.com>
+Waldir Pimenta <waldyrious@gmail.com>
+Jithin D. George <jithindgeorge93@gmail.com>
+Lev Chelyadinov <leva181777@gmail.com>
+Lucas Wiman <lucas.wiman@gmail.com>
+Rhea Parekh <rheaparekh12@gmail.com>
+James Cotton <peabody124@gmail.com>
+Robert Pollak <robert.pollak@posteo.net>
+anca-mc <anca-mc@users.noreply.github.com>
+Sourav Ghosh <souravghosh2197@gmail.com>
+Jonathan Allan <jjallan@users.noreply.github.com>
+Nikhil Pappu <nkhlpappu@gmail.com>
+Ethan Ward <etkewa@gmail.com>
+Cezary Marczak <zeddq1@gmail.com>
+dps7ud <dps7ud@virginia.edu>
+Nilabja Bhattacharya <nilabja10201992@gmail.com>
+Itay4 <31018228+Itay4@users.noreply.github.com>
+Poom Chiarawongse <eight1911@gmail.com>
+Yang Yang <wdscxsj@gmail.com>
+Cavendish McKay <cmckay@tachycline.com>
+Bradley Gannon <bradley.m.gannon@gmail.com>
+B McG <bmcg0890@gmail.com>
+Rob Drynkin <rob.drynkin@gmail.com>
+Seth Ebner <murgrehk@gmail.com>
+Akash Kundu <sk.sayakkundu1997@gmail.com>
+Mark Jeromin <mark.jeromin@sysfrog.net>
+Roberto Díaz Pérez <r.r.1994a@gmail.com>
+Gleb Siroki <g.shiroki@gmail.com>
+Segev Finer <segev208@gmail.com>
+Alex Lubbock <code@alexlubbock.com>
+Ayodeji Ige <ayodeji18@outlook.com>
+Matthew Wardrop <matthew.wardrop@airbnb.com>
+Hugo van Kemenade <hugovk@users.noreply.github.com>
+Austin Palmer <ap4000@nyu.edu>
+der-blaue-elefant <github@kklein.de>
+Filip Gokstorp <filip@gokstorp.se>
+Yuki Matsuda <yuki.matsuda.w@gmail.com>
+Aaron Miller <acmiller273@gmail.com>
+Salil Vishnu Kapur <salilvishnukapur@gmail.com>
+Atharva Khare <khareatharva@gmail.com>
+Shubham Maheshwari <rmaheshwari05@gmail.com>
+Pavel Tkachenko <paveltkachenko@email.com>
+Ashish Kumar Gaurav <ashishkg0022@gmail.com>
+Rajeev Singh <rajs2010@gmail.com>
+Keno Goertz <keno@goertz-berlin.com>
+Lucas Gallindo <lgallindo@gmail.com>
+Himanshu <hs80941@gmail.com>
+David Menéndez Hurtado <david.menendez.hurtado@scilifelab.se>
+Amit Manchanda <amitdelhi1995@gmail.com>
+Rohit Jain <rohitjain3241@gmail.com>
+Jonathan A. Gross <jarthurgross@gmail.com>
+Unknown <kunda@scribus.net>
+Sayan Goswami <Sayan98@users.noreply.github.com>
+Subhash Saurabh <subhashsaurabh419@gmail.com>
+Rastislav Rabatin <rastislav.rabatin@gmail.com>
+Vishal <vishalg2235@gmail.com>
+Jeremey Gluck <jeremygluck@yahoo.com>
+Akshat Maheshwari <akshat14714@gmail.com>
+symbolique <symbolique@users.noreply.github.com>
+Saloni Jain <tosalonijain@gmail.com>
+Arighna Chakrabarty <arighna.chakrabarty100@gmail.com>
+Abhigyan Khaund <mail@abhigyan.xyz>
+Jashanpreet Singh <jashansingh.4398@gmail.com>
+Saurabh Agarwal <shourabh.agarwal@gmail.com>
+luzpaz <luzpaz@users.noreply.github.com>
+P. Sai Prasanth <psai.prasanth.min16@itbhu.ac.in>
+Nirmal Sarswat <nirmalsarswat400@gmail.com>
+Cristian Di Pietrantonio <cristiandipietrantonio@gmail.com>
+Ravi charan <ravicharan.vsp@gmail.com>
+Nityananda Gohain <nityanandagohain@gmail.com>
+Cédric Travelletti <cedrictravelletti@gmail.com>
+Nicholas Bollweg <nick.bollweg@gmail.com>
+Himanshu Ladia <hladia199811@gmail.com>
+Adwait Baokar <adwaitbaokar18@gmail.com>
+Mihail Tarigradschi <m.tarigradschi@gmail.com>
+Saketh <alurusaisaketh@gmail.com>
+rushyam <rushyamsonu@gmail.com>
+sfoo <sfoohei@gmail.com>
+Rahil Hastu <rahilhastu@gmail.com>
+Zach Raines <raineszm@gmail.com>
+Sidhant Nagpal <sidhantnagpal97@gmail.com>
+Gagandeep Singh <singh.23@iitj.ac.in>
+Rishav Chakraborty <annonymousxyz@outlook.com>
+Malkhan Singh <malkhansinghrathaur@gmail.com>
+Joaquim Monserrat <qmonserrat@mailoo.org>
+Mayank Singh <mayank.singh081997@gmail.com>
+Rémy Léone <rleone@online.net>
+Maxence Mayrand <35958639+maxencemayrand@users.noreply.github.com>
+Nikoleta Glynatsi <GlynatsiNE@cardiff.ac.uk>
+helo9 <helo9@users.noreply.github.com>
+Ken Wakita <wakita@is.titech.ac.jp>
+Carl Sandrock <carl.sandrock@up.ac.za>
+Fredrik Eriksson <freeriks@student.chalmers.se>
+Ian Swire <oversizedpenguin@gmail.com>
+Bulat <daianovich@mail.ru>
+Ehren Metcalfe <ehren.m@gmail.com>
+Dmitry Savransky <dsavransky@gmail.com>
+Kiyohito Yamazaki <kyamaz@openql.org>
+Caley Finn <caleyreuben@gmail.com>
+Zhi-Qiang Zhou <zzq_890709@hotmail.com>
+Alexander Pozdneev <pozdneev@users.noreply.github.com>
+Wes Turner <50891+westurner@users.noreply.github.com>
+JMSS-Unknown <31131631+JMSS-Unknown@users.noreply.github.com>
+Arshdeep Singh <singh.arshdeep1999@gmail.com>
+cym1 <16437732+cym1@users.noreply.github.com>
+Stewart Wadsworth <stewart.wadsworth@gmail.com>
+Jared Lumpe <mjlumpe@gmail.com>
+Avi Shrivastava <shrivastavaavi123@gmail.com>
+ramvenkat98 <ramvenkat98@gmail.com>
+Bilal Ahmed <b.ahmed0918@gmail.com>
+Dimas Abreu Archanjo Dutra <dimasad@ufmg.br>
+Yatna Verma <yatnavermaa@gmail.com>
+S.Y. Lee <sylee957@gmail.com>
+Miro Hrončok <miro@hroncok.cz>
+Sudarshan Kamath <sudarshan.kamath97@gmail.com>
+Ayushman Koul <ayushmankoul4570@gmail.com>
+Robert Dougherty-Bliss <robert.w.bliss@gmail.com>
+Andrey Grozin <A.G.Grozin@inp.nsk.su>
+Bavish Kulur <bavishkulur@gmail.com>
+Arun Singh <arunsin997@gmail.com>
+sirnicolaf <43586954+sirnicolaf@users.noreply.github.com>
+Zachariah Etienne <zachetie@gmail.com>
+Prayush Dawda <35144226+iamprayush@users.noreply.github.com>
+2torus <boris.ettinger@gmail.com>
+Faisal Riyaz <faisalriyaz011@gmail.com>
+Martin Roelfs <u0114255@kuleuven.be>
+SirJohnFranklin <sirjfu@googlemail.com>
+Anthony Sottile <asottile@umich.edu>
+ViacheslavP <public.viacheslav@gmail.com>
+Safiya03 <safiyanesar@gmail.com>
+Alexander Dunlap <alexander.dunlap@gmail.com>
+Rohit Sharma <31184621+rohitx007@users.noreply.github.com>
+Jonathan Warner <warnerjon12@gmail.com>
+Mohit Balwani <mohitbalwani.ict17@gmail.com>
+Marduk Bolaños <mardukbp@mac.com>
+amsuhane <ayushsuhane99@iitkgp.ac.in>
+Matthias Geier <Matthias.Geier@gmail.com>
+klaasvanaarsen <44929042+klaasvanaarsen@users.noreply.github.com>
+Shubham Kumar Jha <skjha832@gmail.com>
+rationa-kunal <kunalgk1999@gmail.com>
+Animesh Sinha <animeshsinha1309@gmail.com>
+Gaurang Tandon <1gaurangtandon@gmail.com>
+Matthew Craven <clyring@users.noreply.github.com>
+Daniel Ingram <ingramds@appstate.edu>
+Jogi Miglani <jmig5776@gmail.com>
+Takumasa Nakamura <n.takumasa@gmail.com>
+Ritu Raj Singh <RituRajSingh878@gmail.com>
+Rajiv Ranjan Singh <rajivperfect007@gmail.com>
+Vera Lozhkina <veralozhkina@gmail.com>
+adhoc-king <46354827+adhoc-king@users.noreply.github.com>
+Mikel Rouco <mikel.mrm@gmail.com>
+Oscar Gustafsson <oscar.gustafsson@gmail.com>
+damianos <damianos@semmle.com>
+Supreet Agrawal <supreet11agrawal@gmail.com>
+shiksha11 <shiksharawat01@gmail.com>
+Martin Ueding <dev@martin-ueding.de>
+sharma-kunal <kunalsharma6914@gmail.com>
+Divyanshu Thakur <divyanshu@iiitmanipur.ac.in>
+Susumu Ishizuka <susumu.ishizuka@kii.com>
+Samnan Rahee <namanush.rsr.16@gmail.com>
+Fredrik Andersson <fredrik.andersson@fcc.chalmers.se>
+Bhavya Srivastava <bhavya17037@iiitd.ac.in>
+Alpesh Jamgade <alpeshjamgade21@gmail.com>
+Shubham Abhang <shubhamabhang77@gmail.com>
+Vishesh Mangla <manglavishesh64@gmail.com>
+Nicko van Someren <nicko@nicko.org>
+dandiez <47832466+dandiez@users.noreply.github.com>
+Frédéric Chapoton <fchapoton2@gmail.com>
+jhanwar <f2015463@pilani.bits-pilani.ac.in>
+Noumbissi valere Gille Geovan <noumbissivalere@gmail.com>
+Salmista-94 <alejandrogroso@hotmail.com>
+Shivani Kohli <shivanikohli.09@gmail.com>
+Parker Berry <parkereberry@gmail.com>
+Pragyan Mehrotra <pragyan18168@iiitd.ac.in>
+Nabanita Dash <dashnabanita@gmail.com>
+Gaetano Guerriero <x.guerriero@tin.it>
+Ankit Raj Pandey <pandeyan@grinnell.edu>
+Ritesh Kumar <ritesh99rakesh@gmail.com>
+kangzhiq <709563092@qq.com>
+Jun Lin <junlin0604@gmail.com>
+Petr Kungurtsev <corwinat@gmail.com>
+Anway De <anway1756@gmail.com>
+znxftw <vishnu2101@gmail.com>
+Denis Ivanenko <ivanenko@ucu.edu.ua>
+Orestis Vaggelis <orestisvaggelis@mail.com>
+Nikhil Maan <nikhilmaan22@gmail.com>
+Abhinav Anand <abhinav.anand2807@gmail.com>
+Qingsha Shi <googol.sqs@gmail.com>
+Juan Barbosa <js.barbosa10@uniandes.edu.co>
+Prionti Nasir <pdn3628@rit.edu>
+Bharat Raghunathan <bharatraghunthan9767@gmail.com>
+arooshiverma <av22@iitbbs.ac.in>
+Christoph Gohle <ctg@mpq.mpg.de>
+Charalampos Tsiagkalis <ctsiagkalis@uth.gr>
+Daniel Sears <highpost@users.noreply.github.com>
+Megan Ly <megan.ly@learnosity.com>
+Sean P. Cornelius <spcornelius@gmail.com>
+Erik R. Gomez <gomez@kth.se>
+Riccardo Magliocchetti <riccardo.magliocchetti@gmail.com>
+Henry Metlov <genrih.metlov@gmail.com>
+pekochun <hamburg_hamburger2000@yahoo.co.jp>
+Bendik Samseth <b.samseth@gmail.com>
+Vighnesh Shenoy <vighneshq@gmail.com>
+Versus Void <versusvoid@gmail.com>
+Denys Rybalka <rybalka.denis@gmail.com>
+Mark Dickinson <dickinsm@gmail.com>
+Rimi <rimibis@umich.edu>
+rimibis <33387803+rimibis@users.noreply.github.com>
+Steven Lee <stevenlee123@protonmail.com>
+Gilles Schintgen <gschintgen@hambier.lu>
+Abhi58 <abhijithbharadwaj58@gmail.com>
+Tomasz Pytel <tompytel@gmail.com>
+Aadit Kamat <aadit.k12@gmail.com>
+Samesh <samesh.lakhotia@gmail.com>
+Velibor Zeli <velibor@mech.kth.se>
+Gabriel Bernardino <gabriel.bernardino@upf.edu>
+Joseph Redfern <joseph@redfern.me>
+Evelyn King <evelyn.cameron.king@gmail.com>
+Miguel Marco <mmarco@unizar.es>
+David Hagen <david@drhagen.com>
+Hannah Kari <hannah.kari@marquette.edu>
+Soniya Nayak <soniyanayak51@gmail.com>
+Harsh Agarwal <hagarwal9200@gmail.com>
+Enric Florit <efz1005@gmail.com>
+Yogesh Mishra <ymishra013@gmail.com>
+Denis Rykov <rykovd@gmail.com>
+Ivan Tkachenko <me@ratijas.tk>
+Kenneth Emeka Odoh <kenneth.odoh@gmail.com>
+Stephan Seitz <stephan.seitz@fau.de>
+Yeshwanth N <yeshsurya@gmail.com>
+Oscar Gerardo Lazo Arjona <oscar.lazoarjona@physics.ox.ac.uk>
+Srinivasa Arun Yeragudipati <ysarun1999@gmail.com>
+Kirtan Mali <kirtanmali555@gmail.com>
+TitanSnow <sweeto@live.cn>
+Pengning Chao <8857165+PengningChao@users.noreply.github.com>
+Louis Abraham <louis.abraham@yahoo.fr>
+Morten Olsen Lysgaard <morten@lysgaard.no>
+Akash Nagaraj (akasnaga) <akasnaga@cisco.com>
+Akash Nagaraj <grassknoted@gmail.com>
+Lauren Glattly <laurenglattly@gmail.com>
+Hou-Rui <houruinus@gmail.com>
+George Korepanov <gkorepanov.gk@gmail.com>
+dranknight09 <cbhaavan@gmail.com>
+aditisingh2362 <aditisingh2362@gmail.com>
+Gina <Dr-G@users.noreply.github.com>
+gregmedlock <gmedlo@gmail.com>
+Georgios Giapitzakis Tzintanos <giorgosgiapis@mail.com>
+Eric Wieser <wieser.eric@gmail.com>
+Bradley Dowling <34559056+btdow@users.noreply.github.com>
+Maria Marginean <33810762+mmargin@users.noreply.github.com>
+Akash Agrawall <akash.wanted@gmail.com>
+jgulian <josephdgulian@gmail.com>
+Sourav Goyal <souravgl0@gmail.com>
+Zlatan Vasović <zlatanvasovic@gmail.com>
+Alex Meiburg <timeroot.alex@gmail.com>
+Smit Lunagariya <smitlunagariya.mat18@itbhu.ac.in>
+Naman Gera <namangera15@gmail.com>
+Julien Palard <julien@palard.fr>
+Dhruv Mendiratta <dhruvmendiratta6@gmail.com>
+erdOne <36414270+erdOne@users.noreply.github.com>
+risubaba <risubhjain1010@gmail.com>
+abhinav28071999 <41710346+abhinav28071999@users.noreply.github.com>
+Jisoo Song <jeesoo9595@snu.ac.kr>
+Jaime R <38530589+Jaime02@users.noreply.github.com>
+Vikrant Malik <vikrantmalik051@gmail.com>
+Hardik Saini <43683678+Guardianofgotham@users.noreply.github.com>
+Abhishek <uchiha@pop-os.localdomain>
+Johannes Hartung <joha2@gmx.net>
+Milan Jolly <milan.cs16@iitp.ac.in>
+faizan2700 <syedfaizan824@gmail.com>
+mohit <39158356+mohitacecode@users.noreply.github.com>
+Mohit Gupta <mohitgupta@gmail.com>
+Psycho-Pirate <prakharsaxena.civ18@iitbhu.ac.in>
+Chanakya-Ekbote <ca10@iitbbs.ac.in>
+Rashmi Shehana <rashmi.watagedara@syscolabs.com>
+Jonty16117 <jonty@DESKTOP-J1O6ANP.localdomain>
+Anubhav Gupta <anubhav.gupta.cse19@itbhu.ac.in>
+Michal Grňo <m93a.cz@gmail.com>
+vezeli <37907135+vezeli@users.noreply.github.com>
+Tim Gates <tim.gates@iress.com>
+Sandeep Murthy <smurthy@protonmail.ch>
+Neil <mistersheik@gmail.com>
+V1krant <46847915+V1krant@users.noreply.github.com>
+alejandro <amartinhernan@gmail.com>
+Riyan Dhiman <Riyandhiman14@gmail.com>
+sbt4104 <sthorat661@gmail.com>
+Seth Troisi <sethtroisi@google.com>
+Bhaskar Gupta <guptabhanu1999@gmail.com>
+Smit Gajjar <smitgajjar.gs@gmail.com>
+rbl <rlee@grove.co>
+Ilya Pchelintsev <ilya.pchelintsev@outlook.com>
+Omar Wagih <o.wagih.ow@gmail.com>
+prshnt19 <prashant.rawat216@gmail.com>
+Johan Guzman <jguzm022@ucr.edu>
+Vasileios Kalos <kalosbasileios@gmail.com>
+BasileiosKal <61801875+BasileiosKal@users.noreply.github.com>
+Shubham Thorat <37049710+sbt4104@users.noreply.github.com>
+Arpan Chattopadhyay <f20180319@pilani.bits-pilani.ac.in>
+Ashutosh Hathidara <ashutoshhathidara98@gmail.com>
+Moses Paul R <iammosespaulr@gmail.com>
+Saanidhya vats <saanidhyavats@gmail.com>
+tnzl <you@example.com>
+Vatsal Srivastava <alstav.trivas.sava@gmail.com>
+Jean-Luc Herren <jlh@gmx.ch>
+Dhruv Kothari <dhruvkothari22@gmail.com>
+seadavis <45022599+seadavis@users.noreply.github.com>
+kamimura <kamimura@live.jp>
+slacker404 <pchantza@gmail.com>
+Jaime Resano <gemailpersonal02@gmail.com>
+Ebrahim Byagowi <ebrahim@gnu.org>
+wuyudi <wuyudi119@163.com>
+Akira Kyle <ak@akirakyle.com>
+Calvin Jay Ross <calvinjayross@gmail.com>
+Martin Thoma <info@martin-thoma.de>
+Thomas A Caswell <tcaswell@gmail.com>
+Lagaras Stelios <stel.lag@hotmail.com>
+Jerry James <loganjerry@gmail.com>
+Jan Kruse <janckruse@t-online.de>
+Nathan Taylor <pecan.pine@gmail.com>
+Vaishnav Damani <vaishnavdamani3496@gmail.com>
+Mohit Shah <mohitshah3111999@gmail.com>
+Mathias Louboutin <mathias.louboutin@gmail.com>
+Marijan Smetko <marijansmetko123@gmail.com>
+Dave Witte Morris <Dave.Morris@uleth.ca>
+soumi7 <soumibardhan10@gmail.com>
+Zhongshi <zj495@nyu.edu>
+Wes Galbraith <galbwe92@gmail.com>
+KaustubhDamania <kaustubh.damania@gmail.com>
+w495 <w495@yandex-team.ru>
+Akhil Rajput <akh1lrjput@gmail.com>
+Markus Mohrhard <markus.mohrhard@googlemail.com>
+Benjamin Wolba <mail@benjaminwolba.com>
+彭于斌 <1931127624@qq.com>
+Rudr Tiwari <rudrtiwari@gmail.com>
+Aaryan Dewan <aaryandewan@yahoo.com>
+Benedikt Placke <benedikt.placke@outlook.com>
+Sneha Goddu <s.goddu@wustl.edu>
+goddus <39923708+goddus@users.noreply.github.com>
+Shivang Dubey <shivangdubey8@gmail.com>
+Michael Greminger <michael.greminger@gmail.com>
+Peter Cock <p.j.a.cock@googlemail.com>
+Willem Melching <willem.melching@gmail.com>
+Elias Basler <e.e.basler@protonmail.com>
+Brandon David <brandon.david@zoho.com>
+Abhay_Dhiman <abhaysdhimans@gmail.com>
+Tasha Kim <jae_young_kim@brown.edu>
+Ayush Malik <ayushmalik779@gmail.com>
+Devesh Sawant <devesh47cool@gmail.com>
+Wolfgang Stöcher <wolfgang@stoecher.com>
+Sudeep Sidhu <sudeepmanilsidhu@gmail.com>
+foice <foice.news@gmail.com>
+Ben Payne <ben.is.located@gmail.com>
+Muskan Kumar <31043527+muskanvk@users.noreply.github.com>
+noam simcha finkelstein <noam.finkelstein@protonmail.com>
+Garrett Folbe <gmfolbe@yahoo.com>
+Islam Mansour <is3mansour@gmail.com>
+Sayandip Halder <sayandiph4@gmail.com>
+Shubham Agrawal <shubham.ag6845@gmail.com>
+numbermaniac <5206120+numbermaniac@users.noreply.github.com>
+Sakirul Alam <binarysakir@gmail.com>
+Mohammed Bilal <r.mohammedbilal@gmail.com>
+Chris du Plessis <christopherjonduplessis@gmail.com>
+Coder-RG <rgoel1999@gmail.com>
+Ansh Mishra <anshmishra471@gmail.com>
+Alex Malins <github@alexmalins.com>
+Lorenzo Contento <lorenzo.contento@gmail.com>
+Naveen Sai <naveensaisreenivas@gmail.com>
+Shital Mule <shitalmule04@gmail.com>
+Amanda Dsouza <meezamanda@yahoo.com>
+Nijso Beishuizen <nijso@koolmees.numerically-related.com>
+Harry Zheng <harry@harryzheng.com>
+Felix Yan <felixonmars@archlinux.org>
+Constantin Mateescu <costica1234@me.com>
+Eva Tiwari <eva.tiwari@gmail.com>
+Aditya Kumar Sinha <adityakumar113141@gmail.com>
+Soumi Bardhan <51290447+Soumi7@users.noreply.github.com>
+Kaustubh Chaudhari <ckaustubhm06@gmail.com>
+Kristian Brünn <hello@kristianbrunn.com>
+Neel Gorasiya <mgorasiya1974@gmail.com>
+Akshat Sood <68052998+akshatsood2249@users.noreply.github.com>
+Jose M. Gomez <chemoki@gmail.com>
+Stefan Petrea <stefan@garage-coding.com>
+Praveen Sahu <povinsahu@gmail.com>
+Mark Bell <mark00bell@googlemail.com>
+AlexCQY <alex_chua@u.nus.edu>
+Fabian Froehlich <fabian@schaluck.com>
+Nikhil Gopalam <gopalamn@umich.edu>
+Kartik Sethi <kartiks31416@gmail.com>
+Muhammed Abdul Quadir Owais <quadirowais200@gmail.com>
+Harshit Yadav <harshityadav2k@gmail.com>
+Sidharth Mundhra <sidharthmundhra16@gmail.com>
+Suryam Arnav Kalra <suryamkalra35@gmail.com>
+Prince Gupta <codemastercpp@gmail.com>
+Kunal Singh <ksingh19136@gmail.com>
+Mayank Raj <mayank_1901cs35@iitp.ac.in>
+Achal Jain <2achaljain@gmail.com>
+Mario Maio <mario.maio@aruba.it>
+Aaron Stiff <69512633+AaronStiff@users.noreply.github.com>
+Wyatt Peak <wyattpeak@gmail.com>
+Bhaskar Joshi <bhaskar.joshi@research.iiit.ac.in>
+Aditya Jindal <jaditya8889@gmail.com>
+Vaibhav Bhat <vaibhav.bhat2097@gmail.com>
+Priyansh Rathi <techiepriyansh@gmail.com>
+Saket Kumar Singh <saketkumar1202@gmail.com>
+Yukai Chou <muzimuzhi@gmail.com>
+Qijia Liu <liumeo@pku.edu.cn>
+Paul Mandel <paulmandel@google.com>
+Nisarg Chaudhari <54911392+Nisarg-Chaudhari@users.noreply.github.com>
+Dominik Stańczak <stanczakdominik@gmail.com>
+Rodrigo Luger <rodluger@gmail.com>
+Marco Antônio Habitzreuter <mahabitzreuter@gmail.com>
+Ayush Bisht <bisht.ayush2001@gmail.com>
+Akshansh Bhatt <akshansh@tuta.io>
+Brandon T. Willard <brandonwillard@users.noreply.github.com>
+Thomas Aarholt <thomasaarholt@gmail.com>
+Hiren Chalodiya <hirenchalodiya99@gmail.com>
+Roland Dixon <rols121@gmail.com>
+dimasvq <dimas.vq.2020@bristol.ac.uk>
+Sagar231 <sagarfeb298@gmail.com>
+Michael Chu <michael02chu@gmail.com>
+Abby Ng <abigailjng@gmail.com>
+Angad Sandhu <55819847+angadsinghsandhu@users.noreply.github.com>
+Alexander Cockburn <alexander_cockburn12@hotmail.com>
+Yaser AlOsh <yaseralosh@outlook.com>
+Davide Sandonà <sandona.davide@gmail.com>
+Jonathan Gutow <gutow@uwosh.edu>
+Nihir Agarwal <f20180701@pilani.bits-pilani.ac.in>
+Lee Johnston <lee.johnston.100@gmail.com>
+Zach Carmichael <20629897+craymichael@users.noreply.github.com>
+Vijairam Ganesh Moorthy <vijairamg@gmail.com>
+Hanspeter Schmid <hanspeter.schmid@fhnw.ch>
+Ben Oostendorp <oostben@umich.edu>
+Nikita <nikita.student.cse19@itbhu.ac.in>
+Aman <amanmourya295@gmail.com>
+Shashank KS <shashankks0987@gmail.com>
+Aman Sharma <amansharma110603@gmail.com>
+Anup Parikh <parikhanupk@gmail.com>
+Lucy Mountain <lucymountain1@icloud.com>
+Miguel Torres Costa <miguelptcosta1995@gmail.com>
+Rikard Nordgren <rikard.nordgren@farmaci.uu.se>
+Arun sanganal <74652697+ArunSanganal@users.noreply.github.com>
+Kamlesh Joshi <72374645+kamleshjoshi8102@users.noreply.github.com>
+Joseph Rance <56409230+Joseph-Rance@users.noreply.github.com>
+Huangduirong <huangduirong@huawei.com>
+Nils Schulte <47043622+Schnilz@users.noreply.github.com>
+Matt Bogosian <matt@bogosian.net>
+Elisha Hollander <just4now666666@gmail.com>
+Aditya Ravuri <infprobscix@gmail.com>
+Mamidi Ratna Praneeth <praneethratna@gmail.com>
+Jeffrey Ryan <jeffaryan7@gmail.com>
+Jonathan Daniel <36337649+jond01@users.noreply.github.com>
+Robin Richard <raisin@ecomail.fr>
+Gautam Menghani <gum3ng@protonmail.com>
+Remco de Boer <29308176+redeboer@users.noreply.github.com>
+Sebastian East <sebastianeast@ymail.com>
+Evani Balasubramanyam <balasubramanyam.evani@gmail.com>
+Rahil Parikh <r.parikh@somaiya.edu>
+Jason Ross <jasonross1024@gmail.com>
+Joannah Nanjekye <joannah.nanjekye@ibm.com>
+Ayush Kumar <ayushk7102@gmail.com>
+Kshitij <kshitijparwani.mat18@itbhu.ac.in>
+Daniel Hyams <dhyams@gmail.com>
+alijosephine <alijosephine@gmail.com>
+Matthias Köppe <mkoeppe@math.ucdavis.edu>
+mohajain <mohajain99@gmail.com>
+Anibal M. Medina-Mardones <ammedmar@gmail.com>
+Travis Ens <ens.travis@gmail.com>
+Evgenia Karunus <lakesare@gmail.com>
+Risiraj Dey <risirajdey@gmail.com>
+lastcodestanding <rohang71604@gmail.com>
+Andrey Lekar <andrey_lekar@adoriasoft.com>
+Abbas Mohammed <42001049+iam-abbas@users.noreply.github.com>
+Anutosh Bhat <andersonbhat491@gmail.com>
+Steve Kieffer <sk@skieffer.info>
+Paul Spiering <paul@spiering.org>
+Pieter Gijsbers <p.gijsbers@tue.nl>
+Wang Ran (汪然) <wangr@smail.nju.edu.cn>
+naelsondouglas <naelson17@gmail.com>
+Aman Thakur <thakuraman22july@gmail.com>
+S. Hanko <suzy.hanko@gmail.com>
+Dennis Sweeney <sweeney.427@osu.edu>
+Gurpartap Singh <dhaliwal.gurpartap@gmail.com>
+Hampus Malmberg <hampus.malmberg88@gmail.com>
+scimax <max.kellermeier@hotmail.de>
+Nikhil Date <nikhil.s.date@gmail.com>
+Kuldeep Borkar Jr <kuldeepborkarjr765@gmail.com>
+AkuBrain <76952313+Franck2111@users.noreply.github.com>
+Leo Battle <leowbattle@gmail.com>
+Advait Pote <apote2050@gmail.com>
+Anurag Bhat <bhat.1@iitj.ac.in>
+Jeremy Monat <jemonat@calalum.org>
+Diane Tchuindjo <dtchuindjo@gmail.com>
+Tom Fryers <61272761+TomFryers@users.noreply.github.com>
+Zouhair <zouhair.mahboubi@gmail.com>
+zzj <29055749+zjzh@users.noreply.github.com>
+shubhayu09 <guptashubhayu601@gmail.com>
+Siddhant Jain <siddhantashoknagar@gmail.com>
+Tirthankar Mazumder <63574588+wermos@users.noreply.github.com>
+Sumit Kumar <mr.sumitkrr@gmail.com>
+Shivam Sagar <technoshivam12@gmail.com>
+Gaurav Jain <gjain369@gmail.com>
+Andrii Oriekhov <andriyorehov@gmail.com>
+Luis Talavera <luisfertalavera15@gmail.com>
+Arie Bovenberg <a.c.bovenberg@gmail.com>
+Carson McManus <carson.mcmanus1@gmail.com>
+Jack Schmidt <1107865+jackschmidt@users.noreply.github.com>
+Riley Britten <nrb1324@hotmail.com>
+Georges Khaznadar <georgesk@debian.org>
+Donald Wilson <donwilson1029@gmail.com>
+Timo Stienstra <timostienstra00@gmail.com>
+dispasha <dispasha@users.noreply.github.com>
+Saksham Alok <sakshamalok13@gmail.com>
+Varenyam Bhardwaj <varenyambhardwaj123@gmail.com>
+oittaa <8972248+oittaa@users.noreply.github.com>
+Omkaar <79257339+Pysics@users.noreply.github.com>
+Islem BOUZENIA <fi_bouzenia@esi.dz>
+extraymond <extraymond@gmail.com>
+Alexander Behrens <alex.git@gmx.net>
+user202729 <25191436+user202729@users.noreply.github.com>
+Pieter Eendebak <pieter.eendebak@gmail.com>
+Zaz Brown <zazbrown@zazbrown.com>
+ritikBhandari <ritikbhandari68@gmail.com>
+viocha <66580331+viocha@users.noreply.github.com>
+Arthur Ryman <arthur.ryman@gmail.com>
+Xiang Wu <hsiangwu@fb.com>
+tttc3 <T.Coxon2@lboro.ac.uk>
+Seth Poulsen <poulsenseth@yahoo.com>
+cocolato <haiizhu@outlook.com>
+Anton Golovanov <agolovanov256@gmail.com>
+Gareth Ma <grhkm21@gmail.com>
+Clément M.T. Robert <cr52@protonmail.com>
+Glenn Horton-Smith <glenn.hortonsmith@gmail.com>
+Karan <grgkaran03@gmail.com>
+Stefan Behnle <84378403+behnle@users.noreply.github.com>
+Shreyash Mishra <72146041+Shreyash-cyber@users.noreply.github.com>
+Arthur Milchior <arthur@milchior.fr>
+NotWearingPants <26556598+NotWearingPants@users.noreply.github.com>
+Ishan Pandhare <ishan9096137017@gmail.com>
+Carlos García Montoro <TrilceAC@gmail.com>
+Parcly Taxel <reddeloostw@gmail.com>
+Saicharan <saicharanhahaha@gmail.com>
+Kunal Sheth <kunal@kunalsheth.info>
+Biswadeep Purkayastha <98874428+metabiswadeep@users.noreply.github.com>
+Jyn Spring 琴春 <me@vx.st>
+Phil LeMaitre <phil_lemaitre@live.ca>
+Chris Kerr <chris.kerr@mykolab.ch>
+José Senart <jose.senart@gmail.com>
+Uwe L. Korn <uwelk@xhochy.com>
+ForeverHaibara <69423537+ForeverHaibara@users.noreply.github.com>
+Yves Tumushimire <yvestumushimire@gmail.com>
+wookie184 <wookie1840@gmail.com>
+Costor <pcs2009@web.de>
+Klaus Rettinghaus <klaus.rettinghaus@enote.com>
+Sam Brockie <sambrockie@icloud.com>
+Abhishek Patidar <1e9abhi1e10@gmail.com>
+Eric Demer <demer@mailbox.org>
+Pontus von Brömssen <pontus.vonbromssen+github@gmail.com>
+Victor Immanuel <chrollolucilfer1402@gmail.com>
+Evandro Bernardes <evbernardes@gmail.com>
+Michele Ceccacci <michelececcacci1@gmail.com>
+Ayush Aryan <ayush.aryan71@gmail.com>
+Kishore Gopalakrishnan <kishore96@gmail.com>
+Jan-Philipp Hoffmann <sonntagsgesicht@icloud.com>
+Daiki Takahashi <haru.td@gmail.com>
+Sayan Mitra <ee18b156@smail.iitm.ac.in>
+Aman Kumar Shukla <theprofessionalaman@gmail.com>
+Zoufiné Lauer-Baré <raszoufine@gmail.com>
+Charles Harris <erdos4d@gmail.com>
+Tejaswini Sanapathi <sastejaswini2002@gmail.com>
+Devansh <be19b002@smail.iitm.ac.in>
+Aaron Gokaslan <aaronGokaslan@gmail.com>
+Daan Koning (he/him) <daanolivierkoning@gmail.com>
+Steven Burns <royalstream@hotmail.com>
+Jay Patankar <patankarjays@gmail.com>
+Vivek Soni <sonisheela1977@gmail.com>
+Le Cong Minh Hieu <hieu.lecongminh@gmail.com>
+Sam Ritchie <sam@mentat.org>
+Maciej Skórski <maciej.skorski@gmail.com>
+Tilo Reneau-Cardoso <tiloreneau@gmail.com>
+Laurence Warne <laurencewarne@gmail.com>
+Lukas Molleman <Lukas.Molleman@gmail.com>
+Konstantinos Riganas <kostasriganas24@gmail.com>
+Grace Su <grace.duansu@gmail.com>
+Pedro Rosa <pedro_sxbr@usp.br>
+Abhinav Cillanki <abhinavcillanki@kgpian.iitkgp.ac.in>
+Baiyuan Qiu <1061688677@qq.com>
+Liwei Cai <cai.lw123@gmail.com>
+Daniel Weindl <daniel.weindl@helmholtz-muenchen.de>
+Isidora Araya <iarayaday@gmail.com>
+Seb Tiburzio <sebtiburzio@gmail.com>
+Victory Omole <vtomole2@gmail.com>
+Abhishek Chaudhary <ac5003@columbia.edu>
+Alexander Zhura <nice.zhura@list.ru>
+Shuai Zhou <shuaivzhou@berkeley.edu>
+Martin Manns <mmanns@gmx.net>
+John Möller <john.moller@outlook.com>
+zzc <1378113190@qq.com>
+Pablo Galindo Salgado <pablogsal@gmail.com>
+Johannes Kasimir <johannes.kasimir@math.lu.se>
+Theodore Dias <theodore.dias@hotmail.co.uk>
+Kaustubh <90597818+kaustubh-765@users.noreply.github.com>
+Idan Pazi <idan.kp@gmail.com>
+Bobby Palmer <bobbyp@umich.edu>
+Saikat Das <saikatdchhe@gmail.com>
+Suman mondal <smondal.qwerty@gmail.com>
+Taylan Sahin <info@taylansahin.net>
+Fabio Luporini <fabio@devitocodes.com>
+Oriel Malihi <orielmalihi1@gmail.com>
+Geetika Vadali <geetika.vadali4@gmail.com>
+Matthias Rettl <matthias.rettl@stud.unileoben.ac.at>
+Mikhail Remnev <maremnev@gmail.com>
+philwillnyc <56197213+philwillnyc@users.noreply.github.com>
+Raphael Lehner <raphael.lehner@gmail.com>
+Harry Mountain <harrymountain1@icloud.com>
+Bhavik Sachdev <b.sachdev1904@gmail.com>
+袁野 (Yuan Ye) <yuanyelele@tutanota.com>
+fazledyn-or <ataf@openrefactory.com>
+mohammedouahman <simofun85@gmail.com>
+K. Kraus <laqueray@googlemail.com>
+Zac Hatfield-Dodds <zac.hatfield.dodds@gmail.com>
+platypus <platypus.computerchip@gmail.com>
+codecruisader <nnisarg55@gmail.com>
+James Whitehead <whiteheadj@gmail.com>
+atharvParlikar <atharvparlikar@gmail.com>
+Ivan Petukhov <satels@gmail.com>
+Augusto Borges <borges.augustoar@gmail.com>
+Han Wei Ang <ang.h.w@u.nus.edu>
+Congxu Yang <u7189828@anu.edu.au>
+Saicharan <62512681+saicharan2804@users.noreply.github.com>
+Arnab Nandi <arnabnandi2002@gmail.com>
+Harrison Oates <48871176+HarrisonOates@users.noreply.github.com>
+Corey Cerovsek <corey@cerovsek.com>
+Harsh Kasat <hkasat@waymore.io>
+omahs <73983677+omahs@users.noreply.github.com>
+Pascal Gitz <pascal.gitz@hotmail.ch>
+Ravindu-Hirimuthugoda <ravindu.18@cse.mrt.ac.lk>
+Sophia Pustova <tripplezzed@gmail.com>
+George Pittock <gpittock4@gmail.com>
+Warren Jacinto <warrenjacinto@gmail.com>
+Sachin Singh <sachinishu02@gmail.com>
+Zedmat <104870914+harshkasat@users.noreply.github.com>
+Soumendra Ganguly <soumendraganguly@gmail.com>
+Samith Karunathilake <55777141+samithkavishke@users.noreply.github.com>
+Viraj Vekaria <virajv5593@gmail.com>
+Shishir Kushwaha <kushwahashishir1112@gmail.com>
+Ankit Kumar Singh <ankitdiswar10@gmail.com>
+Abhishek Kumar <abhishek.nitdelhi@gmail.com>
+Mohak Malviya <mohakmalviya2000@gmail.com>
+Matthias Liesenfeld <116307294+maliesen@users.noreply.github.com>
+dodo <palumbododo@gmail.com>
+Mohamed Rezk <mohrizq895@gmail.com>
+Tommaso Vaccari <05-gesto-follemente@icloud.com>
+Alexis Schotte <alexis.schotte@gmail.com>
+Lauren Yim <31467609+cherryblossom000@users.noreply.github.com>
+Prey Patel <patel.prey@iitgn.ac.in>
+Riccardo Di Girolamo <riccardodigirolamo01@gmail.com>
+Abhishek kumar <kumar325571@gmail.com>
+Sam Lubelsky <sammy56lt@gmail.com>
+Henrique Soares <henrique.c.soares@tecnico.ulisboa.pt>
+Vladimir Sereda <voffch@gmail.com>
+Hwayeon Kang <hwayeonniii@gmail.com>
+Raj Sapale <raj4sapale4@gmail.com>
+Gerald Teschl <gerald.teschl@univie.ac.at>
+Richard Samuel <98638849+samuelard7@users.noreply.github.com>
+HeeJae Chang <hechang@microsoft.com>
+Nick Harder <nharder@umich.edu>
+Ethan DeGuire <ethandeguire@gmail.com>
+Lorenz Winkler <lorenz.winkler@tuwien.ac.at>
+Richard Rodenbusch <rrodenbusch@gmail.com>
+Zhenxu Zhu <xzdlj@outlook.com>
+Mark van Gelder <m.j.vangelder@student.tudelft.nl>
+Mark van Gelder <mvgmvgmvg@live.com>
+Ishan Pandhare <91841626+Ishanned@users.noreply.github.com>
+James A. Preiss <jamesalanpreiss@gmail.com>
+Emile Fourcini <emile.fourcin1@gmail.com>
+Alberto Jiménez Ruiz <Alberto.Jimenez@uclm.es>
+João Bravo <joaocgbravo@tecnico.ulisboa.pt>
+Dean Price <dean1357price1357@gmail.com>
+Edward Z. Yang <ezyang@mit.edu>
+James Titus <titusjames299@gmail.com>
+Zhuoyuan Li <zy.li@stu.pku.edu.cn>
+Hugo Kerstens <hugo@kerstens.me>
+Jan Jancar <johny@neuromancer.sk>
+Andrew Mosson <amosson@yahoo.com>
+Marek Madejski <marekmadejski@yandex.com>
+Gonzalo Tornaría <tornaria@cmat.edu.uy>
+Peter Stahlecker <peter.stahlecker@gmail.com>
+Jean-François B <2589111+jfbu@users.noreply.github.com>
+Zexuan Zhou (Bruce) <zzx498636727@gmail.com>
+George Frolov <gosha@fro.lv>
+Corbet Elkins <corbet286@gmail.com>
+Håkon Kvernmoen <haakon.kvernmoen@gmail.com>
+Muhammad Maaz <mmaaz6004@gmail.com>
+Shishir Kushwaha <138311586+shishir-11@users.noreply.github.com>
+Matt Wang <mattwang44@gmail.com>
+bharatAmeria <21001019007@jcboseust.ac.in>
+Amir Ebrahimi <github@aebrahimi.com>
+Steven Esquea <steven.esquea@irreverente.net>
+Rishabh Kamboj <111004091+VectorNd@users.noreply.github.com>
+Aasim Ali <aasim250205@gmail.com>
+Ivan A. Melnikov <iv@altlinux.org>
+Borek Saheli <boreksaheli@gmail.com>
+Guido Roncarolo <guido.roncarolo@gmail.com>
+Quek Zi Yao <ziyaoqzy2001@gmail.com>
+Roelof Rietbroek <r.rietbroek@utwente.nl>
+MostafaGalal1 <mostafag649.mg@gmail.com>
+Au Huishan <huishan_au@outlook.com>
+Kris Katterjohn <katterjohn@gmail.com>
+Shiyao Guo <mivikq@gmail.com>
+Rushabh Mehta <mehtarushabh2005@gmail.com>
+Temiloluwa Yusuf ytemiloluwa@gmail.com ytemiloluwa <ytemiloluwa@gmail.com>
+Davi Laerte <davilae011@gmail.com>
+Agriya Khetarpal <74401230+agriyakhetarpal@users.noreply.github.com>
+Harshit Gupta <harshithigh2001@gmail.com>
+Praveen Perumal <ppraveen98841@gmail.com>
+Kevin McWhirter <klmcw@yahoo.com>
+Prayag V <v.prayag2005@gmail.com>
+Lucas Kletzander <lucas.kletzander@gmail.com>
+Pratyksh Gupta <pratykshgupta9999@gmail.com>
+Leonardo Mangani <leomangani4@gmail.com>
+Karan Anand <anandkarancompsci@gmail.com>
+Gagan Mishra <simonsimple305@gmail.com>
+Krishnav Bajoria <bajoriakrishnav@gmail.com>
+Matt Ord <matthew.ord1@gmail.com>
+Jatin Bhardwaj <bhardwajjatin093@gmail.com>
+Prashant Tandon <tandonprashant101@gmail.com>
+Paramjit Singh <paramjit1071@gmail.com>
+João Rodrigues <abcjoao@hotmail.com>
+Alejandro García Prada <114813960+AlexGarciaPrada@users.noreply.github.com>
+Matthew Treinish <mtreinish@kortar.org>
+Clayton Rabideau <claytonrabideau@gmail.com>
+Victoria Koval <bictoriakoval16@gmail.com>
+Voaides Negustor Robert <134785947+voaidesr@users.noreply.github.com>
+Ovsk Mendov <bbb23exposed@gmail.com>
+David Brooks <dave@bcs.co.nz>
+Nicholas Laustrup <124007393+nicklaustrup@users.noreply.github.com>
+Harikrishna Srinivasan <harikrishnasri3@gmail.com>
+Mathis Cros <mathis.cros@telecom-paris.fr>
+Arnav Mummineni <45217840+RCoder01@users.noreply.github.com>
+Thangaraju Sibiraj <85477603+t-sibiraj@users.noreply.github.com>
+KJaybhaye <krushnajaybhaye01@gmail.com>
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy-1.14.0.dist-info/licenses/LICENSE b/tool_server/.venv/lib/python3.12/site-packages/sympy-1.14.0.dist-info/licenses/LICENSE
new file mode 100644
index 0000000000000000000000000000000000000000..0744f229d697ca3ed1b1b257bfdb70e3eecf0b9e
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy-1.14.0.dist-info/licenses/LICENSE
@@ -0,0 +1,153 @@
+Copyright (c) 2006-2023 SymPy Development Team
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+  a. Redistributions of source code must retain the above copyright notice,
+     this list of conditions and the following disclaimer.
+  b. Redistributions in binary form must reproduce the above copyright
+     notice, this list of conditions and the following disclaimer in the
+     documentation and/or other materials provided with the distribution.
+  c. Neither the name of SymPy nor the names of its contributors
+     may be used to endorse or promote products derived from this software
+     without specific prior written permission.
+
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+DAMAGE.
+
+--------------------------------------------------------------------------------
+
+Patches that were taken from the Diofant project (https://github.com/diofant/diofant)
+are licensed as:
+
+Copyright (c) 2006-2018 SymPy Development Team,
+              2013-2023 Sergey B Kirpichev
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+  a. Redistributions of source code must retain the above copyright notice,
+     this list of conditions and the following disclaimer.
+  b. Redistributions in binary form must reproduce the above copyright
+     notice, this list of conditions and the following disclaimer in the
+     documentation and/or other materials provided with the distribution.
+  c. Neither the name of Diofant or SymPy nor the names of its contributors
+     may be used to endorse or promote products derived from this software
+     without specific prior written permission.
+
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+DAMAGE.
+
+--------------------------------------------------------------------------------
+
+Submodules taken from the multipledispatch project (https://github.com/mrocklin/multipledispatch)
+are licensed as:
+
+Copyright (c) 2014 Matthew Rocklin
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+  a. Redistributions of source code must retain the above copyright notice,
+     this list of conditions and the following disclaimer.
+  b. Redistributions in binary form must reproduce the above copyright
+     notice, this list of conditions and the following disclaimer in the
+     documentation and/or other materials provided with the distribution.
+  c. Neither the name of multipledispatch nor the names of its contributors
+     may be used to endorse or promote products derived from this software
+     without specific prior written permission.
+
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+DAMAGE.
+
+--------------------------------------------------------------------------------
+
+The files under the directory sympy/parsing/autolev/tests/pydy-example-repo
+are directly copied from PyDy project and are licensed as:
+
+Copyright (c) 2009-2023, PyDy Authors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright
+  notice, this list of conditions and the following disclaimer.
+* Redistributions in binary form must reproduce the above copyright
+  notice, this list of conditions and the following disclaimer in the
+  documentation and/or other materials provided with the distribution.
+* Neither the name of this project nor the names of its contributors may be
+  used to endorse or promote products derived from this software without
+  specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL PYDY AUTHORS BE LIABLE FOR ANY DIRECT,
+INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+--------------------------------------------------------------------------------
+
+The files under the directory sympy/parsing/latex 
+are directly copied from latex2sympy project and are licensed as:
+
+Copyright 2016, latex2sympy
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/__pycache__/__init__.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..447acfdec3f2131086a85f9a98d2e6d8d2b29016
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/__pycache__/__init__.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/__pycache__/aesaracode.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/__pycache__/aesaracode.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f709edc2abb7a74fd9a632122ac57b31c626ee7a
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/__pycache__/aesaracode.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/__pycache__/c.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/__pycache__/c.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a7c1960a8694a6e2ed3ef4a3487607a1b2bc3d84
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/__pycache__/c.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/__pycache__/codeprinter.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/__pycache__/codeprinter.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..63e6de362dd472c300edd2c2cd29ed94cb6812bb
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/__pycache__/codeprinter.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/__pycache__/conventions.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/__pycache__/conventions.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..42a09dbac9618ec253712cdc3618de6c1827ef9f
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/__pycache__/conventions.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/__pycache__/cxx.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/__pycache__/cxx.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a0e72f176973fbafb98f185e3ecb79c416445339
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/__pycache__/cxx.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/__pycache__/defaults.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/__pycache__/defaults.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..e12e2801b209cd938fed44748b616258d50688b3
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/__pycache__/defaults.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/__pycache__/dot.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/__pycache__/dot.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..78cf3985918d20363f0e39c526c3c4059e1e9fa7
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/__pycache__/dot.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/__pycache__/fortran.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/__pycache__/fortran.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..374a500634487d204bb75b88f5013226d7459202
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/__pycache__/fortran.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/__pycache__/glsl.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/__pycache__/glsl.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..cc742d0c5661a0d448c012ab1f726ab3ae6bd9b8
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/__pycache__/glsl.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/__pycache__/gtk.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/__pycache__/gtk.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b2c3b69fca0a3ce5010c3e2b5f75ddaabd65ed90
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/__pycache__/gtk.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/__pycache__/jscode.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/__pycache__/jscode.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..bba1062cc0d87c9e0cfa6e2d7dd0eee066228f7b
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/__pycache__/jscode.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/__pycache__/julia.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/__pycache__/julia.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..02b9c64aa548ed59f449fe9d2bb2b9eda7b5d816
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/__pycache__/julia.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/__pycache__/lambdarepr.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/__pycache__/lambdarepr.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..94e2aa84f5bfeb33970bc799df095bee3cf82a92
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/__pycache__/lambdarepr.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/__pycache__/latex.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/__pycache__/latex.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..bf4108d9e18ec07c161ac32225b51aca8cf6d536
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/__pycache__/latex.cpython-312.pyc
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6b2db65700af667b311efcccfc1f2ea3a15d591b65dfacefd95275a5e4ea7a85
+size 182722
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/__pycache__/llvmjitcode.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/__pycache__/llvmjitcode.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..0891bca1ed56066cd4889856ca347b726c39ce50
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/__pycache__/llvmjitcode.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/__pycache__/maple.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/__pycache__/maple.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..3482159050b86def6c939ff602161c458e4f3d69
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/__pycache__/maple.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/__pycache__/mathematica.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/__pycache__/mathematica.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..758880745b47650be49d86018177451e693132b4
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/__pycache__/mathematica.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/__pycache__/mathml.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/__pycache__/mathml.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c9cfc9ecc124b86943ca618a9ad9742e689dad3e
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/__pycache__/mathml.cpython-312.pyc
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1c7cec3cf94c2d54420ea9827a30c1b28c45dcbb993c1763ee26215b359f43ef
+size 134183
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/__pycache__/numpy.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/__pycache__/numpy.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b7f55a37c9a6b732fbc4f186ff826c8c43aaa511
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/__pycache__/numpy.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/__pycache__/octave.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/__pycache__/octave.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..2f24cb7326c66d6baefb1ca24cde763da2aa3010
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/__pycache__/octave.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/__pycache__/precedence.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/__pycache__/precedence.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..22283a06275afbbd6d7cdb01032b816a3c441ad1
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/__pycache__/precedence.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/__pycache__/preview.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/__pycache__/preview.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..0eacf5efdfc9698cdc060465406560cf85558553
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/__pycache__/preview.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/__pycache__/printer.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/__pycache__/printer.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..fca9159dc4d32dfec176a964e3fd957ddc64758d
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/__pycache__/printer.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/__pycache__/pycode.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/__pycache__/pycode.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..79391c28a42e1274c1b5c6b1368a797de8ceb622
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/__pycache__/pycode.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/__pycache__/python.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/__pycache__/python.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..6db3ed69cf2b26023d2703c38046f1d88e910c0e
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/__pycache__/python.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/__pycache__/pytorch.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/__pycache__/pytorch.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..13e1a1a72f1cb748a370d98f16b4c5565d803cdf
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/__pycache__/pytorch.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/__pycache__/rcode.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/__pycache__/rcode.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..684e773f5dd9c361d7a8701693d1507ebd915600
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/__pycache__/rcode.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/__pycache__/repr.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/__pycache__/repr.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..67747b5cbbe0b2cfec0f91072770da6c886abf38
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/__pycache__/repr.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/__pycache__/rust.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/__pycache__/rust.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..6e1234641cbe894d4685cd6ee9805bb48f4253bb
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/__pycache__/rust.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/__pycache__/smtlib.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/__pycache__/smtlib.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..74d4a222eebe724e31bd9e89f98a3bc5cf4e3d4f
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/__pycache__/smtlib.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/__pycache__/str.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/__pycache__/str.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a32914a8f5ce142bf4d43963e5a8cfb26a8385d5
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/__pycache__/str.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/__pycache__/tableform.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/__pycache__/tableform.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..cfea2a1397f49265da544f25817d0583626e98cd
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/__pycache__/tableform.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/__pycache__/tensorflow.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/__pycache__/tensorflow.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..efa59aa2de4ac1573599dc31f5e5d1a4e0e20c3a
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/__pycache__/tensorflow.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/__pycache__/theanocode.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/__pycache__/theanocode.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..103e987c2cfbf7ff2ec8a69f06a66238b1a3eb93
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/__pycache__/theanocode.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/__pycache__/tree.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/__pycache__/tree.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..fac7dcb3b6d35e2acc9d280ce5e98b4f214b38f3
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/__pycache__/tree.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/pretty/__pycache__/__init__.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/pretty/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..2775309023446a8720ff05e07ced2da8b7d64838
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/pretty/__pycache__/__init__.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/pretty/__pycache__/pretty.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/pretty/__pycache__/pretty.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..46a5ed8193a1ab81931954e8d719bdf9b1b0b41f
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/pretty/__pycache__/pretty.cpython-312.pyc
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d4ba0d22db35515d82f05d16b710c27daef99900f2dfc5354091eac2cf8aaf0c
+size 156846
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/pretty/__pycache__/pretty_symbology.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/pretty/__pycache__/pretty_symbology.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..93dd88c0eaaac068b9f287704dee619eb5bbcbf1
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/pretty/__pycache__/pretty_symbology.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/pretty/__pycache__/stringpict.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/pretty/__pycache__/stringpict.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..cfaf439ef70c89e04683ab97954514af1218cd99
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/pretty/__pycache__/stringpict.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/pretty/tests/__init__.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/pretty/tests/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/pretty/tests/__pycache__/__init__.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/pretty/tests/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..91df09537b642c919760cfbfcf9605d8ac0d9289
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/pretty/tests/__pycache__/__init__.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/pretty/tests/__pycache__/test_pretty.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/pretty/tests/__pycache__/test_pretty.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..1a21259cbca82b20a08b4ae8d74ae7c883107683
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/pretty/tests/__pycache__/test_pretty.cpython-312.pyc
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:65595bbd5823680f025a0f15a0f3e6a968c01c363f633f8085198cf89cc565d6
+size 243922
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/pretty/tests/test_pretty.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/pretty/tests/test_pretty.py
new file mode 100644
index 0000000000000000000000000000000000000000..1cca79bd1dc5c3ba81483c8fe2e87c35926d1b94
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/pretty/tests/test_pretty.py
@@ -0,0 +1,7972 @@
+# -*- coding: utf-8 -*-
+from sympy.concrete.products import Product
+from sympy.concrete.summations import Sum
+from sympy.core.add import Add
+from sympy.core.basic import Basic
+from sympy.core.containers import (Dict, Tuple)
+from sympy.core.function import (Derivative, Function, Lambda, Subs)
+from sympy.core.mul import Mul
+from sympy.core import (EulerGamma, GoldenRatio, Catalan)
+from sympy.core.numbers import (I, Rational, oo, pi)
+from sympy.core.power import Pow
+from sympy.core.relational import (Eq, Ge, Gt, Le, Lt, Ne)
+from sympy.core.singleton import S
+from sympy.core.symbol import (Symbol, symbols)
+from sympy.functions.elementary.complexes import conjugate
+from sympy.functions.elementary.exponential import LambertW
+from sympy.functions.special.bessel import (airyai, airyaiprime, airybi, airybiprime)
+from sympy.functions.special.delta_functions import Heaviside
+from sympy.functions.special.error_functions import (fresnelc, fresnels)
+from sympy.functions.special.singularity_functions import SingularityFunction
+from sympy.functions.special.zeta_functions import dirichlet_eta
+from sympy.geometry.line import (Ray, Segment)
+from sympy.integrals.integrals import Integral
+from sympy.logic.boolalg import (And, Equivalent, ITE, Implies, Nand, Nor, Not, Or, Xor)
+from sympy.matrices.dense import (Matrix, diag)
+from sympy.matrices.expressions.slice import MatrixSlice
+from sympy.matrices.expressions.trace import Trace
+from sympy.polys.domains.finitefield import FF
+from sympy.polys.domains.integerring import ZZ
+from sympy.polys.domains.rationalfield import QQ
+from sympy.polys.domains.realfield import RR
+from sympy.polys.orderings import (grlex, ilex)
+from sympy.polys.polytools import groebner
+from sympy.polys.rootoftools import (RootSum, rootof)
+from sympy.series.formal import fps
+from sympy.series.fourier import fourier_series
+from sympy.series.limits import Limit
+from sympy.series.order import O
+from sympy.series.sequences import (SeqAdd, SeqFormula, SeqMul, SeqPer)
+from sympy.sets.contains import Contains
+from sympy.sets.fancysets import Range
+from sympy.sets.sets import (Complement, FiniteSet, Intersection, Interval, Union)
+from sympy.codegen.ast import (Assignment, AddAugmentedAssignment,
+    SubAugmentedAssignment, MulAugmentedAssignment, DivAugmentedAssignment, ModAugmentedAssignment)
+from sympy.core.expr import UnevaluatedExpr
+from sympy.physics.quantum.trace import Tr
+
+from sympy.functions import (Abs, Chi, Ci, Ei, KroneckerDelta,
+    Piecewise, Shi, Si, atan2, beta, binomial, catalan, ceiling, cos,
+    euler, exp, expint, factorial, factorial2, floor, gamma, hyper, log,
+    meijerg, sin, sqrt, subfactorial, tan, uppergamma, lerchphi, polylog,
+    elliptic_k, elliptic_f, elliptic_e, elliptic_pi, DiracDelta, bell,
+    bernoulli, fibonacci, tribonacci, lucas, stieltjes, mathieuc, mathieus,
+    mathieusprime, mathieucprime)
+
+from sympy.matrices import (Adjoint, Inverse, MatrixSymbol, Transpose,
+                            KroneckerProduct, BlockMatrix, OneMatrix, ZeroMatrix)
+from sympy.matrices.expressions import hadamard_power
+
+from sympy.physics import mechanics
+from sympy.physics.control.lti import (TransferFunction, Feedback, TransferFunctionMatrix,
+    Series, Parallel, MIMOSeries, MIMOParallel, MIMOFeedback, StateSpace)
+from sympy.physics.units import joule, degree
+from sympy.printing.pretty import pprint, pretty as xpretty
+from sympy.printing.pretty.pretty_symbology import center_accent, is_combining, center
+from sympy.sets.conditionset import ConditionSet
+
+from sympy.sets import ImageSet, ProductSet
+from sympy.sets.setexpr import SetExpr
+from sympy.stats.crv_types import Normal
+from sympy.stats.symbolic_probability import (Covariance, Expectation,
+                                              Probability, Variance)
+from sympy.tensor.array import (ImmutableDenseNDimArray, ImmutableSparseNDimArray,
+                                MutableDenseNDimArray, MutableSparseNDimArray, tensorproduct)
+from sympy.tensor.functions import TensorProduct
+from sympy.tensor.tensor import (TensorIndexType, tensor_indices, TensorHead,
+                                 TensorElement, tensor_heads)
+
+from sympy.testing.pytest import raises, _both_exp_pow, warns_deprecated_sympy
+
+from sympy.vector import CoordSys3D, Gradient, Curl, Divergence, Dot, Cross, Laplacian
+
+
+
+import sympy as sym
+class lowergamma(sym.lowergamma):
+    pass   # testing notation inheritance by a subclass with same name
+
+a, b, c, d, x, y, z, k, n, s, p = symbols('a,b,c,d,x,y,z,k,n,s,p')
+f = Function("f")
+th = Symbol('theta')
+ph = Symbol('phi')
+
+"""
+Expressions whose pretty-printing is tested here:
+(A '#' to the right of an expression indicates that its various acceptable
+orderings are accounted for by the tests.)
+
+
+BASIC EXPRESSIONS:
+
+oo
+(x**2)
+1/x
+y*x**-2
+x**Rational(-5,2)
+(-2)**x
+Pow(3, 1, evaluate=False)
+(x**2 + x + 1)  #
+1-x  #
+1-2*x  #
+x/y
+-x/y
+(x+2)/y  #
+(1+x)*y  #3
+-5*x/(x+10)  # correct placement of negative sign
+1 - Rational(3,2)*(x+1)
+-(-x + 5)*(-x - 2*sqrt(2) + 5) - (-y + 5)*(-y + 5) # issue 5524
+
+
+ORDERING:
+
+x**2 + x + 1
+1 - x
+1 - 2*x
+2*x**4 + y**2 - x**2 + y**3
+
+
+RELATIONAL:
+
+Eq(x, y)
+Lt(x, y)
+Gt(x, y)
+Le(x, y)
+Ge(x, y)
+Ne(x/(y+1), y**2)  #
+
+
+RATIONAL NUMBERS:
+
+y*x**-2
+y**Rational(3,2) * x**Rational(-5,2)
+sin(x)**3/tan(x)**2
+
+
+FUNCTIONS (ABS, CONJ, EXP, FUNCTION BRACES, FACTORIAL, FLOOR, CEILING):
+
+(2*x + exp(x))  #
+Abs(x)
+Abs(x/(x**2+1)) #
+Abs(1 / (y - Abs(x)))
+factorial(n)
+factorial(2*n)
+subfactorial(n)
+subfactorial(2*n)
+factorial(factorial(factorial(n)))
+factorial(n+1) #
+conjugate(x)
+conjugate(f(x+1)) #
+f(x)
+f(x, y)
+f(x/(y+1), y) #
+f(x**x**x**x**x**x)
+sin(x)**2
+conjugate(a+b*I)
+conjugate(exp(a+b*I))
+conjugate( f(1 + conjugate(f(x))) ) #
+f(x/(y+1), y)  # denom of first arg
+floor(1 / (y - floor(x)))
+ceiling(1 / (y - ceiling(x)))
+
+
+SQRT:
+
+sqrt(2)
+2**Rational(1,3)
+2**Rational(1,1000)
+sqrt(x**2 + 1)
+(1 + sqrt(5))**Rational(1,3)
+2**(1/x)
+sqrt(2+pi)
+(2+(1+x**2)/(2+x))**Rational(1,4)+(1+x**Rational(1,1000))/sqrt(3+x**2)
+
+
+DERIVATIVES:
+
+Derivative(log(x), x, evaluate=False)
+Derivative(log(x), x, evaluate=False) + x  #
+Derivative(log(x) + x**2, x, y, evaluate=False)
+Derivative(2*x*y, y, x, evaluate=False) + x**2  #
+beta(alpha).diff(alpha)
+
+
+INTEGRALS:
+
+Integral(log(x), x)
+Integral(x**2, x)
+Integral((sin(x))**2 / (tan(x))**2)
+Integral(x**(2**x), x)
+Integral(x**2, (x,1,2))
+Integral(x**2, (x,Rational(1,2),10))
+Integral(x**2*y**2, x,y)
+Integral(x**2, (x, None, 1))
+Integral(x**2, (x, 1, None))
+Integral(sin(th)/cos(ph), (th,0,pi), (ph, 0, 2*pi))
+
+
+MATRICES:
+
+Matrix([[x**2+1, 1], [y, x+y]])  #
+Matrix([[x/y, y, th], [0, exp(I*k*ph), 1]])
+
+
+PIECEWISE:
+
+Piecewise((x,x<1),(x**2,True))
+
+ITE:
+
+ITE(x, y, z)
+
+SEQUENCES (TUPLES, LISTS, DICTIONARIES):
+
+()
+[]
+{}
+(1/x,)
+[x**2, 1/x, x, y, sin(th)**2/cos(ph)**2]
+(x**2, 1/x, x, y, sin(th)**2/cos(ph)**2)
+{x: sin(x)}
+{1/x: 1/y, x: sin(x)**2}  #
+[x**2]
+(x**2,)
+{x**2: 1}
+
+
+LIMITS:
+
+Limit(x, x, oo)
+Limit(x**2, x, 0)
+Limit(1/x, x, 0)
+Limit(sin(x)/x, x, 0)
+
+
+UNITS:
+
+joule => kg*m**2/s
+
+
+SUBS:
+
+Subs(f(x), x, ph**2)
+Subs(f(x).diff(x), x, 0)
+Subs(f(x).diff(x)/y, (x, y), (0, Rational(1, 2)))
+
+
+ORDER:
+
+O(1)
+O(1/x)
+O(x**2 + y**2)
+
+"""
+
+
+def pretty(expr, order=None):
+    """ASCII pretty-printing"""
+    return xpretty(expr, order=order, use_unicode=False, wrap_line=False)
+
+
+def upretty(expr, order=None):
+    """Unicode pretty-printing"""
+    return xpretty(expr, order=order, use_unicode=True, wrap_line=False)
+
+
+def test_pretty_ascii_str():
+    assert pretty( 'xxx' ) == 'xxx'
+    assert pretty( "xxx" ) == 'xxx'
+    assert pretty( 'xxx\'xxx' ) == 'xxx\'xxx'
+    assert pretty( 'xxx"xxx' ) == 'xxx\"xxx'
+    assert pretty( 'xxx\"xxx' ) == 'xxx\"xxx'
+    assert pretty( "xxx'xxx" ) == 'xxx\'xxx'
+    assert pretty( "xxx\'xxx" ) == 'xxx\'xxx'
+    assert pretty( "xxx\"xxx" ) == 'xxx\"xxx'
+    assert pretty( "xxx\"xxx\'xxx" ) == 'xxx"xxx\'xxx'
+    assert pretty( "xxx\nxxx" ) == 'xxx\nxxx'
+
+
+def test_pretty_unicode_str():
+    assert pretty( 'xxx' ) == 'xxx'
+    assert pretty( 'xxx' ) == 'xxx'
+    assert pretty( 'xxx\'xxx' ) == 'xxx\'xxx'
+    assert pretty( 'xxx"xxx' ) == 'xxx\"xxx'
+    assert pretty( 'xxx\"xxx' ) == 'xxx\"xxx'
+    assert pretty( "xxx'xxx" ) == 'xxx\'xxx'
+    assert pretty( "xxx\'xxx" ) == 'xxx\'xxx'
+    assert pretty( "xxx\"xxx" ) == 'xxx\"xxx'
+    assert pretty( "xxx\"xxx\'xxx" ) == 'xxx"xxx\'xxx'
+    assert pretty( "xxx\nxxx" ) == 'xxx\nxxx'
+
+
+def test_upretty_greek():
+    assert upretty( oo ) == '∞'
+    assert upretty( Symbol('alpha^+_1') ) == 'α⁺₁'
+    assert upretty( Symbol('beta') ) == 'β'
+    assert upretty(Symbol('lambda')) == 'λ'
+
+
+def test_upretty_multiindex():
+    assert upretty( Symbol('beta12') ) == 'β₁₂'
+    assert upretty( Symbol('Y00') ) == 'Y₀₀'
+    assert upretty( Symbol('Y_00') ) == 'Y₀₀'
+    assert upretty( Symbol('F^+-') ) == 'F⁺⁻'
+
+
+def test_upretty_sub_super():
+    assert upretty( Symbol('beta_1_2') ) == 'β₁ ₂'
+    assert upretty( Symbol('beta^1^2') ) == 'β¹ ²'
+    assert upretty( Symbol('beta_1^2') ) == 'β²₁'
+    assert upretty( Symbol('beta_10_20') ) == 'β₁₀ ₂₀'
+    assert upretty( Symbol('beta_ax_gamma^i') ) == 'βⁱₐₓ ᵧ'
+    assert upretty( Symbol("F^1^2_3_4") ) == 'F¹ ²₃ ₄'
+    assert upretty( Symbol("F_1_2^3^4") ) == 'F³ ⁴₁ ₂'
+    assert upretty( Symbol("F_1_2_3_4") ) == 'F₁ ₂ ₃ ₄'
+    assert upretty( Symbol("F^1^2^3^4") ) == 'F¹ ² ³ ⁴'
+
+
+def test_upretty_subs_missing_in_24():
+    assert upretty( Symbol('F_beta') ) == 'Fᵦ'
+    assert upretty( Symbol('F_gamma') ) == 'Fᵧ'
+    assert upretty( Symbol('F_rho') ) == 'Fᵨ'
+    assert upretty( Symbol('F_phi') ) == 'Fᵩ'
+    assert upretty( Symbol('F_chi') ) == 'Fᵪ'
+
+    assert upretty( Symbol('F_a') ) == 'Fₐ'
+    assert upretty( Symbol('F_e') ) == 'Fₑ'
+    assert upretty( Symbol('F_i') ) == 'Fᵢ'
+    assert upretty( Symbol('F_o') ) == 'Fₒ'
+    assert upretty( Symbol('F_u') ) == 'Fᵤ'
+    assert upretty( Symbol('F_r') ) == 'Fᵣ'
+    assert upretty( Symbol('F_v') ) == 'Fᵥ'
+    assert upretty( Symbol('F_x') ) == 'Fₓ'
+
+
+def test_missing_in_2X_issue_9047():
+    assert upretty( Symbol('F_h') ) == 'Fₕ'
+    assert upretty( Symbol('F_k') ) == 'Fₖ'
+    assert upretty( Symbol('F_l') ) == 'Fₗ'
+    assert upretty( Symbol('F_m') ) == 'Fₘ'
+    assert upretty( Symbol('F_n') ) == 'Fₙ'
+    assert upretty( Symbol('F_p') ) == 'Fₚ'
+    assert upretty( Symbol('F_s') ) == 'Fₛ'
+    assert upretty( Symbol('F_t') ) == 'Fₜ'
+
+
+def test_upretty_modifiers():
+    # Accents
+    assert upretty( Symbol('Fmathring') ) == 'F̊'
+    assert upretty( Symbol('Fddddot') ) == 'F⃜'
+    assert upretty( Symbol('Fdddot') ) == 'F⃛'
+    assert upretty( Symbol('Fddot') ) == 'F̈'
+    assert upretty( Symbol('Fdot') ) == 'Ḟ'
+    assert upretty( Symbol('Fcheck') ) == 'F̌'
+    assert upretty( Symbol('Fbreve') ) == 'F̆'
+    assert upretty( Symbol('Facute') ) == 'F́'
+    assert upretty( Symbol('Fgrave') ) == 'F̀'
+    assert upretty( Symbol('Ftilde') ) == 'F̃'
+    assert upretty( Symbol('Fhat') ) == 'F̂'
+    assert upretty( Symbol('Fbar') ) == 'F̅'
+    assert upretty( Symbol('Fvec') ) == 'F⃗'
+    assert upretty( Symbol('Fprime') ) == 'F′'
+    assert upretty( Symbol('Fprm') ) == 'F′'
+    # No faces are actually implemented, but test to make sure the modifiers are stripped
+    assert upretty( Symbol('Fbold') ) == 'Fbold'
+    assert upretty( Symbol('Fbm') ) == 'Fbm'
+    assert upretty( Symbol('Fcal') ) == 'Fcal'
+    assert upretty( Symbol('Fscr') ) == 'Fscr'
+    assert upretty( Symbol('Ffrak') ) == 'Ffrak'
+    # Brackets
+    assert upretty( Symbol('Fnorm') ) == '‖F‖'
+    assert upretty( Symbol('Favg') ) == '⟨F⟩'
+    assert upretty( Symbol('Fabs') ) == '|F|'
+    assert upretty( Symbol('Fmag') ) == '|F|'
+    # Combinations
+    assert upretty( Symbol('xvecdot') ) == 'x⃗̇'
+    assert upretty( Symbol('xDotVec') ) == 'ẋ⃗'
+    assert upretty( Symbol('xHATNorm') ) == '‖x̂‖'
+    assert upretty( Symbol('xMathring_yCheckPRM__zbreveAbs') ) == 'x̊_y̌′__|z̆|'
+    assert upretty( Symbol('alphadothat_nVECDOT__tTildePrime') ) == 'α̇̂_n⃗̇__t̃′'
+    assert upretty( Symbol('x_dot') ) == 'x_dot'
+    assert upretty( Symbol('x__dot') ) == 'x__dot'
+
+
+def test_pretty_Cycle():
+    from sympy.combinatorics.permutations import Cycle
+    assert pretty(Cycle(1, 2)) == '(1 2)'
+    assert pretty(Cycle(2)) == '(2)'
+    assert pretty(Cycle(1, 3)(4, 5)) == '(1 3)(4 5)'
+    assert pretty(Cycle()) == '()'
+
+
+def test_pretty_Permutation():
+    from sympy.combinatorics.permutations import Permutation
+    p1 = Permutation(1, 2)(3, 4)
+    assert xpretty(p1, perm_cyclic=True, use_unicode=True) == "(1 2)(3 4)"
+    assert xpretty(p1, perm_cyclic=True, use_unicode=False) == "(1 2)(3 4)"
+    assert xpretty(p1, perm_cyclic=False, use_unicode=True) == \
+    '⎛0 1 2 3 4⎞\n'\
+    '⎝0 2 1 4 3⎠'
+    assert xpretty(p1, perm_cyclic=False, use_unicode=False) == \
+    "/0 1 2 3 4\\\n"\
+    "\\0 2 1 4 3/"
+
+    with warns_deprecated_sympy():
+        old_print_cyclic = Permutation.print_cyclic
+        Permutation.print_cyclic = False
+        assert xpretty(p1, use_unicode=True) == \
+        '⎛0 1 2 3 4⎞\n'\
+        '⎝0 2 1 4 3⎠'
+        assert xpretty(p1, use_unicode=False) == \
+        "/0 1 2 3 4\\\n"\
+        "\\0 2 1 4 3/"
+        Permutation.print_cyclic = old_print_cyclic
+
+
+def test_pretty_basic():
+    assert pretty( -Rational(1)/2 ) == '-1/2'
+    assert pretty( -Rational(13)/22 ) == \
+"""\
+-13 \n\
+----\n\
+ 22 \
+"""
+    expr = oo
+    ascii_str = \
+"""\
+oo\
+"""
+    ucode_str = \
+"""\
+∞\
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = (x**2)
+    ascii_str = \
+"""\
+ 2\n\
+x \
+"""
+    ucode_str = \
+"""\
+ 2\n\
+x \
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = 1/x
+    ascii_str = \
+"""\
+1\n\
+-\n\
+x\
+"""
+    ucode_str = \
+"""\
+1\n\
+─\n\
+x\
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    # not the same as 1/x
+    expr = x**-1.0
+    ascii_str = \
+"""\
+ -1.0\n\
+x    \
+"""
+    ucode_str = \
+"""\
+ -1.0\n\
+x    \
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    # see issue #2860
+    expr = Pow(S(2), -1.0, evaluate=False)
+    ascii_str = \
+"""\
+ -1.0\n\
+2    \
+"""
+    ucode_str = \
+"""\
+ -1.0\n\
+2    \
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = y*x**-2
+    ascii_str = \
+"""\
+y \n\
+--\n\
+ 2\n\
+x \
+"""
+    ucode_str = \
+"""\
+y \n\
+──\n\
+ 2\n\
+x \
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    #see issue #14033
+    expr = x**Rational(1, 3)
+    ascii_str = \
+"""\
+ 1/3\n\
+x   \
+"""
+    ucode_str = \
+"""\
+ 1/3\n\
+x   \
+"""
+    assert xpretty(expr, use_unicode=False, wrap_line=False,\
+    root_notation = False) == ascii_str
+    assert xpretty(expr, use_unicode=True, wrap_line=False,\
+    root_notation = False) == ucode_str
+
+    expr = x**Rational(-5, 2)
+    ascii_str = \
+"""\
+ 1  \n\
+----\n\
+ 5/2\n\
+x   \
+"""
+    ucode_str = \
+"""\
+ 1  \n\
+────\n\
+ 5/2\n\
+x   \
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = (-2)**x
+    ascii_str = \
+"""\
+    x\n\
+(-2) \
+"""
+    ucode_str = \
+"""\
+    x\n\
+(-2) \
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    # See issue 4923
+    expr = Pow(3, 1, evaluate=False)
+    ascii_str = \
+"""\
+ 1\n\
+3 \
+"""
+    ucode_str = \
+"""\
+ 1\n\
+3 \
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = (x**2 + x + 1)
+    ascii_str_1 = \
+"""\
+         2\n\
+1 + x + x \
+"""
+    ascii_str_2 = \
+"""\
+ 2        \n\
+x  + x + 1\
+"""
+    ascii_str_3 = \
+"""\
+ 2        \n\
+x  + 1 + x\
+"""
+    ucode_str_1 = \
+"""\
+         2\n\
+1 + x + x \
+"""
+    ucode_str_2 = \
+"""\
+ 2        \n\
+x  + x + 1\
+"""
+    ucode_str_3 = \
+"""\
+ 2        \n\
+x  + 1 + x\
+"""
+    assert pretty(expr) in [ascii_str_1, ascii_str_2, ascii_str_3]
+    assert upretty(expr) in [ucode_str_1, ucode_str_2, ucode_str_3]
+
+    expr = 1 - x
+    ascii_str_1 = \
+"""\
+1 - x\
+"""
+    ascii_str_2 = \
+"""\
+-x + 1\
+"""
+    ucode_str_1 = \
+"""\
+1 - x\
+"""
+    ucode_str_2 = \
+"""\
+-x + 1\
+"""
+    assert pretty(expr) in [ascii_str_1, ascii_str_2]
+    assert upretty(expr) in [ucode_str_1, ucode_str_2]
+
+    expr = 1 - 2*x
+    ascii_str_1 = \
+"""\
+1 - 2*x\
+"""
+    ascii_str_2 = \
+"""\
+-2*x + 1\
+"""
+    ucode_str_1 = \
+"""\
+1 - 2⋅x\
+"""
+    ucode_str_2 = \
+"""\
+-2⋅x + 1\
+"""
+    assert pretty(expr) in [ascii_str_1, ascii_str_2]
+    assert upretty(expr) in [ucode_str_1, ucode_str_2]
+
+    expr = x/y
+    ascii_str = \
+"""\
+x\n\
+-\n\
+y\
+"""
+    ucode_str = \
+"""\
+x\n\
+─\n\
+y\
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = -x/y
+    ascii_str = \
+"""\
+-x \n\
+---\n\
+ y \
+"""
+    ucode_str = \
+"""\
+-x \n\
+───\n\
+ y \
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = (x + 2)/y
+    ascii_str_1 = \
+"""\
+2 + x\n\
+-----\n\
+  y  \
+"""
+    ascii_str_2 = \
+"""\
+x + 2\n\
+-----\n\
+  y  \
+"""
+    ucode_str_1 = \
+"""\
+2 + x\n\
+─────\n\
+  y  \
+"""
+    ucode_str_2 = \
+"""\
+x + 2\n\
+─────\n\
+  y  \
+"""
+    assert pretty(expr) in [ascii_str_1, ascii_str_2]
+    assert upretty(expr) in [ucode_str_1, ucode_str_2]
+
+    expr = (1 + x)*y
+    ascii_str_1 = \
+"""\
+y*(1 + x)\
+"""
+    ascii_str_2 = \
+"""\
+(1 + x)*y\
+"""
+    ascii_str_3 = \
+"""\
+y*(x + 1)\
+"""
+    ucode_str_1 = \
+"""\
+y⋅(1 + x)\
+"""
+    ucode_str_2 = \
+"""\
+(1 + x)⋅y\
+"""
+    ucode_str_3 = \
+"""\
+y⋅(x + 1)\
+"""
+    assert pretty(expr) in [ascii_str_1, ascii_str_2, ascii_str_3]
+    assert upretty(expr) in [ucode_str_1, ucode_str_2, ucode_str_3]
+
+    # Test for correct placement of the negative sign
+    expr = -5*x/(x + 10)
+    ascii_str_1 = \
+"""\
+-5*x  \n\
+------\n\
+10 + x\
+"""
+    ascii_str_2 = \
+"""\
+-5*x  \n\
+------\n\
+x + 10\
+"""
+    ucode_str_1 = \
+"""\
+-5⋅x  \n\
+──────\n\
+10 + x\
+"""
+    ucode_str_2 = \
+"""\
+-5⋅x  \n\
+──────\n\
+x + 10\
+"""
+    assert pretty(expr) in [ascii_str_1, ascii_str_2]
+    assert upretty(expr) in [ucode_str_1, ucode_str_2]
+
+    expr = -S.Half - 3*x
+    ascii_str = \
+"""\
+-3*x - 1/2\
+"""
+    ucode_str = \
+"""\
+-3⋅x - 1/2\
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = S.Half - 3*x
+    ascii_str = \
+"""\
+1/2 - 3*x\
+"""
+    ucode_str = \
+"""\
+1/2 - 3⋅x\
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = -S.Half - 3*x/2
+    ascii_str = \
+"""\
+  3*x   1\n\
+- --- - -\n\
+   2    2\
+"""
+    ucode_str = \
+"""\
+  3⋅x   1\n\
+- ─── - ─\n\
+   2    2\
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = S.Half - 3*x/2
+    ascii_str = \
+"""\
+1   3*x\n\
+- - ---\n\
+2    2 \
+"""
+    ucode_str = \
+"""\
+1   3⋅x\n\
+─ - ───\n\
+2    2 \
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+
+def test_negative_fractions():
+    expr = -x/y
+    ascii_str =\
+"""\
+-x \n\
+---\n\
+ y \
+"""
+    ucode_str =\
+"""\
+-x \n\
+───\n\
+ y \
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+    expr = -x*z/y
+    ascii_str =\
+"""\
+-x*z \n\
+-----\n\
+  y  \
+"""
+    ucode_str =\
+"""\
+-x⋅z \n\
+─────\n\
+  y  \
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+    expr = x**2/y
+    ascii_str =\
+"""\
+ 2\n\
+x \n\
+--\n\
+y \
+"""
+    ucode_str =\
+"""\
+ 2\n\
+x \n\
+──\n\
+y \
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+    expr = -x**2/y
+    ascii_str =\
+"""\
+  2 \n\
+-x  \n\
+----\n\
+ y  \
+"""
+    ucode_str =\
+"""\
+  2 \n\
+-x  \n\
+────\n\
+ y  \
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+    expr = -x/(y*z)
+    ascii_str =\
+"""\
+-x \n\
+---\n\
+y*z\
+"""
+    ucode_str =\
+"""\
+-x \n\
+───\n\
+y⋅z\
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+    expr = -a/y**2
+    ascii_str =\
+"""\
+-a \n\
+---\n\
+ 2 \n\
+y  \
+"""
+    ucode_str =\
+"""\
+-a \n\
+───\n\
+ 2 \n\
+y  \
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+    expr = y**(-a/b)
+    ascii_str =\
+"""\
+ -a \n\
+ ---\n\
+  b \n\
+y   \
+"""
+    ucode_str =\
+"""\
+ -a \n\
+ ───\n\
+  b \n\
+y   \
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+    expr = -1/y**2
+    ascii_str =\
+"""\
+-1 \n\
+---\n\
+ 2 \n\
+y  \
+"""
+    ucode_str =\
+"""\
+-1 \n\
+───\n\
+ 2 \n\
+y  \
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+    expr = -10/b**2
+    ascii_str =\
+"""\
+-10 \n\
+----\n\
+  2 \n\
+ b  \
+"""
+    ucode_str =\
+"""\
+-10 \n\
+────\n\
+  2 \n\
+ b  \
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+    expr = Rational(-200, 37)
+    ascii_str =\
+"""\
+-200 \n\
+-----\n\
+ 37  \
+"""
+    ucode_str =\
+"""\
+-200 \n\
+─────\n\
+ 37  \
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+
+def test_Mul():
+    expr = Mul(0, 1, evaluate=False)
+    assert pretty(expr) == "0*1"
+    assert upretty(expr) == "0⋅1"
+    expr = Mul(1, 0, evaluate=False)
+    assert pretty(expr) == "1*0"
+    assert upretty(expr) == "1⋅0"
+    expr = Mul(1, 1, evaluate=False)
+    assert pretty(expr) == "1*1"
+    assert upretty(expr) == "1⋅1"
+    expr = Mul(1, 1, 1, evaluate=False)
+    assert pretty(expr) == "1*1*1"
+    assert upretty(expr) == "1⋅1⋅1"
+    expr = Mul(1, 2, evaluate=False)
+    assert pretty(expr) == "1*2"
+    assert upretty(expr) == "1⋅2"
+    expr = Add(0, 1, evaluate=False)
+    assert pretty(expr) == "0 + 1"
+    assert upretty(expr) == "0 + 1"
+    expr = Mul(1, 1, 2, evaluate=False)
+    assert pretty(expr) == "1*1*2"
+    assert upretty(expr) == "1⋅1⋅2"
+    expr = Add(0, 0, 1, evaluate=False)
+    assert pretty(expr) == "0 + 0 + 1"
+    assert upretty(expr) == "0 + 0 + 1"
+    expr = Mul(1, -1, evaluate=False)
+    assert pretty(expr) == "1*-1"
+    assert upretty(expr) == "1⋅-1"
+    expr = Mul(1.0, x, evaluate=False)
+    assert pretty(expr) == "1.0*x"
+    assert upretty(expr) == "1.0⋅x"
+    expr = Mul(1, 1, 2, 3, x, evaluate=False)
+    assert pretty(expr) == "1*1*2*3*x"
+    assert upretty(expr) == "1⋅1⋅2⋅3⋅x"
+    expr = Mul(-1, 1, evaluate=False)
+    assert pretty(expr) == "-1*1"
+    assert upretty(expr) == "-1⋅1"
+    expr = Mul(4, 3, 2, 1, 0, y, x, evaluate=False)
+    assert pretty(expr) == "4*3*2*1*0*y*x"
+    assert upretty(expr) == "4⋅3⋅2⋅1⋅0⋅y⋅x"
+    expr = Mul(4, 3, 2, 1+z, 0, y, x, evaluate=False)
+    assert pretty(expr) == "4*3*2*(z + 1)*0*y*x"
+    assert upretty(expr) == "4⋅3⋅2⋅(z + 1)⋅0⋅y⋅x"
+    expr = Mul(Rational(2, 3), Rational(5, 7), evaluate=False)
+    assert pretty(expr) == "2/3*5/7"
+    assert upretty(expr) == "2/3⋅5/7"
+    expr = Mul(x + y, Rational(1, 2), evaluate=False)
+    assert pretty(expr) == "(x + y)*1/2"
+    assert upretty(expr) == "(x + y)⋅1/2"
+    expr = Mul(Rational(1, 2), x + y, evaluate=False)
+    assert pretty(expr) == "x + y\n-----\n  2  "
+    assert upretty(expr) == "x + y\n─────\n  2  "
+    expr = Mul(S.One, x + y, evaluate=False)
+    assert pretty(expr) == "1*(x + y)"
+    assert upretty(expr) == "1⋅(x + y)"
+    expr = Mul(x - y, S.One, evaluate=False)
+    assert pretty(expr) == "(x - y)*1"
+    assert upretty(expr) == "(x - y)⋅1"
+    expr = Mul(Rational(1, 2), x - y, S.One, x + y, evaluate=False)
+    assert pretty(expr) == "1/2*(x - y)*1*(x + y)"
+    assert upretty(expr) == "1/2⋅(x - y)⋅1⋅(x + y)"
+    expr = Mul(x + y, Rational(3, 4), S.One, y - z, evaluate=False)
+    assert pretty(expr) == "(x + y)*3/4*1*(y - z)"
+    assert upretty(expr) == "(x + y)⋅3/4⋅1⋅(y - z)"
+    expr = Mul(x + y, Rational(1, 1), Rational(3, 4), Rational(5, 6),evaluate=False)
+    assert pretty(expr) == "(x + y)*1*3/4*5/6"
+    assert upretty(expr) == "(x + y)⋅1⋅3/4⋅5/6"
+    expr = Mul(Rational(3, 4), x + y, S.One, y - z, evaluate=False)
+    assert pretty(expr) == "3/4*(x + y)*1*(y - z)"
+    assert upretty(expr) == "3/4⋅(x + y)⋅1⋅(y - z)"
+
+
+def test_issue_5524():
+    assert pretty(-(-x + 5)*(-x - 2*sqrt(2) + 5) - (-y + 5)*(-y + 5)) == \
+"""\
+         2           /         ___    \\\n\
+- (5 - y)  + (x - 5)*\\-x - 2*\\/ 2  + 5/\
+"""
+
+    assert upretty(-(-x + 5)*(-x - 2*sqrt(2) + 5) - (-y + 5)*(-y + 5)) == \
+"""\
+         2                          \n\
+- (5 - y)  + (x - 5)⋅(-x - 2⋅√2 + 5)\
+"""
+
+
+def test_pretty_ordering():
+    assert pretty(x**2 + x + 1, order='lex') == \
+"""\
+ 2        \n\
+x  + x + 1\
+"""
+    assert pretty(x**2 + x + 1, order='rev-lex') == \
+"""\
+         2\n\
+1 + x + x \
+"""
+    assert pretty(1 - x, order='lex') == '-x + 1'
+    assert pretty(1 - x, order='rev-lex') == '1 - x'
+
+    assert pretty(1 - 2*x, order='lex') == '-2*x + 1'
+    assert pretty(1 - 2*x, order='rev-lex') == '1 - 2*x'
+
+    f = 2*x**4 + y**2 - x**2 + y**3
+    assert pretty(f, order=None) == \
+"""\
+   4    2    3    2\n\
+2*x  - x  + y  + y \
+"""
+    assert pretty(f, order='lex') == \
+"""\
+   4    2    3    2\n\
+2*x  - x  + y  + y \
+"""
+    assert pretty(f, order='rev-lex') == \
+"""\
+ 2    3    2      4\n\
+y  + y  - x  + 2*x \
+"""
+
+    expr = x - x**3/6 + x**5/120 + O(x**6)
+    ascii_str = \
+"""\
+     3    5         \n\
+    x    x      / 6\\\n\
+x - -- + --- + O\\x /\n\
+    6    120        \
+"""
+    ucode_str = \
+"""\
+     3    5         \n\
+    x    x      ⎛ 6⎞\n\
+x - ── + ─── + O⎝x ⎠\n\
+    6    120        \
+"""
+    assert pretty(expr, order=None) == ascii_str
+    assert upretty(expr, order=None) == ucode_str
+
+    assert pretty(expr, order='lex') == ascii_str
+    assert upretty(expr, order='lex') == ucode_str
+
+    assert pretty(expr, order='rev-lex') == ascii_str
+    assert upretty(expr, order='rev-lex') == ucode_str
+
+
+def test_EulerGamma():
+    assert pretty(EulerGamma) == str(EulerGamma) == "EulerGamma"
+    assert upretty(EulerGamma) == "γ"
+
+
+def test_GoldenRatio():
+    assert pretty(GoldenRatio) == str(GoldenRatio) == "GoldenRatio"
+    assert upretty(GoldenRatio) == "φ"
+
+
+def test_Catalan():
+    assert pretty(Catalan) == upretty(Catalan) == "G"
+
+
+def test_pretty_relational():
+    expr = Eq(x, y)
+    ascii_str = \
+"""\
+x = y\
+"""
+    ucode_str = \
+"""\
+x = y\
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = Lt(x, y)
+    ascii_str = \
+"""\
+x < y\
+"""
+    ucode_str = \
+"""\
+x < y\
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = Gt(x, y)
+    ascii_str = \
+"""\
+x > y\
+"""
+    ucode_str = \
+"""\
+x > y\
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = Le(x, y)
+    ascii_str = \
+"""\
+x <= y\
+"""
+    ucode_str = \
+"""\
+x ≤ y\
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = Ge(x, y)
+    ascii_str = \
+"""\
+x >= y\
+"""
+    ucode_str = \
+"""\
+x ≥ y\
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = Ne(x/(y + 1), y**2)
+    ascii_str_1 = \
+"""\
+  x       2\n\
+----- != y \n\
+1 + y      \
+"""
+    ascii_str_2 = \
+"""\
+  x       2\n\
+----- != y \n\
+y + 1      \
+"""
+    ucode_str_1 = \
+"""\
+  x      2\n\
+───── ≠ y \n\
+1 + y     \
+"""
+    ucode_str_2 = \
+"""\
+  x      2\n\
+───── ≠ y \n\
+y + 1     \
+"""
+    assert pretty(expr) in [ascii_str_1, ascii_str_2]
+    assert upretty(expr) in [ucode_str_1, ucode_str_2]
+
+
+def test_Assignment():
+    expr = Assignment(x, y)
+    ascii_str = \
+"""\
+x := y\
+"""
+    ucode_str = \
+"""\
+x := y\
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+
+def test_AugmentedAssignment():
+    expr = AddAugmentedAssignment(x, y)
+    ascii_str = \
+"""\
+x += y\
+"""
+    ucode_str = \
+"""\
+x += y\
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = SubAugmentedAssignment(x, y)
+    ascii_str = \
+"""\
+x -= y\
+"""
+    ucode_str = \
+"""\
+x -= y\
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = MulAugmentedAssignment(x, y)
+    ascii_str = \
+"""\
+x *= y\
+"""
+    ucode_str = \
+"""\
+x *= y\
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = DivAugmentedAssignment(x, y)
+    ascii_str = \
+"""\
+x /= y\
+"""
+    ucode_str = \
+"""\
+x /= y\
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = ModAugmentedAssignment(x, y)
+    ascii_str = \
+"""\
+x %= y\
+"""
+    ucode_str = \
+"""\
+x %= y\
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+
+def test_pretty_rational():
+    expr = y*x**-2
+    ascii_str = \
+"""\
+y \n\
+--\n\
+ 2\n\
+x \
+"""
+    ucode_str = \
+"""\
+y \n\
+──\n\
+ 2\n\
+x \
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = y**Rational(3, 2) * x**Rational(-5, 2)
+    ascii_str = \
+"""\
+ 3/2\n\
+y   \n\
+----\n\
+ 5/2\n\
+x   \
+"""
+    ucode_str = \
+"""\
+ 3/2\n\
+y   \n\
+────\n\
+ 5/2\n\
+x   \
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = sin(x)**3/tan(x)**2
+    ascii_str = \
+"""\
+   3   \n\
+sin (x)\n\
+-------\n\
+   2   \n\
+tan (x)\
+"""
+    ucode_str = \
+"""\
+   3   \n\
+sin (x)\n\
+───────\n\
+   2   \n\
+tan (x)\
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+
+@_both_exp_pow
+def test_pretty_functions():
+    """Tests for Abs, conjugate, exp, function braces, and factorial."""
+    expr = (2*x + exp(x))
+    ascii_str_1 = \
+"""\
+       x\n\
+2*x + e \
+"""
+    ascii_str_2 = \
+"""\
+ x      \n\
+e  + 2*x\
+"""
+    ucode_str_1 = \
+"""\
+       x\n\
+2⋅x + ℯ \
+"""
+    ucode_str_2 = \
+"""\
+ x     \n\
+ℯ + 2⋅x\
+"""
+    ucode_str_3 = \
+"""\
+ x      \n\
+ℯ  + 2⋅x\
+"""
+    assert pretty(expr) in [ascii_str_1, ascii_str_2]
+    assert upretty(expr) in [ucode_str_1, ucode_str_2, ucode_str_3]
+
+    expr = Abs(x)
+    ascii_str = \
+"""\
+|x|\
+"""
+    ucode_str = \
+"""\
+│x│\
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = Abs(x/(x**2 + 1))
+    ascii_str_1 = \
+"""\
+|  x   |\n\
+|------|\n\
+|     2|\n\
+|1 + x |\
+"""
+    ascii_str_2 = \
+"""\
+|  x   |\n\
+|------|\n\
+| 2    |\n\
+|x  + 1|\
+"""
+    ucode_str_1 = \
+"""\
+│  x   │\n\
+│──────│\n\
+│     2│\n\
+│1 + x │\
+"""
+    ucode_str_2 = \
+"""\
+│  x   │\n\
+│──────│\n\
+│ 2    │\n\
+│x  + 1│\
+"""
+    assert pretty(expr) in [ascii_str_1, ascii_str_2]
+    assert upretty(expr) in [ucode_str_1, ucode_str_2]
+
+    expr = Abs(1 / (y - Abs(x)))
+    ascii_str = \
+"""\
+    1    \n\
+---------\n\
+|y - |x||\
+"""
+    ucode_str = \
+"""\
+    1    \n\
+─────────\n\
+│y - │x││\
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    n = Symbol('n', integer=True)
+    expr = factorial(n)
+    ascii_str = \
+"""\
+n!\
+"""
+    ucode_str = \
+"""\
+n!\
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = factorial(2*n)
+    ascii_str = \
+"""\
+(2*n)!\
+"""
+    ucode_str = \
+"""\
+(2⋅n)!\
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = factorial(factorial(factorial(n)))
+    ascii_str = \
+"""\
+((n!)!)!\
+"""
+    ucode_str = \
+"""\
+((n!)!)!\
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = factorial(n + 1)
+    ascii_str_1 = \
+"""\
+(1 + n)!\
+"""
+    ascii_str_2 = \
+"""\
+(n + 1)!\
+"""
+    ucode_str_1 = \
+"""\
+(1 + n)!\
+"""
+    ucode_str_2 = \
+"""\
+(n + 1)!\
+"""
+
+    assert pretty(expr) in [ascii_str_1, ascii_str_2]
+    assert upretty(expr) in [ucode_str_1, ucode_str_2]
+
+    expr = subfactorial(n)
+    ascii_str = \
+"""\
+!n\
+"""
+    ucode_str = \
+"""\
+!n\
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = subfactorial(2*n)
+    ascii_str = \
+"""\
+!(2*n)\
+"""
+    ucode_str = \
+"""\
+!(2⋅n)\
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    n = Symbol('n', integer=True)
+    expr = factorial2(n)
+    ascii_str = \
+"""\
+n!!\
+"""
+    ucode_str = \
+"""\
+n!!\
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = factorial2(2*n)
+    ascii_str = \
+"""\
+(2*n)!!\
+"""
+    ucode_str = \
+"""\
+(2⋅n)!!\
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = factorial2(factorial2(factorial2(n)))
+    ascii_str = \
+"""\
+((n!!)!!)!!\
+"""
+    ucode_str = \
+"""\
+((n!!)!!)!!\
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = factorial2(n + 1)
+    ascii_str_1 = \
+"""\
+(1 + n)!!\
+"""
+    ascii_str_2 = \
+"""\
+(n + 1)!!\
+"""
+    ucode_str_1 = \
+"""\
+(1 + n)!!\
+"""
+    ucode_str_2 = \
+"""\
+(n + 1)!!\
+"""
+
+    assert pretty(expr) in [ascii_str_1, ascii_str_2]
+    assert upretty(expr) in [ucode_str_1, ucode_str_2]
+
+    expr = 2*binomial(n, k)
+    ascii_str = \
+"""\
+  /n\\\n\
+2*| |\n\
+  \\k/\
+"""
+    ucode_str = \
+"""\
+  ⎛n⎞\n\
+2⋅⎜ ⎟\n\
+  ⎝k⎠\
+"""
+
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = 2*binomial(2*n, k)
+    ascii_str = \
+"""\
+  /2*n\\\n\
+2*|   |\n\
+  \\ k /\
+"""
+    ucode_str = \
+"""\
+  ⎛2⋅n⎞\n\
+2⋅⎜   ⎟\n\
+  ⎝ k ⎠\
+"""
+
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = 2*binomial(n**2, k)
+    ascii_str = \
+"""\
+  / 2\\\n\
+  |n |\n\
+2*|  |\n\
+  \\k /\
+"""
+    ucode_str = \
+"""\
+  ⎛ 2⎞\n\
+  ⎜n ⎟\n\
+2⋅⎜  ⎟\n\
+  ⎝k ⎠\
+"""
+
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = catalan(n)
+    ascii_str = \
+"""\
+C \n\
+ n\
+"""
+    ucode_str = \
+"""\
+C \n\
+ n\
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = catalan(n)
+    ascii_str = \
+"""\
+C \n\
+ n\
+"""
+    ucode_str = \
+"""\
+C \n\
+ n\
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = bell(n)
+    ascii_str = \
+"""\
+B \n\
+ n\
+"""
+    ucode_str = \
+"""\
+B \n\
+ n\
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = bernoulli(n)
+    ascii_str = \
+"""\
+B \n\
+ n\
+"""
+    ucode_str = \
+"""\
+B \n\
+ n\
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = bernoulli(n, x)
+    ascii_str = \
+"""\
+B (x)\n\
+ n   \
+"""
+    ucode_str = \
+"""\
+B (x)\n\
+ n   \
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = fibonacci(n)
+    ascii_str = \
+"""\
+F \n\
+ n\
+"""
+    ucode_str = \
+"""\
+F \n\
+ n\
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = lucas(n)
+    ascii_str = \
+"""\
+L \n\
+ n\
+"""
+    ucode_str = \
+"""\
+L \n\
+ n\
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = tribonacci(n)
+    ascii_str = \
+"""\
+T \n\
+ n\
+"""
+    ucode_str = \
+"""\
+T \n\
+ n\
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = stieltjes(n)
+    ascii_str = \
+"""\
+stieltjes \n\
+         n\
+"""
+    ucode_str = \
+"""\
+γ \n\
+ n\
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = stieltjes(n, x)
+    ascii_str = \
+"""\
+stieltjes (x)\n\
+         n   \
+"""
+    ucode_str = \
+"""\
+γ (x)\n\
+ n   \
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = mathieuc(x, y, z)
+    ascii_str = 'C(x, y, z)'
+    ucode_str = 'C(x, y, z)'
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = mathieus(x, y, z)
+    ascii_str = 'S(x, y, z)'
+    ucode_str = 'S(x, y, z)'
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = mathieucprime(x, y, z)
+    ascii_str = "C'(x, y, z)"
+    ucode_str = "C'(x, y, z)"
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = mathieusprime(x, y, z)
+    ascii_str = "S'(x, y, z)"
+    ucode_str = "S'(x, y, z)"
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = conjugate(x)
+    ascii_str = \
+"""\
+_\n\
+x\
+"""
+    ucode_str = \
+"""\
+_\n\
+x\
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    f = Function('f')
+    expr = conjugate(f(x + 1))
+    ascii_str_1 = \
+"""\
+________\n\
+f(1 + x)\
+"""
+    ascii_str_2 = \
+"""\
+________\n\
+f(x + 1)\
+"""
+    ucode_str_1 = \
+"""\
+________\n\
+f(1 + x)\
+"""
+    ucode_str_2 = \
+"""\
+________\n\
+f(x + 1)\
+"""
+    assert pretty(expr) in [ascii_str_1, ascii_str_2]
+    assert upretty(expr) in [ucode_str_1, ucode_str_2]
+
+    expr = f(x)
+    ascii_str = \
+"""\
+f(x)\
+"""
+    ucode_str = \
+"""\
+f(x)\
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = f(x, y)
+    ascii_str = \
+"""\
+f(x, y)\
+"""
+    ucode_str = \
+"""\
+f(x, y)\
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = f(x/(y + 1), y)
+    ascii_str_1 = \
+"""\
+ /  x     \\\n\
+f|-----, y|\n\
+ \\1 + y   /\
+"""
+    ascii_str_2 = \
+"""\
+ /  x     \\\n\
+f|-----, y|\n\
+ \\y + 1   /\
+"""
+    ucode_str_1 = \
+"""\
+ ⎛  x     ⎞\n\
+f⎜─────, y⎟\n\
+ ⎝1 + y   ⎠\
+"""
+    ucode_str_2 = \
+"""\
+ ⎛  x     ⎞\n\
+f⎜─────, y⎟\n\
+ ⎝y + 1   ⎠\
+"""
+    assert pretty(expr) in [ascii_str_1, ascii_str_2]
+    assert upretty(expr) in [ucode_str_1, ucode_str_2]
+
+    expr = f(x**x**x**x**x**x)
+    ascii_str = \
+"""\
+ / / / / / x\\\\\\\\\\
+ | | | | \\x /||||
+ | | | \\x    /|||
+ | | \\x       /||
+ | \\x          /|
+f\\x             /\
+"""
+    ucode_str = \
+"""\
+ ⎛ ⎛ ⎛ ⎛ ⎛ x⎞⎞⎞⎞⎞
+ ⎜ ⎜ ⎜ ⎜ ⎝x ⎠⎟⎟⎟⎟
+ ⎜ ⎜ ⎜ ⎝x    ⎠⎟⎟⎟
+ ⎜ ⎜ ⎝x       ⎠⎟⎟
+ ⎜ ⎝x          ⎠⎟
+f⎝x             ⎠\
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = sin(x)**2
+    ascii_str = \
+"""\
+   2   \n\
+sin (x)\
+"""
+    ucode_str = \
+"""\
+   2   \n\
+sin (x)\
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = conjugate(a + b*I)
+    ascii_str = \
+"""\
+_     _\n\
+a - I*b\
+"""
+    ucode_str = \
+"""\
+_     _\n\
+a - ⅈ⋅b\
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = conjugate(exp(a + b*I))
+    ascii_str = \
+"""\
+ _     _\n\
+ a - I*b\n\
+e       \
+"""
+    ucode_str = \
+"""\
+ _     _\n\
+ a - ⅈ⋅b\n\
+ℯ       \
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = conjugate( f(1 + conjugate(f(x))) )
+    ascii_str_1 = \
+"""\
+___________\n\
+ /    ____\\\n\
+f\\1 + f(x)/\
+"""
+    ascii_str_2 = \
+"""\
+___________\n\
+ /____    \\\n\
+f\\f(x) + 1/\
+"""
+    ucode_str_1 = \
+"""\
+___________\n\
+ ⎛    ____⎞\n\
+f⎝1 + f(x)⎠\
+"""
+    ucode_str_2 = \
+"""\
+___________\n\
+ ⎛____    ⎞\n\
+f⎝f(x) + 1⎠\
+"""
+    assert pretty(expr) in [ascii_str_1, ascii_str_2]
+    assert upretty(expr) in [ucode_str_1, ucode_str_2]
+
+    expr = f(x/(y + 1), y)
+    ascii_str_1 = \
+"""\
+ /  x     \\\n\
+f|-----, y|\n\
+ \\1 + y   /\
+"""
+    ascii_str_2 = \
+"""\
+ /  x     \\\n\
+f|-----, y|\n\
+ \\y + 1   /\
+"""
+    ucode_str_1 = \
+"""\
+ ⎛  x     ⎞\n\
+f⎜─────, y⎟\n\
+ ⎝1 + y   ⎠\
+"""
+    ucode_str_2 = \
+"""\
+ ⎛  x     ⎞\n\
+f⎜─────, y⎟\n\
+ ⎝y + 1   ⎠\
+"""
+    assert pretty(expr) in [ascii_str_1, ascii_str_2]
+    assert upretty(expr) in [ucode_str_1, ucode_str_2]
+
+    expr = floor(1 / (y - floor(x)))
+    ascii_str = \
+"""\
+     /     1      \\\n\
+floor|------------|\n\
+     \\y - floor(x)/\
+"""
+    ucode_str = \
+"""\
+⎢   1   ⎥\n\
+⎢───────⎥\n\
+⎣y - ⌊x⌋⎦\
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = ceiling(1 / (y - ceiling(x)))
+    ascii_str = \
+"""\
+       /      1       \\\n\
+ceiling|--------------|\n\
+       \\y - ceiling(x)/\
+"""
+    ucode_str = \
+"""\
+⎡   1   ⎤\n\
+⎢───────⎥\n\
+⎢y - ⌈x⌉⎥\
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = euler(n)
+    ascii_str = \
+"""\
+E \n\
+ n\
+"""
+    ucode_str = \
+"""\
+E \n\
+ n\
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = euler(1/(1 + 1/(1 + 1/n)))
+    ascii_str = \
+"""\
+E         \n\
+     1    \n\
+ ---------\n\
+       1  \n\
+ 1 + -----\n\
+         1\n\
+     1 + -\n\
+         n\
+"""
+
+    ucode_str = \
+"""\
+E         \n\
+     1    \n\
+ ─────────\n\
+       1  \n\
+ 1 + ─────\n\
+         1\n\
+     1 + ─\n\
+         n\
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = euler(n, x)
+    ascii_str = \
+"""\
+E (x)\n\
+ n   \
+"""
+    ucode_str = \
+"""\
+E (x)\n\
+ n   \
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = euler(n, x/2)
+    ascii_str = \
+"""\
+  /x\\\n\
+E |-|\n\
+ n\\2/\
+"""
+    ucode_str = \
+"""\
+  ⎛x⎞\n\
+E ⎜─⎟\n\
+ n⎝2⎠\
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+
+def test_pretty_sqrt():
+    expr = sqrt(2)
+    ascii_str = \
+"""\
+  ___\n\
+\\/ 2 \
+"""
+    ucode_str = \
+"√2"
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = 2**Rational(1, 3)
+    ascii_str = \
+"""\
+3 ___\n\
+\\/ 2 \
+"""
+    ucode_str = \
+"""\
+3 ___\n\
+╲╱ 2 \
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = 2**Rational(1, 1000)
+    ascii_str = \
+"""\
+1000___\n\
+  \\/ 2 \
+"""
+    ucode_str = \
+"""\
+1000___\n\
+  ╲╱ 2 \
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = sqrt(x**2 + 1)
+    ascii_str = \
+"""\
+   ________\n\
+  /  2     \n\
+\\/  x  + 1 \
+"""
+    ucode_str = \
+"""\
+   ________\n\
+  ╱  2     \n\
+╲╱  x  + 1 \
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = (1 + sqrt(5))**Rational(1, 3)
+    ascii_str = \
+"""\
+   ___________\n\
+3 /       ___ \n\
+\\/  1 + \\/ 5  \
+"""
+    ucode_str = \
+"""\
+3 ________\n\
+╲╱ 1 + √5 \
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = 2**(1/x)
+    ascii_str = \
+"""\
+x ___\n\
+\\/ 2 \
+"""
+    ucode_str = \
+"""\
+x ___\n\
+╲╱ 2 \
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = sqrt(2 + pi)
+    ascii_str = \
+"""\
+  ________\n\
+\\/ 2 + pi \
+"""
+    ucode_str = \
+"""\
+  _______\n\
+╲╱ 2 + π \
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = (2 + (
+        1 + x**2)/(2 + x))**Rational(1, 4) + (1 + x**Rational(1, 1000))/sqrt(3 + x**2)
+    ascii_str = \
+"""\
+     ____________              \n\
+    /      2        1000___    \n\
+   /      x  + 1      \\/ x  + 1\n\
+4 /   2 + ------  + -----------\n\
+\\/        x + 2        ________\n\
+                      /  2     \n\
+                    \\/  x  + 3 \
+"""
+    ucode_str = \
+"""\
+     ____________              \n\
+    ╱      2        1000___    \n\
+   ╱      x  + 1      ╲╱ x  + 1\n\
+4 ╱   2 + ──────  + ───────────\n\
+╲╱        x + 2        ________\n\
+                      ╱  2     \n\
+                    ╲╱  x  + 3 \
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+
+def test_pretty_sqrt_char_knob():
+    # See PR #9234.
+    expr = sqrt(2)
+    ucode_str1 = \
+"""\
+  ___\n\
+╲╱ 2 \
+"""
+    ucode_str2 = \
+"√2"
+    assert xpretty(expr, use_unicode=True,
+                   use_unicode_sqrt_char=False) == ucode_str1
+    assert xpretty(expr, use_unicode=True,
+                   use_unicode_sqrt_char=True) == ucode_str2
+
+
+def test_pretty_sqrt_longsymbol_no_sqrt_char():
+    # Do not use unicode sqrt char for long symbols (see PR #9234).
+    expr = sqrt(Symbol('C1'))
+    ucode_str = \
+"""\
+  ____\n\
+╲╱ C₁ \
+"""
+    assert upretty(expr) == ucode_str
+
+
+def test_pretty_KroneckerDelta():
+    x, y = symbols("x, y")
+    expr = KroneckerDelta(x, y)
+    ascii_str = \
+"""\
+d   \n\
+ x,y\
+"""
+    ucode_str = \
+"""\
+δ   \n\
+ x,y\
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+
+def test_pretty_product():
+    n, m, k, l = symbols('n m k l')
+    f = symbols('f', cls=Function)
+    expr = Product(f((n/3)**2), (n, k**2, l))
+
+    unicode_str = \
+"""\
+    l           \n\
+─┬──────┬─      \n\
+ │      │   ⎛ 2⎞\n\
+ │      │   ⎜n ⎟\n\
+ │      │  f⎜──⎟\n\
+ │      │   ⎝9 ⎠\n\
+ │      │       \n\
+       2        \n\
+  n = k         """
+    ascii_str = \
+"""\
+    l           \n\
+__________      \n\
+ |      |   / 2\\\n\
+ |      |   |n |\n\
+ |      |  f|--|\n\
+ |      |   \\9 /\n\
+ |      |       \n\
+       2        \n\
+  n = k         """
+
+    expr = Product(f((n/3)**2), (n, k**2, l), (l, 1, m))
+
+    unicode_str = \
+"""\
+    m          l           \n\
+─┬──────┬─ ─┬──────┬─      \n\
+ │      │   │      │   ⎛ 2⎞\n\
+ │      │   │      │   ⎜n ⎟\n\
+ │      │   │      │  f⎜──⎟\n\
+ │      │   │      │   ⎝9 ⎠\n\
+ │      │   │      │       \n\
+  l = 1           2        \n\
+             n = k         """
+    ascii_str = \
+"""\
+    m          l           \n\
+__________ __________      \n\
+ |      |   |      |   / 2\\\n\
+ |      |   |      |   |n |\n\
+ |      |   |      |  f|--|\n\
+ |      |   |      |   \\9 /\n\
+ |      |   |      |       \n\
+  l = 1           2        \n\
+             n = k         """
+
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == unicode_str
+
+
+def test_pretty_Lambda():
+    # S.IdentityFunction is a special case
+    expr = Lambda(y, y)
+    assert pretty(expr) == "x -> x"
+    assert upretty(expr) == "x ↦ x"
+
+    expr = Lambda(x, x+1)
+    assert pretty(expr) == "x -> x + 1"
+    assert upretty(expr) == "x ↦ x + 1"
+
+    expr = Lambda(x, x**2)
+    ascii_str = \
+"""\
+      2\n\
+x -> x \
+"""
+    ucode_str = \
+"""\
+     2\n\
+x ↦ x \
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = Lambda(x, x**2)**2
+    ascii_str = \
+"""\
+         2
+/      2\\ \n\
+\\x -> x / \
+"""
+    ucode_str = \
+"""\
+        2
+⎛     2⎞ \n\
+⎝x ↦ x ⎠ \
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = Lambda((x, y), x)
+    ascii_str = "(x, y) -> x"
+    ucode_str = "(x, y) ↦ x"
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = Lambda((x, y), x**2)
+    ascii_str = \
+"""\
+           2\n\
+(x, y) -> x \
+"""
+    ucode_str = \
+"""\
+          2\n\
+(x, y) ↦ x \
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = Lambda(((x, y),), x**2)
+    ascii_str = \
+"""\
+              2\n\
+((x, y),) -> x \
+"""
+    ucode_str = \
+"""\
+             2\n\
+((x, y),) ↦ x \
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+
+def test_pretty_TransferFunction():
+    tf1 = TransferFunction(s - 1, s + 1, s)
+    assert upretty(tf1) == "s - 1\n─────\ns + 1"
+    tf2 = TransferFunction(2*s + 1, 3 - p, s)
+    assert upretty(tf2) == "2⋅s + 1\n───────\n 3 - p "
+    tf3 = TransferFunction(p, p + 1, p)
+    assert upretty(tf3) == "  p  \n─────\np + 1"
+
+
+def test_pretty_Series():
+    tf1 = TransferFunction(x + y, x - 2*y, y)
+    tf2 = TransferFunction(x - y, x + y, y)
+    tf3 = TransferFunction(x**2 + y, y - x, y)
+    tf4 = TransferFunction(2, 3, y)
+
+    tfm1 = TransferFunctionMatrix([[tf1, tf2], [tf3, tf4]])
+    tfm2 = TransferFunctionMatrix([[tf3], [-tf4]])
+    tfm3 = TransferFunctionMatrix([[tf1, -tf2, -tf3], [tf3, -tf4, tf2]])
+    tfm4 = TransferFunctionMatrix([[tf1, tf2], [tf3, -tf4], [-tf2, -tf1]])
+    tfm5 = TransferFunctionMatrix([[-tf2, -tf1], [tf4, -tf3], [tf1, tf2]])
+
+    expected1 = \
+"""\
+          ⎛ 2    ⎞\n\
+⎛ x + y ⎞ ⎜x  + y⎟\n\
+⎜───────⎟⋅⎜──────⎟\n\
+⎝x - 2⋅y⎠ ⎝-x + y⎠\
+"""
+    expected2 = \
+"""\
+⎛-x + y⎞ ⎛-x - y ⎞\n\
+⎜──────⎟⋅⎜───────⎟\n\
+⎝x + y ⎠ ⎝x - 2⋅y⎠\
+"""
+    expected3 = \
+"""\
+⎛ 2    ⎞                            \n\
+⎜x  + y⎟ ⎛ x + y ⎞ ⎛-x - y    x - y⎞\n\
+⎜──────⎟⋅⎜───────⎟⋅⎜─────── + ─────⎟\n\
+⎝-x + y⎠ ⎝x - 2⋅y⎠ ⎝x - 2⋅y   x + y⎠\
+"""
+    expected4 = \
+"""\
+                  ⎛         2    ⎞\n\
+⎛ x + y    x - y⎞ ⎜x - y   x  + y⎟\n\
+⎜─────── + ─────⎟⋅⎜───── + ──────⎟\n\
+⎝x - 2⋅y   x + y⎠ ⎝x + y   -x + y⎠\
+"""
+    expected5 = \
+"""\
+⎡ x + y   x - y⎤  ⎡ 2    ⎤ \n\
+⎢───────  ─────⎥  ⎢x  + y⎥ \n\
+⎢x - 2⋅y  x + y⎥  ⎢──────⎥ \n\
+⎢              ⎥  ⎢-x + y⎥ \n\
+⎢ 2            ⎥ ⋅⎢      ⎥ \n\
+⎢x  + y     2  ⎥  ⎢ -2   ⎥ \n\
+⎢──────     ─  ⎥  ⎢ ───  ⎥ \n\
+⎣-x + y     3  ⎦τ ⎣  3   ⎦τ\
+"""
+    expected6 = \
+"""\
+                                               ⎛⎡ x + y    x - y ⎤    ⎡ x - y    x + y ⎤ ⎞\n\
+                                               ⎜⎢───────   ───── ⎥    ⎢ ─────   ───────⎥ ⎟\n\
+⎡ x + y   x - y⎤  ⎡                    2    ⎤  ⎜⎢x - 2⋅y   x + y ⎥    ⎢ x + y   x - 2⋅y⎥ ⎟\n\
+⎢───────  ─────⎥  ⎢ x + y   -x + y  - x  - y⎥  ⎜⎢                ⎥    ⎢                ⎥ ⎟\n\
+⎢x - 2⋅y  x + y⎥  ⎢───────  ──────  ────────⎥  ⎜⎢ 2              ⎥    ⎢          2     ⎥ ⎟\n\
+⎢              ⎥  ⎢x - 2⋅y  x + y    -x + y ⎥  ⎜⎢x  + y     -2   ⎥    ⎢  -2     x  + y ⎥ ⎟\n\
+⎢ 2            ⎥ ⋅⎢                         ⎥ ⋅⎜⎢──────     ───  ⎥  + ⎢  ───    ────── ⎥ ⎟\n\
+⎢x  + y     2  ⎥  ⎢ 2                       ⎥  ⎜⎢-x + y      3   ⎥    ⎢   3     -x + y ⎥ ⎟\n\
+⎢──────     ─  ⎥  ⎢x  + y    -2      x - y  ⎥  ⎜⎢                ⎥    ⎢                ⎥ ⎟\n\
+⎣-x + y     3  ⎦τ ⎢──────    ───     ─────  ⎥  ⎜⎢-x + y   -x - y ⎥    ⎢-x - y   -x + y ⎥ ⎟\n\
+                  ⎣-x + y     3      x + y  ⎦τ ⎜⎢──────   ───────⎥    ⎢───────  ────── ⎥ ⎟\n\
+                                               ⎝⎣x + y    x - 2⋅y⎦τ   ⎣x - 2⋅y  x + y  ⎦τ⎠\
+"""
+
+    assert upretty(Series(tf1, tf3)) == expected1
+    assert upretty(Series(-tf2, -tf1)) == expected2
+    assert upretty(Series(tf3, tf1, Parallel(-tf1, tf2))) == expected3
+    assert upretty(Series(Parallel(tf1, tf2), Parallel(tf2, tf3))) == expected4
+    assert upretty(MIMOSeries(tfm2, tfm1)) == expected5
+    assert upretty(MIMOSeries(MIMOParallel(tfm4, -tfm5), tfm3, tfm1)) == expected6
+
+
+def test_pretty_Parallel():
+    tf1 = TransferFunction(x + y, x - 2*y, y)
+    tf2 = TransferFunction(x - y, x + y, y)
+    tf3 = TransferFunction(x**2 + y, y - x, y)
+    tf4 = TransferFunction(y**2 - x, x**3 + x, y)
+
+    tfm1 = TransferFunctionMatrix([[tf1, tf2], [tf3, -tf4], [-tf2, -tf1]])
+    tfm2 = TransferFunctionMatrix([[-tf2, -tf1], [tf4, -tf3], [tf1, tf2]])
+    tfm3 = TransferFunctionMatrix([[-tf1, tf2], [-tf3, tf4], [tf2, tf1]])
+    tfm4 = TransferFunctionMatrix([[-tf1, -tf2], [-tf3, -tf4]])
+
+    expected1 = \
+"""\
+ x + y    x - y\n\
+─────── + ─────\n\
+x - 2⋅y   x + y\
+"""
+    expected2 = \
+"""\
+-x + y   -x - y \n\
+────── + ───────
+x + y    x - 2⋅y\
+"""
+    expected3 = \
+"""\
+ 2                                  \n\
+x  + y    x + y    ⎛-x - y ⎞ ⎛x - y⎞
+────── + ─────── + ⎜───────⎟⋅⎜─────⎟
+-x + y   x - 2⋅y   ⎝x - 2⋅y⎠ ⎝x + y⎠\
+"""
+
+    expected4 = \
+"""\
+                            ⎛ 2    ⎞\n\
+⎛ x + y ⎞ ⎛x - y⎞   ⎛x - y⎞ ⎜x  + y⎟\n\
+⎜───────⎟⋅⎜─────⎟ + ⎜─────⎟⋅⎜──────⎟\n\
+⎝x - 2⋅y⎠ ⎝x + y⎠   ⎝x + y⎠ ⎝-x + y⎠\
+"""
+    expected5 = \
+"""\
+⎡ x + y   -x + y ⎤    ⎡ x - y    x + y ⎤    ⎡ x + y    x - y ⎤ \n\
+⎢───────  ────── ⎥    ⎢ ─────   ───────⎥    ⎢───────   ───── ⎥ \n\
+⎢x - 2⋅y  x + y  ⎥    ⎢ x + y   x - 2⋅y⎥    ⎢x - 2⋅y   x + y ⎥ \n\
+⎢                ⎥    ⎢                ⎥    ⎢                ⎥ \n\
+⎢ 2            2 ⎥    ⎢     2    2     ⎥    ⎢ 2            2 ⎥ \n\
+⎢x  + y   x - y  ⎥    ⎢x - y    x  + y ⎥    ⎢x  + y   x - y  ⎥ \n\
+⎢──────   ────── ⎥  + ⎢──────   ────── ⎥  + ⎢──────   ────── ⎥ \n\
+⎢-x + y    3     ⎥    ⎢ 3       -x + y ⎥    ⎢-x + y    3     ⎥ \n\
+⎢         x  + x ⎥    ⎢x  + x          ⎥    ⎢         x  + x ⎥ \n\
+⎢                ⎥    ⎢                ⎥    ⎢                ⎥ \n\
+⎢-x + y   -x - y ⎥    ⎢-x - y   -x + y ⎥    ⎢-x + y   -x - y ⎥ \n\
+⎢──────   ───────⎥    ⎢───────  ────── ⎥    ⎢──────   ───────⎥ \n\
+⎣x + y    x - 2⋅y⎦τ   ⎣x - 2⋅y  x + y  ⎦τ   ⎣x + y    x - 2⋅y⎦τ\
+"""
+    expected6 = \
+"""\
+⎡ x - y    x + y ⎤                        ⎡-x + y   -x - y  ⎤ \n\
+⎢ ─────   ───────⎥                        ⎢──────   ─────── ⎥ \n\
+⎢ x + y   x - 2⋅y⎥  ⎡-x - y    -x + y⎤    ⎢x + y    x - 2⋅y ⎥ \n\
+⎢                ⎥  ⎢───────   ──────⎥    ⎢                 ⎥ \n\
+⎢     2    2     ⎥  ⎢x - 2⋅y   x + y ⎥    ⎢      2     2    ⎥ \n\
+⎢x - y    x  + y ⎥  ⎢                ⎥    ⎢-x + y   - x  - y⎥ \n\
+⎢──────   ────── ⎥ ⋅⎢   2           2⎥  + ⎢───────  ────────⎥ \n\
+⎢ 3       -x + y ⎥  ⎢- x  - y  x - y ⎥    ⎢ 3        -x + y ⎥ \n\
+⎢x  + x          ⎥  ⎢────────  ──────⎥    ⎢x  + x           ⎥ \n\
+⎢                ⎥  ⎢ -x + y    3    ⎥    ⎢                 ⎥ \n\
+⎢-x - y   -x + y ⎥  ⎣          x  + x⎦τ   ⎢ x + y    x - y  ⎥ \n\
+⎢───────  ────── ⎥                        ⎢───────   ─────  ⎥ \n\
+⎣x - 2⋅y  x + y  ⎦τ                       ⎣x - 2⋅y   x + y  ⎦τ\
+"""
+    assert upretty(Parallel(tf1, tf2)) == expected1
+    assert upretty(Parallel(-tf2, -tf1)) == expected2
+    assert upretty(Parallel(tf3, tf1, Series(-tf1, tf2))) == expected3
+    assert upretty(Parallel(Series(tf1, tf2), Series(tf2, tf3))) == expected4
+    assert upretty(MIMOParallel(-tfm3, -tfm2, tfm1)) == expected5
+    assert upretty(MIMOParallel(MIMOSeries(tfm4, -tfm2), tfm2)) == expected6
+
+
+def test_pretty_Feedback():
+    tf = TransferFunction(1, 1, y)
+    tf1 = TransferFunction(x + y, x - 2*y, y)
+    tf2 = TransferFunction(x - y, x + y, y)
+    tf3 = TransferFunction(y**2 - 2*y + 1, y + 5, y)
+    tf4 = TransferFunction(x - 2*y**3, x + y, x)
+    tf5 = TransferFunction(1 - x, x - y, y)
+    tf6 = TransferFunction(2, 2, x)
+    expected1 = \
+"""\
+     ⎛1⎞     \n\
+     ⎜─⎟     \n\
+     ⎝1⎠     \n\
+─────────────\n\
+1   ⎛ x + y ⎞\n\
+─ + ⎜───────⎟\n\
+1   ⎝x - 2⋅y⎠\
+"""
+    expected2 = \
+"""\
+                ⎛1⎞                 \n\
+                ⎜─⎟                 \n\
+                ⎝1⎠                 \n\
+────────────────────────────────────\n\
+                      ⎛ 2          ⎞\n\
+1   ⎛x - y⎞ ⎛ x + y ⎞ ⎜y  - 2⋅y + 1⎟\n\
+─ + ⎜─────⎟⋅⎜───────⎟⋅⎜────────────⎟\n\
+1   ⎝x + y⎠ ⎝x - 2⋅y⎠ ⎝   y + 5    ⎠\
+"""
+    expected3 = \
+"""\
+                 ⎛ x + y ⎞                  \n\
+                 ⎜───────⎟                  \n\
+                 ⎝x - 2⋅y⎠                  \n\
+────────────────────────────────────────────\n\
+                      ⎛ 2          ⎞        \n\
+1   ⎛ x + y ⎞ ⎛x - y⎞ ⎜y  - 2⋅y + 1⎟ ⎛1 - x⎞\n\
+─ + ⎜───────⎟⋅⎜─────⎟⋅⎜────────────⎟⋅⎜─────⎟\n\
+1   ⎝x - 2⋅y⎠ ⎝x + y⎠ ⎝   y + 5    ⎠ ⎝x - y⎠\
+"""
+    expected4 = \
+"""\
+  ⎛ x + y ⎞ ⎛x - y⎞  \n\
+  ⎜───────⎟⋅⎜─────⎟  \n\
+  ⎝x - 2⋅y⎠ ⎝x + y⎠  \n\
+─────────────────────\n\
+1   ⎛ x + y ⎞ ⎛x - y⎞\n\
+─ + ⎜───────⎟⋅⎜─────⎟\n\
+1   ⎝x - 2⋅y⎠ ⎝x + y⎠\
+"""
+    expected5 = \
+"""\
+      ⎛ x + y ⎞ ⎛x - y⎞      \n\
+      ⎜───────⎟⋅⎜─────⎟      \n\
+      ⎝x - 2⋅y⎠ ⎝x + y⎠      \n\
+─────────────────────────────\n\
+1   ⎛ x + y ⎞ ⎛x - y⎞ ⎛1 - x⎞\n\
+─ + ⎜───────⎟⋅⎜─────⎟⋅⎜─────⎟\n\
+1   ⎝x - 2⋅y⎠ ⎝x + y⎠ ⎝x - y⎠\
+"""
+    expected6 = \
+"""\
+           ⎛ 2          ⎞                   \n\
+           ⎜y  - 2⋅y + 1⎟ ⎛1 - x⎞           \n\
+           ⎜────────────⎟⋅⎜─────⎟           \n\
+           ⎝   y + 5    ⎠ ⎝x - y⎠           \n\
+────────────────────────────────────────────\n\
+    ⎛ 2          ⎞                          \n\
+1   ⎜y  - 2⋅y + 1⎟ ⎛1 - x⎞ ⎛x - y⎞ ⎛ x + y ⎞\n\
+─ + ⎜────────────⎟⋅⎜─────⎟⋅⎜─────⎟⋅⎜───────⎟\n\
+1   ⎝   y + 5    ⎠ ⎝x - y⎠ ⎝x + y⎠ ⎝x - 2⋅y⎠\
+"""
+    expected7 = \
+"""\
+    ⎛       3⎞    \n\
+    ⎜x - 2⋅y ⎟    \n\
+    ⎜────────⎟    \n\
+    ⎝ x + y  ⎠    \n\
+──────────────────\n\
+    ⎛       3⎞    \n\
+1   ⎜x - 2⋅y ⎟ ⎛2⎞\n\
+─ + ⎜────────⎟⋅⎜─⎟\n\
+1   ⎝ x + y  ⎠ ⎝2⎠\
+"""
+    expected8 = \
+"""\
+  ⎛1 - x⎞  \n\
+  ⎜─────⎟  \n\
+  ⎝x - y⎠  \n\
+───────────\n\
+1   ⎛1 - x⎞\n\
+─ + ⎜─────⎟\n\
+1   ⎝x - y⎠\
+"""
+    expected9 = \
+"""\
+      ⎛ x + y ⎞ ⎛x - y⎞      \n\
+      ⎜───────⎟⋅⎜─────⎟      \n\
+      ⎝x - 2⋅y⎠ ⎝x + y⎠      \n\
+─────────────────────────────\n\
+1   ⎛ x + y ⎞ ⎛x - y⎞ ⎛1 - x⎞\n\
+─ - ⎜───────⎟⋅⎜─────⎟⋅⎜─────⎟\n\
+1   ⎝x - 2⋅y⎠ ⎝x + y⎠ ⎝x - y⎠\
+"""
+    expected10 = \
+"""\
+  ⎛1 - x⎞  \n\
+  ⎜─────⎟  \n\
+  ⎝x - y⎠  \n\
+───────────\n\
+1   ⎛1 - x⎞\n\
+─ - ⎜─────⎟\n\
+1   ⎝x - y⎠\
+"""
+    assert upretty(Feedback(tf, tf1)) == expected1
+    assert upretty(Feedback(tf, tf2*tf1*tf3)) == expected2
+    assert upretty(Feedback(tf1, tf2*tf3*tf5)) == expected3
+    assert upretty(Feedback(tf1*tf2, tf)) == expected4
+    assert upretty(Feedback(tf1*tf2, tf5)) == expected5
+    assert upretty(Feedback(tf3*tf5, tf2*tf1)) == expected6
+    assert upretty(Feedback(tf4, tf6)) == expected7
+    assert upretty(Feedback(tf5, tf)) == expected8
+
+    assert upretty(Feedback(tf1*tf2, tf5, 1)) == expected9
+    assert upretty(Feedback(tf5, tf, 1)) == expected10
+
+
+def test_pretty_MIMOFeedback():
+    tf1 = TransferFunction(x + y, x - 2*y, y)
+    tf2 = TransferFunction(x - y, x + y, y)
+    tfm_1 = TransferFunctionMatrix([[tf1, tf2], [tf2, tf1]])
+    tfm_2 = TransferFunctionMatrix([[tf2, tf1], [tf1, tf2]])
+    tfm_3 = TransferFunctionMatrix([[tf1, tf1], [tf2, tf2]])
+
+    expected1 = \
+"""\
+⎛    ⎡ x + y    x - y ⎤  ⎡ x - y    x + y ⎤ ⎞-1   ⎡ x + y    x - y ⎤ \n\
+⎜    ⎢───────   ───── ⎥  ⎢ ─────   ───────⎥ ⎟     ⎢───────   ───── ⎥ \n\
+⎜    ⎢x - 2⋅y   x + y ⎥  ⎢ x + y   x - 2⋅y⎥ ⎟     ⎢x - 2⋅y   x + y ⎥ \n\
+⎜I - ⎢                ⎥ ⋅⎢                ⎥ ⎟   ⋅ ⎢                ⎥ \n\
+⎜    ⎢ x - y    x + y ⎥  ⎢ x + y    x - y ⎥ ⎟     ⎢ x - y    x + y ⎥ \n\
+⎜    ⎢ ─────   ───────⎥  ⎢───────   ───── ⎥ ⎟     ⎢ ─────   ───────⎥ \n\
+⎝    ⎣ x + y   x - 2⋅y⎦τ ⎣x - 2⋅y   x + y ⎦τ⎠     ⎣ x + y   x - 2⋅y⎦τ\
+"""
+    expected2 = \
+"""\
+⎛    ⎡ x + y    x - y ⎤  ⎡ x - y    x + y ⎤  ⎡ x + y    x + y ⎤ ⎞-1   ⎡ x + y    x - y ⎤  ⎡ x - y    x + y ⎤ \n\
+⎜    ⎢───────   ───── ⎥  ⎢ ─────   ───────⎥  ⎢───────  ───────⎥ ⎟     ⎢───────   ───── ⎥  ⎢ ─────   ───────⎥ \n\
+⎜    ⎢x - 2⋅y   x + y ⎥  ⎢ x + y   x - 2⋅y⎥  ⎢x - 2⋅y  x - 2⋅y⎥ ⎟     ⎢x - 2⋅y   x + y ⎥  ⎢ x + y   x - 2⋅y⎥ \n\
+⎜I + ⎢                ⎥ ⋅⎢                ⎥ ⋅⎢                ⎥ ⎟   ⋅ ⎢                ⎥ ⋅⎢                ⎥ \n\
+⎜    ⎢ x - y    x + y ⎥  ⎢ x + y    x - y ⎥  ⎢ x - y    x - y ⎥ ⎟     ⎢ x - y    x + y ⎥  ⎢ x + y    x - y ⎥ \n\
+⎜    ⎢ ─────   ───────⎥  ⎢───────   ───── ⎥  ⎢ ─────    ───── ⎥ ⎟     ⎢ ─────   ───────⎥  ⎢───────   ───── ⎥ \n\
+⎝    ⎣ x + y   x - 2⋅y⎦τ ⎣x - 2⋅y   x + y ⎦τ ⎣ x + y    x + y ⎦τ⎠     ⎣ x + y   x - 2⋅y⎦τ ⎣x - 2⋅y   x + y ⎦τ\
+"""
+
+    assert upretty(MIMOFeedback(tfm_1, tfm_2, 1)) == \
+        expected1  # Positive MIMOFeedback
+    assert upretty(MIMOFeedback(tfm_1*tfm_2, tfm_3)) == \
+        expected2  # Negative MIMOFeedback (Default)
+
+
+def test_pretty_TransferFunctionMatrix():
+    tf1 = TransferFunction(x + y, x - 2*y, y)
+    tf2 = TransferFunction(x - y, x + y, y)
+    tf3 = TransferFunction(y**2 - 2*y + 1, y + 5, y)
+    tf4 = TransferFunction(y, x**2 + x + 1, y)
+    tf5 = TransferFunction(1 - x, x - y, y)
+    tf6 = TransferFunction(2, 2, y)
+    expected1 = \
+"""\
+⎡ x + y ⎤ \n\
+⎢───────⎥ \n\
+⎢x - 2⋅y⎥ \n\
+⎢       ⎥ \n\
+⎢ x - y ⎥ \n\
+⎢ ───── ⎥ \n\
+⎣ x + y ⎦τ\
+"""
+    expected2 = \
+"""\
+⎡    x + y     ⎤ \n\
+⎢   ───────    ⎥ \n\
+⎢   x - 2⋅y    ⎥ \n\
+⎢              ⎥ \n\
+⎢    x - y     ⎥ \n\
+⎢    ─────     ⎥ \n\
+⎢    x + y     ⎥ \n\
+⎢              ⎥ \n\
+⎢   2          ⎥ \n\
+⎢- y  + 2⋅y - 1⎥ \n\
+⎢──────────────⎥ \n\
+⎣    y + 5     ⎦τ\
+"""
+    expected3 = \
+"""\
+⎡   x + y        x - y   ⎤ \n\
+⎢  ───────       ─────   ⎥ \n\
+⎢  x - 2⋅y       x + y   ⎥ \n\
+⎢                        ⎥ \n\
+⎢ 2                      ⎥ \n\
+⎢y  - 2⋅y + 1      y     ⎥ \n\
+⎢────────────  ──────────⎥ \n\
+⎢   y + 5       2        ⎥ \n\
+⎢              x  + x + 1⎥ \n\
+⎢                        ⎥ \n\
+⎢   1 - x          2     ⎥ \n\
+⎢   ─────          ─     ⎥ \n\
+⎣   x - y          2     ⎦τ\
+"""
+    expected4 = \
+"""\
+⎡    x - y        x + y       y     ⎤ \n\
+⎢    ─────       ───────  ──────────⎥ \n\
+⎢    x + y       x - 2⋅y   2        ⎥ \n\
+⎢                         x  + x + 1⎥ \n\
+⎢                                   ⎥ \n\
+⎢   2                               ⎥ \n\
+⎢- y  + 2⋅y - 1   x - 1      -2     ⎥ \n\
+⎢──────────────   ─────      ───    ⎥ \n\
+⎣    y + 5        x - y       2     ⎦τ\
+"""
+    expected5 = \
+"""\
+⎡ x + y  x - y   x + y       y     ⎤ \n\
+⎢───────⋅─────  ───────  ──────────⎥ \n\
+⎢x - 2⋅y x + y  x - 2⋅y   2        ⎥ \n\
+⎢                        x  + x + 1⎥ \n\
+⎢                                  ⎥ \n\
+⎢  1 - x   2     x + y      -2     ⎥ \n\
+⎢  ───── + ─    ───────     ───    ⎥ \n\
+⎣  x - y   2    x - 2⋅y      2     ⎦τ\
+"""
+
+    assert upretty(TransferFunctionMatrix([[tf1], [tf2]])) == expected1
+    assert upretty(TransferFunctionMatrix([[tf1], [tf2], [-tf3]])) == expected2
+    assert upretty(TransferFunctionMatrix([[tf1, tf2], [tf3, tf4], [tf5, tf6]])) == expected3
+    assert upretty(TransferFunctionMatrix([[tf2, tf1, tf4], [-tf3, -tf5, -tf6]])) == expected4
+    assert upretty(TransferFunctionMatrix([[Series(tf2, tf1), tf1, tf4], [Parallel(tf6, tf5), tf1, -tf6]])) == \
+        expected5
+
+
+def test_pretty_StateSpace():
+    ss1 = StateSpace(Matrix([a]), Matrix([b]), Matrix([c]), Matrix([d]))
+    A = Matrix([[0, 1], [1, 0]])
+    B = Matrix([1, 0])
+    C = Matrix([[0, 1]])
+    D = Matrix([0])
+    ss2 = StateSpace(A, B, C, D)
+    ss3 = StateSpace(Matrix([[-1.5, -2], [1, 0]]),
+                    Matrix([[0.5, 0], [0, 1]]),
+                    Matrix([[0, 1], [0, 2]]),
+                    Matrix([[2, 2], [1, 1]]))
+
+    expected1 = \
+"""\
+⎡[a]  [b]⎤\n\
+⎢        ⎥\n\
+⎣[c]  [d]⎦\
+"""
+    expected2 = \
+"""\
+⎡⎡0  1⎤  ⎡1⎤⎤\n\
+⎢⎢    ⎥  ⎢ ⎥⎥\n\
+⎢⎣1  0⎦  ⎣0⎦⎥\n\
+⎢           ⎥\n\
+⎣[0  1]  [0]⎦\
+"""
+    expected3 = \
+"""\
+⎡⎡-1.5  -2⎤  ⎡0.5  0⎤⎤\n\
+⎢⎢        ⎥  ⎢      ⎥⎥\n\
+⎢⎣ 1    0 ⎦  ⎣ 0   1⎦⎥\n\
+⎢                    ⎥\n\
+⎢  ⎡0  1⎤     ⎡2  2⎤ ⎥\n\
+⎢  ⎢    ⎥     ⎢    ⎥ ⎥\n\
+⎣  ⎣0  2⎦     ⎣1  1⎦ ⎦\
+"""
+
+    assert upretty(ss1) == expected1
+    assert upretty(ss2) == expected2
+    assert upretty(ss3) == expected3
+
+def test_pretty_order():
+    expr = O(1)
+    ascii_str = \
+"""\
+O(1)\
+"""
+    ucode_str = \
+"""\
+O(1)\
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = O(1/x)
+    ascii_str = \
+"""\
+ /1\\\n\
+O|-|\n\
+ \\x/\
+"""
+    ucode_str = \
+"""\
+ ⎛1⎞\n\
+O⎜─⎟\n\
+ ⎝x⎠\
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = O(x**2 + y**2)
+    ascii_str = \
+"""\
+ / 2    2                  \\\n\
+O\\x  + y ; (x, y) -> (0, 0)/\
+"""
+    ucode_str = \
+"""\
+ ⎛ 2    2                 ⎞\n\
+O⎝x  + y ; (x, y) → (0, 0)⎠\
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = O(1, (x, oo))
+    ascii_str = \
+"""\
+O(1; x -> oo)\
+"""
+    ucode_str = \
+"""\
+O(1; x → ∞)\
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = O(1/x, (x, oo))
+    ascii_str = \
+"""\
+ /1         \\\n\
+O|-; x -> oo|\n\
+ \\x         /\
+"""
+    ucode_str = \
+"""\
+ ⎛1       ⎞\n\
+O⎜─; x → ∞⎟\n\
+ ⎝x       ⎠\
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = O(x**2 + y**2, (x, oo), (y, oo))
+    ascii_str = \
+"""\
+ / 2    2                    \\\n\
+O\\x  + y ; (x, y) -> (oo, oo)/\
+"""
+    ucode_str = \
+"""\
+ ⎛ 2    2                 ⎞\n\
+O⎝x  + y ; (x, y) → (∞, ∞)⎠\
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+
+def test_pretty_derivatives():
+    # Simple
+    expr = Derivative(log(x), x, evaluate=False)
+    ascii_str = \
+"""\
+d         \n\
+--(log(x))\n\
+dx        \
+"""
+    ucode_str = \
+"""\
+d         \n\
+──(log(x))\n\
+dx        \
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = Derivative(log(x), x, evaluate=False) + x
+    ascii_str_1 = \
+"""\
+    d         \n\
+x + --(log(x))\n\
+    dx        \
+"""
+    ascii_str_2 = \
+"""\
+d             \n\
+--(log(x)) + x\n\
+dx            \
+"""
+    ucode_str_1 = \
+"""\
+    d         \n\
+x + ──(log(x))\n\
+    dx        \
+"""
+    ucode_str_2 = \
+"""\
+d             \n\
+──(log(x)) + x\n\
+dx            \
+"""
+    assert pretty(expr) in [ascii_str_1, ascii_str_2]
+    assert upretty(expr) in [ucode_str_1, ucode_str_2]
+
+    # basic partial derivatives
+    expr = Derivative(log(x + y) + x, x)
+    ascii_str_1 = \
+"""\
+d                 \n\
+--(log(x + y) + x)\n\
+dx                \
+"""
+    ascii_str_2 = \
+"""\
+d                 \n\
+--(x + log(x + y))\n\
+dx                \
+"""
+    ucode_str_1 = \
+"""\
+∂                 \n\
+──(log(x + y) + x)\n\
+∂x                \
+"""
+    ucode_str_2 = \
+"""\
+∂                 \n\
+──(x + log(x + y))\n\
+∂x                \
+"""
+    assert pretty(expr) in [ascii_str_1, ascii_str_2]
+    assert upretty(expr) in [ucode_str_1, ucode_str_2], upretty(expr)
+
+    # Multiple symbols
+    expr = Derivative(log(x) + x**2, x, y)
+    ascii_str_1 = \
+"""\
+   2              \n\
+  d  /          2\\\n\
+-----\\log(x) + x /\n\
+dy dx             \
+"""
+    ascii_str_2 = \
+"""\
+   2              \n\
+  d  / 2         \\\n\
+-----\\x  + log(x)/\n\
+dy dx             \
+"""
+    ascii_str_3 = \
+"""\
+  2               \n\
+ d   / 2         \\\n\
+-----\\x  + log(x)/\n\
+dy dx             \
+"""
+    ucode_str_1 = \
+"""\
+   2              \n\
+  d  ⎛          2⎞\n\
+─────⎝log(x) + x ⎠\n\
+dy dx             \
+"""
+    ucode_str_2 = \
+"""\
+   2              \n\
+  d  ⎛ 2         ⎞\n\
+─────⎝x  + log(x)⎠\n\
+dy dx             \
+"""
+    ucode_str_3 = \
+"""\
+  2               \n\
+ d   ⎛ 2         ⎞\n\
+─────⎝x  + log(x)⎠\n\
+dy dx             \
+"""
+    assert pretty(expr) in [ascii_str_1, ascii_str_2, ascii_str_3]
+    assert upretty(expr) in [ucode_str_1, ucode_str_2, ucode_str_3]
+
+    expr = Derivative(2*x*y, y, x) + x**2
+    ascii_str_1 = \
+"""\
+   2             \n\
+  d             2\n\
+-----(2*x*y) + x \n\
+dx dy            \
+"""
+    ascii_str_2 = \
+"""\
+        2        \n\
+ 2     d         \n\
+x  + -----(2*x*y)\n\
+     dx dy       \
+"""
+    ascii_str_3 = \
+"""\
+       2         \n\
+ 2    d          \n\
+x  + -----(2*x*y)\n\
+     dx dy       \
+"""
+    ucode_str_1 = \
+"""\
+   2             \n\
+  ∂             2\n\
+─────(2⋅x⋅y) + x \n\
+∂x ∂y            \
+"""
+    ucode_str_2 = \
+"""\
+        2        \n\
+ 2     ∂         \n\
+x  + ─────(2⋅x⋅y)\n\
+     ∂x ∂y       \
+"""
+    ucode_str_3 = \
+"""\
+       2         \n\
+ 2    ∂          \n\
+x  + ─────(2⋅x⋅y)\n\
+     ∂x ∂y       \
+"""
+    assert pretty(expr) in [ascii_str_1, ascii_str_2, ascii_str_3]
+    assert upretty(expr) in [ucode_str_1, ucode_str_2, ucode_str_3]
+
+    expr = Derivative(2*x*y, x, x)
+    ascii_str = \
+"""\
+ 2        \n\
+d         \n\
+---(2*x*y)\n\
+  2       \n\
+dx        \
+"""
+    ucode_str = \
+"""\
+ 2        \n\
+∂         \n\
+───(2⋅x⋅y)\n\
+  2       \n\
+∂x        \
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = Derivative(2*x*y, x, 17)
+    ascii_str = \
+"""\
+ 17        \n\
+d          \n\
+----(2*x*y)\n\
+  17       \n\
+dx         \
+"""
+    ucode_str = \
+"""\
+ 17        \n\
+∂          \n\
+────(2⋅x⋅y)\n\
+  17       \n\
+∂x         \
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = Derivative(2*x*y, x, x, y)
+    ascii_str = \
+"""\
+   3         \n\
+  d          \n\
+------(2*x*y)\n\
+     2       \n\
+dy dx        \
+"""
+    ucode_str = \
+"""\
+   3         \n\
+  ∂          \n\
+──────(2⋅x⋅y)\n\
+     2       \n\
+∂y ∂x        \
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    # Greek letters
+    alpha = Symbol('alpha')
+    beta = Function('beta')
+    expr = beta(alpha).diff(alpha)
+    ascii_str = \
+"""\
+  d                \n\
+------(beta(alpha))\n\
+dalpha             \
+"""
+    ucode_str = \
+"""\
+d       \n\
+──(β(α))\n\
+dα      \
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = Derivative(f(x), (x, n))
+
+    ascii_str = \
+"""\
+ n       \n\
+d        \n\
+---(f(x))\n\
+  n      \n\
+dx       \
+"""
+    ucode_str = \
+"""\
+ n       \n\
+d        \n\
+───(f(x))\n\
+  n      \n\
+dx       \
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+
+def test_pretty_integrals():
+    expr = Integral(log(x), x)
+    ascii_str = \
+"""\
+  /         \n\
+ |          \n\
+ | log(x) dx\n\
+ |          \n\
+/           \
+"""
+    ucode_str = \
+"""\
+⌠          \n\
+⎮ log(x) dx\n\
+⌡          \
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = Integral(x**2, x)
+    ascii_str = \
+"""\
+  /     \n\
+ |      \n\
+ |  2   \n\
+ | x  dx\n\
+ |      \n\
+/       \
+"""
+    ucode_str = \
+"""\
+⌠      \n\
+⎮  2   \n\
+⎮ x  dx\n\
+⌡      \
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = Integral((sin(x))**2 / (tan(x))**2)
+    ascii_str = \
+"""\
+  /          \n\
+ |           \n\
+ |    2      \n\
+ | sin (x)   \n\
+ | ------- dx\n\
+ |    2      \n\
+ | tan (x)   \n\
+ |           \n\
+/            \
+"""
+    ucode_str = \
+"""\
+⌠           \n\
+⎮    2      \n\
+⎮ sin (x)   \n\
+⎮ ─────── dx\n\
+⎮    2      \n\
+⎮ tan (x)   \n\
+⌡           \
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = Integral(x**(2**x), x)
+    ascii_str = \
+"""\
+  /        \n\
+ |         \n\
+ |  / x\\   \n\
+ |  \\2 /   \n\
+ | x     dx\n\
+ |         \n\
+/          \
+"""
+    ucode_str = \
+"""\
+⌠         \n\
+⎮  ⎛ x⎞   \n\
+⎮  ⎝2 ⎠   \n\
+⎮ x     dx\n\
+⌡         \
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = Integral(x**2, (x, 1, 2))
+    ascii_str = \
+"""\
+  2      \n\
+  /      \n\
+ |       \n\
+ |   2   \n\
+ |  x  dx\n\
+ |       \n\
+/        \n\
+1        \
+"""
+    ucode_str = \
+"""\
+2      \n\
+⌠      \n\
+⎮  2   \n\
+⎮ x  dx\n\
+⌡      \n\
+1      \
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = Integral(x**2, (x, Rational(1, 2), 10))
+    ascii_str = \
+"""\
+ 10      \n\
+  /      \n\
+ |       \n\
+ |   2   \n\
+ |  x  dx\n\
+ |       \n\
+/        \n\
+1/2      \
+"""
+    ucode_str = \
+"""\
+10       \n\
+⌠        \n\
+⎮    2   \n\
+⎮   x  dx\n\
+⌡        \n\
+1/2      \
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = Integral(x**2*y**2, x, y)
+    ascii_str = \
+"""\
+  /  /           \n\
+ |  |            \n\
+ |  |  2  2      \n\
+ |  | x *y  dx dy\n\
+ |  |            \n\
+/  /             \
+"""
+    ucode_str = \
+"""\
+⌠ ⌠            \n\
+⎮ ⎮  2  2      \n\
+⎮ ⎮ x ⋅y  dx dy\n\
+⌡ ⌡            \
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = Integral(sin(th)/cos(ph), (th, 0, pi), (ph, 0, 2*pi))
+    ascii_str = \
+"""\
+ 2*pi pi                           \n\
+   /   /                           \n\
+  |   |                            \n\
+  |   |  sin(theta)                \n\
+  |   |  ---------- d(theta) d(phi)\n\
+  |   |   cos(phi)                 \n\
+  |   |                            \n\
+ /   /                             \n\
+0    0                             \
+"""
+    ucode_str = \
+"""\
+2⋅π π             \n\
+ ⌠  ⌠             \n\
+ ⎮  ⎮ sin(θ)      \n\
+ ⎮  ⎮ ────── dθ dφ\n\
+ ⎮  ⎮ cos(φ)      \n\
+ ⌡  ⌡             \n\
+ 0  0             \
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+
+def test_pretty_matrix():
+    # Empty Matrix
+    expr = Matrix()
+    ascii_str = "[]"
+    unicode_str = "[]"
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == unicode_str
+    expr = Matrix(2, 0, lambda i, j: 0)
+    ascii_str = "[]"
+    unicode_str = "[]"
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == unicode_str
+    expr = Matrix(0, 2, lambda i, j: 0)
+    ascii_str = "[]"
+    unicode_str = "[]"
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == unicode_str
+    expr = Matrix([[x**2 + 1, 1], [y, x + y]])
+    ascii_str_1 = \
+"""\
+[     2       ]
+[1 + x     1  ]
+[             ]
+[  y     x + y]\
+"""
+    ascii_str_2 = \
+"""\
+[ 2           ]
+[x  + 1    1  ]
+[             ]
+[  y     x + y]\
+"""
+    ucode_str_1 = \
+"""\
+⎡     2       ⎤
+⎢1 + x     1  ⎥
+⎢             ⎥
+⎣  y     x + y⎦\
+"""
+    ucode_str_2 = \
+"""\
+⎡ 2           ⎤
+⎢x  + 1    1  ⎥
+⎢             ⎥
+⎣  y     x + y⎦\
+"""
+    assert pretty(expr) in [ascii_str_1, ascii_str_2]
+    assert upretty(expr) in [ucode_str_1, ucode_str_2]
+
+    expr = Matrix([[x/y, y, th], [0, exp(I*k*ph), 1]])
+    ascii_str = \
+"""\
+[x                 ]
+[-     y      theta]
+[y                 ]
+[                  ]
+[    I*k*phi       ]
+[0  e           1  ]\
+"""
+    ucode_str = \
+"""\
+⎡x           ⎤
+⎢─    y     θ⎥
+⎢y           ⎥
+⎢            ⎥
+⎢    ⅈ⋅k⋅φ   ⎥
+⎣0  ℯ       1⎦\
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    unicode_str = \
+"""\
+⎡v̇_msc_00     0         0    ⎤
+⎢                            ⎥
+⎢   0      v̇_msc_01     0    ⎥
+⎢                            ⎥
+⎣   0         0      v̇_msc_02⎦\
+"""
+
+    expr = diag(*MatrixSymbol('vdot_msc',1,3))
+    assert upretty(expr) == unicode_str
+
+
+def test_pretty_ndim_arrays():
+    x, y, z, w = symbols("x y z w")
+
+    for ArrayType in (ImmutableDenseNDimArray, ImmutableSparseNDimArray, MutableDenseNDimArray, MutableSparseNDimArray):
+        # Basic: scalar array
+        M = ArrayType(x)
+
+        assert pretty(M) == "x"
+        assert upretty(M) == "x"
+
+        M = ArrayType([[1/x, y], [z, w]])
+        M1 = ArrayType([1/x, y, z])
+
+        M2 = tensorproduct(M1, M)
+        M3 = tensorproduct(M, M)
+
+        ascii_str = \
+"""\
+[1   ]\n\
+[-  y]\n\
+[x   ]\n\
+[    ]\n\
+[z  w]\
+"""
+        ucode_str = \
+"""\
+⎡1   ⎤\n\
+⎢─  y⎥\n\
+⎢x   ⎥\n\
+⎢    ⎥\n\
+⎣z  w⎦\
+"""
+        assert pretty(M) == ascii_str
+        assert upretty(M) == ucode_str
+
+        ascii_str = \
+"""\
+[1      ]\n\
+[-  y  z]\n\
+[x      ]\
+"""
+        ucode_str = \
+"""\
+⎡1      ⎤\n\
+⎢─  y  z⎥\n\
+⎣x      ⎦\
+"""
+        assert pretty(M1) == ascii_str
+        assert upretty(M1) == ucode_str
+
+        ascii_str = \
+"""\
+[[1   y]                       ]\n\
+[[--  -]              [z      ]]\n\
+[[ 2  x]  [ y    2 ]  [-   y*z]]\n\
+[[x    ]  [ -   y  ]  [x      ]]\n\
+[[     ]  [ x      ]  [       ]]\n\
+[[z   w]  [        ]  [ 2     ]]\n\
+[[-   -]  [y*z  w*y]  [z   w*z]]\n\
+[[x   x]                       ]\
+"""
+        ucode_str = \
+"""\
+⎡⎡1   y⎤                       ⎤\n\
+⎢⎢──  ─⎥              ⎡z      ⎤⎥\n\
+⎢⎢ 2  x⎥  ⎡ y    2 ⎤  ⎢─   y⋅z⎥⎥\n\
+⎢⎢x    ⎥  ⎢ ─   y  ⎥  ⎢x      ⎥⎥\n\
+⎢⎢     ⎥  ⎢ x      ⎥  ⎢       ⎥⎥\n\
+⎢⎢z   w⎥  ⎢        ⎥  ⎢ 2     ⎥⎥\n\
+⎢⎢─   ─⎥  ⎣y⋅z  w⋅y⎦  ⎣z   w⋅z⎦⎥\n\
+⎣⎣x   x⎦                       ⎦\
+"""
+        assert pretty(M2) == ascii_str
+        assert upretty(M2) == ucode_str
+
+        ascii_str = \
+"""\
+[ [1   y]             ]\n\
+[ [--  -]             ]\n\
+[ [ 2  x]   [ y    2 ]]\n\
+[ [x    ]   [ -   y  ]]\n\
+[ [     ]   [ x      ]]\n\
+[ [z   w]   [        ]]\n\
+[ [-   -]   [y*z  w*y]]\n\
+[ [x   x]             ]\n\
+[                     ]\n\
+[[z      ]  [ w      ]]\n\
+[[-   y*z]  [ -   w*y]]\n\
+[[x      ]  [ x      ]]\n\
+[[       ]  [        ]]\n\
+[[ 2     ]  [      2 ]]\n\
+[[z   w*z]  [w*z  w  ]]\
+"""
+        ucode_str = \
+"""\
+⎡ ⎡1   y⎤             ⎤\n\
+⎢ ⎢──  ─⎥             ⎥\n\
+⎢ ⎢ 2  x⎥   ⎡ y    2 ⎤⎥\n\
+⎢ ⎢x    ⎥   ⎢ ─   y  ⎥⎥\n\
+⎢ ⎢     ⎥   ⎢ x      ⎥⎥\n\
+⎢ ⎢z   w⎥   ⎢        ⎥⎥\n\
+⎢ ⎢─   ─⎥   ⎣y⋅z  w⋅y⎦⎥\n\
+⎢ ⎣x   x⎦             ⎥\n\
+⎢                     ⎥\n\
+⎢⎡z      ⎤  ⎡ w      ⎤⎥\n\
+⎢⎢─   y⋅z⎥  ⎢ ─   w⋅y⎥⎥\n\
+⎢⎢x      ⎥  ⎢ x      ⎥⎥\n\
+⎢⎢       ⎥  ⎢        ⎥⎥\n\
+⎢⎢ 2     ⎥  ⎢      2 ⎥⎥\n\
+⎣⎣z   w⋅z⎦  ⎣w⋅z  w  ⎦⎦\
+"""
+        assert pretty(M3) == ascii_str
+        assert upretty(M3) == ucode_str
+
+        Mrow = ArrayType([[x, y, 1 / z]])
+        Mcolumn = ArrayType([[x], [y], [1 / z]])
+        Mcol2 = ArrayType([Mcolumn.tolist()])
+
+        ascii_str = \
+"""\
+[[      1]]\n\
+[[x  y  -]]\n\
+[[      z]]\
+"""
+        ucode_str = \
+"""\
+⎡⎡      1⎤⎤\n\
+⎢⎢x  y  ─⎥⎥\n\
+⎣⎣      z⎦⎦\
+"""
+        assert pretty(Mrow) == ascii_str
+        assert upretty(Mrow) == ucode_str
+
+        ascii_str = \
+"""\
+[x]\n\
+[ ]\n\
+[y]\n\
+[ ]\n\
+[1]\n\
+[-]\n\
+[z]\
+"""
+        ucode_str = \
+"""\
+⎡x⎤\n\
+⎢ ⎥\n\
+⎢y⎥\n\
+⎢ ⎥\n\
+⎢1⎥\n\
+⎢─⎥\n\
+⎣z⎦\
+"""
+        assert pretty(Mcolumn) == ascii_str
+        assert upretty(Mcolumn) == ucode_str
+
+        ascii_str = \
+"""\
+[[x]]\n\
+[[ ]]\n\
+[[y]]\n\
+[[ ]]\n\
+[[1]]\n\
+[[-]]\n\
+[[z]]\
+"""
+        ucode_str = \
+"""\
+⎡⎡x⎤⎤\n\
+⎢⎢ ⎥⎥\n\
+⎢⎢y⎥⎥\n\
+⎢⎢ ⎥⎥\n\
+⎢⎢1⎥⎥\n\
+⎢⎢─⎥⎥\n\
+⎣⎣z⎦⎦\
+"""
+        assert pretty(Mcol2) == ascii_str
+        assert upretty(Mcol2) == ucode_str
+
+
+def test_tensor_TensorProduct():
+    A = MatrixSymbol("A", 3, 3)
+    B = MatrixSymbol("B", 3, 3)
+    assert upretty(TensorProduct(A, B)) == "A\u2297B"
+    assert upretty(TensorProduct(A, B, A)) == "A\u2297B\u2297A"
+
+
+def test_diffgeom_print_WedgeProduct():
+    from sympy.diffgeom.rn import R2
+    from sympy.diffgeom import WedgeProduct
+    wp = WedgeProduct(R2.dx, R2.dy)
+    assert upretty(wp) == "ⅆ x∧ⅆ y"
+    assert pretty(wp) == r"d x/\d y"
+
+
+def test_Adjoint():
+    X = MatrixSymbol('X', 2, 2)
+    Y = MatrixSymbol('Y', 2, 2)
+    assert pretty(Adjoint(X)) == " +\nX "
+    assert pretty(Adjoint(X + Y)) == "       +\n(X + Y) "
+    assert pretty(Adjoint(X) + Adjoint(Y)) == " +    +\nX  + Y "
+    assert pretty(Adjoint(X*Y)) == "     +\n(X*Y) "
+    assert pretty(Adjoint(Y)*Adjoint(X)) == " +  +\nY *X "
+    assert pretty(Adjoint(X**2)) == "    +\n/ 2\\ \n\\X / "
+    assert pretty(Adjoint(X)**2) == "    2\n/ +\\ \n\\X / "
+    assert pretty(Adjoint(Inverse(X))) == "     +\n/ -1\\ \n\\X  / "
+    assert pretty(Inverse(Adjoint(X))) == "    -1\n/ +\\  \n\\X /  "
+    assert pretty(Adjoint(Transpose(X))) == "    +\n/ T\\ \n\\X / "
+    assert pretty(Transpose(Adjoint(X))) == "    T\n/ +\\ \n\\X / "
+    assert upretty(Adjoint(X)) == " †\nX "
+    assert upretty(Adjoint(X + Y)) == "       †\n(X + Y) "
+    assert upretty(Adjoint(X) + Adjoint(Y)) == " †    †\nX  + Y "
+    assert upretty(Adjoint(X*Y)) == "     †\n(X⋅Y) "
+    assert upretty(Adjoint(Y)*Adjoint(X)) == " †  †\nY ⋅X "
+    assert upretty(Adjoint(X**2)) == \
+        "    †\n⎛ 2⎞ \n⎝X ⎠ "
+    assert upretty(Adjoint(X)**2) == \
+        "    2\n⎛ †⎞ \n⎝X ⎠ "
+    assert upretty(Adjoint(Inverse(X))) == \
+        "     †\n⎛ -1⎞ \n⎝X  ⎠ "
+    assert upretty(Inverse(Adjoint(X))) == \
+        "    -1\n⎛ †⎞  \n⎝X ⎠  "
+    assert upretty(Adjoint(Transpose(X))) == \
+        "    †\n⎛ T⎞ \n⎝X ⎠ "
+    assert upretty(Transpose(Adjoint(X))) == \
+        "    T\n⎛ †⎞ \n⎝X ⎠ "
+    m = Matrix(((1, 2), (3, 4)))
+    assert upretty(Adjoint(m)) == \
+        '      †\n'\
+        '⎡1  2⎤ \n'\
+        '⎢    ⎥ \n'\
+        '⎣3  4⎦ '
+    assert upretty(Adjoint(m+X)) == \
+        '            †\n'\
+        '⎛⎡1  2⎤    ⎞ \n'\
+        '⎜⎢    ⎥ + X⎟ \n'\
+        '⎝⎣3  4⎦    ⎠ '
+    assert upretty(Adjoint(BlockMatrix(((OneMatrix(2, 2), X),
+                                        (m, ZeroMatrix(2, 2)))))) == \
+        '           †\n'\
+        '⎡  𝟙     X⎤ \n'\
+        '⎢         ⎥ \n'\
+        '⎢⎡1  2⎤   ⎥ \n'\
+        '⎢⎢    ⎥  𝟘⎥ \n'\
+        '⎣⎣3  4⎦   ⎦ '
+
+
+def test_Transpose():
+    X = MatrixSymbol('X', 2, 2)
+    Y = MatrixSymbol('Y', 2, 2)
+    assert pretty(Transpose(X)) == " T\nX "
+    assert pretty(Transpose(X + Y)) == "       T\n(X + Y) "
+    assert pretty(Transpose(X) + Transpose(Y)) == " T    T\nX  + Y "
+    assert pretty(Transpose(X*Y)) == "     T\n(X*Y) "
+    assert pretty(Transpose(Y)*Transpose(X)) == " T  T\nY *X "
+    assert pretty(Transpose(X**2)) == "    T\n/ 2\\ \n\\X / "
+    assert pretty(Transpose(X)**2) == "    2\n/ T\\ \n\\X / "
+    assert pretty(Transpose(Inverse(X))) == "     T\n/ -1\\ \n\\X  / "
+    assert pretty(Inverse(Transpose(X))) == "    -1\n/ T\\  \n\\X /  "
+    assert upretty(Transpose(X)) == " T\nX "
+    assert upretty(Transpose(X + Y)) == "       T\n(X + Y) "
+    assert upretty(Transpose(X) + Transpose(Y)) == " T    T\nX  + Y "
+    assert upretty(Transpose(X*Y)) == "     T\n(X⋅Y) "
+    assert upretty(Transpose(Y)*Transpose(X)) == " T  T\nY ⋅X "
+    assert upretty(Transpose(X**2)) == \
+        "    T\n⎛ 2⎞ \n⎝X ⎠ "
+    assert upretty(Transpose(X)**2) == \
+        "    2\n⎛ T⎞ \n⎝X ⎠ "
+    assert upretty(Transpose(Inverse(X))) == \
+        "     T\n⎛ -1⎞ \n⎝X  ⎠ "
+    assert upretty(Inverse(Transpose(X))) == \
+        "    -1\n⎛ T⎞  \n⎝X ⎠  "
+    m = Matrix(((1, 2), (3, 4)))
+    assert upretty(Transpose(m)) == \
+        '      T\n'\
+        '⎡1  2⎤ \n'\
+        '⎢    ⎥ \n'\
+        '⎣3  4⎦ '
+    assert upretty(Transpose(m+X)) == \
+        '            T\n'\
+        '⎛⎡1  2⎤    ⎞ \n'\
+        '⎜⎢    ⎥ + X⎟ \n'\
+        '⎝⎣3  4⎦    ⎠ '
+    assert upretty(Transpose(BlockMatrix(((OneMatrix(2, 2), X),
+                                          (m, ZeroMatrix(2, 2)))))) == \
+        '           T\n'\
+        '⎡  𝟙     X⎤ \n'\
+        '⎢         ⎥ \n'\
+        '⎢⎡1  2⎤   ⎥ \n'\
+        '⎢⎢    ⎥  𝟘⎥ \n'\
+        '⎣⎣3  4⎦   ⎦ '
+
+
+def test_pretty_Trace_issue_9044():
+    X = Matrix([[1, 2], [3, 4]])
+    Y = Matrix([[2, 4], [6, 8]])
+    ascii_str_1 = \
+"""\
+  /[1  2]\\
+tr|[    ]|
+  \\[3  4]/\
+"""
+    ucode_str_1 = \
+"""\
+  ⎛⎡1  2⎤⎞
+tr⎜⎢    ⎥⎟
+  ⎝⎣3  4⎦⎠\
+"""
+    ascii_str_2 = \
+"""\
+  /[1  2]\\     /[2  4]\\
+tr|[    ]| + tr|[    ]|
+  \\[3  4]/     \\[6  8]/\
+"""
+    ucode_str_2 = \
+"""\
+  ⎛⎡1  2⎤⎞     ⎛⎡2  4⎤⎞
+tr⎜⎢    ⎥⎟ + tr⎜⎢    ⎥⎟
+  ⎝⎣3  4⎦⎠     ⎝⎣6  8⎦⎠\
+"""
+    assert pretty(Trace(X)) == ascii_str_1
+    assert upretty(Trace(X)) == ucode_str_1
+
+    assert pretty(Trace(X) + Trace(Y)) == ascii_str_2
+    assert upretty(Trace(X) + Trace(Y)) == ucode_str_2
+
+
+def test_MatrixSlice():
+    n = Symbol('n', integer=True)
+    x, y, z, w, t, = symbols('x y z w t')
+    X = MatrixSymbol('X', n, n)
+    Y = MatrixSymbol('Y', 10, 10)
+    Z = MatrixSymbol('Z', 10, 10)
+
+    expr = MatrixSlice(X, (None, None, None), (None, None, None))
+    assert pretty(expr) == upretty(expr) == 'X[:, :]'
+    expr = X[x:x + 1, y:y + 1]
+    assert pretty(expr) == upretty(expr) == 'X[x:x + 1, y:y + 1]'
+    expr = X[x:x + 1:2, y:y + 1:2]
+    assert pretty(expr) == upretty(expr) == 'X[x:x + 1:2, y:y + 1:2]'
+    expr = X[:x, y:]
+    assert pretty(expr) == upretty(expr) == 'X[:x, y:]'
+    expr = X[:x, y:]
+    assert pretty(expr) == upretty(expr) == 'X[:x, y:]'
+    expr = X[x:, :y]
+    assert pretty(expr) == upretty(expr) == 'X[x:, :y]'
+    expr = X[x:y, z:w]
+    assert pretty(expr) == upretty(expr) == 'X[x:y, z:w]'
+    expr = X[x:y:t, w:t:x]
+    assert pretty(expr) == upretty(expr) == 'X[x:y:t, w:t:x]'
+    expr = X[x::y, t::w]
+    assert pretty(expr) == upretty(expr) == 'X[x::y, t::w]'
+    expr = X[:x:y, :t:w]
+    assert pretty(expr) == upretty(expr) == 'X[:x:y, :t:w]'
+    expr = X[::x, ::y]
+    assert pretty(expr) == upretty(expr) == 'X[::x, ::y]'
+    expr = MatrixSlice(X, (0, None, None), (0, None, None))
+    assert pretty(expr) == upretty(expr) == 'X[:, :]'
+    expr = MatrixSlice(X, (None, n, None), (None, n, None))
+    assert pretty(expr) == upretty(expr) == 'X[:, :]'
+    expr = MatrixSlice(X, (0, n, None), (0, n, None))
+    assert pretty(expr) == upretty(expr) == 'X[:, :]'
+    expr = MatrixSlice(X, (0, n, 2), (0, n, 2))
+    assert pretty(expr) == upretty(expr) == 'X[::2, ::2]'
+    expr = X[1:2:3, 4:5:6]
+    assert pretty(expr) == upretty(expr) == 'X[1:2:3, 4:5:6]'
+    expr = X[1:3:5, 4:6:8]
+    assert pretty(expr) == upretty(expr) == 'X[1:3:5, 4:6:8]'
+    expr = X[1:10:2]
+    assert pretty(expr) == upretty(expr) == 'X[1:10:2, :]'
+    expr = Y[:5, 1:9:2]
+    assert pretty(expr) == upretty(expr) == 'Y[:5, 1:9:2]'
+    expr = Y[:5, 1:10:2]
+    assert pretty(expr) == upretty(expr) == 'Y[:5, 1::2]'
+    expr = Y[5, :5:2]
+    assert pretty(expr) == upretty(expr) == 'Y[5:6, :5:2]'
+    expr = X[0:1, 0:1]
+    assert pretty(expr) == upretty(expr) == 'X[:1, :1]'
+    expr = X[0:1:2, 0:1:2]
+    assert pretty(expr) == upretty(expr) == 'X[:1:2, :1:2]'
+    expr = (Y + Z)[2:, 2:]
+    assert pretty(expr) == upretty(expr) == '(Y + Z)[2:, 2:]'
+
+
+def test_MatrixExpressions():
+    n = Symbol('n', integer=True)
+    X = MatrixSymbol('X', n, n)
+
+    assert pretty(X) == upretty(X) == "X"
+
+    # Apply function elementwise (`ElementwiseApplyFunc`):
+
+    expr = (X.T*X).applyfunc(sin)
+
+    ascii_str = """\
+              / T  \\\n\
+(d -> sin(d)).\\X *X/\
+"""
+    ucode_str = """\
+             ⎛ T  ⎞\n\
+(d ↦ sin(d))˳⎝X ⋅X⎠\
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    lamda = Lambda(x, 1/x)
+    expr = (n*X).applyfunc(lamda)
+    ascii_str = """\
+/     1\\      \n\
+|x -> -|.(n*X)\n\
+\\     x/      \
+"""
+    ucode_str = """\
+⎛    1⎞      \n\
+⎜x ↦ ─⎟˳(n⋅X)\n\
+⎝    x⎠      \
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+
+def test_pretty_dotproduct():
+    from sympy.matrices.expressions.dotproduct import DotProduct
+    n = symbols("n", integer=True)
+    A = MatrixSymbol('A', n, 1)
+    B = MatrixSymbol('B', n, 1)
+    C = Matrix(1, 3, [1, 2, 3])
+    D = Matrix(1, 3, [1, 3, 4])
+
+    assert pretty(DotProduct(A, B)) == "A*B"
+    assert pretty(DotProduct(C, D)) == "[1  2  3]*[1  3  4]"
+    assert upretty(DotProduct(A, B)) == "A⋅B"
+    assert upretty(DotProduct(C, D)) == "[1  2  3]⋅[1  3  4]"
+
+
+def test_pretty_Determinant():
+    from sympy.matrices import Determinant, Inverse, BlockMatrix, OneMatrix, ZeroMatrix
+    m = Matrix(((1, 2), (3, 4)))
+    assert upretty(Determinant(m)) == '│1  2│\n│    │\n│3  4│'
+    assert upretty(Determinant(Inverse(m))) == \
+        '│      -1│\n'\
+        '│⎡1  2⎤  │\n'\
+        '│⎢    ⎥  │\n'\
+        '│⎣3  4⎦  │'
+    X = MatrixSymbol('X', 2, 2)
+    assert upretty(Determinant(X)) == '│X│'
+    assert upretty(Determinant(X + m)) == \
+        '│⎡1  2⎤    │\n'\
+        '│⎢    ⎥ + X│\n'\
+        '│⎣3  4⎦    │'
+    assert upretty(Determinant(BlockMatrix(((OneMatrix(2, 2), X),
+                                            (m, ZeroMatrix(2, 2)))))) == \
+        '│  𝟙     X│\n'\
+        '│         │\n'\
+        '│⎡1  2⎤   │\n'\
+        '│⎢    ⎥  𝟘│\n'\
+        '│⎣3  4⎦   │'
+
+
+def test_pretty_piecewise():
+    expr = Piecewise((x, x < 1), (x**2, True))
+    ascii_str = \
+"""\
+/x   for x < 1\n\
+|             \n\
+< 2           \n\
+|x   otherwise\n\
+\\             \
+"""
+    ucode_str = \
+"""\
+⎧x   for x < 1\n\
+⎪             \n\
+⎨ 2           \n\
+⎪x   otherwise\n\
+⎩             \
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = -Piecewise((x, x < 1), (x**2, True))
+    ascii_str = \
+"""\
+ //x   for x < 1\\\n\
+ ||             |\n\
+-|< 2           |\n\
+ ||x   otherwise|\n\
+ \\\\             /\
+"""
+    ucode_str = \
+"""\
+ ⎛⎧x   for x < 1⎞\n\
+ ⎜⎪             ⎟\n\
+-⎜⎨ 2           ⎟\n\
+ ⎜⎪x   otherwise⎟\n\
+ ⎝⎩             ⎠\
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = x + Piecewise((x, x > 0), (y, True)) + Piecewise((x/y, x < 2),
+    (y**2, x > 2), (1, True)) + 1
+    ascii_str = \
+"""\
+                      //x            \\    \n\
+                      ||-   for x < 2|    \n\
+                      ||y            |    \n\
+    //x  for x > 0\\   ||             |    \n\
+x + |<            | + |< 2           | + 1\n\
+    \\\\y  otherwise/   ||y   for x > 2|    \n\
+                      ||             |    \n\
+                      ||1   otherwise|    \n\
+                      \\\\             /    \
+"""
+    ucode_str = \
+"""\
+                      ⎛⎧x            ⎞    \n\
+                      ⎜⎪─   for x < 2⎟    \n\
+                      ⎜⎪y            ⎟    \n\
+    ⎛⎧x  for x > 0⎞   ⎜⎪             ⎟    \n\
+x + ⎜⎨            ⎟ + ⎜⎨ 2           ⎟ + 1\n\
+    ⎝⎩y  otherwise⎠   ⎜⎪y   for x > 2⎟    \n\
+                      ⎜⎪             ⎟    \n\
+                      ⎜⎪1   otherwise⎟    \n\
+                      ⎝⎩             ⎠    \
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = x - Piecewise((x, x > 0), (y, True)) + Piecewise((x/y, x < 2),
+    (y**2, x > 2), (1, True)) + 1
+    ascii_str = \
+"""\
+                      //x            \\    \n\
+                      ||-   for x < 2|    \n\
+                      ||y            |    \n\
+    //x  for x > 0\\   ||             |    \n\
+x - |<            | + |< 2           | + 1\n\
+    \\\\y  otherwise/   ||y   for x > 2|    \n\
+                      ||             |    \n\
+                      ||1   otherwise|    \n\
+                      \\\\             /    \
+"""
+    ucode_str = \
+"""\
+                      ⎛⎧x            ⎞    \n\
+                      ⎜⎪─   for x < 2⎟    \n\
+                      ⎜⎪y            ⎟    \n\
+    ⎛⎧x  for x > 0⎞   ⎜⎪             ⎟    \n\
+x - ⎜⎨            ⎟ + ⎜⎨ 2           ⎟ + 1\n\
+    ⎝⎩y  otherwise⎠   ⎜⎪y   for x > 2⎟    \n\
+                      ⎜⎪             ⎟    \n\
+                      ⎜⎪1   otherwise⎟    \n\
+                      ⎝⎩             ⎠    \
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = x*Piecewise((x, x > 0), (y, True))
+    ascii_str = \
+"""\
+  //x  for x > 0\\\n\
+x*|<            |\n\
+  \\\\y  otherwise/\
+"""
+    ucode_str = \
+"""\
+  ⎛⎧x  for x > 0⎞\n\
+x⋅⎜⎨            ⎟\n\
+  ⎝⎩y  otherwise⎠\
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = Piecewise((x, x > 0), (y, True))*Piecewise((x/y, x < 2), (y**2, x >
+    2), (1, True))
+    ascii_str = \
+"""\
+                //x            \\\n\
+                ||-   for x < 2|\n\
+                ||y            |\n\
+//x  for x > 0\\ ||             |\n\
+|<            |*|< 2           |\n\
+\\\\y  otherwise/ ||y   for x > 2|\n\
+                ||             |\n\
+                ||1   otherwise|\n\
+                \\\\             /\
+"""
+    ucode_str = \
+"""\
+                ⎛⎧x            ⎞\n\
+                ⎜⎪─   for x < 2⎟\n\
+                ⎜⎪y            ⎟\n\
+⎛⎧x  for x > 0⎞ ⎜⎪             ⎟\n\
+⎜⎨            ⎟⋅⎜⎨ 2           ⎟\n\
+⎝⎩y  otherwise⎠ ⎜⎪y   for x > 2⎟\n\
+                ⎜⎪             ⎟\n\
+                ⎜⎪1   otherwise⎟\n\
+                ⎝⎩             ⎠\
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = -Piecewise((x, x > 0), (y, True))*Piecewise((x/y, x < 2), (y**2, x
+        > 2), (1, True))
+    ascii_str = \
+"""\
+                 //x            \\\n\
+                 ||-   for x < 2|\n\
+                 ||y            |\n\
+ //x  for x > 0\\ ||             |\n\
+-|<            |*|< 2           |\n\
+ \\\\y  otherwise/ ||y   for x > 2|\n\
+                 ||             |\n\
+                 ||1   otherwise|\n\
+                 \\\\             /\
+"""
+    ucode_str = \
+"""\
+                 ⎛⎧x            ⎞\n\
+                 ⎜⎪─   for x < 2⎟\n\
+                 ⎜⎪y            ⎟\n\
+ ⎛⎧x  for x > 0⎞ ⎜⎪             ⎟\n\
+-⎜⎨            ⎟⋅⎜⎨ 2           ⎟\n\
+ ⎝⎩y  otherwise⎠ ⎜⎪y   for x > 2⎟\n\
+                 ⎜⎪             ⎟\n\
+                 ⎜⎪1   otherwise⎟\n\
+                 ⎝⎩             ⎠\
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = Piecewise((0, Abs(1/y) < 1), (1, Abs(y) < 1), (y*meijerg(((2, 1),
+        ()), ((), (1, 0)), 1/y), True))
+    ascii_str = \
+"""\
+/                                 1     \n\
+|            0               for --- < 1\n\
+|                                |y|    \n\
+|                                       \n\
+<            1               for |y| < 1\n\
+|                                       \n\
+|   __0, 2 /1, 2       | 1\\             \n\
+|y*/__     |           | -|   otherwise \n\
+\\  \\_|2, 2 \\      0, 1 | y/             \
+"""
+    ucode_str = \
+"""\
+⎧                                 1     \n\
+⎪            0               for ─── < 1\n\
+⎪                                │y│    \n\
+⎪                                       \n\
+⎨            1               for │y│ < 1\n\
+⎪                                       \n\
+⎪  ╭─╮0, 2 ⎛1, 2       │ 1⎞             \n\
+⎪y⋅│╶┐     ⎜           │ ─⎟   otherwise \n\
+⎩  ╰─╯2, 2 ⎝      0, 1 │ y⎠             \
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    # XXX: We have to use evaluate=False here because Piecewise._eval_power
+    # denests the power.
+    expr = Pow(Piecewise((x, x > 0), (y, True)), 2, evaluate=False)
+    ascii_str = \
+"""\
+               2\n\
+//x  for x > 0\\ \n\
+|<            | \n\
+\\\\y  otherwise/ \
+"""
+    ucode_str = \
+"""\
+               2\n\
+⎛⎧x  for x > 0⎞ \n\
+⎜⎨            ⎟ \n\
+⎝⎩y  otherwise⎠ \
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+
+def test_pretty_ITE():
+    expr = ITE(x, y, z)
+    assert pretty(expr) == (
+        '/y    for x  \n'
+        '<            \n'
+        '\\z  otherwise'
+        )
+    assert upretty(expr) == """\
+⎧y    for x  \n\
+⎨            \n\
+⎩z  otherwise\
+"""
+
+
+def test_pretty_seq():
+    expr = ()
+    ascii_str = \
+"""\
+()\
+"""
+    ucode_str = \
+"""\
+()\
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = []
+    ascii_str = \
+"""\
+[]\
+"""
+    ucode_str = \
+"""\
+[]\
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = {}
+    expr_2 = {}
+    ascii_str = \
+"""\
+{}\
+"""
+    ucode_str = \
+"""\
+{}\
+"""
+    assert pretty(expr) == ascii_str
+    assert pretty(expr_2) == ascii_str
+    assert upretty(expr) == ucode_str
+    assert upretty(expr_2) == ucode_str
+
+    expr = (1/x,)
+    ascii_str = \
+"""\
+ 1  \n\
+(-,)\n\
+ x  \
+"""
+    ucode_str = \
+"""\
+⎛1 ⎞\n\
+⎜─,⎟\n\
+⎝x ⎠\
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = [x**2, 1/x, x, y, sin(th)**2/cos(ph)**2]
+    ascii_str = \
+"""\
+                 2        \n\
+  2  1        sin (theta) \n\
+[x , -, x, y, -----------]\n\
+     x            2       \n\
+               cos (phi)  \
+"""
+    ucode_str = \
+"""\
+⎡                2   ⎤\n\
+⎢ 2  1        sin (θ)⎥\n\
+⎢x , ─, x, y, ───────⎥\n\
+⎢    x           2   ⎥\n\
+⎣             cos (φ)⎦\
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = (x**2, 1/x, x, y, sin(th)**2/cos(ph)**2)
+    ascii_str = \
+"""\
+                 2        \n\
+  2  1        sin (theta) \n\
+(x , -, x, y, -----------)\n\
+     x            2       \n\
+               cos (phi)  \
+"""
+    ucode_str = \
+"""\
+⎛                2   ⎞\n\
+⎜ 2  1        sin (θ)⎟\n\
+⎜x , ─, x, y, ───────⎟\n\
+⎜    x           2   ⎟\n\
+⎝             cos (φ)⎠\
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = Tuple(x**2, 1/x, x, y, sin(th)**2/cos(ph)**2)
+    ascii_str = \
+"""\
+                 2        \n\
+  2  1        sin (theta) \n\
+(x , -, x, y, -----------)\n\
+     x            2       \n\
+               cos (phi)  \
+"""
+    ucode_str = \
+"""\
+⎛                2   ⎞\n\
+⎜ 2  1        sin (θ)⎟\n\
+⎜x , ─, x, y, ───────⎟\n\
+⎜    x           2   ⎟\n\
+⎝             cos (φ)⎠\
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = {x: sin(x)}
+    expr_2 = Dict({x: sin(x)})
+    ascii_str = \
+"""\
+{x: sin(x)}\
+"""
+    ucode_str = \
+"""\
+{x: sin(x)}\
+"""
+    assert pretty(expr) == ascii_str
+    assert pretty(expr_2) == ascii_str
+    assert upretty(expr) == ucode_str
+    assert upretty(expr_2) == ucode_str
+
+    expr = {1/x: 1/y, x: sin(x)**2}
+    expr_2 = Dict({1/x: 1/y, x: sin(x)**2})
+    ascii_str = \
+"""\
+ 1  1        2    \n\
+{-: -, x: sin (x)}\n\
+ x  y             \
+"""
+    ucode_str = \
+"""\
+⎧1  1        2   ⎫\n\
+⎨─: ─, x: sin (x)⎬\n\
+⎩x  y            ⎭\
+"""
+    assert pretty(expr) == ascii_str
+    assert pretty(expr_2) == ascii_str
+    assert upretty(expr) == ucode_str
+    assert upretty(expr_2) == ucode_str
+
+    # There used to be a bug with pretty-printing sequences of even height.
+    expr = [x**2]
+    ascii_str = \
+"""\
+  2 \n\
+[x ]\
+"""
+    ucode_str = \
+"""\
+⎡ 2⎤\n\
+⎣x ⎦\
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = (x**2,)
+    ascii_str = \
+"""\
+  2  \n\
+(x ,)\
+"""
+    ucode_str = \
+"""\
+⎛ 2 ⎞\n\
+⎝x ,⎠\
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = Tuple(x**2)
+    ascii_str = \
+"""\
+  2  \n\
+(x ,)\
+"""
+    ucode_str = \
+"""\
+⎛ 2 ⎞\n\
+⎝x ,⎠\
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = {x**2: 1}
+    expr_2 = Dict({x**2: 1})
+    ascii_str = \
+"""\
+  2    \n\
+{x : 1}\
+"""
+    ucode_str = \
+"""\
+⎧ 2   ⎫\n\
+⎨x : 1⎬\n\
+⎩     ⎭\
+"""
+    assert pretty(expr) == ascii_str
+    assert pretty(expr_2) == ascii_str
+    assert upretty(expr) == ucode_str
+    assert upretty(expr_2) == ucode_str
+
+
+def test_any_object_in_sequence():
+    # Cf. issue 5306
+    b1 = Basic()
+    b2 = Basic(Basic())
+
+    expr = [b2, b1]
+    assert pretty(expr) == "[Basic(Basic()), Basic()]"
+    assert upretty(expr) == "[Basic(Basic()), Basic()]"
+
+    expr = {b2, b1}
+    assert pretty(expr) == "{Basic(), Basic(Basic())}"
+    assert upretty(expr) == "{Basic(), Basic(Basic())}"
+
+    expr = {b2: b1, b1: b2}
+    expr2 = Dict({b2: b1, b1: b2})
+    assert pretty(expr) == "{Basic(): Basic(Basic()), Basic(Basic()): Basic()}"
+    assert pretty(
+        expr2) == "{Basic(): Basic(Basic()), Basic(Basic()): Basic()}"
+    assert upretty(
+        expr) == "{Basic(): Basic(Basic()), Basic(Basic()): Basic()}"
+    assert upretty(
+        expr2) == "{Basic(): Basic(Basic()), Basic(Basic()): Basic()}"
+
+
+def test_print_builtin_set():
+    assert pretty(set()) == 'set()'
+    assert upretty(set()) == 'set()'
+
+    assert pretty(frozenset()) == 'frozenset()'
+    assert upretty(frozenset()) == 'frozenset()'
+
+    s1 = {1/x, x}
+    s2 = frozenset(s1)
+
+    assert pretty(s1) == \
+"""\
+ 1    \n\
+{-, x}
+ x    \
+"""
+    assert upretty(s1) == \
+"""\
+⎧1   ⎫
+⎨─, x⎬
+⎩x   ⎭\
+"""
+
+    assert pretty(s2) == \
+"""\
+           1     \n\
+frozenset({-, x})
+           x     \
+"""
+    assert upretty(s2) == \
+"""\
+         ⎛⎧1   ⎫⎞
+frozenset⎜⎨─, x⎬⎟
+         ⎝⎩x   ⎭⎠\
+"""
+
+
+def test_pretty_sets():
+    s = FiniteSet
+    assert pretty(s(*[x*y, x**2])) == \
+"""\
+  2      \n\
+{x , x*y}\
+"""
+    assert pretty(s(*range(1, 6))) == "{1, 2, 3, 4, 5}"
+    assert pretty(s(*range(1, 13))) == "{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}"
+
+    assert pretty({x*y, x**2}) == \
+"""\
+  2      \n\
+{x , x*y}\
+"""
+    assert pretty(set(range(1, 6))) == "{1, 2, 3, 4, 5}"
+    assert pretty(set(range(1, 13))) == \
+        "{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}"
+
+    assert pretty(frozenset([x*y, x**2])) == \
+"""\
+            2       \n\
+frozenset({x , x*y})\
+"""
+    assert pretty(frozenset(range(1, 6))) == "frozenset({1, 2, 3, 4, 5})"
+    assert pretty(frozenset(range(1, 13))) == \
+        "frozenset({1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12})"
+
+    assert pretty(Range(0, 3, 1)) == '{0, 1, 2}'
+
+    ascii_str = '{0, 1, ..., 29}'
+    ucode_str = '{0, 1, …, 29}'
+    assert pretty(Range(0, 30, 1)) == ascii_str
+    assert upretty(Range(0, 30, 1)) == ucode_str
+
+    ascii_str = '{30, 29, ..., 2}'
+    ucode_str = '{30, 29, …, 2}'
+    assert pretty(Range(30, 1, -1)) == ascii_str
+    assert upretty(Range(30, 1, -1)) == ucode_str
+
+    ascii_str = '{0, 2, ...}'
+    ucode_str = '{0, 2, …}'
+    assert pretty(Range(0, oo, 2)) == ascii_str
+    assert upretty(Range(0, oo, 2)) == ucode_str
+
+    ascii_str = '{..., 2, 0}'
+    ucode_str = '{…, 2, 0}'
+    assert pretty(Range(oo, -2, -2)) == ascii_str
+    assert upretty(Range(oo, -2, -2)) == ucode_str
+
+    ascii_str = '{-2, -3, ...}'
+    ucode_str = '{-2, -3, …}'
+    assert pretty(Range(-2, -oo, -1)) == ascii_str
+    assert upretty(Range(-2, -oo, -1)) == ucode_str
+
+
+def test_pretty_SetExpr():
+    iv = Interval(1, 3)
+    se = SetExpr(iv)
+    ascii_str = "SetExpr([1, 3])"
+    ucode_str = "SetExpr([1, 3])"
+    assert pretty(se) == ascii_str
+    assert upretty(se) == ucode_str
+
+
+def test_pretty_ImageSet():
+    imgset = ImageSet(Lambda((x, y), x + y), {1, 2, 3}, {3, 4})
+    ascii_str = '{x + y | x in {1, 2, 3}, y in {3, 4}}'
+    ucode_str = '{x + y │ x ∊ {1, 2, 3}, y ∊ {3, 4}}'
+    assert pretty(imgset) == ascii_str
+    assert upretty(imgset) == ucode_str
+
+    imgset = ImageSet(Lambda(((x, y),), x + y), ProductSet({1, 2, 3}, {3, 4}))
+    ascii_str = '{x + y | (x, y) in {1, 2, 3} x {3, 4}}'
+    ucode_str = '{x + y │ (x, y) ∊ {1, 2, 3} × {3, 4}}'
+    assert pretty(imgset) == ascii_str
+    assert upretty(imgset) == ucode_str
+
+    imgset = ImageSet(Lambda(x, x**2), S.Naturals)
+    ascii_str = '''\
+  2                 \n\
+{x  | x in Naturals}'''
+    ucode_str = '''\
+⎧ 2 │      ⎫\n\
+⎨x  │ x ∊ ℕ⎬\n\
+⎩   │      ⎭'''
+    assert pretty(imgset) == ascii_str
+    assert upretty(imgset) == ucode_str
+
+    # TODO: The "x in N" parts below should be centered independently of the
+    # 1/x**2 fraction
+    imgset = ImageSet(Lambda(x, 1/x**2), S.Naturals)
+    ascii_str = '''\
+ 1                  \n\
+{-- | x in Naturals}
+  2                 \n\
+ x                  '''
+    ucode_str = '''\
+⎧1  │      ⎫\n\
+⎪── │ x ∊ ℕ⎪\n\
+⎨ 2 │      ⎬\n\
+⎪x  │      ⎪\n\
+⎩   │      ⎭'''
+    assert pretty(imgset) == ascii_str
+    assert upretty(imgset) == ucode_str
+
+    imgset = ImageSet(Lambda((x, y), 1/(x + y)**2), S.Naturals, S.Naturals)
+    ascii_str = '''\
+    1                                    \n\
+{-------- | x in Naturals, y in Naturals}
+        2                                \n\
+ (x + y)                                 '''
+    ucode_str = '''\
+⎧   1     │             ⎫
+⎪──────── │ x ∊ ℕ, y ∊ ℕ⎪
+⎨       2 │             ⎬
+⎪(x + y)  │             ⎪
+⎩         │             ⎭'''
+    assert pretty(imgset) == ascii_str
+    assert upretty(imgset) == ucode_str
+
+    # issue 23449 centering issue
+    assert upretty([Symbol("ihat") / (Symbol("i") + 1)]) == '''\
+⎡  î  ⎤
+⎢─────⎥
+⎣i + 1⎦\
+'''
+    assert upretty(Matrix([Symbol("ihat"), Symbol("i") + 1])) == '''\
+⎡  î  ⎤
+⎢     ⎥
+⎣i + 1⎦\
+'''
+
+
+def test_pretty_ConditionSet():
+    ascii_str = '{x | x in (-oo, oo) and sin(x) = 0}'
+    ucode_str = '{x │ x ∊ ℝ ∧ (sin(x) = 0)}'
+    assert pretty(ConditionSet(x, Eq(sin(x), 0), S.Reals)) == ascii_str
+    assert upretty(ConditionSet(x, Eq(sin(x), 0), S.Reals)) == ucode_str
+
+    assert pretty(ConditionSet(x, Contains(x, S.Reals, evaluate=False), FiniteSet(1))) == '{1}'
+    assert upretty(ConditionSet(x, Contains(x, S.Reals, evaluate=False), FiniteSet(1))) == '{1}'
+
+    assert pretty(ConditionSet(x, And(x > 1, x < -1), FiniteSet(1, 2, 3))) == "EmptySet"
+    assert upretty(ConditionSet(x, And(x > 1, x < -1), FiniteSet(1, 2, 3))) == "∅"
+
+    assert pretty(ConditionSet(x, Or(x > 1, x < -1), FiniteSet(1, 2))) == '{2}'
+    assert upretty(ConditionSet(x, Or(x > 1, x < -1), FiniteSet(1, 2))) == '{2}'
+
+    condset = ConditionSet(x, 1/x**2 > 0)
+    ascii_str = '''\
+     1      \n\
+{x | -- > 0}
+      2     \n\
+     x      '''
+    ucode_str = '''\
+⎧  │ ⎛1     ⎞⎫
+⎪x │ ⎜── > 0⎟⎪
+⎨  │ ⎜ 2    ⎟⎬
+⎪  │ ⎝x     ⎠⎪
+⎩  │         ⎭'''
+    assert pretty(condset) == ascii_str
+    assert upretty(condset) == ucode_str
+
+    condset = ConditionSet(x, 1/x**2 > 0, S.Reals)
+    ascii_str = '''\
+                        1      \n\
+{x | x in (-oo, oo) and -- > 0}
+                         2     \n\
+                        x      '''
+    ucode_str = '''\
+⎧  │         ⎛1     ⎞⎫
+⎪x │ x ∊ ℝ ∧ ⎜── > 0⎟⎪
+⎨  │         ⎜ 2    ⎟⎬
+⎪  │         ⎝x     ⎠⎪
+⎩  │                 ⎭'''
+    assert pretty(condset) == ascii_str
+    assert upretty(condset) == ucode_str
+
+
+def test_pretty_ComplexRegion():
+    from sympy.sets.fancysets import ComplexRegion
+    cregion = ComplexRegion(Interval(3, 5)*Interval(4, 6))
+    ascii_str = '{x + y*I | x, y in [3, 5] x [4, 6]}'
+    ucode_str = '{x + y⋅ⅈ │ x, y ∊ [3, 5] × [4, 6]}'
+    assert pretty(cregion) == ascii_str
+    assert upretty(cregion) == ucode_str
+
+    cregion = ComplexRegion(Interval(0, 1)*Interval(0, 2*pi), polar=True)
+    ascii_str = '{r*(I*sin(theta) + cos(theta)) | r, theta in [0, 1] x [0, 2*pi)}'
+    ucode_str = '{r⋅(ⅈ⋅sin(θ) + cos(θ)) │ r, θ ∊ [0, 1] × [0, 2⋅π)}'
+    assert pretty(cregion) == ascii_str
+    assert upretty(cregion) == ucode_str
+
+    cregion = ComplexRegion(Interval(3, 1/a**2)*Interval(4, 6))
+    ascii_str = '''\
+                       1            \n\
+{x + y*I | x, y in [3, --] x [4, 6]}
+                        2           \n\
+                       a            '''
+    ucode_str = '''\
+⎧        │        ⎡   1 ⎤         ⎫
+⎪x + y⋅ⅈ │ x, y ∊ ⎢3, ──⎥ × [4, 6]⎪
+⎨        │        ⎢    2⎥         ⎬
+⎪        │        ⎣   a ⎦         ⎪
+⎩        │                        ⎭'''
+    assert pretty(cregion) == ascii_str
+    assert upretty(cregion) == ucode_str
+
+    cregion = ComplexRegion(Interval(0, 1/a**2)*Interval(0, 2*pi), polar=True)
+    ascii_str = '''\
+                                                 1               \n\
+{r*(I*sin(theta) + cos(theta)) | r, theta in [0, --] x [0, 2*pi)}
+                                                  2              \n\
+                                                 a               '''
+    ucode_str = '''\
+⎧                      │        ⎡   1 ⎤           ⎫
+⎪r⋅(ⅈ⋅sin(θ) + cos(θ)) │ r, θ ∊ ⎢0, ──⎥ × [0, 2⋅π)⎪
+⎨                      │        ⎢    2⎥           ⎬
+⎪                      │        ⎣   a ⎦           ⎪
+⎩                      │                          ⎭'''
+    assert pretty(cregion) == ascii_str
+    assert upretty(cregion) == ucode_str
+
+
+def test_pretty_Union_issue_10414():
+    a, b = Interval(2, 3), Interval(4, 7)
+    ucode_str = '[2, 3] ∪ [4, 7]'
+    ascii_str = '[2, 3] U [4, 7]'
+    assert upretty(Union(a, b)) == ucode_str
+    assert pretty(Union(a, b)) == ascii_str
+
+
+def test_pretty_Intersection_issue_10414():
+    x, y, z, w = symbols('x, y, z, w')
+    a, b = Interval(x, y), Interval(z, w)
+    ucode_str = '[x, y] ∩ [z, w]'
+    ascii_str = '[x, y] n [z, w]'
+    assert upretty(Intersection(a, b)) == ucode_str
+    assert pretty(Intersection(a, b)) == ascii_str
+
+
+def test_ProductSet_exponent():
+    ucode_str = '      1\n[0, 1] '
+    assert upretty(Interval(0, 1)**1) == ucode_str
+    ucode_str = '      2\n[0, 1] '
+    assert upretty(Interval(0, 1)**2) == ucode_str
+
+
+def test_ProductSet_parenthesis():
+    ucode_str = '([4, 7] × {1, 2}) ∪ ([2, 3] × [4, 7])'
+
+    a, b = Interval(2, 3), Interval(4, 7)
+    assert upretty(Union(a*b, b*FiniteSet(1, 2))) == ucode_str
+
+
+def test_ProductSet_prod_char_issue_10413():
+    ascii_str = '[2, 3] x [4, 7]'
+    ucode_str = '[2, 3] × [4, 7]'
+
+    a, b = Interval(2, 3), Interval(4, 7)
+    assert pretty(a*b) == ascii_str
+    assert upretty(a*b) == ucode_str
+
+
+def test_pretty_sequences():
+    s1 = SeqFormula(a**2, (0, oo))
+    s2 = SeqPer((1, 2))
+
+    ascii_str = '[0, 1, 4, 9, ...]'
+    ucode_str = '[0, 1, 4, 9, …]'
+
+    assert pretty(s1) == ascii_str
+    assert upretty(s1) == ucode_str
+
+    ascii_str = '[1, 2, 1, 2, ...]'
+    ucode_str = '[1, 2, 1, 2, …]'
+    assert pretty(s2) == ascii_str
+    assert upretty(s2) == ucode_str
+
+    s3 = SeqFormula(a**2, (0, 2))
+    s4 = SeqPer((1, 2), (0, 2))
+
+    ascii_str = '[0, 1, 4]'
+    ucode_str = '[0, 1, 4]'
+
+    assert pretty(s3) == ascii_str
+    assert upretty(s3) == ucode_str
+
+    ascii_str = '[1, 2, 1]'
+    ucode_str = '[1, 2, 1]'
+    assert pretty(s4) == ascii_str
+    assert upretty(s4) == ucode_str
+
+    s5 = SeqFormula(a**2, (-oo, 0))
+    s6 = SeqPer((1, 2), (-oo, 0))
+
+    ascii_str = '[..., 9, 4, 1, 0]'
+    ucode_str = '[…, 9, 4, 1, 0]'
+
+    assert pretty(s5) == ascii_str
+    assert upretty(s5) == ucode_str
+
+    ascii_str = '[..., 2, 1, 2, 1]'
+    ucode_str = '[…, 2, 1, 2, 1]'
+    assert pretty(s6) == ascii_str
+    assert upretty(s6) == ucode_str
+
+    ascii_str = '[1, 3, 5, 11, ...]'
+    ucode_str = '[1, 3, 5, 11, …]'
+
+    assert pretty(SeqAdd(s1, s2)) == ascii_str
+    assert upretty(SeqAdd(s1, s2)) == ucode_str
+
+    ascii_str = '[1, 3, 5]'
+    ucode_str = '[1, 3, 5]'
+
+    assert pretty(SeqAdd(s3, s4)) == ascii_str
+    assert upretty(SeqAdd(s3, s4)) == ucode_str
+
+    ascii_str = '[..., 11, 5, 3, 1]'
+    ucode_str = '[…, 11, 5, 3, 1]'
+
+    assert pretty(SeqAdd(s5, s6)) == ascii_str
+    assert upretty(SeqAdd(s5, s6)) == ucode_str
+
+    ascii_str = '[0, 2, 4, 18, ...]'
+    ucode_str = '[0, 2, 4, 18, …]'
+
+    assert pretty(SeqMul(s1, s2)) == ascii_str
+    assert upretty(SeqMul(s1, s2)) == ucode_str
+
+    ascii_str = '[0, 2, 4]'
+    ucode_str = '[0, 2, 4]'
+
+    assert pretty(SeqMul(s3, s4)) == ascii_str
+    assert upretty(SeqMul(s3, s4)) == ucode_str
+
+    ascii_str = '[..., 18, 4, 2, 0]'
+    ucode_str = '[…, 18, 4, 2, 0]'
+
+    assert pretty(SeqMul(s5, s6)) == ascii_str
+    assert upretty(SeqMul(s5, s6)) == ucode_str
+
+    # Sequences with symbolic limits, issue 12629
+    s7 = SeqFormula(a**2, (a, 0, x))
+    raises(NotImplementedError, lambda: pretty(s7))
+    raises(NotImplementedError, lambda: upretty(s7))
+
+    b = Symbol('b')
+    s8 = SeqFormula(b*a**2, (a, 0, 2))
+    ascii_str = '[0, b, 4*b]'
+    ucode_str = '[0, b, 4⋅b]'
+    assert pretty(s8) == ascii_str
+    assert upretty(s8) == ucode_str
+
+
+def test_pretty_FourierSeries():
+    f = fourier_series(x, (x, -pi, pi))
+
+    ascii_str = \
+"""\
+                      2*sin(3*x)      \n\
+2*sin(x) - sin(2*x) + ---------- + ...\n\
+                          3           \
+"""
+
+    ucode_str = \
+"""\
+                      2⋅sin(3⋅x)    \n\
+2⋅sin(x) - sin(2⋅x) + ────────── + …\n\
+                          3         \
+"""
+
+    assert pretty(f) == ascii_str
+    assert upretty(f) == ucode_str
+
+
+def test_pretty_FormalPowerSeries():
+    f = fps(log(1 + x))
+
+
+    ascii_str = \
+"""\
+ oo              \n\
+____             \n\
+\\   `            \n\
+ \\         -k  k \n\
+  \\   -(-1)  *x  \n\
+  /   -----------\n\
+ /         k     \n\
+/___,            \n\
+k = 1            \
+"""
+
+    ucode_str = \
+"""\
+ ∞               \n\
+____             \n\
+╲                \n\
+ ╲         -k  k \n\
+  ╲   -(-1)  ⋅x  \n\
+  ╱   ───────────\n\
+ ╱         k     \n\
+╱                \n\
+‾‾‾‾             \n\
+k = 1            \
+"""
+
+    assert pretty(f) == ascii_str
+    assert upretty(f) == ucode_str
+
+
+def test_pretty_limits():
+    expr = Limit(x, x, oo)
+    ascii_str = \
+"""\
+ lim x\n\
+x->oo \
+"""
+    ucode_str = \
+"""\
+lim x\n\
+x─→∞ \
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = Limit(x**2, x, 0)
+    ascii_str = \
+"""\
+      2\n\
+ lim x \n\
+x->0+  \
+"""
+    ucode_str = \
+"""\
+      2\n\
+ lim x \n\
+x─→0⁺  \
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = Limit(1/x, x, 0)
+    ascii_str = \
+"""\
+     1\n\
+ lim -\n\
+x->0+x\
+"""
+    ucode_str = \
+"""\
+     1\n\
+ lim ─\n\
+x─→0⁺x\
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = Limit(sin(x)/x, x, 0)
+    ascii_str = \
+"""\
+     /sin(x)\\\n\
+ lim |------|\n\
+x->0+\\  x   /\
+"""
+    ucode_str = \
+"""\
+     ⎛sin(x)⎞\n\
+ lim ⎜──────⎟\n\
+x─→0⁺⎝  x   ⎠\
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = Limit(sin(x)/x, x, 0, "-")
+    ascii_str = \
+"""\
+     /sin(x)\\\n\
+ lim |------|\n\
+x->0-\\  x   /\
+"""
+    ucode_str = \
+"""\
+     ⎛sin(x)⎞\n\
+ lim ⎜──────⎟\n\
+x─→0⁻⎝  x   ⎠\
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = Limit(x + sin(x), x, 0)
+    ascii_str = \
+"""\
+ lim (x + sin(x))\n\
+x->0+            \
+"""
+    ucode_str = \
+"""\
+ lim (x + sin(x))\n\
+x─→0⁺            \
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = Limit(x, x, 0)**2
+    ascii_str = \
+"""\
+        2\n\
+/ lim x\\ \n\
+\\x->0+ / \
+"""
+    ucode_str = \
+"""\
+        2\n\
+⎛ lim x⎞ \n\
+⎝x─→0⁺ ⎠ \
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = Limit(x*Limit(y/2,y,0), x, 0)
+    ascii_str = \
+"""\
+     /       /y\\\\\n\
+ lim |x* lim |-||\n\
+x->0+\\  y->0+\\2//\
+"""
+    ucode_str = \
+"""\
+     ⎛       ⎛y⎞⎞\n\
+ lim ⎜x⋅ lim ⎜─⎟⎟\n\
+x─→0⁺⎝  y─→0⁺⎝2⎠⎠\
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = 2*Limit(x*Limit(y/2,y,0), x, 0)
+    ascii_str = \
+"""\
+       /       /y\\\\\n\
+2* lim |x* lim |-||\n\
+  x->0+\\  y->0+\\2//\
+"""
+    ucode_str = \
+"""\
+       ⎛       ⎛y⎞⎞\n\
+2⋅ lim ⎜x⋅ lim ⎜─⎟⎟\n\
+  x─→0⁺⎝  y─→0⁺⎝2⎠⎠\
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = Limit(sin(x), x, 0, dir='+-')
+    ascii_str = \
+"""\
+lim sin(x)\n\
+x->0      \
+"""
+    ucode_str = \
+"""\
+lim sin(x)\n\
+x─→0      \
+"""
+
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+
+def test_pretty_ComplexRootOf():
+    expr = rootof(x**5 + 11*x - 2, 0)
+    ascii_str = \
+"""\
+       / 5              \\\n\
+CRootOf\\x  + 11*x - 2, 0/\
+"""
+    ucode_str = \
+"""\
+       ⎛ 5              ⎞\n\
+CRootOf⎝x  + 11⋅x - 2, 0⎠\
+"""
+
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+
+def test_pretty_RootSum():
+    expr = RootSum(x**5 + 11*x - 2, auto=False)
+    ascii_str = \
+"""\
+       / 5           \\\n\
+RootSum\\x  + 11*x - 2/\
+"""
+    ucode_str = \
+"""\
+       ⎛ 5           ⎞\n\
+RootSum⎝x  + 11⋅x - 2⎠\
+"""
+
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = RootSum(x**5 + 11*x - 2, Lambda(z, exp(z)))
+    ascii_str = \
+"""\
+       / 5                   z\\\n\
+RootSum\\x  + 11*x - 2, z -> e /\
+"""
+    ucode_str = \
+"""\
+       ⎛ 5                  z⎞\n\
+RootSum⎝x  + 11⋅x - 2, z ↦ ℯ ⎠\
+"""
+
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+
+def test_GroebnerBasis():
+    expr = groebner([], x, y)
+
+    ascii_str = \
+"""\
+GroebnerBasis([], x, y, domain=ZZ, order=lex)\
+"""
+    ucode_str = \
+"""\
+GroebnerBasis([], x, y, domain=ℤ, order=lex)\
+"""
+
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    F = [x**2 - 3*y - x + 1, y**2 - 2*x + y - 1]
+    expr = groebner(F, x, y, order='grlex')
+
+    ascii_str = \
+"""\
+             /[ 2                 2              ]                              \\\n\
+GroebnerBasis\\[x  - x - 3*y + 1, y  - 2*x + y - 1], x, y, domain=ZZ, order=grlex/\
+"""
+    ucode_str = \
+"""\
+             ⎛⎡ 2                 2              ⎤                             ⎞\n\
+GroebnerBasis⎝⎣x  - x - 3⋅y + 1, y  - 2⋅x + y - 1⎦, x, y, domain=ℤ, order=grlex⎠\
+"""
+
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = expr.fglm('lex')
+
+    ascii_str = \
+"""\
+             /[       2           4      3      2           ]                            \\\n\
+GroebnerBasis\\[2*x - y  - y + 1, y  + 2*y  - 3*y  - 16*y + 7], x, y, domain=ZZ, order=lex/\
+"""
+    ucode_str = \
+"""\
+             ⎛⎡       2           4      3      2           ⎤                           ⎞\n\
+GroebnerBasis⎝⎣2⋅x - y  - y + 1, y  + 2⋅y  - 3⋅y  - 16⋅y + 7⎦, x, y, domain=ℤ, order=lex⎠\
+"""
+
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+
+def test_pretty_UniversalSet():
+    assert pretty(S.UniversalSet) == "UniversalSet"
+    assert upretty(S.UniversalSet) == '𝕌'
+
+
+def test_pretty_Boolean():
+    expr = Not(x, evaluate=False)
+
+    assert pretty(expr) == "Not(x)"
+    assert upretty(expr) == "¬x"
+
+    expr = And(x, y)
+
+    assert pretty(expr) == "And(x, y)"
+    assert upretty(expr) == "x ∧ y"
+
+    expr = Or(x, y)
+
+    assert pretty(expr) == "Or(x, y)"
+    assert upretty(expr) == "x ∨ y"
+
+    syms = symbols('a:f')
+    expr = And(*syms)
+
+    assert pretty(expr) == "And(a, b, c, d, e, f)"
+    assert upretty(expr) == "a ∧ b ∧ c ∧ d ∧ e ∧ f"
+
+    expr = Or(*syms)
+
+    assert pretty(expr) == "Or(a, b, c, d, e, f)"
+    assert upretty(expr) == "a ∨ b ∨ c ∨ d ∨ e ∨ f"
+
+    expr = Xor(x, y, evaluate=False)
+
+    assert pretty(expr) == "Xor(x, y)"
+    assert upretty(expr) == "x ⊻ y"
+
+    expr = Nand(x, y, evaluate=False)
+
+    assert pretty(expr) == "Nand(x, y)"
+    assert upretty(expr) == "x ⊼ y"
+
+    expr = Nor(x, y, evaluate=False)
+
+    assert pretty(expr) == "Nor(x, y)"
+    assert upretty(expr) == "x ⊽ y"
+
+    expr = Implies(x, y, evaluate=False)
+
+    assert pretty(expr) == "Implies(x, y)"
+    assert upretty(expr) == "x → y"
+
+    # don't sort args
+    expr = Implies(y, x, evaluate=False)
+
+    assert pretty(expr) == "Implies(y, x)"
+    assert upretty(expr) == "y → x"
+
+    expr = Equivalent(x, y, evaluate=False)
+
+    assert pretty(expr) == "Equivalent(x, y)"
+    assert upretty(expr) == "x ⇔ y"
+
+    expr = Equivalent(y, x, evaluate=False)
+
+    assert pretty(expr) == "Equivalent(x, y)"
+    assert upretty(expr) == "x ⇔ y"
+
+
+def test_pretty_Domain():
+    expr = FF(23)
+
+    assert pretty(expr) == "GF(23)"
+    assert upretty(expr) == "ℤ₂₃"
+
+    expr = ZZ
+
+    assert pretty(expr) == "ZZ"
+    assert upretty(expr) == "ℤ"
+
+    expr = QQ
+
+    assert pretty(expr) == "QQ"
+    assert upretty(expr) == "ℚ"
+
+    expr = RR
+
+    assert pretty(expr) == "RR"
+    assert upretty(expr) == "ℝ"
+
+    expr = QQ[x]
+
+    assert pretty(expr) == "QQ[x]"
+    assert upretty(expr) == "ℚ[x]"
+
+    expr = QQ[x, y]
+
+    assert pretty(expr) == "QQ[x, y]"
+    assert upretty(expr) == "ℚ[x, y]"
+
+    expr = ZZ.frac_field(x)
+
+    assert pretty(expr) == "ZZ(x)"
+    assert upretty(expr) == "ℤ(x)"
+
+    expr = ZZ.frac_field(x, y)
+
+    assert pretty(expr) == "ZZ(x, y)"
+    assert upretty(expr) == "ℤ(x, y)"
+
+    expr = QQ.poly_ring(x, y, order=grlex)
+
+    assert pretty(expr) == "QQ[x, y, order=grlex]"
+    assert upretty(expr) == "ℚ[x, y, order=grlex]"
+
+    expr = QQ.poly_ring(x, y, order=ilex)
+
+    assert pretty(expr) == "QQ[x, y, order=ilex]"
+    assert upretty(expr) == "ℚ[x, y, order=ilex]"
+
+
+def test_pretty_prec():
+    assert xpretty(S("0.3"), full_prec=True, wrap_line=False) == "0.300000000000000"
+    assert xpretty(S("0.3"), full_prec="auto", wrap_line=False) == "0.300000000000000"
+    assert xpretty(S("0.3"), full_prec=False, wrap_line=False) == "0.3"
+    assert xpretty(S("0.3")*x, full_prec=True, use_unicode=False, wrap_line=False) in [
+        "0.300000000000000*x",
+        "x*0.300000000000000"
+    ]
+    assert xpretty(S("0.3")*x, full_prec="auto", use_unicode=False, wrap_line=False) in [
+        "0.3*x",
+        "x*0.3"
+    ]
+    assert xpretty(S("0.3")*x, full_prec=False, use_unicode=False, wrap_line=False) in [
+        "0.3*x",
+        "x*0.3"
+    ]
+
+
+def test_pprint():
+    import sys
+    from io import StringIO
+    fd = StringIO()
+    sso = sys.stdout
+    sys.stdout = fd
+    try:
+        pprint(pi, use_unicode=False, wrap_line=False)
+    finally:
+        sys.stdout = sso
+    assert fd.getvalue() == 'pi\n'
+
+
+def test_pretty_class():
+    """Test that the printer dispatcher correctly handles classes."""
+    class C:
+        pass   # C has no .__class__ and this was causing problems
+
+    class D:
+        pass
+
+    assert pretty( C ) == str( C )
+    assert pretty( D ) == str( D )
+
+
+def test_pretty_no_wrap_line():
+    huge_expr = 0
+    for i in range(20):
+        huge_expr += i*sin(i + x)
+    assert xpretty(huge_expr            ).find('\n') != -1
+    assert xpretty(huge_expr, wrap_line=False).find('\n') == -1
+
+
+def test_settings():
+    raises(TypeError, lambda: pretty(S(4), method="garbage"))
+
+
+def test_pretty_sum():
+    from sympy.abc import x, a, b, k, m, n
+
+    expr = Sum(k**k, (k, 0, n))
+    ascii_str = \
+"""\
+ n      \n\
+___     \n\
+\\  `    \n\
+ \\     k\n\
+ /    k \n\
+/__,    \n\
+k = 0   \
+"""
+    ucode_str = \
+"""\
+  n     \n\
+ ___    \n\
+ ╲      \n\
+  ╲    k\n\
+  ╱   k \n\
+ ╱      \n\
+ ‾‾‾    \n\
+k = 0   \
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = Sum(k**k, (k, oo, n))
+    ascii_str = \
+"""\
+  n      \n\
+ ___     \n\
+ \\  `    \n\
+  \\     k\n\
+  /    k \n\
+ /__,    \n\
+k = oo   \
+"""
+    ucode_str = \
+"""\
+  n     \n\
+ ___    \n\
+ ╲      \n\
+  ╲    k\n\
+  ╱   k \n\
+ ╱      \n\
+ ‾‾‾    \n\
+k = ∞   \
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = Sum(k**(Integral(x**n, (x, -oo, oo))), (k, 0, n**n))
+    ascii_str = \
+"""\
+   n              \n\
+  n               \n\
+______            \n\
+\\     `           \n\
+ \\        oo      \n\
+  \\        /      \n\
+   \\      |       \n\
+    \\     |   n   \n\
+     )    |  x  dx\n\
+    /     |       \n\
+   /     /        \n\
+  /      -oo      \n\
+ /      k         \n\
+/_____,           \n\
+ k = 0            \
+"""
+    ucode_str = \
+"""\
+   n            \n\
+  n             \n\
+______          \n\
+╲               \n\
+ ╲              \n\
+  ╲     ∞       \n\
+   ╲    ⌠       \n\
+    ╲   ⎮   n   \n\
+    ╱   ⎮  x  dx\n\
+   ╱    ⌡       \n\
+  ╱     -∞      \n\
+ ╱     k        \n\
+╱               \n\
+‾‾‾‾‾‾          \n\
+k = 0           \
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = Sum(k**(
+        Integral(x**n, (x, -oo, oo))), (k, 0, Integral(x**x, (x, -oo, oo))))
+    ascii_str = \
+"""\
+ oo                 \n\
+  /                 \n\
+ |                  \n\
+ |   x              \n\
+ |  x  dx           \n\
+ |                  \n\
+/                   \n\
+-oo                 \n\
+ ______             \n\
+ \\     `            \n\
+  \\         oo      \n\
+   \\         /      \n\
+    \\       |       \n\
+     \\      |   n   \n\
+      )     |  x  dx\n\
+     /      |       \n\
+    /      /        \n\
+   /       -oo      \n\
+  /       k         \n\
+ /_____,            \n\
+  k = 0             \
+"""
+    ucode_str = \
+"""\
+∞                 \n\
+⌠                 \n\
+⎮   x             \n\
+⎮  x  dx          \n\
+⌡                 \n\
+-∞                \n\
+ ______           \n\
+ ╲                \n\
+  ╲               \n\
+   ╲      ∞       \n\
+    ╲     ⌠       \n\
+     ╲    ⎮   n   \n\
+     ╱    ⎮  x  dx\n\
+    ╱     ⌡       \n\
+   ╱      -∞      \n\
+  ╱      k        \n\
+ ╱                \n\
+ ‾‾‾‾‾‾           \n\
+ k = 0            \
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = Sum(k**(Integral(x**n, (x, -oo, oo))), (
+        k, x + n + x**2 + n**2 + (x/n) + (1/x), Integral(x**x, (x, -oo, oo))))
+    ascii_str = \
+"""\
+          oo                          \n\
+           /                          \n\
+          |                           \n\
+          |   x                       \n\
+          |  x  dx                    \n\
+          |                           \n\
+         /                            \n\
+         -oo                          \n\
+          ______                      \n\
+          \\     `                     \n\
+           \\                  oo      \n\
+            \\                  /      \n\
+             \\                |       \n\
+              \\               |   n   \n\
+               )              |  x  dx\n\
+              /               |       \n\
+             /               /        \n\
+            /                -oo      \n\
+           /                k         \n\
+          /_____,                     \n\
+     2        2       1   x           \n\
+k = n  + n + x  + x + - + -           \n\
+                      x   n           \
+"""
+    ucode_str = \
+"""\
+         ∞                           \n\
+         ⌠                           \n\
+         ⎮   x                       \n\
+         ⎮  x  dx                    \n\
+         ⌡                           \n\
+         -∞                          \n\
+          ______                     \n\
+          ╲                          \n\
+           ╲                         \n\
+            ╲                ∞       \n\
+             ╲               ⌠       \n\
+              ╲              ⎮   n   \n\
+              ╱              ⎮  x  dx\n\
+             ╱               ⌡       \n\
+            ╱                -∞      \n\
+           ╱                k        \n\
+          ╱                          \n\
+          ‾‾‾‾‾‾                     \n\
+     2        2       1   x          \n\
+k = n  + n + x  + x + ─ + ─          \n\
+                      x   n          \
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = Sum(k**(
+        Integral(x**n, (x, -oo, oo))), (k, 0, x + n + x**2 + n**2 + (x/n) + (1/x)))
+    ascii_str = \
+"""\
+ 2        2       1   x           \n\
+n  + n + x  + x + - + -           \n\
+                  x   n           \n\
+        ______                    \n\
+        \\     `                   \n\
+         \\                oo      \n\
+          \\                /      \n\
+           \\              |       \n\
+            \\             |   n   \n\
+             )            |  x  dx\n\
+            /             |       \n\
+           /             /        \n\
+          /              -oo      \n\
+         /              k         \n\
+        /_____,                   \n\
+         k = 0                    \
+"""
+    ucode_str = \
+"""\
+ 2        2       1   x          \n\
+n  + n + x  + x + ─ + ─          \n\
+                  x   n          \n\
+        ______                   \n\
+        ╲                        \n\
+         ╲                       \n\
+          ╲              ∞       \n\
+           ╲             ⌠       \n\
+            ╲            ⎮   n   \n\
+            ╱            ⎮  x  dx\n\
+           ╱             ⌡       \n\
+          ╱              -∞      \n\
+         ╱              k        \n\
+        ╱                        \n\
+        ‾‾‾‾‾‾                   \n\
+         k = 0                   \
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = Sum(x, (x, 0, oo))
+    ascii_str = \
+"""\
+ oo    \n\
+ __    \n\
+ \\ `   \n\
+  )   x\n\
+ /_,   \n\
+x = 0  \
+"""
+    ucode_str = \
+"""\
+  ∞    \n\
+ ___   \n\
+ ╲     \n\
+  ╲    \n\
+  ╱   x\n\
+ ╱     \n\
+ ‾‾‾   \n\
+x = 0  \
+"""
+
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = Sum(x**2, (x, 0, oo))
+    ascii_str = \
+"""\
+ oo     \n\
+___     \n\
+\\  `    \n\
+ \\     2\n\
+ /    x \n\
+/__,    \n\
+x = 0   \
+"""
+    ucode_str = \
+"""\
+  ∞     \n\
+ ___    \n\
+ ╲      \n\
+  ╲    2\n\
+  ╱   x \n\
+ ╱      \n\
+ ‾‾‾    \n\
+x = 0   \
+"""
+
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = Sum(x/2, (x, 0, oo))
+    ascii_str = \
+"""\
+ oo    \n\
+___    \n\
+\\  `   \n\
+ \\    x\n\
+  )   -\n\
+ /    2\n\
+/__,   \n\
+x = 0  \
+"""
+    ucode_str = \
+"""\
+ ∞     \n\
+____   \n\
+╲      \n\
+ ╲     \n\
+  ╲   x\n\
+  ╱   ─\n\
+ ╱    2\n\
+╱      \n\
+‾‾‾‾   \n\
+x = 0  \
+"""
+
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = Sum(x**3/2, (x, 0, oo))
+    ascii_str = \
+"""\
+ oo     \n\
+____    \n\
+\\   `   \n\
+ \\     3\n\
+  \\   x \n\
+  /   --\n\
+ /    2 \n\
+/___,   \n\
+x = 0   \
+"""
+    ucode_str = \
+"""\
+ ∞      \n\
+____    \n\
+╲       \n\
+ ╲     3\n\
+  ╲   x \n\
+  ╱   ──\n\
+ ╱    2 \n\
+╱       \n\
+‾‾‾‾    \n\
+x = 0   \
+"""
+
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = Sum((x**3*y**(x/2))**n, (x, 0, oo))
+    ascii_str = \
+"""\
+ oo           \n\
+____          \n\
+\\   `         \n\
+ \\           n\n\
+  \\   /    x\\ \n\
+   )  |    -| \n\
+  /   | 3  2| \n\
+ /    \\x *y / \n\
+/___,         \n\
+x = 0         \
+"""
+    ucode_str = \
+"""\
+  ∞           \n\
+_____         \n\
+╲             \n\
+ ╲            \n\
+  ╲          n\n\
+   ╲  ⎛    x⎞ \n\
+   ╱  ⎜    ─⎟ \n\
+  ╱   ⎜ 3  2⎟ \n\
+ ╱    ⎝x ⋅y ⎠ \n\
+╱             \n\
+‾‾‾‾‾         \n\
+x = 0         \
+"""
+
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = Sum(1/x**2, (x, 0, oo))
+    ascii_str = \
+"""\
+ oo     \n\
+____    \n\
+\\   `   \n\
+ \\    1 \n\
+  \\   --\n\
+  /    2\n\
+ /    x \n\
+/___,   \n\
+x = 0   \
+"""
+    ucode_str = \
+"""\
+ ∞      \n\
+____    \n\
+╲       \n\
+ ╲    1 \n\
+  ╲   ──\n\
+  ╱    2\n\
+ ╱    x \n\
+╱       \n\
+‾‾‾‾    \n\
+x = 0   \
+"""
+
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = Sum(1/y**(a/b), (x, 0, oo))
+    ascii_str = \
+"""\
+ oo       \n\
+____      \n\
+\\   `     \n\
+ \\     -a \n\
+  \\    ---\n\
+  /     b \n\
+ /    y   \n\
+/___,     \n\
+x = 0     \
+"""
+    ucode_str = \
+"""\
+ ∞        \n\
+____      \n\
+╲         \n\
+ ╲     -a \n\
+  ╲    ───\n\
+  ╱     b \n\
+ ╱    y   \n\
+╱         \n\
+‾‾‾‾      \n\
+x = 0     \
+"""
+
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = Sum(1/y**(a/b), (x, 0, oo), (y, 1, 2))
+    ascii_str = \
+"""\
+  2     oo     \n\
+____  ____     \n\
+\\   ` \\   `    \n\
+ \\     \\     -a\n\
+  \\     \\    --\n\
+  /     /    b \n\
+ /     /    y  \n\
+/___, /___,    \n\
+y = 1 x = 0    \
+"""
+    ucode_str = \
+"""\
+  2     ∞      \n\
+____  ____     \n\
+╲     ╲        \n\
+ ╲     ╲     -a\n\
+  ╲     ╲    ──\n\
+  ╱     ╱    b \n\
+ ╱     ╱    y  \n\
+╱     ╱        \n\
+‾‾‾‾  ‾‾‾‾     \n\
+y = 1 x = 0    \
+"""
+    expr = Sum(1/(1 + 1/(
+        1 + 1/k)) + 1, (k, 111, 1 + 1/n), (k, 1/(1 + m), oo)) + 1/(1 + 1/k)
+    ascii_str = \
+"""\
+              1                          \n\
+          1 + -                          \n\
+   oo         n                          \n\
+ _____    _____                          \n\
+ \\    `   \\    `                         \n\
+  \\        \\      /        1    \\        \n\
+   \\        \\     |1 + ---------|        \n\
+    \\        \\    |          1  |     1  \n\
+     )        )   |    1 + -----| + -----\n\
+    /        /    |            1|       1\n\
+   /        /     |        1 + -|   1 + -\n\
+  /        /      \\            k/       k\n\
+ /____,   /____,                         \n\
+      1   k = 111                        \n\
+k = -----                                \n\
+    m + 1                                \
+"""
+    ucode_str = \
+"""\
+              1                          \n\
+          1 + ─                          \n\
+   ∞          n                          \n\
+ ______   ______                         \n\
+ ╲        ╲                              \n\
+  ╲        ╲                             \n\
+   ╲        ╲     ⎛        1    ⎞        \n\
+    ╲        ╲    ⎜1 + ─────────⎟        \n\
+     ╲        ╲   ⎜          1  ⎟     1  \n\
+     ╱        ╱   ⎜    1 + ─────⎟ + ─────\n\
+    ╱        ╱    ⎜            1⎟       1\n\
+   ╱        ╱     ⎜        1 + ─⎟   1 + ─\n\
+  ╱        ╱      ⎝            k⎠       k\n\
+ ╱        ╱                              \n\
+ ‾‾‾‾‾‾   ‾‾‾‾‾‾                         \n\
+      1   k = 111                        \n\
+k = ─────                                \n\
+    m + 1                                \
+"""
+
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+
+def test_units():
+    expr = joule
+    ascii_str1 = \
+"""\
+              2\n\
+kilogram*meter \n\
+---------------\n\
+          2    \n\
+    second     \
+"""
+    unicode_str1 = \
+"""\
+              2\n\
+kilogram⋅meter \n\
+───────────────\n\
+          2    \n\
+    second     \
+"""
+
+    ascii_str2 = \
+"""\
+                    2\n\
+3*x*y*kilogram*meter \n\
+---------------------\n\
+             2       \n\
+       second        \
+"""
+    unicode_str2 = \
+"""\
+                    2\n\
+3⋅x⋅y⋅kilogram⋅meter \n\
+─────────────────────\n\
+             2       \n\
+       second        \
+"""
+
+    from sympy.physics.units import kg, m, s
+    assert upretty(expr) == "joule"
+    assert pretty(expr) == "joule"
+    assert upretty(expr.convert_to(kg*m**2/s**2)) == unicode_str1
+    assert pretty(expr.convert_to(kg*m**2/s**2)) == ascii_str1
+    assert upretty(3*kg*x*m**2*y/s**2) == unicode_str2
+    assert pretty(3*kg*x*m**2*y/s**2) == ascii_str2
+
+
+def test_pretty_Subs():
+    f = Function('f')
+    expr = Subs(f(x), x, ph**2)
+    ascii_str = \
+"""\
+(f(x))|     2\n\
+      |x=phi \
+"""
+    unicode_str = \
+"""\
+(f(x))│   2\n\
+      │x=φ \
+"""
+
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == unicode_str
+
+    expr = Subs(f(x).diff(x), x, 0)
+    ascii_str = \
+"""\
+/d       \\|   \n\
+|--(f(x))||   \n\
+\\dx      /|x=0\
+"""
+    unicode_str = \
+"""\
+⎛d       ⎞│   \n\
+⎜──(f(x))⎟│   \n\
+⎝dx      ⎠│x=0\
+"""
+
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == unicode_str
+
+    expr = Subs(f(x).diff(x)/y, (x, y), (0, Rational(1, 2)))
+    ascii_str = \
+"""\
+/d       \\|          \n\
+|--(f(x))||          \n\
+|dx      ||          \n\
+|--------||          \n\
+\\   y    /|x=0, y=1/2\
+"""
+    unicode_str = \
+"""\
+⎛d       ⎞│          \n\
+⎜──(f(x))⎟│          \n\
+⎜dx      ⎟│          \n\
+⎜────────⎟│          \n\
+⎝   y    ⎠│x=0, y=1/2\
+"""
+
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == unicode_str
+
+
+def test_gammas():
+    assert upretty(lowergamma(x, y)) == "γ(x, y)"
+    assert upretty(uppergamma(x, y)) == "Γ(x, y)"
+    assert xpretty(gamma(x), use_unicode=True) == 'Γ(x)'
+    assert xpretty(gamma, use_unicode=True) == 'Γ'
+    assert xpretty(symbols('gamma', cls=Function)(x), use_unicode=True) == 'γ(x)'
+    assert xpretty(symbols('gamma', cls=Function), use_unicode=True) == 'γ'
+
+
+def test_beta():
+    assert xpretty(beta(x,y), use_unicode=True) == 'Β(x, y)'
+    assert xpretty(beta(x,y), use_unicode=False) == 'B(x, y)'
+    assert xpretty(beta, use_unicode=True) == 'Β'
+    assert xpretty(beta, use_unicode=False) == 'B'
+    mybeta = Function('beta')
+    assert xpretty(mybeta(x), use_unicode=True) == 'β(x)'
+    assert xpretty(mybeta(x, y, z), use_unicode=False) == 'beta(x, y, z)'
+    assert xpretty(mybeta, use_unicode=True) == 'β'
+
+
+# test that notation passes to subclasses of the same name only
+def test_function_subclass_different_name():
+    class mygamma(gamma):
+        pass
+    assert xpretty(mygamma, use_unicode=True) == r"mygamma"
+    assert xpretty(mygamma(x), use_unicode=True) == r"mygamma(x)"
+
+
+def test_SingularityFunction():
+    assert xpretty(SingularityFunction(x, 0, n), use_unicode=True) == (
+"""\
+   n\n\
+<x> \
+""")
+    assert xpretty(SingularityFunction(x, 1, n), use_unicode=True) == (
+"""\
+       n\n\
+<x - 1> \
+""")
+    assert xpretty(SingularityFunction(x, -1, n), use_unicode=True) == (
+"""\
+       n\n\
+<x + 1> \
+""")
+    assert xpretty(SingularityFunction(x, a, n), use_unicode=True) == (
+"""\
+        n\n\
+<-a + x> \
+""")
+    assert xpretty(SingularityFunction(x, y, n), use_unicode=True) == (
+"""\
+       n\n\
+<x - y> \
+""")
+    assert xpretty(SingularityFunction(x, 0, n), use_unicode=False) == (
+"""\
+   n\n\
+<x> \
+""")
+    assert xpretty(SingularityFunction(x, 1, n), use_unicode=False) == (
+"""\
+       n\n\
+<x - 1> \
+""")
+    assert xpretty(SingularityFunction(x, -1, n), use_unicode=False) == (
+"""\
+       n\n\
+<x + 1> \
+""")
+    assert xpretty(SingularityFunction(x, a, n), use_unicode=False) == (
+"""\
+        n\n\
+<-a + x> \
+""")
+    assert xpretty(SingularityFunction(x, y, n), use_unicode=False) == (
+"""\
+       n\n\
+<x - y> \
+""")
+
+
+def test_deltas():
+    assert xpretty(DiracDelta(x), use_unicode=True) == 'δ(x)'
+    assert xpretty(DiracDelta(x, 1), use_unicode=True) == \
+"""\
+ (1)    \n\
+δ    (x)\
+"""
+    assert xpretty(x*DiracDelta(x, 1), use_unicode=True) == \
+"""\
+   (1)    \n\
+x⋅δ    (x)\
+"""
+
+
+def test_hyper():
+    expr = hyper((), (), z)
+    ucode_str = \
+"""\
+ ┌─  ⎛  │  ⎞\n\
+ ├─  ⎜  │ z⎟\n\
+0╵ 0 ⎝  │  ⎠\
+"""
+    ascii_str = \
+"""\
+  _         \n\
+ |_  /  |  \\\n\
+ |   |  | z|\n\
+0  0 \\  |  /\
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = hyper((), (1,), x)
+    ucode_str = \
+"""\
+ ┌─  ⎛  │  ⎞\n\
+ ├─  ⎜  │ x⎟\n\
+0╵ 1 ⎝1 │  ⎠\
+"""
+    ascii_str = \
+"""\
+  _         \n\
+ |_  /  |  \\\n\
+ |   |  | x|\n\
+0  1 \\1 |  /\
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = hyper([2], [1], x)
+    ucode_str = \
+"""\
+ ┌─  ⎛2 │  ⎞\n\
+ ├─  ⎜  │ x⎟\n\
+1╵ 1 ⎝1 │  ⎠\
+"""
+    ascii_str = \
+"""\
+  _         \n\
+ |_  /2 |  \\\n\
+ |   |  | x|\n\
+1  1 \\1 |  /\
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = hyper((pi/3, -2*k), (3, 4, 5, -3), x)
+    ucode_str = \
+"""\
+     ⎛  π         │  ⎞\n\
+ ┌─  ⎜  ─, -2⋅k   │  ⎟\n\
+ ├─  ⎜  3         │ x⎟\n\
+2╵ 4 ⎜            │  ⎟\n\
+     ⎝-3, 3, 4, 5 │  ⎠\
+"""
+    ascii_str = \
+"""\
+                      \n\
+  _  / pi         |  \\\n\
+ |_  | --, -2*k   |  |\n\
+ |   | 3          | x|\n\
+2  4 |            |  |\n\
+     \\-3, 3, 4, 5 |  /\
+"""
+
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = hyper((pi, S('2/3'), -2*k), (3, 4, 5, -3), x**2)
+    ucode_str = \
+"""\
+ ┌─  ⎛2/3, π, -2⋅k │  2⎞\n\
+ ├─  ⎜             │ x ⎟\n\
+3╵ 4 ⎝-3, 3, 4, 5  │   ⎠\
+"""
+    ascii_str = \
+"""\
+  _                      \n\
+ |_  /2/3, pi, -2*k |  2\\
+ |   |              | x |
+3  4 \\ -3, 3, 4, 5  |   /"""
+
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = hyper([1, 2], [3, 4], 1/(1/(1/(1/x + 1) + 1) + 1))
+    ucode_str = \
+"""\
+     ⎛     │       1      ⎞\n\
+     ⎜     │ ─────────────⎟\n\
+     ⎜     │         1    ⎟\n\
+ ┌─  ⎜1, 2 │ 1 + ─────────⎟\n\
+ ├─  ⎜     │           1  ⎟\n\
+2╵ 2 ⎜3, 4 │     1 + ─────⎟\n\
+     ⎜     │             1⎟\n\
+     ⎜     │         1 + ─⎟\n\
+     ⎝     │             x⎠\
+"""
+
+    ascii_str = \
+"""\
+                           \n\
+     /     |       1      \\\n\
+     |     | -------------|\n\
+  _  |     |         1    |\n\
+ |_  |1, 2 | 1 + ---------|\n\
+ |   |     |           1  |\n\
+2  2 |3, 4 |     1 + -----|\n\
+     |     |             1|\n\
+     |     |         1 + -|\n\
+     \\     |             x/\
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+
+def test_meijerg():
+    expr = meijerg([pi, pi, x], [1], [0, 1], [1, 2, 3], z)
+    ucode_str = \
+"""\
+╭─╮2, 3 ⎛π, π, x     1    │  ⎞\n\
+│╶┐     ⎜                 │ z⎟\n\
+╰─╯4, 5 ⎝ 0, 1    1, 2, 3 │  ⎠\
+"""
+    ascii_str = \
+"""\
+ __2, 3 /pi, pi, x     1    |  \\\n\
+/__     |                   | z|\n\
+\\_|4, 5 \\  0, 1     1, 2, 3 |  /\
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = meijerg([1, pi/7], [2, pi, 5], [], [], z**2)
+    ucode_str = \
+"""\
+        ⎛   π          │   ⎞\n\
+╭─╮0, 2 ⎜1, ─  2, 5, π │  2⎟\n\
+│╶┐     ⎜   7          │ z ⎟\n\
+╰─╯5, 0 ⎜              │   ⎟\n\
+        ⎝              │   ⎠\
+"""
+    ascii_str = \
+"""\
+        /   pi           |   \\\n\
+ __0, 2 |1, --  2, 5, pi |  2|\n\
+/__     |   7            | z |\n\
+\\_|5, 0 |                |   |\n\
+        \\                |   /\
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    ucode_str = \
+"""\
+╭─╮ 1, 10 ⎛1, 1, 1, 1, 1, 1, 1, 1, 1, 1  1 │  ⎞\n\
+│╶┐       ⎜                                │ z⎟\n\
+╰─╯11,  2 ⎝             1                1 │  ⎠\
+"""
+    ascii_str = \
+"""\
+ __ 1, 10 /1, 1, 1, 1, 1, 1, 1, 1, 1, 1  1 |  \\\n\
+/__       |                                | z|\n\
+\\_|11,  2 \\             1                1 |  /\
+"""
+
+    expr = meijerg([1]*10, [1], [1], [1], z)
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = meijerg([1, 2, ], [4, 3], [3], [4, 5], 1/(1/(1/(1/x + 1) + 1) + 1))
+
+    ucode_str = \
+"""\
+        ⎛           │       1      ⎞\n\
+        ⎜           │ ─────────────⎟\n\
+        ⎜           │         1    ⎟\n\
+╭─╮1, 2 ⎜1, 2  3, 4 │ 1 + ─────────⎟\n\
+│╶┐     ⎜           │           1  ⎟\n\
+╰─╯4, 3 ⎜ 3    4, 5 │     1 + ─────⎟\n\
+        ⎜           │             1⎟\n\
+        ⎜           │         1 + ─⎟\n\
+        ⎝           │             x⎠\
+"""
+
+    ascii_str = \
+"""\
+        /           |       1      \\\n\
+        |           | -------------|\n\
+        |           |         1    |\n\
+ __1, 2 |1, 2  3, 4 | 1 + ---------|\n\
+/__     |           |           1  |\n\
+\\_|4, 3 | 3    4, 5 |     1 + -----|\n\
+        |           |             1|\n\
+        |           |         1 + -|\n\
+        \\           |             x/\
+"""
+
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = Integral(expr, x)
+
+    ucode_str = \
+"""\
+⌠                                        \n\
+⎮         ⎛           │       1      ⎞   \n\
+⎮         ⎜           │ ─────────────⎟   \n\
+⎮         ⎜           │         1    ⎟   \n\
+⎮ ╭─╮1, 2 ⎜1, 2  3, 4 │ 1 + ─────────⎟   \n\
+⎮ │╶┐     ⎜           │           1  ⎟ dx\n\
+⎮ ╰─╯4, 3 ⎜ 3    4, 5 │     1 + ─────⎟   \n\
+⎮         ⎜           │             1⎟   \n\
+⎮         ⎜           │         1 + ─⎟   \n\
+⎮         ⎝           │             x⎠   \n\
+⌡                                        \
+"""
+
+    ascii_str = \
+"""\
+  /                                       \n\
+ |                                        \n\
+ |         /           |       1      \\   \n\
+ |         |           | -------------|   \n\
+ |         |           |         1    |   \n\
+ |  __1, 2 |1, 2  3, 4 | 1 + ---------|   \n\
+ | /__     |           |           1  | dx\n\
+ | \\_|4, 3 | 3    4, 5 |     1 + -----|   \n\
+ |         |           |             1|   \n\
+ |         |           |         1 + -|   \n\
+ |         \\           |             x/   \n\
+ |                                        \n\
+/                                         \
+"""
+
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+
+def test_noncommutative():
+    A, B, C = symbols('A,B,C', commutative=False)
+
+    expr = A*B*C**-1
+    ascii_str = \
+"""\
+     -1\n\
+A*B*C  \
+"""
+    ucode_str = \
+"""\
+     -1\n\
+A⋅B⋅C  \
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = C**-1*A*B
+    ascii_str = \
+"""\
+ -1    \n\
+C  *A*B\
+"""
+    ucode_str = \
+"""\
+ -1    \n\
+C  ⋅A⋅B\
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = A*C**-1*B
+    ascii_str = \
+"""\
+   -1  \n\
+A*C  *B\
+"""
+    ucode_str = \
+"""\
+   -1  \n\
+A⋅C  ⋅B\
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = A*C**-1*B/x
+    ascii_str = \
+"""\
+   -1  \n\
+A*C  *B\n\
+-------\n\
+   x   \
+"""
+    ucode_str = \
+"""\
+   -1  \n\
+A⋅C  ⋅B\n\
+───────\n\
+   x   \
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+
+def test_pretty_special_functions():
+    x, y = symbols("x y")
+
+    # atan2
+    expr = atan2(y/sqrt(200), sqrt(x))
+    ascii_str = \
+"""\
+     /  ___         \\\n\
+     |\\/ 2 *y    ___|\n\
+atan2|-------, \\/ x |\n\
+     \\  20          /\
+"""
+    ucode_str = \
+"""\
+     ⎛√2⋅y    ⎞\n\
+atan2⎜────, √x⎟\n\
+     ⎝ 20     ⎠\
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+
+def test_pretty_geometry():
+    e = Segment((0, 1), (0, 2))
+    assert pretty(e) == 'Segment2D(Point2D(0, 1), Point2D(0, 2))'
+    e = Ray((1, 1), angle=4.02*pi)
+    assert pretty(e) == 'Ray2D(Point2D(1, 1), Point2D(2, tan(pi/50) + 1))'
+
+
+def test_expint():
+    expr = Ei(x)
+    string = 'Ei(x)'
+    assert pretty(expr) == string
+    assert upretty(expr) == string
+
+    expr = expint(1, z)
+    ucode_str = "E₁(z)"
+    ascii_str = "expint(1, z)"
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    assert pretty(Shi(x)) == 'Shi(x)'
+    assert pretty(Si(x)) == 'Si(x)'
+    assert pretty(Ci(x)) == 'Ci(x)'
+    assert pretty(Chi(x)) == 'Chi(x)'
+    assert upretty(Shi(x)) == 'Shi(x)'
+    assert upretty(Si(x)) == 'Si(x)'
+    assert upretty(Ci(x)) == 'Ci(x)'
+    assert upretty(Chi(x)) == 'Chi(x)'
+
+
+def test_elliptic_functions():
+    ascii_str = \
+"""\
+ /  1  \\\n\
+K|-----|\n\
+ \\z + 1/\
+"""
+    ucode_str = \
+"""\
+ ⎛  1  ⎞\n\
+K⎜─────⎟\n\
+ ⎝z + 1⎠\
+"""
+    expr = elliptic_k(1/(z + 1))
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    ascii_str = \
+"""\
+ / |  1  \\\n\
+F|1|-----|\n\
+ \\ |z + 1/\
+"""
+    ucode_str = \
+"""\
+ ⎛ │  1  ⎞\n\
+F⎜1│─────⎟\n\
+ ⎝ │z + 1⎠\
+"""
+    expr = elliptic_f(1, 1/(1 + z))
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    ascii_str = \
+"""\
+ /  1  \\\n\
+E|-----|\n\
+ \\z + 1/\
+"""
+    ucode_str = \
+"""\
+ ⎛  1  ⎞\n\
+E⎜─────⎟\n\
+ ⎝z + 1⎠\
+"""
+    expr = elliptic_e(1/(z + 1))
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    ascii_str = \
+"""\
+ / |  1  \\\n\
+E|1|-----|\n\
+ \\ |z + 1/\
+"""
+    ucode_str = \
+"""\
+ ⎛ │  1  ⎞\n\
+E⎜1│─────⎟\n\
+ ⎝ │z + 1⎠\
+"""
+    expr = elliptic_e(1, 1/(1 + z))
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    ascii_str = \
+"""\
+  / |4\\\n\
+Pi|3|-|\n\
+  \\ |x/\
+"""
+    ucode_str = \
+"""\
+ ⎛ │4⎞\n\
+Π⎜3│─⎟\n\
+ ⎝ │x⎠\
+"""
+    expr = elliptic_pi(3, 4/x)
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    ascii_str = \
+"""\
+  /   4| \\\n\
+Pi|3; -|6|\n\
+  \\   x| /\
+"""
+    ucode_str = \
+"""\
+ ⎛   4│ ⎞\n\
+Π⎜3; ─│6⎟\n\
+ ⎝   x│ ⎠\
+"""
+    expr = elliptic_pi(3, 4/x, 6)
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+
+def test_RandomDomain():
+    from sympy.stats import Normal, Die, Exponential, pspace, where
+    X = Normal('x1', 0, 1)
+    assert upretty(where(X > 0)) == "Domain: 0 < x₁ ∧ x₁ < ∞"
+
+    D = Die('d1', 6)
+    assert upretty(where(D > 4)) == 'Domain: d₁ = 5 ∨ d₁ = 6'
+
+    A = Exponential('a', 1)
+    B = Exponential('b', 1)
+    assert upretty(pspace(Tuple(A, B)).domain) == \
+        'Domain: 0 ≤ a ∧ 0 ≤ b ∧ a < ∞ ∧ b < ∞'
+
+
+def test_PrettyPoly():
+    F = QQ.frac_field(x, y)
+    R = QQ.poly_ring(x, y)
+
+    expr = F.convert(x/(x + y))
+    assert pretty(expr) == "x/(x + y)"
+    assert upretty(expr) == "x/(x + y)"
+
+    expr = R.convert(x + y)
+    assert pretty(expr) == "x + y"
+    assert upretty(expr) == "x + y"
+
+
+def test_issue_6285():
+    assert pretty(Pow(2, -5, evaluate=False)) == '1 \n--\n 5\n2 '
+    assert pretty(Pow(x, (1/pi))) == \
+    ' 1 \n'\
+    ' --\n'\
+    ' pi\n'\
+    'x  '
+
+
+def test_issue_6359():
+    assert pretty(Integral(x**2, x)**2) == \
+"""\
+          2
+/  /     \\ \n\
+| |      | \n\
+| |  2   | \n\
+| | x  dx| \n\
+| |      | \n\
+\\/       / \
+"""
+    assert upretty(Integral(x**2, x)**2) == \
+"""\
+         2
+⎛⌠      ⎞ \n\
+⎜⎮  2   ⎟ \n\
+⎜⎮ x  dx⎟ \n\
+⎝⌡      ⎠ \
+"""
+
+    assert pretty(Sum(x**2, (x, 0, 1))**2) == \
+"""\
+          2\n\
+/ 1      \\ \n\
+|___     | \n\
+|\\  `    | \n\
+| \\     2| \n\
+| /    x | \n\
+|/__,    | \n\
+\\x = 0   / \
+"""
+    assert upretty(Sum(x**2, (x, 0, 1))**2) == \
+"""\
+          2
+⎛  1     ⎞ \n\
+⎜ ___    ⎟ \n\
+⎜ ╲      ⎟ \n\
+⎜  ╲    2⎟ \n\
+⎜  ╱   x ⎟ \n\
+⎜ ╱      ⎟ \n\
+⎜ ‾‾‾    ⎟ \n\
+⎝x = 0   ⎠ \
+"""
+
+    assert pretty(Product(x**2, (x, 1, 2))**2) == \
+"""\
+           2
+/  2      \\ \n\
+|______   | \n\
+| |  |   2| \n\
+| |  |  x | \n\
+| |  |    | \n\
+\\x = 1    / \
+"""
+    assert upretty(Product(x**2, (x, 1, 2))**2) == \
+"""\
+           2
+⎛  2      ⎞ \n\
+⎜─┬──┬─   ⎟ \n\
+⎜ │  │   2⎟ \n\
+⎜ │  │  x ⎟ \n\
+⎜ │  │    ⎟ \n\
+⎝x = 1    ⎠ \
+"""
+
+    f = Function('f')
+    assert pretty(Derivative(f(x), x)**2) == \
+"""\
+          2
+/d       \\ \n\
+|--(f(x))| \n\
+\\dx      / \
+"""
+    assert upretty(Derivative(f(x), x)**2) == \
+"""\
+          2
+⎛d       ⎞ \n\
+⎜──(f(x))⎟ \n\
+⎝dx      ⎠ \
+"""
+
+
+def test_issue_6739():
+    ascii_str = \
+"""\
+  1  \n\
+-----\n\
+  ___\n\
+\\/ x \
+"""
+    ucode_str = \
+"""\
+1 \n\
+──\n\
+√x\
+"""
+    assert pretty(1/sqrt(x)) == ascii_str
+    assert upretty(1/sqrt(x)) == ucode_str
+
+
+def test_complicated_symbol_unchanged():
+    for symb_name in ["dexpr2_d1tau", "dexpr2^d1tau"]:
+        assert pretty(Symbol(symb_name)) == symb_name
+
+
+def test_categories():
+    from sympy.categories import (Object, IdentityMorphism,
+        NamedMorphism, Category, Diagram, DiagramGrid)
+
+    A1 = Object("A1")
+    A2 = Object("A2")
+    A3 = Object("A3")
+
+    f1 = NamedMorphism(A1, A2, "f1")
+    f2 = NamedMorphism(A2, A3, "f2")
+    id_A1 = IdentityMorphism(A1)
+
+    K1 = Category("K1")
+
+    assert pretty(A1) == "A1"
+    assert upretty(A1) == "A₁"
+
+    assert pretty(f1) == "f1:A1-->A2"
+    assert upretty(f1) == "f₁:A₁——▶A₂"
+    assert pretty(id_A1) == "id:A1-->A1"
+    assert upretty(id_A1) == "id:A₁——▶A₁"
+
+    assert pretty(f2*f1) == "f2*f1:A1-->A3"
+    assert upretty(f2*f1) == "f₂∘f₁:A₁——▶A₃"
+
+    assert pretty(K1) == "K1"
+    assert upretty(K1) == "K₁"
+
+    # Test how diagrams are printed.
+    d = Diagram()
+    assert pretty(d) == "EmptySet"
+    assert upretty(d) == "∅"
+
+    d = Diagram({f1: "unique", f2: S.EmptySet})
+    assert pretty(d) == "{f2*f1:A1-->A3: EmptySet, id:A1-->A1: " \
+        "EmptySet, id:A2-->A2: EmptySet, id:A3-->A3: " \
+        "EmptySet, f1:A1-->A2: {unique}, f2:A2-->A3: EmptySet}"
+
+    assert upretty(d) == "{f₂∘f₁:A₁——▶A₃: ∅, id:A₁——▶A₁: ∅, " \
+        "id:A₂——▶A₂: ∅, id:A₃——▶A₃: ∅, f₁:A₁——▶A₂: {unique}, f₂:A₂——▶A₃: ∅}"
+
+    d = Diagram({f1: "unique", f2: S.EmptySet}, {f2 * f1: "unique"})
+    assert pretty(d) == "{f2*f1:A1-->A3: EmptySet, id:A1-->A1: " \
+        "EmptySet, id:A2-->A2: EmptySet, id:A3-->A3: " \
+        "EmptySet, f1:A1-->A2: {unique}, f2:A2-->A3: EmptySet}" \
+        " ==> {f2*f1:A1-->A3: {unique}}"
+    assert upretty(d) == "{f₂∘f₁:A₁——▶A₃: ∅, id:A₁——▶A₁: ∅, id:A₂——▶A₂: " \
+        "∅, id:A₃——▶A₃: ∅, f₁:A₁——▶A₂: {unique}, f₂:A₂——▶A₃: ∅}" \
+        " ══▶ {f₂∘f₁:A₁——▶A₃: {unique}}"
+
+    grid = DiagramGrid(d)
+    assert pretty(grid) == "A1  A2\n      \nA3    "
+    assert upretty(grid) == "A₁  A₂\n      \nA₃    "
+
+
+def test_PrettyModules():
+    R = QQ.old_poly_ring(x, y)
+    F = R.free_module(2)
+    M = F.submodule([x, y], [1, x**2])
+
+    ucode_str = \
+"""\
+       2\n\
+ℚ[x, y] \
+"""
+    ascii_str = \
+"""\
+        2\n\
+QQ[x, y] \
+"""
+
+    assert upretty(F) == ucode_str
+    assert pretty(F) == ascii_str
+
+    ucode_str = \
+"""\
+╱        ⎡    2⎤╲\n\
+╲[x, y], ⎣1, x ⎦╱\
+"""
+    ascii_str = \
+"""\
+              2  \n\
+<[x, y], [1, x ]>\
+"""
+
+    assert upretty(M) == ucode_str
+    assert pretty(M) == ascii_str
+
+    I = R.ideal(x**2, y)
+
+    ucode_str = \
+"""\
+╱ 2   ╲\n\
+╲x , y╱\
+"""
+
+    ascii_str = \
+"""\
+  2    \n\
+<x , y>\
+"""
+
+    assert upretty(I) == ucode_str
+    assert pretty(I) == ascii_str
+
+    Q = F / M
+
+    ucode_str = \
+"""\
+           2     \n\
+    ℚ[x, y]      \n\
+─────────────────\n\
+╱        ⎡    2⎤╲\n\
+╲[x, y], ⎣1, x ⎦╱\
+"""
+
+    ascii_str = \
+"""\
+            2    \n\
+    QQ[x, y]     \n\
+-----------------\n\
+              2  \n\
+<[x, y], [1, x ]>\
+"""
+
+    assert upretty(Q) == ucode_str
+    assert pretty(Q) == ascii_str
+
+    ucode_str = \
+"""\
+╱⎡    3⎤                                                ╲\n\
+│⎢   x ⎥   ╱        ⎡    2⎤╲           ╱        ⎡    2⎤╲│\n\
+│⎢1, ──⎥ + ╲[x, y], ⎣1, x ⎦╱, [2, y] + ╲[x, y], ⎣1, x ⎦╱│\n\
+╲⎣   2 ⎦                                                ╱\
+"""
+
+    ascii_str = \
+"""\
+      3                                                  \n\
+     x                   2                           2   \n\
+<[1, --] + <[x, y], [1, x ]>, [2, y] + <[x, y], [1, x ]>>\n\
+     2                                                   \
+"""
+
+
+def test_QuotientRing():
+    R = QQ.old_poly_ring(x)/[x**2 + 1]
+
+    ucode_str = \
+"""\
+  ℚ[x]  \n\
+────────\n\
+╱ 2    ╲\n\
+╲x  + 1╱\
+"""
+
+    ascii_str = \
+"""\
+ QQ[x]  \n\
+--------\n\
+  2     \n\
+<x  + 1>\
+"""
+
+    assert upretty(R) == ucode_str
+    assert pretty(R) == ascii_str
+
+    ucode_str = \
+"""\
+    ╱ 2    ╲\n\
+1 + ╲x  + 1╱\
+"""
+
+    ascii_str = \
+"""\
+      2     \n\
+1 + <x  + 1>\
+"""
+
+    assert upretty(R.one) == ucode_str
+    assert pretty(R.one) == ascii_str
+
+
+def test_Homomorphism():
+    from sympy.polys.agca import homomorphism
+
+    R = QQ.old_poly_ring(x)
+
+    expr = homomorphism(R.free_module(1), R.free_module(1), [0])
+
+    ucode_str = \
+"""\
+          1         1\n\
+[0] : ℚ[x]  ──> ℚ[x] \
+"""
+
+    ascii_str = \
+"""\
+           1          1\n\
+[0] : QQ[x]  --> QQ[x] \
+"""
+
+    assert upretty(expr) == ucode_str
+    assert pretty(expr) == ascii_str
+
+    expr = homomorphism(R.free_module(2), R.free_module(2), [0, 0])
+
+    ucode_str = \
+"""\
+⎡0  0⎤       2         2\n\
+⎢    ⎥ : ℚ[x]  ──> ℚ[x] \n\
+⎣0  0⎦                  \
+"""
+
+    ascii_str = \
+"""\
+[0  0]        2          2\n\
+[    ] : QQ[x]  --> QQ[x] \n\
+[0  0]                    \
+"""
+
+    assert upretty(expr) == ucode_str
+    assert pretty(expr) == ascii_str
+
+    expr = homomorphism(R.free_module(1), R.free_module(1) / [[x]], [0])
+
+    ucode_str = \
+"""\
+                    1\n\
+          1     ℚ[x] \n\
+[0] : ℚ[x]  ──> ─────\n\
+                <[x]>\
+"""
+
+    ascii_str = \
+"""\
+                      1\n\
+           1     QQ[x] \n\
+[0] : QQ[x]  --> ------\n\
+                 <[x]> \
+"""
+
+    assert upretty(expr) == ucode_str
+    assert pretty(expr) == ascii_str
+
+
+def test_Tr():
+    A, B = symbols('A B', commutative=False)
+    t = Tr(A*B)
+    assert pretty(t) == r'Tr(A*B)'
+    assert upretty(t) == 'Tr(A⋅B)'
+
+
+def test_pretty_Add():
+    eq = Mul(-2, x - 2, evaluate=False) + 5
+    assert pretty(eq) == '5 - 2*(x - 2)'
+
+
+def test_issue_7179():
+    assert upretty(Not(Equivalent(x, y))) == 'x ⇎ y'
+    assert upretty(Not(Implies(x, y))) == 'x ↛ y'
+
+
+def test_issue_7180():
+    assert upretty(Equivalent(x, y)) == 'x ⇔ y'
+
+
+def test_pretty_Complement():
+    assert pretty(S.Reals - S.Naturals) == '(-oo, oo) \\ Naturals'
+    assert upretty(S.Reals - S.Naturals) == 'ℝ \\ ℕ'
+    assert pretty(S.Reals - S.Naturals0) == '(-oo, oo) \\ Naturals0'
+    assert upretty(S.Reals - S.Naturals0) == 'ℝ \\ ℕ₀'
+
+
+def test_pretty_SymmetricDifference():
+    from sympy.sets.sets import SymmetricDifference
+    assert upretty(SymmetricDifference(Interval(2,3), Interval(3,5), \
+           evaluate = False)) == '[2, 3] ∆ [3, 5]'
+    with raises(NotImplementedError):
+        pretty(SymmetricDifference(Interval(2,3), Interval(3,5), evaluate = False))
+
+
+def test_pretty_Contains():
+    assert pretty(Contains(x, S.Integers)) == 'Contains(x, Integers)'
+    assert upretty(Contains(x, S.Integers)) == 'x ∈ ℤ'
+
+
+def test_issue_8292():
+    from sympy.core import sympify
+    e = sympify('((x+x**4)/(x-1))-(2*(x-1)**4/(x-1)**4)', evaluate=False)
+    ucode_str = \
+"""\
+           4    4    \n\
+  2⋅(x - 1)    x  + x\n\
+- ────────── + ──────\n\
+          4    x - 1 \n\
+   (x - 1)           \
+"""
+    ascii_str = \
+"""\
+           4    4    \n\
+  2*(x - 1)    x  + x\n\
+- ---------- + ------\n\
+          4    x - 1 \n\
+   (x - 1)           \
+"""
+    assert pretty(e) == ascii_str
+    assert upretty(e) == ucode_str
+
+
+def test_issue_4335():
+    y = Function('y')
+    expr = -y(x).diff(x)
+    ucode_str = \
+"""\
+ d       \n\
+-──(y(x))\n\
+ dx      \
+"""
+    ascii_str = \
+"""\
+  d       \n\
+- --(y(x))\n\
+  dx      \
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+
+def test_issue_8344():
+    from sympy.core import sympify
+    e = sympify('2*x*y**2/1**2 + 1', evaluate=False)
+    ucode_str = \
+"""\
+     2    \n\
+2⋅x⋅y     \n\
+────── + 1\n\
+   2      \n\
+  1       \
+"""
+    assert upretty(e) == ucode_str
+
+
+def test_issue_6324():
+    x = Pow(2, 3, evaluate=False)
+    y = Pow(10, -2, evaluate=False)
+    e = Mul(x, y, evaluate=False)
+    ucode_str = \
+"""\
+ 3 \n\
+2  \n\
+───\n\
+  2\n\
+10 \
+"""
+    assert upretty(e) == ucode_str
+
+
+def test_issue_7927():
+    e = sin(x/2)**cos(x/2)
+    ucode_str = \
+"""\
+           ⎛x⎞\n\
+        cos⎜─⎟\n\
+           ⎝2⎠\n\
+⎛   ⎛x⎞⎞      \n\
+⎜sin⎜─⎟⎟      \n\
+⎝   ⎝2⎠⎠      \
+"""
+    assert upretty(e) == ucode_str
+    e = sin(x)**(S(11)/13)
+    ucode_str = \
+"""\
+        11\n\
+        ──\n\
+        13\n\
+(sin(x))  \
+"""
+    assert upretty(e) == ucode_str
+
+
+def test_issue_6134():
+    from sympy.abc import lamda, t
+    phi = Function('phi')
+
+    e = lamda*x*Integral(phi(t)*pi*sin(pi*t), (t, 0, 1)) + lamda*x**2*Integral(phi(t)*2*pi*sin(2*pi*t), (t, 0, 1))
+    ucode_str = \
+"""\
+     1                              1                   \n\
+   2 ⌠                              ⌠                   \n\
+λ⋅x ⋅⎮ 2⋅π⋅φ(t)⋅sin(2⋅π⋅t) dt + λ⋅x⋅⎮ π⋅φ(t)⋅sin(π⋅t) dt\n\
+     ⌡                              ⌡                   \n\
+     0                              0                   \
+"""
+    assert upretty(e) == ucode_str
+
+
+def test_issue_9877():
+    ucode_str1 = '(2, 3) ∪ ([1, 2] \\ {x})'
+    a, b, c = Interval(2, 3, True, True), Interval(1, 2), FiniteSet(x)
+    assert upretty(Union(a, Complement(b, c))) == ucode_str1
+
+    ucode_str2 = '{x} ∩ {y} ∩ ({z} \\ [1, 2])'
+    d, e, f, g = FiniteSet(x), FiniteSet(y), FiniteSet(z), Interval(1, 2)
+    assert upretty(Intersection(d, e, Complement(f, g))) == ucode_str2
+
+
+def test_issue_13651():
+    expr1 = c + Mul(-1, a + b, evaluate=False)
+    assert pretty(expr1) == 'c - (a + b)'
+    expr2 = c + Mul(-1, a - b + d, evaluate=False)
+    assert pretty(expr2) == 'c - (a - b + d)'
+
+
+def test_pretty_primenu():
+    from sympy.functions.combinatorial.numbers import primenu
+
+    ascii_str1 = "nu(n)"
+    ucode_str1 = "ν(n)"
+
+    n = symbols('n', integer=True)
+    assert pretty(primenu(n)) == ascii_str1
+    assert upretty(primenu(n)) == ucode_str1
+
+
+def test_pretty_primeomega():
+    from sympy.functions.combinatorial.numbers import primeomega
+
+    ascii_str1 = "Omega(n)"
+    ucode_str1 = "Ω(n)"
+
+    n = symbols('n', integer=True)
+    assert pretty(primeomega(n)) == ascii_str1
+    assert upretty(primeomega(n)) == ucode_str1
+
+
+def test_pretty_Mod():
+    from sympy.core import Mod
+
+    ascii_str1 = "x mod 7"
+    ucode_str1 = "x mod 7"
+
+    ascii_str2 = "(x + 1) mod 7"
+    ucode_str2 = "(x + 1) mod 7"
+
+    ascii_str3 = "2*x mod 7"
+    ucode_str3 = "2⋅x mod 7"
+
+    ascii_str4 = "(x mod 7) + 1"
+    ucode_str4 = "(x mod 7) + 1"
+
+    ascii_str5 = "2*(x mod 7)"
+    ucode_str5 = "2⋅(x mod 7)"
+
+    x = symbols('x', integer=True)
+    assert pretty(Mod(x, 7)) == ascii_str1
+    assert upretty(Mod(x, 7)) == ucode_str1
+    assert pretty(Mod(x + 1, 7)) == ascii_str2
+    assert upretty(Mod(x + 1, 7)) == ucode_str2
+    assert pretty(Mod(2 * x, 7)) == ascii_str3
+    assert upretty(Mod(2 * x, 7)) == ucode_str3
+    assert pretty(Mod(x, 7) + 1) == ascii_str4
+    assert upretty(Mod(x, 7) + 1) == ucode_str4
+    assert pretty(2 * Mod(x, 7)) == ascii_str5
+    assert upretty(2 * Mod(x, 7)) == ucode_str5
+
+
+def test_issue_11801():
+    assert pretty(Symbol("")) == ""
+    assert upretty(Symbol("")) == ""
+
+
+def test_pretty_UnevaluatedExpr():
+    x = symbols('x')
+    he = UnevaluatedExpr(1/x)
+
+    ucode_str = \
+"""\
+1\n\
+─\n\
+x\
+"""
+
+    assert upretty(he) == ucode_str
+
+    ucode_str = \
+"""\
+   2\n\
+⎛1⎞ \n\
+⎜─⎟ \n\
+⎝x⎠ \
+"""
+
+    assert upretty(he**2) == ucode_str
+
+    ucode_str = \
+"""\
+    1\n\
+1 + ─\n\
+    x\
+"""
+
+    assert upretty(he + 1) == ucode_str
+
+    ucode_str = \
+('''\
+  1\n\
+x⋅─\n\
+  x\
+''')
+    assert upretty(x*he) == ucode_str
+
+
+def test_issue_10472():
+    M = (Matrix([[0, 0], [0, 0]]), Matrix([0, 0]))
+
+    ucode_str = \
+"""\
+⎛⎡0  0⎤  ⎡0⎤⎞
+⎜⎢    ⎥, ⎢ ⎥⎟
+⎝⎣0  0⎦  ⎣0⎦⎠\
+"""
+    assert upretty(M) == ucode_str
+
+
+def test_MatrixElement_printing():
+    # test cases for issue #11821
+    A = MatrixSymbol("A", 1, 3)
+    B = MatrixSymbol("B", 1, 3)
+    C = MatrixSymbol("C", 1, 3)
+
+    ascii_str1 = "A_00"
+    ucode_str1 = "A₀₀"
+    assert pretty(A[0, 0])  == ascii_str1
+    assert upretty(A[0, 0]) == ucode_str1
+
+    ascii_str1 = "3*A_00"
+    ucode_str1 = "3⋅A₀₀"
+    assert pretty(3*A[0, 0])  == ascii_str1
+    assert upretty(3*A[0, 0]) == ucode_str1
+
+    ascii_str1 = "(-B + A)[0, 0]"
+    ucode_str1 = "(-B + A)[0, 0]"
+    F = C[0, 0].subs(C, A - B)
+    assert pretty(F)  == ascii_str1
+    assert upretty(F) == ucode_str1
+
+
+def test_issue_12675():
+    x, y, t, j = symbols('x y t j')
+    e = CoordSys3D('e')
+
+    ucode_str = \
+"""\
+⎛   t⎞    \n\
+⎜⎛x⎞ ⎟ j_e\n\
+⎜⎜─⎟ ⎟    \n\
+⎝⎝y⎠ ⎠    \
+"""
+    assert upretty((x/y)**t*e.j) == ucode_str
+    ucode_str = \
+"""\
+⎛1⎞    \n\
+⎜─⎟ j_e\n\
+⎝y⎠    \
+"""
+    assert upretty((1/y)*e.j) == ucode_str
+
+
+def test_MatrixSymbol_printing():
+    # test cases for issue #14237
+    A = MatrixSymbol("A", 3, 3)
+    B = MatrixSymbol("B", 3, 3)
+    C = MatrixSymbol("C", 3, 3)
+    assert pretty(-A*B*C) == "-A*B*C"
+    assert pretty(A - B) == "-B + A"
+    assert pretty(A*B*C - A*B - B*C) == "-A*B -B*C + A*B*C"
+
+    # issue #14814
+    x = MatrixSymbol('x', n, n)
+    y = MatrixSymbol('y*', n, n)
+    assert pretty(x + y) == "x + y*"
+    ascii_str = \
+"""\
+     2     \n\
+-2*y*  -a*x\
+"""
+    assert pretty(-a*x + -2*y*y) == ascii_str
+
+
+def test_degree_printing():
+    expr1 = 90*degree
+    assert pretty(expr1) == '90°'
+    expr2 = x*degree
+    assert pretty(expr2) == 'x°'
+    expr3 = cos(x*degree + 90*degree)
+    assert pretty(expr3) == 'cos(x° + 90°)'
+
+
+def test_vector_expr_pretty_printing():
+    A = CoordSys3D('A')
+
+    assert upretty(Cross(A.i, A.x*A.i+3*A.y*A.j)) == "(i_A)×((x_A) i_A + (3⋅y_A) j_A)"
+    assert upretty(x*Cross(A.i, A.j)) == 'x⋅(i_A)×(j_A)'
+
+    assert upretty(Curl(A.x*A.i + 3*A.y*A.j)) == "∇×((x_A) i_A + (3⋅y_A) j_A)"
+
+    assert upretty(Divergence(A.x*A.i + 3*A.y*A.j)) == "∇⋅((x_A) i_A + (3⋅y_A) j_A)"
+
+    assert upretty(Dot(A.i, A.x*A.i+3*A.y*A.j)) == "(i_A)⋅((x_A) i_A + (3⋅y_A) j_A)"
+
+    assert upretty(Gradient(A.x+3*A.y)) == "∇(x_A + 3⋅y_A)"
+    assert upretty(Laplacian(A.x+3*A.y)) == "∆(x_A + 3⋅y_A)"
+    # TODO: add support for ASCII pretty.
+
+
+def test_pretty_print_tensor_expr():
+    L = TensorIndexType("L")
+    i, j, k = tensor_indices("i j k", L)
+    i0 = tensor_indices("i_0", L)
+    A, B, C, D = tensor_heads("A B C D", [L])
+    H = TensorHead("H", [L, L])
+
+    expr = -i
+    ascii_str = \
+"""\
+-i\
+"""
+    ucode_str = \
+"""\
+-i\
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = A(i)
+    ascii_str = \
+"""\
+ i\n\
+A \n\
+  \
+"""
+    ucode_str = \
+"""\
+ i\n\
+A \n\
+  \
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = A(i0)
+    ascii_str = \
+"""\
+ i_0\n\
+A   \n\
+    \
+"""
+    ucode_str = \
+"""\
+ i₀\n\
+A  \n\
+   \
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = A(-i)
+    ascii_str = \
+"""\
+  \n\
+A \n\
+ i\
+"""
+    ucode_str = \
+"""\
+  \n\
+A \n\
+ i\
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = -3*A(-i)
+    ascii_str = \
+"""\
+     \n\
+-3*A \n\
+    i\
+"""
+    ucode_str = \
+"""\
+     \n\
+-3⋅A \n\
+    i\
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = H(i, -j)
+    ascii_str = \
+"""\
+ i \n\
+H  \n\
+  j\
+"""
+    ucode_str = \
+"""\
+ i \n\
+H  \n\
+  j\
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = H(i, -i)
+    ascii_str = \
+"""\
+ L_0   \n\
+H      \n\
+    L_0\
+"""
+    ucode_str = \
+"""\
+ L₀  \n\
+H    \n\
+   L₀\
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = H(i, -j)*A(j)*B(k)
+    ascii_str = \
+"""\
+ i     L_0  k\n\
+H    *A   *B \n\
+  L_0        \
+"""
+    ucode_str = \
+"""\
+ i    L₀  k\n\
+H   ⋅A  ⋅B \n\
+  L₀       \
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = (1+x)*A(i)
+    ascii_str = \
+"""\
+         i\n\
+(x + 1)*A \n\
+          \
+"""
+    ucode_str = \
+"""\
+         i\n\
+(x + 1)⋅A \n\
+          \
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = A(i) + 3*B(i)
+    ascii_str = \
+"""\
+   i    i\n\
+3*B  + A \n\
+         \
+"""
+    ucode_str = \
+"""\
+   i    i\n\
+3⋅B  + A \n\
+         \
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+
+def test_pretty_print_tensor_partial_deriv():
+    from sympy.tensor.toperators import PartialDerivative
+
+    L = TensorIndexType("L")
+    i, j, k = tensor_indices("i j k", L)
+
+    A, B, C, D = tensor_heads("A B C D", [L])
+
+    H = TensorHead("H", [L, L])
+
+    expr = PartialDerivative(A(i), A(j))
+    ascii_str = \
+"""\
+ d / i\\\n\
+---|A |\n\
+  j\\  /\n\
+dA     \n\
+       \
+"""
+    ucode_str = \
+"""\
+ ∂ ⎛ i⎞\n\
+───⎜A ⎟\n\
+  j⎝  ⎠\n\
+∂A     \n\
+       \
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = A(i)*PartialDerivative(H(k, -i), A(j))
+    ascii_str = \
+"""\
+ L_0  d / k   \\\n\
+A   *---|H    |\n\
+       j\\  L_0/\n\
+     dA        \n\
+               \
+"""
+    ucode_str = \
+"""\
+ L₀  ∂ ⎛ k  ⎞\n\
+A  ⋅───⎜H   ⎟\n\
+      j⎝  L₀⎠\n\
+    ∂A       \n\
+             \
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = A(i)*PartialDerivative(B(k)*C(-i) + 3*H(k, -i), A(j))
+    ascii_str = \
+"""\
+ L_0  d /   k       k     \\\n\
+A   *---|3*H     + B *C   |\n\
+       j\\    L_0       L_0/\n\
+     dA                    \n\
+                           \
+"""
+    ucode_str = \
+"""\
+ L₀  ∂ ⎛   k      k    ⎞\n\
+A  ⋅───⎜3⋅H    + B ⋅C  ⎟\n\
+      j⎝    L₀       L₀⎠\n\
+    ∂A                  \n\
+                        \
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = (A(i) + B(i))*PartialDerivative(C(j), D(j))
+    ascii_str = \
+"""\
+/ i    i\\   d  / L_0\\\n\
+|A  + B |*-----|C   |\n\
+\\       /   L_0\\    /\n\
+          dD         \n\
+                     \
+"""
+    ucode_str = \
+"""\
+⎛ i    i⎞  ∂  ⎛ L₀⎞\n\
+⎜A  + B ⎟⋅────⎜C  ⎟\n\
+⎝       ⎠   L₀⎝   ⎠\n\
+          ∂D       \n\
+                   \
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = (A(i) + B(i))*PartialDerivative(C(-i), D(j))
+    ascii_str = \
+"""\
+/ L_0    L_0\\  d /    \\\n\
+|A    + B   |*---|C   |\n\
+\\           /   j\\ L_0/\n\
+              dD       \n\
+                       \
+"""
+    ucode_str = \
+"""\
+⎛ L₀    L₀⎞  ∂ ⎛   ⎞\n\
+⎜A   + B  ⎟⋅───⎜C  ⎟\n\
+⎝         ⎠   j⎝ L₀⎠\n\
+            ∂D      \n\
+                    \
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = PartialDerivative(B(-i) + A(-i), A(-j), A(-n))
+    ucode_str = """\
+   2            \n\
+  ∂    ⎛       ⎞\n\
+───────⎜A  + B ⎟\n\
+       ⎝ i    i⎠\n\
+∂A  ∂A          \n\
+  n   j         \
+"""
+    assert upretty(expr) == ucode_str
+
+    expr = PartialDerivative(3*A(-i), A(-j), A(-n))
+    ucode_str = """\
+   2         \n\
+  ∂    ⎛    ⎞\n\
+───────⎜3⋅A ⎟\n\
+       ⎝   i⎠\n\
+∂A  ∂A       \n\
+  n   j      \
+"""
+    assert upretty(expr) == ucode_str
+
+    expr = TensorElement(H(i, j), {i:1})
+    ascii_str = \
+"""\
+ i=1,j\n\
+H     \n\
+      \
+"""
+    ucode_str = ascii_str
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = TensorElement(H(i, j), {i: 1, j: 1})
+    ascii_str = \
+"""\
+ i=1,j=1\n\
+H       \n\
+        \
+"""
+    ucode_str = ascii_str
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = TensorElement(H(i, j), {j: 1})
+    ascii_str = \
+"""\
+ i,j=1\n\
+H     \n\
+      \
+"""
+    ucode_str = ascii_str
+
+    expr = TensorElement(H(-i, j), {-i: 1})
+    ascii_str = \
+"""\
+    j\n\
+H    \n\
+ i=1 \
+"""
+    ucode_str = ascii_str
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+
+def test_issue_15560():
+    a = MatrixSymbol('a', 1, 1)
+    e = pretty(a*(KroneckerProduct(a, a)))
+    result = 'a*(a x a)'
+    assert e == result
+
+
+def test_print_polylog():
+    # Part of issue 6013
+    uresult = 'Li₂(3)'
+    aresult = 'polylog(2, 3)'
+    assert pretty(polylog(2, 3)) == aresult
+    assert upretty(polylog(2, 3)) == uresult
+
+
+# Issue #25312
+def test_print_expint_polylog_symbolic_order():
+    s, z = symbols("s, z")
+    uresult = 'Liₛ(z)'
+    aresult = 'polylog(s, z)'
+    assert pretty(polylog(s, z)) == aresult
+    assert upretty(polylog(s, z)) == uresult
+    # TODO: TBD polylog(s - 1, z)
+    uresult = 'Eₛ(z)'
+    aresult = 'expint(s, z)'
+    assert pretty(expint(s, z)) == aresult
+    assert upretty(expint(s, z)) == uresult
+
+
+
+def test_print_polylog_long_order_issue_25309():
+    s, z = symbols("s, z")
+    ucode_str = \
+"""\
+       ⎛ 2   ⎞\n\
+polylog⎝s , z⎠\
+"""
+    assert upretty(polylog(s**2, z)) == ucode_str
+
+
+def test_print_lerchphi():
+    # Part of issue 6013
+    a = Symbol('a')
+    pretty(lerchphi(a, 1, 2))
+    uresult = 'Φ(a, 1, 2)'
+    aresult = 'lerchphi(a, 1, 2)'
+    assert pretty(lerchphi(a, 1, 2)) == aresult
+    assert upretty(lerchphi(a, 1, 2)) == uresult
+
+
+def test_issue_15583():
+
+    N = mechanics.ReferenceFrame('N')
+    result = '(n_x, n_y, n_z)'
+    e = pretty((N.x, N.y, N.z))
+    assert e == result
+
+
+def test_matrixSymbolBold():
+    # Issue 15871
+    def boldpretty(expr):
+        return xpretty(expr, use_unicode=True, wrap_line=False, mat_symbol_style="bold")
+
+    from sympy.matrices.expressions.trace import trace
+    A = MatrixSymbol("A", 2, 2)
+    assert boldpretty(trace(A)) == 'tr(𝐀)'
+
+    A = MatrixSymbol("A", 3, 3)
+    B = MatrixSymbol("B", 3, 3)
+    C = MatrixSymbol("C", 3, 3)
+
+    assert boldpretty(-A) == '-𝐀'
+    assert boldpretty(A - A*B - B) == '-𝐁 -𝐀⋅𝐁 + 𝐀'
+    assert boldpretty(-A*B - A*B*C - B) == '-𝐁 -𝐀⋅𝐁 -𝐀⋅𝐁⋅𝐂'
+
+    A = MatrixSymbol("Addot", 3, 3)
+    assert boldpretty(A) == '𝐀̈'
+    omega = MatrixSymbol("omega", 3, 3)
+    assert boldpretty(omega) == 'ω'
+    omega = MatrixSymbol("omeganorm", 3, 3)
+    assert boldpretty(omega) == '‖ω‖'
+
+    a = Symbol('alpha')
+    b = Symbol('b')
+    c = MatrixSymbol("c", 3, 1)
+    d = MatrixSymbol("d", 3, 1)
+
+    assert boldpretty(a*B*c+b*d) == 'b⋅𝐝 + α⋅𝐁⋅𝐜'
+
+    d = MatrixSymbol("delta", 3, 1)
+    B = MatrixSymbol("Beta", 3, 3)
+
+    assert boldpretty(a*B*c+b*d) == 'b⋅δ + α⋅Β⋅𝐜'
+
+    A = MatrixSymbol("A_2", 3, 3)
+    assert boldpretty(A) == '𝐀₂'
+
+
+def test_center_accent():
+    assert center_accent('a', '\N{COMBINING TILDE}') == 'ã'
+    assert center_accent('aa', '\N{COMBINING TILDE}') == 'aã'
+    assert center_accent('aaa', '\N{COMBINING TILDE}') == 'aãa'
+    assert center_accent('aaaa', '\N{COMBINING TILDE}') == 'aaãa'
+    assert center_accent('aaaaa', '\N{COMBINING TILDE}') == 'aaãaa'
+    assert center_accent('abcdefg', '\N{COMBINING FOUR DOTS ABOVE}') == 'abcd⃜efg'
+
+
+def test_imaginary_unit():
+    from sympy.printing.pretty import pretty  # b/c it was redefined above
+    assert pretty(1 + I, use_unicode=False) == '1 + I'
+    assert pretty(1 + I, use_unicode=True) == '1 + ⅈ'
+    assert pretty(1 + I, use_unicode=False, imaginary_unit='j') == '1 + I'
+    assert pretty(1 + I, use_unicode=True, imaginary_unit='j') == '1 + ⅉ'
+
+    raises(TypeError, lambda: pretty(I, imaginary_unit=I))
+    raises(ValueError, lambda: pretty(I, imaginary_unit="kkk"))
+
+
+def test_str_special_matrices():
+    from sympy.matrices import Identity, ZeroMatrix, OneMatrix
+    assert pretty(Identity(4)) == 'I'
+    assert upretty(Identity(4)) == '𝕀'
+    assert pretty(ZeroMatrix(2, 2)) == '0'
+    assert upretty(ZeroMatrix(2, 2)) == '𝟘'
+    assert pretty(OneMatrix(2, 2)) == '1'
+    assert upretty(OneMatrix(2, 2)) == '𝟙'
+
+
+def test_pretty_misc_functions():
+    assert pretty(LambertW(x)) == 'W(x)'
+    assert upretty(LambertW(x)) == 'W(x)'
+    assert pretty(LambertW(x, y)) == 'W(x, y)'
+    assert upretty(LambertW(x, y)) == 'W(x, y)'
+    assert pretty(airyai(x)) == 'Ai(x)'
+    assert upretty(airyai(x)) == 'Ai(x)'
+    assert pretty(airybi(x)) == 'Bi(x)'
+    assert upretty(airybi(x)) == 'Bi(x)'
+    assert pretty(airyaiprime(x)) == "Ai'(x)"
+    assert upretty(airyaiprime(x)) == "Ai'(x)"
+    assert pretty(airybiprime(x)) == "Bi'(x)"
+    assert upretty(airybiprime(x)) == "Bi'(x)"
+    assert pretty(fresnelc(x)) == 'C(x)'
+    assert upretty(fresnelc(x)) == 'C(x)'
+    assert pretty(fresnels(x)) == 'S(x)'
+    assert upretty(fresnels(x)) == 'S(x)'
+    assert pretty(Heaviside(x)) == 'Heaviside(x)'
+    assert upretty(Heaviside(x)) == 'θ(x)'
+    assert pretty(Heaviside(x, y)) == 'Heaviside(x, y)'
+    assert upretty(Heaviside(x, y)) == 'θ(x, y)'
+    assert pretty(dirichlet_eta(x)) == 'dirichlet_eta(x)'
+    assert upretty(dirichlet_eta(x)) == 'η(x)'
+
+
+def test_hadamard_power():
+    m, n, p = symbols('m, n, p', integer=True)
+    A = MatrixSymbol('A', m, n)
+    B = MatrixSymbol('B', m, n)
+
+    # Testing printer:
+    expr = hadamard_power(A, n)
+    ascii_str = \
+"""\
+ .n\n\
+A  \
+"""
+    ucode_str = \
+"""\
+ ∘n\n\
+A  \
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = hadamard_power(A, 1+n)
+    ascii_str = \
+"""\
+ .(n + 1)\n\
+A        \
+"""
+    ucode_str = \
+"""\
+ ∘(n + 1)\n\
+A        \
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+    expr = hadamard_power(A*B.T, 1+n)
+    ascii_str = \
+"""\
+      .(n + 1)\n\
+/   T\\        \n\
+\\A*B /        \
+"""
+    ucode_str = \
+"""\
+      ∘(n + 1)\n\
+⎛   T⎞        \n\
+⎝A⋅B ⎠        \
+"""
+    assert pretty(expr) == ascii_str
+    assert upretty(expr) == ucode_str
+
+
+def test_issue_17258():
+    n = Symbol('n', integer=True)
+    assert pretty(Sum(n, (n, -oo, 1))) == \
+    '   1     \n'\
+    '  __     \n'\
+    '  \\ `    \n'\
+    '   )    n\n'\
+    '  /_,    \n'\
+    'n = -oo  '
+
+    assert upretty(Sum(n, (n, -oo, 1))) == \
+"""\
+  1     \n\
+ ___    \n\
+ ╲      \n\
+  ╲     \n\
+  ╱    n\n\
+ ╱      \n\
+ ‾‾‾    \n\
+n = -∞  \
+"""
+
+
+def test_is_combining():
+    line = "v̇_m"
+    assert [is_combining(sym) for sym in line] == \
+        [False, True, False, False]
+
+
+def test_issue_17616():
+    assert pretty(pi**(1/exp(1))) == \
+   '  / -1\\\n'\
+   '  \\e  /\n'\
+   'pi     '
+
+    assert upretty(pi**(1/exp(1))) == \
+   ' ⎛ -1⎞\n'\
+   ' ⎝ℯ  ⎠\n'\
+   'π     '
+
+    assert pretty(pi**(1/pi)) == \
+    '  1 \n'\
+    '  --\n'\
+    '  pi\n'\
+    'pi  '
+
+    assert upretty(pi**(1/pi)) == \
+    ' 1\n'\
+    ' ─\n'\
+    ' π\n'\
+    'π '
+
+    assert pretty(pi**(1/EulerGamma)) == \
+    '      1     \n'\
+    '  ----------\n'\
+    '  EulerGamma\n'\
+    'pi          '
+
+    assert upretty(pi**(1/EulerGamma)) == \
+    ' 1\n'\
+    ' ─\n'\
+    ' γ\n'\
+    'π '
+
+    z = Symbol("x_17")
+    assert upretty(7**(1/z)) == \
+    'x₁₇___\n'\
+    ' ╲╱ 7 '
+
+    assert pretty(7**(1/z)) == \
+    'x_17___\n'\
+    '  \\/ 7 '
+
+
+def test_issue_17857():
+    assert pretty(Range(-oo, oo)) == '{..., -1, 0, 1, ...}'
+    assert pretty(Range(oo, -oo, -1)) == '{..., 1, 0, -1, ...}'
+
+
+def test_issue_18272():
+    x = Symbol('x')
+    n = Symbol('n')
+
+    assert upretty(ConditionSet(x, Eq(-x + exp(x), 0), S.Complexes)) == \
+    '⎧  │         ⎛      x    ⎞⎫\n'\
+    '⎨x │ x ∊ ℂ ∧ ⎝-x + ℯ  = 0⎠⎬\n'\
+    '⎩  │                      ⎭'
+    assert upretty(ConditionSet(x, Contains(n/2, Interval(0, oo)), FiniteSet(-n/2, n/2))) == \
+    '⎧  │     ⎧-n   n⎫   ⎛n         ⎞⎫\n'\
+    '⎨x │ x ∊ ⎨───, ─⎬ ∧ ⎜─ ∈ [0, ∞)⎟⎬\n'\
+    '⎩  │     ⎩ 2   2⎭   ⎝2         ⎠⎭'
+    assert upretty(ConditionSet(x, Eq(Piecewise((1, x >= 3), (x/2 - 1/2, x >= 2), (1/2, x >= 1),
+                (x/2, True)) - 1/2, 0), Interval(0, 3))) == \
+    '⎧  │              ⎛⎛⎧   1     for x ≥ 3⎞          ⎞⎫\n'\
+    '⎪  │              ⎜⎜⎪                  ⎟          ⎟⎪\n'\
+    '⎪  │              ⎜⎜⎪x                 ⎟          ⎟⎪\n'\
+    '⎪  │              ⎜⎜⎪─ - 0.5  for x ≥ 2⎟          ⎟⎪\n'\
+    '⎪  │              ⎜⎜⎪2                 ⎟          ⎟⎪\n'\
+    '⎨x │ x ∊ [0, 3] ∧ ⎜⎜⎨                  ⎟ - 0.5 = 0⎟⎬\n'\
+    '⎪  │              ⎜⎜⎪  0.5    for x ≥ 1⎟          ⎟⎪\n'\
+    '⎪  │              ⎜⎜⎪                  ⎟          ⎟⎪\n'\
+    '⎪  │              ⎜⎜⎪   x              ⎟          ⎟⎪\n'\
+    '⎪  │              ⎜⎜⎪   ─     otherwise⎟          ⎟⎪\n'\
+    '⎩  │              ⎝⎝⎩   2              ⎠          ⎠⎭'
+
+
+def test_Str():
+    from sympy.core.symbol import Str
+    assert pretty(Str('x')) == 'x'
+
+
+def test_symbolic_probability():
+    mu = symbols("mu")
+    sigma = symbols("sigma", positive=True)
+    X = Normal("X", mu, sigma)
+    assert pretty(Expectation(X)) == r'E[X]'
+    assert pretty(Variance(X)) == r'Var(X)'
+    assert pretty(Probability(X > 0)) == r'P(X > 0)'
+    Y = Normal("Y", mu, sigma)
+    assert pretty(Covariance(X, Y)) == 'Cov(X, Y)'
+
+
+def test_issue_21758():
+    from sympy.functions.elementary.piecewise import piecewise_fold
+    from sympy.series.fourier import FourierSeries
+    x = Symbol('x')
+    k, n = symbols('k n')
+    fo = FourierSeries(x, (x, -pi, pi), (0, SeqFormula(0, (k, 1, oo)), SeqFormula(
+        Piecewise((-2*pi*cos(n*pi)/n + 2*sin(n*pi)/n**2, (n > -oo) & (n < oo) & Ne(n, 0)),
+                  (0, True))*sin(n*x)/pi, (n, 1, oo))))
+    assert upretty(piecewise_fold(fo)) == \
+        '⎧                      2⋅sin(3⋅x)                                \n'\
+        '⎪2⋅sin(x) - sin(2⋅x) + ────────── + …  for n > -∞ ∧ n < ∞ ∧ n ≠ 0\n'\
+        '⎨                          3                                     \n'\
+        '⎪                                                                \n'\
+        '⎩                 0                            otherwise         '
+    assert pretty(FourierSeries(x, (x, -pi, pi), (0, SeqFormula(0, (k, 1, oo)),
+                                                 SeqFormula(0, (n, 1, oo))))) == '0'
+
+
+def test_diffgeom():
+    from sympy.diffgeom import Manifold, Patch, CoordSystem, BaseScalarField
+    x,y = symbols('x y', real=True)
+    m = Manifold('M', 2)
+    assert pretty(m) == 'M'
+    p = Patch('P', m)
+    assert pretty(p) == "P"
+    rect = CoordSystem('rect', p, [x, y])
+    assert pretty(rect) == "rect"
+    b = BaseScalarField(rect, 0)
+    assert pretty(b) == "x"
+
+
+def test_deprecated_prettyForm():
+    with warns_deprecated_sympy():
+        from sympy.printing.pretty.pretty_symbology import xstr
+        assert xstr(1) == '1'
+
+    with warns_deprecated_sympy():
+        from sympy.printing.pretty.stringpict import prettyForm
+        p = prettyForm('s', unicode='s')
+
+    with warns_deprecated_sympy():
+        assert p.unicode == p.s == 's'
+
+
+def test_center():
+    assert center('1', 2) == '1 '
+    assert center('1', 3) == ' 1 '
+    assert center('1', 3, '-') == '-1-'
+    assert center('1', 5, '-') == '--1--'
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/__pycache__/__init__.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5805b158affc993f87b39443e8f0d4e4df5ef67a
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/__pycache__/__init__.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/__pycache__/test_aesaracode.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/__pycache__/test_aesaracode.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..2ad4cb020ed46638c9b085a01b438d8eda2e6580
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/__pycache__/test_aesaracode.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/__pycache__/test_c.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/__pycache__/test_c.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..998b8f043afaea437be24cd737969ec23843d86b
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/__pycache__/test_c.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/__pycache__/test_codeprinter.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/__pycache__/test_codeprinter.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d4a0f556fdad03eb715b8944e60dc98a821401f0
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/__pycache__/test_codeprinter.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/__pycache__/test_conventions.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/__pycache__/test_conventions.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..8044ec4a0f761fa5b71c3addb4a24e107bda8220
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/__pycache__/test_conventions.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/__pycache__/test_cupy.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/__pycache__/test_cupy.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..2c41e65125a85532c10547dbc8986eeb506612fb
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/__pycache__/test_cupy.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/__pycache__/test_cxx.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/__pycache__/test_cxx.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..46c25e7cc5a7d0893a98a1e5911781ddb2de2568
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/__pycache__/test_cxx.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/__pycache__/test_dot.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/__pycache__/test_dot.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..1d2be62e30216ef87efbc2cde9047fb65ba16757
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/__pycache__/test_dot.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/__pycache__/test_fortran.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/__pycache__/test_fortran.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..202ffa3822ef05cf50d8df8ac2f963588e750fb2
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/__pycache__/test_fortran.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/__pycache__/test_glsl.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/__pycache__/test_glsl.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..22d5bd20455d8bc2cfc8da8dde76023435c79127
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/__pycache__/test_glsl.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/__pycache__/test_gtk.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/__pycache__/test_gtk.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..bb661469cadbb51789bdc6119db36fd80fd15629
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/__pycache__/test_gtk.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/__pycache__/test_jax.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/__pycache__/test_jax.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..4bdac4ab5d54c11dd8bca48b4e8474234c7a0d5f
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/__pycache__/test_jax.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/__pycache__/test_jscode.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/__pycache__/test_jscode.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..9ea1c324d6001546f6150c609c4c5b52f803d1a7
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/__pycache__/test_jscode.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/__pycache__/test_julia.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/__pycache__/test_julia.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..3dcf2fb09801ca272d166bbfecb89c01dfc7f2c7
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/__pycache__/test_julia.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/__pycache__/test_lambdarepr.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/__pycache__/test_lambdarepr.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..8695bf5934201e61a9fd0cd45b3f0e1231d220da
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/__pycache__/test_lambdarepr.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/__pycache__/test_latex.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/__pycache__/test_latex.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..2ebf9bd0e1eab62f2bcb5daddca971bff1233de0
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/__pycache__/test_latex.cpython-312.pyc
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d068d4558e3124658bee1b3ef36eff254ff3f3f4afcf4281cee50583de530a01
+size 226218
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/__pycache__/test_llvmjit.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/__pycache__/test_llvmjit.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..6f27952fe530b819dfb495342d8651d6c00ba49c
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/__pycache__/test_llvmjit.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/__pycache__/test_maple.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/__pycache__/test_maple.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..e10792440d4922d2dc64b7154c72117e9fd43d85
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/__pycache__/test_maple.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/__pycache__/test_mathematica.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/__pycache__/test_mathematica.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..dda1b088aff84aa2b67d12901365465be581581b
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/__pycache__/test_mathematica.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/__pycache__/test_mathml.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/__pycache__/test_mathml.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..624e4a10e126bf02058edf8ff15c7b6d9d5a80f1
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/__pycache__/test_mathml.cpython-312.pyc
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:13d4b4561491c65dcee806ad80e8744abfa06473973fd869f1a761ec13551676
+size 166504
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/__pycache__/test_numpy.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/__pycache__/test_numpy.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..116b7f8eb1f601514412bb3c0f63f22f2b2c9102
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/__pycache__/test_numpy.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/__pycache__/test_octave.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/__pycache__/test_octave.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..4fb1dc872f0771ee5284d23526e6675b4b6fcf4f
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/__pycache__/test_octave.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/__pycache__/test_precedence.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/__pycache__/test_precedence.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..dcb0d11497960e803ef978cdc59b8f272052b87d
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/__pycache__/test_precedence.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/__pycache__/test_preview.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/__pycache__/test_preview.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f2c1eca2dbfee92143e6b35cb562cdef6f7accd9
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/__pycache__/test_preview.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/__pycache__/test_pycode.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/__pycache__/test_pycode.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5e0c7e3c26dedb9159119813b9c6f385cad8b17d
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/__pycache__/test_pycode.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/__pycache__/test_python.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/__pycache__/test_python.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..44770329c83fdf74bd514d0ca7649a782f00e0c5
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/__pycache__/test_python.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/__pycache__/test_rcode.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/__pycache__/test_rcode.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..11d653dbcfd8f80984f39999a09a0ef2c4ae9ed5
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/__pycache__/test_rcode.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/__pycache__/test_repr.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/__pycache__/test_repr.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d0026e916b0ad439461138e56f689af2de54929b
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/__pycache__/test_repr.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/__pycache__/test_rust.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/__pycache__/test_rust.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a1a83c1796cfbae0d678e9e0877a6fea28777334
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/__pycache__/test_rust.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/__pycache__/test_smtlib.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/__pycache__/test_smtlib.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..bb3382b7d0a99431d0116ea656a34430e5fd59a8
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/__pycache__/test_smtlib.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/__pycache__/test_str.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/__pycache__/test_str.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a5d3df76e6976bbdee5c424d950cf92207d77ecc
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/__pycache__/test_str.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/__pycache__/test_tableform.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/__pycache__/test_tableform.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d5c719a4497535b41b18a63426e63504782d70d9
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/__pycache__/test_tableform.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/__pycache__/test_tensorflow.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/__pycache__/test_tensorflow.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a6692db544a3c7ee3cf836a630789823c1286f65
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/__pycache__/test_tensorflow.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/__pycache__/test_theanocode.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/__pycache__/test_theanocode.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..8890d4c2dfad6f42987cbac20071a3be944bf39a
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/__pycache__/test_theanocode.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/__pycache__/test_torch.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/__pycache__/test_torch.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..9441ce5419e6a909a0b52625b4654532683e5d44
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/__pycache__/test_torch.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/__pycache__/test_tree.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/__pycache__/test_tree.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5d6e216e7d96063e49c5cb37573a8a0ef728ea88
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/__pycache__/test_tree.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/test_preview.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/test_preview.py
new file mode 100644
index 0000000000000000000000000000000000000000..91771ceb0466d6b0fee00570426713d02da14872
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/test_preview.py
@@ -0,0 +1,38 @@
+# -*- coding: utf-8 -*-
+
+from sympy.core.relational import Eq
+from sympy.core.symbol import Symbol
+from sympy.functions.elementary.piecewise import Piecewise
+from sympy.printing.preview import preview
+
+from io import BytesIO
+
+
+def test_preview():
+    x = Symbol('x')
+    obj = BytesIO()
+    try:
+        preview(x, output='png', viewer='BytesIO', outputbuffer=obj)
+    except RuntimeError:
+        pass  # latex not installed on CI server
+
+
+def test_preview_unicode_symbol():
+    # issue 9107
+    a = Symbol('α')
+    obj = BytesIO()
+    try:
+        preview(a, output='png', viewer='BytesIO', outputbuffer=obj)
+    except RuntimeError:
+        pass  # latex not installed on CI server
+
+
+def test_preview_latex_construct_in_expr():
+    # see PR 9801
+    x = Symbol('x')
+    pw = Piecewise((1, Eq(x, 0)), (0, True))
+    obj = BytesIO()
+    try:
+        preview(pw, output='png', viewer='BytesIO', outputbuffer=obj)
+    except RuntimeError:
+        pass  # latex not installed on CI server
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/test_pycode.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/test_pycode.py
new file mode 100644
index 0000000000000000000000000000000000000000..2c38fe81d830149cdce6b55f15e6e07513fdd146
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/test_pycode.py
@@ -0,0 +1,493 @@
+from sympy import Not
+from sympy.codegen import Assignment
+from sympy.codegen.ast import none
+from sympy.codegen.cfunctions import expm1, log1p
+from sympy.codegen.scipy_nodes import cosm1
+from sympy.codegen.matrix_nodes import MatrixSolve
+from sympy.core import Expr, Mod, symbols, Eq, Le, Gt, zoo, oo, Rational, Pow
+from sympy.core.function import Derivative
+from sympy.core.numbers import pi
+from sympy.core.singleton import S
+from sympy.functions import acos, KroneckerDelta, Piecewise, sign, sqrt, Min, Max, cot, acsch, asec, coth, sec, log, sin, cos, tan, asin, atan, sinh, cosh, tanh, asinh, acosh, atanh
+from sympy.functions.elementary.trigonometric import atan2
+from sympy.logic import And, Or
+from sympy.matrices import SparseMatrix, MatrixSymbol, Identity
+from sympy.printing.codeprinter import PrintMethodNotImplementedError
+from sympy.printing.pycode import (
+    MpmathPrinter, CmathPrinter, PythonCodePrinter, pycode, SymPyPrinter
+)
+from sympy.printing.tensorflow import TensorflowPrinter
+from sympy.printing.numpy import NumPyPrinter, SciPyPrinter
+from sympy.testing.pytest import raises, skip
+from sympy.tensor import IndexedBase, Idx
+from sympy.tensor.array.expressions.array_expressions import ArraySymbol, ArrayDiagonal, ArrayContraction, ZeroArray, OneArray
+from sympy.external import import_module
+from sympy.functions.special.gamma_functions import loggamma
+
+
+
+x, y, z = symbols('x y z')
+p = IndexedBase("p")
+
+
+def test_PythonCodePrinter():
+    prntr = PythonCodePrinter()
+
+    assert not prntr.module_imports
+
+    assert prntr.doprint(x**y) == 'x**y'
+    assert prntr.doprint(Mod(x, 2)) == 'x % 2'
+    assert prntr.doprint(-Mod(x, y)) == '-(x % y)'
+    assert prntr.doprint(Mod(-x, y)) == '(-x) % y'
+    assert prntr.doprint(And(x, y)) == 'x and y'
+    assert prntr.doprint(Or(x, y)) == 'x or y'
+    assert prntr.doprint(1/(x+y)) == '1/(x + y)'
+    assert prntr.doprint(Not(x)) == 'not x'
+    assert not prntr.module_imports
+
+    assert prntr.doprint(pi) == 'math.pi'
+    assert prntr.module_imports == {'math': {'pi'}}
+
+    assert prntr.doprint(x**Rational(1, 2)) == 'math.sqrt(x)'
+    assert prntr.doprint(sqrt(x)) == 'math.sqrt(x)'
+    assert prntr.module_imports == {'math': {'pi', 'sqrt'}}
+
+    assert prntr.doprint(acos(x)) == 'math.acos(x)'
+    assert prntr.doprint(cot(x)) == '(1/math.tan(x))'
+    assert prntr.doprint(coth(x)) == '((math.exp(x) + math.exp(-x))/(math.exp(x) - math.exp(-x)))'
+    assert prntr.doprint(asec(x)) == '(math.acos(1/x))'
+    assert prntr.doprint(acsch(x)) == '(math.log(math.sqrt(1 + x**(-2)) + 1/x))'
+
+    assert prntr.doprint(Assignment(x, 2)) == 'x = 2'
+    assert prntr.doprint(Piecewise((1, Eq(x, 0)),
+                        (2, x>6))) == '((1) if (x == 0) else (2) if (x > 6) else None)'
+    assert prntr.doprint(Piecewise((2, Le(x, 0)),
+                        (3, Gt(x, 0)), evaluate=False)) == '((2) if (x <= 0) else'\
+                                                        ' (3) if (x > 0) else None)'
+    assert prntr.doprint(sign(x)) == '(0.0 if x == 0 else math.copysign(1, x))'
+    assert prntr.doprint(p[0, 1]) == 'p[0, 1]'
+    assert prntr.doprint(KroneckerDelta(x,y)) == '(1 if x == y else 0)'
+
+    assert prntr.doprint((2,3)) == "(2, 3)"
+    assert prntr.doprint([2,3]) == "[2, 3]"
+
+    assert prntr.doprint(Min(x, y)) == "min(x, y)"
+    assert prntr.doprint(Max(x, y)) == "max(x, y)"
+
+
+def test_PythonCodePrinter_standard():
+    prntr = PythonCodePrinter()
+
+    assert prntr.standard == 'python3'
+
+    raises(ValueError, lambda: PythonCodePrinter({'standard':'python4'}))
+
+
+def test_CmathPrinter():
+    p = CmathPrinter()
+
+    assert p.doprint(sqrt(x)) == 'cmath.sqrt(x)'
+    assert p.doprint(log(x)) == 'cmath.log(x)'
+
+    assert p.doprint(sin(x)) == 'cmath.sin(x)'
+    assert p.doprint(cos(x)) == 'cmath.cos(x)'
+    assert p.doprint(tan(x)) == 'cmath.tan(x)'
+
+    assert p.doprint(asin(x)) == 'cmath.asin(x)'
+    assert p.doprint(acos(x)) == 'cmath.acos(x)'
+    assert p.doprint(atan(x)) == 'cmath.atan(x)'
+
+    assert p.doprint(sinh(x)) == 'cmath.sinh(x)'
+    assert p.doprint(cosh(x)) == 'cmath.cosh(x)'
+    assert p.doprint(tanh(x)) == 'cmath.tanh(x)'
+
+    assert p.doprint(asinh(x)) == 'cmath.asinh(x)'
+    assert p.doprint(acosh(x)) == 'cmath.acosh(x)'
+    assert p.doprint(atanh(x)) == 'cmath.atanh(x)'
+
+
+def test_MpmathPrinter():
+    p = MpmathPrinter()
+    assert p.doprint(sign(x)) == 'mpmath.sign(x)'
+    assert p.doprint(Rational(1, 2)) == 'mpmath.mpf(1)/mpmath.mpf(2)'
+
+    assert p.doprint(S.Exp1) == 'mpmath.e'
+    assert p.doprint(S.Pi) == 'mpmath.pi'
+    assert p.doprint(S.GoldenRatio) == 'mpmath.phi'
+    assert p.doprint(S.EulerGamma) == 'mpmath.euler'
+    assert p.doprint(S.NaN) == 'mpmath.nan'
+    assert p.doprint(S.Infinity) == 'mpmath.inf'
+    assert p.doprint(S.NegativeInfinity) == 'mpmath.ninf'
+    assert p.doprint(loggamma(x)) == 'mpmath.loggamma(x)'
+
+
+def test_NumPyPrinter():
+    from sympy.core.function import Lambda
+    from sympy.matrices.expressions.adjoint import Adjoint
+    from sympy.matrices.expressions.diagonal import (DiagMatrix, DiagonalMatrix, DiagonalOf)
+    from sympy.matrices.expressions.funcmatrix import FunctionMatrix
+    from sympy.matrices.expressions.hadamard import HadamardProduct
+    from sympy.matrices.expressions.kronecker import KroneckerProduct
+    from sympy.matrices.expressions.special import (OneMatrix, ZeroMatrix)
+    from sympy.abc import a, b
+    p = NumPyPrinter()
+    assert p.doprint(sign(x)) == 'numpy.sign(x)'
+    A = MatrixSymbol("A", 2, 2)
+    B = MatrixSymbol("B", 2, 2)
+    C = MatrixSymbol("C", 1, 5)
+    D = MatrixSymbol("D", 3, 4)
+    assert p.doprint(A**(-1)) == "numpy.linalg.inv(A)"
+    assert p.doprint(A**5) == "numpy.linalg.matrix_power(A, 5)"
+    assert p.doprint(Identity(3)) == "numpy.eye(3)"
+
+    u = MatrixSymbol('x', 2, 1)
+    v = MatrixSymbol('y', 2, 1)
+    assert p.doprint(MatrixSolve(A, u)) == 'numpy.linalg.solve(A, x)'
+    assert p.doprint(MatrixSolve(A, u) + v) == 'numpy.linalg.solve(A, x) + y'
+
+    assert p.doprint(ZeroMatrix(2, 3)) == "numpy.zeros((2, 3))"
+    assert p.doprint(OneMatrix(2, 3)) == "numpy.ones((2, 3))"
+    assert p.doprint(FunctionMatrix(4, 5, Lambda((a, b), a + b))) == \
+        "numpy.fromfunction(lambda a, b: a + b, (4, 5))"
+    assert p.doprint(HadamardProduct(A, B)) == "numpy.multiply(A, B)"
+    assert p.doprint(KroneckerProduct(A, B)) == "numpy.kron(A, B)"
+    assert p.doprint(Adjoint(A)) == "numpy.conjugate(numpy.transpose(A))"
+    assert p.doprint(DiagonalOf(A)) == "numpy.reshape(numpy.diag(A), (-1, 1))"
+    assert p.doprint(DiagMatrix(C)) == "numpy.diagflat(C)"
+    assert p.doprint(DiagonalMatrix(D)) == "numpy.multiply(D, numpy.eye(3, 4))"
+
+    # Workaround for numpy negative integer power errors
+    assert p.doprint(x**-1) == 'x**(-1.0)'
+    assert p.doprint(x**-2) == 'x**(-2.0)'
+
+    expr = Pow(2, -1, evaluate=False)
+    assert p.doprint(expr) == "2**(-1.0)"
+
+    assert p.doprint(S.Exp1) == 'numpy.e'
+    assert p.doprint(S.Pi) == 'numpy.pi'
+    assert p.doprint(S.EulerGamma) == 'numpy.euler_gamma'
+    assert p.doprint(S.NaN) == 'numpy.nan'
+    assert p.doprint(S.Infinity) == 'numpy.inf'
+    assert p.doprint(S.NegativeInfinity) == '-numpy.inf'
+
+    # Function rewriting operator precedence fix
+    assert p.doprint(sec(x)**2) == '(numpy.cos(x)**(-1.0))**2'
+
+
+def test_issue_18770():
+    numpy = import_module('numpy')
+    if not numpy:
+        skip("numpy not installed.")
+
+    from sympy.functions.elementary.miscellaneous import (Max, Min)
+    from sympy.utilities.lambdify import lambdify
+
+    expr1 = Min(0.1*x + 3, x + 1, 0.5*x + 1)
+    func = lambdify(x, expr1, "numpy")
+    assert (func(numpy.linspace(0, 3, 3)) == [1.0, 1.75, 2.5 ]).all()
+    assert  func(4) == 3
+
+    expr1 = Max(x**2, x**3)
+    func = lambdify(x,expr1, "numpy")
+    assert (func(numpy.linspace(-1, 2, 4)) == [1, 0, 1, 8] ).all()
+    assert func(4) == 64
+
+
+def test_SciPyPrinter():
+    p = SciPyPrinter()
+    expr = acos(x)
+    assert 'numpy' not in p.module_imports
+    assert p.doprint(expr) == 'numpy.arccos(x)'
+    assert 'numpy' in p.module_imports
+    assert not any(m.startswith('scipy') for m in p.module_imports)
+    smat = SparseMatrix(2, 5, {(0, 1): 3})
+    assert p.doprint(smat) == \
+        'scipy.sparse.coo_matrix(([3], ([0], [1])), shape=(2, 5))'
+    assert 'scipy.sparse' in p.module_imports
+
+    assert p.doprint(S.GoldenRatio) == 'scipy.constants.golden_ratio'
+    assert p.doprint(S.Pi) == 'scipy.constants.pi'
+    assert p.doprint(S.Exp1) == 'numpy.e'
+
+
+def test_pycode_reserved_words():
+    s1, s2 = symbols('if else')
+    raises(ValueError, lambda: pycode(s1 + s2, error_on_reserved=True))
+    py_str = pycode(s1 + s2)
+    assert py_str in ('else_ + if_', 'if_ + else_')
+
+
+def test_issue_20762():
+    # Make sure pycode removes curly braces from subscripted variables
+    a_b, b, a_11 = symbols('a_{b} b a_{11}')
+    expr = a_b*b
+    assert pycode(expr) == 'a_b*b'
+    expr = a_11*b
+    assert pycode(expr) == 'a_11*b'
+
+
+def test_sqrt():
+    prntr = PythonCodePrinter()
+    assert prntr._print_Pow(sqrt(x), rational=False) == 'math.sqrt(x)'
+    assert prntr._print_Pow(1/sqrt(x), rational=False) == '1/math.sqrt(x)'
+
+    prntr = PythonCodePrinter({'standard' : 'python3'})
+    assert prntr._print_Pow(sqrt(x), rational=True) == 'x**(1/2)'
+    assert prntr._print_Pow(1/sqrt(x), rational=True) == 'x**(-1/2)'
+
+    prntr = MpmathPrinter()
+    assert prntr._print_Pow(sqrt(x), rational=False) == 'mpmath.sqrt(x)'
+    assert prntr._print_Pow(sqrt(x), rational=True) == \
+        "x**(mpmath.mpf(1)/mpmath.mpf(2))"
+
+    prntr = NumPyPrinter()
+    assert prntr._print_Pow(sqrt(x), rational=False) == 'numpy.sqrt(x)'
+    assert prntr._print_Pow(sqrt(x), rational=True) == 'x**(1/2)'
+
+    prntr = SciPyPrinter()
+    assert prntr._print_Pow(sqrt(x), rational=False) == 'numpy.sqrt(x)'
+    assert prntr._print_Pow(sqrt(x), rational=True) == 'x**(1/2)'
+
+    prntr = SymPyPrinter()
+    assert prntr._print_Pow(sqrt(x), rational=False) == 'sympy.sqrt(x)'
+    assert prntr._print_Pow(sqrt(x), rational=True) == 'x**(1/2)'
+
+
+def test_frac():
+    from sympy.functions.elementary.integers import frac
+
+    expr = frac(x)
+    prntr = NumPyPrinter()
+    assert prntr.doprint(expr) == 'numpy.mod(x, 1)'
+
+    prntr = SciPyPrinter()
+    assert prntr.doprint(expr) == 'numpy.mod(x, 1)'
+
+    prntr = PythonCodePrinter()
+    assert prntr.doprint(expr) == 'x % 1'
+
+    prntr = MpmathPrinter()
+    assert prntr.doprint(expr) == 'mpmath.frac(x)'
+
+    prntr = SymPyPrinter()
+    assert prntr.doprint(expr) == 'sympy.functions.elementary.integers.frac(x)'
+
+
+class CustomPrintedObject(Expr):
+    def _numpycode(self, printer):
+        return 'numpy'
+
+    def _mpmathcode(self, printer):
+        return 'mpmath'
+
+
+def test_printmethod():
+    obj = CustomPrintedObject()
+    assert NumPyPrinter().doprint(obj) == 'numpy'
+    assert MpmathPrinter().doprint(obj) == 'mpmath'
+
+
+def test_codegen_ast_nodes():
+    assert pycode(none) == 'None'
+
+
+def test_issue_14283():
+    prntr = PythonCodePrinter()
+
+    assert prntr.doprint(zoo) == "math.nan"
+    assert prntr.doprint(-oo) == "float('-inf')"
+
+
+def test_NumPyPrinter_print_seq():
+    n = NumPyPrinter()
+
+    assert n._print_seq(range(2)) == '(0, 1,)'
+
+
+def test_issue_16535_16536():
+    from sympy.functions.special.gamma_functions import (lowergamma, uppergamma)
+
+    a = symbols('a')
+    expr1 = lowergamma(a, x)
+    expr2 = uppergamma(a, x)
+
+    prntr = SciPyPrinter()
+    assert prntr.doprint(expr1) == 'scipy.special.gamma(a)*scipy.special.gammainc(a, x)'
+    assert prntr.doprint(expr2) == 'scipy.special.gamma(a)*scipy.special.gammaincc(a, x)'
+
+    p_numpy = NumPyPrinter()
+    p_pycode = PythonCodePrinter({'strict': False})
+
+    for expr in [expr1, expr2]:
+        with raises(NotImplementedError):
+            p_numpy.doprint(expr1)
+        assert "Not supported" in p_pycode.doprint(expr)
+
+
+def test_Integral():
+    from sympy.functions.elementary.exponential import exp
+    from sympy.integrals.integrals import Integral
+
+    single = Integral(exp(-x), (x, 0, oo))
+    double = Integral(x**2*exp(x*y), (x, -z, z), (y, 0, z))
+    indefinite = Integral(x**2, x)
+    evaluateat = Integral(x**2, (x, 1))
+
+    prntr = SciPyPrinter()
+    assert prntr.doprint(single) == 'scipy.integrate.quad(lambda x: numpy.exp(-x), 0, numpy.inf)[0]'
+    assert prntr.doprint(double) == 'scipy.integrate.nquad(lambda x, y: x**2*numpy.exp(x*y), ((-z, z), (0, z)))[0]'
+    raises(NotImplementedError, lambda: prntr.doprint(indefinite))
+    raises(NotImplementedError, lambda: prntr.doprint(evaluateat))
+
+    prntr = MpmathPrinter()
+    assert prntr.doprint(single) == 'mpmath.quad(lambda x: mpmath.exp(-x), (0, mpmath.inf))'
+    assert prntr.doprint(double) == 'mpmath.quad(lambda x, y: x**2*mpmath.exp(x*y), (-z, z), (0, z))'
+    raises(NotImplementedError, lambda: prntr.doprint(indefinite))
+    raises(NotImplementedError, lambda: prntr.doprint(evaluateat))
+
+
+def test_fresnel_integrals():
+    from sympy.functions.special.error_functions import (fresnelc, fresnels)
+
+    expr1 = fresnelc(x)
+    expr2 = fresnels(x)
+
+    prntr = SciPyPrinter()
+    assert prntr.doprint(expr1) == 'scipy.special.fresnel(x)[1]'
+    assert prntr.doprint(expr2) == 'scipy.special.fresnel(x)[0]'
+
+    p_numpy = NumPyPrinter()
+    p_pycode = PythonCodePrinter()
+    p_mpmath = MpmathPrinter()
+    for expr in [expr1, expr2]:
+        with raises(NotImplementedError):
+            p_numpy.doprint(expr)
+        with raises(NotImplementedError):
+            p_pycode.doprint(expr)
+
+    assert p_mpmath.doprint(expr1) == 'mpmath.fresnelc(x)'
+    assert p_mpmath.doprint(expr2) == 'mpmath.fresnels(x)'
+
+
+def test_beta():
+    from sympy.functions.special.beta_functions import beta
+
+    expr = beta(x, y)
+
+    prntr = SciPyPrinter()
+    assert prntr.doprint(expr) == 'scipy.special.beta(x, y)'
+
+    prntr = NumPyPrinter()
+    assert prntr.doprint(expr) == '(math.gamma(x)*math.gamma(y)/math.gamma(x + y))'
+
+    prntr = PythonCodePrinter()
+    assert prntr.doprint(expr) == '(math.gamma(x)*math.gamma(y)/math.gamma(x + y))'
+
+    prntr = PythonCodePrinter({'allow_unknown_functions': True})
+    assert prntr.doprint(expr) == '(math.gamma(x)*math.gamma(y)/math.gamma(x + y))'
+
+    prntr = MpmathPrinter()
+    assert prntr.doprint(expr) ==  'mpmath.beta(x, y)'
+
+def test_airy():
+    from sympy.functions.special.bessel import (airyai, airybi)
+
+    expr1 = airyai(x)
+    expr2 = airybi(x)
+
+    prntr = SciPyPrinter()
+    assert prntr.doprint(expr1) == 'scipy.special.airy(x)[0]'
+    assert prntr.doprint(expr2) == 'scipy.special.airy(x)[2]'
+
+    prntr = NumPyPrinter({'strict': False})
+    assert "Not supported" in prntr.doprint(expr1)
+    assert "Not supported" in prntr.doprint(expr2)
+
+    prntr = PythonCodePrinter({'strict': False})
+    assert "Not supported" in prntr.doprint(expr1)
+    assert "Not supported" in prntr.doprint(expr2)
+
+def test_airy_prime():
+    from sympy.functions.special.bessel import (airyaiprime, airybiprime)
+
+    expr1 = airyaiprime(x)
+    expr2 = airybiprime(x)
+
+    prntr = SciPyPrinter()
+    assert prntr.doprint(expr1) == 'scipy.special.airy(x)[1]'
+    assert prntr.doprint(expr2) == 'scipy.special.airy(x)[3]'
+
+    prntr = NumPyPrinter({'strict': False})
+    assert "Not supported" in prntr.doprint(expr1)
+    assert "Not supported" in prntr.doprint(expr2)
+
+    prntr = PythonCodePrinter({'strict': False})
+    assert "Not supported" in prntr.doprint(expr1)
+    assert "Not supported" in prntr.doprint(expr2)
+
+
+def test_numerical_accuracy_functions():
+    prntr = SciPyPrinter()
+    assert prntr.doprint(expm1(x)) == 'numpy.expm1(x)'
+    assert prntr.doprint(log1p(x)) == 'numpy.log1p(x)'
+    assert prntr.doprint(cosm1(x)) == 'scipy.special.cosm1(x)'
+
+def test_array_printer():
+    A = ArraySymbol('A', (4,4,6,6,6))
+    I = IndexedBase('I')
+    i,j,k = Idx('i', (0,1)), Idx('j', (2,3)), Idx('k', (4,5))
+
+    prntr = NumPyPrinter()
+    assert prntr.doprint(ZeroArray(5)) == 'numpy.zeros((5,))'
+    assert prntr.doprint(OneArray(5)) == 'numpy.ones((5,))'
+    assert prntr.doprint(ArrayContraction(A, [2,3])) == 'numpy.einsum("abccd->abd", A)'
+    assert prntr.doprint(I) == 'I'
+    assert prntr.doprint(ArrayDiagonal(A, [2,3,4])) == 'numpy.einsum("abccc->abc", A)'
+    assert prntr.doprint(ArrayDiagonal(A, [0,1], [2,3])) == 'numpy.einsum("aabbc->cab", A)'
+    assert prntr.doprint(ArrayContraction(A, [2], [3])) == 'numpy.einsum("abcde->abe", A)'
+    assert prntr.doprint(Assignment(I[i,j,k], I[i,j,k])) == 'I = I'
+
+    prntr = TensorflowPrinter()
+    assert prntr.doprint(ZeroArray(5)) == 'tensorflow.zeros((5,))'
+    assert prntr.doprint(OneArray(5)) == 'tensorflow.ones((5,))'
+    assert prntr.doprint(ArrayContraction(A, [2,3])) == 'tensorflow.linalg.einsum("abccd->abd", A)'
+    assert prntr.doprint(I) == 'I'
+    assert prntr.doprint(ArrayDiagonal(A, [2,3,4])) == 'tensorflow.linalg.einsum("abccc->abc", A)'
+    assert prntr.doprint(ArrayDiagonal(A, [0,1], [2,3])) == 'tensorflow.linalg.einsum("aabbc->cab", A)'
+    assert prntr.doprint(ArrayContraction(A, [2], [3])) == 'tensorflow.linalg.einsum("abcde->abe", A)'
+    assert prntr.doprint(Assignment(I[i,j,k], I[i,j,k])) == 'I = I'
+
+
+def test_custom_Derivative_methods():
+    class MyPrinter(SciPyPrinter):
+        def _print_Derivative_cosm1(self, args, seq_orders):
+            arg, = args
+            order, = seq_orders
+            return 'my_custom_cosm1(%s, deriv_order=%d)' % (self._print(arg), order)
+
+        def _print_Derivative_atan2(self, args, seq_orders):
+            arg1, arg2 = args
+            ord1, ord2 = seq_orders
+            return 'my_custom_atan2(%s, %s, deriv1=%d, deriv2=%d)' % (
+                self._print(arg1), self._print(arg2), ord1, ord2
+            )
+
+    p = MyPrinter()
+    cosm1_1 = cosm1(x).diff(x, evaluate=False)
+    assert p.doprint(cosm1_1) == 'my_custom_cosm1(x, deriv_order=1)'
+    atan2_2_3 = atan2(x, y).diff(x, 2, y, 3, evaluate=False)
+    assert p.doprint(atan2_2_3) == 'my_custom_atan2(x, y, deriv1=2, deriv2=3)'
+
+    try:
+        p.doprint(expm1(x).diff(x, evaluate=False))
+    except PrintMethodNotImplementedError as e:
+        assert '_print_Derivative_expm1' in repr(e)
+    else:
+        assert False  # should have thrown
+
+    try:
+        p.doprint(Derivative(cosm1(x**2),x))
+    except ValueError as e:
+        assert '_print_Derivative(' in repr(e)
+    else:
+        assert False  # should have thrown
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/test_python.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/test_python.py
new file mode 100644
index 0000000000000000000000000000000000000000..fb94a662be90934a672d08b3de44a22e2580d8b6
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/test_python.py
@@ -0,0 +1,203 @@
+from sympy.core.function import (Derivative, Function)
+from sympy.core.numbers import (I, Rational, oo, pi)
+from sympy.core.relational import (Eq, Ge, Gt, Le, Lt, Ne)
+from sympy.core.symbol import (Symbol, symbols)
+from sympy.functions.elementary.complexes import (Abs, conjugate)
+from sympy.functions.elementary.exponential import (exp, log)
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import sin
+from sympy.integrals.integrals import Integral
+from sympy.matrices.dense import Matrix
+from sympy.series.limits import limit
+
+from sympy.printing.python import python
+
+from sympy.testing.pytest import raises, XFAIL
+
+x, y = symbols('x,y')
+th = Symbol('theta')
+ph = Symbol('phi')
+
+
+def test_python_basic():
+    # Simple numbers/symbols
+    assert python(-Rational(1)/2) == "e = Rational(-1, 2)"
+    assert python(-Rational(13)/22) == "e = Rational(-13, 22)"
+    assert python(oo) == "e = oo"
+
+    # Powers
+    assert python(x**2) == "x = Symbol(\'x\')\ne = x**2"
+    assert python(1/x) == "x = Symbol('x')\ne = 1/x"
+    assert python(y*x**-2) == "y = Symbol('y')\nx = Symbol('x')\ne = y/x**2"
+    assert python(
+        x**Rational(-5, 2)) == "x = Symbol('x')\ne = x**Rational(-5, 2)"
+
+    # Sums of terms
+    assert python(x**2 + x + 1) in [
+        "x = Symbol('x')\ne = 1 + x + x**2",
+        "x = Symbol('x')\ne = x + x**2 + 1",
+        "x = Symbol('x')\ne = x**2 + x + 1", ]
+    assert python(1 - x) in [
+        "x = Symbol('x')\ne = 1 - x",
+        "x = Symbol('x')\ne = -x + 1"]
+    assert python(1 - 2*x) in [
+        "x = Symbol('x')\ne = 1 - 2*x",
+        "x = Symbol('x')\ne = -2*x + 1"]
+    assert python(1 - Rational(3, 2)*y/x) in [
+        "y = Symbol('y')\nx = Symbol('x')\ne = 1 - 3/2*y/x",
+        "y = Symbol('y')\nx = Symbol('x')\ne = -3/2*y/x + 1",
+        "y = Symbol('y')\nx = Symbol('x')\ne = 1 - 3*y/(2*x)"]
+
+    # Multiplication
+    assert python(x/y) == "x = Symbol('x')\ny = Symbol('y')\ne = x/y"
+    assert python(-x/y) == "x = Symbol('x')\ny = Symbol('y')\ne = -x/y"
+    assert python((x + 2)/y) in [
+        "y = Symbol('y')\nx = Symbol('x')\ne = 1/y*(2 + x)",
+        "y = Symbol('y')\nx = Symbol('x')\ne = 1/y*(x + 2)",
+        "x = Symbol('x')\ny = Symbol('y')\ne = 1/y*(2 + x)",
+        "x = Symbol('x')\ny = Symbol('y')\ne = (2 + x)/y",
+        "x = Symbol('x')\ny = Symbol('y')\ne = (x + 2)/y"]
+    assert python((1 + x)*y) in [
+        "y = Symbol('y')\nx = Symbol('x')\ne = y*(1 + x)",
+        "y = Symbol('y')\nx = Symbol('x')\ne = y*(x + 1)", ]
+
+    # Check for proper placement of negative sign
+    assert python(-5*x/(x + 10)) == "x = Symbol('x')\ne = -5*x/(x + 10)"
+    assert python(1 - Rational(3, 2)*(x + 1)) in [
+        "x = Symbol('x')\ne = Rational(-3, 2)*x + Rational(-1, 2)",
+        "x = Symbol('x')\ne = -3*x/2 + Rational(-1, 2)",
+        "x = Symbol('x')\ne = -3*x/2 + Rational(-1, 2)"
+    ]
+
+
+def test_python_keyword_symbol_name_escaping():
+    # Check for escaping of keywords
+    assert python(
+        5*Symbol("lambda")) == "lambda_ = Symbol('lambda')\ne = 5*lambda_"
+    assert (python(5*Symbol("lambda") + 7*Symbol("lambda_")) ==
+            "lambda__ = Symbol('lambda')\nlambda_ = Symbol('lambda_')\ne = 7*lambda_ + 5*lambda__")
+    assert (python(5*Symbol("for") + Function("for_")(8)) ==
+            "for__ = Symbol('for')\nfor_ = Function('for_')\ne = 5*for__ + for_(8)")
+
+
+def test_python_keyword_function_name_escaping():
+    assert python(
+        5*Function("for")(8)) == "for_ = Function('for')\ne = 5*for_(8)"
+
+
+def test_python_relational():
+    assert python(Eq(x, y)) == "x = Symbol('x')\ny = Symbol('y')\ne = Eq(x, y)"
+    assert python(Ge(x, y)) == "x = Symbol('x')\ny = Symbol('y')\ne = x >= y"
+    assert python(Le(x, y)) == "x = Symbol('x')\ny = Symbol('y')\ne = x <= y"
+    assert python(Gt(x, y)) == "x = Symbol('x')\ny = Symbol('y')\ne = x > y"
+    assert python(Lt(x, y)) == "x = Symbol('x')\ny = Symbol('y')\ne = x < y"
+    assert python(Ne(x/(y + 1), y**2)) in [
+        "x = Symbol('x')\ny = Symbol('y')\ne = Ne(x/(1 + y), y**2)",
+        "x = Symbol('x')\ny = Symbol('y')\ne = Ne(x/(y + 1), y**2)"]
+
+
+def test_python_functions():
+    # Simple
+    assert python(2*x + exp(x)) in "x = Symbol('x')\ne = 2*x + exp(x)"
+    assert python(sqrt(2)) == 'e = sqrt(2)'
+    assert python(2**Rational(1, 3)) == 'e = 2**Rational(1, 3)'
+    assert python(sqrt(2 + pi)) == 'e = sqrt(2 + pi)'
+    assert python((2 + pi)**Rational(1, 3)) == 'e = (2 + pi)**Rational(1, 3)'
+    assert python(2**Rational(1, 4)) == 'e = 2**Rational(1, 4)'
+    assert python(Abs(x)) == "x = Symbol('x')\ne = Abs(x)"
+    assert python(
+        Abs(x/(x**2 + 1))) in ["x = Symbol('x')\ne = Abs(x/(1 + x**2))",
+            "x = Symbol('x')\ne = Abs(x/(x**2 + 1))"]
+
+    # Univariate/Multivariate functions
+    f = Function('f')
+    assert python(f(x)) == "x = Symbol('x')\nf = Function('f')\ne = f(x)"
+    assert python(f(x, y)) == "x = Symbol('x')\ny = Symbol('y')\nf = Function('f')\ne = f(x, y)"
+    assert python(f(x/(y + 1), y)) in [
+        "x = Symbol('x')\ny = Symbol('y')\nf = Function('f')\ne = f(x/(1 + y), y)",
+        "x = Symbol('x')\ny = Symbol('y')\nf = Function('f')\ne = f(x/(y + 1), y)"]
+
+    # Nesting of square roots
+    assert python(sqrt((sqrt(x + 1)) + 1)) in [
+        "x = Symbol('x')\ne = sqrt(1 + sqrt(1 + x))",
+        "x = Symbol('x')\ne = sqrt(sqrt(x + 1) + 1)"]
+
+    # Nesting of powers
+    assert python((((x + 1)**Rational(1, 3)) + 1)**Rational(1, 3)) in [
+        "x = Symbol('x')\ne = (1 + (1 + x)**Rational(1, 3))**Rational(1, 3)",
+        "x = Symbol('x')\ne = ((x + 1)**Rational(1, 3) + 1)**Rational(1, 3)"]
+
+    # Function powers
+    assert python(sin(x)**2) == "x = Symbol('x')\ne = sin(x)**2"
+
+
+@XFAIL
+def test_python_functions_conjugates():
+    a, b = map(Symbol, 'ab')
+    assert python( conjugate(a + b*I) ) == '_     _\na - I*b'
+    assert python( conjugate(exp(a + b*I)) ) == ' _     _\n a - I*b\ne       '
+
+
+def test_python_derivatives():
+    # Simple
+    f_1 = Derivative(log(x), x, evaluate=False)
+    assert python(f_1) == "x = Symbol('x')\ne = Derivative(log(x), x)"
+
+    f_2 = Derivative(log(x), x, evaluate=False) + x
+    assert python(f_2) == "x = Symbol('x')\ne = x + Derivative(log(x), x)"
+
+    # Multiple symbols
+    f_3 = Derivative(log(x) + x**2, x, y, evaluate=False)
+    assert python(f_3) == \
+        "x = Symbol('x')\ny = Symbol('y')\ne = Derivative(x**2 + log(x), x, y)"
+
+    f_4 = Derivative(2*x*y, y, x, evaluate=False) + x**2
+    assert python(f_4) in [
+        "x = Symbol('x')\ny = Symbol('y')\ne = x**2 + Derivative(2*x*y, y, x)",
+        "x = Symbol('x')\ny = Symbol('y')\ne = Derivative(2*x*y, y, x) + x**2"]
+
+
+def test_python_integrals():
+    # Simple
+    f_1 = Integral(log(x), x)
+    assert python(f_1) == "x = Symbol('x')\ne = Integral(log(x), x)"
+
+    f_2 = Integral(x**2, x)
+    assert python(f_2) == "x = Symbol('x')\ne = Integral(x**2, x)"
+
+    # Double nesting of pow
+    f_3 = Integral(x**(2**x), x)
+    assert python(f_3) == "x = Symbol('x')\ne = Integral(x**(2**x), x)"
+
+    # Definite integrals
+    f_4 = Integral(x**2, (x, 1, 2))
+    assert python(f_4) == "x = Symbol('x')\ne = Integral(x**2, (x, 1, 2))"
+
+    f_5 = Integral(x**2, (x, Rational(1, 2), 10))
+    assert python(
+        f_5) == "x = Symbol('x')\ne = Integral(x**2, (x, Rational(1, 2), 10))"
+
+    # Nested integrals
+    f_6 = Integral(x**2*y**2, x, y)
+    assert python(f_6) == "x = Symbol('x')\ny = Symbol('y')\ne = Integral(x**2*y**2, x, y)"
+
+
+def test_python_matrix():
+    p = python(Matrix([[x**2+1, 1], [y, x+y]]))
+    s = "x = Symbol('x')\ny = Symbol('y')\ne = MutableDenseMatrix([[x**2 + 1, 1], [y, x + y]])"
+    assert p == s
+
+def test_python_limits():
+    assert python(limit(x, x, oo)) == 'e = oo'
+    assert python(limit(x**2, x, 0)) == 'e = 0'
+
+def test_issue_20762():
+    # Make sure Python removes curly braces from subscripted variables
+    a_b = Symbol('a_{b}')
+    b = Symbol('b')
+    expr = a_b*b
+    assert python(expr) == "a_b = Symbol('a_{b}')\nb = Symbol('b')\ne = a_b*b"
+
+
+def test_settings():
+    raises(TypeError, lambda: python(x, method="garbage"))
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/test_rcode.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/test_rcode.py
new file mode 100644
index 0000000000000000000000000000000000000000..a83235b0654c6bf24c30846dbf68678d29cd3c80
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/test_rcode.py
@@ -0,0 +1,476 @@
+from sympy.core import (S, pi, oo, Symbol, symbols, Rational, Integer,
+                        GoldenRatio, EulerGamma, Catalan, Lambda, Dummy)
+from sympy.functions import (Piecewise, sin, cos, Abs, exp, ceiling, sqrt,
+                             gamma, sign, Max, Min, factorial, beta)
+from sympy.core.relational import (Eq, Ge, Gt, Le, Lt, Ne)
+from sympy.sets import Range
+from sympy.logic import ITE
+from sympy.codegen import For, aug_assign, Assignment
+from sympy.testing.pytest import raises
+from sympy.printing.rcode import RCodePrinter
+from sympy.utilities.lambdify import implemented_function
+from sympy.tensor import IndexedBase, Idx
+from sympy.matrices import Matrix, MatrixSymbol
+
+from sympy.printing.rcode import rcode
+
+x, y, z = symbols('x,y,z')
+
+
+def test_printmethod():
+    class fabs(Abs):
+        def _rcode(self, printer):
+            return "abs(%s)" % printer._print(self.args[0])
+
+    assert rcode(fabs(x)) == "abs(x)"
+
+
+def test_rcode_sqrt():
+    assert rcode(sqrt(x)) == "sqrt(x)"
+    assert rcode(x**0.5) == "sqrt(x)"
+    assert rcode(sqrt(x)) == "sqrt(x)"
+
+
+def test_rcode_Pow():
+    assert rcode(x**3) == "x^3"
+    assert rcode(x**(y**3)) == "x^(y^3)"
+    g = implemented_function('g', Lambda(x, 2*x))
+    assert rcode(1/(g(x)*3.5)**(x - y**x)/(x**2 + y)) == \
+        "(3.5*2*x)^(-x + y^x)/(x^2 + y)"
+    assert rcode(x**-1.0) == '1.0/x'
+    assert rcode(x**Rational(2, 3)) == 'x^(2.0/3.0)'
+    _cond_cfunc = [(lambda base, exp: exp.is_integer, "dpowi"),
+                   (lambda base, exp: not exp.is_integer, "pow")]
+    assert rcode(x**3, user_functions={'Pow': _cond_cfunc}) == 'dpowi(x, 3)'
+    assert rcode(x**3.2, user_functions={'Pow': _cond_cfunc}) == 'pow(x, 3.2)'
+
+
+def test_rcode_Max():
+    # Test for gh-11926
+    assert rcode(Max(x,x*x),user_functions={"Max":"my_max", "Pow":"my_pow"}) == 'my_max(x, my_pow(x, 2))'
+
+
+def test_rcode_constants_mathh():
+    assert rcode(exp(1)) == "exp(1)"
+    assert rcode(pi) == "pi"
+    assert rcode(oo) == "Inf"
+    assert rcode(-oo) == "-Inf"
+
+
+def test_rcode_constants_other():
+    assert rcode(2*GoldenRatio) == "GoldenRatio = 1.61803398874989;\n2*GoldenRatio"
+    assert rcode(
+        2*Catalan) == "Catalan = 0.915965594177219;\n2*Catalan"
+    assert rcode(2*EulerGamma) == "EulerGamma = 0.577215664901533;\n2*EulerGamma"
+
+
+def test_rcode_Rational():
+    assert rcode(Rational(3, 7)) == "3.0/7.0"
+    assert rcode(Rational(18, 9)) == "2"
+    assert rcode(Rational(3, -7)) == "-3.0/7.0"
+    assert rcode(Rational(-3, -7)) == "3.0/7.0"
+    assert rcode(x + Rational(3, 7)) == "x + 3.0/7.0"
+    assert rcode(Rational(3, 7)*x) == "(3.0/7.0)*x"
+
+
+def test_rcode_Integer():
+    assert rcode(Integer(67)) == "67"
+    assert rcode(Integer(-1)) == "-1"
+
+
+def test_rcode_functions():
+    assert rcode(sin(x) ** cos(x)) == "sin(x)^cos(x)"
+    assert rcode(factorial(x) + gamma(y)) == "factorial(x) + gamma(y)"
+    assert rcode(beta(Min(x, y), Max(x, y))) == "beta(min(x, y), max(x, y))"
+
+
+def test_rcode_inline_function():
+    x = symbols('x')
+    g = implemented_function('g', Lambda(x, 2*x))
+    assert rcode(g(x)) == "2*x"
+    g = implemented_function('g', Lambda(x, 2*x/Catalan))
+    assert rcode(
+        g(x)) == "Catalan = %s;\n2*x/Catalan" % Catalan.n()
+    A = IndexedBase('A')
+    i = Idx('i', symbols('n', integer=True))
+    g = implemented_function('g', Lambda(x, x*(1 + x)*(2 + x)))
+    res=rcode(g(A[i]), assign_to=A[i])
+    ref=(
+        "for (i in 1:n){\n"
+        "   A[i] = (A[i] + 1)*(A[i] + 2)*A[i];\n"
+        "}"
+    )
+    assert res == ref
+
+
+def test_rcode_exceptions():
+    assert rcode(ceiling(x)) == "ceiling(x)"
+    assert rcode(Abs(x)) == "abs(x)"
+    assert rcode(gamma(x)) == "gamma(x)"
+
+
+def test_rcode_user_functions():
+    x = symbols('x', integer=False)
+    n = symbols('n', integer=True)
+    custom_functions = {
+        "ceiling": "myceil",
+        "Abs": [(lambda x: not x.is_integer, "fabs"), (lambda x: x.is_integer, "abs")],
+    }
+    assert rcode(ceiling(x), user_functions=custom_functions) == "myceil(x)"
+    assert rcode(Abs(x), user_functions=custom_functions) == "fabs(x)"
+    assert rcode(Abs(n), user_functions=custom_functions) == "abs(n)"
+
+
+def test_rcode_boolean():
+    assert rcode(True) == "True"
+    assert rcode(S.true) == "True"
+    assert rcode(False) == "False"
+    assert rcode(S.false) == "False"
+    assert rcode(x & y) == "x & y"
+    assert rcode(x | y) == "x | y"
+    assert rcode(~x) == "!x"
+    assert rcode(x & y & z) == "x & y & z"
+    assert rcode(x | y | z) == "x | y | z"
+    assert rcode((x & y) | z) == "z | x & y"
+    assert rcode((x | y) & z) == "z & (x | y)"
+
+def test_rcode_Relational():
+    assert rcode(Eq(x, y)) == "x == y"
+    assert rcode(Ne(x, y)) == "x != y"
+    assert rcode(Le(x, y)) == "x <= y"
+    assert rcode(Lt(x, y)) == "x < y"
+    assert rcode(Gt(x, y)) == "x > y"
+    assert rcode(Ge(x, y)) == "x >= y"
+
+
+def test_rcode_Piecewise():
+    expr = Piecewise((x, x < 1), (x**2, True))
+    res=rcode(expr)
+    ref="ifelse(x < 1,x,x^2)"
+    assert res == ref
+    tau=Symbol("tau")
+    res=rcode(expr,tau)
+    ref="tau = ifelse(x < 1,x,x^2);"
+    assert res == ref
+
+    expr = 2*Piecewise((x, x < 1), (x**2, x<2), (x**3,True))
+    assert rcode(expr) == "2*ifelse(x < 1,x,ifelse(x < 2,x^2,x^3))"
+    res = rcode(expr, assign_to='c')
+    assert res == "c = 2*ifelse(x < 1,x,ifelse(x < 2,x^2,x^3));"
+
+    # Check that Piecewise without a True (default) condition error
+    #expr = Piecewise((x, x < 1), (x**2, x > 1), (sin(x), x > 0))
+    #raises(ValueError, lambda: rcode(expr))
+    expr = 2*Piecewise((x, x < 1), (x**2, x<2))
+    assert(rcode(expr))== "2*ifelse(x < 1,x,ifelse(x < 2,x^2,NA))"
+
+
+def test_rcode_sinc():
+    from sympy.functions.elementary.trigonometric import sinc
+    expr = sinc(x)
+    res = rcode(expr)
+    ref = "(ifelse(x != 0,sin(x)/x,1))"
+    assert res == ref
+
+
+def test_rcode_Piecewise_deep():
+    p = rcode(2*Piecewise((x, x < 1), (x + 1, x < 2), (x**2, True)))
+    assert p == "2*ifelse(x < 1,x,ifelse(x < 2,x + 1,x^2))"
+    expr = x*y*z + x**2 + y**2 + Piecewise((0, x < 0.5), (1, True)) + cos(z) - 1
+    p = rcode(expr)
+    ref="x^2 + x*y*z + y^2 + ifelse(x < 0.5,0,1) + cos(z) - 1"
+    assert p == ref
+
+    ref="c = x^2 + x*y*z + y^2 + ifelse(x < 0.5,0,1) + cos(z) - 1;"
+    p = rcode(expr, assign_to='c')
+    assert p == ref
+
+
+def test_rcode_ITE():
+    expr = ITE(x < 1, y, z)
+    p = rcode(expr)
+    ref="ifelse(x < 1,y,z)"
+    assert p == ref
+
+
+def test_rcode_settings():
+    raises(TypeError, lambda: rcode(sin(x), method="garbage"))
+
+
+def test_rcode_Indexed():
+    n, m, o = symbols('n m o', integer=True)
+    i, j, k = Idx('i', n), Idx('j', m), Idx('k', o)
+    p = RCodePrinter()
+    p._not_r = set()
+
+    x = IndexedBase('x')[j]
+    assert p._print_Indexed(x) == 'x[j]'
+    A = IndexedBase('A')[i, j]
+    assert p._print_Indexed(A) == 'A[i, j]'
+    B = IndexedBase('B')[i, j, k]
+    assert p._print_Indexed(B) == 'B[i, j, k]'
+
+    assert p._not_r == set()
+
+def test_rcode_Indexed_without_looking_for_contraction():
+    len_y = 5
+    y = IndexedBase('y', shape=(len_y,))
+    x = IndexedBase('x', shape=(len_y,))
+    Dy = IndexedBase('Dy', shape=(len_y-1,))
+    i = Idx('i', len_y-1)
+    e=Eq(Dy[i], (y[i+1]-y[i])/(x[i+1]-x[i]))
+    code0 = rcode(e.rhs, assign_to=e.lhs, contract=False)
+    assert code0 == 'Dy[i] = (y[%s] - y[i])/(x[%s] - x[i]);' % (i + 1, i + 1)
+
+
+def test_rcode_loops_matrix_vector():
+    n, m = symbols('n m', integer=True)
+    A = IndexedBase('A')
+    x = IndexedBase('x')
+    y = IndexedBase('y')
+    i = Idx('i', m)
+    j = Idx('j', n)
+
+    s = (
+        'for (i in 1:m){\n'
+        '   y[i] = 0;\n'
+        '}\n'
+        'for (i in 1:m){\n'
+        '   for (j in 1:n){\n'
+        '      y[i] = A[i, j]*x[j] + y[i];\n'
+        '   }\n'
+        '}'
+    )
+    c = rcode(A[i, j]*x[j], assign_to=y[i])
+    assert c == s
+
+
+def test_dummy_loops():
+    # the following line could also be
+    # [Dummy(s, integer=True) for s in 'im']
+    # or [Dummy(integer=True) for s in 'im']
+    i, m = symbols('i m', integer=True, cls=Dummy)
+    x = IndexedBase('x')
+    y = IndexedBase('y')
+    i = Idx(i, m)
+
+    expected = (
+            'for (i_%(icount)i in 1:m_%(mcount)i){\n'
+        '   y[i_%(icount)i] = x[i_%(icount)i];\n'
+        '}'
+    ) % {'icount': i.label.dummy_index, 'mcount': m.dummy_index}
+    code = rcode(x[i], assign_to=y[i])
+    assert code == expected
+
+
+def test_rcode_loops_add():
+    n, m = symbols('n m', integer=True)
+    A = IndexedBase('A')
+    x = IndexedBase('x')
+    y = IndexedBase('y')
+    z = IndexedBase('z')
+    i = Idx('i', m)
+    j = Idx('j', n)
+
+    s = (
+        'for (i in 1:m){\n'
+        '   y[i] = x[i] + z[i];\n'
+        '}\n'
+        'for (i in 1:m){\n'
+        '   for (j in 1:n){\n'
+        '      y[i] = A[i, j]*x[j] + y[i];\n'
+        '   }\n'
+        '}'
+    )
+    c = rcode(A[i, j]*x[j] + x[i] + z[i], assign_to=y[i])
+    assert c == s
+
+
+def test_rcode_loops_multiple_contractions():
+    n, m, o, p = symbols('n m o p', integer=True)
+    a = IndexedBase('a')
+    b = IndexedBase('b')
+    y = IndexedBase('y')
+    i = Idx('i', m)
+    j = Idx('j', n)
+    k = Idx('k', o)
+    l = Idx('l', p)
+
+    s = (
+        'for (i in 1:m){\n'
+        '   y[i] = 0;\n'
+        '}\n'
+        'for (i in 1:m){\n'
+        '   for (j in 1:n){\n'
+        '      for (k in 1:o){\n'
+        '         for (l in 1:p){\n'
+        '            y[i] = a[i, j, k, l]*b[j, k, l] + y[i];\n'
+        '         }\n'
+        '      }\n'
+        '   }\n'
+        '}'
+    )
+    c = rcode(b[j, k, l]*a[i, j, k, l], assign_to=y[i])
+    assert c == s
+
+
+def test_rcode_loops_addfactor():
+    n, m, o, p = symbols('n m o p', integer=True)
+    a = IndexedBase('a')
+    b = IndexedBase('b')
+    c = IndexedBase('c')
+    y = IndexedBase('y')
+    i = Idx('i', m)
+    j = Idx('j', n)
+    k = Idx('k', o)
+    l = Idx('l', p)
+
+    s = (
+        'for (i in 1:m){\n'
+        '   y[i] = 0;\n'
+        '}\n'
+        'for (i in 1:m){\n'
+        '   for (j in 1:n){\n'
+        '      for (k in 1:o){\n'
+        '         for (l in 1:p){\n'
+        '            y[i] = (a[i, j, k, l] + b[i, j, k, l])*c[j, k, l] + y[i];\n'
+        '         }\n'
+        '      }\n'
+        '   }\n'
+        '}'
+    )
+    c = rcode((a[i, j, k, l] + b[i, j, k, l])*c[j, k, l], assign_to=y[i])
+    assert c == s
+
+
+def test_rcode_loops_multiple_terms():
+    n, m, o, p = symbols('n m o p', integer=True)
+    a = IndexedBase('a')
+    b = IndexedBase('b')
+    c = IndexedBase('c')
+    y = IndexedBase('y')
+    i = Idx('i', m)
+    j = Idx('j', n)
+    k = Idx('k', o)
+
+    s0 = (
+        'for (i in 1:m){\n'
+        '   y[i] = 0;\n'
+        '}\n'
+    )
+    s1 = (
+        'for (i in 1:m){\n'
+        '   for (j in 1:n){\n'
+        '      for (k in 1:o){\n'
+        '         y[i] = b[j]*b[k]*c[i, j, k] + y[i];\n'
+        '      }\n'
+        '   }\n'
+        '}\n'
+    )
+    s2 = (
+        'for (i in 1:m){\n'
+        '   for (k in 1:o){\n'
+        '      y[i] = a[i, k]*b[k] + y[i];\n'
+        '   }\n'
+        '}\n'
+    )
+    s3 = (
+        'for (i in 1:m){\n'
+        '   for (j in 1:n){\n'
+        '      y[i] = a[i, j]*b[j] + y[i];\n'
+        '   }\n'
+        '}\n'
+    )
+    c = rcode(
+        b[j]*a[i, j] + b[k]*a[i, k] + b[j]*b[k]*c[i, j, k], assign_to=y[i])
+
+    ref={}
+    ref[0] = s0 + s1 + s2 + s3[:-1]
+    ref[1] = s0 + s1 + s3 + s2[:-1]
+    ref[2] = s0 + s2 + s1 + s3[:-1]
+    ref[3] = s0 + s2 + s3 + s1[:-1]
+    ref[4] = s0 + s3 + s1 + s2[:-1]
+    ref[5] = s0 + s3 + s2 + s1[:-1]
+
+    assert (c == ref[0] or
+            c == ref[1] or
+            c == ref[2] or
+            c == ref[3] or
+            c == ref[4] or
+            c == ref[5])
+
+
+def test_dereference_printing():
+    expr = x + y + sin(z) + z
+    assert rcode(expr, dereference=[z]) == "x + y + (*z) + sin((*z))"
+
+
+def test_Matrix_printing():
+    # Test returning a Matrix
+    mat = Matrix([x*y, Piecewise((2 + x, y>0), (y, True)), sin(z)])
+    A = MatrixSymbol('A', 3, 1)
+    p = rcode(mat, A)
+    assert p == (
+        "A[0] = x*y;\n"
+        "A[1] = ifelse(y > 0,x + 2,y);\n"
+        "A[2] = sin(z);")
+    # Test using MatrixElements in expressions
+    expr = Piecewise((2*A[2, 0], x > 0), (A[2, 0], True)) + sin(A[1, 0]) + A[0, 0]
+    p = rcode(expr)
+    assert p  == ("ifelse(x > 0,2*A[2],A[2]) + sin(A[1]) + A[0]")
+    # Test using MatrixElements in a Matrix
+    q = MatrixSymbol('q', 5, 1)
+    M = MatrixSymbol('M', 3, 3)
+    m = Matrix([[sin(q[1,0]), 0, cos(q[2,0])],
+        [q[1,0] + q[2,0], q[3, 0], 5],
+        [2*q[4, 0]/q[1,0], sqrt(q[0,0]) + 4, 0]])
+    assert rcode(m, M) == (
+        "M[0] = sin(q[1]);\n"
+        "M[1] = 0;\n"
+        "M[2] = cos(q[2]);\n"
+        "M[3] = q[1] + q[2];\n"
+        "M[4] = q[3];\n"
+        "M[5] = 5;\n"
+        "M[6] = 2*q[4]/q[1];\n"
+        "M[7] = sqrt(q[0]) + 4;\n"
+        "M[8] = 0;")
+
+
+def test_rcode_sgn():
+
+    expr = sign(x) * y
+    assert rcode(expr) == 'y*sign(x)'
+    p = rcode(expr, 'z')
+    assert p  == 'z = y*sign(x);'
+
+    p = rcode(sign(2 * x + x**2) * x + x**2)
+    assert p  == "x^2 + x*sign(x^2 + 2*x)"
+
+    expr = sign(cos(x))
+    p = rcode(expr)
+    assert p == 'sign(cos(x))'
+
+def test_rcode_Assignment():
+    assert rcode(Assignment(x, y + z)) == 'x = y + z;'
+    assert rcode(aug_assign(x, '+', y + z)) == 'x += y + z;'
+
+
+def test_rcode_For():
+    f = For(x, Range(0, 10, 2), [aug_assign(y, '*', x)])
+    sol = rcode(f)
+    assert sol == ("for(x in seq(from=0, to=9, by=2){\n"
+                   "   y *= x;\n"
+                   "}")
+
+
+def test_MatrixElement_printing():
+    # test cases for issue #11821
+    A = MatrixSymbol("A", 1, 3)
+    B = MatrixSymbol("B", 1, 3)
+    C = MatrixSymbol("C", 1, 3)
+
+    assert(rcode(A[0, 0]) == "A[0]")
+    assert(rcode(3 * A[0, 0]) == "3*A[0]")
+
+    F = C[0, 0].subs(C, A - B)
+    assert(rcode(F) == "(A - B)[0]")
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/test_repr.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/test_repr.py
new file mode 100644
index 0000000000000000000000000000000000000000..da58883b4fb027ed82db842a0a1ce5f76a49a8bb
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/test_repr.py
@@ -0,0 +1,382 @@
+from __future__ import annotations
+from typing import Any
+
+from sympy.external.gmpy import GROUND_TYPES
+from sympy.testing.pytest import raises, warns_deprecated_sympy
+from sympy.assumptions.ask import Q
+from sympy.core.function import (Function, WildFunction)
+from sympy.core.numbers import (AlgebraicNumber, Float, Integer, Rational)
+from sympy.core.singleton import S
+from sympy.core.symbol import (Dummy, Symbol, Wild, symbols)
+from sympy.core.sympify import sympify
+from sympy.functions.elementary.complexes import Abs
+from sympy.functions.elementary.miscellaneous import (root, sqrt)
+from sympy.functions.elementary.trigonometric import sin
+from sympy.functions.special.delta_functions import Heaviside
+from sympy.logic.boolalg import (false, true)
+from sympy.matrices.dense import (Matrix, ones)
+from sympy.matrices.expressions.matexpr import MatrixSymbol
+from sympy.matrices.immutable import ImmutableDenseMatrix
+from sympy.combinatorics import Cycle, Permutation
+from sympy.core.symbol import Str
+from sympy.geometry import Point, Ellipse
+from sympy.printing import srepr
+from sympy.polys import ring, field, ZZ, QQ, lex, grlex, Poly
+from sympy.polys.polyclasses import DMP
+from sympy.polys.agca.extensions import FiniteExtension
+
+x, y = symbols('x,y')
+
+# eval(srepr(expr)) == expr has to succeed in the right environment. The right
+# environment is the scope of "from sympy import *" for most cases.
+ENV: dict[str, Any] = {"Str": Str}
+exec("from sympy import *", ENV)
+
+
+def sT(expr, string, import_stmt=None, **kwargs):
+    """
+    sT := sreprTest
+
+    Tests that srepr delivers the expected string and that
+    the condition eval(srepr(expr))==expr holds.
+    """
+    if import_stmt is None:
+        ENV2 = ENV
+    else:
+        ENV2 = ENV.copy()
+        exec(import_stmt, ENV2)
+
+    assert srepr(expr, **kwargs) == string
+    assert eval(string, ENV2) == expr
+
+
+def test_printmethod():
+    class R(Abs):
+        def _sympyrepr(self, printer):
+            return "foo(%s)" % printer._print(self.args[0])
+    assert srepr(R(x)) == "foo(Symbol('x'))"
+
+
+def test_Add():
+    sT(x + y, "Add(Symbol('x'), Symbol('y'))")
+    assert srepr(x**2 + 1, order='lex') == "Add(Pow(Symbol('x'), Integer(2)), Integer(1))"
+    assert srepr(x**2 + 1, order='old') == "Add(Integer(1), Pow(Symbol('x'), Integer(2)))"
+    assert srepr(sympify('x + 3 - 2', evaluate=False), order='none') == "Add(Symbol('x'), Integer(3), Mul(Integer(-1), Integer(2)))"
+
+
+def test_more_than_255_args_issue_10259():
+    from sympy.core.add import Add
+    from sympy.core.mul import Mul
+    for op in (Add, Mul):
+        expr = op(*symbols('x:256'))
+        assert eval(srepr(expr)) == expr
+
+
+def test_Function():
+    sT(Function("f")(x), "Function('f')(Symbol('x'))")
+    # test unapplied Function
+    sT(Function('f'), "Function('f')")
+
+    sT(sin(x), "sin(Symbol('x'))")
+    sT(sin, "sin")
+
+
+def test_Heaviside():
+    sT(Heaviside(x), "Heaviside(Symbol('x'))")
+    sT(Heaviside(x, 1), "Heaviside(Symbol('x'), Integer(1))")
+
+
+def test_Geometry():
+    sT(Point(0, 0), "Point2D(Integer(0), Integer(0))")
+    sT(Ellipse(Point(0, 0), 5, 1),
+       "Ellipse(Point2D(Integer(0), Integer(0)), Integer(5), Integer(1))")
+    # TODO more tests
+
+
+def test_Singletons():
+    sT(S.Catalan, 'Catalan')
+    sT(S.ComplexInfinity, 'zoo')
+    sT(S.EulerGamma, 'EulerGamma')
+    sT(S.Exp1, 'E')
+    sT(S.GoldenRatio, 'GoldenRatio')
+    sT(S.TribonacciConstant, 'TribonacciConstant')
+    sT(S.Half, 'Rational(1, 2)')
+    sT(S.ImaginaryUnit, 'I')
+    sT(S.Infinity, 'oo')
+    sT(S.NaN, 'nan')
+    sT(S.NegativeInfinity, '-oo')
+    sT(S.NegativeOne, 'Integer(-1)')
+    sT(S.One, 'Integer(1)')
+    sT(S.Pi, 'pi')
+    sT(S.Zero, 'Integer(0)')
+    sT(S.Complexes, 'Complexes')
+    sT(S.EmptySequence, 'EmptySequence')
+    sT(S.EmptySet, 'EmptySet')
+    # sT(S.IdentityFunction, 'Lambda(_x, _x)')
+    sT(S.Naturals, 'Naturals')
+    sT(S.Naturals0, 'Naturals0')
+    sT(S.Rationals, 'Rationals')
+    sT(S.Reals, 'Reals')
+    sT(S.UniversalSet, 'UniversalSet')
+
+
+def test_Integer():
+    sT(Integer(4), "Integer(4)")
+
+
+def test_list():
+    sT([x, Integer(4)], "[Symbol('x'), Integer(4)]")
+
+
+def test_Matrix():
+    for cls, name in [(Matrix, "MutableDenseMatrix"), (ImmutableDenseMatrix, "ImmutableDenseMatrix")]:
+        sT(cls([[x**+1, 1], [y, x + y]]),
+           "%s([[Symbol('x'), Integer(1)], [Symbol('y'), Add(Symbol('x'), Symbol('y'))]])" % name)
+
+        sT(cls(), "%s([])" % name)
+
+        sT(cls([[x**+1, 1], [y, x + y]]), "%s([[Symbol('x'), Integer(1)], [Symbol('y'), Add(Symbol('x'), Symbol('y'))]])" % name)
+
+
+def test_empty_Matrix():
+    sT(ones(0, 3), "MutableDenseMatrix(0, 3, [])")
+    sT(ones(4, 0), "MutableDenseMatrix(4, 0, [])")
+    sT(ones(0, 0), "MutableDenseMatrix([])")
+
+
+def test_Rational():
+    sT(Rational(1, 3), "Rational(1, 3)")
+    sT(Rational(-1, 3), "Rational(-1, 3)")
+
+
+def test_Float():
+    sT(Float('1.23', dps=3), "Float('1.22998', precision=13)")
+    sT(Float('1.23456789', dps=9), "Float('1.23456788994', precision=33)")
+    sT(Float('1.234567890123456789', dps=19),
+       "Float('1.234567890123456789013', precision=66)")
+    sT(Float('0.60038617995049726', dps=15),
+       "Float('0.60038617995049726', precision=53)")
+
+    sT(Float('1.23', precision=13), "Float('1.22998', precision=13)")
+    sT(Float('1.23456789', precision=33),
+       "Float('1.23456788994', precision=33)")
+    sT(Float('1.234567890123456789', precision=66),
+       "Float('1.234567890123456789013', precision=66)")
+    sT(Float('0.60038617995049726', precision=53),
+       "Float('0.60038617995049726', precision=53)")
+
+    sT(Float('0.60038617995049726', 15),
+       "Float('0.60038617995049726', precision=53)")
+
+
+def test_Symbol():
+    sT(x, "Symbol('x')")
+    sT(y, "Symbol('y')")
+    sT(Symbol('x', negative=True), "Symbol('x', negative=True)")
+
+
+def test_Symbol_two_assumptions():
+    x = Symbol('x', negative=0, integer=1)
+    # order could vary
+    s1 = "Symbol('x', integer=True, negative=False)"
+    s2 = "Symbol('x', negative=False, integer=True)"
+    assert srepr(x) in (s1, s2)
+    assert eval(srepr(x), ENV) == x
+
+
+def test_Symbol_no_special_commutative_treatment():
+    sT(Symbol('x'), "Symbol('x')")
+    sT(Symbol('x', commutative=False), "Symbol('x', commutative=False)")
+    sT(Symbol('x', commutative=0), "Symbol('x', commutative=False)")
+    sT(Symbol('x', commutative=True), "Symbol('x', commutative=True)")
+    sT(Symbol('x', commutative=1), "Symbol('x', commutative=True)")
+
+
+def test_Wild():
+    sT(Wild('x', even=True), "Wild('x', even=True)")
+
+
+def test_Dummy():
+    d = Dummy('d')
+    sT(d, "Dummy('d', dummy_index=%s)" % str(d.dummy_index))
+
+
+def test_Dummy_assumption():
+    d = Dummy('d', nonzero=True)
+    assert d == eval(srepr(d))
+    s1 = "Dummy('d', dummy_index=%s, nonzero=True)" % str(d.dummy_index)
+    s2 = "Dummy('d', nonzero=True, dummy_index=%s)" % str(d.dummy_index)
+    assert srepr(d) in (s1, s2)
+
+
+def test_Dummy_from_Symbol():
+    # should not get the full dictionary of assumptions
+    n = Symbol('n', integer=True)
+    d = n.as_dummy()
+    assert srepr(d
+        ) == "Dummy('n', dummy_index=%s)" % str(d.dummy_index)
+
+
+def test_tuple():
+    sT((x,), "(Symbol('x'),)")
+    sT((x, y), "(Symbol('x'), Symbol('y'))")
+
+
+def test_WildFunction():
+    sT(WildFunction('w'), "WildFunction('w')")
+
+
+def test_settins():
+    raises(TypeError, lambda: srepr(x, method="garbage"))
+
+
+def test_Mul():
+    sT(3*x**3*y, "Mul(Integer(3), Pow(Symbol('x'), Integer(3)), Symbol('y'))")
+    assert srepr(3*x**3*y, order='old') == "Mul(Integer(3), Symbol('y'), Pow(Symbol('x'), Integer(3)))"
+    assert srepr(sympify('(x+4)*2*x*7', evaluate=False), order='none') == "Mul(Add(Symbol('x'), Integer(4)), Integer(2), Symbol('x'), Integer(7))"
+
+
+def test_AlgebraicNumber():
+    a = AlgebraicNumber(sqrt(2))
+    sT(a, "AlgebraicNumber(Pow(Integer(2), Rational(1, 2)), [Integer(1), Integer(0)])")
+    a = AlgebraicNumber(root(-2, 3))
+    sT(a, "AlgebraicNumber(Pow(Integer(-2), Rational(1, 3)), [Integer(1), Integer(0)])")
+
+
+def test_PolyRing():
+    assert srepr(ring("x", ZZ, lex)[0]) == "PolyRing((Symbol('x'),), ZZ, lex)"
+    assert srepr(ring("x,y", QQ, grlex)[0]) == "PolyRing((Symbol('x'), Symbol('y')), QQ, grlex)"
+    assert srepr(ring("x,y,z", ZZ["t"], lex)[0]) == "PolyRing((Symbol('x'), Symbol('y'), Symbol('z')), ZZ[t], lex)"
+
+
+def test_FracField():
+    assert srepr(field("x", ZZ, lex)[0]) == "FracField((Symbol('x'),), ZZ, lex)"
+    assert srepr(field("x,y", QQ, grlex)[0]) == "FracField((Symbol('x'), Symbol('y')), QQ, grlex)"
+    assert srepr(field("x,y,z", ZZ["t"], lex)[0]) == "FracField((Symbol('x'), Symbol('y'), Symbol('z')), ZZ[t], lex)"
+
+
+def test_PolyElement():
+    R, x, y = ring("x,y", ZZ)
+    assert srepr(3*x**2*y + 1) == "PolyElement(PolyRing((Symbol('x'), Symbol('y')), ZZ, lex), [((2, 1), 3), ((0, 0), 1)])"
+
+
+def test_FracElement():
+    F, x, y = field("x,y", ZZ)
+    assert srepr((3*x**2*y + 1)/(x - y**2)) == "FracElement(FracField((Symbol('x'), Symbol('y')), ZZ, lex), [((2, 1), 3), ((0, 0), 1)], [((1, 0), 1), ((0, 2), -1)])"
+
+
+def test_FractionField():
+    assert srepr(QQ.frac_field(x)) == \
+        "FractionField(FracField((Symbol('x'),), QQ, lex))"
+    assert srepr(QQ.frac_field(x, y, order=grlex)) == \
+        "FractionField(FracField((Symbol('x'), Symbol('y')), QQ, grlex))"
+
+
+def test_PolynomialRingBase():
+    assert srepr(ZZ.old_poly_ring(x)) == \
+        "GlobalPolynomialRing(ZZ, Symbol('x'))"
+    assert srepr(ZZ[x].old_poly_ring(y)) == \
+        "GlobalPolynomialRing(ZZ[x], Symbol('y'))"
+    assert srepr(QQ.frac_field(x).old_poly_ring(y)) == \
+        "GlobalPolynomialRing(FractionField(FracField((Symbol('x'),), QQ, lex)), Symbol('y'))"
+
+
+def test_DMP():
+    p1 = DMP([1, 2], ZZ)
+    p2 = ZZ.old_poly_ring(x)([1, 2])
+    if GROUND_TYPES != 'flint':
+        assert srepr(p1) == "DMP_Python([1, 2], ZZ)"
+        assert srepr(p2) == "DMP_Python([1, 2], ZZ)"
+    else:
+        assert srepr(p1) == "DUP_Flint([1, 2], ZZ)"
+        assert srepr(p2) == "DUP_Flint([1, 2], ZZ)"
+
+
+def test_FiniteExtension():
+    assert srepr(FiniteExtension(Poly(x**2 + 1, x))) == \
+        "FiniteExtension(Poly(x**2 + 1, x, domain='ZZ'))"
+
+
+def test_ExtensionElement():
+    A = FiniteExtension(Poly(x**2 + 1, x))
+    if GROUND_TYPES != 'flint':
+        ans = "ExtElem(DMP_Python([1, 0], ZZ), FiniteExtension(Poly(x**2 + 1, x, domain='ZZ')))"
+    else:
+        ans = "ExtElem(DUP_Flint([1, 0], ZZ), FiniteExtension(Poly(x**2 + 1, x, domain='ZZ')))"
+    assert srepr(A.generator) == ans
+
+def test_BooleanAtom():
+    assert srepr(true) == "true"
+    assert srepr(false) == "false"
+
+
+def test_Integers():
+    sT(S.Integers, "Integers")
+
+
+def test_Naturals():
+    sT(S.Naturals, "Naturals")
+
+
+def test_Naturals0():
+    sT(S.Naturals0, "Naturals0")
+
+
+def test_Reals():
+    sT(S.Reals, "Reals")
+
+
+def test_matrix_expressions():
+    n = symbols('n', integer=True)
+    A = MatrixSymbol("A", n, n)
+    B = MatrixSymbol("B", n, n)
+    sT(A, "MatrixSymbol(Str('A'), Symbol('n', integer=True), Symbol('n', integer=True))")
+    sT(A*B, "MatMul(MatrixSymbol(Str('A'), Symbol('n', integer=True), Symbol('n', integer=True)), MatrixSymbol(Str('B'), Symbol('n', integer=True), Symbol('n', integer=True)))")
+    sT(A + B, "MatAdd(MatrixSymbol(Str('A'), Symbol('n', integer=True), Symbol('n', integer=True)), MatrixSymbol(Str('B'), Symbol('n', integer=True), Symbol('n', integer=True)))")
+
+
+def test_Cycle():
+    # FIXME: sT fails because Cycle is not immutable and calling srepr(Cycle(1, 2))
+    # adds keys to the Cycle dict (GH-17661)
+    #import_stmt = "from sympy.combinatorics import Cycle"
+    #sT(Cycle(1, 2), "Cycle(1, 2)", import_stmt)
+    assert srepr(Cycle(1, 2)) == "Cycle(1, 2)"
+
+
+def test_Permutation():
+    import_stmt = "from sympy.combinatorics import Permutation"
+    sT(Permutation(1, 2)(3, 4), "Permutation([0, 2, 1, 4, 3])", import_stmt, perm_cyclic=False)
+    sT(Permutation(1, 2)(3, 4), "Permutation(1, 2)(3, 4)", import_stmt, perm_cyclic=True)
+
+    with warns_deprecated_sympy():
+        old_print_cyclic = Permutation.print_cyclic
+        Permutation.print_cyclic = False
+        sT(Permutation(1, 2)(3, 4), "Permutation([0, 2, 1, 4, 3])", import_stmt)
+        Permutation.print_cyclic = old_print_cyclic
+
+def test_dict():
+    from sympy.abc import x, y, z
+    d = {}
+    assert srepr(d) == "{}"
+    d = {x: y}
+    assert srepr(d) == "{Symbol('x'): Symbol('y')}"
+    d = {x: y, y: z}
+    assert srepr(d) in (
+        "{Symbol('x'): Symbol('y'), Symbol('y'): Symbol('z')}",
+        "{Symbol('y'): Symbol('z'), Symbol('x'): Symbol('y')}",
+    )
+    d = {x: {y: z}}
+    assert srepr(d) == "{Symbol('x'): {Symbol('y'): Symbol('z')}}"
+
+def test_set():
+    from sympy.abc import x, y
+    s = set()
+    assert srepr(s) == "set()"
+    s = {x, y}
+    assert srepr(s) in ("{Symbol('x'), Symbol('y')}", "{Symbol('y'), Symbol('x')}")
+
+def test_Predicate():
+    sT(Q.even, "Q.even")
+
+def test_AppliedPredicate():
+    sT(Q.even(Symbol('z')), "AppliedPredicate(Q.even, Symbol('z'))")
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/test_rust.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/test_rust.py
new file mode 100644
index 0000000000000000000000000000000000000000..c81d592faca0d4a31e5a9618a48d67cb19ca94d8
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/test_rust.py
@@ -0,0 +1,363 @@
+from sympy.core import (S, pi, oo, symbols, Rational, Integer,
+                        GoldenRatio, EulerGamma, Catalan, Lambda, Dummy,
+                        Eq, Ne, Le, Lt, Gt, Ge, Mod)
+from sympy.functions import (Piecewise, sin, cos, Abs, exp, ceiling, sqrt,
+                             sign, floor)
+from sympy.logic import ITE
+from sympy.testing.pytest import raises
+from sympy.utilities.lambdify import implemented_function
+from sympy.tensor import IndexedBase, Idx
+from sympy.matrices import MatrixSymbol, SparseMatrix, Matrix
+
+from sympy.printing.codeprinter import rust_code
+
+x, y, z = symbols('x,y,z', integer=False, real=True)
+k, m, n = symbols('k,m,n', integer=True)
+
+
+def test_Integer():
+    assert rust_code(Integer(42)) == "42"
+    assert rust_code(Integer(-56)) == "-56"
+
+
+def test_Relational():
+    assert rust_code(Eq(x, y)) == "x == y"
+    assert rust_code(Ne(x, y)) == "x != y"
+    assert rust_code(Le(x, y)) == "x <= y"
+    assert rust_code(Lt(x, y)) == "x < y"
+    assert rust_code(Gt(x, y)) == "x > y"
+    assert rust_code(Ge(x, y)) == "x >= y"
+
+
+def test_Rational():
+    assert rust_code(Rational(3, 7)) == "3_f64/7.0"
+    assert rust_code(Rational(18, 9)) == "2"
+    assert rust_code(Rational(3, -7)) == "-3_f64/7.0"
+    assert rust_code(Rational(-3, -7)) == "3_f64/7.0"
+    assert rust_code(x + Rational(3, 7)) == "x + 3_f64/7.0"
+    assert rust_code(Rational(3, 7)*x) == "(3_f64/7.0)*x"
+
+
+def test_basic_ops():
+    assert rust_code(x + y) == "x + y"
+    assert rust_code(x - y) == "x - y"
+    assert rust_code(x * y) == "x*y"
+    assert rust_code(x / y) == "x*y.recip()"
+    assert rust_code(-x) == "-x"
+    assert rust_code(2 * x) == "2.0*x"
+    assert rust_code(y + 2) == "y + 2.0"
+    assert rust_code(x + n) == "n as f64 + x"
+
+def test_printmethod():
+    class fabs(Abs):
+        def _rust_code(self, printer):
+            return "%s.fabs()" % printer._print(self.args[0])
+    assert rust_code(fabs(x)) == "x.fabs()"
+    a = MatrixSymbol("a", 1, 3)
+    assert rust_code(a[0,0]) == 'a[0]'
+
+
+def test_Functions():
+    assert rust_code(sin(x) ** cos(x)) == "x.sin().powf(x.cos())"
+    assert rust_code(abs(x)) == "x.abs()"
+    assert rust_code(ceiling(x)) == "x.ceil()"
+    assert rust_code(floor(x)) == "x.floor()"
+
+    # Automatic rewrite
+    assert rust_code(Mod(x, 3)) == 'x - 3.0*((1_f64/3.0)*x).floor()'
+
+
+def test_Pow():
+    assert rust_code(1/x) == "x.recip()"
+    assert rust_code(x**-1) == rust_code(x**-1.0) == "x.recip()"
+    assert rust_code(sqrt(x)) == "x.sqrt()"
+    assert rust_code(x**S.Half) == rust_code(x**0.5) == "x.sqrt()"
+
+    assert rust_code(1/sqrt(x)) == "x.sqrt().recip()"
+    assert rust_code(x**-S.Half) == rust_code(x**-0.5) == "x.sqrt().recip()"
+
+    assert rust_code(1/pi) == "PI.recip()"
+    assert rust_code(pi**-1) == rust_code(pi**-1.0) == "PI.recip()"
+    assert rust_code(pi**-0.5) == "PI.sqrt().recip()"
+
+    assert rust_code(x**Rational(1, 3)) == "x.cbrt()"
+    assert rust_code(2**x) == "x.exp2()"
+    assert rust_code(exp(x)) == "x.exp()"
+    assert rust_code(x**3) == "x.powi(3)"
+    assert rust_code(x**(y**3)) == "x.powf(y.powi(3))"
+    assert rust_code(x**Rational(2, 3)) == "x.powf(2_f64/3.0)"
+
+    g = implemented_function('g', Lambda(x, 2*x))
+    assert rust_code(1/(g(x)*3.5)**(x - y**x)/(x**2 + y)) == \
+        "(3.5*2.0*x).powf(-x + y.powf(x))/(x.powi(2) + y)"
+    _cond_cfunc = [(lambda base, exp: exp.is_integer, "dpowi", 1),
+                   (lambda base, exp: not exp.is_integer, "pow", 1)]
+    assert rust_code(x**3, user_functions={'Pow': _cond_cfunc}) == 'x.dpowi(3)'
+    assert rust_code(x**3.2, user_functions={'Pow': _cond_cfunc}) == 'x.pow(3.2)'
+
+
+def test_constants():
+    assert rust_code(pi) == "PI"
+    assert rust_code(oo) == "INFINITY"
+    assert rust_code(S.Infinity) == "INFINITY"
+    assert rust_code(-oo) == "NEG_INFINITY"
+    assert rust_code(S.NegativeInfinity) == "NEG_INFINITY"
+    assert rust_code(S.NaN) == "NAN"
+    assert rust_code(exp(1)) == "E"
+    assert rust_code(S.Exp1) == "E"
+
+
+def test_constants_other():
+    assert rust_code(2*GoldenRatio) == "const GoldenRatio: f64 = %s;\n2.0*GoldenRatio" % GoldenRatio.evalf(17)
+    assert rust_code(
+            2*Catalan) == "const Catalan: f64 = %s;\n2.0*Catalan" % Catalan.evalf(17)
+    assert rust_code(2*EulerGamma) == "const EulerGamma: f64 = %s;\n2.0*EulerGamma" % EulerGamma.evalf(17)
+
+
+def test_boolean():
+    assert rust_code(True) == "true"
+    assert rust_code(S.true) == "true"
+    assert rust_code(False) == "false"
+    assert rust_code(S.false) == "false"
+    assert rust_code(k & m) == "k && m"
+    assert rust_code(k | m) == "k || m"
+    assert rust_code(~k) == "!k"
+    assert rust_code(k & m & n) == "k && m && n"
+    assert rust_code(k | m | n) == "k || m || n"
+    assert rust_code((k & m) | n) == "n || k && m"
+    assert rust_code((k | m) & n) == "n && (k || m)"
+
+
+def test_Piecewise():
+    expr = Piecewise((x, x < 1), (x + 2, True))
+    assert rust_code(expr) == (
+            "if (x < 1.0) {\n"
+            "    x\n"
+            "} else {\n"
+            "    x + 2.0\n"
+            "}")
+    assert rust_code(expr, assign_to="r") == (
+        "r = if (x < 1.0) {\n"
+        "    x\n"
+        "} else {\n"
+        "    x + 2.0\n"
+        "};")
+    assert rust_code(expr, assign_to="r", inline=True) == (
+        "r = if (x < 1.0) { x } else { x + 2.0 };")
+    expr = Piecewise((x, x < 1), (x + 1, x < 5), (x + 2, True))
+    assert rust_code(expr, inline=True) == (
+        "if (x < 1.0) { x } else if (x < 5.0) { x + 1.0 } else { x + 2.0 }")
+    assert rust_code(expr, assign_to="r", inline=True) == (
+        "r = if (x < 1.0) { x } else if (x < 5.0) { x + 1.0 } else { x + 2.0 };")
+    assert rust_code(expr, assign_to="r") == (
+        "r = if (x < 1.0) {\n"
+        "    x\n"
+        "} else if (x < 5.0) {\n"
+        "    x + 1.0\n"
+        "} else {\n"
+        "    x + 2.0\n"
+        "};")
+    expr = 2*Piecewise((x, x < 1), (x + 1, x < 5), (x + 2, True))
+    assert rust_code(expr, inline=True) == (
+        "2.0*if (x < 1.0) { x } else if (x < 5.0) { x + 1.0 } else { x + 2.0 }")
+    expr = 2*Piecewise((x, x < 1), (x + 1, x < 5), (x + 2, True)) - 42
+    assert rust_code(expr, inline=True) == (
+        "2.0*if (x < 1.0) { x } else if (x < 5.0) { x + 1.0 } else { x + 2.0 } - 42.0")
+    # Check that Piecewise without a True (default) condition error
+    expr = Piecewise((x, x < 1), (x**2, x > 1), (sin(x), x > 0))
+    raises(ValueError, lambda: rust_code(expr))
+
+
+def test_dereference_printing():
+    expr = x + y + sin(z) + z
+    assert rust_code(expr, dereference=[z]) == "x + y + (*z) + (*z).sin()"
+
+
+def test_sign():
+    expr = sign(x) * y
+    assert rust_code(expr) == "y*(if (x == 0.0) { 0.0 } else { (x).signum() }) as f64"
+    assert rust_code(expr, assign_to='r') == "r = y*(if (x == 0.0) { 0.0 } else { (x).signum() }) as f64;"
+
+    expr = sign(x + y) + 42
+    assert rust_code(expr) == "(if (x + y == 0.0) { 0.0 } else { (x + y).signum() }) + 42"
+    assert rust_code(expr, assign_to='r') == "r = (if (x + y == 0.0) { 0.0 } else { (x + y).signum() }) + 42;"
+
+    expr = sign(cos(x))
+    assert rust_code(expr) == "(if (x.cos() == 0.0) { 0.0 } else { (x.cos()).signum() })"
+
+
+def test_reserved_words():
+
+    x, y = symbols("x if")
+
+    expr = sin(y)
+    assert rust_code(expr) == "if_.sin()"
+    assert rust_code(expr, dereference=[y]) == "(*if_).sin()"
+    assert rust_code(expr, reserved_word_suffix='_unreserved') == "if_unreserved.sin()"
+
+    with raises(ValueError):
+        rust_code(expr, error_on_reserved=True)
+
+
+def test_ITE():
+    ekpr = ITE(k < 1, m, n)
+    assert rust_code(ekpr) == (
+            "if (k < 1) {\n"
+            "    m\n"
+            "} else {\n"
+            "    n\n"
+            "}")
+
+
+def test_Indexed():
+    n, m, o = symbols('n m o', integer=True)
+    i, j, k = Idx('i', n), Idx('j', m), Idx('k', o)
+
+    x = IndexedBase('x')[j]
+    assert rust_code(x) == "x[j]"
+
+    A = IndexedBase('A')[i, j]
+    assert rust_code(A) == "A[m*i + j]"
+
+    B = IndexedBase('B')[i, j, k]
+    assert rust_code(B) == "B[m*o*i + o*j + k]"
+
+
+def test_dummy_loops():
+    i, m = symbols('i m', integer=True, cls=Dummy)
+    x = IndexedBase('x')
+    y = IndexedBase('y')
+    i = Idx(i, m)
+
+    assert rust_code(x[i], assign_to=y[i]) == (
+        "for i in 0..m {\n"
+        "    y[i] = x[i];\n"
+        "}")
+
+
+def test_loops():
+    m, n = symbols('m n', integer=True)
+    A = IndexedBase('A')
+    x = IndexedBase('x')
+    y = IndexedBase('y')
+    z = IndexedBase('z')
+    i = Idx('i', m)
+    j = Idx('j', n)
+
+    assert rust_code(A[i, j]*x[j], assign_to=y[i]) == (
+        "for i in 0..m {\n"
+        "    y[i] = 0;\n"
+        "}\n"
+        "for i in 0..m {\n"
+        "    for j in 0..n {\n"
+        "        y[i] = A[n*i + j]*x[j] + y[i];\n"
+        "    }\n"
+        "}")
+
+    assert rust_code(A[i, j]*x[j] + x[i] + z[i], assign_to=y[i]) == (
+        "for i in 0..m {\n"
+        "    y[i] = x[i] + z[i];\n"
+        "}\n"
+        "for i in 0..m {\n"
+        "    for j in 0..n {\n"
+        "        y[i] = A[n*i + j]*x[j] + y[i];\n"
+        "    }\n"
+        "}")
+
+
+def test_loops_multiple_contractions():
+    n, m, o, p = symbols('n m o p', integer=True)
+    a = IndexedBase('a')
+    b = IndexedBase('b')
+    y = IndexedBase('y')
+    i = Idx('i', m)
+    j = Idx('j', n)
+    k = Idx('k', o)
+    l = Idx('l', p)
+
+    assert rust_code(b[j, k, l]*a[i, j, k, l], assign_to=y[i]) == (
+        "for i in 0..m {\n"
+        "    y[i] = 0;\n"
+        "}\n"
+        "for i in 0..m {\n"
+        "    for j in 0..n {\n"
+        "        for k in 0..o {\n"
+        "            for l in 0..p {\n"
+        "                y[i] = a[%s]*b[%s] + y[i];\n" % (i*n*o*p + j*o*p + k*p + l, j*o*p + k*p + l) +\
+        "            }\n"
+        "        }\n"
+        "    }\n"
+        "}")
+
+
+def test_loops_addfactor():
+    m, n, o, p = symbols('m n o p', integer=True)
+    a = IndexedBase('a')
+    b = IndexedBase('b')
+    c = IndexedBase('c')
+    y = IndexedBase('y')
+    i = Idx('i', m)
+    j = Idx('j', n)
+    k = Idx('k', o)
+    l = Idx('l', p)
+
+    code = rust_code((a[i, j, k, l] + b[i, j, k, l])*c[j, k, l], assign_to=y[i])
+    assert code == (
+        "for i in 0..m {\n"
+        "    y[i] = 0;\n"
+        "}\n"
+        "for i in 0..m {\n"
+        "    for j in 0..n {\n"
+        "        for k in 0..o {\n"
+        "            for l in 0..p {\n"
+        "                y[i] = (a[%s] + b[%s])*c[%s] + y[i];\n" % (i*n*o*p + j*o*p + k*p + l, i*n*o*p + j*o*p + k*p + l, j*o*p + k*p + l) +\
+        "            }\n"
+        "        }\n"
+        "    }\n"
+        "}")
+
+
+def test_settings():
+    raises(TypeError, lambda: rust_code(sin(x), method="garbage"))
+
+
+def test_inline_function():
+    x = symbols('x')
+    g = implemented_function('g', Lambda(x, 2*x))
+    assert rust_code(g(x)) == "2*x"
+
+    g = implemented_function('g', Lambda(x, 2*x/Catalan))
+    assert rust_code(g(x)) == (
+        "const Catalan: f64 = %s;\n2.0*x/Catalan" % Catalan.evalf(17))
+
+    A = IndexedBase('A')
+    i = Idx('i', symbols('n', integer=True))
+    g = implemented_function('g', Lambda(x, x*(1 + x)*(2 + x)))
+    assert rust_code(g(A[i]), assign_to=A[i]) == (
+        "for i in 0..n {\n"
+        "    A[i] = (A[i] + 1)*(A[i] + 2)*A[i];\n"
+        "}")
+
+
+def test_user_functions():
+    x = symbols('x', integer=False)
+    n = symbols('n', integer=True)
+    custom_functions = {
+        "ceiling": "ceil",
+        "Abs": [(lambda x: not x.is_integer, "fabs", 4), (lambda x: x.is_integer, "abs", 4)],
+    }
+    assert rust_code(ceiling(x), user_functions=custom_functions) == "x.ceil()"
+    assert rust_code(Abs(x), user_functions=custom_functions) == "fabs(x)"
+    assert rust_code(Abs(n), user_functions=custom_functions) == "abs(n)"
+
+
+def test_matrix():
+    assert rust_code(Matrix([1, 2, 3])) == '[1, 2, 3]'
+    with raises(ValueError):
+        rust_code(Matrix([[1, 2, 3]]))
+
+
+def test_sparse_matrix():
+    # gh-15791
+    with raises(NotImplementedError):
+        rust_code(SparseMatrix([[1, 2, 3]]))
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/test_smtlib.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/test_smtlib.py
new file mode 100644
index 0000000000000000000000000000000000000000..48ff3d432d9042bf178f4e52dc46c787059937a3
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/test_smtlib.py
@@ -0,0 +1,553 @@
+import contextlib
+import itertools
+import re
+import typing
+from enum import Enum
+from typing import Callable
+
+import sympy
+from sympy import Add, Implies, sqrt
+from sympy.core import Mul, Pow
+from sympy.core import (S, pi, symbols, Function, Rational, Integer,
+                        Symbol, Eq, Ne, Le, Lt, Gt, Ge)
+from sympy.functions import Piecewise, exp, sin, cos
+from sympy.assumptions.ask import Q
+from sympy.printing.smtlib import smtlib_code
+from sympy.testing.pytest import raises, Failed
+
+x, y, z = symbols('x,y,z')
+
+
+class _W(Enum):
+    DEFAULTING_TO_FLOAT = re.compile("Could not infer type of `.+`. Defaulting to float.", re.IGNORECASE)
+    WILL_NOT_DECLARE = re.compile("Non-Symbol/Function `.+` will not be declared.", re.IGNORECASE)
+    WILL_NOT_ASSERT = re.compile("Non-Boolean expression `.+` will not be asserted. Converting to SMTLib verbatim.", re.IGNORECASE)
+
+
+@contextlib.contextmanager
+def _check_warns(expected: typing.Iterable[_W]):
+    warns: typing.List[str] = []
+    log_warn = warns.append
+    yield log_warn
+
+    errors = []
+    for i, (w, e) in enumerate(itertools.zip_longest(warns, expected)):
+        if not e:
+            errors += [f"[{i}] Received unexpected warning `{w}`."]
+        elif not w:
+            errors += [f"[{i}] Did not receive expected warning `{e.name}`."]
+        elif not e.value.match(w):
+            errors += [f"[{i}] Warning `{w}` does not match expected {e.name}."]
+
+    if errors: raise Failed('\n'.join(errors))
+
+
+def test_Integer():
+    with _check_warns([_W.WILL_NOT_ASSERT] * 2) as w:
+        assert smtlib_code(Integer(67), log_warn=w) == "67"
+        assert smtlib_code(Integer(-1), log_warn=w) == "-1"
+    with _check_warns([]) as w:
+        assert smtlib_code(Integer(67)) == "67"
+        assert smtlib_code(Integer(-1)) == "-1"
+
+
+def test_Rational():
+    with _check_warns([_W.WILL_NOT_ASSERT] * 4) as w:
+        assert smtlib_code(Rational(3, 7), log_warn=w) == "(/ 3 7)"
+        assert smtlib_code(Rational(18, 9), log_warn=w) == "2"
+        assert smtlib_code(Rational(3, -7), log_warn=w) == "(/ -3 7)"
+        assert smtlib_code(Rational(-3, -7), log_warn=w) == "(/ 3 7)"
+
+    with _check_warns([_W.DEFAULTING_TO_FLOAT, _W.WILL_NOT_ASSERT] * 2) as w:
+        assert smtlib_code(x + Rational(3, 7), auto_declare=False, log_warn=w) == "(+ (/ 3 7) x)"
+        assert smtlib_code(Rational(3, 7) * x, log_warn=w) == "(declare-const x Real)\n" \
+                                                              "(* (/ 3 7) x)"
+
+
+def test_Relational():
+    with _check_warns([_W.DEFAULTING_TO_FLOAT] * 12) as w:
+        assert smtlib_code(Eq(x, y), auto_declare=False, log_warn=w) == "(assert (= x y))"
+        assert smtlib_code(Ne(x, y), auto_declare=False, log_warn=w) == "(assert (not (= x y)))"
+        assert smtlib_code(Le(x, y), auto_declare=False, log_warn=w) == "(assert (<= x y))"
+        assert smtlib_code(Lt(x, y), auto_declare=False, log_warn=w) == "(assert (< x y))"
+        assert smtlib_code(Gt(x, y), auto_declare=False, log_warn=w) == "(assert (> x y))"
+        assert smtlib_code(Ge(x, y), auto_declare=False, log_warn=w) == "(assert (>= x y))"
+
+
+def test_AppliedBinaryRelation():
+    with _check_warns([_W.DEFAULTING_TO_FLOAT] * 12) as w:
+        assert smtlib_code(Q.eq(x, y), auto_declare=False, log_warn=w) == "(assert (= x y))"
+        assert smtlib_code(Q.ne(x, y), auto_declare=False, log_warn=w) == "(assert (not (= x y)))"
+        assert smtlib_code(Q.lt(x, y), auto_declare=False, log_warn=w) == "(assert (< x y))"
+        assert smtlib_code(Q.le(x, y), auto_declare=False, log_warn=w) == "(assert (<= x y))"
+        assert smtlib_code(Q.gt(x, y), auto_declare=False, log_warn=w) == "(assert (> x y))"
+        assert smtlib_code(Q.ge(x, y), auto_declare=False, log_warn=w) == "(assert (>= x y))"
+
+    raises(ValueError, lambda: smtlib_code(Q.complex(x), log_warn=w))
+
+
+def test_AppliedPredicate():
+    with _check_warns([_W.DEFAULTING_TO_FLOAT] * 6) as w:
+        assert smtlib_code(Q.positive(x), auto_declare=False, log_warn=w) == "(assert (> x 0))"
+        assert smtlib_code(Q.negative(x), auto_declare=False, log_warn=w) == "(assert (< x 0))"
+        assert smtlib_code(Q.zero(x), auto_declare=False, log_warn=w) == "(assert (= x 0))"
+        assert smtlib_code(Q.nonpositive(x), auto_declare=False, log_warn=w) == "(assert (<= x 0))"
+        assert smtlib_code(Q.nonnegative(x), auto_declare=False, log_warn=w) == "(assert (>= x 0))"
+        assert smtlib_code(Q.nonzero(x), auto_declare=False, log_warn=w) == "(assert (not (= x 0)))"
+
+def test_Function():
+    with _check_warns([_W.DEFAULTING_TO_FLOAT, _W.WILL_NOT_ASSERT]) as w:
+        assert smtlib_code(sin(x) ** cos(x), auto_declare=False, log_warn=w) == "(pow (sin x) (cos x))"
+
+    with _check_warns([_W.WILL_NOT_ASSERT]) as w:
+        assert smtlib_code(
+            abs(x),
+            symbol_table={x: int, y: bool},
+            known_types={int: "INTEGER_TYPE"},
+            known_functions={sympy.Abs: "ABSOLUTE_VALUE_OF"},
+            log_warn=w
+        ) == "(declare-const x INTEGER_TYPE)\n" \
+             "(ABSOLUTE_VALUE_OF x)"
+
+    my_fun1 = Function('f1')
+    with _check_warns([_W.WILL_NOT_ASSERT]) as w:
+        assert smtlib_code(
+            my_fun1(x),
+            symbol_table={my_fun1: Callable[[bool], float]},
+            log_warn=w
+        ) == "(declare-const x Bool)\n" \
+             "(declare-fun f1 (Bool) Real)\n" \
+             "(f1 x)"
+
+    with _check_warns([]) as w:
+        assert smtlib_code(
+            my_fun1(x),
+            symbol_table={my_fun1: Callable[[bool], bool]},
+            log_warn=w
+        ) == "(declare-const x Bool)\n" \
+             "(declare-fun f1 (Bool) Bool)\n" \
+             "(assert (f1 x))"
+
+        assert smtlib_code(
+            Eq(my_fun1(x, z), y),
+            symbol_table={my_fun1: Callable[[int, bool], bool]},
+            log_warn=w
+        ) == "(declare-const x Int)\n" \
+             "(declare-const y Bool)\n" \
+             "(declare-const z Bool)\n" \
+             "(declare-fun f1 (Int Bool) Bool)\n" \
+             "(assert (= (f1 x z) y))"
+
+        assert smtlib_code(
+            Eq(my_fun1(x, z), y),
+            symbol_table={my_fun1: Callable[[int, bool], bool]},
+            known_functions={my_fun1: "MY_KNOWN_FUN", Eq: '=='},
+            log_warn=w
+        ) == "(declare-const x Int)\n" \
+             "(declare-const y Bool)\n" \
+             "(declare-const z Bool)\n" \
+             "(assert (== (MY_KNOWN_FUN x z) y))"
+
+    with _check_warns([_W.DEFAULTING_TO_FLOAT] * 3) as w:
+        assert smtlib_code(
+            Eq(my_fun1(x, z), y),
+            known_functions={my_fun1: "MY_KNOWN_FUN", Eq: '=='},
+            log_warn=w
+        ) == "(declare-const x Real)\n" \
+             "(declare-const y Real)\n" \
+             "(declare-const z Real)\n" \
+             "(assert (== (MY_KNOWN_FUN x z) y))"
+
+
+def test_Pow():
+    with _check_warns([_W.DEFAULTING_TO_FLOAT, _W.WILL_NOT_ASSERT]) as w:
+        assert smtlib_code(x ** 3, auto_declare=False, log_warn=w) == "(pow x 3)"
+    with _check_warns([_W.DEFAULTING_TO_FLOAT, _W.DEFAULTING_TO_FLOAT, _W.WILL_NOT_ASSERT]) as w:
+        assert smtlib_code(x ** (y ** 3), auto_declare=False, log_warn=w) == "(pow x (pow y 3))"
+    with _check_warns([_W.DEFAULTING_TO_FLOAT, _W.WILL_NOT_ASSERT]) as w:
+        assert smtlib_code(x ** Rational(2, 3), auto_declare=False, log_warn=w) == '(pow x (/ 2 3))'
+
+        a = Symbol('a', integer=True)
+        b = Symbol('b', real=True)
+        c = Symbol('c')
+
+        def g(x): return 2 * x
+
+        # if x=1, y=2, then expr=2.333...
+        expr = 1 / (g(a) * 3.5) ** (a - b ** a) / (a ** 2 + b)
+
+    with _check_warns([]) as w:
+        assert smtlib_code(
+            [
+                Eq(a < 2, c),
+                Eq(b > a, c),
+                c & True,
+                Eq(expr, 2 + Rational(1, 3))
+            ],
+            log_warn=w
+        ) == '(declare-const a Int)\n' \
+             '(declare-const b Real)\n' \
+             '(declare-const c Bool)\n' \
+             '(assert (= (< a 2) c))\n' \
+             '(assert (= (> b a) c))\n' \
+             '(assert c)\n' \
+             '(assert (= ' \
+             '(* (pow (* 7.0 a) (+ (pow b a) (* -1 a))) (pow (+ b (pow a 2)) -1)) ' \
+             '(/ 7 3)' \
+             '))'
+
+    with _check_warns([_W.DEFAULTING_TO_FLOAT, _W.WILL_NOT_ASSERT]) as w:
+        assert smtlib_code(
+            Mul(-2, c, Pow(Mul(b, b, evaluate=False), -1, evaluate=False), evaluate=False),
+            log_warn=w
+        ) == '(declare-const b Real)\n' \
+             '(declare-const c Real)\n' \
+             '(* -2 c (pow (* b b) -1))'
+
+
+def test_basic_ops():
+    with _check_warns([_W.DEFAULTING_TO_FLOAT, _W.DEFAULTING_TO_FLOAT, _W.WILL_NOT_ASSERT]) as w:
+        assert smtlib_code(x * y, auto_declare=False, log_warn=w) == "(* x y)"
+
+    with _check_warns([_W.DEFAULTING_TO_FLOAT, _W.DEFAULTING_TO_FLOAT, _W.WILL_NOT_ASSERT]) as w:
+        assert smtlib_code(x + y, auto_declare=False, log_warn=w) == "(+ x y)"
+
+    # with _check_warns([_SmtlibWarnings.DEFAULTING_TO_FLOAT, _SmtlibWarnings.DEFAULTING_TO_FLOAT, _SmtlibWarnings.WILL_NOT_ASSERT]) as w:
+    # todo: implement re-write, currently does '(+ x (* -1 y))' instead
+    # assert smtlib_code(x - y, auto_declare=False, log_warn=w) == "(- x y)"
+
+    with _check_warns([_W.DEFAULTING_TO_FLOAT, _W.WILL_NOT_ASSERT]) as w:
+        assert smtlib_code(-x, auto_declare=False, log_warn=w) == "(* -1 x)"
+
+
+def test_quantifier_extensions():
+    from sympy.logic.boolalg import Boolean
+    from sympy import Interval, Tuple, sympify
+
+    # start For-all quantifier class example
+    class ForAll(Boolean):
+        def _smtlib(self, printer):
+            bound_symbol_declarations = [
+                printer._s_expr(sym.name, [
+                    printer._known_types[printer.symbol_table[sym]],
+                    Interval(start, end)
+                ]) for sym, start, end in self.limits
+            ]
+            return printer._s_expr('forall', [
+                printer._s_expr('', bound_symbol_declarations),
+                self.function
+            ])
+
+        @property
+        def bound_symbols(self):
+            return {s for s, _, _ in self.limits}
+
+        @property
+        def free_symbols(self):
+            bound_symbol_names = {s.name for s in self.bound_symbols}
+            return {
+                s for s in self.function.free_symbols
+                if s.name not in bound_symbol_names
+            }
+
+        def __new__(cls, *args):
+            limits = [sympify(a) for a in args if isinstance(a, (tuple, Tuple))]
+            function = [sympify(a) for a in args if isinstance(a, Boolean)]
+            assert len(limits) + len(function) == len(args)
+            assert len(function) == 1
+            function = function[0]
+
+            if isinstance(function, ForAll): return ForAll.__new__(
+                ForAll, *(limits + function.limits), function.function
+            )
+            inst = Boolean.__new__(cls)
+            inst._args = tuple(limits + [function])
+            inst.limits = limits
+            inst.function = function
+            return inst
+
+    # end For-All Quantifier class example
+
+    f = Function('f')
+    with _check_warns([_W.DEFAULTING_TO_FLOAT]) as w:
+        assert smtlib_code(
+            ForAll((x, -42, +21), Eq(f(x), f(x))),
+            symbol_table={f: Callable[[float], float]},
+            log_warn=w
+        ) == '(assert (forall ( (x Real [-42, 21])) true))'
+
+    with _check_warns([_W.DEFAULTING_TO_FLOAT] * 2) as w:
+        assert smtlib_code(
+            ForAll(
+                (x, -42, +21), (y, -100, 3),
+                Implies(Eq(x, y), Eq(f(x), f(y)))
+            ),
+            symbol_table={f: Callable[[float], float]},
+            log_warn=w
+        ) == '(declare-fun f (Real) Real)\n' \
+             '(assert (' \
+             'forall ( (x Real [-42, 21]) (y Real [-100, 3])) ' \
+             '(=> (= x y) (= (f x) (f y)))' \
+             '))'
+
+    a = Symbol('a', integer=True)
+    b = Symbol('b', real=True)
+    c = Symbol('c')
+
+    with _check_warns([]) as w:
+        assert smtlib_code(
+            ForAll(
+                (a, 2, 100), ForAll(
+                    (b, 2, 100),
+                    Implies(a < b, sqrt(a) < b) | c
+                )),
+            log_warn=w
+        ) == '(declare-const c Bool)\n' \
+             '(assert (forall ( (a Int [2, 100]) (b Real [2, 100])) ' \
+             '(or c (=> (< a b) (< (pow a (/ 1 2)) b)))' \
+             '))'
+
+
+def test_mix_number_mult_symbols():
+    with _check_warns([_W.WILL_NOT_ASSERT]) as w:
+        assert smtlib_code(
+            1 / pi,
+            known_constants={pi: "MY_PI"},
+            log_warn=w
+        ) == '(pow MY_PI -1)'
+
+    with _check_warns([_W.WILL_NOT_ASSERT]) as w:
+        assert smtlib_code(
+            [
+                Eq(pi, 3.14, evaluate=False),
+                1 / pi,
+            ],
+            known_constants={pi: "MY_PI"},
+            log_warn=w
+        ) == '(assert (= MY_PI 3.14))\n' \
+             '(pow MY_PI -1)'
+
+    with _check_warns([_W.WILL_NOT_ASSERT]) as w:
+        assert smtlib_code(
+            Add(S.Zero, S.One, S.NegativeOne, S.Half,
+                S.Exp1, S.Pi, S.GoldenRatio, evaluate=False),
+            known_constants={
+                S.Pi: 'p', S.GoldenRatio: 'g',
+                S.Exp1: 'e'
+            },
+            known_functions={
+                Add: 'plus',
+                exp: 'exp'
+            },
+            precision=3,
+            log_warn=w
+        ) == '(plus 0 1 -1 (/ 1 2) (exp 1) p g)'
+
+    with _check_warns([_W.WILL_NOT_ASSERT]) as w:
+        assert smtlib_code(
+            Add(S.Zero, S.One, S.NegativeOne, S.Half,
+                S.Exp1, S.Pi, S.GoldenRatio, evaluate=False),
+            known_constants={
+                S.Pi: 'p'
+            },
+            known_functions={
+                Add: 'plus',
+                exp: 'exp'
+            },
+            precision=3,
+            log_warn=w
+        ) == '(plus 0 1 -1 (/ 1 2) (exp 1) p 1.62)'
+
+    with _check_warns([_W.WILL_NOT_ASSERT]) as w:
+        assert smtlib_code(
+            Add(S.Zero, S.One, S.NegativeOne, S.Half,
+                S.Exp1, S.Pi, S.GoldenRatio, evaluate=False),
+            known_functions={Add: 'plus'},
+            precision=3,
+            log_warn=w
+        ) == '(plus 0 1 -1 (/ 1 2) 2.72 3.14 1.62)'
+
+    with _check_warns([_W.WILL_NOT_ASSERT]) as w:
+        assert smtlib_code(
+            Add(S.Zero, S.One, S.NegativeOne, S.Half,
+                S.Exp1, S.Pi, S.GoldenRatio, evaluate=False),
+            known_constants={S.Exp1: 'e'},
+            known_functions={Add: 'plus'},
+            precision=3,
+            log_warn=w
+        ) == '(plus 0 1 -1 (/ 1 2) e 3.14 1.62)'
+
+
+def test_boolean():
+    with _check_warns([]) as w:
+        assert smtlib_code(x & y, log_warn=w) == '(declare-const x Bool)\n' \
+                                                 '(declare-const y Bool)\n' \
+                                                 '(assert (and x y))'
+        assert smtlib_code(x | y, log_warn=w) == '(declare-const x Bool)\n' \
+                                                 '(declare-const y Bool)\n' \
+                                                 '(assert (or x y))'
+        assert smtlib_code(~x, log_warn=w) == '(declare-const x Bool)\n' \
+                                              '(assert (not x))'
+        assert smtlib_code(x & y & z, log_warn=w) == '(declare-const x Bool)\n' \
+                                                     '(declare-const y Bool)\n' \
+                                                     '(declare-const z Bool)\n' \
+                                                     '(assert (and x y z))'
+
+    with _check_warns([_W.DEFAULTING_TO_FLOAT]) as w:
+        assert smtlib_code((x & ~y) | (z > 3), log_warn=w) == '(declare-const x Bool)\n' \
+                                                              '(declare-const y Bool)\n' \
+                                                              '(declare-const z Real)\n' \
+                                                              '(assert (or (> z 3) (and x (not y))))'
+
+    f = Function('f')
+    g = Function('g')
+    h = Function('h')
+    with _check_warns([_W.DEFAULTING_TO_FLOAT]) as w:
+        assert smtlib_code(
+            [Gt(f(x), y),
+             Lt(y, g(z))],
+            symbol_table={
+                f: Callable[[bool], int], g: Callable[[bool], int],
+            }, log_warn=w
+        ) == '(declare-const x Bool)\n' \
+             '(declare-const y Real)\n' \
+             '(declare-const z Bool)\n' \
+             '(declare-fun f (Bool) Int)\n' \
+             '(declare-fun g (Bool) Int)\n' \
+             '(assert (> (f x) y))\n' \
+             '(assert (< y (g z)))'
+
+    with _check_warns([]) as w:
+        assert smtlib_code(
+            [Eq(f(x), y),
+             Lt(y, g(z))],
+            symbol_table={
+                f: Callable[[bool], int], g: Callable[[bool], int],
+            }, log_warn=w
+        ) == '(declare-const x Bool)\n' \
+             '(declare-const y Int)\n' \
+             '(declare-const z Bool)\n' \
+             '(declare-fun f (Bool) Int)\n' \
+             '(declare-fun g (Bool) Int)\n' \
+             '(assert (= (f x) y))\n' \
+             '(assert (< y (g z)))'
+
+    with _check_warns([]) as w:
+        assert smtlib_code(
+            [Eq(f(x), y),
+             Eq(g(f(x)), z),
+             Eq(h(g(f(x))), x)],
+            symbol_table={
+                f: Callable[[float], int],
+                g: Callable[[int], bool],
+                h: Callable[[bool], float]
+            },
+            log_warn=w
+        ) == '(declare-const x Real)\n' \
+             '(declare-const y Int)\n' \
+             '(declare-const z Bool)\n' \
+             '(declare-fun f (Real) Int)\n' \
+             '(declare-fun g (Int) Bool)\n' \
+             '(declare-fun h (Bool) Real)\n' \
+             '(assert (= (f x) y))\n' \
+             '(assert (= (g (f x)) z))\n' \
+             '(assert (= (h (g (f x))) x))'
+
+
+# todo: make smtlib_code support arrays
+# def test_containers():
+#     assert julia_code([1, 2, 3, [4, 5, [6, 7]], 8, [9, 10], 11]) == \
+#            "Any[1, 2, 3, Any[4, 5, Any[6, 7]], 8, Any[9, 10], 11]"
+#     assert julia_code((1, 2, (3, 4))) == "(1, 2, (3, 4))"
+#     assert julia_code([1]) == "Any[1]"
+#     assert julia_code((1,)) == "(1,)"
+#     assert julia_code(Tuple(*[1, 2, 3])) == "(1, 2, 3)"
+#     assert julia_code((1, x * y, (3, x ** 2))) == "(1, x .* y, (3, x .^ 2))"
+#     # scalar, matrix, empty matrix and empty list
+#     assert julia_code((1, eye(3), Matrix(0, 0, []), [])) == "(1, [1 0 0;\n0 1 0;\n0 0 1], zeros(0, 0), Any[])"
+
+def test_smtlib_piecewise():
+    with _check_warns([_W.DEFAULTING_TO_FLOAT, _W.WILL_NOT_ASSERT]) as w:
+        assert smtlib_code(
+            Piecewise((x, x < 1),
+                      (x ** 2, True)),
+            auto_declare=False,
+            log_warn=w
+        ) == '(ite (< x 1) x (pow x 2))'
+
+    with _check_warns([_W.DEFAULTING_TO_FLOAT, _W.WILL_NOT_ASSERT]) as w:
+        assert smtlib_code(
+            Piecewise((x ** 2, x < 1),
+                      (x ** 3, x < 2),
+                      (x ** 4, x < 3),
+                      (x ** 5, True)),
+            auto_declare=False,
+            log_warn=w
+        ) == '(ite (< x 1) (pow x 2) ' \
+             '(ite (< x 2) (pow x 3) ' \
+             '(ite (< x 3) (pow x 4) ' \
+             '(pow x 5))))'
+
+    # Check that Piecewise without a True (default) condition error
+    expr = Piecewise((x, x < 1), (x ** 2, x > 1), (sin(x), x > 0))
+    with _check_warns([_W.DEFAULTING_TO_FLOAT, _W.WILL_NOT_ASSERT]) as w:
+        raises(AssertionError, lambda: smtlib_code(expr, log_warn=w))
+
+
+def test_smtlib_piecewise_times_const():
+    pw = Piecewise((x, x < 1), (x ** 2, True))
+    with _check_warns([_W.DEFAULTING_TO_FLOAT, _W.WILL_NOT_ASSERT]) as w:
+        assert smtlib_code(2 * pw, log_warn=w) == '(declare-const x Real)\n(* 2 (ite (< x 1) x (pow x 2)))'
+    with _check_warns([_W.DEFAULTING_TO_FLOAT, _W.WILL_NOT_ASSERT]) as w:
+        assert smtlib_code(pw / x, log_warn=w) == '(declare-const x Real)\n(* (pow x -1) (ite (< x 1) x (pow x 2)))'
+    with _check_warns([_W.DEFAULTING_TO_FLOAT, _W.DEFAULTING_TO_FLOAT, _W.WILL_NOT_ASSERT]) as w:
+        assert smtlib_code(pw / (x * y), log_warn=w) == '(declare-const x Real)\n(declare-const y Real)\n(* (pow x -1) (pow y -1) (ite (< x 1) x (pow x 2)))'
+    with _check_warns([_W.DEFAULTING_TO_FLOAT, _W.WILL_NOT_ASSERT]) as w:
+        assert smtlib_code(pw / 3, log_warn=w) == '(declare-const x Real)\n(* (/ 1 3) (ite (< x 1) x (pow x 2)))'
+
+
+# todo: make smtlib_code support arrays / matrices ?
+# def test_smtlib_matrix_assign_to():
+#     A = Matrix([[1, 2, 3]])
+#     assert smtlib_code(A, assign_to='a') == "a = [1 2 3]"
+#     A = Matrix([[1, 2], [3, 4]])
+#     assert smtlib_code(A, assign_to='A') == "A = [1 2;\n3 4]"
+
+# def test_julia_matrix_1x1():
+#     A = Matrix([[3]])
+#     B = MatrixSymbol('B', 1, 1)
+#     C = MatrixSymbol('C', 1, 2)
+#     assert julia_code(A, assign_to=B) == "B = [3]"
+#     raises(ValueError, lambda: julia_code(A, assign_to=C))
+
+# def test_julia_matrix_elements():
+#     A = Matrix([[x, 2, x * y]])
+#     assert julia_code(A[0, 0] ** 2 + A[0, 1] + A[0, 2]) == "x .^ 2 + x .* y + 2"
+#     A = MatrixSymbol('AA', 1, 3)
+#     assert julia_code(A) == "AA"
+#     assert julia_code(A[0, 0] ** 2 + sin(A[0, 1]) + A[0, 2]) == \
+#            "sin(AA[1,2]) + AA[1,1] .^ 2 + AA[1,3]"
+#     assert julia_code(sum(A)) == "AA[1,1] + AA[1,2] + AA[1,3]"
+
+def test_smtlib_boolean():
+    with _check_warns([]) as w:
+        assert smtlib_code(True, auto_assert=False, log_warn=w) == 'true'
+        assert smtlib_code(True, log_warn=w) == '(assert true)'
+        assert smtlib_code(S.true, log_warn=w) == '(assert true)'
+        assert smtlib_code(S.false, log_warn=w) == '(assert false)'
+        assert smtlib_code(False, log_warn=w) == '(assert false)'
+        assert smtlib_code(False, auto_assert=False, log_warn=w) == 'false'
+
+
+def test_not_supported():
+    f = Function('f')
+    with _check_warns([_W.DEFAULTING_TO_FLOAT, _W.WILL_NOT_ASSERT]) as w:
+        raises(KeyError, lambda: smtlib_code(f(x).diff(x), symbol_table={f: Callable[[float], float]}, log_warn=w))
+    with _check_warns([_W.WILL_NOT_ASSERT]) as w:
+        raises(KeyError, lambda: smtlib_code(S.ComplexInfinity, log_warn=w))
+
+
+def test_Float():
+    assert smtlib_code(0.0) == "0.0"
+    assert smtlib_code(0.000000000000000003) == '(* 3.0 (pow 10 -18))'
+    assert smtlib_code(5.3) == "5.3"
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/test_str.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/test_str.py
new file mode 100644
index 0000000000000000000000000000000000000000..675212964b03bf9a9806088225c28d7f70971ca7
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/test_str.py
@@ -0,0 +1,1206 @@
+from sympy import MatAdd
+from sympy.algebras.quaternion import Quaternion
+from sympy.assumptions.ask import Q
+from sympy.calculus.accumulationbounds import AccumBounds
+from sympy.combinatorics.partitions import Partition
+from sympy.concrete.summations import (Sum, summation)
+from sympy.core.add import Add
+from sympy.core.containers import (Dict, Tuple)
+from sympy.core.expr import UnevaluatedExpr, Expr
+from sympy.core.function import (Derivative, Function, Lambda, Subs, WildFunction)
+from sympy.core.mul import Mul
+from sympy.core import (Catalan, EulerGamma, GoldenRatio, TribonacciConstant)
+from sympy.core.numbers import (E, Float, I, Integer, Rational, nan, oo, pi, zoo)
+from sympy.core.parameters import _exp_is_pow
+from sympy.core.power import Pow
+from sympy.core.relational import (Eq, Rel, Ne)
+from sympy.core.singleton import S
+from sympy.core.symbol import (Dummy, Symbol, Wild, symbols)
+from sympy.functions.combinatorial.factorials import (factorial, factorial2, subfactorial)
+from sympy.functions.elementary.complexes import Abs
+from sympy.functions.elementary.exponential import exp
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import (cos, sin)
+from sympy.functions.special.delta_functions import Heaviside
+from sympy.functions.special.zeta_functions import zeta
+from sympy.integrals.integrals import Integral
+from sympy.logic.boolalg import (Equivalent, false, true, Xor)
+from sympy.matrices.dense import Matrix
+from sympy.matrices.expressions.matexpr import MatrixSymbol
+from sympy.matrices.expressions import Identity
+from sympy.matrices.expressions.slice import MatrixSlice
+from sympy.matrices import SparseMatrix
+from sympy.polys.polytools import factor
+from sympy.series.limits import Limit
+from sympy.series.order import O
+from sympy.sets.sets import (Complement, FiniteSet, Interval, SymmetricDifference)
+from sympy.stats import (Covariance, Expectation, Probability, Variance)
+from sympy.stats.rv import RandomSymbol
+from sympy.external import import_module
+from sympy.physics.control.lti import TransferFunction, Series, Parallel, \
+    Feedback, TransferFunctionMatrix, MIMOSeries, MIMOParallel, MIMOFeedback
+from sympy.physics.units import second, joule
+from sympy.polys import (Poly, rootof, RootSum, groebner, ring, field, ZZ, QQ,
+    ZZ_I, QQ_I, lex, grlex)
+from sympy.geometry import Point, Circle, Polygon, Ellipse, Triangle
+from sympy.tensor import NDimArray
+from sympy.tensor.array.expressions.array_expressions import ArraySymbol, ArrayElement
+
+from sympy.testing.pytest import raises, warns_deprecated_sympy
+
+from sympy.printing import sstr, sstrrepr, StrPrinter
+from sympy.physics.quantum.trace import Tr
+
+x, y, z, w, t = symbols('x,y,z,w,t')
+d = Dummy('d')
+
+
+def test_printmethod():
+    class R(Abs):
+        def _sympystr(self, printer):
+            return "foo(%s)" % printer._print(self.args[0])
+    assert sstr(R(x)) == "foo(x)"
+
+    class R(Abs):
+        def _sympystr(self, printer):
+            return "foo"
+    assert sstr(R(x)) == "foo"
+
+
+def test_Abs():
+    assert str(Abs(x)) == "Abs(x)"
+    assert str(Abs(Rational(1, 6))) == "1/6"
+    assert str(Abs(Rational(-1, 6))) == "1/6"
+
+
+def test_Add():
+    assert str(x + y) == "x + y"
+    assert str(x + 1) == "x + 1"
+    assert str(x + x**2) == "x**2 + x"
+    assert str(Add(0, 1, evaluate=False)) == "0 + 1"
+    assert str(Add(0, 0, 1, evaluate=False)) == "0 + 0 + 1"
+    assert str(1.0*x) == "1.0*x"
+    assert str(5 + x + y + x*y + x**2 + y**2) == "x**2 + x*y + x + y**2 + y + 5"
+    assert str(1 + x + x**2/2 + x**3/3) == "x**3/3 + x**2/2 + x + 1"
+    assert str(2*x - 7*x**2 + 2 + 3*y) == "-7*x**2 + 2*x + 3*y + 2"
+    assert str(x - y) == "x - y"
+    assert str(2 - x) == "2 - x"
+    assert str(x - 2) == "x - 2"
+    assert str(x - y - z - w) == "-w + x - y - z"
+    assert str(x - z*y**2*z*w) == "-w*y**2*z**2 + x"
+    assert str(x - 1*y*x*y) == "-x*y**2 + x"
+    assert str(sin(x).series(x, 0, 15)) == "x - x**3/6 + x**5/120 - x**7/5040 + x**9/362880 - x**11/39916800 + x**13/6227020800 + O(x**15)"
+    assert str(Add(Add(-w, x, evaluate=False), Add(-y, z,  evaluate=False),  evaluate=False)) == "(-w + x) + (-y + z)"
+    assert str(Add(Add(-x, -y, evaluate=False), -z, evaluate=False)) == "-z + (-x - y)"
+    assert str(Add(Add(Add(-x, -y, evaluate=False), -z, evaluate=False), -t, evaluate=False)) == "-t + (-z + (-x - y))"
+
+
+def test_Catalan():
+    assert str(Catalan) == "Catalan"
+
+
+def test_ComplexInfinity():
+    assert str(zoo) == "zoo"
+
+
+def test_Derivative():
+    assert str(Derivative(x, y)) == "Derivative(x, y)"
+    assert str(Derivative(x**2, x, evaluate=False)) == "Derivative(x**2, x)"
+    assert str(Derivative(
+        x**2/y, x, y, evaluate=False)) == "Derivative(x**2/y, x, y)"
+
+
+def test_dict():
+    assert str({1: 1 + x}) == sstr({1: 1 + x}) == "{1: x + 1}"
+    assert str({1: x**2, 2: y*x}) in ("{1: x**2, 2: x*y}", "{2: x*y, 1: x**2}")
+    assert sstr({1: x**2, 2: y*x}) == "{1: x**2, 2: x*y}"
+
+
+def test_Dict():
+    assert str(Dict({1: 1 + x})) == sstr({1: 1 + x}) == "{1: x + 1}"
+    assert str(Dict({1: x**2, 2: y*x})) in (
+        "{1: x**2, 2: x*y}", "{2: x*y, 1: x**2}")
+    assert sstr(Dict({1: x**2, 2: y*x})) == "{1: x**2, 2: x*y}"
+
+
+def test_Dummy():
+    assert str(d) == "_d"
+    assert str(d + x) == "_d + x"
+
+
+def test_EulerGamma():
+    assert str(EulerGamma) == "EulerGamma"
+
+
+def test_Exp():
+    assert str(E) == "E"
+    with _exp_is_pow(True):
+        assert str(exp(x)) == "E**x"
+
+
+def test_factorial():
+    n = Symbol('n', integer=True)
+    assert str(factorial(-2)) == "zoo"
+    assert str(factorial(0)) == "1"
+    assert str(factorial(7)) == "5040"
+    assert str(factorial(n)) == "factorial(n)"
+    assert str(factorial(2*n)) == "factorial(2*n)"
+    assert str(factorial(factorial(n))) == 'factorial(factorial(n))'
+    assert str(factorial(factorial2(n))) == 'factorial(factorial2(n))'
+    assert str(factorial2(factorial(n))) == 'factorial2(factorial(n))'
+    assert str(factorial2(factorial2(n))) == 'factorial2(factorial2(n))'
+    assert str(subfactorial(3)) == "2"
+    assert str(subfactorial(n)) == "subfactorial(n)"
+    assert str(subfactorial(2*n)) == "subfactorial(2*n)"
+
+
+def test_Function():
+    f = Function('f')
+    fx = f(x)
+    w = WildFunction('w')
+    assert str(f) == "f"
+    assert str(fx) == "f(x)"
+    assert str(w) == "w_"
+
+
+def test_Geometry():
+    assert sstr(Point(0, 0)) == 'Point2D(0, 0)'
+    assert sstr(Circle(Point(0, 0), 3)) == 'Circle(Point2D(0, 0), 3)'
+    assert sstr(Ellipse(Point(1, 2), 3, 4)) == 'Ellipse(Point2D(1, 2), 3, 4)'
+    assert sstr(Triangle(Point(1, 1), Point(7, 8), Point(0, -1))) == \
+        'Triangle(Point2D(1, 1), Point2D(7, 8), Point2D(0, -1))'
+    assert sstr(Polygon(Point(5, 6), Point(-2, -3), Point(0, 0), Point(4, 7))) == \
+        'Polygon(Point2D(5, 6), Point2D(-2, -3), Point2D(0, 0), Point2D(4, 7))'
+    assert sstr(Triangle(Point(0, 0), Point(1, 0), Point(0, 1)), sympy_integers=True) == \
+        'Triangle(Point2D(S(0), S(0)), Point2D(S(1), S(0)), Point2D(S(0), S(1)))'
+    assert sstr(Ellipse(Point(1, 2), 3, 4), sympy_integers=True) == \
+        'Ellipse(Point2D(S(1), S(2)), S(3), S(4))'
+
+
+def test_GoldenRatio():
+    assert str(GoldenRatio) == "GoldenRatio"
+
+
+def test_Heaviside():
+    assert str(Heaviside(x)) == str(Heaviside(x, S.Half)) == "Heaviside(x)"
+    assert str(Heaviside(x, 1)) == "Heaviside(x, 1)"
+
+
+def test_TribonacciConstant():
+    assert str(TribonacciConstant) == "TribonacciConstant"
+
+
+def test_ImaginaryUnit():
+    assert str(I) == "I"
+
+
+def test_Infinity():
+    assert str(oo) == "oo"
+    assert str(oo*I) == "oo*I"
+
+
+def test_Integer():
+    assert str(Integer(-1)) == "-1"
+    assert str(Integer(1)) == "1"
+    assert str(Integer(-3)) == "-3"
+    assert str(Integer(0)) == "0"
+    assert str(Integer(25)) == "25"
+
+
+def test_Integral():
+    assert str(Integral(sin(x), y)) == "Integral(sin(x), y)"
+    assert str(Integral(sin(x), (y, 0, 1))) == "Integral(sin(x), (y, 0, 1))"
+
+
+def test_Interval():
+    n = (S.NegativeInfinity, 1, 2, S.Infinity)
+    for i in range(len(n)):
+        for j in range(i + 1, len(n)):
+            for l in (True, False):
+                for r in (True, False):
+                    ival = Interval(n[i], n[j], l, r)
+                    assert S(str(ival)) == ival
+
+
+def test_AccumBounds():
+    a = Symbol('a', real=True)
+    assert str(AccumBounds(0, a)) == "AccumBounds(0, a)"
+    assert str(AccumBounds(0, 1)) == "AccumBounds(0, 1)"
+
+
+def test_Lambda():
+    assert str(Lambda(d, d**2)) == "Lambda(_d, _d**2)"
+    # issue 2908
+    assert str(Lambda((), 1)) == "Lambda((), 1)"
+    assert str(Lambda((), x)) == "Lambda((), x)"
+    assert str(Lambda((x, y), x+y)) == "Lambda((x, y), x + y)"
+    assert str(Lambda(((x, y),), x+y)) == "Lambda(((x, y),), x + y)"
+
+
+def test_Limit():
+    assert str(Limit(sin(x)/x, x, y)) == "Limit(sin(x)/x, x, y, dir='+')"
+    assert str(Limit(1/x, x, 0)) == "Limit(1/x, x, 0, dir='+')"
+    assert str(
+        Limit(sin(x)/x, x, y, dir="-")) == "Limit(sin(x)/x, x, y, dir='-')"
+
+
+def test_list():
+    assert str([x]) == sstr([x]) == "[x]"
+    assert str([x**2, x*y + 1]) == sstr([x**2, x*y + 1]) == "[x**2, x*y + 1]"
+    assert str([x**2, [y + x]]) == sstr([x**2, [y + x]]) == "[x**2, [x + y]]"
+
+
+def test_Matrix_str():
+    M = Matrix([[x**+1, 1], [y, x + y]])
+    assert str(M) == "Matrix([[x, 1], [y, x + y]])"
+    assert sstr(M) == "Matrix([\n[x,     1],\n[y, x + y]])"
+    M = Matrix([[1]])
+    assert str(M) == sstr(M) == "Matrix([[1]])"
+    M = Matrix([[1, 2]])
+    assert str(M) == sstr(M) ==  "Matrix([[1, 2]])"
+    M = Matrix()
+    assert str(M) == sstr(M) == "Matrix(0, 0, [])"
+    M = Matrix(0, 1, lambda i, j: 0)
+    assert str(M) == sstr(M) == "Matrix(0, 1, [])"
+
+
+def test_Mul():
+    assert str(x/y) == "x/y"
+    assert str(y/x) == "y/x"
+    assert str(x/y/z) == "x/(y*z)"
+    assert str((x + 1)/(y + 2)) == "(x + 1)/(y + 2)"
+    assert str(2*x/3) == '2*x/3'
+    assert str(-2*x/3) == '-2*x/3'
+    assert str(-1.0*x) == '-1.0*x'
+    assert str(1.0*x) == '1.0*x'
+    assert str(Mul(0, 1, evaluate=False)) == '0*1'
+    assert str(Mul(1, 0, evaluate=False)) == '1*0'
+    assert str(Mul(1, 1, evaluate=False)) == '1*1'
+    assert str(Mul(1, 1, 1, evaluate=False)) == '1*1*1'
+    assert str(Mul(1, 2, evaluate=False)) == '1*2'
+    assert str(Mul(1, S.Half, evaluate=False)) == '1*(1/2)'
+    assert str(Mul(1, 1, S.Half, evaluate=False)) == '1*1*(1/2)'
+    assert str(Mul(1, 1, 2, 3, x, evaluate=False)) == '1*1*2*3*x'
+    assert str(Mul(1, -1, evaluate=False)) == '1*(-1)'
+    assert str(Mul(-1, 1, evaluate=False)) == '-1*1'
+    assert str(Mul(4, 3, 2, 1, 0, y, x, evaluate=False)) == '4*3*2*1*0*y*x'
+    assert str(Mul(4, 3, 2, 1+z, 0, y, x, evaluate=False)) == '4*3*2*(z + 1)*0*y*x'
+    assert str(Mul(Rational(2, 3), Rational(5, 7), evaluate=False)) == '(2/3)*(5/7)'
+    # For issue 14160
+    assert str(Mul(-2, x, Pow(Mul(y,y,evaluate=False), -1, evaluate=False),
+                                                evaluate=False)) == '-2*x/(y*y)'
+    # issue 21537
+    assert str(Mul(x, Pow(1/y, -1, evaluate=False), evaluate=False)) == 'x/(1/y)'
+
+    # Issue 24108
+    from sympy.core.parameters import evaluate
+    with evaluate(False):
+        assert str(Mul(Pow(Integer(2), Integer(-1)), Add(Integer(-1), Mul(Integer(-1), Integer(1))))) == "(-1 - 1*1)/2"
+
+    class CustomClass1(Expr):
+        is_commutative = True
+
+    class CustomClass2(Expr):
+        is_commutative = True
+    cc1 = CustomClass1()
+    cc2 = CustomClass2()
+    assert str(Rational(2)*cc1) == '2*CustomClass1()'
+    assert str(cc1*Rational(2)) == '2*CustomClass1()'
+    assert str(cc1*Float("1.5")) == '1.5*CustomClass1()'
+    assert str(cc2*Rational(2)) == '2*CustomClass2()'
+    assert str(cc2*Rational(2)*cc1) == '2*CustomClass1()*CustomClass2()'
+    assert str(cc1*Rational(2)*cc2) == '2*CustomClass1()*CustomClass2()'
+
+
+def test_NaN():
+    assert str(nan) == "nan"
+
+
+def test_NegativeInfinity():
+    assert str(-oo) == "-oo"
+
+def test_Order():
+    assert str(O(x)) == "O(x)"
+    assert str(O(x**2)) == "O(x**2)"
+    assert str(O(x*y)) == "O(x*y, x, y)"
+    assert str(O(x, x)) == "O(x)"
+    assert str(O(x, (x, 0))) == "O(x)"
+    assert str(O(x, (x, oo))) == "O(x, (x, oo))"
+    assert str(O(x, x, y)) == "O(x, x, y)"
+    assert str(O(x, x, y)) == "O(x, x, y)"
+    assert str(O(x, (x, oo), (y, oo))) == "O(x, (x, oo), (y, oo))"
+
+
+def test_Permutation_Cycle():
+    from sympy.combinatorics import Permutation, Cycle
+
+    # general principle: economically, canonically show all moved elements
+    # and the size of the permutation.
+
+    for p, s in [
+        (Cycle(),
+        '()'),
+        (Cycle(2),
+        '(2)'),
+        (Cycle(2, 1),
+        '(1 2)'),
+        (Cycle(1, 2)(5)(6, 7)(10),
+        '(1 2)(6 7)(10)'),
+        (Cycle(3, 4)(1, 2)(3, 4),
+        '(1 2)(4)'),
+    ]:
+        assert sstr(p) == s
+
+    for p, s in [
+        (Permutation([]),
+        'Permutation([])'),
+        (Permutation([], size=1),
+        'Permutation([0])'),
+        (Permutation([], size=2),
+        'Permutation([0, 1])'),
+        (Permutation([], size=10),
+        'Permutation([], size=10)'),
+        (Permutation([1, 0, 2]),
+        'Permutation([1, 0, 2])'),
+        (Permutation([1, 0, 2, 3, 4, 5]),
+        'Permutation([1, 0], size=6)'),
+        (Permutation([1, 0, 2, 3, 4, 5], size=10),
+        'Permutation([1, 0], size=10)'),
+    ]:
+        assert sstr(p, perm_cyclic=False) == s
+
+    for p, s in [
+        (Permutation([]),
+        '()'),
+        (Permutation([], size=1),
+        '(0)'),
+        (Permutation([], size=2),
+        '(1)'),
+        (Permutation([], size=10),
+        '(9)'),
+        (Permutation([1, 0, 2]),
+        '(2)(0 1)'),
+        (Permutation([1, 0, 2, 3, 4, 5]),
+        '(5)(0 1)'),
+        (Permutation([1, 0, 2, 3, 4, 5], size=10),
+        '(9)(0 1)'),
+        (Permutation([0, 1, 3, 2, 4, 5], size=10),
+        '(9)(2 3)'),
+    ]:
+        assert sstr(p) == s
+
+
+    with warns_deprecated_sympy():
+        old_print_cyclic = Permutation.print_cyclic
+        Permutation.print_cyclic = False
+        assert sstr(Permutation([1, 0, 2])) == 'Permutation([1, 0, 2])'
+        Permutation.print_cyclic = old_print_cyclic
+
+def test_Pi():
+    assert str(pi) == "pi"
+
+
+def test_Poly():
+    assert str(Poly(0, x)) == "Poly(0, x, domain='ZZ')"
+    assert str(Poly(1, x)) == "Poly(1, x, domain='ZZ')"
+    assert str(Poly(x, x)) == "Poly(x, x, domain='ZZ')"
+
+    assert str(Poly(2*x + 1, x)) == "Poly(2*x + 1, x, domain='ZZ')"
+    assert str(Poly(2*x - 1, x)) == "Poly(2*x - 1, x, domain='ZZ')"
+
+    assert str(Poly(-1, x)) == "Poly(-1, x, domain='ZZ')"
+    assert str(Poly(-x, x)) == "Poly(-x, x, domain='ZZ')"
+
+    assert str(Poly(-2*x + 1, x)) == "Poly(-2*x + 1, x, domain='ZZ')"
+    assert str(Poly(-2*x - 1, x)) == "Poly(-2*x - 1, x, domain='ZZ')"
+
+    assert str(Poly(x - 1, x)) == "Poly(x - 1, x, domain='ZZ')"
+    assert str(Poly(2*x + x**5, x)) == "Poly(x**5 + 2*x, x, domain='ZZ')"
+
+    assert str(Poly(3**(2*x), 3**x)) == "Poly((3**x)**2, 3**x, domain='ZZ')"
+    assert str(Poly((x**2)**x)) == "Poly(((x**2)**x), (x**2)**x, domain='ZZ')"
+
+    assert str(Poly((x + y)**3, (x + y), expand=False)
+                ) == "Poly((x + y)**3, x + y, domain='ZZ')"
+    assert str(Poly((x - 1)**2, (x - 1), expand=False)
+                ) == "Poly((x - 1)**2, x - 1, domain='ZZ')"
+
+    assert str(
+        Poly(x**2 + 1 + y, x)) == "Poly(x**2 + y + 1, x, domain='ZZ[y]')"
+    assert str(
+        Poly(x**2 - 1 + y, x)) == "Poly(x**2 + y - 1, x, domain='ZZ[y]')"
+
+    assert str(Poly(x**2 + I*x, x)) == "Poly(x**2 + I*x, x, domain='ZZ_I')"
+    assert str(Poly(x**2 - I*x, x)) == "Poly(x**2 - I*x, x, domain='ZZ_I')"
+
+    assert str(Poly(-x*y*z + x*y - 1, x, y, z)
+               ) == "Poly(-x*y*z + x*y - 1, x, y, z, domain='ZZ')"
+    assert str(Poly(-w*x**21*y**7*z + (1 + w)*z**3 - 2*x*z + 1, x, y, z)) == \
+        "Poly(-w*x**21*y**7*z - 2*x*z + (w + 1)*z**3 + 1, x, y, z, domain='ZZ[w]')"
+
+    assert str(Poly(x**2 + 1, x, modulus=2)) == "Poly(x**2 + 1, x, modulus=2)"
+    assert str(Poly(2*x**2 + 3*x + 4, x, modulus=17)) == "Poly(2*x**2 + 3*x + 4, x, modulus=17)"
+
+
+def test_PolyRing():
+    assert str(ring("x", ZZ, lex)[0]) == "Polynomial ring in x over ZZ with lex order"
+    assert str(ring("x,y", QQ, grlex)[0]) == "Polynomial ring in x, y over QQ with grlex order"
+    assert str(ring("x,y,z", ZZ["t"], lex)[0]) == "Polynomial ring in x, y, z over ZZ[t] with lex order"
+
+
+def test_FracField():
+    assert str(field("x", ZZ, lex)[0]) == "Rational function field in x over ZZ with lex order"
+    assert str(field("x,y", QQ, grlex)[0]) == "Rational function field in x, y over QQ with grlex order"
+    assert str(field("x,y,z", ZZ["t"], lex)[0]) == "Rational function field in x, y, z over ZZ[t] with lex order"
+
+
+def test_PolyElement():
+    Ruv, u,v = ring("u,v", ZZ)
+    Rxyz, x,y,z = ring("x,y,z", Ruv)
+    Rx_zzi, xz = ring("x", ZZ_I)
+
+    assert str(x - x) == "0"
+    assert str(x - 1) == "x - 1"
+    assert str(x + 1) == "x + 1"
+    assert str(x**2) == "x**2"
+
+    assert str((u**2 + 3*u*v + 1)*x**2*y + u + 1) == "(u**2 + 3*u*v + 1)*x**2*y + u + 1"
+    assert str((u**2 + 3*u*v + 1)*x**2*y + (u + 1)*x) == "(u**2 + 3*u*v + 1)*x**2*y + (u + 1)*x"
+    assert str((u**2 + 3*u*v + 1)*x**2*y + (u + 1)*x + 1) == "(u**2 + 3*u*v + 1)*x**2*y + (u + 1)*x + 1"
+    assert str((-u**2 + 3*u*v - 1)*x**2*y - (u + 1)*x - 1) == "-(u**2 - 3*u*v + 1)*x**2*y - (u + 1)*x - 1"
+
+    assert str(-(v**2 + v + 1)*x + 3*u*v + 1) == "-(v**2 + v + 1)*x + 3*u*v + 1"
+    assert str(-(v**2 + v + 1)*x - 3*u*v + 1) == "-(v**2 + v + 1)*x - 3*u*v + 1"
+
+    assert str((1+I)*xz + 2) == "(1 + 1*I)*x + (2 + 0*I)"
+
+
+def test_FracElement():
+    Fuv, u,v = field("u,v", ZZ)
+    Fxyzt, x,y,z,t = field("x,y,z,t", Fuv)
+    Rx_zzi, xz = field("x", QQ_I)
+    i = QQ_I(0, 1)
+
+    assert str(x - x) == "0"
+    assert str(x - 1) == "x - 1"
+    assert str(x + 1) == "x + 1"
+
+    assert str(x/3) == "x/3"
+    assert str(x/z) == "x/z"
+    assert str(x*y/z) == "x*y/z"
+    assert str(x/(z*t)) == "x/(z*t)"
+    assert str(x*y/(z*t)) == "x*y/(z*t)"
+
+    assert str((x - 1)/y) == "(x - 1)/y"
+    assert str((x + 1)/y) == "(x + 1)/y"
+    assert str((-x - 1)/y) == "(-x - 1)/y"
+    assert str((x + 1)/(y*z)) == "(x + 1)/(y*z)"
+    assert str(-y/(x + 1)) == "-y/(x + 1)"
+    assert str(y*z/(x + 1)) == "y*z/(x + 1)"
+
+    assert str(((u + 1)*x*y + 1)/((v - 1)*z - 1)) == "((u + 1)*x*y + 1)/((v - 1)*z - 1)"
+    assert str(((u + 1)*x*y + 1)/((v - 1)*z - t*u*v - 1)) == "((u + 1)*x*y + 1)/((v - 1)*z - u*v*t - 1)"
+
+    assert str((1+i)/xz) == "(1 + 1*I)/x"
+    assert str(((1+i)*xz - i)/xz) == "((1 + 1*I)*x + (0 + -1*I))/x"
+
+
+def test_GaussianInteger():
+    assert str(ZZ_I(1, 0)) == "1"
+    assert str(ZZ_I(-1, 0)) == "-1"
+    assert str(ZZ_I(0, 1)) == "I"
+    assert str(ZZ_I(0, -1)) == "-I"
+    assert str(ZZ_I(0, 2)) == "2*I"
+    assert str(ZZ_I(0, -2)) == "-2*I"
+    assert str(ZZ_I(1, 1)) == "1 + I"
+    assert str(ZZ_I(-1, -1)) == "-1 - I"
+    assert str(ZZ_I(-1, -2)) == "-1 - 2*I"
+
+
+def test_GaussianRational():
+    assert str(QQ_I(1, 0)) == "1"
+    assert str(QQ_I(QQ(2, 3), 0)) == "2/3"
+    assert str(QQ_I(0, QQ(2, 3))) == "2*I/3"
+    assert str(QQ_I(QQ(1, 2), QQ(-2, 3))) == "1/2 - 2*I/3"
+
+
+def test_Pow():
+    assert str(x**-1) == "1/x"
+    assert str(x**-2) == "x**(-2)"
+    assert str(x**2) == "x**2"
+    assert str((x + y)**-1) == "1/(x + y)"
+    assert str((x + y)**-2) == "(x + y)**(-2)"
+    assert str((x + y)**2) == "(x + y)**2"
+    assert str((x + y)**(1 + x)) == "(x + y)**(x + 1)"
+    assert str(x**Rational(1, 3)) == "x**(1/3)"
+    assert str(1/x**Rational(1, 3)) == "x**(-1/3)"
+    assert str(sqrt(sqrt(x))) == "x**(1/4)"
+    # not the same as x**-1
+    assert str(x**-1.0) == 'x**(-1.0)'
+    # see issue #2860
+    assert str(Pow(S(2), -1.0, evaluate=False)) == '2**(-1.0)'
+
+
+def test_sqrt():
+    assert str(sqrt(x)) == "sqrt(x)"
+    assert str(sqrt(x**2)) == "sqrt(x**2)"
+    assert str(1/sqrt(x)) == "1/sqrt(x)"
+    assert str(1/sqrt(x**2)) == "1/sqrt(x**2)"
+    assert str(y/sqrt(x)) == "y/sqrt(x)"
+    assert str(x**0.5) == "x**0.5"
+    assert str(1/x**0.5) == "x**(-0.5)"
+
+
+def test_Rational():
+    n1 = Rational(1, 4)
+    n2 = Rational(1, 3)
+    n3 = Rational(2, 4)
+    n4 = Rational(2, -4)
+    n5 = Rational(0)
+    n7 = Rational(3)
+    n8 = Rational(-3)
+    assert str(n1*n2) == "1/12"
+    assert str(n1*n2) == "1/12"
+    assert str(n3) == "1/2"
+    assert str(n1*n3) == "1/8"
+    assert str(n1 + n3) == "3/4"
+    assert str(n1 + n2) == "7/12"
+    assert str(n1 + n4) == "-1/4"
+    assert str(n4*n4) == "1/4"
+    assert str(n4 + n2) == "-1/6"
+    assert str(n4 + n5) == "-1/2"
+    assert str(n4*n5) == "0"
+    assert str(n3 + n4) == "0"
+    assert str(n1**n7) == "1/64"
+    assert str(n2**n7) == "1/27"
+    assert str(n2**n8) == "27"
+    assert str(n7**n8) == "1/27"
+    assert str(Rational("-25")) == "-25"
+    assert str(Rational("1.25")) == "5/4"
+    assert str(Rational("-2.6e-2")) == "-13/500"
+    assert str(S("25/7")) == "25/7"
+    assert str(S("-123/569")) == "-123/569"
+    assert str(S("0.1[23]", rational=1)) == "61/495"
+    assert str(S("5.1[666]", rational=1)) == "31/6"
+    assert str(S("-5.1[666]", rational=1)) == "-31/6"
+    assert str(S("0.[9]", rational=1)) == "1"
+    assert str(S("-0.[9]", rational=1)) == "-1"
+
+    assert str(sqrt(Rational(1, 4))) == "1/2"
+    assert str(sqrt(Rational(1, 36))) == "1/6"
+
+    assert str((123**25) ** Rational(1, 25)) == "123"
+    assert str((123**25 + 1)**Rational(1, 25)) != "123"
+    assert str((123**25 - 1)**Rational(1, 25)) != "123"
+    assert str((123**25 - 1)**Rational(1, 25)) != "122"
+
+    assert str(sqrt(Rational(81, 36))**3) == "27/8"
+    assert str(1/sqrt(Rational(81, 36))**3) == "8/27"
+
+    assert str(sqrt(-4)) == str(2*I)
+    assert str(2**Rational(1, 10**10)) == "2**(1/10000000000)"
+
+    assert sstr(Rational(2, 3), sympy_integers=True) == "S(2)/3"
+    x = Symbol("x")
+    assert sstr(x**Rational(2, 3), sympy_integers=True) == "x**(S(2)/3)"
+    assert sstr(Eq(x, Rational(2, 3)), sympy_integers=True) == "Eq(x, S(2)/3)"
+    assert sstr(Limit(x, x, Rational(7, 2)), sympy_integers=True) == \
+        "Limit(x, x, S(7)/2, dir='+')"
+
+
+def test_Float():
+    # NOTE dps is the whole number of decimal digits
+    assert str(Float('1.23', dps=1 + 2)) == '1.23'
+    assert str(Float('1.23456789', dps=1 + 8)) == '1.23456789'
+    assert str(
+        Float('1.234567890123456789', dps=1 + 18)) == '1.234567890123456789'
+    assert str(pi.evalf(1 + 2)) == '3.14'
+    assert str(pi.evalf(1 + 14)) == '3.14159265358979'
+    assert str(pi.evalf(1 + 64)) == ('3.141592653589793238462643383279'
+                                     '5028841971693993751058209749445923')
+    assert str(pi.round(-1)) == '0.0'
+    assert str((pi**400 - (pi**400).round(1)).n(2)) == '-0.e+88'
+    assert sstr(Float("100"), full_prec=False, min=-2, max=2) == '1.0e+2'
+    assert sstr(Float("100"), full_prec=False, min=-2, max=3) == '100.0'
+    assert sstr(Float("0.1"), full_prec=False, min=-2, max=3) == '0.1'
+    assert sstr(Float("0.099"), min=-2, max=3) == '9.90000000000000e-2'
+
+
+def test_Relational():
+    assert str(Rel(x, y, "<")) == "x < y"
+    assert str(Rel(x + y, y, "==")) == "Eq(x + y, y)"
+    assert str(Rel(x, y, "!=")) == "Ne(x, y)"
+    assert str(Eq(x, 1) | Eq(x, 2)) == "Eq(x, 1) | Eq(x, 2)"
+    assert str(Ne(x, 1) & Ne(x, 2)) == "Ne(x, 1) & Ne(x, 2)"
+
+
+def test_AppliedBinaryRelation():
+    assert str(Q.eq(x, y)) == "Q.eq(x, y)"
+    assert str(Q.ne(x, y)) == "Q.ne(x, y)"
+
+
+def test_CRootOf():
+    assert str(rootof(x**5 + 2*x - 1, 0)) == "CRootOf(x**5 + 2*x - 1, 0)"
+
+
+def test_RootSum():
+    f = x**5 + 2*x - 1
+
+    assert str(
+        RootSum(f, Lambda(z, z), auto=False)) == "RootSum(x**5 + 2*x - 1)"
+    assert str(RootSum(f, Lambda(
+        z, z**2), auto=False)) == "RootSum(x**5 + 2*x - 1, Lambda(z, z**2))"
+
+
+def test_GroebnerBasis():
+    assert str(groebner(
+        [], x, y)) == "GroebnerBasis([], x, y, domain='ZZ', order='lex')"
+
+    F = [x**2 - 3*y - x + 1, y**2 - 2*x + y - 1]
+
+    assert str(groebner(F, order='grlex')) == \
+        "GroebnerBasis([x**2 - x - 3*y + 1, y**2 - 2*x + y - 1], x, y, domain='ZZ', order='grlex')"
+    assert str(groebner(F, order='lex')) == \
+        "GroebnerBasis([2*x - y**2 - y + 1, y**4 + 2*y**3 - 3*y**2 - 16*y + 7], x, y, domain='ZZ', order='lex')"
+
+def test_set():
+    assert sstr(set()) == 'set()'
+    assert sstr(frozenset()) == 'frozenset()'
+
+    assert sstr({1}) == '{1}'
+    assert sstr(frozenset([1])) == 'frozenset({1})'
+    assert sstr({1, 2, 3}) == '{1, 2, 3}'
+    assert sstr(frozenset([1, 2, 3])) == 'frozenset({1, 2, 3})'
+
+    assert sstr(
+        {1, x, x**2, x**3, x**4}) == '{1, x, x**2, x**3, x**4}'
+    assert sstr(
+        frozenset([1, x, x**2, x**3, x**4])) == 'frozenset({1, x, x**2, x**3, x**4})'
+
+
+def test_SparseMatrix():
+    M = SparseMatrix([[x**+1, 1], [y, x + y]])
+    assert str(M) == "Matrix([[x, 1], [y, x + y]])"
+    assert sstr(M) == "Matrix([\n[x,     1],\n[y, x + y]])"
+
+
+def test_Sum():
+    assert str(summation(cos(3*z), (z, x, y))) == "Sum(cos(3*z), (z, x, y))"
+    assert str(Sum(x*y**2, (x, -2, 2), (y, -5, 5))) == \
+        "Sum(x*y**2, (x, -2, 2), (y, -5, 5))"
+
+
+def test_Symbol():
+    assert str(y) == "y"
+    assert str(x) == "x"
+    e = x
+    assert str(e) == "x"
+
+
+def test_tuple():
+    assert str((x,)) == sstr((x,)) == "(x,)"
+    assert str((x + y, 1 + x)) == sstr((x + y, 1 + x)) == "(x + y, x + 1)"
+    assert str((x + y, (
+        1 + x, x**2))) == sstr((x + y, (1 + x, x**2))) == "(x + y, (x + 1, x**2))"
+
+
+def test_Series_str():
+    tf1 = TransferFunction(x*y**2 - z, y**3 - t**3, y)
+    tf2 = TransferFunction(x - y, x + y, y)
+    tf3 = TransferFunction(t*x**2 - t**w*x + w, t - y, y)
+    assert str(Series(tf1, tf2)) == \
+        "Series(TransferFunction(x*y**2 - z, -t**3 + y**3, y), TransferFunction(x - y, x + y, y))"
+    assert str(Series(tf1, tf2, tf3)) == \
+        "Series(TransferFunction(x*y**2 - z, -t**3 + y**3, y), TransferFunction(x - y, x + y, y), TransferFunction(t*x**2 - t**w*x + w, t - y, y))"
+    assert str(Series(-tf2, tf1)) == \
+        "Series(TransferFunction(-x + y, x + y, y), TransferFunction(x*y**2 - z, -t**3 + y**3, y))"
+
+
+def test_MIMOSeries_str():
+    tf1 = TransferFunction(x*y**2 - z, y**3 - t**3, y)
+    tf2 = TransferFunction(x - y, x + y, y)
+    tfm_1 = TransferFunctionMatrix([[tf1, tf2], [tf2, tf1]])
+    tfm_2 = TransferFunctionMatrix([[tf2, tf1], [tf1, tf2]])
+    assert str(MIMOSeries(tfm_1, tfm_2)) == \
+        "MIMOSeries(TransferFunctionMatrix(((TransferFunction(x*y**2 - z, -t**3 + y**3, y), TransferFunction(x - y, x + y, y)), "\
+            "(TransferFunction(x - y, x + y, y), TransferFunction(x*y**2 - z, -t**3 + y**3, y)))), "\
+                "TransferFunctionMatrix(((TransferFunction(x - y, x + y, y), TransferFunction(x*y**2 - z, -t**3 + y**3, y)), "\
+                    "(TransferFunction(x*y**2 - z, -t**3 + y**3, y), TransferFunction(x - y, x + y, y)))))"
+
+
+def test_TransferFunction_str():
+    tf1 = TransferFunction(x - 1, x + 1, x)
+    assert str(tf1) == "TransferFunction(x - 1, x + 1, x)"
+    tf2 = TransferFunction(x + 1, 2 - y, x)
+    assert str(tf2) == "TransferFunction(x + 1, 2 - y, x)"
+    tf3 = TransferFunction(y, y**2 + 2*y + 3, y)
+    assert str(tf3) == "TransferFunction(y, y**2 + 2*y + 3, y)"
+
+
+def test_Parallel_str():
+    tf1 = TransferFunction(x*y**2 - z, y**3 - t**3, y)
+    tf2 = TransferFunction(x - y, x + y, y)
+    tf3 = TransferFunction(t*x**2 - t**w*x + w, t - y, y)
+    assert str(Parallel(tf1, tf2)) == \
+        "Parallel(TransferFunction(x*y**2 - z, -t**3 + y**3, y), TransferFunction(x - y, x + y, y))"
+    assert str(Parallel(tf1, tf2, tf3)) == \
+        "Parallel(TransferFunction(x*y**2 - z, -t**3 + y**3, y), TransferFunction(x - y, x + y, y), TransferFunction(t*x**2 - t**w*x + w, t - y, y))"
+    assert str(Parallel(-tf2, tf1)) == \
+        "Parallel(TransferFunction(-x + y, x + y, y), TransferFunction(x*y**2 - z, -t**3 + y**3, y))"
+
+
+def test_MIMOParallel_str():
+    tf1 = TransferFunction(x*y**2 - z, y**3 - t**3, y)
+    tf2 = TransferFunction(x - y, x + y, y)
+    tfm_1 = TransferFunctionMatrix([[tf1, tf2], [tf2, tf1]])
+    tfm_2 = TransferFunctionMatrix([[tf2, tf1], [tf1, tf2]])
+    assert str(MIMOParallel(tfm_1, tfm_2)) == \
+        "MIMOParallel(TransferFunctionMatrix(((TransferFunction(x*y**2 - z, -t**3 + y**3, y), TransferFunction(x - y, x + y, y)), "\
+            "(TransferFunction(x - y, x + y, y), TransferFunction(x*y**2 - z, -t**3 + y**3, y)))), "\
+                "TransferFunctionMatrix(((TransferFunction(x - y, x + y, y), TransferFunction(x*y**2 - z, -t**3 + y**3, y)), "\
+                    "(TransferFunction(x*y**2 - z, -t**3 + y**3, y), TransferFunction(x - y, x + y, y)))))"
+
+
+def test_Feedback_str():
+    tf1 = TransferFunction(x*y**2 - z, y**3 - t**3, y)
+    tf2 = TransferFunction(x - y, x + y, y)
+    tf3 = TransferFunction(t*x**2 - t**w*x + w, t - y, y)
+    assert str(Feedback(tf1*tf2, tf3)) == \
+        "Feedback(Series(TransferFunction(x*y**2 - z, -t**3 + y**3, y), TransferFunction(x - y, x + y, y)), " \
+        "TransferFunction(t*x**2 - t**w*x + w, t - y, y), -1)"
+    assert str(Feedback(tf1, TransferFunction(1, 1, y), 1)) == \
+        "Feedback(TransferFunction(x*y**2 - z, -t**3 + y**3, y), TransferFunction(1, 1, y), 1)"
+
+
+def test_MIMOFeedback_str():
+    tf1 = TransferFunction(x**2 - y**3, y - z, x)
+    tf2 = TransferFunction(y - x, z + y, x)
+    tfm_1 = TransferFunctionMatrix([[tf2, tf1], [tf1, tf2]])
+    tfm_2 = TransferFunctionMatrix([[tf1, tf2], [tf2, tf1]])
+    assert (str(MIMOFeedback(tfm_1, tfm_2)) \
+            == "MIMOFeedback(TransferFunctionMatrix(((TransferFunction(-x + y, y + z, x), TransferFunction(x**2 - y**3, y - z, x))," \
+            " (TransferFunction(x**2 - y**3, y - z, x), TransferFunction(-x + y, y + z, x)))), " \
+            "TransferFunctionMatrix(((TransferFunction(x**2 - y**3, y - z, x), " \
+            "TransferFunction(-x + y, y + z, x)), (TransferFunction(-x + y, y + z, x), TransferFunction(x**2 - y**3, y - z, x)))), -1)")
+    assert (str(MIMOFeedback(tfm_1, tfm_2, 1)) \
+            == "MIMOFeedback(TransferFunctionMatrix(((TransferFunction(-x + y, y + z, x), TransferFunction(x**2 - y**3, y - z, x)), " \
+            "(TransferFunction(x**2 - y**3, y - z, x), TransferFunction(-x + y, y + z, x)))), " \
+            "TransferFunctionMatrix(((TransferFunction(x**2 - y**3, y - z, x), TransferFunction(-x + y, y + z, x)), "\
+            "(TransferFunction(-x + y, y + z, x), TransferFunction(x**2 - y**3, y - z, x)))), 1)")
+
+
+def test_TransferFunctionMatrix_str():
+    tf1 = TransferFunction(x*y**2 - z, y**3 - t**3, y)
+    tf2 = TransferFunction(x - y, x + y, y)
+    tf3 = TransferFunction(t*x**2 - t**w*x + w, t - y, y)
+    assert str(TransferFunctionMatrix([[tf1], [tf2]])) == \
+        "TransferFunctionMatrix(((TransferFunction(x*y**2 - z, -t**3 + y**3, y),), (TransferFunction(x - y, x + y, y),)))"
+    assert str(TransferFunctionMatrix([[tf1, tf2], [tf3, tf2]])) == \
+        "TransferFunctionMatrix(((TransferFunction(x*y**2 - z, -t**3 + y**3, y), TransferFunction(x - y, x + y, y)), (TransferFunction(t*x**2 - t**w*x + w, t - y, y), TransferFunction(x - y, x + y, y))))"
+
+
+def test_Quaternion_str_printer():
+    q = Quaternion(x, y, z, t)
+    assert str(q) == "x + y*i + z*j + t*k"
+    q = Quaternion(x,y,z,x*t)
+    assert str(q) == "x + y*i + z*j + t*x*k"
+    q = Quaternion(x,y,z,x+t)
+    assert str(q) == "x + y*i + z*j + (t + x)*k"
+
+
+def test_Quantity_str():
+    assert sstr(second, abbrev=True) == "s"
+    assert sstr(joule, abbrev=True) == "J"
+    assert str(second) == "second"
+    assert str(joule) == "joule"
+
+
+def test_wild_str():
+    # Check expressions containing Wild not causing infinite recursion
+    w = Wild('x')
+    assert str(w + 1) == 'x_ + 1'
+    assert str(exp(2**w) + 5) == 'exp(2**x_) + 5'
+    assert str(3*w + 1) == '3*x_ + 1'
+    assert str(1/w + 1) == '1 + 1/x_'
+    assert str(w**2 + 1) == 'x_**2 + 1'
+    assert str(1/(1 - w)) == '1/(1 - x_)'
+
+
+def test_wild_matchpy():
+    from sympy.utilities.matchpy_connector import WildDot, WildPlus, WildStar
+
+    matchpy = import_module("matchpy")
+
+    if matchpy is None:
+        return
+
+    wd = WildDot('w_')
+    wp = WildPlus('w__')
+    ws = WildStar('w___')
+
+    assert str(wd) == 'w_'
+    assert str(wp) == 'w__'
+    assert str(ws) == 'w___'
+
+    assert str(wp/ws + 2**wd) == '2**w_ + w__/w___'
+    assert str(sin(wd)*cos(wp)*sqrt(ws)) == 'sqrt(w___)*sin(w_)*cos(w__)'
+
+
+def test_zeta():
+    assert str(zeta(3)) == "zeta(3)"
+
+
+def test_issue_3101():
+    e = x - y
+    a = str(e)
+    b = str(e)
+    assert a == b
+
+
+def test_issue_3103():
+    e = -2*sqrt(x) - y/sqrt(x)/2
+    assert str(e) not in ["(-2)*x**1/2(-1/2)*x**(-1/2)*y",
+            "-2*x**1/2(-1/2)*x**(-1/2)*y", "-2*x**1/2-1/2*x**-1/2*w"]
+    assert str(e) == "-2*sqrt(x) - y/(2*sqrt(x))"
+
+
+def test_issue_4021():
+    e = Integral(x, x) + 1
+    assert str(e) == 'Integral(x, x) + 1'
+
+
+def test_sstrrepr():
+    assert sstr('abc') == 'abc'
+    assert sstrrepr('abc') == "'abc'"
+
+    e = ['a', 'b', 'c', x]
+    assert sstr(e) == "[a, b, c, x]"
+    assert sstrrepr(e) == "['a', 'b', 'c', x]"
+
+
+def test_infinity():
+    assert sstr(oo*I) == "oo*I"
+
+
+def test_full_prec():
+    assert sstr(S("0.3"), full_prec=True) == "0.300000000000000"
+    assert sstr(S("0.3"), full_prec="auto") == "0.300000000000000"
+    assert sstr(S("0.3"), full_prec=False) == "0.3"
+    assert sstr(S("0.3")*x, full_prec=True) in [
+        "0.300000000000000*x",
+        "x*0.300000000000000"
+    ]
+    assert sstr(S("0.3")*x, full_prec="auto") in [
+        "0.3*x",
+        "x*0.3"
+    ]
+    assert sstr(S("0.3")*x, full_prec=False) in [
+        "0.3*x",
+        "x*0.3"
+    ]
+
+
+def test_noncommutative():
+    A, B, C = symbols('A,B,C', commutative=False)
+
+    assert sstr(A*B*C**-1) == "A*B*C**(-1)"
+    assert sstr(C**-1*A*B) == "C**(-1)*A*B"
+    assert sstr(A*C**-1*B) == "A*C**(-1)*B"
+    assert sstr(sqrt(A)) == "sqrt(A)"
+    assert sstr(1/sqrt(A)) == "A**(-1/2)"
+
+
+def test_empty_printer():
+    str_printer = StrPrinter()
+    assert str_printer.emptyPrinter("foo") == "foo"
+    assert str_printer.emptyPrinter(x*y) == "x*y"
+    assert str_printer.emptyPrinter(32) == "32"
+
+def test_decimal_printer():
+    dec_printer = StrPrinter(settings={"dps":3})
+    f = Function('f')
+    assert dec_printer.doprint(f(1.329294)) == "f(1.33)"
+
+
+def test_settings():
+    raises(TypeError, lambda: sstr(S(4), method="garbage"))
+
+
+def test_RandomDomain():
+    from sympy.stats import Normal, Die, Exponential, pspace, where
+    X = Normal('x1', 0, 1)
+    assert str(where(X > 0)) == "Domain: (0 < x1) & (x1 < oo)"
+
+    D = Die('d1', 6)
+    assert str(where(D > 4)) == "Domain: Eq(d1, 5) | Eq(d1, 6)"
+
+    A = Exponential('a', 1)
+    B = Exponential('b', 1)
+    assert str(pspace(Tuple(A, B)).domain) == "Domain: (0 <= a) & (0 <= b) & (a < oo) & (b < oo)"
+
+
+def test_FiniteSet():
+    assert str(FiniteSet(*range(1, 51))) == (
+        '{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17,'
+        ' 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34,'
+        ' 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50}'
+    )
+    assert str(FiniteSet(*range(1, 6))) == '{1, 2, 3, 4, 5}'
+    assert str(FiniteSet(*[x*y, x**2])) == '{x**2, x*y}'
+    assert str(FiniteSet(FiniteSet(FiniteSet(x, y), 5), FiniteSet(x,y), 5)
+               ) == 'FiniteSet(5, FiniteSet(5, {x, y}), {x, y})'
+
+
+def test_Partition():
+    assert str(Partition(FiniteSet(x, y), {z})) == 'Partition({z}, {x, y})'
+
+def test_UniversalSet():
+    assert str(S.UniversalSet) == 'UniversalSet'
+
+
+def test_PrettyPoly():
+    F = QQ.frac_field(x, y)
+    R = QQ[x, y]
+    assert sstr(F.convert(x/(x + y))) == sstr(x/(x + y))
+    assert sstr(R.convert(x + y)) == sstr(x + y)
+
+
+def test_categories():
+    from sympy.categories import (Object, NamedMorphism,
+        IdentityMorphism, Category)
+
+    A = Object("A")
+    B = Object("B")
+
+    f = NamedMorphism(A, B, "f")
+    id_A = IdentityMorphism(A)
+
+    K = Category("K")
+
+    assert str(A) == 'Object("A")'
+    assert str(f) == 'NamedMorphism(Object("A"), Object("B"), "f")'
+    assert str(id_A) == 'IdentityMorphism(Object("A"))'
+
+    assert str(K) == 'Category("K")'
+
+
+def test_Tr():
+    A, B = symbols('A B', commutative=False)
+    t = Tr(A*B)
+    assert str(t) == 'Tr(A*B)'
+
+
+def test_issue_6387():
+    assert str(factor(-3.0*z + 3)) == '-3.0*(1.0*z - 1.0)'
+
+
+def test_MatMul_MatAdd():
+    X, Y = MatrixSymbol("X", 2, 2), MatrixSymbol("Y", 2, 2)
+    assert str(2*(X + Y)) == "2*X + 2*Y"
+
+    assert str(I*X) == "I*X"
+    assert str(-I*X) == "-I*X"
+    assert str((1 + I)*X) == '(1 + I)*X'
+    assert str(-(1 + I)*X) == '(-1 - I)*X'
+    assert str(MatAdd(MatAdd(X, Y), MatAdd(X, Y))) == '(X + Y) + (X + Y)'
+
+
+def test_MatrixSlice():
+    n = Symbol('n', integer=True)
+    X = MatrixSymbol('X', n, n)
+    Y = MatrixSymbol('Y', 10, 10)
+    Z = MatrixSymbol('Z', 10, 10)
+
+    assert str(MatrixSlice(X, (None, None, None), (None, None, None))) == 'X[:, :]'
+    assert str(X[x:x + 1, y:y + 1]) == 'X[x:x + 1, y:y + 1]'
+    assert str(X[x:x + 1:2, y:y + 1:2]) == 'X[x:x + 1:2, y:y + 1:2]'
+    assert str(X[:x, y:]) == 'X[:x, y:]'
+    assert str(X[:x, y:]) == 'X[:x, y:]'
+    assert str(X[x:, :y]) == 'X[x:, :y]'
+    assert str(X[x:y, z:w]) == 'X[x:y, z:w]'
+    assert str(X[x:y:t, w:t:x]) == 'X[x:y:t, w:t:x]'
+    assert str(X[x::y, t::w]) == 'X[x::y, t::w]'
+    assert str(X[:x:y, :t:w]) == 'X[:x:y, :t:w]'
+    assert str(X[::x, ::y]) == 'X[::x, ::y]'
+    assert str(MatrixSlice(X, (0, None, None), (0, None, None))) == 'X[:, :]'
+    assert str(MatrixSlice(X, (None, n, None), (None, n, None))) == 'X[:, :]'
+    assert str(MatrixSlice(X, (0, n, None), (0, n, None))) == 'X[:, :]'
+    assert str(MatrixSlice(X, (0, n, 2), (0, n, 2))) == 'X[::2, ::2]'
+    assert str(X[1:2:3, 4:5:6]) == 'X[1:2:3, 4:5:6]'
+    assert str(X[1:3:5, 4:6:8]) == 'X[1:3:5, 4:6:8]'
+    assert str(X[1:10:2]) == 'X[1:10:2, :]'
+    assert str(Y[:5, 1:9:2]) == 'Y[:5, 1:9:2]'
+    assert str(Y[:5, 1:10:2]) == 'Y[:5, 1::2]'
+    assert str(Y[5, :5:2]) == 'Y[5:6, :5:2]'
+    assert str(X[0:1, 0:1]) == 'X[:1, :1]'
+    assert str(X[0:1:2, 0:1:2]) == 'X[:1:2, :1:2]'
+    assert str((Y + Z)[2:, 2:]) == '(Y + Z)[2:, 2:]'
+
+def test_true_false():
+    assert str(true) == repr(true) == sstr(true) == "True"
+    assert str(false) == repr(false) == sstr(false) == "False"
+
+def test_Equivalent():
+    assert str(Equivalent(y, x)) == "Equivalent(x, y)"
+
+def test_Xor():
+    assert str(Xor(y, x, evaluate=False)) == "x ^ y"
+
+def test_Complement():
+    assert str(Complement(S.Reals, S.Naturals)) == 'Complement(Reals, Naturals)'
+
+def test_SymmetricDifference():
+    assert str(SymmetricDifference(Interval(2, 3), Interval(3, 4),evaluate=False)) == \
+           'SymmetricDifference(Interval(2, 3), Interval(3, 4))'
+
+
+def test_UnevaluatedExpr():
+    a, b = symbols("a b")
+    expr1 = 2*UnevaluatedExpr(a+b)
+    assert str(expr1) == "2*(a + b)"
+
+
+def test_MatrixElement_printing():
+    # test cases for issue #11821
+    A = MatrixSymbol("A", 1, 3)
+    B = MatrixSymbol("B", 1, 3)
+    C = MatrixSymbol("C", 1, 3)
+
+    assert(str(A[0, 0]) == "A[0, 0]")
+    assert(str(3 * A[0, 0]) == "3*A[0, 0]")
+
+    F = C[0, 0].subs(C, A - B)
+    assert str(F) == "(A - B)[0, 0]"
+
+
+def test_MatrixSymbol_printing():
+    A = MatrixSymbol("A", 3, 3)
+    B = MatrixSymbol("B", 3, 3)
+
+    assert str(A - A*B - B) == "A - A*B - B"
+    assert str(A*B - (A+B)) == "-A + A*B - B"
+    assert str(A**(-1)) == "A**(-1)"
+    assert str(A**3) == "A**3"
+
+
+def test_MatrixExpressions():
+    n = Symbol('n', integer=True)
+    X = MatrixSymbol('X', n, n)
+
+    assert str(X) == "X"
+
+    # Apply function elementwise (`ElementwiseApplyFunc`):
+
+    expr = (X.T*X).applyfunc(sin)
+    assert str(expr) == 'Lambda(_d, sin(_d)).(X.T*X)'
+
+    lamda = Lambda(x, 1/x)
+    expr = (n*X).applyfunc(lamda)
+    assert str(expr) == 'Lambda(x, 1/x).(n*X)'
+
+
+def test_Subs_printing():
+    assert str(Subs(x, (x,), (1,))) == 'Subs(x, x, 1)'
+    assert str(Subs(x + y, (x, y), (1, 2))) == 'Subs(x + y, (x, y), (1, 2))'
+
+
+def test_issue_15716():
+    e = Integral(factorial(x), (x, -oo, oo))
+    assert e.as_terms() == ([(e, ((1.0, 0.0), (1,), ()))], [e])
+
+
+def test_str_special_matrices():
+    from sympy.matrices import Identity, ZeroMatrix, OneMatrix
+    assert str(Identity(4)) == 'I'
+    assert str(ZeroMatrix(2, 2)) == '0'
+    assert str(OneMatrix(2, 2)) == '1'
+
+
+def test_issue_14567():
+    assert factorial(Sum(-1, (x, 0, 0))) + y  # doesn't raise an error
+
+
+def test_issue_21823():
+    assert str(Partition([1, 2])) == 'Partition({1, 2})'
+    assert str(Partition({1, 2})) == 'Partition({1, 2})'
+
+
+def test_issue_22689():
+    assert str(Mul(Pow(x,-2, evaluate=False), Pow(3,-1,evaluate=False), evaluate=False)) == "1/(x**2*3)"
+
+
+def test_issue_21119_21460():
+    ss = lambda x: str(S(x, evaluate=False))
+    assert ss('4/2') == '4/2'
+    assert ss('4/-2') == '4/(-2)'
+    assert ss('-4/2') == '-4/2'
+    assert ss('-4/-2') == '-4/(-2)'
+    assert ss('-2*3/-1') == '-2*3/(-1)'
+    assert ss('-2*3/-1/2') == '-2*3/(-1*2)'
+    assert ss('4/2/1') == '4/(2*1)'
+    assert ss('-2/-1/2') == '-2/(-1*2)'
+    assert ss('2*3*4**(-2*3)') == '2*3/4**(2*3)'
+    assert ss('2*3*1*4**(-2*3)') == '2*3*1/4**(2*3)'
+
+
+def test_Str():
+    from sympy.core.symbol import Str
+    assert str(Str('x')) == 'x'
+    assert sstrrepr(Str('x')) == "Str('x')"
+
+
+def test_diffgeom():
+    from sympy.diffgeom import Manifold, Patch, CoordSystem, BaseScalarField
+    x,y = symbols('x y', real=True)
+    m = Manifold('M', 2)
+    assert str(m) == "M"
+    p = Patch('P', m)
+    assert str(p) == "P"
+    rect = CoordSystem('rect', p, [x, y])
+    assert str(rect) == "rect"
+    b = BaseScalarField(rect, 0)
+    assert str(b) == "x"
+
+def test_NDimArray():
+    assert sstr(NDimArray(1.0), full_prec=True) == '1.00000000000000'
+    assert sstr(NDimArray(1.0), full_prec=False) == '1.0'
+    assert sstr(NDimArray([1.0, 2.0]), full_prec=True) == '[1.00000000000000, 2.00000000000000]'
+    assert sstr(NDimArray([1.0, 2.0]), full_prec=False) == '[1.0, 2.0]'
+    assert sstr(NDimArray([], (0,))) == 'ImmutableDenseNDimArray([], (0,))'
+    assert sstr(NDimArray([], (0, 0))) == 'ImmutableDenseNDimArray([], (0, 0))'
+    assert sstr(NDimArray([], (0, 1))) == 'ImmutableDenseNDimArray([], (0, 1))'
+    assert sstr(NDimArray([], (1, 0))) == 'ImmutableDenseNDimArray([], (1, 0))'
+
+def test_Predicate():
+    assert sstr(Q.even) == 'Q.even'
+
+def test_AppliedPredicate():
+    assert sstr(Q.even(x)) == 'Q.even(x)'
+
+def test_printing_str_array_expressions():
+    assert sstr(ArraySymbol("A", (2, 3, 4))) == "A"
+    assert sstr(ArrayElement("A", (2, 1/(1-x), 0))) == "A[2, 1/(1 - x), 0]"
+    M = MatrixSymbol("M", 3, 3)
+    N = MatrixSymbol("N", 3, 3)
+    assert sstr(ArrayElement(M*N, [x, 0])) == "(M*N)[x, 0]"
+
+def test_printing_stats():
+    # issue 24132
+    x = RandomSymbol("x")
+    y = RandomSymbol("y")
+    z1 = Probability(x > 0)*Identity(2)
+    z2 = Expectation(x)*Identity(2)
+    z3 = Variance(x)*Identity(2)
+    z4 = Covariance(x, y) * Identity(2)
+
+    assert str(z1) == "Probability(x > 0)*I"
+    assert str(z2) == "Expectation(x)*I"
+    assert str(z3) == "Variance(x)*I"
+    assert str(z4) ==  "Covariance(x, y)*I"
+    assert z1.is_commutative == False
+    assert z2.is_commutative == False
+    assert z3.is_commutative == False
+    assert z4.is_commutative == False
+    assert z2._eval_is_commutative() == False
+    assert z3._eval_is_commutative() == False
+    assert z4._eval_is_commutative() == False
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/test_tableform.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/test_tableform.py
new file mode 100644
index 0000000000000000000000000000000000000000..05802dd104a12f2f53d137167ecf31d201ff8dfc
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/test_tableform.py
@@ -0,0 +1,182 @@
+from sympy.core.singleton import S
+from sympy.printing.tableform import TableForm
+from sympy.printing.latex import latex
+from sympy.abc import x
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import sin
+from sympy.testing.pytest import raises
+
+from textwrap import dedent
+
+
+def test_TableForm():
+    s = str(TableForm([["a", "b"], ["c", "d"], ["e", 0]],
+        headings="automatic"))
+    assert s == (
+        '  | 1 2\n'
+        '-------\n'
+        '1 | a b\n'
+        '2 | c d\n'
+        '3 | e  '
+    )
+    s = str(TableForm([["a", "b"], ["c", "d"], ["e", 0]],
+        headings="automatic", wipe_zeros=False))
+    assert s == dedent('''\
+          | 1 2
+        -------
+        1 | a b
+        2 | c d
+        3 | e 0''')
+    s = str(TableForm([[x**2, "b"], ["c", x**2], ["e", "f"]],
+            headings=("automatic", None)))
+    assert s == (
+        '1 | x**2 b   \n'
+        '2 | c    x**2\n'
+        '3 | e    f   '
+    )
+    s = str(TableForm([["a", "b"], ["c", "d"], ["e", "f"]],
+            headings=(None, "automatic")))
+    assert s == dedent('''\
+        1 2
+        ---
+        a b
+        c d
+        e f''')
+    s = str(TableForm([[5, 7], [4, 2], [10, 3]],
+            headings=[["Group A", "Group B", "Group C"], ["y1", "y2"]]))
+    assert s == (
+        '        | y1 y2\n'
+        '---------------\n'
+        'Group A | 5  7 \n'
+        'Group B | 4  2 \n'
+        'Group C | 10 3 '
+    )
+    raises(
+        ValueError,
+        lambda:
+        TableForm(
+            [[5, 7], [4, 2], [10, 3]],
+            headings=[["Group A", "Group B", "Group C"], ["y1", "y2"]],
+            alignments="middle")
+    )
+    s = str(TableForm([[5, 7], [4, 2], [10, 3]],
+            headings=[["Group A", "Group B", "Group C"], ["y1", "y2"]],
+            alignments="right"))
+    assert s == dedent('''\
+                | y1 y2
+        ---------------
+        Group A |  5  7
+        Group B |  4  2
+        Group C | 10  3''')
+
+    # other alignment permutations
+    d = [[1, 100], [100, 1]]
+    s = TableForm(d, headings=(('xxx', 'x'), None), alignments='l')
+    assert str(s) == (
+        'xxx | 1   100\n'
+        '  x | 100 1  '
+    )
+    s = TableForm(d, headings=(('xxx', 'x'), None), alignments='lr')
+    assert str(s) == dedent('''\
+    xxx | 1   100
+      x | 100   1''')
+    s = TableForm(d, headings=(('xxx', 'x'), None), alignments='clr')
+    assert str(s) == dedent('''\
+    xxx | 1   100
+     x  | 100   1''')
+
+    s = TableForm(d, headings=(('xxx', 'x'), None))
+    assert str(s) == (
+        'xxx | 1   100\n'
+        '  x | 100 1  '
+    )
+
+    raises(ValueError, lambda: TableForm(d, alignments='clr'))
+
+    #pad
+    s = str(TableForm([[None, "-", 2], [1]], pad='?'))
+    assert s == dedent('''\
+        ? - 2
+        1 ? ?''')
+
+
+def test_TableForm_latex():
+    s = latex(TableForm([[0, x**3], ["c", S.One/4], [sqrt(x), sin(x**2)]],
+            wipe_zeros=True, headings=("automatic", "automatic")))
+    assert s == (
+        '\\begin{tabular}{r l l}\n'
+        ' & 1 & 2 \\\\\n'
+        '\\hline\n'
+        '1 &   & $x^{3}$ \\\\\n'
+        '2 & $c$ & $\\frac{1}{4}$ \\\\\n'
+        '3 & $\\sqrt{x}$ & $\\sin{\\left(x^{2} \\right)}$ \\\\\n'
+        '\\end{tabular}'
+    )
+    s = latex(TableForm([[0, x**3], ["c", S.One/4], [sqrt(x), sin(x**2)]],
+            wipe_zeros=True, headings=("automatic", "automatic"), alignments='l'))
+    assert s == (
+        '\\begin{tabular}{r l l}\n'
+        ' & 1 & 2 \\\\\n'
+        '\\hline\n'
+        '1 &   & $x^{3}$ \\\\\n'
+        '2 & $c$ & $\\frac{1}{4}$ \\\\\n'
+        '3 & $\\sqrt{x}$ & $\\sin{\\left(x^{2} \\right)}$ \\\\\n'
+        '\\end{tabular}'
+    )
+    s = latex(TableForm([[0, x**3], ["c", S.One/4], [sqrt(x), sin(x**2)]],
+            wipe_zeros=True, headings=("automatic", "automatic"), alignments='l'*3))
+    assert s == (
+        '\\begin{tabular}{l l l}\n'
+        ' & 1 & 2 \\\\\n'
+        '\\hline\n'
+        '1 &   & $x^{3}$ \\\\\n'
+        '2 & $c$ & $\\frac{1}{4}$ \\\\\n'
+        '3 & $\\sqrt{x}$ & $\\sin{\\left(x^{2} \\right)}$ \\\\\n'
+        '\\end{tabular}'
+    )
+    s = latex(TableForm([["a", x**3], ["c", S.One/4], [sqrt(x), sin(x**2)]],
+            headings=("automatic", "automatic")))
+    assert s == (
+        '\\begin{tabular}{r l l}\n'
+        ' & 1 & 2 \\\\\n'
+        '\\hline\n'
+        '1 & $a$ & $x^{3}$ \\\\\n'
+        '2 & $c$ & $\\frac{1}{4}$ \\\\\n'
+        '3 & $\\sqrt{x}$ & $\\sin{\\left(x^{2} \\right)}$ \\\\\n'
+        '\\end{tabular}'
+    )
+    s = latex(TableForm([["a", x**3], ["c", S.One/4], [sqrt(x), sin(x**2)]],
+            formats=['(%s)', None], headings=("automatic", "automatic")))
+    assert s == (
+        '\\begin{tabular}{r l l}\n'
+        ' & 1 & 2 \\\\\n'
+        '\\hline\n'
+        '1 & (a) & $x^{3}$ \\\\\n'
+        '2 & (c) & $\\frac{1}{4}$ \\\\\n'
+        '3 & (sqrt(x)) & $\\sin{\\left(x^{2} \\right)}$ \\\\\n'
+        '\\end{tabular}'
+    )
+
+    def neg_in_paren(x, i, j):
+        if i % 2:
+            return ('(%s)' if x < 0 else '%s') % x
+        else:
+            pass  # use default print
+    s = latex(TableForm([[-1, 2], [-3, 4]],
+            formats=[neg_in_paren]*2, headings=("automatic", "automatic")))
+    assert s == (
+        '\\begin{tabular}{r l l}\n'
+        ' & 1 & 2 \\\\\n'
+        '\\hline\n'
+        '1 & -1 & 2 \\\\\n'
+        '2 & (-3) & 4 \\\\\n'
+        '\\end{tabular}'
+    )
+    s = latex(TableForm([["a", x**3], ["c", S.One/4], [sqrt(x), sin(x**2)]]))
+    assert s == (
+        '\\begin{tabular}{l l}\n'
+        '$a$ & $x^{3}$ \\\\\n'
+        '$c$ & $\\frac{1}{4}$ \\\\\n'
+        '$\\sqrt{x}$ & $\\sin{\\left(x^{2} \\right)}$ \\\\\n'
+        '\\end{tabular}'
+    )
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/test_tensorflow.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/test_tensorflow.py
new file mode 100644
index 0000000000000000000000000000000000000000..e9c92cd17b13e1148ebf83f13f66854b983491fe
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/test_tensorflow.py
@@ -0,0 +1,493 @@
+import random
+from sympy.core.function import Derivative
+from sympy.core.symbol import symbols
+from sympy import Piecewise
+from sympy.tensor.array.expressions.array_expressions import ArrayTensorProduct, ArrayAdd, \
+    PermuteDims, ArrayDiagonal
+from sympy.core.relational import Eq, Ne, Ge, Gt, Le, Lt
+from sympy.external import import_module
+from sympy.functions import \
+    Abs, ceiling, exp, floor, sign, sin, asin, sqrt, cos, \
+    acos, tan, atan, atan2, cosh, acosh, sinh, asinh, tanh, atanh, \
+    re, im, arg, erf, loggamma, log
+from sympy.codegen.cfunctions import isnan, isinf
+from sympy.matrices import Matrix, MatrixBase, eye, randMatrix
+from sympy.matrices.expressions import \
+    Determinant, HadamardProduct, Inverse, MatrixSymbol, Trace
+from sympy.printing.tensorflow import tensorflow_code
+from sympy.tensor.array.expressions.from_matrix_to_array import convert_matrix_to_array
+from sympy.utilities.lambdify import lambdify
+from sympy.testing.pytest import skip
+from sympy.testing.pytest import XFAIL
+
+
+tf = tensorflow = import_module("tensorflow")
+
+if tensorflow:
+    # Hide Tensorflow warnings
+    import os
+    os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
+
+
+M = MatrixSymbol("M", 3, 3)
+N = MatrixSymbol("N", 3, 3)
+P = MatrixSymbol("P", 3, 3)
+Q = MatrixSymbol("Q", 3, 3)
+
+x, y, z, t = symbols("x y z t")
+
+if tf is not None:
+    llo = [list(range(i, i+3)) for i in range(0, 9, 3)]
+    m3x3 = tf.constant(llo)
+    m3x3sympy = Matrix(llo)
+
+
+def _compare_tensorflow_matrix(variables, expr, use_float=False):
+    f = lambdify(variables, expr, 'tensorflow')
+    if not use_float:
+        random_matrices = [randMatrix(v.rows, v.cols) for v in variables]
+    else:
+        random_matrices = [randMatrix(v.rows, v.cols)/100. for v in variables]
+
+    graph = tf.Graph()
+    r = None
+    with graph.as_default():
+        random_variables = [eval(tensorflow_code(i)) for i in random_matrices]
+        session = tf.compat.v1.Session(graph=graph)
+        r = session.run(f(*random_variables))
+
+    e = expr.subs(dict(zip(variables, random_matrices)))
+    e = e.doit()
+    if e.is_Matrix:
+        if not isinstance(e, MatrixBase):
+            e = e.as_explicit()
+        e = e.tolist()
+
+    if not use_float:
+        assert (r == e).all()
+    else:
+        r = [i for row in r for i in row]
+        e = [i for row in e for i in row]
+        assert all(
+            abs(a-b) < 10**-(4-int(log(abs(a), 10))) for a, b in zip(r, e))
+
+
+# Creating a custom inverse test.
+# See https://github.com/sympy/sympy/issues/18469
+def _compare_tensorflow_matrix_inverse(variables, expr, use_float=False):
+    f = lambdify(variables, expr, 'tensorflow')
+    if not use_float:
+        random_matrices = [eye(v.rows, v.cols)*4 for v in variables]
+    else:
+        random_matrices = [eye(v.rows, v.cols)*3.14 for v in variables]
+
+    graph = tf.Graph()
+    r = None
+    with graph.as_default():
+        random_variables = [eval(tensorflow_code(i)) for i in random_matrices]
+        session = tf.compat.v1.Session(graph=graph)
+        r = session.run(f(*random_variables))
+
+    e = expr.subs(dict(zip(variables, random_matrices)))
+    e = e.doit()
+    if e.is_Matrix:
+        if not isinstance(e, MatrixBase):
+            e = e.as_explicit()
+        e = e.tolist()
+
+    if not use_float:
+        assert (r == e).all()
+    else:
+        r = [i for row in r for i in row]
+        e = [i for row in e for i in row]
+        assert all(
+            abs(a-b) < 10**-(4-int(log(abs(a), 10))) for a, b in zip(r, e))
+
+
+def _compare_tensorflow_matrix_scalar(variables, expr):
+    f = lambdify(variables, expr, 'tensorflow')
+    random_matrices = [
+        randMatrix(v.rows, v.cols).evalf() / 100 for v in variables]
+
+    graph = tf.Graph()
+    r = None
+    with graph.as_default():
+        random_variables = [eval(tensorflow_code(i)) for i in random_matrices]
+        session = tf.compat.v1.Session(graph=graph)
+        r = session.run(f(*random_variables))
+
+    e = expr.subs(dict(zip(variables, random_matrices)))
+    e = e.doit()
+    assert abs(r-e) < 10**-6
+
+
+def _compare_tensorflow_scalar(
+    variables, expr, rng=lambda: random.randint(0, 10)):
+    f = lambdify(variables, expr, 'tensorflow')
+    rvs = [rng() for v in variables]
+
+    graph = tf.Graph()
+    r = None
+    with graph.as_default():
+        tf_rvs = [eval(tensorflow_code(i)) for i in rvs]
+        session = tf.compat.v1.Session(graph=graph)
+        r = session.run(f(*tf_rvs))
+
+    e = expr.subs(dict(zip(variables, rvs))).evalf().doit()
+    assert abs(r-e) < 10**-6
+
+
+def _compare_tensorflow_relational(
+    variables, expr, rng=lambda: random.randint(0, 10)):
+    f = lambdify(variables, expr, 'tensorflow')
+    rvs = [rng() for v in variables]
+
+    graph = tf.Graph()
+    r = None
+    with graph.as_default():
+        tf_rvs = [eval(tensorflow_code(i)) for i in rvs]
+        session = tf.compat.v1.Session(graph=graph)
+        r = session.run(f(*tf_rvs))
+
+    e = expr.subs(dict(zip(variables, rvs))).doit()
+    assert r == e
+
+
+def test_tensorflow_printing():
+    assert tensorflow_code(eye(3)) == \
+        "tensorflow.constant([[1, 0, 0], [0, 1, 0], [0, 0, 1]])"
+
+    expr = Matrix([[x, sin(y)], [exp(z), -t]])
+    assert tensorflow_code(expr) == \
+        "tensorflow.Variable(" \
+            "[[x, tensorflow.math.sin(y)]," \
+            " [tensorflow.math.exp(z), -t]])"
+
+
+# This (random) test is XFAIL because it fails occasionally
+# See https://github.com/sympy/sympy/issues/18469
+@XFAIL
+def test_tensorflow_math():
+    if not tf:
+        skip("TensorFlow not installed")
+
+    expr = Abs(x)
+    assert tensorflow_code(expr) == "tensorflow.math.abs(x)"
+    _compare_tensorflow_scalar((x,), expr)
+
+    expr = sign(x)
+    assert tensorflow_code(expr) == "tensorflow.math.sign(x)"
+    _compare_tensorflow_scalar((x,), expr)
+
+    expr = ceiling(x)
+    assert tensorflow_code(expr) == "tensorflow.math.ceil(x)"
+    _compare_tensorflow_scalar((x,), expr, rng=lambda: random.random())
+
+    expr = floor(x)
+    assert tensorflow_code(expr) == "tensorflow.math.floor(x)"
+    _compare_tensorflow_scalar((x,), expr, rng=lambda: random.random())
+
+    expr = exp(x)
+    assert tensorflow_code(expr) == "tensorflow.math.exp(x)"
+    _compare_tensorflow_scalar((x,), expr, rng=lambda: random.random())
+
+    expr = sqrt(x)
+    assert tensorflow_code(expr) == "tensorflow.math.sqrt(x)"
+    _compare_tensorflow_scalar((x,), expr, rng=lambda: random.random())
+
+    expr = x ** 4
+    assert tensorflow_code(expr) == "tensorflow.math.pow(x, 4)"
+    _compare_tensorflow_scalar((x,), expr, rng=lambda: random.random())
+
+    expr = cos(x)
+    assert tensorflow_code(expr) == "tensorflow.math.cos(x)"
+    _compare_tensorflow_scalar((x,), expr, rng=lambda: random.random())
+
+    expr = acos(x)
+    assert tensorflow_code(expr) == "tensorflow.math.acos(x)"
+    _compare_tensorflow_scalar((x,), expr, rng=lambda: random.uniform(0, 0.95))
+
+    expr = sin(x)
+    assert tensorflow_code(expr) == "tensorflow.math.sin(x)"
+    _compare_tensorflow_scalar((x,), expr, rng=lambda: random.random())
+
+    expr = asin(x)
+    assert tensorflow_code(expr) == "tensorflow.math.asin(x)"
+    _compare_tensorflow_scalar((x,), expr, rng=lambda: random.random())
+
+    expr = tan(x)
+    assert tensorflow_code(expr) == "tensorflow.math.tan(x)"
+    _compare_tensorflow_scalar((x,), expr, rng=lambda: random.random())
+
+    expr = atan(x)
+    assert tensorflow_code(expr) == "tensorflow.math.atan(x)"
+    _compare_tensorflow_scalar((x,), expr, rng=lambda: random.random())
+
+    expr = atan2(y, x)
+    assert tensorflow_code(expr) == "tensorflow.math.atan2(y, x)"
+    _compare_tensorflow_scalar((y, x), expr, rng=lambda: random.random())
+
+    expr = cosh(x)
+    assert tensorflow_code(expr) == "tensorflow.math.cosh(x)"
+    _compare_tensorflow_scalar((x,), expr, rng=lambda: random.random())
+
+    expr = acosh(x)
+    assert tensorflow_code(expr) == "tensorflow.math.acosh(x)"
+    _compare_tensorflow_scalar((x,), expr, rng=lambda: random.uniform(1, 2))
+
+    expr = sinh(x)
+    assert tensorflow_code(expr) == "tensorflow.math.sinh(x)"
+    _compare_tensorflow_scalar((x,), expr, rng=lambda: random.uniform(1, 2))
+
+    expr = asinh(x)
+    assert tensorflow_code(expr) == "tensorflow.math.asinh(x)"
+    _compare_tensorflow_scalar((x,), expr, rng=lambda: random.uniform(1, 2))
+
+    expr = tanh(x)
+    assert tensorflow_code(expr) == "tensorflow.math.tanh(x)"
+    _compare_tensorflow_scalar((x,), expr, rng=lambda: random.uniform(1, 2))
+
+    expr = atanh(x)
+    assert tensorflow_code(expr) == "tensorflow.math.atanh(x)"
+    _compare_tensorflow_scalar(
+        (x,), expr, rng=lambda: random.uniform(-.5, .5))
+
+    expr = erf(x)
+    assert tensorflow_code(expr) == "tensorflow.math.erf(x)"
+    _compare_tensorflow_scalar(
+        (x,), expr, rng=lambda: random.random())
+
+    expr = loggamma(x)
+    assert tensorflow_code(expr) == "tensorflow.math.lgamma(x)"
+    _compare_tensorflow_scalar(
+        (x,), expr, rng=lambda: random.random())
+
+
+def test_tensorflow_complexes():
+    assert tensorflow_code(re(x)) == "tensorflow.math.real(x)"
+    assert tensorflow_code(im(x)) == "tensorflow.math.imag(x)"
+    assert tensorflow_code(arg(x)) == "tensorflow.math.angle(x)"
+
+
+def test_tensorflow_relational():
+    if not tf:
+        skip("TensorFlow not installed")
+
+    expr = Eq(x, y)
+    assert tensorflow_code(expr) == "tensorflow.math.equal(x, y)"
+    _compare_tensorflow_relational((x, y), expr)
+
+    expr = Ne(x, y)
+    assert tensorflow_code(expr) == "tensorflow.math.not_equal(x, y)"
+    _compare_tensorflow_relational((x, y), expr)
+
+    expr = Ge(x, y)
+    assert tensorflow_code(expr) == "tensorflow.math.greater_equal(x, y)"
+    _compare_tensorflow_relational((x, y), expr)
+
+    expr = Gt(x, y)
+    assert tensorflow_code(expr) == "tensorflow.math.greater(x, y)"
+    _compare_tensorflow_relational((x, y), expr)
+
+    expr = Le(x, y)
+    assert tensorflow_code(expr) == "tensorflow.math.less_equal(x, y)"
+    _compare_tensorflow_relational((x, y), expr)
+
+    expr = Lt(x, y)
+    assert tensorflow_code(expr) == "tensorflow.math.less(x, y)"
+    _compare_tensorflow_relational((x, y), expr)
+
+
+# This (random) test is XFAIL because it fails occasionally
+# See https://github.com/sympy/sympy/issues/18469
+@XFAIL
+def test_tensorflow_matrices():
+    if not tf:
+        skip("TensorFlow not installed")
+
+    expr = M
+    assert tensorflow_code(expr) == "M"
+    _compare_tensorflow_matrix((M,), expr)
+
+    expr = M + N
+    assert tensorflow_code(expr) == "tensorflow.math.add(M, N)"
+    _compare_tensorflow_matrix((M, N), expr)
+
+    expr = M * N
+    assert tensorflow_code(expr) == "tensorflow.linalg.matmul(M, N)"
+    _compare_tensorflow_matrix((M, N), expr)
+
+    expr = HadamardProduct(M, N)
+    assert tensorflow_code(expr) == "tensorflow.math.multiply(M, N)"
+    _compare_tensorflow_matrix((M, N), expr)
+
+    expr = M*N*P*Q
+    assert tensorflow_code(expr) == \
+        "tensorflow.linalg.matmul(" \
+            "tensorflow.linalg.matmul(" \
+                "tensorflow.linalg.matmul(M, N), P), Q)"
+    _compare_tensorflow_matrix((M, N, P, Q), expr)
+
+    expr = M**3
+    assert tensorflow_code(expr) == \
+        "tensorflow.linalg.matmul(tensorflow.linalg.matmul(M, M), M)"
+    _compare_tensorflow_matrix((M,), expr)
+
+    expr = Trace(M)
+    assert tensorflow_code(expr) == "tensorflow.linalg.trace(M)"
+    _compare_tensorflow_matrix((M,), expr)
+
+    expr = Determinant(M)
+    assert tensorflow_code(expr) == "tensorflow.linalg.det(M)"
+    _compare_tensorflow_matrix_scalar((M,), expr)
+
+    expr = Inverse(M)
+    assert tensorflow_code(expr) == "tensorflow.linalg.inv(M)"
+    _compare_tensorflow_matrix_inverse((M,), expr, use_float=True)
+
+    expr = M.T
+    assert tensorflow_code(expr, tensorflow_version='1.14') == \
+        "tensorflow.linalg.matrix_transpose(M)"
+    assert tensorflow_code(expr, tensorflow_version='1.13') == \
+        "tensorflow.matrix_transpose(M)"
+
+    _compare_tensorflow_matrix((M,), expr)
+
+
+def test_codegen_einsum():
+    if not tf:
+        skip("TensorFlow not installed")
+
+    graph = tf.Graph()
+    with graph.as_default():
+        session = tf.compat.v1.Session(graph=graph)
+
+        M = MatrixSymbol("M", 2, 2)
+        N = MatrixSymbol("N", 2, 2)
+
+        cg = convert_matrix_to_array(M * N)
+        f = lambdify((M, N), cg, 'tensorflow')
+
+        ma = tf.constant([[1, 2], [3, 4]])
+        mb = tf.constant([[1,-2], [-1, 3]])
+        y = session.run(f(ma, mb))
+        c = session.run(tf.matmul(ma, mb))
+        assert (y == c).all()
+
+
+def test_codegen_extra():
+    if not tf:
+        skip("TensorFlow not installed")
+
+    graph = tf.Graph()
+    with graph.as_default():
+        session = tf.compat.v1.Session()
+
+        M = MatrixSymbol("M", 2, 2)
+        N = MatrixSymbol("N", 2, 2)
+        P = MatrixSymbol("P", 2, 2)
+        Q = MatrixSymbol("Q", 2, 2)
+        ma = tf.constant([[1, 2], [3, 4]])
+        mb = tf.constant([[1,-2], [-1, 3]])
+        mc = tf.constant([[2, 0], [1, 2]])
+        md = tf.constant([[1,-1], [4, 7]])
+
+        cg = ArrayTensorProduct(M, N)
+        assert tensorflow_code(cg) == \
+            'tensorflow.linalg.einsum("ab,cd", M, N)'
+        f = lambdify((M, N), cg, 'tensorflow')
+        y = session.run(f(ma, mb))
+        c = session.run(tf.einsum("ij,kl", ma, mb))
+        assert (y == c).all()
+
+        cg = ArrayAdd(M, N)
+        assert tensorflow_code(cg) == 'tensorflow.math.add(M, N)'
+        f = lambdify((M, N), cg, 'tensorflow')
+        y = session.run(f(ma, mb))
+        c = session.run(ma + mb)
+        assert (y == c).all()
+
+        cg = ArrayAdd(M, N, P)
+        assert tensorflow_code(cg) == \
+            'tensorflow.math.add(tensorflow.math.add(M, N), P)'
+        f = lambdify((M, N, P), cg, 'tensorflow')
+        y = session.run(f(ma, mb, mc))
+        c = session.run(ma + mb + mc)
+        assert (y == c).all()
+
+        cg = ArrayAdd(M, N, P, Q)
+        assert tensorflow_code(cg) == \
+            'tensorflow.math.add(' \
+                'tensorflow.math.add(tensorflow.math.add(M, N), P), Q)'
+        f = lambdify((M, N, P, Q), cg, 'tensorflow')
+        y = session.run(f(ma, mb, mc, md))
+        c = session.run(ma + mb + mc + md)
+        assert (y == c).all()
+
+        cg = PermuteDims(M, [1, 0])
+        assert tensorflow_code(cg) == 'tensorflow.transpose(M, [1, 0])'
+        f = lambdify((M,), cg, 'tensorflow')
+        y = session.run(f(ma))
+        c = session.run(tf.transpose(ma))
+        assert (y == c).all()
+
+        cg = PermuteDims(ArrayTensorProduct(M, N), [1, 2, 3, 0])
+        assert tensorflow_code(cg) == \
+            'tensorflow.transpose(' \
+                'tensorflow.linalg.einsum("ab,cd", M, N), [1, 2, 3, 0])'
+        f = lambdify((M, N), cg, 'tensorflow')
+        y = session.run(f(ma, mb))
+        c = session.run(tf.transpose(tf.einsum("ab,cd", ma, mb), [1, 2, 3, 0]))
+        assert (y == c).all()
+
+        cg = ArrayDiagonal(ArrayTensorProduct(M, N), (1, 2))
+        assert tensorflow_code(cg) == \
+            'tensorflow.linalg.einsum("ab,bc->acb", M, N)'
+        f = lambdify((M, N), cg, 'tensorflow')
+        y = session.run(f(ma, mb))
+        c = session.run(tf.einsum("ab,bc->acb", ma, mb))
+        assert (y == c).all()
+
+
+def test_MatrixElement_printing():
+    A = MatrixSymbol("A", 1, 3)
+    B = MatrixSymbol("B", 1, 3)
+    C = MatrixSymbol("C", 1, 3)
+
+    assert tensorflow_code(A[0, 0]) == "A[0, 0]"
+    assert tensorflow_code(3 * A[0, 0]) == "3*A[0, 0]"
+
+    F = C[0, 0].subs(C, A - B)
+    assert tensorflow_code(F) == "(tensorflow.math.add((-1)*B, A))[0, 0]"
+
+
+def test_tensorflow_Derivative():
+    expr = Derivative(sin(x), x)
+    assert tensorflow_code(expr) == \
+        "tensorflow.gradients(tensorflow.math.sin(x), x)[0]"
+
+def test_tensorflow_isnan_isinf():
+    if not tf:
+        skip("TensorFlow not installed")
+
+    # Test for isnan
+    x = symbols("x")
+    # Return 0 if x is of nan value, and 1 otherwise
+    expression = Piecewise((0.0, isnan(x)), (1.0, True))
+    printed_code = tensorflow_code(expression)
+    expected_printed_code = "tensorflow.where(tensorflow.math.is_nan(x), 0.0, 1.0)"
+    assert tensorflow_code(expression) == expected_printed_code, f"Incorrect printed result {printed_code}, expected {expected_printed_code}"
+    for _input, _expected in [(float('nan'), 0.0), (float('inf'), 1.0), (float('-inf'), 1.0), (1.0, 1.0)]:
+        _output = lambdify((x), expression, modules="tensorflow")(x=tf.constant([_input]))
+        assert (_output == _expected).numpy().all()
+
+    # Test for isinf
+    x = symbols("x")
+    # Return 0 if x is of nan value, and 1 otherwise
+    expression = Piecewise((0.0, isinf(x)), (1.0, True))
+    printed_code = tensorflow_code(expression)
+    expected_printed_code = "tensorflow.where(tensorflow.math.is_inf(x), 0.0, 1.0)"
+    assert tensorflow_code(expression) == expected_printed_code, f"Incorrect printed result {printed_code}, expected {expected_printed_code}"
+    for _input, _expected in [(float('inf'), 0.0), (float('-inf'), 0.0), (float('nan'), 1.0), (1.0, 1.0)]:
+        _output = lambdify((x), expression, modules="tensorflow")(x=tf.constant([_input]))
+        assert (_output == _expected).numpy().all()
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/test_theanocode.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/test_theanocode.py
new file mode 100644
index 0000000000000000000000000000000000000000..6ff40f78cb4de16149cb5e780756b7e32b574b71
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/test_theanocode.py
@@ -0,0 +1,639 @@
+"""
+Important note on tests in this module - the Theano printing functions use a
+global cache by default, which means that tests using it will modify global
+state and thus not be independent from each other. Instead of using the "cache"
+keyword argument each time, this module uses the theano_code_ and
+theano_function_ functions defined below which default to using a new, empty
+cache instead.
+"""
+
+import logging
+
+from sympy.external import import_module
+from sympy.testing.pytest import raises, SKIP, warns_deprecated_sympy
+
+theanologger = logging.getLogger('theano.configdefaults')
+theanologger.setLevel(logging.CRITICAL)
+theano = import_module('theano')
+theanologger.setLevel(logging.WARNING)
+
+
+if theano:
+    import numpy as np
+    ts = theano.scalar
+    tt = theano.tensor
+    xt, yt, zt = [tt.scalar(name, 'floatX') for name in 'xyz']
+    Xt, Yt, Zt = [tt.tensor('floatX', (False, False), name=n) for n in 'XYZ']
+else:
+    #bin/test will not execute any tests now
+    disabled = True
+
+import sympy as sy
+from sympy.core.singleton import S
+from sympy.abc import x, y, z, t
+from sympy.printing.theanocode import (theano_code, dim_handling,
+        theano_function)
+
+
+# Default set of matrix symbols for testing - make square so we can both
+# multiply and perform elementwise operations between them.
+X, Y, Z = [sy.MatrixSymbol(n, 4, 4) for n in 'XYZ']
+
+# For testing AppliedUndef
+f_t = sy.Function('f')(t)
+
+
+def theano_code_(expr, **kwargs):
+    """ Wrapper for theano_code that uses a new, empty cache by default. """
+    kwargs.setdefault('cache', {})
+    with warns_deprecated_sympy():
+        return theano_code(expr, **kwargs)
+
+def theano_function_(inputs, outputs, **kwargs):
+    """ Wrapper for theano_function that uses a new, empty cache by default. """
+    kwargs.setdefault('cache', {})
+    with warns_deprecated_sympy():
+        return theano_function(inputs, outputs, **kwargs)
+
+
+def fgraph_of(*exprs):
+    """ Transform SymPy expressions into Theano Computation.
+
+    Parameters
+    ==========
+    exprs
+        SymPy expressions
+
+    Returns
+    =======
+    theano.gof.FunctionGraph
+    """
+    outs = list(map(theano_code_, exprs))
+    ins = theano.gof.graph.inputs(outs)
+    ins, outs = theano.gof.graph.clone(ins, outs)
+    return theano.gof.FunctionGraph(ins, outs)
+
+
+def theano_simplify(fgraph):
+    """ Simplify a Theano Computation.
+
+    Parameters
+    ==========
+    fgraph : theano.gof.FunctionGraph
+
+    Returns
+    =======
+    theano.gof.FunctionGraph
+    """
+    mode = theano.compile.get_default_mode().excluding("fusion")
+    fgraph = fgraph.clone()
+    mode.optimizer.optimize(fgraph)
+    return fgraph
+
+
+def theq(a, b):
+    """ Test two Theano objects for equality.
+
+    Also accepts numeric types and lists/tuples of supported types.
+
+    Note - debugprint() has a bug where it will accept numeric types but does
+    not respect the "file" argument and in this case and instead prints the number
+    to stdout and returns an empty string. This can lead to tests passing where
+    they should fail because any two numbers will always compare as equal. To
+    prevent this we treat numbers as a separate case.
+    """
+    numeric_types = (int, float, np.number)
+    a_is_num = isinstance(a, numeric_types)
+    b_is_num = isinstance(b, numeric_types)
+
+    # Compare numeric types using regular equality
+    if a_is_num or b_is_num:
+        if not (a_is_num and b_is_num):
+            return False
+
+        return a == b
+
+    # Compare sequences element-wise
+    a_is_seq = isinstance(a, (tuple, list))
+    b_is_seq = isinstance(b, (tuple, list))
+
+    if a_is_seq or b_is_seq:
+        if not (a_is_seq and b_is_seq) or type(a) != type(b):
+            return False
+
+        return list(map(theq, a)) == list(map(theq, b))
+
+    # Otherwise, assume debugprint() can handle it
+    astr = theano.printing.debugprint(a, file='str')
+    bstr = theano.printing.debugprint(b, file='str')
+
+    # Check for bug mentioned above
+    for argname, argval, argstr in [('a', a, astr), ('b', b, bstr)]:
+        if argstr == '':
+            raise TypeError(
+                'theano.printing.debugprint(%s) returned empty string '
+                '(%s is instance of %r)'
+                % (argname, argname, type(argval))
+            )
+
+    return astr == bstr
+
+
+def test_example_symbols():
+    """
+    Check that the example symbols in this module print to their Theano
+    equivalents, as many of the other tests depend on this.
+    """
+    assert theq(xt, theano_code_(x))
+    assert theq(yt, theano_code_(y))
+    assert theq(zt, theano_code_(z))
+    assert theq(Xt, theano_code_(X))
+    assert theq(Yt, theano_code_(Y))
+    assert theq(Zt, theano_code_(Z))
+
+
+def test_Symbol():
+    """ Test printing a Symbol to a theano variable. """
+    xx = theano_code_(x)
+    assert isinstance(xx, (tt.TensorVariable, ts.ScalarVariable))
+    assert xx.broadcastable == ()
+    assert xx.name == x.name
+
+    xx2 = theano_code_(x, broadcastables={x: (False,)})
+    assert xx2.broadcastable == (False,)
+    assert xx2.name == x.name
+
+def test_MatrixSymbol():
+    """ Test printing a MatrixSymbol to a theano variable. """
+    XX = theano_code_(X)
+    assert isinstance(XX, tt.TensorVariable)
+    assert XX.broadcastable == (False, False)
+
+@SKIP  # TODO - this is currently not checked but should be implemented
+def test_MatrixSymbol_wrong_dims():
+    """ Test MatrixSymbol with invalid broadcastable. """
+    bcs = [(), (False,), (True,), (True, False), (False, True,), (True, True)]
+    for bc in bcs:
+        with raises(ValueError):
+            theano_code_(X, broadcastables={X: bc})
+
+def test_AppliedUndef():
+    """ Test printing AppliedUndef instance, which works similarly to Symbol. """
+    ftt = theano_code_(f_t)
+    assert isinstance(ftt, tt.TensorVariable)
+    assert ftt.broadcastable == ()
+    assert ftt.name == 'f_t'
+
+
+def test_add():
+    expr = x + y
+    comp = theano_code_(expr)
+    assert comp.owner.op == theano.tensor.add
+
+def test_trig():
+    assert theq(theano_code_(sy.sin(x)), tt.sin(xt))
+    assert theq(theano_code_(sy.tan(x)), tt.tan(xt))
+
+def test_many():
+    """ Test printing a complex expression with multiple symbols. """
+    expr = sy.exp(x**2 + sy.cos(y)) * sy.log(2*z)
+    comp = theano_code_(expr)
+    expected = tt.exp(xt**2 + tt.cos(yt)) * tt.log(2*zt)
+    assert theq(comp, expected)
+
+
+def test_dtype():
+    """ Test specifying specific data types through the dtype argument. """
+    for dtype in ['float32', 'float64', 'int8', 'int16', 'int32', 'int64']:
+        assert theano_code_(x, dtypes={x: dtype}).type.dtype == dtype
+
+    # "floatX" type
+    assert theano_code_(x, dtypes={x: 'floatX'}).type.dtype in ('float32', 'float64')
+
+    # Type promotion
+    assert theano_code_(x + 1, dtypes={x: 'float32'}).type.dtype == 'float32'
+    assert theano_code_(x + y, dtypes={x: 'float64', y: 'float32'}).type.dtype == 'float64'
+
+
+def test_broadcastables():
+    """ Test the "broadcastables" argument when printing symbol-like objects. """
+
+    # No restrictions on shape
+    for s in [x, f_t]:
+        for bc in [(), (False,), (True,), (False, False), (True, False)]:
+            assert theano_code_(s, broadcastables={s: bc}).broadcastable == bc
+
+    # TODO - matrix broadcasting?
+
+def test_broadcasting():
+    """ Test "broadcastable" attribute after applying element-wise binary op. """
+
+    expr = x + y
+
+    cases = [
+        [(), (), ()],
+        [(False,), (False,), (False,)],
+        [(True,), (False,), (False,)],
+        [(False, True), (False, False), (False, False)],
+        [(True, False), (False, False), (False, False)],
+    ]
+
+    for bc1, bc2, bc3 in cases:
+        comp = theano_code_(expr, broadcastables={x: bc1, y: bc2})
+        assert comp.broadcastable == bc3
+
+
+def test_MatMul():
+    expr = X*Y*Z
+    expr_t = theano_code_(expr)
+    assert isinstance(expr_t.owner.op, tt.Dot)
+    assert theq(expr_t, Xt.dot(Yt).dot(Zt))
+
+def test_Transpose():
+    assert isinstance(theano_code_(X.T).owner.op, tt.DimShuffle)
+
+def test_MatAdd():
+    expr = X+Y+Z
+    assert isinstance(theano_code_(expr).owner.op, tt.Elemwise)
+
+
+def test_Rationals():
+    assert theq(theano_code_(sy.Integer(2) / 3), tt.true_div(2, 3))
+    assert theq(theano_code_(S.Half), tt.true_div(1, 2))
+
+def test_Integers():
+    assert theano_code_(sy.Integer(3)) == 3
+
+def test_factorial():
+    n = sy.Symbol('n')
+    assert theano_code_(sy.factorial(n))
+
+def test_Derivative():
+    simp = lambda expr: theano_simplify(fgraph_of(expr))
+    assert theq(simp(theano_code_(sy.Derivative(sy.sin(x), x, evaluate=False))),
+                simp(theano.grad(tt.sin(xt), xt)))
+
+
+def test_theano_function_simple():
+    """ Test theano_function() with single output. """
+    f = theano_function_([x, y], [x+y])
+    assert f(2, 3) == 5
+
+def test_theano_function_multi():
+    """ Test theano_function() with multiple outputs. """
+    f = theano_function_([x, y], [x+y, x-y])
+    o1, o2 = f(2, 3)
+    assert o1 == 5
+    assert o2 == -1
+
+def test_theano_function_numpy():
+    """ Test theano_function() vs Numpy implementation. """
+    f = theano_function_([x, y], [x+y], dim=1,
+                         dtypes={x: 'float64', y: 'float64'})
+    assert np.linalg.norm(f([1, 2], [3, 4]) - np.asarray([4, 6])) < 1e-9
+
+    f = theano_function_([x, y], [x+y], dtypes={x: 'float64', y: 'float64'},
+                         dim=1)
+    xx = np.arange(3).astype('float64')
+    yy = 2*np.arange(3).astype('float64')
+    assert np.linalg.norm(f(xx, yy) - 3*np.arange(3)) < 1e-9
+
+
+def test_theano_function_matrix():
+    m = sy.Matrix([[x, y], [z, x + y + z]])
+    expected = np.array([[1.0, 2.0], [3.0, 1.0 + 2.0 + 3.0]])
+    f = theano_function_([x, y, z], [m])
+    np.testing.assert_allclose(f(1.0, 2.0, 3.0), expected)
+    f = theano_function_([x, y, z], [m], scalar=True)
+    np.testing.assert_allclose(f(1.0, 2.0, 3.0), expected)
+    f = theano_function_([x, y, z], [m, m])
+    assert isinstance(f(1.0, 2.0, 3.0), type([]))
+    np.testing.assert_allclose(f(1.0, 2.0, 3.0)[0], expected)
+    np.testing.assert_allclose(f(1.0, 2.0, 3.0)[1], expected)
+
+def test_dim_handling():
+    assert dim_handling([x], dim=2) == {x: (False, False)}
+    assert dim_handling([x, y], dims={x: 1, y: 2}) == {x: (False, True),
+                                                       y: (False, False)}
+    assert dim_handling([x], broadcastables={x: (False,)}) == {x: (False,)}
+
+def test_theano_function_kwargs():
+    """
+    Test passing additional kwargs from theano_function() to theano.function().
+    """
+    import numpy as np
+    f = theano_function_([x, y, z], [x+y], dim=1, on_unused_input='ignore',
+            dtypes={x: 'float64', y: 'float64', z: 'float64'})
+    assert np.linalg.norm(f([1, 2], [3, 4], [0, 0]) - np.asarray([4, 6])) < 1e-9
+
+    f = theano_function_([x, y, z], [x+y],
+                        dtypes={x: 'float64', y: 'float64', z: 'float64'},
+                        dim=1, on_unused_input='ignore')
+    xx = np.arange(3).astype('float64')
+    yy = 2*np.arange(3).astype('float64')
+    zz = 2*np.arange(3).astype('float64')
+    assert np.linalg.norm(f(xx, yy, zz) - 3*np.arange(3)) < 1e-9
+
+def test_theano_function_scalar():
+    """ Test the "scalar" argument to theano_function(). """
+
+    args = [
+        ([x, y], [x + y], None, [0]),  # Single 0d output
+        ([X, Y], [X + Y], None, [2]),  # Single 2d output
+        ([x, y], [x + y], {x: 0, y: 1}, [1]),  # Single 1d output
+        ([x, y], [x + y, x - y], None, [0, 0]),  # Two 0d outputs
+        ([x, y, X, Y], [x + y, X + Y], None, [0, 2]),  # One 0d output, one 2d
+    ]
+
+    # Create and test functions with and without the scalar setting
+    for inputs, outputs, in_dims, out_dims in args:
+        for scalar in [False, True]:
+
+            f = theano_function_(inputs, outputs, dims=in_dims, scalar=scalar)
+
+            # Check the theano_function attribute is set whether wrapped or not
+            assert isinstance(f.theano_function, theano.compile.function_module.Function)
+
+            # Feed in inputs of the appropriate size and get outputs
+            in_values = [
+                np.ones([1 if bc else 5 for bc in i.type.broadcastable])
+                for i in f.theano_function.input_storage
+            ]
+            out_values = f(*in_values)
+            if not isinstance(out_values, list):
+                out_values = [out_values]
+
+            # Check output types and shapes
+            assert len(out_dims) == len(out_values)
+            for d, value in zip(out_dims, out_values):
+
+                if scalar and d == 0:
+                    # Should have been converted to a scalar value
+                    assert isinstance(value, np.number)
+
+                else:
+                    # Otherwise should be an array
+                    assert isinstance(value, np.ndarray)
+                    assert value.ndim == d
+
+def test_theano_function_bad_kwarg():
+    """
+    Passing an unknown keyword argument to theano_function() should raise an
+    exception.
+    """
+    raises(Exception, lambda : theano_function_([x], [x+1], foobar=3))
+
+
+def test_slice():
+    assert theano_code_(slice(1, 2, 3)) == slice(1, 2, 3)
+
+    def theq_slice(s1, s2):
+        for attr in ['start', 'stop', 'step']:
+            a1 = getattr(s1, attr)
+            a2 = getattr(s2, attr)
+            if a1 is None or a2 is None:
+                if not (a1 is None or a2 is None):
+                    return False
+            elif not theq(a1, a2):
+                return False
+        return True
+
+    dtypes = {x: 'int32', y: 'int32'}
+    assert theq_slice(theano_code_(slice(x, y), dtypes=dtypes), slice(xt, yt))
+    assert theq_slice(theano_code_(slice(1, x, 3), dtypes=dtypes), slice(1, xt, 3))
+
+def test_MatrixSlice():
+    from theano import Constant
+
+    cache = {}
+
+    n = sy.Symbol('n', integer=True)
+    X = sy.MatrixSymbol('X', n, n)
+
+    Y = X[1:2:3, 4:5:6]
+    Yt = theano_code_(Y, cache=cache)
+
+    s = ts.Scalar('int64')
+    assert tuple(Yt.owner.op.idx_list) == (slice(s, s, s), slice(s, s, s))
+    assert Yt.owner.inputs[0] == theano_code_(X, cache=cache)
+    # == doesn't work in theano like it does in SymPy. You have to use
+    # equals.
+    assert all(Yt.owner.inputs[i].equals(Constant(s, i)) for i in range(1, 7))
+
+    k = sy.Symbol('k')
+    theano_code_(k, dtypes={k: 'int32'})
+    start, stop, step = 4, k, 2
+    Y = X[start:stop:step]
+    Yt = theano_code_(Y, dtypes={n: 'int32', k: 'int32'})
+    # assert Yt.owner.op.idx_list[0].stop == kt
+
+def test_BlockMatrix():
+    n = sy.Symbol('n', integer=True)
+    A, B, C, D = [sy.MatrixSymbol(name, n, n) for name in 'ABCD']
+    At, Bt, Ct, Dt = map(theano_code_, (A, B, C, D))
+    Block = sy.BlockMatrix([[A, B], [C, D]])
+    Blockt = theano_code_(Block)
+    solutions = [tt.join(0, tt.join(1, At, Bt), tt.join(1, Ct, Dt)),
+                 tt.join(1, tt.join(0, At, Ct), tt.join(0, Bt, Dt))]
+    assert any(theq(Blockt, solution) for solution in solutions)
+
+@SKIP
+def test_BlockMatrix_Inverse_execution():
+    k, n = 2, 4
+    dtype = 'float32'
+    A = sy.MatrixSymbol('A', n, k)
+    B = sy.MatrixSymbol('B', n, n)
+    inputs = A, B
+    output = B.I*A
+
+    cutsizes = {A: [(n//2, n//2), (k//2, k//2)],
+                B: [(n//2, n//2), (n//2, n//2)]}
+    cutinputs = [sy.blockcut(i, *cutsizes[i]) for i in inputs]
+    cutoutput = output.subs(dict(zip(inputs, cutinputs)))
+
+    dtypes = dict(zip(inputs, [dtype]*len(inputs)))
+    f = theano_function_(inputs, [output], dtypes=dtypes, cache={})
+    fblocked = theano_function_(inputs, [sy.block_collapse(cutoutput)],
+                                dtypes=dtypes, cache={})
+
+    ninputs = [np.random.rand(*x.shape).astype(dtype) for x in inputs]
+    ninputs = [np.arange(n*k).reshape(A.shape).astype(dtype),
+               np.eye(n).astype(dtype)]
+    ninputs[1] += np.ones(B.shape)*1e-5
+
+    assert np.allclose(f(*ninputs), fblocked(*ninputs), rtol=1e-5)
+
+def test_DenseMatrix():
+    t = sy.Symbol('theta')
+    for MatrixType in [sy.Matrix, sy.ImmutableMatrix]:
+        X = MatrixType([[sy.cos(t), -sy.sin(t)], [sy.sin(t), sy.cos(t)]])
+        tX = theano_code_(X)
+        assert isinstance(tX, tt.TensorVariable)
+        assert tX.owner.op == tt.join_
+
+
+def test_cache_basic():
+    """ Test single symbol-like objects are cached when printed by themselves. """
+
+    # Pairs of objects which should be considered equivalent with respect to caching
+    pairs = [
+        (x, sy.Symbol('x')),
+        (X, sy.MatrixSymbol('X', *X.shape)),
+        (f_t, sy.Function('f')(sy.Symbol('t'))),
+    ]
+
+    for s1, s2 in pairs:
+        cache = {}
+        st = theano_code_(s1, cache=cache)
+
+        # Test hit with same instance
+        assert theano_code_(s1, cache=cache) is st
+
+        # Test miss with same instance but new cache
+        assert theano_code_(s1, cache={}) is not st
+
+        # Test hit with different but equivalent instance
+        assert theano_code_(s2, cache=cache) is st
+
+def test_global_cache():
+    """ Test use of the global cache. """
+    from sympy.printing.theanocode import global_cache
+
+    backup = dict(global_cache)
+    try:
+        # Temporarily empty global cache
+        global_cache.clear()
+
+        for s in [x, X, f_t]:
+            with warns_deprecated_sympy():
+                st = theano_code(s)
+                assert theano_code(s) is st
+
+    finally:
+        # Restore global cache
+        global_cache.update(backup)
+
+def test_cache_types_distinct():
+    """
+    Test that symbol-like objects of different types (Symbol, MatrixSymbol,
+    AppliedUndef) are distinguished by the cache even if they have the same
+    name.
+    """
+    symbols = [sy.Symbol('f_t'), sy.MatrixSymbol('f_t', 4, 4), f_t]
+
+    cache = {}  # Single shared cache
+    printed = {}
+
+    for s in symbols:
+        st = theano_code_(s, cache=cache)
+        assert st not in printed.values()
+        printed[s] = st
+
+    # Check all printed objects are distinct
+    assert len(set(map(id, printed.values()))) == len(symbols)
+
+    # Check retrieving
+    for s, st in printed.items():
+        with warns_deprecated_sympy():
+            assert theano_code(s, cache=cache) is st
+
+def test_symbols_are_created_once():
+    """
+    Test that a symbol is cached and reused when it appears in an expression
+    more than once.
+    """
+    expr = sy.Add(x, x, evaluate=False)
+    comp = theano_code_(expr)
+
+    assert theq(comp, xt + xt)
+    assert not theq(comp, xt + theano_code_(x))
+
+def test_cache_complex():
+    """
+    Test caching on a complicated expression with multiple symbols appearing
+    multiple times.
+    """
+    expr = x ** 2 + (y - sy.exp(x)) * sy.sin(z - x * y)
+    symbol_names = {s.name for s in expr.free_symbols}
+    expr_t = theano_code_(expr)
+
+    # Iterate through variables in the Theano computational graph that the
+    # printed expression depends on
+    seen = set()
+    for v in theano.gof.graph.ancestors([expr_t]):
+        # Owner-less, non-constant variables should be our symbols
+        if v.owner is None and not isinstance(v, theano.gof.graph.Constant):
+            # Check it corresponds to a symbol and appears only once
+            assert v.name in symbol_names
+            assert v.name not in seen
+            seen.add(v.name)
+
+    # Check all were present
+    assert seen == symbol_names
+
+
+def test_Piecewise():
+    # A piecewise linear
+    expr = sy.Piecewise((0, x<0), (x, x<2), (1, True))  # ___/III
+    result = theano_code_(expr)
+    assert result.owner.op == tt.switch
+
+    expected = tt.switch(xt<0, 0, tt.switch(xt<2, xt, 1))
+    assert theq(result, expected)
+
+    expr = sy.Piecewise((x, x < 0))
+    result = theano_code_(expr)
+    expected = tt.switch(xt < 0, xt, np.nan)
+    assert theq(result, expected)
+
+    expr = sy.Piecewise((0, sy.And(x>0, x<2)), \
+        (x, sy.Or(x>2, x<0)))
+    result = theano_code_(expr)
+    expected = tt.switch(tt.and_(xt>0,xt<2), 0, \
+        tt.switch(tt.or_(xt>2, xt<0), xt, np.nan))
+    assert theq(result, expected)
+
+
+def test_Relationals():
+    assert theq(theano_code_(sy.Eq(x, y)), tt.eq(xt, yt))
+    # assert theq(theano_code_(sy.Ne(x, y)), tt.neq(xt, yt))  # TODO - implement
+    assert theq(theano_code_(x > y), xt > yt)
+    assert theq(theano_code_(x < y), xt < yt)
+    assert theq(theano_code_(x >= y), xt >= yt)
+    assert theq(theano_code_(x <= y), xt <= yt)
+
+
+def test_complexfunctions():
+    with warns_deprecated_sympy():
+        xt, yt = theano_code_(x, dtypes={x:'complex128'}), theano_code_(y, dtypes={y: 'complex128'})
+    from sympy.functions.elementary.complexes import conjugate
+    from theano.tensor import as_tensor_variable as atv
+    from theano.tensor import complex as cplx
+    with warns_deprecated_sympy():
+        assert theq(theano_code_(y*conjugate(x)), yt*(xt.conj()))
+        assert theq(theano_code_((1+2j)*x), xt*(atv(1.0)+atv(2.0)*cplx(0,1)))
+
+
+def test_constantfunctions():
+    with warns_deprecated_sympy():
+        tf = theano_function_([],[1+1j])
+    assert(tf()==1+1j)
+
+
+def test_Exp1():
+    """
+    Test that exp(1) prints without error and evaluates close to SymPy's E
+    """
+    # sy.exp(1) should yield same instance of E as sy.E (singleton), but extra
+    # check added for sanity
+    e_a = sy.exp(1)
+    e_b = sy.E
+
+    np.testing.assert_allclose(float(e_a), np.e)
+    np.testing.assert_allclose(float(e_b), np.e)
+
+    e = theano_code_(e_a)
+    np.testing.assert_allclose(float(e_a), e.eval())
+
+    e = theano_code_(e_b)
+    np.testing.assert_allclose(float(e_b), e.eval())
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/test_torch.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/test_torch.py
new file mode 100644
index 0000000000000000000000000000000000000000..8ce2c6cec75e03264f93b472a79eb073742e3486
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/test_torch.py
@@ -0,0 +1,531 @@
+import random
+import math
+
+from sympy import symbols, Derivative
+from sympy.printing.pytorch import torch_code
+from sympy import (eye, MatrixSymbol, Matrix)
+from sympy.tensor.array import NDimArray
+from sympy.tensor.array.expressions.array_expressions import (
+    ArrayTensorProduct, ArrayAdd,
+    PermuteDims, ArrayDiagonal, _CodegenArrayAbstract)
+from sympy.utilities.lambdify import lambdify
+from sympy.core.relational import Eq, Ne, Ge, Gt, Le, Lt
+from sympy.functions import \
+    Abs, ceiling, exp, floor, sign, sin, asin, cos, \
+    acos, tan, atan, atan2, cosh, acosh, sinh, asinh, tanh, atanh, \
+    re, im, arg, erf, loggamma, sqrt
+from sympy.testing.pytest import skip
+from sympy.external import import_module
+from sympy.matrices.expressions import \
+    Determinant, HadamardProduct, Inverse, Trace
+from sympy.matrices import randMatrix
+from sympy.matrices import Identity, ZeroMatrix, OneMatrix
+from sympy import conjugate, I
+from sympy import Heaviside, gamma, polygamma
+
+
+
+torch = import_module("torch")
+
+M = MatrixSymbol("M", 3, 3)
+N = MatrixSymbol("N", 3, 3)
+P = MatrixSymbol("P", 3, 3)
+Q = MatrixSymbol("Q", 3, 3)
+
+x, y, z, t = symbols("x y z t")
+
+if torch is not None:
+    llo = [list(range(i, i + 3)) for i in range(0, 9, 3)]
+    m3x3 = torch.tensor(llo, dtype=torch.float64)
+    m3x3sympy = Matrix(llo)
+
+
+def _compare_torch_matrix(variables, expr):
+    f = lambdify(variables, expr, 'torch')
+
+    random_matrices = [randMatrix(i.shape[0], i.shape[1]) for i in variables]
+    random_variables = [torch.tensor(i.tolist(), dtype=torch.float64) for i in random_matrices]
+    r = f(*random_variables)
+    e = expr.subs(dict(zip(variables, random_matrices))).doit()
+
+    if isinstance(e, _CodegenArrayAbstract):
+        e = e.doit()
+
+    if hasattr(e, 'is_number') and e.is_number:
+        if isinstance(r, torch.Tensor) and r.dim() == 0:
+            r = r.item()
+            e = float(e)
+            assert abs(r - e) < 1e-6
+            return
+
+    if e.is_Matrix or isinstance(e, NDimArray):
+        e = torch.tensor(e.tolist(), dtype=torch.float64)
+        assert torch.allclose(r, e, atol=1e-6)
+    else:
+        raise TypeError(f"Cannot compare {type(r)} with {type(e)}")
+
+
+def _compare_torch_scalar(variables, expr, rng=lambda: random.uniform(-5, 5)):
+    f = lambdify(variables, expr, 'torch')
+    rvs = [rng() for v in variables]
+    t_rvs = [torch.tensor(i, dtype=torch.float64) for i in rvs]
+    r = f(*t_rvs)
+    if isinstance(r, torch.Tensor):
+        r = r.item()
+    e = expr.subs(dict(zip(variables, rvs))).doit()
+    assert abs(r - e) < 1e-6
+
+
+def _compare_torch_relational(variables, expr, rng=lambda: random.randint(0, 10)):
+    f = lambdify(variables, expr, 'torch')
+    rvs = [rng() for v in variables]
+    t_rvs = [torch.tensor(i, dtype=torch.float64) for i in rvs]
+    r = f(*t_rvs)
+    e = bool(expr.subs(dict(zip(variables, rvs))).doit())
+    assert r.item() == e
+
+
+def test_torch_math():
+    if not torch:
+        skip("PyTorch not installed")
+
+    expr = Abs(x)
+    assert torch_code(expr) == "torch.abs(x)"
+    f = lambdify(x, expr, 'torch')
+    ma = torch.tensor([[-1, 2, -3, -4]], dtype=torch.float64)
+    y_abs = f(ma)
+    c = torch.abs(ma)
+    assert torch.all(y_abs == c)
+
+    expr = sign(x)
+    assert torch_code(expr) == "torch.sign(x)"
+    _compare_torch_scalar((x,), expr, rng=lambda: random.uniform(-10, 10))
+
+    expr = ceiling(x)
+    assert torch_code(expr) == "torch.ceil(x)"
+    _compare_torch_scalar((x,), expr, rng=lambda: random.random())
+
+    expr = floor(x)
+    assert torch_code(expr) == "torch.floor(x)"
+    _compare_torch_scalar((x,), expr, rng=lambda: random.random())
+
+    expr = exp(x)
+    assert torch_code(expr) == "torch.exp(x)"
+    _compare_torch_scalar((x,), expr, rng=lambda: random.uniform(-2, 2))
+
+    expr = sqrt(x)
+    assert torch_code(expr) == "torch.sqrt(x)"
+    _compare_torch_scalar((x,), expr, rng=lambda: random.random())
+
+    expr = x ** 4
+    assert torch_code(expr) == "torch.pow(x, 4)"
+    _compare_torch_scalar((x,), expr, rng=lambda: random.random())
+
+    expr = cos(x)
+    assert torch_code(expr) == "torch.cos(x)"
+    _compare_torch_scalar((x,), expr, rng=lambda: random.random())
+
+    expr = acos(x)
+    assert torch_code(expr) == "torch.acos(x)"
+    _compare_torch_scalar((x,), expr, rng=lambda: random.uniform(-0.99, 0.99))
+
+    expr = sin(x)
+    assert torch_code(expr) == "torch.sin(x)"
+    _compare_torch_scalar((x,), expr, rng=lambda: random.random())
+
+    expr = asin(x)
+    assert torch_code(expr) == "torch.asin(x)"
+    _compare_torch_scalar((x,), expr, rng=lambda: random.uniform(-0.99, 0.99))
+
+    expr = tan(x)
+    assert torch_code(expr) == "torch.tan(x)"
+    _compare_torch_scalar((x,), expr, rng=lambda: random.uniform(-1.5, 1.5))
+
+    expr = atan(x)
+    assert torch_code(expr) == "torch.atan(x)"
+    _compare_torch_scalar((x,), expr, rng=lambda: random.uniform(-5, 5))
+
+    expr = atan2(y, x)
+    assert torch_code(expr) == "torch.atan2(y, x)"
+    _compare_torch_scalar((y, x), expr, rng=lambda: random.uniform(-5, 5))
+
+    expr = cosh(x)
+    assert torch_code(expr) == "torch.cosh(x)"
+    _compare_torch_scalar((x,), expr, rng=lambda: random.uniform(-2, 2))
+
+    expr = acosh(x)
+    assert torch_code(expr) == "torch.acosh(x)"
+    _compare_torch_scalar((x,), expr, rng=lambda: random.uniform(1.1, 5))
+
+    expr = sinh(x)
+    assert torch_code(expr) == "torch.sinh(x)"
+    _compare_torch_scalar((x,), expr, rng=lambda: random.uniform(-2, 2))
+
+    expr = asinh(x)
+    assert torch_code(expr) == "torch.asinh(x)"
+    _compare_torch_scalar((x,), expr, rng=lambda: random.uniform(-5, 5))
+
+    expr = tanh(x)
+    assert torch_code(expr) == "torch.tanh(x)"
+    _compare_torch_scalar((x,), expr, rng=lambda: random.uniform(-2, 2))
+
+    expr = atanh(x)
+    assert torch_code(expr) == "torch.atanh(x)"
+    _compare_torch_scalar((x,), expr, rng=lambda: random.uniform(-0.9, 0.9))
+
+    expr = erf(x)
+    assert torch_code(expr) == "torch.erf(x)"
+    _compare_torch_scalar((x,), expr, rng=lambda: random.uniform(-2, 2))
+
+    expr = loggamma(x)
+    assert torch_code(expr) == "torch.lgamma(x)"
+    _compare_torch_scalar((x,), expr, rng=lambda: random.uniform(0.5, 5))
+
+
+def test_torch_complexes():
+    assert torch_code(re(x)) == "torch.real(x)"
+    assert torch_code(im(x)) == "torch.imag(x)"
+    assert torch_code(arg(x)) == "torch.angle(x)"
+
+
+def test_torch_relational():
+    if not torch:
+        skip("PyTorch not installed")
+
+    expr = Eq(x, y)
+    assert torch_code(expr) == "torch.eq(x, y)"
+    _compare_torch_relational((x, y), expr)
+
+    expr = Ne(x, y)
+    assert torch_code(expr) == "torch.ne(x, y)"
+    _compare_torch_relational((x, y), expr)
+
+    expr = Ge(x, y)
+    assert torch_code(expr) == "torch.ge(x, y)"
+    _compare_torch_relational((x, y), expr)
+
+    expr = Gt(x, y)
+    assert torch_code(expr) == "torch.gt(x, y)"
+    _compare_torch_relational((x, y), expr)
+
+    expr = Le(x, y)
+    assert torch_code(expr) == "torch.le(x, y)"
+    _compare_torch_relational((x, y), expr)
+
+    expr = Lt(x, y)
+    assert torch_code(expr) == "torch.lt(x, y)"
+    _compare_torch_relational((x, y), expr)
+
+
+def test_torch_matrix():
+    if torch is None:
+        skip("PyTorch not installed")
+
+    expr = M
+    assert torch_code(expr) == "M"
+    f = lambdify((M,), expr, "torch")
+    eye_mat = eye(3)
+    eye_tensor = torch.tensor(eye_mat.tolist(), dtype=torch.float64)
+    assert torch.allclose(f(eye_tensor), eye_tensor)
+
+    expr = M * N
+    assert torch_code(expr) == "torch.matmul(M, N)"
+    _compare_torch_matrix((M, N), expr)
+
+    expr = M ** 3
+    assert torch_code(expr) == "torch.mm(torch.mm(M, M), M)"
+    _compare_torch_matrix((M,), expr)
+
+    expr = M * N * P * Q
+    assert torch_code(expr) == "torch.matmul(torch.matmul(torch.matmul(M, N), P), Q)"
+    _compare_torch_matrix((M, N, P, Q), expr)
+
+    expr = Trace(M)
+    assert torch_code(expr) == "torch.trace(M)"
+    _compare_torch_matrix((M,), expr)
+
+    expr = Determinant(M)
+    assert torch_code(expr) == "torch.det(M)"
+    _compare_torch_matrix((M,), expr)
+
+    expr = HadamardProduct(M, N)
+    assert torch_code(expr) == "torch.mul(M, N)"
+    _compare_torch_matrix((M, N), expr)
+
+    expr = Inverse(M)
+    assert torch_code(expr) == "torch.linalg.inv(M)"
+
+    # For inverse, use a matrix that's guaranteed to be invertible
+    eye_mat = eye(3)
+    eye_tensor = torch.tensor(eye_mat.tolist(), dtype=torch.float64)
+    f = lambdify((M,), expr, "torch")
+    result = f(eye_tensor)
+    expected = torch.linalg.inv(eye_tensor)
+    assert torch.allclose(result, expected)
+
+
+def test_torch_array_operations():
+    if not torch:
+        skip("PyTorch not installed")
+
+    M = MatrixSymbol("M", 2, 2)
+    N = MatrixSymbol("N", 2, 2)
+    P = MatrixSymbol("P", 2, 2)
+    Q = MatrixSymbol("Q", 2, 2)
+
+    ma = torch.tensor([[1., 2.], [3., 4.]], dtype=torch.float64)
+    mb = torch.tensor([[1., -2.], [-1., 3.]], dtype=torch.float64)
+    mc = torch.tensor([[2., 0.], [1., 2.]], dtype=torch.float64)
+    md = torch.tensor([[1., -1.], [4., 7.]], dtype=torch.float64)
+
+    cg = ArrayTensorProduct(M, N)
+    assert torch_code(cg) == 'torch.einsum("ab,cd", M, N)'
+    f = lambdify((M, N), cg, 'torch')
+    y = f(ma, mb)
+    c = torch.einsum("ij,kl", ma, mb)
+    assert torch.allclose(y, c)
+
+    cg = ArrayAdd(M, N)
+    assert torch_code(cg) == 'torch.add(M, N)'
+    f = lambdify((M, N), cg, 'torch')
+    y = f(ma, mb)
+    c = ma + mb
+    assert torch.allclose(y, c)
+
+    cg = ArrayAdd(M, N, P)
+    assert torch_code(cg) == 'torch.add(torch.add(M, N), P)'
+    f = lambdify((M, N, P), cg, 'torch')
+    y = f(ma, mb, mc)
+    c = ma + mb + mc
+    assert torch.allclose(y, c)
+
+    cg = ArrayAdd(M, N, P, Q)
+    assert torch_code(cg) == 'torch.add(torch.add(torch.add(M, N), P), Q)'
+    f = lambdify((M, N, P, Q), cg, 'torch')
+    y = f(ma, mb, mc, md)
+    c = ma + mb + mc + md
+    assert torch.allclose(y, c)
+
+    cg = PermuteDims(M, [1, 0])
+    assert torch_code(cg) == 'M.permute(1, 0)'
+    f = lambdify((M,), cg, 'torch')
+    y = f(ma)
+    c = ma.T
+    assert torch.allclose(y, c)
+
+    cg = PermuteDims(ArrayTensorProduct(M, N), [1, 2, 3, 0])
+    assert torch_code(cg) == 'torch.einsum("ab,cd", M, N).permute(1, 2, 3, 0)'
+    f = lambdify((M, N), cg, 'torch')
+    y = f(ma, mb)
+    c = torch.einsum("ab,cd", ma, mb).permute(1, 2, 3, 0)
+    assert torch.allclose(y, c)
+
+    cg = ArrayDiagonal(ArrayTensorProduct(M, N), (1, 2))
+    assert torch_code(cg) == 'torch.einsum("ab,bc->acb", M, N)'
+    f = lambdify((M, N), cg, 'torch')
+    y = f(ma, mb)
+    c = torch.einsum("ab,bc->acb", ma, mb)
+    assert torch.allclose(y, c)
+
+
+def test_torch_derivative():
+    """Test derivative handling."""
+    expr = Derivative(sin(x), x)
+    assert torch_code(expr) == 'torch.autograd.grad(torch.sin(x), x)[0]'
+
+
+def test_torch_printing_dtype():
+    if not torch:
+        skip("PyTorch not installed")
+
+    # matrix printing with default dtype
+    expr = Matrix([[x, sin(y)], [exp(z), -t]])
+    assert "dtype=torch.float64" in torch_code(expr)
+
+    # explicit dtype
+    assert "dtype=torch.float32" in torch_code(expr, dtype="torch.float32")
+
+    # with requires_grad
+    result = torch_code(expr, requires_grad=True)
+    assert "requires_grad=True" in result
+    assert "dtype=torch.float64" in result
+
+    # both
+    result = torch_code(expr, requires_grad=True, dtype="torch.float32")
+    assert "requires_grad=True" in result
+    assert "dtype=torch.float32" in result
+
+
+def test_requires_grad():
+    if not torch:
+        skip("PyTorch not installed")
+
+    expr = sin(x) + cos(y)
+    f = lambdify([x, y], expr, 'torch')
+
+    # make sure the gradients flow
+    x_val = torch.tensor(1.0, requires_grad=True)
+    y_val = torch.tensor(2.0, requires_grad=True)
+    result = f(x_val, y_val)
+    assert result.requires_grad
+    result.backward()
+
+    # x_val.grad should be cos(x_val) which is close to cos(1.0)
+    assert abs(x_val.grad.item() - float(cos(1.0).evalf())) < 1e-6
+
+    # y_val.grad should be -sin(y_val) which is close to -sin(2.0)
+    assert abs(y_val.grad.item() - float(-sin(2.0).evalf())) < 1e-6
+
+
+def test_torch_multi_variable_derivatives():
+    if not torch:
+        skip("PyTorch not installed")
+
+    x, y, z = symbols("x y z")
+
+    expr = Derivative(sin(x), x)
+    assert torch_code(expr) == "torch.autograd.grad(torch.sin(x), x)[0]"
+
+    expr = Derivative(sin(x), (x, 2))
+    assert torch_code(
+        expr) == "torch.autograd.grad(torch.autograd.grad(torch.sin(x), x, create_graph=True)[0], x, create_graph=True)[0]"
+
+    expr = Derivative(sin(x * y), x, y)
+    result = torch_code(expr)
+    expected = "torch.autograd.grad(torch.autograd.grad(torch.sin(x*y), x, create_graph=True)[0], y, create_graph=True)[0]"
+    normalized_result = result.replace(" ", "")
+    normalized_expected = expected.replace(" ", "")
+    assert normalized_result == normalized_expected
+
+    expr = Derivative(sin(x), x, x)
+    result = torch_code(expr)
+    expected = "torch.autograd.grad(torch.autograd.grad(torch.sin(x), x, create_graph=True)[0], x, create_graph=True)[0]"
+    assert result == expected
+
+    expr = Derivative(sin(x * y * z), x, (y, 2), z)
+    result = torch_code(expr)
+    expected = "torch.autograd.grad(torch.autograd.grad(torch.autograd.grad(torch.autograd.grad(torch.sin(x*y*z), x, create_graph=True)[0], y, create_graph=True)[0], y, create_graph=True)[0], z, create_graph=True)[0]"
+    normalized_result = result.replace(" ", "")
+    normalized_expected = expected.replace(" ", "")
+    assert normalized_result == normalized_expected
+
+
+def test_torch_derivative_lambdify():
+    if not torch:
+        skip("PyTorch not installed")
+
+    x = symbols("x")
+    y = symbols("y")
+
+    expr = Derivative(x ** 2, x)
+    f = lambdify(x, expr, 'torch')
+    x_val = torch.tensor(2.0, requires_grad=True)
+    result = f(x_val)
+    assert torch.isclose(result, torch.tensor(4.0))
+
+    expr = Derivative(sin(x), (x, 2))
+    f = lambdify(x, expr, 'torch')
+    # Second derivative of sin(x) at x=0 is 0, not -1
+    x_val = torch.tensor(0.0, requires_grad=True)
+    result = f(x_val)
+    assert torch.isclose(result, torch.tensor(0.0), atol=1e-5)
+
+    x_val = torch.tensor(math.pi / 2, requires_grad=True)
+    result = f(x_val)
+    assert torch.isclose(result, torch.tensor(-1.0), atol=1e-5)
+
+    expr = Derivative(x * y ** 2, x, y)
+    f = lambdify((x, y), expr, 'torch')
+    x_val = torch.tensor(2.0, requires_grad=True)
+    y_val = torch.tensor(3.0, requires_grad=True)
+    result = f(x_val, y_val)
+    assert torch.isclose(result, torch.tensor(6.0))
+
+
+def test_torch_special_matrices():
+    if not torch:
+        skip("PyTorch not installed")
+
+    expr = Identity(3)
+    assert torch_code(expr) == "torch.eye(3)"
+
+    n = symbols("n")
+    expr = Identity(n)
+    assert torch_code(expr) == "torch.eye(n, n)"
+
+    expr = ZeroMatrix(2, 3)
+    assert torch_code(expr) == "torch.zeros((2, 3))"
+
+    m, n = symbols("m n")
+    expr = ZeroMatrix(m, n)
+    assert torch_code(expr) == "torch.zeros((m, n))"
+
+    expr = OneMatrix(2, 3)
+    assert torch_code(expr) == "torch.ones((2, 3))"
+
+    expr = OneMatrix(m, n)
+    assert torch_code(expr) == "torch.ones((m, n))"
+
+
+def test_torch_special_matrices_lambdify():
+    if not torch:
+        skip("PyTorch not installed")
+
+    expr = Identity(3)
+    f = lambdify([], expr, 'torch')
+    result = f()
+    expected = torch.eye(3)
+    assert torch.allclose(result, expected)
+
+    expr = ZeroMatrix(2, 3)
+    f = lambdify([], expr, 'torch')
+    result = f()
+    expected = torch.zeros((2, 3))
+    assert torch.allclose(result, expected)
+
+    expr = OneMatrix(2, 3)
+    f = lambdify([], expr, 'torch')
+    result = f()
+    expected = torch.ones((2, 3))
+    assert torch.allclose(result, expected)
+
+
+def test_torch_complex_operations():
+    if not torch:
+        skip("PyTorch not installed")
+
+    expr = conjugate(x)
+    assert torch_code(expr) == "torch.conj(x)"
+
+    # SymPy distributes conjugate over addition and applies specific rules for each term
+    expr = conjugate(sin(x) + I * cos(y))
+    assert torch_code(expr) == "torch.sin(torch.conj(x)) - 1j*torch.cos(torch.conj(y))"
+
+    expr = I
+    assert torch_code(expr) == "1j"
+
+    expr = 2 * I + x
+    assert torch_code(expr) == "x + 2*1j"
+
+    expr = exp(I * x)
+    assert torch_code(expr) == "torch.exp(1j*x)"
+
+
+def test_torch_special_functions():
+    if not torch:
+        skip("PyTorch not installed")
+
+    expr = Heaviside(x)
+    assert torch_code(expr) == "torch.heaviside(x, 1/2)"
+
+    expr = Heaviside(x, 0)
+    assert torch_code(expr) == "torch.heaviside(x, 0)"
+
+    expr = gamma(x)
+    assert torch_code(expr) == "torch.special.gamma(x)"
+
+    expr = polygamma(0, x)  # Use polygamma instead of digamma because sympy will default to that anyway
+    assert torch_code(expr) == "torch.special.digamma(x)"
+
+    expr = gamma(sin(x))
+    assert torch_code(expr) == "torch.special.gamma(torch.sin(x))"
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/test_tree.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/test_tree.py
new file mode 100644
index 0000000000000000000000000000000000000000..cf116d0cac5d38f225815fcd2d4ac90cd0dd96d7
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/printing/tests/test_tree.py
@@ -0,0 +1,196 @@
+from sympy.printing.tree import tree
+from sympy.testing.pytest import XFAIL
+
+
+# Remove this flag after making _assumptions cache deterministic.
+@XFAIL
+def test_print_tree_MatAdd():
+    from sympy.matrices.expressions import MatrixSymbol
+    A = MatrixSymbol('A', 3, 3)
+    B = MatrixSymbol('B', 3, 3)
+
+    test_str = [
+        'MatAdd: A + B\n',
+        'algebraic: False\n',
+        'commutative: False\n',
+        'complex: False\n',
+        'composite: False\n',
+        'even: False\n',
+        'extended_negative: False\n',
+        'extended_nonnegative: False\n',
+        'extended_nonpositive: False\n',
+        'extended_nonzero: False\n',
+        'extended_positive: False\n',
+        'extended_real: False\n',
+        'imaginary: False\n',
+        'integer: False\n',
+        'irrational: False\n',
+        'negative: False\n',
+        'noninteger: False\n',
+        'nonnegative: False\n',
+        'nonpositive: False\n',
+        'nonzero: False\n',
+        'odd: False\n',
+        'positive: False\n',
+        'prime: False\n',
+        'rational: False\n',
+        'real: False\n',
+        'transcendental: False\n',
+        'zero: False\n',
+        '+-MatrixSymbol: A\n',
+        '| algebraic: False\n',
+        '| commutative: False\n',
+        '| complex: False\n',
+        '| composite: False\n',
+        '| even: False\n',
+        '| extended_negative: False\n',
+        '| extended_nonnegative: False\n',
+        '| extended_nonpositive: False\n',
+        '| extended_nonzero: False\n',
+        '| extended_positive: False\n',
+        '| extended_real: False\n',
+        '| imaginary: False\n',
+        '| integer: False\n',
+        '| irrational: False\n',
+        '| negative: False\n',
+        '| noninteger: False\n',
+        '| nonnegative: False\n',
+        '| nonpositive: False\n',
+        '| nonzero: False\n',
+        '| odd: False\n',
+        '| positive: False\n',
+        '| prime: False\n',
+        '| rational: False\n',
+        '| real: False\n',
+        '| transcendental: False\n',
+        '| zero: False\n',
+        '| +-Symbol: A\n',
+        '| | commutative: True\n',
+        '| +-Integer: 3\n',
+        '| | algebraic: True\n',
+        '| | commutative: True\n',
+        '| | complex: True\n',
+        '| | extended_negative: False\n',
+        '| | extended_nonnegative: True\n',
+        '| | extended_real: True\n',
+        '| | finite: True\n',
+        '| | hermitian: True\n',
+        '| | imaginary: False\n',
+        '| | infinite: False\n',
+        '| | integer: True\n',
+        '| | irrational: False\n',
+        '| | negative: False\n',
+        '| | noninteger: False\n',
+        '| | nonnegative: True\n',
+        '| | rational: True\n',
+        '| | real: True\n',
+        '| | transcendental: False\n',
+        '| +-Integer: 3\n',
+        '|   algebraic: True\n',
+        '|   commutative: True\n',
+        '|   complex: True\n',
+        '|   extended_negative: False\n',
+        '|   extended_nonnegative: True\n',
+        '|   extended_real: True\n',
+        '|   finite: True\n',
+        '|   hermitian: True\n',
+        '|   imaginary: False\n',
+        '|   infinite: False\n',
+        '|   integer: True\n',
+        '|   irrational: False\n',
+        '|   negative: False\n',
+        '|   noninteger: False\n',
+        '|   nonnegative: True\n',
+        '|   rational: True\n',
+        '|   real: True\n',
+        '|   transcendental: False\n',
+        '+-MatrixSymbol: B\n',
+        '  algebraic: False\n',
+        '  commutative: False\n',
+        '  complex: False\n',
+        '  composite: False\n',
+        '  even: False\n',
+        '  extended_negative: False\n',
+        '  extended_nonnegative: False\n',
+        '  extended_nonpositive: False\n',
+        '  extended_nonzero: False\n',
+        '  extended_positive: False\n',
+        '  extended_real: False\n',
+        '  imaginary: False\n',
+        '  integer: False\n',
+        '  irrational: False\n',
+        '  negative: False\n',
+        '  noninteger: False\n',
+        '  nonnegative: False\n',
+        '  nonpositive: False\n',
+        '  nonzero: False\n',
+        '  odd: False\n',
+        '  positive: False\n',
+        '  prime: False\n',
+        '  rational: False\n',
+        '  real: False\n',
+        '  transcendental: False\n',
+        '  zero: False\n',
+        '  +-Symbol: B\n',
+        '  | commutative: True\n',
+        '  +-Integer: 3\n',
+        '  | algebraic: True\n',
+        '  | commutative: True\n',
+        '  | complex: True\n',
+        '  | extended_negative: False\n',
+        '  | extended_nonnegative: True\n',
+        '  | extended_real: True\n',
+        '  | finite: True\n',
+        '  | hermitian: True\n',
+        '  | imaginary: False\n',
+        '  | infinite: False\n',
+        '  | integer: True\n',
+        '  | irrational: False\n',
+        '  | negative: False\n',
+        '  | noninteger: False\n',
+        '  | nonnegative: True\n',
+        '  | rational: True\n',
+        '  | real: True\n',
+        '  | transcendental: False\n',
+        '  +-Integer: 3\n',
+        '    algebraic: True\n',
+        '    commutative: True\n',
+        '    complex: True\n',
+        '    extended_negative: False\n',
+        '    extended_nonnegative: True\n',
+        '    extended_real: True\n',
+        '    finite: True\n',
+        '    hermitian: True\n',
+        '    imaginary: False\n',
+        '    infinite: False\n',
+        '    integer: True\n',
+        '    irrational: False\n',
+        '    negative: False\n',
+        '    noninteger: False\n',
+        '    nonnegative: True\n',
+        '    rational: True\n',
+        '    real: True\n',
+        '    transcendental: False\n'
+    ]
+
+    assert tree(A + B) == "".join(test_str)
+
+
+def test_print_tree_MatAdd_noassumptions():
+    from sympy.matrices.expressions import MatrixSymbol
+    A = MatrixSymbol('A', 3, 3)
+    B = MatrixSymbol('B', 3, 3)
+
+    test_str = \
+"""MatAdd: A + B
++-MatrixSymbol: A
+| +-Str: A
+| +-Integer: 3
+| +-Integer: 3
++-MatrixSymbol: B
+  +-Str: B
+  +-Integer: 3
+  +-Integer: 3
+"""
+
+    assert tree(A + B, assumptions=False) == test_str
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/sandbox/__pycache__/__init__.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/sandbox/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..20bcb78d3cd9e012b7e1805d2ee5c4e3d9cc8ab4
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/sandbox/__pycache__/__init__.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/sandbox/__pycache__/indexed_integrals.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/sandbox/__pycache__/indexed_integrals.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b24f5066a39c1b8506d043eb5159c9cf6f60e192
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/sandbox/__pycache__/indexed_integrals.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/sandbox/tests/__init__.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/sandbox/tests/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/sandbox/tests/__pycache__/__init__.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/sandbox/tests/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..6ac26f46208ad1e3bd9f8e49877e994286f2e9c7
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/sandbox/tests/__pycache__/__init__.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/sandbox/tests/__pycache__/test_indexed_integrals.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/sandbox/tests/__pycache__/test_indexed_integrals.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..747053c8390474a8431c63f4a06552c46d624824
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/sandbox/tests/__pycache__/test_indexed_integrals.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/sandbox/tests/test_indexed_integrals.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/sandbox/tests/test_indexed_integrals.py
new file mode 100644
index 0000000000000000000000000000000000000000..61b98f0ffec29e026f6dfe8e16fde8b5818b0b09
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/sandbox/tests/test_indexed_integrals.py
@@ -0,0 +1,25 @@
+from sympy.sandbox.indexed_integrals import IndexedIntegral
+from sympy.core.symbol import symbols
+from sympy.functions.elementary.trigonometric import (cos, sin)
+from sympy.tensor.indexed import (Idx, IndexedBase)
+
+
+def test_indexed_integrals():
+    A = IndexedBase('A')
+    i, j = symbols('i j', integer=True)
+    a1, a2 = symbols('a1:3', cls=Idx)
+    assert isinstance(a1, Idx)
+
+    assert IndexedIntegral(1, A[i]).doit() == A[i]
+    assert IndexedIntegral(A[i], A[i]).doit() == A[i] ** 2 / 2
+    assert IndexedIntegral(A[j], A[i]).doit() == A[i] * A[j]
+    assert IndexedIntegral(A[i] * A[j], A[i]).doit() == A[i] ** 2 * A[j] / 2
+    assert IndexedIntegral(sin(A[i]), A[i]).doit() == -cos(A[i])
+    assert IndexedIntegral(sin(A[j]), A[i]).doit() == sin(A[j]) * A[i]
+
+    assert IndexedIntegral(1, A[a1]).doit() == A[a1]
+    assert IndexedIntegral(A[a1], A[a1]).doit() == A[a1] ** 2 / 2
+    assert IndexedIntegral(A[a2], A[a1]).doit() == A[a1] * A[a2]
+    assert IndexedIntegral(A[a1] * A[a2], A[a1]).doit() == A[a1] ** 2 * A[a2] / 2
+    assert IndexedIntegral(sin(A[a1]), A[a1]).doit() == -cos(A[a1])
+    assert IndexedIntegral(sin(A[a2]), A[a1]).doit() == sin(A[a2]) * A[a1]
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/series/__pycache__/__init__.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/series/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..7f5a6ee8d1183d0ffe01e3ebca944abd52123adb
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/series/__pycache__/__init__.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/series/__pycache__/acceleration.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/series/__pycache__/acceleration.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ed509458750f09986ffff6228d344c5dd7b3f69a
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/series/__pycache__/acceleration.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/series/__pycache__/approximants.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/series/__pycache__/approximants.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..1fede3f75185533af1335a99da6b1045f2af2787
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/series/__pycache__/approximants.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/series/__pycache__/aseries.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/series/__pycache__/aseries.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..89e839629f7f579689682abe15f0c385f56f51d9
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/series/__pycache__/aseries.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/series/__pycache__/formal.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/series/__pycache__/formal.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..7bc3104845f989ce7c861c4280fdbdf0a236c946
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/series/__pycache__/formal.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/series/__pycache__/fourier.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/series/__pycache__/fourier.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..4009e5050ce0d3138388d76365d9cd2e78859ad5
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/series/__pycache__/fourier.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/series/__pycache__/gruntz.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/series/__pycache__/gruntz.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..e63ce0ee948f563176d149bbfc4451ceca1148f4
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/series/__pycache__/gruntz.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/series/__pycache__/kauers.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/series/__pycache__/kauers.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ae75eab064b65cf435ca6568fba01a9126a390f4
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/series/__pycache__/kauers.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/series/__pycache__/limits.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/series/__pycache__/limits.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c05cb566ddbf29c0ce2901f49b74eaf4d73eda9a
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/series/__pycache__/limits.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/series/__pycache__/limitseq.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/series/__pycache__/limitseq.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..00e87981062e6589c68722a67e12f44ffe1b3626
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/series/__pycache__/limitseq.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/series/__pycache__/order.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/series/__pycache__/order.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..0d95083d931553c8f7fe48036aba31fd7049f6cb
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/series/__pycache__/order.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/series/__pycache__/residues.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/series/__pycache__/residues.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d2a7a0ceb7de57f78b9710bbf174345a5a3c378c
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/series/__pycache__/residues.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/series/__pycache__/sequences.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/series/__pycache__/sequences.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b753bdb2c9f32c36bf58d0511299a945265a3b78
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/series/__pycache__/sequences.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/series/__pycache__/series.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/series/__pycache__/series.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..16a3c571ce11c2e6c76f67f825cff1bd0475cec6
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/series/__pycache__/series.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/series/__pycache__/series_class.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/series/__pycache__/series_class.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..4093702d0290254cca0467477c2d6ac4b13ad160
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/series/__pycache__/series_class.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/series/benchmarks/__init__.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/series/benchmarks/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/series/benchmarks/__pycache__/__init__.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/series/benchmarks/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..e6c81d7b3fc500cbbf1ae6e4ecdf63b0ccf5c84a
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/series/benchmarks/__pycache__/__init__.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/series/benchmarks/__pycache__/bench_limit.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/series/benchmarks/__pycache__/bench_limit.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..41bd1b6a6752f0e4516d7cf2856230a2de320181
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/series/benchmarks/__pycache__/bench_limit.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/series/benchmarks/__pycache__/bench_order.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/series/benchmarks/__pycache__/bench_order.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..40576c1b530300d55f54f3b27732c324681070a7
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/series/benchmarks/__pycache__/bench_order.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/series/benchmarks/bench_limit.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/series/benchmarks/bench_limit.py
new file mode 100644
index 0000000000000000000000000000000000000000..eafc28328848dad4b3ea433537971f5785253afe
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/series/benchmarks/bench_limit.py
@@ -0,0 +1,9 @@
+from sympy.core.numbers import oo
+from sympy.core.symbol import Symbol
+from sympy.series.limits import limit
+
+x = Symbol('x')
+
+
+def timeit_limit_1x():
+    limit(1/x, x, oo)
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/series/benchmarks/bench_order.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/series/benchmarks/bench_order.py
new file mode 100644
index 0000000000000000000000000000000000000000..1c85fa173dfc2a478792de8ab816c23ba9d408ef
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/series/benchmarks/bench_order.py
@@ -0,0 +1,10 @@
+from sympy.core.add import Add
+from sympy.core.symbol import Symbol
+from sympy.series.order import O
+
+x = Symbol('x')
+l = [x**i for i in range(1000)]
+l.append(O(x**1001))
+
+def timeit_order_1x():
+    Add(*l)
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/series/tests/__init__.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/series/tests/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/series/tests/__pycache__/__init__.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/series/tests/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..1af372f644e40f8ab0d88c64c01160e25a01cd09
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/series/tests/__pycache__/__init__.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/series/tests/__pycache__/test_approximants.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/series/tests/__pycache__/test_approximants.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..20494f65d59bbaba06a62be85bc278c5d310735f
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/series/tests/__pycache__/test_approximants.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/series/tests/__pycache__/test_aseries.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/series/tests/__pycache__/test_aseries.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..24e265fde0ff26ca3dc34547bd08ee2ff2b69ac2
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/series/tests/__pycache__/test_aseries.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/series/tests/__pycache__/test_demidovich.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/series/tests/__pycache__/test_demidovich.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..18c10ee8940bafddf02c1d54bf3ae8f2574b1072
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/series/tests/__pycache__/test_demidovich.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/series/tests/__pycache__/test_formal.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/series/tests/__pycache__/test_formal.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c4dd61e051f41b3624b04a76ce4de86d2a6d6833
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/series/tests/__pycache__/test_formal.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/series/tests/__pycache__/test_fourier.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/series/tests/__pycache__/test_fourier.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..8c4b86663e9e179d01a5d1eba4ff666aba274df5
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/series/tests/__pycache__/test_fourier.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/series/tests/__pycache__/test_gruntz.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/series/tests/__pycache__/test_gruntz.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d78a455acba9b329874eafd3ae6c992ef2f7ce10
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/series/tests/__pycache__/test_gruntz.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/series/tests/__pycache__/test_kauers.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/series/tests/__pycache__/test_kauers.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..52b17da2355195717f420c1ab9066e6fa3432d20
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/series/tests/__pycache__/test_kauers.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/series/tests/__pycache__/test_limits.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/series/tests/__pycache__/test_limits.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d2d0f353f0fbba5c0c4fff8b2afb01532a94a4fc
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/series/tests/__pycache__/test_limits.cpython-312.pyc
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0879ae537085db4a91cbd3686f7d70c70ef95aea8adf32ce35649db0d67ffe36
+size 138765
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/series/tests/__pycache__/test_limitseq.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/series/tests/__pycache__/test_limitseq.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..43d374b6a99840908483365cec10c1d7058f03a2
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/series/tests/__pycache__/test_limitseq.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/series/tests/__pycache__/test_lseries.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/series/tests/__pycache__/test_lseries.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ddbe12c21d5c44eaf6febdaf6cdda024fc6d0a1f
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/series/tests/__pycache__/test_lseries.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/series/tests/__pycache__/test_nseries.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/series/tests/__pycache__/test_nseries.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..04185b3a58ffe00d1d6227c0bf8d7f0a52e7a5f2
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/series/tests/__pycache__/test_nseries.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/series/tests/__pycache__/test_order.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/series/tests/__pycache__/test_order.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..aebc76e901b047b199dda10d2ff2ee4468ef48c8
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/series/tests/__pycache__/test_order.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/series/tests/__pycache__/test_residues.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/series/tests/__pycache__/test_residues.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d00a7f2b669f17837f8c7ef40cdfbcb24be00928
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/series/tests/__pycache__/test_residues.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/series/tests/__pycache__/test_sequences.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/series/tests/__pycache__/test_sequences.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c93d79e4b2b4e97d640f4e5c0ea0082f9613c946
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/series/tests/__pycache__/test_sequences.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/series/tests/__pycache__/test_series.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/series/tests/__pycache__/test_series.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d42afd60ea3051280e0da8163faa8e19a4165ad8
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/series/tests/__pycache__/test_series.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/series/tests/test_approximants.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/series/tests/test_approximants.py
new file mode 100644
index 0000000000000000000000000000000000000000..9c03d2ce38add99b0dce8725b6c8d8844b31f76b
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/series/tests/test_approximants.py
@@ -0,0 +1,23 @@
+from sympy.series import approximants
+from sympy.core.symbol import symbols
+from sympy.functions.combinatorial.factorials import binomial
+from sympy.functions.combinatorial.numbers import (fibonacci, lucas)
+
+
+def test_approximants():
+    x, t = symbols("x,t")
+    g = [lucas(k) for k in range(16)]
+    assert list(approximants(g)) == (
+        [2, -4/(x - 2), (5*x - 2)/(3*x - 1), (x - 2)/(x**2 + x - 1)] )
+    g = [lucas(k)+fibonacci(k+2) for k in range(16)]
+    assert list(approximants(g)) == (
+        [3, -3/(x - 1), (3*x - 3)/(2*x - 1), -3/(x**2 + x - 1)] )
+    g = [lucas(k)**2 for k in range(16)]
+    assert list(approximants(g)) == (
+        [4, -16/(x - 4), (35*x - 4)/(9*x - 1), (37*x - 28)/(13*x**2 + 11*x - 7),
+        (50*x**2 + 63*x - 52)/(37*x**2 + 19*x - 13),
+        (-x**2 - 7*x + 4)/(x**3 - 2*x**2 - 2*x + 1)] )
+    p = [sum(binomial(k,i)*x**i for i in range(k+1)) for k in range(16)]
+    y = approximants(p, t, simplify=True)
+    assert next(y) == 1
+    assert next(y) == -1/(t*(x + 1) - 1)
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/series/tests/test_aseries.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/series/tests/test_aseries.py
new file mode 100644
index 0000000000000000000000000000000000000000..cae0ac0a43f2406dd96e45c6a31939ac6b4cdcaa
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/series/tests/test_aseries.py
@@ -0,0 +1,55 @@
+from sympy.core.function import PoleError
+from sympy.core.numbers import oo
+from sympy.core.symbol import Symbol
+from sympy.functions.elementary.exponential import (exp, log)
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import (cos, sin)
+from sympy.series.order import O
+from sympy.abc import x
+
+from sympy.testing.pytest import raises
+
+def test_simple():
+    # Gruntz' theses pp. 91 to 96
+    # 6.6
+    e = sin(1/x + exp(-x)) - sin(1/x)
+    assert e.aseries(x) == (1/(24*x**4) - 1/(2*x**2) + 1 + O(x**(-6), (x, oo)))*exp(-x)
+
+    e = exp(x) * (exp(1/x + exp(-x)) - exp(1/x))
+    assert e.aseries(x, n=4) == 1/(6*x**3) + 1/(2*x**2) + 1/x + 1 + O(x**(-4), (x, oo))
+
+    e = exp(exp(x) / (1 - 1/x))
+    assert e.aseries(x) == exp(exp(x) / (1 - 1/x))
+
+    # The implementation of bound in aseries is incorrect currently. This test
+    # should be commented out when that is fixed.
+    # assert e.aseries(x, bound=3) == exp(exp(x) / x**2)*exp(exp(x) / x)*exp(-exp(x) + exp(x)/(1 - 1/x) - \
+    #         exp(x) / x - exp(x) / x**2) * exp(exp(x))
+
+    e = exp(sin(1/x + exp(-exp(x)))) - exp(sin(1/x))
+    assert e.aseries(x, n=4) == (-1/(2*x**3) + 1/x + 1 + O(x**(-4), (x, oo)))*exp(-exp(x))
+
+    e3 = lambda x:exp(exp(exp(x)))
+    e = e3(x)/e3(x - 1/e3(x))
+    assert e.aseries(x, n=3) == 1 + exp(2*x + 2*exp(x))*exp(-2*exp(exp(x)))/2\
+            - exp(2*x + exp(x))*exp(-2*exp(exp(x)))/2 - exp(x + exp(x))*exp(-2*exp(exp(x)))/2\
+            + exp(x + exp(x))*exp(-exp(exp(x))) + O(exp(-3*exp(exp(x))), (x, oo))
+
+    e = exp(exp(x)) * (exp(sin(1/x + 1/exp(exp(x)))) - exp(sin(1/x)))
+    assert e.aseries(x, n=4) == -1/(2*x**3) + 1/x + 1 + O(x**(-4), (x, oo))
+
+    n = Symbol('n', integer=True)
+    e = (sqrt(n)*log(n)**2*exp(sqrt(log(n))*log(log(n))**2*exp(sqrt(log(log(n)))*log(log(log(n)))**3)))/n
+    assert e.aseries(n) == \
+            exp(exp(sqrt(log(log(n)))*log(log(log(n)))**3)*sqrt(log(n))*log(log(n))**2)*log(n)**2/sqrt(n)
+
+
+def test_hierarchical():
+    e = sin(1/x + exp(-x))
+    assert e.aseries(x, n=3, hir=True) == -exp(-2*x)*sin(1/x)/2 + \
+            exp(-x)*cos(1/x) + sin(1/x) + O(exp(-3*x), (x, oo))
+
+    e = sin(x) * cos(exp(-x))
+    assert e.aseries(x, hir=True) == exp(-4*x)*sin(x)/24 - \
+            exp(-2*x)*sin(x)/2 + sin(x) + O(exp(-6*x), (x, oo))
+    raises(PoleError, lambda: e.aseries(x))
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/series/tests/test_demidovich.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/series/tests/test_demidovich.py
new file mode 100644
index 0000000000000000000000000000000000000000..98cafbae6f019dd3d97d306099d5780ed2f37f04
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/series/tests/test_demidovich.py
@@ -0,0 +1,143 @@
+from sympy.core.numbers import (Rational, oo, pi)
+from sympy.core.singleton import S
+from sympy.core.symbol import Symbol
+from sympy.functions.elementary.exponential import (exp, log)
+from sympy.functions.elementary.miscellaneous import (root, sqrt)
+from sympy.functions.elementary.trigonometric import (asin, cos, sin, tan)
+from sympy.polys.rationaltools import together
+from sympy.series.limits import limit
+
+# Numbers listed with the tests refer to problem numbers in the book
+# "Anti-demidovich, problemas resueltos, Ed. URSS"
+
+x = Symbol("x")
+
+
+def test_leadterm():
+    assert (3 + 2*x**(log(3)/log(2) - 1)).leadterm(x) == (3, 0)
+
+
+def root3(x):
+    return root(x, 3)
+
+
+def root4(x):
+    return root(x, 4)
+
+
+def test_Limits_simple_0():
+    assert limit((2**(x + 1) + 3**(x + 1))/(2**x + 3**x), x, oo) == 3  # 175
+
+
+def test_Limits_simple_1():
+    assert limit((x + 1)*(x + 2)*(x + 3)/x**3, x, oo) == 1  # 172
+    assert limit(sqrt(x + 1) - sqrt(x), x, oo) == 0  # 179
+    assert limit((2*x - 3)*(3*x + 5)*(4*x - 6)/(3*x**3 + x - 1), x, oo) == 8  # Primjer 1
+    assert limit(x/root3(x**3 + 10), x, oo) == 1  # Primjer 2
+    assert limit((x + 1)**2/(x**2 + 1), x, oo) == 1  # 181
+
+
+def test_Limits_simple_2():
+    assert limit(1000*x/(x**2 - 1), x, oo) == 0  # 182
+    assert limit((x**2 - 5*x + 1)/(3*x + 7), x, oo) is oo  # 183
+    assert limit((2*x**2 - x + 3)/(x**3 - 8*x + 5), x, oo) == 0  # 184
+    assert limit((2*x**2 - 3*x - 4)/sqrt(x**4 + 1), x, oo) == 2  # 186
+    assert limit((2*x + 3)/(x + root3(x)), x, oo) == 2  # 187
+    assert limit(x**2/(10 + x*sqrt(x)), x, oo) is oo  # 188
+    assert limit(root3(x**2 + 1)/(x + 1), x, oo) == 0  # 189
+    assert limit(sqrt(x)/sqrt(x + sqrt(x + sqrt(x))), x, oo) == 1  # 190
+
+
+def test_Limits_simple_3a():
+    a = Symbol('a')
+    #issue 3513
+    assert together(limit((x**2 - (a + 1)*x + a)/(x**3 - a**3), x, a)) == \
+        (a - 1)/(3*a**2)  # 196
+
+
+def test_Limits_simple_3b():
+    h = Symbol("h")
+    assert limit(((x + h)**3 - x**3)/h, h, 0) == 3*x**2  # 197
+    assert limit((1/(1 - x) - 3/(1 - x**3)), x, 1) == -1  # 198
+    assert limit((sqrt(1 + x) - 1)/(root3(1 + x) - 1), x, 0) == Rational(3)/2  # Primer 4
+    assert limit((sqrt(x) - 1)/(x - 1), x, 1) == Rational(1)/2  # 199
+    assert limit((sqrt(x) - 8)/(root3(x) - 4), x, 64) == 3  # 200
+    assert limit((root3(x) - 1)/(root4(x) - 1), x, 1) == Rational(4)/3  # 201
+    assert limit(
+        (root3(x**2) - 2*root3(x) + 1)/(x - 1)**2, x, 1) == Rational(1)/9  # 202
+
+
+def test_Limits_simple_4a():
+    a = Symbol('a')
+    assert limit((sqrt(x) - sqrt(a))/(x - a), x, a) == 1/(2*sqrt(a))  # Primer 5
+    assert limit((sqrt(x) - 1)/(root3(x) - 1), x, 1) == Rational(3, 2)  # 205
+    assert limit((sqrt(1 + x) - sqrt(1 - x))/x, x, 0) == 1  # 207
+    assert limit(sqrt(x**2 - 5*x + 6) - x, x, oo) == Rational(-5, 2)  # 213
+
+
+def test_limits_simple_4aa():
+    assert limit(x*(sqrt(x**2 + 1) - x), x, oo) == Rational(1)/2  # 214
+
+
+def test_Limits_simple_4b():
+    #issue 3511
+    assert limit(x - root3(x**3 - 1), x, oo) == 0  # 215
+
+
+def test_Limits_simple_4c():
+    assert limit(log(1 + exp(x))/x, x, -oo) == 0  # 267a
+    assert limit(log(1 + exp(x))/x, x, oo) == 1  # 267b
+
+
+def test_bounded():
+    assert limit(sin(x)/x, x, oo) == 0  # 216b
+    assert limit(x*sin(1/x), x, 0) == 0  # 227a
+
+
+def test_f1a():
+    #issue 3508:
+    assert limit((sin(2*x)/x)**(1 + x), x, 0) == 2  # Primer 7
+
+
+def test_f1a2():
+    #issue 3509:
+    assert limit(((x - 1)/(x + 1))**x, x, oo) == exp(-2)  # Primer 9
+
+
+def test_f1b():
+    m = Symbol("m")
+    n = Symbol("n")
+    h = Symbol("h")
+    a = Symbol("a")
+    assert limit(sin(x)/x, x, 2) == sin(2)/2  # 216a
+    assert limit(sin(3*x)/x, x, 0) == 3  # 217
+    assert limit(sin(5*x)/sin(2*x), x, 0) == Rational(5, 2)  # 218
+    assert limit(sin(pi*x)/sin(3*pi*x), x, 0) == Rational(1, 3)  # 219
+    assert limit(x*sin(pi/x), x, oo) == pi  # 220
+    assert limit((1 - cos(x))/x**2, x, 0) == S.Half  # 221
+    assert limit(x*sin(1/x), x, oo) == 1  # 227b
+    assert limit((cos(m*x) - cos(n*x))/x**2, x, 0) == -m**2/2 + n**2/2  # 232
+    assert limit((tan(x) - sin(x))/x**3, x, 0) == S.Half  # 233
+    assert limit((x - sin(2*x))/(x + sin(3*x)), x, 0) == -Rational(1, 4)  # 237
+    assert limit((1 - sqrt(cos(x)))/x**2, x, 0) == Rational(1, 4)  # 239
+    assert limit((sqrt(1 + sin(x)) - sqrt(1 - sin(x)))/x, x, 0) == 1  # 240
+
+    assert limit((1 + h/x)**x, x, oo) == exp(h)  # Primer 9
+    assert limit((sin(x) - sin(a))/(x - a), x, a) == cos(a)  # 222, *176
+    assert limit((cos(x) - cos(a))/(x - a), x, a) == -sin(a)  # 223
+    assert limit((sin(x + h) - sin(x))/h, h, 0) == cos(x)  # 225
+
+
+def test_f2a():
+    assert limit(((x + 1)/(2*x + 1))**(x**2), x, oo) == 0  # Primer 8
+
+
+def test_f2():
+    assert limit((sqrt(
+        cos(x)) - root3(cos(x)))/(sin(x)**2), x, 0) == -Rational(1, 12)  # *184
+
+
+def test_f3():
+    a = Symbol('a')
+    #issue 3504
+    assert limit(asin(a*x)/x, x, 0) == a
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/series/tests/test_formal.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/series/tests/test_formal.py
new file mode 100644
index 0000000000000000000000000000000000000000..cac60b12534152a5783bb8f0faab2c06da6691fb
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/series/tests/test_formal.py
@@ -0,0 +1,618 @@
+from sympy.concrete.summations import Sum
+from sympy.core.add import Add
+from sympy.core.function import (Derivative, Function)
+from sympy.core.mul import Mul
+from sympy.core.numbers import (I, Rational, oo, pi)
+from sympy.core.singleton import S
+from sympy.core.symbol import symbols
+from sympy.functions.combinatorial.factorials import factorial
+from sympy.functions.elementary.exponential import (exp, log)
+from sympy.functions.elementary.hyperbolic import (acosh, asech)
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import (acos, asin, atan, cos, sin)
+from sympy.functions.special.bessel import airyai
+from sympy.functions.special.error_functions import erf
+from sympy.functions.special.gamma_functions import gamma
+from sympy.integrals.integrals import integrate
+from sympy.series.formal import fps
+from sympy.series.order import O
+from sympy.series.formal import (rational_algorithm, FormalPowerSeries,
+                                 FormalPowerSeriesProduct, FormalPowerSeriesCompose,
+                                 FormalPowerSeriesInverse, simpleDE,
+                                 rational_independent, exp_re, hyper_re)
+from sympy.testing.pytest import raises, XFAIL, slow
+
+x, y, z = symbols('x y z')
+n, m, k = symbols('n m k', integer=True)
+f, r = Function('f'), Function('r')
+
+
+def test_rational_algorithm():
+    f = 1 / ((x - 1)**2 * (x - 2))
+    assert rational_algorithm(f, x, k) == \
+        (-2**(-k - 1) + 1 - (factorial(k + 1) / factorial(k)), 0, 0)
+
+    f = (1 + x + x**2 + x**3) / ((x - 1) * (x - 2))
+    assert rational_algorithm(f, x, k) == \
+        (-15*2**(-k - 1) + 4, x + 4, 0)
+
+    f = z / (y*m - m*x - y*x + x**2)
+    assert rational_algorithm(f, x, k) == \
+        (((-y**(-k - 1)*z) / (y - m)) + ((m**(-k - 1)*z) / (y - m)), 0, 0)
+
+    f = x / (1 - x - x**2)
+    assert rational_algorithm(f, x, k) is None
+    assert rational_algorithm(f, x, k, full=True) == \
+        (((Rational(-1, 2) + sqrt(5)/2)**(-k - 1) *
+         (-sqrt(5)/10 + S.Half)) +
+         ((-sqrt(5)/2 - S.Half)**(-k - 1) *
+         (sqrt(5)/10 + S.Half)), 0, 0)
+
+    f = 1 / (x**2 + 2*x + 2)
+    assert rational_algorithm(f, x, k) is None
+    assert rational_algorithm(f, x, k, full=True) == \
+        ((I*(-1 + I)**(-k - 1)) / 2 - (I*(-1 - I)**(-k - 1)) / 2, 0, 0)
+
+    f = log(1 + x)
+    assert rational_algorithm(f, x, k) == \
+        (-(-1)**(-k) / k, 0, 1)
+
+    f = atan(x)
+    assert rational_algorithm(f, x, k) is None
+    assert rational_algorithm(f, x, k, full=True) == \
+        (((I*I**(-k)) / 2 - (I*(-I)**(-k)) / 2) / k, 0, 1)
+
+    f = x*atan(x) - log(1 + x**2) / 2
+    assert rational_algorithm(f, x, k) is None
+    assert rational_algorithm(f, x, k, full=True) == \
+        (((I*I**(-k + 1)) / 2 - (I*(-I)**(-k + 1)) / 2) /
+         (k*(k - 1)), 0, 2)
+
+    f = log((1 + x) / (1 - x)) / 2 - atan(x)
+    assert rational_algorithm(f, x, k) is None
+    assert rational_algorithm(f, x, k, full=True) == \
+        ((-(-1)**(-k) / 2 - (I*I**(-k)) / 2 + (I*(-I)**(-k)) / 2 +
+          S.Half) / k, 0, 1)
+
+    assert rational_algorithm(cos(x), x, k) is None
+
+
+def test_rational_independent():
+    ri = rational_independent
+    assert ri([], x) == []
+    assert ri([cos(x), sin(x)], x) == [cos(x), sin(x)]
+    assert ri([x**2, sin(x), x*sin(x), x**3], x) == \
+        [x**3 + x**2, x*sin(x) + sin(x)]
+    assert ri([S.One, x*log(x), log(x), sin(x)/x, cos(x), sin(x), x], x) == \
+        [x + 1, x*log(x) + log(x), sin(x)/x + sin(x), cos(x)]
+
+
+def test_simpleDE():
+    # Tests just the first valid DE
+    for DE in simpleDE(exp(x), x, f):
+        assert DE == (-f(x) + Derivative(f(x), x), 1)
+        break
+    for DE in simpleDE(sin(x), x, f):
+        assert DE == (f(x) + Derivative(f(x), x, x), 2)
+        break
+    for DE in simpleDE(log(1 + x), x, f):
+        assert DE == ((x + 1)*Derivative(f(x), x, 2) + Derivative(f(x), x), 2)
+        break
+    for DE in simpleDE(asin(x), x, f):
+        assert DE == (x*Derivative(f(x), x) + (x**2 - 1)*Derivative(f(x), x, x),
+                      2)
+        break
+    for DE in simpleDE(exp(x)*sin(x), x, f):
+        assert DE == (2*f(x) - 2*Derivative(f(x)) + Derivative(f(x), x, x), 2)
+        break
+    for DE in simpleDE(((1 + x)/(1 - x))**n, x, f):
+        assert DE == (2*n*f(x) + (x**2 - 1)*Derivative(f(x), x), 1)
+        break
+    for DE in simpleDE(airyai(x), x, f):
+        assert DE == (-x*f(x) + Derivative(f(x), x, x), 2)
+        break
+
+
+def test_exp_re():
+    d = -f(x) + Derivative(f(x), x)
+    assert exp_re(d, r, k) == -r(k) + r(k + 1)
+
+    d = f(x) + Derivative(f(x), x, x)
+    assert exp_re(d, r, k) == r(k) + r(k + 2)
+
+    d = f(x) + Derivative(f(x), x) + Derivative(f(x), x, x)
+    assert exp_re(d, r, k) == r(k) + r(k + 1) + r(k + 2)
+
+    d = Derivative(f(x), x) + Derivative(f(x), x, x)
+    assert exp_re(d, r, k) == r(k) + r(k + 1)
+
+    d = Derivative(f(x), x, 3) + Derivative(f(x), x, 4) + Derivative(f(x))
+    assert exp_re(d, r, k) == r(k) + r(k + 2) + r(k + 3)
+
+
+def test_hyper_re():
+    d = f(x) + Derivative(f(x), x, x)
+    assert hyper_re(d, r, k) == r(k) + (k+1)*(k+2)*r(k + 2)
+
+    d = -x*f(x) + Derivative(f(x), x, x)
+    assert hyper_re(d, r, k) == (k + 2)*(k + 3)*r(k + 3) - r(k)
+
+    d = 2*f(x) - 2*Derivative(f(x), x) + Derivative(f(x), x, x)
+    assert hyper_re(d, r, k) == \
+        (-2*k - 2)*r(k + 1) + (k + 1)*(k + 2)*r(k + 2) + 2*r(k)
+
+    d = 2*n*f(x) + (x**2 - 1)*Derivative(f(x), x)
+    assert hyper_re(d, r, k) == \
+        k*r(k) + 2*n*r(k + 1) + (-k - 2)*r(k + 2)
+
+    d = (x**10 + 4)*Derivative(f(x), x) + x*(x**10 - 1)*Derivative(f(x), x, x)
+    assert hyper_re(d, r, k) == \
+        (k*(k - 1) + k)*r(k) + (4*k - (k + 9)*(k + 10) + 40)*r(k + 10)
+
+    d = ((x**2 - 1)*Derivative(f(x), x, 3) + 3*x*Derivative(f(x), x, x) +
+         Derivative(f(x), x))
+    assert hyper_re(d, r, k) == \
+        ((k*(k - 2)*(k - 1) + 3*k*(k - 1) + k)*r(k) +
+         (-k*(k + 1)*(k + 2))*r(k + 2))
+
+
+def test_fps():
+    assert fps(1) == 1
+    assert fps(2, x) == 2
+    assert fps(2, x, dir='+') == 2
+    assert fps(2, x, dir='-') == 2
+    assert fps(1/x + 1/x**2) == 1/x + 1/x**2
+    assert fps(log(1 + x), hyper=False, rational=False) == log(1 + x)
+
+    f = fps(x**2 + x + 1)
+    assert isinstance(f, FormalPowerSeries)
+    assert f.function == x**2 + x + 1
+    assert f[0] == 1
+    assert f[2] == x**2
+    assert f.truncate(4) == x**2 + x + 1 + O(x**4)
+    assert f.polynomial() == x**2 + x + 1
+
+    f = fps(log(1 + x))
+    assert isinstance(f, FormalPowerSeries)
+    assert f.function == log(1 + x)
+    assert f.subs(x, y) == f
+    assert f[:5] == [0, x, -x**2/2, x**3/3, -x**4/4]
+    assert f.as_leading_term(x) == x
+    assert f.polynomial(6) == x - x**2/2 + x**3/3 - x**4/4 + x**5/5
+
+    k = f.ak.variables[0]
+    assert f.infinite == Sum((-(-1)**(-k)*x**k)/k, (k, 1, oo))
+
+    ft, s = f.truncate(n=None), f[:5]
+    for i, t in enumerate(ft):
+        if i == 5:
+            break
+        assert s[i] == t
+
+    f = sin(x).fps(x)
+    assert isinstance(f, FormalPowerSeries)
+    assert f.truncate() == x - x**3/6 + x**5/120 + O(x**6)
+
+    raises(NotImplementedError, lambda: fps(y*x))
+    raises(ValueError, lambda: fps(x, dir=0))
+
+
+@slow
+def test_fps__rational():
+    assert fps(1/x) == (1/x)
+    assert fps((x**2 + x + 1) / x**3, dir=-1) == (x**2 + x + 1) / x**3
+
+    f = 1 / ((x - 1)**2 * (x - 2))
+    assert fps(f, x).truncate() == \
+        (Rational(-1, 2) - x*Rational(5, 4) - 17*x**2/8 - 49*x**3/16 - 129*x**4/32 -
+         321*x**5/64 + O(x**6))
+
+    f = (1 + x + x**2 + x**3) / ((x - 1) * (x - 2))
+    assert fps(f, x).truncate() == \
+        (S.Half + x*Rational(5, 4) + 17*x**2/8 + 49*x**3/16 + 113*x**4/32 +
+         241*x**5/64 + O(x**6))
+
+    f = x / (1 - x - x**2)
+    assert fps(f, x, full=True).truncate() == \
+        x + x**2 + 2*x**3 + 3*x**4 + 5*x**5 + O(x**6)
+
+    f = 1 / (x**2 + 2*x + 2)
+    assert fps(f, x, full=True).truncate() == \
+        S.Half - x/2 + x**2/4 - x**4/8 + x**5/8 + O(x**6)
+
+    f = log(1 + x)
+    assert fps(f, x).truncate() == \
+        x - x**2/2 + x**3/3 - x**4/4 + x**5/5 + O(x**6)
+    assert fps(f, x, dir=1).truncate() == fps(f, x, dir=-1).truncate()
+    assert fps(f, x, 2).truncate() == \
+        (log(3) - Rational(2, 3) - (x - 2)**2/18 + (x - 2)**3/81 -
+         (x - 2)**4/324 + (x - 2)**5/1215 + x/3 + O((x - 2)**6, (x, 2)))
+    assert fps(f, x, 2, dir=-1).truncate() == \
+        (log(3) - Rational(2, 3) - (-x + 2)**2/18 - (-x + 2)**3/81 -
+         (-x + 2)**4/324 - (-x + 2)**5/1215 + x/3 + O((x - 2)**6, (x, 2)))
+
+    f = atan(x)
+    assert fps(f, x, full=True).truncate() == x - x**3/3 + x**5/5 + O(x**6)
+    assert fps(f, x, full=True, dir=1).truncate() == \
+        fps(f, x, full=True, dir=-1).truncate()
+    assert fps(f, x, 2, full=True).truncate() == \
+        (atan(2) - Rational(2, 5) - 2*(x - 2)**2/25 + 11*(x - 2)**3/375 -
+         6*(x - 2)**4/625 + 41*(x - 2)**5/15625 + x/5 + O((x - 2)**6, (x, 2)))
+    assert fps(f, x, 2, full=True, dir=-1).truncate() == \
+        (atan(2) - Rational(2, 5) - 2*(-x + 2)**2/25 - 11*(-x + 2)**3/375 -
+         6*(-x + 2)**4/625 - 41*(-x + 2)**5/15625 + x/5 + O((x - 2)**6, (x, 2)))
+
+    f = x*atan(x) - log(1 + x**2) / 2
+    assert fps(f, x, full=True).truncate() == x**2/2 - x**4/12 + O(x**6)
+
+    f = log((1 + x) / (1 - x)) / 2 - atan(x)
+    assert fps(f, x, full=True).truncate(n=10) == 2*x**3/3 + 2*x**7/7 + O(x**10)
+
+
+@slow
+def test_fps__hyper():
+    f = sin(x)
+    assert fps(f, x).truncate() == x - x**3/6 + x**5/120 + O(x**6)
+
+    f = cos(x)
+    assert fps(f, x).truncate() == 1 - x**2/2 + x**4/24 + O(x**6)
+
+    f = exp(x)
+    assert fps(f, x).truncate() == \
+        1 + x + x**2/2 + x**3/6 + x**4/24 + x**5/120 + O(x**6)
+
+    f = atan(x)
+    assert fps(f, x).truncate() == x - x**3/3 + x**5/5 + O(x**6)
+
+    f = exp(acos(x))
+    assert fps(f, x).truncate() == \
+        (exp(pi/2) - x*exp(pi/2) + x**2*exp(pi/2)/2 - x**3*exp(pi/2)/3 +
+         5*x**4*exp(pi/2)/24 - x**5*exp(pi/2)/6 + O(x**6))
+
+    f = exp(acosh(x))
+    assert fps(f, x).truncate() == I + x - I*x**2/2 - I*x**4/8 + O(x**6)
+
+    f = atan(1/x)
+    assert fps(f, x).truncate() == pi/2 - x + x**3/3 - x**5/5 + O(x**6)
+
+    f = x*atan(x) - log(1 + x**2) / 2
+    assert fps(f, x, rational=False).truncate() == x**2/2 - x**4/12 + O(x**6)
+
+    f = log(1 + x)
+    assert fps(f, x, rational=False).truncate() == \
+        x - x**2/2 + x**3/3 - x**4/4 + x**5/5 + O(x**6)
+
+    f = airyai(x**2)
+    assert fps(f, x).truncate() == \
+        (3**Rational(5, 6)*gamma(Rational(1, 3))/(6*pi) -
+         3**Rational(2, 3)*x**2/(3*gamma(Rational(1, 3))) + O(x**6))
+
+    f = exp(x)*sin(x)
+    assert fps(f, x).truncate() == x + x**2 + x**3/3 - x**5/30 + O(x**6)
+
+    f = exp(x)*sin(x)/x
+    assert fps(f, x).truncate() == 1 + x + x**2/3 - x**4/30 - x**5/90 + O(x**6)
+
+    f = sin(x) * cos(x)
+    assert fps(f, x).truncate() == x - 2*x**3/3 + 2*x**5/15 + O(x**6)
+
+
+def test_fps_shift():
+    f = x**-5*sin(x)
+    assert fps(f, x).truncate() == \
+        1/x**4 - 1/(6*x**2) + Rational(1, 120) - x**2/5040 + x**4/362880 + O(x**6)
+
+    f = x**2*atan(x)
+    assert fps(f, x, rational=False).truncate() == \
+        x**3 - x**5/3 + O(x**6)
+
+    f = cos(sqrt(x))*x
+    assert fps(f, x).truncate() == \
+        x - x**2/2 + x**3/24 - x**4/720 + x**5/40320 + O(x**6)
+
+    f = x**2*cos(sqrt(x))
+    assert fps(f, x).truncate() == \
+        x**2 - x**3/2 + x**4/24 - x**5/720 + O(x**6)
+
+
+def test_fps__Add_expr():
+    f = x*atan(x) - log(1 + x**2) / 2
+    assert fps(f, x).truncate() == x**2/2 - x**4/12 + O(x**6)
+
+    f = sin(x) + cos(x) - exp(x) + log(1 + x)
+    assert fps(f, x).truncate() == x - 3*x**2/2 - x**4/4 + x**5/5 + O(x**6)
+
+    f = 1/x + sin(x)
+    assert fps(f, x).truncate() == 1/x + x - x**3/6 + x**5/120 + O(x**6)
+
+    f = sin(x) - cos(x) + 1/(x - 1)
+    assert fps(f, x).truncate() == \
+        -2 - x**2/2 - 7*x**3/6 - 25*x**4/24 - 119*x**5/120 + O(x**6)
+
+
+def test_fps__asymptotic():
+    f = exp(x)
+    assert fps(f, x, oo) == f
+    assert fps(f, x, -oo).truncate() == O(1/x**6, (x, oo))
+
+    f = erf(x)
+    assert fps(f, x, oo).truncate() == 1 + O(1/x**6, (x, oo))
+    assert fps(f, x, -oo).truncate() == -1 + O(1/x**6, (x, oo))
+
+    f = atan(x)
+    assert fps(f, x, oo, full=True).truncate() == \
+        -1/(5*x**5) + 1/(3*x**3) - 1/x + pi/2 + O(1/x**6, (x, oo))
+    assert fps(f, x, -oo, full=True).truncate() == \
+        -1/(5*x**5) + 1/(3*x**3) - 1/x - pi/2 + O(1/x**6, (x, oo))
+
+    f = log(1 + x)
+    assert fps(f, x, oo) != \
+        (-1/(5*x**5) - 1/(4*x**4) + 1/(3*x**3) - 1/(2*x**2) + 1/x - log(1/x) +
+         O(1/x**6, (x, oo)))
+    assert fps(f, x, -oo) != \
+        (-1/(5*x**5) - 1/(4*x**4) + 1/(3*x**3) - 1/(2*x**2) + 1/x + I*pi -
+         log(-1/x) + O(1/x**6, (x, oo)))
+
+
+def test_fps__fractional():
+    f = sin(sqrt(x)) / x
+    assert fps(f, x).truncate() == \
+        (1/sqrt(x) - sqrt(x)/6 + x**Rational(3, 2)/120 -
+         x**Rational(5, 2)/5040 + x**Rational(7, 2)/362880 -
+         x**Rational(9, 2)/39916800 + x**Rational(11, 2)/6227020800 + O(x**6))
+
+    f = sin(sqrt(x)) * x
+    assert fps(f, x).truncate() == \
+        (x**Rational(3, 2) - x**Rational(5, 2)/6 + x**Rational(7, 2)/120 -
+         x**Rational(9, 2)/5040 + x**Rational(11, 2)/362880 + O(x**6))
+
+    f = atan(sqrt(x)) / x**2
+    assert fps(f, x).truncate() == \
+        (x**Rational(-3, 2) - x**Rational(-1, 2)/3 + x**S.Half/5 -
+         x**Rational(3, 2)/7 + x**Rational(5, 2)/9 - x**Rational(7, 2)/11 +
+         x**Rational(9, 2)/13 - x**Rational(11, 2)/15 + O(x**6))
+
+    f = exp(sqrt(x))
+    assert fps(f, x).truncate().expand() == \
+        (1 + x/2 + x**2/24 + x**3/720 + x**4/40320 + x**5/3628800 + sqrt(x) +
+         x**Rational(3, 2)/6 + x**Rational(5, 2)/120 + x**Rational(7, 2)/5040 +
+         x**Rational(9, 2)/362880 + x**Rational(11, 2)/39916800 + O(x**6))
+
+    f = exp(sqrt(x))*x
+    assert fps(f, x).truncate().expand() == \
+        (x + x**2/2 + x**3/24 + x**4/720 + x**5/40320 + x**Rational(3, 2) +
+         x**Rational(5, 2)/6 + x**Rational(7, 2)/120 + x**Rational(9, 2)/5040 +
+         x**Rational(11, 2)/362880 + O(x**6))
+
+
+def test_fps__logarithmic_singularity():
+    f = log(1 + 1/x)
+    assert fps(f, x) != \
+        -log(x) + x - x**2/2 + x**3/3 - x**4/4 + x**5/5 + O(x**6)
+    assert fps(f, x, rational=False) != \
+        -log(x) + x - x**2/2 + x**3/3 - x**4/4 + x**5/5 + O(x**6)
+
+
+@XFAIL
+def test_fps__logarithmic_singularity_fail():
+    f = asech(x)  # Algorithms for computing limits probably needs improvements
+    assert fps(f, x) == log(2) - log(x) - x**2/4 - 3*x**4/64 + O(x**6)
+
+
+def test_fps_symbolic():
+    f = x**n*sin(x**2)
+    assert fps(f, x).truncate(8) == x**(n + 2) - x**(n + 6)/6 + O(x**(n + 8), x)
+
+    f = x**n*log(1 + x)
+    fp = fps(f, x)
+    k = fp.ak.variables[0]
+    assert fp.infinite == \
+        Sum((-(-1)**(-k)*x**(k + n))/k, (k, 1, oo))
+
+    f = (x - 2)**n*log(1 + x)
+    assert fps(f, x, 2).truncate() == \
+        ((x - 2)**n*log(3) + (x - 2)**(n + 1)/3 - (x - 2)**(n + 2)/18 + (x - 2)**(n + 3)/81 -
+         (x - 2)**(n + 4)/324 + (x - 2)**(n + 5)/1215 + O((x - 2)**(n + 6), (x, 2)))
+
+    f = x**(n - 2)*cos(x)
+    assert fps(f, x).truncate() == \
+        (x**(n - 2) - x**n/2 + x**(n + 2)/24 + O(x**(n + 4), x))
+
+    f = x**(n - 2)*sin(x) + x**n*exp(x)
+    assert fps(f, x).truncate() == \
+        (x**(n - 1) + x**(n + 1) + x**(n + 2)/2 + x**n +
+         x**(n + 4)/24 + x**(n + 5)/60 + O(x**(n + 6), x))
+
+    f = x**n*atan(x)
+    assert fps(f, x, oo).truncate() == \
+        (-x**(n - 5)/5 + x**(n - 3)/3 + x**n*(pi/2 - 1/x) +
+         O((1/x)**(-n)/x**6, (x, oo)))
+
+    f = x**(n/2)*cos(x)
+    assert fps(f, x).truncate() == \
+        x**(n/2) - x**(n/2 + 2)/2 + x**(n/2 + 4)/24 + O(x**(n/2 + 6), x)
+
+    f = x**(n + m)*sin(x)
+    assert fps(f, x).truncate() == \
+        x**(m + n + 1) - x**(m + n + 3)/6 + x**(m + n + 5)/120 + O(x**(m + n + 6), x)
+
+
+def test_fps__slow():
+    f = x*exp(x)*sin(2*x)  # TODO: rsolve needs improvement
+    assert fps(f, x).truncate() == 2*x**2 + 2*x**3 - x**4/3 - x**5 + O(x**6)
+
+
+def test_fps__operations():
+    f1, f2 = fps(sin(x)), fps(cos(x))
+
+    fsum = f1 + f2
+    assert fsum.function == sin(x) + cos(x)
+    assert fsum.truncate() == \
+        1 + x - x**2/2 - x**3/6 + x**4/24 + x**5/120 + O(x**6)
+
+    fsum = f1 + 1
+    assert fsum.function == sin(x) + 1
+    assert fsum.truncate() == 1 + x - x**3/6 + x**5/120 + O(x**6)
+
+    fsum = 1 + f2
+    assert fsum.function == cos(x) + 1
+    assert fsum.truncate() == 2 - x**2/2 + x**4/24 + O(x**6)
+
+    assert (f1 + x) == Add(f1, x)
+
+    assert -f2.truncate() == -1 + x**2/2 - x**4/24 + O(x**6)
+    assert (f1 - f1) is S.Zero
+
+    fsub = f1 - f2
+    assert fsub.function == sin(x) - cos(x)
+    assert fsub.truncate() == \
+        -1 + x + x**2/2 - x**3/6 - x**4/24 + x**5/120 + O(x**6)
+
+    fsub = f1 - 1
+    assert fsub.function == sin(x) - 1
+    assert fsub.truncate() == -1 + x - x**3/6 + x**5/120 + O(x**6)
+
+    fsub = 1 - f2
+    assert fsub.function == -cos(x) + 1
+    assert fsub.truncate() == x**2/2 - x**4/24 + O(x**6)
+
+    raises(ValueError, lambda: f1 + fps(exp(x), dir=-1))
+    raises(ValueError, lambda: f1 + fps(exp(x), x0=1))
+
+    fm = f1 * 3
+
+    assert fm.function == 3*sin(x)
+    assert fm.truncate() == 3*x - x**3/2 + x**5/40 + O(x**6)
+
+    fm = 3 * f2
+
+    assert fm.function == 3*cos(x)
+    assert fm.truncate() == 3 - 3*x**2/2 + x**4/8 + O(x**6)
+
+    assert (f1 * f2) == Mul(f1, f2)
+    assert (f1 * x) == Mul(f1, x)
+
+    fd = f1.diff()
+    assert fd.function == cos(x)
+    assert fd.truncate() == 1 - x**2/2 + x**4/24 + O(x**6)
+
+    fd = f2.diff()
+    assert fd.function == -sin(x)
+    assert fd.truncate() == -x + x**3/6 - x**5/120 + O(x**6)
+
+    fd = f2.diff().diff()
+    assert fd.function == -cos(x)
+    assert fd.truncate() == -1 + x**2/2 - x**4/24 + O(x**6)
+
+    f3 = fps(exp(sqrt(x)))
+    fd = f3.diff()
+    assert fd.truncate().expand() == \
+        (1/(2*sqrt(x)) + S.Half + x/12 + x**2/240 + x**3/10080 + x**4/725760 +
+         x**5/79833600 + sqrt(x)/4 + x**Rational(3, 2)/48 + x**Rational(5, 2)/1440 +
+         x**Rational(7, 2)/80640 + x**Rational(9, 2)/7257600 + x**Rational(11, 2)/958003200 +
+         O(x**6))
+
+    assert f1.integrate((x, 0, 1)) == -cos(1) + 1
+    assert integrate(f1, (x, 0, 1)) == -cos(1) + 1
+
+    fi = integrate(f1, x)
+    assert fi.function == -cos(x)
+    assert fi.truncate() == -1 + x**2/2 - x**4/24 + O(x**6)
+
+    fi = f2.integrate(x)
+    assert fi.function == sin(x)
+    assert fi.truncate() == x - x**3/6 + x**5/120 + O(x**6)
+
+def test_fps__product():
+    f1, f2, f3 = fps(sin(x)), fps(exp(x)), fps(cos(x))
+
+    raises(ValueError, lambda: f1.product(exp(x), x))
+    raises(ValueError, lambda: f1.product(fps(exp(x), dir=-1), x, 4))
+    raises(ValueError, lambda: f1.product(fps(exp(x), x0=1), x, 4))
+    raises(ValueError, lambda: f1.product(fps(exp(y)), x, 4))
+
+    fprod = f1.product(f2, x)
+    assert isinstance(fprod, FormalPowerSeriesProduct)
+    assert isinstance(fprod.ffps, FormalPowerSeries)
+    assert isinstance(fprod.gfps, FormalPowerSeries)
+    assert fprod.f == sin(x)
+    assert fprod.g == exp(x)
+    assert fprod.function == sin(x) * exp(x)
+    assert fprod._eval_terms(4) == x + x**2 + x**3/3
+    assert fprod.truncate(4) == x + x**2 + x**3/3 + O(x**4)
+    assert fprod.polynomial(4) == x + x**2 + x**3/3
+
+    raises(NotImplementedError, lambda: fprod._eval_term(5))
+    raises(NotImplementedError, lambda: fprod.infinite)
+    raises(NotImplementedError, lambda: fprod._eval_derivative(x))
+    raises(NotImplementedError, lambda: fprod.integrate(x))
+
+    assert f1.product(f3, x)._eval_terms(4) == x - 2*x**3/3
+    assert f1.product(f3, x).truncate(4) == x - 2*x**3/3 + O(x**4)
+
+
+def test_fps__compose():
+    f1, f2, f3 = fps(exp(x)), fps(sin(x)), fps(cos(x))
+
+    raises(ValueError, lambda: f1.compose(sin(x), x))
+    raises(ValueError, lambda: f1.compose(fps(sin(x), dir=-1), x, 4))
+    raises(ValueError, lambda: f1.compose(fps(sin(x), x0=1), x, 4))
+    raises(ValueError, lambda: f1.compose(fps(sin(y)), x, 4))
+
+    raises(ValueError, lambda: f1.compose(f3, x))
+    raises(ValueError, lambda: f2.compose(f3, x))
+
+    fcomp = f1.compose(f2, x)
+    assert isinstance(fcomp, FormalPowerSeriesCompose)
+    assert isinstance(fcomp.ffps, FormalPowerSeries)
+    assert isinstance(fcomp.gfps, FormalPowerSeries)
+    assert fcomp.f == exp(x)
+    assert fcomp.g == sin(x)
+    assert fcomp.function == exp(sin(x))
+    assert fcomp._eval_terms(6) == 1 + x + x**2/2 - x**4/8 - x**5/15
+    assert fcomp.truncate() == 1 + x + x**2/2 - x**4/8 - x**5/15 + O(x**6)
+    assert fcomp.truncate(5) == 1 + x + x**2/2 - x**4/8 + O(x**5)
+
+    raises(NotImplementedError, lambda: fcomp._eval_term(5))
+    raises(NotImplementedError, lambda: fcomp.infinite)
+    raises(NotImplementedError, lambda: fcomp._eval_derivative(x))
+    raises(NotImplementedError, lambda: fcomp.integrate(x))
+
+    assert f1.compose(f2, x).truncate(4) == 1 + x + x**2/2 + O(x**4)
+    assert f1.compose(f2, x).truncate(8) == \
+        1 + x + x**2/2 - x**4/8 - x**5/15 - x**6/240 + x**7/90 + O(x**8)
+    assert f1.compose(f2, x).truncate(6) == \
+        1 + x + x**2/2 - x**4/8 - x**5/15 + O(x**6)
+
+    assert f2.compose(f2, x).truncate(4) == x - x**3/3 + O(x**4)
+    assert f2.compose(f2, x).truncate(8) == x - x**3/3 + x**5/10 - 8*x**7/315 + O(x**8)
+    assert f2.compose(f2, x).truncate(6) == x - x**3/3 + x**5/10 + O(x**6)
+
+
+def test_fps__inverse():
+    f1, f2, f3 = fps(sin(x)), fps(exp(x)), fps(cos(x))
+
+    raises(ValueError, lambda: f1.inverse(x))
+
+    finv = f2.inverse(x)
+    assert isinstance(finv, FormalPowerSeriesInverse)
+    assert isinstance(finv.ffps, FormalPowerSeries)
+    raises(ValueError, lambda: finv.gfps)
+
+    assert finv.f == exp(x)
+    assert finv.function == exp(-x)
+    assert finv._eval_terms(5) == 1 - x + x**2/2 - x**3/6 + x**4/24
+    assert finv.truncate() == 1 - x + x**2/2 - x**3/6 + x**4/24 - x**5/120 + O(x**6)
+    assert finv.truncate(5) == 1 - x + x**2/2 - x**3/6 + x**4/24 + O(x**5)
+
+    raises(NotImplementedError, lambda: finv._eval_term(5))
+    raises(ValueError, lambda: finv.g)
+    raises(NotImplementedError, lambda: finv.infinite)
+    raises(NotImplementedError, lambda: finv._eval_derivative(x))
+    raises(NotImplementedError, lambda: finv.integrate(x))
+
+    assert f2.inverse(x).truncate(8) == \
+        1 - x + x**2/2 - x**3/6 + x**4/24 - x**5/120 + x**6/720 - x**7/5040 + O(x**8)
+
+    assert f3.inverse(x).truncate() == 1 + x**2/2 + 5*x**4/24 + O(x**6)
+    assert f3.inverse(x).truncate(8) == 1 + x**2/2 + 5*x**4/24 + 61*x**6/720 + O(x**8)
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/series/tests/test_fourier.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/series/tests/test_fourier.py
new file mode 100644
index 0000000000000000000000000000000000000000..994f182088b09b038e0e1b3885fec1c27f69f2b0
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/series/tests/test_fourier.py
@@ -0,0 +1,165 @@
+from sympy.core.add import Add
+from sympy.core.numbers import (Rational, oo, pi)
+from sympy.core.singleton import S
+from sympy.core.symbol import symbols
+from sympy.functions.elementary.exponential import (exp, log)
+from sympy.functions.elementary.piecewise import Piecewise
+from sympy.functions.elementary.trigonometric import (cos, sin, sinc, tan)
+from sympy.series.fourier import fourier_series
+from sympy.series.fourier import FourierSeries
+from sympy.testing.pytest import raises
+from functools import lru_cache
+
+x, y, z = symbols('x y z')
+
+# Don't declare these during import because they are slow
+@lru_cache()
+def _get_examples():
+    fo = fourier_series(x, (x, -pi, pi))
+    fe = fourier_series(x**2, (-pi, pi))
+    fp = fourier_series(Piecewise((0, x < 0), (pi, True)), (x, -pi, pi))
+    return fo, fe, fp
+
+
+def test_FourierSeries():
+    fo, fe, fp = _get_examples()
+
+    assert fourier_series(1, (-pi, pi)) == 1
+    assert (Piecewise((0, x < 0), (pi, True)).
+            fourier_series((x, -pi, pi)).truncate()) == fp.truncate()
+    assert isinstance(fo, FourierSeries)
+    assert fo.function == x
+    assert fo.x == x
+    assert fo.period == (-pi, pi)
+
+    assert fo.term(3) == 2*sin(3*x) / 3
+    assert fe.term(3) == -4*cos(3*x) / 9
+    assert fp.term(3) == 2*sin(3*x) / 3
+
+    assert fo.as_leading_term(x) == 2*sin(x)
+    assert fe.as_leading_term(x) == pi**2 / 3
+    assert fp.as_leading_term(x) == pi / 2
+
+    assert fo.truncate() == 2*sin(x) - sin(2*x) + (2*sin(3*x) / 3)
+    assert fe.truncate() == -4*cos(x) + cos(2*x) + pi**2 / 3
+    assert fp.truncate() == 2*sin(x) + (2*sin(3*x) / 3) + pi / 2
+
+    fot = fo.truncate(n=None)
+    s = [0, 2*sin(x), -sin(2*x)]
+    for i, t in enumerate(fot):
+        if i == 3:
+            break
+        assert s[i] == t
+
+    def _check_iter(f, i):
+        for ind, t in enumerate(f):
+            assert t == f[ind]  # noqa: PLR1736
+            if ind == i:
+                break
+
+    _check_iter(fo, 3)
+    _check_iter(fe, 3)
+    _check_iter(fp, 3)
+
+    assert fo.subs(x, x**2) == fo
+
+    raises(ValueError, lambda: fourier_series(x, (0, 1, 2)))
+    raises(ValueError, lambda: fourier_series(x, (x, 0, oo)))
+    raises(ValueError, lambda: fourier_series(x*y, (0, oo)))
+
+
+def test_FourierSeries_2():
+    p = Piecewise((0, x < 0), (x, True))
+    f = fourier_series(p, (x, -2, 2))
+
+    assert f.term(3) == (2*sin(3*pi*x / 2) / (3*pi) -
+                         4*cos(3*pi*x / 2) / (9*pi**2))
+    assert f.truncate() == (2*sin(pi*x / 2) / pi - sin(pi*x) / pi -
+                            4*cos(pi*x / 2) / pi**2 + S.Half)
+
+
+def test_square_wave():
+    """Test if fourier_series approximates discontinuous function correctly."""
+    square_wave = Piecewise((1, x < pi), (-1, True))
+    s = fourier_series(square_wave, (x, 0, 2*pi))
+
+    assert s.truncate(3) == 4 / pi * sin(x) + 4 / (3 * pi) * sin(3 * x) + \
+        4 / (5 * pi) * sin(5 * x)
+    assert s.sigma_approximation(4) == 4 / pi * sin(x) * sinc(pi / 4) + \
+        4 / (3 * pi) * sin(3 * x) * sinc(3 * pi / 4)
+
+
+def test_sawtooth_wave():
+    s = fourier_series(x, (x, 0, pi))
+    assert s.truncate(4) == \
+        pi/2 - sin(2*x) - sin(4*x)/2 - sin(6*x)/3
+    s = fourier_series(x, (x, 0, 1))
+    assert s.truncate(4) == \
+        S.Half - sin(2*pi*x)/pi - sin(4*pi*x)/(2*pi) - sin(6*pi*x)/(3*pi)
+
+
+def test_FourierSeries__operations():
+    fo, fe, fp = _get_examples()
+
+    fes = fe.scale(-1).shift(pi**2)
+    assert fes.truncate() == 4*cos(x) - cos(2*x) + 2*pi**2 / 3
+
+    assert fp.shift(-pi/2).truncate() == (2*sin(x) + (2*sin(3*x) / 3) +
+                                          (2*sin(5*x) / 5))
+
+    fos = fo.scale(3)
+    assert fos.truncate() == 6*sin(x) - 3*sin(2*x) + 2*sin(3*x)
+
+    fx = fe.scalex(2).shiftx(1)
+    assert fx.truncate() == -4*cos(2*x + 2) + cos(4*x + 4) + pi**2 / 3
+
+    fl = fe.scalex(3).shift(-pi).scalex(2).shiftx(1).scale(4)
+    assert fl.truncate() == (-16*cos(6*x + 6) + 4*cos(12*x + 12) -
+                             4*pi + 4*pi**2 / 3)
+
+    raises(ValueError, lambda: fo.shift(x))
+    raises(ValueError, lambda: fo.shiftx(sin(x)))
+    raises(ValueError, lambda: fo.scale(x*y))
+    raises(ValueError, lambda: fo.scalex(x**2))
+
+
+def test_FourierSeries__neg():
+    fo, fe, fp = _get_examples()
+
+    assert (-fo).truncate() == -2*sin(x) + sin(2*x) - (2*sin(3*x) / 3)
+    assert (-fe).truncate() == +4*cos(x) - cos(2*x) - pi**2 / 3
+
+
+def test_FourierSeries__add__sub():
+    fo, fe, fp = _get_examples()
+
+    assert fo + fo == fo.scale(2)
+    assert fo - fo == 0
+    assert -fe - fe == fe.scale(-2)
+
+    assert (fo + fe).truncate() == 2*sin(x) - sin(2*x) - 4*cos(x) + cos(2*x) \
+        + pi**2 / 3
+    assert (fo - fe).truncate() == 2*sin(x) - sin(2*x) + 4*cos(x) - cos(2*x) \
+        - pi**2 / 3
+
+    assert isinstance(fo + 1, Add)
+
+    raises(ValueError, lambda: fo + fourier_series(x, (x, 0, 2)))
+
+
+def test_FourierSeries_finite():
+
+    assert fourier_series(sin(x)).truncate(1) == sin(x)
+    # assert type(fourier_series(sin(x)*log(x))).truncate() == FourierSeries
+    # assert type(fourier_series(sin(x**2+6))).truncate() == FourierSeries
+    assert fourier_series(sin(x)*log(y)*exp(z),(x,pi,-pi)).truncate() == sin(x)*log(y)*exp(z)
+    assert fourier_series(sin(x)**6).truncate(oo) == -15*cos(2*x)/32 + 3*cos(4*x)/16 - cos(6*x)/32 \
+           + Rational(5, 16)
+    assert fourier_series(sin(x) ** 6).truncate() == -15 * cos(2 * x) / 32 + 3 * cos(4 * x) / 16 \
+           + Rational(5, 16)
+    assert fourier_series(sin(4*x+3) + cos(3*x+4)).truncate(oo) ==  -sin(4)*sin(3*x) + sin(4*x)*cos(3) \
+           + cos(4)*cos(3*x) + sin(3)*cos(4*x)
+    assert fourier_series(sin(x)+cos(x)*tan(x)).truncate(oo) == 2*sin(x)
+    assert fourier_series(cos(pi*x), (x, -1, 1)).truncate(oo) == cos(pi*x)
+    assert fourier_series(cos(3*pi*x + 4) - sin(4*pi*x)*log(pi*y), (x, -1, 1)).truncate(oo) == -log(pi*y)*sin(4*pi*x)\
+           - sin(4)*sin(3*pi*x) + cos(4)*cos(3*pi*x)
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/series/tests/test_gruntz.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/series/tests/test_gruntz.py
new file mode 100644
index 0000000000000000000000000000000000000000..4cae15297048bc52a69a3d9ca57a7614cfcdc61c
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/series/tests/test_gruntz.py
@@ -0,0 +1,490 @@
+from sympy.core import EulerGamma
+from sympy.core.function import Function
+from sympy.core.numbers import (E, I, Integer, Rational, oo, pi)
+from sympy.core.singleton import S
+from sympy.core.symbol import Symbol
+from sympy.functions.elementary.exponential import (exp, log)
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import (acot, atan, cos, sin)
+from sympy.functions.special.error_functions import (Ei, erf)
+from sympy.functions.special.gamma_functions import (digamma, gamma, loggamma)
+from sympy.functions.special.zeta_functions import zeta
+from sympy.polys.polytools import cancel
+from sympy.functions.elementary.hyperbolic import cosh, coth, sinh, tanh
+from sympy.series.gruntz import compare, mrv, rewrite, mrv_leadterm, gruntz, \
+    sign
+from sympy.testing.pytest import XFAIL, raises, skip, slow
+
+"""
+This test suite is testing the limit algorithm using the bottom up approach.
+See the documentation in limits2.py. The algorithm itself is highly recursive
+by nature, so "compare" is logically the lowest part of the algorithm, yet in
+some sense it's the most complex part, because it needs to calculate a limit
+to return the result.
+
+Nevertheless, the rest of the algorithm depends on compare working correctly.
+"""
+
+x = Symbol('x', real=True)
+m = Symbol('m', real=True)
+
+
+runslow = False
+
+
+def _sskip():
+    if not runslow:
+        skip("slow")
+
+
+@slow
+def test_gruntz_evaluation():
+    # Gruntz' thesis pp. 122 to 123
+    # 8.1
+    assert gruntz(exp(x)*(exp(1/x - exp(-x)) - exp(1/x)), x, oo) == -1
+    # 8.2
+    assert gruntz(exp(x)*(exp(1/x + exp(-x) + exp(-x**2))
+                  - exp(1/x - exp(-exp(x)))), x, oo) == 1
+    # 8.3
+    assert gruntz(exp(exp(x - exp(-x))/(1 - 1/x)) - exp(exp(x)), x, oo) is oo
+    # 8.5
+    assert gruntz(exp(exp(exp(x + exp(-x)))) / exp(exp(exp(x))), x, oo) is oo
+    # 8.6
+    assert gruntz(exp(exp(exp(x))) / exp(exp(exp(x - exp(-exp(x))))),
+                  x, oo) is oo
+    # 8.7
+    assert gruntz(exp(exp(exp(x))) / exp(exp(exp(x - exp(-exp(exp(x)))))),
+                  x, oo) == 1
+    # 8.8
+    assert gruntz(exp(exp(x)) / exp(exp(x - exp(-exp(exp(x))))), x, oo) == 1
+    # 8.9
+    assert gruntz(log(x)**2 * exp(sqrt(log(x))*(log(log(x)))**2
+                  * exp(sqrt(log(log(x))) * (log(log(log(x))))**3)) / sqrt(x),
+                  x, oo) == 0
+    # 8.10
+    assert gruntz((x*log(x)*(log(x*exp(x) - x**2))**2)
+                  / (log(log(x**2 + 2*exp(exp(3*x**3*log(x)))))), x, oo) == Rational(1, 3)
+    # 8.11
+    assert gruntz((exp(x*exp(-x)/(exp(-x) + exp(-2*x**2/(x + 1)))) - exp(x))/x,
+                  x, oo) == -exp(2)
+    # 8.12
+    assert gruntz((3**x + 5**x)**(1/x), x, oo) == 5
+    # 8.13
+    assert gruntz(x/log(x**(log(x**(log(2)/log(x))))), x, oo) is oo
+    # 8.14
+    assert gruntz(exp(exp(2*log(x**5 + x)*log(log(x))))
+                  / exp(exp(10*log(x)*log(log(x)))), x, oo) is oo
+    # 8.15
+    assert gruntz(exp(exp(Rational(5, 2)*x**Rational(-5, 7) + Rational(21, 8)*x**Rational(6, 11)
+                          + 2*x**(-8) + Rational(54, 17)*x**Rational(49, 45)))**8
+                  / log(log(-log(Rational(4, 3)*x**Rational(-5, 14))))**Rational(7, 6), x, oo) is oo
+    # 8.16
+    assert gruntz((exp(4*x*exp(-x)/(1/exp(x) + 1/exp(2*x**2/(x + 1)))) - exp(x))
+                  / exp(x)**4, x, oo) == 1
+    # 8.17
+    assert gruntz(exp(x*exp(-x)/(exp(-x) + exp(-2*x**2/(x + 1))))/exp(x), x, oo) \
+        == 1
+    # 8.19
+    assert gruntz(log(x)*(log(log(x) + log(log(x))) - log(log(x)))
+                  / (log(log(x) + log(log(log(x))))), x, oo) == 1
+    # 8.20
+    assert gruntz(exp((log(log(x + exp(log(x)*log(log(x))))))
+                  / (log(log(log(exp(x) + x + log(x)))))), x, oo) == E
+    # Another
+    assert gruntz(exp(exp(exp(x + exp(-x)))) / exp(exp(x)), x, oo) is oo
+
+
+def test_gruntz_evaluation_slow():
+    _sskip()
+    # 8.4
+    assert gruntz(exp(exp(exp(x)/(1 - 1/x)))
+                  - exp(exp(exp(x)/(1 - 1/x - log(x)**(-log(x))))), x, oo) is -oo
+    # 8.18
+    assert gruntz((exp(exp(-x/(1 + exp(-x))))*exp(-x/(1 + exp(-x/(1 + exp(-x)))))
+                   *exp(exp(-x + exp(-x/(1 + exp(-x))))))
+                  / (exp(-x/(1 + exp(-x))))**2 - exp(x) + x, x, oo) == 2
+
+
+@slow
+def test_gruntz_eval_special():
+    # Gruntz, p. 126
+    assert gruntz(exp(x)*(sin(1/x + exp(-x)) - sin(1/x + exp(-x**2))), x, oo) == 1
+    assert gruntz((erf(x - exp(-exp(x))) - erf(x)) * exp(exp(x)) * exp(x**2),
+                  x, oo) == -2/sqrt(pi)
+    assert gruntz(exp(exp(x)) * (exp(sin(1/x + exp(-exp(x)))) - exp(sin(1/x))),
+                  x, oo) == 1
+    assert gruntz(exp(x)*(gamma(x + exp(-x)) - gamma(x)), x, oo) is oo
+    assert gruntz(exp(exp(digamma(digamma(x))))/x, x, oo) == exp(Rational(-1, 2))
+    assert gruntz(exp(exp(digamma(log(x))))/x, x, oo) == exp(Rational(-1, 2))
+    assert gruntz(digamma(digamma(digamma(x))), x, oo) is oo
+    assert gruntz(loggamma(loggamma(x)), x, oo) is oo
+    assert gruntz(((gamma(x + 1/gamma(x)) - gamma(x))/log(x) - cos(1/x))
+                  * x*log(x), x, oo) == Rational(-1, 2)
+    assert gruntz(x * (gamma(x - 1/gamma(x)) - gamma(x) + log(x)), x, oo) \
+        == S.Half
+    assert gruntz((gamma(x + 1/gamma(x)) - gamma(x)) / log(x), x, oo) == 1
+
+
+def test_gruntz_eval_special_slow():
+    _sskip()
+    assert gruntz(gamma(x + 1)/sqrt(2*pi)
+                  - exp(-x)*(x**(x + S.Half) + x**(x - S.Half)/12), x, oo) is oo
+    assert gruntz(exp(exp(exp(digamma(digamma(digamma(x))))))/x, x, oo) == 0
+
+
+@XFAIL
+def test_grunts_eval_special_slow_sometimes_fail():
+    _sskip()
+    # XXX This sometimes fails!!!
+    assert gruntz(exp(gamma(x - exp(-x))*exp(1/x)) - exp(gamma(x)), x, oo) is oo
+
+
+def test_gruntz_Ei():
+    assert gruntz((Ei(x - exp(-exp(x))) - Ei(x)) *exp(-x)*exp(exp(x))*x, x, oo) == -1
+
+
+@XFAIL
+def test_gruntz_eval_special_fail():
+    # TODO zeta function series
+    assert gruntz(
+        exp((log(2) + 1)*x) * (zeta(x + exp(-x)) - zeta(x)), x, oo) == -log(2)
+
+    # TODO 8.35 - 8.37 (bessel, max-min)
+
+
+def test_gruntz_hyperbolic():
+    assert gruntz(cosh(x), x, oo) is oo
+    assert gruntz(cosh(x), x, -oo) is oo
+    assert gruntz(sinh(x), x, oo) is oo
+    assert gruntz(sinh(x), x, -oo) is -oo
+    assert gruntz(2*cosh(x)*exp(x), x, oo) is oo
+    assert gruntz(2*cosh(x)*exp(x), x, -oo) == 1
+    assert gruntz(2*sinh(x)*exp(x), x, oo) is oo
+    assert gruntz(2*sinh(x)*exp(x), x, -oo) == -1
+    assert gruntz(tanh(x), x, oo) == 1
+    assert gruntz(tanh(x), x, -oo) == -1
+    assert gruntz(coth(x), x, oo) == 1
+    assert gruntz(coth(x), x, -oo) == -1
+
+
+def test_compare1():
+    assert compare(2, x, x) == "<"
+    assert compare(x, exp(x), x) == "<"
+    assert compare(exp(x), exp(x**2), x) == "<"
+    assert compare(exp(x**2), exp(exp(x)), x) == "<"
+    assert compare(1, exp(exp(x)), x) == "<"
+
+    assert compare(x, 2, x) == ">"
+    assert compare(exp(x), x, x) == ">"
+    assert compare(exp(x**2), exp(x), x) == ">"
+    assert compare(exp(exp(x)), exp(x**2), x) == ">"
+    assert compare(exp(exp(x)), 1, x) == ">"
+
+    assert compare(2, 3, x) == "="
+    assert compare(3, -5, x) == "="
+    assert compare(2, -5, x) == "="
+
+    assert compare(x, x**2, x) == "="
+    assert compare(x**2, x**3, x) == "="
+    assert compare(x**3, 1/x, x) == "="
+    assert compare(1/x, x**m, x) == "="
+    assert compare(x**m, -x, x) == "="
+
+    assert compare(exp(x), exp(-x), x) == "="
+    assert compare(exp(-x), exp(2*x), x) == "="
+    assert compare(exp(2*x), exp(x)**2, x) == "="
+    assert compare(exp(x)**2, exp(x + exp(-x)), x) == "="
+    assert compare(exp(x), exp(x + exp(-x)), x) == "="
+
+    assert compare(exp(x**2), 1/exp(x**2), x) == "="
+
+
+def test_compare2():
+    assert compare(exp(x), x**5, x) == ">"
+    assert compare(exp(x**2), exp(x)**2, x) == ">"
+    assert compare(exp(x), exp(x + exp(-x)), x) == "="
+    assert compare(exp(x + exp(-x)), exp(x), x) == "="
+    assert compare(exp(x + exp(-x)), exp(-x), x) == "="
+    assert compare(exp(-x), x, x) == ">"
+    assert compare(x, exp(-x), x) == "<"
+    assert compare(exp(x + 1/x), x, x) == ">"
+    assert compare(exp(-exp(x)), exp(x), x) == ">"
+    assert compare(exp(exp(-exp(x)) + x), exp(-exp(x)), x) == "<"
+
+
+def test_compare3():
+    assert compare(exp(exp(x)), exp(x + exp(-exp(x))), x) == ">"
+
+
+def test_sign1():
+    assert sign(Rational(0), x) == 0
+    assert sign(Rational(3), x) == 1
+    assert sign(Rational(-5), x) == -1
+    assert sign(log(x), x) == 1
+    assert sign(exp(-x), x) == 1
+    assert sign(exp(x), x) == 1
+    assert sign(-exp(x), x) == -1
+    assert sign(3 - 1/x, x) == 1
+    assert sign(-3 - 1/x, x) == -1
+    assert sign(sin(1/x), x) == 1
+    assert sign((x**Integer(2)), x) == 1
+    assert sign(x**2, x) == 1
+    assert sign(x**5, x) == 1
+
+
+def test_sign2():
+    assert sign(x, x) == 1
+    assert sign(-x, x) == -1
+    y = Symbol("y", positive=True)
+    assert sign(y, x) == 1
+    assert sign(-y, x) == -1
+    assert sign(y*x, x) == 1
+    assert sign(-y*x, x) == -1
+
+
+def mmrv(a, b):
+    return set(mrv(a, b)[0].keys())
+
+
+def test_mrv1():
+    assert mmrv(x, x) == {x}
+    assert mmrv(x + 1/x, x) == {x}
+    assert mmrv(x**2, x) == {x}
+    assert mmrv(log(x), x) == {x}
+    assert mmrv(exp(x), x) == {exp(x)}
+    assert mmrv(exp(-x), x) == {exp(-x)}
+    assert mmrv(exp(x**2), x) == {exp(x**2)}
+    assert mmrv(-exp(1/x), x) == {x}
+    assert mmrv(exp(x + 1/x), x) == {exp(x + 1/x)}
+
+
+def test_mrv2a():
+    assert mmrv(exp(x + exp(-exp(x))), x) == {exp(-exp(x))}
+    assert mmrv(exp(x + exp(-x)), x) == {exp(x + exp(-x)), exp(-x)}
+    assert mmrv(exp(1/x + exp(-x)), x) == {exp(-x)}
+
+#sometimes infinite recursion due to log(exp(x**2)) not simplifying
+
+
+def test_mrv2b():
+    assert mmrv(exp(x + exp(-x**2)), x) == {exp(-x**2)}
+
+#sometimes infinite recursion due to log(exp(x**2)) not simplifying
+
+
+def test_mrv2c():
+    assert mmrv(
+        exp(-x + 1/x**2) - exp(x + 1/x), x) == {exp(x + 1/x), exp(1/x**2 - x)}
+
+#sometimes infinite recursion due to log(exp(x**2)) not simplifying
+
+
+def test_mrv3():
+    assert mmrv(exp(x**2) + x*exp(x) + log(x)**x/x, x) == {exp(x**2)}
+    assert mmrv(
+        exp(x)*(exp(1/x + exp(-x)) - exp(1/x)), x) == {exp(x), exp(-x)}
+    assert mmrv(log(
+        x**2 + 2*exp(exp(3*x**3*log(x)))), x) == {exp(exp(3*x**3*log(x)))}
+    assert mmrv(log(x - log(x))/log(x), x) == {x}
+    assert mmrv(
+        (exp(1/x - exp(-x)) - exp(1/x))*exp(x), x) == {exp(x), exp(-x)}
+    assert mmrv(
+        1/exp(-x + exp(-x)) - exp(x), x) == {exp(x), exp(-x), exp(x - exp(-x))}
+    assert mmrv(log(log(x*exp(x*exp(x)) + 1)), x) == {exp(x*exp(x))}
+    assert mmrv(exp(exp(log(log(x) + 1/x))), x) == {x}
+
+
+def test_mrv4():
+    ln = log
+    assert mmrv((ln(ln(x) + ln(ln(x))) - ln(ln(x)))/ln(ln(x) + ln(ln(ln(x))))*ln(x),
+            x) == {x}
+    assert mmrv(log(log(x*exp(x*exp(x)) + 1)) - exp(exp(log(log(x) + 1/x))), x) == \
+        {exp(x*exp(x))}
+
+
+def mrewrite(a, b, c):
+    return rewrite(a[1], a[0], b, c)
+
+
+def test_rewrite1():
+    e = exp(x)
+    assert mrewrite(mrv(e, x), x, m) == (1/m, -x)
+    e = exp(x**2)
+    assert mrewrite(mrv(e, x), x, m) == (1/m, -x**2)
+    e = exp(x + 1/x)
+    assert mrewrite(mrv(e, x), x, m) == (1/m, -x - 1/x)
+    e = 1/exp(-x + exp(-x)) - exp(x)
+    assert mrewrite(mrv(e, x), x, m) == ((-m*exp(m) + m)*exp(-m)/m**2, -x)
+
+
+def test_rewrite2():
+    e = exp(x)*log(log(exp(x)))
+    assert mmrv(e, x) == {exp(x)}
+    assert mrewrite(mrv(e, x), x, m) == (1/m*log(x), -x)
+
+#sometimes infinite recursion due to log(exp(x**2)) not simplifying
+
+
+def test_rewrite3():
+    e = exp(-x + 1/x**2) - exp(x + 1/x)
+    #both of these are correct and should be equivalent:
+    assert mrewrite(mrv(e, x), x, m) in [(-1/m + m*exp(
+        (x**2 + x)/x**3), -x - 1/x), ((m**2 - exp((x**2 + x)/x**3))/m, x**(-2) - x)]
+
+
+def test_mrv_leadterm1():
+    assert mrv_leadterm(-exp(1/x), x) == (-1, 0)
+    assert mrv_leadterm(1/exp(-x + exp(-x)) - exp(x), x) == (-1, 0)
+    assert mrv_leadterm(
+        (exp(1/x - exp(-x)) - exp(1/x))*exp(x), x) == (-exp(1/x), 0)
+
+
+def test_mrv_leadterm2():
+    #Gruntz: p51, 3.25
+    assert mrv_leadterm((log(exp(x) + x) - x)/log(exp(x) + log(x))*exp(x), x) == \
+        (1, 0)
+
+
+def test_mrv_leadterm3():
+    #Gruntz: p56, 3.27
+    assert mmrv(exp(-x + exp(-x)*exp(-x*log(x))), x) == {exp(-x - x*log(x))}
+    assert mrv_leadterm(exp(-x + exp(-x)*exp(-x*log(x))), x) == (exp(-x), 0)
+
+
+def test_limit1():
+    assert gruntz(x, x, oo) is oo
+    assert gruntz(x, x, -oo) is -oo
+    assert gruntz(-x, x, oo) is -oo
+    assert gruntz(x**2, x, -oo) is oo
+    assert gruntz(-x**2, x, oo) is -oo
+    assert gruntz(x*log(x), x, 0, dir="+") == 0
+    assert gruntz(1/x, x, oo) == 0
+    assert gruntz(exp(x), x, oo) is oo
+    assert gruntz(-exp(x), x, oo) is -oo
+    assert gruntz(exp(x)/x, x, oo) is oo
+    assert gruntz(1/x - exp(-x), x, oo) == 0
+    assert gruntz(x + 1/x, x, oo) is oo
+
+
+def test_limit2():
+    assert gruntz(x**x, x, 0, dir="+") == 1
+    assert gruntz((exp(x) - 1)/x, x, 0) == 1
+    assert gruntz(1 + 1/x, x, oo) == 1
+    assert gruntz(-exp(1/x), x, oo) == -1
+    assert gruntz(x + exp(-x), x, oo) is oo
+    assert gruntz(x + exp(-x**2), x, oo) is oo
+    assert gruntz(x + exp(-exp(x)), x, oo) is oo
+    assert gruntz(13 + 1/x - exp(-x), x, oo) == 13
+
+
+def test_limit3():
+    a = Symbol('a')
+    assert gruntz(x - log(1 + exp(x)), x, oo) == 0
+    assert gruntz(x - log(a + exp(x)), x, oo) == 0
+    assert gruntz(exp(x)/(1 + exp(x)), x, oo) == 1
+    assert gruntz(exp(x)/(a + exp(x)), x, oo) == 1
+
+
+def test_limit4():
+    #issue 3463
+    assert gruntz((3**x + 5**x)**(1/x), x, oo) == 5
+    #issue 3463
+    assert gruntz((3**(1/x) + 5**(1/x))**x, x, 0) == 5
+
+
+@XFAIL
+def test_MrvTestCase_page47_ex3_21():
+    h = exp(-x/(1 + exp(-x)))
+    expr = exp(h)*exp(-x/(1 + h))*exp(exp(-x + h))/h**2 - exp(x) + x
+    assert mmrv(expr, x) == {1/h, exp(-x), exp(x), exp(x - h), exp(x/(1 + h))}
+
+
+def test_gruntz_I():
+    y = Symbol("y")
+    assert gruntz(I*x, x, oo) == I*oo
+    assert gruntz(y*I*x, x, oo) == y*I*oo
+    assert gruntz(y*3*I*x, x, oo) == y*I*oo
+    assert gruntz(y*3*sin(I)*x, x, oo) == y*I*oo
+
+
+def test_issue_4814():
+    assert gruntz((x + 1)**(1/log(x + 1)), x, oo) == E
+
+
+def test_intractable():
+    assert gruntz(1/gamma(x), x, oo) == 0
+    assert gruntz(1/loggamma(x), x, oo) == 0
+    assert gruntz(gamma(x)/loggamma(x), x, oo) is oo
+    assert gruntz(exp(gamma(x))/gamma(x), x, oo) is oo
+    assert gruntz(gamma(x), x, 3) == 2
+    assert gruntz(gamma(Rational(1, 7) + 1/x), x, oo) == gamma(Rational(1, 7))
+    assert gruntz(log(x**x)/log(gamma(x)), x, oo) == 1
+    assert gruntz(log(gamma(gamma(x)))/exp(x), x, oo) is oo
+
+
+def test_aseries_trig():
+    assert cancel(gruntz(1/log(atan(x)), x, oo)
+           - 1/(log(pi) + log(S.Half))) == 0
+    assert gruntz(1/acot(x), x, -oo) is -oo
+
+
+def test_exp_log_series():
+    assert gruntz(x/log(log(x*exp(x))), x, oo) is oo
+
+
+def test_issue_3644():
+    assert gruntz(((x**7 + x + 1)/(2**x + x**2))**(-1/x), x, oo) == 2
+
+
+def test_issue_6843():
+    n = Symbol('n', integer=True, positive=True)
+    r = (n + 1)*x**(n + 1)/(x**(n + 1) - 1) - x/(x - 1)
+    assert gruntz(r, x, 1).simplify() == n/2
+
+
+def test_issue_4190():
+    assert gruntz(x - gamma(1/x), x, oo) == S.EulerGamma
+
+
+@XFAIL
+def test_issue_5172():
+    n = Symbol('n')
+    r = Symbol('r', positive=True)
+    c = Symbol('c')
+    p = Symbol('p', positive=True)
+    m = Symbol('m', negative=True)
+    expr = ((2*n*(n - r + 1)/(n + r*(n - r + 1)))**c + \
+        (r - 1)*(n*(n - r + 2)/(n + r*(n - r + 1)))**c - n)/(n**c - n)
+    expr = expr.subs(c, c + 1)
+    assert gruntz(expr.subs(c, m), n, oo) == 1
+    # fail:
+    assert gruntz(expr.subs(c, p), n, oo).simplify() == \
+        (2**(p + 1) + r - 1)/(r + 1)**(p + 1)
+
+
+def test_issue_4109():
+    assert gruntz(1/gamma(x), x, 0) == 0
+    assert gruntz(x*gamma(x), x, 0) == 1
+
+
+def test_issue_6682():
+    assert gruntz(exp(2*Ei(-x))/x**2, x, 0) == exp(2*EulerGamma)
+
+
+def test_issue_7096():
+    from sympy.functions import sign
+    assert gruntz(x**-pi, x, 0, dir='-') == oo*sign((-1)**(-pi))
+
+
+def test_issue_7391_8166():
+    f = Function('f')
+    # limit should depend on the continuity of the expression at the point passed
+    raises(ValueError, lambda: gruntz(f(x), x, 4))
+    raises(ValueError, lambda: gruntz(x*f(x)**2/(x**2 + f(x)**4), x, 0))
+
+
+def test_issue_24210_25885():
+    eq = exp(x)/(1+1/x)**x**2
+    ans = sqrt(E)
+    assert gruntz(eq, x, oo) == ans
+    assert gruntz(1/eq, x, oo) == 1/ans
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/series/tests/test_kauers.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/series/tests/test_kauers.py
new file mode 100644
index 0000000000000000000000000000000000000000..bfb9044b33416bc38879649b258150ba2906250c
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/series/tests/test_kauers.py
@@ -0,0 +1,23 @@
+from sympy.series.kauers import finite_diff
+from sympy.series.kauers import finite_diff_kauers
+from sympy.abc import x, y, z, m, n, w
+from sympy.core.numbers import pi
+from sympy.functions.elementary.trigonometric import (cos, sin)
+from sympy.concrete.summations import Sum
+
+
+def test_finite_diff():
+    assert finite_diff(x**2 + 2*x + 1, x) == 2*x + 3
+    assert finite_diff(y**3 + 2*y**2 + 3*y + 5, y) == 3*y**2 + 7*y + 6
+    assert finite_diff(z**2 - 2*z + 3, z) == 2*z - 1
+    assert finite_diff(w**2 + 3*w - 2, w) == 2*w + 4
+    assert finite_diff(sin(x), x, pi/6) == -sin(x) + sin(x + pi/6)
+    assert finite_diff(cos(y), y, pi/3) == -cos(y) + cos(y + pi/3)
+    assert finite_diff(x**2 - 2*x + 3, x, 2) == 4*x
+    assert finite_diff(n**2 - 2*n + 3, n, 3) == 6*n + 3
+
+def test_finite_diff_kauers():
+    assert finite_diff_kauers(Sum(x**2, (x, 1, n))) == (n + 1)**2
+    assert finite_diff_kauers(Sum(y, (y, 1, m))) == (m + 1)
+    assert finite_diff_kauers(Sum((x*y), (x, 1, m), (y, 1, n))) == (m + 1)*(n + 1)
+    assert finite_diff_kauers(Sum((x*y**2), (x, 1, m), (y, 1, n))) == (n + 1)**2*(m + 1)
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/series/tests/test_limits.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/series/tests/test_limits.py
new file mode 100644
index 0000000000000000000000000000000000000000..aa3ab7683f057424f1c3215a06381d27687710dc
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/series/tests/test_limits.py
@@ -0,0 +1,1440 @@
+from itertools import product
+
+from sympy.concrete.summations import Sum
+from sympy.core.function import (Function, diff)
+from sympy.core import EulerGamma, GoldenRatio
+from sympy.core.mod import Mod
+from sympy.core.numbers import (E, I, Rational, oo, pi, zoo)
+from sympy.core.singleton import S
+from sympy.core.symbol import (Symbol, symbols)
+from sympy.functions.combinatorial.numbers import fibonacci
+from sympy.functions.combinatorial.factorials import (binomial, factorial, subfactorial)
+from sympy.functions.elementary.complexes import (Abs, re, sign)
+from sympy.functions.elementary.exponential import (LambertW, exp, log)
+from sympy.functions.elementary.hyperbolic import (atanh, asinh, acosh, acoth, acsch, asech, tanh, sinh)
+from sympy.functions.elementary.integers import (ceiling, floor, frac)
+from sympy.functions.elementary.miscellaneous import (cbrt, real_root, sqrt)
+from sympy.functions.elementary.piecewise import Piecewise
+from sympy.functions.elementary.trigonometric import (acos, acot, acsc, asec, asin,
+                                                      atan, cos, cot, csc, sec, sin, tan)
+from sympy.functions.special.bessel import (besseli, bessely, besselj, besselk)
+from sympy.functions.special.error_functions import (Ei, erf, erfc, erfi, fresnelc, fresnels)
+from sympy.functions.special.gamma_functions import (digamma, gamma, uppergamma)
+from sympy.functions.special.hyper import meijerg
+from sympy.integrals.integrals import (Integral, integrate)
+from sympy.series.limits import (Limit, limit)
+from sympy.simplify.simplify import (logcombine, simplify)
+from sympy.simplify.hyperexpand import hyperexpand
+
+from sympy.calculus.accumulationbounds import AccumBounds
+from sympy.core.mul import Mul
+from sympy.series.limits import heuristics
+from sympy.series.order import Order
+from sympy.testing.pytest import XFAIL, raises
+
+from sympy import elliptic_e, elliptic_k
+
+from sympy.abc import x, y, z, k
+n = Symbol('n', integer=True, positive=True)
+
+
+def test_basic1():
+    assert limit(x, x, oo) is oo
+    assert limit(x, x, -oo) is -oo
+    assert limit(-x, x, oo) is -oo
+    assert limit(x**2, x, -oo) is oo
+    assert limit(-x**2, x, oo) is -oo
+    assert limit(x*log(x), x, 0, dir="+") == 0
+    assert limit(1/x, x, oo) == 0
+    assert limit(exp(x), x, oo) is oo
+    assert limit(-exp(x), x, oo) is -oo
+    assert limit(exp(x)/x, x, oo) is oo
+    assert limit(1/x - exp(-x), x, oo) == 0
+    assert limit(x + 1/x, x, oo) is oo
+    assert limit(x - x**2, x, oo) is -oo
+    assert limit((1 + x)**(1 + sqrt(2)), x, 0) == 1
+    assert limit((1 + x)**oo, x, 0) == Limit((x + 1)**oo, x, 0)
+    assert limit((1 + x)**oo, x, 0, dir='-') == Limit((x + 1)**oo, x, 0, dir='-')
+    assert limit((1 + x + y)**oo, x, 0, dir='-') == Limit((1 + x + y)**oo, x, 0, dir='-')
+    assert limit(y/x/log(x), x, 0) == -oo*sign(y)
+    assert limit(cos(x + y)/x, x, 0) == sign(cos(y))*oo
+    assert limit(gamma(1/x + 3), x, oo) == 2
+    assert limit(S.NaN, x, -oo) is S.NaN
+    assert limit(Order(2)*x, x, S.NaN) is S.NaN
+    assert limit(1/(x - 1), x, 1, dir="+") is oo
+    assert limit(1/(x - 1), x, 1, dir="-") is -oo
+    assert limit(1/(5 - x)**3, x, 5, dir="+") is -oo
+    assert limit(1/(5 - x)**3, x, 5, dir="-") is oo
+    assert limit(1/sin(x), x, pi, dir="+") is -oo
+    assert limit(1/sin(x), x, pi, dir="-") is oo
+    assert limit(1/cos(x), x, pi/2, dir="+") is -oo
+    assert limit(1/cos(x), x, pi/2, dir="-") is oo
+    assert limit(1/tan(x**3), x, (2*pi)**Rational(1, 3), dir="+") is oo
+    assert limit(1/tan(x**3), x, (2*pi)**Rational(1, 3), dir="-") is -oo
+    assert limit(1/cot(x)**3, x, (pi*Rational(3, 2)), dir="+") is -oo
+    assert limit(1/cot(x)**3, x, (pi*Rational(3, 2)), dir="-") is oo
+    assert limit(tan(x), x, oo) == AccumBounds(S.NegativeInfinity, S.Infinity)
+    assert limit(cot(x), x, oo) == AccumBounds(S.NegativeInfinity, S.Infinity)
+    assert limit(sec(x), x, oo) == AccumBounds(S.NegativeInfinity, S.Infinity)
+    assert limit(csc(x), x, oo) == AccumBounds(S.NegativeInfinity, S.Infinity)
+
+    # test bi-directional limits
+    assert limit(sin(x)/x, x, 0, dir="+-") == 1
+    assert limit(x**2, x, 0, dir="+-") == 0
+    assert limit(1/x**2, x, 0, dir="+-") is oo
+
+    # test failing bi-directional limits
+    assert limit(1/x, x, 0, dir="+-") is zoo
+    # approaching 0
+    # from dir="+"
+    assert limit(1 + 1/x, x, 0) is oo
+    # from dir='-'
+    # Add
+    assert limit(1 + 1/x, x, 0, dir='-') is -oo
+    # Pow
+    assert limit(x**(-2), x, 0, dir='-') is oo
+    assert limit(x**(-3), x, 0, dir='-') is -oo
+    assert limit(1/sqrt(x), x, 0, dir='-') == (-oo)*I
+    assert limit(x**2, x, 0, dir='-') == 0
+    assert limit(sqrt(x), x, 0, dir='-') == 0
+    assert limit(x**-pi, x, 0, dir='-') == -oo*(-1)**(1 - pi)
+    assert limit((1 + cos(x))**oo, x, 0) == Limit((cos(x) + 1)**oo, x, 0)
+
+    # test pull request 22491
+    assert limit(1/asin(x), x, 0, dir = '+') == oo
+    assert limit(1/asin(x), x, 0, dir = '-') == -oo
+    assert limit(1/sinh(x), x, 0, dir = '+') == oo
+    assert limit(1/sinh(x), x, 0, dir = '-') == -oo
+    assert limit(log(1/x) + 1/sin(x), x, 0, dir = '+') == oo
+    assert limit(log(1/x) + 1/x, x, 0, dir = '+') == oo
+
+
+def test_basic2():
+    assert limit(x**x, x, 0, dir="+") == 1
+    assert limit((exp(x) - 1)/x, x, 0) == 1
+    assert limit(1 + 1/x, x, oo) == 1
+    assert limit(-exp(1/x), x, oo) == -1
+    assert limit(x + exp(-x), x, oo) is oo
+    assert limit(x + exp(-x**2), x, oo) is oo
+    assert limit(x + exp(-exp(x)), x, oo) is oo
+    assert limit(13 + 1/x - exp(-x), x, oo) == 13
+
+
+def test_basic3():
+    assert limit(1/x, x, 0, dir="+") is oo
+    assert limit(1/x, x, 0, dir="-") is -oo
+
+
+def test_basic4():
+    assert limit(2*x + y*x, x, 0) == 0
+    assert limit(2*x + y*x, x, 1) == 2 + y
+    assert limit(2*x**8 + y*x**(-3), x, -2) == 512 - y/8
+    assert limit(sqrt(x + 1) - sqrt(x), x, oo) == 0
+    assert integrate(1/(x**3 + 1), (x, 0, oo)) == 2*pi*sqrt(3)/9
+
+
+def test_log():
+    # https://github.com/sympy/sympy/issues/21598
+    a, b, c = symbols('a b c', positive=True)
+    A = log(a/b) - (log(a) - log(b))
+    assert A.limit(a, oo) == 0
+    assert (A * c).limit(a, oo) == 0
+
+    tau, x = symbols('tau x', positive=True)
+    # The value of manualintegrate in the issue
+    expr = tau**2*((tau - 1)*(tau + 1)*log(x + 1)/(tau**2 + 1)**2 + 1/((tau**2\
+            + 1)*(x + 1)) - (-2*tau*atan(x/tau) + (tau**2/2 - 1/2)*log(tau**2\
+            + x**2))/(tau**2 + 1)**2)
+    assert limit(expr, x, oo) == pi*tau**3/(tau**2 + 1)**2
+
+
+def test_piecewise():
+    # https://github.com/sympy/sympy/issues/18363
+    assert limit((real_root(x - 6, 3) + 2)/(x + 2), x, -2, '+') == Rational(1, 12)
+
+
+def test_piecewise2():
+    func1 = 2*sqrt(x)*Piecewise(((4*x - 2)/Abs(sqrt(4 - 4*(2*x - 1)**2)), 4*x - 2\
+            >= 0), ((2 - 4*x)/Abs(sqrt(4 - 4*(2*x - 1)**2)), True))
+    func2 = Piecewise((x**2/2, x <= 0.5), (x/2 - 0.125, True))
+    func3 = Piecewise(((x - 9) / 5, x < -1), ((x - 9) / 5, x > 4), (sqrt(Abs(x - 3)), True))
+    assert limit(func1, x, 0) == 1
+    assert limit(func2, x, 0) == 0
+    assert limit(func3, x, -1) == 2
+
+
+def test_basic5():
+    class my(Function):
+        @classmethod
+        def eval(cls, arg):
+            if arg is S.Infinity:
+                return S.NaN
+    assert limit(my(x), x, oo) == Limit(my(x), x, oo)
+
+
+def test_issue_3885():
+    assert limit(x*y + x*z, z, 2) == x*y + 2*x
+
+
+def test_Limit():
+    assert Limit(sin(x)/x, x, 0) != 1
+    assert Limit(sin(x)/x, x, 0).doit() == 1
+    assert Limit(x, x, 0, dir='+-').args == (x, x, 0, Symbol('+-'))
+
+
+def test_floor():
+    assert limit(floor(x), x, -2, "+") == -2
+    assert limit(floor(x), x, -2, "-") == -3
+    assert limit(floor(x), x, -1, "+") == -1
+    assert limit(floor(x), x, -1, "-") == -2
+    assert limit(floor(x), x, 0, "+") == 0
+    assert limit(floor(x), x, 0, "-") == -1
+    assert limit(floor(x), x, 1, "+") == 1
+    assert limit(floor(x), x, 1, "-") == 0
+    assert limit(floor(x), x, 2, "+") == 2
+    assert limit(floor(x), x, 2, "-") == 1
+    assert limit(floor(x), x, 248, "+") == 248
+    assert limit(floor(x), x, 248, "-") == 247
+
+    # https://github.com/sympy/sympy/issues/14478
+    assert limit(x*floor(3/x)/2, x, 0, '+') == Rational(3, 2)
+    assert limit(floor(x + 1/2) - floor(x), x, oo) == AccumBounds(-S.Half, S(3)/2)
+
+    # test issue 9158
+    assert limit(floor(atan(x)), x, oo) == 1
+    assert limit(floor(atan(x)), x, -oo) == -2
+    assert limit(ceiling(atan(x)), x, oo) == 2
+    assert limit(ceiling(atan(x)), x, -oo) == -1
+
+
+def test_floor_requires_robust_assumptions():
+    assert limit(floor(sin(x)), x, 0, "+") == 0
+    assert limit(floor(sin(x)), x, 0, "-") == -1
+    assert limit(floor(cos(x)), x, 0, "+") == 0
+    assert limit(floor(cos(x)), x, 0, "-") == 0
+    assert limit(floor(5 + sin(x)), x, 0, "+") == 5
+    assert limit(floor(5 + sin(x)), x, 0, "-") == 4
+    assert limit(floor(5 + cos(x)), x, 0, "+") == 5
+    assert limit(floor(5 + cos(x)), x, 0, "-") == 5
+
+
+def test_ceiling():
+    assert limit(ceiling(x), x, -2, "+") == -1
+    assert limit(ceiling(x), x, -2, "-") == -2
+    assert limit(ceiling(x), x, -1, "+") == 0
+    assert limit(ceiling(x), x, -1, "-") == -1
+    assert limit(ceiling(x), x, 0, "+") == 1
+    assert limit(ceiling(x), x, 0, "-") == 0
+    assert limit(ceiling(x), x, 1, "+") == 2
+    assert limit(ceiling(x), x, 1, "-") == 1
+    assert limit(ceiling(x), x, 2, "+") == 3
+    assert limit(ceiling(x), x, 2, "-") == 2
+    assert limit(ceiling(x), x, 248, "+") == 249
+    assert limit(ceiling(x), x, 248, "-") == 248
+
+    # https://github.com/sympy/sympy/issues/14478
+    assert limit(x*ceiling(3/x)/2, x, 0, '+') == Rational(3, 2)
+    assert limit(ceiling(x + 1/2) - ceiling(x), x, oo) == AccumBounds(-S.Half, S(3)/2)
+
+
+def test_ceiling_requires_robust_assumptions():
+    assert limit(ceiling(sin(x)), x, 0, "+") == 1
+    assert limit(ceiling(sin(x)), x, 0, "-") == 0
+    assert limit(ceiling(cos(x)), x, 0, "+") == 1
+    assert limit(ceiling(cos(x)), x, 0, "-") == 1
+    assert limit(ceiling(5 + sin(x)), x, 0, "+") == 6
+    assert limit(ceiling(5 + sin(x)), x, 0, "-") == 5
+    assert limit(ceiling(5 + cos(x)), x, 0, "+") == 6
+    assert limit(ceiling(5 + cos(x)), x, 0, "-") == 6
+
+
+def test_frac():
+    assert limit(frac(x), x, oo) == AccumBounds(0, 1)
+    assert limit(frac(x)**(1/x), x, oo) == AccumBounds(0, 1)
+    assert limit(frac(x)**(1/x), x, -oo) == AccumBounds(1, oo)
+    assert limit(frac(x)**x, x, oo) == AccumBounds(0, oo)  # wolfram gives (0, 1)
+    assert limit(frac(sin(x)), x, 0, "+") == 0
+    assert limit(frac(sin(x)), x, 0, "-") == 1
+    assert limit(frac(cos(x)), x, 0, "+-") == 1
+    assert limit(frac(x**2), x, 0, "+-") == 0
+    raises(ValueError, lambda: limit(frac(x), x, 0, '+-'))
+    assert limit(frac(-2*x + 1), x, 0, "+") == 1
+    assert limit(frac(-2*x + 1), x, 0, "-") == 0
+    assert limit(frac(x + S.Half), x, 0, "+-") == S(1)/2
+    assert limit(frac(1/x), x, 0) == AccumBounds(0, 1)
+
+
+def test_issue_14355():
+    assert limit(floor(sin(x)/x), x, 0, '+') == 0
+    assert limit(floor(sin(x)/x), x, 0, '-') == 0
+    # test comment https://github.com/sympy/sympy/issues/14355#issuecomment-372121314
+    assert limit(floor(-tan(x)/x), x, 0, '+') == -2
+    assert limit(floor(-tan(x)/x), x, 0, '-') == -2
+
+
+def test_atan():
+    x = Symbol("x", real=True)
+    assert limit(atan(x)*sin(1/x), x, 0) == 0
+    assert limit(atan(x) + sqrt(x + 1) - sqrt(x), x, oo) == pi/2
+
+
+def test_set_signs():
+    assert limit(abs(x), x, 0) == 0
+    assert limit(abs(sin(x)), x, 0) == 0
+    assert limit(abs(cos(x)), x, 0) == 1
+    assert limit(abs(sin(x + 1)), x, 0) == sin(1)
+
+    # https://github.com/sympy/sympy/issues/9449
+    assert limit((Abs(x + y) - Abs(x - y))/(2*x), x, 0) == sign(y)
+
+    # https://github.com/sympy/sympy/issues/12398
+    assert limit(Abs(log(x)/x**3), x, oo) == 0
+    assert limit(x*(Abs(log(x)/x**3)/Abs(log(x + 1)/(x + 1)**3) - 1), x, oo) == 3
+
+    # https://github.com/sympy/sympy/issues/18501
+    assert limit(Abs(log(x - 1)**3 - 1), x, 1, '+') == oo
+
+    # https://github.com/sympy/sympy/issues/18997
+    assert limit(Abs(log(x)), x, 0) == oo
+    assert limit(Abs(log(Abs(x))), x, 0) == oo
+
+    # https://github.com/sympy/sympy/issues/19026
+    z = Symbol('z', positive=True)
+    assert limit(Abs(log(z) + 1)/log(z), z, oo) == 1
+
+    # https://github.com/sympy/sympy/issues/20704
+    assert limit(z*(Abs(1/z + y) - Abs(y - 1/z))/2, z, 0) == 0
+
+    # https://github.com/sympy/sympy/issues/21606
+    assert limit(cos(z)/sign(z), z, pi, '-') == -1
+
+
+def test_heuristic():
+    x = Symbol("x", real=True)
+    assert heuristics(sin(1/x) + atan(x), x, 0, '+') == AccumBounds(-1, 1)
+    assert limit(log(2 + sqrt(atan(x))*sqrt(sin(1/x))), x, 0) == log(2)
+
+
+def test_issue_3871():
+    z = Symbol("z", positive=True)
+    f = -1/z*exp(-z*x)
+    assert limit(f, x, oo) == 0
+    assert f.limit(x, oo) == 0
+
+
+def test_exponential():
+    n = Symbol('n')
+    x = Symbol('x', real=True)
+    assert limit((1 + x/n)**n, n, oo) == exp(x)
+    assert limit((1 + x/(2*n))**n, n, oo) == exp(x/2)
+    assert limit((1 + x/(2*n + 1))**n, n, oo) == exp(x/2)
+    assert limit(((x - 1)/(x + 1))**x, x, oo) == exp(-2)
+    assert limit(1 + (1 + 1/x)**x, x, oo) == 1 + S.Exp1
+    assert limit((2 + 6*x)**x/(6*x)**x, x, oo) == exp(S('1/3'))
+
+
+def test_exponential2():
+    n = Symbol('n')
+    assert limit((1 + x/(n + sin(n)))**n, n, oo) == exp(x)
+
+
+def test_doit():
+    f = Integral(2 * x, x)
+    l = Limit(f, x, oo)
+    assert l.doit() is oo
+
+
+def test_series_AccumBounds():
+    assert limit(sin(k) - sin(k + 1), k, oo) == AccumBounds(-2, 2)
+    assert limit(cos(k) - cos(k + 1) + 1, k, oo) == AccumBounds(-1, 3)
+
+    # not the exact bound
+    assert limit(sin(k) - sin(k)*cos(k), k, oo) == AccumBounds(-2, 2)
+
+    # test for issue #9934
+    lo = (-3 + cos(1))/2
+    hi = (1 + cos(1))/2
+    t1 = Mul(AccumBounds(lo, hi), 1/(-1 + cos(1)), evaluate=False)
+    assert limit(simplify(Sum(cos(n).rewrite(exp), (n, 0, k)).doit().rewrite(sin)), k, oo) == t1
+
+    t2 = Mul(AccumBounds(-1 + sin(1)/2, sin(1)/2 + 1), 1/(1 - cos(1)))
+    assert limit(simplify(Sum(sin(n).rewrite(exp), (n, 0, k)).doit().rewrite(sin)), k, oo) == t2
+
+    assert limit(((sin(x) + 1)/2)**x, x, oo) == AccumBounds(0, oo)  # wolfram says 0
+
+    # https://github.com/sympy/sympy/issues/12312
+    e = 2**(-x)*(sin(x) + 1)**x
+    assert limit(e, x, oo) == AccumBounds(0, oo)
+
+
+def test_bessel_functions_at_infinity():
+    # Pull Request 23844 implements limits for all bessel and modified bessel
+    # functions approaching infinity along any direction i.e. abs(z0) tends to oo
+
+    assert limit(besselj(1, x), x, oo) == 0
+    assert limit(besselj(1, x), x, -oo) == 0
+    assert limit(besselj(1, x), x, I*oo) == oo*I
+    assert limit(besselj(1, x), x, -I*oo) == -oo*I
+    assert limit(bessely(1, x), x, oo) == 0
+    assert limit(bessely(1, x), x, -oo) == 0
+    assert limit(bessely(1, x), x, I*oo) == -oo
+    assert limit(bessely(1, x), x, -I*oo) == -oo
+    assert limit(besseli(1, x), x, oo) == oo
+    assert limit(besseli(1, x), x, -oo) == -oo
+    assert limit(besseli(1, x), x, I*oo) == 0
+    assert limit(besseli(1, x), x, -I*oo) == 0
+    assert limit(besselk(1, x), x, oo) == 0
+    assert limit(besselk(1, x), x, -oo) == -oo*I
+    assert limit(besselk(1, x), x, I*oo) == 0
+    assert limit(besselk(1, x), x, -I*oo) == 0
+
+    # test issue 14874
+    assert limit(besselk(0, x), x, oo) == 0
+
+
+@XFAIL
+def test_doit2():
+    f = Integral(2 * x, x)
+    l = Limit(f, x, oo)
+    # limit() breaks on the contained Integral.
+    assert l.doit(deep=False) == l
+
+
+def test_issue_2929():
+    assert limit((x * exp(x))/(exp(x) - 1), x, -oo) == 0
+
+
+def test_issue_3792():
+    assert limit((1 - cos(x))/x**2, x, S.Half) == 4 - 4*cos(S.Half)
+    assert limit(sin(sin(x + 1) + 1), x, 0) == sin(1 + sin(1))
+    assert limit(abs(sin(x + 1) + 1), x, 0) == 1 + sin(1)
+
+
+def test_issue_4090():
+    assert limit(1/(x + 3), x, 2) == Rational(1, 5)
+    assert limit(1/(x + pi), x, 2) == S.One/(2 + pi)
+    assert limit(log(x)/(x**2 + 3), x, 2) == log(2)/7
+    assert limit(log(x)/(x**2 + pi), x, 2) == log(2)/(4 + pi)
+
+
+def test_issue_4547():
+    assert limit(cot(x), x, 0, dir='+') is oo
+    assert limit(cot(x), x, pi/2, dir='+') == 0
+
+
+def test_issue_5164():
+    assert limit(x**0.5, x, oo) == oo**0.5 is oo
+    assert limit(x**0.5, x, 16) == 4 # Should this be a float?
+    assert limit(x**0.5, x, 0) == 0
+    assert limit(x**(-0.5), x, oo) == 0
+    assert limit(x**(-0.5), x, 4) == S.Half # Should this be a float?
+
+
+def test_issue_5383():
+    func = (1.0 * 1 + 1.0 * x)**(1.0 * 1 / x)
+    assert limit(func, x, 0) == E
+
+
+def test_issue_14793():
+    expr = ((x + S(1)/2) * log(x) - x + log(2*pi)/2 - \
+        log(factorial(x)) + S(1)/(12*x))*x**3
+    assert limit(expr, x, oo) == S(1)/360
+
+
+def test_issue_5183():
+    # using list(...) so py.test can recalculate values
+    tests = list(product([x, -x],
+                         [-1, 1],
+                         [2, 3, S.Half, Rational(2, 3)],
+                         ['-', '+']))
+    results = (oo, oo, -oo, oo, -oo*I, oo, -oo*(-1)**Rational(1, 3), oo,
+               0, 0, 0, 0, 0, 0, 0, 0,
+               oo, oo, oo, -oo, oo, -oo*I, oo, -oo*(-1)**Rational(1, 3),
+               0, 0, 0, 0, 0, 0, 0, 0)
+    assert len(tests) == len(results)
+    for i, (args, res) in enumerate(zip(tests, results)):
+        y, s, e, d = args
+        eq = y**(s*e)
+        try:
+            assert limit(eq, x, 0, dir=d) == res
+        except AssertionError:
+            if 0:  # change to 1 if you want to see the failing tests
+                print()
+                print(i, res, eq, d, limit(eq, x, 0, dir=d))
+            else:
+                assert None
+
+
+def test_issue_5184():
+    assert limit(sin(x)/x, x, oo) == 0
+    assert limit(atan(x), x, oo) == pi/2
+    assert limit(gamma(x), x, oo) is oo
+    assert limit(cos(x)/x, x, oo) == 0
+    assert limit(gamma(x), x, S.Half) == sqrt(pi)
+
+    r = Symbol('r', real=True)
+    assert limit(r*sin(1/r), r, 0) == 0
+
+
+def test_issue_5229():
+    assert limit((1 + y)**(1/y) - S.Exp1, y, 0) == 0
+
+
+def test_issue_4546():
+    # using list(...) so py.test can recalculate values
+    tests = list(product([cot, tan],
+                         [-pi/2, 0, pi/2, pi, pi*Rational(3, 2)],
+                         ['-', '+']))
+    results = (0, 0, -oo, oo, 0, 0, -oo, oo, 0, 0,
+               oo, -oo, 0, 0, oo, -oo, 0, 0, oo, -oo)
+    assert len(tests) == len(results)
+    for i, (args, res) in enumerate(zip(tests, results)):
+        f, l, d = args
+        eq = f(x)
+        try:
+            assert limit(eq, x, l, dir=d) == res
+        except AssertionError:
+            if 0:  # change to 1 if you want to see the failing tests
+                print()
+                print(i, res, eq, l, d, limit(eq, x, l, dir=d))
+            else:
+                assert None
+
+
+def test_issue_3934():
+    assert limit((1 + x**log(3))**(1/x), x, 0) == 1
+    assert limit((5**(1/x) + 3**(1/x))**x, x, 0) == 5
+
+
+def test_issue_5955():
+    assert limit((x**16)/(1 + x**16), x, oo) == 1
+    assert limit((x**100)/(1 + x**100), x, oo) == 1
+    assert limit((x**1885)/(1 + x**1885), x, oo) == 1
+    assert limit((x**1000/((x + 1)**1000 + exp(-x))), x, oo) == 1
+
+
+def test_newissue():
+    assert limit(exp(1/sin(x))/exp(cot(x)), x, 0) == 1
+
+
+def test_extended_real_line():
+    assert limit(x - oo, x, oo) == Limit(x - oo, x, oo)
+    assert limit(1/(x + sin(x)) - oo, x, 0) == Limit(1/(x + sin(x)) - oo, x, 0)
+    assert limit(oo/x, x, oo) == Limit(oo/x, x, oo)
+    assert limit(x - oo + 1/x, x, oo) == Limit(x - oo + 1/x, x, oo)
+
+
+@XFAIL
+def test_order_oo():
+    x = Symbol('x', positive=True)
+    assert Order(x)*oo != Order(1, x)
+    assert limit(oo/(x**2 - 4), x, oo) is oo
+
+
+def test_issue_5436():
+    raises(NotImplementedError, lambda: limit(exp(x*y), x, oo))
+    raises(NotImplementedError, lambda: limit(exp(-x*y), x, oo))
+
+
+def test_Limit_dir():
+    raises(TypeError, lambda: Limit(x, x, 0, dir=0))
+    raises(ValueError, lambda: Limit(x, x, 0, dir='0'))
+
+
+def test_polynomial():
+    assert limit((x + 1)**1000/((x + 1)**1000 + 1), x, oo) == 1
+    assert limit((x + 1)**1000/((x + 1)**1000 + 1), x, -oo) == 1
+    assert limit(x ** Rational(77, 3) / (1 + x ** Rational(77, 3)), x, oo) == 1
+    assert limit(x ** 101.1 / (1 + x ** 101.1), x, oo) == 1
+
+
+def test_rational():
+    assert limit(1/y - (1/(y + x) + x/(y + x)/y)/z, x, oo) == (z - 1)/(y*z)
+    assert limit(1/y - (1/(y + x) + x/(y + x)/y)/z, x, -oo) == (z - 1)/(y*z)
+
+
+def test_issue_5740():
+    assert limit(log(x)*z - log(2*x)*y, x, 0) == oo*sign(y - z)
+
+
+def test_issue_6366():
+    n = Symbol('n', integer=True, positive=True)
+    r = (n + 1)*x**(n + 1)/(x**(n + 1) - 1) - x/(x - 1)
+    assert limit(r, x, 1).cancel() == n/2
+
+
+def test_factorial():
+    f = factorial(x)
+    assert limit(f, x, oo) is oo
+    assert limit(x/f, x, oo) == 0
+    # see Stirling's approximation:
+    # https://en.wikipedia.org/wiki/Stirling's_approximation
+    assert limit(f/(sqrt(2*pi*x)*(x/E)**x), x, oo) == 1
+    assert limit(f, x, -oo) == gamma(-oo)
+
+
+def test_issue_6560():
+    e = (5*x**3/4 - x*Rational(3, 4) + (y*(3*x**2/2 - S.Half) +
+                             35*x**4/8 - 15*x**2/4 + Rational(3, 8))/(2*(y + 1)))
+    assert limit(e, y, oo) == 5*x**3/4 + 3*x**2/4 - 3*x/4 - Rational(1, 4)
+
+@XFAIL
+def test_issue_5172():
+    n = Symbol('n')
+    r = Symbol('r', positive=True)
+    c = Symbol('c')
+    p = Symbol('p', positive=True)
+    m = Symbol('m', negative=True)
+    expr = ((2*n*(n - r + 1)/(n + r*(n - r + 1)))**c +
+            (r - 1)*(n*(n - r + 2)/(n + r*(n - r + 1)))**c - n)/(n**c - n)
+    expr = expr.subs(c, c + 1)
+    raises(NotImplementedError, lambda: limit(expr, n, oo))
+    assert limit(expr.subs(c, m), n, oo) == 1
+    assert limit(expr.subs(c, p), n, oo).simplify() == \
+        (2**(p + 1) + r - 1)/(r + 1)**(p + 1)
+
+
+def test_issue_7088():
+    a = Symbol('a')
+    assert limit(sqrt(x/(x + a)), x, oo) == 1
+
+
+def test_branch_cuts():
+    assert limit(asin(I*x + 2), x, 0) == pi - asin(2)
+    assert limit(asin(I*x + 2), x, 0, '-') == asin(2)
+    assert limit(asin(I*x - 2), x, 0) == -asin(2)
+    assert limit(asin(I*x - 2), x, 0, '-') == -pi + asin(2)
+    assert limit(acos(I*x + 2), x, 0) == -acos(2)
+    assert limit(acos(I*x + 2), x, 0, '-') == acos(2)
+    assert limit(acos(I*x - 2), x, 0) == acos(-2)
+    assert limit(acos(I*x - 2), x, 0, '-') == 2*pi - acos(-2)
+    assert limit(atan(x + 2*I), x, 0) == I*atanh(2)
+    assert limit(atan(x + 2*I), x, 0, '-') == -pi + I*atanh(2)
+    assert limit(atan(x - 2*I), x, 0) == pi - I*atanh(2)
+    assert limit(atan(x - 2*I), x, 0, '-') == -I*atanh(2)
+    assert limit(atan(1/x), x, 0) == pi/2
+    assert limit(atan(1/x), x, 0, '-') == -pi/2
+    assert limit(atan(x), x, oo) == pi/2
+    assert limit(atan(x), x, -oo) == -pi/2
+    assert limit(acot(x + S(1)/2*I), x, 0) == pi - I*acoth(S(1)/2)
+    assert limit(acot(x + S(1)/2*I), x, 0, '-') == -I*acoth(S(1)/2)
+    assert limit(acot(x - S(1)/2*I), x, 0) == I*acoth(S(1)/2)
+    assert limit(acot(x - S(1)/2*I), x, 0, '-') == -pi + I*acoth(S(1)/2)
+    assert limit(acot(x), x, 0) == pi/2
+    assert limit(acot(x), x, 0, '-') == -pi/2
+    assert limit(asec(I*x + S(1)/2), x, 0) == asec(S(1)/2)
+    assert limit(asec(I*x + S(1)/2), x, 0, '-') == -asec(S(1)/2)
+    assert limit(asec(I*x - S(1)/2), x, 0) == 2*pi - asec(-S(1)/2)
+    assert limit(asec(I*x - S(1)/2), x, 0, '-') == asec(-S(1)/2)
+    assert limit(acsc(I*x + S(1)/2), x, 0) == acsc(S(1)/2)
+    assert limit(acsc(I*x + S(1)/2), x, 0, '-') == pi - acsc(S(1)/2)
+    assert limit(acsc(I*x - S(1)/2), x, 0) == -pi + acsc(S(1)/2)
+    assert limit(acsc(I*x - S(1)/2), x, 0, '-') == -acsc(S(1)/2)
+
+    assert limit(log(I*x - 1), x, 0) == I*pi
+    assert limit(log(I*x - 1), x, 0, '-') == -I*pi
+    assert limit(log(-I*x - 1), x, 0) == -I*pi
+    assert limit(log(-I*x - 1), x, 0, '-') == I*pi
+
+    assert limit(sqrt(I*x - 1), x, 0) == I
+    assert limit(sqrt(I*x - 1), x, 0, '-') == -I
+    assert limit(sqrt(-I*x - 1), x, 0) == -I
+    assert limit(sqrt(-I*x - 1), x, 0, '-') == I
+
+    assert limit(cbrt(I*x - 1), x, 0) == (-1)**(S(1)/3)
+    assert limit(cbrt(I*x - 1), x, 0, '-') == -(-1)**(S(2)/3)
+    assert limit(cbrt(-I*x - 1), x, 0) == -(-1)**(S(2)/3)
+    assert limit(cbrt(-I*x - 1), x, 0, '-') == (-1)**(S(1)/3)
+
+
+def test_issue_6364():
+    a = Symbol('a')
+    e = z/(1 - sqrt(1 + z)*sin(a)**2 - sqrt(1 - z)*cos(a)**2)
+    assert limit(e, z, 0) == 1/(cos(a)**2 - S.Half)
+
+
+def test_issue_6682():
+    assert limit(exp(2*Ei(-x))/x**2, x, 0) == exp(2*EulerGamma)
+
+
+def test_issue_4099():
+    a = Symbol('a')
+    assert limit(a/x, x, 0) == oo*sign(a)
+    assert limit(-a/x, x, 0) == -oo*sign(a)
+    assert limit(-a*x, x, oo) == -oo*sign(a)
+    assert limit(a*x, x, oo) == oo*sign(a)
+
+
+def test_issue_4503():
+    dx = Symbol('dx')
+    assert limit((sqrt(1 + exp(x + dx)) - sqrt(1 + exp(x)))/dx, dx, 0) == \
+        exp(x)/(2*sqrt(exp(x) + 1))
+
+
+def test_issue_6052():
+    G = meijerg((), (), (1,), (0,), -x)
+    g = hyperexpand(G)
+    assert limit(g, x, 0, '+-') == 0
+    assert limit(g, x, oo) == -oo
+
+
+def test_issue_7224():
+    expr = sqrt(x)*besseli(1,sqrt(8*x))
+    assert limit(x*diff(expr, x, x)/expr, x, 0) == 2
+    assert limit(x*diff(expr, x, x)/expr, x, 1).evalf() == 2.0
+
+
+def test_issue_7391_8166():
+    f = Function('f')
+    # limit should depend on the continuity of the expression at the point passed
+    assert limit(f(x), x, 4) == Limit(f(x), x, 4, dir='+')
+    assert limit(x*f(x)**2/(x**2 + f(x)**4), x, 0) == Limit(x*f(x)**2/(x**2 + f(x)**4), x, 0, dir='+')
+
+
+def test_issue_8208():
+    assert limit(n**(Rational(1, 1e9) - 1), n, oo) == 0
+
+
+def test_issue_8229():
+    assert limit((x**Rational(1, 4) - 2)/(sqrt(x) - 4)**Rational(2, 3), x, 16) == 0
+
+
+def test_issue_8433():
+    d, t = symbols('d t', positive=True)
+    assert limit(erf(1 - t/d), t, oo) == -1
+
+
+def test_issue_8481():
+    k = Symbol('k', integer=True, nonnegative=True)
+    lamda = Symbol('lamda', positive=True)
+    assert limit(lamda**k * exp(-lamda) / factorial(k), k, oo) == 0
+
+
+def test_issue_8462():
+    assert limit(binomial(n, n/2), n, oo) == oo
+    assert limit(binomial(n, n/2) * 3 ** (-n), n, oo) == 0
+
+
+def test_issue_8634():
+    n = Symbol('n', integer=True, positive=True)
+    x = Symbol('x')
+    assert limit(x**n, x, -oo) == oo*sign((-1)**n)
+
+
+def test_issue_8635_18176():
+    x = Symbol('x', real=True)
+    k = Symbol('k', positive=True)
+    assert limit(x**n - x**(n - 0), x, oo) == 0
+    assert limit(x**n - x**(n - 5), x, oo) == oo
+    assert limit(x**n - x**(n - 2.5), x, oo) == oo
+    assert limit(x**n - x**(n - k - 1), x, oo) == oo
+    x = Symbol('x', positive=True)
+    assert limit(x**n - x**(n - 1), x, oo) == oo
+    assert limit(x**n - x**(n + 2), x, oo) == -oo
+
+
+def test_issue_8730():
+    assert limit(subfactorial(x), x, oo) is oo
+
+
+def test_issue_9252():
+    n = Symbol('n', integer=True)
+    c = Symbol('c', positive=True)
+    assert limit((log(n))**(n/log(n)) / (1 + c)**n, n, oo) == 0
+    # limit should depend on the value of c
+    raises(NotImplementedError, lambda: limit((log(n))**(n/log(n)) / c**n, n, oo))
+
+
+def test_issue_9558():
+    assert limit(sin(x)**15, x, 0, '-') == 0
+
+
+def test_issue_10801():
+    # make sure limits work with binomial
+    assert limit(16**k / (k * binomial(2*k, k)**2), k, oo) == pi
+
+
+def test_issue_10976():
+    s, x = symbols('s x', real=True)
+    assert limit(erf(s*x)/erf(s), s, 0) == x
+
+
+def test_issue_9041():
+    assert limit(factorial(n) / ((n/exp(1))**n * sqrt(2*pi*n)), n, oo) == 1
+
+
+def test_issue_9205():
+    x, y, a = symbols('x, y, a')
+    assert Limit(x, x, a).free_symbols == {a}
+    assert Limit(x, x, a, '-').free_symbols == {a}
+    assert Limit(x + y, x + y, a).free_symbols == {a}
+    assert Limit(-x**2 + y, x**2, a).free_symbols == {y, a}
+
+
+def test_issue_9471():
+    assert limit(((27**(log(n,3)))/n**3),n,oo) == 1
+    assert limit(((27**(log(n,3)+1))/n**3),n,oo) == 27
+
+
+def test_issue_10382():
+    assert limit(fibonacci(n + 1)/fibonacci(n), n, oo) == GoldenRatio
+
+
+def test_issue_11496():
+    assert limit(erfc(log(1/x)), x, oo) == 2
+
+
+def test_issue_11879():
+    assert simplify(limit(((x+y)**n-x**n)/y, y, 0)) == n*x**(n-1)
+
+
+def test_limit_with_Float():
+    k = symbols("k")
+    assert limit(1.0 ** k, k, oo) == 1
+    assert limit(0.3*1.0**k, k, oo) == Rational(3, 10)
+
+
+def test_issue_10610():
+    assert limit(3**x*3**(-x - 1)*(x + 1)**2/x**2, x, oo) == Rational(1, 3)
+
+
+def test_issue_10868():
+    assert limit(log(x) + asech(x), x, 0, '+') == log(2)
+    assert limit(log(x) + asech(x), x, 0, '-') == log(2) + 2*I*pi
+    raises(ValueError, lambda: limit(log(x) + asech(x), x, 0, '+-'))
+    assert limit(log(x) + asech(x), x, oo) == oo
+    assert limit(log(x) + acsch(x), x, 0, '+') == log(2)
+    assert limit(log(x) + acsch(x), x, 0, '-') == -oo
+    raises(ValueError, lambda: limit(log(x) + acsch(x), x, 0, '+-'))
+    assert limit(log(x) + acsch(x), x, oo) == oo
+
+
+def test_issue_6599():
+    assert limit((n + cos(n))/n, n, oo) == 1
+
+
+def test_issue_12555():
+    assert limit((3**x + 2* x**10) / (x**10 + exp(x)), x, -oo) == 2
+    assert limit((3**x + 2* x**10) / (x**10 + exp(x)), x, oo) is oo
+
+
+def test_issue_12769():
+    r, z, x = symbols('r z x', real=True)
+    a, b, s0, K, F0, s, T = symbols('a b s0 K F0 s T', positive=True, real=True)
+    fx = (F0**b*K**b*r*s0 - sqrt((F0**2*K**(2*b)*a**2*(b - 1) + \
+        F0**(2*b)*K**2*a**2*(b - 1) + F0**(2*b)*K**(2*b)*s0**2*(b - 1)*(b**2 - 2*b + 1) - \
+        2*F0**(2*b)*K**(b + 1)*a*r*s0*(b**2 - 2*b +  1) + \
+        2*F0**(b + 1)*K**(2*b)*a*r*s0*(b**2 - 2*b + 1) - \
+        2*F0**(b + 1)*K**(b + 1)*a**2*(b - 1))/((b - 1)*(b**2 - 2*b + 1))))*(b*r -  b - r + 1)
+
+    assert fx.subs(K, F0).factor(deep=True) == limit(fx, K, F0).factor(deep=True)
+
+
+def test_issue_13332():
+    assert limit(sqrt(30)*5**(-5*x - 1)*(46656*x)**x*(5*x + 2)**(5*x + 5*S.Half) *
+                (6*x + 2)**(-6*x - 5*S.Half), x, oo) == Rational(25, 36)
+
+
+def test_issue_12564():
+    assert limit(x**2 + x*sin(x) + cos(x), x, -oo) is oo
+    assert limit(x**2 + x*sin(x) + cos(x), x, oo) is oo
+    assert limit(((x + cos(x))**2).expand(), x, oo) is oo
+    assert limit(((x + sin(x))**2).expand(), x, oo) is oo
+    assert limit(((x + cos(x))**2).expand(), x, -oo) is oo
+    assert limit(((x + sin(x))**2).expand(), x, -oo) is oo
+
+
+def test_issue_14456():
+    raises(NotImplementedError, lambda: Limit(exp(x), x, zoo).doit())
+    raises(NotImplementedError, lambda: Limit(x**2/(x+1), x, zoo).doit())
+
+
+def test_issue_14411():
+    assert limit(3*sec(4*pi*x - x/3), x, 3*pi/(24*pi - 2)) is -oo
+
+
+def test_issue_13382():
+    assert limit(x*(((x + 1)**2 + 1)/(x**2 + 1) - 1), x, oo) == 2
+
+
+def test_issue_13403():
+    assert limit(x*(-1 + (x + log(x + 1) + 1)/(x + log(x))), x, oo) == 1
+
+
+def test_issue_13416():
+    assert limit((-x**3*log(x)**3 + (x - 1)*(x + 1)**2*log(x + 1)**3)/(x**2*log(x)**3), x, oo) == 1
+
+
+def test_issue_13462():
+    assert limit(n**2*(2*n*(-(1 - 1/(2*n))**x + 1) - x - (-x**2/4 + x/4)/n), n, oo) == x**3/24 - x**2/8 + x/12
+
+
+def test_issue_13750():
+    a = Symbol('a')
+    assert limit(erf(a - x), x, oo) == -1
+    assert limit(erf(sqrt(x) - x), x, oo) == -1
+
+
+def test_issue_14276():
+    assert isinstance(limit(sin(x)**log(x), x, oo), Limit)
+    assert isinstance(limit(sin(x)**cos(x), x, oo), Limit)
+    assert isinstance(limit(sin(log(cos(x))), x, oo), Limit)
+    assert limit((1 + 1/(x**2 + cos(x)))**(x**2 + x), x, oo) == E
+
+
+def test_issue_14514():
+    assert limit((1/(log(x)**log(x)))**(1/x), x, oo) == 1
+
+
+def test_issues_14525():
+    assert limit(sin(x)**2 - cos(x) + tan(x)*csc(x), x, oo) == AccumBounds(S.NegativeInfinity, S.Infinity)
+    assert limit(sin(x)**2 - cos(x) + sin(x)*cot(x), x, oo) == AccumBounds(S.NegativeInfinity, S.Infinity)
+    assert limit(cot(x) - tan(x)**2, x, oo) == AccumBounds(S.NegativeInfinity, S.Infinity)
+    assert limit(cos(x) - tan(x)**2, x, oo) == AccumBounds(S.NegativeInfinity, S.One)
+    assert limit(sin(x) - tan(x)**2, x, oo) == AccumBounds(S.NegativeInfinity, S.One)
+    assert limit(cos(x)**2 - tan(x)**2, x, oo) == AccumBounds(S.NegativeInfinity, S.One)
+    assert limit(tan(x)**2 + sin(x)**2 - cos(x), x, oo) == AccumBounds(-S.One, S.Infinity)
+
+
+def test_issue_14574():
+    assert limit(sqrt(x)*cos(x - x**2) / (x + 1), x, oo) == 0
+
+
+def test_issue_10102():
+    assert limit(fresnels(x), x, oo) == S.Half
+    assert limit(3 + fresnels(x), x, oo) == 3 + S.Half
+    assert limit(5*fresnels(x), x, oo) == Rational(5, 2)
+    assert limit(fresnelc(x), x, oo) == S.Half
+    assert limit(fresnels(x), x, -oo) == Rational(-1, 2)
+    assert limit(4*fresnelc(x), x, -oo) == -2
+
+
+def test_issue_14377():
+    raises(NotImplementedError, lambda: limit(exp(I*x)*sin(pi*x), x, oo))
+
+
+def test_issue_15146():
+    e = (x/2) * (-2*x**3 - 2*(x**3 - 1) * x**2 * digamma(x**3 + 1) + \
+        2*(x**3 - 1) * x**2 * digamma(x**3 + x + 1) + x + 3)
+    assert limit(e, x, oo) == S(1)/3
+
+
+def test_issue_15202():
+    e = (2**x*(2 + 2**(-x)*(-2*2**x + x + 2))/(x + 1))**(x + 1)
+    assert limit(e, x, oo) == exp(1)
+
+    e = (log(x, 2)**7 + 10*x*factorial(x) + 5**x) / (factorial(x + 1) + 3*factorial(x) + 10**x)
+    assert limit(e, x, oo) == 10
+
+
+def test_issue_15282():
+    assert limit((x**2000 - (x + 1)**2000) / x**1999, x, oo) == -2000
+
+
+def test_issue_15984():
+    assert limit((-x + log(exp(x) + 1))/x, x, oo, dir='-') == 0
+
+
+def test_issue_13571():
+    assert limit(uppergamma(x, 1) / gamma(x), x, oo) == 1
+
+
+def test_issue_13575():
+    assert limit(acos(erfi(x)), x, 1) == acos(erfi(S.One))
+
+
+def test_issue_17325():
+    assert Limit(sin(x)/x, x, 0, dir="+-").doit() == 1
+    assert Limit(x**2, x, 0, dir="+-").doit() == 0
+    assert Limit(1/x**2, x, 0, dir="+-").doit() is oo
+    assert Limit(1/x, x, 0, dir="+-").doit() is zoo
+
+
+def test_issue_10978():
+    assert LambertW(x).limit(x, 0) == 0
+
+
+def test_issue_14313_comment():
+    assert limit(floor(n/2), n, oo) is oo
+
+
+def test_issue_15323():
+    d = ((1 - 1/x)**x).diff(x)
+    assert limit(d, x, 1, dir='+') == 1
+
+
+def test_issue_12571():
+    assert limit(-LambertW(-log(x))/log(x), x, 1) == 1
+
+
+def test_issue_14590():
+    assert limit((x**3*((x + 1)/x)**x)/((x + 1)*(x + 2)*(x + 3)), x, oo) == exp(1)
+
+
+def test_issue_14393():
+    a, b = symbols('a b')
+    assert limit((x**b - y**b)/(x**a - y**a), x, y) == b*y**(-a + b)/a
+
+
+def test_issue_14556():
+    assert limit(factorial(n + 1)**(1/(n + 1)) - factorial(n)**(1/n), n, oo) == exp(-1)
+
+
+def test_issue_14811():
+    assert limit(((1 + ((S(2)/3)**(x + 1)))**(2**x))/(2**((S(4)/3)**(x - 1))), x, oo) == oo
+
+
+def test_issue_16222():
+    assert limit(exp(x), x, 1000000000) == exp(1000000000)
+
+
+def test_issue_16714():
+    assert limit(((x**(x + 1) + (x + 1)**x) / x**(x + 1))**x, x, oo) == exp(exp(1))
+
+
+def test_issue_16722():
+    z = symbols('z', positive=True)
+    assert limit(binomial(n + z, n)*n**-z, n, oo) == 1/gamma(z + 1)
+    z = symbols('z', positive=True, integer=True)
+    assert limit(binomial(n + z, n)*n**-z, n, oo) == 1/gamma(z + 1)
+
+
+def test_issue_17431():
+    assert limit(((n + 1) + 1) / (((n + 1) + 2) * factorial(n + 1)) *
+                 (n + 2) * factorial(n) / (n + 1), n, oo) == 0
+    assert limit((n + 2)**2*factorial(n)/((n + 1)*(n + 3)*factorial(n + 1))
+                 , n, oo) == 0
+    assert limit((n + 1) * factorial(n) / (n * factorial(n + 1)), n, oo) == 0
+
+
+def test_issue_17671():
+    assert limit(Ei(-log(x)) - log(log(x))/x, x, 1) == EulerGamma
+
+
+def test_issue_17751():
+    a, b, c, x = symbols('a b c x', positive=True)
+    assert limit((a + 1)*x - sqrt((a + 1)**2*x**2 + b*x + c), x, oo) == -b/(2*a + 2)
+
+
+def test_issue_17792():
+    assert limit(factorial(n)/sqrt(n)*(exp(1)/n)**n, n, oo) == sqrt(2)*sqrt(pi)
+
+
+def test_issue_18118():
+    assert limit(sign(sin(x)), x, 0, "-") == -1
+    assert limit(sign(sin(x)), x, 0, "+") == 1
+
+
+def test_issue_18306():
+    assert limit(sin(sqrt(x))/sqrt(sin(x)), x, 0, '+') == 1
+
+
+def test_issue_18378():
+    assert limit(log(exp(3*x) + x)/log(exp(x) + x**100), x, oo) == 3
+
+
+def test_issue_18399():
+    assert limit((1 - S(1)/2*x)**(3*x), x, oo) is zoo
+    assert limit((-x)**x, x, oo) is zoo
+
+
+def test_issue_18442():
+    assert limit(tan(x)**(2**(sqrt(pi))), x, oo, dir='-') == Limit(tan(x)**(2**(sqrt(pi))), x, oo, dir='-')
+
+
+def test_issue_18452():
+    assert limit(abs(log(x))**x, x, 0) == 1
+    assert limit(abs(log(x))**x, x, 0, "-") == 1
+
+
+def test_issue_18473():
+    assert limit(sin(x)**(1/x), x, oo) == Limit(sin(x)**(1/x), x, oo, dir='-')
+    assert limit(cos(x)**(1/x), x, oo) == Limit(cos(x)**(1/x), x, oo, dir='-')
+    assert limit(tan(x)**(1/x), x, oo) == Limit(tan(x)**(1/x), x, oo, dir='-')
+    assert limit((cos(x) + 2)**(1/x), x, oo) == 1
+    assert limit((sin(x) + 10)**(1/x), x, oo) == 1
+    assert limit((cos(x) - 2)**(1/x), x, oo) == Limit((cos(x) - 2)**(1/x), x, oo, dir='-')
+    assert limit((cos(x) + 1)**(1/x), x, oo) == AccumBounds(0, 1)
+    assert limit((tan(x)**2)**(2/x) , x, oo) == AccumBounds(0, oo)
+    assert limit((sin(x)**2)**(1/x), x, oo) == AccumBounds(0, 1)
+    # Tests for issue #23751
+    assert limit((cos(x) + 1)**(1/x), x, -oo) == AccumBounds(1, oo)
+    assert limit((sin(x)**2)**(1/x), x, -oo) == AccumBounds(1, oo)
+    assert limit((tan(x)**2)**(2/x) , x, -oo) == AccumBounds(0, oo)
+
+
+def test_issue_18482():
+    assert limit((2*exp(3*x)/(exp(2*x) + 1))**(1/x), x, oo) == exp(1)
+
+
+def test_issue_18508():
+    assert limit(sin(x)/sqrt(1-cos(x)), x, 0) == sqrt(2)
+    assert limit(sin(x)/sqrt(1-cos(x)), x, 0, dir='+') == sqrt(2)
+    assert limit(sin(x)/sqrt(1-cos(x)), x, 0, dir='-') == -sqrt(2)
+
+
+def test_issue_18521():
+    raises(NotImplementedError, lambda: limit(exp((2 - n) * x), x, oo))
+
+
+def test_issue_18969():
+    a, b = symbols('a b', positive=True)
+    assert limit(LambertW(a), a, b) == LambertW(b)
+    assert limit(exp(LambertW(a)), a, b) == exp(LambertW(b))
+
+
+def test_issue_18992():
+    assert limit(n/(factorial(n)**(1/n)), n, oo) == exp(1)
+
+
+def test_issue_19067():
+    x = Symbol('x')
+    assert limit(gamma(x)/(gamma(x - 1)*gamma(x + 2)), x, 0) == -1
+
+
+def test_issue_19586():
+    assert limit(x**(2**x*3**(-x)), x, oo) == 1
+
+
+def test_issue_13715():
+    n = Symbol('n')
+    p = Symbol('p', zero=True)
+    assert limit(n + p, n, 0) == 0
+
+
+def test_issue_15055():
+    assert limit(n**3*((-n - 1)*sin(1/n) + (n + 2)*sin(1/(n + 1)))/(-n + 1), n, oo) == 1
+
+
+def test_issue_16708():
+    m, vi = symbols('m vi', positive=True)
+    B, ti, d = symbols('B ti d')
+    assert limit((B*ti*vi - sqrt(m)*sqrt(-2*B*d*vi + m*(vi)**2) + m*vi)/(B*vi), B, 0) == (d + ti*vi)/vi
+
+
+def test_issue_19154():
+    assert limit(besseli(1, 3 *x)/(x *besseli(1, x)**3), x , oo) == 2*sqrt(3)*pi/3
+    assert limit(besseli(1, 3 *x)/(x *besseli(1, x)**3), x , -oo) == -2*sqrt(3)*pi/3
+
+
+def test_issue_19453():
+    beta = Symbol("beta", positive=True)
+    h = Symbol("h", positive=True)
+    m = Symbol("m", positive=True)
+    w = Symbol("omega", positive=True)
+    g = Symbol("g", positive=True)
+
+    e = exp(1)
+    q = 3*h**2*beta*g*e**(0.5*h*beta*w)
+    p = m**2*w**2
+    s = e**(h*beta*w) - 1
+    Z = -q/(4*p*s) - q/(2*p*s**2) - q*(e**(h*beta*w) + 1)/(2*p*s**3)\
+            + e**(0.5*h*beta*w)/s
+    E = -diff(log(Z), beta)
+
+    assert limit(E - 0.5*h*w, beta, oo) == 0
+    assert limit(E.simplify() - 0.5*h*w, beta, oo) == 0
+
+
+def test_issue_19739():
+    assert limit((-S(1)/4)**x, x, oo) == 0
+
+
+def test_issue_19766():
+    assert limit(2**(-x)*sqrt(4**(x + 1) + 1), x, oo) == 2
+
+
+def test_issue_19770():
+    m = Symbol('m')
+    # the result is not 0 for non-real m
+    assert limit(cos(m*x)/x, x, oo) == Limit(cos(m*x)/x, x, oo, dir='-')
+    m = Symbol('m', real=True)
+    # can be improved to give the correct result 0
+    assert limit(cos(m*x)/x, x, oo) == Limit(cos(m*x)/x, x, oo, dir='-')
+    m = Symbol('m', nonzero=True)
+    assert limit(cos(m*x), x, oo) == AccumBounds(-1, 1)
+    assert limit(cos(m*x)/x, x, oo) == 0
+
+
+def test_issue_7535():
+    assert limit(tan(x)/sin(tan(x)), x, pi/2) == Limit(tan(x)/sin(tan(x)), x, pi/2, dir='+')
+    assert limit(tan(x)/sin(tan(x)), x, pi/2, dir='-') == Limit(tan(x)/sin(tan(x)), x, pi/2, dir='-')
+    assert limit(tan(x)/sin(tan(x)), x, pi/2, dir='+-') == Limit(tan(x)/sin(tan(x)), x, pi/2, dir='+-')
+    assert limit(sin(tan(x)),x,pi/2) == AccumBounds(-1, 1)
+    assert -oo*(1/sin(-oo)) == AccumBounds(-oo, oo)
+    assert oo*(1/sin(oo)) == AccumBounds(-oo, oo)
+    assert oo*(1/sin(-oo)) == AccumBounds(-oo, oo)
+    assert -oo*(1/sin(oo)) == AccumBounds(-oo, oo)
+
+
+def test_issue_20365():
+    assert limit(((x + 1)**(1/x) - E)/x, x, 0) == -E/2
+
+
+def test_issue_21031():
+    assert limit(((1 + x)**(1/x) - (1 + 2*x)**(1/(2*x)))/asin(x), x, 0) == E/2
+
+
+def test_issue_21038():
+    assert limit(sin(pi*x)/(3*x - 12), x, 4) == pi/3
+
+
+def test_issue_20578():
+    expr = abs(x) * sin(1/x)
+    assert limit(expr,x,0,'+') == 0
+    assert limit(expr,x,0,'-') == 0
+    assert limit(expr,x,0,'+-') == 0
+
+
+def test_issue_21227():
+    f = log(x)
+
+    assert f.nseries(x, logx=y) == y
+    assert f.nseries(x, logx=-x) == -x
+
+    f = log(-log(x))
+
+    assert f.nseries(x, logx=y) == log(-y)
+    assert f.nseries(x, logx=-x) == log(x)
+
+    f = log(log(x))
+
+    assert f.nseries(x, logx=y) == log(y)
+    assert f.nseries(x, logx=-x) == log(-x)
+    assert f.nseries(x, logx=x) == log(x)
+
+    f = log(log(log(1/x)))
+
+    assert f.nseries(x, logx=y) == log(log(-y))
+    assert f.nseries(x, logx=-y) == log(log(y))
+    assert f.nseries(x, logx=x) == log(log(-x))
+    assert f.nseries(x, logx=-x) == log(log(x))
+
+
+def test_issue_21415():
+    exp = (x-1)*cos(1/(x-1))
+    assert exp.limit(x,1) == 0
+    assert exp.expand().limit(x,1) == 0
+
+
+def test_issue_21530():
+    assert limit(sinh(n + 1)/sinh(n), n, oo) == E
+
+
+def test_issue_21550():
+    r = (sqrt(5) - 1)/2
+    assert limit((x - r)/(x**2 + x - 1), x, r) == sqrt(5)/5
+
+
+def test_issue_21661():
+    out = limit((x**(x + 1) * (log(x) + 1) + 1) / x, x, 11)
+    assert out == S(3138428376722)/11 + 285311670611*log(11)
+
+
+def test_issue_21701():
+    assert limit((besselj(z, x)/x**z).subs(z, 7), x, 0) == S(1)/645120
+
+
+def test_issue_21721():
+    a = Symbol('a', real=True)
+    I = integrate(1/(pi*(1 + (x - a)**2)), x)
+    assert I.limit(x, oo) == S.Half
+
+
+def test_issue_21756():
+    term = (1 - exp(-2*I*pi*z))/(1 - exp(-2*I*pi*z/5))
+    assert term.limit(z, 0) == 5
+    assert re(term).limit(z, 0) == 5
+
+
+def test_issue_21785():
+    a = Symbol('a')
+    assert sqrt((-a**2 + x**2)/(1 - x**2)).limit(a, 1, '-') == I
+
+
+def test_issue_22181():
+    assert limit((-1)**x * 2**(-x), x, oo) == 0
+
+
+def test_issue_22220():
+    e1 = sqrt(30)*atan(sqrt(30)*tan(x/2)/6)/30
+    e2 = sqrt(30)*I*(-log(sqrt(2)*tan(x/2) - 2*sqrt(15)*I/5) +
+                     +log(sqrt(2)*tan(x/2) + 2*sqrt(15)*I/5))/60
+
+    assert limit(e1, x, -pi) == -sqrt(30)*pi/60
+    assert limit(e2, x, -pi) == -sqrt(30)*pi/30
+
+    assert limit(e1, x, -pi, '-') == sqrt(30)*pi/60
+    assert limit(e2, x, -pi, '-') == 0
+
+    # test https://github.com/sympy/sympy/issues/22220#issuecomment-972727694
+    expr = log(x - I) - log(-x - I)
+    expr2 = logcombine(expr, force=True)
+    assert limit(expr, x, oo) == limit(expr2, x, oo) == I*pi
+
+    # test https://github.com/sympy/sympy/issues/22220#issuecomment-1077618340
+    expr = expr = (-log(tan(x/2) - I) +log(tan(x/2) + I))
+    assert limit(expr, x, pi, '+') == 2*I*pi
+    assert limit(expr, x, pi, '-') == 0
+
+
+def test_issue_22334():
+    k, n  = symbols('k, n', positive=True)
+    assert limit((n+1)**k/((n+1)**(k+1) - (n)**(k+1)), n, oo) == 1/(k + 1)
+    assert limit((n+1)**k/((n+1)**(k+1) - (n)**(k+1)).expand(), n, oo) == 1/(k + 1)
+    assert limit((n+1)**k/(n*(-n**k + (n + 1)**k) + (n + 1)**k), n, oo) == 1/(k + 1)
+
+
+def test_issue_22836_limit():
+    assert limit(2**(1/x)/factorial(1/(x)), x, 0) == S.Zero
+
+
+def test_sympyissue_22986():
+    assert limit(acosh(1 + 1/x)*sqrt(x), x, oo) == sqrt(2)
+
+
+def test_issue_23231():
+    f = (2**x - 2**(-x))/(2**x + 2**(-x))
+    assert limit(f, x, -oo) == -1
+
+
+def test_issue_23596():
+    assert integrate(((1 + x)/x**2)*exp(-1/x), (x, 0, oo)) == oo
+
+
+def test_issue_23752():
+    expr1 = sqrt(-I*x**2 + x - 3)
+    expr2 = sqrt(-I*x**2 + I*x - 3)
+    assert limit(expr1, x, 0, '+') == -sqrt(3)*I
+    assert limit(expr1, x, 0, '-') == -sqrt(3)*I
+    assert limit(expr2, x, 0, '+') == sqrt(3)*I
+    assert limit(expr2, x, 0, '-') == -sqrt(3)*I
+
+
+def test_issue_24276():
+    fx = log(tan(pi/2*tanh(x))).diff(x)
+    assert fx.limit(x, oo) == 2
+    assert fx.simplify().limit(x, oo) == 2
+    assert fx.rewrite(sin).limit(x, oo) == 2
+    assert fx.rewrite(sin).simplify().limit(x, oo) == 2
+
+def test_issue_25230():
+    a = Symbol('a', real = True)
+    b = Symbol('b', positive = True)
+    c = Symbol('c', negative = True)
+    n = Symbol('n', integer = True)
+    raises(NotImplementedError, lambda: limit(Mod(x, a), x, a))
+    assert limit(Mod(x, b), x, n*b, '+') == 0
+    assert limit(Mod(x, b), x, n*b, '-') == b
+    assert limit(Mod(x, c), x, n*c, '+') == c
+    assert limit(Mod(x, c), x, n*c, '-') == 0
+
+
+def test_issue_25582():
+
+    assert limit(asin(exp(x)), x, oo, '-') == -oo*I
+    assert limit(acos(exp(x)), x, oo, '-') == oo*I
+    assert limit(atan(exp(x)), x, oo, '-') == pi/2
+    assert limit(acot(exp(x)), x, oo, '-') == 0
+    assert limit(asec(exp(x)), x, oo, '-') == pi/2
+    assert limit(acsc(exp(x)), x, oo, '-') == 0
+
+
+def test_issue_25847():
+    #atan
+    assert limit(atan(sin(x)/x), x, 0, '+-') == pi/4
+    assert limit(atan(exp(1/x)), x, 0, '+') == pi/2
+    assert limit(atan(exp(1/x)), x, 0, '-') == 0
+
+    #asin
+    assert limit(asin(sin(x)/x), x, 0, '+-') == pi/2
+    assert limit(asin(exp(1/x)), x, 0, '+') == -oo*I
+    assert limit(asin(exp(1/x)), x, 0, '-') == 0
+
+    #acos
+    assert limit(acos(sin(x)/x), x, 0, '+-') == 0
+    assert limit(acos(exp(1/x)), x, 0, '+') == oo*I
+    assert limit(acos(exp(1/x)), x, 0, '-') == pi/2
+
+    #acot
+    assert limit(acot(sin(x)/x), x, 0, '+-') == pi/4
+    assert limit(acot(exp(1/x)), x, 0, '+') == 0
+    assert limit(acot(exp(1/x)), x, 0, '-') == pi/2
+
+    #asec
+    assert limit(asec(sin(x)/x), x, 0, '+-') == 0
+    assert limit(asec(exp(1/x)), x, 0, '+') == pi/2
+    assert limit(asec(exp(1/x)), x, 0, '-') == oo*I
+
+    #acsc
+    assert limit(acsc(sin(x)/x), x, 0, '+-') == pi/2
+    assert limit(acsc(exp(1/x)), x, 0, '+') == 0
+    assert limit(acsc(exp(1/x)), x, 0, '-') == -oo*I
+
+    #atanh
+    assert limit(atanh(sin(x)/x), x, 0, '+-') == oo
+    assert limit(atanh(exp(1/x)), x, 0, '+') == -I*pi/2
+    assert limit(atanh(exp(1/x)), x, 0, '-') == 0
+
+    #asinh
+    assert limit(asinh(sin(x)/x), x, 0, '+-') == log(1 + sqrt(2))
+    assert limit(asinh(exp(1/x)), x, 0, '+') == oo
+    assert limit(asinh(exp(1/x)), x, 0, '-') == 0
+
+    #acosh
+    assert limit(acosh(sin(x)/x), x, 0, '+-') == 0
+    assert limit(acosh(exp(1/x)), x, 0, '+') == oo
+    assert limit(acosh(exp(1/x)), x, 0, '-') == I*pi/2
+
+    #acoth
+    assert limit(acoth(sin(x)/x), x, 0, '+-') == oo
+    assert limit(acoth(exp(1/x)), x, 0, '+') == 0
+    assert limit(acoth(exp(1/x)), x, 0, '-') == -I*pi/2
+
+    #asech
+    assert limit(asech(sin(x)/x), x, 0, '+-') == 0
+    assert limit(asech(exp(1/x)), x, 0, '+') == I*pi/2
+    assert limit(asech(exp(1/x)), x, 0, '-') == oo
+
+    #acsch
+    assert limit(acsch(sin(x)/x), x, 0, '+-') == log(1 + sqrt(2))
+    assert limit(acsch(exp(1/x)), x, 0, '+') == 0
+    assert limit(acsch(exp(1/x)), x, 0, '-') == oo
+
+
+def test_issue_26040():
+    assert limit(besseli(0, x + 1)/besseli(0, x), x, oo) == S.Exp1
+
+
+def test_issue_26250():
+    e = elliptic_e(4*x/(x**2 + 2*x + 1))
+    k = elliptic_k(4*x/(x**2 + 2*x + 1))
+    e1 = ((1-3*x**2)*e**2/2 - (x**2-2*x+1)*e*k/2)
+    e2 = pi**2*(x**8 - 2*x**7 - x**6 + 4*x**5 - x**4 - 2*x**3 + x**2)
+    assert limit(e1/e2, x, 0) == -S(1)/8
+
+
+def test_issue_26513():
+    assert limit(abs((-x/(x+1))**x), x ,oo) == exp(-1)
+    assert limit((x/(x + 1))**x, x, oo) == exp(-1)
+    raises (NotImplementedError, lambda: limit((-x/(x+1))**x, x, oo))
+
+
+def test_issue_26916():
+    assert limit(Ei(x)*exp(-x), x, +oo) == 0
+    assert limit(Ei(x)*exp(-x), x, -oo) == 0
+
+
+def test_issue_22982_15323():
+    assert limit((log(E + 1/x) - 1)**(1 - sqrt(E + 1/x)), x, oo) == oo
+    assert limit((1 - 1/x)**x*(log(1 - 1/x) + 1/(x*(1 - 1/x))), x, 1, dir='+') == 1
+    assert limit((log(E + 1/x) )**(1 - sqrt(E + 1/x)), x, oo) == 1
+    assert limit((log(E + 1/x) - 1)**(- sqrt(E + 1/x)), x, oo) == oo
+
+
+def test_issue_26991():
+    assert limit(x/((x - 6)*sinh(tanh(0.03*x)) + tanh(x) - 0.5), x, oo) == 1/sinh(1)
+
+def test_issue_27278():
+    expr = (1/(x*log((x + 3)/x)))**x*((x + 1)*log((x + 4)/(x + 1)))**(x + 1)/3
+    assert limit(expr, x, oo) == 1
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/series/tests/test_limitseq.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/series/tests/test_limitseq.py
new file mode 100644
index 0000000000000000000000000000000000000000..362bb0397feb0ec63929920855c81279eca0bd6a
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/series/tests/test_limitseq.py
@@ -0,0 +1,177 @@
+from sympy.concrete.summations import Sum
+from sympy.core.add import Add
+from sympy.core.numbers import (I, Rational, oo, pi)
+from sympy.core.singleton import S
+from sympy.core.symbol import (Symbol, symbols)
+from sympy.functions.combinatorial.factorials import (binomial, factorial, subfactorial)
+from sympy.functions.combinatorial.numbers import (fibonacci, harmonic)
+from sympy.functions.elementary.exponential import (exp, log)
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import (cos, sin)
+from sympy.functions.special.gamma_functions import gamma
+from sympy.series.limitseq import limit_seq
+from sympy.series.limitseq import difference_delta as dd
+from sympy.testing.pytest import raises, XFAIL
+from sympy.calculus.accumulationbounds import AccumulationBounds
+
+n, m, k = symbols('n m k', integer=True)
+
+
+def test_difference_delta():
+    e = n*(n + 1)
+    e2 = e * k
+
+    assert dd(e) == 2*n + 2
+    assert dd(e2, n, 2) == k*(4*n + 6)
+
+    raises(ValueError, lambda: dd(e2))
+    raises(ValueError, lambda: dd(e2, n, oo))
+
+
+def test_difference_delta__Sum():
+    e = Sum(1/k, (k, 1, n))
+    assert dd(e, n) == 1/(n + 1)
+    assert dd(e, n, 5) == Add(*[1/(i + n + 1) for i in range(5)])
+
+    e = Sum(1/k, (k, 1, 3*n))
+    assert dd(e, n) == Add(*[1/(i + 3*n + 1) for i in range(3)])
+
+    e = n * Sum(1/k, (k, 1, n))
+    assert dd(e, n) == 1 + Sum(1/k, (k, 1, n))
+
+    e = Sum(1/k, (k, 1, n), (m, 1, n))
+    assert dd(e, n) == harmonic(n)
+
+
+def test_difference_delta__Add():
+    e = n + n*(n + 1)
+    assert dd(e, n) == 2*n + 3
+    assert dd(e, n, 2) == 4*n + 8
+
+    e = n + Sum(1/k, (k, 1, n))
+    assert dd(e, n) == 1 + 1/(n + 1)
+    assert dd(e, n, 5) == 5 + Add(*[1/(i + n + 1) for i in range(5)])
+
+
+def test_difference_delta__Pow():
+    e = 4**n
+    assert dd(e, n) == 3*4**n
+    assert dd(e, n, 2) == 15*4**n
+
+    e = 4**(2*n)
+    assert dd(e, n) == 15*4**(2*n)
+    assert dd(e, n, 2) == 255*4**(2*n)
+
+    e = n**4
+    assert dd(e, n) == (n + 1)**4 - n**4
+
+    e = n**n
+    assert dd(e, n) == (n + 1)**(n + 1) - n**n
+
+
+def test_limit_seq():
+    e = binomial(2*n, n) / Sum(binomial(2*k, k), (k, 1, n))
+    assert limit_seq(e) == S(3) / 4
+    assert limit_seq(e, m) == e
+
+    e = (5*n**3 + 3*n**2 + 4) / (3*n**3 + 4*n - 5)
+    assert limit_seq(e, n) == S(5) / 3
+
+    e = (harmonic(n) * Sum(harmonic(k), (k, 1, n))) / (n * harmonic(2*n)**2)
+    assert limit_seq(e, n) == 1
+
+    e = Sum(k**2 * Sum(2**m/m, (m, 1, k)), (k, 1, n)) / (2**n*n)
+    assert limit_seq(e, n) == 4
+
+    e = (Sum(binomial(3*k, k) * binomial(5*k, k), (k, 1, n)) /
+         (binomial(3*n, n) * binomial(5*n, n)))
+    assert limit_seq(e, n) == S(84375) / 83351
+
+    e = Sum(harmonic(k)**2/k, (k, 1, 2*n)) / harmonic(n)**3
+    assert limit_seq(e, n) == S.One / 3
+
+    raises(ValueError, lambda: limit_seq(e * m))
+
+
+def test_alternating_sign():
+    assert limit_seq((-1)**n/n**2, n) == 0
+    assert limit_seq((-2)**(n+1)/(n + 3**n), n) == 0
+    assert limit_seq((2*n + (-1)**n)/(n + 1), n) == 2
+    assert limit_seq(sin(pi*n), n) == 0
+    assert limit_seq(cos(2*pi*n), n) == 1
+    assert limit_seq((S.NegativeOne/5)**n, n) == 0
+    assert limit_seq((Rational(-1, 5))**n, n) == 0
+    assert limit_seq((I/3)**n, n) == 0
+    assert limit_seq(sqrt(n)*(I/2)**n, n) == 0
+    assert limit_seq(n**7*(I/3)**n, n) == 0
+    assert limit_seq(n/(n + 1) + (I/2)**n, n) == 1
+
+
+def test_accum_bounds():
+    assert limit_seq((-1)**n, n) == AccumulationBounds(-1, 1)
+    assert limit_seq(cos(pi*n), n) == AccumulationBounds(-1, 1)
+    assert limit_seq(sin(pi*n/2)**2, n) == AccumulationBounds(0, 1)
+    assert limit_seq(2*(-3)**n/(n + 3**n), n) == AccumulationBounds(-2, 2)
+    assert limit_seq(3*n/(n + 1) + 2*(-1)**n, n) == AccumulationBounds(1, 5)
+
+
+def test_limitseq_sum():
+    from sympy.abc import x, y, z
+    assert limit_seq(Sum(1/x, (x, 1, y)) - log(y), y) == S.EulerGamma
+    assert limit_seq(Sum(1/x, (x, 1, y)) - 1/y, y) is S.Infinity
+    assert (limit_seq(binomial(2*x, x) / Sum(binomial(2*y, y), (y, 1, x)), x) ==
+            S(3) / 4)
+    assert (limit_seq(Sum(y**2 * Sum(2**z/z, (z, 1, y)), (y, 1, x)) /
+                  (2**x*x), x) == 4)
+
+
+def test_issue_9308():
+    assert limit_seq(subfactorial(n)/factorial(n), n) == exp(-1)
+
+
+def test_issue_10382():
+    n = Symbol('n', integer=True)
+    assert limit_seq(fibonacci(n+1)/fibonacci(n), n).together() == S.GoldenRatio
+
+
+def test_issue_11672():
+    assert limit_seq(Rational(-1, 2)**n, n) == 0
+
+
+def test_issue_14196():
+    k, n  = symbols('k, n', positive=True)
+    m = Symbol('m')
+    assert limit_seq(Sum(m**k, (m, 1, n)).doit()/(n**(k + 1)), n) == 1/(k + 1)
+
+
+def test_issue_16735():
+    assert limit_seq(5**n/factorial(n), n) == 0
+
+
+def test_issue_19868():
+    assert limit_seq(1/gamma(n + S.One/2), n) == 0
+
+
+@XFAIL
+def test_limit_seq_fail():
+    # improve Summation algorithm or add ad-hoc criteria
+    e = (harmonic(n)**3 * Sum(1/harmonic(k), (k, 1, n)) /
+         (n * Sum(harmonic(k)/k, (k, 1, n))))
+    assert limit_seq(e, n) == 2
+
+    # No unique dominant term
+    e = (Sum(2**k * binomial(2*k, k) / k**2, (k, 1, n)) /
+         (Sum(2**k/k*2, (k, 1, n)) * Sum(binomial(2*k, k), (k, 1, n))))
+    assert limit_seq(e, n) == S(3) / 7
+
+    # Simplifications of summations needs to be improved.
+    e = n**3*Sum(2**k/k**2, (k, 1, n))**2 / (2**n * Sum(2**k/k, (k, 1, n)))
+    assert limit_seq(e, n) == 2
+
+    e = (harmonic(n) * Sum(2**k/k, (k, 1, n)) /
+         (n * Sum(2**k*harmonic(k)/k**2, (k, 1, n))))
+    assert limit_seq(e, n) == 1
+
+    e = (Sum(2**k*factorial(k) / k**2, (k, 1, 2*n)) /
+         (Sum(4**k/k**2, (k, 1, n)) * Sum(factorial(k), (k, 1, 2*n))))
+    assert limit_seq(e, n) == S(3) / 16
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/series/tests/test_lseries.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/series/tests/test_lseries.py
new file mode 100644
index 0000000000000000000000000000000000000000..42d327bf60c76eebdc4570d631efef4bc84b58e3
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/series/tests/test_lseries.py
@@ -0,0 +1,65 @@
+from sympy.core.numbers import E
+from sympy.core.singleton import S
+from sympy.functions.elementary.exponential import exp
+from sympy.functions.elementary.hyperbolic import tanh
+from sympy.functions.elementary.trigonometric import (cos, sin)
+from sympy.series.order import Order
+from sympy.abc import x, y
+
+
+def test_sin():
+    e = sin(x).lseries(x)
+    assert next(e) == x
+    assert next(e) == -x**3/6
+    assert next(e) == x**5/120
+
+
+def test_cos():
+    e = cos(x).lseries(x)
+    assert next(e) == 1
+    assert next(e) == -x**2/2
+    assert next(e) == x**4/24
+
+
+def test_exp():
+    e = exp(x).lseries(x)
+    assert next(e) == 1
+    assert next(e) == x
+    assert next(e) == x**2/2
+    assert next(e) == x**3/6
+
+
+def test_exp2():
+    e = exp(cos(x)).lseries(x)
+    assert next(e) == E
+    assert next(e) == -E*x**2/2
+    assert next(e) == E*x**4/6
+    assert next(e) == -31*E*x**6/720
+
+
+def test_simple():
+    assert list(x.lseries()) == [x]
+    assert list(S.One.lseries(x)) == [1]
+    assert not next((x/(x + y)).lseries(y)).has(Order)
+
+
+def test_issue_5183():
+    s = (x + 1/x).lseries()
+    assert list(s) == [1/x, x]
+    assert next((x + x**2).lseries()) == x
+    assert next(((1 + x)**7).lseries(x)) == 1
+    assert next((sin(x + y)).series(x, n=3).lseries(y)) == x
+    # it would be nice if all terms were grouped, but in the
+    # following case that would mean that all the terms would have
+    # to be known since, for example, every term has a constant in it.
+    s = ((1 + x)**7).series(x, 1, n=None)
+    assert [next(s) for i in range(2)] == [128, -448 + 448*x]
+
+
+def test_issue_6999():
+    s = tanh(x).lseries(x, 1)
+    assert next(s) == tanh(1)
+    assert next(s) == x - (x - 1)*tanh(1)**2 - 1
+    assert next(s) == -(x - 1)**2*tanh(1) + (x - 1)**2*tanh(1)**3
+    assert next(s) == -(x - 1)**3*tanh(1)**4 - (x - 1)**3/3 + \
+        4*(x - 1)**3*tanh(1)**2/3
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/series/tests/test_nseries.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/series/tests/test_nseries.py
new file mode 100644
index 0000000000000000000000000000000000000000..a2f20add82d3e858e2ce145fc9fcd4a6548a48cc
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/series/tests/test_nseries.py
@@ -0,0 +1,557 @@
+from sympy.calculus.util import AccumBounds
+from sympy.core.function import (Derivative, PoleError)
+from sympy.core.numbers import (E, I, Integer, Rational, pi)
+from sympy.core.singleton import S
+from sympy.core.symbol import (Symbol, symbols)
+from sympy.functions.elementary.complexes import sign
+from sympy.functions.elementary.exponential import (exp, log)
+from sympy.functions.elementary.hyperbolic import (acosh, acoth, asinh, atanh, cosh, coth, sinh, tanh)
+from sympy.functions.elementary.integers import (ceiling, floor, frac)
+from sympy.functions.elementary.miscellaneous import (cbrt, sqrt)
+from sympy.functions.elementary.trigonometric import (asin, cos, cot, sin, tan)
+from sympy.series.limits import limit
+from sympy.series.order import O
+from sympy.abc import x, y, z
+
+from sympy.testing.pytest import raises, XFAIL
+
+
+def test_simple_1():
+    assert x.nseries(x, n=5) == x
+    assert y.nseries(x, n=5) == y
+    assert (1/(x*y)).nseries(y, n=5) == 1/(x*y)
+    assert Rational(3, 4).nseries(x, n=5) == Rational(3, 4)
+    assert x.nseries() == x
+
+
+def test_mul_0():
+    assert (x*log(x)).nseries(x, n=5) == x*log(x)
+
+
+def test_mul_1():
+    assert (x*log(2 + x)).nseries(x, n=5) == x*log(2) + x**2/2 - x**3/8 + \
+        x**4/24 + O(x**5)
+    assert (x*log(1 + x)).nseries(
+        x, n=5) == x**2 - x**3/2 + x**4/3 + O(x**5)
+
+
+def test_pow_0():
+    assert (x**2).nseries(x, n=5) == x**2
+    assert (1/x).nseries(x, n=5) == 1/x
+    assert (1/x**2).nseries(x, n=5) == 1/x**2
+    assert (x**Rational(2, 3)).nseries(x, n=5) == (x**Rational(2, 3))
+    assert (sqrt(x)**3).nseries(x, n=5) == (sqrt(x)**3)
+
+
+def test_pow_1():
+    assert ((1 + x)**2).nseries(x, n=5) == x**2 + 2*x + 1
+
+    # https://github.com/sympy/sympy/issues/21075
+    assert ((sqrt(x) + 1)**2).nseries(x) == 2*sqrt(x) + x + 1
+    assert ((sqrt(x) + cbrt(x))**2).nseries(x) == 2*x**Rational(5, 6)\
+        + x**Rational(2, 3) + x
+
+
+def test_geometric_1():
+    assert (1/(1 - x)).nseries(x, n=5) == 1 + x + x**2 + x**3 + x**4 + O(x**5)
+    assert (x/(1 - x)).nseries(x, n=6) == x + x**2 + x**3 + x**4 + x**5 + O(x**6)
+    assert (x**3/(1 - x)).nseries(x, n=8) == x**3 + x**4 + x**5 + x**6 + \
+        x**7 + O(x**8)
+
+
+def test_sqrt_1():
+    assert sqrt(1 + x).nseries(x, n=5) == 1 + x/2 - x**2/8 + x**3/16 - 5*x**4/128 + O(x**5)
+
+
+def test_exp_1():
+    assert exp(x).nseries(x, n=5) == 1 + x + x**2/2 + x**3/6 + x**4/24 + O(x**5)
+    assert exp(x).nseries(x, n=12) == 1 + x + x**2/2 + x**3/6 + x**4/24 + x**5/120 +  \
+        x**6/720 + x**7/5040 + x**8/40320 + x**9/362880 + x**10/3628800 +  \
+        x**11/39916800 + O(x**12)
+    assert exp(1/x).nseries(x, n=5) == exp(1/x)
+    assert exp(1/(1 + x)).nseries(x, n=4) ==  \
+        (E*(1 - x - 13*x**3/6 + 3*x**2/2)).expand() + O(x**4)
+    assert exp(2 + x).nseries(x, n=5) ==  \
+        (exp(2)*(1 + x + x**2/2 + x**3/6 + x**4/24)).expand() + O(x**5)
+
+
+def test_exp_sqrt_1():
+    assert exp(1 + sqrt(x)).nseries(x, n=3) ==  \
+        (exp(1)*(1 + sqrt(x) + x/2 + sqrt(x)*x/6)).expand() + O(sqrt(x)**3)
+
+
+def test_power_x_x1():
+    assert (exp(x*log(x))).nseries(x, n=4) == \
+        1 + x*log(x) + x**2*log(x)**2/2 + x**3*log(x)**3/6 + O(x**4*log(x)**4)
+
+
+def test_power_x_x2():
+    assert (x**x).nseries(x, n=4) == \
+        1 + x*log(x) + x**2*log(x)**2/2 + x**3*log(x)**3/6 + O(x**4*log(x)**4)
+
+
+def test_log_singular1():
+    assert log(1 + 1/x).nseries(x, n=5) == x - log(x) - x**2/2 + x**3/3 - \
+        x**4/4 + O(x**5)
+
+
+def test_log_power1():
+    e = 1 / (1/x + x ** (log(3)/log(2)))
+    assert e.nseries(x, n=5) == -x**(log(3)/log(2) + 2) + x + O(x**5)
+
+
+def test_log_series():
+    l = Symbol('l')
+    e = 1/(1 - log(x))
+    assert e.nseries(x, n=5, logx=l) == 1/(1 - l)
+
+
+def test_log2():
+    e = log(-1/x)
+    assert e.nseries(x, n=5) == -log(x) + log(-1)
+
+
+def test_log3():
+    l = Symbol('l')
+    e = 1/log(-1/x)
+    assert e.nseries(x, n=4, logx=l) == 1/(-l + log(-1))
+
+
+def test_series1():
+    e = sin(x)
+    assert e.nseries(x, 0, 0) != 0
+    assert e.nseries(x, 0, 0) == O(1, x)
+    assert e.nseries(x, 0, 1) == O(x, x)
+    assert e.nseries(x, 0, 2) == x + O(x**2, x)
+    assert e.nseries(x, 0, 3) == x + O(x**3, x)
+    assert e.nseries(x, 0, 4) == x - x**3/6 + O(x**4, x)
+
+    e = (exp(x) - 1)/x
+    assert e.nseries(x, 0, 3) == 1 + x/2 + x**2/6 + O(x**3)
+
+    assert x.nseries(x, 0, 2) == x
+
+
+@XFAIL
+def test_series1_failing():
+    assert x.nseries(x, 0, 0) == O(1, x)
+    assert x.nseries(x, 0, 1) == O(x, x)
+
+
+def test_seriesbug1():
+    assert (1/x).nseries(x, 0, 3) == 1/x
+    assert (x + 1/x).nseries(x, 0, 3) == x + 1/x
+
+
+def test_series2x():
+    assert ((x + 1)**(-2)).nseries(x, 0, 4) == 1 - 2*x + 3*x**2 - 4*x**3 + O(x**4, x)
+    assert ((x + 1)**(-1)).nseries(x, 0, 4) == 1 - x + x**2 - x**3 + O(x**4, x)
+    assert ((x + 1)**0).nseries(x, 0, 3) == 1
+    assert ((x + 1)**1).nseries(x, 0, 3) == 1 + x
+    assert ((x + 1)**2).nseries(x, 0, 3) == x**2 + 2*x + 1
+    assert ((x + 1)**3).nseries(x, 0, 3) == 1 + 3*x + 3*x**2 + O(x**3)
+
+    assert (1/(1 + x)).nseries(x, 0, 4) == 1 - x + x**2 - x**3 + O(x**4, x)
+    assert (x + 3/(1 + 2*x)).nseries(x, 0, 4) == 3 - 5*x + 12*x**2 - 24*x**3 + O(x**4, x)
+
+    assert ((1/x + 1)**3).nseries(x, 0, 3) == 1 + 3/x + 3/x**2 + x**(-3)
+    assert (1/(1 + 1/x)).nseries(x, 0, 4) == x - x**2 + x**3 - O(x**4, x)
+    assert (1/(1 + 1/x**2)).nseries(x, 0, 6) == x**2 - x**4 + O(x**6, x)
+
+
+def test_bug2():  # 1/log(0)*log(0) problem
+    w = Symbol("w")
+    e = (w**(-1) + w**(
+        -log(3)*log(2)**(-1)))**(-1)*(3*w**(-log(3)*log(2)**(-1)) + 2*w**(-1))
+    e = e.expand()
+    assert e.nseries(w, 0, 4).subs(w, 0) == 3
+
+
+def test_exp():
+    e = (1 + x)**(1/x)
+    assert e.nseries(x, n=3) == exp(1) - x*exp(1)/2 + 11*exp(1)*x**2/24 + O(x**3)
+
+
+def test_exp2():
+    w = Symbol("w")
+    e = w**(1 - log(x)/(log(2) + log(x)))
+    logw = Symbol("logw")
+    assert e.nseries(
+        w, 0, 1, logx=logw) == exp(logw*log(2)/(log(x) + log(2)))
+
+
+def test_bug3():
+    e = (2/x + 3/x**2)/(1/x + 1/x**2)
+    assert e.nseries(x, n=3) == 3 - x + x**2 + O(x**3)
+
+
+def test_generalexponent():
+    p = 2
+    e = (2/x + 3/x**p)/(1/x + 1/x**p)
+    assert e.nseries(x, 0, 3) == 3 - x + x**2 + O(x**3)
+    p = S.Half
+    e = (2/x + 3/x**p)/(1/x + 1/x**p)
+    assert e.nseries(x, 0, 2) == 2 - x + sqrt(x) + x**(S(3)/2) + O(x**2)
+
+    e = 1 + sqrt(x)
+    assert e.nseries(x, 0, 4) == 1 + sqrt(x)
+
+# more complicated example
+
+
+def test_genexp_x():
+    e = 1/(1 + sqrt(x))
+    assert e.nseries(x, 0, 2) == \
+        1 + x - sqrt(x) - sqrt(x)**3 + O(x**2, x)
+
+# more complicated example
+
+
+def test_genexp_x2():
+    p = Rational(3, 2)
+    e = (2/x + 3/x**p)/(1/x + 1/x**p)
+    assert e.nseries(x, 0, 3) == 3 + x + x**2 - sqrt(x) - x**(S(3)/2) - x**(S(5)/2) + O(x**3)
+
+
+def test_seriesbug2():
+    w = Symbol("w")
+    #simple case (1):
+    e = ((2*w)/w)**(1 + w)
+    assert e.nseries(w, 0, 1) == 2 + O(w, w)
+    assert e.nseries(w, 0, 1).subs(w, 0) == 2
+
+
+def test_seriesbug2b():
+    w = Symbol("w")
+    #test sin
+    e = sin(2*w)/w
+    assert e.nseries(w, 0, 3) == 2 - 4*w**2/3 + O(w**3)
+
+
+def test_seriesbug2d():
+    w = Symbol("w", real=True)
+    e = log(sin(2*w)/w)
+    assert e.series(w, n=5) == log(2) - 2*w**2/3 - 4*w**4/45 + O(w**5)
+
+
+def test_seriesbug2c():
+    w = Symbol("w", real=True)
+    #more complicated case, but sin(x)~x, so the result is the same as in (1)
+    e = (sin(2*w)/w)**(1 + w)
+    assert e.series(w, 0, 1) == 2 + O(w)
+    assert e.series(w, 0, 3) == 2 + 2*w*log(2) + \
+        w**2*(Rational(-4, 3) + log(2)**2) + O(w**3)
+    assert e.series(w, 0, 2).subs(w, 0) == 2
+
+
+def test_expbug4():
+    x = Symbol("x", real=True)
+    assert (log(
+        sin(2*x)/x)*(1 + x)).series(x, 0, 2) == log(2) + x*log(2) + O(x**2, x)
+    assert exp(
+        log(sin(2*x)/x)*(1 + x)).series(x, 0, 2) == 2 + 2*x*log(2) + O(x**2)
+
+    assert exp(log(2) + O(x)).nseries(x, 0, 2) == 2 + O(x)
+    assert ((2 + O(x))**(1 + x)).nseries(x, 0, 2) == 2 + O(x)
+
+
+def test_logbug4():
+    assert log(2 + O(x)).nseries(x, 0, 2) == log(2) + O(x, x)
+
+
+def test_expbug5():
+    assert exp(log(1 + x)/x).nseries(x, n=3) == exp(1) + -exp(1)*x/2 + 11*exp(1)*x**2/24 + O(x**3)
+
+    assert exp(O(x)).nseries(x, 0, 2) == 1 + O(x)
+
+
+def test_sinsinbug():
+    assert sin(sin(x)).nseries(x, 0, 8) == x - x**3/3 + x**5/10 - 8*x**7/315 + O(x**8)
+
+
+def test_issue_3258():
+    a = x/(exp(x) - 1)
+    assert a.nseries(x, 0, 5) == 1 - x/2 - x**4/720 + x**2/12 + O(x**5)
+
+
+def test_issue_3204():
+    x = Symbol("x", nonnegative=True)
+    f = sin(x**3)**Rational(1, 3)
+    assert f.nseries(x, 0, 17) == x - x**7/18 - x**13/3240 + O(x**17)
+
+
+def test_issue_3224():
+    f = sqrt(1 - sqrt(y))
+    assert f.nseries(y, 0, 2) == 1 - sqrt(y)/2 - y/8 - sqrt(y)**3/16 + O(y**2)
+
+
+def test_issue_3463():
+    w, i = symbols('w,i')
+    r = log(5)/log(3)
+    p = w**(-1 + r)
+    e = 1/x*(-log(w**(1 + r)) + log(w + w**r))
+    e_ser = -r*log(w)/x + p/x - p**2/(2*x) + O(w)
+    assert e.nseries(w, n=1) == e_ser
+
+
+def test_sin():
+    assert sin(8*x).nseries(x, n=4) == 8*x - 256*x**3/3 + O(x**4)
+    assert sin(x + y).nseries(x, n=1) == sin(y) + O(x)
+    assert sin(x + y).nseries(x, n=2) == sin(y) + cos(y)*x + O(x**2)
+    assert sin(x + y).nseries(x, n=5) == sin(y) + cos(y)*x - sin(y)*x**2/2 - \
+        cos(y)*x**3/6 + sin(y)*x**4/24 + O(x**5)
+
+
+def test_issue_3515():
+    e = sin(8*x)/x
+    assert e.nseries(x, n=6) == 8 - 256*x**2/3 + 4096*x**4/15 + O(x**6)
+
+
+def test_issue_3505():
+    e = sin(x)**(-4)*(sqrt(cos(x))*sin(x)**2 -
+        cos(x)**Rational(1, 3)*sin(x)**2)
+    assert e.nseries(x, n=9) == Rational(-1, 12) - 7*x**2/288 - \
+        43*x**4/10368 - 1123*x**6/2488320 + 377*x**8/29859840 + O(x**9)
+
+
+def test_issue_3501():
+    a = Symbol("a")
+    e = x**(-2)*(x*sin(a + x) - x*sin(a))
+    assert e.nseries(x, n=6) == cos(a) - sin(a)*x/2 - cos(a)*x**2/6 + \
+        x**3*sin(a)/24 + x**4*cos(a)/120 - x**5*sin(a)/720 + O(x**6)
+    e = x**(-2)*(x*cos(a + x) - x*cos(a))
+    assert e.nseries(x, n=6) == -sin(a) - cos(a)*x/2 + sin(a)*x**2/6 + \
+        cos(a)*x**3/24 - x**4*sin(a)/120 - x**5*cos(a)/720 + O(x**6)
+
+
+def test_issue_3502():
+    e = sin(5*x)/sin(2*x)
+    assert e.nseries(x, n=2) == Rational(5, 2) + O(x**2)
+    assert e.nseries(x, n=6) == \
+        Rational(5, 2) - 35*x**2/4 + 329*x**4/48 + O(x**6)
+
+
+def test_issue_3503():
+    e = sin(2 + x)/(2 + x)
+    assert e.nseries(x, n=2) == sin(2)/2 + x*cos(2)/2 - x*sin(2)/4 + O(x**2)
+
+
+def test_issue_3506():
+    e = (x + sin(3*x))**(-2)*(x*(x + sin(3*x)) - (x + sin(3*x))*sin(2*x))
+    assert e.nseries(x, n=7) == \
+        Rational(-1, 4) + 5*x**2/96 + 91*x**4/768 + 11117*x**6/129024 + O(x**7)
+
+
+def test_issue_3508():
+    x = Symbol("x", real=True)
+    assert log(sin(x)).series(x, n=5) == log(x) - x**2/6 - x**4/180 + O(x**5)
+    e = -log(x) + x*(-log(x) + log(sin(2*x))) + log(sin(2*x))
+    assert e.series(x, n=5) == \
+        log(2) + log(2)*x - 2*x**2/3 - 2*x**3/3 - 4*x**4/45 + O(x**5)
+
+
+def test_issue_3507():
+    e = x**(-4)*(x**2 - x**2*sqrt(cos(x)))
+    assert e.nseries(x, n=9) == \
+        Rational(1, 4) + x**2/96 + 19*x**4/5760 + 559*x**6/645120 + 29161*x**8/116121600 + O(x**9)
+
+
+def test_issue_3639():
+    assert sin(cos(x)).nseries(x, n=5) == \
+        sin(1) - x**2*cos(1)/2 - x**4*sin(1)/8 + x**4*cos(1)/24 + O(x**5)
+
+
+def test_hyperbolic():
+    assert sinh(x).nseries(x, n=6) == x + x**3/6 + x**5/120 + O(x**6)
+    assert cosh(x).nseries(x, n=5) == 1 + x**2/2 + x**4/24 + O(x**5)
+    assert tanh(x).nseries(x, n=6) == x - x**3/3 + 2*x**5/15 + O(x**6)
+    assert coth(x).nseries(x, n=6) == \
+        1/x - x**3/45 + x/3 + 2*x**5/945 + O(x**6)
+    assert asinh(x).nseries(x, n=6) == x - x**3/6 + 3*x**5/40 + O(x**6)
+    assert acosh(x).nseries(x, n=6) == \
+        pi*I/2 - I*x - 3*I*x**5/40 - I*x**3/6 + O(x**6)
+    assert atanh(x).nseries(x, n=6) == x + x**3/3 + x**5/5 + O(x**6)
+    assert acoth(x).nseries(x, n=6) == -I*pi/2 + x + x**3/3 + x**5/5 + O(x**6)
+
+
+def test_series2():
+    w = Symbol("w", real=True)
+    x = Symbol("x", real=True)
+    e = w**(-2)*(w*exp(1/x - w) - w*exp(1/x))
+    assert e.nseries(w, n=4) == -exp(1/x) + w*exp(1/x)/2 - w**2*exp(1/x)/6 + w**3*exp(1/x)/24 + O(w**4)
+
+
+def test_series3():
+    w = Symbol("w", real=True)
+    e = w**(-6)*(w**3*tan(w) - w**3*sin(w))
+    assert e.nseries(w, n=8) == Integer(1)/2 + w**2/8 + 13*w**4/240 + 529*w**6/24192 + O(w**8)
+
+
+def test_bug4():
+    w = Symbol("w")
+    e = x/(w**4 + x**2*w**4 + 2*x*w**4)*w**4
+    assert e.nseries(w, n=2).removeO().expand() in [x/(1 + 2*x + x**2),
+        1/(1 + x/2 + 1/x/2)/2, 1/x/(1 + 2/x + x**(-2))]
+
+
+def test_bug5():
+    w = Symbol("w")
+    l = Symbol('l')
+    e = (-log(w) + log(1 + w*log(x)))**(-2)*w**(-2)*((-log(w) +
+        log(1 + x*w))*(-log(w) + log(1 + w*log(x)))*w - x*(-log(w) +
+        log(1 + w*log(x)))*w)
+    assert e.nseries(w, n=0, logx=l) == x/w/l + 1/w + O(1, w)
+    assert e.nseries(w, n=1, logx=l) == x/w/l + 1/w - x/l + 1/l*log(x) \
+        + x*log(x)/l**2 + O(w)
+
+
+def test_issue_4115():
+    assert (sin(x)/(1 - cos(x))).nseries(x, n=1) == 2/x + O(x)
+    assert (sin(x)**2/(1 - cos(x))).nseries(x, n=1) == 2 + O(x)
+
+
+def test_pole():
+    raises(PoleError, lambda: sin(1/x).series(x, 0, 5))
+    raises(PoleError, lambda: sin(1 + 1/x).series(x, 0, 5))
+    raises(PoleError, lambda: (x*sin(1/x)).series(x, 0, 5))
+
+
+def test_expsinbug():
+    assert exp(sin(x)).series(x, 0, 0) == O(1, x)
+    assert exp(sin(x)).series(x, 0, 1) == 1 + O(x)
+    assert exp(sin(x)).series(x, 0, 2) == 1 + x + O(x**2)
+    assert exp(sin(x)).series(x, 0, 3) == 1 + x + x**2/2 + O(x**3)
+    assert exp(sin(x)).series(x, 0, 4) == 1 + x + x**2/2 + O(x**4)
+    assert exp(sin(x)).series(x, 0, 5) == 1 + x + x**2/2 - x**4/8 + O(x**5)
+
+
+def test_floor():
+    x = Symbol('x')
+    assert floor(x).series(x) == 0
+    assert floor(-x).series(x) == -1
+    assert floor(sin(x)).series(x) == 0
+    assert floor(sin(-x)).series(x) == -1
+    assert floor(x**3).series(x) == 0
+    assert floor(-x**3).series(x) == -1
+    assert floor(cos(x)).series(x) == 0
+    assert floor(cos(-x)).series(x) == 0
+    assert floor(5 + sin(x)).series(x) == 5
+    assert floor(5 + sin(-x)).series(x) == 4
+
+    assert floor(x).series(x, 2) == 2
+    assert floor(-x).series(x, 2) == -3
+
+    x = Symbol('x', negative=True)
+    assert floor(x + 1.5).series(x) == 1
+
+
+def test_frac():
+    assert frac(x).series(x, cdir=1) == x
+    assert frac(x).series(x, cdir=-1) == 1 + x
+    assert frac(2*x + 1).series(x, cdir=1) == 2*x
+    assert frac(2*x + 1).series(x, cdir=-1) == 1 + 2*x
+    assert frac(x**2).series(x, cdir=1) == x**2
+    assert frac(x**2).series(x, cdir=-1) == x**2
+    assert frac(sin(x) + 5).series(x, cdir=1) == x - x**3/6 + x**5/120 + O(x**6)
+    assert frac(sin(x) + 5).series(x, cdir=-1) == 1 + x - x**3/6 + x**5/120 + O(x**6)
+    assert frac(sin(x) + S.Half).series(x) == S.Half + x - x**3/6 + x**5/120 + O(x**6)
+    assert frac(x**8).series(x, cdir=1) == O(x**6)
+    assert frac(1/x).series(x) == AccumBounds(0, 1) + O(x**6)
+
+
+def test_ceiling():
+    assert ceiling(x).series(x) == 1
+    assert ceiling(-x).series(x) == 0
+    assert ceiling(sin(x)).series(x) == 1
+    assert ceiling(sin(-x)).series(x) == 0
+    assert ceiling(1 - cos(x)).series(x) == 1
+    assert ceiling(1 - cos(-x)).series(x) == 1
+    assert ceiling(x).series(x, 2) == 3
+    assert ceiling(-x).series(x, 2) == -2
+
+
+def test_abs():
+    a = Symbol('a')
+    assert abs(x).nseries(x, n=4) == x
+    assert abs(-x).nseries(x, n=4) == x
+    assert abs(x + 1).nseries(x, n=4) == x + 1
+    assert abs(sin(x)).nseries(x, n=4) == x - Rational(1, 6)*x**3 + O(x**4)
+    assert abs(sin(-x)).nseries(x, n=4) == x - Rational(1, 6)*x**3 + O(x**4)
+    assert abs(x - a).nseries(x, 1) == -a*sign(1 - a) + (x - 1)*sign(1 - a) + sign(1 - a)
+
+
+def test_dir():
+    assert abs(x).series(x, 0, dir="+") == x
+    assert abs(x).series(x, 0, dir="-") == -x
+    assert floor(x + 2).series(x, 0, dir='+') == 2
+    assert floor(x + 2).series(x, 0, dir='-') == 1
+    assert floor(x + 2.2).series(x, 0, dir='-') == 2
+    assert ceiling(x + 2.2).series(x, 0, dir='-') == 3
+    assert sin(x + y).series(x, 0, dir='-') == sin(x + y).series(x, 0, dir='+')
+
+
+def test_cdir():
+    assert abs(x).series(x, 0, cdir=1) == x
+    assert abs(x).series(x, 0, cdir=-1) == -x
+    assert floor(x + 2).series(x, 0, cdir=1) == 2
+    assert floor(x + 2).series(x, 0, cdir=-1) == 1
+    assert floor(x + 2.2).series(x, 0, cdir=1) == 2
+    assert ceiling(x + 2.2).series(x, 0, cdir=-1) == 3
+    assert sin(x + y).series(x, 0, cdir=-1) == sin(x + y).series(x, 0, cdir=1)
+
+
+def test_issue_3504():
+    a = Symbol("a")
+    e = asin(a*x)/x
+    assert e.series(x, 4, n=2).removeO() == \
+        (x - 4)*(a/(4*sqrt(-16*a**2 + 1)) - asin(4*a)/16) + asin(4*a)/4
+
+
+def test_issue_4441():
+    a, b = symbols('a,b')
+    f = 1/(1 + a*x)
+    assert f.series(x, 0, 5) == 1 - a*x + a**2*x**2 - a**3*x**3 + \
+        a**4*x**4 + O(x**5)
+    f = 1/(1 + (a + b)*x)
+    assert f.series(x, 0, 3) == 1 + x*(-a - b)\
+        + x**2*(a + b)**2 + O(x**3)
+
+
+def test_issue_4329():
+    assert tan(x).series(x, pi/2, n=3).removeO() == \
+        -pi/6 + x/3 - 1/(x - pi/2)
+    assert cot(x).series(x, pi, n=3).removeO() == \
+        -x/3 + pi/3 + 1/(x - pi)
+    assert limit(tan(x)**tan(2*x), x, pi/4) == exp(-1)
+
+
+def test_issue_5183():
+    assert abs(x + x**2).series(n=1) == O(x)
+    assert abs(x + x**2).series(n=2) == x + O(x**2)
+    assert ((1 + x)**2).series(x, n=6) == x**2 + 2*x + 1
+    assert (1 + 1/x).series() == 1 + 1/x
+    assert Derivative(exp(x).series(), x).doit() == \
+        1 + x + x**2/2 + x**3/6 + x**4/24 + O(x**5)
+
+
+def test_issue_5654():
+    a = Symbol('a')
+    assert (1/(x**2+a**2)**2).nseries(x, x0=I*a, n=0) == \
+        -I/(4*a**3*(-I*a + x)) - 1/(4*a**2*(-I*a + x)**2) + O(1, (x, I*a))
+    assert (1/(x**2+a**2)**2).nseries(x, x0=I*a, n=1) == 3/(16*a**4) \
+        -I/(4*a**3*(-I*a + x)) - 1/(4*a**2*(-I*a + x)**2) + O(-I*a + x, (x, I*a))
+
+
+def test_issue_5925():
+    sx = sqrt(x + z).series(z, 0, 1)
+    sxy = sqrt(x + y + z).series(z, 0, 1)
+    s1, s2 = sx.subs(x, x + y), sxy
+    assert (s1 - s2).expand().removeO().simplify() == 0
+
+    sx = sqrt(x + z).series(z, 0, 1)
+    sxy = sqrt(x + y + z).series(z, 0, 1)
+    assert sxy.subs({x:1, y:2}) == sx.subs(x, 3)
+
+
+def test_exp_2():
+    assert exp(x**3).nseries(x, 0, 14) == 1 + x**3 + x**6/2 + x**9/6 + x**12/24 + O(x**14)
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/series/tests/test_order.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/series/tests/test_order.py
new file mode 100644
index 0000000000000000000000000000000000000000..50fcb861ee2a76c730baae6d26cc1e7a00347176
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/series/tests/test_order.py
@@ -0,0 +1,503 @@
+from sympy.core.add import Add
+from sympy.core.function import (Function, expand)
+from sympy.core.numbers import (I, Rational, nan, oo, pi)
+from sympy.core.singleton import S
+from sympy.core.symbol import (Symbol, symbols)
+from sympy.functions.combinatorial.factorials import factorial
+from sympy.functions.elementary.complexes import (conjugate, transpose)
+from sympy.functions.elementary.exponential import (exp, log)
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import (cos, sin)
+from sympy.integrals.integrals import Integral
+from sympy.series.order import O, Order
+from sympy.core.expr import unchanged
+from sympy.testing.pytest import raises
+from sympy.abc import w, x, y, z
+from sympy.testing.pytest import XFAIL
+
+
+def test_caching_bug():
+    #needs to be a first test, so that all caches are clean
+    #cache it
+    O(w)
+    #and test that this won't raise an exception
+    O(w**(-1/x/log(3)*log(5)), w)
+
+
+def test_free_symbols():
+    assert Order(1).free_symbols == set()
+    assert Order(x).free_symbols == {x}
+    assert Order(1, x).free_symbols == {x}
+    assert Order(x*y).free_symbols == {x, y}
+    assert Order(x, x, y).free_symbols == {x, y}
+
+
+def test_simple_1():
+    o = Rational(0)
+    assert Order(2*x) == Order(x)
+    assert Order(x)*3 == Order(x)
+    assert -28*Order(x) == Order(x)
+    assert Order(Order(x)) == Order(x)
+    assert Order(Order(x), y) == Order(Order(x), x, y)
+    assert Order(-23) == Order(1)
+    assert Order(exp(x)) == Order(1, x)
+    assert Order(exp(1/x)).expr == exp(1/x)
+    assert Order(x*exp(1/x)).expr == x*exp(1/x)
+    assert Order(x**(o/3)).expr == x**(o/3)
+    assert Order(x**(o*Rational(5, 3))).expr == x**(o*Rational(5, 3))
+    assert Order(x**2 + x + y, x) == O(1, x)
+    assert Order(x**2 + x + y, y) == O(1, y)
+    raises(ValueError, lambda: Order(exp(x), x, x))
+    raises(TypeError, lambda: Order(x, 2 - x))
+
+
+def test_simple_2():
+    assert Order(2*x)*x == Order(x**2)
+    assert Order(2*x)/x == Order(1, x)
+    assert Order(2*x)*x*exp(1/x) == Order(x**2*exp(1/x))
+    assert (Order(2*x)*x*exp(1/x)/log(x)**3).expr == x**2*exp(1/x)*log(x)**-3
+
+
+def test_simple_3():
+    assert Order(x) + x == Order(x)
+    assert Order(x) + 2 == 2 + Order(x)
+    assert Order(x) + x**2 == Order(x)
+    assert Order(x) + 1/x == 1/x + Order(x)
+    assert Order(1/x) + 1/x**2 == 1/x**2 + Order(1/x)
+    assert Order(x) + exp(1/x) == Order(x) + exp(1/x)
+
+
+def test_simple_4():
+    assert Order(x)**2 == Order(x**2)
+
+
+def test_simple_5():
+    assert Order(x) + Order(x**2) == Order(x)
+    assert Order(x) + Order(x**-2) == Order(x**-2)
+    assert Order(x) + Order(1/x) == Order(1/x)
+
+
+def test_simple_6():
+    assert Order(x) - Order(x) == Order(x)
+    assert Order(x) + Order(1) == Order(1)
+    assert Order(x) + Order(x**2) == Order(x)
+    assert Order(1/x) + Order(1) == Order(1/x)
+    assert Order(x) + Order(exp(1/x)) == Order(exp(1/x))
+    assert Order(x**3) + Order(exp(2/x)) == Order(exp(2/x))
+    assert Order(x**-3) + Order(exp(2/x)) == Order(exp(2/x))
+
+
+def test_simple_7():
+    assert 1 + O(1) == O(1)
+    assert 2 + O(1) == O(1)
+    assert x + O(1) == O(1)
+    assert 1/x + O(1) == 1/x + O(1)
+
+
+def test_simple_8():
+    assert O(sqrt(-x)) == O(sqrt(x))
+    assert O(x**2*sqrt(x)) == O(x**Rational(5, 2))
+    assert O(x**3*sqrt(-(-x)**3)) == O(x**Rational(9, 2))
+    assert O(x**Rational(3, 2)*sqrt((-x)**3)) == O(x**3)
+    assert O(x*(-2*x)**(I/2)) == O(x*(-x)**(I/2))
+
+
+def test_as_expr_variables():
+    assert Order(x).as_expr_variables(None) == (x, ((x, 0),))
+    assert Order(x).as_expr_variables(((x, 0),)) == (x, ((x, 0),))
+    assert Order(y).as_expr_variables(((x, 0),)) == (y, ((x, 0), (y, 0)))
+    assert Order(y).as_expr_variables(((x, 0), (y, 0))) == (y, ((x, 0), (y, 0)))
+
+
+def test_contains_0():
+    assert Order(1, x).contains(Order(1, x))
+    assert Order(1, x).contains(Order(1))
+    assert Order(1).contains(Order(1, x)) is False
+
+
+def test_contains_1():
+    assert Order(x).contains(Order(x))
+    assert Order(x).contains(Order(x**2))
+    assert not Order(x**2).contains(Order(x))
+    assert not Order(x).contains(Order(1/x))
+    assert not Order(1/x).contains(Order(exp(1/x)))
+    assert not Order(x).contains(Order(exp(1/x)))
+    assert Order(1/x).contains(Order(x))
+    assert Order(exp(1/x)).contains(Order(x))
+    assert Order(exp(1/x)).contains(Order(1/x))
+    assert Order(exp(1/x)).contains(Order(exp(1/x)))
+    assert Order(exp(2/x)).contains(Order(exp(1/x)))
+    assert not Order(exp(1/x)).contains(Order(exp(2/x)))
+
+
+def test_contains_2():
+    assert Order(x).contains(Order(y)) is None
+    assert Order(x).contains(Order(y*x))
+    assert Order(y*x).contains(Order(x))
+    assert Order(y).contains(Order(x*y))
+    assert Order(x).contains(Order(y**2*x))
+
+
+def test_contains_3():
+    assert Order(x*y**2).contains(Order(x**2*y)) is None
+    assert Order(x**2*y).contains(Order(x*y**2)) is None
+
+
+def test_contains_4():
+    assert Order(sin(1/x**2)).contains(Order(cos(1/x**2))) is True
+    assert Order(cos(1/x**2)).contains(Order(sin(1/x**2))) is True
+
+
+def test_contains():
+    assert Order(1, x) not in Order(1)
+    assert Order(1) in Order(1, x)
+    raises(TypeError, lambda: Order(x*y**2) in Order(x**2*y))
+
+
+def test_add_1():
+    assert Order(x + x) == Order(x)
+    assert Order(3*x - 2*x**2) == Order(x)
+    assert Order(1 + x) == Order(1, x)
+    assert Order(1 + 1/x) == Order(1/x)
+    # TODO : A better output for Order(log(x) + 1/log(x))
+    # could be Order(log(x)). Currently Order for expressions
+    # where all arguments would involve a log term would fall
+    # in this category and outputs for these should be improved.
+    assert Order(log(x) + 1/log(x)) == Order((log(x)**2 + 1)/log(x))
+    assert Order(exp(1/x) + x) == Order(exp(1/x))
+    assert Order(exp(1/x) + 1/x**20) == Order(exp(1/x))
+
+
+def test_ln_args():
+    assert O(log(x)) + O(log(2*x)) == O(log(x))
+    assert O(log(x)) + O(log(x**3)) == O(log(x))
+    assert O(log(x*y)) + O(log(x) + log(y)) == O(log(x) + log(y), x, y)
+
+
+def test_multivar_0():
+    assert Order(x*y).expr == x*y
+    assert Order(x*y**2).expr == x*y**2
+    assert Order(x*y, x).expr == x
+    assert Order(x*y**2, y).expr == y**2
+    assert Order(x*y*z).expr == x*y*z
+    assert Order(x/y).expr == x/y
+    assert Order(x*exp(1/y)).expr == x*exp(1/y)
+    assert Order(exp(x)*exp(1/y)).expr == exp(x)*exp(1/y)
+
+
+def test_multivar_0a():
+    assert Order(exp(1/x)*exp(1/y)).expr == exp(1/x)*exp(1/y)
+
+
+def test_multivar_1():
+    assert Order(x + y).expr == x + y
+    assert Order(x + 2*y).expr == x + y
+    assert (Order(x + y) + x).expr == (x + y)
+    assert (Order(x + y) + x**2) == Order(x + y)
+    assert (Order(x + y) + 1/x) == 1/x + Order(x + y)
+    assert Order(x**2 + y*x).expr == x**2 + y*x
+
+
+def test_multivar_2():
+    assert Order(x**2*y + y**2*x, x, y).expr == x**2*y + y**2*x
+
+
+def test_multivar_mul_1():
+    assert Order(x + y)*x == Order(x**2 + y*x, x, y)
+
+
+def test_multivar_3():
+    assert (Order(x) + Order(y)).args in [
+        (Order(x), Order(y)),
+        (Order(y), Order(x))]
+    assert Order(x) + Order(y) + Order(x + y) == Order(x + y)
+    assert (Order(x**2*y) + Order(y**2*x)).args in [
+        (Order(x*y**2), Order(y*x**2)),
+        (Order(y*x**2), Order(x*y**2))]
+    assert (Order(x**2*y) + Order(y*x)) == Order(x*y)
+
+
+def test_issue_3468():
+    y = Symbol('y', negative=True)
+    z = Symbol('z', complex=True)
+
+    # check that Order does not modify assumptions about symbols
+    Order(x)
+    Order(y)
+    Order(z)
+
+    assert x.is_positive is None
+    assert y.is_positive is False
+    assert z.is_positive is None
+
+
+def test_leading_order():
+    assert (x + 1 + 1/x**5).extract_leading_order(x) == ((1/x**5, O(1/x**5)),)
+    assert (1 + 1/x).extract_leading_order(x) == ((1/x, O(1/x)),)
+    assert (1 + x).extract_leading_order(x) == ((1, O(1, x)),)
+    assert (1 + x**2).extract_leading_order(x) == ((1, O(1, x)),)
+    assert (2 + x**2).extract_leading_order(x) == ((2, O(1, x)),)
+    assert (x + x**2).extract_leading_order(x) == ((x, O(x)),)
+
+
+def test_leading_order2():
+    assert set((2 + pi + x**2).extract_leading_order(x)) == {(pi, O(1, x)),
+            (S(2), O(1, x))}
+    assert set((2*x + pi*x + x**2).extract_leading_order(x)) == {(2*x, O(x)),
+            (x*pi, O(x))}
+
+
+def test_order_leadterm():
+    assert O(x**2)._eval_as_leading_term(x, None, 1) == O(x**2)
+
+
+def test_order_symbols():
+    e = x*y*sin(x)*Integral(x, (x, 1, 2))
+    assert O(e) == O(x**2*y, x, y)
+    assert O(e, x) == O(x**2)
+
+
+def test_nan():
+    assert O(nan) is nan
+    assert not O(x).contains(nan)
+
+
+def test_O1():
+    assert O(1, x) * x == O(x)
+    assert O(1, y) * x == O(1, y)
+
+
+def test_getn():
+    # other lines are tested incidentally by the suite
+    assert O(x).getn() == 1
+    assert O(x/log(x)).getn() == 1
+    assert O(x**2/log(x)**2).getn() == 2
+    assert O(x*log(x)).getn() == 1
+    raises(NotImplementedError, lambda: (O(x) + O(y)).getn())
+
+
+def test_diff():
+    assert O(x**2).diff(x) == O(x)
+
+
+def test_getO():
+    assert (x).getO() is None
+    assert (x).removeO() == x
+    assert (O(x)).getO() == O(x)
+    assert (O(x)).removeO() == 0
+    assert (z + O(x) + O(y)).getO() == O(x) + O(y)
+    assert (z + O(x) + O(y)).removeO() == z
+    raises(NotImplementedError, lambda: (O(x) + O(y)).getn())
+
+
+def test_leading_term():
+    from sympy.functions.special.gamma_functions import digamma
+    assert O(1/digamma(1/x)) == O(1/log(x))
+
+
+def test_eval():
+    assert Order(x).subs(Order(x), 1) == 1
+    assert Order(x).subs(x, y) == Order(y)
+    assert Order(x).subs(y, x) == Order(x)
+    assert Order(x).subs(x, x + y) == Order(x + y, (x, -y))
+    assert (O(1)**x).is_Pow
+
+
+def test_issue_4279():
+    a, b = symbols('a b')
+    assert O(a, a, b) + O(1, a, b) == O(1, a, b)
+    assert O(b, a, b) + O(1, a, b) == O(1, a, b)
+    assert O(a + b, a, b) + O(1, a, b) == O(1, a, b)
+    assert O(1, a, b) + O(a, a, b) == O(1, a, b)
+    assert O(1, a, b) + O(b, a, b) == O(1, a, b)
+    assert O(1, a, b) + O(a + b, a, b) == O(1, a, b)
+
+
+def test_issue_4855():
+    assert 1/O(1) != O(1)
+    assert 1/O(x) != O(1/x)
+    assert 1/O(x, (x, oo)) != O(1/x, (x, oo))
+
+    f = Function('f')
+    assert 1/O(f(x)) != O(1/x)
+
+
+def test_order_conjugate_transpose():
+    x = Symbol('x', real=True)
+    y = Symbol('y', imaginary=True)
+    assert conjugate(Order(x)) == Order(conjugate(x))
+    assert conjugate(Order(y)) == Order(conjugate(y))
+    assert conjugate(Order(x**2)) == Order(conjugate(x)**2)
+    assert conjugate(Order(y**2)) == Order(conjugate(y)**2)
+    assert transpose(Order(x)) == Order(transpose(x))
+    assert transpose(Order(y)) == Order(transpose(y))
+    assert transpose(Order(x**2)) == Order(transpose(x)**2)
+    assert transpose(Order(y**2)) == Order(transpose(y)**2)
+
+
+def test_order_noncommutative():
+    A = Symbol('A', commutative=False)
+    assert Order(A + A*x, x) == Order(1, x)
+    assert (A + A*x)*Order(x) == Order(x)
+    assert (A*x)*Order(x) == Order(x**2, x)
+    assert expand((1 + Order(x))*A*A*x) == A*A*x + Order(x**2, x)
+    assert expand((A*A + Order(x))*x) == A*A*x + Order(x**2, x)
+    assert expand((A + Order(x))*A*x) == A*A*x + Order(x**2, x)
+
+
+def test_issue_6753():
+    assert (1 + x**2)**10000*O(x) == O(x)
+
+
+def test_order_at_infinity():
+    assert Order(1 + x, (x, oo)) == Order(x, (x, oo))
+    assert Order(3*x, (x, oo)) == Order(x, (x, oo))
+    assert Order(x, (x, oo))*3 == Order(x, (x, oo))
+    assert -28*Order(x, (x, oo)) == Order(x, (x, oo))
+    assert Order(Order(x, (x, oo)), (x, oo)) == Order(x, (x, oo))
+    assert Order(Order(x, (x, oo)), (y, oo)) == Order(x, (x, oo), (y, oo))
+    assert Order(3, (x, oo)) == Order(1, (x, oo))
+    assert Order(x**2 + x + y, (x, oo)) == O(x**2, (x, oo))
+    assert Order(x**2 + x + y, (y, oo)) == O(y, (y, oo))
+
+    assert Order(2*x, (x, oo))*x == Order(x**2, (x, oo))
+    assert Order(2*x, (x, oo))/x == Order(1, (x, oo))
+    assert Order(2*x, (x, oo))*x*exp(1/x) == Order(x**2*exp(1/x), (x, oo))
+    assert Order(2*x, (x, oo))*x*exp(1/x)/log(x)**3 == Order(x**2*exp(1/x)*log(x)**-3, (x, oo))
+
+    assert Order(x, (x, oo)) + 1/x == 1/x + Order(x, (x, oo)) == Order(x, (x, oo))
+    assert Order(x, (x, oo)) + 1 == 1 + Order(x, (x, oo)) == Order(x, (x, oo))
+    assert Order(x, (x, oo)) + x == x + Order(x, (x, oo)) == Order(x, (x, oo))
+    assert Order(x, (x, oo)) + x**2 == x**2 + Order(x, (x, oo))
+    assert Order(1/x, (x, oo)) + 1/x**2 == 1/x**2 + Order(1/x, (x, oo)) == Order(1/x, (x, oo))
+    assert Order(x, (x, oo)) + exp(1/x) == exp(1/x) + Order(x, (x, oo))
+
+    assert Order(x, (x, oo))**2 == Order(x**2, (x, oo))
+
+    assert Order(x, (x, oo)) + Order(x**2, (x, oo)) == Order(x**2, (x, oo))
+    assert Order(x, (x, oo)) + Order(x**-2, (x, oo)) == Order(x, (x, oo))
+    assert Order(x, (x, oo)) + Order(1/x, (x, oo)) == Order(x, (x, oo))
+
+    assert Order(x, (x, oo)) - Order(x, (x, oo)) == Order(x, (x, oo))
+    assert Order(x, (x, oo)) + Order(1, (x, oo)) == Order(x, (x, oo))
+    assert Order(x, (x, oo)) + Order(x**2, (x, oo)) == Order(x**2, (x, oo))
+    assert Order(1/x, (x, oo)) + Order(1, (x, oo)) == Order(1, (x, oo))
+    assert Order(x, (x, oo)) + Order(exp(1/x), (x, oo)) == Order(x, (x, oo))
+    assert Order(x**3, (x, oo)) + Order(exp(2/x), (x, oo)) == Order(x**3, (x, oo))
+    assert Order(x**-3, (x, oo)) + Order(exp(2/x), (x, oo)) == Order(exp(2/x), (x, oo))
+
+    # issue 7207
+    assert Order(exp(x), (x, oo)).expr == Order(2*exp(x), (x, oo)).expr == exp(x)
+    assert Order(y**x, (x, oo)).expr == Order(2*y**x, (x, oo)).expr == exp(x*log(y))
+
+    # issue 19545
+    assert Order(1/x - 3/(3*x + 2), (x, oo)).expr == x**(-2)
+
+def test_mixing_order_at_zero_and_infinity():
+    assert (Order(x, (x, 0)) + Order(x, (x, oo))).is_Add
+    assert Order(x, (x, 0)) + Order(x, (x, oo)) == Order(x, (x, oo)) + Order(x, (x, 0))
+    assert Order(Order(x, (x, oo))) == Order(x, (x, oo))
+
+    # not supported (yet)
+    raises(NotImplementedError, lambda: Order(x, (x, 0))*Order(x, (x, oo)))
+    raises(NotImplementedError, lambda: Order(x, (x, oo))*Order(x, (x, 0)))
+    raises(NotImplementedError, lambda: Order(Order(x, (x, oo)), y))
+    raises(NotImplementedError, lambda: Order(Order(x), (x, oo)))
+
+
+def test_order_at_some_point():
+    assert Order(x, (x, 1)) == Order(1, (x, 1))
+    assert Order(2*x - 2, (x, 1)) == Order(x - 1, (x, 1))
+    assert Order(-x + 1, (x, 1)) == Order(x - 1, (x, 1))
+    assert Order(x - 1, (x, 1))**2 == Order((x - 1)**2, (x, 1))
+    assert Order(x - 2, (x, 2)) - O(x - 2, (x, 2)) == Order(x - 2, (x, 2))
+
+
+def test_order_subs_limits():
+    # issue 3333
+    assert (1 + Order(x)).subs(x, 1/x) == 1 + Order(1/x, (x, oo))
+    assert (1 + Order(x)).limit(x, 0) == 1
+    # issue 5769
+    assert ((x + Order(x**2))/x).limit(x, 0) == 1
+
+    assert Order(x**2).subs(x, y - 1) == Order((y - 1)**2, (y, 1))
+    assert Order(10*x**2, (x, 2)).subs(x, y - 1) == Order(1, (y, 3))
+
+    #issue 19120
+    assert O(x).subs(x, O(x)) == O(x)
+    assert O(x**2).subs(x, x + O(x)) == O(x**2)
+    assert O(x, (x, oo)).subs(x, O(x, (x, oo))) == O(x, (x, oo))
+    assert O(x**2, (x, oo)).subs(x, x + O(x, (x, oo))) == O(x**2, (x, oo))
+    assert (x + O(x**2)).subs(x, x + O(x**2)) == x + O(x**2)
+    assert (x**2 + O(x**2) + 1/x**2).subs(x, x + O(x**2)) == (x + O(x**2))**(-2) + O(x**2)
+    assert (x**2 + O(x**2) + 1).subs(x, x + O(x**2)) == 1 + O(x**2)
+    assert O(x, (x, oo)).subs(x, x + O(x**2, (x, oo))) == O(x**2, (x, oo))
+    assert sin(x).series(n=8).subs(x,sin(x).series(n=8)).expand() == x - x**3/3 + x**5/10 - 8*x**7/315 + O(x**8)
+    assert cos(x).series(n=8).subs(x,sin(x).series(n=8)).expand() == 1 - x**2/2 + 5*x**4/24 - 37*x**6/720 + O(x**8)
+    assert O(x).subs(x, O(1/x, (x, oo))) == O(1/x, (x, oo))
+
+@XFAIL
+def test_order_failing_due_to_solveset():
+    assert O(x**3).subs(x, exp(-x**2)) == O(exp(-3*x**2), (x, -oo))
+    raises(NotImplementedError, lambda: O(x).subs(x, O(1/x))) # mixing of order at different points
+
+
+def test_issue_9351():
+    assert exp(x).series(x, 10, 1) == exp(10) + Order(x - 10, (x, 10))
+
+
+def test_issue_9192():
+    assert O(1)*O(1) == O(1)
+    assert O(1)**O(1) == O(1)
+
+
+def test_issue_9910():
+    assert O(x*log(x) + sin(x), (x, oo)) == O(x*log(x), (x, oo))
+
+
+def test_performance_of_adding_order():
+    l = [x**i for i in range(1000)]
+    l.append(O(x**1001))
+    assert Add(*l).subs(x,1) == O(1)
+
+def test_issue_14622():
+    assert (x**(-4) + x**(-3) + x**(-1) + O(x**(-6), (x, oo))).as_numer_denom() == (
+        x**4 + x**5 + x**7 + O(x**2, (x, oo)), x**8)
+    assert (x**3 + O(x**2, (x, oo))).is_Add
+    assert O(x**2, (x, oo)).contains(x**3) is False
+    assert O(x, (x, oo)).contains(O(x, (x, 0))) is None
+    assert O(x, (x, 0)).contains(O(x, (x, oo))) is None
+    raises(NotImplementedError, lambda: O(x**3).contains(x**w))
+
+
+def test_issue_15539():
+    assert O(1/x**2 + 1/x**4, (x, -oo)) == O(1/x**2, (x, -oo))
+    assert O(1/x**4 + exp(x), (x, -oo)) == O(1/x**4, (x, -oo))
+    assert O(1/x**4 + exp(-x), (x, -oo)) == O(exp(-x), (x, -oo))
+    assert O(1/x, (x, oo)).subs(x, -x) == O(-1/x, (x, -oo))
+
+def test_issue_18606():
+    assert unchanged(Order, 0)
+
+
+def test_issue_22165():
+    assert O(log(x)).contains(2)
+
+
+def test_issue_23231():
+    # This test checks Order for expressions having
+    # arguments containing variables in exponents/powers.
+    assert O(x**x + 2**x, (x, oo)) == O(exp(x*log(x)), (x, oo))
+    assert O(x**x + x**2, (x, oo)) == O(exp(x*log(x)), (x, oo))
+    assert O(x**x + 1/x**2, (x, oo)) == O(exp(x*log(x)), (x, oo))
+    assert O(2**x + 3**x , (x, oo)) == O(exp(x*log(3)), (x, oo))
+
+
+def test_issue_9917():
+    assert O(x*sin(x) + 1, (x, oo)) == O(x, (x, oo))
+
+
+def test_issue_22836():
+    assert O(2**x + factorial(x), (x, oo)) == O(factorial(x), (x, oo))
+    assert O(2**x + factorial(x) + x**x, (x, oo)) == O(exp(x*log(x)), (x, oo))
+    assert O(x + factorial(x), (x, oo)) == O(factorial(x), (x, oo))
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/series/tests/test_residues.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/series/tests/test_residues.py
new file mode 100644
index 0000000000000000000000000000000000000000..9f7d075a56500d008e3c8b46c1fda5db890fd76a
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/series/tests/test_residues.py
@@ -0,0 +1,101 @@
+from sympy.core.function import Function
+from sympy.core.numbers import (I, Rational, pi)
+from sympy.core.singleton import S
+from sympy.core.symbol import Symbol
+from sympy.functions.combinatorial.factorials import factorial
+from sympy.functions.elementary.exponential import (exp, log)
+from sympy.functions.elementary.hyperbolic import tanh
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import (cot, sin, tan)
+from sympy.series.residues import residue
+from sympy.testing.pytest import XFAIL, raises
+from sympy.abc import x, z, a, s, k
+
+
+def test_basic1():
+    assert residue(1/x, x, 0) == 1
+    assert residue(-2/x, x, 0) == -2
+    assert residue(81/x, x, 0) == 81
+    assert residue(1/x**2, x, 0) == 0
+    assert residue(0, x, 0) == 0
+    assert residue(5, x, 0) == 0
+    assert residue(x, x, 0) == 0
+    assert residue(x**2, x, 0) == 0
+
+
+def test_basic2():
+    assert residue(1/x, x, 1) == 0
+    assert residue(-2/x, x, 1) == 0
+    assert residue(81/x, x, -1) == 0
+    assert residue(1/x**2, x, 1) == 0
+    assert residue(0, x, 1) == 0
+    assert residue(5, x, 1) == 0
+    assert residue(x, x, 1) == 0
+    assert residue(x**2, x, 5) == 0
+
+
+def test_f():
+    f = Function("f")
+    assert residue(f(x)/x**5, x, 0) == f(x).diff(x, 4).subs(x, 0)/24
+
+
+def test_functions():
+    assert residue(1/sin(x), x, 0) == 1
+    assert residue(2/sin(x), x, 0) == 2
+    assert residue(1/sin(x)**2, x, 0) == 0
+    assert residue(1/sin(x)**5, x, 0) == Rational(3, 8)
+
+
+def test_expressions():
+    assert residue(1/(x + 1), x, 0) == 0
+    assert residue(1/(x + 1), x, -1) == 1
+    assert residue(1/(x**2 + 1), x, -1) == 0
+    assert residue(1/(x**2 + 1), x, I) == -I/2
+    assert residue(1/(x**2 + 1), x, -I) == I/2
+    assert residue(1/(x**4 + 1), x, 0) == 0
+    assert residue(1/(x**4 + 1), x, exp(I*pi/4)).equals(-(Rational(1, 4) + I/4)/sqrt(2))
+    assert residue(1/(x**2 + a**2)**2, x, a*I) == -I/4/a**3
+
+
+@XFAIL
+def test_expressions_failing():
+    n = Symbol('n', integer=True, positive=True)
+    assert residue(exp(z)/(z - pi*I/4*a)**n, z, I*pi*a) == \
+        exp(I*pi*a/4)/factorial(n - 1)
+
+
+def test_NotImplemented():
+    raises(NotImplementedError, lambda: residue(exp(1/z), z, 0))
+
+
+def test_bug():
+    assert residue(2**(z)*(s + z)*(1 - s - z)/z**2, z, 0) == \
+        1 + s*log(2) - s**2*log(2) - 2*s
+
+
+def test_issue_5654():
+    assert residue(1/(x**2 + a**2)**2, x, a*I) == -I/(4*a**3)
+    assert residue(1/s*1/(z - exp(s)), s, 0) == 1/(z - 1)
+    assert residue((1 + k)/s*1/(z - exp(s)), s, 0) == k/(z - 1) + 1/(z - 1)
+
+
+def test_issue_6499():
+    assert residue(1/(exp(z) - 1), z, 0) == 1
+
+
+def test_issue_14037():
+    assert residue(sin(x**50)/x**51, x, 0) == 1
+
+
+def test_issue_21176():
+    f = x**2*cot(pi*x)/(x**4 + 1)
+    assert residue(f, x, -sqrt(2)/2 - sqrt(2)*I/2).cancel().together(deep=True)\
+        == sqrt(2)*(1 - I)/(8*tan(sqrt(2)*pi*(1 + I)/2))
+
+
+def test_issue_21177():
+    r = -sqrt(3)*tanh(sqrt(3)*pi/2)/3
+    a = residue(cot(pi*x)/((x - 1)*(x - 2) + 1), x, S(3)/2 - sqrt(3)*I/2)
+    b = residue(cot(pi*x)/(x**2 - 3*x + 3), x, S(3)/2 - sqrt(3)*I/2)
+    assert a == r
+    assert (b - a).cancel() == 0
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/series/tests/test_sequences.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/series/tests/test_sequences.py
new file mode 100644
index 0000000000000000000000000000000000000000..61e276ad67982f0a9877de3548d70238976d28a5
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/series/tests/test_sequences.py
@@ -0,0 +1,312 @@
+from sympy.core.containers import Tuple
+from sympy.core.function import Function
+from sympy.core.numbers import oo, Rational
+from sympy.core.singleton import S
+from sympy.core.symbol import symbols, Symbol
+from sympy.functions.combinatorial.numbers import tribonacci, fibonacci
+from sympy.functions.elementary.exponential import exp
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import cos, sin
+from sympy.series import EmptySequence
+from sympy.series.sequences import (SeqMul, SeqAdd, SeqPer, SeqFormula,
+    sequence)
+from sympy.sets.sets import Interval
+from sympy.tensor.indexed import Indexed, Idx
+from sympy.series.sequences import SeqExpr, SeqExprOp, RecursiveSeq
+from sympy.testing.pytest import raises, slow
+
+x, y, z = symbols('x y z')
+n, m = symbols('n m')
+
+
+def test_EmptySequence():
+    assert S.EmptySequence is EmptySequence
+
+    assert S.EmptySequence.interval is S.EmptySet
+    assert S.EmptySequence.length is S.Zero
+
+    assert list(S.EmptySequence) == []
+
+
+def test_SeqExpr():
+    #SeqExpr is a baseclass and does not take care of
+    #ensuring all arguments are Basics hence the use of
+    #Tuple(...) here.
+    s = SeqExpr(Tuple(1, n, y), Tuple(x, 0, 10))
+
+    assert isinstance(s, SeqExpr)
+    assert s.gen == (1, n, y)
+    assert s.interval == Interval(0, 10)
+    assert s.start == 0
+    assert s.stop == 10
+    assert s.length == 11
+    assert s.variables == (x,)
+
+    assert SeqExpr(Tuple(1, 2, 3), Tuple(x, 0, oo)).length is oo
+
+
+def test_SeqPer():
+    s = SeqPer((1, n, 3), (x, 0, 5))
+
+    assert isinstance(s, SeqPer)
+    assert s.periodical == Tuple(1, n, 3)
+    assert s.period == 3
+    assert s.coeff(3) == 1
+    assert s.free_symbols == {n}
+
+    assert list(s) == [1, n, 3, 1, n, 3]
+    assert s[:] == [1, n, 3, 1, n, 3]
+    assert SeqPer((1, n, 3), (x, -oo, 0))[0:6] == [1, n, 3, 1, n, 3]
+
+    raises(ValueError, lambda: SeqPer((1, 2, 3), (0, 1, 2)))
+    raises(ValueError, lambda: SeqPer((1, 2, 3), (x, -oo, oo)))
+    raises(ValueError, lambda: SeqPer(n**2, (0, oo)))
+
+    assert SeqPer((n, n**2, n**3), (m, 0, oo))[:6] == \
+        [n, n**2, n**3, n, n**2, n**3]
+    assert SeqPer((n, n**2, n**3), (n, 0, oo))[:6] == [0, 1, 8, 3, 16, 125]
+    assert SeqPer((n, m), (n, 0, oo))[:6] == [0, m, 2, m, 4, m]
+
+
+def test_SeqFormula():
+    s = SeqFormula(n**2, (n, 0, 5))
+
+    assert isinstance(s, SeqFormula)
+    assert s.formula == n**2
+    assert s.coeff(3) == 9
+
+    assert list(s) == [i**2 for i in range(6)]
+    assert s[:] == [i**2 for i in range(6)]
+    assert SeqFormula(n**2, (n, -oo, 0))[0:6] == [i**2 for i in range(6)]
+
+    assert SeqFormula(n**2, (0, oo)) == SeqFormula(n**2, (n, 0, oo))
+
+    assert SeqFormula(n**2, (0, m)).subs(m, x) == SeqFormula(n**2, (0, x))
+    assert SeqFormula(m*n**2, (n, 0, oo)).subs(m, x) == \
+        SeqFormula(x*n**2, (n, 0, oo))
+
+    raises(ValueError, lambda: SeqFormula(n**2, (0, 1, 2)))
+    raises(ValueError, lambda: SeqFormula(n**2, (n, -oo, oo)))
+    raises(ValueError, lambda: SeqFormula(m*n**2, (0, oo)))
+
+    seq = SeqFormula(x*(y**2 + z), (z, 1, 100))
+    assert seq.expand() == SeqFormula(x*y**2 + x*z, (z, 1, 100))
+    seq = SeqFormula(sin(x*(y**2 + z)),(z, 1, 100))
+    assert seq.expand(trig=True) == SeqFormula(sin(x*y**2)*cos(x*z) + sin(x*z)*cos(x*y**2), (z, 1, 100))
+    assert seq.expand() == SeqFormula(sin(x*y**2 + x*z), (z, 1, 100))
+    assert seq.expand(trig=False) == SeqFormula(sin(x*y**2 + x*z), (z, 1, 100))
+    seq = SeqFormula(exp(x*(y**2 + z)), (z, 1, 100))
+    assert seq.expand() == SeqFormula(exp(x*y**2)*exp(x*z), (z, 1, 100))
+    assert seq.expand(power_exp=False) == SeqFormula(exp(x*y**2 + x*z), (z, 1, 100))
+    assert seq.expand(mul=False, power_exp=False) == SeqFormula(exp(x*(y**2 + z)), (z, 1, 100))
+
+def test_sequence():
+    form = SeqFormula(n**2, (n, 0, 5))
+    per = SeqPer((1, 2, 3), (n, 0, 5))
+    inter = SeqFormula(n**2)
+
+    assert sequence(n**2, (n, 0, 5)) == form
+    assert sequence((1, 2, 3), (n, 0, 5)) == per
+    assert sequence(n**2) == inter
+
+
+def test_SeqExprOp():
+    form = SeqFormula(n**2, (n, 0, 10))
+    per = SeqPer((1, 2, 3), (m, 5, 10))
+
+    s = SeqExprOp(form, per)
+    assert s.gen == (n**2, (1, 2, 3))
+    assert s.interval == Interval(5, 10)
+    assert s.start == 5
+    assert s.stop == 10
+    assert s.length == 6
+    assert s.variables == (n, m)
+
+
+def test_SeqAdd():
+    per = SeqPer((1, 2, 3), (n, 0, oo))
+    form = SeqFormula(n**2)
+
+    per_bou = SeqPer((1, 2), (n, 1, 5))
+    form_bou = SeqFormula(n**2, (6, 10))
+    form_bou2 = SeqFormula(n**2, (1, 5))
+
+    assert SeqAdd() == S.EmptySequence
+    assert SeqAdd(S.EmptySequence) == S.EmptySequence
+    assert SeqAdd(per) == per
+    assert SeqAdd(per, S.EmptySequence) == per
+    assert SeqAdd(per_bou, form_bou) == S.EmptySequence
+
+    s = SeqAdd(per_bou, form_bou2, evaluate=False)
+    assert s.args == (form_bou2, per_bou)
+    assert s[:] == [2, 6, 10, 18, 26]
+    assert list(s) == [2, 6, 10, 18, 26]
+
+    assert isinstance(SeqAdd(per, per_bou, evaluate=False), SeqAdd)
+
+    s1 = SeqAdd(per, per_bou)
+    assert isinstance(s1, SeqPer)
+    assert s1 == SeqPer((2, 4, 4, 3, 3, 5), (n, 1, 5))
+    s2 = SeqAdd(form, form_bou)
+    assert isinstance(s2, SeqFormula)
+    assert s2 == SeqFormula(2*n**2, (6, 10))
+
+    assert SeqAdd(form, form_bou, per) == \
+        SeqAdd(per, SeqFormula(2*n**2, (6, 10)))
+    assert SeqAdd(form, SeqAdd(form_bou, per)) == \
+        SeqAdd(per, SeqFormula(2*n**2, (6, 10)))
+    assert SeqAdd(per, SeqAdd(form, form_bou), evaluate=False) == \
+        SeqAdd(per, SeqFormula(2*n**2, (6, 10)))
+
+    assert SeqAdd(SeqPer((1, 2), (n, 0, oo)), SeqPer((1, 2), (m, 0, oo))) == \
+        SeqPer((2, 4), (n, 0, oo))
+
+
+def test_SeqMul():
+    per = SeqPer((1, 2, 3), (n, 0, oo))
+    form = SeqFormula(n**2)
+
+    per_bou = SeqPer((1, 2), (n, 1, 5))
+    form_bou = SeqFormula(n**2, (n, 6, 10))
+    form_bou2 = SeqFormula(n**2, (1, 5))
+
+    assert SeqMul() == S.EmptySequence
+    assert SeqMul(S.EmptySequence) == S.EmptySequence
+    assert SeqMul(per) == per
+    assert SeqMul(per, S.EmptySequence) == S.EmptySequence
+    assert SeqMul(per_bou, form_bou) == S.EmptySequence
+
+    s = SeqMul(per_bou, form_bou2, evaluate=False)
+    assert s.args == (form_bou2, per_bou)
+    assert s[:] == [1, 8, 9, 32, 25]
+    assert list(s) == [1, 8, 9, 32, 25]
+
+    assert isinstance(SeqMul(per, per_bou, evaluate=False), SeqMul)
+
+    s1 = SeqMul(per, per_bou)
+    assert isinstance(s1, SeqPer)
+    assert s1 == SeqPer((1, 4, 3, 2, 2, 6), (n, 1, 5))
+    s2 = SeqMul(form, form_bou)
+    assert isinstance(s2, SeqFormula)
+    assert s2 == SeqFormula(n**4, (6, 10))
+
+    assert SeqMul(form, form_bou, per) == \
+        SeqMul(per, SeqFormula(n**4, (6, 10)))
+    assert SeqMul(form, SeqMul(form_bou, per)) == \
+        SeqMul(per, SeqFormula(n**4, (6, 10)))
+    assert SeqMul(per, SeqMul(form, form_bou2,
+                              evaluate=False), evaluate=False) == \
+        SeqMul(form, per, form_bou2, evaluate=False)
+
+    assert SeqMul(SeqPer((1, 2), (n, 0, oo)), SeqPer((1, 2), (n, 0, oo))) == \
+        SeqPer((1, 4), (n, 0, oo))
+
+
+def test_add():
+    per = SeqPer((1, 2), (n, 0, oo))
+    form = SeqFormula(n**2)
+
+    assert per + (SeqPer((2, 3))) == SeqPer((3, 5), (n, 0, oo))
+    assert form + SeqFormula(n**3) == SeqFormula(n**2 + n**3)
+
+    assert per + form == SeqAdd(per, form)
+
+    raises(TypeError, lambda: per + n)
+    raises(TypeError, lambda: n + per)
+
+
+def test_sub():
+    per = SeqPer((1, 2), (n, 0, oo))
+    form = SeqFormula(n**2)
+
+    assert per - (SeqPer((2, 3))) == SeqPer((-1, -1), (n, 0, oo))
+    assert form - (SeqFormula(n**3)) == SeqFormula(n**2 - n**3)
+
+    assert per - form == SeqAdd(per, -form)
+
+    raises(TypeError, lambda: per - n)
+    raises(TypeError, lambda: n - per)
+
+
+def test_mul__coeff_mul():
+    assert SeqPer((1, 2), (n, 0, oo)).coeff_mul(2) == SeqPer((2, 4), (n, 0, oo))
+    assert SeqFormula(n**2).coeff_mul(2) == SeqFormula(2*n**2)
+    assert S.EmptySequence.coeff_mul(100) == S.EmptySequence
+
+    assert SeqPer((1, 2), (n, 0, oo)) * (SeqPer((2, 3))) == \
+        SeqPer((2, 6), (n, 0, oo))
+    assert SeqFormula(n**2) * SeqFormula(n**3) == SeqFormula(n**5)
+
+    assert S.EmptySequence * SeqFormula(n**2) == S.EmptySequence
+    assert SeqFormula(n**2) * S.EmptySequence == S.EmptySequence
+
+    raises(TypeError, lambda: sequence(n**2) * n)
+    raises(TypeError, lambda: n * sequence(n**2))
+
+
+def test_neg():
+    assert -SeqPer((1, -2), (n, 0, oo)) == SeqPer((-1, 2), (n, 0, oo))
+    assert -SeqFormula(n**2) == SeqFormula(-n**2)
+
+
+def test_operations():
+    per = SeqPer((1, 2), (n, 0, oo))
+    per2 = SeqPer((2, 4), (n, 0, oo))
+    form = SeqFormula(n**2)
+    form2 = SeqFormula(n**3)
+
+    assert per + form + form2 == SeqAdd(per, form, form2)
+    assert per + form - form2 == SeqAdd(per, form, -form2)
+    assert per + form - S.EmptySequence == SeqAdd(per, form)
+    assert per + per2 + form == SeqAdd(SeqPer((3, 6), (n, 0, oo)), form)
+    assert S.EmptySequence - per == -per
+    assert form + form == SeqFormula(2*n**2)
+
+    assert per * form * form2 == SeqMul(per, form, form2)
+    assert form * form == SeqFormula(n**4)
+    assert form * -form == SeqFormula(-n**4)
+
+    assert form * (per + form2) == SeqMul(form, SeqAdd(per, form2))
+    assert form * (per + per) == SeqMul(form, per2)
+
+    assert form.coeff_mul(m) == SeqFormula(m*n**2, (n, 0, oo))
+    assert per.coeff_mul(m) == SeqPer((m, 2*m), (n, 0, oo))
+
+
+def test_Idx_limits():
+    i = symbols('i', cls=Idx)
+    r = Indexed('r', i)
+
+    assert SeqFormula(r, (i, 0, 5))[:] == [r.subs(i, j) for j in range(6)]
+    assert SeqPer((1, 2), (i, 0, 5))[:] == [1, 2, 1, 2, 1, 2]
+
+
+@slow
+def test_find_linear_recurrence():
+    assert sequence((0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55), \
+    (n, 0, 10)).find_linear_recurrence(11) == [1, 1]
+    assert sequence((1, 2, 4, 7, 28, 128, 582, 2745, 13021, 61699, 292521, \
+    1387138), (n, 0, 11)).find_linear_recurrence(12) == [5, -2, 6, -11]
+    assert sequence(x*n**3+y*n, (n, 0, oo)).find_linear_recurrence(10) \
+    == [4, -6, 4, -1]
+    assert sequence(x**n, (n,0,20)).find_linear_recurrence(21) == [x]
+    assert sequence((1,2,3)).find_linear_recurrence(10, 5) == [0, 0, 1]
+    assert sequence(((1 + sqrt(5))/2)**n + \
+    (-(1 + sqrt(5))/2)**(-n)).find_linear_recurrence(10) == [1, 1]
+    assert sequence(x*((1 + sqrt(5))/2)**n + y*(-(1 + sqrt(5))/2)**(-n), \
+    (n,0,oo)).find_linear_recurrence(10) == [1, 1]
+    assert sequence((1,2,3,4,6),(n, 0, 4)).find_linear_recurrence(5) == []
+    assert sequence((2,3,4,5,6,79),(n, 0, 5)).find_linear_recurrence(6,gfvar=x) \
+    == ([], None)
+    assert sequence((2,3,4,5,8,30),(n, 0, 5)).find_linear_recurrence(6,gfvar=x) \
+    == ([Rational(19, 2), -20, Rational(27, 2)], (-31*x**2 + 32*x - 4)/(27*x**3 - 40*x**2 + 19*x -2))
+    assert sequence(fibonacci(n)).find_linear_recurrence(30,gfvar=x) \
+    == ([1, 1], -x/(x**2 + x - 1))
+    assert sequence(tribonacci(n)).find_linear_recurrence(30,gfvar=x) \
+    ==  ([1, 1, 1], -x/(x**3 + x**2 + x - 1))
+
+def test_RecursiveSeq():
+    y = Function('y')
+    n = Symbol('n')
+    fib = RecursiveSeq(y(n - 1) + y(n - 2), y(n), n, [0, 1])
+    assert fib.coeff(3) == 2
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/series/tests/test_series.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/series/tests/test_series.py
new file mode 100644
index 0000000000000000000000000000000000000000..e3f3c122b98c14a58c6d5c6636cbb53e1e66a75d
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/series/tests/test_series.py
@@ -0,0 +1,421 @@
+from sympy.core.evalf import N
+from sympy.core.function import (Derivative, Function, PoleError, Subs)
+from sympy.core.numbers import (E, Float, Rational, oo, pi, I)
+from sympy.core.singleton import S
+from sympy.core.symbol import (Symbol, symbols)
+from sympy.functions.elementary.exponential import (LambertW, exp, log)
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import (atan, cos, sin)
+from sympy.functions.special.gamma_functions import gamma
+from sympy.integrals.integrals import Integral, integrate
+from sympy.series.order import O
+from sympy.series.series import series
+from sympy.abc import x, y, n, k
+from sympy.testing.pytest import raises
+from sympy.core import EulerGamma
+
+
+def test_sin():
+    e1 = sin(x).series(x, 0)
+    e2 = series(sin(x), x, 0)
+    assert e1 == e2
+
+
+def test_cos():
+    e1 = cos(x).series(x, 0)
+    e2 = series(cos(x), x, 0)
+    assert e1 == e2
+
+
+def test_exp():
+    e1 = exp(x).series(x, 0)
+    e2 = series(exp(x), x, 0)
+    assert e1 == e2
+
+
+def test_exp2():
+    e1 = exp(cos(x)).series(x, 0)
+    e2 = series(exp(cos(x)), x, 0)
+    assert e1 == e2
+
+
+def test_issue_5223():
+    assert series(1, x) == 1
+    assert next(S.Zero.lseries(x)) == 0
+    assert cos(x).series() == cos(x).series(x)
+    raises(ValueError, lambda: cos(x + y).series())
+    raises(ValueError, lambda: x.series(dir=""))
+
+    assert (cos(x).series(x, 1) -
+            cos(x + 1).series(x).subs(x, x - 1)).removeO() == 0
+    e = cos(x).series(x, 1, n=None)
+    assert [next(e) for i in range(2)] == [cos(1), -((x - 1)*sin(1))]
+    e = cos(x).series(x, 1, n=None, dir='-')
+    assert [next(e) for i in range(2)] == [cos(1), (1 - x)*sin(1)]
+    # the following test is exact so no need for x -> x - 1 replacement
+    assert abs(x).series(x, 1, dir='-') == x
+    assert exp(x).series(x, 1, dir='-', n=3).removeO() == \
+        E - E*(-x + 1) + E*(-x + 1)**2/2
+
+    D = Derivative
+    assert D(x**2 + x**3*y**2, x, 2, y, 1).series(x).doit() == 12*x*y
+    assert next(D(cos(x), x).lseries()) == D(1, x)
+    assert D(
+        exp(x), x).series(n=3) == D(1, x) + D(x, x) + D(x**2/2, x) + D(x**3/6, x) + O(x**3)
+
+    assert Integral(x, (x, 1, 3), (y, 1, x)).series(x) == -4 + 4*x
+
+    assert (1 + x + O(x**2)).getn() == 2
+    assert (1 + x).getn() is None
+
+    raises(PoleError, lambda: ((1/sin(x))**oo).series())
+    logx = Symbol('logx')
+    assert ((sin(x))**y).nseries(x, n=1, logx=logx) == \
+        exp(y*logx) + O(x*exp(y*logx), x)
+
+    assert sin(1/x).series(x, oo, n=5) == 1/x - 1/(6*x**3) + O(x**(-5), (x, oo))
+    assert abs(x).series(x, oo, n=5, dir='+') == x
+    assert abs(x).series(x, -oo, n=5, dir='-') == -x
+    assert abs(-x).series(x, oo, n=5, dir='+') == x
+    assert abs(-x).series(x, -oo, n=5, dir='-') == -x
+
+    assert exp(x*log(x)).series(n=3) == \
+        1 + x*log(x) + x**2*log(x)**2/2 + O(x**3*log(x)**3)
+    # XXX is this right? If not, fix "ngot > n" handling in expr.
+    p = Symbol('p', positive=True)
+    assert exp(sqrt(p)**3*log(p)).series(n=3) == \
+        1 + p**S('3/2')*log(p) + O(p**3*log(p)**3)
+
+    assert exp(sin(x)*log(x)).series(n=2) == 1 + x*log(x) + O(x**2*log(x)**2)
+
+
+def test_issue_6350():
+    expr = integrate(exp(k*(y**3 - 3*y)), (y, 0, oo), conds='none')
+    assert expr.series(k, 0, 3) == -(-1)**(S(2)/3)*sqrt(3)*gamma(S(1)/3)**2*gamma(S(2)/3)/(6*pi*k**(S(1)/3)) - \
+        sqrt(3)*k*gamma(-S(2)/3)*gamma(-S(1)/3)/(6*pi) - \
+        (-1)**(S(1)/3)*sqrt(3)*k**(S(1)/3)*gamma(-S(1)/3)*gamma(S(1)/3)*gamma(S(2)/3)/(6*pi) - \
+        (-1)**(S(2)/3)*sqrt(3)*k**(S(5)/3)*gamma(S(1)/3)**2*gamma(S(2)/3)/(4*pi) - \
+        (-1)**(S(1)/3)*sqrt(3)*k**(S(7)/3)*gamma(-S(1)/3)*gamma(S(1)/3)*gamma(S(2)/3)/(8*pi) + O(k**3)
+
+
+def test_issue_11313():
+    assert Integral(cos(x), x).series(x) == sin(x).series(x)
+    assert Derivative(sin(x), x).series(x, n=3).doit() == cos(x).series(x, n=3)
+
+    assert Derivative(x**3, x).as_leading_term(x) == 3*x**2
+    assert Derivative(x**3, y).as_leading_term(x) == 0
+    assert Derivative(sin(x), x).as_leading_term(x) == 1
+    assert Derivative(cos(x), x).as_leading_term(x) == -x
+
+    # This result is equivalent to zero, zero is not return because
+    # `Expr.series` doesn't currently detect an `x` in its `free_symbol`s.
+    assert Derivative(1, x).as_leading_term(x) == Derivative(1, x)
+
+    assert Derivative(exp(x), x).series(x).doit() == exp(x).series(x)
+    assert 1 + Integral(exp(x), x).series(x) == exp(x).series(x)
+
+    assert Derivative(log(x), x).series(x).doit() == (1/x).series(x)
+    assert Integral(log(x), x).series(x) == Integral(log(x), x).doit().series(x).removeO()
+
+
+def test_series_of_Subs():
+    from sympy.abc import z
+
+    subs1 = Subs(sin(x), x, y)
+    subs2 = Subs(sin(x) * cos(z), x, y)
+    subs3 = Subs(sin(x * z), (x, z), (y, x))
+
+    assert subs1.series(x) == subs1
+    subs1_series = (Subs(x, x, y) + Subs(-x**3/6, x, y) +
+        Subs(x**5/120, x, y) + O(y**6))
+    assert subs1.series() == subs1_series
+    assert subs1.series(y) == subs1_series
+    assert subs1.series(z) == subs1
+    assert subs2.series(z) == (Subs(z**4*sin(x)/24, x, y) +
+        Subs(-z**2*sin(x)/2, x, y) + Subs(sin(x), x, y) + O(z**6))
+    assert subs3.series(x).doit() == subs3.doit().series(x)
+    assert subs3.series(z).doit() == sin(x*y)
+
+    raises(ValueError, lambda: Subs(x + 2*y, y, z).series())
+    assert Subs(x + y, y, z).series(x).doit() == x + z
+
+
+def test_issue_3978():
+    f = Function('f')
+    assert f(x).series(x, 0, 3, dir='-') == \
+            f(0) + x*Subs(Derivative(f(x), x), x, 0) + \
+            x**2*Subs(Derivative(f(x), x, x), x, 0)/2 + O(x**3)
+    assert f(x).series(x, 0, 3) == \
+            f(0) + x*Subs(Derivative(f(x), x), x, 0) + \
+            x**2*Subs(Derivative(f(x), x, x), x, 0)/2 + O(x**3)
+    assert f(x**2).series(x, 0, 3) == \
+            f(0) + x**2*Subs(Derivative(f(x), x), x, 0) + O(x**3)
+    assert f(x**2+1).series(x, 0, 3) == \
+            f(1) + x**2*Subs(Derivative(f(x), x), x, 1) + O(x**3)
+
+    class TestF(Function):
+        pass
+
+    assert TestF(x).series(x, 0, 3) ==  TestF(0) + \
+            x*Subs(Derivative(TestF(x), x), x, 0) + \
+            x**2*Subs(Derivative(TestF(x), x, x), x, 0)/2 + O(x**3)
+
+from sympy.series.acceleration import richardson, shanks
+from sympy.concrete.summations import Sum
+from sympy.core.numbers import Integer
+
+
+def test_acceleration():
+    e = (1 + 1/n)**n
+    assert round(richardson(e, n, 10, 20).evalf(), 10) == round(E.evalf(), 10)
+
+    A = Sum(Integer(-1)**(k + 1) / k, (k, 1, n))
+    assert round(shanks(A, n, 25).evalf(), 4) == round(log(2).evalf(), 4)
+    assert round(shanks(A, n, 25, 5).evalf(), 10) == round(log(2).evalf(), 10)
+
+
+def test_issue_5852():
+    assert series(1/cos(x/log(x)), x, 0) == 1 + x**2/(2*log(x)**2) + \
+        5*x**4/(24*log(x)**4) + O(x**6)
+
+
+def test_issue_4583():
+    assert cos(1 + x + x**2).series(x, 0, 5) == cos(1) - x*sin(1) + \
+        x**2*(-sin(1) - cos(1)/2) + x**3*(-cos(1) + sin(1)/6) + \
+        x**4*(-11*cos(1)/24 + sin(1)/2) + O(x**5)
+
+
+def test_issue_6318():
+    eq = (1/x)**Rational(2, 3)
+    assert (eq + 1).as_leading_term(x) == eq
+
+
+def test_x_is_base_detection():
+    eq = (x**2)**Rational(2, 3)
+    assert eq.series() == x**Rational(4, 3)
+
+
+def test_issue_7203():
+    assert series(cos(x), x, pi, 3) == \
+        -1 + (x - pi)**2/2 + O((x - pi)**3, (x, pi))
+
+
+def test_exp_product_positive_factors():
+    a, b = symbols('a, b', positive=True)
+    x = a * b
+    assert series(exp(x), x, n=8) == 1 + a*b + a**2*b**2/2 + \
+        a**3*b**3/6 + a**4*b**4/24 + a**5*b**5/120 + a**6*b**6/720 + \
+        a**7*b**7/5040 + O(a**8*b**8, a, b)
+
+
+def test_issue_8805():
+    assert series(1, n=8) == 1
+
+
+def test_issue_9173():
+    p0,p1,p2,p3,b0,b1,b2=symbols('p0 p1 p2 p3 b0 b1 b2')
+    Q=(p0+(p1+(p2+p3/y)/y)/y)/(1+((p3/(b0*y)+(b0*p2-b1*p3)/b0**2)/y+\
+       (b0**2*p1-b0*b1*p2-p3*(b0*b2-b1**2))/b0**3)/y)
+
+    series = Q.series(y,n=3)
+
+    assert series == y*(b0*p2/p3+b0*(-p2/p3+b1/b0))+y**2*(b0*p1/p3+b0*p2*\
+            (-p2/p3+b1/b0)/p3+b0*(-p1/p3+(p2/p3-b1/b0)**2+b1*p2/(b0*p3)+\
+            b2/b0-b1**2/b0**2))+b0+O(y**3)
+    assert series.simplify() == b2*y**2 + b1*y + b0 + O(y**3)
+
+
+def test_issue_9549():
+    y = (x**2 + x + 1) / (x**3 + x**2)
+    assert series(y, x, oo) == x**(-5) - 1/x**4 + x**(-3) + 1/x + O(x**(-6), (x, oo))
+
+
+def test_issue_10761():
+    assert series(1/(x**-2 + x**-3), x, 0) == x**3 - x**4 + x**5 + O(x**6)
+
+
+def test_issue_12578():
+    y = (1 - 1/(x/2 - 1/(2*x))**4)**(S(1)/8)
+    assert y.series(x, 0, n=17) == 1 - 2*x**4 - 8*x**6 - 34*x**8 - 152*x**10 - 714*x**12 - \
+        3472*x**14 - 17318*x**16 + O(x**17)
+
+
+def test_issue_12791():
+    beta = symbols('beta', positive=True)
+    theta, varphi = symbols('theta varphi', real=True)
+
+    expr = (-beta**2*varphi*sin(theta) + beta**2*cos(theta) + \
+        beta*varphi*sin(theta) - beta*cos(theta) - beta + 1)/(beta*cos(theta) - 1)**2
+
+    sol = (0.5/(0.5*cos(theta) - 1.0)**2 - 0.25*cos(theta)/(0.5*cos(theta) - 1.0)**2
+        + (beta - 0.5)*(-0.25*varphi*sin(2*theta) - 1.5*cos(theta)
+        + 0.25*cos(2*theta) + 1.25)/((0.5*cos(theta) - 1.0)**2*(0.5*cos(theta) - 1.0))
+        + 0.25*varphi*sin(theta)/(0.5*cos(theta) - 1.0)**2
+        + O((beta - S.Half)**2, (beta, S.Half)))
+
+    assert expr.series(beta, 0.5, 2).trigsimp() == sol
+
+
+def test_issue_14384():
+    x, a = symbols('x a')
+    assert series(x**a, x) == x**a
+    assert series(x**(-2*a), x) == x**(-2*a)
+    assert series(exp(a*log(x)), x) == exp(a*log(x))
+    raises(PoleError, lambda: series(x**I, x))
+    raises(PoleError, lambda: series(x**(I + 1), x))
+    raises(PoleError, lambda: series(exp(I*log(x)), x))
+
+
+def test_issue_14885():
+    assert series(x**Rational(-3, 2)*exp(x), x, 0) == (x**Rational(-3, 2) + 1/sqrt(x) +
+        sqrt(x)/2 + x**Rational(3, 2)/6 + x**Rational(5, 2)/24 + x**Rational(7, 2)/120 +
+        x**Rational(9, 2)/720 + x**Rational(11, 2)/5040 + O(x**6))
+
+
+def test_issue_15539():
+    assert series(atan(x), x, -oo) == (-1/(5*x**5) + 1/(3*x**3) - 1/x - pi/2
+        + O(x**(-6), (x, -oo)))
+    assert series(atan(x), x, oo) == (-1/(5*x**5) + 1/(3*x**3) - 1/x + pi/2
+        + O(x**(-6), (x, oo)))
+
+
+def test_issue_7259():
+    assert series(LambertW(x), x) == x - x**2 + 3*x**3/2 - 8*x**4/3 + 125*x**5/24 + O(x**6)
+    assert series(LambertW(x**2), x, n=8) == x**2 - x**4 + 3*x**6/2 + O(x**8)
+    assert series(LambertW(sin(x)), x, n=4) == x - x**2 + 4*x**3/3 + O(x**4)
+
+def test_issue_11884():
+    assert cos(x).series(x, 1, n=1) == cos(1) + O(x - 1, (x, 1))
+
+
+def test_issue_18008():
+    y = x*(1 + x*(1 - x))/((1 + x*(1 - x)) - (1 - x)*(1 - x))
+    assert y.series(x, oo, n=4) == -9/(32*x**3) - 3/(16*x**2) - 1/(8*x) + S(1)/4 + x/2 + \
+        O(x**(-4), (x, oo))
+
+
+def test_issue_18842():
+    f = log(x/(1 - x))
+    assert f.series(x, 0.491, n=1).removeO().nsimplify() ==  \
+        -S(180019443780011)/5000000000000000
+
+
+def test_issue_19534():
+    dt = symbols('dt', real=True)
+    expr = 16*dt*(0.125*dt*(2.0*dt + 1.0) + 0.875*dt + 1.0)/45 + \
+            49*dt*(-0.049335189898860408029*dt*(2.0*dt + 1.0) + \
+            0.29601113939316244817*dt*(0.125*dt*(2.0*dt + 1.0) + 0.875*dt + 1.0) - \
+            0.12564355335492979587*dt*(0.074074074074074074074*dt*(2.0*dt + 1.0) + \
+            0.2962962962962962963*dt*(0.125*dt*(2.0*dt + 1.0) + 0.875*dt + 1.0) + \
+            0.96296296296296296296*dt + 1.0) + 0.051640768506639183825*dt + \
+            dt*(1/2 - sqrt(21)/14) + 1.0)/180 + 49*dt*(-0.23637909581542530626*dt*(2.0*dt + 1.0) - \
+            0.74817562366625959291*dt*(0.125*dt*(2.0*dt + 1.0) + 0.875*dt + 1.0) + \
+            0.88085458023927036857*dt*(0.074074074074074074074*dt*(2.0*dt + 1.0) + \
+            0.2962962962962962963*dt*(0.125*dt*(2.0*dt + 1.0) + 0.875*dt + 1.0) + \
+            0.96296296296296296296*dt + 1.0) + \
+            2.1165151389911680013*dt*(-0.049335189898860408029*dt*(2.0*dt + 1.0) + \
+            0.29601113939316244817*dt*(0.125*dt*(2.0*dt + 1.0) + 0.875*dt + 1.0) - \
+            0.12564355335492979587*dt*(0.074074074074074074074*dt*(2.0*dt + 1.0) + \
+            0.2962962962962962963*dt*(0.125*dt*(2.0*dt + 1.0) + 0.875*dt + 1.0) + \
+            0.96296296296296296296*dt + 1.0) + 0.22431393315265061193*dt + 1.0) - \
+            1.1854881643947648988*dt + dt*(sqrt(21)/14 + 1/2) + 1.0)/180 + \
+            dt*(0.66666666666666666667*dt*(2.0*dt + 1.0) + \
+            6.0173399699313066769*dt*(0.125*dt*(2.0*dt + 1.0) + 0.875*dt + 1.0) - \
+            4.1117044797036320069*dt*(0.074074074074074074074*dt*(2.0*dt + 1.0) + \
+            0.2962962962962962963*dt*(0.125*dt*(2.0*dt + 1.0) + 0.875*dt + 1.0) + \
+            0.96296296296296296296*dt + 1.0) - \
+            7.0189140975801991157*dt*(-0.049335189898860408029*dt*(2.0*dt + 1.0) + \
+            0.29601113939316244817*dt*(0.125*dt*(2.0*dt + 1.0) + 0.875*dt + 1.0) - \
+            0.12564355335492979587*dt*(0.074074074074074074074*dt*(2.0*dt + 1.0) + \
+            0.2962962962962962963*dt*(0.125*dt*(2.0*dt + 1.0) + 0.875*dt + 1.0) + \
+            0.96296296296296296296*dt + 1.0) + 0.22431393315265061193*dt + 1.0) + \
+            0.94010945196161777522*dt*(-0.23637909581542530626*dt*(2.0*dt + 1.0) - \
+            0.74817562366625959291*dt*(0.125*dt*(2.0*dt + 1.0) + 0.875*dt + 1.0) + \
+            0.88085458023927036857*dt*(0.074074074074074074074*dt*(2.0*dt + 1.0) + \
+            0.2962962962962962963*dt*(0.125*dt*(2.0*dt + 1.0) + 0.875*dt + 1.0) + \
+            0.96296296296296296296*dt + 1.0) + \
+            2.1165151389911680013*dt*(-0.049335189898860408029*dt*(2.0*dt + 1.0) + \
+            0.29601113939316244817*dt*(0.125*dt*(2.0*dt + 1.0) + 0.875*dt + 1.0) - \
+            0.12564355335492979587*dt*(0.074074074074074074074*dt*(2.0*dt + 1.0) + \
+            0.2962962962962962963*dt*(0.125*dt*(2.0*dt + 1.0) + 0.875*dt + 1.0) + \
+            0.96296296296296296296*dt + 1.0) + 0.22431393315265061193*dt + 1.0) - \
+            0.35816132904077632692*dt + 1.0) + 5.5065024887242400038*dt + 1.0)/20 + dt/20 + 1
+
+    assert N(expr.series(dt, 0, 8), 20) == (
+            - Float('0.00092592592592592596126289', precision=70) * dt**7
+            + Float('0.0027777777777777783174695', precision=70) * dt**6
+            + Float('0.016666666666666656027029', precision=70) * dt**5
+            + Float('0.083333333333333300951828', precision=70) * dt**4
+            + Float('0.33333333333333337034077', precision=70) * dt**3
+            + Float('1.0', precision=70) * dt**2
+            + Float('1.0', precision=70) * dt
+            + Float('1.0', precision=70)
+        )
+
+
+def test_issue_11407():
+    a, b, c, x = symbols('a b c x')
+    assert series(sqrt(a + b + c*x), x, 0, 1) == sqrt(a + b) + O(x)
+    assert series(sqrt(a + b + c + c*x), x, 0, 1) == sqrt(a + b + c) + O(x)
+
+
+def test_issue_14037():
+    assert (sin(x**50)/x**51).series(x, n=0) == 1/x + O(1, x)
+
+
+def test_issue_20551():
+    expr = (exp(x)/x).series(x, n=None)
+    terms = [ next(expr) for i in range(3) ]
+    assert terms == [1/x, 1, x/2]
+
+
+def test_issue_20697():
+    p_0, p_1, p_2, p_3, b_0, b_1, b_2 = symbols('p_0 p_1 p_2 p_3 b_0 b_1 b_2')
+    Q = (p_0 + (p_1 + (p_2 + p_3/y)/y)/y)/(1 + ((p_3/(b_0*y) + (b_0*p_2\
+        - b_1*p_3)/b_0**2)/y + (b_0**2*p_1 - b_0*b_1*p_2 - p_3*(b_0*b_2\
+        - b_1**2))/b_0**3)/y)
+    assert Q.series(y, n=3).ratsimp() == b_2*y**2 + b_1*y + b_0 + O(y**3)
+
+
+def test_issue_21245():
+    fi = (1 + sqrt(5))/2
+    assert (1/(1 - x - x**2)).series(x, 1/fi, 1).factor() == \
+        (-37*sqrt(5) - 83 + 13*sqrt(5)*x + 29*x + O((x - 2/(1 + sqrt(5)))**2, (x\
+            , 2/(1 + sqrt(5)))))/((2*sqrt(5) + 5)**2*(x + sqrt(5)*x - 2))
+
+
+
+def test_issue_21938():
+    expr = sin(1/x + exp(-x)) - sin(1/x)
+    assert expr.series(x, oo) == (1/(24*x**4) - 1/(2*x**2) + 1 + O(x**(-6), (x, oo)))*exp(-x)
+
+
+def test_issue_23432():
+    expr = 1/sqrt(1 - x**2)
+    result = expr.series(x, 0.5)
+    assert result.is_Add and len(result.args) == 7
+
+
+def test_issue_23727():
+    res = series(sqrt(1 - x**2), x, 0.1)
+    assert res.is_Add == True
+
+
+def test_issue_24266():
+    #type1: exp(f(x))
+    assert (exp(-I*pi*(2*x+1))).series(x, 0, 3) == -1 + 2*I*pi*x + 2*pi**2*x**2 + O(x**3)
+    assert (exp(-I*pi*(2*x+1))*gamma(1+x)).series(x, 0, 3) == -1 + x*(EulerGamma + 2*I*pi) + \
+        x**2*(-EulerGamma**2/2 + 23*pi**2/12 - 2*EulerGamma*I*pi) + O(x**3)
+
+    #type2: c**f(x)
+    assert ((2*I)**(-I*pi*(2*x+1))).series(x, 0, 2) == exp(pi**2/2 - I*pi*log(2)) + \
+          x*(pi**2*exp(pi**2/2 - I*pi*log(2)) - 2*I*pi*exp(pi**2/2 - I*pi*log(2))*log(2)) + O(x**2)
+    assert ((2)**(-I*pi*(2*x+1))).series(x, 0, 2) == exp(-I*pi*log(2)) - 2*I*pi*x*exp(-I*pi*log(2))*log(2) + O(x**2)
+
+    #type3: f(y)**g(x)
+    assert ((y)**(I*pi*(2*x+1))).series(x, 0, 2) == exp(I*pi*log(y)) + 2*I*pi*x*exp(I*pi*log(y))*log(y) + O(x**2)
+    assert ((I*y)**(I*pi*(2*x+1))).series(x, 0, 2) == exp(I*pi*log(I*y)) + 2*I*pi*x*exp(I*pi*log(I*y))*log(I*y) + O(x**2)
+
+
+def test_issue_26856():
+    raises(ValueError, lambda: (2**x).series(x, oo, -1))
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/sets/__pycache__/__init__.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/sets/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..987c0d5bfd4312e974dba985a57e6cb8aa8cfed6
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/sets/__pycache__/__init__.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/sets/__pycache__/conditionset.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/sets/__pycache__/conditionset.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..523612e6bbaba5c2c5facf52b9faf940120e0320
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/sets/__pycache__/conditionset.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/sets/__pycache__/contains.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/sets/__pycache__/contains.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..1c0fe9bbeb5c7f4abd034294908be3cafa767cb1
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/sets/__pycache__/contains.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/sets/__pycache__/fancysets.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/sets/__pycache__/fancysets.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..735e0325e5414c0c02c9e6e0895e6ccc04fdab56
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/sets/__pycache__/fancysets.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/sets/__pycache__/ordinals.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/sets/__pycache__/ordinals.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a3b8d3c720075daedf1f76f9cd0cb96ff6d38bc5
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/sets/__pycache__/ordinals.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/sets/__pycache__/powerset.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/sets/__pycache__/powerset.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..38665c052e89747518b1dffd74a4500418e5bc1e
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/sets/__pycache__/powerset.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/sets/__pycache__/setexpr.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/sets/__pycache__/setexpr.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..2fb0fb21cc8651b5f3291d0bb61feaee397eab9b
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/sets/__pycache__/setexpr.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/sets/__pycache__/sets.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/sets/__pycache__/sets.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..aa74f6c2bd53abbe3c3a5eea75208b2b0070706f
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/sets/__pycache__/sets.cpython-312.pyc
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:dad699964f346af36034136de3ad0656abb267a546162671d10383b23204610c
+size 115019
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/sets/handlers/__init__.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/sets/handlers/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/sets/handlers/__pycache__/__init__.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/sets/handlers/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..9cd355b10719c5d7070774dd1eae0b813839243d
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/sets/handlers/__pycache__/__init__.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/sets/handlers/__pycache__/add.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/sets/handlers/__pycache__/add.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c7ea913df0dea9f305230f36bf39784dfd88bb16
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/sets/handlers/__pycache__/add.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/sets/handlers/__pycache__/comparison.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/sets/handlers/__pycache__/comparison.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..902c8f40332a90d55c29e65ea0fdc7809609f7a7
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/sets/handlers/__pycache__/comparison.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/sets/handlers/__pycache__/functions.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/sets/handlers/__pycache__/functions.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..9e41dff1d98098e4167d8a5a7227ab3cce70f393
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/sets/handlers/__pycache__/functions.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/sets/handlers/__pycache__/intersection.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/sets/handlers/__pycache__/intersection.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a90e031ab979c79cc072336ca54ae37c1d0a3e0c
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/sets/handlers/__pycache__/intersection.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/sets/handlers/__pycache__/issubset.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/sets/handlers/__pycache__/issubset.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..46405e43a0954cc8d6a6f987be5997202abfbb68
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/sets/handlers/__pycache__/issubset.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/sets/handlers/__pycache__/mul.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/sets/handlers/__pycache__/mul.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..391de82453f3a07748bdc78ceac1de86480f53d4
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/sets/handlers/__pycache__/mul.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/sets/handlers/__pycache__/power.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/sets/handlers/__pycache__/power.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..02224e3fa93347c876e7d38dcfdc034dc0582d0c
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/sets/handlers/__pycache__/power.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/sets/handlers/__pycache__/union.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/sets/handlers/__pycache__/union.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..90b6c15809bf32556d95211fef2606df083bf329
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/sets/handlers/__pycache__/union.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/sets/handlers/add.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/sets/handlers/add.py
new file mode 100644
index 0000000000000000000000000000000000000000..8c07b25ed19d21febffd6b23a92b34b787179f44
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/sets/handlers/add.py
@@ -0,0 +1,79 @@
+from sympy.core.numbers import oo, Infinity, NegativeInfinity
+from sympy.core.singleton import S
+from sympy.core import Basic, Expr
+from sympy.multipledispatch import Dispatcher
+from sympy.sets import Interval, FiniteSet
+
+
+
+# XXX: The functions in this module are clearly not tested and are broken in a
+# number of ways.
+
+_set_add = Dispatcher('_set_add')
+_set_sub = Dispatcher('_set_sub')
+
+
+@_set_add.register(Basic, Basic)
+def _(x, y):
+    return None
+
+
+@_set_add.register(Expr, Expr)
+def _(x, y):
+    return x+y
+
+
+@_set_add.register(Interval, Interval)
+def _(x, y):
+    """
+    Additions in interval arithmetic
+    https://en.wikipedia.org/wiki/Interval_arithmetic
+    """
+    return Interval(x.start + y.start, x.end + y.end,
+                    x.left_open or y.left_open, x.right_open or y.right_open)
+
+
+@_set_add.register(Interval, Infinity)
+def _(x, y):
+    if x.start is S.NegativeInfinity:
+        return Interval(-oo, oo)
+    return FiniteSet({S.Infinity})
+
+@_set_add.register(Interval, NegativeInfinity)
+def _(x, y):
+    if x.end is S.Infinity:
+        return Interval(-oo, oo)
+    return FiniteSet({S.NegativeInfinity})
+
+
+@_set_sub.register(Basic, Basic)
+def _(x, y):
+    return None
+
+
+@_set_sub.register(Expr, Expr)
+def _(x, y):
+    return x-y
+
+
+@_set_sub.register(Interval, Interval)
+def _(x, y):
+    """
+    Subtractions in interval arithmetic
+    https://en.wikipedia.org/wiki/Interval_arithmetic
+    """
+    return Interval(x.start - y.end, x.end - y.start,
+                    x.left_open or y.right_open, x.right_open or y.left_open)
+
+
+@_set_sub.register(Interval, Infinity)
+def _(x, y):
+    if x.start is S.NegativeInfinity:
+        return Interval(-oo, oo)
+    return FiniteSet(-oo)
+
+@_set_sub.register(Interval, NegativeInfinity)
+def _(x, y):
+    if x.start is S.NegativeInfinity:
+        return Interval(-oo, oo)
+    return FiniteSet(-oo)
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/sets/handlers/comparison.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/sets/handlers/comparison.py
new file mode 100644
index 0000000000000000000000000000000000000000..b64d1a2a22e15d09f6f10fb4fef730163d468d45
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/sets/handlers/comparison.py
@@ -0,0 +1,53 @@
+from sympy.core.relational import Eq, is_eq
+from sympy.core.basic import Basic
+from sympy.core.logic import fuzzy_and, fuzzy_bool
+from sympy.logic.boolalg import And
+from sympy.multipledispatch import dispatch
+from sympy.sets.sets import tfn, ProductSet, Interval, FiniteSet, Set
+
+
+@dispatch(Interval, FiniteSet) # type:ignore
+def _eval_is_eq(lhs, rhs): # noqa: F811
+    return False
+
+
+@dispatch(FiniteSet, Interval) # type:ignore
+def _eval_is_eq(lhs, rhs): # noqa: F811
+    return False
+
+
+@dispatch(Interval, Interval) # type:ignore
+def _eval_is_eq(lhs, rhs): # noqa: F811
+    return And(Eq(lhs.left, rhs.left),
+               Eq(lhs.right, rhs.right),
+               lhs.left_open == rhs.left_open,
+               lhs.right_open == rhs.right_open)
+
+@dispatch(FiniteSet, FiniteSet) # type:ignore
+def _eval_is_eq(lhs, rhs): # noqa: F811
+    def all_in_both():
+        s_set = set(lhs.args)
+        o_set = set(rhs.args)
+        yield fuzzy_and(lhs._contains(e) for e in o_set - s_set)
+        yield fuzzy_and(rhs._contains(e) for e in s_set - o_set)
+
+    return tfn[fuzzy_and(all_in_both())]
+
+
+@dispatch(ProductSet, ProductSet) # type:ignore
+def _eval_is_eq(lhs, rhs): # noqa: F811
+    if len(lhs.sets) != len(rhs.sets):
+        return False
+
+    eqs = (is_eq(x, y) for x, y in zip(lhs.sets, rhs.sets))
+    return tfn[fuzzy_and(map(fuzzy_bool, eqs))]
+
+
+@dispatch(Set, Basic) # type:ignore
+def _eval_is_eq(lhs, rhs): # noqa: F811
+    return False
+
+
+@dispatch(Set, Set) # type:ignore
+def _eval_is_eq(lhs, rhs): # noqa: F811
+    return tfn[fuzzy_and(a.is_subset(b) for a, b in [(lhs, rhs), (rhs, lhs)])]
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/sets/handlers/functions.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/sets/handlers/functions.py
new file mode 100644
index 0000000000000000000000000000000000000000..2529dbfd458451d7d09e91c717b170df77b1d9fe
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/sets/handlers/functions.py
@@ -0,0 +1,262 @@
+from sympy.core.singleton import S
+from sympy.sets.sets import Set
+from sympy.calculus.singularities import singularities
+from sympy.core import Expr, Add
+from sympy.core.function import Lambda, FunctionClass, diff, expand_mul
+from sympy.core.numbers import Float, oo
+from sympy.core.symbol import Dummy, symbols, Wild
+from sympy.functions.elementary.exponential import exp, log
+from sympy.functions.elementary.miscellaneous import Min, Max
+from sympy.logic.boolalg import true
+from sympy.multipledispatch import Dispatcher
+from sympy.sets import (imageset, Interval, FiniteSet, Union, ImageSet,
+    Intersection, Range, Complement)
+from sympy.sets.sets import EmptySet, is_function_invertible_in_set
+from sympy.sets.fancysets import Integers, Naturals, Reals
+from sympy.functions.elementary.exponential import match_real_imag
+
+
+_x, _y = symbols("x y")
+
+FunctionUnion = (FunctionClass, Lambda)
+
+_set_function = Dispatcher('_set_function')
+
+
+@_set_function.register(FunctionClass, Set)
+def _(f, x):
+    return None
+
+@_set_function.register(FunctionUnion, FiniteSet)
+def _(f, x):
+    return FiniteSet(*map(f, x))
+
+@_set_function.register(Lambda, Interval)
+def _(f, x):
+    from sympy.solvers.solveset import solveset
+    from sympy.series import limit
+    # TODO: handle functions with infinitely many solutions (eg, sin, tan)
+    # TODO: handle multivariate functions
+
+    expr = f.expr
+    if len(expr.free_symbols) > 1 or len(f.variables) != 1:
+        return
+    var = f.variables[0]
+    if not var.is_real:
+        if expr.subs(var, Dummy(real=True)).is_real is False:
+            return
+
+    if expr.is_Piecewise:
+        result = S.EmptySet
+        domain_set = x
+        for (p_expr, p_cond) in expr.args:
+            if p_cond is true:
+                intrvl = domain_set
+            else:
+                intrvl = p_cond.as_set()
+                intrvl = Intersection(domain_set, intrvl)
+
+            if p_expr.is_Number:
+                image = FiniteSet(p_expr)
+            else:
+                image = imageset(Lambda(var, p_expr), intrvl)
+            result = Union(result, image)
+
+            # remove the part which has been `imaged`
+            domain_set = Complement(domain_set, intrvl)
+            if domain_set is S.EmptySet:
+                break
+        return result
+
+    if not x.start.is_comparable or not x.end.is_comparable:
+        return
+
+    try:
+        from sympy.polys.polyutils import _nsort
+        sing = list(singularities(expr, var, x))
+        if len(sing) > 1:
+            sing = _nsort(sing)
+    except NotImplementedError:
+        return
+
+    if x.left_open:
+        _start = limit(expr, var, x.start, dir="+")
+    elif x.start not in sing:
+        _start = f(x.start)
+    if x.right_open:
+        _end = limit(expr, var, x.end, dir="-")
+    elif x.end not in sing:
+        _end = f(x.end)
+
+    if len(sing) == 0:
+        soln_expr = solveset(diff(expr, var), var)
+        if not (isinstance(soln_expr, FiniteSet)
+                or soln_expr is S.EmptySet):
+            return
+        solns = list(soln_expr)
+
+        extr = [_start, _end] + [f(i) for i in solns
+                                 if i.is_real and i in x]
+        start, end = Min(*extr), Max(*extr)
+
+        left_open, right_open = False, False
+        if _start <= _end:
+            # the minimum or maximum value can occur simultaneously
+            # on both the edge of the interval and in some interior
+            # point
+            if start == _start and start not in solns:
+                left_open = x.left_open
+            if end == _end and end not in solns:
+                right_open = x.right_open
+        else:
+            if start == _end and start not in solns:
+                left_open = x.right_open
+            if end == _start and end not in solns:
+                right_open = x.left_open
+
+        return Interval(start, end, left_open, right_open)
+    else:
+        return imageset(f, Interval(x.start, sing[0],
+                                    x.left_open, True)) + \
+            Union(*[imageset(f, Interval(sing[i], sing[i + 1], True, True))
+                    for i in range(0, len(sing) - 1)]) + \
+            imageset(f, Interval(sing[-1], x.end, True, x.right_open))
+
+@_set_function.register(FunctionClass, Interval)
+def _(f, x):
+    if f == exp:
+        return Interval(exp(x.start), exp(x.end), x.left_open, x.right_open)
+    elif f == log:
+        return Interval(log(x.start), log(x.end), x.left_open, x.right_open)
+    return ImageSet(Lambda(_x, f(_x)), x)
+
+@_set_function.register(FunctionUnion, Union)
+def _(f, x):
+    return Union(*(imageset(f, arg) for arg in x.args))
+
+@_set_function.register(FunctionUnion, Intersection)
+def _(f, x):
+    # If the function is invertible, intersect the maps of the sets.
+    if is_function_invertible_in_set(f, x):
+        return Intersection(*(imageset(f, arg) for arg in x.args))
+    else:
+        return ImageSet(Lambda(_x, f(_x)), x)
+
+@_set_function.register(FunctionUnion, EmptySet)
+def _(f, x):
+    return x
+
+@_set_function.register(FunctionUnion, Set)
+def _(f, x):
+    return ImageSet(Lambda(_x, f(_x)), x)
+
+@_set_function.register(FunctionUnion, Range)
+def _(f, self):
+    if not self:
+        return S.EmptySet
+    if not isinstance(f.expr, Expr):
+        return
+    if self.size == 1:
+        return FiniteSet(f(self[0]))
+    if f is S.IdentityFunction:
+        return self
+
+    x = f.variables[0]
+    expr = f.expr
+    # handle f that is linear in f's variable
+    if x not in expr.free_symbols or x in expr.diff(x).free_symbols:
+        return
+    if self.start.is_finite:
+        F = f(self.step*x + self.start)  # for i in range(len(self))
+    else:
+        F = f(-self.step*x + self[-1])
+    F = expand_mul(F)
+    if F != expr:
+        return imageset(x, F, Range(self.size))
+
+@_set_function.register(FunctionUnion, Integers)
+def _(f, self):
+    expr = f.expr
+    if not isinstance(expr, Expr):
+        return
+
+    n = f.variables[0]
+    if expr == abs(n):
+        return S.Naturals0
+
+    # f(x) + c and f(-x) + c cover the same integers
+    # so choose the form that has the fewest negatives
+    c = f(0)
+    fx = f(n) - c
+    f_x = f(-n) - c
+    neg_count = lambda e: sum(_.could_extract_minus_sign()
+        for _ in Add.make_args(e))
+    if neg_count(f_x) < neg_count(fx):
+        expr = f_x + c
+
+    a = Wild('a', exclude=[n])
+    b = Wild('b', exclude=[n])
+    match = expr.match(a*n + b)
+    if match and match[a] and (
+            not match[a].atoms(Float) and
+            not match[b].atoms(Float)):
+        # canonical shift
+        a, b = match[a], match[b]
+        if a in [1, -1]:
+            # drop integer addends in b
+            nonint = []
+            for bi in Add.make_args(b):
+                if not bi.is_integer:
+                    nonint.append(bi)
+            b = Add(*nonint)
+        if b.is_number and a.is_real:
+            # avoid Mod for complex numbers, #11391
+            br, bi = match_real_imag(b)
+            if br and br.is_comparable and a.is_comparable:
+                br %= a
+                b = br + S.ImaginaryUnit*bi
+        elif b.is_number and a.is_imaginary:
+            br, bi = match_real_imag(b)
+            ai = a/S.ImaginaryUnit
+            if bi and bi.is_comparable and ai.is_comparable:
+                bi %= ai
+                b = br + S.ImaginaryUnit*bi
+        expr = a*n + b
+
+    if expr != f.expr:
+        return ImageSet(Lambda(n, expr), S.Integers)
+
+
+@_set_function.register(FunctionUnion, Naturals)
+def _(f, self):
+    expr = f.expr
+    if not isinstance(expr, Expr):
+        return
+
+    x = f.variables[0]
+    if not expr.free_symbols - {x}:
+        if expr == abs(x):
+            if self is S.Naturals:
+                return self
+            return S.Naturals0
+        step = expr.coeff(x)
+        c = expr.subs(x, 0)
+        if c.is_Integer and step.is_Integer and expr == step*x + c:
+            if self is S.Naturals:
+                c += step
+            if step > 0:
+                if step == 1:
+                    if c == 0:
+                        return S.Naturals0
+                    elif c == 1:
+                        return S.Naturals
+                return Range(c, oo, step)
+            return Range(c, -oo, step)
+
+
+@_set_function.register(FunctionUnion, Reals)
+def _(f, self):
+    expr = f.expr
+    if not isinstance(expr, Expr):
+        return
+    return _set_function(f, Interval(-oo, oo))
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/sets/handlers/intersection.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/sets/handlers/intersection.py
new file mode 100644
index 0000000000000000000000000000000000000000..fcb9309ef3e9d2722ab1bfe664f1d1644f17da5d
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/sets/handlers/intersection.py
@@ -0,0 +1,533 @@
+from sympy.core.basic import _aresame
+from sympy.core.function import Lambda, expand_complex
+from sympy.core.mul import Mul
+from sympy.core.numbers import ilcm, Float
+from sympy.core.relational import Eq
+from sympy.core.singleton import S
+from sympy.core.symbol import (Dummy, symbols)
+from sympy.core.sorting import ordered
+from sympy.functions.elementary.complexes import sign
+from sympy.functions.elementary.integers import floor, ceiling
+from sympy.sets.fancysets import ComplexRegion
+from sympy.sets.sets import (FiniteSet, Intersection, Interval, Set, Union)
+from sympy.multipledispatch import Dispatcher
+from sympy.sets.conditionset import ConditionSet
+from sympy.sets.fancysets import (Integers, Naturals, Reals, Range,
+    ImageSet, Rationals)
+from sympy.sets.sets import EmptySet, UniversalSet, imageset, ProductSet
+from sympy.simplify.radsimp import numer
+
+
+intersection_sets = Dispatcher('intersection_sets')
+
+
+@intersection_sets.register(ConditionSet, ConditionSet)
+def _(a, b):
+    return None
+
+@intersection_sets.register(ConditionSet, Set)
+def _(a, b):
+    return ConditionSet(a.sym, a.condition, Intersection(a.base_set, b))
+
+@intersection_sets.register(Naturals, Integers)
+def _(a, b):
+    return a
+
+@intersection_sets.register(Naturals, Naturals)
+def _(a, b):
+    return a if a is S.Naturals else b
+
+@intersection_sets.register(Interval, Naturals)
+def _(a, b):
+    return intersection_sets(b, a)
+
+@intersection_sets.register(ComplexRegion, Set)
+def _(self, other):
+    if other.is_ComplexRegion:
+        # self in rectangular form
+        if (not self.polar) and (not other.polar):
+            return ComplexRegion(Intersection(self.sets, other.sets))
+
+        # self in polar form
+        elif self.polar and other.polar:
+            r1, theta1 = self.a_interval, self.b_interval
+            r2, theta2 = other.a_interval, other.b_interval
+            new_r_interval = Intersection(r1, r2)
+            new_theta_interval = Intersection(theta1, theta2)
+
+            # 0 and 2*Pi means the same
+            if ((2*S.Pi in theta1 and S.Zero in theta2) or
+               (2*S.Pi in theta2 and S.Zero in theta1)):
+                new_theta_interval = Union(new_theta_interval,
+                                           FiniteSet(0))
+            return ComplexRegion(new_r_interval*new_theta_interval,
+                                polar=True)
+
+
+    if other.is_subset(S.Reals):
+        new_interval = []
+        x = symbols("x", cls=Dummy, real=True)
+
+        # self in rectangular form
+        if not self.polar:
+            for element in self.psets:
+                if S.Zero in element.args[1]:
+                    new_interval.append(element.args[0])
+            new_interval = Union(*new_interval)
+            return Intersection(new_interval, other)
+
+        # self in polar form
+        elif self.polar:
+            for element in self.psets:
+                if S.Zero in element.args[1]:
+                    new_interval.append(element.args[0])
+                if S.Pi in element.args[1]:
+                    new_interval.append(ImageSet(Lambda(x, -x), element.args[0]))
+                if S.Zero in element.args[0]:
+                    new_interval.append(FiniteSet(0))
+            new_interval = Union(*new_interval)
+            return Intersection(new_interval, other)
+
+@intersection_sets.register(Integers, Reals)
+def _(a, b):
+    return a
+
+@intersection_sets.register(Range, Interval)
+def _(a, b):
+    # Check that there are no symbolic arguments
+    if not all(i.is_number for i in a.args + b.args[:2]):
+        return
+
+    # In case of null Range, return an EmptySet.
+    if a.size == 0:
+        return S.EmptySet
+
+    # trim down to self's size, and represent
+    # as a Range with step 1.
+    start = ceiling(max(b.inf, a.inf))
+    if start not in b:
+        start += 1
+    end = floor(min(b.sup, a.sup))
+    if end not in b:
+        end -= 1
+    return intersection_sets(a, Range(start, end + 1))
+
+@intersection_sets.register(Range, Naturals)
+def _(a, b):
+    return intersection_sets(a, Interval(b.inf, S.Infinity))
+
+@intersection_sets.register(Range, Range)
+def _(a, b):
+    # Check that there are no symbolic range arguments
+    if not all(all(v.is_number for v in r.args) for r in [a, b]):
+        return None
+
+    # non-overlap quick exits
+    if not b:
+        return S.EmptySet
+    if not a:
+        return S.EmptySet
+    if b.sup < a.inf:
+        return S.EmptySet
+    if b.inf > a.sup:
+        return S.EmptySet
+
+    # work with finite end at the start
+    r1 = a
+    if r1.start.is_infinite:
+        r1 = r1.reversed
+    r2 = b
+    if r2.start.is_infinite:
+        r2 = r2.reversed
+
+    # If both ends are infinite then it means that one Range is just the set
+    # of all integers (the step must be 1).
+    if r1.start.is_infinite:
+        return b
+    if r2.start.is_infinite:
+        return a
+
+    from sympy.solvers.diophantine.diophantine import diop_linear
+
+    # this equation represents the values of the Range;
+    # it's a linear equation
+    eq = lambda r, i: r.start + i*r.step
+
+    # we want to know when the two equations might
+    # have integer solutions so we use the diophantine
+    # solver
+    va, vb = diop_linear(eq(r1, Dummy('a')) - eq(r2, Dummy('b')))
+
+    # check for no solution
+    no_solution = va is None and vb is None
+    if no_solution:
+        return S.EmptySet
+
+    # there is a solution
+    # -------------------
+
+    # find the coincident point, c
+    a0 = va.as_coeff_Add()[0]
+    c = eq(r1, a0)
+
+    # find the first point, if possible, in each range
+    # since c may not be that point
+    def _first_finite_point(r1, c):
+        if c == r1.start:
+            return c
+        # st is the signed step we need to take to
+        # get from c to r1.start
+        st = sign(r1.start - c)*step
+        # use Range to calculate the first point:
+        # we want to get as close as possible to
+        # r1.start; the Range will not be null since
+        # it will at least contain c
+        s1 = Range(c, r1.start + st, st)[-1]
+        if s1 == r1.start:
+            pass
+        else:
+            # if we didn't hit r1.start then, if the
+            # sign of st didn't match the sign of r1.step
+            # we are off by one and s1 is not in r1
+            if sign(r1.step) != sign(st):
+                s1 -= st
+        if s1 not in r1:
+            return
+        return s1
+
+    # calculate the step size of the new Range
+    step = abs(ilcm(r1.step, r2.step))
+    s1 = _first_finite_point(r1, c)
+    if s1 is None:
+        return S.EmptySet
+    s2 = _first_finite_point(r2, c)
+    if s2 is None:
+        return S.EmptySet
+
+    # replace the corresponding start or stop in
+    # the original Ranges with these points; the
+    # result must have at least one point since
+    # we know that s1 and s2 are in the Ranges
+    def _updated_range(r, first):
+        st = sign(r.step)*step
+        if r.start.is_finite:
+            rv = Range(first, r.stop, st)
+        else:
+            rv = Range(r.start, first + st, st)
+        return rv
+    r1 = _updated_range(a, s1)
+    r2 = _updated_range(b, s2)
+
+    # work with them both in the increasing direction
+    if sign(r1.step) < 0:
+        r1 = r1.reversed
+    if sign(r2.step) < 0:
+        r2 = r2.reversed
+
+    # return clipped Range with positive step; it
+    # can't be empty at this point
+    start = max(r1.start, r2.start)
+    stop = min(r1.stop, r2.stop)
+    return Range(start, stop, step)
+
+
+@intersection_sets.register(Range, Integers)
+def _(a, b):
+    return a
+
+
+@intersection_sets.register(Range, Rationals)
+def _(a, b):
+    return a
+
+
+@intersection_sets.register(ImageSet, Set)
+def _(self, other):
+    from sympy.solvers.diophantine import diophantine
+
+    # Only handle the straight-forward univariate case
+    if (len(self.lamda.variables) > 1
+            or self.lamda.signature != self.lamda.variables):
+        return None
+    base_set = self.base_sets[0]
+
+    # Intersection between ImageSets with Integers as base set
+    # For {f(n) : n in Integers} & {g(m) : m in Integers} we solve the
+    # diophantine equations f(n)=g(m).
+    # If the solutions for n are {h(t) : t in Integers} then we return
+    # {f(h(t)) : t in integers}.
+    # If the solutions for n are {n_1, n_2, ..., n_k} then we return
+    # {f(n_i) : 1 <= i <= k}.
+    if base_set is S.Integers:
+        gm = None
+        if isinstance(other, ImageSet) and other.base_sets == (S.Integers,):
+            gm = other.lamda.expr
+            var = other.lamda.variables[0]
+            # Symbol of second ImageSet lambda must be distinct from first
+            m = Dummy('m')
+            gm = gm.subs(var, m)
+        elif other is S.Integers:
+            m = gm = Dummy('m')
+        if gm is not None:
+            fn = self.lamda.expr
+            n = self.lamda.variables[0]
+            try:
+                solns = list(diophantine(fn - gm, syms=(n, m), permute=True))
+            except (TypeError, NotImplementedError):
+                # TypeError if equation not polynomial with rational coeff.
+                # NotImplementedError if correct format but no solver.
+                return
+            # 3 cases are possible for solns:
+            # - empty set,
+            # - one or more parametric (infinite) solutions,
+            # - a finite number of (non-parametric) solution couples.
+            # Among those, there is one type of solution set that is
+            # not helpful here: multiple parametric solutions.
+            if len(solns) == 0:
+                return S.EmptySet
+            elif any(s.free_symbols for tupl in solns for s in tupl):
+                if len(solns) == 1:
+                    soln, solm = solns[0]
+                    (t,) = soln.free_symbols
+                    expr = fn.subs(n, soln.subs(t, n)).expand()
+                    return imageset(Lambda(n, expr), S.Integers)
+                else:
+                    return
+            else:
+                return FiniteSet(*(fn.subs(n, s[0]) for s in solns))
+
+    if other == S.Reals:
+        from sympy.solvers.solvers import denoms, solve_linear
+
+        def _solution_union(exprs, sym):
+            # return a union of linear solutions to i in expr;
+            # if i cannot be solved, use a ConditionSet for solution
+            sols = []
+            for i in exprs:
+                x, xis = solve_linear(i, 0, [sym])
+                if x == sym:
+                    sols.append(FiniteSet(xis))
+                else:
+                    sols.append(ConditionSet(sym, Eq(i, 0)))
+            return Union(*sols)
+
+        f = self.lamda.expr
+        n = self.lamda.variables[0]
+
+        n_ = Dummy(n.name, real=True)
+        f_ = f.subs(n, n_)
+
+        re, im = f_.as_real_imag()
+        im = expand_complex(im)
+
+        re = re.subs(n_, n)
+        im = im.subs(n_, n)
+        ifree = im.free_symbols
+        lam = Lambda(n, re)
+        if im.is_zero:
+            # allow re-evaluation
+            # of self in this case to make
+            # the result canonical
+            pass
+        elif im.is_zero is False:
+            return S.EmptySet
+        elif ifree != {n}:
+            return None
+        else:
+            # univarite imaginary part in same variable;
+            # use numer instead of as_numer_denom to keep
+            # this as fast as possible while still handling
+            # simple cases
+            base_set &= _solution_union(
+                Mul.make_args(numer(im)), n)
+        # exclude values that make denominators 0
+        base_set -= _solution_union(denoms(f), n)
+        return imageset(lam, base_set)
+
+    elif isinstance(other, Interval):
+        from sympy.solvers.solveset import (invert_real, invert_complex,
+                                            solveset)
+
+        f = self.lamda.expr
+        n = self.lamda.variables[0]
+        new_inf, new_sup = None, None
+        new_lopen, new_ropen = other.left_open, other.right_open
+
+        if f.is_real:
+            inverter = invert_real
+        else:
+            inverter = invert_complex
+
+        g1, h1 = inverter(f, other.inf, n)
+        g2, h2 = inverter(f, other.sup, n)
+
+        if all(isinstance(i, FiniteSet) for i in (h1, h2)):
+            if g1 == n:
+                if len(h1) == 1:
+                    new_inf = h1.args[0]
+            if g2 == n:
+                if len(h2) == 1:
+                    new_sup = h2.args[0]
+            # TODO: Design a technique to handle multiple-inverse
+            # functions
+
+            # Any of the new boundary values cannot be determined
+            if any(i is None for i in (new_sup, new_inf)):
+                return
+
+
+            range_set = S.EmptySet
+
+            if all(i.is_real for i in (new_sup, new_inf)):
+                # this assumes continuity of underlying function
+                # however fixes the case when it is decreasing
+                if new_inf > new_sup:
+                    new_inf, new_sup = new_sup, new_inf
+                new_interval = Interval(new_inf, new_sup, new_lopen, new_ropen)
+                range_set = base_set.intersect(new_interval)
+            else:
+                if other.is_subset(S.Reals):
+                    solutions = solveset(f, n, S.Reals)
+                    if not isinstance(range_set, (ImageSet, ConditionSet)):
+                        range_set = solutions.intersect(other)
+                    else:
+                        return
+
+            if range_set is S.EmptySet:
+                return S.EmptySet
+            elif isinstance(range_set, Range) and range_set.size is not S.Infinity:
+                range_set = FiniteSet(*list(range_set))
+
+            if range_set is not None:
+                return imageset(Lambda(n, f), range_set)
+            return
+        else:
+            return
+
+
+@intersection_sets.register(ProductSet, ProductSet)
+def _(a, b):
+    if len(b.args) != len(a.args):
+        return S.EmptySet
+    return ProductSet(*(i.intersect(j) for i, j in zip(a.sets, b.sets)))
+
+
+@intersection_sets.register(Interval, Interval)
+def _(a, b):
+    # handle (-oo, oo)
+    infty = S.NegativeInfinity, S.Infinity
+    if a == Interval(*infty):
+        l, r = a.left, a.right
+        if l.is_real or l in infty or r.is_real or r in infty:
+            return b
+
+    # We can't intersect [0,3] with [x,6] -- we don't know if x>0 or x<0
+    if not a._is_comparable(b):
+        return None
+
+    empty = False
+
+    if a.start <= b.end and b.start <= a.end:
+        # Get topology right.
+        if a.start < b.start:
+            start = b.start
+            left_open = b.left_open
+        elif a.start > b.start:
+            start = a.start
+            left_open = a.left_open
+        else:
+            start = a.start
+            if not _aresame(a.start, b.start):
+                # For example Integer(2) != Float(2)
+                # Prefer the Float boundary because Floats should be
+                # contagious in calculations.
+                if b.start.has(Float) and not a.start.has(Float):
+                    start = b.start
+                elif a.start.has(Float) and not b.start.has(Float):
+                    start = a.start
+                else:
+                    #this is to ensure that if Eq(a.start, b.start) but
+                    #type(a.start) != type(b.start) the order of a and b
+                    #does not matter for the result
+                    start = list(ordered([a,b]))[0].start
+            left_open = a.left_open or b.left_open
+
+        if a.end < b.end:
+            end = a.end
+            right_open = a.right_open
+        elif a.end > b.end:
+            end = b.end
+            right_open = b.right_open
+        else:
+            # see above for logic with start
+            end = a.end
+            if not _aresame(a.end, b.end):
+                if b.end.has(Float) and not a.end.has(Float):
+                    end = b.end
+                elif a.end.has(Float) and not b.end.has(Float):
+                    end = a.end
+                else:
+                    end = list(ordered([a,b]))[0].end
+            right_open = a.right_open or b.right_open
+
+        if end - start == 0 and (left_open or right_open):
+            empty = True
+    else:
+        empty = True
+
+    if empty:
+        return S.EmptySet
+
+    return Interval(start, end, left_open, right_open)
+
+@intersection_sets.register(EmptySet, Set)
+def _(a, b):
+    return S.EmptySet
+
+@intersection_sets.register(UniversalSet, Set)
+def _(a, b):
+    return b
+
+@intersection_sets.register(FiniteSet, FiniteSet)
+def _(a, b):
+    return FiniteSet(*(a._elements & b._elements))
+
+@intersection_sets.register(FiniteSet, Set)
+def _(a, b):
+    try:
+        return FiniteSet(*[el for el in a if el in b])
+    except TypeError:
+        return None  # could not evaluate `el in b` due to symbolic ranges.
+
+@intersection_sets.register(Set, Set)
+def _(a, b):
+    return None
+
+@intersection_sets.register(Integers, Rationals)
+def _(a, b):
+    return a
+
+@intersection_sets.register(Naturals, Rationals)
+def _(a, b):
+    return a
+
+@intersection_sets.register(Rationals, Reals)
+def _(a, b):
+    return a
+
+def _intlike_interval(a, b):
+    try:
+        if b._inf is S.NegativeInfinity and b._sup is S.Infinity:
+            return a
+        s = Range(max(a.inf, ceiling(b.left)), floor(b.right) + 1)
+        return intersection_sets(s, b)  # take out endpoints if open interval
+    except ValueError:
+        return None
+
+@intersection_sets.register(Integers, Interval)
+def _(a, b):
+    return _intlike_interval(a, b)
+
+@intersection_sets.register(Naturals, Interval)
+def _(a, b):
+    return _intlike_interval(a, b)
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/sets/handlers/issubset.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/sets/handlers/issubset.py
new file mode 100644
index 0000000000000000000000000000000000000000..cc23e8bf56f1743cd7f08452dd09a0acf981f5da
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/sets/handlers/issubset.py
@@ -0,0 +1,144 @@
+from sympy.core.singleton import S
+from sympy.core.symbol import Symbol
+from sympy.core.logic import fuzzy_and, fuzzy_bool, fuzzy_not, fuzzy_or
+from sympy.core.relational import Eq
+from sympy.sets.sets import FiniteSet, Interval, Set, Union, ProductSet
+from sympy.sets.fancysets import Complexes, Reals, Range, Rationals
+from sympy.multipledispatch import Dispatcher
+
+
+_inf_sets = [S.Naturals, S.Naturals0, S.Integers, S.Rationals, S.Reals, S.Complexes]
+
+
+is_subset_sets = Dispatcher('is_subset_sets')
+
+
+@is_subset_sets.register(Set, Set)
+def _(a, b):
+    return None
+
+@is_subset_sets.register(Interval, Interval)
+def _(a, b):
+    # This is correct but can be made more comprehensive...
+    if fuzzy_bool(a.start < b.start):
+        return False
+    if fuzzy_bool(a.end > b.end):
+        return False
+    if (b.left_open and not a.left_open and fuzzy_bool(Eq(a.start, b.start))):
+        return False
+    if (b.right_open and not a.right_open and fuzzy_bool(Eq(a.end, b.end))):
+        return False
+
+@is_subset_sets.register(Interval, FiniteSet)
+def _(a_interval, b_fs):
+    # An Interval can only be a subset of a finite set if it is finite
+    # which can only happen if it has zero measure.
+    if fuzzy_not(a_interval.measure.is_zero):
+        return False
+
+@is_subset_sets.register(Interval, Union)
+def _(a_interval, b_u):
+    if all(isinstance(s, (Interval, FiniteSet)) for s in b_u.args):
+        intervals = [s for s in b_u.args if isinstance(s, Interval)]
+        if all(fuzzy_bool(a_interval.start < s.start) for s in intervals):
+            return False
+        if all(fuzzy_bool(a_interval.end > s.end) for s in intervals):
+            return False
+        if a_interval.measure.is_nonzero:
+            no_overlap = lambda s1, s2: fuzzy_or([
+                    fuzzy_bool(s1.end <= s2.start),
+                    fuzzy_bool(s1.start >= s2.end),
+                    ])
+            if all(no_overlap(s, a_interval) for s in intervals):
+                return False
+
+@is_subset_sets.register(Range, Range)
+def _(a, b):
+    if a.step == b.step == 1:
+        return fuzzy_and([fuzzy_bool(a.start >= b.start),
+                          fuzzy_bool(a.stop <= b.stop)])
+
+@is_subset_sets.register(Range, Interval)
+def _(a_range, b_interval):
+    if a_range.step.is_positive:
+        if b_interval.left_open and a_range.inf.is_finite:
+            cond_left = a_range.inf > b_interval.left
+        else:
+            cond_left = a_range.inf >= b_interval.left
+        if b_interval.right_open and a_range.sup.is_finite:
+            cond_right = a_range.sup < b_interval.right
+        else:
+            cond_right = a_range.sup <= b_interval.right
+        return fuzzy_and([cond_left, cond_right])
+
+@is_subset_sets.register(Range, FiniteSet)
+def _(a_range, b_finiteset):
+    try:
+        a_size = a_range.size
+    except ValueError:
+        # symbolic Range of unknown size
+        return None
+    if a_size > len(b_finiteset):
+        return False
+    elif any(arg.has(Symbol) for arg in a_range.args):
+        return fuzzy_and(b_finiteset.contains(x) for x in a_range)
+    else:
+        # Checking A \ B == EmptySet is more efficient than repeated naive
+        # membership checks on an arbitrary FiniteSet.
+        a_set = set(a_range)
+        b_remaining = len(b_finiteset)
+        # Symbolic expressions and numbers of unknown type (integer or not) are
+        # all counted as "candidates", i.e. *potentially* matching some a in
+        # a_range.
+        cnt_candidate = 0
+        for b in b_finiteset:
+            if b.is_Integer:
+                a_set.discard(b)
+            elif fuzzy_not(b.is_integer):
+                pass
+            else:
+                cnt_candidate += 1
+            b_remaining -= 1
+            if len(a_set) > b_remaining + cnt_candidate:
+                return False
+            if len(a_set) == 0:
+                return True
+        return None
+
+@is_subset_sets.register(Interval, Range)
+def _(a_interval, b_range):
+    if a_interval.measure.is_extended_nonzero:
+        return False
+
+@is_subset_sets.register(Interval, Rationals)
+def _(a_interval, b_rationals):
+    if a_interval.measure.is_extended_nonzero:
+        return False
+
+@is_subset_sets.register(Range, Complexes)
+def _(a, b):
+    return True
+
+@is_subset_sets.register(Complexes, Interval)
+def _(a, b):
+    return False
+
+@is_subset_sets.register(Complexes, Range)
+def _(a, b):
+    return False
+
+@is_subset_sets.register(Complexes, Rationals)
+def _(a, b):
+    return False
+
+@is_subset_sets.register(Rationals, Reals)
+def _(a, b):
+    return True
+
+@is_subset_sets.register(Rationals, Range)
+def _(a, b):
+    return False
+
+@is_subset_sets.register(ProductSet, FiniteSet)
+def _(a_ps, b_fs):
+    return fuzzy_and(b_fs.contains(x) for x in a_ps)
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/sets/handlers/mul.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/sets/handlers/mul.py
new file mode 100644
index 0000000000000000000000000000000000000000..0dedc8068b7973fd4cb6fbf2854e5fa671d188de
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/sets/handlers/mul.py
@@ -0,0 +1,79 @@
+from sympy.core import Basic, Expr
+from sympy.core.numbers import oo
+from sympy.core.symbol import symbols
+from sympy.multipledispatch import Dispatcher
+from sympy.sets.setexpr import set_mul
+from sympy.sets.sets import Interval, Set
+
+
+_x, _y = symbols("x y")
+
+
+_set_mul = Dispatcher('_set_mul')
+_set_div = Dispatcher('_set_div')
+
+
+@_set_mul.register(Basic, Basic)
+def _(x, y):
+    return None
+
+@_set_mul.register(Set, Set)
+def _(x, y):
+    return None
+
+@_set_mul.register(Expr, Expr)
+def _(x, y):
+    return x*y
+
+@_set_mul.register(Interval, Interval)
+def _(x, y):
+    """
+    Multiplications in interval arithmetic
+    https://en.wikipedia.org/wiki/Interval_arithmetic
+    """
+    # TODO: some intervals containing 0 and oo will fail as 0*oo returns nan.
+    comvals = (
+        (x.start * y.start, bool(x.left_open or y.left_open)),
+        (x.start * y.end, bool(x.left_open or y.right_open)),
+        (x.end * y.start, bool(x.right_open or y.left_open)),
+        (x.end * y.end, bool(x.right_open or y.right_open)),
+    )
+    # TODO: handle symbolic intervals
+    minval, minopen = min(comvals)
+    maxval, maxopen = max(comvals)
+    return Interval(
+        minval,
+        maxval,
+        minopen,
+        maxopen
+    )
+
+@_set_div.register(Basic, Basic)
+def _(x, y):
+    return None
+
+@_set_div.register(Expr, Expr)
+def _(x, y):
+    return x/y
+
+@_set_div.register(Set, Set)
+def _(x, y):
+    return None
+
+@_set_div.register(Interval, Interval)
+def _(x, y):
+    """
+    Divisions in interval arithmetic
+    https://en.wikipedia.org/wiki/Interval_arithmetic
+    """
+    if (y.start*y.end).is_negative:
+        return Interval(-oo, oo)
+    if y.start == 0:
+        s2 = oo
+    else:
+        s2 = 1/y.start
+    if y.end == 0:
+        s1 = -oo
+    else:
+        s1 = 1/y.end
+    return set_mul(x, Interval(s1, s2, y.right_open, y.left_open))
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/sets/handlers/power.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/sets/handlers/power.py
new file mode 100644
index 0000000000000000000000000000000000000000..3cad4ee49ab27770143bc121d1fbcd024bf01548
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/sets/handlers/power.py
@@ -0,0 +1,107 @@
+from sympy.core import Basic, Expr
+from sympy.core.function import Lambda
+from sympy.core.numbers import oo, Infinity, NegativeInfinity, Zero, Integer
+from sympy.core.singleton import S
+from sympy.core.symbol import symbols
+from sympy.functions.elementary.miscellaneous import (Max, Min)
+from sympy.sets.fancysets import ImageSet
+from sympy.sets.setexpr import set_div
+from sympy.sets.sets import Set, Interval, FiniteSet, Union
+from sympy.multipledispatch import Dispatcher
+
+
+_x, _y = symbols("x y")
+
+
+_set_pow = Dispatcher('_set_pow')
+
+
+@_set_pow.register(Basic, Basic)
+def _(x, y):
+    return None
+
+@_set_pow.register(Set, Set)
+def _(x, y):
+    return ImageSet(Lambda((_x, _y), (_x ** _y)), x, y)
+
+@_set_pow.register(Expr, Expr)
+def _(x, y):
+    return x**y
+
+@_set_pow.register(Interval, Zero)
+def _(x, z):
+    return FiniteSet(S.One)
+
+@_set_pow.register(Interval, Integer)
+def _(x, exponent):
+    """
+    Powers in interval arithmetic
+    https://en.wikipedia.org/wiki/Interval_arithmetic
+    """
+    s1 = x.start**exponent
+    s2 = x.end**exponent
+    if ((s2 > s1) if exponent > 0 else (x.end > -x.start)) == True:
+        left_open = x.left_open
+        right_open = x.right_open
+        # TODO: handle unevaluated condition.
+        sleft = s2
+    else:
+        # TODO: `s2 > s1` could be unevaluated.
+        left_open = x.right_open
+        right_open = x.left_open
+        sleft = s1
+
+    if x.start.is_positive:
+        return Interval(
+            Min(s1, s2),
+            Max(s1, s2), left_open, right_open)
+    elif x.end.is_negative:
+        return Interval(
+            Min(s1, s2),
+            Max(s1, s2), left_open, right_open)
+
+    # Case where x.start < 0 and x.end > 0:
+    if exponent.is_odd:
+        if exponent.is_negative:
+            if x.start.is_zero:
+                return Interval(s2, oo, x.right_open)
+            if x.end.is_zero:
+                return Interval(-oo, s1, True, x.left_open)
+            return Union(Interval(-oo, s1, True, x.left_open), Interval(s2, oo, x.right_open))
+        else:
+            return Interval(s1, s2, x.left_open, x.right_open)
+    elif exponent.is_even:
+        if exponent.is_negative:
+            if x.start.is_zero:
+                return Interval(s2, oo, x.right_open)
+            if x.end.is_zero:
+                return Interval(s1, oo, x.left_open)
+            return Interval(0, oo)
+        else:
+            return Interval(S.Zero, sleft, S.Zero not in x, left_open)
+
+@_set_pow.register(Interval, Infinity)
+def _(b, e):
+    # TODO: add logic for open intervals?
+    if b.start.is_nonnegative:
+        if b.end < 1:
+            return FiniteSet(S.Zero)
+        if b.start > 1:
+            return FiniteSet(S.Infinity)
+        return Interval(0, oo)
+    elif b.end.is_negative:
+        if b.start > -1:
+            return FiniteSet(S.Zero)
+        if b.end < -1:
+            return FiniteSet(-oo, oo)
+        return Interval(-oo, oo)
+    else:
+        if b.start > -1:
+            if b.end < 1:
+                return FiniteSet(S.Zero)
+            return Interval(0, oo)
+        return Interval(-oo, oo)
+
+@_set_pow.register(Interval, NegativeInfinity)
+def _(b, e):
+    return _set_pow(set_div(S.One, b), oo)
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/sets/handlers/union.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/sets/handlers/union.py
new file mode 100644
index 0000000000000000000000000000000000000000..75d867b49969ae2aeea76155dbaae7e05c1a6847
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/sets/handlers/union.py
@@ -0,0 +1,147 @@
+from sympy.core.singleton import S
+from sympy.core.sympify import sympify
+from sympy.functions.elementary.miscellaneous import Min, Max
+from sympy.sets.sets import (EmptySet, FiniteSet, Intersection,
+    Interval, ProductSet, Set, Union, UniversalSet)
+from sympy.sets.fancysets import (ComplexRegion, Naturals, Naturals0,
+    Integers, Rationals, Reals)
+from sympy.multipledispatch import Dispatcher
+
+
+union_sets = Dispatcher('union_sets')
+
+
+@union_sets.register(Naturals0, Naturals)
+def _(a, b):
+    return a
+
+@union_sets.register(Rationals, Naturals)
+def _(a, b):
+    return a
+
+@union_sets.register(Rationals, Naturals0)
+def _(a, b):
+    return a
+
+@union_sets.register(Reals, Naturals)
+def _(a, b):
+    return a
+
+@union_sets.register(Reals, Naturals0)
+def _(a, b):
+    return a
+
+@union_sets.register(Reals, Rationals)
+def _(a, b):
+    return a
+
+@union_sets.register(Integers, Set)
+def _(a, b):
+    intersect = Intersection(a, b)
+    if intersect == a:
+        return b
+    elif intersect == b:
+        return a
+
+@union_sets.register(ComplexRegion, Set)
+def _(a, b):
+    if b.is_subset(S.Reals):
+        # treat a subset of reals as a complex region
+        b = ComplexRegion.from_real(b)
+
+    if b.is_ComplexRegion:
+        # a in rectangular form
+        if (not a.polar) and (not b.polar):
+            return ComplexRegion(Union(a.sets, b.sets))
+        # a in polar form
+        elif a.polar and b.polar:
+            return ComplexRegion(Union(a.sets, b.sets), polar=True)
+    return None
+
+@union_sets.register(EmptySet, Set)
+def _(a, b):
+    return b
+
+
+@union_sets.register(UniversalSet, Set)
+def _(a, b):
+    return a
+
+@union_sets.register(ProductSet, ProductSet)
+def _(a, b):
+    if b.is_subset(a):
+        return a
+    if len(b.sets) != len(a.sets):
+        return None
+    if len(a.sets) == 2:
+        a1, a2 = a.sets
+        b1, b2 = b.sets
+        if a1 == b1:
+            return a1 * Union(a2, b2)
+        if a2 == b2:
+            return Union(a1, b1) * a2
+    return None
+
+@union_sets.register(ProductSet, Set)
+def _(a, b):
+    if b.is_subset(a):
+        return a
+    return None
+
+@union_sets.register(Interval, Interval)
+def _(a, b):
+    if a._is_comparable(b):
+        # Non-overlapping intervals
+        end = Min(a.end, b.end)
+        start = Max(a.start, b.start)
+        if (end < start or
+           (end == start and (end not in a and end not in b))):
+            return None
+        else:
+            start = Min(a.start, b.start)
+            end = Max(a.end, b.end)
+
+            left_open = ((a.start != start or a.left_open) and
+                         (b.start != start or b.left_open))
+            right_open = ((a.end != end or a.right_open) and
+                          (b.end != end or b.right_open))
+            return Interval(start, end, left_open, right_open)
+
+@union_sets.register(Interval, UniversalSet)
+def _(a, b):
+    return S.UniversalSet
+
+@union_sets.register(Interval, Set)
+def _(a, b):
+    # If I have open end points and these endpoints are contained in b
+    # But only in case, when endpoints are finite. Because
+    # interval does not contain oo or -oo.
+    open_left_in_b_and_finite = (a.left_open and
+                                     sympify(b.contains(a.start)) is S.true and
+                                     a.start.is_finite)
+    open_right_in_b_and_finite = (a.right_open and
+                                      sympify(b.contains(a.end)) is S.true and
+                                      a.end.is_finite)
+    if open_left_in_b_and_finite or open_right_in_b_and_finite:
+        # Fill in my end points and return
+        open_left = a.left_open and a.start not in b
+        open_right = a.right_open and a.end not in b
+        new_a = Interval(a.start, a.end, open_left, open_right)
+        return {new_a, b}
+    return None
+
+@union_sets.register(FiniteSet, FiniteSet)
+def _(a, b):
+    return FiniteSet(*(a._elements | b._elements))
+
+@union_sets.register(FiniteSet, Set)
+def _(a, b):
+    # If `b` set contains one of my elements, remove it from `a`
+    if any(b.contains(x) == True for x in a):
+        return {
+            FiniteSet(*[x for x in a if b.contains(x) != True]), b}
+    return None
+
+@union_sets.register(Set, Set)
+def _(a, b):
+    return None
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/sets/tests/__init__.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/sets/tests/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/sets/tests/__pycache__/__init__.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/sets/tests/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5d68268a4669189e487a823d31495c2045eaa088
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/sets/tests/__pycache__/__init__.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/sets/tests/__pycache__/test_conditionset.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/sets/tests/__pycache__/test_conditionset.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..2beb197c0bb9b98bf9e9f68d339c5034c9202b51
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/sets/tests/__pycache__/test_conditionset.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/sets/tests/__pycache__/test_contains.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/sets/tests/__pycache__/test_contains.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..768178b67efebd6abd06ece77451fc77a83c1840
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/sets/tests/__pycache__/test_contains.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/sets/tests/__pycache__/test_fancysets.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/sets/tests/__pycache__/test_fancysets.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..4c5fab5e34869e5201a97331d05dd0b160019342
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/sets/tests/__pycache__/test_fancysets.cpython-312.pyc
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4cb74bdbd08bcaeaed6e7961052f7de3598d22379b5106adf7b7a9ac0cf2c233
+size 124918
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/sets/tests/__pycache__/test_ordinals.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/sets/tests/__pycache__/test_ordinals.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..30f013229eea582cfa319c7aeeb6a40e386dce8a
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/sets/tests/__pycache__/test_ordinals.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/sets/tests/__pycache__/test_powerset.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/sets/tests/__pycache__/test_powerset.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..09160926fae4d55905381155b4f18cffd6be6fda
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/sets/tests/__pycache__/test_powerset.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/sets/tests/__pycache__/test_setexpr.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/sets/tests/__pycache__/test_setexpr.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f5b62354d7fe279d9263dd299211199db54874c4
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/sets/tests/__pycache__/test_setexpr.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/sets/tests/__pycache__/test_sets.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/sets/tests/__pycache__/test_sets.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..7bdd7d60ea33d6b088bfd972b49076b67057a408
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/sets/tests/__pycache__/test_sets.cpython-312.pyc
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c5f56152ab43599c83628ab1f5c89ad4f7797bdd3d5b83aafe2137acb6120600
+size 154746
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/sets/tests/test_conditionset.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/sets/tests/test_conditionset.py
new file mode 100644
index 0000000000000000000000000000000000000000..4818246f306afd46a09a2cbea1faab858a9e7806
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/sets/tests/test_conditionset.py
@@ -0,0 +1,294 @@
+from sympy.core.expr import unchanged
+from sympy.sets import (ConditionSet, Intersection, FiniteSet,
+    EmptySet, Union, Contains, ImageSet)
+from sympy.sets.sets import SetKind
+from sympy.core.function import (Function, Lambda)
+from sympy.core.mod import Mod
+from sympy.core.kind import NumberKind
+from sympy.core.numbers import (oo, pi)
+from sympy.core.relational import (Eq, Ne)
+from sympy.core.singleton import S
+from sympy.core.symbol import (Symbol, symbols)
+from sympy.functions.elementary.complexes import Abs
+from sympy.functions.elementary.trigonometric import (asin, sin)
+from sympy.logic.boolalg import And
+from sympy.matrices.dense import Matrix
+from sympy.matrices.expressions.matexpr import MatrixSymbol
+from sympy.sets.sets import Interval
+from sympy.testing.pytest import raises, warns_deprecated_sympy
+
+
+w = Symbol('w')
+x = Symbol('x')
+y = Symbol('y')
+z = Symbol('z')
+f = Function('f')
+
+
+def test_CondSet():
+    sin_sols_principal = ConditionSet(x, Eq(sin(x), 0),
+                                      Interval(0, 2*pi, False, True))
+    assert pi in sin_sols_principal
+    assert pi/2 not in sin_sols_principal
+    assert 3*pi not in sin_sols_principal
+    assert oo not in sin_sols_principal
+    assert 5 in ConditionSet(x, x**2 > 4, S.Reals)
+    assert 1 not in ConditionSet(x, x**2 > 4, S.Reals)
+    # in this case, 0 is not part of the base set so
+    # it can't be in any subset selected by the condition
+    assert 0 not in ConditionSet(x, y > 5, Interval(1, 7))
+    # since 'in' requires a true/false, the following raises
+    # an error because the given value provides no information
+    # for the condition to evaluate (since the condition does
+    # not depend on the dummy symbol): the result is `y > 5`.
+    # In this case, ConditionSet is just acting like
+    # Piecewise((Interval(1, 7), y > 5), (S.EmptySet, True)).
+    raises(TypeError, lambda: 6 in ConditionSet(x, y > 5,
+        Interval(1, 7)))
+
+    X = MatrixSymbol('X', 2, 2)
+    matrix_set = ConditionSet(X, Eq(X*Matrix([[1, 1], [1, 1]]), X))
+    Y = Matrix([[0, 0], [0, 0]])
+    assert matrix_set.contains(Y).doit() is S.true
+    Z = Matrix([[1, 2], [3, 4]])
+    assert matrix_set.contains(Z).doit() is S.false
+
+    assert isinstance(ConditionSet(x, x < 1, {x, y}).base_set,
+        FiniteSet)
+    raises(TypeError, lambda: ConditionSet(x, x + 1, {x, y}))
+    raises(TypeError, lambda: ConditionSet(x, x, 1))
+
+    I = S.Integers
+    U = S.UniversalSet
+    C = ConditionSet
+    assert C(x, False, I) is S.EmptySet
+    assert C(x, True, I) is I
+    assert C(x, x < 1, C(x, x < 2, I)
+        ) == C(x, (x < 1) & (x < 2), I)
+    assert C(y, y < 1, C(x, y < 2, I)
+        ) == C(x, (x < 1) & (y < 2), I), C(y, y < 1, C(x, y < 2, I))
+    assert C(y, y < 1, C(x, x < 2, I)
+        ) == C(y, (y < 1) & (y < 2), I)
+    assert C(y, y < 1, C(x, y < x, I)
+        ) == C(x, (x < 1) & (y < x), I)
+    assert unchanged(C, y, x < 1, C(x, y < x, I))
+    assert ConditionSet(x, x < 1).base_set is U
+    # arg checking is not done at instantiation but this
+    # will raise an error when containment is tested
+    assert ConditionSet((x,), x < 1).base_set is U
+
+    c = ConditionSet((x, y), x < y, I**2)
+    assert (1, 2) in c
+    assert (1, pi) not in c
+
+    raises(TypeError, lambda: C(x, x > 1, C((x, y), x > 1, I**2)))
+    # signature mismatch since only 3 args are accepted
+    raises(TypeError, lambda: C((x, y), x + y < 2, U, U))
+
+
+def test_CondSet_intersect():
+    input_conditionset = ConditionSet(x, x**2 > 4, Interval(1, 4, False,
+        False))
+    other_domain = Interval(0, 3, False, False)
+    output_conditionset = ConditionSet(x, x**2 > 4, Interval(
+        1, 3, False, False))
+    assert Intersection(input_conditionset, other_domain
+        ) == output_conditionset
+
+
+def test_issue_9849():
+    assert ConditionSet(x, Eq(x, x), S.Naturals
+        ) is S.Naturals
+    assert ConditionSet(x, Eq(Abs(sin(x)), -1), S.Naturals
+        ) == S.EmptySet
+
+
+def test_simplified_FiniteSet_in_CondSet():
+    assert ConditionSet(x, And(x < 1, x > -3), FiniteSet(0, 1, 2)
+        ) == FiniteSet(0)
+    assert ConditionSet(x, x < 0, FiniteSet(0, 1, 2)) == EmptySet
+    assert ConditionSet(x, And(x < -3), EmptySet) == EmptySet
+    y = Symbol('y')
+    assert (ConditionSet(x, And(x > 0), FiniteSet(-1, 0, 1, y)) ==
+        Union(FiniteSet(1), ConditionSet(x, And(x > 0), FiniteSet(y))))
+    assert (ConditionSet(x, Eq(Mod(x, 3), 1), FiniteSet(1, 4, 2, y)) ==
+        Union(FiniteSet(1, 4), ConditionSet(x, Eq(Mod(x, 3), 1),
+        FiniteSet(y))))
+
+
+def test_free_symbols():
+    assert ConditionSet(x, Eq(y, 0), FiniteSet(z)
+        ).free_symbols == {y, z}
+    assert ConditionSet(x, Eq(x, 0), FiniteSet(z)
+        ).free_symbols == {z}
+    assert ConditionSet(x, Eq(x, 0), FiniteSet(x, z)
+        ).free_symbols == {x, z}
+    assert ConditionSet(x, Eq(x, 0), ImageSet(Lambda(y, y**2),
+        S.Integers)).free_symbols == set()
+
+
+def test_bound_symbols():
+    assert ConditionSet(x, Eq(y, 0), FiniteSet(z)
+        ).bound_symbols == [x]
+    assert ConditionSet(x, Eq(x, 0), FiniteSet(x, y)
+        ).bound_symbols == [x]
+    assert ConditionSet(x, x < 10, ImageSet(Lambda(y, y**2), S.Integers)
+        ).bound_symbols == [x]
+    assert ConditionSet(x, x < 10, ConditionSet(y, y > 1, S.Integers)
+        ).bound_symbols == [x]
+
+
+def test_as_dummy():
+    _0, _1 = symbols('_0 _1')
+    assert ConditionSet(x, x < 1, Interval(y, oo)
+        ).as_dummy() == ConditionSet(_0, _0 < 1, Interval(y, oo))
+    assert ConditionSet(x, x < 1, Interval(x, oo)
+        ).as_dummy() == ConditionSet(_0, _0 < 1, Interval(x, oo))
+    assert ConditionSet(x, x < 1, ImageSet(Lambda(y, y**2), S.Integers)
+        ).as_dummy() == ConditionSet(
+            _0, _0 < 1, ImageSet(Lambda(_0, _0**2), S.Integers))
+    e = ConditionSet((x, y), x <= y, S.Reals**2)
+    assert e.bound_symbols == [x, y]
+    assert e.as_dummy() == ConditionSet((_0, _1), _0 <= _1, S.Reals**2)
+    assert e.as_dummy() == ConditionSet((y, x), y <= x, S.Reals**2
+        ).as_dummy()
+
+
+def test_subs_CondSet():
+    s = FiniteSet(z, y)
+    c = ConditionSet(x, x < 2, s)
+    assert c.subs(x, y) == c
+    assert c.subs(z, y) == ConditionSet(x, x < 2, FiniteSet(y))
+    assert c.xreplace({x: y}) == ConditionSet(y, y < 2, s)
+
+    assert ConditionSet(x, x < y, s
+        ).subs(y, w) == ConditionSet(x, x < w, s.subs(y, w))
+    # if the user uses assumptions that cause the condition
+    # to evaluate, that can't be helped from SymPy's end
+    n = Symbol('n', negative=True)
+    assert ConditionSet(n, 0 < n, S.Integers) is S.EmptySet
+    p = Symbol('p', positive=True)
+    assert ConditionSet(n, n < y, S.Integers
+        ).subs(n, x) == ConditionSet(n, n < y, S.Integers)
+    raises(ValueError, lambda: ConditionSet(
+        x + 1, x < 1, S.Integers))
+    assert ConditionSet(
+        p, n < x, Interval(-5, 5)).subs(x, p) == Interval(-5, 5), ConditionSet(
+        p, n < x, Interval(-5, 5)).subs(x, p)
+    assert ConditionSet(
+        n, n < x, Interval(-oo, 0)).subs(x, p
+        ) == Interval(-oo, 0)
+
+    assert ConditionSet(f(x), f(x) < 1, {w, z}
+        ).subs(f(x), y) == ConditionSet(f(x), f(x) < 1, {w, z})
+
+    # issue 17341
+    k = Symbol('k')
+    img1 = ImageSet(Lambda(k, 2*k*pi + asin(y)), S.Integers)
+    img2 = ImageSet(Lambda(k, 2*k*pi + asin(S.One/3)), S.Integers)
+    assert ConditionSet(x, Contains(
+        y, Interval(-1,1)), img1).subs(y, S.One/3).dummy_eq(img2)
+
+    assert (0, 1) in ConditionSet((x, y), x + y < 3, S.Integers**2)
+
+    raises(TypeError, lambda: ConditionSet(n, n < -10, Interval(0, 10)))
+
+
+def test_subs_CondSet_tebr():
+    with warns_deprecated_sympy():
+        assert ConditionSet((x, y), {x + 1, x + y}, S.Reals**2) == \
+            ConditionSet((x, y), Eq(x + 1, 0) & Eq(x + y, 0), S.Reals**2)
+
+
+def test_dummy_eq():
+    C = ConditionSet
+    I = S.Integers
+    c = C(x, x < 1, I)
+    assert c.dummy_eq(C(y, y < 1, I))
+    assert c.dummy_eq(1) == False
+    assert c.dummy_eq(C(x, x < 1, S.Reals)) == False
+
+    c1 = ConditionSet((x, y), Eq(x + 1, 0) & Eq(x + y, 0), S.Reals**2)
+    c2 = ConditionSet((x, y), Eq(x + 1, 0) & Eq(x + y, 0), S.Reals**2)
+    c3 = ConditionSet((x, y), Eq(x + 1, 0) & Eq(x + y, 0), S.Complexes**2)
+    assert c1.dummy_eq(c2)
+    assert c1.dummy_eq(c3) is False
+    assert c.dummy_eq(c1) is False
+    assert c1.dummy_eq(c) is False
+
+    # issue 19496
+    m = Symbol('m')
+    n = Symbol('n')
+    a = Symbol('a')
+    d1 = ImageSet(Lambda(m, m*pi), S.Integers)
+    d2 = ImageSet(Lambda(n, n*pi), S.Integers)
+    c1 = ConditionSet(x, Ne(a, 0), d1)
+    c2 = ConditionSet(x, Ne(a, 0), d2)
+    assert c1.dummy_eq(c2)
+
+
+def test_contains():
+    assert 6 in ConditionSet(x, x > 5, Interval(1, 7))
+    assert (8 in ConditionSet(x, y > 5, Interval(1, 7))) is False
+    # `in` should give True or False; in this case there is not
+    # enough information for that result
+    raises(TypeError,
+        lambda: 6 in ConditionSet(x, y > 5, Interval(1, 7)))
+    # here, there is enough information but the comparison is
+    # not defined
+    raises(TypeError, lambda: 0 in ConditionSet(x, 1/x >= 0, S.Reals))
+    assert ConditionSet(x, y > 5, Interval(1, 7)
+        ).contains(6) == (y > 5)
+    assert ConditionSet(x, y > 5, Interval(1, 7)
+        ).contains(8) is S.false
+    assert ConditionSet(x, y > 5, Interval(1, 7)
+        ).contains(w) == And(Contains(w, Interval(1, 7)), y > 5)
+    # This returns an unevaluated Contains object
+    # because 1/0 should not be defined for 1 and 0 in the context of
+    # reals.
+    assert ConditionSet(x, 1/x >= 0, S.Reals).contains(0) == \
+        Contains(0, ConditionSet(x, 1/x >= 0, S.Reals), evaluate=False)
+    c = ConditionSet((x, y), x + y > 1, S.Integers**2)
+    assert not c.contains(1)
+    assert c.contains((2, 1))
+    assert not c.contains((0, 1))
+    c = ConditionSet((w, (x, y)), w + x + y > 1, S.Integers*S.Integers**2)
+    assert not c.contains(1)
+    assert not c.contains((1, 2))
+    assert not c.contains(((1, 2), 3))
+    assert not c.contains(((1, 2), (3, 4)))
+    assert c.contains((1, (3, 4)))
+
+
+def test_as_relational():
+    assert ConditionSet((x, y), x > 1, S.Integers**2).as_relational((x, y)
+        ) == (x > 1) & Contains(x, S.Integers) & Contains(y, S.Integers)
+    assert ConditionSet(x, x > 1, S.Integers).as_relational(x
+        ) == Contains(x, S.Integers) & (x > 1)
+
+
+def test_flatten():
+    """Tests whether there is basic denesting functionality"""
+    inner = ConditionSet(x, sin(x) + x > 0)
+    outer = ConditionSet(x, Contains(x, inner), S.Reals)
+    assert outer == ConditionSet(x, sin(x) + x > 0, S.Reals)
+
+    inner = ConditionSet(y, sin(y) + y > 0)
+    outer = ConditionSet(x, Contains(y, inner), S.Reals)
+    assert outer != ConditionSet(x, sin(x) + x > 0, S.Reals)
+
+    inner = ConditionSet(x, sin(x) + x > 0).intersect(Interval(-1, 1))
+    outer = ConditionSet(x, Contains(x, inner), S.Reals)
+    assert outer == ConditionSet(x, sin(x) + x > 0, Interval(-1, 1))
+
+
+def test_duplicate():
+    from sympy.core.function import BadSignatureError
+    # test coverage for line 95 in conditionset.py, check for duplicates in symbols
+    dup = symbols('a,a')
+    raises(BadSignatureError, lambda: ConditionSet(dup, x < 0))
+
+
+def test_SetKind_ConditionSet():
+    assert ConditionSet(x, Eq(sin(x), 0), Interval(0, 2*pi)).kind is SetKind(NumberKind)
+    assert ConditionSet(x, x < 0).kind is SetKind(NumberKind)
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/sets/tests/test_contains.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/sets/tests/test_contains.py
new file mode 100644
index 0000000000000000000000000000000000000000..bb6b98940946f98bf377aad6810f5b32eb6dd069
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/sets/tests/test_contains.py
@@ -0,0 +1,52 @@
+from sympy.core.expr import unchanged
+from sympy.core.numbers import oo
+from sympy.core.relational import Eq
+from sympy.core.singleton import S
+from sympy.core.symbol import Symbol
+from sympy.sets.contains import Contains
+from sympy.sets.sets import (FiniteSet, Interval)
+from sympy.testing.pytest import raises
+
+
+def test_contains_basic():
+    raises(TypeError, lambda: Contains(S.Integers, 1))
+    assert Contains(2, S.Integers) is S.true
+    assert Contains(-2, S.Naturals) is S.false
+
+    i = Symbol('i', integer=True)
+    assert Contains(i, S.Naturals) == Contains(i, S.Naturals, evaluate=False)
+
+
+def test_issue_6194():
+    x = Symbol('x')
+    assert unchanged(Contains, x, Interval(0, 1))
+    assert Interval(0, 1).contains(x) == (S.Zero <= x) & (x <= 1)
+    assert Contains(x, FiniteSet(0)) != S.false
+    assert Contains(x, Interval(1, 1)) != S.false
+    assert Contains(x, S.Integers) != S.false
+
+
+def test_issue_10326():
+    assert Contains(oo, Interval(-oo, oo)) == False
+    assert Contains(-oo, Interval(-oo, oo)) == False
+
+
+def test_binary_symbols():
+    x = Symbol('x')
+    y = Symbol('y')
+    z = Symbol('z')
+    assert Contains(x, FiniteSet(y, Eq(z, True))
+        ).binary_symbols == {y, z}
+
+
+def test_as_set():
+    x = Symbol('x')
+    y = Symbol('y')
+    assert Contains(x, FiniteSet(y)).as_set() == FiniteSet(y)
+    assert Contains(x, S.Integers).as_set() == S.Integers
+    assert Contains(x, S.Reals).as_set() == S.Reals
+
+
+def test_type_error():
+    # Pass in a parameter not of type "set"
+    raises(TypeError, lambda: Contains(2, None))
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/sets/tests/test_fancysets.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/sets/tests/test_fancysets.py
new file mode 100644
index 0000000000000000000000000000000000000000..b23c2a99fce0af5bfe7c667185465ee417de19ce
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/sets/tests/test_fancysets.py
@@ -0,0 +1,1313 @@
+
+from sympy.core.expr import unchanged
+from sympy.sets.contains import Contains
+from sympy.sets.fancysets import (ImageSet, Range, normalize_theta_set,
+                                  ComplexRegion)
+from sympy.sets.sets import (FiniteSet, Interval, Union, imageset,
+                             Intersection, ProductSet, SetKind)
+from sympy.sets.conditionset import ConditionSet
+from sympy.simplify.simplify import simplify
+from sympy.core.basic import Basic
+from sympy.core.containers import Tuple, TupleKind
+from sympy.core.function import Lambda
+from sympy.core.kind import NumberKind
+from sympy.core.numbers import (I, Rational, oo, pi)
+from sympy.core.relational import Eq
+from sympy.core.singleton import S
+from sympy.core.symbol import (Dummy, Symbol, symbols)
+from sympy.functions.elementary.complexes import Abs
+from sympy.functions.elementary.exponential import (exp, log)
+from sympy.functions.elementary.integers import floor
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import (cos, sin, tan)
+from sympy.logic.boolalg import And
+from sympy.matrices.dense import eye
+from sympy.testing.pytest import XFAIL, raises
+from sympy.abc import x, y, t, z
+from sympy.core.mod import Mod
+
+import itertools
+
+
+def test_naturals():
+    N = S.Naturals
+    assert 5 in N
+    assert -5 not in N
+    assert 5.5 not in N
+    ni = iter(N)
+    a, b, c, d = next(ni), next(ni), next(ni), next(ni)
+    assert (a, b, c, d) == (1, 2, 3, 4)
+    assert isinstance(a, Basic)
+
+    assert N.intersect(Interval(-5, 5)) == Range(1, 6)
+    assert N.intersect(Interval(-5, 5, True, True)) == Range(1, 5)
+
+    assert N.boundary == N
+    assert N.is_open == False
+    assert N.is_closed == True
+
+    assert N.inf == 1
+    assert N.sup is oo
+    assert not N.contains(oo)
+    for s in (S.Naturals0, S.Naturals):
+        assert s.intersection(S.Reals) is s
+        assert s.is_subset(S.Reals)
+
+    assert N.as_relational(x) == And(Eq(floor(x), x), x >= 1, x < oo)
+
+
+def test_naturals0():
+    N = S.Naturals0
+    assert 0 in N
+    assert -1 not in N
+    assert next(iter(N)) == 0
+    assert not N.contains(oo)
+    assert N.contains(sin(x)) == Contains(sin(x), N)
+
+
+def test_integers():
+    Z = S.Integers
+    assert 5 in Z
+    assert -5 in Z
+    assert 5.5 not in Z
+    assert not Z.contains(oo)
+    assert not Z.contains(-oo)
+
+    zi = iter(Z)
+    a, b, c, d = next(zi), next(zi), next(zi), next(zi)
+    assert (a, b, c, d) == (0, 1, -1, 2)
+    assert isinstance(a, Basic)
+
+    assert Z.intersect(Interval(-5, 5)) == Range(-5, 6)
+    assert Z.intersect(Interval(-5, 5, True, True)) == Range(-4, 5)
+    assert Z.intersect(Interval(5, S.Infinity)) == Range(5, S.Infinity)
+    assert Z.intersect(Interval.Lopen(5, S.Infinity)) == Range(6, S.Infinity)
+
+    assert Z.inf is -oo
+    assert Z.sup is oo
+
+    assert Z.boundary == Z
+    assert Z.is_open == False
+    assert Z.is_closed == True
+
+    assert Z.as_relational(x) == And(Eq(floor(x), x), -oo < x, x < oo)
+
+
+def test_ImageSet():
+    raises(ValueError, lambda: ImageSet(x, S.Integers))
+    assert ImageSet(Lambda(x, 1), S.Integers) == FiniteSet(1)
+    assert ImageSet(Lambda(x, y), S.Integers) == {y}
+    assert ImageSet(Lambda(x, 1), S.EmptySet) == S.EmptySet
+    empty = Intersection(FiniteSet(log(2)/pi), S.Integers)
+    assert unchanged(ImageSet, Lambda(x, 1), empty)  # issue #17471
+    squares = ImageSet(Lambda(x, x**2), S.Naturals)
+    assert 4 in squares
+    assert 5 not in squares
+    assert FiniteSet(*range(10)).intersect(squares) == FiniteSet(1, 4, 9)
+
+    assert 16 not in squares.intersect(Interval(0, 10))
+
+    si = iter(squares)
+    a, b, c, d = next(si), next(si), next(si), next(si)
+    assert (a, b, c, d) == (1, 4, 9, 16)
+
+    harmonics = ImageSet(Lambda(x, 1/x), S.Naturals)
+    assert Rational(1, 5) in harmonics
+    assert Rational(.25) in harmonics
+    assert harmonics.contains(.25) == Contains(
+        0.25, ImageSet(Lambda(x, 1/x), S.Naturals), evaluate=False)
+    assert Rational(.3) not in harmonics
+    assert (1, 2) not in harmonics
+
+    assert harmonics.is_iterable
+
+    assert imageset(x, -x, Interval(0, 1)) == Interval(-1, 0)
+
+    assert ImageSet(Lambda(x, x**2), Interval(0, 2)).doit() == Interval(0, 4)
+    assert ImageSet(Lambda((x, y), 2*x), {4}, {3}).doit() == FiniteSet(8)
+    assert (ImageSet(Lambda((x, y), x+y), {1, 2, 3}, {10, 20, 30}).doit() ==
+                FiniteSet(11, 12, 13, 21, 22, 23, 31, 32, 33))
+
+    c = Interval(1, 3) * Interval(1, 3)
+    assert Tuple(2, 6) in ImageSet(Lambda(((x, y),), (x, 2*y)), c)
+    assert Tuple(2, S.Half) in ImageSet(Lambda(((x, y),), (x, 1/y)), c)
+    assert Tuple(2, -2) not in ImageSet(Lambda(((x, y),), (x, y**2)), c)
+    assert Tuple(2, -2) in ImageSet(Lambda(((x, y),), (x, -2)), c)
+    c3 = ProductSet(Interval(3, 7), Interval(8, 11), Interval(5, 9))
+    assert Tuple(8, 3, 9) in ImageSet(Lambda(((t, y, x),), (y, t, x)), c3)
+    assert Tuple(Rational(1, 8), 3, 9) in ImageSet(Lambda(((t, y, x),), (1/y, t, x)), c3)
+    assert 2/pi not in ImageSet(Lambda(((x, y),), 2/x), c)
+    assert 2/S(100) not in ImageSet(Lambda(((x, y),), 2/x), c)
+    assert Rational(2, 3) in ImageSet(Lambda(((x, y),), 2/x), c)
+
+    S1 = imageset(lambda x, y: x + y, S.Integers, S.Naturals)
+    assert S1.base_pset == ProductSet(S.Integers, S.Naturals)
+    assert S1.base_sets == (S.Integers, S.Naturals)
+
+    # Passing a set instead of a FiniteSet shouldn't raise
+    assert unchanged(ImageSet, Lambda(x, x**2), {1, 2, 3})
+
+    S2 = ImageSet(Lambda(((x, y),), x+y), {(1, 2), (3, 4)})
+    assert 3 in S2.doit()
+    # FIXME: This doesn't yet work:
+    #assert 3 in S2
+    assert S2._contains(3) is None
+
+    raises(TypeError, lambda: ImageSet(Lambda(x, x**2), 1))
+
+
+def test_image_is_ImageSet():
+    assert isinstance(imageset(x, sqrt(sin(x)), Range(5)), ImageSet)
+
+
+def test_halfcircle():
+    r, th = symbols('r, theta', real=True)
+    L = Lambda(((r, th),), (r*cos(th), r*sin(th)))
+    halfcircle = ImageSet(L, Interval(0, 1)*Interval(0, pi))
+
+    assert (1, 0) in halfcircle
+    assert (0, -1) not in halfcircle
+    assert (0, 0) in halfcircle
+    assert halfcircle._contains((r, 0)) is None
+    assert not halfcircle.is_iterable
+
+
+@XFAIL
+def test_halfcircle_fail():
+    r, th = symbols('r, theta', real=True)
+    L = Lambda(((r, th),), (r*cos(th), r*sin(th)))
+    halfcircle = ImageSet(L, Interval(0, 1)*Interval(0, pi))
+    assert (r, 2*pi) not in halfcircle
+
+
+def test_ImageSet_iterator_not_injective():
+    L = Lambda(x, x - x % 2)  # produces 0, 2, 2, 4, 4, 6, 6, ...
+    evens = ImageSet(L, S.Naturals)
+    i = iter(evens)
+    # No repeats here
+    assert (next(i), next(i), next(i), next(i)) == (0, 2, 4, 6)
+
+
+def test_inf_Range_len():
+    raises(ValueError, lambda: len(Range(0, oo, 2)))
+    assert Range(0, oo, 2).size is S.Infinity
+    assert Range(0, -oo, -2).size is S.Infinity
+    assert Range(oo, 0, -2).size is S.Infinity
+    assert Range(-oo, 0, 2).size is S.Infinity
+
+
+def test_Range_set():
+    empty = Range(0)
+
+    assert Range(5) == Range(0, 5) == Range(0, 5, 1)
+
+    r = Range(10, 20, 2)
+    assert 12 in r
+    assert 8 not in r
+    assert 11 not in r
+    assert 30 not in r
+
+    assert list(Range(0, 5)) == list(range(5))
+    assert list(Range(5, 0, -1)) == list(range(5, 0, -1))
+
+
+    assert Range(5, 15).sup == 14
+    assert Range(5, 15).inf == 5
+    assert Range(15, 5, -1).sup == 15
+    assert Range(15, 5, -1).inf == 6
+    assert Range(10, 67, 10).sup == 60
+    assert Range(60, 7, -10).inf == 10
+
+    assert len(Range(10, 38, 10)) == 3
+
+    assert Range(0, 0, 5) == empty
+    assert Range(oo, oo, 1) == empty
+    assert Range(oo, 1, 1) == empty
+    assert Range(-oo, 1, -1) == empty
+    assert Range(1, oo, -1) == empty
+    assert Range(1, -oo, 1) == empty
+    assert Range(1, -4, oo) == empty
+    ip = symbols('ip', positive=True)
+    assert Range(0, ip, -1) == empty
+    assert Range(0, -ip, 1) == empty
+    assert Range(1, -4, -oo) == Range(1, 2)
+    assert Range(1, 4, oo) == Range(1, 2)
+    assert Range(-oo, oo).size == oo
+    assert Range(oo, -oo, -1).size == oo
+    raises(ValueError, lambda: Range(-oo, oo, 2))
+    raises(ValueError, lambda: Range(x, pi, y))
+    raises(ValueError, lambda: Range(x, y, 0))
+
+    assert 5 in Range(0, oo, 5)
+    assert -5 in Range(-oo, 0, 5)
+    assert oo not in Range(0, oo)
+    ni = symbols('ni', integer=False)
+    assert ni not in Range(oo)
+    u = symbols('u', integer=None)
+    assert Range(oo).contains(u) is not False
+    inf = symbols('inf', infinite=True)
+    assert inf not in Range(-oo, oo)
+    raises(ValueError, lambda: Range(0, oo, 2)[-1])
+    raises(ValueError, lambda: Range(0, -oo, -2)[-1])
+    assert Range(-oo, 1, 1)[-1] is S.Zero
+    assert Range(oo, 1, -1)[-1] == 2
+    assert inf not in Range(oo)
+    assert Range(1, 10, 1)[-1] == 9
+    assert all(i.is_Integer for i in Range(0, -1, 1))
+    it = iter(Range(-oo, 0, 2))
+    raises(TypeError, lambda: next(it))
+
+    assert empty.intersect(S.Integers) == empty
+    assert Range(-1, 10, 1).intersect(S.Complexes) == Range(-1, 10, 1)
+    assert Range(-1, 10, 1).intersect(S.Reals) == Range(-1, 10, 1)
+    assert Range(-1, 10, 1).intersect(S.Rationals) == Range(-1, 10, 1)
+    assert Range(-1, 10, 1).intersect(S.Integers) == Range(-1, 10, 1)
+    assert Range(-1, 10, 1).intersect(S.Naturals) == Range(1, 10, 1)
+    assert Range(-1, 10, 1).intersect(S.Naturals0) == Range(0, 10, 1)
+
+    # test slicing
+    assert Range(1, 10, 1)[5] == 6
+    assert Range(1, 12, 2)[5] == 11
+    assert Range(1, 10, 1)[-1] == 9
+    assert Range(1, 10, 3)[-1] == 7
+    raises(ValueError, lambda: Range(oo,0,-1)[1:3:0])
+    raises(ValueError, lambda: Range(oo,0,-1)[:1])
+    raises(ValueError, lambda: Range(1, oo)[-2])
+    raises(ValueError, lambda: Range(-oo, 1)[2])
+    raises(IndexError, lambda: Range(10)[-20])
+    raises(IndexError, lambda: Range(10)[20])
+    raises(ValueError, lambda: Range(2, -oo, -2)[2:2:0])
+    assert Range(2, -oo, -2)[2:2:2] == empty
+    assert Range(2, -oo, -2)[:2:2] == Range(2, -2, -4)
+    raises(ValueError, lambda: Range(-oo, 4, 2)[:2:2])
+    assert Range(-oo, 4, 2)[::-2] == Range(2, -oo, -4)
+    raises(ValueError, lambda: Range(-oo, 4, 2)[::2])
+    assert Range(oo, 2, -2)[::] == Range(oo, 2, -2)
+    assert Range(-oo, 4, 2)[:-2:-2] == Range(2, 0, -4)
+    assert Range(-oo, 4, 2)[:-2:2] == Range(-oo, 0, 4)
+    raises(ValueError, lambda: Range(-oo, 4, 2)[:0:-2])
+    raises(ValueError, lambda: Range(-oo, 4, 2)[:2:-2])
+    assert Range(-oo, 4, 2)[-2::-2] == Range(0, -oo, -4)
+    raises(ValueError, lambda: Range(-oo, 4, 2)[-2:0:-2])
+    raises(ValueError, lambda: Range(-oo, 4, 2)[0::2])
+    assert Range(oo, 2, -2)[0::] == Range(oo, 2, -2)
+    raises(ValueError, lambda: Range(-oo, 4, 2)[0:-2:2])
+    assert Range(oo, 2, -2)[0:-2:] == Range(oo, 6, -2)
+    raises(ValueError, lambda: Range(oo, 2, -2)[0:2:])
+    raises(ValueError, lambda: Range(-oo, 4, 2)[2::-1])
+    assert Range(-oo, 4, 2)[-2::2] == Range(0, 4, 4)
+    assert Range(oo, 0, -2)[-10:0:2] == empty
+    raises(ValueError, lambda: Range(oo, 0, -2)[0])
+    raises(ValueError, lambda: Range(oo, 0, -2)[-10:10:2])
+    raises(ValueError, lambda: Range(oo, 0, -2)[0::-2])
+    assert Range(oo, 0, -2)[0:-4:-2] == empty
+    assert Range(oo, 0, -2)[:0:2] == empty
+    raises(ValueError, lambda: Range(oo, 0, -2)[:1:-1])
+
+    # test empty Range
+    assert Range(x, x, y) == empty
+    assert empty.reversed == empty
+    assert 0 not in empty
+    assert list(empty) == []
+    assert len(empty) == 0
+    assert empty.size is S.Zero
+    assert empty.intersect(FiniteSet(0)) is S.EmptySet
+    assert bool(empty) is False
+    raises(IndexError, lambda: empty[0])
+    assert empty[:0] == empty
+    raises(NotImplementedError, lambda: empty.inf)
+    raises(NotImplementedError, lambda: empty.sup)
+    assert empty.as_relational(x) is S.false
+
+    AB = [None] + list(range(12))
+    for R in [
+            Range(1, 10),
+            Range(1, 10, 2),
+        ]:
+        r = list(R)
+        for a, b, c in itertools.product(AB, AB, [-3, -1, None, 1, 3]):
+            for reverse in range(2):
+                r = list(reversed(r))
+                R = R.reversed
+                result = list(R[a:b:c])
+                ans = r[a:b:c]
+                txt = ('\n%s[%s:%s:%s] = %s -> %s' % (
+                R, a, b, c, result, ans))
+                check = ans == result
+                assert check, txt
+
+    assert Range(1, 10, 1).boundary == Range(1, 10, 1)
+
+    for r in (Range(1, 10, 2), Range(1, oo, 2)):
+        rev = r.reversed
+        assert r.inf == rev.inf and r.sup == rev.sup
+        assert r.step == -rev.step
+
+    builtin_range = range
+
+    raises(TypeError, lambda: Range(builtin_range(1)))
+    assert S(builtin_range(10)) == Range(10)
+    assert S(builtin_range(1000000000000)) == Range(1000000000000)
+
+    # test Range.as_relational
+    assert Range(1, 4).as_relational(x) == (x >= 1) & (x <= 3)  & Eq(Mod(x, 1), 0)
+    assert Range(oo, 1, -2).as_relational(x) == (x >= 3) & (x < oo)  & Eq(Mod(x + 1, -2), 0)
+
+
+def test_Range_symbolic():
+    # symbolic Range
+    xr = Range(x, x + 4, 5)
+    sr = Range(x, y, t)
+    i = Symbol('i', integer=True)
+    ip = Symbol('i', integer=True, positive=True)
+    ipr = Range(ip)
+    inr = Range(0, -ip, -1)
+    ir = Range(i, i + 19, 2)
+    ir2 = Range(i, i*8, 3*i)
+    i = Symbol('i', integer=True)
+    inf = symbols('inf', infinite=True)
+    raises(ValueError, lambda: Range(inf))
+    raises(ValueError, lambda: Range(inf, 0, -1))
+    raises(ValueError, lambda: Range(inf, inf, 1))
+    raises(ValueError, lambda: Range(1, 1, inf))
+    # args
+    assert xr.args == (x, x + 5, 5)
+    assert sr.args == (x, y, t)
+    assert ir.args == (i, i + 20, 2)
+    assert ir2.args == (i, 10*i, 3*i)
+    # reversed
+    raises(ValueError, lambda: xr.reversed)
+    raises(ValueError, lambda: sr.reversed)
+    assert ipr.reversed.args == (ip - 1, -1, -1)
+    assert inr.reversed.args == (-ip + 1, 1, 1)
+    assert ir.reversed.args == (i + 18, i - 2, -2)
+    assert ir2.reversed.args == (7*i, -2*i, -3*i)
+    # contains
+    assert inf not in sr
+    assert inf not in ir
+    assert 0 in ipr
+    assert 0 in inr
+    raises(TypeError, lambda: 1 in ipr)
+    raises(TypeError, lambda: -1 in inr)
+    assert .1 not in sr
+    assert .1 not in ir
+    assert i + 1 not in ir
+    assert i + 2 in ir
+    raises(TypeError, lambda: x in xr)  # XXX is this what contains is supposed to do?
+    raises(TypeError, lambda: 1 in sr)  # XXX is this what contains is supposed to do?
+    # iter
+    raises(ValueError, lambda: next(iter(xr)))
+    raises(ValueError, lambda: next(iter(sr)))
+    assert next(iter(ir)) == i
+    assert next(iter(ir2)) == i
+    assert sr.intersect(S.Integers) == sr
+    assert sr.intersect(FiniteSet(x)) == Intersection({x}, sr)
+    raises(ValueError, lambda: sr[:2])
+    raises(ValueError, lambda: xr[0])
+    raises(ValueError, lambda: sr[0])
+    # len
+    assert len(ir) == ir.size == 10
+    assert len(ir2) == ir2.size == 3
+    raises(ValueError, lambda: len(xr))
+    raises(ValueError, lambda: xr.size)
+    raises(ValueError, lambda: len(sr))
+    raises(ValueError, lambda: sr.size)
+    # bool
+    assert bool(Range(0)) == False
+    assert bool(xr)
+    assert bool(ir)
+    assert bool(ipr)
+    assert bool(inr)
+    raises(ValueError, lambda: bool(sr))
+    raises(ValueError, lambda: bool(ir2))
+    # inf
+    raises(ValueError, lambda: xr.inf)
+    raises(ValueError, lambda: sr.inf)
+    assert ipr.inf == 0
+    assert inr.inf == -ip + 1
+    assert ir.inf == i
+    raises(ValueError, lambda: ir2.inf)
+    # sup
+    raises(ValueError, lambda: xr.sup)
+    raises(ValueError, lambda: sr.sup)
+    assert ipr.sup == ip - 1
+    assert inr.sup == 0
+    assert ir.inf == i
+    raises(ValueError, lambda: ir2.sup)
+    # getitem
+    raises(ValueError, lambda: xr[0])
+    raises(ValueError, lambda: sr[0])
+    raises(ValueError, lambda: sr[-1])
+    raises(ValueError, lambda: sr[:2])
+    assert ir[:2] == Range(i, i + 4, 2)
+    assert ir[0] == i
+    assert ir[-2] == i + 16
+    assert ir[-1] == i + 18
+    assert ir2[:2] == Range(i, 7*i, 3*i)
+    assert ir2[0] == i
+    assert ir2[-2] == 4*i
+    assert ir2[-1] == 7*i
+    raises(ValueError, lambda: Range(i)[-1])
+    assert ipr[0] == ipr.inf == 0
+    assert ipr[-1] == ipr.sup == ip - 1
+    assert inr[0] == inr.sup == 0
+    assert inr[-1] == inr.inf == -ip + 1
+    raises(ValueError, lambda: ipr[-2])
+    assert ir.inf == i
+    assert ir.sup == i + 18
+    raises(ValueError, lambda: Range(i).inf)
+    # as_relational
+    assert ir.as_relational(x) == ((x >= i) & (x <= i + 18) &
+        Eq(Mod(-i + x, 2), 0))
+    assert ir2.as_relational(x) == Eq(
+        Mod(-i + x, 3*i), 0) & (((x >= i) & (x <= 7*i) & (3*i >= 1)) |
+        ((x <= i) & (x >= 7*i) & (3*i <= -1)))
+    assert Range(i, i + 1).as_relational(x) == Eq(x, i)
+    assert sr.as_relational(z) == Eq(
+        Mod(t, 1), 0) & Eq(Mod(x, 1), 0) & Eq(Mod(-x + z, t), 0
+        ) & (((z >= x) & (z <= -t + y) & (t >= 1)) |
+        ((z <= x) & (z >= -t + y) & (t <= -1)))
+    assert xr.as_relational(z) == Eq(z, x) & Eq(Mod(x, 1), 0)
+    # symbols can clash if user wants (but it must be integer)
+    assert xr.as_relational(x) == Eq(Mod(x, 1), 0)
+    # contains() for symbolic values (issue #18146)
+    e = Symbol('e', integer=True, even=True)
+    o = Symbol('o', integer=True, odd=True)
+    assert Range(5).contains(i) == And(i >= 0, i <= 4)
+    assert Range(1).contains(i) == Eq(i, 0)
+    assert Range(-oo, 5, 1).contains(i) == (i <= 4)
+    assert Range(-oo, oo).contains(i) == True
+    assert Range(0, 8, 2).contains(i) == Contains(i, Range(0, 8, 2))
+    assert Range(0, 8, 2).contains(e) == And(e >= 0, e <= 6)
+    assert Range(0, 8, 2).contains(2*i) == And(2*i >= 0, 2*i <= 6)
+    assert Range(0, 8, 2).contains(o) == False
+    assert Range(1, 9, 2).contains(e) == False
+    assert Range(1, 9, 2).contains(o) == And(o >= 1, o <= 7)
+    assert Range(8, 0, -2).contains(o) == False
+    assert Range(9, 1, -2).contains(o) == And(o >= 3, o <= 9)
+    assert Range(-oo, 8, 2).contains(i) == Contains(i, Range(-oo, 8, 2))
+
+
+def test_range_range_intersection():
+    for a, b, r in [
+            (Range(0), Range(1), S.EmptySet),
+            (Range(3), Range(4, oo), S.EmptySet),
+            (Range(3), Range(-3, -1), S.EmptySet),
+            (Range(1, 3), Range(0, 3), Range(1, 3)),
+            (Range(1, 3), Range(1, 4), Range(1, 3)),
+            (Range(1, oo, 2), Range(2, oo, 2), S.EmptySet),
+            (Range(0, oo, 2), Range(oo), Range(0, oo, 2)),
+            (Range(0, oo, 2), Range(100), Range(0, 100, 2)),
+            (Range(2, oo, 2), Range(oo), Range(2, oo, 2)),
+            (Range(0, oo, 2), Range(5, 6), S.EmptySet),
+            (Range(2, 80, 1), Range(55, 71, 4), Range(55, 71, 4)),
+            (Range(0, 6, 3), Range(-oo, 5, 3), S.EmptySet),
+            (Range(0, oo, 2), Range(5, oo, 3), Range(8, oo, 6)),
+            (Range(4, 6, 2), Range(2, 16, 7), S.EmptySet),]:
+        assert a.intersect(b) == r
+        assert a.intersect(b.reversed) == r
+        assert a.reversed.intersect(b) == r
+        assert a.reversed.intersect(b.reversed) == r
+        a, b = b, a
+        assert a.intersect(b) == r
+        assert a.intersect(b.reversed) == r
+        assert a.reversed.intersect(b) == r
+        assert a.reversed.intersect(b.reversed) == r
+
+
+def test_range_interval_intersection():
+    p = symbols('p', positive=True)
+    assert isinstance(Range(3).intersect(Interval(p, p + 2)), Intersection)
+    assert Range(4).intersect(Interval(0, 3)) == Range(4)
+    assert Range(4).intersect(Interval(-oo, oo)) == Range(4)
+    assert Range(4).intersect(Interval(1, oo)) == Range(1, 4)
+    assert Range(4).intersect(Interval(1.1, oo)) == Range(2, 4)
+    assert Range(4).intersect(Interval(0.1, 3)) == Range(1, 4)
+    assert Range(4).intersect(Interval(0.1, 3.1)) == Range(1, 4)
+    assert Range(4).intersect(Interval.open(0, 3)) == Range(1, 3)
+    assert Range(4).intersect(Interval.open(0.1, 0.5)) is S.EmptySet
+    assert Interval(-1, 5).intersect(S.Complexes) == Interval(-1, 5)
+    assert Interval(-1, 5).intersect(S.Reals) == Interval(-1, 5)
+    assert Interval(-1, 5).intersect(S.Integers) == Range(-1, 6)
+    assert Interval(-1, 5).intersect(S.Naturals) == Range(1, 6)
+    assert Interval(-1, 5).intersect(S.Naturals0) == Range(0, 6)
+
+    # Null Range intersections
+    assert Range(0).intersect(Interval(0.2, 0.8)) is S.EmptySet
+    assert Range(0).intersect(Interval(-oo, oo)) is S.EmptySet
+
+
+def test_range_is_finite_set():
+    assert Range(-100, 100).is_finite_set is True
+    assert Range(2, oo).is_finite_set is False
+    assert Range(-oo, 50).is_finite_set is False
+    assert Range(-oo, oo).is_finite_set is False
+    assert Range(oo, -oo).is_finite_set is True
+    assert Range(0, 0).is_finite_set is True
+    assert Range(oo, oo).is_finite_set is True
+    assert Range(-oo, -oo).is_finite_set is True
+    n = Symbol('n', integer=True)
+    m = Symbol('m', integer=True)
+    assert Range(n, n + 49).is_finite_set is True
+    assert Range(n, 0).is_finite_set is True
+    assert Range(-3, n + 7).is_finite_set is True
+    assert Range(n, m).is_finite_set is True
+    assert Range(n + m, m - n).is_finite_set is True
+    assert Range(n, n + m + n).is_finite_set is True
+    assert Range(n, oo).is_finite_set is False
+    assert Range(-oo, n).is_finite_set is False
+    assert Range(n, -oo).is_finite_set is True
+    assert Range(oo, n).is_finite_set is True
+
+
+def test_Range_is_iterable():
+    assert Range(-100, 100).is_iterable is True
+    assert Range(2, oo).is_iterable is False
+    assert Range(-oo, 50).is_iterable is False
+    assert Range(-oo, oo).is_iterable is False
+    assert Range(oo, -oo).is_iterable is True
+    assert Range(0, 0).is_iterable is True
+    assert Range(oo, oo).is_iterable is True
+    assert Range(-oo, -oo).is_iterable is True
+    n = Symbol('n', integer=True)
+    m = Symbol('m', integer=True)
+    p = Symbol('p', integer=True, positive=True)
+    assert Range(n, n + 49).is_iterable is True
+    assert Range(n, 0).is_iterable is False
+    assert Range(-3, n + 7).is_iterable is False
+    assert Range(-3, p + 7).is_iterable is False # Should work with better __iter__
+    assert Range(n, m).is_iterable is False
+    assert Range(n + m, m - n).is_iterable is False
+    assert Range(n, n + m + n).is_iterable is False
+    assert Range(n, oo).is_iterable is False
+    assert Range(-oo, n).is_iterable is False
+    x = Symbol('x')
+    assert Range(x, x + 49).is_iterable is False
+    assert Range(x, 0).is_iterable is False
+    assert Range(-3, x + 7).is_iterable is False
+    assert Range(x, m).is_iterable is False
+    assert Range(x + m, m - x).is_iterable is False
+    assert Range(x, x + m + x).is_iterable is False
+    assert Range(x, oo).is_iterable is False
+    assert Range(-oo, x).is_iterable is False
+
+
+def test_Integers_eval_imageset():
+    ans = ImageSet(Lambda(x, 2*x + Rational(3, 7)), S.Integers)
+    im = imageset(Lambda(x, -2*x + Rational(3, 7)), S.Integers)
+    assert im == ans
+    im = imageset(Lambda(x, -2*x - Rational(11, 7)), S.Integers)
+    assert im == ans
+    y = Symbol('y')
+    L = imageset(x, 2*x + y, S.Integers)
+    assert y + 4 in L
+    a, b, c = 0.092, 0.433, 0.341
+    assert a in imageset(x, a + c*x, S.Integers)
+    assert b in imageset(x, b + c*x, S.Integers)
+
+    _x = symbols('x', negative=True)
+    eq = _x**2 - _x + 1
+    assert imageset(_x, eq, S.Integers).lamda.expr == _x**2 + _x + 1
+    eq = 3*_x - 1
+    assert imageset(_x, eq, S.Integers).lamda.expr == 3*_x + 2
+
+    assert imageset(x, (x, 1/x), S.Integers) == \
+        ImageSet(Lambda(x, (x, 1/x)), S.Integers)
+
+
+def test_Range_eval_imageset():
+    a, b, c = symbols('a b c')
+    assert imageset(x, a*(x + b) + c, Range(3)) == \
+        imageset(x, a*x + a*b + c, Range(3))
+    eq = (x + 1)**2
+    assert imageset(x, eq, Range(3)).lamda.expr == eq
+    eq = a*(x + b) + c
+    r = Range(3, -3, -2)
+    imset = imageset(x, eq, r)
+    assert imset.lamda.expr != eq
+    assert list(imset) == [eq.subs(x, i).expand() for i in list(r)]
+
+
+def test_fun():
+    assert (FiniteSet(*ImageSet(Lambda(x, sin(pi*x/4)),
+        Range(-10, 11))) == FiniteSet(-1, -sqrt(2)/2, 0, sqrt(2)/2, 1))
+
+
+def test_Range_is_empty():
+    i = Symbol('i', integer=True)
+    n = Symbol('n', negative=True, integer=True)
+    p = Symbol('p', positive=True, integer=True)
+
+    assert Range(0).is_empty
+    assert not Range(1).is_empty
+    assert Range(1, 0).is_empty
+    assert not Range(-1, 0).is_empty
+    assert Range(i).is_empty is None
+    assert Range(n).is_empty
+    assert Range(p).is_empty is False
+    assert Range(n, 0).is_empty is False
+    assert Range(n, p).is_empty is False
+    assert Range(p, n).is_empty
+    assert Range(n, -1).is_empty is None
+    assert Range(p, n, -1).is_empty is False
+
+
+def test_Reals():
+    assert 5 in S.Reals
+    assert S.Pi in S.Reals
+    assert -sqrt(2) in S.Reals
+    assert (2, 5) not in S.Reals
+    assert sqrt(-1) not in S.Reals
+    assert S.Reals == Interval(-oo, oo)
+    assert S.Reals != Interval(0, oo)
+    assert S.Reals.is_subset(Interval(-oo, oo))
+    assert S.Reals.intersect(Range(-oo, oo)) == Range(-oo, oo)
+    assert S.ComplexInfinity not in S.Reals
+    assert S.NaN not in S.Reals
+    assert x + S.ComplexInfinity not in S.Reals
+
+
+def test_Complex():
+    assert 5 in S.Complexes
+    assert 5 + 4*I in S.Complexes
+    assert S.Pi in S.Complexes
+    assert -sqrt(2) in S.Complexes
+    assert -I in S.Complexes
+    assert sqrt(-1) in S.Complexes
+    assert S.Complexes.intersect(S.Reals) == S.Reals
+    assert S.Complexes.union(S.Reals) == S.Complexes
+    assert S.Complexes == ComplexRegion(S.Reals*S.Reals)
+    assert (S.Complexes == ComplexRegion(Interval(1, 2)*Interval(3, 4))) == False
+    assert str(S.Complexes) == "Complexes"
+    assert repr(S.Complexes) == "Complexes"
+
+
+def take(n, iterable):
+    "Return first n items of the iterable as a list"
+    return list(itertools.islice(iterable, n))
+
+
+def test_intersections():
+    assert S.Integers.intersect(S.Reals) == S.Integers
+    assert 5 in S.Integers.intersect(S.Reals)
+    assert 5 in S.Integers.intersect(S.Reals)
+    assert -5 not in S.Naturals.intersect(S.Reals)
+    assert 5.5 not in S.Integers.intersect(S.Reals)
+    assert 5 in S.Integers.intersect(Interval(3, oo))
+    assert -5 in S.Integers.intersect(Interval(-oo, 3))
+    assert all(x.is_Integer
+            for x in take(10, S.Integers.intersect(Interval(3, oo)) ))
+
+
+def test_infinitely_indexed_set_1():
+    from sympy.abc import n, m
+    assert imageset(Lambda(n, n), S.Integers) == imageset(Lambda(m, m), S.Integers)
+
+    assert imageset(Lambda(n, 2*n), S.Integers).intersect(
+            imageset(Lambda(m, 2*m + 1), S.Integers)) is S.EmptySet
+
+    assert imageset(Lambda(n, 2*n), S.Integers).intersect(
+            imageset(Lambda(n, 2*n + 1), S.Integers)) is S.EmptySet
+
+    assert imageset(Lambda(m, 2*m), S.Integers).intersect(
+                imageset(Lambda(n, 3*n), S.Integers)).dummy_eq(
+            ImageSet(Lambda(t, 6*t), S.Integers))
+
+    assert imageset(x, x/2 + Rational(1, 3), S.Integers).intersect(S.Integers) is S.EmptySet
+    assert imageset(x, x/2 + S.Half, S.Integers).intersect(S.Integers) is S.Integers
+
+    # https://github.com/sympy/sympy/issues/17355
+    S53 = ImageSet(Lambda(n, 5*n + 3), S.Integers)
+    assert S53.intersect(S.Integers) == S53
+
+
+def test_infinitely_indexed_set_2():
+    from sympy.abc import n
+    a = Symbol('a', integer=True)
+    assert imageset(Lambda(n, n), S.Integers) == \
+        imageset(Lambda(n, n + a), S.Integers)
+    assert imageset(Lambda(n, n + pi), S.Integers) == \
+        imageset(Lambda(n, n + a + pi), S.Integers)
+    assert imageset(Lambda(n, n), S.Integers) == \
+        imageset(Lambda(n, -n + a), S.Integers)
+    assert imageset(Lambda(n, -6*n), S.Integers) == \
+        ImageSet(Lambda(n, 6*n), S.Integers)
+    assert imageset(Lambda(n, 2*n + pi), S.Integers) == \
+        ImageSet(Lambda(n, 2*n + pi - 2), S.Integers)
+
+
+def test_imageset_intersect_real():
+    from sympy.abc import n
+    assert imageset(Lambda(n, n + (n - 1)*(n + 1)*I), S.Integers).intersect(S.Reals) == FiniteSet(-1, 1)
+    im = (n - 1)*(n + S.Half)
+    assert imageset(Lambda(n, n + im*I), S.Integers
+        ).intersect(S.Reals) == FiniteSet(1)
+    assert imageset(Lambda(n, n + im*(n + 1)*I), S.Naturals0
+        ).intersect(S.Reals) == FiniteSet(1)
+    assert imageset(Lambda(n, n/2 + im.expand()*I), S.Integers
+        ).intersect(S.Reals) == ImageSet(Lambda(x, x/2), ConditionSet(
+        n, Eq(n**2 - n/2 - S(1)/2, 0), S.Integers))
+    assert imageset(Lambda(n, n/(1/n - 1) + im*(n + 1)*I), S.Integers
+        ).intersect(S.Reals) == FiniteSet(S.Half)
+    assert imageset(Lambda(n, n/(n - 6) +
+        (n - 3)*(n + 1)*I/(2*n + 2)), S.Integers).intersect(
+        S.Reals) == FiniteSet(-1)
+    assert imageset(Lambda(n, n/(n**2 - 9) +
+        (n - 3)*(n + 1)*I/(2*n + 2)), S.Integers).intersect(
+        S.Reals) is S.EmptySet
+    s = ImageSet(
+        Lambda(n, -I*(I*(2*pi*n - pi/4) + log(Abs(sqrt(-I))))),
+        S.Integers)
+    # s is unevaluated, but after intersection the result
+    # should be canonical
+    assert s.intersect(S.Reals) == imageset(
+        Lambda(n, 2*n*pi - pi/4), S.Integers) == ImageSet(
+        Lambda(n, 2*pi*n + pi*Rational(7, 4)), S.Integers)
+
+
+def test_imageset_intersect_interval():
+    from sympy.abc import n
+    f1 = ImageSet(Lambda(n, n*pi), S.Integers)
+    f2 = ImageSet(Lambda(n, 2*n), Interval(0, pi))
+    f3 = ImageSet(Lambda(n, 2*n*pi + pi/2), S.Integers)
+    # complex expressions
+    f4 = ImageSet(Lambda(n, n*I*pi), S.Integers)
+    f5 = ImageSet(Lambda(n, 2*I*n*pi + pi/2), S.Integers)
+    # non-linear expressions
+    f6 = ImageSet(Lambda(n, log(n)), S.Integers)
+    f7 = ImageSet(Lambda(n, n**2), S.Integers)
+    f8 = ImageSet(Lambda(n, Abs(n)), S.Integers)
+    f9 = ImageSet(Lambda(n, exp(n)), S.Naturals0)
+
+    assert f1.intersect(Interval(-1, 1)) == FiniteSet(0)
+    assert f1.intersect(Interval(0, 2*pi, False, True)) == FiniteSet(0, pi)
+    assert f2.intersect(Interval(1, 2)) == Interval(1, 2)
+    assert f3.intersect(Interval(-1, 1)) == S.EmptySet
+    assert f3.intersect(Interval(-5, 5)) == FiniteSet(pi*Rational(-3, 2), pi/2)
+    assert f4.intersect(Interval(-1, 1)) == FiniteSet(0)
+    assert f4.intersect(Interval(1, 2)) == S.EmptySet
+    assert f5.intersect(Interval(0, 1)) == S.EmptySet
+    assert f6.intersect(Interval(0, 1)) == FiniteSet(S.Zero, log(2))
+    assert f7.intersect(Interval(0, 10)) == Intersection(f7, Interval(0, 10))
+    assert f8.intersect(Interval(0, 2)) == Intersection(f8, Interval(0, 2))
+    assert f9.intersect(Interval(1, 2)) == Intersection(f9, Interval(1, 2))
+
+
+def test_imageset_intersect_diophantine():
+    from sympy.abc import m, n
+    # Check that same lambda variable for both ImageSets is handled correctly
+    img1 = ImageSet(Lambda(n, 2*n + 1), S.Integers)
+    img2 = ImageSet(Lambda(n, 4*n + 1), S.Integers)
+    assert img1.intersect(img2) == img2
+    # Empty solution set returned by diophantine:
+    assert ImageSet(Lambda(n, 2*n), S.Integers).intersect(
+            ImageSet(Lambda(n, 2*n + 1), S.Integers)) == S.EmptySet
+    # Check intersection with S.Integers:
+    assert ImageSet(Lambda(n, 9/n + 20*n/3), S.Integers).intersect(
+            S.Integers) == FiniteSet(-61, -23, 23, 61)
+    # Single solution (2, 3) for diophantine solution:
+    assert ImageSet(Lambda(n, (n - 2)**2), S.Integers).intersect(
+            ImageSet(Lambda(n, -(n - 3)**2), S.Integers)) == FiniteSet(0)
+    # Single parametric solution for diophantine solution:
+    assert ImageSet(Lambda(n, n**2 + 5), S.Integers).intersect(
+            ImageSet(Lambda(m, 2*m), S.Integers)).dummy_eq(ImageSet(
+            Lambda(n, 4*n**2 + 4*n + 6), S.Integers))
+    # 4 non-parametric solution couples for dioph. equation:
+    assert ImageSet(Lambda(n, n**2 - 9), S.Integers).intersect(
+            ImageSet(Lambda(m, -m**2), S.Integers)) == FiniteSet(-9, 0)
+    # Double parametric solution for diophantine solution:
+    assert ImageSet(Lambda(m, m**2 + 40), S.Integers).intersect(
+            ImageSet(Lambda(n, 41*n), S.Integers)).dummy_eq(Intersection(
+            ImageSet(Lambda(m, m**2 + 40), S.Integers),
+            ImageSet(Lambda(n, 41*n), S.Integers)))
+    # Check that diophantine returns *all* (8) solutions (permute=True)
+    assert ImageSet(Lambda(n, n**4 - 2**4), S.Integers).intersect(
+            ImageSet(Lambda(m, -m**4 + 3**4), S.Integers)) == FiniteSet(0, 65)
+    assert ImageSet(Lambda(n, pi/12 + n*5*pi/12), S.Integers).intersect(
+            ImageSet(Lambda(n, 7*pi/12 + n*11*pi/12), S.Integers)).dummy_eq(ImageSet(
+            Lambda(n, 55*pi*n/12 + 17*pi/4), S.Integers))
+    # TypeError raised by diophantine (#18081)
+    assert ImageSet(Lambda(n, n*log(2)), S.Integers).intersection(
+        S.Integers).dummy_eq(Intersection(ImageSet(
+        Lambda(n, n*log(2)), S.Integers), S.Integers))
+    # NotImplementedError raised by diophantine (no solver for cubic_thue)
+    assert ImageSet(Lambda(n, n**3 + 1), S.Integers).intersect(
+            ImageSet(Lambda(n, n**3), S.Integers)).dummy_eq(Intersection(
+            ImageSet(Lambda(n, n**3 + 1), S.Integers),
+            ImageSet(Lambda(n, n**3), S.Integers)))
+
+
+def test_infinitely_indexed_set_3():
+    from sympy.abc import n, m
+    assert imageset(Lambda(m, 2*pi*m), S.Integers).intersect(
+            imageset(Lambda(n, 3*pi*n), S.Integers)).dummy_eq(
+        ImageSet(Lambda(t, 6*pi*t), S.Integers))
+    assert imageset(Lambda(n, 2*n + 1), S.Integers) == \
+        imageset(Lambda(n, 2*n - 1), S.Integers)
+    assert imageset(Lambda(n, 3*n + 2), S.Integers) == \
+        imageset(Lambda(n, 3*n - 1), S.Integers)
+
+
+def test_ImageSet_simplification():
+    from sympy.abc import n, m
+    assert imageset(Lambda(n, n), S.Integers) == S.Integers
+    assert imageset(Lambda(n, sin(n)),
+                    imageset(Lambda(m, tan(m)), S.Integers)) == \
+            imageset(Lambda(m, sin(tan(m))), S.Integers)
+    assert imageset(n, 1 + 2*n, S.Naturals) == Range(3, oo, 2)
+    assert imageset(n, 1 + 2*n, S.Naturals0) == Range(1, oo, 2)
+    assert imageset(n, 1 - 2*n, S.Naturals) == Range(-1, -oo, -2)
+
+
+def test_ImageSet_contains():
+    assert (2, S.Half) in imageset(x, (x, 1/x), S.Integers)
+    assert imageset(x, x + I*3, S.Integers).intersection(S.Reals) is S.EmptySet
+    i = Dummy(integer=True)
+    q = imageset(x, x + I*y, S.Integers).intersection(S.Reals)
+    assert q.subs(y, I*i).intersection(S.Integers) is S.Integers
+    q = imageset(x, x + I*y/x, S.Integers).intersection(S.Reals)
+    assert q.subs(y, 0) is S.Integers
+    assert q.subs(y, I*i*x).intersection(S.Integers) is S.Integers
+    z = cos(1)**2 + sin(1)**2 - 1
+    q = imageset(x, x + I*z, S.Integers).intersection(S.Reals)
+    assert q is not S.EmptySet
+
+
+def test_ComplexRegion_contains():
+    r = Symbol('r', real=True)
+    # contains in ComplexRegion
+    a = Interval(2, 3)
+    b = Interval(4, 6)
+    c = Interval(7, 9)
+    c1 = ComplexRegion(a*b)
+    c2 = ComplexRegion(Union(a*b, c*a))
+    assert 2.5 + 4.5*I in c1
+    assert 2 + 4*I in c1
+    assert 3 + 4*I in c1
+    assert 8 + 2.5*I in c2
+    assert 2.5 + 6.1*I not in c1
+    assert 4.5 + 3.2*I not in c1
+    assert c1.contains(x) == Contains(x, c1, evaluate=False)
+    assert c1.contains(r) == False
+    assert c2.contains(x) == Contains(x, c2, evaluate=False)
+    assert c2.contains(r) == False
+
+    r1 = Interval(0, 1)
+    theta1 = Interval(0, 2*S.Pi)
+    c3 = ComplexRegion(r1*theta1, polar=True)
+    assert (0.5 + I*6/10) in c3
+    assert (S.Half + I*6/10) in c3
+    assert (S.Half + .6*I) in c3
+    assert (0.5 + .6*I) in c3
+    assert I in c3
+    assert 1 in c3
+    assert 0 in c3
+    assert 1 + I not in c3
+    assert 1 - I not in c3
+    assert c3.contains(x) == Contains(x, c3, evaluate=False)
+    assert c3.contains(r + 2*I) == Contains(
+        r + 2*I, c3, evaluate=False)  # is in fact False
+    assert c3.contains(1/(1 + r**2)) == Contains(
+        1/(1 + r**2), c3, evaluate=False)  # is in fact True
+
+    r2 = Interval(0, 3)
+    theta2 = Interval(pi, 2*pi, left_open=True)
+    c4 = ComplexRegion(r2*theta2, polar=True)
+    assert c4.contains(0) == True
+    assert c4.contains(2 + I) == False
+    assert c4.contains(-2 + I) == False
+    assert c4.contains(-2 - I) == True
+    assert c4.contains(2 - I) == True
+    assert c4.contains(-2) == False
+    assert c4.contains(2) == True
+    assert c4.contains(x) == Contains(x, c4, evaluate=False)
+    assert c4.contains(3/(1 + r**2)) == Contains(
+        3/(1 + r**2), c4, evaluate=False)  # is in fact True
+
+    raises(ValueError, lambda: ComplexRegion(r1*theta1, polar=2))
+
+
+def test_symbolic_Range():
+    n = Symbol('n')
+    raises(ValueError, lambda: Range(n)[0])
+    raises(IndexError, lambda: Range(n, n)[0])
+    raises(ValueError, lambda: Range(n, n+1)[0])
+    raises(ValueError, lambda: Range(n).size)
+
+    n = Symbol('n', integer=True)
+    raises(ValueError, lambda: Range(n)[0])
+    raises(IndexError, lambda: Range(n, n)[0])
+    assert Range(n, n+1)[0] == n
+    raises(ValueError, lambda: Range(n).size)
+    assert Range(n, n+1).size == 1
+
+    n = Symbol('n', integer=True, nonnegative=True)
+    raises(ValueError, lambda: Range(n)[0])
+    raises(IndexError, lambda: Range(n, n)[0])
+    assert Range(n+1)[0] == 0
+    assert Range(n, n+1)[0] == n
+    assert Range(n).size == n
+    assert Range(n+1).size == n+1
+    assert Range(n, n+1).size == 1
+
+    n = Symbol('n', integer=True, positive=True)
+    assert Range(n)[0] == 0
+    assert Range(n, n+1)[0] == n
+    assert Range(n).size == n
+    assert Range(n, n+1).size == 1
+
+    m = Symbol('m', integer=True, positive=True)
+
+    assert Range(n, n+m)[0] == n
+    assert Range(n, n+m).size == m
+    assert Range(n, n+1).size == 1
+    assert Range(n, n+m, 2).size == floor(m/2)
+
+    m = Symbol('m', integer=True, positive=True, even=True)
+    assert Range(n, n+m, 2).size == m/2
+
+
+def test_issue_18400():
+    n = Symbol('n', integer=True)
+    raises(ValueError, lambda: imageset(lambda x: x*2, Range(n)))
+
+    n = Symbol('n', integer=True, positive=True)
+    # No exception
+    assert imageset(lambda x: x*2, Range(n)) == imageset(lambda x: x*2, Range(n))
+
+
+def test_ComplexRegion_intersect():
+    # Polar form
+    X_axis = ComplexRegion(Interval(0, oo)*FiniteSet(0, S.Pi), polar=True)
+
+    unit_disk = ComplexRegion(Interval(0, 1)*Interval(0, 2*S.Pi), polar=True)
+    upper_half_unit_disk = ComplexRegion(Interval(0, 1)*Interval(0, S.Pi), polar=True)
+    upper_half_disk = ComplexRegion(Interval(0, oo)*Interval(0, S.Pi), polar=True)
+    lower_half_disk = ComplexRegion(Interval(0, oo)*Interval(S.Pi, 2*S.Pi), polar=True)
+    right_half_disk = ComplexRegion(Interval(0, oo)*Interval(-S.Pi/2, S.Pi/2), polar=True)
+    first_quad_disk = ComplexRegion(Interval(0, oo)*Interval(0, S.Pi/2), polar=True)
+
+    assert upper_half_disk.intersect(unit_disk) == upper_half_unit_disk
+    assert right_half_disk.intersect(first_quad_disk) == first_quad_disk
+    assert upper_half_disk.intersect(right_half_disk) == first_quad_disk
+    assert upper_half_disk.intersect(lower_half_disk) == X_axis
+
+    c1 = ComplexRegion(Interval(0, 4)*Interval(0, 2*S.Pi), polar=True)
+    assert c1.intersect(Interval(1, 5)) == Interval(1, 4)
+    assert c1.intersect(Interval(4, 9)) == FiniteSet(4)
+    assert c1.intersect(Interval(5, 12)) is S.EmptySet
+
+    # Rectangular form
+    X_axis = ComplexRegion(Interval(-oo, oo)*FiniteSet(0))
+
+    unit_square = ComplexRegion(Interval(-1, 1)*Interval(-1, 1))
+    upper_half_unit_square = ComplexRegion(Interval(-1, 1)*Interval(0, 1))
+    upper_half_plane = ComplexRegion(Interval(-oo, oo)*Interval(0, oo))
+    lower_half_plane = ComplexRegion(Interval(-oo, oo)*Interval(-oo, 0))
+    right_half_plane = ComplexRegion(Interval(0, oo)*Interval(-oo, oo))
+    first_quad_plane = ComplexRegion(Interval(0, oo)*Interval(0, oo))
+
+    assert upper_half_plane.intersect(unit_square) == upper_half_unit_square
+    assert right_half_plane.intersect(first_quad_plane) == first_quad_plane
+    assert upper_half_plane.intersect(right_half_plane) == first_quad_plane
+    assert upper_half_plane.intersect(lower_half_plane) == X_axis
+
+    c1 = ComplexRegion(Interval(-5, 5)*Interval(-10, 10))
+    assert c1.intersect(Interval(2, 7)) == Interval(2, 5)
+    assert c1.intersect(Interval(5, 7)) == FiniteSet(5)
+    assert c1.intersect(Interval(6, 9)) is S.EmptySet
+
+    # unevaluated object
+    C1 = ComplexRegion(Interval(0, 1)*Interval(0, 2*S.Pi), polar=True)
+    C2 = ComplexRegion(Interval(-1, 1)*Interval(-1, 1))
+    assert C1.intersect(C2) == Intersection(C1, C2, evaluate=False)
+
+
+def test_ComplexRegion_union():
+    # Polar form
+    c1 = ComplexRegion(Interval(0, 1)*Interval(0, 2*S.Pi), polar=True)
+    c2 = ComplexRegion(Interval(0, 1)*Interval(0, S.Pi), polar=True)
+    c3 = ComplexRegion(Interval(0, oo)*Interval(0, S.Pi), polar=True)
+    c4 = ComplexRegion(Interval(0, oo)*Interval(S.Pi, 2*S.Pi), polar=True)
+
+    p1 = Union(Interval(0, 1)*Interval(0, 2*S.Pi), Interval(0, 1)*Interval(0, S.Pi))
+    p2 = Union(Interval(0, oo)*Interval(0, S.Pi), Interval(0, oo)*Interval(S.Pi, 2*S.Pi))
+
+    assert c1.union(c2) == ComplexRegion(p1, polar=True)
+    assert c3.union(c4) == ComplexRegion(p2, polar=True)
+
+    # Rectangular form
+    c5 = ComplexRegion(Interval(2, 5)*Interval(6, 9))
+    c6 = ComplexRegion(Interval(4, 6)*Interval(10, 12))
+    c7 = ComplexRegion(Interval(0, 10)*Interval(-10, 0))
+    c8 = ComplexRegion(Interval(12, 16)*Interval(14, 20))
+
+    p3 = Union(Interval(2, 5)*Interval(6, 9), Interval(4, 6)*Interval(10, 12))
+    p4 = Union(Interval(0, 10)*Interval(-10, 0), Interval(12, 16)*Interval(14, 20))
+
+    assert c5.union(c6) == ComplexRegion(p3)
+    assert c7.union(c8) == ComplexRegion(p4)
+
+    assert c1.union(Interval(2, 4)) == Union(c1, Interval(2, 4), evaluate=False)
+    assert c5.union(Interval(2, 4)) == Union(c5, ComplexRegion.from_real(Interval(2, 4)))
+
+
+def test_ComplexRegion_from_real():
+    c1 = ComplexRegion(Interval(0, 1) * Interval(0, 2 * S.Pi), polar=True)
+
+    raises(ValueError, lambda: c1.from_real(c1))
+    assert c1.from_real(Interval(-1, 1)) == ComplexRegion(Interval(-1, 1) * FiniteSet(0), False)
+
+
+def test_ComplexRegion_measure():
+    a, b = Interval(2, 5), Interval(4, 8)
+    theta1, theta2 = Interval(0, 2*S.Pi), Interval(0, S.Pi)
+    c1 = ComplexRegion(a*b)
+    c2 = ComplexRegion(Union(a*theta1, b*theta2), polar=True)
+
+    assert c1.measure == 12
+    assert c2.measure == 9*pi
+
+
+def test_normalize_theta_set():
+    # Interval
+    assert normalize_theta_set(Interval(pi, 2*pi)) == \
+        Union(FiniteSet(0), Interval.Ropen(pi, 2*pi))
+    assert normalize_theta_set(Interval(pi*Rational(9, 2), 5*pi)) == Interval(pi/2, pi)
+    assert normalize_theta_set(Interval(pi*Rational(-3, 2), pi/2)) == Interval.Ropen(0, 2*pi)
+    assert normalize_theta_set(Interval.open(pi*Rational(-3, 2), pi/2)) == \
+        Union(Interval.Ropen(0, pi/2), Interval.open(pi/2, 2*pi))
+    assert normalize_theta_set(Interval.open(pi*Rational(-7, 2), pi*Rational(-3, 2))) == \
+        Union(Interval.Ropen(0, pi/2), Interval.open(pi/2, 2*pi))
+    assert normalize_theta_set(Interval(-pi/2, pi/2)) == \
+        Union(Interval(0, pi/2), Interval.Ropen(pi*Rational(3, 2), 2*pi))
+    assert normalize_theta_set(Interval.open(-pi/2, pi/2)) == \
+        Union(Interval.Ropen(0, pi/2), Interval.open(pi*Rational(3, 2), 2*pi))
+    assert normalize_theta_set(Interval(-4*pi, 3*pi)) == Interval.Ropen(0, 2*pi)
+    assert normalize_theta_set(Interval(pi*Rational(-3, 2), -pi/2)) == Interval(pi/2, pi*Rational(3, 2))
+    assert normalize_theta_set(Interval.open(0, 2*pi)) == Interval.open(0, 2*pi)
+    assert normalize_theta_set(Interval.Ropen(-pi/2, pi/2)) == \
+        Union(Interval.Ropen(0, pi/2), Interval.Ropen(pi*Rational(3, 2), 2*pi))
+    assert normalize_theta_set(Interval.Lopen(-pi/2, pi/2)) == \
+        Union(Interval(0, pi/2), Interval.open(pi*Rational(3, 2), 2*pi))
+    assert normalize_theta_set(Interval(-pi/2, pi/2)) == \
+        Union(Interval(0, pi/2), Interval.Ropen(pi*Rational(3, 2), 2*pi))
+    assert normalize_theta_set(Interval.open(4*pi, pi*Rational(9, 2))) == Interval.open(0, pi/2)
+    assert normalize_theta_set(Interval.Lopen(4*pi, pi*Rational(9, 2))) == Interval.Lopen(0, pi/2)
+    assert normalize_theta_set(Interval.Ropen(4*pi, pi*Rational(9, 2))) == Interval.Ropen(0, pi/2)
+    assert normalize_theta_set(Interval.open(3*pi, 5*pi)) == \
+        Union(Interval.Ropen(0, pi), Interval.open(pi, 2*pi))
+
+    # FiniteSet
+    assert normalize_theta_set(FiniteSet(0, pi, 3*pi)) == FiniteSet(0, pi)
+    assert normalize_theta_set(FiniteSet(0, pi/2, pi, 2*pi)) == FiniteSet(0, pi/2, pi)
+    assert normalize_theta_set(FiniteSet(0, -pi/2, -pi, -2*pi)) == FiniteSet(0, pi, pi*Rational(3, 2))
+    assert normalize_theta_set(FiniteSet(pi*Rational(-3, 2), pi/2)) == \
+        FiniteSet(pi/2)
+    assert normalize_theta_set(FiniteSet(2*pi)) == FiniteSet(0)
+
+    # Unions
+    assert normalize_theta_set(Union(Interval(0, pi/3), Interval(pi/2, pi))) == \
+        Union(Interval(0, pi/3), Interval(pi/2, pi))
+    assert normalize_theta_set(Union(Interval(0, pi), Interval(2*pi, pi*Rational(7, 3)))) == \
+        Interval(0, pi)
+
+    # ValueError for non-real sets
+    raises(ValueError, lambda: normalize_theta_set(S.Complexes))
+
+    # NotImplementedError for subset of reals
+    raises(NotImplementedError, lambda: normalize_theta_set(Interval(0, 1)))
+
+    # NotImplementedError without pi as coefficient
+    raises(NotImplementedError, lambda: normalize_theta_set(Interval(1, 2*pi)))
+    raises(NotImplementedError, lambda: normalize_theta_set(Interval(2*pi, 10)))
+    raises(NotImplementedError, lambda: normalize_theta_set(FiniteSet(0, 3, 3*pi)))
+
+
+def test_ComplexRegion_FiniteSet():
+    x, y, z, a, b, c = symbols('x y z a b c')
+
+    # Issue #9669
+    assert ComplexRegion(FiniteSet(a, b, c)*FiniteSet(x, y, z)) == \
+        FiniteSet(a + I*x, a + I*y, a + I*z, b + I*x, b + I*y,
+                  b + I*z, c + I*x, c + I*y, c + I*z)
+    assert ComplexRegion(FiniteSet(2)*FiniteSet(3)) == FiniteSet(2 + 3*I)
+
+
+def test_union_RealSubSet():
+    assert (S.Complexes).union(Interval(1, 2)) == S.Complexes
+    assert (S.Complexes).union(S.Integers) == S.Complexes
+
+
+def test_SetKind_fancySet():
+    G = lambda *args: ImageSet(Lambda(x, x ** 2), *args)
+    assert G(Interval(1, 4)).kind is SetKind(NumberKind)
+    assert G(FiniteSet(1, 4)).kind is SetKind(NumberKind)
+    assert S.Rationals.kind is SetKind(NumberKind)
+    assert S.Naturals.kind is SetKind(NumberKind)
+    assert S.Integers.kind is SetKind(NumberKind)
+    assert Range(3).kind is SetKind(NumberKind)
+    a = Interval(2, 3)
+    b = Interval(4, 6)
+    c1 = ComplexRegion(a*b)
+    assert c1.kind is SetKind(TupleKind(NumberKind, NumberKind))
+
+
+def test_issue_9980():
+    c1 = ComplexRegion(Interval(1, 2)*Interval(2, 3))
+    c2 = ComplexRegion(Interval(1, 5)*Interval(1, 3))
+    R = Union(c1, c2)
+    assert simplify(R) == ComplexRegion(Union(Interval(1, 2)*Interval(2, 3), \
+                                    Interval(1, 5)*Interval(1, 3)), False)
+    assert c1.func(*c1.args) == c1
+    assert R.func(*R.args) == R
+
+
+def test_issue_11732():
+    interval12 = Interval(1, 2)
+    finiteset1234 = FiniteSet(1, 2, 3, 4)
+    pointComplex = Tuple(1, 5)
+
+    assert (interval12 in S.Naturals) == False
+    assert (interval12 in S.Naturals0) == False
+    assert (interval12 in S.Integers) == False
+    assert (interval12 in S.Complexes) == False
+
+    assert (finiteset1234 in S.Naturals) == False
+    assert (finiteset1234 in S.Naturals0) == False
+    assert (finiteset1234 in S.Integers) == False
+    assert (finiteset1234 in S.Complexes) == False
+
+    assert (pointComplex in S.Naturals) == False
+    assert (pointComplex in S.Naturals0) == False
+    assert (pointComplex in S.Integers) == False
+    assert (pointComplex in S.Complexes) == True
+
+
+def test_issue_11730():
+    unit = Interval(0, 1)
+    square = ComplexRegion(unit ** 2)
+
+    assert Union(S.Complexes, FiniteSet(oo)) != S.Complexes
+    assert Union(S.Complexes, FiniteSet(eye(4))) != S.Complexes
+    assert Union(unit, square) == square
+    assert Intersection(S.Reals, square) == unit
+
+
+def test_issue_11938():
+    unit = Interval(0, 1)
+    ival = Interval(1, 2)
+    cr1 = ComplexRegion(ival * unit)
+
+    assert Intersection(cr1, S.Reals) == ival
+    assert Intersection(cr1, unit) == FiniteSet(1)
+
+    arg1 = Interval(0, S.Pi)
+    arg2 = FiniteSet(S.Pi)
+    arg3 = Interval(S.Pi / 4, 3 * S.Pi / 4)
+    cp1 = ComplexRegion(unit * arg1, polar=True)
+    cp2 = ComplexRegion(unit * arg2, polar=True)
+    cp3 = ComplexRegion(unit * arg3, polar=True)
+
+    assert Intersection(cp1, S.Reals) == Interval(-1, 1)
+    assert Intersection(cp2, S.Reals) == Interval(-1, 0)
+    assert Intersection(cp3, S.Reals) == FiniteSet(0)
+
+
+def test_issue_11914():
+    a, b = Interval(0, 1), Interval(0, pi)
+    c, d = Interval(2, 3), Interval(pi, 3 * pi / 2)
+    cp1 = ComplexRegion(a * b, polar=True)
+    cp2 = ComplexRegion(c * d, polar=True)
+
+    assert -3 in cp1.union(cp2)
+    assert -3 in cp2.union(cp1)
+    assert -5 not in cp1.union(cp2)
+
+
+def test_issue_9543():
+    assert ImageSet(Lambda(x, x**2), S.Naturals).is_subset(S.Reals)
+
+
+def test_issue_16871():
+    assert ImageSet(Lambda(x, x), FiniteSet(1)) == {1}
+    assert ImageSet(Lambda(x, x - 3), S.Integers
+        ).intersection(S.Integers) is S.Integers
+
+
+@XFAIL
+def test_issue_16871b():
+    assert ImageSet(Lambda(x, x - 3), S.Integers).is_subset(S.Integers)
+
+
+def test_issue_18050():
+    assert imageset(Lambda(x, I*x + 1), S.Integers
+        ) == ImageSet(Lambda(x, I*x + 1), S.Integers)
+    assert imageset(Lambda(x, 3*I*x + 4 + 8*I), S.Integers
+        ) == ImageSet(Lambda(x, 3*I*x + 4 + 2*I), S.Integers)
+    # no 'Mod' for next 2 tests:
+    assert imageset(Lambda(x, 2*x + 3*I), S.Integers
+        ) == ImageSet(Lambda(x, 2*x + 3*I), S.Integers)
+    r = Symbol('r', positive=True)
+    assert imageset(Lambda(x, r*x + 10), S.Integers
+        ) == ImageSet(Lambda(x, r*x + 10), S.Integers)
+    # reduce real part:
+    assert imageset(Lambda(x, 3*x + 8 + 5*I), S.Integers
+        ) == ImageSet(Lambda(x, 3*x + 2 + 5*I), S.Integers)
+
+
+def test_Rationals():
+    assert S.Integers.is_subset(S.Rationals)
+    assert S.Naturals.is_subset(S.Rationals)
+    assert S.Naturals0.is_subset(S.Rationals)
+    assert S.Rationals.is_subset(S.Reals)
+    assert S.Rationals.inf is -oo
+    assert S.Rationals.sup is oo
+    it = iter(S.Rationals)
+    assert [next(it) for i in range(12)] == [
+        0, 1, -1, S.Half, 2, Rational(-1, 2), -2,
+        Rational(1, 3), 3, Rational(-1, 3), -3, Rational(2, 3)]
+    assert Basic() not in S.Rationals
+    assert S.Half in S.Rationals
+    assert S.Rationals.contains(0.5) == Contains(
+        0.5, S.Rationals, evaluate=False)
+    assert 2 in S.Rationals
+    r = symbols('r', rational=True)
+    assert r in S.Rationals
+    raises(TypeError, lambda: x in S.Rationals)
+    # issue #18134:
+    assert S.Rationals.boundary == S.Reals
+    assert S.Rationals.closure == S.Reals
+    assert S.Rationals.is_open == False
+    assert S.Rationals.is_closed == False
+
+
+def test_NZQRC_unions():
+    # check that all trivial number set unions are simplified:
+    nbrsets = (S.Naturals, S.Naturals0, S.Integers, S.Rationals,
+        S.Reals, S.Complexes)
+    unions = (Union(a, b) for a in nbrsets for b in nbrsets)
+    assert all(u.is_Union is False for u in unions)
+
+
+def test_imageset_intersection():
+    n = Dummy()
+    s = ImageSet(Lambda(n, -I*(I*(2*pi*n - pi/4) +
+        log(Abs(sqrt(-I))))), S.Integers)
+    assert s.intersect(S.Reals) == ImageSet(
+        Lambda(n, 2*pi*n + pi*Rational(7, 4)), S.Integers)
+
+
+def test_issue_17858():
+    assert 1 in Range(-oo, oo)
+    assert 0 in Range(oo, -oo, -1)
+    assert oo not in Range(-oo, oo)
+    assert -oo not in Range(-oo, oo)
+
+def test_issue_17859():
+    r = Range(-oo,oo)
+    raises(ValueError,lambda: r[::2])
+    raises(ValueError, lambda: r[::-2])
+    r = Range(oo,-oo,-1)
+    raises(ValueError,lambda: r[::2])
+    raises(ValueError, lambda: r[::-2])
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/sets/tests/test_ordinals.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/sets/tests/test_ordinals.py
new file mode 100644
index 0000000000000000000000000000000000000000..973ca329586f3e904f9377c44022c266f81c805c
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/sets/tests/test_ordinals.py
@@ -0,0 +1,67 @@
+from sympy.sets.ordinals import Ordinal, OmegaPower, ord0, omega
+from sympy.testing.pytest import raises
+
+def test_string_ordinals():
+    assert str(omega) == 'w'
+    assert str(Ordinal(OmegaPower(5, 3), OmegaPower(3, 2))) == 'w**5*3 + w**3*2'
+    assert str(Ordinal(OmegaPower(5, 3), OmegaPower(0, 5))) == 'w**5*3 + 5'
+    assert str(Ordinal(OmegaPower(1, 3), OmegaPower(0, 5))) == 'w*3 + 5'
+    assert str(Ordinal(OmegaPower(omega + 1, 1), OmegaPower(3, 2))) == 'w**(w + 1) + w**3*2'
+
+def test_addition_with_integers():
+    assert 3 + Ordinal(OmegaPower(5, 3)) == Ordinal(OmegaPower(5, 3))
+    assert Ordinal(OmegaPower(5, 3))+3 == Ordinal(OmegaPower(5, 3), OmegaPower(0, 3))
+    assert Ordinal(OmegaPower(5, 3), OmegaPower(0, 2))+3 == \
+        Ordinal(OmegaPower(5, 3), OmegaPower(0, 5))
+
+
+def test_addition_with_ordinals():
+    assert Ordinal(OmegaPower(5, 3), OmegaPower(3, 2)) + Ordinal(OmegaPower(3, 3)) == \
+        Ordinal(OmegaPower(5, 3), OmegaPower(3, 5))
+    assert Ordinal(OmegaPower(5, 3), OmegaPower(3, 2)) + Ordinal(OmegaPower(4, 2)) == \
+        Ordinal(OmegaPower(5, 3), OmegaPower(4, 2))
+    assert Ordinal(OmegaPower(omega, 2), OmegaPower(3, 2)) + Ordinal(OmegaPower(4, 2)) == \
+        Ordinal(OmegaPower(omega, 2), OmegaPower(4, 2))
+
+def test_comparison():
+    assert Ordinal(OmegaPower(5, 3)) > Ordinal(OmegaPower(4, 3), OmegaPower(2, 1))
+    assert Ordinal(OmegaPower(5, 3), OmegaPower(3, 2)) < Ordinal(OmegaPower(5, 4))
+    assert Ordinal(OmegaPower(5, 4)) < Ordinal(OmegaPower(5, 5), OmegaPower(4, 1))
+
+    assert Ordinal(OmegaPower(5, 3), OmegaPower(3, 2)) == \
+        Ordinal(OmegaPower(5, 3), OmegaPower(3, 2))
+    assert not Ordinal(OmegaPower(5, 3), OmegaPower(3, 2)) == Ordinal(OmegaPower(5, 3))
+    assert Ordinal(OmegaPower(omega, 3)) > Ordinal(OmegaPower(5, 3))
+
+def test_multiplication_with_integers():
+    w = omega
+    assert 3*w == w
+    assert w*9 == Ordinal(OmegaPower(1, 9))
+
+def test_multiplication():
+    w = omega
+    assert w*(w + 1) == w*w + w
+    assert (w + 1)*(w + 1) ==  w*w + w + 1
+    assert w*1 == w
+    assert 1*w == w
+    assert w*ord0 == ord0
+    assert ord0*w == ord0
+    assert w**w == w * w**w
+    assert (w**w)*w*w == w**(w + 2)
+
+def test_exponentiation():
+    w = omega
+    assert w**2 == w*w
+    assert w**3 == w*w*w
+    assert w**(w + 1) == Ordinal(OmegaPower(omega + 1, 1))
+    assert (w**w)*(w**w) == w**(w*2)
+
+def test_comapre_not_instance():
+    w = OmegaPower(omega + 1, 1)
+    assert(not (w == None))
+    assert(not (w < 5))
+    raises(TypeError, lambda: w < 6.66)
+
+def test_is_successort():
+    w = Ordinal(OmegaPower(5, 1))
+    assert not w.is_successor_ordinal
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/sets/tests/test_powerset.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/sets/tests/test_powerset.py
new file mode 100644
index 0000000000000000000000000000000000000000..2e3a407d565f6b9537a296af103ec0a4e137cff9
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/sets/tests/test_powerset.py
@@ -0,0 +1,141 @@
+from sympy.core.expr import unchanged
+from sympy.core.singleton import S
+from sympy.core.symbol import Symbol
+from sympy.sets.contains import Contains
+from sympy.sets.fancysets import Interval
+from sympy.sets.powerset import PowerSet
+from sympy.sets.sets import FiniteSet
+from sympy.testing.pytest import raises, XFAIL
+
+
+def test_powerset_creation():
+    assert unchanged(PowerSet, FiniteSet(1, 2))
+    assert unchanged(PowerSet, S.EmptySet)
+    raises(ValueError, lambda: PowerSet(123))
+    assert unchanged(PowerSet, S.Reals)
+    assert unchanged(PowerSet, S.Integers)
+
+
+def test_powerset_rewrite_FiniteSet():
+    assert PowerSet(FiniteSet(1, 2)).rewrite(FiniteSet) == \
+        FiniteSet(S.EmptySet, FiniteSet(1), FiniteSet(2), FiniteSet(1, 2))
+    assert PowerSet(S.EmptySet).rewrite(FiniteSet) == FiniteSet(S.EmptySet)
+    assert PowerSet(S.Naturals).rewrite(FiniteSet) == PowerSet(S.Naturals)
+
+
+def test_finiteset_rewrite_powerset():
+    assert FiniteSet(S.EmptySet).rewrite(PowerSet) == PowerSet(S.EmptySet)
+    assert FiniteSet(
+        S.EmptySet, FiniteSet(1),
+        FiniteSet(2), FiniteSet(1, 2)).rewrite(PowerSet) == \
+            PowerSet(FiniteSet(1, 2))
+    assert FiniteSet(1, 2, 3).rewrite(PowerSet) == FiniteSet(1, 2, 3)
+
+
+def test_powerset__contains__():
+    subset_series = [
+        S.EmptySet,
+        FiniteSet(1, 2),
+        S.Naturals,
+        S.Naturals0,
+        S.Integers,
+        S.Rationals,
+        S.Reals,
+        S.Complexes]
+
+    l = len(subset_series)
+    for i in range(l):
+        for j in range(l):
+            if i <= j:
+                assert subset_series[i] in \
+                    PowerSet(subset_series[j], evaluate=False)
+            else:
+                assert subset_series[i] not in \
+                    PowerSet(subset_series[j], evaluate=False)
+
+
+@XFAIL
+def test_failing_powerset__contains__():
+    # XXX These are failing when evaluate=True,
+    # but using unevaluated PowerSet works fine.
+    assert FiniteSet(1, 2) not in PowerSet(S.EmptySet).rewrite(FiniteSet)
+    assert S.Naturals not in PowerSet(S.EmptySet).rewrite(FiniteSet)
+    assert S.Naturals not in PowerSet(FiniteSet(1, 2)).rewrite(FiniteSet)
+    assert S.Naturals0 not in PowerSet(S.EmptySet).rewrite(FiniteSet)
+    assert S.Naturals0 not in PowerSet(FiniteSet(1, 2)).rewrite(FiniteSet)
+    assert S.Integers not in PowerSet(S.EmptySet).rewrite(FiniteSet)
+    assert S.Integers not in PowerSet(FiniteSet(1, 2)).rewrite(FiniteSet)
+    assert S.Rationals not in PowerSet(S.EmptySet).rewrite(FiniteSet)
+    assert S.Rationals not in PowerSet(FiniteSet(1, 2)).rewrite(FiniteSet)
+    assert S.Reals not in PowerSet(S.EmptySet).rewrite(FiniteSet)
+    assert S.Reals not in PowerSet(FiniteSet(1, 2)).rewrite(FiniteSet)
+    assert S.Complexes not in PowerSet(S.EmptySet).rewrite(FiniteSet)
+    assert S.Complexes not in PowerSet(FiniteSet(1, 2)).rewrite(FiniteSet)
+
+
+def test_powerset__len__():
+    A = PowerSet(S.EmptySet, evaluate=False)
+    assert len(A) == 1
+    A = PowerSet(A, evaluate=False)
+    assert len(A) == 2
+    A = PowerSet(A, evaluate=False)
+    assert len(A) == 4
+    A = PowerSet(A, evaluate=False)
+    assert len(A) == 16
+
+
+def test_powerset__iter__():
+    a = PowerSet(FiniteSet(1, 2)).__iter__()
+    assert next(a) == S.EmptySet
+    assert next(a) == FiniteSet(1)
+    assert next(a) == FiniteSet(2)
+    assert next(a) == FiniteSet(1, 2)
+
+    a = PowerSet(S.Naturals).__iter__()
+    assert next(a) == S.EmptySet
+    assert next(a) == FiniteSet(1)
+    assert next(a) == FiniteSet(2)
+    assert next(a) == FiniteSet(1, 2)
+    assert next(a) == FiniteSet(3)
+    assert next(a) == FiniteSet(1, 3)
+    assert next(a) == FiniteSet(2, 3)
+    assert next(a) == FiniteSet(1, 2, 3)
+
+
+def test_powerset_contains():
+    A = PowerSet(FiniteSet(1), evaluate=False)
+    assert A.contains(2) == Contains(2, A)
+
+    x = Symbol('x')
+
+    A = PowerSet(FiniteSet(x), evaluate=False)
+    assert A.contains(FiniteSet(1)) == Contains(FiniteSet(1), A)
+
+
+def test_powerset_method():
+    # EmptySet
+    A = FiniteSet()
+    pset = A.powerset()
+    assert len(pset) == 1
+    assert pset ==  FiniteSet(S.EmptySet)
+
+    # FiniteSets
+    A = FiniteSet(1, 2)
+    pset = A.powerset()
+    assert len(pset) == 2**len(A)
+    assert pset == FiniteSet(FiniteSet(), FiniteSet(1),
+                             FiniteSet(2), A)
+    # Not finite sets
+    A = Interval(0, 1)
+    assert A.powerset() == PowerSet(A)
+
+def test_is_subset():
+    # covers line 101-102
+    # initialize powerset(1), which is a subset of powerset(1,2)
+    subset = PowerSet(FiniteSet(1))
+    pset = PowerSet(FiniteSet(1, 2))
+    bad_set = PowerSet(FiniteSet(2, 3))
+    # assert "subset" is subset of pset == True
+    assert subset.is_subset(pset)
+    # assert "bad_set" is subset of pset == False
+    assert not pset.is_subset(bad_set)
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/sets/tests/test_setexpr.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/sets/tests/test_setexpr.py
new file mode 100644
index 0000000000000000000000000000000000000000..faab1261c8d3e86901b04d30e8bc94de31642b93
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/sets/tests/test_setexpr.py
@@ -0,0 +1,317 @@
+from sympy.sets.setexpr import SetExpr
+from sympy.sets import Interval, FiniteSet, Intersection, ImageSet, Union
+
+from sympy.core.expr import Expr
+from sympy.core.function import Lambda
+from sympy.core.numbers import (I, Rational, oo)
+from sympy.core.singleton import S
+from sympy.core.symbol import (Dummy, Symbol, symbols)
+from sympy.functions.elementary.exponential import (exp, log)
+from sympy.functions.elementary.miscellaneous import (Max, Min, sqrt)
+from sympy.functions.elementary.trigonometric import cos
+from sympy.sets.sets import Set
+
+
+a, x = symbols("a, x")
+_d = Dummy("d")
+
+
+def test_setexpr():
+    se = SetExpr(Interval(0, 1))
+    assert isinstance(se.set, Set)
+    assert isinstance(se, Expr)
+
+
+def test_scalar_funcs():
+    assert SetExpr(Interval(0, 1)).set == Interval(0, 1)
+    a, b = Symbol('a', real=True), Symbol('b', real=True)
+    a, b = 1, 2
+    # TODO: add support for more functions in the future:
+    for f in [exp, log]:
+        input_se = f(SetExpr(Interval(a, b)))
+        output = input_se.set
+        expected = Interval(Min(f(a), f(b)), Max(f(a), f(b)))
+        assert output == expected
+
+
+def test_Add_Mul():
+    assert (SetExpr(Interval(0, 1)) + 1).set == Interval(1, 2)
+    assert (SetExpr(Interval(0, 1))*2).set == Interval(0, 2)
+
+
+def test_Pow():
+    assert (SetExpr(Interval(0, 2))**2).set == Interval(0, 4)
+
+
+def test_compound():
+    assert (exp(SetExpr(Interval(0, 1))*2 + 1)).set == \
+           Interval(exp(1), exp(3))
+
+
+def test_Interval_Interval():
+    assert (SetExpr(Interval(1, 2)) + SetExpr(Interval(10, 20))).set == \
+           Interval(11, 22)
+    assert (SetExpr(Interval(1, 2))*SetExpr(Interval(10, 20))).set == \
+           Interval(10, 40)
+
+
+def test_FiniteSet_FiniteSet():
+    assert (SetExpr(FiniteSet(1, 2, 3)) + SetExpr(FiniteSet(1, 2))).set == \
+           FiniteSet(2, 3, 4, 5)
+    assert (SetExpr(FiniteSet(1, 2, 3))*SetExpr(FiniteSet(1, 2))).set == \
+           FiniteSet(1, 2, 3, 4, 6)
+
+
+def test_Interval_FiniteSet():
+    assert (SetExpr(FiniteSet(1, 2)) + SetExpr(Interval(0, 10))).set == \
+           Interval(1, 12)
+
+
+def test_Many_Sets():
+    assert (SetExpr(Interval(0, 1)) +
+            SetExpr(Interval(2, 3)) +
+            SetExpr(FiniteSet(10, 11, 12))).set == Interval(12, 16)
+
+
+def test_same_setexprs_are_not_identical():
+    a = SetExpr(FiniteSet(0, 1))
+    b = SetExpr(FiniteSet(0, 1))
+    assert (a + b).set == FiniteSet(0, 1, 2)
+
+    # Cannot detect the set being the same:
+    # assert (a + a).set == FiniteSet(0, 2)
+
+
+def test_Interval_arithmetic():
+    i12cc = SetExpr(Interval(1, 2))
+    i12lo = SetExpr(Interval.Lopen(1, 2))
+    i12ro = SetExpr(Interval.Ropen(1, 2))
+    i12o = SetExpr(Interval.open(1, 2))
+
+    n23cc = SetExpr(Interval(-2, 3))
+    n23lo = SetExpr(Interval.Lopen(-2, 3))
+    n23ro = SetExpr(Interval.Ropen(-2, 3))
+    n23o = SetExpr(Interval.open(-2, 3))
+
+    n3n2cc = SetExpr(Interval(-3, -2))
+
+    assert i12cc + i12cc == SetExpr(Interval(2, 4))
+    assert i12cc - i12cc == SetExpr(Interval(-1, 1))
+    assert i12cc*i12cc == SetExpr(Interval(1, 4))
+    assert i12cc/i12cc == SetExpr(Interval(S.Half, 2))
+    assert i12cc**2 == SetExpr(Interval(1, 4))
+    assert i12cc**3 == SetExpr(Interval(1, 8))
+
+    assert i12lo + i12ro == SetExpr(Interval.open(2, 4))
+    assert i12lo - i12ro == SetExpr(Interval.Lopen(-1, 1))
+    assert i12lo*i12ro == SetExpr(Interval.open(1, 4))
+    assert i12lo/i12ro == SetExpr(Interval.Lopen(S.Half, 2))
+    assert i12lo + i12lo == SetExpr(Interval.Lopen(2, 4))
+    assert i12lo - i12lo == SetExpr(Interval.open(-1, 1))
+    assert i12lo*i12lo == SetExpr(Interval.Lopen(1, 4))
+    assert i12lo/i12lo == SetExpr(Interval.open(S.Half, 2))
+    assert i12lo + i12cc == SetExpr(Interval.Lopen(2, 4))
+    assert i12lo - i12cc == SetExpr(Interval.Lopen(-1, 1))
+    assert i12lo*i12cc == SetExpr(Interval.Lopen(1, 4))
+    assert i12lo/i12cc == SetExpr(Interval.Lopen(S.Half, 2))
+    assert i12lo + i12o == SetExpr(Interval.open(2, 4))
+    assert i12lo - i12o == SetExpr(Interval.open(-1, 1))
+    assert i12lo*i12o == SetExpr(Interval.open(1, 4))
+    assert i12lo/i12o == SetExpr(Interval.open(S.Half, 2))
+    assert i12lo**2 == SetExpr(Interval.Lopen(1, 4))
+    assert i12lo**3 == SetExpr(Interval.Lopen(1, 8))
+
+    assert i12ro + i12ro == SetExpr(Interval.Ropen(2, 4))
+    assert i12ro - i12ro == SetExpr(Interval.open(-1, 1))
+    assert i12ro*i12ro == SetExpr(Interval.Ropen(1, 4))
+    assert i12ro/i12ro == SetExpr(Interval.open(S.Half, 2))
+    assert i12ro + i12cc == SetExpr(Interval.Ropen(2, 4))
+    assert i12ro - i12cc == SetExpr(Interval.Ropen(-1, 1))
+    assert i12ro*i12cc == SetExpr(Interval.Ropen(1, 4))
+    assert i12ro/i12cc == SetExpr(Interval.Ropen(S.Half, 2))
+    assert i12ro + i12o == SetExpr(Interval.open(2, 4))
+    assert i12ro - i12o == SetExpr(Interval.open(-1, 1))
+    assert i12ro*i12o == SetExpr(Interval.open(1, 4))
+    assert i12ro/i12o == SetExpr(Interval.open(S.Half, 2))
+    assert i12ro**2 == SetExpr(Interval.Ropen(1, 4))
+    assert i12ro**3 == SetExpr(Interval.Ropen(1, 8))
+
+    assert i12o + i12lo == SetExpr(Interval.open(2, 4))
+    assert i12o - i12lo == SetExpr(Interval.open(-1, 1))
+    assert i12o*i12lo == SetExpr(Interval.open(1, 4))
+    assert i12o/i12lo == SetExpr(Interval.open(S.Half, 2))
+    assert i12o + i12ro == SetExpr(Interval.open(2, 4))
+    assert i12o - i12ro == SetExpr(Interval.open(-1, 1))
+    assert i12o*i12ro == SetExpr(Interval.open(1, 4))
+    assert i12o/i12ro == SetExpr(Interval.open(S.Half, 2))
+    assert i12o + i12cc == SetExpr(Interval.open(2, 4))
+    assert i12o - i12cc == SetExpr(Interval.open(-1, 1))
+    assert i12o*i12cc == SetExpr(Interval.open(1, 4))
+    assert i12o/i12cc == SetExpr(Interval.open(S.Half, 2))
+    assert i12o**2 == SetExpr(Interval.open(1, 4))
+    assert i12o**3 == SetExpr(Interval.open(1, 8))
+
+    assert n23cc + n23cc == SetExpr(Interval(-4, 6))
+    assert n23cc - n23cc == SetExpr(Interval(-5, 5))
+    assert n23cc*n23cc == SetExpr(Interval(-6, 9))
+    assert n23cc/n23cc == SetExpr(Interval.open(-oo, oo))
+    assert n23cc + n23ro == SetExpr(Interval.Ropen(-4, 6))
+    assert n23cc - n23ro == SetExpr(Interval.Lopen(-5, 5))
+    assert n23cc*n23ro == SetExpr(Interval.Ropen(-6, 9))
+    assert n23cc/n23ro == SetExpr(Interval.Lopen(-oo, oo))
+    assert n23cc + n23lo == SetExpr(Interval.Lopen(-4, 6))
+    assert n23cc - n23lo == SetExpr(Interval.Ropen(-5, 5))
+    assert n23cc*n23lo == SetExpr(Interval(-6, 9))
+    assert n23cc/n23lo == SetExpr(Interval.open(-oo, oo))
+    assert n23cc + n23o == SetExpr(Interval.open(-4, 6))
+    assert n23cc - n23o == SetExpr(Interval.open(-5, 5))
+    assert n23cc*n23o == SetExpr(Interval.open(-6, 9))
+    assert n23cc/n23o == SetExpr(Interval.open(-oo, oo))
+    assert n23cc**2 == SetExpr(Interval(0, 9))
+    assert n23cc**3 == SetExpr(Interval(-8, 27))
+
+    n32cc = SetExpr(Interval(-3, 2))
+    n32lo = SetExpr(Interval.Lopen(-3, 2))
+    n32ro = SetExpr(Interval.Ropen(-3, 2))
+    assert n32cc*n32lo == SetExpr(Interval.Ropen(-6, 9))
+    assert n32cc*n32cc == SetExpr(Interval(-6, 9))
+    assert n32lo*n32cc == SetExpr(Interval.Ropen(-6, 9))
+    assert n32cc*n32ro == SetExpr(Interval(-6, 9))
+    assert n32lo*n32ro == SetExpr(Interval.Ropen(-6, 9))
+    assert n32cc/n32lo == SetExpr(Interval.Ropen(-oo, oo))
+    assert i12cc/n32lo == SetExpr(Interval.Ropen(-oo, oo))
+
+    assert n3n2cc**2 == SetExpr(Interval(4, 9))
+    assert n3n2cc**3 == SetExpr(Interval(-27, -8))
+
+    assert n23cc + i12cc == SetExpr(Interval(-1, 5))
+    assert n23cc - i12cc == SetExpr(Interval(-4, 2))
+    assert n23cc*i12cc == SetExpr(Interval(-4, 6))
+    assert n23cc/i12cc == SetExpr(Interval(-2, 3))
+
+
+def test_SetExpr_Intersection():
+    x, y, z, w = symbols("x y z w")
+    set1 = Interval(x, y)
+    set2 = Interval(w, z)
+    inter = Intersection(set1, set2)
+    se = SetExpr(inter)
+    assert exp(se).set == Intersection(
+        ImageSet(Lambda(x, exp(x)), set1),
+        ImageSet(Lambda(x, exp(x)), set2))
+    assert cos(se).set == ImageSet(Lambda(x, cos(x)), inter)
+
+
+def test_SetExpr_Interval_div():
+    # TODO: some expressions cannot be calculated due to bugs (currently
+    # commented):
+    assert SetExpr(Interval(-3, -2))/SetExpr(Interval(-2, 1)) == SetExpr(Interval(-oo, oo))
+    assert SetExpr(Interval(2, 3))/SetExpr(Interval(-2, 2)) == SetExpr(Interval(-oo, oo))
+
+    assert SetExpr(Interval(-3, -2))/SetExpr(Interval(0, 4)) == SetExpr(Interval(-oo, Rational(-1, 2)))
+    assert SetExpr(Interval(2, 4))/SetExpr(Interval(-3, 0)) == SetExpr(Interval(-oo, Rational(-2, 3)))
+    assert SetExpr(Interval(2, 4))/SetExpr(Interval(0, 3)) == SetExpr(Interval(Rational(2, 3), oo))
+
+    # assert SetExpr(Interval(0, 1))/SetExpr(Interval(0, 1)) == SetExpr(Interval(0, oo))
+    # assert SetExpr(Interval(-1, 0))/SetExpr(Interval(0, 1)) == SetExpr(Interval(-oo, 0))
+    assert SetExpr(Interval(-1, 2))/SetExpr(Interval(-2, 2)) == SetExpr(Interval(-oo, oo))
+
+    assert 1/SetExpr(Interval(-1, 2)) == SetExpr(Union(Interval(-oo, -1), Interval(S.Half, oo)))
+
+    assert 1/SetExpr(Interval(0, 2)) == SetExpr(Interval(S.Half, oo))
+    assert (-1)/SetExpr(Interval(0, 2)) == SetExpr(Interval(-oo, Rational(-1, 2)))
+    assert 1/SetExpr(Interval(-oo, 0)) == SetExpr(Interval.open(-oo, 0))
+    assert 1/SetExpr(Interval(-1, 0)) == SetExpr(Interval(-oo, -1))
+    # assert (-2)/SetExpr(Interval(-oo, 0)) == SetExpr(Interval(0, oo))
+    # assert 1/SetExpr(Interval(-oo, -1)) == SetExpr(Interval(-1, 0))
+
+    # assert SetExpr(Interval(1, 2))/a == Mul(SetExpr(Interval(1, 2)), 1/a, evaluate=False)
+
+    # assert SetExpr(Interval(1, 2))/0 == SetExpr(Interval(1, 2))*zoo
+    # assert SetExpr(Interval(1, oo))/oo == SetExpr(Interval(0, oo))
+    # assert SetExpr(Interval(1, oo))/(-oo) == SetExpr(Interval(-oo, 0))
+    # assert SetExpr(Interval(-oo, -1))/oo == SetExpr(Interval(-oo, 0))
+    # assert SetExpr(Interval(-oo, -1))/(-oo) == SetExpr(Interval(0, oo))
+    # assert SetExpr(Interval(-oo, oo))/oo == SetExpr(Interval(-oo, oo))
+    # assert SetExpr(Interval(-oo, oo))/(-oo) == SetExpr(Interval(-oo, oo))
+    # assert SetExpr(Interval(-1, oo))/oo == SetExpr(Interval(0, oo))
+    # assert SetExpr(Interval(-1, oo))/(-oo) == SetExpr(Interval(-oo, 0))
+    # assert SetExpr(Interval(-oo, 1))/oo == SetExpr(Interval(-oo, 0))
+    # assert SetExpr(Interval(-oo, 1))/(-oo) == SetExpr(Interval(0, oo))
+
+
+def test_SetExpr_Interval_pow():
+    assert SetExpr(Interval(0, 2))**2 == SetExpr(Interval(0, 4))
+    assert SetExpr(Interval(-1, 1))**2 == SetExpr(Interval(0, 1))
+    assert SetExpr(Interval(1, 2))**2 == SetExpr(Interval(1, 4))
+    assert SetExpr(Interval(-1, 2))**3 == SetExpr(Interval(-1, 8))
+    assert SetExpr(Interval(-1, 1))**0 == SetExpr(FiniteSet(1))
+
+
+    assert SetExpr(Interval(1, 2))**Rational(5, 2) == SetExpr(Interval(1, 4*sqrt(2)))
+    #assert SetExpr(Interval(-1, 2))**Rational(1, 3) == SetExpr(Interval(-1, 2**Rational(1, 3)))
+    #assert SetExpr(Interval(0, 2))**S.Half == SetExpr(Interval(0, sqrt(2)))
+
+    #assert SetExpr(Interval(-4, 2))**Rational(2, 3) == SetExpr(Interval(0, 2*2**Rational(1, 3)))
+
+    #assert SetExpr(Interval(-1, 5))**S.Half == SetExpr(Interval(0, sqrt(5)))
+    #assert SetExpr(Interval(-oo, 2))**S.Half == SetExpr(Interval(0, sqrt(2)))
+    #assert SetExpr(Interval(-2, 3))**(Rational(-1, 4)) == SetExpr(Interval(0, oo))
+
+    assert SetExpr(Interval(1, 5))**(-2) == SetExpr(Interval(Rational(1, 25), 1))
+    assert SetExpr(Interval(-1, 3))**(-2) == SetExpr(Interval(0, oo))
+
+    assert SetExpr(Interval(0, 2))**(-2) == SetExpr(Interval(Rational(1, 4), oo))
+    assert SetExpr(Interval(-1, 2))**(-3) == SetExpr(Union(Interval(-oo, -1), Interval(Rational(1, 8), oo)))
+    assert SetExpr(Interval(-3, -2))**(-3) == SetExpr(Interval(Rational(-1, 8), Rational(-1, 27)))
+    assert SetExpr(Interval(-3, -2))**(-2) == SetExpr(Interval(Rational(1, 9), Rational(1, 4)))
+    #assert SetExpr(Interval(0, oo))**S.Half == SetExpr(Interval(0, oo))
+    #assert SetExpr(Interval(-oo, -1))**Rational(1, 3) == SetExpr(Interval(-oo, -1))
+    #assert SetExpr(Interval(-2, 3))**(Rational(-1, 3)) == SetExpr(Interval(-oo, oo))
+
+    assert SetExpr(Interval(-oo, 0))**(-2) == SetExpr(Interval.open(0, oo))
+    assert SetExpr(Interval(-2, 0))**(-2) == SetExpr(Interval(Rational(1, 4), oo))
+
+    assert SetExpr(Interval(Rational(1, 3), S.Half))**oo == SetExpr(FiniteSet(0))
+    assert SetExpr(Interval(0, S.Half))**oo == SetExpr(FiniteSet(0))
+    assert SetExpr(Interval(S.Half, 1))**oo == SetExpr(Interval(0, oo))
+    assert SetExpr(Interval(0, 1))**oo == SetExpr(Interval(0, oo))
+    assert SetExpr(Interval(2, 3))**oo == SetExpr(FiniteSet(oo))
+    assert SetExpr(Interval(1, 2))**oo == SetExpr(Interval(0, oo))
+    assert SetExpr(Interval(S.Half, 3))**oo == SetExpr(Interval(0, oo))
+    assert SetExpr(Interval(Rational(-1, 3), Rational(-1, 4)))**oo == SetExpr(FiniteSet(0))
+    assert SetExpr(Interval(-1, Rational(-1, 2)))**oo == SetExpr(Interval(-oo, oo))
+    assert SetExpr(Interval(-3, -2))**oo == SetExpr(FiniteSet(-oo, oo))
+    assert SetExpr(Interval(-2, -1))**oo == SetExpr(Interval(-oo, oo))
+    assert SetExpr(Interval(-2, Rational(-1, 2)))**oo == SetExpr(Interval(-oo, oo))
+    assert SetExpr(Interval(Rational(-1, 2), S.Half))**oo == SetExpr(FiniteSet(0))
+    assert SetExpr(Interval(Rational(-1, 2), 1))**oo == SetExpr(Interval(0, oo))
+    assert SetExpr(Interval(Rational(-2, 3), 2))**oo == SetExpr(Interval(0, oo))
+    assert SetExpr(Interval(-1, 1))**oo == SetExpr(Interval(-oo, oo))
+    assert SetExpr(Interval(-1, S.Half))**oo == SetExpr(Interval(-oo, oo))
+    assert SetExpr(Interval(-1, 2))**oo == SetExpr(Interval(-oo, oo))
+    assert SetExpr(Interval(-2, S.Half))**oo == SetExpr(Interval(-oo, oo))
+
+    assert (SetExpr(Interval(1, 2))**x).dummy_eq(SetExpr(ImageSet(Lambda(_d, _d**x), Interval(1, 2))))
+
+    assert SetExpr(Interval(2, 3))**(-oo) == SetExpr(FiniteSet(0))
+    assert SetExpr(Interval(0, 2))**(-oo) == SetExpr(Interval(0, oo))
+    assert (SetExpr(Interval(-1, 2))**(-oo)).dummy_eq(SetExpr(ImageSet(Lambda(_d, _d**(-oo)), Interval(-1, 2))))
+
+
+def test_SetExpr_Integers():
+    assert SetExpr(S.Integers) + 1 == SetExpr(S.Integers)
+    assert (SetExpr(S.Integers) + I).dummy_eq(
+        SetExpr(ImageSet(Lambda(_d, _d + I), S.Integers)))
+    assert SetExpr(S.Integers)*(-1) == SetExpr(S.Integers)
+    assert (SetExpr(S.Integers)*2).dummy_eq(
+        SetExpr(ImageSet(Lambda(_d, 2*_d), S.Integers)))
+    assert (SetExpr(S.Integers)*I).dummy_eq(
+        SetExpr(ImageSet(Lambda(_d, I*_d), S.Integers)))
+    # issue #18050:
+    assert SetExpr(S.Integers)._eval_func(Lambda(x, I*x + 1)).dummy_eq(
+        SetExpr(ImageSet(Lambda(_d, I*_d + 1), S.Integers)))
+    # needs improvement:
+    assert (SetExpr(S.Integers)*I + 1).dummy_eq(
+        SetExpr(ImageSet(Lambda(x, x + 1),
+        ImageSet(Lambda(_d, _d*I), S.Integers))))
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/sets/tests/test_sets.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/sets/tests/test_sets.py
new file mode 100644
index 0000000000000000000000000000000000000000..657ab19a90eb88ca48f266f7a5cf050504caed43
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/sets/tests/test_sets.py
@@ -0,0 +1,1753 @@
+from sympy.concrete.summations import Sum
+from sympy.core.add import Add
+from sympy.core.containers import TupleKind
+from sympy.core.function import Lambda
+from sympy.core.kind import NumberKind, UndefinedKind
+from sympy.core.numbers import (Float, I, Rational, nan, oo, pi, zoo)
+from sympy.core.power import Pow
+from sympy.core.singleton import S
+from sympy.core.symbol import (Symbol, symbols)
+from sympy.core.sympify import sympify
+from sympy.functions.elementary.miscellaneous import (Max, Min, sqrt)
+from sympy.functions.elementary.piecewise import Piecewise
+from sympy.functions.elementary.trigonometric import (cos, sin)
+from sympy.logic.boolalg import (false, true)
+from sympy.matrices.kind import MatrixKind
+from sympy.matrices.dense import Matrix
+from sympy.polys.rootoftools import rootof
+from sympy.sets.contains import Contains
+from sympy.sets.fancysets import (ImageSet, Range)
+from sympy.sets.sets import (Complement, DisjointUnion, FiniteSet, Intersection, Interval, ProductSet, Set, SymmetricDifference, Union, imageset, SetKind)
+from mpmath import mpi
+
+from sympy.core.expr import unchanged
+from sympy.core.relational import Eq, Ne, Le, Lt, LessThan
+from sympy.logic import And, Or, Xor
+from sympy.testing.pytest import raises, XFAIL, warns_deprecated_sympy
+from sympy.utilities.iterables import cartes
+
+from sympy.abc import x, y, z, m, n
+
+EmptySet = S.EmptySet
+
+def test_imageset():
+    ints = S.Integers
+    assert imageset(x, x - 1, S.Naturals) is S.Naturals0
+    assert imageset(x, x + 1, S.Naturals0) is S.Naturals
+    assert imageset(x, abs(x), S.Naturals0) is S.Naturals0
+    assert imageset(x, abs(x), S.Naturals) is S.Naturals
+    assert imageset(x, abs(x), S.Integers) is S.Naturals0
+    # issue 16878a
+    r = symbols('r', real=True)
+    assert imageset(x, (x, x), S.Reals)._contains((1, r)) == None
+    assert imageset(x, (x, x), S.Reals)._contains((1, 2)) == False
+    assert (r, r) in imageset(x, (x, x), S.Reals)
+    assert 1 + I in imageset(x, x + I, S.Reals)
+    assert {1} not in imageset(x, (x,), S.Reals)
+    assert (1, 1) not in imageset(x, (x,), S.Reals)
+    raises(TypeError, lambda: imageset(x, ints))
+    raises(ValueError, lambda: imageset(x, y, z, ints))
+    raises(ValueError, lambda: imageset(Lambda(x, cos(x)), y))
+    assert (1, 2) in imageset(Lambda((x, y), (x, y)), ints, ints)
+    raises(ValueError, lambda: imageset(Lambda(x, x), ints, ints))
+    assert imageset(cos, ints) == ImageSet(Lambda(x, cos(x)), ints)
+    def f(x):
+        return cos(x)
+    assert imageset(f, ints) == imageset(x, cos(x), ints)
+    f = lambda x: cos(x)
+    assert imageset(f, ints) == ImageSet(Lambda(x, cos(x)), ints)
+    assert imageset(x, 1, ints) == FiniteSet(1)
+    assert imageset(x, y, ints) == {y}
+    assert imageset((x, y), (1, z), ints, S.Reals) == {(1, z)}
+    clash = Symbol('x', integer=true)
+    assert (str(imageset(lambda x: x + clash, Interval(-2, 1)).lamda.expr)
+        in ('x0 + x', 'x + x0'))
+    x1, x2 = symbols("x1, x2")
+    assert imageset(lambda x, y:
+        Add(x, y), Interval(1, 2), Interval(2, 3)).dummy_eq(
+        ImageSet(Lambda((x1, x2), x1 + x2),
+        Interval(1, 2), Interval(2, 3)))
+
+
+def test_is_empty():
+    for s in [S.Naturals, S.Naturals0, S.Integers, S.Rationals, S.Reals,
+            S.UniversalSet]:
+        assert s.is_empty is False
+
+    assert S.EmptySet.is_empty is True
+
+
+def test_is_finiteset():
+    for s in [S.Naturals, S.Naturals0, S.Integers, S.Rationals, S.Reals,
+            S.UniversalSet]:
+        assert s.is_finite_set is False
+
+    assert S.EmptySet.is_finite_set is True
+
+    assert FiniteSet(1, 2).is_finite_set is True
+    assert Interval(1, 2).is_finite_set is False
+    assert Interval(x, y).is_finite_set is None
+    assert ProductSet(FiniteSet(1), FiniteSet(2)).is_finite_set is True
+    assert ProductSet(FiniteSet(1), Interval(1, 2)).is_finite_set is False
+    assert ProductSet(FiniteSet(1), Interval(x, y)).is_finite_set is None
+    assert Union(Interval(0, 1), Interval(2, 3)).is_finite_set is False
+    assert Union(FiniteSet(1), Interval(2, 3)).is_finite_set is False
+    assert Union(FiniteSet(1), FiniteSet(2)).is_finite_set is True
+    assert Union(FiniteSet(1), Interval(x, y)).is_finite_set is None
+    assert Intersection(Interval(x, y), FiniteSet(1)).is_finite_set is True
+    assert Intersection(Interval(x, y), Interval(1, 2)).is_finite_set is None
+    assert Intersection(FiniteSet(x), FiniteSet(y)).is_finite_set is True
+    assert Complement(FiniteSet(1), Interval(x, y)).is_finite_set is True
+    assert Complement(Interval(x, y), FiniteSet(1)).is_finite_set is None
+    assert Complement(Interval(1, 2), FiniteSet(x)).is_finite_set is False
+    assert DisjointUnion(Interval(-5, 3), FiniteSet(x, y)).is_finite_set is False
+    assert DisjointUnion(S.EmptySet, FiniteSet(x, y), S.EmptySet).is_finite_set is True
+
+
+def test_deprecated_is_EmptySet():
+    with warns_deprecated_sympy():
+        S.EmptySet.is_EmptySet
+
+    with warns_deprecated_sympy():
+        FiniteSet(1).is_EmptySet
+
+
+def test_interval_arguments():
+    assert Interval(0, oo) == Interval(0, oo, False, True)
+    assert Interval(0, oo).right_open is true
+    assert Interval(-oo, 0) == Interval(-oo, 0, True, False)
+    assert Interval(-oo, 0).left_open is true
+    assert Interval(oo, -oo) == S.EmptySet
+    assert Interval(oo, oo) == S.EmptySet
+    assert Interval(-oo, -oo) == S.EmptySet
+    assert Interval(oo, x) == S.EmptySet
+    assert Interval(oo, oo) == S.EmptySet
+    assert Interval(x, -oo) == S.EmptySet
+    assert Interval(x, x) == {x}
+
+    assert isinstance(Interval(1, 1), FiniteSet)
+    e = Sum(x, (x, 1, 3))
+    assert isinstance(Interval(e, e), FiniteSet)
+
+    assert Interval(1, 0) == S.EmptySet
+    assert Interval(1, 1).measure == 0
+
+    assert Interval(1, 1, False, True) == S.EmptySet
+    assert Interval(1, 1, True, False) == S.EmptySet
+    assert Interval(1, 1, True, True) == S.EmptySet
+
+
+    assert isinstance(Interval(0, Symbol('a')), Interval)
+    assert Interval(Symbol('a', positive=True), 0) == S.EmptySet
+    raises(ValueError, lambda: Interval(0, S.ImaginaryUnit))
+    raises(ValueError, lambda: Interval(0, Symbol('z', extended_real=False)))
+    raises(ValueError, lambda: Interval(x, x + S.ImaginaryUnit))
+
+    raises(NotImplementedError, lambda: Interval(0, 1, And(x, y)))
+    raises(NotImplementedError, lambda: Interval(0, 1, False, And(x, y)))
+    raises(NotImplementedError, lambda: Interval(0, 1, z, And(x, y)))
+
+
+def test_interval_symbolic_end_points():
+    a = Symbol('a', real=True)
+
+    assert Union(Interval(0, a), Interval(0, 3)).sup == Max(a, 3)
+    assert Union(Interval(a, 0), Interval(-3, 0)).inf == Min(-3, a)
+
+    assert Interval(0, a).contains(1) == LessThan(1, a)
+
+
+def test_interval_is_empty():
+    x, y = symbols('x, y')
+    r = Symbol('r', real=True)
+    p = Symbol('p', positive=True)
+    n = Symbol('n', negative=True)
+    nn = Symbol('nn', nonnegative=True)
+    assert Interval(1, 2).is_empty == False
+    assert Interval(3, 3).is_empty == False  # FiniteSet
+    assert Interval(r, r).is_empty == False  # FiniteSet
+    assert Interval(r, r + nn).is_empty == False
+    assert Interval(x, x).is_empty == False
+    assert Interval(1, oo).is_empty == False
+    assert Interval(-oo, oo).is_empty == False
+    assert Interval(-oo, 1).is_empty == False
+    assert Interval(x, y).is_empty == None
+    assert Interval(r, oo).is_empty == False  # real implies finite
+    assert Interval(n, 0).is_empty == False
+    assert Interval(n, 0, left_open=True).is_empty == False
+    assert Interval(p, 0).is_empty == True  # EmptySet
+    assert Interval(nn, 0).is_empty == None
+    assert Interval(n, p).is_empty == False
+    assert Interval(0, p, left_open=True).is_empty == False
+    assert Interval(0, p, right_open=True).is_empty == False
+    assert Interval(0, nn, left_open=True).is_empty == None
+    assert Interval(0, nn, right_open=True).is_empty == None
+
+
+def test_union():
+    assert Union(Interval(1, 2), Interval(2, 3)) == Interval(1, 3)
+    assert Union(Interval(1, 2), Interval(2, 3, True)) == Interval(1, 3)
+    assert Union(Interval(1, 3), Interval(2, 4)) == Interval(1, 4)
+    assert Union(Interval(1, 2), Interval(1, 3)) == Interval(1, 3)
+    assert Union(Interval(1, 3), Interval(1, 2)) == Interval(1, 3)
+    assert Union(Interval(1, 3, False, True), Interval(1, 2)) == \
+        Interval(1, 3, False, True)
+    assert Union(Interval(1, 3), Interval(1, 2, False, True)) == Interval(1, 3)
+    assert Union(Interval(1, 2, True), Interval(1, 3)) == Interval(1, 3)
+    assert Union(Interval(1, 2, True), Interval(1, 3, True)) == \
+        Interval(1, 3, True)
+    assert Union(Interval(1, 2, True), Interval(1, 3, True, True)) == \
+        Interval(1, 3, True, True)
+    assert Union(Interval(1, 2, True, True), Interval(1, 3, True)) == \
+        Interval(1, 3, True)
+    assert Union(Interval(1, 3), Interval(2, 3)) == Interval(1, 3)
+    assert Union(Interval(1, 3, False, True), Interval(2, 3)) == \
+        Interval(1, 3)
+    assert Union(Interval(1, 2, False, True), Interval(2, 3, True)) != \
+        Interval(1, 3)
+    assert Union(Interval(1, 2), S.EmptySet) == Interval(1, 2)
+    assert Union(S.EmptySet) == S.EmptySet
+
+    assert Union(Interval(0, 1), *[FiniteSet(1.0/n) for n in range(1, 10)]) == \
+        Interval(0, 1)
+    # issue #18241:
+    x = Symbol('x')
+    assert Union(Interval(0, 1), FiniteSet(1, x)) == Union(
+        Interval(0, 1), FiniteSet(x))
+    assert unchanged(Union, Interval(0, 1), FiniteSet(2, x))
+
+    assert Interval(1, 2).union(Interval(2, 3)) == \
+        Interval(1, 2) + Interval(2, 3)
+
+    assert Interval(1, 2).union(Interval(2, 3)) == Interval(1, 3)
+
+    assert Union(Set()) == Set()
+
+    assert FiniteSet(1) + FiniteSet(2) + FiniteSet(3) == FiniteSet(1, 2, 3)
+    assert FiniteSet('ham') + FiniteSet('eggs') == FiniteSet('ham', 'eggs')
+    assert FiniteSet(1, 2, 3) + S.EmptySet == FiniteSet(1, 2, 3)
+
+    assert FiniteSet(1, 2, 3) & FiniteSet(2, 3, 4) == FiniteSet(2, 3)
+    assert FiniteSet(1, 2, 3) | FiniteSet(2, 3, 4) == FiniteSet(1, 2, 3, 4)
+
+    assert FiniteSet(1, 2, 3) & S.EmptySet == S.EmptySet
+    assert FiniteSet(1, 2, 3) | S.EmptySet == FiniteSet(1, 2, 3)
+
+    x = Symbol("x")
+    y = Symbol("y")
+    z = Symbol("z")
+    assert S.EmptySet | FiniteSet(x, FiniteSet(y, z)) == \
+        FiniteSet(x, FiniteSet(y, z))
+
+    # Test that Intervals and FiniteSets play nicely
+    assert Interval(1, 3) + FiniteSet(2) == Interval(1, 3)
+    assert Interval(1, 3, True, True) + FiniteSet(3) == \
+        Interval(1, 3, True, False)
+    X = Interval(1, 3) + FiniteSet(5)
+    Y = Interval(1, 2) + FiniteSet(3)
+    XandY = X.intersect(Y)
+    assert 2 in X and 3 in X and 3 in XandY
+    assert XandY.is_subset(X) and XandY.is_subset(Y)
+
+    raises(TypeError, lambda: Union(1, 2, 3))
+
+    assert X.is_iterable is False
+
+    # issue 7843
+    assert Union(S.EmptySet, FiniteSet(-sqrt(-I), sqrt(-I))) == \
+        FiniteSet(-sqrt(-I), sqrt(-I))
+
+    assert Union(S.Reals, S.Integers) == S.Reals
+
+
+def test_union_iter():
+    # Use Range because it is ordered
+    u = Union(Range(3), Range(5), Range(4), evaluate=False)
+
+    # Round robin
+    assert list(u) == [0, 0, 0, 1, 1, 1, 2, 2, 2, 3, 3, 4]
+
+
+def test_union_is_empty():
+    assert (Interval(x, y) + FiniteSet(1)).is_empty == False
+    assert (Interval(x, y) + Interval(-x, y)).is_empty == None
+
+
+def test_difference():
+    assert Interval(1, 3) - Interval(1, 2) == Interval(2, 3, True)
+    assert Interval(1, 3) - Interval(2, 3) == Interval(1, 2, False, True)
+    assert Interval(1, 3, True) - Interval(2, 3) == Interval(1, 2, True, True)
+    assert Interval(1, 3, True) - Interval(2, 3, True) == \
+        Interval(1, 2, True, False)
+    assert Interval(0, 2) - FiniteSet(1) == \
+        Union(Interval(0, 1, False, True), Interval(1, 2, True, False))
+
+    # issue #18119
+    assert S.Reals - FiniteSet(I) == S.Reals
+    assert S.Reals - FiniteSet(-I, I) == S.Reals
+    assert Interval(0, 10) - FiniteSet(-I, I) == Interval(0, 10)
+    assert Interval(0, 10) - FiniteSet(1, I) == Union(
+        Interval.Ropen(0, 1), Interval.Lopen(1, 10))
+    assert S.Reals - FiniteSet(1, 2 + I, x, y**2) == Complement(
+        Union(Interval.open(-oo, 1), Interval.open(1, oo)), FiniteSet(x, y**2),
+        evaluate=False)
+
+    assert FiniteSet(1, 2, 3) - FiniteSet(2) == FiniteSet(1, 3)
+    assert FiniteSet('ham', 'eggs') - FiniteSet('eggs') == FiniteSet('ham')
+    assert FiniteSet(1, 2, 3, 4) - Interval(2, 10, True, False) == \
+        FiniteSet(1, 2)
+    assert FiniteSet(1, 2, 3, 4) - S.EmptySet == FiniteSet(1, 2, 3, 4)
+    assert Union(Interval(0, 2), FiniteSet(2, 3, 4)) - Interval(1, 3) == \
+        Union(Interval(0, 1, False, True), FiniteSet(4))
+
+    assert -1 in S.Reals - S.Naturals
+
+
+def test_Complement():
+    A = FiniteSet(1, 3, 4)
+    B = FiniteSet(3, 4)
+    C = Interval(1, 3)
+    D = Interval(1, 2)
+
+    assert Complement(A, B, evaluate=False).is_iterable is True
+    assert Complement(A, C, evaluate=False).is_iterable is True
+    assert Complement(C, D, evaluate=False).is_iterable is None
+
+    assert FiniteSet(*Complement(A, B, evaluate=False)) == FiniteSet(1)
+    assert FiniteSet(*Complement(A, C, evaluate=False)) == FiniteSet(4)
+    raises(TypeError, lambda: FiniteSet(*Complement(C, A, evaluate=False)))
+
+    assert Complement(Interval(1, 3), Interval(1, 2)) == Interval(2, 3, True)
+    assert Complement(FiniteSet(1, 3, 4), FiniteSet(3, 4)) == FiniteSet(1)
+    assert Complement(Union(Interval(0, 2), FiniteSet(2, 3, 4)),
+                      Interval(1, 3)) == \
+        Union(Interval(0, 1, False, True), FiniteSet(4))
+
+    assert 3 not in Complement(Interval(0, 5), Interval(1, 4), evaluate=False)
+    assert -1 in Complement(S.Reals, S.Naturals, evaluate=False)
+    assert 1 not in Complement(S.Reals, S.Naturals, evaluate=False)
+
+    assert Complement(S.Integers, S.UniversalSet) == EmptySet
+    assert S.UniversalSet.complement(S.Integers) == EmptySet
+
+    assert (0 not in S.Reals.intersect(S.Integers - FiniteSet(0)))
+
+    assert S.EmptySet - S.Integers == S.EmptySet
+
+    assert (S.Integers - FiniteSet(0)) - FiniteSet(1) == S.Integers - FiniteSet(0, 1)
+
+    assert S.Reals - Union(S.Naturals, FiniteSet(pi)) == \
+            Intersection(S.Reals - S.Naturals, S.Reals - FiniteSet(pi))
+    # issue 12712
+    assert Complement(FiniteSet(x, y, 2), Interval(-10, 10)) == \
+            Complement(FiniteSet(x, y), Interval(-10, 10))
+
+    A = FiniteSet(*symbols('a:c'))
+    B = FiniteSet(*symbols('d:f'))
+    assert unchanged(Complement, ProductSet(A, A), B)
+
+    A2 = ProductSet(A, A)
+    B3 = ProductSet(B, B, B)
+    assert A2 - B3 == A2
+    assert B3 - A2 == B3
+
+
+def test_set_operations_nonsets():
+    '''Tests that e.g. FiniteSet(1) * 2 raises TypeError'''
+    ops = [
+        lambda a, b: a + b,
+        lambda a, b: a - b,
+        lambda a, b: a * b,
+        lambda a, b: a / b,
+        lambda a, b: a // b,
+        lambda a, b: a | b,
+        lambda a, b: a & b,
+        lambda a, b: a ^ b,
+        # FiniteSet(1) ** 2 gives a ProductSet
+        #lambda a, b: a ** b,
+    ]
+    Sx = FiniteSet(x)
+    Sy = FiniteSet(y)
+    sets = [
+        {1},
+        FiniteSet(1),
+        Interval(1, 2),
+        Union(Sx, Interval(1, 2)),
+        Intersection(Sx, Sy),
+        Complement(Sx, Sy),
+        ProductSet(Sx, Sy),
+        S.EmptySet,
+    ]
+    nums = [0, 1, 2, S(0), S(1), S(2)]
+
+    for si in sets:
+        for ni in nums:
+            for op in ops:
+                raises(TypeError, lambda : op(si, ni))
+                raises(TypeError, lambda : op(ni, si))
+        raises(TypeError, lambda: si ** object())
+        raises(TypeError, lambda: si ** {1})
+
+
+def test_complement():
+    assert Complement({1, 2}, {1}) == {2}
+    assert Interval(0, 1).complement(S.Reals) == \
+        Union(Interval(-oo, 0, True, True), Interval(1, oo, True, True))
+    assert Interval(0, 1, True, False).complement(S.Reals) == \
+        Union(Interval(-oo, 0, True, False), Interval(1, oo, True, True))
+    assert Interval(0, 1, False, True).complement(S.Reals) == \
+        Union(Interval(-oo, 0, True, True), Interval(1, oo, False, True))
+    assert Interval(0, 1, True, True).complement(S.Reals) == \
+        Union(Interval(-oo, 0, True, False), Interval(1, oo, False, True))
+
+    assert S.UniversalSet.complement(S.EmptySet) == S.EmptySet
+    assert S.UniversalSet.complement(S.Reals) == S.EmptySet
+    assert S.UniversalSet.complement(S.UniversalSet) == S.EmptySet
+
+    assert S.EmptySet.complement(S.Reals) == S.Reals
+
+    assert Union(Interval(0, 1), Interval(2, 3)).complement(S.Reals) == \
+        Union(Interval(-oo, 0, True, True), Interval(1, 2, True, True),
+              Interval(3, oo, True, True))
+
+    assert FiniteSet(0).complement(S.Reals) ==  \
+        Union(Interval(-oo, 0, True, True), Interval(0, oo, True, True))
+
+    assert (FiniteSet(5) + Interval(S.NegativeInfinity,
+                                    0)).complement(S.Reals) == \
+        Interval(0, 5, True, True) + Interval(5, S.Infinity, True, True)
+
+    assert FiniteSet(1, 2, 3).complement(S.Reals) == \
+        Interval(S.NegativeInfinity, 1, True, True) + \
+        Interval(1, 2, True, True) + Interval(2, 3, True, True) +\
+        Interval(3, S.Infinity, True, True)
+
+    assert FiniteSet(x).complement(S.Reals) == Complement(S.Reals, FiniteSet(x))
+
+    assert FiniteSet(0, x).complement(S.Reals) == Complement(Interval(-oo, 0, True, True) +
+                                                             Interval(0, oo, True, True)
+                                                             , FiniteSet(x), evaluate=False)
+
+    square = Interval(0, 1) * Interval(0, 1)
+    notsquare = square.complement(S.Reals*S.Reals)
+
+    assert all(pt in square for pt in [(0, 0), (.5, .5), (1, 0), (1, 1)])
+    assert not any(
+        pt in notsquare for pt in [(0, 0), (.5, .5), (1, 0), (1, 1)])
+    assert not any(pt in square for pt in [(-1, 0), (1.5, .5), (10, 10)])
+    assert all(pt in notsquare for pt in [(-1, 0), (1.5, .5), (10, 10)])
+
+
+def test_intersect1():
+    assert all(S.Integers.intersection(i) is i for i in
+        (S.Naturals, S.Naturals0))
+    assert all(i.intersection(S.Integers) is i for i in
+        (S.Naturals, S.Naturals0))
+    s =  S.Naturals0
+    assert S.Naturals.intersection(s) is S.Naturals
+    assert s.intersection(S.Naturals) is S.Naturals
+    x = Symbol('x')
+    assert Interval(0, 2).intersect(Interval(1, 2)) == Interval(1, 2)
+    assert Interval(0, 2).intersect(Interval(1, 2, True)) == \
+        Interval(1, 2, True)
+    assert Interval(0, 2, True).intersect(Interval(1, 2)) == \
+        Interval(1, 2, False, False)
+    assert Interval(0, 2, True, True).intersect(Interval(1, 2)) == \
+        Interval(1, 2, False, True)
+    assert Interval(0, 2).intersect(Union(Interval(0, 1), Interval(2, 3))) == \
+        Union(Interval(0, 1), Interval(2, 2))
+
+    assert FiniteSet(1, 2).intersect(FiniteSet(1, 2, 3)) == FiniteSet(1, 2)
+    assert FiniteSet(1, 2, x).intersect(FiniteSet(x)) == FiniteSet(x)
+    assert FiniteSet('ham', 'eggs').intersect(FiniteSet('ham')) == \
+        FiniteSet('ham')
+    assert FiniteSet(1, 2, 3, 4, 5).intersect(S.EmptySet) == S.EmptySet
+
+    assert Interval(0, 5).intersect(FiniteSet(1, 3)) == FiniteSet(1, 3)
+    assert Interval(0, 1, True, True).intersect(FiniteSet(1)) == S.EmptySet
+
+    assert Union(Interval(0, 1), Interval(2, 3)).intersect(Interval(1, 2)) == \
+        Union(Interval(1, 1), Interval(2, 2))
+    assert Union(Interval(0, 1), Interval(2, 3)).intersect(Interval(0, 2)) == \
+        Union(Interval(0, 1), Interval(2, 2))
+    assert Union(Interval(0, 1), Interval(2, 3)).intersect(Interval(1, 2, True, True)) == \
+        S.EmptySet
+    assert Union(Interval(0, 1), Interval(2, 3)).intersect(S.EmptySet) == \
+        S.EmptySet
+    assert Union(Interval(0, 5), FiniteSet('ham')).intersect(FiniteSet(2, 3, 4, 5, 6)) == \
+        Intersection(FiniteSet(2, 3, 4, 5, 6), Union(FiniteSet('ham'), Interval(0, 5)))
+    assert Intersection(FiniteSet(1, 2, 3), Interval(2, x), Interval(3, y)) == \
+        Intersection(FiniteSet(3), Interval(2, x), Interval(3, y), evaluate=False)
+    assert Intersection(FiniteSet(1, 2), Interval(0, 3), Interval(x, y)) == \
+        Intersection({1, 2}, Interval(x, y), evaluate=False)
+    assert Intersection(FiniteSet(1, 2, 4), Interval(0, 3), Interval(x, y)) == \
+        Intersection({1, 2}, Interval(x, y), evaluate=False)
+    # XXX: Is the real=True necessary here?
+    # https://github.com/sympy/sympy/issues/17532
+    m, n = symbols('m, n', real=True)
+    assert Intersection(FiniteSet(m), FiniteSet(m, n), Interval(m, m+1)) == \
+        FiniteSet(m)
+
+    # issue 8217
+    assert Intersection(FiniteSet(x), FiniteSet(y)) == \
+        Intersection(FiniteSet(x), FiniteSet(y), evaluate=False)
+    assert FiniteSet(x).intersect(S.Reals) == \
+        Intersection(S.Reals, FiniteSet(x), evaluate=False)
+
+    # tests for the intersection alias
+    assert Interval(0, 5).intersection(FiniteSet(1, 3)) == FiniteSet(1, 3)
+    assert Interval(0, 1, True, True).intersection(FiniteSet(1)) == S.EmptySet
+
+    assert Union(Interval(0, 1), Interval(2, 3)).intersection(Interval(1, 2)) == \
+        Union(Interval(1, 1), Interval(2, 2))
+
+    # canonical boundary selected
+    a = sqrt(2*sqrt(6) + 5)
+    b = sqrt(2) + sqrt(3)
+    assert Interval(a, 4).intersection(Interval(b, 5)) == Interval(b, 4)
+    assert Interval(1, a).intersection(Interval(0, b)) == Interval(1, b)
+
+
+def test_intersection_interval_float():
+    # intersection of Intervals with mixed Rational/Float boundaries should
+    # lead to Float boundaries in all cases regardless of which Interval is
+    # open or closed.
+    typs = [
+        (Interval, Interval, Interval),
+        (Interval, Interval.open, Interval.open),
+        (Interval, Interval.Lopen, Interval.Lopen),
+        (Interval, Interval.Ropen, Interval.Ropen),
+        (Interval.open, Interval.open, Interval.open),
+        (Interval.open, Interval.Lopen, Interval.open),
+        (Interval.open, Interval.Ropen, Interval.open),
+        (Interval.Lopen, Interval.Lopen, Interval.Lopen),
+        (Interval.Lopen, Interval.Ropen, Interval.open),
+        (Interval.Ropen, Interval.Ropen, Interval.Ropen),
+    ]
+
+    as_float = lambda a1, a2: a2 if isinstance(a2, float) else a1
+
+    for t1, t2, t3 in typs:
+        for t1i, t2i in [(t1, t2), (t2, t1)]:
+            for a1, a2, b1, b2 in cartes([2, 2.0], [2, 2.0], [3, 3.0], [3, 3.0]):
+                I1 = t1(a1, b1)
+                I2 = t2(a2, b2)
+                I3 = t3(as_float(a1, a2), as_float(b1, b2))
+                assert I1.intersect(I2) == I3
+
+
+def test_intersection():
+    # iterable
+    i = Intersection(FiniteSet(1, 2, 3), Interval(2, 5), evaluate=False)
+    assert i.is_iterable
+    assert set(i) == {S(2), S(3)}
+
+    # challenging intervals
+    x = Symbol('x', real=True)
+    i = Intersection(Interval(0, 3), Interval(x, 6))
+    assert (5 in i) is False
+    raises(TypeError, lambda: 2 in i)
+
+    # Singleton special cases
+    assert Intersection(Interval(0, 1), S.EmptySet) == S.EmptySet
+    assert Intersection(Interval(-oo, oo), Interval(-oo, x)) == Interval(-oo, x)
+
+    # Products
+    line = Interval(0, 5)
+    i = Intersection(line**2, line**3, evaluate=False)
+    assert (2, 2) not in i
+    assert (2, 2, 2) not in i
+    raises(TypeError, lambda: list(i))
+
+    a = Intersection(Intersection(S.Integers, S.Naturals, evaluate=False), S.Reals, evaluate=False)
+    assert a._argset == frozenset([Intersection(S.Naturals, S.Integers, evaluate=False), S.Reals])
+
+    assert Intersection(S.Complexes, FiniteSet(S.ComplexInfinity)) == S.EmptySet
+
+    # issue 12178
+    assert Intersection() == S.UniversalSet
+
+    # issue 16987
+    assert Intersection({1}, {1}, {x}) == Intersection({1}, {x})
+
+
+def test_issue_9623():
+    n = Symbol('n')
+
+    a = S.Reals
+    b = Interval(0, oo)
+    c = FiniteSet(n)
+
+    assert Intersection(a, b, c) == Intersection(b, c)
+    assert Intersection(Interval(1, 2), Interval(3, 4), FiniteSet(n)) == EmptySet
+
+
+def test_is_disjoint():
+    assert Interval(0, 2).is_disjoint(Interval(1, 2)) == False
+    assert Interval(0, 2).is_disjoint(Interval(3, 4)) == True
+
+
+def test_ProductSet__len__():
+    A = FiniteSet(1, 2)
+    B = FiniteSet(1, 2, 3)
+    assert ProductSet(A).__len__() == 2
+    assert ProductSet(A).__len__() is not S(2)
+    assert ProductSet(A, B).__len__() == 6
+    assert ProductSet(A, B).__len__() is not S(6)
+
+
+def test_ProductSet():
+    # ProductSet is always a set of Tuples
+    assert ProductSet(S.Reals) == S.Reals ** 1
+    assert ProductSet(S.Reals, S.Reals) == S.Reals ** 2
+    assert ProductSet(S.Reals, S.Reals, S.Reals) == S.Reals ** 3
+
+    assert ProductSet(S.Reals) != S.Reals
+    assert ProductSet(S.Reals, S.Reals) == S.Reals * S.Reals
+    assert ProductSet(S.Reals, S.Reals, S.Reals) != S.Reals * S.Reals * S.Reals
+    assert ProductSet(S.Reals, S.Reals, S.Reals) == (S.Reals * S.Reals * S.Reals).flatten()
+
+    assert 1 not in ProductSet(S.Reals)
+    assert (1,) in ProductSet(S.Reals)
+
+    assert 1 not in ProductSet(S.Reals, S.Reals)
+    assert (1, 2) in ProductSet(S.Reals, S.Reals)
+    assert (1, I) not in ProductSet(S.Reals, S.Reals)
+
+    assert (1, 2, 3) in ProductSet(S.Reals, S.Reals, S.Reals)
+    assert (1, 2, 3) in S.Reals ** 3
+    assert (1, 2, 3) not in S.Reals * S.Reals * S.Reals
+    assert ((1, 2), 3) in S.Reals * S.Reals * S.Reals
+    assert (1, (2, 3)) not in S.Reals * S.Reals * S.Reals
+    assert (1, (2, 3)) in S.Reals * (S.Reals * S.Reals)
+
+    assert ProductSet() == FiniteSet(())
+    assert ProductSet(S.Reals, S.EmptySet) == S.EmptySet
+
+    # See GH-17458
+
+    for ni in range(5):
+        Rn = ProductSet(*(S.Reals,) * ni)
+        assert (1,) * ni in Rn
+        assert 1 not in Rn
+
+    assert (S.Reals * S.Reals) * S.Reals != S.Reals * (S.Reals * S.Reals)
+
+    S1 = S.Reals
+    S2 = S.Integers
+    x1 = pi
+    x2 = 3
+    assert x1 in S1
+    assert x2 in S2
+    assert (x1, x2) in S1 * S2
+    S3 = S1 * S2
+    x3 = (x1, x2)
+    assert x3 in S3
+    assert (x3, x3) in S3 * S3
+    assert x3 + x3 not in S3 * S3
+
+    raises(ValueError, lambda: S.Reals**-1)
+    with warns_deprecated_sympy():
+        ProductSet(FiniteSet(s) for s in range(2))
+    raises(TypeError, lambda: ProductSet(None))
+
+    S1 = FiniteSet(1, 2)
+    S2 = FiniteSet(3, 4)
+    S3 = ProductSet(S1, S2)
+    assert (S3.as_relational(x, y)
+            == And(S1.as_relational(x), S2.as_relational(y))
+            == And(Or(Eq(x, 1), Eq(x, 2)), Or(Eq(y, 3), Eq(y, 4))))
+    raises(ValueError, lambda: S3.as_relational(x))
+    raises(ValueError, lambda: S3.as_relational(x, 1))
+    raises(ValueError, lambda: ProductSet(Interval(0, 1)).as_relational(x, y))
+
+    Z2 = ProductSet(S.Integers, S.Integers)
+    assert Z2.contains((1, 2)) is S.true
+    assert Z2.contains((1,)) is S.false
+    assert Z2.contains(x) == Contains(x, Z2, evaluate=False)
+    assert Z2.contains(x).subs(x, 1) is S.false
+    assert Z2.contains((x, 1)).subs(x, 2) is S.true
+    assert Z2.contains((x, y)) == Contains(x, S.Integers) & Contains(y, S.Integers)
+    assert unchanged(Contains, (x, y), Z2)
+    assert Contains((1, 2), Z2) is S.true
+
+
+def test_ProductSet_of_single_arg_is_not_arg():
+    assert unchanged(ProductSet, Interval(0, 1))
+    assert unchanged(ProductSet, ProductSet(Interval(0, 1)))
+
+
+def test_ProductSet_is_empty():
+    assert ProductSet(S.Integers, S.Reals).is_empty == False
+    assert ProductSet(Interval(x, 1), S.Reals).is_empty == None
+
+
+def test_interval_subs():
+    a = Symbol('a', real=True)
+
+    assert Interval(0, a).subs(a, 2) == Interval(0, 2)
+    assert Interval(a, 0).subs(a, 2) == S.EmptySet
+
+
+def test_interval_to_mpi():
+    assert Interval(0, 1).to_mpi() == mpi(0, 1)
+    assert Interval(0, 1, True, False).to_mpi() == mpi(0, 1)
+    assert type(Interval(0, 1).to_mpi()) == type(mpi(0, 1))
+
+
+def test_set_evalf():
+    assert Interval(S(11)/64, S.Half).evalf() == Interval(
+        Float('0.171875'), Float('0.5'))
+    assert Interval(x, S.Half, right_open=True).evalf() == Interval(
+        x, Float('0.5'), right_open=True)
+    assert Interval(-oo, S.Half).evalf() == Interval(-oo, Float('0.5'))
+    assert FiniteSet(2, x).evalf() == FiniteSet(Float('2.0'), x)
+
+
+def test_measure():
+    a = Symbol('a', real=True)
+
+    assert Interval(1, 3).measure == 2
+    assert Interval(0, a).measure == a
+    assert Interval(1, a).measure == a - 1
+
+    assert Union(Interval(1, 2), Interval(3, 4)).measure == 2
+    assert Union(Interval(1, 2), Interval(3, 4), FiniteSet(5, 6, 7)).measure \
+        == 2
+
+    assert FiniteSet(1, 2, oo, a, -oo, -5).measure == 0
+
+    assert S.EmptySet.measure == 0
+
+    square = Interval(0, 10) * Interval(0, 10)
+    offsetsquare = Interval(5, 15) * Interval(5, 15)
+    band = Interval(-oo, oo) * Interval(2, 4)
+
+    assert square.measure == offsetsquare.measure == 100
+    assert (square + offsetsquare).measure == 175  # there is some overlap
+    assert (square - offsetsquare).measure == 75
+    assert (square * FiniteSet(1, 2, 3)).measure == 0
+    assert (square.intersect(band)).measure == 20
+    assert (square + band).measure is oo
+    assert (band * FiniteSet(1, 2, 3)).measure is nan
+
+
+def test_is_subset():
+    assert Interval(0, 1).is_subset(Interval(0, 2)) is True
+    assert Interval(0, 3).is_subset(Interval(0, 2)) is False
+    assert Interval(0, 1).is_subset(FiniteSet(0, 1)) is False
+
+    assert FiniteSet(1, 2).is_subset(FiniteSet(1, 2, 3, 4))
+    assert FiniteSet(4, 5).is_subset(FiniteSet(1, 2, 3, 4)) is False
+    assert FiniteSet(1).is_subset(Interval(0, 2))
+    assert FiniteSet(1, 2).is_subset(Interval(0, 2, True, True)) is False
+    assert (Interval(1, 2) + FiniteSet(3)).is_subset(
+        Interval(0, 2, False, True) + FiniteSet(2, 3))
+
+    assert Interval(3, 4).is_subset(Union(Interval(0, 1), Interval(2, 5))) is True
+    assert Interval(3, 6).is_subset(Union(Interval(0, 1), Interval(2, 5))) is False
+
+    assert FiniteSet(1, 2, 3, 4).is_subset(Interval(0, 5)) is True
+    assert S.EmptySet.is_subset(FiniteSet(1, 2, 3)) is True
+
+    assert Interval(0, 1).is_subset(S.EmptySet) is False
+    assert S.EmptySet.is_subset(S.EmptySet) is True
+
+    raises(ValueError, lambda: S.EmptySet.is_subset(1))
+
+    # tests for the issubset alias
+    assert FiniteSet(1, 2, 3, 4).issubset(Interval(0, 5)) is True
+    assert S.EmptySet.issubset(FiniteSet(1, 2, 3)) is True
+
+    assert S.Naturals.is_subset(S.Integers)
+    assert S.Naturals0.is_subset(S.Integers)
+
+    assert FiniteSet(x).is_subset(FiniteSet(y)) is None
+    assert FiniteSet(x).is_subset(FiniteSet(y).subs(y, x)) is True
+    assert FiniteSet(x).is_subset(FiniteSet(y).subs(y, x+1)) is False
+
+    assert Interval(0, 1).is_subset(Interval(0, 1, left_open=True)) is False
+    assert Interval(-2, 3).is_subset(Union(Interval(-oo, -2), Interval(3, oo))) is False
+
+    n = Symbol('n', integer=True)
+    assert Range(-3, 4, 1).is_subset(FiniteSet(-10, 10)) is False
+    assert Range(S(10)**100).is_subset(FiniteSet(0, 1, 2)) is False
+    assert Range(6, 0, -2).is_subset(FiniteSet(2, 4, 6)) is True
+    assert Range(1, oo).is_subset(FiniteSet(1, 2)) is False
+    assert Range(-oo, 1).is_subset(FiniteSet(1)) is False
+    assert Range(3).is_subset(FiniteSet(0, 1, n)) is None
+    assert Range(n, n + 2).is_subset(FiniteSet(n, n + 1)) is True
+    assert Range(5).is_subset(Interval(0, 4, right_open=True)) is False
+    #issue 19513
+    assert imageset(Lambda(n, 1/n), S.Integers).is_subset(S.Reals) is None
+
+def test_is_proper_subset():
+    assert Interval(0, 1).is_proper_subset(Interval(0, 2)) is True
+    assert Interval(0, 3).is_proper_subset(Interval(0, 2)) is False
+    assert S.EmptySet.is_proper_subset(FiniteSet(1, 2, 3)) is True
+
+    raises(ValueError, lambda: Interval(0, 1).is_proper_subset(0))
+
+
+def test_is_superset():
+    assert Interval(0, 1).is_superset(Interval(0, 2)) == False
+    assert Interval(0, 3).is_superset(Interval(0, 2))
+
+    assert FiniteSet(1, 2).is_superset(FiniteSet(1, 2, 3, 4)) == False
+    assert FiniteSet(4, 5).is_superset(FiniteSet(1, 2, 3, 4)) == False
+    assert FiniteSet(1).is_superset(Interval(0, 2)) == False
+    assert FiniteSet(1, 2).is_superset(Interval(0, 2, True, True)) == False
+    assert (Interval(1, 2) + FiniteSet(3)).is_superset(
+        Interval(0, 2, False, True) + FiniteSet(2, 3)) == False
+
+    assert Interval(3, 4).is_superset(Union(Interval(0, 1), Interval(2, 5))) == False
+
+    assert FiniteSet(1, 2, 3, 4).is_superset(Interval(0, 5)) == False
+    assert S.EmptySet.is_superset(FiniteSet(1, 2, 3)) == False
+
+    assert Interval(0, 1).is_superset(S.EmptySet) == True
+    assert S.EmptySet.is_superset(S.EmptySet) == True
+
+    raises(ValueError, lambda: S.EmptySet.is_superset(1))
+
+    # tests for the issuperset alias
+    assert Interval(0, 1).issuperset(S.EmptySet) == True
+    assert S.EmptySet.issuperset(S.EmptySet) == True
+
+
+def test_is_proper_superset():
+    assert Interval(0, 1).is_proper_superset(Interval(0, 2)) is False
+    assert Interval(0, 3).is_proper_superset(Interval(0, 2)) is True
+    assert FiniteSet(1, 2, 3).is_proper_superset(S.EmptySet) is True
+
+    raises(ValueError, lambda: Interval(0, 1).is_proper_superset(0))
+
+
+def test_contains():
+    assert Interval(0, 2).contains(1) is S.true
+    assert Interval(0, 2).contains(3) is S.false
+    assert Interval(0, 2, True, False).contains(0) is S.false
+    assert Interval(0, 2, True, False).contains(2) is S.true
+    assert Interval(0, 2, False, True).contains(0) is S.true
+    assert Interval(0, 2, False, True).contains(2) is S.false
+    assert Interval(0, 2, True, True).contains(0) is S.false
+    assert Interval(0, 2, True, True).contains(2) is S.false
+
+    assert (Interval(0, 2) in Interval(0, 2)) is False
+
+    assert FiniteSet(1, 2, 3).contains(2) is S.true
+    assert FiniteSet(1, 2, Symbol('x')).contains(Symbol('x')) is S.true
+
+    assert FiniteSet(y)._contains(x) == Eq(y, x, evaluate=False)
+    raises(TypeError, lambda: x in FiniteSet(y))
+    assert FiniteSet({x, y})._contains({x}) == Eq({x, y}, {x}, evaluate=False)
+    assert FiniteSet({x, y}).subs(y, x)._contains({x}) is S.true
+    assert FiniteSet({x, y}).subs(y, x+1)._contains({x}) is S.false
+
+    # issue 8197
+    from sympy.abc import a, b
+    assert FiniteSet(b).contains(-a) == Eq(b, -a)
+    assert FiniteSet(b).contains(a) == Eq(b, a)
+    assert FiniteSet(a).contains(1) == Eq(a, 1)
+    raises(TypeError, lambda: 1 in FiniteSet(a))
+
+    # issue 8209
+    rad1 = Pow(Pow(2, Rational(1, 3)) - 1, Rational(1, 3))
+    rad2 = Pow(Rational(1, 9), Rational(1, 3)) - Pow(Rational(2, 9), Rational(1, 3)) + Pow(Rational(4, 9), Rational(1, 3))
+    s1 = FiniteSet(rad1)
+    s2 = FiniteSet(rad2)
+    assert s1 - s2 == S.EmptySet
+
+    items = [1, 2, S.Infinity, S('ham'), -1.1]
+    fset = FiniteSet(*items)
+    assert all(item in fset for item in items)
+    assert all(fset.contains(item) is S.true for item in items)
+
+    assert Union(Interval(0, 1), Interval(2, 5)).contains(3) is S.true
+    assert Union(Interval(0, 1), Interval(2, 5)).contains(6) is S.false
+    assert Union(Interval(0, 1), FiniteSet(2, 5)).contains(3) is S.false
+
+    assert S.EmptySet.contains(1) is S.false
+    assert FiniteSet(rootof(x**3 + x - 1, 0)).contains(S.Infinity) is S.false
+
+    assert rootof(x**5 + x**3 + 1, 0) in S.Reals
+    assert not rootof(x**5 + x**3 + 1, 1) in S.Reals
+
+    # non-bool results
+    assert Union(Interval(1, 2), Interval(3, 4)).contains(x) == \
+        Or(And(S.One <= x, x <= 2), And(S(3) <= x, x <= 4))
+    assert Intersection(Interval(1, x), Interval(2, 3)).contains(y) == \
+        And(y <= 3, y <= x, S.One <= y, S(2) <= y)
+
+    assert (S.Complexes).contains(S.ComplexInfinity) == S.false
+
+
+def test_interval_symbolic():
+    x = Symbol('x')
+    e = Interval(0, 1)
+    assert e.contains(x) == And(S.Zero <= x, x <= 1)
+    raises(TypeError, lambda: x in e)
+    e = Interval(0, 1, True, True)
+    assert e.contains(x) == And(S.Zero < x, x < 1)
+    c = Symbol('c', real=False)
+    assert Interval(x, x + 1).contains(c) == False
+    e = Symbol('e', extended_real=True)
+    assert Interval(-oo, oo).contains(e) == And(
+        S.NegativeInfinity < e, e < S.Infinity)
+
+
+def test_union_contains():
+    x = Symbol('x')
+    i1 = Interval(0, 1)
+    i2 = Interval(2, 3)
+    i3 = Union(i1, i2)
+    assert i3.as_relational(x) == Or(And(S.Zero <= x, x <= 1), And(S(2) <= x, x <= 3))
+    raises(TypeError, lambda: x in i3)
+    e = i3.contains(x)
+    assert e == i3.as_relational(x)
+    assert e.subs(x, -0.5) is false
+    assert e.subs(x, 0.5) is true
+    assert e.subs(x, 1.5) is false
+    assert e.subs(x, 2.5) is true
+    assert e.subs(x, 3.5) is false
+
+    U = Interval(0, 2, True, True) + Interval(10, oo) + FiniteSet(-1, 2, 5, 6)
+    assert all(el not in U for el in [0, 4, -oo])
+    assert all(el in U for el in [2, 5, 10])
+
+
+def test_is_number():
+    assert Interval(0, 1).is_number is False
+    assert Set().is_number is False
+
+
+def test_Interval_is_left_unbounded():
+    assert Interval(3, 4).is_left_unbounded is False
+    assert Interval(-oo, 3).is_left_unbounded is True
+    assert Interval(Float("-inf"), 3).is_left_unbounded is True
+
+
+def test_Interval_is_right_unbounded():
+    assert Interval(3, 4).is_right_unbounded is False
+    assert Interval(3, oo).is_right_unbounded is True
+    assert Interval(3, Float("+inf")).is_right_unbounded is True
+
+
+def test_Interval_as_relational():
+    x = Symbol('x')
+
+    assert Interval(-1, 2, False, False).as_relational(x) == \
+        And(Le(-1, x), Le(x, 2))
+    assert Interval(-1, 2, True, False).as_relational(x) == \
+        And(Lt(-1, x), Le(x, 2))
+    assert Interval(-1, 2, False, True).as_relational(x) == \
+        And(Le(-1, x), Lt(x, 2))
+    assert Interval(-1, 2, True, True).as_relational(x) == \
+        And(Lt(-1, x), Lt(x, 2))
+
+    assert Interval(-oo, 2, right_open=False).as_relational(x) == And(Lt(-oo, x), Le(x, 2))
+    assert Interval(-oo, 2, right_open=True).as_relational(x) == And(Lt(-oo, x), Lt(x, 2))
+
+    assert Interval(-2, oo, left_open=False).as_relational(x) == And(Le(-2, x), Lt(x, oo))
+    assert Interval(-2, oo, left_open=True).as_relational(x) == And(Lt(-2, x), Lt(x, oo))
+
+    assert Interval(-oo, oo).as_relational(x) == And(Lt(-oo, x), Lt(x, oo))
+    x = Symbol('x', real=True)
+    y = Symbol('y', real=True)
+    assert Interval(x, y).as_relational(x) == (x <= y)
+    assert Interval(y, x).as_relational(x) == (y <= x)
+
+
+def test_Finite_as_relational():
+    x = Symbol('x')
+    y = Symbol('y')
+
+    assert FiniteSet(1, 2).as_relational(x) == Or(Eq(x, 1), Eq(x, 2))
+    assert FiniteSet(y, -5).as_relational(x) == Or(Eq(x, y), Eq(x, -5))
+
+
+def test_Union_as_relational():
+    x = Symbol('x')
+    assert (Interval(0, 1) + FiniteSet(2)).as_relational(x) == \
+        Or(And(Le(0, x), Le(x, 1)), Eq(x, 2))
+    assert (Interval(0, 1, True, True) + FiniteSet(1)).as_relational(x) == \
+        And(Lt(0, x), Le(x, 1))
+    assert Or(x < 0, x > 0).as_set().as_relational(x) == \
+        And((x > -oo), (x < oo), Ne(x, 0))
+    assert (Interval.Ropen(1, 3) + Interval.Lopen(3, 5)
+        ).as_relational(x) == And(Ne(x,3),(x>=1),(x<=5))
+
+
+def test_Intersection_as_relational():
+    x = Symbol('x')
+    assert (Intersection(Interval(0, 1), FiniteSet(2),
+            evaluate=False).as_relational(x)
+            == And(And(Le(0, x), Le(x, 1)), Eq(x, 2)))
+
+
+def test_Complement_as_relational():
+    x = Symbol('x')
+    expr = Complement(Interval(0, 1), FiniteSet(2), evaluate=False)
+    assert expr.as_relational(x) == \
+        And(Le(0, x), Le(x, 1), Ne(x, 2))
+
+
+@XFAIL
+def test_Complement_as_relational_fail():
+    x = Symbol('x')
+    expr = Complement(Interval(0, 1), FiniteSet(2), evaluate=False)
+    # XXX This example fails because 0 <= x changes to x >= 0
+    # during the evaluation.
+    assert expr.as_relational(x) == \
+            (0 <= x) & (x <= 1) & Ne(x, 2)
+
+
+def test_SymmetricDifference_as_relational():
+    x = Symbol('x')
+    expr = SymmetricDifference(Interval(0, 1), FiniteSet(2), evaluate=False)
+    assert expr.as_relational(x) == Xor(Eq(x, 2), Le(0, x) & Le(x, 1))
+
+
+def test_EmptySet():
+    assert S.EmptySet.as_relational(Symbol('x')) is S.false
+    assert S.EmptySet.intersect(S.UniversalSet) == S.EmptySet
+    assert S.EmptySet.boundary == S.EmptySet
+
+
+def test_finite_basic():
+    x = Symbol('x')
+    A = FiniteSet(1, 2, 3)
+    B = FiniteSet(3, 4, 5)
+    AorB = Union(A, B)
+    AandB = A.intersect(B)
+    assert A.is_subset(AorB) and B.is_subset(AorB)
+    assert AandB.is_subset(A)
+    assert AandB == FiniteSet(3)
+
+    assert A.inf == 1 and A.sup == 3
+    assert AorB.inf == 1 and AorB.sup == 5
+    assert FiniteSet(x, 1, 5).sup == Max(x, 5)
+    assert FiniteSet(x, 1, 5).inf == Min(x, 1)
+
+    # issue 7335
+    assert FiniteSet(S.EmptySet) != S.EmptySet
+    assert FiniteSet(FiniteSet(1, 2, 3)) != FiniteSet(1, 2, 3)
+    assert FiniteSet((1, 2, 3)) != FiniteSet(1, 2, 3)
+
+    # Ensure a variety of types can exist in a FiniteSet
+    assert FiniteSet((1, 2), A, -5, x, 'eggs', x**2)
+
+    assert (A > B) is False
+    assert (A >= B) is False
+    assert (A < B) is False
+    assert (A <= B) is False
+    assert AorB > A and AorB > B
+    assert AorB >= A and AorB >= B
+    assert A >= A and A <= A
+    assert A >= AandB and B >= AandB
+    assert A > AandB and B > AandB
+
+
+def test_product_basic():
+    H, T = 'H', 'T'
+    unit_line = Interval(0, 1)
+    d6 = FiniteSet(1, 2, 3, 4, 5, 6)
+    d4 = FiniteSet(1, 2, 3, 4)
+    coin = FiniteSet(H, T)
+
+    square = unit_line * unit_line
+
+    assert (0, 0) in square
+    assert 0 not in square
+    assert (H, T) in coin ** 2
+    assert (.5, .5, .5) in (square * unit_line).flatten()
+    assert ((.5, .5), .5) in square * unit_line
+    assert (H, 3, 3) in (coin * d6 * d6).flatten()
+    assert ((H, 3), 3) in coin * d6 * d6
+    HH, TT = sympify(H), sympify(T)
+    assert set(coin**2) == {(HH, HH), (HH, TT), (TT, HH), (TT, TT)}
+
+    assert (d4*d4).is_subset(d6*d6)
+
+    assert square.complement(Interval(-oo, oo)*Interval(-oo, oo)) == Union(
+        (Interval(-oo, 0, True, True) +
+         Interval(1, oo, True, True))*Interval(-oo, oo),
+         Interval(-oo, oo)*(Interval(-oo, 0, True, True) +
+                  Interval(1, oo, True, True)))
+
+    assert (Interval(-5, 5)**3).is_subset(Interval(-10, 10)**3)
+    assert not (Interval(-10, 10)**3).is_subset(Interval(-5, 5)**3)
+    assert not (Interval(-5, 5)**2).is_subset(Interval(-10, 10)**3)
+
+    assert (Interval(.2, .5)*FiniteSet(.5)).is_subset(square)  # segment in square
+
+    assert len(coin*coin*coin) == 8
+    assert len(S.EmptySet*S.EmptySet) == 0
+    assert len(S.EmptySet*coin) == 0
+    raises(TypeError, lambda: len(coin*Interval(0, 2)))
+
+
+def test_real():
+    x = Symbol('x', real=True)
+
+    I = Interval(0, 5)
+    J = Interval(10, 20)
+    A = FiniteSet(1, 2, 30, x, S.Pi)
+    B = FiniteSet(-4, 0)
+    C = FiniteSet(100)
+    D = FiniteSet('Ham', 'Eggs')
+
+    assert all(s.is_subset(S.Reals) for s in [I, J, A, B, C])
+    assert not D.is_subset(S.Reals)
+    assert all((a + b).is_subset(S.Reals) for a in [I, J, A, B, C] for b in [I, J, A, B, C])
+    assert not any((a + D).is_subset(S.Reals) for a in [I, J, A, B, C, D])
+
+    assert not (I + A + D).is_subset(S.Reals)
+
+
+def test_supinf():
+    x = Symbol('x', real=True)
+    y = Symbol('y', real=True)
+
+    assert (Interval(0, 1) + FiniteSet(2)).sup == 2
+    assert (Interval(0, 1) + FiniteSet(2)).inf == 0
+    assert (Interval(0, 1) + FiniteSet(x)).sup == Max(1, x)
+    assert (Interval(0, 1) + FiniteSet(x)).inf == Min(0, x)
+    assert FiniteSet(5, 1, x).sup == Max(5, x)
+    assert FiniteSet(5, 1, x).inf == Min(1, x)
+    assert FiniteSet(5, 1, x, y).sup == Max(5, x, y)
+    assert FiniteSet(5, 1, x, y).inf == Min(1, x, y)
+    assert FiniteSet(5, 1, x, y, S.Infinity, S.NegativeInfinity).sup == \
+        S.Infinity
+    assert FiniteSet(5, 1, x, y, S.Infinity, S.NegativeInfinity).inf == \
+        S.NegativeInfinity
+    assert FiniteSet('Ham', 'Eggs').sup == Max('Ham', 'Eggs')
+
+
+def test_universalset():
+    U = S.UniversalSet
+    x = Symbol('x')
+    assert U.as_relational(x) is S.true
+    assert U.union(Interval(2, 4)) == U
+
+    assert U.intersect(Interval(2, 4)) == Interval(2, 4)
+    assert U.measure is S.Infinity
+    assert U.boundary == S.EmptySet
+    assert U.contains(0) is S.true
+
+
+def test_Union_of_ProductSets_shares():
+    line = Interval(0, 2)
+    points = FiniteSet(0, 1, 2)
+    assert Union(line * line, line * points) == line * line
+
+
+def test_Interval_free_symbols():
+    # issue 6211
+    assert Interval(0, 1).free_symbols == set()
+    x = Symbol('x', real=True)
+    assert Interval(0, x).free_symbols == {x}
+
+
+def test_image_interval():
+    x = Symbol('x', real=True)
+    a = Symbol('a', real=True)
+    assert imageset(x, 2*x, Interval(-2, 1)) == Interval(-4, 2)
+    assert imageset(x, 2*x, Interval(-2, 1, True, False)) == \
+        Interval(-4, 2, True, False)
+    assert imageset(x, x**2, Interval(-2, 1, True, False)) == \
+        Interval(0, 4, False, True)
+    assert imageset(x, x**2, Interval(-2, 1)) == Interval(0, 4)
+    assert imageset(x, x**2, Interval(-2, 1, True, False)) == \
+        Interval(0, 4, False, True)
+    assert imageset(x, x**2, Interval(-2, 1, True, True)) == \
+        Interval(0, 4, False, True)
+    assert imageset(x, (x - 2)**2, Interval(1, 3)) == Interval(0, 1)
+    assert imageset(x, 3*x**4 - 26*x**3 + 78*x**2 - 90*x, Interval(0, 4)) == \
+        Interval(-35, 0)  # Multiple Maxima
+    assert imageset(x, x + 1/x, Interval(-oo, oo)) == Interval(-oo, -2) \
+        + Interval(2, oo)  # Single Infinite discontinuity
+    assert imageset(x, 1/x + 1/(x-1)**2, Interval(0, 2, True, False)) == \
+        Interval(Rational(3, 2), oo, False)  # Multiple Infinite discontinuities
+
+    # Test for Python lambda
+    assert imageset(lambda x: 2*x, Interval(-2, 1)) == Interval(-4, 2)
+
+    assert imageset(Lambda(x, a*x), Interval(0, 1)) == \
+            ImageSet(Lambda(x, a*x), Interval(0, 1))
+
+    assert imageset(Lambda(x, sin(cos(x))), Interval(0, 1)) == \
+            ImageSet(Lambda(x, sin(cos(x))), Interval(0, 1))
+
+
+def test_image_piecewise():
+    f = Piecewise((x, x <= -1), (1/x**2, x <= 5), (x**3, True))
+    f1 = Piecewise((0, x <= 1), (1, x <= 2), (2, True))
+    assert imageset(x, f, Interval(-5, 5)) == Union(Interval(-5, -1), Interval(Rational(1, 25), oo))
+    assert imageset(x, f1, Interval(1, 2)) == FiniteSet(0, 1)
+
+
+@XFAIL  # See: https://github.com/sympy/sympy/pull/2723#discussion_r8659826
+def test_image_Intersection():
+    x = Symbol('x', real=True)
+    y = Symbol('y', real=True)
+    assert imageset(x, x**2, Interval(-2, 0).intersect(Interval(x, y))) == \
+           Interval(0, 4).intersect(Interval(Min(x**2, y**2), Max(x**2, y**2)))
+
+
+def test_image_FiniteSet():
+    x = Symbol('x', real=True)
+    assert imageset(x, 2*x, FiniteSet(1, 2, 3)) == FiniteSet(2, 4, 6)
+
+
+def test_image_Union():
+    x = Symbol('x', real=True)
+    assert imageset(x, x**2, Interval(-2, 0) + FiniteSet(1, 2, 3)) == \
+            (Interval(0, 4) + FiniteSet(9))
+
+
+def test_image_EmptySet():
+    x = Symbol('x', real=True)
+    assert imageset(x, 2*x, S.EmptySet) == S.EmptySet
+
+
+def test_issue_5724_7680():
+    assert I not in S.Reals  # issue 7680
+    assert Interval(-oo, oo).contains(I) is S.false
+
+
+def test_boundary():
+    assert FiniteSet(1).boundary == FiniteSet(1)
+    assert all(Interval(0, 1, left_open, right_open).boundary == FiniteSet(0, 1)
+            for left_open in (true, false) for right_open in (true, false))
+
+
+def test_boundary_Union():
+    assert (Interval(0, 1) + Interval(2, 3)).boundary == FiniteSet(0, 1, 2, 3)
+    assert ((Interval(0, 1, False, True)
+           + Interval(1, 2, True, False)).boundary == FiniteSet(0, 1, 2))
+
+    assert (Interval(0, 1) + FiniteSet(2)).boundary == FiniteSet(0, 1, 2)
+    assert Union(Interval(0, 10), Interval(5, 15), evaluate=False).boundary \
+            == FiniteSet(0, 15)
+
+    assert Union(Interval(0, 10), Interval(0, 1), evaluate=False).boundary \
+            == FiniteSet(0, 10)
+    assert Union(Interval(0, 10, True, True),
+                 Interval(10, 15, True, True), evaluate=False).boundary \
+            == FiniteSet(0, 10, 15)
+
+
+@XFAIL
+def test_union_boundary_of_joining_sets():
+    """ Testing the boundary of unions is a hard problem """
+    assert Union(Interval(0, 10), Interval(10, 15), evaluate=False).boundary \
+            == FiniteSet(0, 15)
+
+
+def test_boundary_ProductSet():
+    open_square = Interval(0, 1, True, True) ** 2
+    assert open_square.boundary == (FiniteSet(0, 1) * Interval(0, 1)
+                                  + Interval(0, 1) * FiniteSet(0, 1))
+
+    second_square = Interval(1, 2, True, True) * Interval(0, 1, True, True)
+    assert (open_square + second_square).boundary == (
+                FiniteSet(0, 1) * Interval(0, 1)
+              + FiniteSet(1, 2) * Interval(0, 1)
+              + Interval(0, 1) * FiniteSet(0, 1)
+              + Interval(1, 2) * FiniteSet(0, 1))
+
+
+def test_boundary_ProductSet_line():
+    line_in_r2 = Interval(0, 1) * FiniteSet(0)
+    assert line_in_r2.boundary == line_in_r2
+
+
+def test_is_open():
+    assert Interval(0, 1, False, False).is_open is False
+    assert Interval(0, 1, True, False).is_open is False
+    assert Interval(0, 1, True, True).is_open is True
+    assert FiniteSet(1, 2, 3).is_open is False
+
+
+def test_is_closed():
+    assert Interval(0, 1, False, False).is_closed is True
+    assert Interval(0, 1, True, False).is_closed is False
+    assert FiniteSet(1, 2, 3).is_closed is True
+
+
+def test_closure():
+    assert Interval(0, 1, False, True).closure == Interval(0, 1, False, False)
+
+
+def test_interior():
+    assert Interval(0, 1, False, True).interior == Interval(0, 1, True, True)
+
+
+def test_issue_7841():
+    raises(TypeError, lambda: x in S.Reals)
+
+
+def test_Eq():
+    assert Eq(Interval(0, 1), Interval(0, 1))
+    assert Eq(Interval(0, 1), Interval(0, 2)) == False
+
+    s1 = FiniteSet(0, 1)
+    s2 = FiniteSet(1, 2)
+
+    assert Eq(s1, s1)
+    assert Eq(s1, s2) == False
+
+    assert Eq(s1*s2, s1*s2)
+    assert Eq(s1*s2, s2*s1) == False
+
+    assert unchanged(Eq, FiniteSet({x, y}), FiniteSet({x}))
+    assert Eq(FiniteSet({x, y}).subs(y, x), FiniteSet({x})) is S.true
+    assert Eq(FiniteSet({x, y}), FiniteSet({x})).subs(y, x) is S.true
+    assert Eq(FiniteSet({x, y}).subs(y, x+1), FiniteSet({x})) is S.false
+    assert Eq(FiniteSet({x, y}), FiniteSet({x})).subs(y, x+1) is S.false
+
+    assert Eq(ProductSet({1}, {2}), Interval(1, 2)) is S.false
+    assert Eq(ProductSet({1}), ProductSet({1}, {2})) is S.false
+
+    assert Eq(FiniteSet(()), FiniteSet(1)) is S.false
+    assert Eq(ProductSet(), FiniteSet(1)) is S.false
+
+    i1 = Interval(0, 1)
+    i2 = Interval(x, y)
+    assert unchanged(Eq, ProductSet(i1, i1), ProductSet(i2, i2))
+
+
+def test_SymmetricDifference():
+    A = FiniteSet(0, 1, 2, 3, 4, 5)
+    B = FiniteSet(2, 4, 6, 8, 10)
+    C = Interval(8, 10)
+
+    assert SymmetricDifference(A, B, evaluate=False).is_iterable is True
+    assert SymmetricDifference(A, C, evaluate=False).is_iterable is None
+    assert FiniteSet(*SymmetricDifference(A, B, evaluate=False)) == \
+        FiniteSet(0, 1, 3, 5, 6, 8, 10)
+    raises(TypeError,
+        lambda: FiniteSet(*SymmetricDifference(A, C, evaluate=False)))
+
+    assert SymmetricDifference(FiniteSet(0, 1, 2, 3, 4, 5), \
+            FiniteSet(2, 4, 6, 8, 10)) == FiniteSet(0, 1, 3, 5, 6, 8, 10)
+    assert SymmetricDifference(FiniteSet(2, 3, 4), FiniteSet(2, 3, 4 ,5)) \
+            == FiniteSet(5)
+    assert FiniteSet(1, 2, 3, 4, 5) ^ FiniteSet(1, 2, 5, 6) == \
+            FiniteSet(3, 4, 6)
+    assert Set(S(1), S(2), S(3)) ^ Set(S(2), S(3), S(4)) == Union(Set(S(1), S(2), S(3)) - Set(S(2), S(3), S(4)), \
+            Set(S(2), S(3), S(4)) - Set(S(1), S(2), S(3)))
+    assert Interval(0, 4) ^ Interval(2, 5) == Union(Interval(0, 4) - \
+            Interval(2, 5), Interval(2, 5) - Interval(0, 4))
+
+
+def test_issue_9536():
+    from sympy.functions.elementary.exponential import log
+    a = Symbol('a', real=True)
+    assert FiniteSet(log(a)).intersect(S.Reals) == Intersection(S.Reals, FiniteSet(log(a)))
+
+
+def test_issue_9637():
+    n = Symbol('n')
+    a = FiniteSet(n)
+    b = FiniteSet(2, n)
+    assert Complement(S.Reals, a) == Complement(S.Reals, a, evaluate=False)
+    assert Complement(Interval(1, 3), a) == Complement(Interval(1, 3), a, evaluate=False)
+    assert Complement(Interval(1, 3), b) == \
+        Complement(Union(Interval(1, 2, False, True), Interval(2, 3, True, False)), a)
+    assert Complement(a, S.Reals) == Complement(a, S.Reals, evaluate=False)
+    assert Complement(a, Interval(1, 3)) == Complement(a, Interval(1, 3), evaluate=False)
+
+
+def test_issue_9808():
+    # See https://github.com/sympy/sympy/issues/16342
+    assert Complement(FiniteSet(y), FiniteSet(1)) == Complement(FiniteSet(y), FiniteSet(1), evaluate=False)
+    assert Complement(FiniteSet(1, 2, x), FiniteSet(x, y, 2, 3)) == \
+        Complement(FiniteSet(1), FiniteSet(y), evaluate=False)
+
+
+def test_issue_9956():
+    assert Union(Interval(-oo, oo), FiniteSet(1)) == Interval(-oo, oo)
+    assert Interval(-oo, oo).contains(1) is S.true
+
+
+def test_issue_Symbol_inter():
+    i = Interval(0, oo)
+    r = S.Reals
+    mat = Matrix([0, 0, 0])
+    assert Intersection(r, i, FiniteSet(m), FiniteSet(m, n)) == \
+        Intersection(i, FiniteSet(m))
+    assert Intersection(FiniteSet(1, m, n), FiniteSet(m, n, 2), i) == \
+        Intersection(i, FiniteSet(m, n))
+    assert Intersection(FiniteSet(m, n, x), FiniteSet(m, z), r) == \
+        Intersection(Intersection({m, z}, {m, n, x}), r)
+    assert Intersection(FiniteSet(m, n, 3), FiniteSet(m, n, x), r) == \
+        Intersection(FiniteSet(3, m, n), FiniteSet(m, n, x), r, evaluate=False)
+    assert Intersection(FiniteSet(m, n, 3), FiniteSet(m, n, 2, 3), r) == \
+        Intersection(FiniteSet(3, m, n), r)
+    assert Intersection(r, FiniteSet(mat, 2, n), FiniteSet(0, mat, n)) == \
+        Intersection(r, FiniteSet(n))
+    assert Intersection(FiniteSet(sin(x), cos(x)), FiniteSet(sin(x), cos(x), 1), r) == \
+        Intersection(r, FiniteSet(sin(x), cos(x)))
+    assert Intersection(FiniteSet(x**2, 1, sin(x)), FiniteSet(x**2, 2, sin(x)), r) == \
+        Intersection(r, FiniteSet(x**2, sin(x)))
+
+
+def test_issue_11827():
+    assert S.Naturals0**4
+
+
+def test_issue_10113():
+    f = x**2/(x**2 - 4)
+    assert imageset(x, f, S.Reals) == Union(Interval(-oo, 0), Interval(1, oo, True, True))
+    assert imageset(x, f, Interval(-2, 2)) == Interval(-oo, 0)
+    assert imageset(x, f, Interval(-2, 3)) == Union(Interval(-oo, 0), Interval(Rational(9, 5), oo))
+
+
+def test_issue_10248():
+    raises(
+        TypeError, lambda: list(Intersection(S.Reals, FiniteSet(x)))
+    )
+    A = Symbol('A', real=True)
+    assert list(Intersection(S.Reals, FiniteSet(A))) == [A]
+
+
+def test_issue_9447():
+    a = Interval(0, 1) + Interval(2, 3)
+    assert Complement(S.UniversalSet, a) == Complement(
+            S.UniversalSet, Union(Interval(0, 1), Interval(2, 3)), evaluate=False)
+    assert Complement(S.Naturals, a) == Complement(
+            S.Naturals, Union(Interval(0, 1), Interval(2, 3)), evaluate=False)
+
+
+def test_issue_10337():
+    assert (FiniteSet(2) == 3) is False
+    assert (FiniteSet(2) != 3) is True
+    raises(TypeError, lambda: FiniteSet(2) < 3)
+    raises(TypeError, lambda: FiniteSet(2) <= 3)
+    raises(TypeError, lambda: FiniteSet(2) > 3)
+    raises(TypeError, lambda: FiniteSet(2) >= 3)
+
+
+def test_issue_10326():
+    bad = [
+        EmptySet,
+        FiniteSet(1),
+        Interval(1, 2),
+        S.ComplexInfinity,
+        S.ImaginaryUnit,
+        S.Infinity,
+        S.NaN,
+        S.NegativeInfinity,
+        ]
+    interval = Interval(0, 5)
+    for i in bad:
+        assert i not in interval
+
+    x = Symbol('x', real=True)
+    nr = Symbol('nr', extended_real=False)
+    assert x + 1 in Interval(x, x + 4)
+    assert nr not in Interval(x, x + 4)
+    assert Interval(1, 2) in FiniteSet(Interval(0, 5), Interval(1, 2))
+    assert Interval(-oo, oo).contains(oo) is S.false
+    assert Interval(-oo, oo).contains(-oo) is S.false
+
+
+def test_issue_2799():
+    U = S.UniversalSet
+    a = Symbol('a', real=True)
+    inf_interval = Interval(a, oo)
+    R = S.Reals
+
+    assert U + inf_interval == inf_interval + U
+    assert U + R == R + U
+    assert R + inf_interval == inf_interval + R
+
+
+def test_issue_9706():
+    assert Interval(-oo, 0).closure == Interval(-oo, 0, True, False)
+    assert Interval(0, oo).closure == Interval(0, oo, False, True)
+    assert Interval(-oo, oo).closure == Interval(-oo, oo)
+
+
+def test_issue_8257():
+    reals_plus_infinity = Union(Interval(-oo, oo), FiniteSet(oo))
+    reals_plus_negativeinfinity = Union(Interval(-oo, oo), FiniteSet(-oo))
+    assert Interval(-oo, oo) + FiniteSet(oo) == reals_plus_infinity
+    assert FiniteSet(oo) + Interval(-oo, oo) == reals_plus_infinity
+    assert Interval(-oo, oo) + FiniteSet(-oo) == reals_plus_negativeinfinity
+    assert FiniteSet(-oo) + Interval(-oo, oo) == reals_plus_negativeinfinity
+
+
+def test_issue_10931():
+    assert S.Integers - S.Integers == EmptySet
+    assert S.Integers - S.Reals == EmptySet
+
+
+def test_issue_11174():
+    soln = Intersection(Interval(-oo, oo), FiniteSet(-x), evaluate=False)
+    assert Intersection(FiniteSet(-x), S.Reals) == soln
+
+    soln = Intersection(S.Reals, FiniteSet(x), evaluate=False)
+    assert Intersection(FiniteSet(x), S.Reals) == soln
+
+
+def test_issue_18505():
+    assert ImageSet(Lambda(n, sqrt(pi*n/2 - 1 + pi/2)), S.Integers).contains(0) == \
+            Contains(0, ImageSet(Lambda(n, sqrt(pi*n/2 - 1 + pi/2)), S.Integers))
+
+
+def test_finite_set_intersection():
+    # The following should not produce recursion errors
+    # Note: some of these are not completely correct. See
+    # https://github.com/sympy/sympy/issues/16342.
+    assert Intersection(FiniteSet(-oo, x), FiniteSet(x)) == FiniteSet(x)
+    assert Intersection._handle_finite_sets([FiniteSet(-oo, x), FiniteSet(0, x)]) == FiniteSet(x)
+
+    assert Intersection._handle_finite_sets([FiniteSet(-oo, x), FiniteSet(x)]) == FiniteSet(x)
+    assert Intersection._handle_finite_sets([FiniteSet(2, 3, x, y), FiniteSet(1, 2, x)]) == \
+        Intersection._handle_finite_sets([FiniteSet(1, 2, x), FiniteSet(2, 3, x, y)]) == \
+        Intersection(FiniteSet(1, 2, x), FiniteSet(2, 3, x, y)) == \
+        Intersection(FiniteSet(1, 2, x), FiniteSet(2, x, y))
+
+    assert FiniteSet(1+x-y) & FiniteSet(1) == \
+        FiniteSet(1) & FiniteSet(1+x-y) == \
+        Intersection(FiniteSet(1+x-y), FiniteSet(1), evaluate=False)
+
+    assert FiniteSet(1) & FiniteSet(x) == FiniteSet(x) & FiniteSet(1) == \
+        Intersection(FiniteSet(1), FiniteSet(x), evaluate=False)
+
+    assert FiniteSet({x}) & FiniteSet({x, y}) == \
+        Intersection(FiniteSet({x}), FiniteSet({x, y}), evaluate=False)
+
+
+def test_union_intersection_constructor():
+    # The actual exception does not matter here, so long as these fail
+    sets = [FiniteSet(1), FiniteSet(2)]
+    raises(Exception, lambda: Union(sets))
+    raises(Exception, lambda: Intersection(sets))
+    raises(Exception, lambda: Union(tuple(sets)))
+    raises(Exception, lambda: Intersection(tuple(sets)))
+    raises(Exception, lambda: Union(i for i in sets))
+    raises(Exception, lambda: Intersection(i for i in sets))
+
+    # Python sets are treated the same as FiniteSet
+    # The union of a single set (of sets) is the set (of sets) itself
+    assert Union(set(sets)) == FiniteSet(*sets)
+    assert Intersection(set(sets)) == FiniteSet(*sets)
+
+    assert Union({1}, {2}) == FiniteSet(1, 2)
+    assert Intersection({1, 2}, {2, 3}) == FiniteSet(2)
+
+
+def test_Union_contains():
+    assert zoo not in Union(
+        Interval.open(-oo, 0), Interval.open(0, oo))
+
+
+@XFAIL
+def test_issue_16878b():
+    # in intersection_sets for (ImageSet, Set) there is no code
+    # that handles the base_set of S.Reals like there is
+    # for Integers
+    assert imageset(x, (x, x), S.Reals).is_subset(S.Reals**2) is True
+
+def test_DisjointUnion():
+    assert DisjointUnion(FiniteSet(1, 2, 3), FiniteSet(1, 2, 3), FiniteSet(1, 2, 3)).rewrite(Union) == (FiniteSet(1, 2, 3) * FiniteSet(0, 1, 2))
+    assert DisjointUnion(Interval(1, 3), Interval(2, 4)).rewrite(Union) == Union(Interval(1, 3) * FiniteSet(0), Interval(2, 4) * FiniteSet(1))
+    assert DisjointUnion(Interval(0, 5), Interval(0, 5)).rewrite(Union) == Union(Interval(0, 5) * FiniteSet(0), Interval(0, 5) * FiniteSet(1))
+    assert DisjointUnion(Interval(-1, 2), S.EmptySet, S.EmptySet).rewrite(Union) == Interval(-1, 2) * FiniteSet(0)
+    assert DisjointUnion(Interval(-1, 2)).rewrite(Union) == Interval(-1, 2) * FiniteSet(0)
+    assert DisjointUnion(S.EmptySet, Interval(-1, 2), S.EmptySet).rewrite(Union) == Interval(-1, 2) * FiniteSet(1)
+    assert DisjointUnion(Interval(-oo, oo)).rewrite(Union) == Interval(-oo, oo) * FiniteSet(0)
+    assert DisjointUnion(S.EmptySet).rewrite(Union) == S.EmptySet
+    assert DisjointUnion().rewrite(Union) == S.EmptySet
+    raises(TypeError, lambda: DisjointUnion(Symbol('n')))
+
+    x = Symbol("x")
+    y = Symbol("y")
+    z = Symbol("z")
+    assert DisjointUnion(FiniteSet(x), FiniteSet(y, z)).rewrite(Union) == (FiniteSet(x) * FiniteSet(0)) + (FiniteSet(y, z) * FiniteSet(1))
+
+def test_DisjointUnion_is_empty():
+    assert DisjointUnion(S.EmptySet).is_empty is True
+    assert DisjointUnion(S.EmptySet, S.EmptySet).is_empty is True
+    assert DisjointUnion(S.EmptySet, FiniteSet(1, 2, 3)).is_empty is False
+
+def test_DisjointUnion_is_iterable():
+    assert DisjointUnion(S.Integers, S.Naturals, S.Rationals).is_iterable is True
+    assert DisjointUnion(S.EmptySet, S.Reals).is_iterable is False
+    assert DisjointUnion(FiniteSet(1, 2, 3), S.EmptySet, FiniteSet(x, y)).is_iterable is True
+    assert DisjointUnion(S.EmptySet, S.EmptySet).is_iterable is False
+
+def test_DisjointUnion_contains():
+    assert (0, 0) in DisjointUnion(FiniteSet(0, 1, 2), FiniteSet(0, 1, 2), FiniteSet(0, 1, 2))
+    assert (0, 1) in DisjointUnion(FiniteSet(0, 1, 2), FiniteSet(0, 1, 2), FiniteSet(0, 1, 2))
+    assert (0, 2) in DisjointUnion(FiniteSet(0, 1, 2), FiniteSet(0, 1, 2), FiniteSet(0, 1, 2))
+    assert (1, 0) in DisjointUnion(FiniteSet(0, 1, 2), FiniteSet(0, 1, 2), FiniteSet(0, 1, 2))
+    assert (1, 1) in DisjointUnion(FiniteSet(0, 1, 2), FiniteSet(0, 1, 2), FiniteSet(0, 1, 2))
+    assert (1, 2) in DisjointUnion(FiniteSet(0, 1, 2), FiniteSet(0, 1, 2), FiniteSet(0, 1, 2))
+    assert (2, 0) in DisjointUnion(FiniteSet(0, 1, 2), FiniteSet(0, 1, 2), FiniteSet(0, 1, 2))
+    assert (2, 1) in DisjointUnion(FiniteSet(0, 1, 2), FiniteSet(0, 1, 2), FiniteSet(0, 1, 2))
+    assert (2, 2) in DisjointUnion(FiniteSet(0, 1, 2), FiniteSet(0, 1, 2), FiniteSet(0, 1, 2))
+    assert (0, 1, 2) not in DisjointUnion(FiniteSet(0, 1, 2), FiniteSet(0, 1, 2), FiniteSet(0, 1, 2))
+    assert (0, 0.5) not in DisjointUnion(FiniteSet(0.5))
+    assert (0, 5) not in DisjointUnion(FiniteSet(0, 1, 2), FiniteSet(0, 1, 2), FiniteSet(0, 1, 2))
+    assert (x, 0) in DisjointUnion(FiniteSet(x, y, z), S.EmptySet, FiniteSet(y))
+    assert (y, 0) in DisjointUnion(FiniteSet(x, y, z), S.EmptySet, FiniteSet(y))
+    assert (z, 0) in DisjointUnion(FiniteSet(x, y, z), S.EmptySet, FiniteSet(y))
+    assert (y, 2) in DisjointUnion(FiniteSet(x, y, z), S.EmptySet, FiniteSet(y))
+    assert (0.5, 0) in DisjointUnion(Interval(0, 1), Interval(0, 2))
+    assert (0.5, 1) in DisjointUnion(Interval(0, 1), Interval(0, 2))
+    assert (1.5, 0) not in DisjointUnion(Interval(0, 1), Interval(0, 2))
+    assert (1.5, 1) in DisjointUnion(Interval(0, 1), Interval(0, 2))
+
+def test_DisjointUnion_iter():
+    D = DisjointUnion(FiniteSet(3, 5, 7, 9), FiniteSet(x, y, z))
+    it = iter(D)
+    L1 = [(x, 1), (y, 1), (z, 1)]
+    L2 = [(3, 0), (5, 0), (7, 0), (9, 0)]
+    nxt = next(it)
+    assert nxt in L2
+    L2.remove(nxt)
+    nxt = next(it)
+    assert nxt in L1
+    L1.remove(nxt)
+    nxt = next(it)
+    assert nxt in L2
+    L2.remove(nxt)
+    nxt = next(it)
+    assert nxt in L1
+    L1.remove(nxt)
+    nxt = next(it)
+    assert nxt in L2
+    L2.remove(nxt)
+    nxt = next(it)
+    assert nxt in L1
+    L1.remove(nxt)
+    nxt = next(it)
+    assert nxt in L2
+    L2.remove(nxt)
+    raises(StopIteration, lambda: next(it))
+
+    raises(ValueError, lambda: iter(DisjointUnion(Interval(0, 1), S.EmptySet)))
+
+def test_DisjointUnion_len():
+    assert len(DisjointUnion(FiniteSet(3, 5, 7, 9), FiniteSet(x, y, z))) == 7
+    assert len(DisjointUnion(S.EmptySet, S.EmptySet, FiniteSet(x, y, z), S.EmptySet)) == 3
+    raises(ValueError, lambda: len(DisjointUnion(Interval(0, 1), S.EmptySet)))
+
+def test_SetKind_ProductSet():
+    p = ProductSet(FiniteSet(Matrix([1, 2])), FiniteSet(Matrix([1, 2])))
+    mk = MatrixKind(NumberKind)
+    k = SetKind(TupleKind(mk, mk))
+    assert p.kind is k
+    assert ProductSet(Interval(1, 2), FiniteSet(Matrix([1, 2]))).kind is SetKind(TupleKind(NumberKind, mk))
+
+def test_SetKind_Interval():
+    assert Interval(1, 2).kind is SetKind(NumberKind)
+
+def test_SetKind_EmptySet_UniversalSet():
+    assert S.UniversalSet.kind is SetKind(UndefinedKind)
+    assert EmptySet.kind is SetKind()
+
+def test_SetKind_FiniteSet():
+    assert FiniteSet(1, Matrix([1, 2])).kind is SetKind(UndefinedKind)
+    assert FiniteSet(1, 2).kind is SetKind(NumberKind)
+
+def test_SetKind_Unions():
+    assert Union(FiniteSet(Matrix([1, 2])), Interval(1, 2)).kind is SetKind(UndefinedKind)
+    assert Union(Interval(1, 2), Interval(1, 7)).kind is SetKind(NumberKind)
+
+def test_SetKind_DisjointUnion():
+    A = FiniteSet(1, 2, 3)
+    B = Interval(0, 5)
+    assert DisjointUnion(A, B).kind is SetKind(NumberKind)
+
+def test_SetKind_evaluate_False():
+    U = lambda *args: Union(*args, evaluate=False)
+    assert U({1}, EmptySet).kind is SetKind(NumberKind)
+    assert U(Interval(1, 2), EmptySet).kind is SetKind(NumberKind)
+    assert U({1}, S.UniversalSet).kind is SetKind(UndefinedKind)
+    assert U(Interval(1, 2), Interval(4, 5),
+            FiniteSet(1)).kind is SetKind(NumberKind)
+    I = lambda *args: Intersection(*args, evaluate=False)
+    assert I({1}, S.UniversalSet).kind is SetKind(NumberKind)
+    assert I({1}, EmptySet).kind is SetKind()
+    C = lambda *args: Complement(*args, evaluate=False)
+    assert C(S.UniversalSet, {1, 2, 4, 5}).kind is SetKind(UndefinedKind)
+    assert C({1, 2, 3, 4, 5}, EmptySet).kind is SetKind(NumberKind)
+    assert C(EmptySet, {1, 2, 3, 4, 5}).kind is SetKind()
+
+def test_SetKind_ImageSet_Special():
+    f = ImageSet(Lambda(n, n ** 2), Interval(1, 4))
+    assert (f - FiniteSet(3)).kind is SetKind(NumberKind)
+    assert (f + Interval(16, 17)).kind is SetKind(NumberKind)
+    assert (f + FiniteSet(17)).kind is SetKind(NumberKind)
+
+def test_issue_20089():
+    B = FiniteSet(FiniteSet(1, 2), FiniteSet(1))
+    assert 1 not in B
+    assert 1.0 not in B
+    assert not Eq(1, FiniteSet(1, 2))
+    assert FiniteSet(1) in B
+    A = FiniteSet(1, 2)
+    assert A in B
+    assert B.issubset(B)
+    assert not A.issubset(B)
+    assert 1 in A
+    C = FiniteSet(FiniteSet(1, 2), FiniteSet(1), 1, 2)
+    assert A.issubset(C)
+    assert B.issubset(C)
+
+def test_issue_19378():
+    a = FiniteSet(1, 2)
+    b = ProductSet(a, a)
+    c = FiniteSet((1, 1), (1, 2), (2, 1), (2, 2))
+    assert b.is_subset(c) is True
+    d = FiniteSet(1)
+    assert b.is_subset(d) is False
+    assert Eq(c, b).simplify() is S.true
+    assert Eq(a, c).simplify() is S.false
+    assert Eq({1}, {x}).simplify() == Eq({1}, {x})
+
+def test_intersection_symbolic():
+    n = Symbol('n')
+    # These should not throw an error
+    assert isinstance(Intersection(Range(n), Range(100)), Intersection)
+    assert isinstance(Intersection(Range(n), Interval(1, 100)), Intersection)
+    assert isinstance(Intersection(Range(100), Interval(1, n)), Intersection)
+
+
+@XFAIL
+def test_intersection_symbolic_failing():
+    n = Symbol('n', integer=True, positive=True)
+    assert Intersection(Range(10, n), Range(4, 500, 5)) == Intersection(
+        Range(14, n), Range(14, 500, 5))
+    assert Intersection(Interval(10, n), Range(4, 500, 5)) == Intersection(
+        Interval(14, n), Range(14, 500, 5))
+
+
+def test_issue_20379():
+    #https://github.com/sympy/sympy/issues/20379
+    x = pi - 3.14159265358979
+    assert FiniteSet(x).evalf(2) == FiniteSet(Float('3.23108914886517e-15', 2))
+
+def test_finiteset_simplify():
+    S = FiniteSet(1, cos(1)**2 + sin(1)**2)
+    assert S.simplify() == {1}
+
+def test_issue_14336():
+    #https://github.com/sympy/sympy/issues/14336
+    U = S.Complexes
+    x = Symbol("x")
+    U -= U.intersect(Ne(x, 1).as_set())
+    U -= U.intersect(S.true.as_set())
+
+def test_issue_9855():
+    #https://github.com/sympy/sympy/issues/9855
+    x, y, z = symbols('x, y, z', real=True)
+    s1 = Interval(1, x) & Interval(y, 2)
+    s2 = Interval(1, 2)
+    assert s1.is_subset(s2) == None
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/__pycache__/__init__.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c1528499bc0c0bdc74b5d98bb47bc4c1afcf098f
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/__pycache__/__init__.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/__pycache__/_cse_diff.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/__pycache__/_cse_diff.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..54699fd16178d0aaf08a503b71bf58cb48c65738
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/__pycache__/_cse_diff.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/__pycache__/combsimp.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/__pycache__/combsimp.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..e104954372d1e35f84d1c996e930ba3580646b8a
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/__pycache__/combsimp.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/__pycache__/cse_main.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/__pycache__/cse_main.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..1b024ccb255ad084cf53351f1de7f00ccae5f930
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/__pycache__/cse_main.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/__pycache__/cse_opts.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/__pycache__/cse_opts.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..16e89a615eb7f77a4941125b3681039804ac02f1
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/__pycache__/cse_opts.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/__pycache__/epathtools.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/__pycache__/epathtools.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..07ab0ca4d50e7d583c7847718c42cea09c521fc6
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/__pycache__/epathtools.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/__pycache__/fu.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/__pycache__/fu.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..dfbef7f44aafbc9f2a6e1b18a1880ee790787e10
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/__pycache__/fu.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/__pycache__/gammasimp.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/__pycache__/gammasimp.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..2987796c67a6143185560d36e2ef11d4e0614570
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/__pycache__/gammasimp.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/__pycache__/hyperexpand.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/__pycache__/hyperexpand.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f17af0d0d0b4b8c6b3e7c8800c4a4c903bdebb46
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/__pycache__/hyperexpand.cpython-312.pyc
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:52b66efad1e9803d2c979b9653ddcd5f9a72aefa140e67434bbdb8c200e43e9c
+size 128022
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/__pycache__/hyperexpand_doc.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/__pycache__/hyperexpand_doc.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..3f7f8a9983812062c7284411143ed7d5a2530d77
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/__pycache__/hyperexpand_doc.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/__pycache__/powsimp.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/__pycache__/powsimp.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..bbc1255d1a0a036577a126ca48caf82eef00bac4
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/__pycache__/powsimp.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/__pycache__/radsimp.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/__pycache__/radsimp.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f09bb1942bd7b90b7cf4c934c7727c47406497c0
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/__pycache__/radsimp.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/__pycache__/ratsimp.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/__pycache__/ratsimp.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..620eabe5de242398f77a5040b16f0464a2c01ec5
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/__pycache__/ratsimp.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/__pycache__/simplify.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/__pycache__/simplify.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..df5cda71c655121386ca9d9f822c2e5e65647d6f
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/__pycache__/simplify.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/__pycache__/sqrtdenest.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/__pycache__/sqrtdenest.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ea39b50c8b9a501a07e7ae5c28134718b9f90b1a
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/__pycache__/sqrtdenest.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/__pycache__/traversaltools.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/__pycache__/traversaltools.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..507c0b73281892cb93d3c26ea0a200f933b2e833
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/__pycache__/traversaltools.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/__pycache__/trigsimp.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/__pycache__/trigsimp.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..0946ac7de4bd32c5bc22bdf261d554c86a831b5d
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/__pycache__/trigsimp.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/tests/__init__.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/tests/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/tests/__pycache__/__init__.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/tests/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..8fe1bd914ce6ed2725cb00d8971eb2fdb767b9cc
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/tests/__pycache__/__init__.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/tests/__pycache__/test_combsimp.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/tests/__pycache__/test_combsimp.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..051ec10eeafc2078f5b40b7e04a7707bb56d06d9
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/tests/__pycache__/test_combsimp.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/tests/__pycache__/test_cse.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/tests/__pycache__/test_cse.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..234972d0b208234d07124a40e327a046849f3fe9
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/tests/__pycache__/test_cse.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/tests/__pycache__/test_cse_diff.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/tests/__pycache__/test_cse_diff.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..69c64db0cff0aadfb0a8e615719caa9597860387
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/tests/__pycache__/test_cse_diff.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/tests/__pycache__/test_epathtools.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/tests/__pycache__/test_epathtools.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c31c9f295a7e39e488ea410228eb281c35e78849
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/tests/__pycache__/test_epathtools.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/tests/__pycache__/test_fu.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/tests/__pycache__/test_fu.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..db602064e5c806bccf688d87e54f7e91874a49b3
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/tests/__pycache__/test_fu.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/tests/__pycache__/test_function.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/tests/__pycache__/test_function.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..16a0c13189d09148ebc9a496f4572fc32e2a21a2
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/tests/__pycache__/test_function.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/tests/__pycache__/test_gammasimp.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/tests/__pycache__/test_gammasimp.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..9241a805158eb474056aa020d9645737bcf4319c
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/tests/__pycache__/test_gammasimp.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/tests/__pycache__/test_hyperexpand.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/tests/__pycache__/test_hyperexpand.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..2dca12b01d6bd5d5579cba81b739dc4a6a8df84f
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/tests/__pycache__/test_hyperexpand.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/tests/__pycache__/test_powsimp.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/tests/__pycache__/test_powsimp.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f7364b5824d48a752bb527d81367b220c15f23f4
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/tests/__pycache__/test_powsimp.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/tests/__pycache__/test_radsimp.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/tests/__pycache__/test_radsimp.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a9097b3c1a9adbc68cae40ca7e2c344578bb40a4
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/tests/__pycache__/test_radsimp.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/tests/__pycache__/test_ratsimp.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/tests/__pycache__/test_ratsimp.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..def8a35a5357b1c8a21df6d9f980d63c32907675
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/tests/__pycache__/test_ratsimp.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/tests/__pycache__/test_rewrite.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/tests/__pycache__/test_rewrite.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..454c43538afcb9153e264e634cdc55f8e60fecfb
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/tests/__pycache__/test_rewrite.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/tests/__pycache__/test_simplify.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/tests/__pycache__/test_simplify.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ebefbf21a240510c195e7d9540045a5b71461837
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/tests/__pycache__/test_simplify.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/tests/__pycache__/test_sqrtdenest.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/tests/__pycache__/test_sqrtdenest.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..30f1290f83fef9e2e55842e453b9d2a4c2048c59
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/tests/__pycache__/test_sqrtdenest.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/tests/__pycache__/test_trigsimp.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/tests/__pycache__/test_trigsimp.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d225f8f0de5863b0c2cb65b3089a42d1da56ab28
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/tests/__pycache__/test_trigsimp.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/tests/test_combsimp.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/tests/test_combsimp.py
new file mode 100644
index 0000000000000000000000000000000000000000..e56758a005fbb013c2b6ea4121b16c3434a54b03
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/tests/test_combsimp.py
@@ -0,0 +1,75 @@
+from sympy.core.numbers import Rational
+from sympy.core.symbol import symbols
+from sympy.functions.combinatorial.factorials import (FallingFactorial, RisingFactorial, binomial, factorial)
+from sympy.functions.special.gamma_functions import gamma
+from sympy.simplify.combsimp import combsimp
+from sympy.abc import x
+
+
+def test_combsimp():
+    k, m, n = symbols('k m n', integer = True)
+
+    assert combsimp(factorial(n)) == factorial(n)
+    assert combsimp(binomial(n, k)) == binomial(n, k)
+
+    assert combsimp(factorial(n)/factorial(n - 3)) == n*(-1 + n)*(-2 + n)
+    assert combsimp(binomial(n + 1, k + 1)/binomial(n, k)) == (1 + n)/(1 + k)
+
+    assert combsimp(binomial(3*n + 4, n + 1)/binomial(3*n + 1, n)) == \
+        Rational(3, 2)*((3*n + 2)*(3*n + 4)/((n + 1)*(2*n + 3)))
+
+    assert combsimp(factorial(n)**2/factorial(n - 3)) == \
+        factorial(n)*n*(-1 + n)*(-2 + n)
+    assert combsimp(factorial(n)*binomial(n + 1, k + 1)/binomial(n, k)) == \
+        factorial(n + 1)/(1 + k)
+
+    assert combsimp(gamma(n + 3)) == factorial(n + 2)
+
+    assert combsimp(factorial(x)) == gamma(x + 1)
+
+    # issue 9699
+    assert combsimp((n + 1)*factorial(n)) == factorial(n + 1)
+    assert combsimp(factorial(n)/n) == factorial(n-1)
+
+    # issue 6658
+    assert combsimp(binomial(n, n - k)) == binomial(n, k)
+
+    # issue 6341, 7135
+    assert combsimp(factorial(n)/(factorial(k)*factorial(n - k))) == \
+        binomial(n, k)
+    assert combsimp(factorial(k)*factorial(n - k)/factorial(n)) == \
+        1/binomial(n, k)
+    assert combsimp(factorial(2*n)/factorial(n)**2) == binomial(2*n, n)
+    assert combsimp(factorial(2*n)*factorial(k)*factorial(n - k)/
+        factorial(n)**3) == binomial(2*n, n)/binomial(n, k)
+
+    assert combsimp(factorial(n*(1 + n) - n**2 - n)) == 1
+
+    assert combsimp(6*FallingFactorial(-4, n)/factorial(n)) == \
+        (-1)**n*(n + 1)*(n + 2)*(n + 3)
+    assert combsimp(6*FallingFactorial(-4, n - 1)/factorial(n - 1)) == \
+        (-1)**(n - 1)*n*(n + 1)*(n + 2)
+    assert combsimp(6*FallingFactorial(-4, n - 3)/factorial(n - 3)) == \
+        (-1)**(n - 3)*n*(n - 1)*(n - 2)
+    assert combsimp(6*FallingFactorial(-4, -n - 1)/factorial(-n - 1)) == \
+        -(-1)**(-n - 1)*n*(n - 1)*(n - 2)
+
+    assert combsimp(6*RisingFactorial(4, n)/factorial(n)) == \
+        (n + 1)*(n + 2)*(n + 3)
+    assert combsimp(6*RisingFactorial(4, n - 1)/factorial(n - 1)) == \
+        n*(n + 1)*(n + 2)
+    assert combsimp(6*RisingFactorial(4, n - 3)/factorial(n - 3)) == \
+        n*(n - 1)*(n - 2)
+    assert combsimp(6*RisingFactorial(4, -n - 1)/factorial(-n - 1)) == \
+        -n*(n - 1)*(n - 2)
+
+
+def test_issue_6878():
+    n = symbols('n', integer=True)
+    assert combsimp(RisingFactorial(-10, n)) == 3628800*(-1)**n/factorial(10 - n)
+
+
+def test_issue_14528():
+    p = symbols("p", integer=True, positive=True)
+    assert combsimp(binomial(1,p)) == 1/(factorial(p)*factorial(1-p))
+    assert combsimp(factorial(2-p)) == factorial(2-p)
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/tests/test_cse.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/tests/test_cse.py
new file mode 100644
index 0000000000000000000000000000000000000000..c2a34dfb0e227547bd41bed2491284fd7150d0b6
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/tests/test_cse.py
@@ -0,0 +1,761 @@
+from functools import reduce
+import itertools
+from operator import add
+
+from sympy.codegen.matrix_nodes import MatrixSolve
+from sympy.core.add import Add
+from sympy.core.containers import Tuple
+from sympy.core.expr import UnevaluatedExpr
+from sympy.core.function import Function
+from sympy.core.mul import Mul
+from sympy.core.power import Pow
+from sympy.core.relational import Eq
+from sympy.core.singleton import S
+from sympy.core.symbol import (Symbol, symbols)
+from sympy.core.sympify import sympify
+from sympy.functions.elementary.exponential import exp
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.piecewise import Piecewise
+from sympy.functions.elementary.trigonometric import (cos, sin)
+from sympy.matrices.dense import Matrix
+from sympy.matrices.expressions import Inverse, MatAdd, MatMul, Transpose
+from sympy.polys.rootoftools import CRootOf
+from sympy.series.order import O
+from sympy.simplify.cse_main import cse
+from sympy.simplify.simplify import signsimp
+from sympy.tensor.indexed import (Idx, IndexedBase)
+
+from sympy.core.function import count_ops
+from sympy.simplify.cse_opts import sub_pre, sub_post
+from sympy.functions.special.hyper import meijerg
+from sympy.simplify import cse_main, cse_opts
+from sympy.utilities.iterables import subsets
+from sympy.testing.pytest import XFAIL, raises
+from sympy.matrices import (MutableDenseMatrix, MutableSparseMatrix,
+        ImmutableDenseMatrix, ImmutableSparseMatrix)
+from sympy.matrices.expressions import MatrixSymbol
+
+
+w, x, y, z = symbols('w,x,y,z')
+x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12 = symbols('x:13')
+
+
+def test_numbered_symbols():
+    ns = cse_main.numbered_symbols(prefix='y')
+    assert list(itertools.islice(
+        ns, 0, 10)) == [Symbol('y%s' % i) for i in range(0, 10)]
+    ns = cse_main.numbered_symbols(prefix='y')
+    assert list(itertools.islice(
+        ns, 10, 20)) == [Symbol('y%s' % i) for i in range(10, 20)]
+    ns = cse_main.numbered_symbols()
+    assert list(itertools.islice(
+        ns, 0, 10)) == [Symbol('x%s' % i) for i in range(0, 10)]
+
+# Dummy "optimization" functions for testing.
+
+
+def opt1(expr):
+    return expr + y
+
+
+def opt2(expr):
+    return expr*z
+
+
+def test_preprocess_for_cse():
+    assert cse_main.preprocess_for_cse(x, [(opt1, None)]) == x + y
+    assert cse_main.preprocess_for_cse(x, [(None, opt1)]) == x
+    assert cse_main.preprocess_for_cse(x, [(None, None)]) == x
+    assert cse_main.preprocess_for_cse(x, [(opt1, opt2)]) == x + y
+    assert cse_main.preprocess_for_cse(
+        x, [(opt1, None), (opt2, None)]) == (x + y)*z
+
+
+def test_postprocess_for_cse():
+    assert cse_main.postprocess_for_cse(x, [(opt1, None)]) == x
+    assert cse_main.postprocess_for_cse(x, [(None, opt1)]) == x + y
+    assert cse_main.postprocess_for_cse(x, [(None, None)]) == x
+    assert cse_main.postprocess_for_cse(x, [(opt1, opt2)]) == x*z
+    # Note the reverse order of application.
+    assert cse_main.postprocess_for_cse(
+        x, [(None, opt1), (None, opt2)]) == x*z + y
+
+
+def test_cse_single():
+    # Simple substitution.
+    e = Add(Pow(x + y, 2), sqrt(x + y))
+    substs, reduced = cse([e])
+    assert substs == [(x0, x + y)]
+    assert reduced == [sqrt(x0) + x0**2]
+
+    subst42, (red42,) = cse([42])  # issue_15082
+    assert len(subst42) == 0 and red42 == 42
+    subst_half, (red_half,) = cse([0.5])
+    assert len(subst_half) == 0 and red_half == 0.5
+
+
+def test_cse_single2():
+    # Simple substitution, test for being able to pass the expression directly
+    e = Add(Pow(x + y, 2), sqrt(x + y))
+    substs, reduced = cse(e)
+    assert substs == [(x0, x + y)]
+    assert reduced == [sqrt(x0) + x0**2]
+    substs, reduced = cse(Matrix([[1]]))
+    assert isinstance(reduced[0], Matrix)
+
+    subst42, (red42,) = cse(42)  # issue 15082
+    assert len(subst42) == 0 and red42 == 42
+    subst_half, (red_half,) = cse(0.5)  # issue 15082
+    assert len(subst_half) == 0 and red_half == 0.5
+
+
+def test_cse_not_possible():
+    # No substitution possible.
+    e = Add(x, y)
+    substs, reduced = cse([e])
+    assert substs == []
+    assert reduced == [x + y]
+    # issue 6329
+    eq = (meijerg((1, 2), (y, 4), (5,), [], x) +
+          meijerg((1, 3), (y, 4), (5,), [], x))
+    assert cse(eq) == ([], [eq])
+
+
+def test_nested_substitution():
+    # Substitution within a substitution.
+    e = Add(Pow(w*x + y, 2), sqrt(w*x + y))
+    substs, reduced = cse([e])
+    assert substs == [(x0, w*x + y)]
+    assert reduced == [sqrt(x0) + x0**2]
+
+
+def test_subtraction_opt():
+    # Make sure subtraction is optimized.
+    e = (x - y)*(z - y) + exp((x - y)*(z - y))
+    substs, reduced = cse(
+        [e], optimizations=[(cse_opts.sub_pre, cse_opts.sub_post)])
+    assert substs == [(x0, (x - y)*(y - z))]
+    assert reduced == [-x0 + exp(-x0)]
+    e = -(x - y)*(z - y) + exp(-(x - y)*(z - y))
+    substs, reduced = cse(
+        [e], optimizations=[(cse_opts.sub_pre, cse_opts.sub_post)])
+    assert substs == [(x0, (x - y)*(y - z))]
+    assert reduced == [x0 + exp(x0)]
+    # issue 4077
+    n = -1 + 1/x
+    e = n/x/(-n)**2 - 1/n/x
+    assert cse(e, optimizations=[(cse_opts.sub_pre, cse_opts.sub_post)]) == \
+        ([], [0])
+    assert cse(((w + x + y + z)*(w - y - z))/(w + x)**3) == \
+        ([(x0, w + x), (x1, y + z)], [(w - x1)*(x0 + x1)/x0**3])
+
+
+def test_multiple_expressions():
+    e1 = (x + y)*z
+    e2 = (x + y)*w
+    substs, reduced = cse([e1, e2])
+    assert substs == [(x0, x + y)]
+    assert reduced == [x0*z, x0*w]
+    l = [w*x*y + z, w*y]
+    substs, reduced = cse(l)
+    rsubsts, _ = cse(reversed(l))
+    assert substs == rsubsts
+    assert reduced == [z + x*x0, x0]
+    l = [w*x*y, w*x*y + z, w*y]
+    substs, reduced = cse(l)
+    rsubsts, _ = cse(reversed(l))
+    assert substs == rsubsts
+    assert reduced == [x1, x1 + z, x0]
+    l = [(x - z)*(y - z), x - z, y - z]
+    substs, reduced = cse(l)
+    rsubsts, _ = cse(reversed(l))
+    assert substs == [(x0, -z), (x1, x + x0), (x2, x0 + y)]
+    assert rsubsts == [(x0, -z), (x1, x0 + y), (x2, x + x0)]
+    assert reduced == [x1*x2, x1, x2]
+    l = [w*y + w + x + y + z, w*x*y]
+    assert cse(l) == ([(x0, w*y)], [w + x + x0 + y + z, x*x0])
+    assert cse([x + y, x + y + z]) == ([(x0, x + y)], [x0, z + x0])
+    assert cse([x + y, x + z]) == ([], [x + y, x + z])
+    assert cse([x*y, z + x*y, x*y*z + 3]) == \
+        ([(x0, x*y)], [x0, z + x0, 3 + x0*z])
+
+
+@XFAIL # CSE of non-commutative Mul terms is disabled
+def test_non_commutative_cse():
+    A, B, C = symbols('A B C', commutative=False)
+    l = [A*B*C, A*C]
+    assert cse(l) == ([], l)
+    l = [A*B*C, A*B]
+    assert cse(l) == ([(x0, A*B)], [x0*C, x0])
+
+
+# Test if CSE of non-commutative Mul terms is disabled
+def test_bypass_non_commutatives():
+    A, B, C = symbols('A B C', commutative=False)
+    l = [A*B*C, A*C]
+    assert cse(l) == ([], l)
+    l = [A*B*C, A*B]
+    assert cse(l) == ([], l)
+    l = [B*C, A*B*C]
+    assert cse(l) == ([], l)
+
+
+@XFAIL # CSE fails when replacing non-commutative sub-expressions
+def test_non_commutative_order():
+    A, B, C = symbols('A B C', commutative=False)
+    x0 = symbols('x0', commutative=False)
+    l = [B+C, A*(B+C)]
+    assert cse(l) == ([(x0, B+C)], [x0, A*x0])
+
+
+@XFAIL # Worked in gh-11232, but was reverted due to performance considerations
+def test_issue_10228():
+    assert cse([x*y**2 + x*y]) == ([(x0, x*y)], [x0*y + x0])
+    assert cse([x + y, 2*x + y]) == ([(x0, x + y)], [x0, x + x0])
+    assert cse((w + 2*x + y + z, w + x + 1)) == (
+        [(x0, w + x)], [x0 + x + y + z, x0 + 1])
+    assert cse(((w + x + y + z)*(w - x))/(w + x)) == (
+        [(x0, w + x)], [(x0 + y + z)*(w - x)/x0])
+    a, b, c, d, f, g, j, m = symbols('a, b, c, d, f, g, j, m')
+    exprs = (d*g**2*j*m, 4*a*f*g*m, a*b*c*f**2)
+    assert cse(exprs) == (
+        [(x0, g*m), (x1, a*f)], [d*g*j*x0, 4*x0*x1, b*c*f*x1]
+)
+
+@XFAIL
+def test_powers():
+    assert cse(x*y**2 + x*y) == ([(x0, x*y)], [x0*y + x0])
+
+
+def test_issue_4498():
+    assert cse(w/(x - y) + z/(y - x), optimizations='basic') == \
+        ([], [(w - z)/(x - y)])
+
+
+def test_issue_4020():
+    assert cse(x**5 + x**4 + x**3 + x**2, optimizations='basic') \
+        == ([(x0, x**2)], [x0*(x**3 + x + x0 + 1)])
+
+
+def test_issue_4203():
+    assert cse(sin(x**x)/x**x) == ([(x0, x**x)], [sin(x0)/x0])
+
+
+def test_issue_6263():
+    e = Eq(x*(-x + 1) + x*(x - 1), 0)
+    assert cse(e, optimizations='basic') == ([], [True])
+
+
+def test_issue_25043():
+    c = symbols("c")
+    x = symbols("x0", real=True)
+    cse_expr = cse(c*x**2 + c*(x**4 - x**2))[-1][-1]
+    free = cse_expr.free_symbols
+    assert len(free) == len({i.name for i in free})
+
+
+def test_dont_cse_tuples():
+    from sympy.core.function import Subs
+    f = Function("f")
+    g = Function("g")
+
+    name_val, (expr,) = cse(
+        Subs(f(x, y), (x, y), (0, 1))
+        + Subs(g(x, y), (x, y), (0, 1)))
+
+    assert name_val == []
+    assert expr == (Subs(f(x, y), (x, y), (0, 1))
+            + Subs(g(x, y), (x, y), (0, 1)))
+
+    name_val, (expr,) = cse(
+        Subs(f(x, y), (x, y), (0, x + y))
+        + Subs(g(x, y), (x, y), (0, x + y)))
+
+    assert name_val == [(x0, x + y)]
+    assert expr == Subs(f(x, y), (x, y), (0, x0)) + \
+        Subs(g(x, y), (x, y), (0, x0))
+
+
+def test_pow_invpow():
+    assert cse(1/x**2 + x**2) == \
+        ([(x0, x**2)], [x0 + 1/x0])
+    assert cse(x**2 + (1 + 1/x**2)/x**2) == \
+        ([(x0, x**2), (x1, 1/x0)], [x0 + x1*(x1 + 1)])
+    assert cse(1/x**2 + (1 + 1/x**2)*x**2) == \
+        ([(x0, x**2), (x1, 1/x0)], [x0*(x1 + 1) + x1])
+    assert cse(cos(1/x**2) + sin(1/x**2)) == \
+        ([(x0, x**(-2))], [sin(x0) + cos(x0)])
+    assert cse(cos(x**2) + sin(x**2)) == \
+        ([(x0, x**2)], [sin(x0) + cos(x0)])
+    assert cse(y/(2 + x**2) + z/x**2/y) == \
+        ([(x0, x**2)], [y/(x0 + 2) + z/(x0*y)])
+    assert cse(exp(x**2) + x**2*cos(1/x**2)) == \
+        ([(x0, x**2)], [x0*cos(1/x0) + exp(x0)])
+    assert cse((1 + 1/x**2)/x**2) == \
+        ([(x0, x**(-2))], [x0*(x0 + 1)])
+    assert cse(x**(2*y) + x**(-2*y)) == \
+        ([(x0, x**(2*y))], [x0 + 1/x0])
+
+
+def test_postprocess():
+    eq = (x + 1 + exp((x + 1)/(y + 1)) + cos(y + 1))
+    assert cse([eq, Eq(x, z + 1), z - 2, (z + 1)*(x + 1)],
+        postprocess=cse_main.cse_separate) == \
+        [[(x0, y + 1), (x2, z + 1), (x, x2), (x1, x + 1)],
+        [x1 + exp(x1/x0) + cos(x0), z - 2, x1*x2]]
+
+
+def test_issue_4499():
+    # previously, this gave 16 constants
+    from sympy.abc import a, b
+    B = Function('B')
+    G = Function('G')
+    t = Tuple(*
+        (a, a + S.Half, 2*a, b, 2*a - b + 1, (sqrt(z)/2)**(-2*a + 1)*B(2*a -
+        b, sqrt(z))*B(b - 1, sqrt(z))*G(b)*G(2*a - b + 1),
+        sqrt(z)*(sqrt(z)/2)**(-2*a + 1)*B(b, sqrt(z))*B(2*a - b,
+        sqrt(z))*G(b)*G(2*a - b + 1), sqrt(z)*(sqrt(z)/2)**(-2*a + 1)*B(b - 1,
+        sqrt(z))*B(2*a - b + 1, sqrt(z))*G(b)*G(2*a - b + 1),
+        (sqrt(z)/2)**(-2*a + 1)*B(b, sqrt(z))*B(2*a - b + 1,
+        sqrt(z))*G(b)*G(2*a - b + 1), 1, 0, S.Half, z/2, -b + 1, -2*a + b,
+        -2*a))
+    c = cse(t)
+    ans = (
+        [(x0, 2*a), (x1, -b + x0), (x2, x1 + 1), (x3, b - 1), (x4, sqrt(z)),
+         (x5, B(x3, x4)), (x6, (x4/2)**(1 - x0)*G(b)*G(x2)), (x7, x6*B(x1, x4)),
+         (x8, B(b, x4)), (x9, x6*B(x2, x4))],
+        [(a, a + S.Half, x0, b, x2, x5*x7, x4*x7*x8, x4*x5*x9, x8*x9,
+          1, 0, S.Half, z/2, -x3, -x1, -x0)])
+    assert ans == c
+
+
+def test_issue_6169():
+    r = CRootOf(x**6 - 4*x**5 - 2, 1)
+    assert cse(r) == ([], [r])
+    # and a check that the right thing is done with the new
+    # mechanism
+    assert sub_post(sub_pre((-x - y)*z - x - y)) == -z*(x + y) - x - y
+
+
+def test_cse_Indexed():
+    len_y = 5
+    y = IndexedBase('y', shape=(len_y,))
+    x = IndexedBase('x', shape=(len_y,))
+    i = Idx('i', len_y-1)
+
+    expr1 = (y[i+1]-y[i])/(x[i+1]-x[i])
+    expr2 = 1/(x[i+1]-x[i])
+    replacements, reduced_exprs = cse([expr1, expr2])
+    assert len(replacements) > 0
+
+
+def test_cse_MatrixSymbol():
+    # MatrixSymbols have non-Basic args, so make sure that works
+    A = MatrixSymbol("A", 3, 3)
+    assert cse(A) == ([], [A])
+
+    n = symbols('n', integer=True)
+    B = MatrixSymbol("B", n, n)
+    assert cse(B) == ([], [B])
+
+    assert cse(A[0] * A[0]) == ([], [A[0]*A[0]])
+
+    assert cse(A[0,0]*A[0,1] + A[0,0]*A[0,1]*A[0,2]) == ([(x0, A[0, 0]*A[0, 1])], [x0*A[0, 2] + x0])
+
+def test_cse_MatrixExpr():
+    A = MatrixSymbol('A', 3, 3)
+    y = MatrixSymbol('y', 3, 1)
+
+    expr1 = (A.T*A).I * A * y
+    expr2 = (A.T*A) * A * y
+    replacements, reduced_exprs = cse([expr1, expr2])
+    assert len(replacements) > 0
+
+    replacements, reduced_exprs = cse([expr1 + expr2, expr1])
+    assert replacements
+
+    replacements, reduced_exprs = cse([A**2, A + A**2])
+    assert replacements
+
+
+def test_Piecewise():
+    f = Piecewise((-z + x*y, Eq(y, 0)), (-z - x*y, True))
+    ans = cse(f)
+    actual_ans = ([(x0, x*y)],
+        [Piecewise((x0 - z, Eq(y, 0)), (-z - x0, True))])
+    assert ans == actual_ans
+
+
+def test_ignore_order_terms():
+    eq = exp(x).series(x,0,3) + sin(y+x**3) - 1
+    assert cse(eq) == ([], [sin(x**3 + y) + x + x**2/2 + O(x**3)])
+
+
+def test_name_conflict():
+    z1 = x0 + y
+    z2 = x2 + x3
+    l = [cos(z1) + z1, cos(z2) + z2, x0 + x2]
+    substs, reduced = cse(l)
+    assert [e.subs(reversed(substs)) for e in reduced] == l
+
+
+def test_name_conflict_cust_symbols():
+    z1 = x0 + y
+    z2 = x2 + x3
+    l = [cos(z1) + z1, cos(z2) + z2, x0 + x2]
+    substs, reduced = cse(l, symbols("x:10"))
+    assert [e.subs(reversed(substs)) for e in reduced] == l
+
+
+def test_symbols_exhausted_error():
+    l = cos(x+y)+x+y+cos(w+y)+sin(w+y)
+    sym = [x, y, z]
+    with raises(ValueError):
+        cse(l, symbols=sym)
+
+
+def test_issue_7840():
+    # daveknippers' example
+    C393 = sympify( \
+        'Piecewise((C391 - 1.65, C390 < 0.5), (Piecewise((C391 - 1.65, \
+        C391 > 2.35), (C392, True)), True))'
+    )
+    C391 = sympify( \
+        'Piecewise((2.05*C390**(-1.03), C390 < 0.5), (2.5*C390**(-0.625), True))'
+    )
+    C393 = C393.subs('C391',C391)
+    # simple substitution
+    sub = {}
+    sub['C390'] = 0.703451854
+    sub['C392'] = 1.01417794
+    ss_answer = C393.subs(sub)
+    # cse
+    substitutions,new_eqn = cse(C393)
+    for pair in substitutions:
+        sub[pair[0].name] = pair[1].subs(sub)
+    cse_answer = new_eqn[0].subs(sub)
+    # both methods should be the same
+    assert ss_answer == cse_answer
+
+    # GitRay's example
+    expr = sympify(
+        "Piecewise((Symbol('ON'), Equality(Symbol('mode'), Symbol('ON'))), \
+        (Piecewise((Piecewise((Symbol('OFF'), StrictLessThan(Symbol('x'), \
+        Symbol('threshold'))), (Symbol('ON'), true)), Equality(Symbol('mode'), \
+        Symbol('AUTO'))), (Symbol('OFF'), true)), true))"
+    )
+    substitutions, new_eqn = cse(expr)
+    # this Piecewise should be exactly the same
+    assert new_eqn[0] == expr
+    # there should not be any replacements
+    assert len(substitutions) < 1
+
+
+def test_issue_8891():
+    for cls in (MutableDenseMatrix, MutableSparseMatrix,
+            ImmutableDenseMatrix, ImmutableSparseMatrix):
+        m = cls(2, 2, [x + y, 0, 0, 0])
+        res = cse([x + y, m])
+        ans = ([(x0, x + y)], [x0, cls([[x0, 0], [0, 0]])])
+        assert res == ans
+        assert isinstance(res[1][-1], cls)
+
+
+def test_issue_11230():
+    # a specific test that always failed
+    a, b, f, k, l, i = symbols('a b f k l i')
+    p = [a*b*f*k*l, a*i*k**2*l, f*i*k**2*l]
+    R, C = cse(p)
+    assert not any(i.is_Mul for a in C for i in a.args)
+
+    # random tests for the issue
+    from sympy.core.random import choice
+    from sympy.core.function import expand_mul
+    s = symbols('a:m')
+    # 35 Mul tests, none of which should ever fail
+    ex = [Mul(*[choice(s) for i in range(5)]) for i in range(7)]
+    for p in subsets(ex, 3):
+        p = list(p)
+        R, C = cse(p)
+        assert not any(i.is_Mul for a in C for i in a.args)
+        for ri in reversed(R):
+            for i in range(len(C)):
+                C[i] = C[i].subs(*ri)
+        assert p == C
+    # 35 Add tests, none of which should ever fail
+    ex = [Add(*[choice(s[:7]) for i in range(5)]) for i in range(7)]
+    for p in subsets(ex, 3):
+        p = list(p)
+        R, C = cse(p)
+        assert not any(i.is_Add for a in C for i in a.args)
+        for ri in reversed(R):
+            for i in range(len(C)):
+                C[i] = C[i].subs(*ri)
+        # use expand_mul to handle cases like this:
+        # p = [a + 2*b + 2*e, 2*b + c + 2*e, b + 2*c + 2*g]
+        # x0 = 2*(b + e) is identified giving a rebuilt p that
+        # is now `[a + 2*(b + e), c + 2*(b + e), b + 2*c + 2*g]`
+        assert p == [expand_mul(i) for i in C]
+
+
+@XFAIL
+def test_issue_11577():
+    def check(eq):
+        r, c = cse(eq)
+        assert eq.count_ops() >= \
+            len(r) + sum(i[1].count_ops() for i in r) + \
+            count_ops(c)
+
+    eq = x**5*y**2 + x**5*y + x**5
+    assert cse(eq) == (
+        [(x0, x**4), (x1, x*y)], [x**5 + x0*x1*y + x0*x1])
+        # ([(x0, x**5*y)], [x0*y + x0 + x**5]) or
+        # ([(x0, x**5)], [x0*y**2 + x0*y + x0])
+    check(eq)
+
+    eq = x**2/(y + 1)**2 + x/(y + 1)
+    assert cse(eq) == (
+        [(x0, y + 1)], [x**2/x0**2 + x/x0])
+        # ([(x0, x/(y + 1))], [x0**2 + x0])
+    check(eq)
+
+
+def test_hollow_rejection():
+    eq = [x + 3, x + 4]
+    assert cse(eq) == ([], eq)
+
+
+def test_cse_ignore():
+    exprs = [exp(y)*(3*y + 3*sqrt(x+1)), exp(y)*(5*y + 5*sqrt(x+1))]
+    subst1, red1 = cse(exprs)
+    assert any(y in sub.free_symbols for _, sub in subst1), "cse failed to identify any term with y"
+
+    subst2, red2 = cse(exprs, ignore=(y,))  # y is not allowed in substitutions
+    assert not any(y in sub.free_symbols for _, sub in subst2), "Sub-expressions containing y must be ignored"
+    assert any(sub - sqrt(x + 1) == 0 for _, sub in subst2), "cse failed to identify sqrt(x + 1) as sub-expression"
+
+
+def test_cse_ignore_issue_15002():
+    l = [
+        w*exp(x)*exp(-z),
+        exp(y)*exp(x)*exp(-z)
+    ]
+    substs, reduced = cse(l, ignore=(x,))
+    rl = [e.subs(reversed(substs)) for e in reduced]
+    assert rl == l
+
+
+def test_cse_unevaluated():
+    xp1 = UnevaluatedExpr(x + 1)
+    # This used to cause RecursionError
+    [(x0, ue)], [red] = cse([(-1 - xp1) / (1 - xp1)])
+    if ue == xp1:
+        assert red == (-1 - x0) / (1 - x0)
+    elif ue == -xp1:
+        assert red == (-1 + x0) / (1 + x0)
+    else:
+        msg = f'Expected common subexpression {xp1} or {-xp1}, instead got {ue}'
+        assert False, msg
+
+
+def test_cse__performance():
+    nexprs, nterms = 3, 20
+    x = symbols('x:%d' % nterms)
+    exprs = [
+        reduce(add, [x[j]*(-1)**(i+j) for j in range(nterms)])
+        for i in range(nexprs)
+    ]
+    assert (exprs[0] + exprs[1]).simplify() == 0
+    subst, red = cse(exprs)
+    assert len(subst) > 0, "exprs[0] == -exprs[2], i.e. a CSE"
+    for i, e in enumerate(red):
+        assert (e.subs(reversed(subst)) - exprs[i]).simplify() == 0
+
+
+def test_issue_12070():
+    exprs = [x + y, 2 + x + y, x + y + z, 3 + x + y + z]
+    subst, red = cse(exprs)
+    assert 6 >= (len(subst) + sum(v.count_ops() for k, v in subst) +
+                 count_ops(red))
+
+
+def test_issue_13000():
+    eq = x/(-4*x**2 + y**2)
+    cse_eq = cse(eq)[1][0]
+    assert cse_eq == eq
+
+
+def test_issue_18203():
+    eq = CRootOf(x**5 + 11*x - 2, 0) + CRootOf(x**5 + 11*x - 2, 1)
+    assert cse(eq) == ([], [eq])
+
+
+def test_unevaluated_mul():
+    eq = Mul(x + y, x + y, evaluate=False)
+    assert cse(eq) == ([(x0, x + y)], [x0**2])
+
+
+def test_cse_release_variables():
+    from sympy.simplify.cse_main import cse_release_variables
+    _0, _1, _2, _3, _4 = symbols('_:5')
+    eqs = [(x + y - 1)**2, x,
+        x + y, (x + y)/(2*x + 1) + (x + y - 1)**2,
+        (2*x + 1)**(x + y)]
+    r, e = cse(eqs, postprocess=cse_release_variables)
+    # this can change in keeping with the intention of the function
+    assert r, e == ([
+    (x0, x + y), (x1, (x0 - 1)**2), (x2, 2*x + 1),
+    (_3, x0/x2 + x1), (_4, x2**x0), (x2, None), (_0, x1),
+    (x1, None), (_2, x0), (x0, None), (_1, x)], (_0, _1, _2, _3, _4))
+    r.reverse()
+    r = [(s, v) for s, v in r if v is not None]
+    assert eqs == [i.subs(r) for i in e]
+
+
+def test_cse_list():
+    _cse = lambda x: cse(x, list=False)
+    assert _cse(x) == ([], x)
+    assert _cse('x') == ([], 'x')
+    it = [x]
+    for c in (list, tuple, set):
+        assert _cse(c(it)) == ([], c(it))
+    #Tuple works different from tuple:
+    assert _cse(Tuple(*it)) == ([], Tuple(*it))
+    d = {x: 1}
+    assert _cse(d) == ([], d)
+
+def test_issue_18991():
+    A = MatrixSymbol('A', 2, 2)
+    assert signsimp(-A * A - A) == -A * A - A
+
+
+def test_unevaluated_Mul():
+    m = [Mul(1, 2, evaluate=False)]
+    assert cse(m) == ([], m)
+
+
+def test_cse_matrix_expression_inverse():
+    A = ImmutableDenseMatrix(symbols('A:4')).reshape(2, 2)
+    x = Inverse(A)
+    cse_expr = cse(x)
+    assert cse_expr == ([], [Inverse(A)])
+
+
+def test_cse_matrix_expression_matmul_inverse():
+    A = ImmutableDenseMatrix(symbols('A:4')).reshape(2, 2)
+    b = ImmutableDenseMatrix(symbols('b:2'))
+    x = MatMul(Inverse(A), b)
+    cse_expr = cse(x)
+    assert cse_expr == ([], [x])
+
+
+def test_cse_matrix_negate_matrix():
+    A = ImmutableDenseMatrix(symbols('A:4')).reshape(2, 2)
+    x = MatMul(S.NegativeOne, A)
+    cse_expr = cse(x)
+    assert cse_expr == ([], [x])
+
+
+def test_cse_matrix_negate_matmul_not_extracted():
+    A = ImmutableDenseMatrix(symbols('A:4')).reshape(2, 2)
+    B = ImmutableDenseMatrix(symbols('B:4')).reshape(2, 2)
+    x = MatMul(S.NegativeOne, A, B)
+    cse_expr = cse(x)
+    assert cse_expr == ([], [x])
+
+
+@XFAIL  # No simplification rule for nested associative operations
+def test_cse_matrix_nested_matmul_collapsed():
+    A = ImmutableDenseMatrix(symbols('A:4')).reshape(2, 2)
+    B = ImmutableDenseMatrix(symbols('B:4')).reshape(2, 2)
+    x = MatMul(S.NegativeOne, MatMul(A, B))
+    cse_expr = cse(x)
+    assert cse_expr == ([], [MatMul(S.NegativeOne, A, B)])
+
+
+def test_cse_matrix_optimize_out_single_argument_mul():
+    A = ImmutableDenseMatrix(symbols('A:4')).reshape(2, 2)
+    x = MatMul(MatMul(MatMul(A)))
+    cse_expr = cse(x)
+    assert cse_expr == ([], [A])
+
+
+@XFAIL  # Multiple simplification passed not supported in CSE
+def test_cse_matrix_optimize_out_single_argument_mul_combined():
+    A = ImmutableDenseMatrix(symbols('A:4')).reshape(2, 2)
+    x = MatAdd(MatMul(MatMul(MatMul(A))), MatMul(MatMul(A)), MatMul(A), A)
+    cse_expr = cse(x)
+    assert cse_expr == ([], [MatMul(4, A)])
+
+
+def test_cse_matrix_optimize_out_single_argument_add():
+    A = ImmutableDenseMatrix(symbols('A:4')).reshape(2, 2)
+    x = MatAdd(MatAdd(MatAdd(MatAdd(A))))
+    cse_expr = cse(x)
+    assert cse_expr == ([], [A])
+
+
+@XFAIL  # Multiple simplification passed not supported in CSE
+def test_cse_matrix_optimize_out_single_argument_add_combined():
+    A = ImmutableDenseMatrix(symbols('A:4')).reshape(2, 2)
+    x = MatMul(MatAdd(MatAdd(MatAdd(A))), MatAdd(MatAdd(A)), MatAdd(A), A)
+    cse_expr = cse(x)
+    assert cse_expr == ([], [MatMul(4, A)])
+
+
+def test_cse_matrix_expression_matrix_solve():
+    A = ImmutableDenseMatrix(symbols('A:4')).reshape(2, 2)
+    b = ImmutableDenseMatrix(symbols('b:2'))
+    x = MatrixSolve(A, b)
+    cse_expr = cse(x)
+    assert cse_expr == ([], [x])
+
+
+def test_cse_matrix_matrix_expression():
+    X = ImmutableDenseMatrix(symbols('X:4')).reshape(2, 2)
+    y = ImmutableDenseMatrix(symbols('y:2'))
+    b = MatMul(Inverse(MatMul(Transpose(X), X)), Transpose(X), y)
+    cse_expr = cse(b)
+    x0 = MatrixSymbol('x0', 2, 2)
+    reduced_expr_expected = MatMul(Inverse(MatMul(x0, X)), x0, y)
+    assert cse_expr == ([(x0, Transpose(X))], [reduced_expr_expected])
+
+
+def test_cse_matrix_kalman_filter():
+    """Kalman Filter example from Matthew Rocklin's SciPy 2013 talk.
+
+    Talk titled: "Matrix Expressions and BLAS/LAPACK; SciPy 2013 Presentation"
+
+    Video: https://pyvideo.org/scipy-2013/matrix-expressions-and-blaslapack-scipy-2013-pr.html
+
+    Notes
+    =====
+
+    Equations are:
+
+    new_mu = mu + Sigma*H.T * (R + H*Sigma*H.T).I * (H*mu - data)
+           = MatAdd(mu, MatMul(Sigma, Transpose(H), Inverse(MatAdd(R, MatMul(H, Sigma, Transpose(H)))), MatAdd(MatMul(H, mu), MatMul(S.NegativeOne, data))))
+    new_Sigma = Sigma - Sigma*H.T * (R + H*Sigma*H.T).I * H * Sigma
+              = MatAdd(Sigma, MatMul(S.NegativeOne, Sigma, Transpose(H)), Inverse(MatAdd(R, MatMul(H*Sigma*Transpose(H)))), H, Sigma))
+
+    """
+    N = 2
+    mu = ImmutableDenseMatrix(symbols(f'mu:{N}'))
+    Sigma = ImmutableDenseMatrix(symbols(f'Sigma:{N * N}')).reshape(N, N)
+    H = ImmutableDenseMatrix(symbols(f'H:{N * N}')).reshape(N, N)
+    R = ImmutableDenseMatrix(symbols(f'R:{N * N}')).reshape(N, N)
+    data = ImmutableDenseMatrix(symbols(f'data:{N}'))
+    new_mu = MatAdd(mu, MatMul(Sigma, Transpose(H), Inverse(MatAdd(R, MatMul(H, Sigma, Transpose(H)))), MatAdd(MatMul(H, mu), MatMul(S.NegativeOne, data))))
+    new_Sigma = MatAdd(Sigma, MatMul(S.NegativeOne, Sigma, Transpose(H), Inverse(MatAdd(R, MatMul(H, Sigma, Transpose(H)))), H, Sigma))
+    cse_expr = cse([new_mu, new_Sigma])
+    x0 = MatrixSymbol('x0', N, N)
+    x1 = MatrixSymbol('x1', N, N)
+    replacements_expected = [
+        (x0, Transpose(H)),
+        (x1, Inverse(MatAdd(R, MatMul(H, Sigma, x0)))),
+    ]
+    reduced_exprs_expected = [
+        MatAdd(mu, MatMul(Sigma, x0, x1, MatAdd(MatMul(H, mu), MatMul(S.NegativeOne, data)))),
+        MatAdd(Sigma, MatMul(S.NegativeOne, Sigma, x0, x1, H, Sigma)),
+    ]
+    assert cse_expr == (replacements_expected, reduced_exprs_expected)
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/tests/test_cse_diff.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/tests/test_cse_diff.py
new file mode 100644
index 0000000000000000000000000000000000000000..92b2d3d6bbaafb838a5e75f32a214511a1d39567
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/tests/test_cse_diff.py
@@ -0,0 +1,206 @@
+"""Tests for the ``sympy.simplify._cse_diff.py`` module."""
+
+import pytest
+
+from sympy.core.symbol import (Symbol, symbols)
+from sympy.core.numbers import Integer
+from sympy.core.function import Function
+from sympy.core import Derivative
+from sympy.functions.elementary.exponential import exp
+from sympy.matrices.immutable import ImmutableDenseMatrix
+from sympy.physics.mechanics import dynamicsymbols
+from sympy.simplify._cse_diff import (_forward_jacobian,
+                                      _remove_cse_from_derivative,
+                                      _forward_jacobian_cse,
+                                      _forward_jacobian_norm_in_cse_out)
+from sympy.simplify.simplify import simplify
+from sympy.matrices import Matrix, eye
+
+from sympy.testing.pytest import raises
+from sympy.functions.elementary.trigonometric import (cos, sin, tan)
+from sympy.simplify.trigsimp import trigsimp
+
+from sympy import cse
+
+
+w = Symbol('w')
+x = Symbol('x')
+y = Symbol('y')
+z = Symbol('z')
+
+q1, q2, q3 = dynamicsymbols('q1 q2 q3')
+
+# Define the custom functions
+k = Function('k')(x, y)
+f = Function('f')(k, z)
+
+zero = Integer(0)
+one = Integer(1)
+two = Integer(2)
+neg_one = Integer(-1)
+
+
+@pytest.mark.parametrize(
+    'expr, wrt',
+    [
+        ([zero], [x]),
+        ([one], [x]),
+        ([two], [x]),
+        ([neg_one], [x]),
+        ([x], [x]),
+        ([y], [x]),
+        ([x + y], [x]),
+        ([x*y], [x]),
+        ([x**2], [x]),
+        ([x**y], [x]),
+        ([exp(x)], [x]),
+        ([sin(x)], [x]),
+        ([tan(x)], [x]),
+        ([zero, one, x, y, x*y, x + y], [x, y]),
+        ([((x/y) + sin(x/y) - exp(y))*((x/y) - exp(y))], [x, y]),
+        ([w*tan(y*z)/(x - tan(y*z)), w*x*tan(y*z)/(x - tan(y*z))], [w, x, y, z]),
+        ([q1**2 + q2, q2**2 + q3, q3**2 + q1], [q1, q2, q3]),
+        ([f + Derivative(f, x) + k + 2*x], [x])
+    ]
+)
+
+
+def test_forward_jacobian(expr, wrt):
+    expr = ImmutableDenseMatrix([expr]).T
+    wrt = ImmutableDenseMatrix([wrt]).T
+    jacobian = _forward_jacobian(expr, wrt)
+    zeros = ImmutableDenseMatrix.zeros(*jacobian.shape)
+    assert simplify(jacobian - expr.jacobian(wrt)) == zeros
+
+
+def test_process_cse():
+    x, y, z = symbols('x y z')
+    f = Function('f')
+    k = Function('k')
+    expr = Matrix([f(k(x,y), z) + Derivative(f(k(x,y), z), x) + k(x,y) + 2*x])
+    repl, reduced = cse(expr)
+    p_repl, p_reduced = _remove_cse_from_derivative(repl, reduced)
+
+    x0 = symbols('x0')
+    x1 = symbols('x1')
+
+    expected_output = (
+        [(x0, k(x, y)), (x1, f(x0, z))],
+        [Matrix([2 * x + x0 + x1 + Derivative(f(k(x, y), z), x)])]
+    )
+
+    assert p_repl == expected_output[0], f"Expected {expected_output[0]}, but got {p_repl}"
+    assert p_reduced == expected_output[1], f"Expected {expected_output[1]}, but got {p_reduced}"
+
+
+def test_io_matrix_type():
+    x, y, z = symbols('x y z')
+    expr = ImmutableDenseMatrix([
+        x * y + y * z + x * y * z,
+        x ** 2 + y ** 2 + z ** 2,
+        x * y + x * z + y * z
+    ])
+    wrt = ImmutableDenseMatrix([x, y, z])
+
+    replacements, reduced_expr = cse(expr)
+
+    # Test _forward_jacobian_core
+    replacements_core, jacobian_core, precomputed_fs_core = _forward_jacobian_cse(replacements, reduced_expr, wrt)
+    assert isinstance(jacobian_core[0], type(reduced_expr[0])), "Jacobian should be a Matrix of the same type as the input"
+
+    # Test _forward_jacobian_norm_in_dag_out
+    replacements_norm, jacobian_norm, precomputed_fs_norm = _forward_jacobian_norm_in_cse_out(
+        expr, wrt)
+    assert isinstance(jacobian_norm[0], type(reduced_expr[0])), "Jacobian should be a Matrix of the same type as the input"
+
+    # Test _forward_jacobian
+    jacobian = _forward_jacobian(expr, wrt)
+    assert isinstance(jacobian, type(expr)), "Jacobian should be a Matrix of the same type as the input"
+
+
+def test_forward_jacobian_input_output():
+    x, y, z = symbols('x y z')
+    expr = Matrix([
+        x * y + y * z + x * y * z,
+        x ** 2 + y ** 2 + z ** 2,
+        x * y + x * z + y * z
+    ])
+    wrt = Matrix([x, y, z])
+
+    replacements, reduced_expr = cse(expr)
+
+    # Test _forward_jacobian_core
+    replacements_core, jacobian_core, precomputed_fs_core = _forward_jacobian_cse(replacements, reduced_expr, wrt)
+    assert isinstance(replacements_core, type(replacements)), "Replacements should be a list"
+    assert isinstance(jacobian_core, type(reduced_expr)), "Jacobian should be a list"
+    assert isinstance(precomputed_fs_core, list), "Precomputed free symbols should be a list"
+    assert len(replacements_core) == len(replacements), "Length of replacements does not match"
+    assert len(jacobian_core) == 1, "Jacobian should have one element"
+    assert len(precomputed_fs_core) == len(replacements), "Length of precomputed free symbols does not match"
+
+    # Test _forward_jacobian_norm_in_dag_out
+    replacements_norm, jacobian_norm, precomputed_fs_norm = _forward_jacobian_norm_in_cse_out(expr, wrt)
+    assert isinstance(replacements_norm, type(replacements)), "Replacements should be a list"
+    assert isinstance(jacobian_norm, type(reduced_expr)), "Jacobian should be a list"
+    assert isinstance(precomputed_fs_norm, list), "Precomputed free symbols should be a list"
+    assert len(replacements_norm) == len(replacements), "Length of replacements does not match"
+    assert len(jacobian_norm) == 1, "Jacobian should have one element"
+    assert len(precomputed_fs_norm) == len(replacements), "Length of precomputed free symbols does not match"
+
+
+def test_jacobian_hessian():
+    L = Matrix(1, 2, [x**2*y, 2*y**2 + x*y])
+    syms = [x, y]
+    assert _forward_jacobian(L, syms) == Matrix([[2*x*y, x**2], [y, 4*y + x]])
+
+    L = Matrix(1, 2, [x, x**2*y**3])
+    assert _forward_jacobian(L, syms) == Matrix([[1, 0], [2*x*y**3, x**2*3*y**2]])
+
+
+def test_jacobian_metrics():
+    rho, phi = symbols("rho,phi")
+    X = Matrix([rho * cos(phi), rho * sin(phi)])
+    Y = Matrix([rho, phi])
+    J = _forward_jacobian(X, Y)
+    assert J == X.jacobian(Y.T)
+    assert J == (X.T).jacobian(Y)
+    assert J == (X.T).jacobian(Y.T)
+    g = J.T * eye(J.shape[0]) * J
+    g = g.applyfunc(trigsimp)
+    assert g == Matrix([[1, 0], [0, rho ** 2]])
+
+
+def test_jacobian2():
+    rho, phi = symbols("rho,phi")
+    X = Matrix([rho * cos(phi), rho * sin(phi), rho ** 2])
+    Y = Matrix([rho, phi])
+    J = Matrix([
+        [cos(phi), -rho * sin(phi)],
+        [sin(phi), rho * cos(phi)],
+        [2 * rho, 0],
+    ])
+    assert _forward_jacobian(X, Y) == J
+
+
+def test_issue_4564():
+    X = Matrix([exp(x + y + z), exp(x + y + z), exp(x + y + z)])
+    Y = Matrix([x, y, z])
+    for i in range(1, 3):
+        for j in range(1, 3):
+            X_slice = X[:i, :]
+            Y_slice = Y[:j, :]
+            J = _forward_jacobian(X_slice, Y_slice)
+            assert J.rows == i
+            assert J.cols == j
+            for k in range(j):
+                assert J[:, k] == X_slice
+
+
+def test_nonvectorJacobian():
+    X = Matrix([[exp(x + y + z), exp(x + y + z)],
+                [exp(x + y + z), exp(x + y + z)]])
+    raises(TypeError, lambda: _forward_jacobian(X, Matrix([x, y, z])))
+    X = X[0, :]
+    Y = Matrix([[x, y], [x, z]])
+    raises(TypeError, lambda: _forward_jacobian(X, Y))
+    raises(TypeError, lambda: _forward_jacobian(X, Matrix([[x, y], [x, z]])))
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/tests/test_epathtools.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/tests/test_epathtools.py
new file mode 100644
index 0000000000000000000000000000000000000000..a8bb47b2f2ff624077ab9905677b181c587ab5a7
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/tests/test_epathtools.py
@@ -0,0 +1,90 @@
+"""Tests for tools for manipulation of expressions using paths. """
+
+from sympy.simplify.epathtools import epath, EPath
+from sympy.testing.pytest import raises
+
+from sympy.core.numbers import E
+from sympy.functions.elementary.trigonometric import (cos, sin)
+from sympy.abc import x, y, z, t
+
+
+def test_epath_select():
+    expr = [((x, 1, t), 2), ((3, y, 4), z)]
+
+    assert epath("/*", expr) == [((x, 1, t), 2), ((3, y, 4), z)]
+    assert epath("/*/*", expr) == [(x, 1, t), 2, (3, y, 4), z]
+    assert epath("/*/*/*", expr) == [x, 1, t, 3, y, 4]
+    assert epath("/*/*/*/*", expr) == []
+
+    assert epath("/[:]", expr) == [((x, 1, t), 2), ((3, y, 4), z)]
+    assert epath("/[:]/[:]", expr) == [(x, 1, t), 2, (3, y, 4), z]
+    assert epath("/[:]/[:]/[:]", expr) == [x, 1, t, 3, y, 4]
+    assert epath("/[:]/[:]/[:]/[:]", expr) == []
+
+    assert epath("/*/[:]", expr) == [(x, 1, t), 2, (3, y, 4), z]
+
+    assert epath("/*/[0]", expr) == [(x, 1, t), (3, y, 4)]
+    assert epath("/*/[1]", expr) == [2, z]
+    assert epath("/*/[2]", expr) == []
+
+    assert epath("/*/int", expr) == [2]
+    assert epath("/*/Symbol", expr) == [z]
+    assert epath("/*/tuple", expr) == [(x, 1, t), (3, y, 4)]
+    assert epath("/*/__iter__?", expr) == [(x, 1, t), (3, y, 4)]
+
+    assert epath("/*/int|tuple", expr) == [(x, 1, t), 2, (3, y, 4)]
+    assert epath("/*/Symbol|tuple", expr) == [(x, 1, t), (3, y, 4), z]
+    assert epath("/*/int|Symbol|tuple", expr) == [(x, 1, t), 2, (3, y, 4), z]
+
+    assert epath("/*/int|__iter__?", expr) == [(x, 1, t), 2, (3, y, 4)]
+    assert epath("/*/Symbol|__iter__?", expr) == [(x, 1, t), (3, y, 4), z]
+    assert epath(
+        "/*/int|Symbol|__iter__?", expr) == [(x, 1, t), 2, (3, y, 4), z]
+
+    assert epath("/*/[0]/int", expr) == [1, 3, 4]
+    assert epath("/*/[0]/Symbol", expr) == [x, t, y]
+
+    assert epath("/*/[0]/int[1:]", expr) == [1, 4]
+    assert epath("/*/[0]/Symbol[1:]", expr) == [t, y]
+
+    assert epath("/Symbol", x + y + z + 1) == [x, y, z]
+    assert epath("/*/*/Symbol", t + sin(x + 1) + cos(x + y + E)) == [x, x, y]
+
+
+def test_epath_apply():
+    expr = [((x, 1, t), 2), ((3, y, 4), z)]
+    func = lambda expr: expr**2
+
+    assert epath("/*", expr, list) == [[(x, 1, t), 2], [(3, y, 4), z]]
+
+    assert epath("/*/[0]", expr, list) == [([x, 1, t], 2), ([3, y, 4], z)]
+    assert epath("/*/[1]", expr, func) == [((x, 1, t), 4), ((3, y, 4), z**2)]
+    assert epath("/*/[2]", expr, list) == expr
+
+    assert epath("/*/[0]/int", expr, func) == [((x, 1, t), 2), ((9, y, 16), z)]
+    assert epath("/*/[0]/Symbol", expr, func) == [((x**2, 1, t**2), 2),
+                 ((3, y**2, 4), z)]
+    assert epath(
+        "/*/[0]/int[1:]", expr, func) == [((x, 1, t), 2), ((3, y, 16), z)]
+    assert epath("/*/[0]/Symbol[1:]", expr, func) == [((x, 1, t**2),
+                 2), ((3, y**2, 4), z)]
+
+    assert epath("/Symbol", x + y + z + 1, func) == x**2 + y**2 + z**2 + 1
+    assert epath("/*/*/Symbol", t + sin(x + 1) + cos(x + y + E), func) == \
+        t + sin(x**2 + 1) + cos(x**2 + y**2 + E)
+
+
+def test_EPath():
+    assert EPath("/*/[0]")._path == "/*/[0]"
+    assert EPath(EPath("/*/[0]"))._path == "/*/[0]"
+    assert isinstance(epath("/*/[0]"), EPath) is True
+
+    assert repr(EPath("/*/[0]")) == "EPath('/*/[0]')"
+
+    raises(ValueError, lambda: EPath(""))
+    raises(ValueError, lambda: EPath("/"))
+    raises(ValueError, lambda: EPath("/|x"))
+    raises(ValueError, lambda: EPath("/["))
+    raises(ValueError, lambda: EPath("/[0]%"))
+
+    raises(NotImplementedError, lambda: EPath("Symbol"))
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/tests/test_fu.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/tests/test_fu.py
new file mode 100644
index 0000000000000000000000000000000000000000..2de2126b7333195fceeffe72dc9cb642e7eba9a9
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/tests/test_fu.py
@@ -0,0 +1,492 @@
+from sympy.core.add import Add
+from sympy.core.mul import Mul
+from sympy.core.numbers import (I, Rational, pi)
+from sympy.core.parameters import evaluate
+from sympy.core.singleton import S
+from sympy.core.symbol import (Dummy, Symbol, symbols)
+from sympy.functions.elementary.hyperbolic import (cosh, coth, csch, sech, sinh, tanh)
+from sympy.functions.elementary.miscellaneous import (root, sqrt)
+from sympy.functions.elementary.trigonometric import (cos, cot, csc, sec, sin, tan)
+from sympy.simplify.powsimp import powsimp
+from sympy.simplify.fu import (
+    L, TR1, TR10, TR10i, TR11, _TR11, TR12, TR12i, TR13, TR14, TR15, TR16,
+    TR111, TR2, TR2i, TR3, TR4, TR5, TR6, TR7, TR8, TR9, TRmorrie, _TR56 as T,
+    TRpower, hyper_as_trig, fu, process_common_addends, trig_split,
+    as_f_sign_1)
+from sympy.core.random import verify_numerically
+from sympy.abc import a, b, c, x, y, z
+
+
+def test_TR1():
+    assert TR1(2*csc(x) + sec(x)) == 1/cos(x) + 2/sin(x)
+
+
+def test_TR2():
+    assert TR2(tan(x)) == sin(x)/cos(x)
+    assert TR2(cot(x)) == cos(x)/sin(x)
+    assert TR2(tan(tan(x) - sin(x)/cos(x))) == 0
+
+
+def test_TR2i():
+    # just a reminder that ratios of powers only simplify if both
+    # numerator and denominator satisfy the condition that each
+    # has a positive base or an integer exponent; e.g. the following,
+    # at y=-1, x=1/2 gives sqrt(2)*I != -sqrt(2)*I
+    assert powsimp(2**x/y**x) != (2/y)**x
+
+    assert TR2i(sin(x)/cos(x)) == tan(x)
+    assert TR2i(sin(x)*sin(y)/cos(x)) == tan(x)*sin(y)
+    assert TR2i(1/(sin(x)/cos(x))) == 1/tan(x)
+    assert TR2i(1/(sin(x)*sin(y)/cos(x))) == 1/tan(x)/sin(y)
+    assert TR2i(sin(x)/2/(cos(x) + 1)) == sin(x)/(cos(x) + 1)/2
+
+    assert TR2i(sin(x)/2/(cos(x) + 1), half=True) == tan(x/2)/2
+    assert TR2i(sin(1)/(cos(1) + 1), half=True) == tan(S.Half)
+    assert TR2i(sin(2)/(cos(2) + 1), half=True) == tan(1)
+    assert TR2i(sin(4)/(cos(4) + 1), half=True) == tan(2)
+    assert TR2i(sin(5)/(cos(5) + 1), half=True) == tan(5*S.Half)
+    assert TR2i((cos(1) + 1)/sin(1), half=True) == 1/tan(S.Half)
+    assert TR2i((cos(2) + 1)/sin(2), half=True) == 1/tan(1)
+    assert TR2i((cos(4) + 1)/sin(4), half=True) == 1/tan(2)
+    assert TR2i((cos(5) + 1)/sin(5), half=True) == 1/tan(5*S.Half)
+    assert TR2i((cos(1) + 1)**(-a)*sin(1)**a, half=True) == tan(S.Half)**a
+    assert TR2i((cos(2) + 1)**(-a)*sin(2)**a, half=True) == tan(1)**a
+    assert TR2i((cos(4) + 1)**(-a)*sin(4)**a, half=True) == (cos(4) + 1)**(-a)*sin(4)**a
+    assert TR2i((cos(5) + 1)**(-a)*sin(5)**a, half=True) == (cos(5) + 1)**(-a)*sin(5)**a
+    assert TR2i((cos(1) + 1)**a*sin(1)**(-a), half=True) == tan(S.Half)**(-a)
+    assert TR2i((cos(2) + 1)**a*sin(2)**(-a), half=True) == tan(1)**(-a)
+    assert TR2i((cos(4) + 1)**a*sin(4)**(-a), half=True) == (cos(4) + 1)**a*sin(4)**(-a)
+    assert TR2i((cos(5) + 1)**a*sin(5)**(-a), half=True) == (cos(5) + 1)**a*sin(5)**(-a)
+
+    i = symbols('i', integer=True)
+    assert TR2i(((cos(5) + 1)**i*sin(5)**(-i)), half=True) == tan(5*S.Half)**(-i)
+    assert TR2i(1/((cos(5) + 1)**i*sin(5)**(-i)), half=True) == tan(5*S.Half)**i
+
+
+def test_TR3():
+    assert TR3(cos(y - x*(y - x))) == cos(x*(x - y) + y)
+    assert cos(pi/2 + x) == -sin(x)
+    assert cos(30*pi/2 + x) == -cos(x)
+
+    for f in (cos, sin, tan, cot, csc, sec):
+        i = f(pi*Rational(3, 7))
+        j = TR3(i)
+        assert verify_numerically(i, j) and i.func != j.func
+
+    with evaluate(False):
+        eq = cos(9*pi/22)
+    assert eq.has(9*pi) and TR3(eq) == sin(pi/11)
+
+
+def test_TR4():
+    for i in [0, pi/6, pi/4, pi/3, pi/2]:
+        with evaluate(False):
+            eq = cos(i)
+        assert isinstance(eq, cos) and TR4(eq) == cos(i)
+
+
+def test__TR56():
+    h = lambda x: 1 - x
+    assert T(sin(x)**3, sin, cos, h, 4, False) == sin(x)*(-cos(x)**2 + 1)
+    assert T(sin(x)**10, sin, cos, h, 4, False) == sin(x)**10
+    assert T(sin(x)**6, sin, cos, h, 6, False) == (-cos(x)**2 + 1)**3
+    assert T(sin(x)**6, sin, cos, h, 6, True) == sin(x)**6
+    assert T(sin(x)**8, sin, cos, h, 10, True) == (-cos(x)**2 + 1)**4
+
+    # issue 17137
+    assert T(sin(x)**I, sin, cos, h, 4, True) == sin(x)**I
+    assert T(sin(x)**(2*I + 1), sin, cos, h, 4, True) == sin(x)**(2*I + 1)
+
+
+def test_TR5():
+    assert TR5(sin(x)**2) == -cos(x)**2 + 1
+    assert TR5(sin(x)**-2) == sin(x)**(-2)
+    assert TR5(sin(x)**4) == (-cos(x)**2 + 1)**2
+
+
+def test_TR6():
+    assert TR6(cos(x)**2) == -sin(x)**2 + 1
+    assert TR6(cos(x)**-2) == cos(x)**(-2)
+    assert TR6(cos(x)**4) == (-sin(x)**2 + 1)**2
+
+
+def test_TR7():
+    assert TR7(cos(x)**2) == cos(2*x)/2 + S.Half
+    assert TR7(cos(x)**2 + 1) == cos(2*x)/2 + Rational(3, 2)
+
+
+def test_TR8():
+    assert TR8(cos(2)*cos(3)) == cos(5)/2 + cos(1)/2
+    assert TR8(cos(2)*sin(3)) == sin(5)/2 + sin(1)/2
+    assert TR8(sin(2)*sin(3)) == -cos(5)/2 + cos(1)/2
+    assert TR8(sin(1)*sin(2)*sin(3)) == sin(4)/4 - sin(6)/4 + sin(2)/4
+    assert TR8(cos(2)*cos(3)*cos(4)*cos(5)) == \
+        cos(4)/4 + cos(10)/8 + cos(2)/8 + cos(8)/8 + cos(14)/8 + \
+        cos(6)/8 + Rational(1, 8)
+    assert TR8(cos(2)*cos(3)*cos(4)*cos(5)*cos(6)) == \
+        cos(10)/8 + cos(4)/8 + 3*cos(2)/16 + cos(16)/16 + cos(8)/8 + \
+        cos(14)/16 + cos(20)/16 + cos(12)/16 + Rational(1, 16) + cos(6)/8
+    assert TR8(sin(pi*Rational(3, 7))**2*cos(pi*Rational(3, 7))**2/(16*sin(pi/7)**2)) == Rational(1, 64)
+
+def test_TR9():
+    a = S.Half
+    b = 3*a
+    assert TR9(a) == a
+    assert TR9(cos(1) + cos(2)) == 2*cos(a)*cos(b)
+    assert TR9(cos(1) - cos(2)) == 2*sin(a)*sin(b)
+    assert TR9(sin(1) - sin(2)) == -2*sin(a)*cos(b)
+    assert TR9(sin(1) + sin(2)) == 2*sin(b)*cos(a)
+    assert TR9(cos(1) + 2*sin(1) + 2*sin(2)) == cos(1) + 4*sin(b)*cos(a)
+    assert TR9(cos(4) + cos(2) + 2*cos(1)*cos(3)) == 4*cos(1)*cos(3)
+    assert TR9((cos(4) + cos(2))/cos(3)/2 + cos(3)) == 2*cos(1)*cos(2)
+    assert TR9(cos(3) + cos(4) + cos(5) + cos(6)) == \
+        4*cos(S.Half)*cos(1)*cos(Rational(9, 2))
+    assert TR9(cos(3) + cos(3)*cos(2)) == cos(3) + cos(2)*cos(3)
+    assert TR9(-cos(y) + cos(x*y)) == -2*sin(x*y/2 - y/2)*sin(x*y/2 + y/2)
+    assert TR9(-sin(y) + sin(x*y)) == 2*sin(x*y/2 - y/2)*cos(x*y/2 + y/2)
+    c = cos(x)
+    s = sin(x)
+    for si in ((1, 1), (1, -1), (-1, 1), (-1, -1)):
+        for a in ((c, s), (s, c), (cos(x), cos(x*y)), (sin(x), sin(x*y))):
+            args = zip(si, a)
+            ex = Add(*[Mul(*ai) for ai in args])
+            t = TR9(ex)
+            assert not (a[0].func == a[1].func and (
+                not verify_numerically(ex, t.expand(trig=True)) or t.is_Add)
+                or a[1].func != a[0].func and ex != t)
+
+
+def test_TR10():
+    assert TR10(cos(a + b)) == -sin(a)*sin(b) + cos(a)*cos(b)
+    assert TR10(sin(a + b)) == sin(a)*cos(b) + sin(b)*cos(a)
+    assert TR10(sin(a + b + c)) == \
+        (-sin(a)*sin(b) + cos(a)*cos(b))*sin(c) + \
+        (sin(a)*cos(b) + sin(b)*cos(a))*cos(c)
+    assert TR10(cos(a + b + c)) == \
+        (-sin(a)*sin(b) + cos(a)*cos(b))*cos(c) - \
+        (sin(a)*cos(b) + sin(b)*cos(a))*sin(c)
+
+
+def test_TR10i():
+    assert TR10i(cos(1)*cos(3) + sin(1)*sin(3)) == cos(2)
+    assert TR10i(cos(1)*cos(3) - sin(1)*sin(3)) == cos(4)
+    assert TR10i(cos(1)*sin(3) - sin(1)*cos(3)) == sin(2)
+    assert TR10i(cos(1)*sin(3) + sin(1)*cos(3)) == sin(4)
+    assert TR10i(cos(1)*sin(3) + sin(1)*cos(3) + 7) == sin(4) + 7
+    assert TR10i(cos(1)*sin(3) + sin(1)*cos(3) + cos(3)) == cos(3) + sin(4)
+    assert TR10i(2*cos(1)*sin(3) + 2*sin(1)*cos(3) + cos(3)) == \
+        2*sin(4) + cos(3)
+    assert TR10i(cos(2)*cos(3) + sin(2)*(cos(1)*sin(2) + cos(2)*sin(1))) == \
+        cos(1)
+    eq = (cos(2)*cos(3) + sin(2)*(
+        cos(1)*sin(2) + cos(2)*sin(1)))*cos(5) + sin(1)*sin(5)
+    assert TR10i(eq) == TR10i(eq.expand()) == cos(4)
+    assert TR10i(sqrt(2)*cos(x)*x + sqrt(6)*sin(x)*x) == \
+        2*sqrt(2)*x*sin(x + pi/6)
+    assert TR10i(cos(x)/sqrt(6) + sin(x)/sqrt(2) +
+            cos(x)/sqrt(6)/3 + sin(x)/sqrt(2)/3) == 4*sqrt(6)*sin(x + pi/6)/9
+    assert TR10i(cos(x)/sqrt(6) + sin(x)/sqrt(2) +
+            cos(y)/sqrt(6)/3 + sin(y)/sqrt(2)/3) == \
+        sqrt(6)*sin(x + pi/6)/3 + sqrt(6)*sin(y + pi/6)/9
+    assert TR10i(cos(x) + sqrt(3)*sin(x) + 2*sqrt(3)*cos(x + pi/6)) == 4*cos(x)
+    assert TR10i(cos(x) + sqrt(3)*sin(x) +
+            2*sqrt(3)*cos(x + pi/6) + 4*sin(x)) == 4*sqrt(2)*sin(x + pi/4)
+    assert TR10i(cos(2)*sin(3) + sin(2)*cos(4)) == \
+        sin(2)*cos(4) + sin(3)*cos(2)
+
+    A = Symbol('A', commutative=False)
+    assert TR10i(sqrt(2)*cos(x)*A + sqrt(6)*sin(x)*A) == \
+        2*sqrt(2)*sin(x + pi/6)*A
+
+
+    c = cos(x)
+    s = sin(x)
+    h = sin(y)
+    r = cos(y)
+    for si in ((1, 1), (1, -1), (-1, 1), (-1, -1)):
+        for argsi in ((c*r, s*h), (c*h, s*r)): # explicit 2-args
+            args = zip(si, argsi)
+            ex = Add(*[Mul(*ai) for ai in args])
+            t = TR10i(ex)
+            assert not (ex - t.expand(trig=True) or t.is_Add)
+
+    c = cos(x)
+    s = sin(x)
+    h = sin(pi/6)
+    r = cos(pi/6)
+    for si in ((1, 1), (1, -1), (-1, 1), (-1, -1)):
+        for argsi in ((c*r, s*h), (c*h, s*r)): # induced
+            args = zip(si, argsi)
+            ex = Add(*[Mul(*ai) for ai in args])
+            t = TR10i(ex)
+            assert not (ex - t.expand(trig=True) or t.is_Add)
+
+
+def test_TR11():
+
+    assert TR11(sin(2*x)) == 2*sin(x)*cos(x)
+    assert TR11(sin(4*x)) == 4*((-sin(x)**2 + cos(x)**2)*sin(x)*cos(x))
+    assert TR11(sin(x*Rational(4, 3))) == \
+        4*((-sin(x/3)**2 + cos(x/3)**2)*sin(x/3)*cos(x/3))
+
+    assert TR11(cos(2*x)) == -sin(x)**2 + cos(x)**2
+    assert TR11(cos(4*x)) == \
+        (-sin(x)**2 + cos(x)**2)**2 - 4*sin(x)**2*cos(x)**2
+
+    assert TR11(cos(2)) == cos(2)
+
+    assert TR11(cos(pi*Rational(3, 7)), pi*Rational(2, 7)) == -cos(pi*Rational(2, 7))**2 + sin(pi*Rational(2, 7))**2
+    assert TR11(cos(4), 2) == -sin(2)**2 + cos(2)**2
+    assert TR11(cos(6), 2) == cos(6)
+    assert TR11(sin(x)/cos(x/2), x/2) == 2*sin(x/2)
+
+def test__TR11():
+
+    assert _TR11(sin(x/3)*sin(2*x)*sin(x/4)/(cos(x/6)*cos(x/8))) == \
+        4*sin(x/8)*sin(x/6)*sin(2*x),_TR11(sin(x/3)*sin(2*x)*sin(x/4)/(cos(x/6)*cos(x/8)))
+    assert _TR11(sin(x/3)/cos(x/6)) == 2*sin(x/6)
+
+    assert _TR11(cos(x/6)/sin(x/3)) == 1/(2*sin(x/6))
+    assert _TR11(sin(2*x)*cos(x/8)/sin(x/4)) == sin(2*x)/(2*sin(x/8)), _TR11(sin(2*x)*cos(x/8)/sin(x/4))
+    assert _TR11(sin(x)/sin(x/2)) == 2*cos(x/2)
+
+
+def test_TR12():
+    assert TR12(tan(x + y)) == (tan(x) + tan(y))/(-tan(x)*tan(y) + 1)
+    assert TR12(tan(x + y + z)) ==\
+        (tan(z) + (tan(x) + tan(y))/(-tan(x)*tan(y) + 1))/(
+        1 - (tan(x) + tan(y))*tan(z)/(-tan(x)*tan(y) + 1))
+    assert TR12(tan(x*y)) == tan(x*y)
+
+
+def test_TR13():
+    assert TR13(tan(3)*tan(2)) == -tan(2)/tan(5) - tan(3)/tan(5) + 1
+    assert TR13(cot(3)*cot(2)) == 1 + cot(3)*cot(5) + cot(2)*cot(5)
+    assert TR13(tan(1)*tan(2)*tan(3)) == \
+        (-tan(2)/tan(5) - tan(3)/tan(5) + 1)*tan(1)
+    assert TR13(tan(1)*tan(2)*cot(3)) == \
+        (-tan(2)/tan(3) + 1 - tan(1)/tan(3))*cot(3)
+
+
+def test_L():
+    assert L(cos(x) + sin(x)) == 2
+
+
+def test_fu():
+
+    assert fu(sin(50)**2 + cos(50)**2 + sin(pi/6)) == Rational(3, 2)
+    assert fu(sqrt(6)*cos(x) + sqrt(2)*sin(x)) == 2*sqrt(2)*sin(x + pi/3)
+
+
+    eq = sin(x)**4 - cos(y)**2 + sin(y)**2 + 2*cos(x)**2
+    assert fu(eq) == cos(x)**4 - 2*cos(y)**2 + 2
+
+    assert fu(S.Half - cos(2*x)/2) == sin(x)**2
+
+    assert fu(sin(a)*(cos(b) - sin(b)) + cos(a)*(sin(b) + cos(b))) == \
+        sqrt(2)*sin(a + b + pi/4)
+
+    assert fu(sqrt(3)*cos(x)/2 + sin(x)/2) == sin(x + pi/3)
+
+    assert fu(1 - sin(2*x)**2/4 - sin(y)**2 - cos(x)**4) == \
+        -cos(x)**2 + cos(y)**2
+
+    assert fu(cos(pi*Rational(4, 9))) == sin(pi/18)
+    assert fu(cos(pi/9)*cos(pi*Rational(2, 9))*cos(pi*Rational(3, 9))*cos(pi*Rational(4, 9))) == Rational(1, 16)
+
+    assert fu(
+        tan(pi*Rational(7, 18)) + tan(pi*Rational(5, 18)) - sqrt(3)*tan(pi*Rational(5, 18))*tan(pi*Rational(7, 18))) == \
+        -sqrt(3)
+
+    assert fu(tan(1)*tan(2)) == tan(1)*tan(2)
+
+    expr = Mul(*[cos(2**i) for i in range(10)])
+    assert fu(expr) == sin(1024)/(1024*sin(1))
+
+    # issue #18059:
+    assert fu(cos(x) + sqrt(sin(x)**2)) == cos(x) + sqrt(sin(x)**2)
+
+    assert fu((-14*sin(x)**3 + 35*sin(x) + 6*sqrt(3)*cos(x)**3 + 9*sqrt(3)*cos(x))/((cos(2*x) + 4))) == \
+        7*sin(x) + 3*sqrt(3)*cos(x)
+
+
+def test_objective():
+    assert fu(sin(x)/cos(x), measure=lambda x: x.count_ops()) == \
+            tan(x)
+    assert fu(sin(x)/cos(x), measure=lambda x: -x.count_ops()) == \
+            sin(x)/cos(x)
+
+
+def test_process_common_addends():
+    # this tests that the args are not evaluated as they are given to do
+    # and that key2 works when key1 is False
+    do = lambda x: Add(*[i**(i%2) for i in x.args])
+    assert process_common_addends(Add(*[1, 2, 3, 4], evaluate=False), do,
+        key2=lambda x: x%2, key1=False) == 1**1 + 3**1 + 2**0 + 4**0
+
+
+def test_trig_split():
+    assert trig_split(cos(x), cos(y)) == (1, 1, 1, x, y, True)
+    assert trig_split(2*cos(x), -2*cos(y)) == (2, 1, -1, x, y, True)
+    assert trig_split(cos(x)*sin(y), cos(y)*sin(y)) == \
+        (sin(y), 1, 1, x, y, True)
+
+    assert trig_split(cos(x), -sqrt(3)*sin(x), two=True) == \
+        (2, 1, -1, x, pi/6, False)
+    assert trig_split(cos(x), sin(x), two=True) == \
+        (sqrt(2), 1, 1, x, pi/4, False)
+    assert trig_split(cos(x), -sin(x), two=True) == \
+        (sqrt(2), 1, -1, x, pi/4, False)
+    assert trig_split(sqrt(2)*cos(x), -sqrt(6)*sin(x), two=True) == \
+        (2*sqrt(2), 1, -1, x, pi/6, False)
+    assert trig_split(-sqrt(6)*cos(x), -sqrt(2)*sin(x), two=True) == \
+        (-2*sqrt(2), 1, 1, x, pi/3, False)
+    assert trig_split(cos(x)/sqrt(6), sin(x)/sqrt(2), two=True) == \
+        (sqrt(6)/3, 1, 1, x, pi/6, False)
+    assert trig_split(-sqrt(6)*cos(x)*sin(y),
+            -sqrt(2)*sin(x)*sin(y), two=True) == \
+        (-2*sqrt(2)*sin(y), 1, 1, x, pi/3, False)
+
+    assert trig_split(cos(x), sin(x)) is None
+    assert trig_split(cos(x), sin(z)) is None
+    assert trig_split(2*cos(x), -sin(x)) is None
+    assert trig_split(cos(x), -sqrt(3)*sin(x)) is None
+    assert trig_split(cos(x)*cos(y), sin(x)*sin(z)) is None
+    assert trig_split(cos(x)*cos(y), sin(x)*sin(y)) is None
+    assert trig_split(-sqrt(6)*cos(x), sqrt(2)*sin(x)*sin(y), two=True) is \
+        None
+
+    assert trig_split(sqrt(3)*sqrt(x), cos(3), two=True) is None
+    assert trig_split(sqrt(3)*root(x, 3), sin(3)*cos(2), two=True) is None
+    assert trig_split(cos(5)*cos(6), cos(7)*sin(5), two=True) is None
+
+
+def test_TRmorrie():
+    assert TRmorrie(7*Mul(*[cos(i) for i in range(10)])) == \
+        7*sin(12)*sin(16)*cos(5)*cos(7)*cos(9)/(64*sin(1)*sin(3))
+    assert TRmorrie(x) == x
+    assert TRmorrie(2*x) == 2*x
+    e = cos(pi/7)*cos(pi*Rational(2, 7))*cos(pi*Rational(4, 7))
+    assert TR8(TRmorrie(e)) == Rational(-1, 8)
+    e = Mul(*[cos(2**i*pi/17) for i in range(1, 17)])
+    assert TR8(TR3(TRmorrie(e))) == Rational(1, 65536)
+    # issue 17063
+    eq = cos(x)/cos(x/2)
+    assert TRmorrie(eq) == eq
+    # issue #20430
+    eq = cos(x/2)*sin(x/2)*cos(x)**3
+    assert TRmorrie(eq) == sin(2*x)*cos(x)**2/4
+
+
+def test_TRpower():
+    assert TRpower(1/sin(x)**2) == 1/sin(x)**2
+    assert TRpower(cos(x)**3*sin(x/2)**4) == \
+        (3*cos(x)/4 + cos(3*x)/4)*(-cos(x)/2 + cos(2*x)/8 + Rational(3, 8))
+    for k in range(2, 8):
+        assert verify_numerically(sin(x)**k, TRpower(sin(x)**k))
+        assert verify_numerically(cos(x)**k, TRpower(cos(x)**k))
+
+
+def test_hyper_as_trig():
+    from sympy.simplify.fu import _osborne, _osbornei
+
+    eq = sinh(x)**2 + cosh(x)**2
+    t, f = hyper_as_trig(eq)
+    assert f(fu(t)) == cosh(2*x)
+    e, f = hyper_as_trig(tanh(x + y))
+    assert f(TR12(e)) == (tanh(x) + tanh(y))/(tanh(x)*tanh(y) + 1)
+
+    d = Dummy()
+    assert _osborne(sinh(x), d) == I*sin(x*d)
+    assert _osborne(tanh(x), d) == I*tan(x*d)
+    assert _osborne(coth(x), d) == cot(x*d)/I
+    assert _osborne(cosh(x), d) == cos(x*d)
+    assert _osborne(sech(x), d) == sec(x*d)
+    assert _osborne(csch(x), d) == csc(x*d)/I
+    for func in (sinh, cosh, tanh, coth, sech, csch):
+        h = func(pi)
+        assert _osbornei(_osborne(h, d), d) == h
+    # /!\ the _osborne functions are not meant to work
+    # in the o(i(trig, d), d) direction so we just check
+    # that they work as they are supposed to work
+    assert _osbornei(cos(x*y + z), y) == cosh(x + z*I)
+    assert _osbornei(sin(x*y + z), y) == sinh(x + z*I)/I
+    assert _osbornei(tan(x*y + z), y) == tanh(x + z*I)/I
+    assert _osbornei(cot(x*y + z), y) == coth(x + z*I)*I
+    assert _osbornei(sec(x*y + z), y) == sech(x + z*I)
+    assert _osbornei(csc(x*y + z), y) == csch(x + z*I)*I
+
+
+def test_TR12i():
+    ta, tb, tc = [tan(i) for i in (a, b, c)]
+    assert TR12i((ta + tb)/(-ta*tb + 1)) == tan(a + b)
+    assert TR12i((ta + tb)/(ta*tb - 1)) == -tan(a + b)
+    assert TR12i((-ta - tb)/(ta*tb - 1)) == tan(a + b)
+    eq = (ta + tb)/(-ta*tb + 1)**2*(-3*ta - 3*tc)/(2*(ta*tc - 1))
+    assert TR12i(eq.expand()) == \
+        -3*tan(a + b)*tan(a + c)/(tan(a) + tan(b) - 1)/2
+    assert TR12i(tan(x)/sin(x)) == tan(x)/sin(x)
+    eq = (ta + cos(2))/(-ta*tb + 1)
+    assert TR12i(eq) == eq
+    eq = (ta + tb + 2)**2/(-ta*tb + 1)
+    assert TR12i(eq) == eq
+    eq = ta/(-ta*tb + 1)
+    assert TR12i(eq) == eq
+    eq = (((ta + tb)*(a + 1)).expand())**2/(ta*tb - 1)
+    assert TR12i(eq) == -(a + 1)**2*tan(a + b)
+
+
+def test_TR14():
+    eq = (cos(x) - 1)*(cos(x) + 1)
+    ans = -sin(x)**2
+    assert TR14(eq) == ans
+    assert TR14(1/eq) == 1/ans
+    assert TR14((cos(x) - 1)**2*(cos(x) + 1)**2) == ans**2
+    assert TR14((cos(x) - 1)**2*(cos(x) + 1)**3) == ans**2*(cos(x) + 1)
+    assert TR14((cos(x) - 1)**3*(cos(x) + 1)**2) == ans**2*(cos(x) - 1)
+    eq = (cos(x) - 1)**y*(cos(x) + 1)**y
+    assert TR14(eq) == eq
+    eq = (cos(x) - 2)**y*(cos(x) + 1)
+    assert TR14(eq) == eq
+    eq = (tan(x) - 2)**2*(cos(x) + 1)
+    assert TR14(eq) == eq
+    i = symbols('i', integer=True)
+    assert TR14((cos(x) - 1)**i*(cos(x) + 1)**i) == ans**i
+    assert TR14((sin(x) - 1)**i*(sin(x) + 1)**i) == (-cos(x)**2)**i
+    # could use extraction in this case
+    eq = (cos(x) - 1)**(i + 1)*(cos(x) + 1)**i
+    assert TR14(eq) in [(cos(x) - 1)*ans**i, eq]
+
+    assert TR14((sin(x) - 1)*(sin(x) + 1)) == -cos(x)**2
+    p1 = (cos(x) + 1)*(cos(x) - 1)
+    p2 = (cos(y) - 1)*2*(cos(y) + 1)
+    p3 = (3*(cos(y) - 1))*(3*(cos(y) + 1))
+    assert TR14(p1*p2*p3*(x - 1)) == -18*((x - 1)*sin(x)**2*sin(y)**4)
+
+
+def test_TR15_16_17():
+    assert TR15(1 - 1/sin(x)**2) == -cot(x)**2
+    assert TR16(1 - 1/cos(x)**2) == -tan(x)**2
+    assert TR111(1 - 1/tan(x)**2) == 1 - cot(x)**2
+
+
+def test_as_f_sign_1():
+    assert as_f_sign_1(x + 1) == (1, x, 1)
+    assert as_f_sign_1(x - 1) == (1, x, -1)
+    assert as_f_sign_1(-x + 1) == (-1, x, -1)
+    assert as_f_sign_1(-x - 1) == (-1, x, 1)
+    assert as_f_sign_1(2*x + 2) == (2, x, 1)
+    assert as_f_sign_1(x*y - y) == (y, x, -1)
+    assert as_f_sign_1(-x*y + y) == (-y, x, -1)
+
+
+def test_issue_25590():
+    A = Symbol('A', commutative=False)
+    B = Symbol('B', commutative=False)
+
+    assert TR8(2*cos(x)*sin(x)*B*A) == sin(2*x)*B*A
+    assert TR13(tan(2)*tan(3)*B*A) == (-tan(2)/tan(5) - tan(3)/tan(5) + 1)*B*A
+
+    # XXX The result may not be optimal than
+    # sin(2*x)*B*A + cos(x)**2 and may change in the future
+    assert (2*cos(x)*sin(x)*B*A + cos(x)**2).simplify() == sin(2*x)*B*A + cos(2*x)/2 + S.One/2
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/tests/test_function.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/tests/test_function.py
new file mode 100644
index 0000000000000000000000000000000000000000..441b9faf1bb3c5e7f2279b2a61066d050e45f773
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/tests/test_function.py
@@ -0,0 +1,54 @@
+""" Unit tests for Hyper_Function"""
+from sympy.core import symbols, Dummy, Tuple, S, Rational
+from sympy.functions import hyper
+
+from sympy.simplify.hyperexpand import Hyper_Function
+
+def test_attrs():
+    a, b = symbols('a, b', cls=Dummy)
+    f = Hyper_Function([2, a], [b])
+    assert f.ap == Tuple(2, a)
+    assert f.bq == Tuple(b)
+    assert f.args == (Tuple(2, a), Tuple(b))
+    assert f.sizes == (2, 1)
+
+def test_call():
+    a, b, x = symbols('a, b, x', cls=Dummy)
+    f = Hyper_Function([2, a], [b])
+    assert f(x) == hyper([2, a], [b], x)
+
+def test_has():
+    a, b, c = symbols('a, b, c', cls=Dummy)
+    f = Hyper_Function([2, -a], [b])
+    assert f.has(a)
+    assert f.has(Tuple(b))
+    assert not f.has(c)
+
+def test_eq():
+    assert Hyper_Function([1], []) == Hyper_Function([1], [])
+    assert (Hyper_Function([1], []) != Hyper_Function([1], [])) is False
+    assert Hyper_Function([1], []) != Hyper_Function([2], [])
+    assert Hyper_Function([1], []) != Hyper_Function([1, 2], [])
+    assert Hyper_Function([1], []) != Hyper_Function([1], [2])
+
+def test_gamma():
+    assert Hyper_Function([2, 3], [-1]).gamma == 0
+    assert Hyper_Function([-2, -3], [-1]).gamma == 2
+    n = Dummy(integer=True)
+    assert Hyper_Function([-1, n, 1], []).gamma == 1
+    assert Hyper_Function([-1, -n, 1], []).gamma == 1
+    p = Dummy(integer=True, positive=True)
+    assert Hyper_Function([-1, p, 1], []).gamma == 1
+    assert Hyper_Function([-1, -p, 1], []).gamma == 2
+
+def test_suitable_origin():
+    assert Hyper_Function((S.Half,), (Rational(3, 2),))._is_suitable_origin() is True
+    assert Hyper_Function((S.Half,), (S.Half,))._is_suitable_origin() is False
+    assert Hyper_Function((S.Half,), (Rational(-1, 2),))._is_suitable_origin() is False
+    assert Hyper_Function((S.Half,), (0,))._is_suitable_origin() is False
+    assert Hyper_Function((S.Half,), (-1, 1,))._is_suitable_origin() is False
+    assert Hyper_Function((S.Half, 0), (1,))._is_suitable_origin() is False
+    assert Hyper_Function((S.Half, 1),
+            (2, Rational(-2, 3)))._is_suitable_origin() is True
+    assert Hyper_Function((S.Half, 1),
+            (2, Rational(-2, 3), Rational(3, 2)))._is_suitable_origin() is True
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/tests/test_gammasimp.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/tests/test_gammasimp.py
new file mode 100644
index 0000000000000000000000000000000000000000..e4c73093250b279510e3c2274db22818a9adffd8
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/tests/test_gammasimp.py
@@ -0,0 +1,127 @@
+from sympy.core.function import Function
+from sympy.core.numbers import (Rational, pi)
+from sympy.core.singleton import S
+from sympy.core.symbol import symbols
+from sympy.functions.combinatorial.factorials import (rf, binomial, factorial)
+from sympy.functions.elementary.exponential import exp
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.piecewise import Piecewise
+from sympy.functions.elementary.trigonometric import (cos, sin)
+from sympy.functions.special.gamma_functions import gamma
+from sympy.simplify.gammasimp import gammasimp
+from sympy.simplify.powsimp import powsimp
+from sympy.simplify.simplify import simplify
+
+from sympy.abc import x, y, n, k
+
+
+def test_gammasimp():
+    R = Rational
+
+    # was part of test_combsimp_gamma() in test_combsimp.py
+    assert gammasimp(gamma(x)) == gamma(x)
+    assert gammasimp(gamma(x + 1)/x) == gamma(x)
+    assert gammasimp(gamma(x)/(x - 1)) == gamma(x - 1)
+    assert gammasimp(x*gamma(x)) == gamma(x + 1)
+    assert gammasimp((x + 1)*gamma(x + 1)) == gamma(x + 2)
+    assert gammasimp(gamma(x + y)*(x + y)) == gamma(x + y + 1)
+    assert gammasimp(x/gamma(x + 1)) == 1/gamma(x)
+    assert gammasimp((x + 1)**2/gamma(x + 2)) == (x + 1)/gamma(x + 1)
+    assert gammasimp(x*gamma(x) + gamma(x + 3)/(x + 2)) == \
+        (x + 2)*gamma(x + 1)
+
+    assert gammasimp(gamma(2*x)*x) == gamma(2*x + 1)/2
+    assert gammasimp(gamma(2*x)/(x - S.Half)) == 2*gamma(2*x - 1)
+
+    assert gammasimp(gamma(x)*gamma(1 - x)) == pi/sin(pi*x)
+    assert gammasimp(gamma(x)*gamma(-x)) == -pi/(x*sin(pi*x))
+    assert gammasimp(1/gamma(x + 3)/gamma(1 - x)) == \
+        sin(pi*x)/(pi*x*(x + 1)*(x + 2))
+
+    assert gammasimp(factorial(n + 2)) == gamma(n + 3)
+    assert gammasimp(binomial(n, k)) == \
+        gamma(n + 1)/(gamma(k + 1)*gamma(-k + n + 1))
+
+    assert powsimp(gammasimp(
+        gamma(x)*gamma(x + S.Half)*gamma(y)/gamma(x + y))) == \
+        2**(-2*x + 1)*sqrt(pi)*gamma(2*x)*gamma(y)/gamma(x + y)
+    assert gammasimp(1/gamma(x)/gamma(x - Rational(1, 3))/gamma(x + Rational(1, 3))) == \
+        3**(3*x - Rational(3, 2))/(2*pi*gamma(3*x - 1))
+    assert simplify(
+        gamma(S.Half + x/2)*gamma(1 + x/2)/gamma(1 + x)/sqrt(pi)*2**x) == 1
+    assert gammasimp(gamma(Rational(-1, 4))*gamma(Rational(-3, 4))) == 16*sqrt(2)*pi/3
+
+    assert powsimp(gammasimp(gamma(2*x)/gamma(x))) == \
+        2**(2*x - 1)*gamma(x + S.Half)/sqrt(pi)
+
+    # issue 6792
+    e = (-gamma(k)*gamma(k + 2) + gamma(k + 1)**2)/gamma(k)**2
+    assert gammasimp(e) == -k
+    assert gammasimp(1/e) == -1/k
+    e = (gamma(x) + gamma(x + 1))/gamma(x)
+    assert gammasimp(e) == x + 1
+    assert gammasimp(1/e) == 1/(x + 1)
+    e = (gamma(x) + gamma(x + 2))*(gamma(x - 1) + gamma(x))/gamma(x)
+    assert gammasimp(e) == (x**2 + x + 1)*gamma(x + 1)/(x - 1)
+    e = (-gamma(k)*gamma(k + 2) + gamma(k + 1)**2)/gamma(k)**2
+    assert gammasimp(e**2) == k**2
+    assert gammasimp(e**2/gamma(k + 1)) == k/gamma(k)
+    a = R(1, 2) + R(1, 3)
+    b = a + R(1, 3)
+    assert gammasimp(gamma(2*k)/gamma(k)*gamma(k + a)*gamma(k + b)
+        ) == 3*2**(2*k + 1)*3**(-3*k - 2)*sqrt(pi)*gamma(3*k + R(3, 2))/2
+
+    # issue 9699
+    assert gammasimp((x + 1)*factorial(x)/gamma(y)) == gamma(x + 2)/gamma(y)
+    assert gammasimp(rf(x + n, k)*binomial(n, k)).simplify() == Piecewise(
+        (gamma(n + 1)*gamma(k + n + x)/(gamma(k + 1)*gamma(n + x)*gamma(-k + n + 1)), n > -x),
+        ((-1)**k*gamma(n + 1)*gamma(-n - x + 1)/(gamma(k + 1)*gamma(-k + n + 1)*gamma(-k - n - x + 1)), True))
+
+    A, B = symbols('A B', commutative=False)
+    assert gammasimp(e*B*A) == gammasimp(e)*B*A
+
+    # check iteration
+    assert gammasimp(gamma(2*k)/gamma(k)*gamma(-k - R(1, 2))) == (
+        -2**(2*k + 1)*sqrt(pi)/(2*((2*k + 1)*cos(pi*k))))
+    assert gammasimp(
+        gamma(k)*gamma(k + R(1, 3))*gamma(k + R(2, 3))/gamma(k*R(3, 2))) == (
+        3*2**(3*k + 1)*3**(-3*k - S.Half)*sqrt(pi)*gamma(k*R(3, 2) + S.Half)/2)
+
+    # issue 6153
+    assert gammasimp(gamma(Rational(1, 4))/gamma(Rational(5, 4))) == 4
+
+    # was part of test_combsimp() in test_combsimp.py
+    assert gammasimp(binomial(n + 2, k + S.Half)) == gamma(n + 3)/ \
+        (gamma(k + R(3, 2))*gamma(-k + n + R(5, 2)))
+    assert gammasimp(binomial(n + 2, k + 2.0)) == \
+        gamma(n + 3)/(gamma(k + 3.0)*gamma(-k + n + 1))
+
+    # issue 11548
+    assert gammasimp(binomial(0, x)) == sin(pi*x)/(pi*x)
+
+    e = gamma(n + Rational(1, 3))*gamma(n + R(2, 3))
+    assert gammasimp(e) == e
+    assert gammasimp(gamma(4*n + S.Half)/gamma(2*n - R(3, 4))) == \
+        2**(4*n - R(5, 2))*(8*n - 3)*gamma(2*n + R(3, 4))/sqrt(pi)
+
+    i, m = symbols('i m', integer = True)
+    e = gamma(exp(i))
+    assert gammasimp(e) == e
+    e = gamma(m + 3)
+    assert gammasimp(e) == e
+    e = gamma(m + 1)/(gamma(i + 1)*gamma(-i + m + 1))
+    assert gammasimp(e) == e
+
+    p = symbols("p", integer=True, positive=True)
+    assert gammasimp(gamma(-p + 4)) == gamma(-p + 4)
+
+
+def test_issue_22606():
+    fx = Function('f')(x)
+    eq = x + gamma(y)
+    # seems like ans should be `eq`, not `(x*y + gamma(y + 1))/y`
+    ans = gammasimp(eq)
+    assert gammasimp(eq.subs(x, fx)).subs(fx, x) == ans
+    assert gammasimp(eq.subs(x, cos(x))).subs(cos(x), x) == ans
+    assert 1/gammasimp(1/eq) == ans
+    assert gammasimp(fx.subs(x, eq)).args[0] == ans
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/tests/test_hyperexpand.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/tests/test_hyperexpand.py
new file mode 100644
index 0000000000000000000000000000000000000000..c703c228a13201de13cfd4c3413fc75a2cf5bdb6
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/tests/test_hyperexpand.py
@@ -0,0 +1,1063 @@
+from sympy.core.random import randrange
+
+from sympy.simplify.hyperexpand import (ShiftA, ShiftB, UnShiftA, UnShiftB,
+                       MeijerShiftA, MeijerShiftB, MeijerShiftC, MeijerShiftD,
+                       MeijerUnShiftA, MeijerUnShiftB, MeijerUnShiftC,
+                       MeijerUnShiftD,
+                       ReduceOrder, reduce_order, apply_operators,
+                       devise_plan, make_derivative_operator, Formula,
+                       hyperexpand, Hyper_Function, G_Function,
+                       reduce_order_meijer,
+                       build_hypergeometric_formula)
+from sympy.concrete.summations import Sum
+from sympy.core.containers import Tuple
+from sympy.core.expr import Expr
+from sympy.core.numbers import I
+from sympy.core.singleton import S
+from sympy.core.symbol import symbols
+from sympy.functions.combinatorial.factorials import binomial
+from sympy.functions.elementary.piecewise import Piecewise
+from sympy.functions.special.hyper import (hyper, meijerg)
+from sympy.abc import z, a, b, c
+from sympy.testing.pytest import XFAIL, raises, slow, tooslow
+from sympy.core.random import verify_numerically as tn
+
+from sympy.core.numbers import (Rational, pi)
+from sympy.functions.elementary.exponential import (exp, exp_polar, log)
+from sympy.functions.elementary.hyperbolic import atanh
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import (asin, cos, sin)
+from sympy.functions.special.bessel import besseli
+from sympy.functions.special.error_functions import erf
+from sympy.functions.special.gamma_functions import (gamma, lowergamma)
+
+
+def test_branch_bug():
+    assert hyperexpand(hyper((Rational(-1, 3), S.Half), (Rational(2, 3), Rational(3, 2)), -z)) == \
+        -z**S('1/3')*lowergamma(exp_polar(I*pi)/3, z)/5 \
+        + sqrt(pi)*erf(sqrt(z))/(5*sqrt(z))
+    assert hyperexpand(meijerg([Rational(7, 6), 1], [], [Rational(2, 3)], [Rational(1, 6), 0], z)) == \
+        2*z**S('2/3')*(2*sqrt(pi)*erf(sqrt(z))/sqrt(z) - 2*lowergamma(
+                       Rational(2, 3), z)/z**S('2/3'))*gamma(Rational(2, 3))/gamma(Rational(5, 3))
+
+
+def test_hyperexpand():
+    # Luke, Y. L. (1969), The Special Functions and Their Approximations,
+    # Volume 1, section 6.2
+
+    assert hyperexpand(hyper([], [], z)) == exp(z)
+    assert hyperexpand(hyper([1, 1], [2], -z)*z) == log(1 + z)
+    assert hyperexpand(hyper([], [S.Half], -z**2/4)) == cos(z)
+    assert hyperexpand(z*hyper([], [S('3/2')], -z**2/4)) == sin(z)
+    assert hyperexpand(hyper([S('1/2'), S('1/2')], [S('3/2')], z**2)*z) \
+        == asin(z)
+    assert isinstance(Sum(binomial(2, z)*z**2, (z, 0, a)).doit(), Expr)
+
+
+def can_do(ap, bq, numerical=True, div=1, lowerplane=False):
+    r = hyperexpand(hyper(ap, bq, z))
+    if r.has(hyper):
+        return False
+    if not numerical:
+        return True
+    repl = {}
+    randsyms = r.free_symbols - {z}
+    while randsyms:
+        # Only randomly generated parameters are checked.
+        for n, ai in enumerate(randsyms):
+            repl[ai] = randcplx(n)/div
+        if not any(b.is_Integer and b <= 0 for b in Tuple(*bq).subs(repl)):
+            break
+    [a, b, c, d] = [2, -1, 3, 1]
+    if lowerplane:
+        [a, b, c, d] = [2, -2, 3, -1]
+    return tn(
+        hyper(ap, bq, z).subs(repl),
+        r.replace(exp_polar, exp).subs(repl),
+        z, a=a, b=b, c=c, d=d)
+
+
+def test_roach():
+    # Kelly B. Roach.  Meijer G Function Representations.
+    # Section "Gallery"
+    assert can_do([S.Half], [Rational(9, 2)])
+    assert can_do([], [1, Rational(5, 2), 4])
+    assert can_do([Rational(-1, 2), 1, 2], [3, 4])
+    assert can_do([Rational(1, 3)], [Rational(-2, 3), Rational(-1, 2), S.Half, 1])
+    assert can_do([Rational(-3, 2), Rational(-1, 2)], [Rational(-5, 2), 1])
+    assert can_do([Rational(-3, 2), ], [Rational(-1, 2), S.Half])  # shine-integral
+    assert can_do([Rational(-3, 2), Rational(-1, 2)], [2])  # elliptic integrals
+
+
+@XFAIL
+def test_roach_fail():
+    assert can_do([Rational(-1, 2), 1], [Rational(1, 4), S.Half, Rational(3, 4)])  # PFDD
+    assert can_do([Rational(3, 2)], [Rational(5, 2), 5])  # struve function
+    assert can_do([Rational(-1, 2), S.Half, 1], [Rational(3, 2), Rational(5, 2)])  # polylog, pfdd
+    assert can_do([1, 2, 3], [S.Half, 4])  # XXX ?
+    assert can_do([S.Half], [Rational(-1, 3), Rational(-1, 2), Rational(-2, 3)])  # PFDD ?
+
+# For the long table tests, see end of file
+
+
+def test_polynomial():
+    from sympy.core.numbers import oo
+    assert hyperexpand(hyper([], [-1], z)) is oo
+    assert hyperexpand(hyper([-2], [-1], z)) is oo
+    assert hyperexpand(hyper([0, 0], [-1], z)) == 1
+    assert can_do([-5, -2, randcplx(), randcplx()], [-10, randcplx()])
+    assert hyperexpand(hyper((-1, 1), (-2,), z)) == 1 + z/2
+
+
+def test_hyperexpand_bases():
+    assert hyperexpand(hyper([2], [a], z)) == \
+        a + z**(-a + 1)*(-a**2 + 3*a + z*(a - 1) - 2)*exp(z)* \
+        lowergamma(a - 1, z) - 1
+    # TODO [a+1, aRational(-1, 2)], [2*a]
+    assert hyperexpand(hyper([1, 2], [3], z)) == -2/z - 2*log(-z + 1)/z**2
+    assert hyperexpand(hyper([S.Half, 2], [Rational(3, 2)], z)) == \
+        -1/(2*z - 2) + atanh(sqrt(z))/sqrt(z)/2
+    assert hyperexpand(hyper([S.Half, S.Half], [Rational(5, 2)], z)) == \
+        (-3*z + 3)/4/(z*sqrt(-z + 1)) \
+        + (6*z - 3)*asin(sqrt(z))/(4*z**Rational(3, 2))
+    assert hyperexpand(hyper([1, 2], [Rational(3, 2)], z)) == -1/(2*z - 2) \
+        - asin(sqrt(z))/(sqrt(z)*(2*z - 2)*sqrt(-z + 1))
+    assert hyperexpand(hyper([Rational(-1, 2) - 1, 1, 2], [S.Half, 3], z)) == \
+        sqrt(z)*(z*Rational(6, 7) - Rational(6, 5))*atanh(sqrt(z)) \
+        + (-30*z**2 + 32*z - 6)/35/z - 6*log(-z + 1)/(35*z**2)
+    assert hyperexpand(hyper([1 + S.Half, 1, 1], [2, 2], z)) == \
+        -4*log(sqrt(-z + 1)/2 + S.Half)/z
+    # TODO hyperexpand(hyper([a], [2*a + 1], z))
+    # TODO [S.Half, a], [Rational(3, 2), a+1]
+    assert hyperexpand(hyper([2], [b, 1], z)) == \
+        z**(-b/2 + S.Half)*besseli(b - 1, 2*sqrt(z))*gamma(b) \
+        + z**(-b/2 + 1)*besseli(b, 2*sqrt(z))*gamma(b)
+    # TODO [a], [a - S.Half, 2*a]
+
+
+def test_hyperexpand_parametric():
+    assert hyperexpand(hyper([a, S.Half + a], [S.Half], z)) \
+        == (1 + sqrt(z))**(-2*a)/2 + (1 - sqrt(z))**(-2*a)/2
+    assert hyperexpand(hyper([a, Rational(-1, 2) + a], [2*a], z)) \
+        == 2**(2*a - 1)*((-z + 1)**S.Half + 1)**(-2*a + 1)
+
+
+def test_shifted_sum():
+    from sympy.simplify.simplify import simplify
+    assert simplify(hyperexpand(z**4*hyper([2], [3, S('3/2')], -z**2))) \
+        == z*sin(2*z) + (-z**2 + S.Half)*cos(2*z) - S.Half
+
+
+def _randrat():
+    """ Steer clear of integers. """
+    return S(randrange(25) + 10)/50
+
+
+def randcplx(offset=-1):
+    """ Polys is not good with real coefficients. """
+    return _randrat() + I*_randrat() + I*(1 + offset)
+
+
+@slow
+def test_formulae():
+    from sympy.simplify.hyperexpand import FormulaCollection
+    formulae = FormulaCollection().formulae
+    for formula in formulae:
+        h = formula.func(formula.z)
+        rep = {}
+        for n, sym in enumerate(formula.symbols):
+            rep[sym] = randcplx(n)
+
+        # NOTE hyperexpand returns truly branched functions. We know we are
+        #      on the main sheet, but numerical evaluation can still go wrong
+        #      (e.g. if exp_polar cannot be evalf'd).
+        #      Just replace all exp_polar by exp, this usually works.
+
+        # first test if the closed-form is actually correct
+        h = h.subs(rep)
+        closed_form = formula.closed_form.subs(rep).rewrite('nonrepsmall')
+        z = formula.z
+        assert tn(h, closed_form.replace(exp_polar, exp), z)
+
+        # now test the computed matrix
+        cl = (formula.C * formula.B)[0].subs(rep).rewrite('nonrepsmall')
+        assert tn(closed_form.replace(
+            exp_polar, exp), cl.replace(exp_polar, exp), z)
+        deriv1 = z*formula.B.applyfunc(lambda t: t.rewrite(
+            'nonrepsmall')).diff(z)
+        deriv2 = formula.M * formula.B
+        for d1, d2 in zip(deriv1, deriv2):
+            assert tn(d1.subs(rep).replace(exp_polar, exp),
+                      d2.subs(rep).rewrite('nonrepsmall').replace(exp_polar, exp), z)
+
+
+def test_meijerg_formulae():
+    from sympy.simplify.hyperexpand import MeijerFormulaCollection
+    formulae = MeijerFormulaCollection().formulae
+    for sig in formulae:
+        for formula in formulae[sig]:
+            g = meijerg(formula.func.an, formula.func.ap,
+                        formula.func.bm, formula.func.bq,
+                        formula.z)
+            rep = {}
+            for sym in formula.symbols:
+                rep[sym] = randcplx()
+
+            # first test if the closed-form is actually correct
+            g = g.subs(rep)
+            closed_form = formula.closed_form.subs(rep)
+            z = formula.z
+            assert tn(g, closed_form, z)
+
+            # now test the computed matrix
+            cl = (formula.C * formula.B)[0].subs(rep)
+            assert tn(closed_form, cl, z)
+            deriv1 = z*formula.B.diff(z)
+            deriv2 = formula.M * formula.B
+            for d1, d2 in zip(deriv1, deriv2):
+                assert tn(d1.subs(rep), d2.subs(rep), z)
+
+
+def op(f):
+    return z*f.diff(z)
+
+
+def test_plan():
+    assert devise_plan(Hyper_Function([0], ()),
+            Hyper_Function([0], ()), z) == []
+    with raises(ValueError):
+        devise_plan(Hyper_Function([1], ()), Hyper_Function((), ()), z)
+    with raises(ValueError):
+        devise_plan(Hyper_Function([2], [1]), Hyper_Function([2], [2]), z)
+    with raises(ValueError):
+        devise_plan(Hyper_Function([2], []), Hyper_Function([S("1/2")], []), z)
+
+    # We cannot use pi/(10000 + n) because polys is insanely slow.
+    a1, a2, b1 = (randcplx(n) for n in range(3))
+    b1 += 2*I
+    h = hyper([a1, a2], [b1], z)
+
+    h2 = hyper((a1 + 1, a2), [b1], z)
+    assert tn(apply_operators(h,
+        devise_plan(Hyper_Function((a1 + 1, a2), [b1]),
+            Hyper_Function((a1, a2), [b1]), z), op),
+        h2, z)
+
+    h2 = hyper((a1 + 1, a2 - 1), [b1], z)
+    assert tn(apply_operators(h,
+        devise_plan(Hyper_Function((a1 + 1, a2 - 1), [b1]),
+            Hyper_Function((a1, a2), [b1]), z), op),
+        h2, z)
+
+
+def test_plan_derivatives():
+    a1, a2, a3 = 1, 2, S('1/2')
+    b1, b2 = 3, S('5/2')
+    h = Hyper_Function((a1, a2, a3), (b1, b2))
+    h2 = Hyper_Function((a1 + 1, a2 + 1, a3 + 2), (b1 + 1, b2 + 1))
+    ops = devise_plan(h2, h, z)
+    f = Formula(h, z, h(z), [])
+    deriv = make_derivative_operator(f.M, z)
+    assert tn((apply_operators(f.C, ops, deriv)*f.B)[0], h2(z), z)
+
+    h2 = Hyper_Function((a1, a2 - 1, a3 - 2), (b1 - 1, b2 - 1))
+    ops = devise_plan(h2, h, z)
+    assert tn((apply_operators(f.C, ops, deriv)*f.B)[0], h2(z), z)
+
+
+def test_reduction_operators():
+    a1, a2, b1 = (randcplx(n) for n in range(3))
+    h = hyper([a1], [b1], z)
+
+    assert ReduceOrder(2, 0) is None
+    assert ReduceOrder(2, -1) is None
+    assert ReduceOrder(1, S('1/2')) is None
+
+    h2 = hyper((a1, a2), (b1, a2), z)
+    assert tn(ReduceOrder(a2, a2).apply(h, op), h2, z)
+
+    h2 = hyper((a1, a2 + 1), (b1, a2), z)
+    assert tn(ReduceOrder(a2 + 1, a2).apply(h, op), h2, z)
+
+    h2 = hyper((a2 + 4, a1), (b1, a2), z)
+    assert tn(ReduceOrder(a2 + 4, a2).apply(h, op), h2, z)
+
+    # test several step order reduction
+    ap = (a2 + 4, a1, b1 + 1)
+    bq = (a2, b1, b1)
+    func, ops = reduce_order(Hyper_Function(ap, bq))
+    assert func.ap == (a1,)
+    assert func.bq == (b1,)
+    assert tn(apply_operators(h, ops, op), hyper(ap, bq, z), z)
+
+
+def test_shift_operators():
+    a1, a2, b1, b2, b3 = (randcplx(n) for n in range(5))
+    h = hyper((a1, a2), (b1, b2, b3), z)
+
+    raises(ValueError, lambda: ShiftA(0))
+    raises(ValueError, lambda: ShiftB(1))
+
+    assert tn(ShiftA(a1).apply(h, op), hyper((a1 + 1, a2), (b1, b2, b3), z), z)
+    assert tn(ShiftA(a2).apply(h, op), hyper((a1, a2 + 1), (b1, b2, b3), z), z)
+    assert tn(ShiftB(b1).apply(h, op), hyper((a1, a2), (b1 - 1, b2, b3), z), z)
+    assert tn(ShiftB(b2).apply(h, op), hyper((a1, a2), (b1, b2 - 1, b3), z), z)
+    assert tn(ShiftB(b3).apply(h, op), hyper((a1, a2), (b1, b2, b3 - 1), z), z)
+
+
+def test_ushift_operators():
+    a1, a2, b1, b2, b3 = (randcplx(n) for n in range(5))
+    h = hyper((a1, a2), (b1, b2, b3), z)
+
+    raises(ValueError, lambda: UnShiftA((1,), (), 0, z))
+    raises(ValueError, lambda: UnShiftB((), (-1,), 0, z))
+    raises(ValueError, lambda: UnShiftA((1,), (0, -1, 1), 0, z))
+    raises(ValueError, lambda: UnShiftB((0, 1), (1,), 0, z))
+
+    s = UnShiftA((a1, a2), (b1, b2, b3), 0, z)
+    assert tn(s.apply(h, op), hyper((a1 - 1, a2), (b1, b2, b3), z), z)
+    s = UnShiftA((a1, a2), (b1, b2, b3), 1, z)
+    assert tn(s.apply(h, op), hyper((a1, a2 - 1), (b1, b2, b3), z), z)
+
+    s = UnShiftB((a1, a2), (b1, b2, b3), 0, z)
+    assert tn(s.apply(h, op), hyper((a1, a2), (b1 + 1, b2, b3), z), z)
+    s = UnShiftB((a1, a2), (b1, b2, b3), 1, z)
+    assert tn(s.apply(h, op), hyper((a1, a2), (b1, b2 + 1, b3), z), z)
+    s = UnShiftB((a1, a2), (b1, b2, b3), 2, z)
+    assert tn(s.apply(h, op), hyper((a1, a2), (b1, b2, b3 + 1), z), z)
+
+
+def can_do_meijer(a1, a2, b1, b2, numeric=True):
+    """
+    This helper function tries to hyperexpand() the meijer g-function
+    corresponding to the parameters a1, a2, b1, b2.
+    It returns False if this expansion still contains g-functions.
+    If numeric is True, it also tests the so-obtained formula numerically
+    (at random values) and returns False if the test fails.
+    Else it returns True.
+    """
+    from sympy.core.function import expand
+    from sympy.functions.elementary.complexes import unpolarify
+    r = hyperexpand(meijerg(a1, a2, b1, b2, z))
+    if r.has(meijerg):
+        return False
+    # NOTE hyperexpand() returns a truly branched function, whereas numerical
+    #      evaluation only works on the main branch. Since we are evaluating on
+    #      the main branch, this should not be a problem, but expressions like
+    #      exp_polar(I*pi/2*x)**a are evaluated incorrectly. We thus have to get
+    #      rid of them. The expand heuristically does this...
+    r = unpolarify(expand(r, force=True, power_base=True, power_exp=False,
+                          mul=False, log=False, multinomial=False, basic=False))
+
+    if not numeric:
+        return True
+
+    repl = {}
+    for n, ai in enumerate(meijerg(a1, a2, b1, b2, z).free_symbols - {z}):
+        repl[ai] = randcplx(n)
+    return tn(meijerg(a1, a2, b1, b2, z).subs(repl), r.subs(repl), z)
+
+
+@slow
+def test_meijerg_expand():
+    from sympy.simplify.gammasimp import gammasimp
+    from sympy.simplify.simplify import simplify
+    # from mpmath docs
+    assert hyperexpand(meijerg([[], []], [[0], []], -z)) == exp(z)
+
+    assert hyperexpand(meijerg([[1, 1], []], [[1], [0]], z)) == \
+        log(z + 1)
+    assert hyperexpand(meijerg([[1, 1], []], [[1], [1]], z)) == \
+        z/(z + 1)
+    assert hyperexpand(meijerg([[], []], [[S.Half], [0]], (z/2)**2)) \
+        == sin(z)/sqrt(pi)
+    assert hyperexpand(meijerg([[], []], [[0], [S.Half]], (z/2)**2)) \
+        == cos(z)/sqrt(pi)
+    assert can_do_meijer([], [a], [a - 1, a - S.Half], [])
+    assert can_do_meijer([], [], [a/2], [-a/2], False)  # branches...
+    assert can_do_meijer([a], [b], [a], [b, a - 1])
+
+    # wikipedia
+    assert hyperexpand(meijerg([1], [], [], [0], z)) == \
+        Piecewise((0, abs(z) < 1), (1, abs(1/z) < 1),
+                 (meijerg([1], [], [], [0], z), True))
+    assert hyperexpand(meijerg([], [1], [0], [], z)) == \
+        Piecewise((1, abs(z) < 1), (0, abs(1/z) < 1),
+                 (meijerg([], [1], [0], [], z), True))
+
+    # The Special Functions and their Approximations
+    assert can_do_meijer([], [], [a + b/2], [a, a - b/2, a + S.Half])
+    assert can_do_meijer(
+        [], [], [a], [b], False)  # branches only agree for small z
+    assert can_do_meijer([], [S.Half], [a], [-a])
+    assert can_do_meijer([], [], [a, b], [])
+    assert can_do_meijer([], [], [a, b], [])
+    assert can_do_meijer([], [], [a, a + S.Half], [b, b + S.Half])
+    assert can_do_meijer([], [], [a, -a], [0, S.Half], False)  # dito
+    assert can_do_meijer([], [], [a, a + S.Half, b, b + S.Half], [])
+    assert can_do_meijer([S.Half], [], [0], [a, -a])
+    assert can_do_meijer([S.Half], [], [a], [0, -a], False)  # dito
+    assert can_do_meijer([], [a - S.Half], [a, b], [a - S.Half], False)
+    assert can_do_meijer([], [a + S.Half], [a + b, a - b, a], [], False)
+    assert can_do_meijer([a + S.Half], [], [b, 2*a - b, a], [], False)
+
+    # This for example is actually zero.
+    assert can_do_meijer([], [], [], [a, b])
+
+    # Testing a bug:
+    assert hyperexpand(meijerg([0, 2], [], [], [-1, 1], z)) == \
+        Piecewise((0, abs(z) < 1),
+                  (z*(1 - 1/z**2)/2, abs(1/z) < 1),
+                  (meijerg([0, 2], [], [], [-1, 1], z), True))
+
+    # Test that the simplest possible answer is returned:
+    assert gammasimp(simplify(hyperexpand(
+        meijerg([1], [1 - a], [-a/2, -a/2 + S.Half], [], 1/z)))) == \
+        -2*sqrt(pi)*(sqrt(z + 1) + 1)**a/a
+
+    # Test that hyper is returned
+    assert hyperexpand(meijerg([1], [], [a], [0, 0], z)) == hyper(
+        (a,), (a + 1, a + 1), z*exp_polar(I*pi))*z**a*gamma(a)/gamma(a + 1)**2
+
+    # Test place option
+    f = meijerg(((0, 1), ()), ((S.Half,), (0,)), z**2)
+    assert hyperexpand(f) == sqrt(pi)/sqrt(1 + z**(-2))
+    assert hyperexpand(f, place=0) == sqrt(pi)*z/sqrt(z**2 + 1)
+
+
+def test_meijerg_lookup():
+    from sympy.functions.special.error_functions import (Ci, Si)
+    from sympy.functions.special.gamma_functions import uppergamma
+    assert hyperexpand(meijerg([a], [], [b, a], [], z)) == \
+        z**b*exp(z)*gamma(-a + b + 1)*uppergamma(a - b, z)
+    assert hyperexpand(meijerg([0], [], [0, 0], [], z)) == \
+        exp(z)*uppergamma(0, z)
+    assert can_do_meijer([a], [], [b, a + 1], [])
+    assert can_do_meijer([a], [], [b + 2, a], [])
+    assert can_do_meijer([a], [], [b - 2, a], [])
+
+    assert hyperexpand(meijerg([a], [], [a, a, a - S.Half], [], z)) == \
+        -sqrt(pi)*z**(a - S.Half)*(2*cos(2*sqrt(z))*(Si(2*sqrt(z)) - pi/2)
+                                   - 2*sin(2*sqrt(z))*Ci(2*sqrt(z))) == \
+        hyperexpand(meijerg([a], [], [a, a - S.Half, a], [], z)) == \
+        hyperexpand(meijerg([a], [], [a - S.Half, a, a], [], z))
+    assert can_do_meijer([a - 1], [], [a + 2, a - Rational(3, 2), a + 1], [])
+
+
+@XFAIL
+def test_meijerg_expand_fail():
+    # These basically test hyper([], [1/2 - a, 1/2 + 1, 1/2], z),
+    # which is *very* messy. But since the meijer g actually yields a
+    # sum of bessel functions, things can sometimes be simplified a lot and
+    # are then put into tables...
+    assert can_do_meijer([], [], [a + S.Half], [a, a - b/2, a + b/2])
+    assert can_do_meijer([], [], [0, S.Half], [a, -a])
+    assert can_do_meijer([], [], [3*a - S.Half, a, -a - S.Half], [a - S.Half])
+    assert can_do_meijer([], [], [0, a - S.Half, -a - S.Half], [S.Half])
+    assert can_do_meijer([], [], [a, b + S.Half, b], [2*b - a])
+    assert can_do_meijer([], [], [a, b + S.Half, b, 2*b - a])
+    assert can_do_meijer([S.Half], [], [-a, a], [0])
+
+
+@slow
+def test_meijerg():
+    # carefully set up the parameters.
+    # NOTE: this used to fail sometimes. I believe it is fixed, but if you
+    #       hit an inexplicable test failure here, please let me know the seed.
+    a1, a2 = (randcplx(n) - 5*I - n*I for n in range(2))
+    b1, b2 = (randcplx(n) + 5*I + n*I for n in range(2))
+    b3, b4, b5, a3, a4, a5 = (randcplx() for n in range(6))
+    g = meijerg([a1], [a3, a4], [b1], [b3, b4], z)
+
+    assert ReduceOrder.meijer_minus(3, 4) is None
+    assert ReduceOrder.meijer_plus(4, 3) is None
+
+    g2 = meijerg([a1, a2], [a3, a4], [b1], [b3, b4, a2], z)
+    assert tn(ReduceOrder.meijer_plus(a2, a2).apply(g, op), g2, z)
+
+    g2 = meijerg([a1, a2], [a3, a4], [b1], [b3, b4, a2 + 1], z)
+    assert tn(ReduceOrder.meijer_plus(a2, a2 + 1).apply(g, op), g2, z)
+
+    g2 = meijerg([a1, a2 - 1], [a3, a4], [b1], [b3, b4, a2 + 2], z)
+    assert tn(ReduceOrder.meijer_plus(a2 - 1, a2 + 2).apply(g, op), g2, z)
+
+    g2 = meijerg([a1], [a3, a4, b2 - 1], [b1, b2 + 2], [b3, b4], z)
+    assert tn(ReduceOrder.meijer_minus(
+        b2 + 2, b2 - 1).apply(g, op), g2, z, tol=1e-6)
+
+    # test several-step reduction
+    an = [a1, a2]
+    bq = [b3, b4, a2 + 1]
+    ap = [a3, a4, b2 - 1]
+    bm = [b1, b2 + 1]
+    niq, ops = reduce_order_meijer(G_Function(an, ap, bm, bq))
+    assert niq.an == (a1,)
+    assert set(niq.ap) == {a3, a4}
+    assert niq.bm == (b1,)
+    assert set(niq.bq) == {b3, b4}
+    assert tn(apply_operators(g, ops, op), meijerg(an, ap, bm, bq, z), z)
+
+
+def test_meijerg_shift_operators():
+    # carefully set up the parameters. XXX this still fails sometimes
+    a1, a2, a3, a4, a5, b1, b2, b3, b4, b5 = (randcplx(n) for n in range(10))
+    g = meijerg([a1], [a3, a4], [b1], [b3, b4], z)
+
+    assert tn(MeijerShiftA(b1).apply(g, op),
+              meijerg([a1], [a3, a4], [b1 + 1], [b3, b4], z), z)
+    assert tn(MeijerShiftB(a1).apply(g, op),
+              meijerg([a1 - 1], [a3, a4], [b1], [b3, b4], z), z)
+    assert tn(MeijerShiftC(b3).apply(g, op),
+              meijerg([a1], [a3, a4], [b1], [b3 + 1, b4], z), z)
+    assert tn(MeijerShiftD(a3).apply(g, op),
+              meijerg([a1], [a3 - 1, a4], [b1], [b3, b4], z), z)
+
+    s = MeijerUnShiftA([a1], [a3, a4], [b1], [b3, b4], 0, z)
+    assert tn(
+        s.apply(g, op), meijerg([a1], [a3, a4], [b1 - 1], [b3, b4], z), z)
+
+    s = MeijerUnShiftC([a1], [a3, a4], [b1], [b3, b4], 0, z)
+    assert tn(
+        s.apply(g, op), meijerg([a1], [a3, a4], [b1], [b3 - 1, b4], z), z)
+
+    s = MeijerUnShiftB([a1], [a3, a4], [b1], [b3, b4], 0, z)
+    assert tn(
+        s.apply(g, op), meijerg([a1 + 1], [a3, a4], [b1], [b3, b4], z), z)
+
+    s = MeijerUnShiftD([a1], [a3, a4], [b1], [b3, b4], 0, z)
+    assert tn(
+        s.apply(g, op), meijerg([a1], [a3 + 1, a4], [b1], [b3, b4], z), z)
+
+
+@slow
+def test_meijerg_confluence():
+    def t(m, a, b):
+        from sympy.core.sympify import sympify
+        a, b = sympify([a, b])
+        m_ = m
+        m = hyperexpand(m)
+        if not m == Piecewise((a, abs(z) < 1), (b, abs(1/z) < 1), (m_, True)):
+            return False
+        if not (m.args[0].args[0] == a and m.args[1].args[0] == b):
+            return False
+        z0 = randcplx()/10
+        if abs(m.subs(z, z0).n() - a.subs(z, z0).n()).n() > 1e-10:
+            return False
+        if abs(m.subs(z, 1/z0).n() - b.subs(z, 1/z0).n()).n() > 1e-10:
+            return False
+        return True
+
+    assert t(meijerg([], [1, 1], [0, 0], [], z), -log(z), 0)
+    assert t(meijerg(
+        [], [3, 1], [0, 0], [], z), -z**2/4 + z - log(z)/2 - Rational(3, 4), 0)
+    assert t(meijerg([], [3, 1], [-1, 0], [], z),
+             z**2/12 - z/2 + log(z)/2 + Rational(1, 4) + 1/(6*z), 0)
+    assert t(meijerg([], [1, 1, 1, 1], [0, 0, 0, 0], [], z), -log(z)**3/6, 0)
+    assert t(meijerg([1, 1], [], [], [0, 0], z), 0, -log(1/z))
+    assert t(meijerg([1, 1], [2, 2], [1, 1], [0, 0], z),
+             -z*log(z) + 2*z, -log(1/z) + 2)
+    assert t(meijerg([S.Half], [1, 1], [0, 0], [Rational(3, 2)], z), log(z)/2 - 1, 0)
+
+    def u(an, ap, bm, bq):
+        m = meijerg(an, ap, bm, bq, z)
+        m2 = hyperexpand(m, allow_hyper=True)
+        if m2.has(meijerg) and not (m2.is_Piecewise and len(m2.args) == 3):
+            return False
+        return tn(m, m2, z)
+    assert u([], [1], [0, 0], [])
+    assert u([1, 1], [], [], [0])
+    assert u([1, 1], [2, 2, 5], [1, 1, 6], [0, 0])
+    assert u([1, 1], [2, 2, 5], [1, 1, 6], [0])
+
+
+def test_meijerg_with_Floats():
+    # see issue #10681
+    from sympy.polys.domains.realfield import RR
+    f = meijerg(((3.0, 1), ()), ((Rational(3, 2),), (0,)), z)
+    a = -2.3632718012073
+    g = a*z**Rational(3, 2)*hyper((-0.5, Rational(3, 2)), (Rational(5, 2),), z*exp_polar(I*pi))
+    assert RR.almosteq((hyperexpand(f)/g).n(), 1.0, 1e-12)
+
+
+def test_lerchphi():
+    from sympy.functions.special.zeta_functions import (lerchphi, polylog)
+    from sympy.simplify.gammasimp import gammasimp
+    assert hyperexpand(hyper([1, a], [a + 1], z)/a) == lerchphi(z, 1, a)
+    assert hyperexpand(
+        hyper([1, a, a], [a + 1, a + 1], z)/a**2) == lerchphi(z, 2, a)
+    assert hyperexpand(hyper([1, a, a, a], [a + 1, a + 1, a + 1], z)/a**3) == \
+        lerchphi(z, 3, a)
+    assert hyperexpand(hyper([1] + [a]*10, [a + 1]*10, z)/a**10) == \
+        lerchphi(z, 10, a)
+    assert gammasimp(hyperexpand(meijerg([0, 1 - a], [], [0],
+        [-a], exp_polar(-I*pi)*z))) == lerchphi(z, 1, a)
+    assert gammasimp(hyperexpand(meijerg([0, 1 - a, 1 - a], [], [0],
+        [-a, -a], exp_polar(-I*pi)*z))) == lerchphi(z, 2, a)
+    assert gammasimp(hyperexpand(meijerg([0, 1 - a, 1 - a, 1 - a], [], [0],
+        [-a, -a, -a], exp_polar(-I*pi)*z))) == lerchphi(z, 3, a)
+
+    assert hyperexpand(z*hyper([1, 1], [2], z)) == -log(1 + -z)
+    assert hyperexpand(z*hyper([1, 1, 1], [2, 2], z)) == polylog(2, z)
+    assert hyperexpand(z*hyper([1, 1, 1, 1], [2, 2, 2], z)) == polylog(3, z)
+
+    assert hyperexpand(hyper([1, a, 1 + S.Half], [a + 1, S.Half], z)) == \
+        -2*a/(z - 1) + (-2*a**2 + a)*lerchphi(z, 1, a)
+
+    # Now numerical tests. These make sure reductions etc are carried out
+    # correctly
+
+    # a rational function (polylog at negative integer order)
+    assert can_do([2, 2, 2], [1, 1])
+
+    # NOTE these contain log(1-x) etc ... better make sure we have |z| < 1
+    # reduction of order for polylog
+    assert can_do([1, 1, 1, b + 5], [2, 2, b], div=10)
+
+    # reduction of order for lerchphi
+    # XXX lerchphi in mpmath is flaky
+    assert can_do(
+        [1, a, a, a, b + 5], [a + 1, a + 1, a + 1, b], numerical=False)
+
+    # test a bug
+    from sympy.functions.elementary.complexes import Abs
+    assert hyperexpand(hyper([S.Half, S.Half, S.Half, 1],
+                             [Rational(3, 2), Rational(3, 2), Rational(3, 2)], Rational(1, 4))) == \
+        Abs(-polylog(3, exp_polar(I*pi)/2) + polylog(3, S.Half))
+
+
+def test_partial_simp():
+    # First test that hypergeometric function formulae work.
+    a, b, c, d, e = (randcplx() for _ in range(5))
+    for func in [Hyper_Function([a, b, c], [d, e]),
+            Hyper_Function([], [a, b, c, d, e])]:
+        f = build_hypergeometric_formula(func)
+        z = f.z
+        assert f.closed_form == func(z)
+        deriv1 = f.B.diff(z)*z
+        deriv2 = f.M*f.B
+        for func1, func2 in zip(deriv1, deriv2):
+            assert tn(func1, func2, z)
+
+    # Now test that formulae are partially simplified.
+    a, b, z = symbols('a b z')
+    assert hyperexpand(hyper([3, a], [1, b], z)) == \
+        (-a*b/2 + a*z/2 + 2*a)*hyper([a + 1], [b], z) \
+        + (a*b/2 - 2*a + 1)*hyper([a], [b], z)
+    assert tn(
+        hyperexpand(hyper([3, d], [1, e], z)), hyper([3, d], [1, e], z), z)
+    assert hyperexpand(hyper([3], [1, a, b], z)) == \
+        hyper((), (a, b), z) \
+        + z*hyper((), (a + 1, b), z)/(2*a) \
+        - z*(b - 4)*hyper((), (a + 1, b + 1), z)/(2*a*b)
+    assert tn(
+        hyperexpand(hyper([3], [1, d, e], z)), hyper([3], [1, d, e], z), z)
+
+
+def test_hyperexpand_special():
+    assert hyperexpand(hyper([a, b], [c], 1)) == \
+        gamma(c)*gamma(c - a - b)/gamma(c - a)/gamma(c - b)
+    assert hyperexpand(hyper([a, b], [1 + a - b], -1)) == \
+        gamma(1 + a/2)*gamma(1 + a - b)/gamma(1 + a)/gamma(1 + a/2 - b)
+    assert hyperexpand(hyper([a, b], [1 + b - a], -1)) == \
+        gamma(1 + b/2)*gamma(1 + b - a)/gamma(1 + b)/gamma(1 + b/2 - a)
+    assert hyperexpand(meijerg([1 - z - a/2], [1 - z + a/2], [b/2], [-b/2], 1)) == \
+        gamma(1 - 2*z)*gamma(z + a/2 + b/2)/gamma(1 - z + a/2 - b/2) \
+        /gamma(1 - z - a/2 + b/2)/gamma(1 - z + a/2 + b/2)
+    assert hyperexpand(hyper([a], [b], 0)) == 1
+    assert hyper([a], [b], 0) != 0
+
+
+def test_Mod1_behavior():
+    from sympy.core.symbol import Symbol
+    from sympy.simplify.simplify import simplify
+    n = Symbol('n', integer=True)
+    # Note: this should not hang.
+    assert simplify(hyperexpand(meijerg([1], [], [n + 1], [0], z))) == \
+        lowergamma(n + 1, z)
+
+
+@slow
+def test_prudnikov_misc():
+    assert can_do([1, (3 + I)/2, (3 - I)/2], [Rational(3, 2), 2])
+    assert can_do([S.Half, a - 1], [Rational(3, 2), a + 1], lowerplane=True)
+    assert can_do([], [b + 1])
+    assert can_do([a], [a - 1, b + 1])
+
+    assert can_do([a], [a - S.Half, 2*a])
+    assert can_do([a], [a - S.Half, 2*a + 1])
+    assert can_do([a], [a - S.Half, 2*a - 1])
+    assert can_do([a], [a + S.Half, 2*a])
+    assert can_do([a], [a + S.Half, 2*a + 1])
+    assert can_do([a], [a + S.Half, 2*a - 1])
+    assert can_do([S.Half], [b, 2 - b])
+    assert can_do([S.Half], [b, 3 - b])
+    assert can_do([1], [2, b])
+
+    assert can_do([a, a + S.Half], [2*a, b, 2*a - b + 1])
+    assert can_do([a, a + S.Half], [S.Half, 2*a, 2*a + S.Half])
+    assert can_do([a], [a + 1], lowerplane=True)  # lowergamma
+
+
+def test_prudnikov_1():
+    # A. P. Prudnikov, Yu. A. Brychkov and O. I. Marichev (1990).
+    # Integrals and Series: More Special Functions, Vol. 3,.
+    # Gordon and Breach Science Publisher
+
+    # 7.3.1
+    assert can_do([a, -a], [S.Half])
+    assert can_do([a, 1 - a], [S.Half])
+    assert can_do([a, 1 - a], [Rational(3, 2)])
+    assert can_do([a, 2 - a], [S.Half])
+    assert can_do([a, 2 - a], [Rational(3, 2)])
+    assert can_do([a, 2 - a], [Rational(3, 2)])
+    assert can_do([a, a + S.Half], [2*a - 1])
+    assert can_do([a, a + S.Half], [2*a])
+    assert can_do([a, a + S.Half], [2*a + 1])
+    assert can_do([a, a + S.Half], [S.Half])
+    assert can_do([a, a + S.Half], [Rational(3, 2)])
+    assert can_do([a, a/2 + 1], [a/2])
+    assert can_do([1, b], [2])
+    assert can_do([1, b], [b + 1], numerical=False)  # Lerch Phi
+             # NOTE: branches are complicated for |z| > 1
+
+    assert can_do([a], [2*a])
+    assert can_do([a], [2*a + 1])
+    assert can_do([a], [2*a - 1])
+
+
+@slow
+def test_prudnikov_2():
+    h = S.Half
+    assert can_do([-h, -h], [h])
+    assert can_do([-h, h], [3*h])
+    assert can_do([-h, h], [5*h])
+    assert can_do([-h, h], [7*h])
+    assert can_do([-h, 1], [h])
+
+    for p in [-h, h]:
+        for n in [-h, h, 1, 3*h, 2, 5*h, 3, 7*h, 4]:
+            for m in [-h, h, 3*h, 5*h, 7*h]:
+                assert can_do([p, n], [m])
+        for n in [1, 2, 3, 4]:
+            for m in [1, 2, 3, 4]:
+                assert can_do([p, n], [m])
+
+
+def test_prudnikov_3():
+    h = S.Half
+    assert can_do([Rational(1, 4), Rational(3, 4)], [h])
+    assert can_do([Rational(1, 4), Rational(3, 4)], [3*h])
+    assert can_do([Rational(1, 3), Rational(2, 3)], [3*h])
+    assert can_do([Rational(3, 4), Rational(5, 4)], [h])
+    assert can_do([Rational(3, 4), Rational(5, 4)], [3*h])
+
+
+@tooslow
+def test_prudnikov_3_slow():
+    # XXX: This is marked as tooslow and hence skipped in CI. None of the
+    # individual cases below fails or hangs. Some cases are slow and the loops
+    # below generate 280 different cases. Is it really necessary to test all
+    # 280 cases here?
+    h = S.Half
+    for p in [1, 2, 3, 4]:
+        for n in [-h, h, 1, 3*h, 2, 5*h, 3, 7*h, 4, 9*h]:
+            for m in [1, 3*h, 2, 5*h, 3, 7*h, 4]:
+                assert can_do([p, m], [n])
+
+
+@slow
+def test_prudnikov_4():
+    h = S.Half
+    for p in [3*h, 5*h, 7*h]:
+        for n in [-h, h, 3*h, 5*h, 7*h]:
+            for m in [3*h, 2, 5*h, 3, 7*h, 4]:
+                assert can_do([p, m], [n])
+        for n in [1, 2, 3, 4]:
+            for m in [2, 3, 4]:
+                assert can_do([p, m], [n])
+
+
+@slow
+def test_prudnikov_5():
+    h = S.Half
+
+    for p in [1, 2, 3]:
+        for q in range(p, 4):
+            for r in [1, 2, 3]:
+                for s in range(r, 4):
+                    assert can_do([-h, p, q], [r, s])
+
+    for p in [h, 1, 3*h, 2, 5*h, 3]:
+        for q in [h, 3*h, 5*h]:
+            for r in [h, 3*h, 5*h]:
+                for s in [h, 3*h, 5*h]:
+                    if s <= q and s <= r:
+                        assert can_do([-h, p, q], [r, s])
+
+    for p in [h, 1, 3*h, 2, 5*h, 3]:
+        for q in [1, 2, 3]:
+            for r in [h, 3*h, 5*h]:
+                for s in [1, 2, 3]:
+                    assert can_do([-h, p, q], [r, s])
+
+
+@slow
+def test_prudnikov_6():
+    h = S.Half
+
+    for m in [3*h, 5*h]:
+        for n in [1, 2, 3]:
+            for q in [h, 1, 2]:
+                for p in [1, 2, 3]:
+                    assert can_do([h, q, p], [m, n])
+            for q in [1, 2, 3]:
+                for p in [3*h, 5*h]:
+                    assert can_do([h, q, p], [m, n])
+
+    for q in [1, 2]:
+        for p in [1, 2, 3]:
+            for m in [1, 2, 3]:
+                for n in [1, 2, 3]:
+                    assert can_do([h, q, p], [m, n])
+
+    assert can_do([h, h, 5*h], [3*h, 3*h])
+    assert can_do([h, 1, 5*h], [3*h, 3*h])
+    assert can_do([h, 2, 2], [1, 3])
+
+    # pages 435 to 457 contain more PFDD and stuff like this
+
+
+@slow
+def test_prudnikov_7():
+    assert can_do([3], [6])
+
+    h = S.Half
+    for n in [h, 3*h, 5*h, 7*h]:
+        assert can_do([-h], [n])
+    for m in [-h, h, 1, 3*h, 2, 5*h, 3, 7*h, 4]:  # HERE
+        for n in [-h, h, 3*h, 5*h, 7*h, 1, 2, 3, 4]:
+            assert can_do([m], [n])
+
+
+@slow
+def test_prudnikov_8():
+    h = S.Half
+
+    # 7.12.2
+    for ai in [1, 2, 3]:
+        for bi in [1, 2, 3]:
+            for ci in range(1, ai + 1):
+                for di in [h, 1, 3*h, 2, 5*h, 3]:
+                    assert can_do([ai, bi], [ci, di])
+        for bi in [3*h, 5*h]:
+            for ci in [h, 1, 3*h, 2, 5*h, 3]:
+                for di in [1, 2, 3]:
+                    assert can_do([ai, bi], [ci, di])
+
+    for ai in [-h, h, 3*h, 5*h]:
+        for bi in [1, 2, 3]:
+            for ci in [h, 1, 3*h, 2, 5*h, 3]:
+                for di in [1, 2, 3]:
+                    assert can_do([ai, bi], [ci, di])
+        for bi in [h, 3*h, 5*h]:
+            for ci in [h, 3*h, 5*h, 3]:
+                for di in [h, 1, 3*h, 2, 5*h, 3]:
+                    if ci <= bi:
+                        assert can_do([ai, bi], [ci, di])
+
+
+def test_prudnikov_9():
+    # 7.13.1 [we have a general formula ... so this is a bit pointless]
+    for i in range(9):
+        assert can_do([], [(S(i) + 1)/2])
+    for i in range(5):
+        assert can_do([], [-(2*S(i) + 1)/2])
+
+
+@slow
+def test_prudnikov_10():
+    # 7.14.2
+    h = S.Half
+    for p in [-h, h, 1, 3*h, 2, 5*h, 3, 7*h, 4]:
+        for m in [1, 2, 3, 4]:
+            for n in range(m, 5):
+                assert can_do([p], [m, n])
+
+    for p in [1, 2, 3, 4]:
+        for n in [h, 3*h, 5*h, 7*h]:
+            for m in [1, 2, 3, 4]:
+                assert can_do([p], [n, m])
+
+    for p in [3*h, 5*h, 7*h]:
+        for m in [h, 1, 2, 5*h, 3, 7*h, 4]:
+            assert can_do([p], [h, m])
+            assert can_do([p], [3*h, m])
+
+    for m in [h, 1, 2, 5*h, 3, 7*h, 4]:
+        assert can_do([7*h], [5*h, m])
+
+    assert can_do([Rational(-1, 2)], [S.Half, S.Half])  # shine-integral shi
+
+
+def test_prudnikov_11():
+    # 7.15
+    assert can_do([a, a + S.Half], [2*a, b, 2*a - b])
+    assert can_do([a, a + S.Half], [Rational(3, 2), 2*a, 2*a - S.Half])
+
+    assert can_do([Rational(1, 4), Rational(3, 4)], [S.Half, S.Half, 1])
+    assert can_do([Rational(5, 4), Rational(3, 4)], [Rational(3, 2), S.Half, 2])
+    assert can_do([Rational(5, 4), Rational(3, 4)], [Rational(3, 2), Rational(3, 2), 1])
+    assert can_do([Rational(5, 4), Rational(7, 4)], [Rational(3, 2), Rational(5, 2), 2])
+
+    assert can_do([1, 1], [Rational(3, 2), 2, 2])  # cosh-integral chi
+
+
+def test_prudnikov_12():
+    # 7.16
+    assert can_do(
+        [], [a, a + S.Half, 2*a], False)  # branches only agree for some z!
+    assert can_do([], [a, a + S.Half, 2*a + 1], False)  # dito
+    assert can_do([], [S.Half, a, a + S.Half])
+    assert can_do([], [Rational(3, 2), a, a + S.Half])
+
+    assert can_do([], [Rational(1, 4), S.Half, Rational(3, 4)])
+    assert can_do([], [S.Half, S.Half, 1])
+    assert can_do([], [S.Half, Rational(3, 2), 1])
+    assert can_do([], [Rational(3, 4), Rational(3, 2), Rational(5, 4)])
+    assert can_do([], [1, 1, Rational(3, 2)])
+    assert can_do([], [1, 2, Rational(3, 2)])
+    assert can_do([], [1, Rational(3, 2), Rational(3, 2)])
+    assert can_do([], [Rational(5, 4), Rational(3, 2), Rational(7, 4)])
+    assert can_do([], [2, Rational(3, 2), Rational(3, 2)])
+
+
+@slow
+def test_prudnikov_2F1():
+    h = S.Half
+    # Elliptic integrals
+    for p in [-h, h]:
+        for m in [h, 3*h, 5*h, 7*h]:
+            for n in [1, 2, 3, 4]:
+                assert can_do([p, m], [n])
+
+
+@XFAIL
+def test_prudnikov_fail_2F1():
+    assert can_do([a, b], [b + 1])  # incomplete beta function
+    assert can_do([-1, b], [c])    # Poly. also -2, -3 etc
+
+    # TODO polys
+
+    # Legendre functions:
+    assert can_do([a, b], [a + b + S.Half])
+    assert can_do([a, b], [a + b - S.Half])
+    assert can_do([a, b], [a + b + Rational(3, 2)])
+    assert can_do([a, b], [(a + b + 1)/2])
+    assert can_do([a, b], [(a + b)/2 + 1])
+    assert can_do([a, b], [a - b + 1])
+    assert can_do([a, b], [a - b + 2])
+    assert can_do([a, b], [2*b])
+    assert can_do([a, b], [S.Half])
+    assert can_do([a, b], [Rational(3, 2)])
+    assert can_do([a, 1 - a], [c])
+    assert can_do([a, 2 - a], [c])
+    assert can_do([a, 3 - a], [c])
+    assert can_do([a, a + S.Half], [c])
+    assert can_do([1, b], [c])
+    assert can_do([1, b], [Rational(3, 2)])
+
+    assert can_do([Rational(1, 4), Rational(3, 4)], [1])
+
+    # PFDD
+    o = S.One
+    assert can_do([o/8, 1], [o/8*9])
+    assert can_do([o/6, 1], [o/6*7])
+    assert can_do([o/6, 1], [o/6*13])
+    assert can_do([o/5, 1], [o/5*6])
+    assert can_do([o/5, 1], [o/5*11])
+    assert can_do([o/4, 1], [o/4*5])
+    assert can_do([o/4, 1], [o/4*9])
+    assert can_do([o/3, 1], [o/3*4])
+    assert can_do([o/3, 1], [o/3*7])
+    assert can_do([o/8*3, 1], [o/8*11])
+    assert can_do([o/5*2, 1], [o/5*7])
+    assert can_do([o/5*2, 1], [o/5*12])
+    assert can_do([o/5*3, 1], [o/5*8])
+    assert can_do([o/5*3, 1], [o/5*13])
+    assert can_do([o/8*5, 1], [o/8*13])
+    assert can_do([o/4*3, 1], [o/4*7])
+    assert can_do([o/4*3, 1], [o/4*11])
+    assert can_do([o/3*2, 1], [o/3*5])
+    assert can_do([o/3*2, 1], [o/3*8])
+    assert can_do([o/5*4, 1], [o/5*9])
+    assert can_do([o/5*4, 1], [o/5*14])
+    assert can_do([o/6*5, 1], [o/6*11])
+    assert can_do([o/6*5, 1], [o/6*17])
+    assert can_do([o/8*7, 1], [o/8*15])
+
+
+@XFAIL
+def test_prudnikov_fail_3F2():
+    assert can_do([a, a + Rational(1, 3), a + Rational(2, 3)], [Rational(1, 3), Rational(2, 3)])
+    assert can_do([a, a + Rational(1, 3), a + Rational(2, 3)], [Rational(2, 3), Rational(4, 3)])
+    assert can_do([a, a + Rational(1, 3), a + Rational(2, 3)], [Rational(4, 3), Rational(5, 3)])
+
+    # page 421
+    assert can_do([a, a + Rational(1, 3), a + Rational(2, 3)], [a*Rational(3, 2), (3*a + 1)/2])
+
+    # pages 422 ...
+    assert can_do([Rational(-1, 2), S.Half, S.Half], [1, 1])  # elliptic integrals
+    assert can_do([Rational(-1, 2), S.Half, 1], [Rational(3, 2), Rational(3, 2)])
+    # TODO LOTS more
+
+    # PFDD
+    assert can_do([Rational(1, 8), Rational(3, 8), 1], [Rational(9, 8), Rational(11, 8)])
+    assert can_do([Rational(1, 8), Rational(5, 8), 1], [Rational(9, 8), Rational(13, 8)])
+    assert can_do([Rational(1, 8), Rational(7, 8), 1], [Rational(9, 8), Rational(15, 8)])
+    assert can_do([Rational(1, 6), Rational(1, 3), 1], [Rational(7, 6), Rational(4, 3)])
+    assert can_do([Rational(1, 6), Rational(2, 3), 1], [Rational(7, 6), Rational(5, 3)])
+    assert can_do([Rational(1, 6), Rational(2, 3), 1], [Rational(5, 3), Rational(13, 6)])
+    assert can_do([S.Half, 1, 1], [Rational(1, 4), Rational(3, 4)])
+    # LOTS more
+
+
+@XFAIL
+def test_prudnikov_fail_other():
+    # 7.11.2
+
+    # 7.12.1
+    assert can_do([1, a], [b, 1 - 2*a + b])  # ???
+
+    # 7.14.2
+    assert can_do([Rational(-1, 2)], [S.Half, 1])  # struve
+    assert can_do([1], [S.Half, S.Half])  # struve
+    assert can_do([Rational(1, 4)], [S.Half, Rational(5, 4)])  # PFDD
+    assert can_do([Rational(3, 4)], [Rational(3, 2), Rational(7, 4)])  # PFDD
+    assert can_do([1], [Rational(1, 4), Rational(3, 4)])  # PFDD
+    assert can_do([1], [Rational(3, 4), Rational(5, 4)])  # PFDD
+    assert can_do([1], [Rational(5, 4), Rational(7, 4)])  # PFDD
+    # TODO LOTS more
+
+    # 7.15.2
+    assert can_do([S.Half, 1], [Rational(3, 4), Rational(5, 4), Rational(3, 2)])  # PFDD
+    assert can_do([S.Half, 1], [Rational(7, 4), Rational(5, 4), Rational(3, 2)])  # PFDD
+
+    # 7.16.1
+    assert can_do([], [Rational(1, 3), S(2/3)])  # PFDD
+    assert can_do([], [Rational(2, 3), S(4/3)])  # PFDD
+    assert can_do([], [Rational(5, 3), S(4/3)])  # PFDD
+
+    # XXX this does not *evaluate* right??
+    assert can_do([], [a, a + S.Half, 2*a - 1])
+
+
+def test_bug():
+    h = hyper([-1, 1], [z], -1)
+    assert hyperexpand(h) == (z + 1)/z
+
+
+def test_omgissue_203():
+    h = hyper((-5, -3, -4), (-6, -6), 1)
+    assert hyperexpand(h) == Rational(1, 30)
+    h = hyper((-6, -7, -5), (-6, -6), 1)
+    assert hyperexpand(h) == Rational(-1, 6)
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/tests/test_powsimp.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/tests/test_powsimp.py
new file mode 100644
index 0000000000000000000000000000000000000000..61bdc93d052baf4b1e80da8f5864cf22b8fa383e
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/tests/test_powsimp.py
@@ -0,0 +1,368 @@
+from sympy.core.function import Function
+from sympy.core.mul import Mul
+from sympy.core.numbers import (E, I, Rational, oo, pi)
+from sympy.core.singleton import S
+from sympy.core.symbol import (Dummy, Symbol, symbols)
+from sympy.functions.elementary.exponential import (exp, log)
+from sympy.functions.elementary.miscellaneous import (root, sqrt)
+from sympy.functions.elementary.trigonometric import sin
+from sympy.functions.special.gamma_functions import gamma
+from sympy.functions.special.hyper import hyper
+from sympy.matrices.expressions.matexpr import MatrixSymbol
+from sympy.simplify.powsimp import (powdenest, powsimp)
+from sympy.simplify.simplify import (signsimp, simplify)
+from sympy.core.symbol import Str
+
+from sympy.abc import x, y, z, a, b
+
+
+def test_powsimp():
+    x, y, z, n = symbols('x,y,z,n')
+    f = Function('f')
+    assert powsimp( 4**x * 2**(-x) * 2**(-x) ) == 1
+    assert powsimp( (-4)**x * (-2)**(-x) * 2**(-x) ) == 1
+
+    assert powsimp(
+        f(4**x * 2**(-x) * 2**(-x)) ) == f(4**x * 2**(-x) * 2**(-x))
+    assert powsimp( f(4**x * 2**(-x) * 2**(-x)), deep=True ) == f(1)
+    assert exp(x)*exp(y) == exp(x)*exp(y)
+    assert powsimp(exp(x)*exp(y)) == exp(x + y)
+    assert powsimp(exp(x)*exp(y)*2**x*2**y) == (2*E)**(x + y)
+    assert powsimp(exp(x)*exp(y)*2**x*2**y, combine='exp') == \
+        exp(x + y)*2**(x + y)
+    assert powsimp(exp(x)*exp(y)*exp(2)*sin(x) + sin(y) + 2**x*2**y) == \
+        exp(2 + x + y)*sin(x) + sin(y) + 2**(x + y)
+    assert powsimp(sin(exp(x)*exp(y))) == sin(exp(x)*exp(y))
+    assert powsimp(sin(exp(x)*exp(y)), deep=True) == sin(exp(x + y))
+    assert powsimp(x**2*x**y) == x**(2 + y)
+    # This should remain factored, because 'exp' with deep=True is supposed
+    # to act like old automatic exponent combining.
+    assert powsimp((1 + E*exp(E))*exp(-E), combine='exp', deep=True) == \
+        (1 + exp(1 + E))*exp(-E)
+    assert powsimp((1 + E*exp(E))*exp(-E), deep=True) == \
+        (1 + exp(1 + E))*exp(-E)
+    assert powsimp((1 + E*exp(E))*exp(-E)) == (1 + exp(1 + E))*exp(-E)
+    assert powsimp((1 + E*exp(E))*exp(-E), combine='exp') == \
+        (1 + exp(1 + E))*exp(-E)
+    assert powsimp((1 + E*exp(E))*exp(-E), combine='base') == \
+        (1 + E*exp(E))*exp(-E)
+    x, y = symbols('x,y', nonnegative=True)
+    n = Symbol('n', real=True)
+    assert powsimp(y**n * (y/x)**(-n)) == x**n
+    assert powsimp(x**(x**(x*y)*y**(x*y))*y**(x**(x*y)*y**(x*y)), deep=True) \
+        == (x*y)**(x*y)**(x*y)
+    assert powsimp(2**(2**(2*x)*x), deep=False) == 2**(2**(2*x)*x)
+    assert powsimp(2**(2**(2*x)*x), deep=True) == 2**(x*4**x)
+    assert powsimp(
+        exp(-x + exp(-x)*exp(-x*log(x))), deep=False, combine='exp') == \
+        exp(-x + exp(-x)*exp(-x*log(x)))
+    assert powsimp(
+        exp(-x + exp(-x)*exp(-x*log(x))), deep=False, combine='exp') == \
+        exp(-x + exp(-x)*exp(-x*log(x)))
+    assert powsimp((x + y)/(3*z), deep=False, combine='exp') == (x + y)/(3*z)
+    assert powsimp((x/3 + y/3)/z, deep=True, combine='exp') == (x/3 + y/3)/z
+    assert powsimp(exp(x)/(1 + exp(x)*exp(y)), deep=True) == \
+        exp(x)/(1 + exp(x + y))
+    assert powsimp(x*y**(z**x*z**y), deep=True) == x*y**(z**(x + y))
+    assert powsimp((z**x*z**y)**x, deep=True) == (z**(x + y))**x
+    assert powsimp(x*(z**x*z**y)**x, deep=True) == x*(z**(x + y))**x
+    p = symbols('p', positive=True)
+    assert powsimp((1/x)**log(2)/x) == (1/x)**(1 + log(2))
+    assert powsimp((1/p)**log(2)/p) == p**(-1 - log(2))
+
+    # coefficient of exponent can only be simplified for positive bases
+    assert powsimp(2**(2*x)) == 4**x
+    assert powsimp((-1)**(2*x)) == (-1)**(2*x)
+    i = symbols('i', integer=True)
+    assert powsimp((-1)**(2*i)) == 1
+    assert powsimp((-1)**(-x)) != (-1)**x  # could be 1/((-1)**x), but is not
+    # force=True overrides assumptions
+    assert powsimp((-1)**(2*x), force=True) == 1
+
+    # rational exponents allow combining of negative terms
+    w, n, m = symbols('w n m', negative=True)
+    e = i/a  # not a rational exponent if `a` is unknown
+    ex = w**e*n**e*m**e
+    assert powsimp(ex) == m**(i/a)*n**(i/a)*w**(i/a)
+    e = i/3
+    ex = w**e*n**e*m**e
+    assert powsimp(ex) == (-1)**i*(-m*n*w)**(i/3)
+    e = (3 + i)/i
+    ex = w**e*n**e*m**e
+    assert powsimp(ex) == (-1)**(3*e)*(-m*n*w)**e
+
+    eq = x**(a*Rational(2, 3))
+    # eq != (x**a)**(2/3) (try x = -1 and a = 3 to see)
+    assert powsimp(eq).exp == eq.exp == a*Rational(2, 3)
+    # powdenest goes the other direction
+    assert powsimp(2**(2*x)) == 4**x
+
+    assert powsimp(exp(p/2)) == exp(p/2)
+
+    # issue 6368
+    eq = Mul(*[sqrt(Dummy(imaginary=True)) for i in range(3)])
+    assert powsimp(eq) == eq and eq.is_Mul
+
+    assert all(powsimp(e) == e for e in (sqrt(x**a), sqrt(x**2)))
+
+    # issue 8836
+    assert str( powsimp(exp(I*pi/3)*root(-1,3)) ) == '(-1)**(2/3)'
+
+    # issue 9183
+    assert powsimp(-0.1**x) == -0.1**x
+
+    # issue 10095
+    assert powsimp((1/(2*E))**oo) == (exp(-1)/2)**oo
+
+    # PR 13131
+    eq = sin(2*x)**2*sin(2.0*x)**2
+    assert powsimp(eq) == eq
+
+    # issue 14615
+    assert powsimp(x**2*y**3*(x*y**2)**Rational(3, 2)
+        ) == x*y*(x*y**2)**Rational(5, 2)
+
+    #issue 27380
+    assert powsimp(1.0**(x+1)/1.0**x) == 1.0
+
+def test_powsimp_negated_base():
+    assert powsimp((-x + y)/sqrt(x - y)) == -sqrt(x - y)
+    assert powsimp((-x + y)*(-z + y)/sqrt(x - y)/sqrt(z - y)) == sqrt(x - y)*sqrt(z - y)
+    p = symbols('p', positive=True)
+    reps = {p: 2, a: S.Half}
+    assert powsimp((-p)**a/p**a).subs(reps) == ((-1)**a).subs(reps)
+    assert powsimp((-p)**a*p**a).subs(reps) == ((-p**2)**a).subs(reps)
+    n = symbols('n', negative=True)
+    reps = {p: -2, a: S.Half}
+    assert powsimp((-n)**a/n**a).subs(reps) == (-1)**(-a).subs(a, S.Half)
+    assert powsimp((-n)**a*n**a).subs(reps) == ((-n**2)**a).subs(reps)
+    # if x is 0 then the lhs is 0**a*oo**a which is not (-1)**a
+    eq = (-x)**a/x**a
+    assert powsimp(eq) == eq
+
+
+def test_powsimp_nc():
+    x, y, z = symbols('x,y,z')
+    A, B, C = symbols('A B C', commutative=False)
+
+    assert powsimp(A**x*A**y, combine='all') == A**(x + y)
+    assert powsimp(A**x*A**y, combine='base') == A**x*A**y
+    assert powsimp(A**x*A**y, combine='exp') == A**(x + y)
+
+    assert powsimp(A**x*B**x, combine='all') == A**x*B**x
+    assert powsimp(A**x*B**x, combine='base') == A**x*B**x
+    assert powsimp(A**x*B**x, combine='exp') == A**x*B**x
+
+    assert powsimp(B**x*A**x, combine='all') == B**x*A**x
+    assert powsimp(B**x*A**x, combine='base') == B**x*A**x
+    assert powsimp(B**x*A**x, combine='exp') == B**x*A**x
+
+    assert powsimp(A**x*A**y*A**z, combine='all') == A**(x + y + z)
+    assert powsimp(A**x*A**y*A**z, combine='base') == A**x*A**y*A**z
+    assert powsimp(A**x*A**y*A**z, combine='exp') == A**(x + y + z)
+
+    assert powsimp(A**x*B**x*C**x, combine='all') == A**x*B**x*C**x
+    assert powsimp(A**x*B**x*C**x, combine='base') == A**x*B**x*C**x
+    assert powsimp(A**x*B**x*C**x, combine='exp') == A**x*B**x*C**x
+
+    assert powsimp(B**x*A**x*C**x, combine='all') == B**x*A**x*C**x
+    assert powsimp(B**x*A**x*C**x, combine='base') == B**x*A**x*C**x
+    assert powsimp(B**x*A**x*C**x, combine='exp') == B**x*A**x*C**x
+
+
+def test_issue_6440():
+    assert powsimp(16*2**a*8**b) == 2**(a + 3*b + 4)
+
+
+def test_powdenest():
+    x, y = symbols('x,y')
+    p, q = symbols('p q', positive=True)
+    i, j = symbols('i,j', integer=True)
+
+    assert powdenest(x) == x
+    assert powdenest(x + 2*(x**(a*Rational(2, 3)))**(3*x)) == (x + 2*(x**(a*Rational(2, 3)))**(3*x))
+    assert powdenest((exp(a*Rational(2, 3)))**(3*x))  # -X-> (exp(a/3))**(6*x)
+    assert powdenest((x**(a*Rational(2, 3)))**(3*x)) == ((x**(a*Rational(2, 3)))**(3*x))
+    assert powdenest(exp(3*x*log(2))) == 2**(3*x)
+    assert powdenest(sqrt(p**2)) == p
+    eq = p**(2*i)*q**(4*i)
+    assert powdenest(eq) == (p*q**2)**(2*i)
+    # -X-> (x**x)**i*(x**x)**j == x**(x*(i + j))
+    assert powdenest((x**x)**(i + j))
+    assert powdenest(exp(3*y*log(x))) == x**(3*y)
+    assert powdenest(exp(y*(log(a) + log(b)))) == (a*b)**y
+    assert powdenest(exp(3*(log(a) + log(b)))) == a**3*b**3
+    assert powdenest(((x**(2*i))**(3*y))**x) == ((x**(2*i))**(3*y))**x
+    assert powdenest(((x**(2*i))**(3*y))**x, force=True) == x**(6*i*x*y)
+    assert powdenest(((x**(a*Rational(2, 3)))**(3*y/i))**x) == \
+        (((x**(a*Rational(2, 3)))**(3*y/i))**x)
+    assert powdenest((x**(2*i)*y**(4*i))**z, force=True) == (x*y**2)**(2*i*z)
+    assert powdenest((p**(2*i)*q**(4*i))**j) == (p*q**2)**(2*i*j)
+    e = ((p**(2*a))**(3*y))**x
+    assert powdenest(e) == e
+    e = ((x**2*y**4)**a)**(x*y)
+    assert powdenest(e) == e
+    e = (((x**2*y**4)**a)**(x*y))**3
+    assert powdenest(e) == ((x**2*y**4)**a)**(3*x*y)
+    assert powdenest((((x**2*y**4)**a)**(x*y)), force=True) == \
+        (x*y**2)**(2*a*x*y)
+    assert powdenest((((x**2*y**4)**a)**(x*y))**3, force=True) == \
+        (x*y**2)**(6*a*x*y)
+    assert powdenest((x**2*y**6)**i) != (x*y**3)**(2*i)
+    x, y = symbols('x,y', positive=True)
+    assert powdenest((x**2*y**6)**i) == (x*y**3)**(2*i)
+
+    assert powdenest((x**(i*Rational(2, 3))*y**(i/2))**(2*i)) == (x**Rational(4, 3)*y)**(i**2)
+    assert powdenest(sqrt(x**(2*i)*y**(6*i))) == (x*y**3)**i
+
+    assert powdenest(4**x) == 2**(2*x)
+    assert powdenest((4**x)**y) == 2**(2*x*y)
+    assert powdenest(4**x*y) == 2**(2*x)*y
+
+
+def test_powdenest_polar():
+    x, y, z = symbols('x y z', polar=True)
+    a, b, c = symbols('a b c')
+    assert powdenest((x*y*z)**a) == x**a*y**a*z**a
+    assert powdenest((x**a*y**b)**c) == x**(a*c)*y**(b*c)
+    assert powdenest(((x**a)**b*y**c)**c) == x**(a*b*c)*y**(c**2)
+
+
+def test_issue_5805():
+    arg = ((gamma(x)*hyper((), (), x))*pi)**2
+    assert powdenest(arg) == (pi*gamma(x)*hyper((), (), x))**2
+    assert arg.is_positive is None
+
+
+def test_issue_9324_powsimp_on_matrix_symbol():
+    M = MatrixSymbol('M', 10, 10)
+    expr = powsimp(M, deep=True)
+    assert expr == M
+    assert expr.args[0] == Str('M')
+
+
+def test_issue_6367():
+    z = -5*sqrt(2)/(2*sqrt(2*sqrt(29) + 29)) + sqrt(-sqrt(29)/29 + S.Half)
+    assert Mul(*[powsimp(a) for a in Mul.make_args(z.normal())]) == 0
+    assert powsimp(z.normal()) == 0
+    assert simplify(z) == 0
+    assert powsimp(sqrt(2 + sqrt(3))*sqrt(2 - sqrt(3)) + 1) == 2
+    assert powsimp(z) != 0
+
+
+def test_powsimp_polar():
+    from sympy.functions.elementary.complexes import polar_lift
+    from sympy.functions.elementary.exponential import exp_polar
+    x, y, z = symbols('x y z')
+    p, q, r = symbols('p q r', polar=True)
+
+    assert (polar_lift(-1))**(2*x) == exp_polar(2*pi*I*x)
+    assert powsimp(p**x * q**x) == (p*q)**x
+    assert p**x * (1/p)**x == 1
+    assert (1/p)**x == p**(-x)
+
+    assert exp_polar(x)*exp_polar(y) == exp_polar(x)*exp_polar(y)
+    assert powsimp(exp_polar(x)*exp_polar(y)) == exp_polar(x + y)
+    assert powsimp(exp_polar(x)*exp_polar(y)*p**x*p**y) == \
+        (p*exp_polar(1))**(x + y)
+    assert powsimp(exp_polar(x)*exp_polar(y)*p**x*p**y, combine='exp') == \
+        exp_polar(x + y)*p**(x + y)
+    assert powsimp(
+        exp_polar(x)*exp_polar(y)*exp_polar(2)*sin(x) + sin(y) + p**x*p**y) \
+        == p**(x + y) + sin(x)*exp_polar(2 + x + y) + sin(y)
+    assert powsimp(sin(exp_polar(x)*exp_polar(y))) == \
+        sin(exp_polar(x)*exp_polar(y))
+    assert powsimp(sin(exp_polar(x)*exp_polar(y)), deep=True) == \
+        sin(exp_polar(x + y))
+
+
+def test_issue_5728():
+    b = x*sqrt(y)
+    a = sqrt(b)
+    c = sqrt(sqrt(x)*y)
+    assert powsimp(a*b) == sqrt(b)**3
+    assert powsimp(a*b**2*sqrt(y)) == sqrt(y)*a**5
+    assert powsimp(a*x**2*c**3*y) == c**3*a**5
+    assert powsimp(a*x*c**3*y**2) == c**7*a
+    assert powsimp(x*c**3*y**2) == c**7
+    assert powsimp(x*c**3*y) == x*y*c**3
+    assert powsimp(sqrt(x)*c**3*y) == c**5
+    assert powsimp(sqrt(x)*a**3*sqrt(y)) == sqrt(x)*sqrt(y)*a**3
+    assert powsimp(Mul(sqrt(x)*c**3*sqrt(y), y, evaluate=False)) == \
+        sqrt(x)*sqrt(y)**3*c**3
+    assert powsimp(a**2*a*x**2*y) == a**7
+
+    # symbolic powers work, too
+    b = x**y*y
+    a = b*sqrt(b)
+    assert a.is_Mul is True
+    assert powsimp(a) == sqrt(b)**3
+
+    # as does exp
+    a = x*exp(y*Rational(2, 3))
+    assert powsimp(a*sqrt(a)) == sqrt(a)**3
+    assert powsimp(a**2*sqrt(a)) == sqrt(a)**5
+    assert powsimp(a**2*sqrt(sqrt(a))) == sqrt(sqrt(a))**9
+
+
+def test_issue_from_PR1599():
+    n1, n2, n3, n4 = symbols('n1 n2 n3 n4', negative=True)
+    assert (powsimp(sqrt(n1)*sqrt(n2)*sqrt(n3)) ==
+        -I*sqrt(-n1)*sqrt(-n2)*sqrt(-n3))
+    assert (powsimp(root(n1, 3)*root(n2, 3)*root(n3, 3)*root(n4, 3)) ==
+        -(-1)**Rational(1, 3)*
+        (-n1)**Rational(1, 3)*(-n2)**Rational(1, 3)*(-n3)**Rational(1, 3)*(-n4)**Rational(1, 3))
+
+
+def test_issue_10195():
+    a = Symbol('a', integer=True)
+    l = Symbol('l', even=True, nonzero=True)
+    n = Symbol('n', odd=True)
+    e_x = (-1)**(n/2 - S.Half) - (-1)**(n*Rational(3, 2) - S.Half)
+    assert powsimp((-1)**(l/2)) == I**l
+    assert powsimp((-1)**(n/2)) == I**n
+    assert powsimp((-1)**(n*Rational(3, 2))) == -I**n
+    assert powsimp(e_x) == (-1)**(n/2 - S.Half) + (-1)**(n*Rational(3, 2) +
+            S.Half)
+    assert powsimp((-1)**(a*Rational(3, 2))) == (-I)**a
+
+def test_issue_15709():
+    assert powsimp(3**x*Rational(2, 3)) == 2*3**(x-1)
+    assert powsimp(2*3**x/3) == 2*3**(x-1)
+
+
+def test_issue_11981():
+    x, y = symbols('x y', commutative=False)
+    assert powsimp((x*y)**2 * (y*x)**2) == (x*y)**2 * (y*x)**2
+
+
+def test_issue_17524():
+    a = symbols("a", real=True)
+    e = (-1 - a**2)*sqrt(1 + a**2)
+    assert signsimp(powsimp(e)) == signsimp(e) == -(a**2 + 1)**(S(3)/2)
+
+
+def test_issue_19627():
+    # if you use force the user must verify
+    assert powdenest(sqrt(sin(x)**2), force=True) == sin(x)
+    assert powdenest((x**(S.Half/y))**(2*y), force=True) == x
+    from sympy.core.function import expand_power_base
+    e = 1 - a
+    expr = (exp(z/e)*x**(b/e)*y**((1 - b)/e))**e
+    assert powdenest(expand_power_base(expr, force=True), force=True
+        ) == x**b*y**(1 - b)*exp(z)
+
+
+def test_issue_22546():
+    p1, p2 = symbols('p1, p2', positive=True)
+    ref = powsimp(p1**z/p2**z)
+    e = z + 1
+    ans = ref.subs(z, e)
+    assert ans.is_Pow
+    assert powsimp(p1**e/p2**e) == ans
+    i = symbols('i', integer=True)
+    ref = powsimp(x**i/y**i)
+    e = i + 1
+    ans = ref.subs(i, e)
+    assert ans.is_Pow
+    assert powsimp(x**e/y**e) == ans
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/tests/test_radsimp.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/tests/test_radsimp.py
new file mode 100644
index 0000000000000000000000000000000000000000..f8ff955e48a34536c1752c565c0864dedae6a214
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/tests/test_radsimp.py
@@ -0,0 +1,498 @@
+from sympy.core.add import Add
+from sympy.core.function import (Derivative, Function, diff)
+from sympy.core.mul import Mul
+from sympy.core.numbers import (I, Rational)
+from sympy.core.power import Pow
+from sympy.core.singleton import S
+from sympy.core.symbol import (Symbol, Wild, symbols)
+from sympy.functions.elementary.complexes import Abs
+from sympy.functions.elementary.exponential import (exp, log)
+from sympy.functions.elementary.miscellaneous import (root, sqrt)
+from sympy.functions.elementary.trigonometric import (cos, sin)
+from sympy.polys.polytools import factor
+from sympy.series.order import O
+from sympy.simplify.radsimp import (collect, collect_const, fraction, radsimp, rcollect)
+
+from sympy.core.expr import unchanged
+from sympy.core.mul import _unevaluated_Mul as umul
+from sympy.simplify.radsimp import (_unevaluated_Add,
+    collect_sqrt, fraction_expand, collect_abs)
+from sympy.testing.pytest import raises
+
+from sympy.abc import x, y, z, a, b, c, d
+
+
+def test_radsimp():
+    r2 = sqrt(2)
+    r3 = sqrt(3)
+    r5 = sqrt(5)
+    r7 = sqrt(7)
+    assert fraction(radsimp(1/r2)) == (sqrt(2), 2)
+    assert radsimp(1/(1 + r2)) == \
+        -1 + sqrt(2)
+    assert radsimp(1/(r2 + r3)) == \
+        -sqrt(2) + sqrt(3)
+    assert fraction(radsimp(1/(1 + r2 + r3))) == \
+        (-sqrt(6) + sqrt(2) + 2, 4)
+    assert fraction(radsimp(1/(r2 + r3 + r5))) == \
+        (-sqrt(30) + 2*sqrt(3) + 3*sqrt(2), 12)
+    assert fraction(radsimp(1/(1 + r2 + r3 + r5))) == (
+        (-34*sqrt(10) - 26*sqrt(15) - 55*sqrt(3) - 61*sqrt(2) + 14*sqrt(30) +
+        93 + 46*sqrt(6) + 53*sqrt(5), 71))
+    assert fraction(radsimp(1/(r2 + r3 + r5 + r7))) == (
+        (-50*sqrt(42) - 133*sqrt(5) - 34*sqrt(70) - 145*sqrt(3) + 22*sqrt(105)
+        + 185*sqrt(2) + 62*sqrt(30) + 135*sqrt(7), 215))
+    z = radsimp(1/(1 + r2/3 + r3/5 + r5 + r7))
+    assert len((3616791619821680643598*z).args) == 16
+    assert radsimp(1/z) == 1/z
+    assert radsimp(1/z, max_terms=20).expand() == 1 + r2/3 + r3/5 + r5 + r7
+    assert radsimp(1/(r2*3)) == \
+        sqrt(2)/6
+    assert radsimp(1/(r2*a + r3 + r5 + r7)) == (
+        (8*sqrt(2)*a**7 - 8*sqrt(7)*a**6 - 8*sqrt(5)*a**6 - 8*sqrt(3)*a**6 -
+        180*sqrt(2)*a**5 + 8*sqrt(30)*a**5 + 8*sqrt(42)*a**5 + 8*sqrt(70)*a**5
+        - 24*sqrt(105)*a**4 + 84*sqrt(3)*a**4 + 100*sqrt(5)*a**4 +
+        116*sqrt(7)*a**4 - 72*sqrt(70)*a**3 - 40*sqrt(42)*a**3 -
+        8*sqrt(30)*a**3 + 782*sqrt(2)*a**3 - 462*sqrt(3)*a**2 -
+        302*sqrt(7)*a**2 - 254*sqrt(5)*a**2 + 120*sqrt(105)*a**2 -
+        795*sqrt(2)*a - 62*sqrt(30)*a + 82*sqrt(42)*a + 98*sqrt(70)*a -
+        118*sqrt(105) + 59*sqrt(7) + 295*sqrt(5) + 531*sqrt(3))/(16*a**8 -
+        480*a**6 + 3128*a**4 - 6360*a**2 + 3481))
+    assert radsimp(1/(r2*a + r2*b + r3 + r7)) == (
+        (sqrt(2)*a*(a + b)**2 - 5*sqrt(2)*a + sqrt(42)*a + sqrt(2)*b*(a +
+        b)**2 - 5*sqrt(2)*b + sqrt(42)*b - sqrt(7)*(a + b)**2 - sqrt(3)*(a +
+        b)**2 - 2*sqrt(3) + 2*sqrt(7))/(2*a**4 + 8*a**3*b + 12*a**2*b**2 -
+        20*a**2 + 8*a*b**3 - 40*a*b + 2*b**4 - 20*b**2 + 8))
+    assert radsimp(1/(r2*a + r2*b + r2*c + r2*d)) == \
+        sqrt(2)/(2*a + 2*b + 2*c + 2*d)
+    assert radsimp(1/(1 + r2*a + r2*b + r2*c + r2*d)) == (
+        (sqrt(2)*a + sqrt(2)*b + sqrt(2)*c + sqrt(2)*d - 1)/(2*a**2 + 4*a*b +
+        4*a*c + 4*a*d + 2*b**2 + 4*b*c + 4*b*d + 2*c**2 + 4*c*d + 2*d**2 - 1))
+    assert radsimp((y**2 - x)/(y - sqrt(x))) == \
+        sqrt(x) + y
+    assert radsimp(-(y**2 - x)/(y - sqrt(x))) == \
+        -(sqrt(x) + y)
+    assert radsimp(1/(1 - I + a*I)) == \
+        (-I*a + 1 + I)/(a**2 - 2*a + 2)
+    assert radsimp(1/((-x + y)*(x - sqrt(y)))) == \
+        (-x - sqrt(y))/((x - y)*(x**2 - y))
+    e = (3 + 3*sqrt(2))*x*(3*x - 3*sqrt(y))
+    assert radsimp(e) == x*(3 + 3*sqrt(2))*(3*x - 3*sqrt(y))
+    assert radsimp(1/e) == (
+        (-9*x + 9*sqrt(2)*x - 9*sqrt(y) + 9*sqrt(2)*sqrt(y))/(9*x*(9*x**2 -
+        9*y)))
+    assert radsimp(1 + 1/(1 + sqrt(3))) == \
+        Mul(S.Half, -1 + sqrt(3), evaluate=False) + 1
+    A = symbols("A", commutative=False)
+    assert radsimp(x**2 + sqrt(2)*x**2 - sqrt(2)*x*A) == \
+        x**2 + sqrt(2)*x**2 - sqrt(2)*x*A
+    assert radsimp(1/sqrt(5 + 2 * sqrt(6))) == -sqrt(2) + sqrt(3)
+    assert radsimp(1/sqrt(5 + 2 * sqrt(6))**3) == -(-sqrt(3) + sqrt(2))**3
+
+    # issue 6532
+    assert fraction(radsimp(1/sqrt(x))) == (sqrt(x), x)
+    assert fraction(radsimp(1/sqrt(2*x + 3))) == (sqrt(2*x + 3), 2*x + 3)
+    assert fraction(radsimp(1/sqrt(2*(x + 3)))) == (sqrt(2*x + 6), 2*x + 6)
+
+    # issue 5994
+    e = S('-(2 + 2*sqrt(2) + 4*2**(1/4))/'
+        '(1 + 2**(3/4) + 3*2**(1/4) + 3*sqrt(2))')
+    assert radsimp(e).expand() == -2*2**Rational(3, 4) - 2*2**Rational(1, 4) + 2 + 2*sqrt(2)
+
+    # issue 5986 (modifications to radimp didn't initially recognize this so
+    # the test is included here)
+    assert radsimp(1/(-sqrt(5)/2 - S.Half + (-sqrt(5)/2 - S.Half)**2)) == 1
+
+    # from issue 5934
+    eq = (
+        (-240*sqrt(2)*sqrt(sqrt(5) + 5)*sqrt(8*sqrt(5) + 40) -
+        360*sqrt(2)*sqrt(-8*sqrt(5) + 40)*sqrt(-sqrt(5) + 5) -
+        120*sqrt(10)*sqrt(-8*sqrt(5) + 40)*sqrt(-sqrt(5) + 5) +
+        120*sqrt(2)*sqrt(-sqrt(5) + 5)*sqrt(8*sqrt(5) + 40) +
+        120*sqrt(2)*sqrt(-8*sqrt(5) + 40)*sqrt(sqrt(5) + 5) +
+        120*sqrt(10)*sqrt(-sqrt(5) + 5)*sqrt(8*sqrt(5) + 40) +
+        120*sqrt(10)*sqrt(-8*sqrt(5) + 40)*sqrt(sqrt(5) + 5))/(-36000 -
+        7200*sqrt(5) + (12*sqrt(10)*sqrt(sqrt(5) + 5) +
+        24*sqrt(10)*sqrt(-sqrt(5) + 5))**2))
+    assert radsimp(eq) is S.NaN  # it's 0/0
+
+    # work with normal form
+    e = 1/sqrt(sqrt(7)/7 + 2*sqrt(2) + 3*sqrt(3) + 5*sqrt(5)) + 3
+    assert radsimp(e) == (
+        -sqrt(sqrt(7) + 14*sqrt(2) + 21*sqrt(3) +
+        35*sqrt(5))*(-11654899*sqrt(35) - 1577436*sqrt(210) - 1278438*sqrt(15)
+        - 1346996*sqrt(10) + 1635060*sqrt(6) + 5709765 + 7539830*sqrt(14) +
+        8291415*sqrt(21))/1300423175 + 3)
+
+    # obey power rules
+    base = sqrt(3) - sqrt(2)
+    assert radsimp(1/base**3) == (sqrt(3) + sqrt(2))**3
+    assert radsimp(1/(-base)**3) == -(sqrt(2) + sqrt(3))**3
+    assert radsimp(1/(-base)**x) == (-base)**(-x)
+    assert radsimp(1/base**x) == (sqrt(2) + sqrt(3))**x
+    assert radsimp(root(1/(-1 - sqrt(2)), -x)) == (-1)**(-1/x)*(1 + sqrt(2))**(1/x)
+
+    # recurse
+    e = cos(1/(1 + sqrt(2)))
+    assert radsimp(e) == cos(-sqrt(2) + 1)
+    assert radsimp(e/2) == cos(-sqrt(2) + 1)/2
+    assert radsimp(1/e) == 1/cos(-sqrt(2) + 1)
+    assert radsimp(2/e) == 2/cos(-sqrt(2) + 1)
+    assert fraction(radsimp(e/sqrt(x))) == (sqrt(x)*cos(-sqrt(2)+1), x)
+
+    # test that symbolic denominators are not processed
+    r = 1 + sqrt(2)
+    assert radsimp(x/r, symbolic=False) == -x*(-sqrt(2) + 1)
+    assert radsimp(x/(y + r), symbolic=False) == x/(y + 1 + sqrt(2))
+    assert radsimp(x/(y + r)/r, symbolic=False) == \
+        -x*(-sqrt(2) + 1)/(y + 1 + sqrt(2))
+
+    # issue 7408
+    eq = sqrt(x)/sqrt(y)
+    assert radsimp(eq) == umul(sqrt(x), sqrt(y), 1/y)
+    assert radsimp(eq, symbolic=False) == eq
+
+    # issue 7498
+    assert radsimp(sqrt(x)/sqrt(y)**3) == umul(sqrt(x), sqrt(y**3), 1/y**3)
+
+    # for coverage
+    eq = sqrt(x)/y**2
+    assert radsimp(eq) == eq
+
+    # handle non-Expr args
+    from sympy.integrals.integrals import Integral
+    eq = Integral(x/(sqrt(2) - 1), (x, 0, 1/(sqrt(2) + 1)))
+    assert radsimp(eq) == Integral((sqrt(2) + 1)*x , (x, 0, sqrt(2) - 1))
+
+    from sympy.sets import FiniteSet
+    eq = FiniteSet(x/(sqrt(2) - 1))
+    assert radsimp(eq) == FiniteSet((sqrt(2) + 1)*x)
+
+def test_radsimp_issue_3214():
+    c, p = symbols('c p', positive=True)
+    s = sqrt(c**2 - p**2)
+    b = (c + I*p - s)/(c + I*p + s)
+    assert radsimp(b) == -I*(c + I*p - sqrt(c**2 - p**2))**2/(2*c*p)
+
+
+def test_collect_1():
+    """Collect with respect to Symbol"""
+    x, y, z, n = symbols('x,y,z,n')
+    assert collect(1, x) == 1
+    assert collect( x + y*x, x ) == x * (1 + y)
+    assert collect( x + x**2, x ) == x + x**2
+    assert collect( x**2 + y*x**2, x ) == (x**2)*(1 + y)
+    assert collect( x**2 + y*x, x ) == x*y + x**2
+    assert collect( 2*x**2 + y*x**2 + 3*x*y, [x] ) == x**2*(2 + y) + 3*x*y
+    assert collect( 2*x**2 + y*x**2 + 3*x*y, [y] ) == 2*x**2 + y*(x**2 + 3*x)
+
+    assert collect( ((1 + y + x)**4).expand(), x) == ((1 + y)**4).expand() + \
+        x*(4*(1 + y)**3).expand() + x**2*(6*(1 + y)**2).expand() + \
+        x**3*(4*(1 + y)).expand() + x**4
+    # symbols can be given as any iterable
+    expr = x + y
+    assert collect(expr, expr.free_symbols) == expr
+    assert collect(x*exp(x) + sin(x)*y + sin(x)*2 + 3*x, x, exact=None
+        ) == x*exp(x) + 3*x + (y + 2)*sin(x)
+    assert collect(x*exp(x) + sin(x)*y + sin(x)*2 + 3*x + y*x +
+        y*x*exp(x), x, exact=None
+        ) == x*exp(x)*(y + 1) + (3 + y)*x + (y + 2)*sin(x)
+
+
+def test_collect_2():
+    """Collect with respect to a sum"""
+    a, b, x = symbols('a,b,x')
+    assert collect(a*(cos(x) + sin(x)) + b*(cos(x) + sin(x)),
+        sin(x) + cos(x)) == (a + b)*(cos(x) + sin(x))
+
+
+def test_collect_3():
+    """Collect with respect to a product"""
+    a, b, c = symbols('a,b,c')
+    f = Function('f')
+    x, y, z, n = symbols('x,y,z,n')
+
+    assert collect(-x/8 + x*y, -x) == x*(y - Rational(1, 8))
+
+    assert collect( 1 + x*(y**2), x*y ) == 1 + x*(y**2)
+    assert collect( x*y + a*x*y, x*y) == x*y*(1 + a)
+    assert collect( 1 + x*y + a*x*y, x*y) == 1 + x*y*(1 + a)
+    assert collect(a*x*f(x) + b*(x*f(x)), x*f(x)) == x*(a + b)*f(x)
+
+    assert collect(a*x*log(x) + b*(x*log(x)), x*log(x)) == x*(a + b)*log(x)
+    assert collect(a*x**2*log(x)**2 + b*(x*log(x))**2, x*log(x)) == \
+        x**2*log(x)**2*(a + b)
+
+    # with respect to a product of three symbols
+    assert collect(y*x*z + a*x*y*z, x*y*z) == (1 + a)*x*y*z
+
+
+def test_collect_4():
+    """Collect with respect to a power"""
+    a, b, c, x = symbols('a,b,c,x')
+
+    assert collect(a*x**c + b*x**c, x**c) == x**c*(a + b)
+    # issue 6096: 2 stays with c (unless c is integer or x is positive0
+    assert collect(a*x**(2*c) + b*x**(2*c), x**c) == x**(2*c)*(a + b)
+
+
+def test_collect_5():
+    """Collect with respect to a tuple"""
+    a, x, y, z, n = symbols('a,x,y,z,n')
+    assert collect(x**2*y**4 + z*(x*y**2)**2 + z + a*z, [x*y**2, z]) in [
+        z*(1 + a + x**2*y**4) + x**2*y**4,
+        z*(1 + a) + x**2*y**4*(1 + z) ]
+    assert collect((1 + (x + y) + (x + y)**2).expand(),
+                   [x, y]) == 1 + y + x*(1 + 2*y) + x**2 + y**2
+
+
+def test_collect_pr19431():
+    """Unevaluated collect with respect to a product"""
+    a = symbols('a')
+    assert collect(a**2*(a**2 + 1), a**2, evaluate=False)[a**2] == (a**2 + 1)
+
+
+def test_collect_D():
+    D = Derivative
+    f = Function('f')
+    x, a, b = symbols('x,a,b')
+    fx = D(f(x), x)
+    fxx = D(f(x), x, x)
+
+    assert collect(a*fx + b*fx, fx) == (a + b)*fx
+    assert collect(a*D(fx, x) + b*D(fx, x), fx) == (a + b)*D(fx, x)
+    assert collect(a*fxx + b*fxx, fx) == (a + b)*D(fx, x)
+    # issue 4784
+    assert collect(5*f(x) + 3*fx, fx) == 5*f(x) + 3*fx
+    assert collect(f(x) + f(x)*diff(f(x), x) + x*diff(f(x), x)*f(x), f(x).diff(x)) == \
+        (x*f(x) + f(x))*D(f(x), x) + f(x)
+    assert collect(f(x) + f(x)*diff(f(x), x) + x*diff(f(x), x)*f(x), f(x).diff(x), exact=True) == \
+        (x*f(x) + f(x))*D(f(x), x) + f(x)
+    assert collect(1/f(x) + 1/f(x)*diff(f(x), x) + x*diff(f(x), x)/f(x), f(x).diff(x), exact=True) == \
+        (1/f(x) + x/f(x))*D(f(x), x) + 1/f(x)
+    e = (1 + x*fx + fx)/f(x)
+    assert collect(e.expand(), fx) == fx*(x/f(x) + 1/f(x)) + 1/f(x)
+
+
+def test_collect_func():
+    f = ((x + a + 1)**3).expand()
+
+    assert collect(f, x) == a**3 + 3*a**2 + 3*a + x**3 + x**2*(3*a + 3) + \
+        x*(3*a**2 + 6*a + 3) + 1
+    assert collect(f, x, factor) == x**3 + 3*x**2*(a + 1) + 3*x*(a + 1)**2 + \
+        (a + 1)**3
+
+    assert collect(f, x, evaluate=False) == {
+        S.One: a**3 + 3*a**2 + 3*a + 1,
+        x: 3*a**2 + 6*a + 3, x**2: 3*a + 3,
+        x**3: 1
+    }
+
+    assert collect(f, x, factor, evaluate=False) == {
+        S.One: (a + 1)**3, x: 3*(a + 1)**2,
+        x**2: umul(S(3), a + 1), x**3: 1}
+
+
+def test_collect_order():
+    a, b, x, t = symbols('a,b,x,t')
+
+    assert collect(t + t*x + t*x**2 + O(x**3), t) == t*(1 + x + x**2 + O(x**3))
+    assert collect(t + t*x + x**2 + O(x**3), t) == \
+        t*(1 + x + O(x**3)) + x**2 + O(x**3)
+
+    f = a*x + b*x + c*x**2 + d*x**2 + O(x**3)
+    g = x*(a + b) + x**2*(c + d) + O(x**3)
+
+    assert collect(f, x) == g
+    assert collect(f, x, distribute_order_term=False) == g
+
+    f = sin(a + b).series(b, 0, 10)
+
+    assert collect(f, [sin(a), cos(a)]) == \
+        sin(a)*cos(b).series(b, 0, 10) + cos(a)*sin(b).series(b, 0, 10)
+    assert collect(f, [sin(a), cos(a)], distribute_order_term=False) == \
+        sin(a)*cos(b).series(b, 0, 10).removeO() + \
+        cos(a)*sin(b).series(b, 0, 10).removeO() + O(b**10)
+
+
+def test_rcollect():
+    assert rcollect((x**2*y + x*y + x + y)/(x + y), y) == \
+        (x + y*(1 + x + x**2))/(x + y)
+    assert rcollect(sqrt(-((x + 1)*(y + 1))), z) == sqrt(-((x + 1)*(y + 1)))
+
+
+def test_collect_D_0():
+    D = Derivative
+    f = Function('f')
+    x, a, b = symbols('x,a,b')
+    fxx = D(f(x), x, x)
+
+    assert collect(a*fxx + b*fxx, fxx) == (a + b)*fxx
+
+
+def test_collect_Wild():
+    """Collect with respect to functions with Wild argument"""
+    a, b, x, y = symbols('a b x y')
+    f = Function('f')
+    w1 = Wild('.1')
+    w2 = Wild('.2')
+    assert collect(f(x) + a*f(x), f(w1)) == (1 + a)*f(x)
+    assert collect(f(x, y) + a*f(x, y), f(w1)) == f(x, y) + a*f(x, y)
+    assert collect(f(x, y) + a*f(x, y), f(w1, w2)) == (1 + a)*f(x, y)
+    assert collect(f(x, y) + a*f(x, y), f(w1, w1)) == f(x, y) + a*f(x, y)
+    assert collect(f(x, x) + a*f(x, x), f(w1, w1)) == (1 + a)*f(x, x)
+    assert collect(a*(x + 1)**y + (x + 1)**y, w1**y) == (1 + a)*(x + 1)**y
+    assert collect(a*(x + 1)**y + (x + 1)**y, w1**b) == \
+        a*(x + 1)**y + (x + 1)**y
+    assert collect(a*(x + 1)**y + (x + 1)**y, (x + 1)**w2) == \
+        (1 + a)*(x + 1)**y
+    assert collect(a*(x + 1)**y + (x + 1)**y, w1**w2) == (1 + a)*(x + 1)**y
+
+
+def test_collect_const():
+    # coverage not provided by above tests
+    assert collect_const(2*sqrt(3) + 4*a*sqrt(5)) == \
+        2*(2*sqrt(5)*a + sqrt(3))  # let the primitive reabsorb
+    assert collect_const(2*sqrt(3) + 4*a*sqrt(5), sqrt(3)) == \
+        2*sqrt(3) + 4*a*sqrt(5)
+    assert collect_const(sqrt(2)*(1 + sqrt(2)) + sqrt(3) + x*sqrt(2)) == \
+        sqrt(2)*(x + 1 + sqrt(2)) + sqrt(3)
+
+    # issue 5290
+    assert collect_const(2*x + 2*y + 1, 2) == \
+        collect_const(2*x + 2*y + 1) == \
+        Add(S.One, Mul(2, x + y, evaluate=False), evaluate=False)
+    assert collect_const(-y - z) == Mul(-1, y + z, evaluate=False)
+    assert collect_const(2*x - 2*y - 2*z, 2) == \
+        Mul(2, x - y - z, evaluate=False)
+    assert collect_const(2*x - 2*y - 2*z, -2) == \
+        _unevaluated_Add(2*x, Mul(-2, y + z, evaluate=False))
+
+    # this is why the content_primitive is used
+    eq = (sqrt(15 + 5*sqrt(2))*x + sqrt(3 + sqrt(2))*y)*2
+    assert collect_sqrt(eq + 2) == \
+        2*sqrt(sqrt(2) + 3)*(sqrt(5)*x + y) + 2
+
+    # issue 16296
+    assert collect_const(a + b + x/2 + y/2) == a + b + Mul(S.Half, x + y, evaluate=False)
+
+
+def test_issue_13143():
+    f = Function('f')
+    fx = f(x).diff(x)
+    e = f(x) + fx + f(x)*fx
+    # collect function before derivative
+    assert collect(e, Wild('w')) == f(x)*(fx + 1) + fx
+    e = f(x) + f(x)*fx + x*fx*f(x)
+    assert collect(e, fx) == (x*f(x) + f(x))*fx + f(x)
+    assert collect(e, f(x)) == (x*fx + fx + 1)*f(x)
+    e = f(x) + fx + f(x)*fx
+    assert collect(e, [f(x), fx]) == f(x)*(1 + fx) + fx
+    assert collect(e, [fx, f(x)]) == fx*(1 + f(x)) + f(x)
+
+
+def test_issue_6097():
+    assert collect(a*y**(2.0*x) + b*y**(2.0*x), y**x) == (a + b)*(y**x)**2.0
+    assert collect(a*2**(2.0*x) + b*2**(2.0*x), 2**x) == (a + b)*(2**x)**2.0
+
+
+def test_fraction_expand():
+    eq = (x + y)*y/x
+    assert eq.expand(frac=True) == fraction_expand(eq) == (x*y + y**2)/x
+    assert eq.expand() == y + y**2/x
+
+
+def test_fraction():
+    x, y, z = map(Symbol, 'xyz')
+    A = Symbol('A', commutative=False)
+
+    assert fraction(S.Half) == (1, 2)
+
+    assert fraction(x) == (x, 1)
+    assert fraction(1/x) == (1, x)
+    assert fraction(x/y) == (x, y)
+    assert fraction(x/2) == (x, 2)
+
+    assert fraction(x*y/z) == (x*y, z)
+    assert fraction(x/(y*z)) == (x, y*z)
+
+    assert fraction(1/y**2) == (1, y**2)
+    assert fraction(x/y**2) == (x, y**2)
+
+    assert fraction((x**2 + 1)/y) == (x**2 + 1, y)
+    assert fraction(x*(y + 1)/y**7) == (x*(y + 1), y**7)
+
+    assert fraction(exp(-x), exact=True) == (exp(-x), 1)
+    assert fraction((1/(x + y))/2, exact=True) == (1, Mul(2,(x + y), evaluate=False))
+
+    assert fraction(x*A/y) == (x*A, y)
+    assert fraction(x*A**-1/y) == (x*A**-1, y)
+
+    n = symbols('n', negative=True)
+    assert fraction(exp(n)) == (1, exp(-n))
+    assert fraction(exp(-n)) == (exp(-n), 1)
+
+    p = symbols('p', positive=True)
+    assert fraction(exp(-p)*log(p), exact=True) == (exp(-p)*log(p), 1)
+
+    m = Mul(1, 1, S.Half, evaluate=False)
+    assert fraction(m) == (1, 2)
+    assert fraction(m, exact=True) == (Mul(1, 1, evaluate=False), 2)
+
+    m = Mul(1, 1, S.Half, S.Half, Pow(1, -1, evaluate=False), evaluate=False)
+    assert fraction(m) == (1, 4)
+    assert fraction(m, exact=True) == \
+            (Mul(1, 1, evaluate=False), Mul(2, 2, 1, evaluate=False))
+
+
+def test_issue_5615():
+    aA, Re, a, b, D = symbols('aA Re a b D')
+    e = ((D**3*a + b*aA**3)/Re).expand()
+    assert collect(e, [aA**3/Re, a]) == e
+
+
+def test_issue_5933():
+    from sympy.geometry.polygon import (Polygon, RegularPolygon)
+    from sympy.simplify.radsimp import denom
+    x = Polygon(*RegularPolygon((0, 0), 1, 5).vertices).centroid.x
+    assert abs(denom(x).n()) > 1e-12
+    assert abs(denom(radsimp(x))) > 1e-12  # in case simplify didn't handle it
+
+
+def test_issue_14608():
+    a, b = symbols('a b', commutative=False)
+    x, y = symbols('x y')
+    raises(AttributeError, lambda: collect(a*b + b*a, a))
+    assert collect(x*y + y*(x+1), a) == x*y + y*(x+1)
+    assert collect(x*y + y*(x+1) + a*b + b*a, y) == y*(2*x + 1) + a*b + b*a
+
+
+def test_collect_abs():
+    s = abs(x) + abs(y)
+    assert collect_abs(s) == s
+    assert unchanged(Mul, abs(x), abs(y))
+    ans = Abs(x*y)
+    assert isinstance(ans, Abs)
+    assert collect_abs(abs(x)*abs(y)) == ans
+    assert collect_abs(1 + exp(abs(x)*abs(y))) == 1 + exp(ans)
+
+    # See https://github.com/sympy/sympy/issues/12910
+    p = Symbol('p', positive=True)
+    assert collect_abs(p/abs(1-p)).is_commutative is True
+
+
+def test_issue_19149():
+    eq = exp(3*x/4)
+    assert collect(eq, exp(x)) == eq
+
+def test_issue_19719():
+    a, b = symbols('a, b')
+    expr = a**2 * (b + 1) + (7 + 1/b)/a
+    collected = collect(expr, (a**2, 1/a), evaluate=False)
+    # Would return {_Dummy_20**(-2): b + 1, 1/a: 7 + 1/b} without xreplace
+    assert collected == {a**2: b + 1, 1/a: 7 + 1/b}
+
+
+def test_issue_21355():
+    assert radsimp(1/(x + sqrt(x**2))) == 1/(x + sqrt(x**2))
+    assert radsimp(1/(x - sqrt(x**2))) == 1/(x - sqrt(x**2))
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/tests/test_ratsimp.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/tests/test_ratsimp.py
new file mode 100644
index 0000000000000000000000000000000000000000..14e84fd2b227518baff1bda4e5b27ecc40a8bcdd
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/tests/test_ratsimp.py
@@ -0,0 +1,78 @@
+from sympy.core.numbers import (Rational, pi)
+from sympy.functions.elementary.exponential import log
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.special.error_functions import erf
+from sympy.polys.domains import GF
+from sympy.simplify.ratsimp import (ratsimp, ratsimpmodprime)
+
+from sympy.abc import x, y, z, t, a, b, c, d, e
+
+
+def test_ratsimp():
+    f, g = 1/x + 1/y, (x + y)/(x*y)
+
+    assert f != g and ratsimp(f) == g
+
+    f, g = 1/(1 + 1/x), 1 - 1/(x + 1)
+
+    assert f != g and ratsimp(f) == g
+
+    f, g = x/(x + y) + y/(x + y), 1
+
+    assert f != g and ratsimp(f) == g
+
+    f, g = -x - y - y**2/(x + y) + x**2/(x + y), -2*y
+
+    assert f != g and ratsimp(f) == g
+
+    f = (a*c*x*y + a*c*z - b*d*x*y - b*d*z - b*t*x*y - b*t*x - b*t*z +
+         e*x)/(x*y + z)
+    G = [a*c - b*d - b*t + (-b*t*x + e*x)/(x*y + z),
+         a*c - b*d - b*t - ( b*t*x - e*x)/(x*y + z)]
+
+    assert f != g and ratsimp(f) in G
+
+    A = sqrt(pi)
+
+    B = log(erf(x) - 1)
+    C = log(erf(x) + 1)
+
+    D = 8 - 8*erf(x)
+
+    f = A*B/D - A*C/D + A*C*erf(x)/D - A*B*erf(x)/D + 2*A/D
+
+    assert ratsimp(f) == A*B/8 - A*C/8 - A/(4*erf(x) - 4)
+
+
+def test_ratsimpmodprime():
+    a = y**5 + x + y
+    b = x - y
+    F = [x*y**5 - x - y]
+    assert ratsimpmodprime(a/b, F, x, y, order='lex') == \
+        (-x**2 - x*y - x - y) / (-x**2 + x*y)
+
+    a = x + y**2 - 2
+    b = x + y**2 - y - 1
+    F = [x*y - 1]
+    assert ratsimpmodprime(a/b, F, x, y, order='lex') == \
+        (1 + y - x)/(y - x)
+
+    a = 5*x**3 + 21*x**2 + 4*x*y + 23*x + 12*y + 15
+    b = 7*x**3 - y*x**2 + 31*x**2 + 2*x*y + 15*y + 37*x + 21
+    F = [x**2 + y**2 - 1]
+    assert ratsimpmodprime(a/b, F, x, y, order='lex') == \
+        (1 + 5*y - 5*x)/(8*y - 6*x)
+
+    a = x*y - x - 2*y + 4
+    b = x + y**2 - 2*y
+    F = [x - 2, y - 3]
+    assert ratsimpmodprime(a/b, F, x, y, order='lex') == \
+        Rational(2, 5)
+
+    # Test a bug where denominators would be dropped
+    assert ratsimpmodprime(x, [y - 2*x], order='lex') == \
+        y/2
+
+    a = (x**5 + 2*x**4 + 2*x**3 + 2*x**2 + x + 2/x + x**(-2))
+    assert ratsimpmodprime(a, [x + 1], domain=GF(2)) == 1
+    assert ratsimpmodprime(a, [x + 1], domain=GF(3)) == -1
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/tests/test_rewrite.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/tests/test_rewrite.py
new file mode 100644
index 0000000000000000000000000000000000000000..56d2fb7a85bd959bd4accc2f36127429efbdbe70
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/tests/test_rewrite.py
@@ -0,0 +1,31 @@
+from sympy.core.numbers import I
+from sympy.core.symbol import symbols
+from sympy.functions.elementary.exponential import exp
+from sympy.functions.elementary.trigonometric import (cos, cot, sin)
+from sympy.testing.pytest import _both_exp_pow
+
+x, y, z, n = symbols('x,y,z,n')
+
+
+@_both_exp_pow
+def test_has():
+    assert cot(x).has(x)
+    assert cot(x).has(cot)
+    assert not cot(x).has(sin)
+    assert sin(x).has(x)
+    assert sin(x).has(sin)
+    assert not sin(x).has(cot)
+    assert exp(x).has(exp)
+
+
+@_both_exp_pow
+def test_sin_exp_rewrite():
+    assert sin(x).rewrite(sin, exp) == -I/2*(exp(I*x) - exp(-I*x))
+    assert sin(x).rewrite(sin, exp).rewrite(exp, sin) == sin(x)
+    assert cos(x).rewrite(cos, exp).rewrite(exp, cos) == cos(x)
+    assert (sin(5*y) - sin(
+        2*x)).rewrite(sin, exp).rewrite(exp, sin) == sin(5*y) - sin(2*x)
+    assert sin(x + y).rewrite(sin, exp).rewrite(exp, sin) == sin(x + y)
+    assert cos(x + y).rewrite(cos, exp).rewrite(exp, cos) == cos(x + y)
+    # This next test currently passes... not clear whether it should or not?
+    assert cos(x).rewrite(cos, exp).rewrite(exp, sin) == cos(x)
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/tests/test_simplify.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/tests/test_simplify.py
new file mode 100644
index 0000000000000000000000000000000000000000..a5bf469f68adf5c5dfbdf7559414681e2fb28ba7
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/tests/test_simplify.py
@@ -0,0 +1,1093 @@
+from sympy.concrete.summations import Sum
+from sympy.core.add import Add
+from sympy.core.basic import Basic
+from sympy.core.expr import unchanged
+from sympy.core.function import (count_ops, diff, expand, expand_multinomial, Function, Derivative)
+from sympy.core.mul import Mul, _keep_coeff
+from sympy.core import GoldenRatio
+from sympy.core.numbers import (E, Float, I, oo, pi, Rational, zoo)
+from sympy.core.relational import (Eq, Lt, Gt, Ge, Le)
+from sympy.core.singleton import S
+from sympy.core.symbol import (Symbol, symbols)
+from sympy.core.sympify import sympify
+from sympy.functions.combinatorial.factorials import (binomial, factorial)
+from sympy.functions.elementary.complexes import (Abs, sign)
+from sympy.functions.elementary.exponential import (exp, exp_polar, log)
+from sympy.functions.elementary.hyperbolic import (cosh, csch, sinh)
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.piecewise import Piecewise
+from sympy.functions.elementary.trigonometric import (acos, asin, atan, cos, sin, sinc, tan)
+from sympy.functions.special.error_functions import erf
+from sympy.functions.special.gamma_functions import gamma
+from sympy.functions.special.hyper import hyper
+from sympy.functions.special.tensor_functions import KroneckerDelta
+from sympy.geometry.polygon import rad
+from sympy.integrals.integrals import (Integral, integrate)
+from sympy.logic.boolalg import (And, Or)
+from sympy.matrices.dense import (Matrix, eye)
+from sympy.matrices.expressions.matexpr import MatrixSymbol
+from sympy.polys.polytools import (factor, Poly)
+from sympy.simplify.simplify import (besselsimp, hypersimp, inversecombine, logcombine, nsimplify, nthroot, posify, separatevars, signsimp, simplify)
+from sympy.solvers.solvers import solve
+
+from sympy.testing.pytest import XFAIL, slow, _both_exp_pow
+from sympy.abc import x, y, z, t, a, b, c, d, e, f, g, h, i, n
+
+
+def test_issue_7263():
+    assert abs((simplify(30.8**2 - 82.5**2 * sin(rad(11.6))**2)).evalf() - \
+            673.447451402970) < 1e-12
+
+
+def test_factorial_simplify():
+    # There are more tests in test_factorials.py.
+    x = Symbol('x')
+    assert simplify(factorial(x)/x) == gamma(x)
+    assert simplify(factorial(factorial(x))) == factorial(factorial(x))
+
+
+def test_simplify_expr():
+    x, y, z, k, n, m, w, s, A = symbols('x,y,z,k,n,m,w,s,A')
+    f = Function('f')
+
+    assert all(simplify(tmp) == tmp for tmp in [I, E, oo, x, -x, -oo, -E, -I])
+
+    e = 1/x + 1/y
+    assert e != (x + y)/(x*y)
+    assert simplify(e) == (x + y)/(x*y)
+
+    e = A**2*s**4/(4*pi*k*m**3)
+    assert simplify(e) == e
+
+    e = (4 + 4*x - 2*(2 + 2*x))/(2 + 2*x)
+    assert simplify(e) == 0
+
+    e = (-4*x*y**2 - 2*y**3 - 2*x**2*y)/(x + y)**2
+    assert simplify(e) == -2*y
+
+    e = -x - y - (x + y)**(-1)*y**2 + (x + y)**(-1)*x**2
+    assert simplify(e) == -2*y
+
+    e = (x + x*y)/x
+    assert simplify(e) == 1 + y
+
+    e = (f(x) + y*f(x))/f(x)
+    assert simplify(e) == 1 + y
+
+    e = (2 * (1/n - cos(n * pi)/n))/pi
+    assert simplify(e) == (-cos(pi*n) + 1)/(pi*n)*2
+
+    e = integrate(1/(x**3 + 1), x).diff(x)
+    assert simplify(e) == 1/(x**3 + 1)
+
+    e = integrate(x/(x**2 + 3*x + 1), x).diff(x)
+    assert simplify(e) == x/(x**2 + 3*x + 1)
+
+    f = Symbol('f')
+    A = Matrix([[2*k - m*w**2, -k], [-k, k - m*w**2]]).inv()
+    assert simplify((A*Matrix([0, f]))[1] -
+            (-f*(2*k - m*w**2)/(k**2 - (k - m*w**2)*(2*k - m*w**2)))) == 0
+
+    f = -x + y/(z + t) + z*x/(z + t) + z*a/(z + t) + t*x/(z + t)
+    assert simplify(f) == (y + a*z)/(z + t)
+
+    # issue 10347
+    expr = -x*(y**2 - 1)*(2*y**2*(x**2 - 1)/(a*(x**2 - y**2)**2) + (x**2 - 1)
+        /(a*(x**2 - y**2)))/(a*(x**2 - y**2)) + x*(-2*x**2*sqrt(-x**2*y**2 + x**2
+        + y**2 - 1)*sin(z)/(a*(x**2 - y**2)**2) - x**2*sqrt(-x**2*y**2 + x**2 +
+        y**2 - 1)*sin(z)/(a*(x**2 - 1)*(x**2 - y**2)) + (x**2*sqrt((-x**2 + 1)*
+        (y**2 - 1))*sqrt(-x**2*y**2 + x**2 + y**2 - 1)*sin(z)/(x**2 - 1) + sqrt(
+        (-x**2 + 1)*(y**2 - 1))*(x*(-x*y**2 + x)/sqrt(-x**2*y**2 + x**2 + y**2 -
+        1) + sqrt(-x**2*y**2 + x**2 + y**2 - 1))*sin(z))/(a*sqrt((-x**2 + 1)*(
+        y**2 - 1))*(x**2 - y**2)))*sqrt(-x**2*y**2 + x**2 + y**2 - 1)*sin(z)/(a*
+        (x**2 - y**2)) + x*(-2*x**2*sqrt(-x**2*y**2 + x**2 + y**2 - 1)*cos(z)/(a*
+        (x**2 - y**2)**2) - x**2*sqrt(-x**2*y**2 + x**2 + y**2 - 1)*cos(z)/(a*
+        (x**2 - 1)*(x**2 - y**2)) + (x**2*sqrt((-x**2 + 1)*(y**2 - 1))*sqrt(-x**2
+        *y**2 + x**2 + y**2 - 1)*cos(z)/(x**2 - 1) + x*sqrt((-x**2 + 1)*(y**2 -
+        1))*(-x*y**2 + x)*cos(z)/sqrt(-x**2*y**2 + x**2 + y**2 - 1) + sqrt((-x**2
+        + 1)*(y**2 - 1))*sqrt(-x**2*y**2 + x**2 + y**2 - 1)*cos(z))/(a*sqrt((-x**2
+        + 1)*(y**2 - 1))*(x**2 - y**2)))*sqrt(-x**2*y**2 + x**2 + y**2 - 1)*cos(
+        z)/(a*(x**2 - y**2)) - y*sqrt((-x**2 + 1)*(y**2 - 1))*(-x*y*sqrt(-x**2*
+        y**2 + x**2 + y**2 - 1)*sin(z)/(a*(x**2 - y**2)*(y**2 - 1)) + 2*x*y*sqrt(
+        -x**2*y**2 + x**2 + y**2 - 1)*sin(z)/(a*(x**2 - y**2)**2) + (x*y*sqrt((
+        -x**2 + 1)*(y**2 - 1))*sqrt(-x**2*y**2 + x**2 + y**2 - 1)*sin(z)/(y**2 -
+        1) + x*sqrt((-x**2 + 1)*(y**2 - 1))*(-x**2*y + y)*sin(z)/sqrt(-x**2*y**2
+        + x**2 + y**2 - 1))/(a*sqrt((-x**2 + 1)*(y**2 - 1))*(x**2 - y**2)))*sin(
+        z)/(a*(x**2 - y**2)) + y*(x**2 - 1)*(-2*x*y*(x**2 - 1)/(a*(x**2 - y**2)
+        **2) + 2*x*y/(a*(x**2 - y**2)))/(a*(x**2 - y**2)) + y*(x**2 - 1)*(y**2 -
+        1)*(-x*y*sqrt(-x**2*y**2 + x**2 + y**2 - 1)*cos(z)/(a*(x**2 - y**2)*(y**2
+        - 1)) + 2*x*y*sqrt(-x**2*y**2 + x**2 + y**2 - 1)*cos(z)/(a*(x**2 - y**2)
+        **2) + (x*y*sqrt((-x**2 + 1)*(y**2 - 1))*sqrt(-x**2*y**2 + x**2 + y**2 -
+        1)*cos(z)/(y**2 - 1) + x*sqrt((-x**2 + 1)*(y**2 - 1))*(-x**2*y + y)*cos(
+        z)/sqrt(-x**2*y**2 + x**2 + y**2 - 1))/(a*sqrt((-x**2 + 1)*(y**2 - 1)
+        )*(x**2 - y**2)))*cos(z)/(a*sqrt((-x**2 + 1)*(y**2 - 1))*(x**2 - y**2)
+        ) - x*sqrt((-x**2 + 1)*(y**2 - 1))*sqrt(-x**2*y**2 + x**2 + y**2 - 1)*sin(
+        z)**2/(a**2*(x**2 - 1)*(x**2 - y**2)*(y**2 - 1)) - x*sqrt((-x**2 + 1)*(
+        y**2 - 1))*sqrt(-x**2*y**2 + x**2 + y**2 - 1)*cos(z)**2/(a**2*(x**2 - 1)*(
+        x**2 - y**2)*(y**2 - 1))
+    assert simplify(expr) == 2*x/(a**2*(x**2 - y**2))
+
+    #issue 17631
+    assert simplify('((-1/2)*Boole(True)*Boole(False)-1)*Boole(True)') == \
+            Mul(sympify('(2 + Boole(True)*Boole(False))'), sympify('-Boole(True)/2'))
+
+    A, B = symbols('A,B', commutative=False)
+
+    assert simplify(A*B - B*A) == A*B - B*A
+    assert simplify(A/(1 + y/x)) == x*A/(x + y)
+    assert simplify(A*(1/x + 1/y)) == A/x + A/y  #(x + y)*A/(x*y)
+
+    assert simplify(log(2) + log(3)) == log(6)
+    assert simplify(log(2*x) - log(2)) == log(x)
+
+    assert simplify(hyper([], [], x)) == exp(x)
+
+
+def test_issue_3557():
+    f_1 = x*a + y*b + z*c - 1
+    f_2 = x*d + y*e + z*f - 1
+    f_3 = x*g + y*h + z*i - 1
+
+    solutions = solve([f_1, f_2, f_3], x, y, z, simplify=False)
+
+    assert simplify(solutions[y]) == \
+        (a*i + c*d + f*g - a*f - c*g - d*i)/ \
+        (a*e*i + b*f*g + c*d*h - a*f*h - b*d*i - c*e*g)
+
+
+def test_simplify_other():
+    assert simplify(sin(x)**2 + cos(x)**2) == 1
+    assert simplify(gamma(x + 1)/gamma(x)) == x
+    assert simplify(sin(x)**2 + cos(x)**2 + factorial(x)/gamma(x)) == 1 + x
+    assert simplify(
+        Eq(sin(x)**2 + cos(x)**2, factorial(x)/gamma(x))) == Eq(x, 1)
+    nc = symbols('nc', commutative=False)
+    assert simplify(x + x*nc) == x*(1 + nc)
+    # issue 6123
+    # f = exp(-I*(k*sqrt(t) + x/(2*sqrt(t)))**2)
+    # ans = integrate(f, (k, -oo, oo), conds='none')
+    ans = I*(-pi*x*exp(I*pi*Rational(-3, 4) + I*x**2/(4*t))*erf(x*exp(I*pi*Rational(-3, 4))/
+        (2*sqrt(t)))/(2*sqrt(t)) + pi*x*exp(I*pi*Rational(-3, 4) + I*x**2/(4*t))/
+        (2*sqrt(t)))*exp(-I*x**2/(4*t))/(sqrt(pi)*x) - I*sqrt(pi) * \
+        (-erf(x*exp(I*pi/4)/(2*sqrt(t))) + 1)*exp(I*pi/4)/(2*sqrt(t))
+    assert simplify(ans) == -(-1)**Rational(3, 4)*sqrt(pi)/sqrt(t)
+    # issue 6370
+    assert simplify(2**(2 + x)/4) == 2**x
+
+
+@_both_exp_pow
+def test_simplify_complex():
+    cosAsExp = cos(x)._eval_rewrite_as_exp(x)
+    tanAsExp = tan(x)._eval_rewrite_as_exp(x)
+    assert simplify(cosAsExp*tanAsExp) == sin(x) # issue 4341
+
+    # issue 10124
+    assert simplify(exp(Matrix([[0, -1], [1, 0]]))) == Matrix([[cos(1),
+        -sin(1)], [sin(1), cos(1)]])
+
+
+def test_simplify_ratio():
+    # roots of x**3-3*x+5
+    roots = ['(1/2 - sqrt(3)*I/2)*(sqrt(21)/2 + 5/2)**(1/3) + 1/((1/2 - '
+             'sqrt(3)*I/2)*(sqrt(21)/2 + 5/2)**(1/3))',
+             '1/((1/2 + sqrt(3)*I/2)*(sqrt(21)/2 + 5/2)**(1/3)) + '
+             '(1/2 + sqrt(3)*I/2)*(sqrt(21)/2 + 5/2)**(1/3)',
+             '-(sqrt(21)/2 + 5/2)**(1/3) - 1/(sqrt(21)/2 + 5/2)**(1/3)']
+
+    for r in roots:
+        r = S(r)
+        assert count_ops(simplify(r, ratio=1)) <= count_ops(r)
+        # If ratio=oo, simplify() is always applied:
+        assert simplify(r, ratio=oo) is not r
+
+
+def test_simplify_measure():
+    measure1 = lambda expr: len(str(expr))
+    measure2 = lambda expr: -count_ops(expr)
+                                       # Return the most complicated result
+    expr = (x + 1)/(x + sin(x)**2 + cos(x)**2)
+    assert measure1(simplify(expr, measure=measure1)) <= measure1(expr)
+    assert measure2(simplify(expr, measure=measure2)) <= measure2(expr)
+
+    expr2 = Eq(sin(x)**2 + cos(x)**2, 1)
+    assert measure1(simplify(expr2, measure=measure1)) <= measure1(expr2)
+    assert measure2(simplify(expr2, measure=measure2)) <= measure2(expr2)
+
+
+def test_simplify_rational():
+    expr = 2**x*2.**y
+    assert simplify(expr, rational = True) == 2**(x+y)
+    assert simplify(expr, rational = None) == 2.0**(x+y)
+    assert simplify(expr, rational = False) == expr
+    assert simplify('0.9 - 0.8 - 0.1', rational = True) == 0
+
+
+def test_simplify_issue_1308():
+    assert simplify(exp(Rational(-1, 2)) + exp(Rational(-3, 2))) == \
+        (1 + E)*exp(Rational(-3, 2))
+
+
+def test_issue_5652():
+    assert simplify(E + exp(-E)) == exp(-E) + E
+    n = symbols('n', commutative=False)
+    assert simplify(n + n**(-n)) == n + n**(-n)
+
+def test_issue_27380():
+    assert simplify(1.0**(x+1)/1.0**x) == 1.0
+
+def test_simplify_fail1():
+    x = Symbol('x')
+    y = Symbol('y')
+    e = (x + y)**2/(-4*x*y**2 - 2*y**3 - 2*x**2*y)
+    assert simplify(e) == 1 / (-2*y)
+
+
+def test_nthroot():
+    assert nthroot(90 + 34*sqrt(7), 3) == sqrt(7) + 3
+    q = 1 + sqrt(2) - 2*sqrt(3) + sqrt(6) + sqrt(7)
+    assert nthroot(expand_multinomial(q**3), 3) == q
+    assert nthroot(41 + 29*sqrt(2), 5) == 1 + sqrt(2)
+    assert nthroot(-41 - 29*sqrt(2), 5) == -1 - sqrt(2)
+    expr = 1320*sqrt(10) + 4216 + 2576*sqrt(6) + 1640*sqrt(15)
+    assert nthroot(expr, 5) == 1 + sqrt(6) + sqrt(15)
+    q = 1 + sqrt(2) + sqrt(3) + sqrt(5)
+    assert expand_multinomial(nthroot(expand_multinomial(q**5), 5)) == q
+    q = 1 + sqrt(2) + 7*sqrt(6) + 2*sqrt(10)
+    assert nthroot(expand_multinomial(q**5), 5, 8) == q
+    q = 1 + sqrt(2) - 2*sqrt(3) + 1171*sqrt(6)
+    assert nthroot(expand_multinomial(q**3), 3) == q
+    assert nthroot(expand_multinomial(q**6), 6) == q
+
+
+def test_nthroot1():
+    q = 1 + sqrt(2) + sqrt(3) + S.One/10**20
+    p = expand_multinomial(q**5)
+    assert nthroot(p, 5) == q
+    q = 1 + sqrt(2) + sqrt(3) + S.One/10**30
+    p = expand_multinomial(q**5)
+    assert nthroot(p, 5) == q
+
+
+@_both_exp_pow
+def test_separatevars():
+    x, y, z, n = symbols('x,y,z,n')
+    assert separatevars(2*n*x*z + 2*x*y*z) == 2*x*z*(n + y)
+    assert separatevars(x*z + x*y*z) == x*z*(1 + y)
+    assert separatevars(pi*x*z + pi*x*y*z) == pi*x*z*(1 + y)
+    assert separatevars(x*y**2*sin(x) + x*sin(x)*sin(y)) == \
+        x*(sin(y) + y**2)*sin(x)
+    assert separatevars(x*exp(x + y) + x*exp(x)) == x*(1 + exp(y))*exp(x)
+    assert separatevars((x*(y + 1))**z).is_Pow  # != x**z*(1 + y)**z
+    assert separatevars(1 + x + y + x*y) == (x + 1)*(y + 1)
+    assert separatevars(y/pi*exp(-(z - x)/cos(n))) == \
+        y*exp(x/cos(n))*exp(-z/cos(n))/pi
+    assert separatevars((x + y)*(x - y) + y**2 + 2*x + 1) == (x + 1)**2
+    # issue 4858
+    p = Symbol('p', positive=True)
+    assert separatevars(sqrt(p**2 + x*p**2)) == p*sqrt(1 + x)
+    assert separatevars(sqrt(y*(p**2 + x*p**2))) == p*sqrt(y*(1 + x))
+    assert separatevars(sqrt(y*(p**2 + x*p**2)), force=True) == \
+        p*sqrt(y)*sqrt(1 + x)
+    # issue 4865
+    assert separatevars(sqrt(x*y)).is_Pow
+    assert separatevars(sqrt(x*y), force=True) == sqrt(x)*sqrt(y)
+    # issue 4957
+    # any type sequence for symbols is fine
+    assert separatevars(((2*x + 2)*y), dict=True, symbols=()) == \
+        {'coeff': 1, x: 2*x + 2, y: y}
+    # separable
+    assert separatevars(((2*x + 2)*y), dict=True, symbols=[x]) == \
+        {'coeff': y, x: 2*x + 2}
+    assert separatevars(((2*x + 2)*y), dict=True, symbols=[]) == \
+        {'coeff': 1, x: 2*x + 2, y: y}
+    assert separatevars(((2*x + 2)*y), dict=True) == \
+        {'coeff': 1, x: 2*x + 2, y: y}
+    assert separatevars(((2*x + 2)*y), dict=True, symbols=None) == \
+        {'coeff': y*(2*x + 2)}
+    # not separable
+    assert separatevars(3, dict=True) is None
+    assert separatevars(2*x + y, dict=True, symbols=()) is None
+    assert separatevars(2*x + y, dict=True) is None
+    assert separatevars(2*x + y, dict=True, symbols=None) == {'coeff': 2*x + y}
+    # issue 4808
+    n, m = symbols('n,m', commutative=False)
+    assert separatevars(m + n*m) == (1 + n)*m
+    assert separatevars(x + x*n) == x*(1 + n)
+    # issue 4910
+    f = Function('f')
+    assert separatevars(f(x) + x*f(x)) == f(x) + x*f(x)
+    # a noncommutable object present
+    eq = x*(1 + hyper((), (), y*z))
+    assert separatevars(eq) == eq
+
+    s = separatevars(abs(x*y))
+    assert s == abs(x)*abs(y) and s.is_Mul
+    z = cos(1)**2 + sin(1)**2 - 1
+    a = abs(x*z)
+    s = separatevars(a)
+    assert not a.is_Mul and s.is_Mul and s == abs(x)*abs(z)
+    s = separatevars(abs(x*y*z))
+    assert s == abs(x)*abs(y)*abs(z)
+
+    # abs(x+y)/abs(z) would be better but we test this here to
+    # see that it doesn't raise
+    assert separatevars(abs((x+y)/z)) == abs((x+y)/z)
+
+
+def test_separatevars_advanced_factor():
+    x, y, z = symbols('x,y,z')
+    assert separatevars(1 + log(x)*log(y) + log(x) + log(y)) == \
+        (log(x) + 1)*(log(y) + 1)
+    assert separatevars(1 + x - log(z) - x*log(z) - exp(y)*log(z) -
+        x*exp(y)*log(z) + x*exp(y) + exp(y)) == \
+        -((x + 1)*(log(z) - 1)*(exp(y) + 1))
+    x, y = symbols('x,y', positive=True)
+    assert separatevars(1 + log(x**log(y)) + log(x*y)) == \
+        (log(x) + 1)*(log(y) + 1)
+
+
+def test_hypersimp():
+    n, k = symbols('n,k', integer=True)
+
+    assert hypersimp(factorial(k), k) == k + 1
+    assert hypersimp(factorial(k**2), k) is None
+
+    assert hypersimp(1/factorial(k), k) == 1/(k + 1)
+
+    assert hypersimp(2**k/factorial(k)**2, k) == 2/(k + 1)**2
+
+    assert hypersimp(binomial(n, k), k) == (n - k)/(k + 1)
+    assert hypersimp(binomial(n + 1, k), k) == (n - k + 1)/(k + 1)
+
+    term = (4*k + 1)*factorial(k)/factorial(2*k + 1)
+    assert hypersimp(term, k) == S.Half*((4*k + 5)/(3 + 14*k + 8*k**2))
+
+    term = 1/((2*k - 1)*factorial(2*k + 1))
+    assert hypersimp(term, k) == (k - S.Half)/((k + 1)*(2*k + 1)*(2*k + 3))
+
+    term = binomial(n, k)*(-1)**k/factorial(k)
+    assert hypersimp(term, k) == (k - n)/(k + 1)**2
+
+
+def test_nsimplify():
+    x = Symbol("x")
+    assert nsimplify(0) == 0
+    assert nsimplify(-1) == -1
+    assert nsimplify(1) == 1
+    assert nsimplify(1 + x) == 1 + x
+    assert nsimplify(2.7) == Rational(27, 10)
+    assert nsimplify(1 - GoldenRatio) == (1 - sqrt(5))/2
+    assert nsimplify((1 + sqrt(5))/4, [GoldenRatio]) == GoldenRatio/2
+    assert nsimplify(2/GoldenRatio, [GoldenRatio]) == 2*GoldenRatio - 2
+    assert nsimplify(exp(pi*I*Rational(5, 3), evaluate=False)) == \
+        sympify('1/2 - sqrt(3)*I/2')
+    assert nsimplify(sin(pi*Rational(3, 5), evaluate=False)) == \
+        sympify('sqrt(sqrt(5)/8 + 5/8)')
+    assert nsimplify(sqrt(atan('1', evaluate=False))*(2 + I), [pi]) == \
+        sqrt(pi) + sqrt(pi)/2*I
+    assert nsimplify(2 + exp(2*atan('1/4')*I)) == sympify('49/17 + 8*I/17')
+    assert nsimplify(pi, tolerance=0.01) == Rational(22, 7)
+    assert nsimplify(pi, tolerance=0.001) == Rational(355, 113)
+    assert nsimplify(0.33333, tolerance=1e-4) == Rational(1, 3)
+    assert nsimplify(2.0**(1/3.), tolerance=0.001) == Rational(635, 504)
+    assert nsimplify(2.0**(1/3.), tolerance=0.001, full=True) == \
+        2**Rational(1, 3)
+    assert nsimplify(x + .5, rational=True) == S.Half + x
+    assert nsimplify(1/.3 + x, rational=True) == Rational(10, 3) + x
+    assert nsimplify(log(3).n(), rational=True) == \
+        sympify('109861228866811/100000000000000')
+    assert nsimplify(Float(0.272198261287950), [pi, log(2)]) == pi*log(2)/8
+    assert nsimplify(Float(0.272198261287950).n(3), [pi, log(2)]) == \
+        -pi/4 - log(2) + Rational(7, 4)
+    assert nsimplify(x/7.0) == x/7
+    assert nsimplify(pi/1e2) == pi/100
+    assert nsimplify(pi/1e2, rational=False) == pi/100.0
+    assert nsimplify(pi/1e-7) == 10000000*pi
+    assert not nsimplify(
+        factor(-3.0*z**2*(z**2)**(-2.5) + 3*(z**2)**(-1.5))).atoms(Float)
+    e = x**0.0
+    assert e.is_Pow and nsimplify(x**0.0) == 1
+    assert nsimplify(3.333333, tolerance=0.1, rational=True) == Rational(10, 3)
+    assert nsimplify(3.333333, tolerance=0.01, rational=True) == Rational(10, 3)
+    assert nsimplify(3.666666, tolerance=0.1, rational=True) == Rational(11, 3)
+    assert nsimplify(3.666666, tolerance=0.01, rational=True) == Rational(11, 3)
+    assert nsimplify(33, tolerance=10, rational=True) == Rational(33)
+    assert nsimplify(33.33, tolerance=10, rational=True) == Rational(30)
+    assert nsimplify(37.76, tolerance=10, rational=True) == Rational(40)
+    assert nsimplify(-203.1) == Rational(-2031, 10)
+    assert nsimplify(.2, tolerance=0) == Rational(1, 5)
+    assert nsimplify(-.2, tolerance=0) == Rational(-1, 5)
+    assert nsimplify(.2222, tolerance=0) == Rational(1111, 5000)
+    assert nsimplify(-.2222, tolerance=0) == Rational(-1111, 5000)
+    # issue 7211, PR 4112
+    assert nsimplify(S(2e-8)) == Rational(1, 50000000)
+    # issue 7322 direct test
+    assert nsimplify(1e-42, rational=True) != 0
+    # issue 10336
+    inf = Float('inf')
+    infs = (-oo, oo, inf, -inf)
+    for zi in infs:
+        ans = sign(zi)*oo
+        assert nsimplify(zi) == ans
+        assert nsimplify(zi + x) == x + ans
+
+    assert nsimplify(0.33333333, rational=True, rational_conversion='exact') == Rational(0.33333333)
+
+    # Make sure nsimplify on expressions uses full precision
+    assert nsimplify(pi.evalf(100)*x, rational_conversion='exact').evalf(100) == pi.evalf(100)*x
+
+
+def test_issue_9448():
+    tmp = sympify("1/(1 - (-1)**(2/3) - (-1)**(1/3)) + 1/(1 + (-1)**(2/3) + (-1)**(1/3))")
+    assert nsimplify(tmp) == S.Half
+
+
+def test_extract_minus_sign():
+    x = Symbol("x")
+    y = Symbol("y")
+    a = Symbol("a")
+    b = Symbol("b")
+    assert simplify(-x/-y) == x/y
+    assert simplify(-x/y) == -x/y
+    assert simplify(x/y) == x/y
+    assert simplify(x/-y) == -x/y
+    assert simplify(-x/0) == zoo*x
+    assert simplify(Rational(-5, 0)) is zoo
+    assert simplify(-a*x/(-y - b)) == a*x/(b + y)
+
+
+def test_diff():
+    x = Symbol("x")
+    y = Symbol("y")
+    f = Function("f")
+    g = Function("g")
+    assert simplify(g(x).diff(x)*f(x).diff(x) - f(x).diff(x)*g(x).diff(x)) == 0
+    assert simplify(2*f(x)*f(x).diff(x) - diff(f(x)**2, x)) == 0
+    assert simplify(diff(1/f(x), x) + f(x).diff(x)/f(x)**2) == 0
+    assert simplify(f(x).diff(x, y) - f(x).diff(y, x)) == 0
+
+
+def test_logcombine_1():
+    x, y = symbols("x,y")
+    a = Symbol("a")
+    z, w = symbols("z,w", positive=True)
+    b = Symbol("b", real=True)
+    assert logcombine(log(x) + 2*log(y)) == log(x) + 2*log(y)
+    assert logcombine(log(x) + 2*log(y), force=True) == log(x*y**2)
+    assert logcombine(a*log(w) + log(z)) == a*log(w) + log(z)
+    assert logcombine(b*log(z) + b*log(x)) == log(z**b) + b*log(x)
+    assert logcombine(b*log(z) - log(w)) == log(z**b/w)
+    assert logcombine(log(x)*log(z)) == log(x)*log(z)
+    assert logcombine(log(w)*log(x)) == log(w)*log(x)
+    assert logcombine(cos(-2*log(z) + b*log(w))) in [cos(log(w**b/z**2)),
+                                                   cos(log(z**2/w**b))]
+    assert logcombine(log(log(x) - log(y)) - log(z), force=True) == \
+        log(log(x/y)/z)
+    assert logcombine((2 + I)*log(x), force=True) == (2 + I)*log(x)
+    assert logcombine((x**2 + log(x) - log(y))/(x*y), force=True) == \
+        (x**2 + log(x/y))/(x*y)
+    # the following could also give log(z*x**log(y**2)), what we
+    # are testing is that a canonical result is obtained
+    assert logcombine(log(x)*2*log(y) + log(z), force=True) == \
+        log(z*y**log(x**2))
+    assert logcombine((x*y + sqrt(x**4 + y**4) + log(x) - log(y))/(pi*x**Rational(2, 3)*
+            sqrt(y)**3), force=True) == (
+            x*y + sqrt(x**4 + y**4) + log(x/y))/(pi*x**Rational(2, 3)*y**Rational(3, 2))
+    assert logcombine(gamma(-log(x/y))*acos(-log(x/y)), force=True) == \
+        acos(-log(x/y))*gamma(-log(x/y))
+
+    assert logcombine(2*log(z)*log(w)*log(x) + log(z) + log(w)) == \
+        log(z**log(w**2))*log(x) + log(w*z)
+    assert logcombine(3*log(w) + 3*log(z)) == log(w**3*z**3)
+    assert logcombine(x*(y + 1) + log(2) + log(3)) == x*(y + 1) + log(6)
+    assert logcombine((x + y)*log(w) + (-x - y)*log(3)) == (x + y)*log(w/3)
+    # a single unknown can combine
+    assert logcombine(log(x) + log(2)) == log(2*x)
+    eq = log(abs(x)) + log(abs(y))
+    assert logcombine(eq) == eq
+    reps = {x: 0, y: 0}
+    assert log(abs(x)*abs(y)).subs(reps) != eq.subs(reps)
+
+
+def test_logcombine_complex_coeff():
+    i = Integral((sin(x**2) + cos(x**3))/x, x)
+    assert logcombine(i, force=True) == i
+    assert logcombine(i + 2*log(x), force=True) == \
+        i + log(x**2)
+
+
+def test_issue_5950():
+    x, y = symbols("x,y", positive=True)
+    assert logcombine(log(3) - log(2)) == log(Rational(3,2), evaluate=False)
+    assert logcombine(log(x) - log(y)) == log(x/y)
+    assert logcombine(log(Rational(3,2), evaluate=False) - log(2)) == \
+        log(Rational(3,4), evaluate=False)
+
+
+def test_posify():
+    x = symbols('x')
+
+    assert str(posify(
+        x +
+        Symbol('p', positive=True) +
+        Symbol('n', negative=True))) == '(_x + n + p, {_x: x})'
+
+    eq, rep = posify(1/x)
+    assert log(eq).expand().subs(rep) == -log(x)
+    assert str(posify([x, 1 + x])) == '([_x, _x + 1], {_x: x})'
+
+    p = symbols('p', positive=True)
+    n = symbols('n', negative=True)
+    orig = [x, n, p]
+    modified, reps = posify(orig)
+    assert str(modified) == '[_x, n, p]'
+    assert [w.subs(reps) for w in modified] == orig
+
+    assert str(Integral(posify(1/x + y)[0], (y, 1, 3)).expand()) == \
+        'Integral(1/_x, (y, 1, 3)) + Integral(_y, (y, 1, 3))'
+    assert str(Sum(posify(1/x**n)[0], (n,1,3)).expand()) == \
+        'Sum(_x**(-n), (n, 1, 3))'
+
+    A = Matrix([[1, 2, 3], [4, 5, 6 * Abs(x)]])
+    Ap, rep = posify(A)
+    assert Ap == A.subs(*reversed(rep.popitem()))
+
+    # issue 16438
+    k = Symbol('k', finite=True)
+    eq, rep = posify(k)
+    assert eq.assumptions0 == {'positive': True, 'zero': False, 'imaginary': False,
+     'nonpositive': False, 'commutative': True, 'hermitian': True, 'real': True, 'nonzero': True,
+     'nonnegative': True, 'negative': False, 'complex': True, 'finite': True,
+     'infinite': False, 'extended_real':True, 'extended_negative': False,
+     'extended_nonnegative': True, 'extended_nonpositive': False,
+     'extended_nonzero': True, 'extended_positive': True}
+
+
+def test_issue_4194():
+    # simplify should call cancel
+    f = Function('f')
+    assert simplify((4*x + 6*f(y))/(2*x + 3*f(y))) == 2
+
+
+@XFAIL
+def test_simplify_float_vs_integer():
+    # Test for issue 4473:
+    # https://github.com/sympy/sympy/issues/4473
+    assert simplify(x**2.0 - x**2) == 0
+    assert simplify(x**2 - x**2.0) == 0
+
+
+def test_as_content_primitive():
+    assert (x/2 + y).as_content_primitive() == (S.Half, x + 2*y)
+    assert (x/2 + y).as_content_primitive(clear=False) == (S.One, x/2 + y)
+    assert (y*(x/2 + y)).as_content_primitive() == (S.Half, y*(x + 2*y))
+    assert (y*(x/2 + y)).as_content_primitive(clear=False) == (S.One, y*(x/2 + y))
+
+    # although the _as_content_primitive methods do not alter the underlying structure,
+    # the as_content_primitive function will touch up the expression and join
+    # bases that would otherwise have not been joined.
+    assert (x*(2 + 2*x)*(3*x + 3)**2).as_content_primitive() == \
+        (18, x*(x + 1)**3)
+    assert (2 + 2*x + 2*y*(3 + 3*y)).as_content_primitive() == \
+        (2, x + 3*y*(y + 1) + 1)
+    assert ((2 + 6*x)**2).as_content_primitive() == \
+        (4, (3*x + 1)**2)
+    assert ((2 + 6*x)**(2*y)).as_content_primitive() == \
+        (1, (_keep_coeff(S(2), (3*x + 1)))**(2*y))
+    assert (5 + 10*x + 2*y*(3 + 3*y)).as_content_primitive() == \
+        (1, 10*x + 6*y*(y + 1) + 5)
+    assert (5*(x*(1 + y)) + 2*x*(3 + 3*y)).as_content_primitive() == \
+        (11, x*(y + 1))
+    assert ((5*(x*(1 + y)) + 2*x*(3 + 3*y))**2).as_content_primitive() == \
+        (121, x**2*(y + 1)**2)
+    assert (y**2).as_content_primitive() == \
+        (1, y**2)
+    assert (S.Infinity).as_content_primitive() == (1, oo)
+    eq = x**(2 + y)
+    assert (eq).as_content_primitive() == (1, eq)
+    assert (S.Half**(2 + x)).as_content_primitive() == (Rational(1, 4), 2**-x)
+    assert (Rational(-1, 2)**(2 + x)).as_content_primitive() == \
+           (Rational(1, 4), (Rational(-1, 2))**x)
+    assert (Rational(-1, 2)**(2 + x)).as_content_primitive() == \
+           (Rational(1, 4), Rational(-1, 2)**x)
+    assert (4**((1 + y)/2)).as_content_primitive() == (2, 4**(y/2))
+    assert (3**((1 + y)/2)).as_content_primitive() == \
+           (1, 3**(Mul(S.Half, 1 + y, evaluate=False)))
+    assert (5**Rational(3, 4)).as_content_primitive() == (1, 5**Rational(3, 4))
+    assert (5**Rational(7, 4)).as_content_primitive() == (5, 5**Rational(3, 4))
+    assert Add(z*Rational(5, 7), 0.5*x, y*Rational(3, 2), evaluate=False).as_content_primitive() == \
+              (Rational(1, 14), 7.0*x + 21*y + 10*z)
+    assert (2**Rational(3, 4) + 2**Rational(1, 4)*sqrt(3)).as_content_primitive(radical=True) == \
+           (1, 2**Rational(1, 4)*(sqrt(2) + sqrt(3)))
+
+
+def test_signsimp():
+    e = x*(-x + 1) + x*(x - 1)
+    assert signsimp(Eq(e, 0)) is S.true
+    assert Abs(x - 1) == Abs(1 - x)
+    assert signsimp(y - x) == y - x
+    assert signsimp(y - x, evaluate=False) == Mul(-1, x - y, evaluate=False)
+
+
+def test_besselsimp():
+    from sympy.functions.special.bessel import (besseli, besselj, bessely)
+    from sympy.integrals.transforms import cosine_transform
+    assert besselsimp(exp(-I*pi*y/2)*besseli(y, z*exp_polar(I*pi/2))) == \
+        besselj(y, z)
+    assert besselsimp(exp(-I*pi*a/2)*besseli(a, 2*sqrt(x)*exp_polar(I*pi/2))) == \
+        besselj(a, 2*sqrt(x))
+    assert besselsimp(sqrt(2)*sqrt(pi)*x**Rational(1, 4)*exp(I*pi/4)*exp(-I*pi*a/2) *
+                      besseli(Rational(-1, 2), sqrt(x)*exp_polar(I*pi/2)) *
+                      besseli(a, sqrt(x)*exp_polar(I*pi/2))/2) == \
+        besselj(a, sqrt(x)) * cos(sqrt(x))
+    assert besselsimp(besseli(Rational(-1, 2), z)) == \
+        sqrt(2)*cosh(z)/(sqrt(pi)*sqrt(z))
+    assert besselsimp(besseli(a, z*exp_polar(-I*pi/2))) == \
+        exp(-I*pi*a/2)*besselj(a, z)
+    assert cosine_transform(1/t*sin(a/t), t, y) == \
+        sqrt(2)*sqrt(pi)*besselj(0, 2*sqrt(a)*sqrt(y))/2
+
+    assert besselsimp(x**2*(a*(-2*besselj(5*I, x) + besselj(-2 + 5*I, x) +
+    besselj(2 + 5*I, x)) + b*(-2*bessely(5*I, x) + bessely(-2 + 5*I, x) +
+    bessely(2 + 5*I, x)))/4 + x*(a*(besselj(-1 + 5*I, x)/2 - besselj(1 + 5*I, x)/2)
+    + b*(bessely(-1 + 5*I, x)/2 - bessely(1 + 5*I, x)/2)) + (x**2 + 25)*(a*besselj(5*I, x)
+    + b*bessely(5*I, x))) == 0
+
+    assert besselsimp(81*x**2*(a*(besselj(Rational(-5, 3), 9*x) - 2*besselj(Rational(1, 3), 9*x) + besselj(Rational(7, 3), 9*x))
+    + b*(bessely(Rational(-5, 3), 9*x) - 2*bessely(Rational(1, 3), 9*x) + bessely(Rational(7, 3), 9*x)))/4 + x*(a*(9*besselj(Rational(-2, 3), 9*x)/2
+    - 9*besselj(Rational(4, 3), 9*x)/2) + b*(9*bessely(Rational(-2, 3), 9*x)/2 - 9*bessely(Rational(4, 3), 9*x)/2)) +
+    (81*x**2 - Rational(1, 9))*(a*besselj(Rational(1, 3), 9*x) + b*bessely(Rational(1, 3), 9*x))) == 0
+
+    assert besselsimp(besselj(a-1,x) + besselj(a+1, x) - 2*a*besselj(a, x)/x) == 0
+
+    assert besselsimp(besselj(a-1,x) + besselj(a+1, x) + besselj(a, x)) == (2*a + x)*besselj(a, x)/x
+
+    assert besselsimp(x**2* besselj(a,x) + x**3*besselj(a+1, x) + besselj(a+2, x)) == \
+    2*a*x*besselj(a + 1, x) + x**3*besselj(a + 1, x) - x**2*besselj(a + 2, x) + 2*x*besselj(a + 1, x) + besselj(a + 2, x)
+
+def test_Piecewise():
+    e1 = x*(x + y) - y*(x + y)
+    e2 = sin(x)**2 + cos(x)**2
+    e3 = expand((x + y)*y/x)
+    s1 = simplify(e1)
+    s2 = simplify(e2)
+    s3 = simplify(e3)
+    assert simplify(Piecewise((e1, x < e2), (e3, True))) == \
+        Piecewise((s1, x < s2), (s3, True))
+
+
+def test_polymorphism():
+    class A(Basic):
+        def _eval_simplify(x, **kwargs):
+            return S.One
+
+    a = A(S(5), S(2))
+    assert simplify(a) == 1
+
+
+def test_issue_from_PR1599():
+    n1, n2, n3, n4 = symbols('n1 n2 n3 n4', negative=True)
+    assert simplify(I*sqrt(n1)) == -sqrt(-n1)
+
+
+def test_issue_6811():
+    eq = (x + 2*y)*(2*x + 2)
+    assert simplify(eq) == (x + 1)*(x + 2*y)*2
+    # reject the 2-arg Mul -- these are a headache for test writing
+    assert simplify(eq.expand()) == \
+        2*x**2 + 4*x*y + 2*x + 4*y
+
+
+def test_issue_6920():
+    e = [cos(x) + I*sin(x), cos(x) - I*sin(x),
+        cosh(x) - sinh(x), cosh(x) + sinh(x)]
+    ok = [exp(I*x), exp(-I*x), exp(-x), exp(x)]
+    # wrap in f to show that the change happens wherever ei occurs
+    f = Function('f')
+    assert [simplify(f(ei)).args[0] for ei in e] == ok
+
+
+def test_issue_7001():
+    from sympy.abc import r, R
+    assert simplify(-(r*Piecewise((pi*Rational(4, 3), r <= R),
+        (-8*pi*R**3/(3*r**3), True)) + 2*Piecewise((pi*r*Rational(4, 3), r <= R),
+        (4*pi*R**3/(3*r**2), True)))/(4*pi*r)) == \
+        Piecewise((-1, r <= R), (0, True))
+
+
+def test_inequality_no_auto_simplify():
+    # no simplify on creation but can be simplified
+    lhs = cos(x)**2 + sin(x)**2
+    rhs = 2
+    e = Lt(lhs, rhs, evaluate=False)
+    assert e is not S.true
+    assert simplify(e)
+
+
+def test_issue_9398():
+    from sympy.core.numbers import Number
+    from sympy.polys.polytools import cancel
+    assert cancel(1e-14) != 0
+    assert cancel(1e-14*I) != 0
+
+    assert simplify(1e-14) != 0
+    assert simplify(1e-14*I) != 0
+
+    assert (I*Number(1.)*Number(10)**Number(-14)).simplify() != 0
+
+    assert cancel(1e-20) != 0
+    assert cancel(1e-20*I) != 0
+
+    assert simplify(1e-20) != 0
+    assert simplify(1e-20*I) != 0
+
+    assert cancel(1e-100) != 0
+    assert cancel(1e-100*I) != 0
+
+    assert simplify(1e-100) != 0
+    assert simplify(1e-100*I) != 0
+
+    f = Float("1e-1000")
+    assert cancel(f) != 0
+    assert cancel(f*I) != 0
+
+    assert simplify(f) != 0
+    assert simplify(f*I) != 0
+
+
+def test_issue_9324_simplify():
+    M = MatrixSymbol('M', 10, 10)
+    e = M[0, 0] + M[5, 4] + 1304
+    assert simplify(e) == e
+
+
+def test_issue_9817_simplify():
+    # simplify on trace of substituted explicit quadratic form of matrix
+    # expressions (a scalar) should return without errors (AttributeError)
+    # See issue #9817 and #9190 for the original bug more discussion on this
+    from sympy.matrices.expressions import Identity, trace
+    v = MatrixSymbol('v', 3, 1)
+    A = MatrixSymbol('A', 3, 3)
+    x = Matrix([i + 1 for i in range(3)])
+    X = Identity(3)
+    quadratic = v.T * A * v
+    assert simplify((trace(quadratic.as_explicit())).xreplace({v:x, A:X})) == 14
+
+
+def test_issue_13474():
+    x = Symbol('x')
+    assert simplify(x + csch(sinc(1))) == x + csch(sinc(1))
+
+
+@_both_exp_pow
+def test_simplify_function_inverse():
+    # "inverse" attribute does not guarantee that f(g(x)) is x
+    # so this simplification should not happen automatically.
+    # See issue #12140
+    x, y = symbols('x, y')
+    g = Function('g')
+
+    class f(Function):
+        def inverse(self, argindex=1):
+            return g
+
+    assert simplify(f(g(x))) == f(g(x))
+    assert inversecombine(f(g(x))) == x
+    assert simplify(f(g(x)), inverse=True) == x
+    assert simplify(f(g(sin(x)**2 + cos(x)**2)), inverse=True) == 1
+    assert simplify(f(g(x, y)), inverse=True) == f(g(x, y))
+    assert unchanged(asin, sin(x))
+    assert simplify(asin(sin(x))) == asin(sin(x))
+    assert simplify(2*asin(sin(3*x)), inverse=True) == 6*x
+    assert simplify(log(exp(x))) == log(exp(x))
+    assert simplify(log(exp(x)), inverse=True) == x
+    assert simplify(exp(log(x)), inverse=True) == x
+    assert simplify(log(exp(x), 2), inverse=True) == x/log(2)
+    assert simplify(log(exp(x), 2, evaluate=False), inverse=True) == x/log(2)
+
+
+def test_clear_coefficients():
+    from sympy.simplify.simplify import clear_coefficients
+    assert clear_coefficients(4*y*(6*x + 3)) == (y*(2*x + 1), 0)
+    assert clear_coefficients(4*y*(6*x + 3) - 2) == (y*(2*x + 1), Rational(1, 6))
+    assert clear_coefficients(4*y*(6*x + 3) - 2, x) == (y*(2*x + 1), x/12 + Rational(1, 6))
+    assert clear_coefficients(sqrt(2) - 2) == (sqrt(2), 2)
+    assert clear_coefficients(4*sqrt(2) - 2) == (sqrt(2), S.Half)
+    assert clear_coefficients(S(3), x) == (0, x - 3)
+    assert clear_coefficients(S.Infinity, x) == (S.Infinity, x)
+    assert clear_coefficients(-S.Pi, x) == (S.Pi, -x)
+    assert clear_coefficients(2 - S.Pi/3, x) == (pi, -3*x + 6)
+
+def test_nc_simplify():
+    from sympy.simplify.simplify import nc_simplify
+    from sympy.matrices.expressions import MatPow, Identity
+    from sympy.core import Pow
+    from functools import reduce
+
+    a, b, c, d = symbols('a b c d', commutative = False)
+    x = Symbol('x')
+    A = MatrixSymbol("A", x, x)
+    B = MatrixSymbol("B", x, x)
+    C = MatrixSymbol("C", x, x)
+    D = MatrixSymbol("D", x, x)
+    subst = {a: A, b: B, c: C, d:D}
+    funcs = {Add: lambda x,y: x+y, Mul: lambda x,y: x*y }
+
+    def _to_matrix(expr):
+        if expr in subst:
+            return subst[expr]
+        if isinstance(expr, Pow):
+            return MatPow(_to_matrix(expr.args[0]), expr.args[1])
+        elif isinstance(expr, (Add, Mul)):
+            return reduce(funcs[expr.func],[_to_matrix(a) for a in expr.args])
+        else:
+            return expr*Identity(x)
+
+    def _check(expr, simplified, deep=True, matrix=True):
+        assert nc_simplify(expr, deep=deep) == simplified
+        assert expand(expr) == expand(simplified)
+        if matrix:
+            m_simp = _to_matrix(simplified).doit(inv_expand=False)
+            assert nc_simplify(_to_matrix(expr), deep=deep) == m_simp
+
+    _check(a*b*a*b*a*b*c*(a*b)**3*c, ((a*b)**3*c)**2)
+    _check(a*b*(a*b)**-2*a*b, 1)
+    _check(a**2*b*a*b*a*b*(a*b)**-1, a*(a*b)**2, matrix=False)
+    _check(b*a*b**2*a*b**2*a*b**2, b*(a*b**2)**3)
+    _check(a*b*a**2*b*a**2*b*a**3, (a*b*a)**3*a**2)
+    _check(a**2*b*a**4*b*a**4*b*a**2, (a**2*b*a**2)**3)
+    _check(a**3*b*a**4*b*a**4*b*a, a**3*(b*a**4)**3*a**-3)
+    _check(a*b*a*b + a*b*c*x*a*b*c, (a*b)**2 + x*(a*b*c)**2)
+    _check(a*b*a*b*c*a*b*a*b*c, ((a*b)**2*c)**2)
+    _check(b**-1*a**-1*(a*b)**2, a*b)
+    _check(a**-1*b*c**-1, (c*b**-1*a)**-1)
+    expr = a**3*b*a**4*b*a**4*b*a**2*b*a**2*(b*a**2)**2*b*a**2*b*a**2
+    for _ in range(10):
+        expr *= a*b
+    _check(expr, a**3*(b*a**4)**2*(b*a**2)**6*(a*b)**10)
+    _check((a*b*a*b)**2, (a*b*a*b)**2, deep=False)
+    _check(a*b*(c*d)**2, a*b*(c*d)**2)
+    expr = b**-1*(a**-1*b**-1 - a**-1*c*b**-1)**-1*a**-1
+    assert nc_simplify(expr) == (1-c)**-1
+    # commutative expressions should be returned without an error
+    assert nc_simplify(2*x**2) == 2*x**2
+
+def test_issue_15965():
+    A = Sum(z*x**y, (x, 1, a))
+    anew = z*Sum(x**y, (x, 1, a))
+    B = Integral(x*y, x)
+    bdo = x**2*y/2
+    assert simplify(A + B) == anew + bdo
+    assert simplify(A) == anew
+    assert simplify(B) == bdo
+    assert simplify(B, doit=False) == y*Integral(x, x)
+
+
+def test_issue_17137():
+    assert simplify(cos(x)**I) == cos(x)**I
+    assert simplify(cos(x)**(2 + 3*I)) == cos(x)**(2 + 3*I)
+
+
+def test_issue_21869():
+    x = Symbol('x', real=True)
+    y = Symbol('y', real=True)
+    expr = And(Eq(x**2, 4), Le(x, y))
+    assert expr.simplify() == expr
+
+    expr = And(Eq(x**2, 4), Eq(x, 2))
+    assert expr.simplify() == Eq(x, 2)
+
+    expr = And(Eq(x**3, x**2), Eq(x, 1))
+    assert expr.simplify() == Eq(x, 1)
+
+    expr = And(Eq(sin(x), x**2), Eq(x, 0))
+    assert expr.simplify() == Eq(x, 0)
+
+    expr = And(Eq(x**3, x**2), Eq(x, 2))
+    assert expr.simplify() == S.false
+
+    expr = And(Eq(y, x**2), Eq(x, 1))
+    assert expr.simplify() == And(Eq(y,1), Eq(x, 1))
+
+    expr = And(Eq(y**2, 1), Eq(y, x**2), Eq(x, 1))
+    assert expr.simplify() == And(Eq(y,1), Eq(x, 1))
+
+    expr = And(Eq(y**2, 4), Eq(y, 2*x**2), Eq(x, 1))
+    assert expr.simplify() == And(Eq(y,2), Eq(x, 1))
+
+    expr = And(Eq(y**2, 4), Eq(y, x**2), Eq(x, 1))
+    assert expr.simplify() == S.false
+
+
+def test_issue_7971_21740():
+    z = Integral(x, (x, 1, 1))
+    assert z != 0
+    assert simplify(z) is S.Zero
+    assert simplify(S.Zero) is S.Zero
+    z = simplify(Float(0))
+    assert z is not S.Zero and z == 0.0
+
+
+@slow
+def test_issue_17141_slow():
+    # Should not give RecursionError
+    assert simplify((2**acos(I+1)**2).rewrite('log')) == 2**((pi + 2*I*log(-1 +
+                   sqrt(1 - 2*I) + I))**2/4)
+
+
+def test_issue_17141():
+    # Check that there is no RecursionError
+    assert simplify(x**(1 / acos(I))) == x**(2/(pi - 2*I*log(1 + sqrt(2))))
+    assert simplify(acos(-I)**2*acos(I)**2) == \
+           log(1 + sqrt(2))**4 + pi**2*log(1 + sqrt(2))**2/2 + pi**4/16
+    assert simplify(2**acos(I)**2) == 2**((pi - 2*I*log(1 + sqrt(2)))**2/4)
+    p = 2**acos(I+1)**2
+    assert simplify(p) == p
+
+
+def test_simplify_kroneckerdelta():
+    i, j = symbols("i j")
+    K = KroneckerDelta
+
+    assert simplify(K(i, j)) == K(i, j)
+    assert simplify(K(0, j)) == K(0, j)
+    assert simplify(K(i, 0)) == K(i, 0)
+
+    assert simplify(K(0, j).rewrite(Piecewise) * K(1, j)) == 0
+    assert simplify(K(1, i) + Piecewise((1, Eq(j, 2)), (0, True))) == K(1, i) + K(2, j)
+
+    # issue 17214
+    assert simplify(K(0, j) * K(1, j)) == 0
+
+    n = Symbol('n', integer=True)
+    assert simplify(K(0, n) * K(1, n)) == 0
+
+    M = Matrix(4, 4, lambda i, j: K(j - i, n) if i <= j else 0)
+    assert simplify(M**2) == Matrix([[K(0, n), 0, K(1, n), 0],
+                                     [0, K(0, n), 0, K(1, n)],
+                                     [0, 0, K(0, n), 0],
+                                     [0, 0, 0, K(0, n)]])
+    assert simplify(eye(1) * KroneckerDelta(0, n) *
+                    KroneckerDelta(1, n)) == Matrix([[0]])
+
+    assert simplify(S.Infinity * KroneckerDelta(0, n) *
+                    KroneckerDelta(1, n)) is S.NaN
+
+
+def test_issue_17292():
+    assert simplify(abs(x)/abs(x**2)) == 1/abs(x)
+    # this is bigger than the issue: check that deep processing works
+    assert simplify(5*abs((x**2 - 1)/(x - 1))) == 5*Abs(x + 1)
+
+
+def test_issue_19822():
+    expr = And(Gt(n-2, 1), Gt(n, 1))
+    assert simplify(expr) == Gt(n, 3)
+
+
+def test_issue_18645():
+    expr = And(Ge(x, 3), Le(x, 3))
+    assert simplify(expr) == Eq(x, 3)
+    expr = And(Eq(x, 3), Le(x, 3))
+    assert simplify(expr) == Eq(x, 3)
+
+
+@XFAIL
+def test_issue_18642():
+    i = Symbol("i", integer=True)
+    n = Symbol("n", integer=True)
+    expr = And(Eq(i, 2 * n), Le(i, 2*n -1))
+    assert simplify(expr) == S.false
+
+
+@XFAIL
+def test_issue_18389():
+    n = Symbol("n", integer=True)
+    expr = Eq(n, 0) | (n >= 1)
+    assert simplify(expr) == Ge(n, 0)
+
+
+def test_issue_8373():
+    x = Symbol('x', real=True)
+    assert simplify(Or(x < 1, x >= 1)) == S.true
+
+
+def test_issue_7950():
+    expr = And(Eq(x, 1), Eq(x, 2))
+    assert simplify(expr) == S.false
+
+
+def test_issue_22020():
+    expr = I*pi/2 -oo
+    assert simplify(expr) == expr
+    # Used to throw an error
+
+
+def test_issue_19484():
+    assert simplify(sign(x) * Abs(x)) == x
+
+    e = x + sign(x + x**3)
+    assert simplify(Abs(x + x**3)*e) == x**3 + x*Abs(x**3 + x) + x
+
+    e = x**2 + sign(x**3 + 1)
+    assert simplify(Abs(x**3 + 1) * e) == x**3 + x**2*Abs(x**3 + 1) + 1
+
+    f = Function('f')
+    e = x + sign(x + f(x)**3)
+    assert simplify(Abs(x + f(x)**3) * e) == x*Abs(x + f(x)**3) + x + f(x)**3
+
+
+def test_issue_23543():
+    # Used to give an error
+    x, y, z = symbols("x y z", commutative=False)
+    assert (x*(y + z/2)).simplify() == x*(2*y + z)/2
+
+
+def test_issue_11004():
+
+    def f(n):
+        return sqrt(2*pi*n) * (n/E)**n
+
+    def m(n, k):
+        return  f(n) / (f(n/k)**k)
+
+    def p(n,k):
+        return m(n, k) / (k**n)
+
+    N, k = symbols('N k')
+    half = Float('0.5', 4)
+    z = log(p(n, k) / p(n, k + 1)).expand(force=True)
+    r = simplify(z.subs(n, N).n(4))
+    assert r == (
+        half*k*log(k)
+        - half*k*log(k + 1)
+        + half*log(N)
+        - half*log(k + 1)
+        + Float(0.9189224, 4)
+    )
+
+
+def test_issue_19161():
+    polynomial = Poly('x**2').simplify()
+    assert (polynomial-x**2).simplify() == 0
+
+
+def test_issue_22210():
+    d = Symbol('d', integer=True)
+    expr = 2*Derivative(sin(x), (x, d))
+    assert expr.simplify() == expr
+
+
+def test_reduce_inverses_nc_pow():
+    x, y = symbols("x y", commutative=True)
+    Z = symbols("Z", commutative=False)
+    assert simplify(2**Z * y**Z) == 2**Z * y**Z
+    assert simplify(x**Z * y**Z) == x**Z * y**Z
+    x, y = symbols("x y", positive=True)
+    assert expand((x*y)**Z) == x**Z * y**Z
+    assert simplify(x**Z * y**Z) == expand((x*y)**Z)
+
+def test_nc_recursion_coeff():
+    X = symbols("X", commutative = False)
+    assert (2 * cos(pi/3) * X).simplify() == X
+    assert (2.0 * cos(pi/3) * X).simplify() == X
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/tests/test_sqrtdenest.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/tests/test_sqrtdenest.py
new file mode 100644
index 0000000000000000000000000000000000000000..41c771bb2055a1199d349ae3649f33927d79313a
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/tests/test_sqrtdenest.py
@@ -0,0 +1,204 @@
+from sympy.core.mul import Mul
+from sympy.core.numbers import (I, Integer, Rational)
+from sympy.core.symbol import Symbol
+from sympy.functions.elementary.miscellaneous import (root, sqrt)
+from sympy.functions.elementary.trigonometric import cos
+from sympy.integrals.integrals import Integral
+from sympy.simplify.sqrtdenest import sqrtdenest
+from sympy.simplify.sqrtdenest import (
+    _subsets as subsets, _sqrt_numeric_denest)
+
+r2, r3, r5, r6, r7, r10, r15, r29 = [sqrt(x) for x in (2, 3, 5, 6, 7, 10,
+                                          15, 29)]
+
+
+def test_sqrtdenest():
+    d = {sqrt(5 + 2 * r6): r2 + r3,
+        sqrt(5. + 2 * r6): sqrt(5. + 2 * r6),
+        sqrt(5. + 4*sqrt(5 + 2 * r6)): sqrt(5.0 + 4*r2 + 4*r3),
+        sqrt(r2): sqrt(r2),
+        sqrt(5 + r7): sqrt(5 + r7),
+        sqrt(3 + sqrt(5 + 2*r7)):
+         3*r2*(5 + 2*r7)**Rational(1, 4)/(2*sqrt(6 + 3*r7)) +
+         r2*sqrt(6 + 3*r7)/(2*(5 + 2*r7)**Rational(1, 4)),
+        sqrt(3 + 2*r3): 3**Rational(3, 4)*(r6/2 + 3*r2/2)/3}
+    for i in d:
+        assert sqrtdenest(i) == d[i], i
+
+
+def test_sqrtdenest2():
+    assert sqrtdenest(sqrt(16 - 2*r29 + 2*sqrt(55 - 10*r29))) == \
+        r5 + sqrt(11 - 2*r29)
+    e = sqrt(-r5 + sqrt(-2*r29 + 2*sqrt(-10*r29 + 55) + 16))
+    assert sqrtdenest(e) == root(-2*r29 + 11, 4)
+    r = sqrt(1 + r7)
+    assert sqrtdenest(sqrt(1 + r)) == sqrt(1 + r)
+    e = sqrt(((1 + sqrt(1 + 2*sqrt(3 + r2 + r5)))**2).expand())
+    assert sqrtdenest(e) == 1 + sqrt(1 + 2*sqrt(r2 + r5 + 3))
+
+    assert sqrtdenest(sqrt(5*r3 + 6*r2)) == \
+        sqrt(2)*root(3, 4) + root(3, 4)**3
+
+    assert sqrtdenest(sqrt(((1 + r5 + sqrt(1 + r3))**2).expand())) == \
+        1 + r5 + sqrt(1 + r3)
+
+    assert sqrtdenest(sqrt(((1 + r5 + r7 + sqrt(1 + r3))**2).expand())) == \
+        1 + sqrt(1 + r3) + r5 + r7
+
+    e = sqrt(((1 + cos(2) + cos(3) + sqrt(1 + r3))**2).expand())
+    assert sqrtdenest(e) == cos(3) + cos(2) + 1 + sqrt(1 + r3)
+
+    e = sqrt(-2*r10 + 2*r2*sqrt(-2*r10 + 11) + 14)
+    assert sqrtdenest(e) == sqrt(-2*r10 - 2*r2 + 4*r5 + 14)
+
+    # check that the result is not more complicated than the input
+    z = sqrt(-2*r29 + cos(2) + 2*sqrt(-10*r29 + 55) + 16)
+    assert sqrtdenest(z) == z
+
+    assert sqrtdenest(sqrt(r6 + sqrt(15))) == sqrt(r6 + sqrt(15))
+
+    z = sqrt(15 - 2*sqrt(31) + 2*sqrt(55 - 10*r29))
+    assert sqrtdenest(z) == z
+
+
+def test_sqrtdenest_rec():
+    assert sqrtdenest(sqrt(-4*sqrt(14) - 2*r6 + 4*sqrt(21) + 33)) == \
+        -r2 + r3 + 2*r7
+    assert sqrtdenest(sqrt(-28*r7 - 14*r5 + 4*sqrt(35) + 82)) == \
+        -7 + r5 + 2*r7
+    assert sqrtdenest(sqrt(6*r2/11 + 2*sqrt(22)/11 + 6*sqrt(11)/11 + 2)) == \
+        sqrt(11)*(r2 + 3 + sqrt(11))/11
+    assert sqrtdenest(sqrt(468*r3 + 3024*r2 + 2912*r6 + 19735)) == \
+        9*r3 + 26 + 56*r6
+    z = sqrt(-490*r3 - 98*sqrt(115) - 98*sqrt(345) - 2107)
+    assert sqrtdenest(z) == sqrt(-1)*(7*r5 + 7*r15 + 7*sqrt(23))
+    z = sqrt(-4*sqrt(14) - 2*r6 + 4*sqrt(21) + 34)
+    assert sqrtdenest(z) == z
+    assert sqrtdenest(sqrt(-8*r2 - 2*r5 + 18)) == -r10 + 1 + r2 + r5
+    assert sqrtdenest(sqrt(8*r2 + 2*r5 - 18)) == \
+        sqrt(-1)*(-r10 + 1 + r2 + r5)
+    assert sqrtdenest(sqrt(8*r2/3 + 14*r5/3 + Rational(154, 9))) == \
+        -r10/3 + r2 + r5 + 3
+    assert sqrtdenest(sqrt(sqrt(2*r6 + 5) + sqrt(2*r7 + 8))) == \
+        sqrt(1 + r2 + r3 + r7)
+    assert sqrtdenest(sqrt(4*r15 + 8*r5 + 12*r3 + 24)) == 1 + r3 + r5 + r15
+
+    w = 1 + r2 + r3 + r5 + r7
+    assert sqrtdenest(sqrt((w**2).expand())) == w
+    z = sqrt((w**2).expand() + 1)
+    assert sqrtdenest(z) == z
+
+    z = sqrt(2*r10 + 6*r2 + 4*r5 + 12 + 10*r15 + 30*r3)
+    assert sqrtdenest(z) == z
+
+
+def test_issue_6241():
+    z = sqrt( -320 + 32*sqrt(5) + 64*r15)
+    assert sqrtdenest(z) == z
+
+
+def test_sqrtdenest3():
+    z = sqrt(13 - 2*r10 + 2*r2*sqrt(-2*r10 + 11))
+    assert sqrtdenest(z) == -1 + r2 + r10
+    assert sqrtdenest(z, max_iter=1) == -1 + sqrt(2) + sqrt(10)
+    z = sqrt(sqrt(r2 + 2) + 2)
+    assert sqrtdenest(z) == z
+    assert sqrtdenest(sqrt(-2*r10 + 4*r2*sqrt(-2*r10 + 11) + 20)) == \
+        sqrt(-2*r10 - 4*r2 + 8*r5 + 20)
+    assert sqrtdenest(sqrt((112 + 70*r2) + (46 + 34*r2)*r5)) == \
+        r10 + 5 + 4*r2 + 3*r5
+    z = sqrt(5 + sqrt(2*r6 + 5)*sqrt(-2*r29 + 2*sqrt(-10*r29 + 55) + 16))
+    r = sqrt(-2*r29 + 11)
+    assert sqrtdenest(z) == sqrt(r2*r + r3*r + r10 + r15 + 5)
+
+    n = sqrt(2*r6/7 + 2*r7/7 + 2*sqrt(42)/7 + 2)
+    d = sqrt(16 - 2*r29 + 2*sqrt(55 - 10*r29))
+    assert sqrtdenest(n/d) == r7*(1 + r6 + r7)/(Mul(7, (sqrt(-2*r29 + 11) + r5),
+                                                    evaluate=False))
+
+
+def test_sqrtdenest4():
+    # see Denest_en.pdf in https://github.com/sympy/sympy/issues/3192
+    z = sqrt(8 - r2*sqrt(5 - r5) - sqrt(3)*(1 + r5))
+    z1 = sqrtdenest(z)
+    c = sqrt(-r5 + 5)
+    z1 = ((-r15*c - r3*c + c + r5*c - r6 - r2 + r10 + sqrt(30))/4).expand()
+    assert sqrtdenest(z) == z1
+
+    z = sqrt(2*r2*sqrt(r2 + 2) + 5*r2 + 4*sqrt(r2 + 2) + 8)
+    assert sqrtdenest(z) == r2 + sqrt(r2 + 2) + 2
+
+    w = 2 + r2 + r3 + (1 + r3)*sqrt(2 + r2 + 5*r3)
+    z = sqrt((w**2).expand())
+    assert sqrtdenest(z) == w.expand()
+
+
+def test_sqrt_symbolic_denest():
+    x = Symbol('x')
+    z = sqrt(((1 + sqrt(sqrt(2 + x) + 3))**2).expand())
+    assert sqrtdenest(z) == sqrt((1 + sqrt(sqrt(2 + x) + 3))**2)
+    z = sqrt(((1 + sqrt(sqrt(2 + cos(1)) + 3))**2).expand())
+    assert sqrtdenest(z) == 1 + sqrt(sqrt(2 + cos(1)) + 3)
+    z = ((1 + cos(2))**4 + 1).expand()
+    assert sqrtdenest(z) == z
+    z = sqrt(((1 + sqrt(sqrt(2 + cos(3*x)) + 3))**2 + 1).expand())
+    assert sqrtdenest(z) == z
+    c = cos(3)
+    c2 = c**2
+    assert sqrtdenest(sqrt(2*sqrt(1 + r3)*c + c2 + 1 + r3*c2)) == \
+        -1 - sqrt(1 + r3)*c
+    ra = sqrt(1 + r3)
+    z = sqrt(20*ra*sqrt(3 + 3*r3) + 12*r3*ra*sqrt(3 + 3*r3) + 64*r3 + 112)
+    assert sqrtdenest(z) == z
+
+
+def test_issue_5857():
+    from sympy.abc import x, y
+    z = sqrt(1/(4*r3 + 7) + 1)
+    ans = (r2 + r6)/(r3 + 2)
+    assert sqrtdenest(z) == ans
+    assert sqrtdenest(1 + z) == 1 + ans
+    assert sqrtdenest(Integral(z + 1, (x, 1, 2))) == \
+        Integral(1 + ans, (x, 1, 2))
+    assert sqrtdenest(x + sqrt(y)) == x + sqrt(y)
+    ans = (r2 + r6)/(r3 + 2)
+    assert sqrtdenest(z) == ans
+    assert sqrtdenest(1 + z) == 1 + ans
+    assert sqrtdenest(Integral(z + 1, (x, 1, 2))) == \
+        Integral(1 + ans, (x, 1, 2))
+    assert sqrtdenest(x + sqrt(y)) == x + sqrt(y)
+
+
+def test_subsets():
+    assert subsets(1) == [[1]]
+    assert subsets(4) == [
+        [1, 0, 0, 0], [0, 1, 0, 0], [1, 1, 0, 0], [0, 0, 1, 0], [1, 0, 1, 0],
+        [0, 1, 1, 0], [1, 1, 1, 0], [0, 0, 0, 1], [1, 0, 0, 1], [0, 1, 0, 1],
+        [1, 1, 0, 1], [0, 0, 1, 1], [1, 0, 1, 1], [0, 1, 1, 1], [1, 1, 1, 1]]
+
+
+def test_issue_5653():
+    assert sqrtdenest(
+        sqrt(2 + sqrt(2 + sqrt(2)))) == sqrt(2 + sqrt(2 + sqrt(2)))
+
+def test_issue_12420():
+    assert sqrtdenest((3 - sqrt(2)*sqrt(4 + 3*I) + 3*I)/2) == I
+    e = 3 - sqrt(2)*sqrt(4 + I) + 3*I
+    assert sqrtdenest(e) == e
+
+def test_sqrt_ratcomb():
+    assert sqrtdenest(sqrt(1 + r3) + sqrt(3 + 3*r3) - sqrt(10 + 6*r3)) == 0
+
+def test_issue_18041():
+    e = -sqrt(-2 + 2*sqrt(3)*I)
+    assert sqrtdenest(e) == -1 - sqrt(3)*I
+
+def test_issue_19914():
+    a = Integer(-8)
+    b = Integer(-1)
+    r = Integer(63)
+    d2 = a*a - b*b*r
+
+    assert _sqrt_numeric_denest(a, b, r, d2) == \
+        sqrt(14)*I/2 + 3*sqrt(2)*I/2
+    assert sqrtdenest(sqrt(-8-sqrt(63))) == sqrt(14)*I/2 + 3*sqrt(2)*I/2
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/tests/test_trigsimp.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/tests/test_trigsimp.py
new file mode 100644
index 0000000000000000000000000000000000000000..ea091ec8a6c7d654405968e3d035c2bbe02ccdf7
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/simplify/tests/test_trigsimp.py
@@ -0,0 +1,520 @@
+from itertools import product
+from sympy.core.function import (Subs, count_ops, diff, expand)
+from sympy.core.numbers import (E, I, Rational, pi)
+from sympy.core.singleton import S
+from sympy.core.symbol import (Symbol, symbols)
+from sympy.functions.elementary.exponential import (exp, log)
+from sympy.functions.elementary.hyperbolic import (cosh, coth, sinh, tanh)
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.piecewise import Piecewise
+from sympy.functions.elementary.trigonometric import (cos, cot, sin, tan)
+from sympy.functions.elementary.trigonometric import (acos, asin, atan2)
+from sympy.functions.elementary.trigonometric import (asec, acsc)
+from sympy.functions.elementary.trigonometric import (acot, atan)
+from sympy.integrals.integrals import integrate
+from sympy.matrices.dense import Matrix
+from sympy.simplify.simplify import simplify
+from sympy.simplify.trigsimp import (exptrigsimp, trigsimp)
+
+from sympy.testing.pytest import XFAIL
+
+from sympy.abc import x, y
+
+
+
+def test_trigsimp1():
+    x, y = symbols('x,y')
+
+    assert trigsimp(1 - sin(x)**2) == cos(x)**2
+    assert trigsimp(1 - cos(x)**2) == sin(x)**2
+    assert trigsimp(sin(x)**2 + cos(x)**2) == 1
+    assert trigsimp(1 + tan(x)**2) == 1/cos(x)**2
+    assert trigsimp(1/cos(x)**2 - 1) == tan(x)**2
+    assert trigsimp(1/cos(x)**2 - tan(x)**2) == 1
+    assert trigsimp(1 + cot(x)**2) == 1/sin(x)**2
+    assert trigsimp(1/sin(x)**2 - 1) == 1/tan(x)**2
+    assert trigsimp(1/sin(x)**2 - cot(x)**2) == 1
+
+    assert trigsimp(5*cos(x)**2 + 5*sin(x)**2) == 5
+    assert trigsimp(5*cos(x/2)**2 + 2*sin(x/2)**2) == 3*cos(x)/2 + Rational(7, 2)
+
+    assert trigsimp(sin(x)/cos(x)) == tan(x)
+    assert trigsimp(2*tan(x)*cos(x)) == 2*sin(x)
+    assert trigsimp(cot(x)**3*sin(x)**3) == cos(x)**3
+    assert trigsimp(y*tan(x)**2/sin(x)**2) == y/cos(x)**2
+    assert trigsimp(cot(x)/cos(x)) == 1/sin(x)
+
+    assert trigsimp(sin(x + y) + sin(x - y)) == 2*sin(x)*cos(y)
+    assert trigsimp(sin(x + y) - sin(x - y)) == 2*sin(y)*cos(x)
+    assert trigsimp(cos(x + y) + cos(x - y)) == 2*cos(x)*cos(y)
+    assert trigsimp(cos(x + y) - cos(x - y)) == -2*sin(x)*sin(y)
+    assert trigsimp(tan(x + y) - tan(x)/(1 - tan(x)*tan(y))) == \
+        sin(y)/(-sin(y)*tan(x) + cos(y))  # -tan(y)/(tan(x)*tan(y) - 1)
+
+    assert trigsimp(sinh(x + y) + sinh(x - y)) == 2*sinh(x)*cosh(y)
+    assert trigsimp(sinh(x + y) - sinh(x - y)) == 2*sinh(y)*cosh(x)
+    assert trigsimp(cosh(x + y) + cosh(x - y)) == 2*cosh(x)*cosh(y)
+    assert trigsimp(cosh(x + y) - cosh(x - y)) == 2*sinh(x)*sinh(y)
+    assert trigsimp(tanh(x + y) - tanh(x)/(1 + tanh(x)*tanh(y))) == \
+        sinh(y)/(sinh(y)*tanh(x) + cosh(y))
+
+    assert trigsimp(cos(0.12345)**2 + sin(0.12345)**2) == 1.0
+    e = 2*sin(x)**2 + 2*cos(x)**2
+    assert trigsimp(log(e)) == log(2)
+
+
+def test_trigsimp1a():
+    assert trigsimp(sin(2)**2*cos(3)*exp(2)/cos(2)**2) == tan(2)**2*cos(3)*exp(2)
+    assert trigsimp(tan(2)**2*cos(3)*exp(2)*cos(2)**2) == sin(2)**2*cos(3)*exp(2)
+    assert trigsimp(cot(2)*cos(3)*exp(2)*sin(2)) == cos(3)*exp(2)*cos(2)
+    assert trigsimp(tan(2)*cos(3)*exp(2)/sin(2)) == cos(3)*exp(2)/cos(2)
+    assert trigsimp(cot(2)*cos(3)*exp(2)/cos(2)) == cos(3)*exp(2)/sin(2)
+    assert trigsimp(cot(2)*cos(3)*exp(2)*tan(2)) == cos(3)*exp(2)
+    assert trigsimp(sinh(2)*cos(3)*exp(2)/cosh(2)) == tanh(2)*cos(3)*exp(2)
+    assert trigsimp(tanh(2)*cos(3)*exp(2)*cosh(2)) == sinh(2)*cos(3)*exp(2)
+    assert trigsimp(coth(2)*cos(3)*exp(2)*sinh(2)) == cosh(2)*cos(3)*exp(2)
+    assert trigsimp(tanh(2)*cos(3)*exp(2)/sinh(2)) == cos(3)*exp(2)/cosh(2)
+    assert trigsimp(coth(2)*cos(3)*exp(2)/cosh(2)) == cos(3)*exp(2)/sinh(2)
+    assert trigsimp(coth(2)*cos(3)*exp(2)*tanh(2)) == cos(3)*exp(2)
+
+
+def test_trigsimp2():
+    x, y = symbols('x,y')
+    assert trigsimp(cos(x)**2*sin(y)**2 + cos(x)**2*cos(y)**2 + sin(x)**2,
+            recursive=True) == 1
+    assert trigsimp(sin(x)**2*sin(y)**2 + sin(x)**2*cos(y)**2 + cos(x)**2,
+            recursive=True) == 1
+    assert trigsimp(
+        Subs(x, x, sin(y)**2 + cos(y)**2)) == Subs(x, x, 1)
+
+
+def test_issue_4373():
+    x = Symbol("x")
+    assert abs(trigsimp(2.0*sin(x)**2 + 2.0*cos(x)**2) - 2.0) < 1e-10
+
+
+def test_trigsimp3():
+    x, y = symbols('x,y')
+    assert trigsimp(sin(x)/cos(x)) == tan(x)
+    assert trigsimp(sin(x)**2/cos(x)**2) == tan(x)**2
+    assert trigsimp(sin(x)**3/cos(x)**3) == tan(x)**3
+    assert trigsimp(sin(x)**10/cos(x)**10) == tan(x)**10
+
+    assert trigsimp(cos(x)/sin(x)) == 1/tan(x)
+    assert trigsimp(cos(x)**2/sin(x)**2) == 1/tan(x)**2
+    assert trigsimp(cos(x)**10/sin(x)**10) == 1/tan(x)**10
+
+    assert trigsimp(tan(x)) == trigsimp(sin(x)/cos(x))
+
+
+def test_issue_4661():
+    a, x, y = symbols('a x y')
+    eq = -4*sin(x)**4 + 4*cos(x)**4 - 8*cos(x)**2
+    assert trigsimp(eq) == -4
+    n = sin(x)**6 + 4*sin(x)**4*cos(x)**2 + 5*sin(x)**2*cos(x)**4 + 2*cos(x)**6
+    d = -sin(x)**2 - 2*cos(x)**2
+    assert simplify(n/d) == -1
+    assert trigsimp(-2*cos(x)**2 + cos(x)**4 - sin(x)**4) == -1
+    eq = (- sin(x)**3/4)*cos(x) + (cos(x)**3/4)*sin(x) - sin(2*x)*cos(2*x)/8
+    assert trigsimp(eq) == 0
+
+
+def test_issue_4494():
+    a, b = symbols('a b')
+    eq = sin(a)**2*sin(b)**2 + cos(a)**2*cos(b)**2*tan(a)**2 + cos(a)**2
+    assert trigsimp(eq) == 1
+
+
+def test_issue_5948():
+    a, x, y = symbols('a x y')
+    assert trigsimp(diff(integrate(cos(x)/sin(x)**7, x), x)) == \
+           cos(x)/sin(x)**7
+
+
+def test_issue_4775():
+    a, x, y = symbols('a x y')
+    assert trigsimp(sin(x)*cos(y)+cos(x)*sin(y)) == sin(x + y)
+    assert trigsimp(sin(x)*cos(y)+cos(x)*sin(y)+3) == sin(x + y) + 3
+
+
+def test_issue_4280():
+    a, x, y = symbols('a x y')
+    assert trigsimp(cos(x)**2 + cos(y)**2*sin(x)**2 + sin(y)**2*sin(x)**2) == 1
+    assert trigsimp(a**2*sin(x)**2 + a**2*cos(y)**2*cos(x)**2 + a**2*cos(x)**2*sin(y)**2) == a**2
+    assert trigsimp(a**2*cos(y)**2*sin(x)**2 + a**2*sin(y)**2*sin(x)**2) == a**2*sin(x)**2
+
+
+def test_issue_3210():
+    eqs = (sin(2)*cos(3) + sin(3)*cos(2),
+        -sin(2)*sin(3) + cos(2)*cos(3),
+        sin(2)*cos(3) - sin(3)*cos(2),
+        sin(2)*sin(3) + cos(2)*cos(3),
+        sin(2)*sin(3) + cos(2)*cos(3) + cos(2),
+        sinh(2)*cosh(3) + sinh(3)*cosh(2),
+        sinh(2)*sinh(3) + cosh(2)*cosh(3),
+        )
+    assert [trigsimp(e) for e in eqs] == [
+        sin(5),
+        cos(5),
+        -sin(1),
+        cos(1),
+        cos(1) + cos(2),
+        sinh(5),
+        cosh(5),
+        ]
+
+
+def test_trigsimp_issues():
+    a, x, y = symbols('a x y')
+
+    # issue 4625 - factor_terms works, too
+    assert trigsimp(sin(x)**3 + cos(x)**2*sin(x)) == sin(x)
+
+    # issue 5948
+    assert trigsimp(diff(integrate(cos(x)/sin(x)**3, x), x)) == \
+        cos(x)/sin(x)**3
+    assert trigsimp(diff(integrate(sin(x)/cos(x)**3, x), x)) == \
+        sin(x)/cos(x)**3
+
+    # check integer exponents
+    e = sin(x)**y/cos(x)**y
+    assert trigsimp(e) == e
+    assert trigsimp(e.subs(y, 2)) == tan(x)**2
+    assert trigsimp(e.subs(x, 1)) == tan(1)**y
+
+    # check for multiple patterns
+    assert (cos(x)**2/sin(x)**2*cos(y)**2/sin(y)**2).trigsimp() == \
+        1/tan(x)**2/tan(y)**2
+    assert trigsimp(cos(x)/sin(x)*cos(x+y)/sin(x+y)) == \
+        1/(tan(x)*tan(x + y))
+
+    eq = cos(2)*(cos(3) + 1)**2/(cos(3) - 1)**2
+    assert trigsimp(eq) == eq.factor()  # factor makes denom (-1 + cos(3))**2
+    assert trigsimp(cos(2)*(cos(3) + 1)**2*(cos(3) - 1)**2) == \
+        cos(2)*sin(3)**4
+
+    # issue 6789; this generates an expression that formerly caused
+    # trigsimp to hang
+    assert cot(x).equals(tan(x)) is False
+
+    # nan or the unchanged expression is ok, but not sin(1)
+    z = cos(x)**2 + sin(x)**2 - 1
+    z1 = tan(x)**2 - 1/cot(x)**2
+    n = (1 + z1/z)
+    assert trigsimp(sin(n)) != sin(1)
+    eq = x*(n - 1) - x*n
+    assert trigsimp(eq) is S.NaN
+    assert trigsimp(eq, recursive=True) is S.NaN
+    assert trigsimp(1).is_Integer
+
+    assert trigsimp(-sin(x)**4 - 2*sin(x)**2*cos(x)**2 - cos(x)**4) == -1
+
+
+def test_trigsimp_issue_2515():
+    x = Symbol('x')
+    assert trigsimp(x*cos(x)*tan(x)) == x*sin(x)
+    assert trigsimp(-sin(x) + cos(x)*tan(x)) == 0
+
+
+def test_trigsimp_issue_3826():
+    assert trigsimp(tan(2*x).expand(trig=True)) == tan(2*x)
+
+
+def test_trigsimp_issue_4032():
+    n = Symbol('n', integer=True, positive=True)
+    assert trigsimp(2**(n/2)*cos(pi*n/4)/2 + 2**(n - 1)/2) == \
+        2**(n/2)*cos(pi*n/4)/2 + 2**n/4
+
+
+def test_trigsimp_issue_7761():
+    assert trigsimp(cosh(pi/4)) == cosh(pi/4)
+
+
+def test_trigsimp_noncommutative():
+    x, y = symbols('x,y')
+    A, B = symbols('A,B', commutative=False)
+
+    assert trigsimp(A - A*sin(x)**2) == A*cos(x)**2
+    assert trigsimp(A - A*cos(x)**2) == A*sin(x)**2
+    assert trigsimp(A*sin(x)**2 + A*cos(x)**2) == A
+    assert trigsimp(A + A*tan(x)**2) == A/cos(x)**2
+    assert trigsimp(A/cos(x)**2 - A) == A*tan(x)**2
+    assert trigsimp(A/cos(x)**2 - A*tan(x)**2) == A
+    assert trigsimp(A + A*cot(x)**2) == A/sin(x)**2
+    assert trigsimp(A/sin(x)**2 - A) == A/tan(x)**2
+    assert trigsimp(A/sin(x)**2 - A*cot(x)**2) == A
+
+    assert trigsimp(y*A*cos(x)**2 + y*A*sin(x)**2) == y*A
+
+    assert trigsimp(A*sin(x)/cos(x)) == A*tan(x)
+    assert trigsimp(A*tan(x)*cos(x)) == A*sin(x)
+    assert trigsimp(A*cot(x)**3*sin(x)**3) == A*cos(x)**3
+    assert trigsimp(y*A*tan(x)**2/sin(x)**2) == y*A/cos(x)**2
+    assert trigsimp(A*cot(x)/cos(x)) == A/sin(x)
+
+    assert trigsimp(A*sin(x + y) + A*sin(x - y)) == 2*A*sin(x)*cos(y)
+    assert trigsimp(A*sin(x + y) - A*sin(x - y)) == 2*A*sin(y)*cos(x)
+    assert trigsimp(A*cos(x + y) + A*cos(x - y)) == 2*A*cos(x)*cos(y)
+    assert trigsimp(A*cos(x + y) - A*cos(x - y)) == -2*A*sin(x)*sin(y)
+
+    assert trigsimp(A*sinh(x + y) + A*sinh(x - y)) == 2*A*sinh(x)*cosh(y)
+    assert trigsimp(A*sinh(x + y) - A*sinh(x - y)) == 2*A*sinh(y)*cosh(x)
+    assert trigsimp(A*cosh(x + y) + A*cosh(x - y)) == 2*A*cosh(x)*cosh(y)
+    assert trigsimp(A*cosh(x + y) - A*cosh(x - y)) == 2*A*sinh(x)*sinh(y)
+
+    assert trigsimp(A*cos(0.12345)**2 + A*sin(0.12345)**2) == 1.0*A
+
+
+def test_hyperbolic_simp():
+    x, y = symbols('x,y')
+
+    assert trigsimp(sinh(x)**2 + 1) == cosh(x)**2
+    assert trigsimp(cosh(x)**2 - 1) == sinh(x)**2
+    assert trigsimp(cosh(x)**2 - sinh(x)**2) == 1
+    assert trigsimp(1 - tanh(x)**2) == 1/cosh(x)**2
+    assert trigsimp(1 - 1/cosh(x)**2) == tanh(x)**2
+    assert trigsimp(tanh(x)**2 + 1/cosh(x)**2) == 1
+    assert trigsimp(coth(x)**2 - 1) == 1/sinh(x)**2
+    assert trigsimp(1/sinh(x)**2 + 1) == 1/tanh(x)**2
+    assert trigsimp(coth(x)**2 - 1/sinh(x)**2) == 1
+
+    assert trigsimp(5*cosh(x)**2 - 5*sinh(x)**2) == 5
+    assert trigsimp(5*cosh(x/2)**2 - 2*sinh(x/2)**2) == 3*cosh(x)/2 + Rational(7, 2)
+
+    assert trigsimp(sinh(x)/cosh(x)) == tanh(x)
+    assert trigsimp(tanh(x)) == trigsimp(sinh(x)/cosh(x))
+    assert trigsimp(cosh(x)/sinh(x)) == 1/tanh(x)
+    assert trigsimp(2*tanh(x)*cosh(x)) == 2*sinh(x)
+    assert trigsimp(coth(x)**3*sinh(x)**3) == cosh(x)**3
+    assert trigsimp(y*tanh(x)**2/sinh(x)**2) == y/cosh(x)**2
+    assert trigsimp(coth(x)/cosh(x)) == 1/sinh(x)
+
+    for a in (pi/6*I, pi/4*I, pi/3*I):
+        assert trigsimp(sinh(a)*cosh(x) + cosh(a)*sinh(x)) == sinh(x + a)
+        assert trigsimp(-sinh(a)*cosh(x) + cosh(a)*sinh(x)) == sinh(x - a)
+
+    e = 2*cosh(x)**2 - 2*sinh(x)**2
+    assert trigsimp(log(e)) == log(2)
+
+    # issue 19535:
+    assert trigsimp(sqrt(cosh(x)**2 - 1)) == sqrt(sinh(x)**2)
+
+    assert trigsimp(cosh(x)**2*cosh(y)**2 - cosh(x)**2*sinh(y)**2 - sinh(x)**2,
+            recursive=True) == 1
+    assert trigsimp(sinh(x)**2*sinh(y)**2 - sinh(x)**2*cosh(y)**2 + cosh(x)**2,
+            recursive=True) == 1
+
+    assert abs(trigsimp(2.0*cosh(x)**2 - 2.0*sinh(x)**2) - 2.0) < 1e-10
+
+    assert trigsimp(sinh(x)**2/cosh(x)**2) == tanh(x)**2
+    assert trigsimp(sinh(x)**3/cosh(x)**3) == tanh(x)**3
+    assert trigsimp(sinh(x)**10/cosh(x)**10) == tanh(x)**10
+    assert trigsimp(cosh(x)**3/sinh(x)**3) == 1/tanh(x)**3
+
+    assert trigsimp(cosh(x)/sinh(x)) == 1/tanh(x)
+    assert trigsimp(cosh(x)**2/sinh(x)**2) == 1/tanh(x)**2
+    assert trigsimp(cosh(x)**10/sinh(x)**10) == 1/tanh(x)**10
+
+    assert trigsimp(x*cosh(x)*tanh(x)) == x*sinh(x)
+    assert trigsimp(-sinh(x) + cosh(x)*tanh(x)) == 0
+
+    assert tan(x) != 1/cot(x)  # cot doesn't auto-simplify
+
+    assert trigsimp(tan(x) - 1/cot(x)) == 0
+    assert trigsimp(3*tanh(x)**7 - 2/coth(x)**7) == tanh(x)**7
+
+
+def test_trigsimp_groebner():
+    from sympy.simplify.trigsimp import trigsimp_groebner
+
+    c = cos(x)
+    s = sin(x)
+    ex = (4*s*c + 12*s + 5*c**3 + 21*c**2 + 23*c + 15)/(
+        -s*c**2 + 2*s*c + 15*s + 7*c**3 + 31*c**2 + 37*c + 21)
+    resnum = (5*s - 5*c + 1)
+    resdenom = (8*s - 6*c)
+    results = [resnum/resdenom, (-resnum)/(-resdenom)]
+    assert trigsimp_groebner(ex) in results
+    assert trigsimp_groebner(s/c, hints=[tan]) == tan(x)
+    assert trigsimp_groebner(c*s) == c*s
+    assert trigsimp((-s + 1)/c + c/(-s + 1),
+                    method='groebner') == 2/c
+    assert trigsimp((-s + 1)/c + c/(-s + 1),
+                    method='groebner', polynomial=True) == 2/c
+
+    # Test quick=False works
+    assert trigsimp_groebner(ex, hints=[2]) in results
+    assert trigsimp_groebner(ex, hints=[int(2)]) in results
+
+    # test "I"
+    assert trigsimp_groebner(sin(I*x)/cos(I*x), hints=[tanh]) == I*tanh(x)
+
+    # test hyperbolic / sums
+    assert trigsimp_groebner((tanh(x)+tanh(y))/(1+tanh(x)*tanh(y)),
+                             hints=[(tanh, x, y)]) == tanh(x + y)
+
+
+def test_issue_2827_trigsimp_methods():
+    measure1 = lambda expr: len(str(expr))
+    measure2 = lambda expr: -count_ops(expr)
+                                       # Return the most complicated result
+    expr = (x + 1)/(x + sin(x)**2 + cos(x)**2)
+    ans = Matrix([1])
+    M = Matrix([expr])
+    assert trigsimp(M, method='fu', measure=measure1) == ans
+    assert trigsimp(M, method='fu', measure=measure2) != ans
+    # all methods should work with Basic expressions even if they
+    # aren't Expr
+    M = Matrix.eye(1)
+    assert all(trigsimp(M, method=m) == M for m in
+        'fu matching groebner old'.split())
+    # watch for E in exptrigsimp, not only exp()
+    eq = 1/sqrt(E) + E
+    assert exptrigsimp(eq) == eq
+
+def test_issue_15129_trigsimp_methods():
+    t1 = Matrix([sin(Rational(1, 50)), cos(Rational(1, 50)), 0])
+    t2 = Matrix([sin(Rational(1, 25)), cos(Rational(1, 25)), 0])
+    t3 = Matrix([cos(Rational(1, 25)), sin(Rational(1, 25)), 0])
+    r1 = t1.dot(t2)
+    r2 = t1.dot(t3)
+    assert trigsimp(r1) == cos(Rational(1, 50))
+    assert trigsimp(r2) == sin(Rational(3, 50))
+
+def test_exptrigsimp():
+    def valid(a, b):
+        from sympy.core.random import verify_numerically as tn
+        if not (tn(a, b) and a == b):
+            return False
+        return True
+
+    assert exptrigsimp(exp(x) + exp(-x)) == 2*cosh(x)
+    assert exptrigsimp(exp(x) - exp(-x)) == 2*sinh(x)
+    assert exptrigsimp((2*exp(x)-2*exp(-x))/(exp(x)+exp(-x))) == 2*tanh(x)
+    assert exptrigsimp((2*exp(2*x)-2)/(exp(2*x)+1)) == 2*tanh(x)
+    e = [cos(x) + I*sin(x), cos(x) - I*sin(x),
+         cosh(x) - sinh(x), cosh(x) + sinh(x)]
+    ok = [exp(I*x), exp(-I*x), exp(-x), exp(x)]
+    assert all(valid(i, j) for i, j in zip(
+        [exptrigsimp(ei) for ei in e], ok))
+
+    ue = [cos(x) + sin(x), cos(x) - sin(x),
+          cosh(x) + I*sinh(x), cosh(x) - I*sinh(x)]
+    assert [exptrigsimp(ei) == ei for ei in ue]
+
+    res = []
+    ok = [y*tanh(1), 1/(y*tanh(1)), I*y*tan(1), -I/(y*tan(1)),
+        y*tanh(x), 1/(y*tanh(x)), I*y*tan(x), -I/(y*tan(x)),
+        y*tanh(1 + I), 1/(y*tanh(1 + I))]
+    for a in (1, I, x, I*x, 1 + I):
+        w = exp(a)
+        eq = y*(w - 1/w)/(w + 1/w)
+        res.append(simplify(eq))
+        res.append(simplify(1/eq))
+    assert all(valid(i, j) for i, j in zip(res, ok))
+
+    for a in range(1, 3):
+        w = exp(a)
+        e = w + 1/w
+        s = simplify(e)
+        assert s == exptrigsimp(e)
+        assert valid(s, 2*cosh(a))
+        e = w - 1/w
+        s = simplify(e)
+        assert s == exptrigsimp(e)
+        assert valid(s, 2*sinh(a))
+
+def test_exptrigsimp_noncommutative():
+    a,b = symbols('a b', commutative=False)
+    x = Symbol('x', commutative=True)
+    assert exp(a + x) == exptrigsimp(exp(a)*exp(x))
+    p = exp(a)*exp(b) - exp(b)*exp(a)
+    assert p == exptrigsimp(p) != 0
+
+def test_powsimp_on_numbers():
+    assert 2**(Rational(1, 3) - 2) == 2**Rational(1, 3)/4
+
+
+@XFAIL
+def test_issue_6811_fail():
+    # from doc/src/modules/physics/mechanics/examples.rst, the current `eq`
+    # at Line 576 (in different variables) was formerly the equivalent and
+    # shorter expression given below...it would be nice to get the short one
+    # back again
+    xp, y, x, z = symbols('xp, y, x, z')
+    eq = 4*(-19*sin(x)*y + 5*sin(3*x)*y + 15*cos(2*x)*z - 21*z)*xp/(9*cos(x) - 5*cos(3*x))
+    assert trigsimp(eq) == -2*(2*cos(x)*tan(x)*y + 3*z)*xp/cos(x)
+
+
+def test_Piecewise():
+    e1 = x*(x + y) - y*(x + y)
+    e2 = sin(x)**2 + cos(x)**2
+    e3 = expand((x + y)*y/x)
+    # s1 = simplify(e1)
+    s2 = simplify(e2)
+    # s3 = simplify(e3)
+
+    # trigsimp tries not to touch non-trig containing args
+    assert trigsimp(Piecewise((e1, e3 < e2), (e3, True))) == \
+        Piecewise((e1, e3 < s2), (e3, True))
+
+
+def test_issue_21594():
+    assert simplify(exp(Rational(1,2)) + exp(Rational(-1,2))) == cosh(S.Half)*2
+
+
+def test_trigsimp_old():
+    x, y = symbols('x,y')
+
+    assert trigsimp(1 - sin(x)**2, old=True) == cos(x)**2
+    assert trigsimp(1 - cos(x)**2, old=True) == sin(x)**2
+    assert trigsimp(sin(x)**2 + cos(x)**2, old=True) == 1
+    assert trigsimp(1 + tan(x)**2, old=True) == 1/cos(x)**2
+    assert trigsimp(1/cos(x)**2 - 1, old=True) == tan(x)**2
+    assert trigsimp(1/cos(x)**2 - tan(x)**2, old=True) == 1
+    assert trigsimp(1 + cot(x)**2, old=True) == 1/sin(x)**2
+    assert trigsimp(1/sin(x)**2 - cot(x)**2, old=True) == 1
+
+    assert trigsimp(5*cos(x)**2 + 5*sin(x)**2, old=True) == 5
+
+    assert trigsimp(sin(x)/cos(x), old=True) == tan(x)
+    assert trigsimp(2*tan(x)*cos(x), old=True) == 2*sin(x)
+    assert trigsimp(cot(x)**3*sin(x)**3, old=True) == cos(x)**3
+    assert trigsimp(y*tan(x)**2/sin(x)**2, old=True) == y/cos(x)**2
+    assert trigsimp(cot(x)/cos(x), old=True) == 1/sin(x)
+
+    assert trigsimp(sin(x + y) + sin(x - y), old=True) == 2*sin(x)*cos(y)
+    assert trigsimp(sin(x + y) - sin(x - y), old=True) == 2*sin(y)*cos(x)
+    assert trigsimp(cos(x + y) + cos(x - y), old=True) == 2*cos(x)*cos(y)
+    assert trigsimp(cos(x + y) - cos(x - y), old=True) == -2*sin(x)*sin(y)
+
+    assert trigsimp(sinh(x + y) + sinh(x - y), old=True) == 2*sinh(x)*cosh(y)
+    assert trigsimp(sinh(x + y) - sinh(x - y), old=True) == 2*sinh(y)*cosh(x)
+    assert trigsimp(cosh(x + y) + cosh(x - y), old=True) == 2*cosh(x)*cosh(y)
+    assert trigsimp(cosh(x + y) - cosh(x - y), old=True) == 2*sinh(x)*sinh(y)
+
+    assert trigsimp(cos(0.12345)**2 + sin(0.12345)**2, old=True) == 1.0
+
+    assert trigsimp(sin(x)/cos(x), old=True, method='combined') == tan(x)
+    assert trigsimp(sin(x)/cos(x), old=True, method='groebner') == sin(x)/cos(x)
+    assert trigsimp(sin(x)/cos(x), old=True, method='groebner', hints=[tan]) == tan(x)
+
+    assert trigsimp(1-sin(sin(x)**2+cos(x)**2)**2, old=True, deep=True) == cos(1)**2
+
+
+def test_trigsimp_inverse():
+    alpha = symbols('alpha')
+    s, c = sin(alpha), cos(alpha)
+
+    for finv in [asin, acos, asec, acsc, atan, acot]:
+        f = finv.inverse(None)
+        assert alpha == trigsimp(finv(f(alpha)), inverse=True)
+
+    # test atan2(cos, sin), atan2(sin, cos), etc...
+    for a, b in [[c, s], [s, c]]:
+        for i, j in product([-1, 1], repeat=2):
+            angle = atan2(i*b, j*a)
+            angle_inverted = trigsimp(angle, inverse=True)
+            assert angle_inverted != angle  # assures simplification happened
+            assert sin(angle_inverted) == trigsimp(sin(angle))
+            assert cos(angle_inverted) == trigsimp(cos(angle))
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/__pycache__/__init__.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..cca469740c6fee28267c74c8b733a23c19d06083
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/__pycache__/__init__.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/__pycache__/bivariate.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/__pycache__/bivariate.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..05b5fd0fac6d4d8ab975b40c1b6fcfa92ecb1aa3
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/__pycache__/bivariate.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/__pycache__/decompogen.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/__pycache__/decompogen.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..99ae96e1467c294354c84c1441915276ff8ef7fd
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/__pycache__/decompogen.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/__pycache__/deutils.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/__pycache__/deutils.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b80db596e0c921b735aab3a0b5be0d69417bea2a
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/__pycache__/deutils.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/__pycache__/inequalities.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/__pycache__/inequalities.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..99c04d87069d6492cbda10a01bd8a162ccc35952
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/__pycache__/inequalities.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/__pycache__/pde.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/__pycache__/pde.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..e2d83fd4b2ab3cdd673cafc0d2588d43d80f4797
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/__pycache__/pde.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/__pycache__/polysys.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/__pycache__/polysys.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..94c59a508f4e183441351a91d0e86aed13e012f5
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/__pycache__/polysys.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/__pycache__/recurr.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/__pycache__/recurr.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..6bd2fa91b3a39826cde71bc1983b9f16315b1d9a
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/__pycache__/recurr.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/__pycache__/simplex.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/__pycache__/simplex.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..110b2529ddb775ac624384e31731534fd6c9f94d
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/__pycache__/simplex.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/__pycache__/solvers.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/__pycache__/solvers.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..10421d0d977c7eed96fe9f265fba3fd17925ffbe
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/__pycache__/solvers.cpython-312.pyc
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9ca4befd6dd5397d29c6f03f74bef1345507b76b292dec3b6e5e1130ce30fe8d
+size 148458
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/__pycache__/solveset.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/__pycache__/solveset.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..32a28fa32a374ec4b8181ff08d3bbc6772f7987b
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/__pycache__/solveset.cpython-312.pyc
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ecdd49acf7a615d24c2fb14669c12c66b6bf05119858ce5a547b0d57bb03885e
+size 158916
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/benchmarks/__init__.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/benchmarks/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/benchmarks/__pycache__/__init__.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/benchmarks/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..0e849ecd3ad04d303c1026f132d5d65fdcd7d5e4
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/benchmarks/__pycache__/__init__.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/benchmarks/__pycache__/bench_solvers.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/benchmarks/__pycache__/bench_solvers.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..2035a4385c70465e5e47b97425ec4808a5d7bb75
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/benchmarks/__pycache__/bench_solvers.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/benchmarks/bench_solvers.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/benchmarks/bench_solvers.py
new file mode 100644
index 0000000000000000000000000000000000000000..d18102873f7efcde1d111e0e8eca12e208f94663
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/benchmarks/bench_solvers.py
@@ -0,0 +1,12 @@
+from sympy.core.symbol import Symbol
+from sympy.matrices.dense import (eye, zeros)
+from sympy.solvers.solvers import solve_linear_system
+
+N = 8
+M = zeros(N, N + 1)
+M[:, :N] = eye(N)
+S = [Symbol('A%i' % i) for i in range(N)]
+
+
+def timeit_linsolve_trivial():
+    solve_linear_system(M, *S)
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/diophantine/__init__.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/diophantine/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..23c21242208d6f520c130250ecdce43382b9d868
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/diophantine/__init__.py
@@ -0,0 +1,5 @@
+from .diophantine import diophantine, classify_diop, diop_solve
+
+__all__ = [
+    'diophantine', 'classify_diop', 'diop_solve'
+]
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/diophantine/__pycache__/__init__.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/diophantine/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..44b1c717649cddc42e994f877031c320c34faedd
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/diophantine/__pycache__/__init__.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/diophantine/__pycache__/diophantine.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/diophantine/__pycache__/diophantine.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..e5ea5d3db6bd833ab9d2424172d078660bd69e96
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/diophantine/__pycache__/diophantine.cpython-312.pyc
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6d2225276987ea69ace241d22f867c77f3dc7ae605825c022e514c454de530c3
+size 148188
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/diophantine/diophantine.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/diophantine/diophantine.py
new file mode 100644
index 0000000000000000000000000000000000000000..ffdef6344451c96ed48dff099cf8f02494f4b504
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/diophantine/diophantine.py
@@ -0,0 +1,3980 @@
+from __future__ import annotations
+
+from sympy.core.add import Add
+from sympy.core.assumptions import check_assumptions
+from sympy.core.containers import Tuple
+from sympy.core.exprtools import factor_terms
+from sympy.core.function import _mexpand
+from sympy.core.mul import Mul
+from sympy.core.numbers import Rational, int_valued
+from sympy.core.intfunc import igcdex, ilcm, igcd, integer_nthroot, isqrt
+from sympy.core.relational import Eq
+from sympy.core.singleton import S
+from sympy.core.sorting import default_sort_key, ordered
+from sympy.core.symbol import Symbol, symbols
+from sympy.core.sympify import _sympify
+from sympy.external.gmpy import jacobi, remove, invert, iroot
+from sympy.functions.elementary.complexes import sign
+from sympy.functions.elementary.integers import floor
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.matrices.dense import MutableDenseMatrix as Matrix
+from sympy.ntheory.factor_ import divisors, factorint, perfect_power
+from sympy.ntheory.generate import nextprime
+from sympy.ntheory.primetest import is_square, isprime
+from sympy.ntheory.modular import symmetric_residue
+from sympy.ntheory.residue_ntheory import sqrt_mod, sqrt_mod_iter
+from sympy.polys.polyerrors import GeneratorsNeeded
+from sympy.polys.polytools import Poly, factor_list
+from sympy.simplify.simplify import signsimp
+from sympy.solvers.solveset import solveset_real
+from sympy.utilities import numbered_symbols
+from sympy.utilities.misc import as_int, filldedent
+from sympy.utilities.iterables import (is_sequence, subsets, permute_signs,
+                                       signed_permutations, ordered_partitions)
+
+
+# these are imported with 'from sympy.solvers.diophantine import *
+__all__ = ['diophantine', 'classify_diop']
+
+
+class DiophantineSolutionSet(set):
+    """
+    Container for a set of solutions to a particular diophantine equation.
+
+    The base representation is a set of tuples representing each of the solutions.
+
+    Parameters
+    ==========
+
+    symbols : list
+        List of free symbols in the original equation.
+    parameters: list
+        List of parameters to be used in the solution.
+
+    Examples
+    ========
+
+    Adding solutions:
+
+        >>> from sympy.solvers.diophantine.diophantine import DiophantineSolutionSet
+        >>> from sympy.abc import x, y, t, u
+        >>> s1 = DiophantineSolutionSet([x, y], [t, u])
+        >>> s1
+        set()
+        >>> s1.add((2, 3))
+        >>> s1.add((-1, u))
+        >>> s1
+        {(-1, u), (2, 3)}
+        >>> s2 = DiophantineSolutionSet([x, y], [t, u])
+        >>> s2.add((3, 4))
+        >>> s1.update(*s2)
+        >>> s1
+        {(-1, u), (2, 3), (3, 4)}
+
+    Conversion of solutions into dicts:
+
+        >>> list(s1.dict_iterator())
+        [{x: -1, y: u}, {x: 2, y: 3}, {x: 3, y: 4}]
+
+    Substituting values:
+
+        >>> s3 = DiophantineSolutionSet([x, y], [t, u])
+        >>> s3.add((t**2, t + u))
+        >>> s3
+        {(t**2, t + u)}
+        >>> s3.subs({t: 2, u: 3})
+        {(4, 5)}
+        >>> s3.subs(t, -1)
+        {(1, u - 1)}
+        >>> s3.subs(t, 3)
+        {(9, u + 3)}
+
+    Evaluation at specific values. Positional arguments are given in the same order as the parameters:
+
+        >>> s3(-2, 3)
+        {(4, 1)}
+        >>> s3(5)
+        {(25, u + 5)}
+        >>> s3(None, 2)
+        {(t**2, t + 2)}
+    """
+
+    def __init__(self, symbols_seq, parameters):
+        super().__init__()
+
+        if not is_sequence(symbols_seq):
+            raise ValueError("Symbols must be given as a sequence.")
+
+        if not is_sequence(parameters):
+            raise ValueError("Parameters must be given as a sequence.")
+
+        self.symbols = tuple(symbols_seq)
+        self.parameters = tuple(parameters)
+
+    def add(self, solution):
+        if len(solution) != len(self.symbols):
+            raise ValueError("Solution should have a length of %s, not %s" % (len(self.symbols), len(solution)))
+        # make solution canonical wrt sign (i.e. no -x unless x is also present as an arg)
+        args = set(solution)
+        for i in range(len(solution)):
+            x = solution[i]
+            if not type(x) is int and (-x).is_Symbol and -x not in args:
+                solution = [_.subs(-x, x) for _ in solution]
+        super().add(Tuple(*solution))
+
+    def update(self, *solutions):
+        for solution in solutions:
+            self.add(solution)
+
+    def dict_iterator(self):
+        for solution in ordered(self):
+            yield dict(zip(self.symbols, solution))
+
+    def subs(self, *args, **kwargs):
+        result = DiophantineSolutionSet(self.symbols, self.parameters)
+        for solution in self:
+            result.add(solution.subs(*args, **kwargs))
+        return result
+
+    def __call__(self, *args):
+        if len(args) > len(self.parameters):
+            raise ValueError("Evaluation should have at most %s values, not %s" % (len(self.parameters), len(args)))
+        rep = {p: v for p, v in zip(self.parameters, args) if v is not None}
+        return self.subs(rep)
+
+
+class DiophantineEquationType:
+    """
+    Internal representation of a particular diophantine equation type.
+
+    Parameters
+    ==========
+
+    equation :
+        The diophantine equation that is being solved.
+    free_symbols : list (optional)
+        The symbols being solved for.
+
+    Attributes
+    ==========
+
+    total_degree :
+        The maximum of the degrees of all terms in the equation
+    homogeneous :
+        Does the equation contain a term of degree 0
+    homogeneous_order :
+        Does the equation contain any coefficient that is in the symbols being solved for
+    dimension :
+        The number of symbols being solved for
+    """
+    name: str
+
+    def __init__(self, equation, free_symbols=None):
+        self.equation = _sympify(equation).expand(force=True)
+
+        if free_symbols is not None:
+            self.free_symbols = free_symbols
+        else:
+            self.free_symbols = list(self.equation.free_symbols)
+            self.free_symbols.sort(key=default_sort_key)
+
+        if not self.free_symbols:
+            raise ValueError('equation should have 1 or more free symbols')
+
+        self.coeff = self.equation.as_coefficients_dict()
+        if not all(int_valued(c) for c in self.coeff.values()):
+            raise TypeError("Coefficients should be Integers")
+
+        self.total_degree = Poly(self.equation).total_degree()
+        self.homogeneous = 1 not in self.coeff
+        self.homogeneous_order = not (set(self.coeff) & set(self.free_symbols))
+        self.dimension = len(self.free_symbols)
+        self._parameters = None
+
+    def matches(self):
+        """
+        Determine whether the given equation can be matched to the particular equation type.
+        """
+        return False
+
+    @property
+    def n_parameters(self):
+        return self.dimension
+
+    @property
+    def parameters(self):
+        if self._parameters is None:
+            self._parameters = symbols('t_:%i' % (self.n_parameters,), integer=True)
+        return self._parameters
+
+    def solve(self, parameters=None, limit=None) -> DiophantineSolutionSet:
+        raise NotImplementedError('No solver has been written for %s.' % self.name)
+
+    def pre_solve(self, parameters=None):
+        if not self.matches():
+            raise ValueError("This equation does not match the %s equation type." % self.name)
+
+        if parameters is not None:
+            if len(parameters) != self.n_parameters:
+                raise ValueError("Expected %s parameter(s) but got %s" % (self.n_parameters, len(parameters)))
+
+        self._parameters = parameters
+
+
+class Univariate(DiophantineEquationType):
+    """
+    Representation of a univariate diophantine equation.
+
+    A univariate diophantine equation is an equation of the form
+    `a_{0} + a_{1}x + a_{2}x^2 + .. + a_{n}x^n = 0` where `a_{1}, a_{2}, ..a_{n}` are
+    integer constants and `x` is an integer variable.
+
+    Examples
+    ========
+
+    >>> from sympy.solvers.diophantine.diophantine import Univariate
+    >>> from sympy.abc import x
+    >>> Univariate((x - 2)*(x - 3)**2).solve() # solves equation (x - 2)*(x - 3)**2 == 0
+    {(2,), (3,)}
+
+    """
+
+    name = 'univariate'
+
+    def matches(self):
+        return self.dimension == 1
+
+    def solve(self, parameters=None, limit=None):
+        self.pre_solve(parameters)
+
+        result = DiophantineSolutionSet(self.free_symbols, parameters=self.parameters)
+        for i in solveset_real(self.equation, self.free_symbols[0]).intersect(S.Integers):
+            result.add((i,))
+        return result
+
+
+class Linear(DiophantineEquationType):
+    """
+    Representation of a linear diophantine equation.
+
+    A linear diophantine equation is an equation of the form `a_{1}x_{1} +
+    a_{2}x_{2} + .. + a_{n}x_{n} = 0` where `a_{1}, a_{2}, ..a_{n}` are
+    integer constants and `x_{1}, x_{2}, ..x_{n}` are integer variables.
+
+    Examples
+    ========
+
+    >>> from sympy.solvers.diophantine.diophantine import Linear
+    >>> from sympy.abc import x, y, z
+    >>> l1 = Linear(2*x - 3*y - 5)
+    >>> l1.matches() # is this equation linear
+    True
+    >>> l1.solve() # solves equation 2*x - 3*y - 5 == 0
+    {(3*t_0 - 5, 2*t_0 - 5)}
+
+    Here x = -3*t_0 - 5 and y = -2*t_0 - 5
+
+    >>> Linear(2*x - 3*y - 4*z -3).solve()
+    {(t_0, 2*t_0 + 4*t_1 + 3, -t_0 - 3*t_1 - 3)}
+
+    """
+
+    name = 'linear'
+
+    def matches(self):
+        return self.total_degree == 1
+
+    def solve(self, parameters=None, limit=None):
+        self.pre_solve(parameters)
+
+        coeff = self.coeff
+        var = self.free_symbols
+
+        if 1 in coeff:
+            # negate coeff[] because input is of the form: ax + by + c ==  0
+            #                              but is used as: ax + by     == -c
+            c = -coeff[1]
+        else:
+            c = 0
+
+        result = DiophantineSolutionSet(var, parameters=self.parameters)
+        params = result.parameters
+
+        if len(var) == 1:
+            q, r = divmod(c, coeff[var[0]])
+            if not r:
+                result.add((q,))
+            return result
+
+        '''
+        base_solution_linear() can solve diophantine equations of the form:
+
+        a*x + b*y == c
+
+        We break down multivariate linear diophantine equations into a
+        series of bivariate linear diophantine equations which can then
+        be solved individually by base_solution_linear().
+
+        Consider the following:
+
+        a_0*x_0 + a_1*x_1 + a_2*x_2 == c
+
+        which can be re-written as:
+
+        a_0*x_0 + g_0*y_0 == c
+
+        where
+
+        g_0 == gcd(a_1, a_2)
+
+        and
+
+        y == (a_1*x_1)/g_0 + (a_2*x_2)/g_0
+
+        This leaves us with two binary linear diophantine equations.
+        For the first equation:
+
+        a == a_0
+        b == g_0
+        c == c
+
+        For the second:
+
+        a == a_1/g_0
+        b == a_2/g_0
+        c == the solution we find for y_0 in the first equation.
+
+        The arrays A and B are the arrays of integers used for
+        'a' and 'b' in each of the n-1 bivariate equations we solve.
+        '''
+
+        A = [coeff[v] for v in var]
+        B = []
+        if len(var) > 2:
+            B.append(igcd(A[-2], A[-1]))
+            A[-2] = A[-2] // B[0]
+            A[-1] = A[-1] // B[0]
+            for i in range(len(A) - 3, 0, -1):
+                gcd = igcd(B[0], A[i])
+                B[0] = B[0] // gcd
+                A[i] = A[i] // gcd
+                B.insert(0, gcd)
+        B.append(A[-1])
+
+        '''
+        Consider the trivariate linear equation:
+
+        4*x_0 + 6*x_1 + 3*x_2 == 2
+
+        This can be re-written as:
+
+        4*x_0 + 3*y_0 == 2
+
+        where
+
+        y_0 == 2*x_1 + x_2
+        (Note that gcd(3, 6) == 3)
+
+        The complete integral solution to this equation is:
+
+        x_0 ==  2 + 3*t_0
+        y_0 == -2 - 4*t_0
+
+        where 't_0' is any integer.
+
+        Now that we have a solution for 'x_0', find 'x_1' and 'x_2':
+
+        2*x_1 + x_2 == -2 - 4*t_0
+
+        We can then solve for '-2' and '-4' independently,
+        and combine the results:
+
+        2*x_1a + x_2a == -2
+        x_1a == 0 + t_0
+        x_2a == -2 - 2*t_0
+
+        2*x_1b + x_2b == -4*t_0
+        x_1b == 0*t_0 + t_1
+        x_2b == -4*t_0 - 2*t_1
+
+        ==>
+
+        x_1 == t_0 + t_1
+        x_2 == -2 - 6*t_0 - 2*t_1
+
+        where 't_0' and 't_1' are any integers.
+
+        Note that:
+
+        4*(2 + 3*t_0) + 6*(t_0 + t_1) + 3*(-2 - 6*t_0 - 2*t_1) == 2
+
+        for any integral values of 't_0', 't_1'; as required.
+
+        This method is generalised for many variables, below.
+
+        '''
+        solutions = []
+        for Ai, Bi in zip(A, B):
+            tot_x, tot_y = [], []
+
+            for arg in Add.make_args(c):
+                if arg.is_Integer:
+                    # example: 5 -> k = 5
+                    k, p = arg, S.One
+                    pnew = params[0]
+                else:  # arg is a Mul or Symbol
+                    # example: 3*t_1 -> k = 3
+                    # example: t_0 -> k = 1
+                    k, p = arg.as_coeff_Mul()
+                    pnew = params[params.index(p) + 1]
+
+                sol = sol_x, sol_y = base_solution_linear(k, Ai, Bi, pnew)
+
+                if p is S.One:
+                    if None in sol:
+                        return result
+                else:
+                    # convert a + b*pnew -> a*p + b*pnew
+                    if isinstance(sol_x, Add):
+                        sol_x = sol_x.args[0]*p + sol_x.args[1]
+                    if isinstance(sol_y, Add):
+                        sol_y = sol_y.args[0]*p + sol_y.args[1]
+
+                tot_x.append(sol_x)
+                tot_y.append(sol_y)
+
+            solutions.append(Add(*tot_x))
+            c = Add(*tot_y)
+
+        solutions.append(c)
+        result.add(solutions)
+        return result
+
+
+class BinaryQuadratic(DiophantineEquationType):
+    """
+    Representation of a binary quadratic diophantine equation.
+
+    A binary quadratic diophantine equation is an equation of the
+    form `Ax^2 + Bxy + Cy^2 + Dx + Ey + F = 0`, where `A, B, C, D, E,
+    F` are integer constants and `x` and `y` are integer variables.
+
+    Examples
+    ========
+
+    >>> from sympy.abc import x, y
+    >>> from sympy.solvers.diophantine.diophantine import BinaryQuadratic
+    >>> b1 = BinaryQuadratic(x**3 + y**2 + 1)
+    >>> b1.matches()
+    False
+    >>> b2 = BinaryQuadratic(x**2 + y**2 + 2*x + 2*y + 2)
+    >>> b2.matches()
+    True
+    >>> b2.solve()
+    {(-1, -1)}
+
+    References
+    ==========
+
+    .. [1] Methods to solve Ax^2 + Bxy + Cy^2 + Dx + Ey + F = 0, [online],
+          Available: https://www.alpertron.com.ar/METHODS.HTM
+    .. [2] Solving the equation ax^2+ bxy + cy^2 + dx + ey + f= 0, [online],
+          Available: https://web.archive.org/web/20160323033111/http://www.jpr2718.org/ax2p.pdf
+
+    """
+
+    name = 'binary_quadratic'
+
+    def matches(self):
+        return self.total_degree == 2 and self.dimension == 2
+
+    def solve(self, parameters=None, limit=None) -> DiophantineSolutionSet:
+        self.pre_solve(parameters)
+
+        var = self.free_symbols
+        coeff = self.coeff
+
+        x, y = var
+
+        A = coeff[x**2]
+        B = coeff[x*y]
+        C = coeff[y**2]
+        D = coeff[x]
+        E = coeff[y]
+        F = coeff[S.One]
+
+        A, B, C, D, E, F = [as_int(i) for i in _remove_gcd(A, B, C, D, E, F)]
+
+        # (1) Simple-Hyperbolic case: A = C = 0, B != 0
+        # In this case equation can be converted to (Bx + E)(By + D) = DE - BF
+        # We consider two cases; DE - BF = 0 and DE - BF != 0
+        # More details, https://www.alpertron.com.ar/METHODS.HTM#SHyperb
+
+        result = DiophantineSolutionSet(var, self.parameters)
+        t, u = result.parameters
+
+        discr = B**2 - 4*A*C
+        if A == 0 and C == 0 and B != 0:
+
+            if D*E - B*F == 0:
+                q, r = divmod(E, B)
+                if not r:
+                    result.add((-q, t))
+                q, r = divmod(D, B)
+                if not r:
+                    result.add((t, -q))
+            else:
+                div = divisors(D*E - B*F)
+                div = div + [-term for term in div]
+                for d in div:
+                    x0, r = divmod(d - E, B)
+                    if not r:
+                        q, r = divmod(D*E - B*F, d)
+                        if not r:
+                            y0, r = divmod(q - D, B)
+                            if not r:
+                                result.add((x0, y0))
+
+        # (2) Parabolic case: B**2 - 4*A*C = 0
+        # There are two subcases to be considered in this case.
+        # sqrt(c)D - sqrt(a)E = 0 and sqrt(c)D - sqrt(a)E != 0
+        # More Details, https://www.alpertron.com.ar/METHODS.HTM#Parabol
+
+        elif discr == 0:
+
+            if A == 0:
+                s = BinaryQuadratic(self.equation, free_symbols=[y, x]).solve(parameters=[t, u])
+                for soln in s:
+                    result.add((soln[1], soln[0]))
+
+            else:
+                g = sign(A)*igcd(A, C)
+                a = A // g
+                c = C // g
+                e = sign(B / A)
+
+                sqa = isqrt(a)
+                sqc = isqrt(c)
+                _c = e*sqc*D - sqa*E
+                if not _c:
+                    z = Symbol("z", real=True)
+                    eq = sqa*g*z**2 + D*z + sqa*F
+                    roots = solveset_real(eq, z).intersect(S.Integers)
+                    for root in roots:
+                        ans = diop_solve(sqa*x + e*sqc*y - root)
+                        result.add((ans[0], ans[1]))
+
+                elif int_valued(c):
+                    solve_x = lambda u: -e*sqc*g*_c*t**2 - (E + 2*e*sqc*g*u)*t \
+                                        - (e*sqc*g*u**2 + E*u + e*sqc*F) // _c
+
+                    solve_y = lambda u: sqa*g*_c*t**2 + (D + 2*sqa*g*u)*t \
+                                        + (sqa*g*u**2 + D*u + sqa*F) // _c
+
+                    for z0 in range(0, abs(_c)):
+                        # Check if the coefficients of y and x obtained are integers or not
+                        if (divisible(sqa*g*z0**2 + D*z0 + sqa*F, _c) and
+                            divisible(e*sqc*g*z0**2 + E*z0 + e*sqc*F, _c)):
+                            result.add((solve_x(z0), solve_y(z0)))
+
+        # (3) Method used when B**2 - 4*A*C is a square, is described in p. 6 of the below paper
+        # by John P. Robertson.
+        # https://web.archive.org/web/20160323033111/http://www.jpr2718.org/ax2p.pdf
+
+        elif is_square(discr):
+            if A != 0:
+                r = sqrt(discr)
+                u, v = symbols("u, v", integer=True)
+                eq = _mexpand(
+                    4*A*r*u*v + 4*A*D*(B*v + r*u + r*v - B*u) +
+                    2*A*4*A*E*(u - v) + 4*A*r*4*A*F)
+
+                solution = diop_solve(eq, t)
+
+                for s0, t0 in solution:
+
+                    num = B*t0 + r*s0 + r*t0 - B*s0
+                    x_0 = S(num) / (4*A*r)
+                    y_0 = S(s0 - t0) / (2*r)
+                    if isinstance(s0, Symbol) or isinstance(t0, Symbol):
+                        if len(check_param(x_0, y_0, 4*A*r, parameters)) > 0:
+                            ans = check_param(x_0, y_0, 4*A*r, parameters)
+                            result.update(*ans)
+                    elif x_0.is_Integer and y_0.is_Integer:
+                        if is_solution_quad(var, coeff, x_0, y_0):
+                            result.add((x_0, y_0))
+
+            else:
+                s = BinaryQuadratic(self.equation, free_symbols=var[::-1]).solve(parameters=[t, u])  # Interchange x and y
+                while s:
+                    result.add(s.pop()[::-1])  # and solution <--------+
+
+        # (4) B**2 - 4*A*C > 0 and B**2 - 4*A*C not a square or B**2 - 4*A*C < 0
+
+        else:
+
+            P, Q = _transformation_to_DN(var, coeff)
+            D, N = _find_DN(var, coeff)
+            solns_pell = diop_DN(D, N)
+
+            if D < 0:
+                for x0, y0 in solns_pell:
+                    for x in [-x0, x0]:
+                        for y in [-y0, y0]:
+                            s = P*Matrix([x, y]) + Q
+                            try:
+                                result.add([as_int(_) for _ in s])
+                            except ValueError:
+                                pass
+            else:
+                # In this case equation can be transformed into a Pell equation
+
+                solns_pell = set(solns_pell)
+                solns_pell.update((-X, -Y) for X, Y in list(solns_pell))
+
+                a = diop_DN(D, 1)
+                T = a[0][0]
+                U = a[0][1]
+
+                if all(int_valued(_) for _ in P[:4] + Q[:2]):
+                    for r, s in solns_pell:
+                        _a = (r + s*sqrt(D))*(T + U*sqrt(D))**t
+                        _b = (r - s*sqrt(D))*(T - U*sqrt(D))**t
+                        x_n = _mexpand(S(_a + _b) / 2)
+                        y_n = _mexpand(S(_a - _b) / (2*sqrt(D)))
+                        s = P*Matrix([x_n, y_n]) + Q
+                        result.add(s)
+
+                else:
+                    L = ilcm(*[_.q for _ in P[:4] + Q[:2]])
+
+                    k = 1
+
+                    T_k = T
+                    U_k = U
+
+                    while (T_k - 1) % L != 0 or U_k % L != 0:
+                        T_k, U_k = T_k*T + D*U_k*U, T_k*U + U_k*T
+                        k += 1
+
+                    for X, Y in solns_pell:
+
+                        for i in range(k):
+                            if all(int_valued(_) for _ in P*Matrix([X, Y]) + Q):
+                                _a = (X + sqrt(D)*Y)*(T_k + sqrt(D)*U_k)**t
+                                _b = (X - sqrt(D)*Y)*(T_k - sqrt(D)*U_k)**t
+                                Xt = S(_a + _b) / 2
+                                Yt = S(_a - _b) / (2*sqrt(D))
+                                s = P*Matrix([Xt, Yt]) + Q
+                                result.add(s)
+
+                            X, Y = X*T + D*U*Y, X*U + Y*T
+
+        return result
+
+
+class InhomogeneousTernaryQuadratic(DiophantineEquationType):
+    """
+
+    Representation of an inhomogeneous ternary quadratic.
+
+    No solver is currently implemented for this equation type.
+
+    """
+
+    name = 'inhomogeneous_ternary_quadratic'
+
+    def matches(self):
+        if not (self.total_degree == 2 and self.dimension == 3):
+            return False
+        if not self.homogeneous:
+            return False
+        return not self.homogeneous_order
+
+
+class HomogeneousTernaryQuadraticNormal(DiophantineEquationType):
+    """
+    Representation of a homogeneous ternary quadratic normal diophantine equation.
+
+    Examples
+    ========
+
+    >>> from sympy.abc import x, y, z
+    >>> from sympy.solvers.diophantine.diophantine import HomogeneousTernaryQuadraticNormal
+    >>> HomogeneousTernaryQuadraticNormal(4*x**2 - 5*y**2 + z**2).solve()
+    {(1, 2, 4)}
+
+    """
+
+    name = 'homogeneous_ternary_quadratic_normal'
+
+    def matches(self):
+        if not (self.total_degree == 2 and self.dimension == 3):
+            return False
+        if not self.homogeneous:
+            return False
+        if not self.homogeneous_order:
+            return False
+
+        nonzero = [k for k in self.coeff if self.coeff[k]]
+        return len(nonzero) == 3 and all(i**2 in nonzero for i in self.free_symbols)
+
+    def solve(self, parameters=None, limit=None) -> DiophantineSolutionSet:
+        self.pre_solve(parameters)
+
+        var = self.free_symbols
+        coeff = self.coeff
+
+        x, y, z = var
+
+        a = coeff[x**2]
+        b = coeff[y**2]
+        c = coeff[z**2]
+
+        (sqf_of_a, sqf_of_b, sqf_of_c), (a_1, b_1, c_1), (a_2, b_2, c_2) = \
+            sqf_normal(a, b, c, steps=True)
+
+        A = -a_2*c_2
+        B = -b_2*c_2
+
+        result = DiophantineSolutionSet(var, parameters=self.parameters)
+
+        # If following two conditions are satisfied then there are no solutions
+        if A < 0 and B < 0:
+            return result
+
+        if (
+            sqrt_mod(-b_2*c_2, a_2) is None or
+            sqrt_mod(-c_2*a_2, b_2) is None or
+            sqrt_mod(-a_2*b_2, c_2) is None):
+            return result
+
+        z_0, x_0, y_0 = descent(A, B)
+
+        z_0, q = _rational_pq(z_0, abs(c_2))
+        x_0 *= q
+        y_0 *= q
+
+        x_0, y_0, z_0 = _remove_gcd(x_0, y_0, z_0)
+
+        # Holzer reduction
+        if sign(a) == sign(b):
+            x_0, y_0, z_0 = holzer(x_0, y_0, z_0, abs(a_2), abs(b_2), abs(c_2))
+        elif sign(a) == sign(c):
+            x_0, z_0, y_0 = holzer(x_0, z_0, y_0, abs(a_2), abs(c_2), abs(b_2))
+        else:
+            y_0, z_0, x_0 = holzer(y_0, z_0, x_0, abs(b_2), abs(c_2), abs(a_2))
+
+        x_0 = reconstruct(b_1, c_1, x_0)
+        y_0 = reconstruct(a_1, c_1, y_0)
+        z_0 = reconstruct(a_1, b_1, z_0)
+
+        sq_lcm = ilcm(sqf_of_a, sqf_of_b, sqf_of_c)
+
+        x_0 = abs(x_0*sq_lcm // sqf_of_a)
+        y_0 = abs(y_0*sq_lcm // sqf_of_b)
+        z_0 = abs(z_0*sq_lcm // sqf_of_c)
+
+        result.add(_remove_gcd(x_0, y_0, z_0))
+        return result
+
+
+class HomogeneousTernaryQuadratic(DiophantineEquationType):
+    """
+    Representation of a homogeneous ternary quadratic diophantine equation.
+
+    Examples
+    ========
+
+    >>> from sympy.abc import x, y, z
+    >>> from sympy.solvers.diophantine.diophantine import HomogeneousTernaryQuadratic
+    >>> HomogeneousTernaryQuadratic(x**2 + y**2 - 3*z**2 + x*y).solve()
+    {(-1, 2, 1)}
+    >>> HomogeneousTernaryQuadratic(3*x**2 + y**2 - 3*z**2 + 5*x*y + y*z).solve()
+    {(3, 12, 13)}
+
+    """
+
+    name = 'homogeneous_ternary_quadratic'
+
+    def matches(self):
+        if not (self.total_degree == 2 and self.dimension == 3):
+            return False
+        if not self.homogeneous:
+            return False
+        if not self.homogeneous_order:
+            return False
+
+        nonzero = [k for k in self.coeff if self.coeff[k]]
+        return not (len(nonzero) == 3 and all(i**2 in nonzero for i in self.free_symbols))
+
+    def solve(self, parameters=None, limit=None):
+        self.pre_solve(parameters)
+
+        _var = self.free_symbols
+        coeff = self.coeff
+
+        x, y, z = _var
+        var = [x, y, z]
+
+        # Equations of the form B*x*y + C*z*x + E*y*z = 0 and At least two of the
+        # coefficients A, B, C are non-zero.
+        # There are infinitely many solutions for the equation.
+        # Ex: (0, 0, t), (0, t, 0), (t, 0, 0)
+        # Equation can be re-written as y*(B*x + E*z) = -C*x*z and we can find rather
+        # unobvious solutions. Set y = -C and B*x + E*z = x*z. The latter can be solved by
+        # using methods for binary quadratic diophantine equations. Let's select the
+        # solution which minimizes |x| + |z|
+
+        result = DiophantineSolutionSet(var, parameters=self.parameters)
+
+        def unpack_sol(sol):
+            if len(sol) > 0:
+                return list(sol)[0]
+            return None, None, None
+
+        if not any(coeff[i**2] for i in var):
+            if coeff[x*z]:
+                sols = diophantine(coeff[x*y]*x + coeff[y*z]*z - x*z)
+                s = min(sols, key=lambda r: abs(r[0]) + abs(r[1]))
+                result.add(_remove_gcd(s[0], -coeff[x*z], s[1]))
+                return result
+
+            var[0], var[1] = _var[1], _var[0]
+            y_0, x_0, z_0 = unpack_sol(_diop_ternary_quadratic(var, coeff))
+            if x_0 is not None:
+                result.add((x_0, y_0, z_0))
+            return result
+
+        if coeff[x**2] == 0:
+            # If the coefficient of x is zero change the variables
+            if coeff[y**2] == 0:
+                var[0], var[2] = _var[2], _var[0]
+                z_0, y_0, x_0 = unpack_sol(_diop_ternary_quadratic(var, coeff))
+
+            else:
+                var[0], var[1] = _var[1], _var[0]
+                y_0, x_0, z_0 = unpack_sol(_diop_ternary_quadratic(var, coeff))
+
+        else:
+            if coeff[x*y] or coeff[x*z]:
+                # Apply the transformation x --> X - (B*y + C*z)/(2*A)
+                A = coeff[x**2]
+                B = coeff[x*y]
+                C = coeff[x*z]
+                D = coeff[y**2]
+                E = coeff[y*z]
+                F = coeff[z**2]
+
+                _coeff = {}
+
+                _coeff[x**2] = 4*A**2
+                _coeff[y**2] = 4*A*D - B**2
+                _coeff[z**2] = 4*A*F - C**2
+                _coeff[y*z] = 4*A*E - 2*B*C
+                _coeff[x*y] = 0
+                _coeff[x*z] = 0
+
+                x_0, y_0, z_0 = unpack_sol(_diop_ternary_quadratic(var, _coeff))
+
+                if x_0 is None:
+                    return result
+
+                p, q = _rational_pq(B*y_0 + C*z_0, 2*A)
+                x_0, y_0, z_0 = x_0*q - p, y_0*q, z_0*q
+
+            elif coeff[z*y] != 0:
+                if coeff[y**2] == 0:
+                    if coeff[z**2] == 0:
+                        # Equations of the form A*x**2 + E*yz = 0.
+                        A = coeff[x**2]
+                        E = coeff[y*z]
+
+                        b, a = _rational_pq(-E, A)
+
+                        x_0, y_0, z_0 = b, a, b
+
+                    else:
+                        # Ax**2 + E*y*z + F*z**2  = 0
+                        var[0], var[2] = _var[2], _var[0]
+                        z_0, y_0, x_0 = unpack_sol(_diop_ternary_quadratic(var, coeff))
+
+                else:
+                    # A*x**2 + D*y**2 + E*y*z + F*z**2 = 0, C may be zero
+                    var[0], var[1] = _var[1], _var[0]
+                    y_0, x_0, z_0 = unpack_sol(_diop_ternary_quadratic(var, coeff))
+
+            else:
+                # Ax**2 + D*y**2 + F*z**2 = 0, C may be zero
+                x_0, y_0, z_0 = unpack_sol(_diop_ternary_quadratic_normal(var, coeff))
+
+        if x_0 is None:
+            return result
+
+        result.add(_remove_gcd(x_0, y_0, z_0))
+        return result
+
+
+class InhomogeneousGeneralQuadratic(DiophantineEquationType):
+    """
+
+    Representation of an inhomogeneous general quadratic.
+
+    No solver is currently implemented for this equation type.
+
+    """
+
+    name = 'inhomogeneous_general_quadratic'
+
+    def matches(self):
+        if not (self.total_degree == 2 and self.dimension >= 3):
+            return False
+        if not self.homogeneous_order:
+            return True
+        # there may be Pow keys like x**2 or Mul keys like x*y
+        return any(k.is_Mul for k in self.coeff) and not self.homogeneous
+
+
+class HomogeneousGeneralQuadratic(DiophantineEquationType):
+    """
+
+    Representation of a homogeneous general quadratic.
+
+    No solver is currently implemented for this equation type.
+
+    """
+
+    name = 'homogeneous_general_quadratic'
+
+    def matches(self):
+        if not (self.total_degree == 2 and self.dimension >= 3):
+            return False
+        if not self.homogeneous_order:
+            return False
+        # there may be Pow keys like x**2 or Mul keys like x*y
+        return any(k.is_Mul for k in self.coeff) and self.homogeneous
+
+
+class GeneralSumOfSquares(DiophantineEquationType):
+    r"""
+    Representation of the diophantine equation
+
+    `x_{1}^2 + x_{2}^2 + . . . + x_{n}^2 - k = 0`.
+
+    Details
+    =======
+
+    When `n = 3` if `k = 4^a(8m + 7)` for some `a, m \in Z` then there will be
+    no solutions. Refer [1]_ for more details.
+
+    Examples
+    ========
+
+    >>> from sympy.solvers.diophantine.diophantine import GeneralSumOfSquares
+    >>> from sympy.abc import a, b, c, d, e
+    >>> GeneralSumOfSquares(a**2 + b**2 + c**2 + d**2 + e**2 - 2345).solve()
+    {(15, 22, 22, 24, 24)}
+
+    By default only 1 solution is returned. Use the `limit` keyword for more:
+
+    >>> sorted(GeneralSumOfSquares(a**2 + b**2 + c**2 + d**2 + e**2 - 2345).solve(limit=3))
+    [(15, 22, 22, 24, 24), (16, 19, 24, 24, 24), (16, 20, 22, 23, 26)]
+
+    References
+    ==========
+
+    .. [1] Representing an integer as a sum of three squares, [online],
+        Available:
+        https://proofwiki.org/wiki/Integer_as_Sum_of_Three_Squares
+    """
+
+    name = 'general_sum_of_squares'
+
+    def matches(self):
+        if not (self.total_degree == 2 and self.dimension >= 3):
+            return False
+        if not self.homogeneous_order:
+            return False
+        if any(k.is_Mul for k in self.coeff):
+            return False
+        return all(self.coeff[k] == 1 for k in self.coeff if k != 1)
+
+    def solve(self, parameters=None, limit=1):
+        self.pre_solve(parameters)
+
+        var = self.free_symbols
+        k = -int(self.coeff[1])
+        n = self.dimension
+
+        result = DiophantineSolutionSet(var, parameters=self.parameters)
+
+        if k < 0 or limit < 1:
+            return result
+
+        signs = [-1 if x.is_nonpositive else 1 for x in var]
+        negs = signs.count(-1) != 0
+
+        took = 0
+        for t in sum_of_squares(k, n, zeros=True):
+            if negs:
+                result.add([signs[i]*j for i, j in enumerate(t)])
+            else:
+                result.add(t)
+            took += 1
+            if took == limit:
+                break
+        return result
+
+
+class GeneralPythagorean(DiophantineEquationType):
+    """
+    Representation of the general pythagorean equation,
+    `a_{1}^2x_{1}^2 + a_{2}^2x_{2}^2 + . . . + a_{n}^2x_{n}^2 - a_{n + 1}^2x_{n + 1}^2 = 0`.
+
+    Examples
+    ========
+
+    >>> from sympy.solvers.diophantine.diophantine import GeneralPythagorean
+    >>> from sympy.abc import a, b, c, d, e, x, y, z, t
+    >>> GeneralPythagorean(a**2 + b**2 + c**2 - d**2).solve()
+    {(t_0**2 + t_1**2 - t_2**2, 2*t_0*t_2, 2*t_1*t_2, t_0**2 + t_1**2 + t_2**2)}
+    >>> GeneralPythagorean(9*a**2 - 4*b**2 + 16*c**2 + 25*d**2 + e**2).solve(parameters=[x, y, z, t])
+    {(-10*t**2 + 10*x**2 + 10*y**2 + 10*z**2, 15*t**2 + 15*x**2 + 15*y**2 + 15*z**2, 15*t*x, 12*t*y, 60*t*z)}
+    """
+
+    name = 'general_pythagorean'
+
+    def matches(self):
+        if not (self.total_degree == 2 and self.dimension >= 3):
+            return False
+        if not self.homogeneous_order:
+            return False
+        if any(k.is_Mul for k in self.coeff):
+            return False
+        if all(self.coeff[k] == 1 for k in self.coeff if k != 1):
+            return False
+        if not all(is_square(abs(self.coeff[k])) for k in self.coeff):
+            return False
+        # all but one has the same sign
+        # e.g. 4*x**2 + y**2 - 4*z**2
+        return abs(sum(sign(self.coeff[k]) for k in self.coeff)) == self.dimension - 2
+
+    @property
+    def n_parameters(self):
+        return self.dimension - 1
+
+    def solve(self, parameters=None, limit=1):
+        self.pre_solve(parameters)
+
+        coeff = self.coeff
+        var = self.free_symbols
+        n = self.dimension
+
+        if sign(coeff[var[0] ** 2]) + sign(coeff[var[1] ** 2]) + sign(coeff[var[2] ** 2]) < 0:
+            for key in coeff.keys():
+                coeff[key] = -coeff[key]
+
+        result = DiophantineSolutionSet(var, parameters=self.parameters)
+
+        index = 0
+
+        for i, v in enumerate(var):
+            if sign(coeff[v ** 2]) == -1:
+                index = i
+
+        m = result.parameters
+
+        ith = sum(m_i ** 2 for m_i in m)
+        L = [ith - 2 * m[n - 2] ** 2]
+        L.extend([2 * m[i] * m[n - 2] for i in range(n - 2)])
+        sol = L[:index] + [ith] + L[index:]
+
+        lcm = 1
+        for i, v in enumerate(var):
+            if i == index or (index > 0 and i == 0) or (index == 0 and i == 1):
+                lcm = ilcm(lcm, sqrt(abs(coeff[v ** 2])))
+            else:
+                s = sqrt(coeff[v ** 2])
+                lcm = ilcm(lcm, s if _odd(s) else s // 2)
+
+        for i, v in enumerate(var):
+            sol[i] = (lcm * sol[i]) / sqrt(abs(coeff[v ** 2]))
+
+        result.add(sol)
+        return result
+
+
+class CubicThue(DiophantineEquationType):
+    """
+    Representation of a cubic Thue diophantine equation.
+
+    A cubic Thue diophantine equation is a polynomial of the form
+    `f(x, y) = r` of degree 3, where `x` and `y` are integers
+    and `r` is a rational number.
+
+    No solver is currently implemented for this equation type.
+
+    Examples
+    ========
+
+    >>> from sympy.abc import x, y
+    >>> from sympy.solvers.diophantine.diophantine import CubicThue
+    >>> c1 = CubicThue(x**3 + y**2 + 1)
+    >>> c1.matches()
+    True
+
+    """
+
+    name = 'cubic_thue'
+
+    def matches(self):
+        return self.total_degree == 3 and self.dimension == 2
+
+
+class GeneralSumOfEvenPowers(DiophantineEquationType):
+    """
+    Representation of the diophantine equation
+
+    `x_{1}^e + x_{2}^e + . . . + x_{n}^e - k = 0`
+
+    where `e` is an even, integer power.
+
+    Examples
+    ========
+
+    >>> from sympy.solvers.diophantine.diophantine import GeneralSumOfEvenPowers
+    >>> from sympy.abc import a, b
+    >>> GeneralSumOfEvenPowers(a**4 + b**4 - (2**4 + 3**4)).solve()
+    {(2, 3)}
+
+    """
+
+    name = 'general_sum_of_even_powers'
+
+    def matches(self):
+        if not self.total_degree > 3:
+            return False
+        if self.total_degree % 2 != 0:
+            return False
+        if not all(k.is_Pow and k.exp == self.total_degree for k in self.coeff if k != 1):
+            return False
+        return all(self.coeff[k] == 1 for k in self.coeff if k != 1)
+
+    def solve(self, parameters=None, limit=1):
+        self.pre_solve(parameters)
+
+        var = self.free_symbols
+        coeff = self.coeff
+
+        p = None
+        for q in coeff.keys():
+            if q.is_Pow and coeff[q]:
+                p = q.exp
+
+        k = len(var)
+        n = -coeff[1]
+
+        result = DiophantineSolutionSet(var, parameters=self.parameters)
+
+        if n < 0 or limit < 1:
+            return result
+
+        sign = [-1 if x.is_nonpositive else 1 for x in var]
+        negs = sign.count(-1) != 0
+
+        took = 0
+        for t in power_representation(n, p, k):
+            if negs:
+                result.add([sign[i]*j for i, j in enumerate(t)])
+            else:
+                result.add(t)
+            took += 1
+            if took == limit:
+                break
+        return result
+
+# these types are known (but not necessarily handled)
+# note that order is important here (in the current solver state)
+all_diop_classes = [
+    Linear,
+    Univariate,
+    BinaryQuadratic,
+    InhomogeneousTernaryQuadratic,
+    HomogeneousTernaryQuadraticNormal,
+    HomogeneousTernaryQuadratic,
+    InhomogeneousGeneralQuadratic,
+    HomogeneousGeneralQuadratic,
+    GeneralSumOfSquares,
+    GeneralPythagorean,
+    CubicThue,
+    GeneralSumOfEvenPowers,
+]
+
+diop_known = {diop_class.name for diop_class in all_diop_classes}
+
+
+def _remove_gcd(*x):
+    try:
+        g = igcd(*x)
+    except ValueError:
+        fx = list(filter(None, x))
+        if len(fx) < 2:
+            return x
+        g = igcd(*[i.as_content_primitive()[0] for i in fx])
+    except TypeError:
+        raise TypeError('_remove_gcd(a,b,c) or _remove_gcd(*container)')
+    if g == 1:
+        return x
+    return tuple([i//g for i in x])
+
+
+def _rational_pq(a, b):
+    # return `(numer, denom)` for a/b; sign in numer and gcd removed
+    return _remove_gcd(sign(b)*a, abs(b))
+
+
+def _nint_or_floor(p, q):
+    # return nearest int to p/q; in case of tie return floor(p/q)
+    w, r = divmod(p, q)
+    if abs(r) <= abs(q)//2:
+        return w
+    return w + 1
+
+
+def _odd(i):
+    return i % 2 != 0
+
+
+def _even(i):
+    return i % 2 == 0
+
+
+def diophantine(eq, param=symbols("t", integer=True), syms=None,
+                permute=False):
+    """
+    Simplify the solution procedure of diophantine equation ``eq`` by
+    converting it into a product of terms which should equal zero.
+
+    Explanation
+    ===========
+
+    For example, when solving, `x^2 - y^2 = 0` this is treated as
+    `(x + y)(x - y) = 0` and `x + y = 0` and `x - y = 0` are solved
+    independently and combined. Each term is solved by calling
+    ``diop_solve()``. (Although it is possible to call ``diop_solve()``
+    directly, one must be careful to pass an equation in the correct
+    form and to interpret the output correctly; ``diophantine()`` is
+    the public-facing function to use in general.)
+
+    Output of ``diophantine()`` is a set of tuples. The elements of the
+    tuple are the solutions for each variable in the equation and
+    are arranged according to the alphabetic ordering of the variables.
+    e.g. For an equation with two variables, `a` and `b`, the first
+    element of the tuple is the solution for `a` and the second for `b`.
+
+    Usage
+    =====
+
+    ``diophantine(eq, t, syms)``: Solve the diophantine
+    equation ``eq``.
+    ``t`` is the optional parameter to be used by ``diop_solve()``.
+    ``syms`` is an optional list of symbols which determines the
+    order of the elements in the returned tuple.
+
+    By default, only the base solution is returned. If ``permute`` is set to
+    True then permutations of the base solution and/or permutations of the
+    signs of the values will be returned when applicable.
+
+    Details
+    =======
+
+    ``eq`` should be an expression which is assumed to be zero.
+    ``t`` is the parameter to be used in the solution.
+
+    Examples
+    ========
+
+    >>> from sympy import diophantine
+    >>> from sympy.abc import a, b
+    >>> eq = a**4 + b**4 - (2**4 + 3**4)
+    >>> diophantine(eq)
+    {(2, 3)}
+    >>> diophantine(eq, permute=True)
+    {(-3, -2), (-3, 2), (-2, -3), (-2, 3), (2, -3), (2, 3), (3, -2), (3, 2)}
+
+    >>> from sympy.abc import x, y, z
+    >>> diophantine(x**2 - y**2)
+    {(t_0, -t_0), (t_0, t_0)}
+
+    >>> diophantine(x*(2*x + 3*y - z))
+    {(0, n1, n2), (t_0, t_1, 2*t_0 + 3*t_1)}
+    >>> diophantine(x**2 + 3*x*y + 4*x)
+    {(0, n1), (-3*t_0 - 4, t_0)}
+
+    See Also
+    ========
+
+    diop_solve
+    sympy.utilities.iterables.permute_signs
+    sympy.utilities.iterables.signed_permutations
+    """
+
+    eq = _sympify(eq)
+
+    if isinstance(eq, Eq):
+        eq = eq.lhs - eq.rhs
+
+    try:
+        var = list(eq.expand(force=True).free_symbols)
+        var.sort(key=default_sort_key)
+        if syms:
+            if not is_sequence(syms):
+                raise TypeError(
+                    'syms should be given as a sequence, e.g. a list')
+            syms = [i for i in syms if i in var]
+            if syms != var:
+                dict_sym_index = dict(zip(syms, range(len(syms))))
+                return {tuple([t[dict_sym_index[i]] for i in var])
+                            for t in diophantine(eq, param, permute=permute)}
+        n, d = eq.as_numer_denom()
+        if n.is_number:
+            return set()
+        if not d.is_number:
+            dsol = diophantine(d)
+            good = diophantine(n) - dsol
+            return {s for s in good if _mexpand(d.subs(zip(var, s)))}
+        eq = factor_terms(n)
+        assert not eq.is_number
+        eq = eq.as_independent(*var, as_Add=False)[1]
+        p = Poly(eq)
+        assert not any(g.is_number for g in p.gens)
+        eq = p.as_expr()
+        assert eq.is_polynomial()
+    except (GeneratorsNeeded, AssertionError):
+        raise TypeError(filldedent('''
+    Equation should be a polynomial with Rational coefficients.'''))
+
+    # permute only sign
+    do_permute_signs = False
+    # permute sign and values
+    do_permute_signs_var = False
+    # permute few signs
+    permute_few_signs = False
+    try:
+        # if we know that factoring should not be attempted, skip
+        # the factoring step
+        v, c, t = classify_diop(eq)
+
+        # check for permute sign
+        if permute:
+            len_var = len(v)
+            permute_signs_for = [
+                GeneralSumOfSquares.name,
+                GeneralSumOfEvenPowers.name]
+            permute_signs_check = [
+                HomogeneousTernaryQuadratic.name,
+                HomogeneousTernaryQuadraticNormal.name,
+                BinaryQuadratic.name]
+            if t in permute_signs_for:
+                do_permute_signs_var = True
+            elif t in permute_signs_check:
+                # if all the variables in eq have even powers
+                # then do_permute_sign = True
+                if len_var == 3:
+                    var_mul = list(subsets(v, 2))
+                    # here var_mul is like [(x, y), (x, z), (y, z)]
+                    xy_coeff = True
+                    x_coeff = True
+                    var1_mul_var2 = (a[0]*a[1] for a in var_mul)
+                    # if coeff(y*z), coeff(y*x), coeff(x*z) is not 0 then
+                    # `xy_coeff` => True and do_permute_sign => False.
+                    # Means no permuted solution.
+                    for v1_mul_v2 in var1_mul_var2:
+                        try:
+                            coeff = c[v1_mul_v2]
+                        except KeyError:
+                            coeff = 0
+                        xy_coeff = bool(xy_coeff) and bool(coeff)
+                    var_mul = list(subsets(v, 1))
+                    # here var_mul is like [(x,), (y, )]
+                    for v1 in var_mul:
+                        try:
+                            coeff = c[v1[0]]
+                        except KeyError:
+                            coeff = 0
+                        x_coeff = bool(x_coeff) and bool(coeff)
+                    if not any((xy_coeff, x_coeff)):
+                        # means only x**2, y**2, z**2, const is present
+                        do_permute_signs = True
+                    elif not x_coeff:
+                        permute_few_signs = True
+                elif len_var == 2:
+                    var_mul = list(subsets(v, 2))
+                    # here var_mul is like [(x, y)]
+                    xy_coeff = True
+                    x_coeff = True
+                    var1_mul_var2 = (x[0]*x[1] for x in var_mul)
+                    for v1_mul_v2 in var1_mul_var2:
+                        try:
+                            coeff = c[v1_mul_v2]
+                        except KeyError:
+                            coeff = 0
+                        xy_coeff = bool(xy_coeff) and bool(coeff)
+                    var_mul = list(subsets(v, 1))
+                    # here var_mul is like [(x,), (y, )]
+                    for v1 in var_mul:
+                        try:
+                            coeff = c[v1[0]]
+                        except KeyError:
+                            coeff = 0
+                        x_coeff = bool(x_coeff) and bool(coeff)
+                    if not any((xy_coeff, x_coeff)):
+                        # means only x**2, y**2 and const is present
+                        # so we can get more soln by permuting this soln.
+                        do_permute_signs = True
+                    elif not x_coeff:
+                        # when coeff(x), coeff(y) is not present then signs of
+                        #  x, y can be permuted such that their sign are same
+                        # as sign of x*y.
+                        # e.g 1. (x_val,y_val)=> (x_val,y_val), (-x_val,-y_val)
+                        # 2. (-x_vall, y_val)=> (-x_val,y_val), (x_val,-y_val)
+                        permute_few_signs = True
+        if t == 'general_sum_of_squares':
+            # trying to factor such expressions will sometimes hang
+            terms = [(eq, 1)]
+        else:
+            raise TypeError
+    except (TypeError, NotImplementedError):
+        fl = factor_list(eq)
+        if fl[0].is_Rational and fl[0] != 1:
+            return diophantine(eq/fl[0], param=param, syms=syms, permute=permute)
+        terms = fl[1]
+
+    sols = set()
+
+    for term in terms:
+
+        base, _ = term
+        var_t, _, eq_type = classify_diop(base, _dict=False)
+        _, base = signsimp(base, evaluate=False).as_coeff_Mul()
+        solution = diop_solve(base, param)
+
+        if eq_type in [
+                Linear.name,
+                HomogeneousTernaryQuadratic.name,
+                HomogeneousTernaryQuadraticNormal.name,
+                GeneralPythagorean.name]:
+            sols.add(merge_solution(var, var_t, solution))
+
+        elif eq_type in [
+                BinaryQuadratic.name,
+                GeneralSumOfSquares.name,
+                GeneralSumOfEvenPowers.name,
+                Univariate.name]:
+            sols.update(merge_solution(var, var_t, sol) for sol in solution)
+
+        else:
+            raise NotImplementedError('unhandled type: %s' % eq_type)
+
+    sols.discard(())
+    null = tuple([0]*len(var))
+    # if there is no solution, return trivial solution
+    if not sols and eq.subs(zip(var, null)).is_zero:
+        if all(check_assumptions(val, **s.assumptions0) is not False for val, s in zip(null, var)):
+            sols.add(null)
+
+    final_soln = set()
+    for sol in sols:
+        if all(int_valued(s) for s in sol):
+            if do_permute_signs:
+                permuted_sign = set(permute_signs(sol))
+                final_soln.update(permuted_sign)
+            elif permute_few_signs:
+                lst = list(permute_signs(sol))
+                lst = list(filter(lambda x: x[0]*x[1] == sol[1]*sol[0], lst))
+                permuted_sign = set(lst)
+                final_soln.update(permuted_sign)
+            elif do_permute_signs_var:
+                permuted_sign_var = set(signed_permutations(sol))
+                final_soln.update(permuted_sign_var)
+            else:
+                final_soln.add(sol)
+        else:
+                final_soln.add(sol)
+    return final_soln
+
+
+def merge_solution(var, var_t, solution):
+    """
+    This is used to construct the full solution from the solutions of sub
+    equations.
+
+    Explanation
+    ===========
+
+    For example when solving the equation `(x - y)(x^2 + y^2 - z^2) = 0`,
+    solutions for each of the equations `x - y = 0` and `x^2 + y^2 - z^2` are
+    found independently. Solutions for `x - y = 0` are `(x, y) = (t, t)`. But
+    we should introduce a value for z when we output the solution for the
+    original equation. This function converts `(t, t)` into `(t, t, n_{1})`
+    where `n_{1}` is an integer parameter.
+    """
+    sol = []
+
+    if None in solution:
+        return ()
+
+    solution = iter(solution)
+    params = numbered_symbols("n", integer=True, start=1)
+    for v in var:
+        if v in var_t:
+            sol.append(next(solution))
+        else:
+            sol.append(next(params))
+
+    for val, symb in zip(sol, var):
+        if check_assumptions(val, **symb.assumptions0) is False:
+            return ()
+
+    return tuple(sol)
+
+
+def _diop_solve(eq, params=None):
+    for diop_type in all_diop_classes:
+        if diop_type(eq).matches():
+            return diop_type(eq).solve(parameters=params)
+
+
+def diop_solve(eq, param=symbols("t", integer=True)):
+    """
+    Solves the diophantine equation ``eq``.
+
+    Explanation
+    ===========
+
+    Unlike ``diophantine()``, factoring of ``eq`` is not attempted. Uses
+    ``classify_diop()`` to determine the type of the equation and calls
+    the appropriate solver function.
+
+    Use of ``diophantine()`` is recommended over other helper functions.
+    ``diop_solve()`` can return either a set or a tuple depending on the
+    nature of the equation. All non-trivial solutions are returned: assumptions
+    on symbols are ignored.
+
+    Usage
+    =====
+
+    ``diop_solve(eq, t)``: Solve diophantine equation, ``eq`` using ``t``
+    as a parameter if needed.
+
+    Details
+    =======
+
+    ``eq`` should be an expression which is assumed to be zero.
+    ``t`` is a parameter to be used in the solution.
+
+    Examples
+    ========
+
+    >>> from sympy.solvers.diophantine import diop_solve
+    >>> from sympy.abc import x, y, z, w
+    >>> diop_solve(2*x + 3*y - 5)
+    (3*t_0 - 5, 5 - 2*t_0)
+    >>> diop_solve(4*x + 3*y - 4*z + 5)
+    (t_0, 8*t_0 + 4*t_1 + 5, 7*t_0 + 3*t_1 + 5)
+    >>> diop_solve(x + 3*y - 4*z + w - 6)
+    (t_0, t_0 + t_1, 6*t_0 + 5*t_1 + 4*t_2 - 6, 5*t_0 + 4*t_1 + 3*t_2 - 6)
+    >>> diop_solve(x**2 + y**2 - 5)
+    {(-2, -1), (-2, 1), (-1, -2), (-1, 2), (1, -2), (1, 2), (2, -1), (2, 1)}
+
+
+    See Also
+    ========
+
+    diophantine()
+    """
+    var, coeff, eq_type = classify_diop(eq, _dict=False)
+
+    if eq_type == Linear.name:
+        return diop_linear(eq, param)
+
+    elif eq_type == BinaryQuadratic.name:
+        return diop_quadratic(eq, param)
+
+    elif eq_type == HomogeneousTernaryQuadratic.name:
+        return diop_ternary_quadratic(eq, parameterize=True)
+
+    elif eq_type == HomogeneousTernaryQuadraticNormal.name:
+        return diop_ternary_quadratic_normal(eq, parameterize=True)
+
+    elif eq_type == GeneralPythagorean.name:
+        return diop_general_pythagorean(eq, param)
+
+    elif eq_type == Univariate.name:
+        return diop_univariate(eq)
+
+    elif eq_type == GeneralSumOfSquares.name:
+        return diop_general_sum_of_squares(eq, limit=S.Infinity)
+
+    elif eq_type == GeneralSumOfEvenPowers.name:
+        return diop_general_sum_of_even_powers(eq, limit=S.Infinity)
+
+    if eq_type is not None and eq_type not in diop_known:
+            raise ValueError(filldedent('''
+    Although this type of equation was identified, it is not yet
+    handled. It should, however, be listed in `diop_known` at the
+    top of this file. Developers should see comments at the end of
+    `classify_diop`.
+            '''))  # pragma: no cover
+    else:
+        raise NotImplementedError(
+            'No solver has been written for %s.' % eq_type)
+
+
+def classify_diop(eq, _dict=True):
+    # docstring supplied externally
+
+    matched = False
+    diop_type = None
+    for diop_class in all_diop_classes:
+        diop_type = diop_class(eq)
+        if diop_type.matches():
+            matched = True
+            break
+
+    if matched:
+        return diop_type.free_symbols, dict(diop_type.coeff) if _dict else diop_type.coeff, diop_type.name
+
+    # new diop type instructions
+    # --------------------------
+    # if this error raises and the equation *can* be classified,
+    #  * it should be identified in the if-block above
+    #  * the type should be added to the diop_known
+    # if a solver can be written for it,
+    #  * a dedicated handler should be written (e.g. diop_linear)
+    #  * it should be passed to that handler in diop_solve
+    raise NotImplementedError(filldedent('''
+        This equation is not yet recognized or else has not been
+        simplified sufficiently to put it in a form recognized by
+        diop_classify().'''))
+
+
+classify_diop.func_doc = (  # type: ignore
+    '''
+    Helper routine used by diop_solve() to find information about ``eq``.
+
+    Explanation
+    ===========
+
+    Returns a tuple containing the type of the diophantine equation
+    along with the variables (free symbols) and their coefficients.
+    Variables are returned as a list and coefficients are returned
+    as a dict with the key being the respective term and the constant
+    term is keyed to 1. The type is one of the following:
+
+    * %s
+
+    Usage
+    =====
+
+    ``classify_diop(eq)``: Return variables, coefficients and type of the
+    ``eq``.
+
+    Details
+    =======
+
+    ``eq`` should be an expression which is assumed to be zero.
+    ``_dict`` is for internal use: when True (default) a dict is returned,
+    otherwise a defaultdict which supplies 0 for missing keys is returned.
+
+    Examples
+    ========
+
+    >>> from sympy.solvers.diophantine import classify_diop
+    >>> from sympy.abc import x, y, z, w, t
+    >>> classify_diop(4*x + 6*y - 4)
+    ([x, y], {1: -4, x: 4, y: 6}, 'linear')
+    >>> classify_diop(x + 3*y -4*z + 5)
+    ([x, y, z], {1: 5, x: 1, y: 3, z: -4}, 'linear')
+    >>> classify_diop(x**2 + y**2 - x*y + x + 5)
+    ([x, y], {1: 5, x: 1, x**2: 1, y**2: 1, x*y: -1}, 'binary_quadratic')
+    ''' % ('\n    * '.join(sorted(diop_known))))
+
+
+def diop_linear(eq, param=symbols("t", integer=True)):
+    """
+    Solves linear diophantine equations.
+
+    A linear diophantine equation is an equation of the form `a_{1}x_{1} +
+    a_{2}x_{2} + .. + a_{n}x_{n} = 0` where `a_{1}, a_{2}, ..a_{n}` are
+    integer constants and `x_{1}, x_{2}, ..x_{n}` are integer variables.
+
+    Usage
+    =====
+
+    ``diop_linear(eq)``: Returns a tuple containing solutions to the
+    diophantine equation ``eq``. Values in the tuple is arranged in the same
+    order as the sorted variables.
+
+    Details
+    =======
+
+    ``eq`` is a linear diophantine equation which is assumed to be zero.
+    ``param`` is the parameter to be used in the solution.
+
+    Examples
+    ========
+
+    >>> from sympy.solvers.diophantine.diophantine import diop_linear
+    >>> from sympy.abc import x, y, z
+    >>> diop_linear(2*x - 3*y - 5) # solves equation 2*x - 3*y - 5 == 0
+    (3*t_0 - 5, 2*t_0 - 5)
+
+    Here x = -3*t_0 - 5 and y = -2*t_0 - 5
+
+    >>> diop_linear(2*x - 3*y - 4*z -3)
+    (t_0, 2*t_0 + 4*t_1 + 3, -t_0 - 3*t_1 - 3)
+
+    See Also
+    ========
+
+    diop_quadratic(), diop_ternary_quadratic(), diop_general_pythagorean(),
+    diop_general_sum_of_squares()
+    """
+    var, coeff, diop_type = classify_diop(eq, _dict=False)
+
+    if diop_type == Linear.name:
+        parameters = None
+        if param is not None:
+            parameters = symbols('%s_0:%i' % (param, len(var)), integer=True)
+
+        result = Linear(eq).solve(parameters=parameters)
+
+        if param is None:
+            result = result(*[0]*len(result.parameters))
+
+        if len(result) > 0:
+            return list(result)[0]
+        else:
+            return tuple([None]*len(result.parameters))
+
+
+def base_solution_linear(c, a, b, t=None):
+    """
+    Return the base solution for the linear equation, `ax + by = c`.
+
+    Explanation
+    ===========
+
+    Used by ``diop_linear()`` to find the base solution of a linear
+    Diophantine equation. If ``t`` is given then the parametrized solution is
+    returned.
+
+    Usage
+    =====
+
+    ``base_solution_linear(c, a, b, t)``: ``a``, ``b``, ``c`` are coefficients
+    in `ax + by = c` and ``t`` is the parameter to be used in the solution.
+
+    Examples
+    ========
+
+    >>> from sympy.solvers.diophantine.diophantine import base_solution_linear
+    >>> from sympy.abc import t
+    >>> base_solution_linear(5, 2, 3) # equation 2*x + 3*y = 5
+    (-5, 5)
+    >>> base_solution_linear(0, 5, 7) # equation 5*x + 7*y = 0
+    (0, 0)
+    >>> base_solution_linear(5, 2, 3, t) # equation 2*x + 3*y = 5
+    (3*t - 5, 5 - 2*t)
+    >>> base_solution_linear(0, 5, 7, t) # equation 5*x + 7*y = 0
+    (7*t, -5*t)
+    """
+    a, b, c = _remove_gcd(a, b, c)
+
+    if c == 0:
+        if t is None:
+            return (0, 0)
+        if b < 0:
+            t = -t
+        return (b*t, -a*t)
+
+    x0, y0, d = igcdex(abs(a), abs(b))
+    x0 *= sign(a)
+    y0 *= sign(b)
+    if c % d:
+        return (None, None)
+    if t is None:
+        return (c*x0, c*y0)
+    if b < 0:
+        t = -t
+    return (c*x0 + b*t, c*y0 - a*t)
+
+
+def diop_univariate(eq):
+    """
+    Solves a univariate diophantine equations.
+
+    Explanation
+    ===========
+
+    A univariate diophantine equation is an equation of the form
+    `a_{0} + a_{1}x + a_{2}x^2 + .. + a_{n}x^n = 0` where `a_{1}, a_{2}, ..a_{n}` are
+    integer constants and `x` is an integer variable.
+
+    Usage
+    =====
+
+    ``diop_univariate(eq)``: Returns a set containing solutions to the
+    diophantine equation ``eq``.
+
+    Details
+    =======
+
+    ``eq`` is a univariate diophantine equation which is assumed to be zero.
+
+    Examples
+    ========
+
+    >>> from sympy.solvers.diophantine.diophantine import diop_univariate
+    >>> from sympy.abc import x
+    >>> diop_univariate((x - 2)*(x - 3)**2) # solves equation (x - 2)*(x - 3)**2 == 0
+    {(2,), (3,)}
+
+    """
+    var, coeff, diop_type = classify_diop(eq, _dict=False)
+
+    if diop_type == Univariate.name:
+        return {(int(i),) for i in solveset_real(
+            eq, var[0]).intersect(S.Integers)}
+
+
+def divisible(a, b):
+    """
+    Returns `True` if ``a`` is divisible by ``b`` and `False` otherwise.
+    """
+    return not a % b
+
+
+def diop_quadratic(eq, param=symbols("t", integer=True)):
+    """
+    Solves quadratic diophantine equations.
+
+    i.e. equations of the form `Ax^2 + Bxy + Cy^2 + Dx + Ey + F = 0`. Returns a
+    set containing the tuples `(x, y)` which contains the solutions. If there
+    are no solutions then `(None, None)` is returned.
+
+    Usage
+    =====
+
+    ``diop_quadratic(eq, param)``: ``eq`` is a quadratic binary diophantine
+    equation. ``param`` is used to indicate the parameter to be used in the
+    solution.
+
+    Details
+    =======
+
+    ``eq`` should be an expression which is assumed to be zero.
+    ``param`` is a parameter to be used in the solution.
+
+    Examples
+    ========
+
+    >>> from sympy.abc import x, y, t
+    >>> from sympy.solvers.diophantine.diophantine import diop_quadratic
+    >>> diop_quadratic(x**2 + y**2 + 2*x + 2*y + 2, t)
+    {(-1, -1)}
+
+    References
+    ==========
+
+    .. [1] Methods to solve Ax^2 + Bxy + Cy^2 + Dx + Ey + F = 0, [online],
+          Available: https://www.alpertron.com.ar/METHODS.HTM
+    .. [2] Solving the equation ax^2+ bxy + cy^2 + dx + ey + f= 0, [online],
+          Available: https://web.archive.org/web/20160323033111/http://www.jpr2718.org/ax2p.pdf
+
+    See Also
+    ========
+
+    diop_linear(), diop_ternary_quadratic(), diop_general_sum_of_squares(),
+    diop_general_pythagorean()
+    """
+    var, coeff, diop_type = classify_diop(eq, _dict=False)
+
+    if diop_type == BinaryQuadratic.name:
+        if param is not None:
+            parameters = [param, Symbol("u", integer=True)]
+        else:
+            parameters = None
+        return set(BinaryQuadratic(eq).solve(parameters=parameters))
+
+
+def is_solution_quad(var, coeff, u, v):
+    """
+    Check whether `(u, v)` is solution to the quadratic binary diophantine
+    equation with the variable list ``var`` and coefficient dictionary
+    ``coeff``.
+
+    Not intended for use by normal users.
+    """
+    reps = dict(zip(var, (u, v)))
+    eq = Add(*[j*i.xreplace(reps) for i, j in coeff.items()])
+    return _mexpand(eq) == 0
+
+
+def diop_DN(D, N, t=symbols("t", integer=True)):
+    """
+    Solves the equation `x^2 - Dy^2 = N`.
+
+    Explanation
+    ===========
+
+    Mainly concerned with the case `D > 0, D` is not a perfect square,
+    which is the same as the generalized Pell equation. The LMM
+    algorithm [1]_ is used to solve this equation.
+
+    Returns one solution tuple, (`x, y)` for each class of the solutions.
+    Other solutions of the class can be constructed according to the
+    values of ``D`` and ``N``.
+
+    Usage
+    =====
+
+    ``diop_DN(D, N, t)``: D and N are integers as in `x^2 - Dy^2 = N` and
+    ``t`` is the parameter to be used in the solutions.
+
+    Details
+    =======
+
+    ``D`` and ``N`` correspond to D and N in the equation.
+    ``t`` is the parameter to be used in the solutions.
+
+    Examples
+    ========
+
+    >>> from sympy.solvers.diophantine.diophantine import diop_DN
+    >>> diop_DN(13, -4) # Solves equation x**2 - 13*y**2 = -4
+    [(3, 1), (393, 109), (36, 10)]
+
+    The output can be interpreted as follows: There are three fundamental
+    solutions to the equation `x^2 - 13y^2 = -4` given by (3, 1), (393, 109)
+    and (36, 10). Each tuple is in the form (x, y), i.e. solution (3, 1) means
+    that `x = 3` and `y = 1`.
+
+    >>> diop_DN(986, 1) # Solves equation x**2 - 986*y**2 = 1
+    [(49299, 1570)]
+
+    See Also
+    ========
+
+    find_DN(), diop_bf_DN()
+
+    References
+    ==========
+
+    .. [1] Solving the generalized Pell equation x**2 - D*y**2 = N, John P.
+        Robertson, July 31, 2004, Pages 16 - 17. [online], Available:
+        https://web.archive.org/web/20160323033128/http://www.jpr2718.org/pell.pdf
+    """
+    if D < 0:
+        if N == 0:
+            return [(0, 0)]
+        if N < 0:
+            return []
+        # N > 0:
+        sol = []
+        for d in divisors(square_factor(N), generator=True):
+            for x, y in cornacchia(1, int(-D), int(N // d**2)):
+                sol.append((d*x, d*y))
+                if D == -1:
+                    sol.append((d*y, d*x))
+        return sol
+
+    if D == 0:
+        if N < 0:
+            return []
+        if N == 0:
+            return [(0, t)]
+        sN, _exact = integer_nthroot(N, 2)
+        if _exact:
+            return [(sN, t)]
+        return []
+
+    # D > 0
+    sD, _exact = integer_nthroot(D, 2)
+    if _exact:
+        if N == 0:
+            return [(sD*t, t)]
+
+        sol = []
+        for y in range(floor(sign(N)*(N - 1)/(2*sD)) + 1):
+            try:
+                sq, _exact = integer_nthroot(D*y**2 + N, 2)
+            except ValueError:
+                _exact = False
+            if _exact:
+                sol.append((sq, y))
+        return sol
+
+    if 1 < N**2 < D:
+        # It is much faster to call `_special_diop_DN`.
+        return _special_diop_DN(D, N)
+
+    if N == 0:
+        return [(0, 0)]
+
+    sol = []
+    if abs(N) == 1:
+        pqa = PQa(0, 1, D)
+        *_, prev_B, prev_G = next(pqa)
+        for j, (*_, a, _, _B, _G) in enumerate(pqa):
+            if a == 2*sD:
+                break
+            prev_B, prev_G = _B, _G
+        if j % 2:
+            if N == 1:
+                sol.append((prev_G, prev_B))
+            return sol
+        if N == -1:
+            return [(prev_G, prev_B)]
+        for _ in range(j):
+            *_, _B, _G = next(pqa)
+        return [(_G, _B)]
+
+    for f in divisors(square_factor(N), generator=True):
+        m = N // f**2
+        am = abs(m)
+        for sqm in sqrt_mod(D, am, all_roots=True):
+            z = symmetric_residue(sqm, am)
+            pqa = PQa(z, am, D)
+            *_, prev_B, prev_G = next(pqa)
+            for _ in range(length(z, am, D) - 1):
+                _, q, *_, _B, _G = next(pqa)
+                if abs(q) == 1:
+                    if prev_G**2 - D*prev_B**2 == m:
+                        sol.append((f*prev_G, f*prev_B))
+                    elif a := diop_DN(D, -1):
+                        sol.append((f*(prev_G*a[0][0] + prev_B*D*a[0][1]),
+                                    f*(prev_G*a[0][1] + prev_B*a[0][0])))
+                    break
+                prev_B, prev_G = _B, _G
+    return sol
+
+
+def _special_diop_DN(D, N):
+    """
+    Solves the equation `x^2 - Dy^2 = N` for the special case where
+    `1 < N**2 < D` and `D` is not a perfect square.
+    It is better to call `diop_DN` rather than this function, as
+    the former checks the condition `1 < N**2 < D`, and calls the latter only
+    if appropriate.
+
+    Usage
+    =====
+
+    WARNING: Internal method. Do not call directly!
+
+    ``_special_diop_DN(D, N)``: D and N are integers as in `x^2 - Dy^2 = N`.
+
+    Details
+    =======
+
+    ``D`` and ``N`` correspond to D and N in the equation.
+
+    Examples
+    ========
+
+    >>> from sympy.solvers.diophantine.diophantine import _special_diop_DN
+    >>> _special_diop_DN(13, -3) # Solves equation x**2 - 13*y**2 = -3
+    [(7, 2), (137, 38)]
+
+    The output can be interpreted as follows: There are two fundamental
+    solutions to the equation `x^2 - 13y^2 = -3` given by (7, 2) and
+    (137, 38). Each tuple is in the form (x, y), i.e. solution (7, 2) means
+    that `x = 7` and `y = 2`.
+
+    >>> _special_diop_DN(2445, -20) # Solves equation x**2 - 2445*y**2 = -20
+    [(445, 9), (17625560, 356454), (698095554475, 14118073569)]
+
+    See Also
+    ========
+
+    diop_DN()
+
+    References
+    ==========
+
+    .. [1] Section 4.4.4 of the following book:
+        Quadratic Diophantine Equations, T. Andreescu and D. Andrica,
+        Springer, 2015.
+    """
+
+    # The following assertion was removed for efficiency, with the understanding
+    #     that this method is not called directly. The parent method, `diop_DN`
+    #     is responsible for performing the appropriate checks.
+    #
+    # assert (1 < N**2 < D) and (not integer_nthroot(D, 2)[1])
+
+    sqrt_D = isqrt(D)
+    F = {N // f**2: f for f in divisors(square_factor(abs(N)), generator=True)}
+    P = 0
+    Q = 1
+    G0, G1 = 0, 1
+    B0, B1 = 1, 0
+
+    solutions = []
+    while True:
+        for _ in range(2):
+            a = (P + sqrt_D) // Q
+            P = a*Q - P
+            Q = (D - P**2) // Q
+            G0, G1 = G1, a*G1 + G0
+            B0, B1 = B1, a*B1 + B0
+            if (s := G1**2 - D*B1**2) in F:
+                f = F[s]
+                solutions.append((f*G1, f*B1))
+        if Q == 1:
+            break
+    return solutions
+
+
+def cornacchia(a:int, b:int, m:int) -> set[tuple[int, int]]:
+    r"""
+    Solves `ax^2 + by^2 = m` where `\gcd(a, b) = 1 = gcd(a, m)` and `a, b > 0`.
+
+    Explanation
+    ===========
+
+    Uses the algorithm due to Cornacchia. The method only finds primitive
+    solutions, i.e. ones with `\gcd(x, y) = 1`. So this method cannot be used to
+    find the solutions of `x^2 + y^2 = 20` since the only solution to former is
+    `(x, y) = (4, 2)` and it is not primitive. When `a = b`, only the
+    solutions with `x \leq y` are found. For more details, see the References.
+
+    Examples
+    ========
+
+    >>> from sympy.solvers.diophantine.diophantine import cornacchia
+    >>> cornacchia(2, 3, 35) # equation 2x**2 + 3y**2 = 35
+    {(2, 3), (4, 1)}
+    >>> cornacchia(1, 1, 25) # equation x**2 + y**2 = 25
+    {(4, 3)}
+
+    References
+    ===========
+
+    .. [1] A. Nitaj, "L'algorithme de Cornacchia"
+    .. [2] Solving the diophantine equation ax**2 + by**2 = m by Cornacchia's
+        method, [online], Available:
+        http://www.numbertheory.org/php/cornacchia.html
+
+    See Also
+    ========
+
+    sympy.utilities.iterables.signed_permutations
+    """
+    # Assume gcd(a, b) = gcd(a, m) = 1 and a, b > 0 but no error checking
+    sols = set()
+
+    if a + b > m:
+        # xy = 0 must hold if there exists a solution
+        if a == 1:
+            # y = 0
+            s, _exact = iroot(m // a, 2)
+            if _exact:
+                sols.add((int(s), 0))
+            if a == b:
+                # only keep one solution
+                return sols
+        if m % b == 0:
+            # x = 0
+            s, _exact = iroot(m // b, 2)
+            if _exact:
+                sols.add((0, int(s)))
+        return sols
+
+    # the original cornacchia
+    for t in sqrt_mod_iter(-b*invert(a, m), m):
+        if t < m // 2:
+            continue
+        u, r = m, t
+        while (m1 := m - a*r**2) <= 0:
+            u, r = r, u % r
+        m1, _r = divmod(m1, b)
+        if _r:
+            continue
+        s, _exact = iroot(m1, 2)
+        if _exact:
+            if a == b and r < s:
+                r, s = s, r
+            sols.add((int(r), int(s)))
+    return sols
+
+
+def PQa(P_0, Q_0, D):
+    r"""
+    Returns useful information needed to solve the Pell equation.
+
+    Explanation
+    ===========
+
+    There are six sequences of integers defined related to the continued
+    fraction representation of `\\frac{P + \sqrt{D}}{Q}`, namely {`P_{i}`},
+    {`Q_{i}`}, {`a_{i}`},{`A_{i}`}, {`B_{i}`}, {`G_{i}`}. ``PQa()`` Returns
+    these values as a 6-tuple in the same order as mentioned above. Refer [1]_
+    for more detailed information.
+
+    Usage
+    =====
+
+    ``PQa(P_0, Q_0, D)``: ``P_0``, ``Q_0`` and ``D`` are integers corresponding
+    to `P_{0}`, `Q_{0}` and `D` in the continued fraction
+    `\\frac{P_{0} + \sqrt{D}}{Q_{0}}`.
+    Also it's assumed that `P_{0}^2 == D mod(|Q_{0}|)` and `D` is square free.
+
+    Examples
+    ========
+
+    >>> from sympy.solvers.diophantine.diophantine import PQa
+    >>> pqa = PQa(13, 4, 5) # (13 + sqrt(5))/4
+    >>> next(pqa) # (P_0, Q_0, a_0, A_0, B_0, G_0)
+    (13, 4, 3, 3, 1, -1)
+    >>> next(pqa) # (P_1, Q_1, a_1, A_1, B_1, G_1)
+    (-1, 1, 1, 4, 1, 3)
+
+    References
+    ==========
+
+    .. [1] Solving the generalized Pell equation x^2 - Dy^2 = N, John P.
+        Robertson, July 31, 2004, Pages 4 - 8. https://web.archive.org/web/20160323033128/http://www.jpr2718.org/pell.pdf
+    """
+    sqD = isqrt(D)
+    A2 = B1 = 0
+    A1 = B2 = 1
+    G1 = Q_0
+    G2 = -P_0
+    P_i = P_0
+    Q_i = Q_0
+
+    while True:
+        a_i = (P_i + sqD) // Q_i
+        A1, A2 = a_i*A1 + A2, A1
+        B1, B2 = a_i*B1 + B2, B1
+        G1, G2 = a_i*G1 + G2, G1
+        yield P_i, Q_i, a_i, A1, B1, G1
+
+        P_i = a_i*Q_i - P_i
+        Q_i = (D - P_i**2) // Q_i
+
+
+def diop_bf_DN(D, N, t=symbols("t", integer=True)):
+    r"""
+    Uses brute force to solve the equation, `x^2 - Dy^2 = N`.
+
+    Explanation
+    ===========
+
+    Mainly concerned with the generalized Pell equation which is the case when
+    `D > 0, D` is not a perfect square. For more information on the case refer
+    [1]_. Let `(t, u)` be the minimal positive solution of the equation
+    `x^2 - Dy^2 = 1`. Then this method requires
+    `\sqrt{\\frac{\mid N \mid (t \pm 1)}{2D}}` to be small.
+
+    Usage
+    =====
+
+    ``diop_bf_DN(D, N, t)``: ``D`` and ``N`` are coefficients in
+    `x^2 - Dy^2 = N` and ``t`` is the parameter to be used in the solutions.
+
+    Details
+    =======
+
+    ``D`` and ``N`` correspond to D and N in the equation.
+    ``t`` is the parameter to be used in the solutions.
+
+    Examples
+    ========
+
+    >>> from sympy.solvers.diophantine.diophantine import diop_bf_DN
+    >>> diop_bf_DN(13, -4)
+    [(3, 1), (-3, 1), (36, 10)]
+    >>> diop_bf_DN(986, 1)
+    [(49299, 1570)]
+
+    See Also
+    ========
+
+    diop_DN()
+
+    References
+    ==========
+
+    .. [1] Solving the generalized Pell equation x**2 - D*y**2 = N, John P.
+        Robertson, July 31, 2004, Page 15. https://web.archive.org/web/20160323033128/http://www.jpr2718.org/pell.pdf
+    """
+    D = as_int(D)
+    N = as_int(N)
+
+    sol = []
+    a = diop_DN(D, 1)
+    u = a[0][0]
+
+    if N == 0:
+        if D < 0:
+            return [(0, 0)]
+        if D == 0:
+            return [(0, t)]
+        sD, _exact = integer_nthroot(D, 2)
+        if _exact:
+            return [(sD*t, t), (-sD*t, t)]
+        return [(0, 0)]
+
+    if abs(N) == 1:
+        return diop_DN(D, N)
+
+    if N > 1:
+        L1 = 0
+        L2 = integer_nthroot(int(N*(u - 1)/(2*D)), 2)[0] + 1
+    else: # N < -1
+        L1, _exact = integer_nthroot(-int(N/D), 2)
+        if not _exact:
+            L1 += 1
+        L2 = integer_nthroot(-int(N*(u + 1)/(2*D)), 2)[0] + 1
+
+    for y in range(L1, L2):
+        try:
+            x, _exact = integer_nthroot(N + D*y**2, 2)
+        except ValueError:
+            _exact = False
+        if _exact:
+            sol.append((x, y))
+            if not equivalent(x, y, -x, y, D, N):
+                sol.append((-x, y))
+
+    return sol
+
+
+def equivalent(u, v, r, s, D, N):
+    """
+    Returns True if two solutions `(u, v)` and `(r, s)` of `x^2 - Dy^2 = N`
+    belongs to the same equivalence class and False otherwise.
+
+    Explanation
+    ===========
+
+    Two solutions `(u, v)` and `(r, s)` to the above equation fall to the same
+    equivalence class iff both `(ur - Dvs)` and `(us - vr)` are divisible by
+    `N`. See reference [1]_. No test is performed to test whether `(u, v)` and
+    `(r, s)` are actually solutions to the equation. User should take care of
+    this.
+
+    Usage
+    =====
+
+    ``equivalent(u, v, r, s, D, N)``: `(u, v)` and `(r, s)` are two solutions
+    of the equation `x^2 - Dy^2 = N` and all parameters involved are integers.
+
+    Examples
+    ========
+
+    >>> from sympy.solvers.diophantine.diophantine import equivalent
+    >>> equivalent(18, 5, -18, -5, 13, -1)
+    True
+    >>> equivalent(3, 1, -18, 393, 109, -4)
+    False
+
+    References
+    ==========
+
+    .. [1] Solving the generalized Pell equation x**2 - D*y**2 = N, John P.
+        Robertson, July 31, 2004, Page 12. https://web.archive.org/web/20160323033128/http://www.jpr2718.org/pell.pdf
+
+    """
+    return divisible(u*r - D*v*s, N) and divisible(u*s - v*r, N)
+
+
+def length(P, Q, D):
+    r"""
+    Returns the (length of aperiodic part + length of periodic part) of
+    continued fraction representation of `\\frac{P + \sqrt{D}}{Q}`.
+
+    It is important to remember that this does NOT return the length of the
+    periodic part but the sum of the lengths of the two parts as mentioned
+    above.
+
+    Usage
+    =====
+
+    ``length(P, Q, D)``: ``P``, ``Q`` and ``D`` are integers corresponding to
+    the continued fraction `\\frac{P + \sqrt{D}}{Q}`.
+
+    Details
+    =======
+
+    ``P``, ``D`` and ``Q`` corresponds to P, D and Q in the continued fraction,
+    `\\frac{P + \sqrt{D}}{Q}`.
+
+    Examples
+    ========
+
+    >>> from sympy.solvers.diophantine.diophantine import length
+    >>> length(-2, 4, 5) # (-2 + sqrt(5))/4
+    3
+    >>> length(-5, 4, 17) # (-5 + sqrt(17))/4
+    4
+
+    See Also
+    ========
+    sympy.ntheory.continued_fraction.continued_fraction_periodic
+    """
+    from sympy.ntheory.continued_fraction import continued_fraction_periodic
+    v = continued_fraction_periodic(P, Q, D)
+    if isinstance(v[-1], list):
+        rpt = len(v[-1])
+        nonrpt = len(v) - 1
+    else:
+        rpt = 0
+        nonrpt = len(v)
+    return rpt + nonrpt
+
+
+def transformation_to_DN(eq):
+    """
+    This function transforms general quadratic,
+    `ax^2 + bxy + cy^2 + dx + ey + f = 0`
+    to more easy to deal with `X^2 - DY^2 = N` form.
+
+    Explanation
+    ===========
+
+    This is used to solve the general quadratic equation by transforming it to
+    the latter form. Refer to [1]_ for more detailed information on the
+    transformation. This function returns a tuple (A, B) where A is a 2 X 2
+    matrix and B is a 2 X 1 matrix such that,
+
+    Transpose([x y]) =  A * Transpose([X Y]) + B
+
+    Usage
+    =====
+
+    ``transformation_to_DN(eq)``: where ``eq`` is the quadratic to be
+    transformed.
+
+    Examples
+    ========
+
+    >>> from sympy.abc import x, y
+    >>> from sympy.solvers.diophantine.diophantine import transformation_to_DN
+    >>> A, B = transformation_to_DN(x**2 - 3*x*y - y**2 - 2*y + 1)
+    >>> A
+    Matrix([
+    [1/26, 3/26],
+    [   0, 1/13]])
+    >>> B
+    Matrix([
+    [-6/13],
+    [-4/13]])
+
+    A, B  returned are such that Transpose((x y)) =  A * Transpose((X Y)) + B.
+    Substituting these values for `x` and `y` and a bit of simplifying work
+    will give an equation of the form `x^2 - Dy^2 = N`.
+
+    >>> from sympy.abc import X, Y
+    >>> from sympy import Matrix, simplify
+    >>> u = (A*Matrix([X, Y]) + B)[0] # Transformation for x
+    >>> u
+    X/26 + 3*Y/26 - 6/13
+    >>> v = (A*Matrix([X, Y]) + B)[1] # Transformation for y
+    >>> v
+    Y/13 - 4/13
+
+    Next we will substitute these formulas for `x` and `y` and do
+    ``simplify()``.
+
+    >>> eq = simplify((x**2 - 3*x*y - y**2 - 2*y + 1).subs(zip((x, y), (u, v))))
+    >>> eq
+    X**2/676 - Y**2/52 + 17/13
+
+    By multiplying the denominator appropriately, we can get a Pell equation
+    in the standard form.
+
+    >>> eq * 676
+    X**2 - 13*Y**2 + 884
+
+    If only the final equation is needed, ``find_DN()`` can be used.
+
+    See Also
+    ========
+
+    find_DN()
+
+    References
+    ==========
+
+    .. [1] Solving the equation ax^2 + bxy + cy^2 + dx + ey + f = 0,
+           John P.Robertson, May 8, 2003, Page 7 - 11.
+           https://web.archive.org/web/20160323033111/http://www.jpr2718.org/ax2p.pdf
+    """
+
+    var, coeff, diop_type = classify_diop(eq, _dict=False)
+    if diop_type == BinaryQuadratic.name:
+        return _transformation_to_DN(var, coeff)
+
+
+def _transformation_to_DN(var, coeff):
+
+    x, y = var
+
+    a = coeff[x**2]
+    b = coeff[x*y]
+    c = coeff[y**2]
+    d = coeff[x]
+    e = coeff[y]
+    f = coeff[1]
+
+    a, b, c, d, e, f = [as_int(i) for i in _remove_gcd(a, b, c, d, e, f)]
+
+    X, Y = symbols("X, Y", integer=True)
+
+    if b:
+        B, C = _rational_pq(2*a, b)
+        A, T = _rational_pq(a, B**2)
+
+        # eq_1 = A*B*X**2 + B*(c*T - A*C**2)*Y**2 + d*T*X + (B*e*T - d*T*C)*Y + f*T*B
+        coeff = {X**2: A*B, X*Y: 0, Y**2: B*(c*T - A*C**2), X: d*T, Y: B*e*T - d*T*C, 1: f*T*B}
+        A_0, B_0 = _transformation_to_DN([X, Y], coeff)
+        return Matrix(2, 2, [S.One/B, -S(C)/B, 0, 1])*A_0, Matrix(2, 2, [S.One/B, -S(C)/B, 0, 1])*B_0
+
+    if d:
+        B, C = _rational_pq(2*a, d)
+        A, T = _rational_pq(a, B**2)
+
+        # eq_2 = A*X**2 + c*T*Y**2 + e*T*Y + f*T - A*C**2
+        coeff = {X**2: A, X*Y: 0, Y**2: c*T, X: 0, Y: e*T, 1: f*T - A*C**2}
+        A_0, B_0 = _transformation_to_DN([X, Y], coeff)
+        return Matrix(2, 2, [S.One/B, 0, 0, 1])*A_0, Matrix(2, 2, [S.One/B, 0, 0, 1])*B_0 + Matrix([-S(C)/B, 0])
+
+    if e:
+        B, C = _rational_pq(2*c, e)
+        A, T = _rational_pq(c, B**2)
+
+        # eq_3 = a*T*X**2 + A*Y**2 + f*T - A*C**2
+        coeff = {X**2: a*T, X*Y: 0, Y**2: A, X: 0, Y: 0, 1: f*T - A*C**2}
+        A_0, B_0 = _transformation_to_DN([X, Y], coeff)
+        return Matrix(2, 2, [1, 0, 0, S.One/B])*A_0, Matrix(2, 2, [1, 0, 0, S.One/B])*B_0 + Matrix([0, -S(C)/B])
+
+    # TODO: pre-simplification: Not necessary but may simplify
+    # the equation.
+    return Matrix(2, 2, [S.One/a, 0, 0, 1]), Matrix([0, 0])
+
+
+def find_DN(eq):
+    """
+    This function returns a tuple, `(D, N)` of the simplified form,
+    `x^2 - Dy^2 = N`, corresponding to the general quadratic,
+    `ax^2 + bxy + cy^2 + dx + ey + f = 0`.
+
+    Solving the general quadratic is then equivalent to solving the equation
+    `X^2 - DY^2 = N` and transforming the solutions by using the transformation
+    matrices returned by ``transformation_to_DN()``.
+
+    Usage
+    =====
+
+    ``find_DN(eq)``: where ``eq`` is the quadratic to be transformed.
+
+    Examples
+    ========
+
+    >>> from sympy.abc import x, y
+    >>> from sympy.solvers.diophantine.diophantine import find_DN
+    >>> find_DN(x**2 - 3*x*y - y**2 - 2*y + 1)
+    (13, -884)
+
+    Interpretation of the output is that we get `X^2 -13Y^2 = -884` after
+    transforming `x^2 - 3xy - y^2 - 2y + 1` using the transformation returned
+    by ``transformation_to_DN()``.
+
+    See Also
+    ========
+
+    transformation_to_DN()
+
+    References
+    ==========
+
+    .. [1] Solving the equation ax^2 + bxy + cy^2 + dx + ey + f = 0,
+           John P.Robertson, May 8, 2003, Page 7 - 11.
+           https://web.archive.org/web/20160323033111/http://www.jpr2718.org/ax2p.pdf
+    """
+    var, coeff, diop_type = classify_diop(eq, _dict=False)
+    if diop_type == BinaryQuadratic.name:
+        return _find_DN(var, coeff)
+
+
+def _find_DN(var, coeff):
+
+    x, y = var
+    X, Y = symbols("X, Y", integer=True)
+    A, B = _transformation_to_DN(var, coeff)
+
+    u = (A*Matrix([X, Y]) + B)[0]
+    v = (A*Matrix([X, Y]) + B)[1]
+    eq = x**2*coeff[x**2] + x*y*coeff[x*y] + y**2*coeff[y**2] + x*coeff[x] + y*coeff[y] + coeff[1]
+
+    simplified = _mexpand(eq.subs(zip((x, y), (u, v))))
+
+    coeff = simplified.as_coefficients_dict()
+
+    return -coeff[Y**2]/coeff[X**2], -coeff[1]/coeff[X**2]
+
+
+def check_param(x, y, a, params):
+    """
+    If there is a number modulo ``a`` such that ``x`` and ``y`` are both
+    integers, then return a parametric representation for ``x`` and ``y``
+    else return (None, None).
+
+    Here ``x`` and ``y`` are functions of ``t``.
+    """
+    from sympy.simplify.simplify import clear_coefficients
+
+    if x.is_number and not x.is_Integer:
+        return DiophantineSolutionSet([x, y], parameters=params)
+
+    if y.is_number and not y.is_Integer:
+        return DiophantineSolutionSet([x, y], parameters=params)
+
+    m, n = symbols("m, n", integer=True)
+    c, p = (m*x + n*y).as_content_primitive()
+    if a % c.q:
+        return DiophantineSolutionSet([x, y], parameters=params)
+
+    # clear_coefficients(mx + b, R)[1] -> (R - b)/m
+    eq = clear_coefficients(x, m)[1] - clear_coefficients(y, n)[1]
+    junk, eq = eq.as_content_primitive()
+
+    return _diop_solve(eq, params=params)
+
+
+def diop_ternary_quadratic(eq, parameterize=False):
+    """
+    Solves the general quadratic ternary form,
+    `ax^2 + by^2 + cz^2 + fxy + gyz + hxz = 0`.
+
+    Returns a tuple `(x, y, z)` which is a base solution for the above
+    equation. If there are no solutions, `(None, None, None)` is returned.
+
+    Usage
+    =====
+
+    ``diop_ternary_quadratic(eq)``: Return a tuple containing a basic solution
+    to ``eq``.
+
+    Details
+    =======
+
+    ``eq`` should be an homogeneous expression of degree two in three variables
+    and it is assumed to be zero.
+
+    Examples
+    ========
+
+    >>> from sympy.abc import x, y, z
+    >>> from sympy.solvers.diophantine.diophantine import diop_ternary_quadratic
+    >>> diop_ternary_quadratic(x**2 + 3*y**2 - z**2)
+    (1, 0, 1)
+    >>> diop_ternary_quadratic(4*x**2 + 5*y**2 - z**2)
+    (1, 0, 2)
+    >>> diop_ternary_quadratic(45*x**2 - 7*y**2 - 8*x*y - z**2)
+    (28, 45, 105)
+    >>> diop_ternary_quadratic(x**2 - 49*y**2 - z**2 + 13*z*y -8*x*y)
+    (9, 1, 5)
+    """
+    var, coeff, diop_type = classify_diop(eq, _dict=False)
+
+    if diop_type in (
+            HomogeneousTernaryQuadratic.name,
+            HomogeneousTernaryQuadraticNormal.name):
+        sol = _diop_ternary_quadratic(var, coeff)
+        if len(sol) > 0:
+            x_0, y_0, z_0 = list(sol)[0]
+        else:
+            x_0, y_0, z_0 = None, None, None
+
+        if parameterize:
+            return _parametrize_ternary_quadratic(
+                (x_0, y_0, z_0), var, coeff)
+        return x_0, y_0, z_0
+
+
+def _diop_ternary_quadratic(_var, coeff):
+    eq = sum(i*coeff[i] for i in coeff)
+    if HomogeneousTernaryQuadratic(eq).matches():
+        return HomogeneousTernaryQuadratic(eq, free_symbols=_var).solve()
+    elif HomogeneousTernaryQuadraticNormal(eq).matches():
+        return HomogeneousTernaryQuadraticNormal(eq, free_symbols=_var).solve()
+
+
+def transformation_to_normal(eq):
+    """
+    Returns the transformation Matrix that converts a general ternary
+    quadratic equation ``eq`` (`ax^2 + by^2 + cz^2 + dxy + eyz + fxz`)
+    to a form without cross terms: `ax^2 + by^2 + cz^2 = 0`. This is
+    not used in solving ternary quadratics; it is only implemented for
+    the sake of completeness.
+    """
+    var, coeff, diop_type = classify_diop(eq, _dict=False)
+
+    if diop_type in (
+            "homogeneous_ternary_quadratic",
+            "homogeneous_ternary_quadratic_normal"):
+        return _transformation_to_normal(var, coeff)
+
+
+def _transformation_to_normal(var, coeff):
+
+    _var = list(var)  # copy
+    x, y, z = var
+
+    if not any(coeff[i**2] for i in var):
+        # https://math.stackexchange.com/questions/448051/transform-quadratic-ternary-form-to-normal-form/448065#448065
+        a = coeff[x*y]
+        b = coeff[y*z]
+        c = coeff[x*z]
+        swap = False
+        if not a:  # b can't be 0 or else there aren't 3 vars
+            swap = True
+            a, b = b, a
+        T = Matrix(((1, 1, -b/a), (1, -1, -c/a), (0, 0, 1)))
+        if swap:
+            T.row_swap(0, 1)
+            T.col_swap(0, 1)
+        return T
+
+    if coeff[x**2] == 0:
+        # If the coefficient of x is zero change the variables
+        if coeff[y**2] == 0:
+            _var[0], _var[2] = var[2], var[0]
+            T = _transformation_to_normal(_var, coeff)
+            T.row_swap(0, 2)
+            T.col_swap(0, 2)
+            return T
+
+        _var[0], _var[1] = var[1], var[0]
+        T = _transformation_to_normal(_var, coeff)
+        T.row_swap(0, 1)
+        T.col_swap(0, 1)
+        return T
+
+    # Apply the transformation x --> X - (B*Y + C*Z)/(2*A)
+    if coeff[x*y] != 0 or coeff[x*z] != 0:
+        A = coeff[x**2]
+        B = coeff[x*y]
+        C = coeff[x*z]
+        D = coeff[y**2]
+        E = coeff[y*z]
+        F = coeff[z**2]
+
+        _coeff = {}
+
+        _coeff[x**2] = 4*A**2
+        _coeff[y**2] = 4*A*D - B**2
+        _coeff[z**2] = 4*A*F - C**2
+        _coeff[y*z] = 4*A*E - 2*B*C
+        _coeff[x*y] = 0
+        _coeff[x*z] = 0
+
+        T_0 = _transformation_to_normal(_var, _coeff)
+        return Matrix(3, 3, [1, S(-B)/(2*A), S(-C)/(2*A), 0, 1, 0, 0, 0, 1])*T_0
+
+    elif coeff[y*z] != 0:
+        if coeff[y**2] == 0:
+            if coeff[z**2] == 0:
+                # Equations of the form A*x**2 + E*yz = 0.
+                # Apply transformation y -> Y + Z ans z -> Y - Z
+                return Matrix(3, 3, [1, 0, 0, 0, 1, 1, 0, 1, -1])
+
+            # Ax**2 + E*y*z + F*z**2  = 0
+            _var[0], _var[2] = var[2], var[0]
+            T = _transformation_to_normal(_var, coeff)
+            T.row_swap(0, 2)
+            T.col_swap(0, 2)
+            return T
+
+        # A*x**2 + D*y**2 + E*y*z + F*z**2 = 0, F may be zero
+        _var[0], _var[1] = var[1], var[0]
+        T = _transformation_to_normal(_var, coeff)
+        T.row_swap(0, 1)
+        T.col_swap(0, 1)
+        return T
+
+    return Matrix.eye(3)
+
+
+def parametrize_ternary_quadratic(eq):
+    """
+    Returns the parametrized general solution for the ternary quadratic
+    equation ``eq`` which has the form
+    `ax^2 + by^2 + cz^2 + fxy + gyz + hxz = 0`.
+
+    Examples
+    ========
+
+    >>> from sympy import Tuple, ordered
+    >>> from sympy.abc import x, y, z
+    >>> from sympy.solvers.diophantine.diophantine import parametrize_ternary_quadratic
+
+    The parametrized solution may be returned with three parameters:
+
+    >>> parametrize_ternary_quadratic(2*x**2 + y**2 - 2*z**2)
+    (p**2 - 2*q**2, -2*p**2 + 4*p*q - 4*p*r - 4*q**2, p**2 - 4*p*q + 2*q**2 - 4*q*r)
+
+    There might also be only two parameters:
+
+    >>> parametrize_ternary_quadratic(4*x**2 + 2*y**2 - 3*z**2)
+    (2*p**2 - 3*q**2, -4*p**2 + 12*p*q - 6*q**2, 4*p**2 - 8*p*q + 6*q**2)
+
+    Notes
+    =====
+
+    Consider ``p`` and ``q`` in the previous 2-parameter
+    solution and observe that more than one solution can be represented
+    by a given pair of parameters. If `p` and ``q`` are not coprime, this is
+    trivially true since the common factor will also be a common factor of the
+    solution values. But it may also be true even when ``p`` and
+    ``q`` are coprime:
+
+    >>> sol = Tuple(*_)
+    >>> p, q = ordered(sol.free_symbols)
+    >>> sol.subs([(p, 3), (q, 2)])
+    (6, 12, 12)
+    >>> sol.subs([(q, 1), (p, 1)])
+    (-1, 2, 2)
+    >>> sol.subs([(q, 0), (p, 1)])
+    (2, -4, 4)
+    >>> sol.subs([(q, 1), (p, 0)])
+    (-3, -6, 6)
+
+    Except for sign and a common factor, these are equivalent to
+    the solution of (1, 2, 2).
+
+    References
+    ==========
+
+    .. [1] The algorithmic resolution of Diophantine equations, Nigel P. Smart,
+           London Mathematical Society Student Texts 41, Cambridge University
+           Press, Cambridge, 1998.
+
+    """
+    var, coeff, diop_type = classify_diop(eq, _dict=False)
+
+    if diop_type in (
+            "homogeneous_ternary_quadratic",
+            "homogeneous_ternary_quadratic_normal"):
+        x_0, y_0, z_0 = list(_diop_ternary_quadratic(var, coeff))[0]
+        return _parametrize_ternary_quadratic(
+            (x_0, y_0, z_0), var, coeff)
+
+
+def _parametrize_ternary_quadratic(solution, _var, coeff):
+    # called for a*x**2 + b*y**2 + c*z**2 + d*x*y + e*y*z + f*x*z = 0
+    assert 1 not in coeff
+
+    x_0, y_0, z_0 = solution
+
+    v = list(_var)  # copy
+
+    if x_0 is None:
+        return (None, None, None)
+
+    if solution.count(0) >= 2:
+        # if there are 2 zeros the equation reduces
+        # to k*X**2 == 0 where X is x, y, or z so X must
+        # be zero, too. So there is only the trivial
+        # solution.
+        return (None, None, None)
+
+    if x_0 == 0:
+        v[0], v[1] = v[1], v[0]
+        y_p, x_p, z_p = _parametrize_ternary_quadratic(
+            (y_0, x_0, z_0), v, coeff)
+        return x_p, y_p, z_p
+
+    x, y, z = v
+    r, p, q = symbols("r, p, q", integer=True)
+
+    eq = sum(k*v for k, v in coeff.items())
+    eq_1 = _mexpand(eq.subs(zip(
+        (x, y, z), (r*x_0, r*y_0 + p, r*z_0 + q))))
+    A, B = eq_1.as_independent(r, as_Add=True)
+
+
+    x = A*x_0
+    y = (A*y_0 - _mexpand(B/r*p))
+    z = (A*z_0 - _mexpand(B/r*q))
+
+    return _remove_gcd(x, y, z)
+
+
+def diop_ternary_quadratic_normal(eq, parameterize=False):
+    """
+    Solves the quadratic ternary diophantine equation,
+    `ax^2 + by^2 + cz^2 = 0`.
+
+    Explanation
+    ===========
+
+    Here the coefficients `a`, `b`, and `c` should be non zero. Otherwise the
+    equation will be a quadratic binary or univariate equation. If solvable,
+    returns a tuple `(x, y, z)` that satisfies the given equation. If the
+    equation does not have integer solutions, `(None, None, None)` is returned.
+
+    Usage
+    =====
+
+    ``diop_ternary_quadratic_normal(eq)``: where ``eq`` is an equation of the form
+    `ax^2 + by^2 + cz^2 = 0`.
+
+    Examples
+    ========
+
+    >>> from sympy.abc import x, y, z
+    >>> from sympy.solvers.diophantine.diophantine import diop_ternary_quadratic_normal
+    >>> diop_ternary_quadratic_normal(x**2 + 3*y**2 - z**2)
+    (1, 0, 1)
+    >>> diop_ternary_quadratic_normal(4*x**2 + 5*y**2 - z**2)
+    (1, 0, 2)
+    >>> diop_ternary_quadratic_normal(34*x**2 - 3*y**2 - 301*z**2)
+    (4, 9, 1)
+    """
+    var, coeff, diop_type = classify_diop(eq, _dict=False)
+    if diop_type == HomogeneousTernaryQuadraticNormal.name:
+        sol = _diop_ternary_quadratic_normal(var, coeff)
+        if len(sol) > 0:
+            x_0, y_0, z_0 = list(sol)[0]
+        else:
+            x_0, y_0, z_0 = None, None, None
+        if parameterize:
+            return _parametrize_ternary_quadratic(
+                (x_0, y_0, z_0), var, coeff)
+        return x_0, y_0, z_0
+
+
+def _diop_ternary_quadratic_normal(var, coeff):
+    eq = sum(i * coeff[i] for i in coeff)
+    return HomogeneousTernaryQuadraticNormal(eq, free_symbols=var).solve()
+
+
+def sqf_normal(a, b, c, steps=False):
+    """
+    Return `a', b', c'`, the coefficients of the square-free normal
+    form of `ax^2 + by^2 + cz^2 = 0`, where `a', b', c'` are pairwise
+    prime.  If `steps` is True then also return three tuples:
+    `sq`, `sqf`, and `(a', b', c')` where `sq` contains the square
+    factors of `a`, `b` and `c` after removing the `gcd(a, b, c)`;
+    `sqf` contains the values of `a`, `b` and `c` after removing
+    both the `gcd(a, b, c)` and the square factors.
+
+    The solutions for `ax^2 + by^2 + cz^2 = 0` can be
+    recovered from the solutions of `a'x^2 + b'y^2 + c'z^2 = 0`.
+
+    Examples
+    ========
+
+    >>> from sympy.solvers.diophantine.diophantine import sqf_normal
+    >>> sqf_normal(2 * 3**2 * 5, 2 * 5 * 11, 2 * 7**2 * 11)
+    (11, 1, 5)
+    >>> sqf_normal(2 * 3**2 * 5, 2 * 5 * 11, 2 * 7**2 * 11, True)
+    ((3, 1, 7), (5, 55, 11), (11, 1, 5))
+
+    References
+    ==========
+
+    .. [1] Legendre's Theorem, Legrange's Descent,
+           https://public.csusm.edu/aitken_html/notes/legendre.pdf
+
+
+    See Also
+    ========
+
+    reconstruct()
+    """
+    ABC = _remove_gcd(a, b, c)
+    sq = tuple(square_factor(i) for i in ABC)
+    sqf = A, B, C = tuple([i//j**2 for i,j in zip(ABC, sq)])
+    pc = igcd(A, B)
+    A /= pc
+    B /= pc
+    pa = igcd(B, C)
+    B /= pa
+    C /= pa
+    pb = igcd(A, C)
+    A /= pb
+    B /= pb
+
+    A *= pa
+    B *= pb
+    C *= pc
+
+    if steps:
+        return (sq, sqf, (A, B, C))
+    else:
+        return A, B, C
+
+
+def square_factor(a):
+    r"""
+    Returns an integer `c` s.t. `a = c^2k, \ c,k \in Z`. Here `k` is square
+    free. `a` can be given as an integer or a dictionary of factors.
+
+    Examples
+    ========
+
+    >>> from sympy.solvers.diophantine.diophantine import square_factor
+    >>> square_factor(24)
+    2
+    >>> square_factor(-36*3)
+    6
+    >>> square_factor(1)
+    1
+    >>> square_factor({3: 2, 2: 1, -1: 1})  # -18
+    3
+
+    See Also
+    ========
+    sympy.ntheory.factor_.core
+    """
+    f = a if isinstance(a, dict) else factorint(a)
+    return Mul(*[p**(e//2) for p, e in f.items()])
+
+
+def reconstruct(A, B, z):
+    """
+    Reconstruct the `z` value of an equivalent solution of `ax^2 + by^2 + cz^2`
+    from the `z` value of a solution of the square-free normal form of the
+    equation, `a'*x^2 + b'*y^2 + c'*z^2`, where `a'`, `b'` and `c'` are square
+    free and `gcd(a', b', c') == 1`.
+    """
+    f = factorint(igcd(A, B))
+    for p, e in f.items():
+        if e != 1:
+            raise ValueError('a and b should be square-free')
+        z *= p
+    return z
+
+
+def ldescent(A, B):
+    """
+    Return a non-trivial solution to `w^2 = Ax^2 + By^2` using
+    Lagrange's method; return None if there is no such solution.
+
+    Parameters
+    ==========
+
+    A : Integer
+    B : Integer
+        non-zero integer
+
+    Returns
+    =======
+
+    (int, int, int) | None : a tuple `(w_0, x_0, y_0)` which is a solution to the above equation.
+
+    Examples
+    ========
+
+    >>> from sympy.solvers.diophantine.diophantine import ldescent
+    >>> ldescent(1, 1) # w^2 = x^2 + y^2
+    (1, 1, 0)
+    >>> ldescent(4, -7) # w^2 = 4x^2 - 7y^2
+    (2, -1, 0)
+
+    This means that `x = -1, y = 0` and `w = 2` is a solution to the equation
+    `w^2 = 4x^2 - 7y^2`
+
+    >>> ldescent(5, -1) # w^2 = 5x^2 - y^2
+    (2, 1, -1)
+
+    References
+    ==========
+
+    .. [1] The algorithmic resolution of Diophantine equations, Nigel P. Smart,
+           London Mathematical Society Student Texts 41, Cambridge University
+           Press, Cambridge, 1998.
+    .. [2] Cremona, J. E., Rusin, D. (2003). Efficient Solution of Rational Conics.
+           Mathematics of Computation, 72(243), 1417-1441.
+           https://doi.org/10.1090/S0025-5718-02-01480-1
+    """
+    if A == 0 or B == 0:
+        raise ValueError("A and B must be non-zero integers")
+    if abs(A) > abs(B):
+        w, y, x = ldescent(B, A)
+        return w, x, y
+    if A == 1:
+        return (1, 1, 0)
+    if B == 1:
+        return (1, 0, 1)
+    if B == -1:  # and A == -1
+        return
+
+    r = sqrt_mod(A, B)
+    if r is None:
+        return
+    Q = (r**2 - A) // B
+    if Q == 0:
+        return r, -1, 0
+    for i in divisors(Q):
+        d, _exact = integer_nthroot(abs(Q) // i, 2)
+        if _exact:
+            B_0 = sign(Q)*i
+            W, X, Y = ldescent(A, B_0)
+            return _remove_gcd(-A*X + r*W, r*X - W, Y*B_0*d)
+
+
+def descent(A, B):
+    """
+    Returns a non-trivial solution, (x, y, z), to `x^2 = Ay^2 + Bz^2`
+    using Lagrange's descent method with lattice-reduction. `A` and `B`
+    are assumed to be valid for such a solution to exist.
+
+    This is faster than the normal Lagrange's descent algorithm because
+    the Gaussian reduction is used.
+
+    Examples
+    ========
+
+    >>> from sympy.solvers.diophantine.diophantine import descent
+    >>> descent(3, 1) # x**2 = 3*y**2 + z**2
+    (1, 0, 1)
+
+    `(x, y, z) = (1, 0, 1)` is a solution to the above equation.
+
+    >>> descent(41, -113)
+    (-16, -3, 1)
+
+    References
+    ==========
+
+    .. [1] Cremona, J. E., Rusin, D. (2003). Efficient Solution of Rational Conics.
+           Mathematics of Computation, 72(243), 1417-1441.
+           https://doi.org/10.1090/S0025-5718-02-01480-1
+    """
+    if abs(A) > abs(B):
+        x, y, z = descent(B, A)
+        return x, z, y
+
+    if B == 1:
+        return (1, 0, 1)
+    if A == 1:
+        return (1, 1, 0)
+    if B == -A:
+        return (0, 1, 1)
+    if B == A:
+        x, z, y = descent(-1, A)
+        return (A*y, z, x)
+
+    w = sqrt_mod(A, B)
+    x_0, z_0 = gaussian_reduce(w, A, B)
+
+    t = (x_0**2 - A*z_0**2) // B
+    t_2 = square_factor(t)
+    t_1 = t // t_2**2
+
+    x_1, z_1, y_1 = descent(A, t_1)
+
+    return _remove_gcd(x_0*x_1 + A*z_0*z_1, z_0*x_1 + x_0*z_1, t_1*t_2*y_1)
+
+
+def gaussian_reduce(w:int, a:int, b:int) -> tuple[int, int]:
+    r"""
+    Returns a reduced solution `(x, z)` to the congruence
+    `X^2 - aZ^2 \equiv 0 \pmod{b}` so that `x^2 + |a|z^2` is as small as possible.
+    Here ``w`` is a solution of the congruence `x^2 \equiv a \pmod{b}`.
+
+    This function is intended to be used only for ``descent()``.
+
+    Explanation
+    ===========
+
+    The Gaussian reduction can find the shortest vector for any norm.
+    So we define the special norm for the vectors `u = (u_1, u_2)` and `v = (v_1, v_2)` as follows.
+
+    .. math ::
+        u \cdot v := (wu_1 + bu_2)(wv_1 + bv_2) + |a|u_1v_1
+
+    Note that, given the mapping `f: (u_1, u_2) \to (wu_1 + bu_2, u_1)`,
+    `f((u_1,u_2))` is the solution to `X^2 - aZ^2 \equiv 0 \pmod{b}`.
+    In other words, finding the shortest vector in this norm will yield a solution with smaller `X^2 + |a|Z^2`.
+    The algorithm starts from basis vectors `(0, 1)` and `(1, 0)`
+    (corresponding to solutions `(b, 0)` and `(w, 1)`, respectively) and finds the shortest vector.
+    The shortest vector does not necessarily correspond to the smallest solution,
+    but since ``descent()`` only wants the smallest possible solution, it is sufficient.
+
+    Parameters
+    ==========
+
+    w : int
+        ``w`` s.t. `w^2 \equiv a \pmod{b}`
+    a : int
+        square-free nonzero integer
+    b : int
+        square-free nonzero integer
+
+    Examples
+    ========
+
+    >>> from sympy.solvers.diophantine.diophantine import gaussian_reduce
+    >>> from sympy.ntheory.residue_ntheory import sqrt_mod
+    >>> a, b = 19, 101
+    >>> gaussian_reduce(sqrt_mod(a, b), a, b) # 1**2 - 19*(-4)**2 = -303
+    (1, -4)
+    >>> a, b = 11, 14
+    >>> x, z = gaussian_reduce(sqrt_mod(a, b), a, b)
+    >>> (x**2 - a*z**2) % b == 0
+    True
+
+    It does not always return the smallest solution.
+
+    >>> a, b = 6, 95
+    >>> min_x, min_z = 1, 4
+    >>> x, z = gaussian_reduce(sqrt_mod(a, b), a, b)
+    >>> (x**2 - a*z**2) % b == 0 and (min_x**2 - a*min_z**2) % b == 0
+    True
+    >>> min_x**2 + abs(a)*min_z**2 < x**2 + abs(a)*z**2
+    True
+
+    References
+    ==========
+
+    .. [1] Gaussian lattice Reduction [online]. Available:
+           https://web.archive.org/web/20201021115213/http://home.ie.cuhk.edu.hk/~wkshum/wordpress/?p=404
+    .. [2] Cremona, J. E., Rusin, D. (2003). Efficient Solution of Rational Conics.
+           Mathematics of Computation, 72(243), 1417-1441.
+           https://doi.org/10.1090/S0025-5718-02-01480-1
+    """
+    a = abs(a)
+    def _dot(u, v):
+        return u[0]*v[0] + a*u[1]*v[1]
+
+    u = (b, 0)
+    v = (w, 1) if b*w >= 0 else (-w, -1)
+    # i.e., _dot(u, v) >= 0
+
+    if b**2 < w**2 + a:
+        u, v = v, u
+    # i.e., norm(u) >= norm(v), where norm(u) := sqrt(_dot(u, u))
+
+    while _dot(u, u) > (dv := _dot(v, v)):
+        k = _dot(u, v) // dv
+        u, v = v, (u[0] - k*v[0], u[1] - k*v[1])
+    c = (v[0] - u[0], v[1] - u[1])
+    if _dot(c, c) <= _dot(u, u) <= 2*_dot(u, v):
+        return c
+    return u
+
+
+def holzer(x, y, z, a, b, c):
+    r"""
+    Simplify the solution `(x, y, z)` of the equation
+    `ax^2 + by^2 = cz^2` with `a, b, c > 0` and `z^2 \geq \mid ab \mid` to
+    a new reduced solution `(x', y', z')` such that `z'^2 \leq \mid ab \mid`.
+
+    The algorithm is an interpretation of Mordell's reduction as described
+    on page 8 of Cremona and Rusin's paper [1]_ and the work of Mordell in
+    reference [2]_.
+
+    References
+    ==========
+
+    .. [1] Cremona, J. E., Rusin, D. (2003). Efficient Solution of Rational Conics.
+           Mathematics of Computation, 72(243), 1417-1441.
+           https://doi.org/10.1090/S0025-5718-02-01480-1
+    .. [2] Diophantine Equations, L. J. Mordell, page 48.
+
+    """
+
+    if _odd(c):
+        k = 2*c
+    else:
+        k = c//2
+
+    small = a*b*c
+    step = 0
+    while True:
+        t1, t2, t3 = a*x**2, b*y**2, c*z**2
+        # check that it's a solution
+        if t1 + t2 != t3:
+            if step == 0:
+                raise ValueError('bad starting solution')
+            break
+        x_0, y_0, z_0 = x, y, z
+        if max(t1, t2, t3) <= small:
+            # Holzer condition
+            break
+
+        uv = u, v = base_solution_linear(k, y_0, -x_0)
+        if None in uv:
+            break
+
+        p, q = -(a*u*x_0 + b*v*y_0), c*z_0
+        r = Rational(p, q)
+        if _even(c):
+            w = _nint_or_floor(p, q)
+            assert abs(w - r) <= S.Half
+        else:
+            w = p//q  # floor
+            if _odd(a*u + b*v + c*w):
+                w += 1
+            assert abs(w - r) <= S.One
+
+        A = (a*u**2 + b*v**2 + c*w**2)
+        B = (a*u*x_0 + b*v*y_0 + c*w*z_0)
+        x = Rational(x_0*A - 2*u*B, k)
+        y = Rational(y_0*A - 2*v*B, k)
+        z = Rational(z_0*A - 2*w*B, k)
+        assert all(i.is_Integer for i in (x, y, z))
+        step += 1
+
+    return tuple([int(i) for i in (x_0, y_0, z_0)])
+
+
+def diop_general_pythagorean(eq, param=symbols("m", integer=True)):
+    """
+    Solves the general pythagorean equation,
+    `a_{1}^2x_{1}^2 + a_{2}^2x_{2}^2 + . . . + a_{n}^2x_{n}^2 - a_{n + 1}^2x_{n + 1}^2 = 0`.
+
+    Returns a tuple which contains a parametrized solution to the equation,
+    sorted in the same order as the input variables.
+
+    Usage
+    =====
+
+    ``diop_general_pythagorean(eq, param)``: where ``eq`` is a general
+    pythagorean equation which is assumed to be zero and ``param`` is the base
+    parameter used to construct other parameters by subscripting.
+
+    Examples
+    ========
+
+    >>> from sympy.solvers.diophantine.diophantine import diop_general_pythagorean
+    >>> from sympy.abc import a, b, c, d, e
+    >>> diop_general_pythagorean(a**2 + b**2 + c**2 - d**2)
+    (m1**2 + m2**2 - m3**2, 2*m1*m3, 2*m2*m3, m1**2 + m2**2 + m3**2)
+    >>> diop_general_pythagorean(9*a**2 - 4*b**2 + 16*c**2 + 25*d**2 + e**2)
+    (10*m1**2  + 10*m2**2  + 10*m3**2 - 10*m4**2, 15*m1**2  + 15*m2**2  + 15*m3**2  + 15*m4**2, 15*m1*m4, 12*m2*m4, 60*m3*m4)
+    """
+    var, coeff, diop_type  = classify_diop(eq, _dict=False)
+
+    if diop_type == GeneralPythagorean.name:
+        if param is None:
+            params = None
+        else:
+            params = symbols('%s1:%i' % (param, len(var)), integer=True)
+        return list(GeneralPythagorean(eq).solve(parameters=params))[0]
+
+
+def diop_general_sum_of_squares(eq, limit=1):
+    r"""
+    Solves the equation `x_{1}^2 + x_{2}^2 + . . . + x_{n}^2 - k = 0`.
+
+    Returns at most ``limit`` number of solutions.
+
+    Usage
+    =====
+
+    ``general_sum_of_squares(eq, limit)`` : Here ``eq`` is an expression which
+    is assumed to be zero. Also, ``eq`` should be in the form,
+    `x_{1}^2 + x_{2}^2 + . . . + x_{n}^2 - k = 0`.
+
+    Details
+    =======
+
+    When `n = 3` if `k = 4^a(8m + 7)` for some `a, m \in Z` then there will be
+    no solutions. Refer to [1]_ for more details.
+
+    Examples
+    ========
+
+    >>> from sympy.solvers.diophantine.diophantine import diop_general_sum_of_squares
+    >>> from sympy.abc import a, b, c, d, e
+    >>> diop_general_sum_of_squares(a**2 + b**2 + c**2 + d**2 + e**2 - 2345)
+    {(15, 22, 22, 24, 24)}
+
+    Reference
+    =========
+
+    .. [1] Representing an integer as a sum of three squares, [online],
+        Available:
+        https://proofwiki.org/wiki/Integer_as_Sum_of_Three_Squares
+    """
+    var, coeff, diop_type = classify_diop(eq, _dict=False)
+
+    if diop_type == GeneralSumOfSquares.name:
+        return set(GeneralSumOfSquares(eq).solve(limit=limit))
+
+
+def diop_general_sum_of_even_powers(eq, limit=1):
+    """
+    Solves the equation `x_{1}^e + x_{2}^e + . . . + x_{n}^e - k = 0`
+    where `e` is an even, integer power.
+
+    Returns at most ``limit`` number of solutions.
+
+    Usage
+    =====
+
+    ``general_sum_of_even_powers(eq, limit)`` : Here ``eq`` is an expression which
+    is assumed to be zero. Also, ``eq`` should be in the form,
+    `x_{1}^e + x_{2}^e + . . . + x_{n}^e - k = 0`.
+
+    Examples
+    ========
+
+    >>> from sympy.solvers.diophantine.diophantine import diop_general_sum_of_even_powers
+    >>> from sympy.abc import a, b
+    >>> diop_general_sum_of_even_powers(a**4 + b**4 - (2**4 + 3**4))
+    {(2, 3)}
+
+    See Also
+    ========
+
+    power_representation
+    """
+    var, coeff, diop_type = classify_diop(eq, _dict=False)
+
+    if diop_type == GeneralSumOfEvenPowers.name:
+        return set(GeneralSumOfEvenPowers(eq).solve(limit=limit))
+
+
+## Functions below this comment can be more suitably grouped under
+## an Additive number theory module rather than the Diophantine
+## equation module.
+
+
+def partition(n, k=None, zeros=False):
+    """
+    Returns a generator that can be used to generate partitions of an integer
+    `n`.
+
+    Explanation
+    ===========
+
+    A partition of `n` is a set of positive integers which add up to `n`. For
+    example, partitions of 3 are 3, 1 + 2, 1 + 1 + 1. A partition is returned
+    as a tuple. If ``k`` equals None, then all possible partitions are returned
+    irrespective of their size, otherwise only the partitions of size ``k`` are
+    returned. If the ``zero`` parameter is set to True then a suitable
+    number of zeros are added at the end of every partition of size less than
+    ``k``.
+
+    ``zero`` parameter is considered only if ``k`` is not None. When the
+    partitions are over, the last `next()` call throws the ``StopIteration``
+    exception, so this function should always be used inside a try - except
+    block.
+
+    Details
+    =======
+
+    ``partition(n, k)``: Here ``n`` is a positive integer and ``k`` is the size
+    of the partition which is also positive integer.
+
+    Examples
+    ========
+
+    >>> from sympy.solvers.diophantine.diophantine import partition
+    >>> f = partition(5)
+    >>> next(f)
+    (1, 1, 1, 1, 1)
+    >>> next(f)
+    (1, 1, 1, 2)
+    >>> g = partition(5, 3)
+    >>> next(g)
+    (1, 1, 3)
+    >>> next(g)
+    (1, 2, 2)
+    >>> g = partition(5, 3, zeros=True)
+    >>> next(g)
+    (0, 0, 5)
+
+    """
+    if not zeros or k is None:
+        for i in ordered_partitions(n, k):
+            yield tuple(i)
+    else:
+        for m in range(1, k + 1):
+            for i in ordered_partitions(n, m):
+                i = tuple(i)
+                yield (0,)*(k - len(i)) + i
+
+
+def prime_as_sum_of_two_squares(p):
+    """
+    Represent a prime `p` as a unique sum of two squares; this can
+    only be done if the prime is congruent to 1 mod 4.
+
+    Parameters
+    ==========
+
+    p : Integer
+        A prime that is congruent to 1 mod 4
+
+    Returns
+    =======
+
+    (int, int) | None : Pair of positive integers ``(x, y)`` satisfying ``x**2 + y**2 = p``.
+                        None if ``p`` is not congruent to 1 mod 4.
+
+    Raises
+    ======
+
+    ValueError
+        If ``p`` is not prime number
+
+    Examples
+    ========
+
+    >>> from sympy.solvers.diophantine.diophantine import prime_as_sum_of_two_squares
+    >>> prime_as_sum_of_two_squares(7)  # can't be done
+    >>> prime_as_sum_of_two_squares(5)
+    (1, 2)
+
+    Reference
+    =========
+
+    .. [1] Representing a number as a sum of four squares, [online],
+           Available: https://schorn.ch/lagrange.html
+
+    See Also
+    ========
+
+    sum_of_squares
+
+    """
+    p = as_int(p)
+    if p % 4 != 1:
+        return
+    if not isprime(p):
+        raise ValueError("p should be a prime number")
+
+    if p % 8 == 5:
+        # Legendre symbol (2/p) == -1 if p % 8 in [3, 5]
+        b = 2
+    elif p % 12 == 5:
+        # Legendre symbol (3/p) == -1 if p % 12 in [5, 7]
+        b = 3
+    elif p % 5 in [2, 3]:
+        # Legendre symbol (5/p) == -1 if p % 5 in [2, 3]
+        b = 5
+    else:
+        b = 7
+        while jacobi(b, p) == 1:
+            b = nextprime(b)
+
+    b = pow(b, p >> 2, p)
+    a = p
+    while b**2 > p:
+        a, b = b, a % b
+    return (int(a % b), int(b))  # convert from long
+
+
+def sum_of_three_squares(n):
+    r"""
+    Returns a 3-tuple $(a, b, c)$ such that $a^2 + b^2 + c^2 = n$ and
+    $a, b, c \geq 0$.
+
+    Returns None if $n = 4^a(8m + 7)$ for some `a, m \in \mathbb{Z}`. See
+    [1]_ for more details.
+
+    Parameters
+    ==========
+
+    n : Integer
+        non-negative integer
+
+    Returns
+    =======
+
+    (int, int, int) | None : 3-tuple non-negative integers ``(a, b, c)`` satisfying ``a**2 + b**2 + c**2 = n``.
+                             a,b,c are sorted in ascending order. ``None`` if no such ``(a,b,c)``.
+
+    Raises
+    ======
+
+    ValueError
+        If ``n`` is a negative integer
+
+    Examples
+    ========
+
+    >>> from sympy.solvers.diophantine.diophantine import sum_of_three_squares
+    >>> sum_of_three_squares(44542)
+    (18, 37, 207)
+
+    References
+    ==========
+
+    .. [1] Representing a number as a sum of three squares, [online],
+        Available: https://schorn.ch/lagrange.html
+
+    See Also
+    ========
+
+    power_representation :
+        ``sum_of_three_squares(n)`` is one of the solutions output by ``power_representation(n, 2, 3, zeros=True)``
+
+    """
+    # https://math.stackexchange.com/questions/483101/rabin-and-shallit-algorithm/651425#651425
+    # discusses these numbers (except for 1, 2, 3) as the exceptions of H&L's conjecture that
+    # Every sufficiently large number n is either a square or the sum of a prime and a square.
+    special = {1: (0, 0, 1), 2: (0, 1, 1), 3: (1, 1, 1), 10: (0, 1, 3), 34: (3, 3, 4),
+               58: (0, 3, 7), 85: (0, 6, 7), 130: (0, 3, 11), 214: (3, 6, 13), 226: (8, 9, 9),
+               370: (8, 9, 15), 526: (6, 7, 21), 706: (15, 15, 16), 730: (0, 1, 27),
+               1414: (6, 17, 33), 1906: (13, 21, 36), 2986: (21, 32, 39), 9634: (56, 57, 57)}
+    n = as_int(n)
+    if n < 0:
+        raise ValueError("n should be a non-negative integer")
+    if n == 0:
+        return (0, 0, 0)
+    n, v = remove(n, 4)
+    v = 1 << v
+    if n % 8 == 7:
+        return
+    if n in special:
+        return tuple([v*i for i in special[n]])
+
+    s, _exact = integer_nthroot(n, 2)
+    if _exact:
+        return (0, 0, v*s)
+    if n % 8 == 3:
+        if not s % 2:
+            s -= 1
+        for x in range(s, -1, -2):
+            N = (n - x**2) // 2
+            if isprime(N):
+                # n % 8 == 3 and x % 2 == 1 => N % 4 == 1
+                y, z = prime_as_sum_of_two_squares(N)
+                return tuple(sorted([v*x, v*(y + z), v*abs(y - z)]))
+        # We will never reach this point because there must be a solution.
+        assert False
+
+    # assert n % 4 in [1, 2]
+    if not((n % 2) ^ (s % 2)):
+        s -= 1
+    for x in range(s, -1, -2):
+        N = n - x**2
+        if isprime(N):
+            # assert N % 4 == 1
+            y, z = prime_as_sum_of_two_squares(N)
+            return tuple(sorted([v*x, v*y, v*z]))
+    # We will never reach this point because there must be a solution.
+    assert False
+
+
+def sum_of_four_squares(n):
+    r"""
+    Returns a 4-tuple `(a, b, c, d)` such that `a^2 + b^2 + c^2 + d^2 = n`.
+    Here `a, b, c, d \geq 0`.
+
+    Parameters
+    ==========
+
+    n : Integer
+        non-negative integer
+
+    Returns
+    =======
+
+    (int, int, int, int) : 4-tuple non-negative integers ``(a, b, c, d)`` satisfying ``a**2 + b**2 + c**2 + d**2 = n``.
+                           a,b,c,d are sorted in ascending order.
+
+    Raises
+    ======
+
+    ValueError
+        If ``n`` is a negative integer
+
+    Examples
+    ========
+
+    >>> from sympy.solvers.diophantine.diophantine import sum_of_four_squares
+    >>> sum_of_four_squares(3456)
+    (8, 8, 32, 48)
+    >>> sum_of_four_squares(1294585930293)
+    (0, 1234, 2161, 1137796)
+
+    References
+    ==========
+
+    .. [1] Representing a number as a sum of four squares, [online],
+        Available: https://schorn.ch/lagrange.html
+
+    See Also
+    ========
+
+    power_representation :
+        ``sum_of_four_squares(n)`` is one of the solutions output by ``power_representation(n, 2, 4, zeros=True)``
+
+    """
+    n = as_int(n)
+    if n < 0:
+        raise ValueError("n should be a non-negative integer")
+    if n == 0:
+        return (0, 0, 0, 0)
+    # remove factors of 4 since a solution in terms of 3 squares is
+    # going to be returned; this is also done in sum_of_three_squares,
+    # but it needs to be done here to select d
+    n, v = remove(n, 4)
+    v = 1 << v
+    if n % 8 == 7:
+        d = 2
+        n = n - 4
+    elif n % 8 in (2, 6):
+        d = 1
+        n = n - 1
+    else:
+        d = 0
+    x, y, z = sum_of_three_squares(n)  # sorted
+    return tuple(sorted([v*d, v*x, v*y, v*z]))
+
+
+def power_representation(n, p, k, zeros=False):
+    r"""
+    Returns a generator for finding k-tuples of integers,
+    `(n_{1}, n_{2}, . . . n_{k})`, such that
+    `n = n_{1}^p + n_{2}^p + . . . n_{k}^p`.
+
+    Usage
+    =====
+
+    ``power_representation(n, p, k, zeros)``: Represent non-negative number
+    ``n`` as a sum of ``k`` ``p``\ th powers. If ``zeros`` is true, then the
+    solutions is allowed to contain zeros.
+
+    Examples
+    ========
+
+    >>> from sympy.solvers.diophantine.diophantine import power_representation
+
+    Represent 1729 as a sum of two cubes:
+
+    >>> f = power_representation(1729, 3, 2)
+    >>> next(f)
+    (9, 10)
+    >>> next(f)
+    (1, 12)
+
+    If the flag `zeros` is True, the solution may contain tuples with
+    zeros; any such solutions will be generated after the solutions
+    without zeros:
+
+    >>> list(power_representation(125, 2, 3, zeros=True))
+    [(5, 6, 8), (3, 4, 10), (0, 5, 10), (0, 2, 11)]
+
+    For even `p` the `permute_sign` function can be used to get all
+    signed values:
+
+    >>> from sympy.utilities.iterables import permute_signs
+    >>> list(permute_signs((1, 12)))
+    [(1, 12), (-1, 12), (1, -12), (-1, -12)]
+
+    All possible signed permutations can also be obtained:
+
+    >>> from sympy.utilities.iterables import signed_permutations
+    >>> list(signed_permutations((1, 12)))
+    [(1, 12), (-1, 12), (1, -12), (-1, -12), (12, 1), (-12, 1), (12, -1), (-12, -1)]
+    """
+    n, p, k = [as_int(i) for i in (n, p, k)]
+
+    if n < 0:
+        if p % 2:
+            for t in power_representation(-n, p, k, zeros):
+                yield tuple(-i for i in t)
+        return
+
+    if p < 1 or k < 1:
+        raise ValueError(filldedent('''
+    Expecting positive integers for `(p, k)`, but got `(%s, %s)`'''
+    % (p, k)))
+
+    if n == 0:
+        if zeros:
+            yield (0,)*k
+        return
+
+    if k == 1:
+        if p == 1:
+            yield (n,)
+        elif n == 1:
+            yield (1,)
+        else:
+            be = perfect_power(n)
+            if be:
+                b, e = be
+                d, r = divmod(e, p)
+                if not r:
+                    yield (b**d,)
+        return
+
+    if p == 1:
+        yield from partition(n, k, zeros=zeros)
+        return
+
+    if p == 2:
+        if k == 3:
+            n, v = remove(n, 4)
+            if v:
+                v = 1 << v
+                for t in power_representation(n, p, k, zeros):
+                    yield tuple(i*v for i in t)
+                return
+        feasible = _can_do_sum_of_squares(n, k)
+        if not feasible:
+            return
+        if not zeros:
+            if n > 33 and k >= 5 and k <= n and n - k in (
+                13, 10, 7, 5, 4, 2, 1):
+                '''Todd G. Will, "When Is n^2 a Sum of k Squares?", [online].
+                Available: https://www.maa.org/sites/default/files/Will-MMz-201037918.pdf'''
+                return
+            # quick tests since feasibility includes the possibility of 0
+            if k == 4 and (n in (1, 3, 5, 9, 11, 17, 29, 41) or remove(n, 4)[0] in (2, 6, 14)):
+                # A000534
+                return
+            if k == 3 and n in (1, 2, 5, 10, 13, 25, 37, 58, 85, 130):  # or n = some number >= 5*10**10
+                # A051952
+                return
+        if feasible is not True:  # it's prime and k == 2
+            yield prime_as_sum_of_two_squares(n)
+            return
+
+    if k == 2 and p > 2:
+        be = perfect_power(n)
+        if be and be[1] % p == 0:
+            return  # Fermat: a**n + b**n = c**n has no solution for n > 2
+
+    if n >= k:
+        a = integer_nthroot(n - (k - 1), p)[0]
+        for t in pow_rep_recursive(a, k, n, [], p):
+            yield tuple(reversed(t))
+
+    if zeros:
+        a = integer_nthroot(n, p)[0]
+        for i in range(1, k):
+            for t in pow_rep_recursive(a, i, n, [], p):
+                yield tuple(reversed(t + (0,)*(k - i)))
+
+
+sum_of_powers = power_representation
+
+
+def pow_rep_recursive(n_i, k, n_remaining, terms, p):
+    # Invalid arguments
+    if n_i <= 0 or k <= 0:
+        return
+
+    # No solutions may exist
+    if n_remaining < k:
+        return
+    if k * pow(n_i, p) < n_remaining:
+        return
+
+    if k == 0 and n_remaining == 0:
+        yield tuple(terms)
+
+    elif k == 1:
+        # next_term^p must equal to n_remaining
+        next_term, exact = integer_nthroot(n_remaining, p)
+        if exact and next_term <= n_i:
+            yield tuple(terms + [next_term])
+        return
+
+    else:
+        # TODO: Fall back to diop_DN when k = 2
+        if n_i >= 1 and k > 0:
+            for next_term in range(1, n_i + 1):
+                residual = n_remaining - pow(next_term, p)
+                if residual < 0:
+                    break
+                yield from pow_rep_recursive(next_term, k - 1, residual, terms + [next_term], p)
+
+
+def sum_of_squares(n, k, zeros=False):
+    """Return a generator that yields the k-tuples of nonnegative
+    values, the squares of which sum to n. If zeros is False (default)
+    then the solution will not contain zeros. The nonnegative
+    elements of a tuple are sorted.
+
+    * If k == 1 and n is square, (n,) is returned.
+
+    * If k == 2 then n can only be written as a sum of squares if
+      every prime in the factorization of n that has the form
+      4*k + 3 has an even multiplicity. If n is prime then
+      it can only be written as a sum of two squares if it is
+      in the form 4*k + 1.
+
+    * if k == 3 then n can be written as a sum of squares if it does
+      not have the form 4**m*(8*k + 7).
+
+    * all integers can be written as the sum of 4 squares.
+
+    * if k > 4 then n can be partitioned and each partition can
+      be written as a sum of 4 squares; if n is not evenly divisible
+      by 4 then n can be written as a sum of squares only if the
+      an additional partition can be written as sum of squares.
+      For example, if k = 6 then n is partitioned into two parts,
+      the first being written as a sum of 4 squares and the second
+      being written as a sum of 2 squares -- which can only be
+      done if the condition above for k = 2 can be met, so this will
+      automatically reject certain partitions of n.
+
+    Examples
+    ========
+
+    >>> from sympy.solvers.diophantine.diophantine import sum_of_squares
+    >>> list(sum_of_squares(25, 2))
+    [(3, 4)]
+    >>> list(sum_of_squares(25, 2, True))
+    [(3, 4), (0, 5)]
+    >>> list(sum_of_squares(25, 4))
+    [(1, 2, 2, 4)]
+
+    See Also
+    ========
+
+    sympy.utilities.iterables.signed_permutations
+    """
+    yield from power_representation(n, 2, k, zeros)
+
+
+def _can_do_sum_of_squares(n, k):
+    """Return True if n can be written as the sum of k squares,
+    False if it cannot, or 1 if ``k == 2`` and ``n`` is prime (in which
+    case it *can* be written as a sum of two squares). A False
+    is returned only if it cannot be written as ``k``-squares, even
+    if 0s are allowed.
+    """
+    if k < 1:
+        return False
+    if n < 0:
+        return False
+    if n == 0:
+        return True
+    if k == 1:
+        return is_square(n)
+    if k == 2:
+        if n in (1, 2):
+            return True
+        if isprime(n):
+            if n % 4 == 1:
+                return 1  # signal that it was prime
+            return False
+        # n is a composite number
+        # we can proceed iff no prime factor in the form 4*k + 3
+        # has an odd multiplicity
+        return all(p % 4 !=3 or m % 2 == 0 for p, m in factorint(n).items())
+    if k == 3:
+        return remove(n, 4)[0] % 8 != 7
+    # every number can be written as a sum of 4 squares; for k > 4 partitions
+    # can be 0
+    return True
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/diophantine/tests/__init__.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/diophantine/tests/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/diophantine/tests/__pycache__/__init__.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/diophantine/tests/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ecef58a83eb1f8061ab23cd006610c20f42e397c
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/diophantine/tests/__pycache__/__init__.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/diophantine/tests/__pycache__/test_diophantine.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/diophantine/tests/__pycache__/test_diophantine.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ab85204ad7615ea5da09b78a961d457594e46416
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/diophantine/tests/__pycache__/test_diophantine.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/diophantine/tests/test_diophantine.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/diophantine/tests/test_diophantine.py
new file mode 100644
index 0000000000000000000000000000000000000000..b8b031a1e63fa445e3dbb0b425f84cfe88888667
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/diophantine/tests/test_diophantine.py
@@ -0,0 +1,1071 @@
+from sympy.core.add import Add
+from sympy.core.mul import Mul
+from sympy.core.numbers import (Rational, oo, pi)
+from sympy.core.relational import Eq
+from sympy.core.singleton import S
+from sympy.core.symbol import symbols
+from sympy.matrices.dense import Matrix
+from sympy.ntheory.factor_ import factorint
+from sympy.simplify.powsimp import powsimp
+from sympy.core.function import _mexpand
+from sympy.core.sorting import default_sort_key, ordered
+from sympy.functions.elementary.trigonometric import sin
+from sympy.solvers.diophantine import diophantine
+from sympy.solvers.diophantine.diophantine import (diop_DN,
+    diop_solve, diop_ternary_quadratic_normal,
+    diop_general_pythagorean, diop_ternary_quadratic, diop_linear,
+    diop_quadratic, diop_general_sum_of_squares, diop_general_sum_of_even_powers,
+    descent, diop_bf_DN, divisible, equivalent, find_DN, ldescent, length,
+    reconstruct, partition, power_representation,
+    prime_as_sum_of_two_squares, square_factor, sum_of_four_squares,
+    sum_of_three_squares, transformation_to_DN, transformation_to_normal,
+    classify_diop, base_solution_linear, cornacchia, sqf_normal, gaussian_reduce, holzer,
+    check_param, parametrize_ternary_quadratic, sum_of_powers, sum_of_squares,
+    _diop_ternary_quadratic_normal, _nint_or_floor,
+    _odd, _even, _remove_gcd, _can_do_sum_of_squares, DiophantineSolutionSet, GeneralPythagorean,
+    BinaryQuadratic)
+
+from sympy.testing.pytest import slow, raises, XFAIL
+from sympy.utilities.iterables import (
+        signed_permutations)
+
+a, b, c, d, p, q, x, y, z, w, t, u, v, X, Y, Z = symbols(
+    "a, b, c, d, p, q, x, y, z, w, t, u, v, X, Y, Z", integer=True)
+t_0, t_1, t_2, t_3, t_4, t_5, t_6 = symbols("t_:7", integer=True)
+m1, m2, m3 = symbols('m1:4', integer=True)
+n1 = symbols('n1', integer=True)
+
+
+def diop_simplify(eq):
+    return _mexpand(powsimp(_mexpand(eq)))
+
+
+def test_input_format():
+    raises(TypeError, lambda: diophantine(sin(x)))
+    raises(TypeError, lambda: diophantine(x/pi - 3))
+
+
+def test_nosols():
+    # diophantine should sympify eq so that these are equivalent
+    assert diophantine(3) == set()
+    assert diophantine(S(3)) == set()
+
+
+def test_univariate():
+    assert diop_solve((x - 1)*(x - 2)**2) == {(1,), (2,)}
+    assert diop_solve((x - 1)*(x - 2)) == {(1,), (2,)}
+
+
+def test_classify_diop():
+    raises(TypeError, lambda: classify_diop(x**2/3 - 1))
+    raises(ValueError, lambda: classify_diop(1))
+    raises(NotImplementedError, lambda: classify_diop(w*x*y*z - 1))
+    raises(NotImplementedError, lambda: classify_diop(x**3 + y**3 + z**4 - 90))
+    assert classify_diop(14*x**2 + 15*x - 42) == (
+        [x], {1: -42, x: 15, x**2: 14}, 'univariate')
+    assert classify_diop(x*y + z) == (
+        [x, y, z], {x*y: 1, z: 1}, 'inhomogeneous_ternary_quadratic')
+    assert classify_diop(x*y + z + w + x**2) == (
+        [w, x, y, z], {x*y: 1, w: 1, x**2: 1, z: 1}, 'inhomogeneous_general_quadratic')
+    assert classify_diop(x*y + x*z + x**2 + 1) == (
+        [x, y, z], {x*y: 1, x*z: 1, x**2: 1, 1: 1}, 'inhomogeneous_general_quadratic')
+    assert classify_diop(x*y + z + w + 42) == (
+        [w, x, y, z], {x*y: 1, w: 1, 1: 42, z: 1}, 'inhomogeneous_general_quadratic')
+    assert classify_diop(x*y + z*w) == (
+        [w, x, y, z], {x*y: 1, w*z: 1}, 'homogeneous_general_quadratic')
+    assert classify_diop(x*y**2 + 1) == (
+        [x, y], {x*y**2: 1, 1: 1}, 'cubic_thue')
+    assert classify_diop(x**4 + y**4 + z**4 - (1 + 16 + 81)) == (
+        [x, y, z], {1: -98, x**4: 1, z**4: 1, y**4: 1}, 'general_sum_of_even_powers')
+    assert classify_diop(x**2 + y**2 + z**2) == (
+        [x, y, z], {x**2: 1, y**2: 1, z**2: 1}, 'homogeneous_ternary_quadratic_normal')
+
+
+def test_linear():
+    assert diop_solve(x) == (0,)
+    assert diop_solve(1*x) == (0,)
+    assert diop_solve(3*x) == (0,)
+    assert diop_solve(x + 1) == (-1,)
+    assert diop_solve(2*x + 1) == (None,)
+    assert diop_solve(2*x + 4) == (-2,)
+    assert diop_solve(y + x) == (t_0, -t_0)
+    assert diop_solve(y + x + 0) == (t_0, -t_0)
+    assert diop_solve(y + x - 0) == (t_0, -t_0)
+    assert diop_solve(0*x - y - 5) == (-5,)
+    assert diop_solve(3*y + 2*x - 5) == (3*t_0 - 5, -2*t_0 + 5)
+    assert diop_solve(2*x - 3*y - 5) == (3*t_0 - 5, 2*t_0 - 5)
+    assert diop_solve(-2*x - 3*y - 5) == (3*t_0 + 5, -2*t_0 - 5)
+    assert diop_solve(7*x + 5*y) == (5*t_0, -7*t_0)
+    assert diop_solve(2*x + 4*y) == (-2*t_0, t_0)
+    assert diop_solve(4*x + 6*y - 4) == (3*t_0 - 2, -2*t_0 + 2)
+    assert diop_solve(4*x + 6*y - 3) == (None, None)
+    assert diop_solve(0*x + 3*y - 4*z + 5) == (4*t_0 + 5, 3*t_0 + 5)
+    assert diop_solve(4*x + 3*y - 4*z + 5) == (t_0, 8*t_0 + 4*t_1 + 5, 7*t_0 + 3*t_1 + 5)
+    assert diop_solve(4*x + 3*y - 4*z + 5, None) == (0, 5, 5)
+    assert diop_solve(4*x + 2*y + 8*z - 5) == (None, None, None)
+    assert diop_solve(5*x + 7*y - 2*z - 6) == (t_0, -3*t_0 + 2*t_1 + 6, -8*t_0 + 7*t_1 + 18)
+    assert diop_solve(3*x - 6*y + 12*z - 9) == (2*t_0 + 3, t_0 + 2*t_1, t_1)
+    assert diop_solve(6*w + 9*x + 20*y - z) == (t_0, t_1, t_1 + t_2, 6*t_0 + 29*t_1 + 20*t_2)
+
+    # to ignore constant factors, use diophantine
+    raises(TypeError, lambda: diop_solve(x/2))
+
+
+def test_quadratic_simple_hyperbolic_case():
+    # Simple Hyperbolic case: A = C = 0 and B != 0
+    assert diop_solve(3*x*y + 34*x - 12*y + 1) == \
+           {(-133, -11), (5, -57)}
+    assert diop_solve(6*x*y + 2*x + 3*y + 1) == set()
+    assert diop_solve(-13*x*y + 2*x - 4*y - 54) == {(27, 0)}
+    assert diop_solve(-27*x*y - 30*x - 12*y - 54) == {(-14, -1)}
+    assert diop_solve(2*x*y + 5*x + 56*y + 7) == {(-161, -3), (-47, -6), (-35, -12),
+                                                  (-29, -69), (-27, 64), (-21, 7),
+                                                  (-9, 1), (105, -2)}
+    assert diop_solve(6*x*y + 9*x + 2*y + 3) == set()
+    assert diop_solve(x*y + x + y + 1) == {(-1, t), (t, -1)}
+    assert diophantine(48*x*y)
+
+
+def test_quadratic_elliptical_case():
+    # Elliptical case: B**2 - 4AC < 0
+
+    assert diop_solve(42*x**2 + 8*x*y + 15*y**2 + 23*x + 17*y - 4915) == {(-11, -1)}
+    assert diop_solve(4*x**2 + 3*y**2 + 5*x - 11*y + 12) == set()
+    assert diop_solve(x**2 + y**2 + 2*x + 2*y + 2) == {(-1, -1)}
+    assert diop_solve(15*x**2 - 9*x*y + 14*y**2 - 23*x - 14*y - 4950) == {(-15, 6)}
+    assert diop_solve(10*x**2 + 12*x*y + 12*y**2 - 34) == \
+           {(-1, -1), (-1, 2), (1, -2), (1, 1)}
+
+
+def test_quadratic_parabolic_case():
+    # Parabolic case: B**2 - 4AC = 0
+    assert check_solutions(8*x**2 - 24*x*y + 18*y**2 + 5*x + 7*y + 16)
+    assert check_solutions(8*x**2 - 24*x*y + 18*y**2 + 6*x + 12*y - 6)
+    assert check_solutions(8*x**2 + 24*x*y + 18*y**2 + 4*x + 6*y - 7)
+    assert check_solutions(-4*x**2 + 4*x*y - y**2 + 2*x - 3)
+    assert check_solutions(x**2 + 2*x*y + y**2 + 2*x + 2*y + 1)
+    assert check_solutions(x**2 - 2*x*y + y**2 + 2*x + 2*y + 1)
+    assert check_solutions(y**2 - 41*x + 40)
+
+
+def test_quadratic_perfect_square():
+    # B**2 - 4*A*C > 0
+    # B**2 - 4*A*C is a perfect square
+    assert check_solutions(48*x*y)
+    assert check_solutions(4*x**2 - 5*x*y + y**2 + 2)
+    assert check_solutions(-2*x**2 - 3*x*y + 2*y**2 -2*x - 17*y + 25)
+    assert check_solutions(12*x**2 + 13*x*y + 3*y**2 - 2*x + 3*y - 12)
+    assert check_solutions(8*x**2 + 10*x*y + 2*y**2 - 32*x - 13*y - 23)
+    assert check_solutions(4*x**2 - 4*x*y - 3*y- 8*x - 3)
+    assert check_solutions(- 4*x*y - 4*y**2 - 3*y- 5*x - 10)
+    assert check_solutions(x**2 - y**2 - 2*x - 2*y)
+    assert check_solutions(x**2 - 9*y**2 - 2*x - 6*y)
+    assert check_solutions(4*x**2 - 9*y**2 - 4*x - 12*y - 3)
+
+
+def test_quadratic_non_perfect_square():
+    # B**2 - 4*A*C is not a perfect square
+    # Used check_solutions() since the solutions are complex expressions involving
+    # square roots and exponents
+    assert check_solutions(x**2 - 2*x - 5*y**2)
+    assert check_solutions(3*x**2 - 2*y**2 - 2*x - 2*y)
+    assert check_solutions(x**2 - x*y - y**2 - 3*y)
+    assert check_solutions(x**2 - 9*y**2 - 2*x - 6*y)
+    assert BinaryQuadratic(x**2 + y**2 + 2*x + 2*y + 2).solve() == {(-1, -1)}
+
+
+def test_issue_9106():
+    eq = -48 - 2*x*(3*x - 1) + y*(3*y - 1)
+    v = (x, y)
+    for sol in diophantine(eq):
+        assert not diop_simplify(eq.xreplace(dict(zip(v, sol))))
+
+
+def test_issue_18138():
+    eq = x**2 - x - y**2
+    v = (x, y)
+    for sol in diophantine(eq):
+        assert not diop_simplify(eq.xreplace(dict(zip(v, sol))))
+
+
+@slow
+def test_quadratic_non_perfect_slow():
+    assert check_solutions(8*x**2 + 10*x*y - 2*y**2 - 32*x - 13*y - 23)
+    # This leads to very large numbers.
+    # assert check_solutions(5*x**2 - 13*x*y + y**2 - 4*x - 4*y - 15)
+    assert check_solutions(-3*x**2 - 2*x*y + 7*y**2 - 5*x - 7)
+    assert check_solutions(-4 - x + 4*x**2 - y - 3*x*y - 4*y**2)
+    assert check_solutions(1 + 2*x + 2*x**2 + 2*y + x*y - 2*y**2)
+
+
+def test_DN():
+    # Most of the test cases were adapted from,
+    # Solving the generalized Pell equation x**2 - D*y**2 = N, John P. Robertson, July 31, 2004.
+    # https://web.archive.org/web/20160323033128/http://www.jpr2718.org/pell.pdf
+    # others are verified using Wolfram Alpha.
+
+    # Covers cases where D <= 0 or D > 0 and D is a square or N = 0
+    # Solutions are straightforward in these cases.
+    assert diop_DN(3, 0) == [(0, 0)]
+    assert diop_DN(-17, -5) == []
+    assert diop_DN(-19, 23) == [(2, 1)]
+    assert diop_DN(-13, 17) == [(2, 1)]
+    assert diop_DN(-15, 13) == []
+    assert diop_DN(0, 5) == []
+    assert diop_DN(0, 9) == [(3, t)]
+    assert diop_DN(9, 0) == [(3*t, t)]
+    assert diop_DN(16, 24) == []
+    assert diop_DN(9, 180) == [(18, 4)]
+    assert diop_DN(9, -180) == [(12, 6)]
+    assert diop_DN(7, 0) == [(0, 0)]
+
+    # When equation is x**2 + y**2 = N
+    # Solutions are interchangeable
+    assert diop_DN(-1, 5) == [(2, 1), (1, 2)]
+    assert diop_DN(-1, 169) == [(12, 5), (5, 12), (13, 0), (0, 13)]
+
+    # D > 0 and D is not a square
+
+    # N = 1
+    assert diop_DN(13, 1) == [(649, 180)]
+    assert diop_DN(980, 1) == [(51841, 1656)]
+    assert diop_DN(981, 1) == [(158070671986249, 5046808151700)]
+    assert diop_DN(986, 1) == [(49299, 1570)]
+    assert diop_DN(991, 1) == [(379516400906811930638014896080, 12055735790331359447442538767)]
+    assert diop_DN(17, 1) == [(33, 8)]
+    assert diop_DN(19, 1) == [(170, 39)]
+
+    # N = -1
+    assert diop_DN(13, -1) == [(18, 5)]
+    assert diop_DN(991, -1) == []
+    assert diop_DN(41, -1) == [(32, 5)]
+    assert diop_DN(290, -1) == [(17, 1)]
+    assert diop_DN(21257, -1) == [(13913102721304, 95427381109)]
+    assert diop_DN(32, -1) == []
+
+    # |N| > 1
+    # Some tests were created using calculator at
+    # http://www.numbertheory.org/php/patz.html
+
+    assert diop_DN(13, -4) == [(3, 1), (393, 109), (36, 10)]
+    # Source I referred returned (3, 1), (393, 109) and (-3, 1) as fundamental solutions
+    # So (-3, 1) and (393, 109) should be in the same equivalent class
+    assert equivalent(-3, 1, 393, 109, 13, -4) == True
+
+    assert diop_DN(13, 27) == [(220, 61), (40, 11), (768, 213), (12, 3)]
+    assert set(diop_DN(157, 12)) == {(13, 1), (10663, 851), (579160, 46222),
+                                     (483790960, 38610722), (26277068347, 2097138361),
+                                     (21950079635497, 1751807067011)}
+    assert diop_DN(13, 25) == [(3245, 900)]
+    assert diop_DN(192, 18) == []
+    assert diop_DN(23, 13) == [(-6, 1), (6, 1)]
+    assert diop_DN(167, 2) == [(13, 1)]
+    assert diop_DN(167, -2) == []
+
+    assert diop_DN(123, -2) == [(11, 1)]
+    # One calculator returned [(11, 1), (-11, 1)] but both of these are in
+    # the same equivalence class
+    assert equivalent(11, 1, -11, 1, 123, -2)
+
+    assert diop_DN(123, -23) == [(-10, 1), (10, 1)]
+
+    assert diop_DN(0, 0, t) == [(0, t)]
+    assert diop_DN(0, -1, t) == []
+
+
+def test_bf_pell():
+    assert diop_bf_DN(13, -4) == [(3, 1), (-3, 1), (36, 10)]
+    assert diop_bf_DN(13, 27) == [(12, 3), (-12, 3), (40, 11), (-40, 11)]
+    assert diop_bf_DN(167, -2) == []
+    assert diop_bf_DN(1729, 1) == [(44611924489705, 1072885712316)]
+    assert diop_bf_DN(89, -8) == [(9, 1), (-9, 1)]
+    assert diop_bf_DN(21257, -1) == [(13913102721304, 95427381109)]
+    assert diop_bf_DN(340, -4) == [(756, 41)]
+    assert diop_bf_DN(-1, 0, t) == [(0, 0)]
+    assert diop_bf_DN(0, 0, t) == [(0, t)]
+    assert diop_bf_DN(4, 0, t) == [(2*t, t), (-2*t, t)]
+    assert diop_bf_DN(3, 0, t) == [(0, 0)]
+    assert diop_bf_DN(1, -2, t) == []
+
+
+def test_length():
+    assert length(2, 1, 0) == 1
+    assert length(-2, 4, 5) == 3
+    assert length(-5, 4, 17) == 4
+    assert length(0, 4, 13) == 6
+    assert length(7, 13, 11) == 23
+    assert length(1, 6, 4) == 2
+
+
+def is_pell_transformation_ok(eq):
+    """
+    Test whether X*Y, X, or Y terms are present in the equation
+    after transforming the equation using the transformation returned
+    by transformation_to_pell(). If they are not present we are good.
+    Moreover, coefficient of X**2 should be a divisor of coefficient of
+    Y**2 and the constant term.
+    """
+    A, B = transformation_to_DN(eq)
+    u = (A*Matrix([X, Y]) + B)[0]
+    v = (A*Matrix([X, Y]) + B)[1]
+    simplified = diop_simplify(eq.subs(zip((x, y), (u, v))))
+
+    coeff = dict([reversed(t.as_independent(*[X, Y])) for t in simplified.args])
+
+    for term in [X*Y, X, Y]:
+        if term in coeff.keys():
+            return False
+
+    for term in [X**2, Y**2, 1]:
+        if term not in coeff.keys():
+            coeff[term] = 0
+
+    if coeff[X**2] != 0:
+        return divisible(coeff[Y**2], coeff[X**2]) and \
+        divisible(coeff[1], coeff[X**2])
+
+    return True
+
+
+def test_transformation_to_pell():
+    assert is_pell_transformation_ok(-13*x**2 - 7*x*y + y**2 + 2*x - 2*y - 14)
+    assert is_pell_transformation_ok(-17*x**2 + 19*x*y - 7*y**2 - 5*x - 13*y - 23)
+    assert is_pell_transformation_ok(x**2 - y**2 + 17)
+    assert is_pell_transformation_ok(-x**2 + 7*y**2 - 23)
+    assert is_pell_transformation_ok(25*x**2 - 45*x*y + 5*y**2 - 5*x - 10*y + 5)
+    assert is_pell_transformation_ok(190*x**2 + 30*x*y + y**2 - 3*y - 170*x - 130)
+    assert is_pell_transformation_ok(x**2 - 2*x*y -190*y**2 - 7*y - 23*x - 89)
+    assert is_pell_transformation_ok(15*x**2 - 9*x*y + 14*y**2 - 23*x - 14*y - 4950)
+
+
+def test_find_DN():
+    assert find_DN(x**2 - 2*x - y**2) == (1, 1)
+    assert find_DN(x**2 - 3*y**2 - 5) == (3, 5)
+    assert find_DN(x**2 - 2*x*y - 4*y**2 - 7) == (5, 7)
+    assert find_DN(4*x**2 - 8*x*y - y**2 - 9) == (20, 36)
+    assert find_DN(7*x**2 - 2*x*y - y**2 - 12) == (8, 84)
+    assert find_DN(-3*x**2 + 4*x*y -y**2) == (1, 0)
+    assert find_DN(-13*x**2 - 7*x*y + y**2 + 2*x - 2*y -14) == (101, -7825480)
+
+
+def test_ldescent():
+    # Equations which have solutions
+    u = ([(13, 23), (3, -11), (41, -113), (4, -7), (-7, 4), (91, -3), (1, 1), (1, -1),
+        (4, 32), (17, 13), (123689, 1), (19, -570)])
+    for a, b in u:
+        w, x, y = ldescent(a, b)
+        assert a*x**2 + b*y**2 == w**2
+    assert ldescent(-1, -1) is None
+    assert ldescent(2, 6) is None
+
+
+def test_diop_ternary_quadratic_normal():
+    assert check_solutions(234*x**2 - 65601*y**2 - z**2)
+    assert check_solutions(23*x**2 + 616*y**2 - z**2)
+    assert check_solutions(5*x**2 + 4*y**2 - z**2)
+    assert check_solutions(3*x**2 + 6*y**2 - 3*z**2)
+    assert check_solutions(x**2 + 3*y**2 - z**2)
+    assert check_solutions(4*x**2 + 5*y**2 - z**2)
+    assert check_solutions(x**2 + y**2 - z**2)
+    assert check_solutions(16*x**2 + y**2 - 25*z**2)
+    assert check_solutions(6*x**2 - y**2 + 10*z**2)
+    assert check_solutions(213*x**2 + 12*y**2 - 9*z**2)
+    assert check_solutions(34*x**2 - 3*y**2 - 301*z**2)
+    assert check_solutions(124*x**2 - 30*y**2 - 7729*z**2)
+
+
+def is_normal_transformation_ok(eq):
+    A = transformation_to_normal(eq)
+    X, Y, Z = A*Matrix([x, y, z])
+    simplified = diop_simplify(eq.subs(zip((x, y, z), (X, Y, Z))))
+
+    coeff = dict([reversed(t.as_independent(*[X, Y, Z])) for t in simplified.args])
+    for term in [X*Y, Y*Z, X*Z]:
+        if term in coeff.keys():
+            return False
+
+    return True
+
+
+def test_transformation_to_normal():
+    assert is_normal_transformation_ok(x**2 + 3*y**2 + z**2 - 13*x*y - 16*y*z + 12*x*z)
+    assert is_normal_transformation_ok(x**2 + 3*y**2 - 100*z**2)
+    assert is_normal_transformation_ok(x**2 + 23*y*z)
+    assert is_normal_transformation_ok(3*y**2 - 100*z**2 - 12*x*y)
+    assert is_normal_transformation_ok(x**2 + 23*x*y - 34*y*z + 12*x*z)
+    assert is_normal_transformation_ok(z**2 + 34*x*y - 23*y*z + x*z)
+    assert is_normal_transformation_ok(x**2 + y**2 + z**2 - x*y - y*z - x*z)
+    assert is_normal_transformation_ok(x**2 + 2*y*z + 3*z**2)
+    assert is_normal_transformation_ok(x*y + 2*x*z + 3*y*z)
+    assert is_normal_transformation_ok(2*x*z + 3*y*z)
+
+
+def test_diop_ternary_quadratic():
+    assert check_solutions(2*x**2 + z**2 + y**2 - 4*x*y)
+    assert check_solutions(x**2 - y**2 - z**2 - x*y - y*z)
+    assert check_solutions(3*x**2 - x*y - y*z - x*z)
+    assert check_solutions(x**2 - y*z - x*z)
+    assert check_solutions(5*x**2 - 3*x*y - x*z)
+    assert check_solutions(4*x**2 - 5*y**2 - x*z)
+    assert check_solutions(3*x**2 + 2*y**2 - z**2 - 2*x*y + 5*y*z - 7*y*z)
+    assert check_solutions(8*x**2 - 12*y*z)
+    assert check_solutions(45*x**2 - 7*y**2 - 8*x*y - z**2)
+    assert check_solutions(x**2 - 49*y**2 - z**2 + 13*z*y -8*x*y)
+    assert check_solutions(90*x**2 + 3*y**2 + 5*x*y + 2*z*y + 5*x*z)
+    assert check_solutions(x**2 + 3*y**2 + z**2 - x*y - 17*y*z)
+    assert check_solutions(x**2 + 3*y**2 + z**2 - x*y - 16*y*z + 12*x*z)
+    assert check_solutions(x**2 + 3*y**2 + z**2 - 13*x*y - 16*y*z + 12*x*z)
+    assert check_solutions(x*y - 7*y*z + 13*x*z)
+
+    assert diop_ternary_quadratic_normal(x**2 + y**2 + z**2) == (None, None, None)
+    assert diop_ternary_quadratic_normal(x**2 + y**2) is None
+    raises(ValueError, lambda:
+        _diop_ternary_quadratic_normal((x, y, z),
+        {x*y: 1, x**2: 2, y**2: 3, z**2: 0}))
+    eq = -2*x*y - 6*x*z + 7*y**2 - 3*y*z + 4*z**2
+    assert diop_ternary_quadratic(eq) == (7, 2, 0)
+    assert diop_ternary_quadratic_normal(4*x**2 + 5*y**2 - z**2) == \
+        (1, 0, 2)
+    assert diop_ternary_quadratic(x*y + 2*y*z) == \
+        (-2, 0, n1)
+    eq = -5*x*y - 8*x*z - 3*y*z + 8*z**2
+    assert parametrize_ternary_quadratic(eq) == \
+        (8*p**2 - 3*p*q, -8*p*q + 8*q**2, 5*p*q)
+    # this cannot be tested with diophantine because it will
+    # factor into a product
+    assert diop_solve(x*y + 2*y*z) == (-2*p*q, -n1*p**2 + p**2, p*q)
+
+
+def test_square_factor():
+    assert square_factor(1) == square_factor(-1) == 1
+    assert square_factor(0) == 1
+    assert square_factor(5) == square_factor(-5) == 1
+    assert square_factor(4) == square_factor(-4) == 2
+    assert square_factor(12) == square_factor(-12) == 2
+    assert square_factor(6) == 1
+    assert square_factor(18) == 3
+    assert square_factor(52) == 2
+    assert square_factor(49) == 7
+    assert square_factor(392) == 14
+    assert square_factor(factorint(-12)) == 2
+
+
+def test_parametrize_ternary_quadratic():
+    assert check_solutions(x**2 + y**2 - z**2)
+    assert check_solutions(x**2 + 2*x*y + z**2)
+    assert check_solutions(234*x**2 - 65601*y**2 - z**2)
+    assert check_solutions(3*x**2 + 2*y**2 - z**2 - 2*x*y + 5*y*z - 7*y*z)
+    assert check_solutions(x**2 - y**2 - z**2)
+    assert check_solutions(x**2 - 49*y**2 - z**2 + 13*z*y - 8*x*y)
+    assert check_solutions(8*x*y + z**2)
+    assert check_solutions(124*x**2 - 30*y**2 - 7729*z**2)
+    assert check_solutions(236*x**2 - 225*y**2 - 11*x*y - 13*y*z - 17*x*z)
+    assert check_solutions(90*x**2 + 3*y**2 + 5*x*y + 2*z*y + 5*x*z)
+    assert check_solutions(124*x**2 - 30*y**2 - 7729*z**2)
+
+
+def test_no_square_ternary_quadratic():
+    assert check_solutions(2*x*y + y*z - 3*x*z)
+    assert check_solutions(189*x*y - 345*y*z - 12*x*z)
+    assert check_solutions(23*x*y + 34*y*z)
+    assert check_solutions(x*y + y*z + z*x)
+    assert check_solutions(23*x*y + 23*y*z + 23*x*z)
+
+
+def test_descent():
+
+    u = ([(13, 23), (3, -11), (41, -113), (91, -3), (1, 1), (1, -1), (17, 13), (123689, 1), (19, -570)])
+    for a, b in u:
+        w, x, y = descent(a, b)
+        assert a*x**2 + b*y**2 == w**2
+    # the docstring warns against bad input, so these are expected results
+    # - can't both be negative
+    raises(TypeError, lambda: descent(-1, -3))
+    # A can't be zero unless B != 1
+    raises(ZeroDivisionError, lambda: descent(0, 3))
+    # supposed to be square-free
+    raises(TypeError, lambda: descent(4, 3))
+
+
+def test_diophantine():
+    assert check_solutions((x - y)*(y - z)*(z - x))
+    assert check_solutions((x - y)*(x**2 + y**2 - z**2))
+    assert check_solutions((x - 3*y + 7*z)*(x**2 + y**2 - z**2))
+    assert check_solutions(x**2 - 3*y**2 - 1)
+    assert check_solutions(y**2 + 7*x*y)
+    assert check_solutions(x**2 - 3*x*y + y**2)
+    assert check_solutions(z*(x**2 - y**2 - 15))
+    assert check_solutions(x*(2*y - 2*z + 5))
+    assert check_solutions((x**2 - 3*y**2 - 1)*(x**2 - y**2 - 15))
+    assert check_solutions((x**2 - 3*y**2 - 1)*(y - 7*z))
+    assert check_solutions((x**2 + y**2 - z**2)*(x - 7*y - 3*z + 4*w))
+    # Following test case caused problems in parametric representation
+    # But this can be solved by factoring out y.
+    # No need to use methods for ternary quadratic equations.
+    assert check_solutions(y**2 - 7*x*y + 4*y*z)
+    assert check_solutions(x**2 - 2*x + 1)
+
+    assert diophantine(x - y) == diophantine(Eq(x, y))
+    # 18196
+    eq = x**4 + y**4 - 97
+    assert diophantine(eq, permute=True) == diophantine(-eq, permute=True)
+    assert diophantine(3*x*pi - 2*y*pi) == {(2*t_0, 3*t_0)}
+    eq = x**2 + y**2 + z**2 - 14
+    base_sol = {(1, 2, 3)}
+    assert diophantine(eq) == base_sol
+    complete_soln = set(signed_permutations(base_sol.pop()))
+    assert diophantine(eq, permute=True) == complete_soln
+
+    assert diophantine(x**2 + x*Rational(15, 14) - 3) == set()
+    # test issue 11049
+    eq = 92*x**2 - 99*y**2 - z**2
+    coeff = eq.as_coefficients_dict()
+    assert _diop_ternary_quadratic_normal((x, y, z), coeff) == \
+           {(9, 7, 51)}
+    assert diophantine(eq) == {(
+        891*p**2 + 9*q**2, -693*p**2 - 102*p*q + 7*q**2,
+        5049*p**2 - 1386*p*q - 51*q**2)}
+    eq = 2*x**2 + 2*y**2 - z**2
+    coeff = eq.as_coefficients_dict()
+    assert _diop_ternary_quadratic_normal((x, y, z), coeff) == \
+           {(1, 1, 2)}
+    assert diophantine(eq) == {(
+        2*p**2 - q**2, -2*p**2 + 4*p*q - q**2,
+        4*p**2 - 4*p*q + 2*q**2)}
+    eq = 411*x**2+57*y**2-221*z**2
+    coeff = eq.as_coefficients_dict()
+    assert _diop_ternary_quadratic_normal((x, y, z), coeff) == \
+           {(2021, 2645, 3066)}
+    assert diophantine(eq) == \
+           {(115197*p**2 - 446641*q**2, -150765*p**2 + 1355172*p*q -
+             584545*q**2, 174762*p**2 - 301530*p*q + 677586*q**2)}
+    eq = 573*x**2+267*y**2-984*z**2
+    coeff = eq.as_coefficients_dict()
+    assert _diop_ternary_quadratic_normal((x, y, z), coeff) == \
+           {(49, 233, 127)}
+    assert diophantine(eq) == \
+           {(4361*p**2 - 16072*q**2, -20737*p**2 + 83312*p*q - 76424*q**2,
+             11303*p**2 - 41474*p*q + 41656*q**2)}
+    # this produces factors during reconstruction
+    eq = x**2 + 3*y**2 - 12*z**2
+    coeff = eq.as_coefficients_dict()
+    assert _diop_ternary_quadratic_normal((x, y, z), coeff) == \
+           {(0, 2, 1)}
+    assert diophantine(eq) == \
+           {(24*p*q, 2*p**2 - 24*q**2, p**2 + 12*q**2)}
+    # solvers have not been written for every type
+    raises(NotImplementedError, lambda: diophantine(x*y**2 + 1))
+
+    # rational expressions
+    assert diophantine(1/x) == set()
+    assert diophantine(1/x + 1/y - S.Half) == {(6, 3), (-2, 1), (4, 4), (1, -2), (3, 6)}
+    assert diophantine(x**2 + y**2 +3*x- 5, permute=True) == \
+           {(-1, 1), (-4, -1), (1, -1), (1, 1), (-4, 1), (-1, -1), (4, 1), (4, -1)}
+
+
+    #test issue 18186
+    assert diophantine(y**4 + x**4 - 2**4 - 3**4, syms=(x, y), permute=True) == \
+           {(-3, -2), (-3, 2), (-2, -3), (-2, 3), (2, -3), (2, 3), (3, -2), (3, 2)}
+    assert diophantine(y**4 + x**4 - 2**4 - 3**4, syms=(y, x), permute=True) == \
+           {(-3, -2), (-3, 2), (-2, -3), (-2, 3), (2, -3), (2, 3), (3, -2), (3, 2)}
+
+    # issue 18122
+    assert check_solutions(x**2 - y)
+    assert check_solutions(y**2 - x)
+    assert diophantine((x**2 - y), t) == {(t, t**2)}
+    assert diophantine((y**2 - x), t) == {(t**2, t)}
+
+
+def test_general_pythagorean():
+    from sympy.abc import a, b, c, d, e
+
+    assert check_solutions(a**2 + b**2 + c**2 - d**2)
+    assert check_solutions(a**2 + 4*b**2 + 4*c**2 - d**2)
+    assert check_solutions(9*a**2 + 4*b**2 + 4*c**2 - d**2)
+    assert check_solutions(9*a**2 + 4*b**2 - 25*d**2 + 4*c**2 )
+    assert check_solutions(9*a**2 - 16*d**2 + 4*b**2 + 4*c**2)
+    assert check_solutions(-e**2 + 9*a**2 + 4*b**2 + 4*c**2 + 25*d**2)
+    assert check_solutions(16*a**2 - b**2 + 9*c**2 + d**2 + 25*e**2)
+
+    assert GeneralPythagorean(a**2 + b**2 + c**2 - d**2).solve(parameters=[x, y, z]) == \
+           {(x**2 + y**2 - z**2, 2*x*z, 2*y*z, x**2 + y**2 + z**2)}
+
+
+def test_diop_general_sum_of_squares_quick():
+    for i in range(3, 10):
+        assert check_solutions(sum(i**2 for i in symbols(':%i' % i)) - i)
+
+    assert diop_general_sum_of_squares(x**2 + y**2 - 2) is None
+    assert diop_general_sum_of_squares(x**2 + y**2 + z**2 + 2) == set()
+    eq = x**2 + y**2 + z**2 - (1 + 4 + 9)
+    assert diop_general_sum_of_squares(eq) == \
+           {(1, 2, 3)}
+    eq = u**2 + v**2 + x**2 + y**2 + z**2 - 1313
+    assert len(diop_general_sum_of_squares(eq, 3)) == 3
+    # issue 11016
+    var = symbols(':5') + (symbols('6', negative=True),)
+    eq = Add(*[i**2 for i in var]) - 112
+
+    base_soln = {(0, 1, 1, 5, 6, -7), (1, 1, 1, 3, 6, -8), (2, 3, 3, 4, 5, -7), (0, 1, 1, 1, 3, -10),
+                 (0, 0, 4, 4, 4, -8), (1, 2, 3, 3, 5, -8), (0, 1, 2, 3, 7, -7), (2, 2, 4, 4, 6, -6),
+                 (1, 1, 3, 4, 6, -7), (0, 2, 3, 3, 3, -9), (0, 0, 2, 2, 2, -10), (1, 1, 2, 3, 4, -9),
+                 (0, 1, 1, 2, 5, -9), (0, 0, 2, 6, 6, -6), (1, 3, 4, 5, 5, -6), (0, 2, 2, 2, 6, -8),
+                 (0, 3, 3, 3, 6, -7), (0, 2, 3, 5, 5, -7), (0, 1, 5, 5, 5, -6)}
+    assert diophantine(eq) == base_soln
+    assert len(diophantine(eq, permute=True)) == 196800
+
+    # handle negated squares with signsimp
+    assert diophantine(12 - x**2 - y**2 - z**2) == {(2, 2, 2)}
+    # diophantine handles simplification, so classify_diop should
+    # not have to look for additional patterns that are removed
+    # by diophantine
+    eq = a**2 + b**2 + c**2 + d**2 - 4
+    raises(NotImplementedError, lambda: classify_diop(-eq))
+
+
+def test_issue_23807():
+    # fixes recursion error
+    eq = x**2 + y**2 + z**2 - 1000000
+    base_soln = {(0, 0, 1000), (0, 352, 936), (480, 600, 640), (24, 640, 768), (192, 640, 744),
+                 (192, 480, 856), (168, 224, 960), (0, 600, 800), (280, 576, 768), (152, 480, 864),
+                 (0, 280, 960), (352, 360, 864), (424, 480, 768), (360, 480, 800), (224, 600, 768),
+                 (96, 360, 928), (168, 576, 800), (96, 480, 872)}
+
+    assert diophantine(eq) == base_soln
+
+
+def test_diop_partition():
+    for n in [8, 10]:
+        for k in range(1, 8):
+            for p in partition(n, k):
+                assert len(p) == k
+    assert list(partition(3, 5)) == []
+    assert [list(p) for p in partition(3, 5, 1)] == [
+        [0, 0, 0, 0, 3], [0, 0, 0, 1, 2], [0, 0, 1, 1, 1]]
+    assert list(partition(0)) == [()]
+    assert list(partition(1, 0)) == [()]
+    assert [list(i) for i in partition(3)] == [[1, 1, 1], [1, 2], [3]]
+
+
+def test_prime_as_sum_of_two_squares():
+    for i in [5, 13, 17, 29, 37, 41, 2341, 3557, 34841, 64601]:
+        a, b = prime_as_sum_of_two_squares(i)
+        assert a**2 + b**2 == i
+    assert prime_as_sum_of_two_squares(7) is None
+    ans = prime_as_sum_of_two_squares(800029)
+    assert ans == (450, 773) and type(ans[0]) is int
+
+
+def test_sum_of_three_squares():
+    for i in [0, 1, 2, 34, 123, 34304595905, 34304595905394941, 343045959052344,
+              800, 801, 802, 803, 804, 805, 806]:
+        a, b, c = sum_of_three_squares(i)
+        assert a**2 + b**2 + c**2 == i
+        assert a >= 0
+
+    # error
+    raises(ValueError, lambda: sum_of_three_squares(-1))
+
+    assert sum_of_three_squares(7) is None
+    assert sum_of_three_squares((4**5)*15) is None
+    # if there are two zeros, there might be a solution
+    # with only one zero, e.g. 25 => (0, 3, 4) or
+    # with no zeros, e.g. 49 => (2, 3, 6)
+    assert sum_of_three_squares(25) == (0, 0, 5)
+    assert sum_of_three_squares(4) == (0, 0, 2)
+
+
+def test_sum_of_four_squares():
+    from sympy.core.random import randint
+
+    # this should never fail
+    n = randint(1, 100000000000000)
+    assert sum(i**2 for i in sum_of_four_squares(n)) == n
+
+    # error
+    raises(ValueError, lambda: sum_of_four_squares(-1))
+
+    for n in range(1000):
+        result = sum_of_four_squares(n)
+        assert len(result) == 4
+        assert all(r >= 0 for r in result)
+        assert sum(r**2 for r in result) == n
+        assert list(result) == sorted(result)
+
+
+def test_power_representation():
+    tests = [(1729, 3, 2), (234, 2, 4), (2, 1, 2), (3, 1, 3), (5, 2, 2), (12352, 2, 4),
+             (32760, 2, 3)]
+
+    for test in tests:
+        n, p, k = test
+        f = power_representation(n, p, k)
+
+        while True:
+            try:
+                l = next(f)
+                assert len(l) == k
+
+                chk_sum = 0
+                for l_i in l:
+                    chk_sum = chk_sum + l_i**p
+                assert chk_sum == n
+
+            except StopIteration:
+                break
+
+    assert list(power_representation(20, 2, 4, True)) == \
+        [(1, 1, 3, 3), (0, 0, 2, 4)]
+    raises(ValueError, lambda: list(power_representation(1.2, 2, 2)))
+    raises(ValueError, lambda: list(power_representation(2, 0, 2)))
+    raises(ValueError, lambda: list(power_representation(2, 2, 0)))
+    assert list(power_representation(-1, 2, 2)) == []
+    assert list(power_representation(1, 1, 1)) == [(1,)]
+    assert list(power_representation(3, 2, 1)) == []
+    assert list(power_representation(4, 2, 1)) == [(2,)]
+    assert list(power_representation(3**4, 4, 6, zeros=True)) == \
+        [(1, 2, 2, 2, 2, 2), (0, 0, 0, 0, 0, 3)]
+    assert list(power_representation(3**4, 4, 5, zeros=False)) == []
+    assert list(power_representation(-2, 3, 2)) == [(-1, -1)]
+    assert list(power_representation(-2, 4, 2)) == []
+    assert list(power_representation(0, 3, 2, True)) == [(0, 0)]
+    assert list(power_representation(0, 3, 2, False)) == []
+    # when we are dealing with squares, do feasibility checks
+    assert len(list(power_representation(4**10*(8*10 + 7), 2, 3))) == 0
+    # there will be a recursion error if these aren't recognized
+    big = 2**30
+    for i in [13, 10, 7, 5, 4, 2, 1]:
+        assert list(sum_of_powers(big, 2, big - i)) == []
+
+
+def test_assumptions():
+    """
+    Test whether diophantine respects the assumptions.
+    """
+    #Test case taken from the below so question regarding assumptions in diophantine module
+    #https://stackoverflow.com/questions/23301941/how-can-i-declare-natural-symbols-with-sympy
+    m, n = symbols('m n', integer=True, positive=True)
+    diof = diophantine(n**2 + m*n - 500)
+    assert diof == {(5, 20), (40, 10), (95, 5), (121, 4), (248, 2), (499, 1)}
+
+    a, b = symbols('a b', integer=True, positive=False)
+    diof = diophantine(a*b + 2*a + 3*b - 6)
+    assert diof == {(-15, -3), (-9, -4), (-7, -5), (-6, -6), (-5, -8), (-4, -14)}
+
+    x, y = symbols('x y', integer=True)
+    diof = diophantine(10*x**2 + 5*x*y - 3*y)
+    assert diof == {(1, -5), (-3, 5), (0, 0)}
+
+    x, y = symbols('x y', integer=True, positive=True)
+    diof = diophantine(10*x**2 + 5*x*y - 3*y)
+    assert diof == set()
+
+    x, y = symbols('x y', integer=True, negative=False)
+    diof = diophantine(10*x**2 + 5*x*y - 3*y)
+    assert diof == {(0, 0)}
+
+
+def check_solutions(eq):
+    """
+    Determines whether solutions returned by diophantine() satisfy the original
+    equation. Hope to generalize this so we can remove functions like check_ternay_quadratic,
+    check_solutions_normal, check_solutions()
+    """
+    s = diophantine(eq)
+
+    factors = Mul.make_args(eq)
+
+    var = list(eq.free_symbols)
+    var.sort(key=default_sort_key)
+
+    while s:
+        solution = s.pop()
+        for f in factors:
+            if diop_simplify(f.subs(zip(var, solution))) == 0:
+                break
+        else:
+            return False
+    return True
+
+
+def test_diopcoverage():
+    eq = (2*x + y + 1)**2
+    assert diop_solve(eq) == {(t_0, -2*t_0 - 1)}
+    eq = 2*x**2 + 6*x*y + 12*x + 4*y**2 + 18*y + 18
+    assert diop_solve(eq) == {(t, -t - 3), (-2*t - 3, t)}
+    assert diop_quadratic(x + y**2 - 3) == {(-t**2 + 3, t)}
+
+    assert diop_linear(x + y - 3) == (t_0, 3 - t_0)
+
+    assert base_solution_linear(0, 1, 2, t=None) == (0, 0)
+    ans = (3*t - 1, -2*t + 1)
+    assert base_solution_linear(4, 8, 12, t) == ans
+    assert base_solution_linear(4, 8, 12, t=None) == tuple(_.subs(t, 0) for _ in ans)
+
+    assert cornacchia(1, 1, 20) == set()
+    assert cornacchia(1, 1, 5) == {(2, 1)}
+    assert cornacchia(1, 2, 17) == {(3, 2)}
+
+    raises(ValueError, lambda: reconstruct(4, 20, 1))
+
+    assert gaussian_reduce(4, 1, 3) == (1, 1)
+    eq = -w**2 - x**2 - y**2 + z**2
+
+    assert diop_general_pythagorean(eq) == \
+        diop_general_pythagorean(-eq) == \
+            (m1**2 + m2**2 - m3**2, 2*m1*m3,
+            2*m2*m3, m1**2 + m2**2 + m3**2)
+
+    assert len(check_param(S(3) + x/3, S(4) + x/2, S(2), [x])) == 0
+    assert len(check_param(Rational(3, 2), S(4) + x, S(2), [x])) == 0
+    assert len(check_param(S(4) + x, Rational(3, 2), S(2), [x])) == 0
+
+    assert _nint_or_floor(16, 10) == 2
+    assert _odd(1) == (not _even(1)) == True
+    assert _odd(0) == (not _even(0)) == False
+    assert _remove_gcd(2, 4, 6) == (1, 2, 3)
+    raises(TypeError, lambda: _remove_gcd((2, 4, 6)))
+    assert sqf_normal(2*3**2*5, 2*5*11, 2*7**2*11)  == \
+        (11, 1, 5)
+
+    # it's ok if these pass some day when the solvers are implemented
+    raises(NotImplementedError, lambda: diophantine(x**2 + y**2 + x*y + 2*y*z - 12))
+    raises(NotImplementedError, lambda: diophantine(x**3 + y**2))
+    assert diop_quadratic(x**2 + y**2 - 1**2 - 3**4) == \
+           {(-9, -1), (-9, 1), (-1, -9), (-1, 9), (1, -9), (1, 9), (9, -1), (9, 1)}
+
+
+def test_holzer():
+    # if the input is good, don't let it diverge in holzer()
+    # (but see test_fail_holzer below)
+    assert holzer(2, 7, 13, 4, 79, 23) == (2, 7, 13)
+
+    # None in uv condition met; solution is not Holzer reduced
+    # so this will hopefully change but is here for coverage
+    assert holzer(2, 6, 2, 1, 1, 10) == (2, 6, 2)
+
+    raises(ValueError, lambda: holzer(2, 7, 14, 4, 79, 23))
+
+
+@XFAIL
+def test_fail_holzer():
+    eq = lambda x, y, z: a*x**2 + b*y**2 - c*z**2
+    a, b, c = 4, 79, 23
+    x, y, z = xyz = 26, 1, 11
+    X, Y, Z = ans = 2, 7, 13
+    assert eq(*xyz) == 0
+    assert eq(*ans) == 0
+    assert max(a*x**2, b*y**2, c*z**2) <= a*b*c
+    assert max(a*X**2, b*Y**2, c*Z**2) <= a*b*c
+    h = holzer(x, y, z, a, b, c)
+    assert h == ans  # it would be nice to get the smaller soln
+
+
+def test_issue_9539():
+    assert diophantine(6*w + 9*y + 20*x - z) == \
+           {(t_0, t_1, t_1 + t_2, 6*t_0 + 29*t_1 + 9*t_2)}
+
+
+def test_issue_8943():
+    assert diophantine(
+        3*(x**2 + y**2 + z**2) - 14*(x*y + y*z + z*x)) == \
+           {(0, 0, 0)}
+
+
+def test_diop_sum_of_even_powers():
+    eq = x**4 + y**4 + z**4 - 2673
+    assert diop_solve(eq) == {(3, 6, 6), (2, 4, 7)}
+    assert diop_general_sum_of_even_powers(eq, 2) == {(3, 6, 6), (2, 4, 7)}
+    raises(NotImplementedError, lambda: diop_general_sum_of_even_powers(-eq, 2))
+    neg = symbols('neg', negative=True)
+    eq = x**4 + y**4 + neg**4 - 2673
+    assert diop_general_sum_of_even_powers(eq) == {(-3, 6, 6)}
+    assert diophantine(x**4 + y**4 + 2) == set()
+    assert diop_general_sum_of_even_powers(x**4 + y**4 - 2, limit=0) == set()
+
+
+def test_sum_of_squares_powers():
+    tru = {(0, 0, 1, 1, 11), (0, 0, 5, 7, 7), (0, 1, 3, 7, 8), (0, 1, 4, 5, 9), (0, 3, 4, 7, 7), (0, 3, 5, 5, 8),
+           (1, 1, 2, 6, 9), (1, 1, 6, 6, 7), (1, 2, 3, 3, 10), (1, 3, 4, 4, 9), (1, 5, 5, 6, 6), (2, 2, 3, 5, 9),
+           (2, 3, 5, 6, 7), (3, 3, 4, 5, 8)}
+    eq = u**2 + v**2 + x**2 + y**2 + z**2 - 123
+    ans = diop_general_sum_of_squares(eq, oo)  # allow oo to be used
+    assert len(ans) == 14
+    assert ans == tru
+
+    raises(ValueError, lambda: list(sum_of_squares(10, -1)))
+    assert list(sum_of_squares(1, 1)) == [(1,)]
+    assert list(sum_of_squares(1, 2)) == []
+    assert list(sum_of_squares(1, 2, True)) == [(0, 1)]
+    assert list(sum_of_squares(-10, 2)) == []
+    assert list(sum_of_squares(2, 3)) == []
+    assert list(sum_of_squares(0, 3, True)) == [(0, 0, 0)]
+    assert list(sum_of_squares(0, 3)) == []
+    assert list(sum_of_squares(4, 1)) == [(2,)]
+    assert list(sum_of_squares(5, 1)) == []
+    assert list(sum_of_squares(50, 2)) == [(5, 5), (1, 7)]
+    assert list(sum_of_squares(11, 5, True)) == [
+        (1, 1, 1, 2, 2), (0, 0, 1, 1, 3)]
+    assert list(sum_of_squares(8, 8)) == [(1, 1, 1, 1, 1, 1, 1, 1)]
+
+    assert [len(list(sum_of_squares(i, 5, True))) for i in range(30)] == [
+        1, 1, 1, 1, 2,
+        2, 1, 1, 2, 2,
+        2, 2, 2, 3, 2,
+        1, 3, 3, 3, 3,
+        4, 3, 3, 2, 2,
+        4, 4, 4, 4, 5]
+    assert [len(list(sum_of_squares(i, 5))) for i in range(30)] == [
+        0, 0, 0, 0, 0,
+        1, 0, 0, 1, 0,
+        0, 1, 0, 1, 1,
+        0, 1, 1, 0, 1,
+        2, 1, 1, 1, 1,
+        1, 1, 1, 1, 3]
+    for i in range(30):
+        s1 = set(sum_of_squares(i, 5, True))
+        assert not s1 or all(sum(j**2 for j in t) == i for t in s1)
+        s2 = set(sum_of_squares(i, 5))
+        assert all(sum(j**2 for j in t) == i for t in s2)
+
+    raises(ValueError, lambda: list(sum_of_powers(2, -1, 1)))
+    raises(ValueError, lambda: list(sum_of_powers(2, 1, -1)))
+    assert list(sum_of_powers(-2, 3, 2)) == [(-1, -1)]
+    assert list(sum_of_powers(-2, 4, 2)) == []
+    assert list(sum_of_powers(2, 1, 1)) == [(2,)]
+    assert list(sum_of_powers(2, 1, 3, True)) == [(0, 0, 2), (0, 1, 1)]
+    assert list(sum_of_powers(5, 1, 2, True)) == [(0, 5), (1, 4), (2, 3)]
+    assert list(sum_of_powers(6, 2, 2)) == []
+    assert list(sum_of_powers(3**5, 3, 1)) == []
+    assert list(sum_of_powers(3**6, 3, 1)) == [(9,)] and (9**3 == 3**6)
+    assert list(sum_of_powers(2**1000, 5, 2)) == []
+
+
+def test__can_do_sum_of_squares():
+    assert _can_do_sum_of_squares(3, -1) is False
+    assert _can_do_sum_of_squares(-3, 1) is False
+    assert _can_do_sum_of_squares(0, 1)
+    assert _can_do_sum_of_squares(4, 1)
+    assert _can_do_sum_of_squares(1, 2)
+    assert _can_do_sum_of_squares(2, 2)
+    assert _can_do_sum_of_squares(3, 2) is False
+
+
+def test_diophantine_permute_sign():
+    from sympy.abc import a, b, c, d, e
+    eq = a**4 + b**4 - (2**4 + 3**4)
+    base_sol = {(2, 3)}
+    assert diophantine(eq) == base_sol
+    complete_soln = set(signed_permutations(base_sol.pop()))
+    assert diophantine(eq, permute=True) == complete_soln
+
+    eq = a**2 + b**2 + c**2 + d**2 + e**2 - 234
+    assert len(diophantine(eq)) == 35
+    assert len(diophantine(eq, permute=True)) == 62000
+    soln = {(-1, -1), (-1, 2), (1, -2), (1, 1)}
+    assert diophantine(10*x**2 + 12*x*y + 12*y**2 - 34, permute=True) == soln
+
+
+@XFAIL
+def test_not_implemented():
+    eq = x**2 + y**4 - 1**2 - 3**4
+    assert diophantine(eq, syms=[x, y]) == {(9, 1), (1, 3)}
+
+
+def test_issue_9538():
+    eq = x - 3*y + 2
+    assert diophantine(eq, syms=[y,x]) == {(t_0, 3*t_0 - 2)}
+    raises(TypeError, lambda: diophantine(eq, syms={y, x}))
+
+
+def test_ternary_quadratic():
+    # solution with 3 parameters
+    s = diophantine(2*x**2 + y**2 - 2*z**2)
+    p, q, r = ordered(S(s).free_symbols)
+    assert s == {(
+        p**2 - 2*q**2,
+        -2*p**2 + 4*p*q - 4*p*r - 4*q**2,
+        p**2 - 4*p*q + 2*q**2 - 4*q*r)}
+    # solution with Mul in solution
+    s = diophantine(x**2 + 2*y**2 - 2*z**2)
+    assert s == {(4*p*q, p**2 - 2*q**2, p**2 + 2*q**2)}
+    # solution with no Mul in solution
+    s = diophantine(2*x**2 + 2*y**2 - z**2)
+    assert s == {(2*p**2 - q**2, -2*p**2 + 4*p*q - q**2,
+        4*p**2 - 4*p*q + 2*q**2)}
+    # reduced form when parametrized
+    s = diophantine(3*x**2 + 72*y**2 - 27*z**2)
+    assert s == {(24*p**2 - 9*q**2, 6*p*q, 8*p**2 + 3*q**2)}
+    assert parametrize_ternary_quadratic(
+        3*x**2 + 2*y**2 - z**2 - 2*x*y + 5*y*z - 7*y*z) == (
+        2*p**2 - 2*p*q - q**2, 2*p**2 + 2*p*q - q**2, 2*p**2 -
+        2*p*q + 3*q**2)
+    assert parametrize_ternary_quadratic(
+        124*x**2 - 30*y**2 - 7729*z**2) == (
+        -1410*p**2 - 363263*q**2, 2700*p**2 + 30916*p*q -
+        695610*q**2, -60*p**2 + 5400*p*q + 15458*q**2)
+
+
+def test_diophantine_solution_set():
+    s1 = DiophantineSolutionSet([], [])
+    assert set(s1) == set()
+    assert s1.symbols == ()
+    assert s1.parameters == ()
+    raises(ValueError, lambda: s1.add((x,)))
+    assert list(s1.dict_iterator()) == []
+
+    s2 = DiophantineSolutionSet([x, y], [t, u])
+    assert s2.symbols == (x, y)
+    assert s2.parameters == (t, u)
+    raises(ValueError, lambda: s2.add((1,)))
+    s2.add((3, 4))
+    assert set(s2) == {(3, 4)}
+    s2.update((3, 4), (-1, u))
+    assert set(s2) == {(3, 4), (-1, u)}
+    raises(ValueError, lambda: s1.update(s2))
+    assert list(s2.dict_iterator()) == [{x: -1, y: u}, {x: 3, y: 4}]
+
+    s3 = DiophantineSolutionSet([x, y, z], [t, u])
+    assert len(s3.parameters) == 2
+    s3.add((t**2 + u, t - u, 1))
+    assert set(s3) == {(t**2 + u, t - u, 1)}
+    assert s3.subs(t, 2) == {(u + 4, 2 - u, 1)}
+    assert s3(2) == {(u + 4, 2 - u, 1)}
+    assert s3.subs({t: 7, u: 8}) == {(57, -1, 1)}
+    assert s3(7, 8) == {(57, -1, 1)}
+    assert s3.subs({t: 5}) == {(u + 25, 5 - u, 1)}
+    assert s3(5) == {(u + 25, 5 - u, 1)}
+    assert s3.subs(u, -3) == {(t**2 - 3, t + 3, 1)}
+    assert s3(None, -3) == {(t**2 - 3, t + 3, 1)}
+    assert s3.subs({t: 2, u: 8}) == {(12, -6, 1)}
+    assert s3(2, 8) == {(12, -6, 1)}
+    assert s3.subs({t: 5, u: -3}) == {(22, 8, 1)}
+    assert s3(5, -3) == {(22, 8, 1)}
+    raises(TypeError, lambda: s3.subs(x=1))
+    raises(TypeError, lambda: s3.subs(1, 2, 3))
+    raises(ValueError, lambda: s3.add(()))
+    raises(ValueError, lambda: s3.add((1, 2, 3, 4)))
+    raises(ValueError, lambda: s3.add((1, 2)))
+    raises(ValueError, lambda: s3(1, 2, 3))
+    raises(TypeError, lambda: s3(t=1))
+
+    s4 = DiophantineSolutionSet([x, y], [t, u])
+    s4.add((t, 11*t))
+    s4.add((-t, 22*t))
+    assert s4(0, 0) == {(0, 0)}
+
+
+def test_quadratic_parameter_passing():
+    eq = -33*x*y + 3*y**2
+    solution = BinaryQuadratic(eq).solve(parameters=[t, u])
+    # test that parameters are passed all the way to the final solution
+    assert solution == {(t, 11*t), (t, -22*t)}
+    assert solution(0, 0) == {(0, 0)}
+
+def test_issue_18628():
+    eq1 = x**2 - 15*x + y**2 - 8*y
+    sol = diophantine(eq1)
+    assert sol == {(15, 0), (15, 8), (-1, 4), (0, 0), (0, 8), (16, 4)}
+    eq2 = 2*x**2 - 9*x + 4*y**2 - 8*y + 14
+    sol = diophantine(eq2)
+    assert sol == {(2, 1)}
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/ode/__init__.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/ode/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..2b543425251dea6380a1860279cb6d636f3dd629
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/ode/__init__.py
@@ -0,0 +1,16 @@
+from .ode import (allhints, checkinfsol, classify_ode,
+        constantsimp, dsolve, homogeneous_order)
+
+from .lie_group import infinitesimals
+
+from .subscheck import checkodesol
+
+from .systems import (canonical_odes, linear_ode_to_matrix,
+        linodesolve)
+
+
+__all__ = [
+    'allhints', 'checkinfsol', 'checkodesol', 'classify_ode', 'constantsimp',
+    'dsolve', 'homogeneous_order', 'infinitesimals', 'canonical_odes', 'linear_ode_to_matrix',
+    'linodesolve'
+]
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/ode/__pycache__/__init__.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/ode/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..3e433e6ba6bb6f63fd6172bfc740eb6db5898c17
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/ode/__pycache__/__init__.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/ode/__pycache__/hypergeometric.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/ode/__pycache__/hypergeometric.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..19969fcd2651729d4386354c8d5ff08bf0fa4742
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/ode/__pycache__/hypergeometric.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/ode/__pycache__/lie_group.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/ode/__pycache__/lie_group.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..640babf7ddac8e198f510e8af5a2c49bbf180ab6
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/ode/__pycache__/lie_group.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/ode/__pycache__/nonhomogeneous.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/ode/__pycache__/nonhomogeneous.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..435bf882c4dcb505fe551383bc8b853e39dde459
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/ode/__pycache__/nonhomogeneous.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/ode/__pycache__/ode.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/ode/__pycache__/ode.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..149bf5b44449806fdc61f153fccec5918b9f1ff7
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/ode/__pycache__/ode.cpython-312.pyc
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:237920f7762b4f727de73062a35c2d8169bf1ba8fa47348619880cca23966191
+size 187710
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/ode/__pycache__/riccati.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/ode/__pycache__/riccati.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b0c595ca3220a7651b4462c5a646fb4207f23bee
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/ode/__pycache__/riccati.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/ode/__pycache__/single.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/ode/__pycache__/single.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..8902355bf9e98df7eacc9588b5bba8a612baf61b
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/ode/__pycache__/single.cpython-312.pyc
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c759802920fe93d1f00d0e7305eb77ddbe5ce9a97176c734fd0440fe034a8426
+size 144733
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/ode/__pycache__/subscheck.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/ode/__pycache__/subscheck.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5057d7b94e979aec99e9f5847dde0ea22d8863ab
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/ode/__pycache__/subscheck.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/ode/__pycache__/systems.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/ode/__pycache__/systems.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..e41263e210ba58437c3678d2d8eac4373850eb9d
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/ode/__pycache__/systems.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/ode/hypergeometric.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/ode/hypergeometric.py
new file mode 100644
index 0000000000000000000000000000000000000000..5699d2418058acaf48d1e4f87f6635a7b1f7284c
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/ode/hypergeometric.py
@@ -0,0 +1,272 @@
+r'''
+This module contains the implementation of the 2nd_hypergeometric hint for
+dsolve. This is an incomplete implementation of the algorithm described in [1].
+The algorithm solves 2nd order linear ODEs of the form
+
+.. math:: y'' + A(x) y' + B(x) y = 0\text{,}
+
+where `A` and `B` are rational functions. The algorithm should find any
+solution of the form
+
+.. math:: y = P(x) _pF_q(..; ..;\frac{\alpha x^k + \beta}{\gamma x^k + \delta})\text{,}
+
+where pFq is any of 2F1, 1F1 or 0F1 and `P` is an "arbitrary function".
+Currently only the 2F1 case is implemented in SymPy but the other cases are
+described in the paper and could be implemented in future (contributions
+welcome!).
+
+References
+==========
+
+.. [1] L. Chan, E.S. Cheb-Terrab, Non-Liouvillian solutions for second order
+       linear ODEs, (2004).
+       https://arxiv.org/abs/math-ph/0402063
+'''
+
+from sympy.core import S, Pow
+from sympy.core.function import expand
+from sympy.core.relational import Eq
+from sympy.core.symbol import Symbol, Wild
+from sympy.functions import exp, sqrt, hyper
+from sympy.integrals import Integral
+from sympy.polys import roots, gcd
+from sympy.polys.polytools import cancel, factor
+from sympy.simplify import collect, simplify, logcombine # type: ignore
+from sympy.simplify.powsimp import powdenest
+from sympy.solvers.ode.ode import get_numbered_constants
+
+
+def match_2nd_hypergeometric(eq, func):
+    x = func.args[0]
+    df = func.diff(x)
+    a3 = Wild('a3', exclude=[func, func.diff(x), func.diff(x, 2)])
+    b3 = Wild('b3', exclude=[func, func.diff(x), func.diff(x, 2)])
+    c3 = Wild('c3', exclude=[func, func.diff(x), func.diff(x, 2)])
+    deq = a3*(func.diff(x, 2)) + b3*df + c3*func
+    r = collect(eq,
+        [func.diff(x, 2), func.diff(x), func]).match(deq)
+    if r:
+        if not all(val.is_polynomial() for val in r.values()):
+            n, d = eq.as_numer_denom()
+            eq = expand(n)
+            r = collect(eq, [func.diff(x, 2), func.diff(x), func]).match(deq)
+
+    if r and r[a3]!=0:
+        A = cancel(r[b3]/r[a3])
+        B = cancel(r[c3]/r[a3])
+        return [A, B]
+    else:
+        return []
+
+
+def equivalence_hypergeometric(A, B, func):
+    # This method for finding the equivalence is only for 2F1 type.
+    # We can extend it for 1F1 and 0F1 type also.
+    x = func.args[0]
+
+    # making given equation in normal form
+    I1 = factor(cancel(A.diff(x)/2 + A**2/4 - B))
+
+    # computing shifted invariant(J1) of the equation
+    J1 = factor(cancel(x**2*I1 + S(1)/4))
+    num, dem = J1.as_numer_denom()
+    num = powdenest(expand(num))
+    dem = powdenest(expand(dem))
+    # this function will compute the different powers of variable(x) in J1.
+    # then it will help in finding value of k. k is power of x such that we can express
+    # J1 = x**k * J0(x**k) then all the powers in J0 become integers.
+    def _power_counting(num):
+        _pow = {0}
+        for val in num:
+            if val.has(x):
+                if isinstance(val, Pow) and val.as_base_exp()[0] == x:
+                    _pow.add(val.as_base_exp()[1])
+                elif val == x:
+                    _pow.add(val.as_base_exp()[1])
+                else:
+                    _pow.update(_power_counting(val.args))
+        return _pow
+
+    pow_num = _power_counting((num, ))
+    pow_dem = _power_counting((dem, ))
+    pow_dem.update(pow_num)
+
+    _pow = pow_dem
+    k = gcd(_pow)
+
+    # computing I0 of the given equation
+    I0 = powdenest(simplify(factor(((J1/k**2) - S(1)/4)/((x**k)**2))), force=True)
+    I0 = factor(cancel(powdenest(I0.subs(x, x**(S(1)/k)), force=True)))
+
+    # Before this point I0, J1 might be functions of e.g. sqrt(x) but replacing
+    # x with x**(1/k) should result in I0 being a rational function of x or
+    # otherwise the hypergeometric solver cannot be used. Note that k can be a
+    # non-integer rational such as 2/7.
+    if not I0.is_rational_function(x):
+        return None
+
+    num, dem = I0.as_numer_denom()
+
+    max_num_pow = max(_power_counting((num, )))
+    dem_args = dem.args
+    sing_point = []
+    dem_pow = []
+    # calculating singular point of I0.
+    for arg in dem_args:
+        if arg.has(x):
+            if isinstance(arg, Pow):
+                # (x-a)**n
+                dem_pow.append(arg.as_base_exp()[1])
+                sing_point.append(list(roots(arg.as_base_exp()[0], x).keys())[0])
+            else:
+                # (x-a) type
+                dem_pow.append(arg.as_base_exp()[1])
+                sing_point.append(list(roots(arg, x).keys())[0])
+
+    dem_pow.sort()
+    # checking if equivalence is exists or not.
+
+    if equivalence(max_num_pow, dem_pow) == "2F1":
+        return {'I0':I0, 'k':k, 'sing_point':sing_point, 'type':"2F1"}
+    else:
+        return None
+
+
+def match_2nd_2F1_hypergeometric(I, k, sing_point, func):
+    x = func.args[0]
+    a = Wild("a")
+    b = Wild("b")
+    c = Wild("c")
+    t = Wild("t")
+    s = Wild("s")
+    r = Wild("r")
+    alpha = Wild("alpha")
+    beta = Wild("beta")
+    gamma = Wild("gamma")
+    delta = Wild("delta")
+    # I0 of the standard 2F1 equation.
+    I0 = ((a-b+1)*(a-b-1)*x**2 + 2*((1-a-b)*c + 2*a*b)*x + c*(c-2))/(4*x**2*(x-1)**2)
+    if sing_point != [0, 1]:
+        # If singular point is [0, 1] then we have standard equation.
+        eqs = []
+        sing_eqs = [-beta/alpha, -delta/gamma, (delta-beta)/(alpha-gamma)]
+        # making equations for the finding the mobius transformation
+        for i in range(3):
+            if i<len(sing_point):
+                eqs.append(Eq(sing_eqs[i], sing_point[i]))
+            else:
+                eqs.append(Eq(1/sing_eqs[i], 0))
+        # solving above equations for the mobius transformation
+        _beta = -alpha*sing_point[0]
+        _delta = -gamma*sing_point[1]
+        _gamma = alpha
+        if len(sing_point) == 3:
+            _gamma = (_beta + sing_point[2]*alpha)/(sing_point[2] - sing_point[1])
+        mob = (alpha*x + beta)/(gamma*x + delta)
+        mob = mob.subs(beta, _beta)
+        mob = mob.subs(delta, _delta)
+        mob = mob.subs(gamma, _gamma)
+        mob = cancel(mob)
+        t = (beta - delta*x)/(gamma*x - alpha)
+        t = cancel(((t.subs(beta, _beta)).subs(delta, _delta)).subs(gamma, _gamma))
+    else:
+        mob = x
+        t = x
+
+    # applying mobius transformation in I to make it into I0.
+    I = I.subs(x, t)
+    I = I*(t.diff(x))**2
+    I = factor(I)
+    dict_I = {x**2:0, x:0, 1:0}
+    I0_num, I0_dem = I0.as_numer_denom()
+    # collecting coeff of (x**2, x), of the standard equation.
+    # substituting (a-b) = s, (a+b) = r
+    dict_I0 = {x**2:s**2 - 1, x:(2*(1-r)*c + (r+s)*(r-s)), 1:c*(c-2)}
+    # collecting coeff of (x**2, x) from I0 of the given equation.
+    dict_I.update(collect(expand(cancel(I*I0_dem)), [x**2, x], evaluate=False))
+    eqs = []
+    # We are comparing the coeff of powers of different x, for finding the values of
+    # parameters of standard equation.
+    for key in [x**2, x, 1]:
+        eqs.append(Eq(dict_I[key], dict_I0[key]))
+
+    # We can have many possible roots for the equation.
+    # I am selecting the root on the basis that when we have
+    # standard equation eq = x*(x-1)*f(x).diff(x, 2) + ((a+b+1)*x-c)*f(x).diff(x) + a*b*f(x)
+    # then root should be a, b, c.
+
+    _c = 1 - factor(sqrt(1+eqs[2].lhs))
+    if not _c.has(Symbol):
+        _c = min(list(roots(eqs[2], c)))
+    _s = factor(sqrt(eqs[0].lhs + 1))
+    _r = _c - factor(sqrt(_c**2 + _s**2 + eqs[1].lhs - 2*_c))
+    _a = (_r + _s)/2
+    _b = (_r - _s)/2
+
+    rn = {'a':simplify(_a), 'b':simplify(_b), 'c':simplify(_c), 'k':k, 'mobius':mob, 'type':"2F1"}
+    return rn
+
+
+def equivalence(max_num_pow, dem_pow):
+    # this function is made for checking the equivalence with 2F1 type of equation.
+    # max_num_pow is the value of maximum power of x in numerator
+    # and dem_pow is list of powers of different factor of form (a*x b).
+    # reference from table 1 in paper - "Non-Liouvillian solutions for second order
+    # linear ODEs" by L. Chan, E.S. Cheb-Terrab.
+    # We can extend it for 1F1 and 0F1 type also.
+
+    if max_num_pow == 2:
+        if dem_pow in [[2, 2], [2, 2, 2]]:
+            return "2F1"
+    elif max_num_pow == 1:
+        if dem_pow in [[1, 2, 2], [2, 2, 2], [1, 2], [2, 2]]:
+            return "2F1"
+    elif max_num_pow == 0:
+        if dem_pow in [[1, 1, 2], [2, 2], [1, 2, 2], [1, 1], [2], [1, 2], [2, 2]]:
+            return "2F1"
+
+    return None
+
+
+def get_sol_2F1_hypergeometric(eq, func, match_object):
+    x = func.args[0]
+    from sympy.simplify.hyperexpand import hyperexpand
+    from sympy.polys.polytools import factor
+    C0, C1 = get_numbered_constants(eq, num=2)
+    a = match_object['a']
+    b = match_object['b']
+    c = match_object['c']
+    A = match_object['A']
+
+    sol = None
+
+    if c.is_integer == False:
+        sol = C0*hyper([a, b], [c], x) + C1*hyper([a-c+1, b-c+1], [2-c], x)*x**(1-c)
+    elif c == 1:
+        y2 = Integral(exp(Integral((-(a+b+1)*x + c)/(x**2-x), x))/(hyperexpand(hyper([a, b], [c], x))**2), x)*hyper([a, b], [c], x)
+        sol = C0*hyper([a, b], [c], x) + C1*y2
+    elif (c-a-b).is_integer == False:
+        sol = C0*hyper([a, b], [1+a+b-c], 1-x) + C1*hyper([c-a, c-b], [1+c-a-b], 1-x)*(1-x)**(c-a-b)
+
+    if sol:
+        # applying transformation in the solution
+        subs = match_object['mobius']
+        dtdx = simplify(1/(subs.diff(x)))
+        _B = ((a + b + 1)*x - c).subs(x, subs)*dtdx
+        _B = factor(_B + ((x**2 -x).subs(x, subs))*(dtdx.diff(x)*dtdx))
+        _A = factor((x**2 - x).subs(x, subs)*(dtdx**2))
+        e = exp(logcombine(Integral(cancel(_B/(2*_A)), x), force=True))
+        sol = sol.subs(x, match_object['mobius'])
+        sol = sol.subs(x, x**match_object['k'])
+        e = e.subs(x, x**match_object['k'])
+
+        if not A.is_zero:
+            e1 = Integral(A/2, x)
+            e1 = exp(logcombine(e1, force=True))
+            sol = cancel((e/e1)*x**((-match_object['k']+1)/2))*sol
+            sol = Eq(func, sol)
+            return sol
+
+        sol = cancel((e)*x**((-match_object['k']+1)/2))*sol
+        sol = Eq(func, sol)
+    return sol
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/ode/lie_group.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/ode/lie_group.py
new file mode 100644
index 0000000000000000000000000000000000000000..260fe33f3771b76e28266062e6a993a2786aaf3b
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/ode/lie_group.py
@@ -0,0 +1,1096 @@
+r"""
+This module contains the implementation of the internal helper functions for the lie_group hint for
+dsolve. These helper functions apply different heuristics on the given equation
+and return the solution. These functions are used by :py:meth:`sympy.solvers.ode.single.LieGroup`
+
+References
+=========
+
+- `abaco1_simple`, `function_sum` and `chi`  are referenced from E.S Cheb-Terrab, L.G.S Duarte
+and L.A,C.P da Mota, Computer Algebra Solving of First Order ODEs Using
+Symmetry Methods, pp. 7 - pp. 8
+
+- `abaco1_product`, `abaco2_similar`, `abaco2_unique_unknown`, `linear`  and `abaco2_unique_general`
+are referenced from E.S. Cheb-Terrab, A.D. Roche, Symmetries and First Order
+ODE Patterns, pp. 7 - pp. 12
+
+- `bivariate` from Lie Groups and Differential Equations pp. 327 - pp. 329
+
+"""
+from itertools import islice
+
+from sympy.core import Add, S, Mul, Pow
+from sympy.core.exprtools import factor_terms
+from sympy.core.function import Function, AppliedUndef, expand
+from sympy.core.relational import Equality, Eq
+from sympy.core.symbol import Symbol, Wild, Dummy, symbols
+from sympy.functions import exp, log
+from sympy.integrals.integrals import integrate
+from sympy.polys import Poly
+from sympy.polys.polytools import cancel, div
+from sympy.simplify import (collect, powsimp,  # type: ignore
+    separatevars, simplify)
+from sympy.solvers import solve
+from sympy.solvers.pde import pdsolve
+
+from sympy.utilities import numbered_symbols
+from sympy.solvers.deutils import _preprocess, ode_order
+from .ode import checkinfsol
+
+
+lie_heuristics = (
+    "abaco1_simple",
+    "abaco1_product",
+    "abaco2_similar",
+    "abaco2_unique_unknown",
+    "abaco2_unique_general",
+    "linear",
+    "function_sum",
+    "bivariate",
+    "chi"
+    )
+
+
+def _ode_lie_group_try_heuristic(eq, heuristic, func, match, inf):
+
+    xi = Function("xi")
+    eta = Function("eta")
+    f = func.func
+    x = func.args[0]
+    y = match['y']
+    h = match['h']
+    tempsol = []
+    if not inf:
+        try:
+            inf = infinitesimals(eq, hint=heuristic, func=func, order=1, match=match)
+        except ValueError:
+            return None
+    for infsim in inf:
+        xiinf = (infsim[xi(x, func)]).subs(func, y)
+        etainf = (infsim[eta(x, func)]).subs(func, y)
+        # This condition creates recursion while using pdsolve.
+        # Since the first step while solving a PDE of form
+        # a*(f(x, y).diff(x)) + b*(f(x, y).diff(y)) + c = 0
+        # is to solve the ODE dy/dx = b/a
+        if simplify(etainf/xiinf) == h:
+            continue
+        rpde = f(x, y).diff(x)*xiinf + f(x, y).diff(y)*etainf
+        r = pdsolve(rpde, func=f(x, y)).rhs
+        s = pdsolve(rpde - 1, func=f(x, y)).rhs
+        newcoord = [_lie_group_remove(coord) for coord in [r, s]]
+        r = Dummy("r")
+        s = Dummy("s")
+        C1 = Symbol("C1")
+        rcoord = newcoord[0]
+        scoord = newcoord[-1]
+        try:
+            sol = solve([r - rcoord, s - scoord], x, y, dict=True)
+            if sol == []:
+                continue
+        except NotImplementedError:
+            continue
+        else:
+            sol = sol[0]
+            xsub = sol[x]
+            ysub = sol[y]
+            num = simplify(scoord.diff(x) + scoord.diff(y)*h)
+            denom = simplify(rcoord.diff(x) + rcoord.diff(y)*h)
+            if num and denom:
+                diffeq = simplify((num/denom).subs([(x, xsub), (y, ysub)]))
+                sep = separatevars(diffeq, symbols=[r, s], dict=True)
+                if sep:
+                    # Trying to separate, r and s coordinates
+                    deq = integrate((1/sep[s]), s) + C1 - integrate(sep['coeff']*sep[r], r)
+                    # Substituting and reverting back to original coordinates
+                    deq = deq.subs([(r, rcoord), (s, scoord)])
+                    try:
+                        sdeq = solve(deq, y)
+                    except NotImplementedError:
+                        tempsol.append(deq)
+                    else:
+                        return [Eq(f(x), sol) for sol in sdeq]
+
+
+            elif denom: # (ds/dr) is zero which means s is constant
+                return [Eq(f(x), solve(scoord - C1, y)[0])]
+
+            elif num: # (dr/ds) is zero which means r is constant
+                return [Eq(f(x), solve(rcoord - C1, y)[0])]
+
+    # If nothing works, return solution as it is, without solving for y
+    if tempsol:
+        return [Eq(sol.subs(y, f(x)), 0) for sol in tempsol]
+    return None
+
+
+def _ode_lie_group( s, func, order, match):
+
+    heuristics = lie_heuristics
+    inf = {}
+    f = func.func
+    x = func.args[0]
+    df = func.diff(x)
+    xi = Function("xi")
+    eta = Function("eta")
+    xis = match['xi']
+    etas = match['eta']
+    y = match.pop('y', None)
+    if y:
+        h = -simplify(match[match['d']]/match[match['e']])
+    else:
+        y = Dummy("y")
+        h = s.subs(func, y)
+
+    if xis is not None and etas is not None:
+        inf = [{xi(x, f(x)): S(xis), eta(x, f(x)): S(etas)}]
+
+        if checkinfsol(Eq(df, s), inf, func=f(x), order=1)[0][0]:
+            heuristics = ["user_defined"] + list(heuristics)
+
+    match = {'h': h, 'y': y}
+
+    # This is done so that if any heuristic raises a ValueError
+    # another heuristic can be used.
+    sol = None
+    for heuristic in heuristics:
+        sol = _ode_lie_group_try_heuristic(Eq(df, s), heuristic, func, match, inf)
+        if sol:
+            return sol
+    return sol
+
+
+def infinitesimals(eq, func=None, order=None, hint='default', match=None):
+    r"""
+    The infinitesimal functions of an ordinary differential equation, `\xi(x,y)`
+    and `\eta(x,y)`, are the infinitesimals of the Lie group of point transformations
+    for which the differential equation is invariant. So, the ODE `y'=f(x,y)`
+    would admit a Lie group `x^*=X(x,y;\varepsilon)=x+\varepsilon\xi(x,y)`,
+    `y^*=Y(x,y;\varepsilon)=y+\varepsilon\eta(x,y)` such that `(y^*)'=f(x^*, y^*)`.
+    A change of coordinates, to `r(x,y)` and `s(x,y)`, can be performed so this Lie group
+    becomes the translation group, `r^*=r` and `s^*=s+\varepsilon`.
+    They are tangents to the coordinate curves of the new system.
+
+    Consider the transformation `(x, y) \to (X, Y)` such that the
+    differential equation remains invariant. `\xi` and `\eta` are the tangents to
+    the transformed coordinates `X` and `Y`, at `\varepsilon=0`.
+
+    .. math:: \left(\frac{\partial X(x,y;\varepsilon)}{\partial\varepsilon
+                }\right)|_{\varepsilon=0} = \xi,
+              \left(\frac{\partial Y(x,y;\varepsilon)}{\partial\varepsilon
+                }\right)|_{\varepsilon=0} = \eta,
+
+    The infinitesimals can be found by solving the following PDE:
+
+        >>> from sympy import Function, Eq, pprint
+        >>> from sympy.abc import x, y
+        >>> xi, eta, h = map(Function, ['xi', 'eta', 'h'])
+        >>> h = h(x, y)  # dy/dx = h
+        >>> eta = eta(x, y)
+        >>> xi = xi(x, y)
+        >>> genform = Eq(eta.diff(x) + (eta.diff(y) - xi.diff(x))*h
+        ... - (xi.diff(y))*h**2 - xi*(h.diff(x)) - eta*(h.diff(y)), 0)
+        >>> pprint(genform)
+        /d               d           \                     d              2       d                       d             d
+        |--(eta(x, y)) - --(xi(x, y))|*h(x, y) - eta(x, y)*--(h(x, y)) - h (x, y)*--(xi(x, y)) - xi(x, y)*--(h(x, y)) + --(eta(x, y)) = 0
+        \dy              dx          /                     dy                     dy                      dx            dx
+
+    Solving the above mentioned PDE is not trivial, and can be solved only by
+    making intelligent assumptions for `\xi` and `\eta` (heuristics). Once an
+    infinitesimal is found, the attempt to find more heuristics stops. This is done to
+    optimise the speed of solving the differential equation. If a list of all the
+    infinitesimals is needed, ``hint`` should be flagged as ``all``, which gives
+    the complete list of infinitesimals. If the infinitesimals for a particular
+    heuristic needs to be found, it can be passed as a flag to ``hint``.
+
+    Examples
+    ========
+
+    >>> from sympy import Function
+    >>> from sympy.solvers.ode.lie_group import infinitesimals
+    >>> from sympy.abc import x
+    >>> f = Function('f')
+    >>> eq = f(x).diff(x) - x**2*f(x)
+    >>> infinitesimals(eq)
+    [{eta(x, f(x)): exp(x**3/3), xi(x, f(x)): 0}]
+
+    References
+    ==========
+
+    - Solving differential equations by Symmetry Groups,
+      John Starrett, pp. 1 - pp. 14
+
+    """
+
+    if isinstance(eq, Equality):
+        eq = eq.lhs - eq.rhs
+    if not func:
+        eq, func = _preprocess(eq)
+    variables = func.args
+    if len(variables) != 1:
+        raise ValueError("ODE's have only one independent variable")
+    else:
+        x = variables[0]
+        if not order:
+            order = ode_order(eq, func)
+        if order != 1:
+            raise NotImplementedError("Infinitesimals for only "
+                "first order ODE's have been implemented")
+        else:
+            df = func.diff(x)
+            # Matching differential equation of the form a*df + b
+            a = Wild('a', exclude = [df])
+            b = Wild('b', exclude = [df])
+            if match:  # Used by lie_group hint
+                h = match['h']
+                y = match['y']
+            else:
+                match = collect(expand(eq), df).match(a*df + b)
+                if match:
+                    h = -simplify(match[b]/match[a])
+                else:
+                    try:
+                        sol = solve(eq, df)
+                    except NotImplementedError:
+                        raise NotImplementedError("Infinitesimals for the "
+                            "first order ODE could not be found")
+                    else:
+                        h = sol[0]  # Find infinitesimals for one solution
+                y = Dummy("y")
+                h = h.subs(func, y)
+
+            u = Dummy("u")
+            hx = h.diff(x)
+            hy = h.diff(y)
+            hinv = ((1/h).subs([(x, u), (y, x)])).subs(u, y)  # Inverse ODE
+            match = {'h': h, 'func': func, 'hx': hx, 'hy': hy, 'y': y, 'hinv': hinv}
+            if hint == 'all':
+                xieta = []
+                for heuristic in lie_heuristics:
+                    function = globals()['lie_heuristic_' + heuristic]
+                    inflist = function(match, comp=True)
+                    if inflist:
+                        xieta.extend([inf for inf in inflist if inf not in xieta])
+                if xieta:
+                    return xieta
+                else:
+                    raise NotImplementedError("Infinitesimals could not be found for "
+                        "the given ODE")
+
+            elif hint == 'default':
+                for heuristic in lie_heuristics:
+                    function = globals()['lie_heuristic_' + heuristic]
+                    xieta = function(match, comp=False)
+                    if xieta:
+                        return xieta
+
+                raise NotImplementedError("Infinitesimals could not be found for"
+                    " the given ODE")
+
+            elif hint not in lie_heuristics:
+                raise ValueError("Heuristic not recognized: " + hint)
+
+            else:
+                function = globals()['lie_heuristic_' + hint]
+                xieta = function(match, comp=True)
+                if xieta:
+                    return xieta
+                else:
+                    raise ValueError("Infinitesimals could not be found using the"
+                         " given heuristic")
+
+
+def lie_heuristic_abaco1_simple(match, comp=False):
+    r"""
+    The first heuristic uses the following four sets of
+    assumptions on `\xi` and `\eta`
+
+    .. math:: \xi = 0, \eta = f(x)
+
+    .. math:: \xi = 0, \eta = f(y)
+
+    .. math:: \xi = f(x), \eta = 0
+
+    .. math:: \xi = f(y), \eta = 0
+
+    The success of this heuristic is determined by algebraic factorisation.
+    For the first assumption `\xi = 0` and `\eta` to be a function of `x`, the PDE
+
+    .. math:: \frac{\partial \eta}{\partial x} + (\frac{\partial \eta}{\partial y}
+                - \frac{\partial \xi}{\partial x})*h
+                - \frac{\partial \xi}{\partial y}*h^{2}
+                - \xi*\frac{\partial h}{\partial x} - \eta*\frac{\partial h}{\partial y} = 0
+
+    reduces to `f'(x) - f\frac{\partial h}{\partial y} = 0`
+    If `\frac{\partial h}{\partial y}` is a function of `x`, then this can usually
+    be integrated easily. A similar idea is applied to the other 3 assumptions as well.
+
+
+    References
+    ==========
+
+    - E.S Cheb-Terrab, L.G.S Duarte and L.A,C.P da Mota, Computer Algebra
+      Solving of First Order ODEs Using Symmetry Methods, pp. 8
+
+
+    """
+
+    xieta = []
+    y = match['y']
+    h = match['h']
+    func = match['func']
+    x = func.args[0]
+    hx = match['hx']
+    hy = match['hy']
+    xi = Function('xi')(x, func)
+    eta = Function('eta')(x, func)
+
+    hysym = hy.free_symbols
+    if y not in hysym:
+        try:
+            fx = exp(integrate(hy, x))
+        except NotImplementedError:
+            pass
+        else:
+            inf = {xi: S.Zero, eta: fx}
+            if not comp:
+                return [inf]
+            if comp and inf not in xieta:
+                xieta.append(inf)
+
+    factor = hy/h
+    facsym = factor.free_symbols
+    if x not in facsym:
+        try:
+            fy = exp(integrate(factor, y))
+        except NotImplementedError:
+            pass
+        else:
+            inf = {xi: S.Zero, eta: fy.subs(y, func)}
+            if not comp:
+                return [inf]
+            if comp and inf not in xieta:
+                xieta.append(inf)
+
+    factor = -hx/h
+    facsym = factor.free_symbols
+    if y not in facsym:
+        try:
+            fx = exp(integrate(factor, x))
+        except NotImplementedError:
+            pass
+        else:
+            inf = {xi: fx, eta: S.Zero}
+            if not comp:
+                return [inf]
+            if comp and inf not in xieta:
+                xieta.append(inf)
+
+    factor = -hx/(h**2)
+    facsym = factor.free_symbols
+    if x not in facsym:
+        try:
+            fy = exp(integrate(factor, y))
+        except NotImplementedError:
+            pass
+        else:
+            inf = {xi: fy.subs(y, func), eta: S.Zero}
+            if not comp:
+                return [inf]
+            if comp and inf not in xieta:
+                xieta.append(inf)
+
+    if xieta:
+        return xieta
+
+def lie_heuristic_abaco1_product(match, comp=False):
+    r"""
+    The second heuristic uses the following two assumptions on `\xi` and `\eta`
+
+    .. math:: \eta = 0, \xi = f(x)*g(y)
+
+    .. math:: \eta = f(x)*g(y), \xi = 0
+
+    The first assumption of this heuristic holds good if
+    `\frac{1}{h^{2}}\frac{\partial^2}{\partial x \partial y}\log(h)` is
+    separable in `x` and `y`, then the separated factors containing `x`
+    is `f(x)`, and `g(y)` is obtained by
+
+    .. math:: e^{\int f\frac{\partial}{\partial x}\left(\frac{1}{f*h}\right)\,dy}
+
+    provided `f\frac{\partial}{\partial x}\left(\frac{1}{f*h}\right)` is a function
+    of `y` only.
+
+    The second assumption holds good if `\frac{dy}{dx} = h(x, y)` is rewritten as
+    `\frac{dy}{dx} = \frac{1}{h(y, x)}` and the same properties of the first assumption
+    satisfies. After obtaining `f(x)` and `g(y)`, the coordinates are again
+    interchanged, to get `\eta` as `f(x)*g(y)`
+
+
+    References
+    ==========
+    - E.S. Cheb-Terrab, A.D. Roche, Symmetries and First Order
+      ODE Patterns, pp. 7 - pp. 8
+
+    """
+
+    xieta = []
+    y = match['y']
+    h = match['h']
+    hinv = match['hinv']
+    func = match['func']
+    x = func.args[0]
+    xi = Function('xi')(x, func)
+    eta = Function('eta')(x, func)
+
+
+    inf = separatevars(((log(h).diff(y)).diff(x))/h**2, dict=True, symbols=[x, y])
+    if inf and inf['coeff']:
+        fx = inf[x]
+        gy = simplify(fx*((1/(fx*h)).diff(x)))
+        gysyms = gy.free_symbols
+        if x not in gysyms:
+            gy = exp(integrate(gy, y))
+            inf = {eta: S.Zero, xi: (fx*gy).subs(y, func)}
+            if not comp:
+                return [inf]
+            if comp and inf not in xieta:
+                xieta.append(inf)
+
+    u1 = Dummy("u1")
+    inf = separatevars(((log(hinv).diff(y)).diff(x))/hinv**2, dict=True, symbols=[x, y])
+    if inf and inf['coeff']:
+        fx = inf[x]
+        gy = simplify(fx*((1/(fx*hinv)).diff(x)))
+        gysyms = gy.free_symbols
+        if x not in gysyms:
+            gy = exp(integrate(gy, y))
+            etaval = fx*gy
+            etaval = (etaval.subs([(x, u1), (y, x)])).subs(u1, y)
+            inf = {eta: etaval.subs(y, func), xi: S.Zero}
+            if not comp:
+                return [inf]
+            if comp and inf not in xieta:
+                xieta.append(inf)
+
+    if xieta:
+        return xieta
+
+def lie_heuristic_bivariate(match, comp=False):
+    r"""
+    The third heuristic assumes the infinitesimals `\xi` and `\eta`
+    to be bi-variate polynomials in `x` and `y`. The assumption made here
+    for the logic below is that `h` is a rational function in `x` and `y`
+    though that may not be necessary for the infinitesimals to be
+    bivariate polynomials. The coefficients of the infinitesimals
+    are found out by substituting them in the PDE and grouping similar terms
+    that are polynomials and since they form a linear system, solve and check
+    for non trivial solutions. The degree of the assumed bivariates
+    are increased till a certain maximum value.
+
+    References
+    ==========
+    - Lie Groups and Differential Equations
+      pp. 327 - pp. 329
+
+    """
+
+    h = match['h']
+    hx = match['hx']
+    hy = match['hy']
+    func = match['func']
+    x = func.args[0]
+    y = match['y']
+    xi = Function('xi')(x, func)
+    eta = Function('eta')(x, func)
+
+    if h.is_rational_function():
+        # The maximum degree that the infinitesimals can take is
+        # calculated by this technique.
+        etax, etay, etad, xix, xiy, xid = symbols("etax etay etad xix xiy xid")
+        ipde = etax + (etay - xix)*h - xiy*h**2 - xid*hx - etad*hy
+        num, denom = cancel(ipde).as_numer_denom()
+        deg = Poly(num, x, y).total_degree()
+        deta = Function('deta')(x, y)
+        dxi = Function('dxi')(x, y)
+        ipde = (deta.diff(x) + (deta.diff(y) - dxi.diff(x))*h - (dxi.diff(y))*h**2
+            - dxi*hx - deta*hy)
+        xieq = Symbol("xi0")
+        etaeq = Symbol("eta0")
+
+        for i in range(deg + 1):
+            if i:
+                xieq += Add(*[
+                    Symbol("xi_" + str(power) + "_" + str(i - power))*x**power*y**(i - power)
+                    for power in range(i + 1)])
+                etaeq += Add(*[
+                    Symbol("eta_" + str(power) + "_" + str(i - power))*x**power*y**(i - power)
+                    for power in range(i + 1)])
+            pden, denom = (ipde.subs({dxi: xieq, deta: etaeq}).doit()).as_numer_denom()
+            pden = expand(pden)
+
+            # If the individual terms are monomials, the coefficients
+            # are grouped
+            if pden.is_polynomial(x, y) and pden.is_Add:
+                polyy = Poly(pden, x, y).as_dict()
+            if polyy:
+                symset = xieq.free_symbols.union(etaeq.free_symbols) - {x, y}
+                soldict = solve(polyy.values(), *symset)
+                if isinstance(soldict, list):
+                    soldict = soldict[0]
+                if any(soldict.values()):
+                    xired = xieq.subs(soldict)
+                    etared = etaeq.subs(soldict)
+                    # Scaling is done by substituting one for the parameters
+                    # This can be any number except zero.
+                    dict_ = dict.fromkeys(symset, 1)
+                    inf = {eta: etared.subs(dict_).subs(y, func),
+                        xi: xired.subs(dict_).subs(y, func)}
+                    return [inf]
+
+def lie_heuristic_chi(match, comp=False):
+    r"""
+    The aim of the fourth heuristic is to find the function `\chi(x, y)`
+    that satisfies the PDE `\frac{d\chi}{dx} + h\frac{d\chi}{dx}
+    - \frac{\partial h}{\partial y}\chi = 0`.
+
+    This assumes `\chi` to be a bivariate polynomial in `x` and `y`. By intuition,
+    `h` should be a rational function in `x` and `y`. The method used here is
+    to substitute a general binomial for `\chi` up to a certain maximum degree
+    is reached. The coefficients of the polynomials, are calculated by by collecting
+    terms of the same order in `x` and `y`.
+
+    After finding `\chi`, the next step is to use `\eta = \xi*h + \chi`, to
+    determine `\xi` and `\eta`. This can be done by dividing `\chi` by `h`
+    which would give `-\xi` as the quotient and `\eta` as the remainder.
+
+
+    References
+    ==========
+    - E.S Cheb-Terrab, L.G.S Duarte and L.A,C.P da Mota, Computer Algebra
+      Solving of First Order ODEs Using Symmetry Methods, pp. 8
+
+    """
+
+    h = match['h']
+    hy = match['hy']
+    func = match['func']
+    x = func.args[0]
+    y = match['y']
+    xi = Function('xi')(x, func)
+    eta = Function('eta')(x, func)
+
+    if h.is_rational_function():
+        schi, schix, schiy = symbols("schi, schix, schiy")
+        cpde = schix + h*schiy - hy*schi
+        num, denom = cancel(cpde).as_numer_denom()
+        deg = Poly(num, x, y).total_degree()
+
+        chi = Function('chi')(x, y)
+        chix = chi.diff(x)
+        chiy = chi.diff(y)
+        cpde = chix + h*chiy - hy*chi
+        chieq = Symbol("chi")
+        for i in range(1, deg + 1):
+            chieq += Add(*[
+                Symbol("chi_" + str(power) + "_" + str(i - power))*x**power*y**(i - power)
+                for power in range(i + 1)])
+            cnum, cden = cancel(cpde.subs({chi : chieq}).doit()).as_numer_denom()
+            cnum = expand(cnum)
+            if cnum.is_polynomial(x, y) and cnum.is_Add:
+                cpoly = Poly(cnum, x, y).as_dict()
+                if cpoly:
+                    solsyms = chieq.free_symbols - {x, y}
+                    soldict = solve(cpoly.values(), *solsyms)
+                    if isinstance(soldict, list):
+                        soldict = soldict[0]
+                    if any(soldict.values()):
+                        chieq = chieq.subs(soldict)
+                        dict_ = dict.fromkeys(solsyms, 1)
+                        chieq = chieq.subs(dict_)
+                        # After finding chi, the main aim is to find out
+                        # eta, xi by the equation eta = xi*h + chi
+                        # One method to set xi, would be rearranging it to
+                        # (eta/h) - xi = (chi/h). This would mean dividing
+                        # chi by h would give -xi as the quotient and eta
+                        # as the remainder. Thanks to Sean Vig for suggesting
+                        # this method.
+                        xic, etac = div(chieq, h)
+                        inf = {eta: etac.subs(y, func), xi: -xic.subs(y, func)}
+                        return [inf]
+
+def lie_heuristic_function_sum(match, comp=False):
+    r"""
+    This heuristic uses the following two assumptions on `\xi` and `\eta`
+
+    .. math:: \eta = 0, \xi = f(x) + g(y)
+
+    .. math:: \eta = f(x) + g(y), \xi = 0
+
+    The first assumption of this heuristic holds good if
+
+    .. math:: \frac{\partial}{\partial y}[(h\frac{\partial^{2}}{
+                \partial x^{2}}(h^{-1}))^{-1}]
+
+    is separable in `x` and `y`,
+
+    1. The separated factors containing `y` is `\frac{\partial g}{\partial y}`.
+       From this `g(y)` can be determined.
+    2. The separated factors containing `x` is `f''(x)`.
+    3. `h\frac{\partial^{2}}{\partial x^{2}}(h^{-1})` equals
+       `\frac{f''(x)}{f(x) + g(y)}`. From this `f(x)` can be determined.
+
+    The second assumption holds good if `\frac{dy}{dx} = h(x, y)` is rewritten as
+    `\frac{dy}{dx} = \frac{1}{h(y, x)}` and the same properties of the first
+    assumption satisfies. After obtaining `f(x)` and `g(y)`, the coordinates
+    are again interchanged, to get `\eta` as `f(x) + g(y)`.
+
+    For both assumptions, the constant factors are separated among `g(y)`
+    and `f''(x)`, such that `f''(x)` obtained from 3] is the same as that
+    obtained from 2]. If not possible, then this heuristic fails.
+
+
+    References
+    ==========
+    - E.S. Cheb-Terrab, A.D. Roche, Symmetries and First Order
+      ODE Patterns, pp. 7 - pp. 8
+
+    """
+
+    xieta = []
+    h = match['h']
+    func = match['func']
+    hinv = match['hinv']
+    x = func.args[0]
+    y = match['y']
+    xi = Function('xi')(x, func)
+    eta = Function('eta')(x, func)
+
+    for odefac in [h, hinv]:
+        factor = odefac*((1/odefac).diff(x, 2))
+        sep = separatevars((1/factor).diff(y), dict=True, symbols=[x, y])
+        if sep and sep['coeff'] and sep[x].has(x) and sep[y].has(y):
+            k = Dummy("k")
+            try:
+                gy = k*integrate(sep[y], y)
+            except NotImplementedError:
+                pass
+            else:
+                fdd = 1/(k*sep[x]*sep['coeff'])
+                fx = simplify(fdd/factor - gy)
+                check = simplify(fx.diff(x, 2) - fdd)
+                if fx:
+                    if not check:
+                        fx = fx.subs(k, 1)
+                        gy = (gy/k)
+                    else:
+                        sol = solve(check, k)
+                        if sol:
+                            sol = sol[0]
+                            fx = fx.subs(k, sol)
+                            gy = (gy/k)*sol
+                        else:
+                            continue
+                    if odefac == hinv:  # Inverse ODE
+                        fx = fx.subs(x, y)
+                        gy = gy.subs(y, x)
+                    etaval = factor_terms(fx + gy)
+                    if etaval.is_Mul:
+                        etaval = Mul(*[arg for arg in etaval.args if arg.has(x, y)])
+                    if odefac == hinv:  # Inverse ODE
+                        inf = {eta: etaval.subs(y, func), xi : S.Zero}
+                    else:
+                        inf = {xi: etaval.subs(y, func), eta : S.Zero}
+                    if not comp:
+                        return [inf]
+                    else:
+                        xieta.append(inf)
+
+        if xieta:
+            return xieta
+
+def lie_heuristic_abaco2_similar(match, comp=False):
+    r"""
+    This heuristic uses the following two assumptions on `\xi` and `\eta`
+
+    .. math:: \eta = g(x), \xi = f(x)
+
+    .. math:: \eta = f(y), \xi = g(y)
+
+    For the first assumption,
+
+    1. First `\frac{\frac{\partial h}{\partial y}}{\frac{\partial^{2} h}{
+       \partial yy}}` is calculated. Let us say this value is A
+
+    2. If this is constant, then `h` is matched to the form `A(x) + B(x)e^{
+       \frac{y}{C}}` then, `\frac{e^{\int \frac{A(x)}{C} \,dx}}{B(x)}` gives `f(x)`
+       and `A(x)*f(x)` gives `g(x)`
+
+    3. Otherwise `\frac{\frac{\partial A}{\partial X}}{\frac{\partial A}{
+       \partial Y}} = \gamma` is calculated. If
+
+       a] `\gamma` is a function of `x` alone
+
+       b] `\frac{\gamma\frac{\partial h}{\partial y} - \gamma'(x) - \frac{
+       \partial h}{\partial x}}{h + \gamma} = G` is a function of `x` alone.
+       then, `e^{\int G \,dx}` gives `f(x)` and `-\gamma*f(x)` gives `g(x)`
+
+    The second assumption holds good if `\frac{dy}{dx} = h(x, y)` is rewritten as
+    `\frac{dy}{dx} = \frac{1}{h(y, x)}` and the same properties of the first assumption
+    satisfies. After obtaining `f(x)` and `g(x)`, the coordinates are again
+    interchanged, to get `\xi` as `f(x^*)` and `\eta` as `g(y^*)`
+
+    References
+    ==========
+    - E.S. Cheb-Terrab, A.D. Roche, Symmetries and First Order
+      ODE Patterns, pp. 10 - pp. 12
+
+    """
+
+    h = match['h']
+    hx = match['hx']
+    hy = match['hy']
+    func = match['func']
+    hinv = match['hinv']
+    x = func.args[0]
+    y = match['y']
+    xi = Function('xi')(x, func)
+    eta = Function('eta')(x, func)
+
+    factor = cancel(h.diff(y)/h.diff(y, 2))
+    factorx = factor.diff(x)
+    factory = factor.diff(y)
+    if not factor.has(x) and not factor.has(y):
+        A = Wild('A', exclude=[y])
+        B = Wild('B', exclude=[y])
+        C = Wild('C', exclude=[x, y])
+        match = h.match(A + B*exp(y/C))
+        try:
+            tau = exp(-integrate(match[A]/match[C]), x)/match[B]
+        except NotImplementedError:
+            pass
+        else:
+            gx = match[A]*tau
+            return [{xi: tau, eta: gx}]
+
+    else:
+        gamma = cancel(factorx/factory)
+        if not gamma.has(y):
+            tauint = cancel((gamma*hy - gamma.diff(x) - hx)/(h + gamma))
+            if not tauint.has(y):
+                try:
+                    tau = exp(integrate(tauint, x))
+                except NotImplementedError:
+                    pass
+                else:
+                    gx = -tau*gamma
+                    return [{xi: tau, eta: gx}]
+
+    factor = cancel(hinv.diff(y)/hinv.diff(y, 2))
+    factorx = factor.diff(x)
+    factory = factor.diff(y)
+    if not factor.has(x) and not factor.has(y):
+        A = Wild('A', exclude=[y])
+        B = Wild('B', exclude=[y])
+        C = Wild('C', exclude=[x, y])
+        match = h.match(A + B*exp(y/C))
+        try:
+            tau = exp(-integrate(match[A]/match[C]), x)/match[B]
+        except NotImplementedError:
+            pass
+        else:
+            gx = match[A]*tau
+            return [{eta: tau.subs(x, func), xi: gx.subs(x, func)}]
+
+    else:
+        gamma = cancel(factorx/factory)
+        if not gamma.has(y):
+            tauint = cancel((gamma*hinv.diff(y) - gamma.diff(x) - hinv.diff(x))/(
+                hinv + gamma))
+            if not tauint.has(y):
+                try:
+                    tau = exp(integrate(tauint, x))
+                except NotImplementedError:
+                    pass
+                else:
+                    gx = -tau*gamma
+                    return [{eta: tau.subs(x, func), xi: gx.subs(x, func)}]
+
+
+def lie_heuristic_abaco2_unique_unknown(match, comp=False):
+    r"""
+    This heuristic assumes the presence of unknown functions or known functions
+    with non-integer powers.
+
+    1. A list of all functions and non-integer powers containing x and y
+    2. Loop over each element `f` in the list, find `\frac{\frac{\partial f}{\partial x}}{
+       \frac{\partial f}{\partial x}} = R`
+
+       If it is separable in `x` and `y`, let `X` be the factors containing `x`. Then
+
+       a] Check if `\xi = X` and `\eta = -\frac{X}{R}` satisfy the PDE. If yes, then return
+          `\xi` and `\eta`
+       b] Check if `\xi = \frac{-R}{X}` and `\eta = -\frac{1}{X}` satisfy the PDE.
+           If yes, then return `\xi` and `\eta`
+
+       If not, then check if
+
+       a] :math:`\xi = -R,\eta = 1`
+
+       b] :math:`\xi = 1, \eta = -\frac{1}{R}`
+
+       are solutions.
+
+    References
+    ==========
+    - E.S. Cheb-Terrab, A.D. Roche, Symmetries and First Order
+      ODE Patterns, pp. 10 - pp. 12
+
+    """
+
+    h = match['h']
+    hx = match['hx']
+    hy = match['hy']
+    func = match['func']
+    x = func.args[0]
+    y = match['y']
+    xi = Function('xi')(x, func)
+    eta = Function('eta')(x, func)
+
+    funclist = []
+    for atom in h.atoms(Pow):
+        base, exp = atom.as_base_exp()
+        if base.has(x) and base.has(y):
+            if not exp.is_Integer:
+                funclist.append(atom)
+
+    for function in h.atoms(AppliedUndef):
+        syms = function.free_symbols
+        if x in syms and y in syms:
+            funclist.append(function)
+
+    for f in funclist:
+        frac = cancel(f.diff(y)/f.diff(x))
+        sep = separatevars(frac, dict=True, symbols=[x, y])
+        if sep and sep['coeff']:
+            xitry1 = sep[x]
+            etatry1 = -1/(sep[y]*sep['coeff'])
+            pde1 = etatry1.diff(y)*h - xitry1.diff(x)*h - xitry1*hx - etatry1*hy
+            if not simplify(pde1):
+                return [{xi: xitry1, eta: etatry1.subs(y, func)}]
+            xitry2 = 1/etatry1
+            etatry2 = 1/xitry1
+            pde2 = etatry2.diff(x) - (xitry2.diff(y))*h**2 - xitry2*hx - etatry2*hy
+            if not simplify(expand(pde2)):
+                return [{xi: xitry2.subs(y, func), eta: etatry2}]
+
+        else:
+            etatry = -1/frac
+            pde = etatry.diff(x) + etatry.diff(y)*h - hx - etatry*hy
+            if not simplify(pde):
+                return [{xi: S.One, eta: etatry.subs(y, func)}]
+            xitry = -frac
+            pde = -xitry.diff(x)*h -xitry.diff(y)*h**2 - xitry*hx -hy
+            if not simplify(expand(pde)):
+                return [{xi: xitry.subs(y, func), eta: S.One}]
+
+
+def lie_heuristic_abaco2_unique_general(match, comp=False):
+    r"""
+    This heuristic finds if infinitesimals of the form `\eta = f(x)`, `\xi = g(y)`
+    without making any assumptions on `h`.
+
+    The complete sequence of steps is given in the paper mentioned below.
+
+    References
+    ==========
+    - E.S. Cheb-Terrab, A.D. Roche, Symmetries and First Order
+      ODE Patterns, pp. 10 - pp. 12
+
+    """
+    hx = match['hx']
+    hy = match['hy']
+    func = match['func']
+    x = func.args[0]
+    y = match['y']
+    xi = Function('xi')(x, func)
+    eta = Function('eta')(x, func)
+
+    A = hx.diff(y)
+    B = hy.diff(y) + hy**2
+    C = hx.diff(x) - hx**2
+
+    if not (A and B and C):
+        return
+
+    Ax = A.diff(x)
+    Ay = A.diff(y)
+    Axy = Ax.diff(y)
+    Axx = Ax.diff(x)
+    Ayy = Ay.diff(y)
+    D = simplify(2*Axy + hx*Ay - Ax*hy + (hx*hy + 2*A)*A)*A - 3*Ax*Ay
+    if not D:
+        E1 = simplify(3*Ax**2 + ((hx**2 + 2*C)*A - 2*Axx)*A)
+        if E1:
+            E2 = simplify((2*Ayy + (2*B - hy**2)*A)*A - 3*Ay**2)
+            if not E2:
+                E3 = simplify(
+                    E1*((28*Ax + 4*hx*A)*A**3 - E1*(hy*A + Ay)) - E1.diff(x)*8*A**4)
+                if not E3:
+                    etaval = cancel((4*A**3*(Ax - hx*A) + E1*(hy*A - Ay))/(S(2)*A*E1))
+                    if x not in etaval:
+                        try:
+                            etaval = exp(integrate(etaval, y))
+                        except NotImplementedError:
+                            pass
+                        else:
+                            xival = -4*A**3*etaval/E1
+                            if y not in xival:
+                                return [{xi: xival, eta: etaval.subs(y, func)}]
+
+    else:
+        E1 = simplify((2*Ayy + (2*B - hy**2)*A)*A - 3*Ay**2)
+        if E1:
+            E2 = simplify(
+                4*A**3*D - D**2 + E1*((2*Axx - (hx**2 + 2*C)*A)*A - 3*Ax**2))
+            if not E2:
+                E3 = simplify(
+                   -(A*D)*E1.diff(y) + ((E1.diff(x) - hy*D)*A + 3*Ay*D +
+                    (A*hx - 3*Ax)*E1)*E1)
+                if not E3:
+                    etaval = cancel(((A*hx - Ax)*E1 - (Ay + A*hy)*D)/(S(2)*A*D))
+                    if x not in etaval:
+                        try:
+                            etaval = exp(integrate(etaval, y))
+                        except NotImplementedError:
+                            pass
+                        else:
+                            xival = -E1*etaval/D
+                            if y not in xival:
+                                return [{xi: xival, eta: etaval.subs(y, func)}]
+
+
+def lie_heuristic_linear(match, comp=False):
+    r"""
+    This heuristic assumes
+
+    1. `\xi = ax + by + c` and
+    2. `\eta = fx + gy + h`
+
+    After substituting the following assumptions in the determining PDE, it
+    reduces to
+
+    .. math:: f + (g - a)h - bh^{2} - (ax + by + c)\frac{\partial h}{\partial x}
+                 - (fx + gy + c)\frac{\partial h}{\partial y}
+
+    Solving the reduced PDE obtained, using the method of characteristics, becomes
+    impractical. The method followed is grouping similar terms and solving the system
+    of linear equations obtained. The difference between the bivariate heuristic is that
+    `h` need not be a rational function in this case.
+
+    References
+    ==========
+    - E.S. Cheb-Terrab, A.D. Roche, Symmetries and First Order
+      ODE Patterns, pp. 10 - pp. 12
+
+    """
+    h = match['h']
+    hx = match['hx']
+    hy = match['hy']
+    func = match['func']
+    x = func.args[0]
+    y = match['y']
+    xi = Function('xi')(x, func)
+    eta = Function('eta')(x, func)
+
+    coeffdict = {}
+    symbols = numbered_symbols("c", cls=Dummy)
+    symlist = [next(symbols) for _ in islice(symbols, 6)]
+    C0, C1, C2, C3, C4, C5 = symlist
+    pde = C3 + (C4 - C0)*h - (C0*x + C1*y + C2)*hx - (C3*x + C4*y + C5)*hy - C1*h**2
+    pde, denom = pde.as_numer_denom()
+    pde = powsimp(expand(pde))
+    if pde.is_Add:
+        terms = pde.args
+        for term in terms:
+            if term.is_Mul:
+                rem = Mul(*[m for m in term.args if not m.has(x, y)])
+                xypart = term/rem
+                if xypart not in coeffdict:
+                    coeffdict[xypart] = rem
+                else:
+                    coeffdict[xypart] += rem
+            else:
+                if term not in coeffdict:
+                    coeffdict[term] = S.One
+                else:
+                    coeffdict[term] += S.One
+
+    sollist = coeffdict.values()
+    soldict = solve(sollist, symlist)
+    if soldict:
+        if isinstance(soldict, list):
+            soldict = soldict[0]
+        subval = soldict.values()
+        if any(t for t in subval):
+            onedict = dict(zip(symlist, [1]*6))
+            xival = C0*x + C1*func + C2
+            etaval = C3*x + C4*func + C5
+            xival = xival.subs(soldict)
+            etaval = etaval.subs(soldict)
+            xival = xival.subs(onedict)
+            etaval = etaval.subs(onedict)
+            return [{xi: xival, eta: etaval}]
+
+
+def _lie_group_remove(coords):
+    r"""
+    This function is strictly meant for internal use by the Lie group ODE solving
+    method. It replaces arbitrary functions returned by pdsolve as follows:
+
+    1] If coords is an arbitrary function, then its argument is returned.
+    2] An arbitrary function in an Add object is replaced by zero.
+    3] An arbitrary function in a Mul object is replaced by one.
+    4] If there is no arbitrary function coords is returned unchanged.
+
+    Examples
+    ========
+
+    >>> from sympy.solvers.ode.lie_group import _lie_group_remove
+    >>> from sympy import Function
+    >>> from sympy.abc import x, y
+    >>> F = Function("F")
+    >>> eq = x**2*y
+    >>> _lie_group_remove(eq)
+    x**2*y
+    >>> eq = F(x**2*y)
+    >>> _lie_group_remove(eq)
+    x**2*y
+    >>> eq = x*y**2 + F(x**3)
+    >>> _lie_group_remove(eq)
+    x*y**2
+    >>> eq = (F(x**3) + y)*x**4
+    >>> _lie_group_remove(eq)
+    x**4*y
+
+    """
+    if isinstance(coords, AppliedUndef):
+        return coords.args[0]
+    elif coords.is_Add:
+        subfunc = coords.atoms(AppliedUndef)
+        if subfunc:
+            for func in subfunc:
+                coords = coords.subs(func, 0)
+        return coords
+    elif coords.is_Pow:
+        base, expr = coords.as_base_exp()
+        base = _lie_group_remove(base)
+        expr = _lie_group_remove(expr)
+        return base**expr
+    elif coords.is_Mul:
+        mulargs = []
+        coordargs = coords.args
+        for arg in coordargs:
+            if not isinstance(coords, AppliedUndef):
+                mulargs.append(_lie_group_remove(arg))
+        return Mul(*mulargs)
+    return coords
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/ode/nonhomogeneous.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/ode/nonhomogeneous.py
new file mode 100644
index 0000000000000000000000000000000000000000..ae39d55664e4850168ca7d68f65cf02171979957
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/ode/nonhomogeneous.py
@@ -0,0 +1,484 @@
+r"""
+This File contains helper functions for nth_linear_constant_coeff_undetermined_coefficients,
+nth_linear_euler_eq_nonhomogeneous_undetermined_coefficients,
+nth_linear_constant_coeff_variation_of_parameters,
+and nth_linear_euler_eq_nonhomogeneous_variation_of_parameters.
+
+All the functions in this file are used by more than one solvers so, instead of creating
+instances in other classes for using them it is better to keep it here as separate helpers.
+
+"""
+from collections import Counter
+from sympy.core import Add, S
+from sympy.core.function import diff, expand, _mexpand, expand_mul
+from sympy.core.relational import Eq
+from sympy.core.sorting import default_sort_key
+from sympy.core.symbol import Dummy, Wild
+from sympy.functions import exp, cos, cosh, im, log, re, sin, sinh, \
+    atan2, conjugate
+from sympy.integrals import Integral
+from sympy.polys import (Poly, RootOf, rootof, roots)
+from sympy.simplify import collect, simplify, separatevars, powsimp, trigsimp # type: ignore
+from sympy.utilities import numbered_symbols
+from sympy.solvers.solvers import solve
+from sympy.matrices import wronskian
+from .subscheck import sub_func_doit
+from sympy.solvers.ode.ode import get_numbered_constants
+
+
+def _test_term(coeff, func, order):
+    r"""
+    Linear Euler ODEs have the form  K*x**order*diff(y(x), x, order) = F(x),
+    where K is independent of x and y(x), order>= 0.
+    So we need to check that for each term, coeff == K*x**order from
+    some K.  We have a few cases, since coeff may have several
+    different types.
+    """
+    x = func.args[0]
+    f = func.func
+    if order < 0:
+        raise ValueError("order should be greater than 0")
+    if coeff == 0:
+        return True
+    if order == 0:
+        if x in coeff.free_symbols:
+            return False
+        return True
+    if coeff.is_Mul:
+        if coeff.has(f(x)):
+            return False
+        return x**order in coeff.args
+    elif coeff.is_Pow:
+        return coeff.as_base_exp() == (x, order)
+    elif order == 1:
+        return x == coeff
+    return False
+
+
+def _get_euler_characteristic_eq_sols(eq, func, match_obj):
+    r"""
+    Returns the solution of homogeneous part of the linear euler ODE and
+    the list of roots of characteristic equation.
+
+    The parameter ``match_obj`` is a dict of order:coeff terms, where order is the order
+    of the derivative on each term, and coeff is the coefficient of that derivative.
+
+    """
+    x = func.args[0]
+    f = func.func
+
+    # First, set up characteristic equation.
+    chareq, symbol = S.Zero, Dummy('x')
+
+    for i in match_obj:
+        if i >= 0:
+            chareq += (match_obj[i]*diff(x**symbol, x, i)*x**-symbol).expand()
+
+    chareq = Poly(chareq, symbol)
+    chareqroots = [rootof(chareq, k) for k in range(chareq.degree())]
+    collectterms = []
+
+    # A generator of constants
+    constants = list(get_numbered_constants(eq, num=chareq.degree()*2))
+    constants.reverse()
+
+    # Create a dict root: multiplicity or charroots
+    charroots = Counter(chareqroots)
+    gsol = S.Zero
+    ln = log
+    for root, multiplicity in charroots.items():
+        for i in range(multiplicity):
+            if isinstance(root, RootOf):
+                gsol += (x**root) * constants.pop()
+                if multiplicity != 1:
+                    raise ValueError("Value should be 1")
+                collectterms = [(0, root, 0)] + collectterms
+            elif root.is_real:
+                gsol += ln(x)**i*(x**root) * constants.pop()
+                collectterms = [(i, root, 0)] + collectterms
+            else:
+                reroot = re(root)
+                imroot = im(root)
+                gsol += ln(x)**i * (x**reroot) * (
+                    constants.pop() * sin(abs(imroot)*ln(x))
+                    + constants.pop() * cos(imroot*ln(x)))
+                collectterms = [(i, reroot, imroot)] + collectterms
+
+    gsol = Eq(f(x), gsol)
+
+    gensols = []
+    # Keep track of when to use sin or cos for nonzero imroot
+    for i, reroot, imroot in collectterms:
+        if imroot == 0:
+            gensols.append(ln(x)**i*x**reroot)
+        else:
+            sin_form = ln(x)**i*x**reroot*sin(abs(imroot)*ln(x))
+            if sin_form in gensols:
+                cos_form = ln(x)**i*x**reroot*cos(imroot*ln(x))
+                gensols.append(cos_form)
+            else:
+                gensols.append(sin_form)
+    return gsol, gensols
+
+
+def _solve_variation_of_parameters(eq, func, roots, homogen_sol, order, match_obj, simplify_flag=True):
+    r"""
+    Helper function for the method of variation of parameters and nonhomogeneous euler eq.
+
+    See the
+    :py:meth:`~sympy.solvers.ode.single.NthLinearConstantCoeffVariationOfParameters`
+    docstring for more information on this method.
+
+    The parameter are ``match_obj`` should be a dictionary that has the following
+    keys:
+
+    ``list``
+    A list of solutions to the homogeneous equation.
+
+    ``sol``
+    The general solution.
+
+    """
+    f = func.func
+    x = func.args[0]
+    r = match_obj
+    psol = 0
+    wr = wronskian(roots, x)
+
+    if simplify_flag:
+        wr = simplify(wr)  # We need much better simplification for
+                        # some ODEs. See issue 4662, for example.
+        # To reduce commonly occurring sin(x)**2 + cos(x)**2 to 1
+        wr = trigsimp(wr, deep=True, recursive=True)
+    if not wr:
+        # The wronskian will be 0 iff the solutions are not linearly
+        # independent.
+        raise NotImplementedError("Cannot find " + str(order) +
+        " solutions to the homogeneous equation necessary to apply " +
+        "variation of parameters to " + str(eq) + " (Wronskian == 0)")
+    if len(roots) != order:
+        raise NotImplementedError("Cannot find " + str(order) +
+        " solutions to the homogeneous equation necessary to apply " +
+        "variation of parameters to " +
+        str(eq) + " (number of terms != order)")
+    negoneterm = S.NegativeOne**(order)
+    for i in roots:
+        psol += negoneterm*Integral(wronskian([sol for sol in roots if sol != i], x)*r[-1]/wr, x)*i/r[order]
+        negoneterm *= -1
+
+    if simplify_flag:
+        psol = simplify(psol)
+        psol = trigsimp(psol, deep=True)
+    return Eq(f(x), homogen_sol.rhs + psol)
+
+
+def _get_const_characteristic_eq_sols(r, func, order):
+    r"""
+    Returns the roots of characteristic equation of constant coefficient
+    linear ODE and list of collectterms which is later on used by simplification
+    to use collect on solution.
+
+    The parameter `r` is a dict of order:coeff terms, where order is the order of the
+    derivative on each term, and coeff is the coefficient of that derivative.
+
+    """
+    x = func.args[0]
+    # First, set up characteristic equation.
+    chareq, symbol = S.Zero, Dummy('x')
+
+    for i in r.keys():
+        if isinstance(i, str) or i < 0:
+            pass
+        else:
+            chareq += r[i]*symbol**i
+
+    chareq = Poly(chareq, symbol)
+    # Can't just call roots because it doesn't return rootof for unsolveable
+    # polynomials.
+    chareqroots = roots(chareq, multiple=True)
+    if len(chareqroots) != order:
+        chareqroots = [rootof(chareq, k) for k in range(chareq.degree())]
+
+    chareq_is_complex = not all(i.is_real for i in chareq.all_coeffs())
+
+    # Create a dict root: multiplicity or charroots
+    charroots = Counter(chareqroots)
+    # We need to keep track of terms so we can run collect() at the end.
+    # This is necessary for constantsimp to work properly.
+    collectterms = []
+    gensols = []
+    conjugate_roots = [] # used to prevent double-use of conjugate roots
+    # Loop over roots in theorder provided by roots/rootof...
+    for root in chareqroots:
+        # but don't repoeat multiple roots.
+        if root not in charroots:
+            continue
+        multiplicity = charroots.pop(root)
+        for i in range(multiplicity):
+            if chareq_is_complex:
+                gensols.append(x**i*exp(root*x))
+                collectterms = [(i, root, 0)] + collectterms
+                continue
+            reroot = re(root)
+            imroot = im(root)
+            if imroot.has(atan2) and reroot.has(atan2):
+                # Remove this condition when re and im stop returning
+                # circular atan2 usages.
+                gensols.append(x**i*exp(root*x))
+                collectterms = [(i, root, 0)] + collectterms
+            else:
+                if root in conjugate_roots:
+                    collectterms = [(i, reroot, imroot)] + collectterms
+                    continue
+                if imroot == 0:
+                    gensols.append(x**i*exp(reroot*x))
+                    collectterms = [(i, reroot, 0)] + collectterms
+                    continue
+                conjugate_roots.append(conjugate(root))
+                gensols.append(x**i*exp(reroot*x) * sin(abs(imroot) * x))
+                gensols.append(x**i*exp(reroot*x) * cos(    imroot  * x))
+
+                # This ordering is important
+                collectterms = [(i, reroot, imroot)] + collectterms
+    return gensols, collectterms
+
+
+# Ideally these kind of simplification functions shouldn't be part of solvers.
+# odesimp should be improved to handle these kind of specific simplifications.
+def _get_simplified_sol(sol, func, collectterms):
+    r"""
+    Helper function which collects the solution on
+    collectterms. Ideally this should be handled by odesimp.It is used
+    only when the simplify is set to True in dsolve.
+
+    The parameter ``collectterms`` is a list of tuple (i, reroot, imroot) where `i` is
+    the multiplicity of the root, reroot is real part and imroot being the imaginary part.
+
+    """
+    f = func.func
+    x = func.args[0]
+    collectterms.sort(key=default_sort_key)
+    collectterms.reverse()
+    assert len(sol) == 1 and sol[0].lhs == f(x)
+    sol = sol[0].rhs
+    sol = expand_mul(sol)
+    for i, reroot, imroot in collectterms:
+        sol = collect(sol, x**i*exp(reroot*x)*sin(abs(imroot)*x))
+        sol = collect(sol, x**i*exp(reroot*x)*cos(imroot*x))
+    for i, reroot, imroot in collectterms:
+        sol = collect(sol, x**i*exp(reroot*x))
+    sol = powsimp(sol)
+    return Eq(f(x), sol)
+
+
+def _undetermined_coefficients_match(expr, x, func=None, eq_homogeneous=S.Zero):
+    r"""
+    Returns a trial function match if undetermined coefficients can be applied
+    to ``expr``, and ``None`` otherwise.
+
+    A trial expression can be found for an expression for use with the method
+    of undetermined coefficients if the expression is an
+    additive/multiplicative combination of constants, polynomials in `x` (the
+    independent variable of expr), `\sin(a x + b)`, `\cos(a x + b)`, and
+    `e^{a x}` terms (in other words, it has a finite number of linearly
+    independent derivatives).
+
+    Note that you may still need to multiply each term returned here by
+    sufficient `x` to make it linearly independent with the solutions to the
+    homogeneous equation.
+
+    This is intended for internal use by ``undetermined_coefficients`` hints.
+
+    SymPy currently has no way to convert `\sin^n(x) \cos^m(y)` into a sum of
+    only `\sin(a x)` and `\cos(b x)` terms, so these are not implemented.  So,
+    for example, you will need to manually convert `\sin^2(x)` into `[1 +
+    \cos(2 x)]/2` to properly apply the method of undetermined coefficients on
+    it.
+
+    Examples
+    ========
+
+    >>> from sympy import log, exp
+    >>> from sympy.solvers.ode.nonhomogeneous import _undetermined_coefficients_match
+    >>> from sympy.abc import x
+    >>> _undetermined_coefficients_match(9*x*exp(x) + exp(-x), x)
+    {'test': True, 'trialset': {x*exp(x), exp(-x), exp(x)}}
+    >>> _undetermined_coefficients_match(log(x), x)
+    {'test': False}
+
+    """
+    a = Wild('a', exclude=[x])
+    b = Wild('b', exclude=[x])
+    expr = powsimp(expr, combine='exp')  # exp(x)*exp(2*x + 1) => exp(3*x + 1)
+    retdict = {}
+
+    def _test_term(expr, x) -> bool:
+        r"""
+        Test if ``expr`` fits the proper form for undetermined coefficients.
+        """
+        if not expr.has(x):
+            return True
+        if expr.is_Add:
+            return all(_test_term(i, x) for i in expr.args)
+        if expr.is_Mul:
+            if expr.has(sin, cos):
+                foundtrig = False
+                # Make sure that there is only one trig function in the args.
+                # See the docstring.
+                for i in expr.args:
+                    if i.has(sin, cos):
+                        if foundtrig:
+                            return False
+                        else:
+                            foundtrig = True
+            return all(_test_term(i, x) for i in expr.args)
+        if expr.is_Function:
+            return expr.func in (sin, cos, exp, sinh, cosh) and \
+                   bool(expr.args[0].match(a*x + b))
+        if expr.is_Pow and expr.base.is_Symbol and expr.exp.is_Integer and \
+                expr.exp >= 0:
+            return True
+        if expr.is_Pow and expr.base.is_number:
+            return bool(expr.exp.match(a*x + b))
+        return expr.is_Symbol or bool(expr.is_number)
+
+    def _get_trial_set(expr, x, exprs=set()):
+        r"""
+        Returns a set of trial terms for undetermined coefficients.
+
+        The idea behind undetermined coefficients is that the terms expression
+        repeat themselves after a finite number of derivatives, except for the
+        coefficients (they are linearly dependent).  So if we collect these,
+        we should have the terms of our trial function.
+        """
+        def _remove_coefficient(expr, x):
+            r"""
+            Returns the expression without a coefficient.
+
+            Similar to expr.as_independent(x)[1], except it only works
+            multiplicatively.
+            """
+            term = S.One
+            if expr.is_Mul:
+                for i in expr.args:
+                    if i.has(x):
+                        term *= i
+            elif expr.has(x):
+                term = expr
+            return term
+
+        expr = expand_mul(expr)
+        if expr.is_Add:
+            for term in expr.args:
+                if _remove_coefficient(term, x) in exprs:
+                    pass
+                else:
+                    exprs.add(_remove_coefficient(term, x))
+                    exprs = exprs.union(_get_trial_set(term, x, exprs))
+        else:
+            term = _remove_coefficient(expr, x)
+            tmpset = exprs.union({term})
+            oldset = set()
+            while tmpset != oldset:
+                # If you get stuck in this loop, then _test_term is probably
+                # broken
+                oldset = tmpset.copy()
+                expr = expr.diff(x)
+                term = _remove_coefficient(expr, x)
+                if term.is_Add:
+                    tmpset = tmpset.union(_get_trial_set(term, x, tmpset))
+                else:
+                    tmpset.add(term)
+            exprs = tmpset
+        return exprs
+
+    def is_homogeneous_solution(term):
+        r""" This function checks whether the given trialset contains any root
+            of homogeneous equation"""
+        return expand(sub_func_doit(eq_homogeneous, func, term)).is_zero
+
+    retdict['test'] = _test_term(expr, x)
+    if retdict['test']:
+        # Try to generate a list of trial solutions that will have the
+        # undetermined coefficients. Note that if any of these are not linearly
+        # independent with any of the solutions to the homogeneous equation,
+        # then they will need to be multiplied by sufficient x to make them so.
+        # This function DOES NOT do that (it doesn't even look at the
+        # homogeneous equation).
+        temp_set = set()
+        for i in Add.make_args(expr):
+            act = _get_trial_set(i, x)
+            if eq_homogeneous is not S.Zero:
+                while any(is_homogeneous_solution(ts) for ts in act):
+                    act = {x*ts for ts in act}
+            temp_set = temp_set.union(act)
+
+        retdict['trialset'] = temp_set
+    return retdict
+
+
+def _solve_undetermined_coefficients(eq, func, order, match, trialset):
+    r"""
+    Helper function for the method of undetermined coefficients.
+
+    See the
+    :py:meth:`~sympy.solvers.ode.single.NthLinearConstantCoeffUndeterminedCoefficients`
+    docstring for more information on this method.
+
+    The parameter ``trialset`` is the set of trial functions as returned by
+    ``_undetermined_coefficients_match()['trialset']``.
+
+    The parameter ``match`` should be a dictionary that has the following
+    keys:
+
+    ``list``
+    A list of solutions to the homogeneous equation.
+
+    ``sol``
+    The general solution.
+
+    """
+    r = match
+    coeffs = numbered_symbols('a', cls=Dummy)
+    coefflist = []
+    gensols = r['list']
+    gsol = r['sol']
+    f = func.func
+    x = func.args[0]
+
+    if len(gensols) != order:
+        raise NotImplementedError("Cannot find " + str(order) +
+        " solutions to the homogeneous equation necessary to apply" +
+        " undetermined coefficients to " + str(eq) +
+        " (number of terms != order)")
+
+    trialfunc = 0
+    for i in trialset:
+        c = next(coeffs)
+        coefflist.append(c)
+        trialfunc += c*i
+
+    eqs = sub_func_doit(eq, f(x), trialfunc)
+
+    coeffsdict = dict(list(zip(trialset, [0]*(len(trialset) + 1))))
+
+    eqs = _mexpand(eqs)
+
+    for i in Add.make_args(eqs):
+        s = separatevars(i, dict=True, symbols=[x])
+        if coeffsdict.get(s[x]):
+            coeffsdict[s[x]] += s['coeff']
+        else:
+            coeffsdict[s[x]] = s['coeff']
+
+    coeffvals = solve(list(coeffsdict.values()), coefflist)
+
+    if not coeffvals:
+        raise NotImplementedError(
+            "Could not solve `%s` using the "
+            "method of undetermined coefficients "
+            "(unable to solve for coefficients)." % eq)
+
+    psol = trialfunc.subs(coeffvals)
+
+    return Eq(f(x), gsol.rhs + psol)
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/ode/ode.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/ode/ode.py
new file mode 100644
index 0000000000000000000000000000000000000000..6a28b2162b38a2dd8612c14e91fd588912f6756a
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/ode/ode.py
@@ -0,0 +1,3572 @@
+r"""
+This module contains :py:meth:`~sympy.solvers.ode.dsolve` and different helper
+functions that it uses.
+
+:py:meth:`~sympy.solvers.ode.dsolve` solves ordinary differential equations.
+See the docstring on the various functions for their uses.  Note that partial
+differential equations support is in ``pde.py``.  Note that hint functions
+have docstrings describing their various methods, but they are intended for
+internal use.  Use ``dsolve(ode, func, hint=hint)`` to solve an ODE using a
+specific hint.  See also the docstring on
+:py:meth:`~sympy.solvers.ode.dsolve`.
+
+**Functions in this module**
+
+    These are the user functions in this module:
+
+    - :py:meth:`~sympy.solvers.ode.dsolve` - Solves ODEs.
+    - :py:meth:`~sympy.solvers.ode.classify_ode` - Classifies ODEs into
+      possible hints for :py:meth:`~sympy.solvers.ode.dsolve`.
+    - :py:meth:`~sympy.solvers.ode.checkodesol` - Checks if an equation is the
+      solution to an ODE.
+    - :py:meth:`~sympy.solvers.ode.homogeneous_order` - Returns the
+      homogeneous order of an expression.
+    - :py:meth:`~sympy.solvers.ode.infinitesimals` - Returns the infinitesimals
+      of the Lie group of point transformations of an ODE, such that it is
+      invariant.
+    - :py:meth:`~sympy.solvers.ode.checkinfsol` - Checks if the given infinitesimals
+      are the actual infinitesimals of a first order ODE.
+
+    These are the non-solver helper functions that are for internal use.  The
+    user should use the various options to
+    :py:meth:`~sympy.solvers.ode.dsolve` to obtain the functionality provided
+    by these functions:
+
+    - :py:meth:`~sympy.solvers.ode.ode.odesimp` - Does all forms of ODE
+      simplification.
+    - :py:meth:`~sympy.solvers.ode.ode.ode_sol_simplicity` - A key function for
+      comparing solutions by simplicity.
+    - :py:meth:`~sympy.solvers.ode.constantsimp` - Simplifies arbitrary
+      constants.
+    - :py:meth:`~sympy.solvers.ode.ode.constant_renumber` - Renumber arbitrary
+      constants.
+    - :py:meth:`~sympy.solvers.ode.ode._handle_Integral` - Evaluate unevaluated
+      Integrals.
+
+    See also the docstrings of these functions.
+
+**Currently implemented solver methods**
+
+The following methods are implemented for solving ordinary differential
+equations.  See the docstrings of the various hint functions for more
+information on each (run ``help(ode)``):
+
+  - 1st order separable differential equations.
+  - 1st order differential equations whose coefficients or `dx` and `dy` are
+    functions homogeneous of the same order.
+  - 1st order exact differential equations.
+  - 1st order linear differential equations.
+  - 1st order Bernoulli differential equations.
+  - Power series solutions for first order differential equations.
+  - Lie Group method of solving first order differential equations.
+  - 2nd order Liouville differential equations.
+  - Power series solutions for second order differential equations
+    at ordinary and regular singular points.
+  - `n`\th order differential equation that can be solved with algebraic
+    rearrangement and integration.
+  - `n`\th order linear homogeneous differential equation with constant
+    coefficients.
+  - `n`\th order linear inhomogeneous differential equation with constant
+    coefficients using the method of undetermined coefficients.
+  - `n`\th order linear inhomogeneous differential equation with constant
+    coefficients using the method of variation of parameters.
+
+**Philosophy behind this module**
+
+This module is designed to make it easy to add new ODE solving methods without
+having to mess with the solving code for other methods.  The idea is that
+there is a :py:meth:`~sympy.solvers.ode.classify_ode` function, which takes in
+an ODE and tells you what hints, if any, will solve the ODE.  It does this
+without attempting to solve the ODE, so it is fast.  Each solving method is a
+hint, and it has its own function, named ``ode_<hint>``.  That function takes
+in the ODE and any match expression gathered by
+:py:meth:`~sympy.solvers.ode.classify_ode` and returns a solved result.  If
+this result has any integrals in it, the hint function will return an
+unevaluated :py:class:`~sympy.integrals.integrals.Integral` class.
+:py:meth:`~sympy.solvers.ode.dsolve`, which is the user wrapper function
+around all of this, will then call :py:meth:`~sympy.solvers.ode.ode.odesimp` on
+the result, which, among other things, will attempt to solve the equation for
+the dependent variable (the function we are solving for), simplify the
+arbitrary constants in the expression, and evaluate any integrals, if the hint
+allows it.
+
+**How to add new solution methods**
+
+If you have an ODE that you want :py:meth:`~sympy.solvers.ode.dsolve` to be
+able to solve, try to avoid adding special case code here.  Instead, try
+finding a general method that will solve your ODE, as well as others.  This
+way, the :py:mod:`~sympy.solvers.ode` module will become more robust, and
+unhindered by special case hacks.  WolphramAlpha and Maple's
+DETools[odeadvisor] function are two resources you can use to classify a
+specific ODE.  It is also better for a method to work with an `n`\th order ODE
+instead of only with specific orders, if possible.
+
+To add a new method, there are a few things that you need to do.  First, you
+need a hint name for your method.  Try to name your hint so that it is
+unambiguous with all other methods, including ones that may not be implemented
+yet.  If your method uses integrals, also include a ``hint_Integral`` hint.
+If there is more than one way to solve ODEs with your method, include a hint
+for each one, as well as a ``<hint>_best`` hint.  Your ``ode_<hint>_best()``
+function should choose the best using min with ``ode_sol_simplicity`` as the
+key argument.  See
+:obj:`~sympy.solvers.ode.single.HomogeneousCoeffBest`, for example.
+The function that uses your method will be called ``ode_<hint>()``, so the
+hint must only use characters that are allowed in a Python function name
+(alphanumeric characters and the underscore '``_``' character).  Include a
+function for every hint, except for ``_Integral`` hints
+(:py:meth:`~sympy.solvers.ode.dsolve` takes care of those automatically).
+Hint names should be all lowercase, unless a word is commonly capitalized
+(such as Integral or Bernoulli).  If you have a hint that you do not want to
+run with ``all_Integral`` that does not have an ``_Integral`` counterpart (such
+as a best hint that would defeat the purpose of ``all_Integral``), you will
+need to remove it manually in the :py:meth:`~sympy.solvers.ode.dsolve` code.
+See also the :py:meth:`~sympy.solvers.ode.classify_ode` docstring for
+guidelines on writing a hint name.
+
+Determine *in general* how the solutions returned by your method compare with
+other methods that can potentially solve the same ODEs.  Then, put your hints
+in the :py:data:`~sympy.solvers.ode.allhints` tuple in the order that they
+should be called.  The ordering of this tuple determines which hints are
+default.  Note that exceptions are ok, because it is easy for the user to
+choose individual hints with :py:meth:`~sympy.solvers.ode.dsolve`.  In
+general, ``_Integral`` variants should go at the end of the list, and
+``_best`` variants should go before the various hints they apply to.  For
+example, the ``undetermined_coefficients`` hint comes before the
+``variation_of_parameters`` hint because, even though variation of parameters
+is more general than undetermined coefficients, undetermined coefficients
+generally returns cleaner results for the ODEs that it can solve than
+variation of parameters does, and it does not require integration, so it is
+much faster.
+
+Next, you need to have a match expression or a function that matches the type
+of the ODE, which you should put in :py:meth:`~sympy.solvers.ode.classify_ode`
+(if the match function is more than just a few lines.  It should match the
+ODE without solving for it as much as possible, so that
+:py:meth:`~sympy.solvers.ode.classify_ode` remains fast and is not hindered by
+bugs in solving code.  Be sure to consider corner cases.  For example, if your
+solution method involves dividing by something, make sure you exclude the case
+where that division will be 0.
+
+In most cases, the matching of the ODE will also give you the various parts
+that you need to solve it.  You should put that in a dictionary (``.match()``
+will do this for you), and add that as ``matching_hints['hint'] = matchdict``
+in the relevant part of :py:meth:`~sympy.solvers.ode.classify_ode`.
+:py:meth:`~sympy.solvers.ode.classify_ode` will then send this to
+:py:meth:`~sympy.solvers.ode.dsolve`, which will send it to your function as
+the ``match`` argument.  Your function should be named ``ode_<hint>(eq, func,
+order, match)`.  If you need to send more information, put it in the ``match``
+dictionary.  For example, if you had to substitute in a dummy variable in
+:py:meth:`~sympy.solvers.ode.classify_ode` to match the ODE, you will need to
+pass it to your function using the `match` dict to access it.  You can access
+the independent variable using ``func.args[0]``, and the dependent variable
+(the function you are trying to solve for) as ``func.func``.  If, while trying
+to solve the ODE, you find that you cannot, raise ``NotImplementedError``.
+:py:meth:`~sympy.solvers.ode.dsolve` will catch this error with the ``all``
+meta-hint, rather than causing the whole routine to fail.
+
+Add a docstring to your function that describes the method employed.  Like
+with anything else in SymPy, you will need to add a doctest to the docstring,
+in addition to real tests in ``test_ode.py``.  Try to maintain consistency
+with the other hint functions' docstrings.  Add your method to the list at the
+top of this docstring.  Also, add your method to ``ode.rst`` in the
+``docs/src`` directory, so that the Sphinx docs will pull its docstring into
+the main SymPy documentation.  Be sure to make the Sphinx documentation by
+running ``make html`` from within the doc directory to verify that the
+docstring formats correctly.
+
+If your solution method involves integrating, use :py:obj:`~.Integral` instead of
+:py:meth:`~sympy.core.expr.Expr.integrate`.  This allows the user to bypass
+hard/slow integration by using the ``_Integral`` variant of your hint.  In
+most cases, calling :py:meth:`sympy.core.basic.Basic.doit` will integrate your
+solution.  If this is not the case, you will need to write special code in
+:py:meth:`~sympy.solvers.ode.ode._handle_Integral`.  Arbitrary constants should be
+symbols named ``C1``, ``C2``, and so on.  All solution methods should return
+an equality instance.  If you need an arbitrary number of arbitrary constants,
+you can use ``constants = numbered_symbols(prefix='C', cls=Symbol, start=1)``.
+If it is possible to solve for the dependent function in a general way, do so.
+Otherwise, do as best as you can, but do not call solve in your
+``ode_<hint>()`` function.  :py:meth:`~sympy.solvers.ode.ode.odesimp` will attempt
+to solve the solution for you, so you do not need to do that.  Lastly, if your
+ODE has a common simplification that can be applied to your solutions, you can
+add a special case in :py:meth:`~sympy.solvers.ode.ode.odesimp` for it.  For
+example, solutions returned from the ``1st_homogeneous_coeff`` hints often
+have many :obj:`~sympy.functions.elementary.exponential.log` terms, so
+:py:meth:`~sympy.solvers.ode.ode.odesimp` calls
+:py:meth:`~sympy.simplify.simplify.logcombine` on them (it also helps to write
+the arbitrary constant as ``log(C1)`` instead of ``C1`` in this case).  Also
+consider common ways that you can rearrange your solution to have
+:py:meth:`~sympy.solvers.ode.constantsimp` take better advantage of it.  It is
+better to put simplification in :py:meth:`~sympy.solvers.ode.ode.odesimp` than in
+your method, because it can then be turned off with the simplify flag in
+:py:meth:`~sympy.solvers.ode.dsolve`.  If you have any extraneous
+simplification in your function, be sure to only run it using ``if
+match.get('simplify', True):``, especially if it can be slow or if it can
+reduce the domain of the solution.
+
+Finally, as with every contribution to SymPy, your method will need to be
+tested.  Add a test for each method in ``test_ode.py``.  Follow the
+conventions there, i.e., test the solver using ``dsolve(eq, f(x),
+hint=your_hint)``, and also test the solution using
+:py:meth:`~sympy.solvers.ode.checkodesol` (you can put these in a separate
+tests and skip/XFAIL if it runs too slow/does not work).  Be sure to call your
+hint specifically in :py:meth:`~sympy.solvers.ode.dsolve`, that way the test
+will not be broken simply by the introduction of another matching hint.  If your
+method works for higher order (>1) ODEs, you will need to run ``sol =
+constant_renumber(sol, 'C', 1, order)`` for each solution, where ``order`` is
+the order of the ODE.  This is because ``constant_renumber`` renumbers the
+arbitrary constants by printing order, which is platform dependent.  Try to
+test every corner case of your solver, including a range of orders if it is a
+`n`\th order solver, but if your solver is slow, such as if it involves hard
+integration, try to keep the test run time down.
+
+Feel free to refactor existing hints to avoid duplicating code or creating
+inconsistencies.  If you can show that your method exactly duplicates an
+existing method, including in the simplicity and speed of obtaining the
+solutions, then you can remove the old, less general method.  The existing
+code is tested extensively in ``test_ode.py``, so if anything is broken, one
+of those tests will surely fail.
+
+"""
+
+from sympy.core import Add, S, Mul, Pow, oo
+from sympy.core.containers import Tuple
+from sympy.core.expr import AtomicExpr, Expr
+from sympy.core.function import (Function, Derivative, AppliedUndef, diff,
+    expand, expand_mul, Subs)
+from sympy.core.multidimensional import vectorize
+from sympy.core.numbers import nan, zoo, Number
+from sympy.core.relational import Equality, Eq
+from sympy.core.sorting import default_sort_key, ordered
+from sympy.core.symbol import Symbol, Wild, Dummy, symbols
+from sympy.core.sympify import sympify
+from sympy.core.traversal import preorder_traversal
+
+from sympy.logic.boolalg import (BooleanAtom, BooleanTrue,
+                                BooleanFalse)
+from sympy.functions import exp, log, sqrt
+from sympy.functions.combinatorial.factorials import factorial
+from sympy.integrals.integrals import Integral
+from sympy.polys import (Poly, terms_gcd, PolynomialError, lcm)
+from sympy.polys.polytools import cancel
+from sympy.series import Order
+from sympy.series.series import series
+from sympy.simplify import (collect, logcombine, powsimp,  # type: ignore
+    separatevars, simplify, cse)
+from sympy.simplify.radsimp import collect_const
+from sympy.solvers import checksol, solve
+
+from sympy.utilities import numbered_symbols
+from sympy.utilities.iterables import uniq, sift, iterable
+from sympy.solvers.deutils import _preprocess, ode_order, _desolve
+
+
+#: This is a list of hints in the order that they should be preferred by
+#: :py:meth:`~sympy.solvers.ode.classify_ode`. In general, hints earlier in the
+#: list should produce simpler solutions than those later in the list (for
+#: ODEs that fit both).  For now, the order of this list is based on empirical
+#: observations by the developers of SymPy.
+#:
+#: The hint used by :py:meth:`~sympy.solvers.ode.dsolve` for a specific ODE
+#: can be overridden (see the docstring).
+#:
+#: In general, ``_Integral`` hints are grouped at the end of the list, unless
+#: there is a method that returns an unevaluable integral most of the time
+#: (which go near the end of the list anyway).  ``default``, ``all``,
+#: ``best``, and ``all_Integral`` meta-hints should not be included in this
+#: list, but ``_best`` and ``_Integral`` hints should be included.
+allhints = (
+    "factorable",
+    "nth_algebraic",
+    "separable",
+    "1st_exact",
+    "1st_linear",
+    "Bernoulli",
+    "1st_rational_riccati",
+    "Riccati_special_minus2",
+    "1st_homogeneous_coeff_best",
+    "1st_homogeneous_coeff_subs_indep_div_dep",
+    "1st_homogeneous_coeff_subs_dep_div_indep",
+    "almost_linear",
+    "linear_coefficients",
+    "separable_reduced",
+    "1st_power_series",
+    "lie_group",
+    "nth_linear_constant_coeff_homogeneous",
+    "nth_linear_euler_eq_homogeneous",
+    "nth_linear_constant_coeff_undetermined_coefficients",
+    "nth_linear_euler_eq_nonhomogeneous_undetermined_coefficients",
+    "nth_linear_constant_coeff_variation_of_parameters",
+    "nth_linear_euler_eq_nonhomogeneous_variation_of_parameters",
+    "Liouville",
+    "2nd_linear_airy",
+    "2nd_linear_bessel",
+    "2nd_hypergeometric",
+    "2nd_hypergeometric_Integral",
+    "nth_order_reducible",
+    "2nd_power_series_ordinary",
+    "2nd_power_series_regular",
+    "nth_algebraic_Integral",
+    "separable_Integral",
+    "1st_exact_Integral",
+    "1st_linear_Integral",
+    "Bernoulli_Integral",
+    "1st_homogeneous_coeff_subs_indep_div_dep_Integral",
+    "1st_homogeneous_coeff_subs_dep_div_indep_Integral",
+    "almost_linear_Integral",
+    "linear_coefficients_Integral",
+    "separable_reduced_Integral",
+    "nth_linear_constant_coeff_variation_of_parameters_Integral",
+    "nth_linear_euler_eq_nonhomogeneous_variation_of_parameters_Integral",
+    "Liouville_Integral",
+    "2nd_nonlinear_autonomous_conserved",
+    "2nd_nonlinear_autonomous_conserved_Integral",
+    )
+
+
+
+def get_numbered_constants(eq, num=1, start=1, prefix='C'):
+    """
+    Returns a list of constants that do not occur
+    in eq already.
+    """
+
+    ncs = iter_numbered_constants(eq, start, prefix)
+    Cs = [next(ncs) for i in range(num)]
+    return (Cs[0] if num == 1 else tuple(Cs))
+
+
+def iter_numbered_constants(eq, start=1, prefix='C'):
+    """
+    Returns an iterator of constants that do not occur
+    in eq already.
+    """
+
+    if isinstance(eq, (Expr, Eq)):
+        eq = [eq]
+    elif not iterable(eq):
+        raise ValueError("Expected Expr or iterable but got %s" % eq)
+
+    atom_set = set().union(*[i.free_symbols for i in eq])
+    func_set = set().union(*[i.atoms(Function) for i in eq])
+    if func_set:
+        atom_set |= {Symbol(str(f.func)) for f in func_set}
+    return numbered_symbols(start=start, prefix=prefix, exclude=atom_set)
+
+
+def dsolve(eq, func=None, hint="default", simplify=True,
+    ics= None, xi=None, eta=None, x0=0, n=6, **kwargs):
+    r"""
+    Solves any (supported) kind of ordinary differential equation and
+    system of ordinary differential equations.
+
+    For single ordinary differential equation
+    =========================================
+
+    It is classified under this when number of equation in ``eq`` is one.
+    **Usage**
+
+        ``dsolve(eq, f(x), hint)`` -> Solve ordinary differential equation
+        ``eq`` for function ``f(x)``, using method ``hint``.
+
+    **Details**
+
+        ``eq`` can be any supported ordinary differential equation (see the
+            :py:mod:`~sympy.solvers.ode` docstring for supported methods).
+            This can either be an :py:class:`~sympy.core.relational.Equality`,
+            or an expression, which is assumed to be equal to ``0``.
+
+        ``f(x)`` is a function of one variable whose derivatives in that
+            variable make up the ordinary differential equation ``eq``.  In
+            many cases it is not necessary to provide this; it will be
+            autodetected (and an error raised if it could not be detected).
+
+        ``hint`` is the solving method that you want dsolve to use.  Use
+            ``classify_ode(eq, f(x))`` to get all of the possible hints for an
+            ODE.  The default hint, ``default``, will use whatever hint is
+            returned first by :py:meth:`~sympy.solvers.ode.classify_ode`.  See
+            Hints below for more options that you can use for hint.
+
+        ``simplify`` enables simplification by
+            :py:meth:`~sympy.solvers.ode.ode.odesimp`.  See its docstring for more
+            information.  Turn this off, for example, to disable solving of
+            solutions for ``func`` or simplification of arbitrary constants.
+            It will still integrate with this hint. Note that the solution may
+            contain more arbitrary constants than the order of the ODE with
+            this option enabled.
+
+        ``xi`` and ``eta`` are the infinitesimal functions of an ordinary
+            differential equation. They are the infinitesimals of the Lie group
+            of point transformations for which the differential equation is
+            invariant. The user can specify values for the infinitesimals. If
+            nothing is specified, ``xi`` and ``eta`` are calculated using
+            :py:meth:`~sympy.solvers.ode.infinitesimals` with the help of various
+            heuristics.
+
+        ``ics`` is the set of initial/boundary conditions for the differential equation.
+          It should be given in the form of ``{f(x0): x1, f(x).diff(x).subs(x, x2):
+          x3}`` and so on.  For power series solutions, if no initial
+          conditions are specified ``f(0)`` is assumed to be ``C0`` and the power
+          series solution is calculated about 0.
+
+        ``x0`` is the point about which the power series solution of a differential
+          equation is to be evaluated.
+
+        ``n`` gives the exponent of the dependent variable up to which the power series
+          solution of a differential equation is to be evaluated.
+
+    **Hints**
+
+        Aside from the various solving methods, there are also some meta-hints
+        that you can pass to :py:meth:`~sympy.solvers.ode.dsolve`:
+
+        ``default``:
+                This uses whatever hint is returned first by
+                :py:meth:`~sympy.solvers.ode.classify_ode`. This is the
+                default argument to :py:meth:`~sympy.solvers.ode.dsolve`.
+
+        ``all``:
+                To make :py:meth:`~sympy.solvers.ode.dsolve` apply all
+                relevant classification hints, use ``dsolve(ODE, func,
+                hint="all")``.  This will return a dictionary of
+                ``hint:solution`` terms.  If a hint causes dsolve to raise the
+                ``NotImplementedError``, value of that hint's key will be the
+                exception object raised.  The dictionary will also include
+                some special keys:
+
+                - ``order``: The order of the ODE.  See also
+                  :py:meth:`~sympy.solvers.deutils.ode_order` in
+                  ``deutils.py``.
+                - ``best``: The simplest hint; what would be returned by
+                  ``best`` below.
+                - ``best_hint``: The hint that would produce the solution
+                  given by ``best``.  If more than one hint produces the best
+                  solution, the first one in the tuple returned by
+                  :py:meth:`~sympy.solvers.ode.classify_ode` is chosen.
+                - ``default``: The solution that would be returned by default.
+                  This is the one produced by the hint that appears first in
+                  the tuple returned by
+                  :py:meth:`~sympy.solvers.ode.classify_ode`.
+
+        ``all_Integral``:
+                This is the same as ``all``, except if a hint also has a
+                corresponding ``_Integral`` hint, it only returns the
+                ``_Integral`` hint.  This is useful if ``all`` causes
+                :py:meth:`~sympy.solvers.ode.dsolve` to hang because of a
+                difficult or impossible integral.  This meta-hint will also be
+                much faster than ``all``, because
+                :py:meth:`~sympy.core.expr.Expr.integrate` is an expensive
+                routine.
+
+        ``best``:
+                To have :py:meth:`~sympy.solvers.ode.dsolve` try all methods
+                and return the simplest one.  This takes into account whether
+                the solution is solvable in the function, whether it contains
+                any Integral classes (i.e.  unevaluatable integrals), and
+                which one is the shortest in size.
+
+        See also the :py:meth:`~sympy.solvers.ode.classify_ode` docstring for
+        more info on hints, and the :py:mod:`~sympy.solvers.ode` docstring for
+        a list of all supported hints.
+
+    **Tips**
+
+        - You can declare the derivative of an unknown function this way:
+
+            >>> from sympy import Function, Derivative
+            >>> from sympy.abc import x # x is the independent variable
+            >>> f = Function("f")(x) # f is a function of x
+            >>> # f_ will be the derivative of f with respect to x
+            >>> f_ = Derivative(f, x)
+
+        - See ``test_ode.py`` for many tests, which serves also as a set of
+          examples for how to use :py:meth:`~sympy.solvers.ode.dsolve`.
+        - :py:meth:`~sympy.solvers.ode.dsolve` always returns an
+          :py:class:`~sympy.core.relational.Equality` class (except for the
+          case when the hint is ``all`` or ``all_Integral``).  If possible, it
+          solves the solution explicitly for the function being solved for.
+          Otherwise, it returns an implicit solution.
+        - Arbitrary constants are symbols named ``C1``, ``C2``, and so on.
+        - Because all solutions should be mathematically equivalent, some
+          hints may return the exact same result for an ODE. Often, though,
+          two different hints will return the same solution formatted
+          differently.  The two should be equivalent. Also note that sometimes
+          the values of the arbitrary constants in two different solutions may
+          not be the same, because one constant may have "absorbed" other
+          constants into it.
+        - Do ``help(ode.ode_<hintname>)`` to get help more information on a
+          specific hint, where ``<hintname>`` is the name of a hint without
+          ``_Integral``.
+
+    For system of ordinary differential equations
+    =============================================
+
+    **Usage**
+        ``dsolve(eq, func)`` -> Solve a system of ordinary differential
+        equations ``eq`` for ``func`` being list of functions including
+        `x(t)`, `y(t)`, `z(t)` where number of functions in the list depends
+        upon the number of equations provided in ``eq``.
+
+    **Details**
+
+        ``eq`` can be any supported system of ordinary differential equations
+        This can either be an :py:class:`~sympy.core.relational.Equality`,
+        or an expression, which is assumed to be equal to ``0``.
+
+        ``func`` holds ``x(t)`` and ``y(t)`` being functions of one variable which
+        together with some of their derivatives make up the system of ordinary
+        differential equation ``eq``. It is not necessary to provide this; it
+        will be autodetected (and an error raised if it could not be detected).
+
+    **Hints**
+
+        The hints are formed by parameters returned by classify_sysode, combining
+        them give hints name used later for forming method name.
+
+    Examples
+    ========
+
+    >>> from sympy import Function, dsolve, Eq, Derivative, sin, cos, symbols
+    >>> from sympy.abc import x
+    >>> f = Function('f')
+    >>> dsolve(Derivative(f(x), x, x) + 9*f(x), f(x))
+    Eq(f(x), C1*sin(3*x) + C2*cos(3*x))
+
+    >>> eq = sin(x)*cos(f(x)) + cos(x)*sin(f(x))*f(x).diff(x)
+    >>> dsolve(eq, hint='1st_exact')
+    [Eq(f(x), -acos(C1/cos(x)) + 2*pi), Eq(f(x), acos(C1/cos(x)))]
+    >>> dsolve(eq, hint='almost_linear')
+    [Eq(f(x), -acos(C1/cos(x)) + 2*pi), Eq(f(x), acos(C1/cos(x)))]
+    >>> t = symbols('t')
+    >>> x, y = symbols('x, y', cls=Function)
+    >>> eq = (Eq(Derivative(x(t),t), 12*t*x(t) + 8*y(t)), Eq(Derivative(y(t),t), 21*x(t) + 7*t*y(t)))
+    >>> dsolve(eq)
+    [Eq(x(t), C1*x0(t) + C2*x0(t)*Integral(8*exp(Integral(7*t, t))*exp(Integral(12*t, t))/x0(t)**2, t)),
+    Eq(y(t), C1*y0(t) + C2*(y0(t)*Integral(8*exp(Integral(7*t, t))*exp(Integral(12*t, t))/x0(t)**2, t) +
+    exp(Integral(7*t, t))*exp(Integral(12*t, t))/x0(t)))]
+    >>> eq = (Eq(Derivative(x(t),t),x(t)*y(t)*sin(t)), Eq(Derivative(y(t),t),y(t)**2*sin(t)))
+    >>> dsolve(eq)
+    {Eq(x(t), -exp(C1)/(C2*exp(C1) - cos(t))), Eq(y(t), -1/(C1 - cos(t)))}
+    """
+    if iterable(eq):
+        from sympy.solvers.ode.systems import dsolve_system
+
+        # This may have to be changed in future
+        # when we have weakly and strongly
+        # connected components. This have to
+        # changed to show the systems that haven't
+        # been solved.
+        try:
+            sol = dsolve_system(eq, funcs=func, ics=ics, doit=True)
+            return sol[0] if len(sol) == 1 else sol
+        except NotImplementedError:
+            pass
+
+        match = classify_sysode(eq, func)
+
+        eq = match['eq']
+        order = match['order']
+        func = match['func']
+        t = list(list(eq[0].atoms(Derivative))[0].atoms(Symbol))[0]
+
+        # keep highest order term coefficient positive
+        for i in range(len(eq)):
+            for func_ in func:
+                if isinstance(func_, list):
+                    pass
+                else:
+                    if eq[i].coeff(diff(func[i],t,ode_order(eq[i], func[i]))).is_negative:
+                        eq[i] = -eq[i]
+        match['eq'] = eq
+        if len(set(order.values()))!=1:
+            raise ValueError("It solves only those systems of equations whose orders are equal")
+        match['order'] = list(order.values())[0]
+        def recur_len(l):
+            return sum(recur_len(item) if isinstance(item,list) else 1 for item in l)
+        if recur_len(func) != len(eq):
+            raise ValueError("dsolve() and classify_sysode() work with "
+            "number of functions being equal to number of equations")
+        if match['type_of_equation'] is None:
+            raise NotImplementedError
+        else:
+            if match['is_linear'] == True:
+                solvefunc = globals()['sysode_linear_%(no_of_equation)seq_order%(order)s' % match]
+            else:
+                solvefunc = globals()['sysode_nonlinear_%(no_of_equation)seq_order%(order)s' % match]
+            sols = solvefunc(match)
+            if ics:
+                constants = Tuple(*sols).free_symbols - Tuple(*eq).free_symbols
+                solved_constants = solve_ics(sols, func, constants, ics)
+                return [sol.subs(solved_constants) for sol in sols]
+            return sols
+    else:
+        given_hint = hint  # hint given by the user
+
+        # See the docstring of _desolve for more details.
+        hints = _desolve(eq, func=func,
+            hint=hint, simplify=True, xi=xi, eta=eta, type='ode', ics=ics,
+            x0=x0, n=n, **kwargs)
+        eq = hints.pop('eq', eq)
+        all_ = hints.pop('all', False)
+        if all_:
+            retdict = {}
+            failed_hints = {}
+            gethints = classify_ode(eq, dict=True, hint='all')
+            orderedhints = gethints['ordered_hints']
+            for hint in hints:
+                try:
+                    rv = _helper_simplify(eq, hint, hints[hint], simplify)
+                except NotImplementedError as detail:
+                    failed_hints[hint] = detail
+                else:
+                    retdict[hint] = rv
+            func = hints[hint]['func']
+
+            retdict['best'] = min(list(retdict.values()), key=lambda x:
+                ode_sol_simplicity(x, func, trysolving=not simplify))
+            if given_hint == 'best':
+                return retdict['best']
+            for i in orderedhints:
+                if retdict['best'] == retdict.get(i, None):
+                    retdict['best_hint'] = i
+                    break
+            retdict['default'] = gethints['default']
+            retdict['order'] = gethints['order']
+            retdict.update(failed_hints)
+            return retdict
+
+        else:
+            # The key 'hint' stores the hint needed to be solved for.
+            hint = hints['hint']
+            return _helper_simplify(eq, hint, hints, simplify, ics=ics)
+
+
+def _helper_simplify(eq, hint, match, simplify=True, ics=None, **kwargs):
+    r"""
+    Helper function of dsolve that calls the respective
+    :py:mod:`~sympy.solvers.ode` functions to solve for the ordinary
+    differential equations. This minimizes the computation in calling
+    :py:meth:`~sympy.solvers.deutils._desolve` multiple times.
+    """
+    r = match
+    func = r['func']
+    order = r['order']
+    match = r[hint]
+
+    if isinstance(match, SingleODESolver):
+        solvefunc = match
+    else:
+        solvefunc = globals()['ode_' + hint.removesuffix('_Integral')]
+
+    free = eq.free_symbols
+    cons = lambda s: s.free_symbols.difference(free)
+
+    if simplify:
+        # odesimp() will attempt to integrate, if necessary, apply constantsimp(),
+        # attempt to solve for func, and apply any other hint specific
+        # simplifications
+        if isinstance(solvefunc, SingleODESolver):
+            sols = solvefunc.get_general_solution()
+        else:
+            sols = solvefunc(eq, func, order, match)
+        if iterable(sols):
+            rv = []
+            for s in sols:
+                simp = odesimp(eq, s, func, hint)
+                if iterable(simp):
+                    rv.extend(simp)
+                else:
+                    rv.append(simp)
+        else:
+            rv = odesimp(eq, sols, func, hint)
+    else:
+        # We still want to integrate (you can disable it separately with the hint)
+        if isinstance(solvefunc, SingleODESolver):
+            exprs = solvefunc.get_general_solution(simplify=False)
+        else:
+            match['simplify'] = False  # Some hints can take advantage of this option
+            exprs = solvefunc(eq, func, order, match)
+        if isinstance(exprs, list):
+            rv = [_handle_Integral(expr, func, hint) for expr in exprs]
+        else:
+            rv = _handle_Integral(exprs, func, hint)
+
+    if isinstance(rv, list):
+        assert all(isinstance(i, Eq) for i in rv), rv  # if not => internal error
+        if simplify:
+            rv = _remove_redundant_solutions(eq, rv, order, func.args[0])
+        if len(rv) == 1:
+            rv = rv[0]
+    if ics and 'power_series' not in hint:
+        if isinstance(rv, (Expr, Eq)):
+            solved_constants = solve_ics([rv], [r['func']], cons(rv), ics)
+            rv = rv.subs(solved_constants)
+        else:
+            rv1 = []
+            for s in rv:
+                try:
+                    solved_constants = solve_ics([s], [r['func']], cons(s), ics)
+                except ValueError:
+                    continue
+                rv1.append(s.subs(solved_constants))
+            if len(rv1) == 1:
+                return rv1[0]
+            rv = rv1
+    return rv
+
+
+def solve_ics(sols, funcs, constants, ics):
+    """
+    Solve for the constants given initial conditions
+
+    ``sols`` is a list of solutions.
+
+    ``funcs`` is a list of functions.
+
+    ``constants`` is a list of constants.
+
+    ``ics`` is the set of initial/boundary conditions for the differential
+    equation. It should be given in the form of ``{f(x0): x1,
+    f(x).diff(x).subs(x, x2):  x3}`` and so on.
+
+    Returns a dictionary mapping constants to values.
+    ``solution.subs(constants)`` will replace the constants in ``solution``.
+
+    Example
+    =======
+    >>> # From dsolve(f(x).diff(x) - f(x), f(x))
+    >>> from sympy import symbols, Eq, exp, Function
+    >>> from sympy.solvers.ode.ode import solve_ics
+    >>> f = Function('f')
+    >>> x, C1 = symbols('x C1')
+    >>> sols = [Eq(f(x), C1*exp(x))]
+    >>> funcs = [f(x)]
+    >>> constants = [C1]
+    >>> ics = {f(0): 2}
+    >>> solved_constants = solve_ics(sols, funcs, constants, ics)
+    >>> solved_constants
+    {C1: 2}
+    >>> sols[0].subs(solved_constants)
+    Eq(f(x), 2*exp(x))
+
+    """
+    # Assume ics are of the form f(x0): value or Subs(diff(f(x), x, n), (x,
+    # x0)): value (currently checked by classify_ode). To solve, replace x
+    # with x0, f(x0) with value, then solve for constants. For f^(n)(x0),
+    # differentiate the solution n times, so that f^(n)(x) appears.
+    x = funcs[0].args[0]
+    diff_sols = []
+    subs_sols = []
+    diff_variables = set()
+    for funcarg, value in ics.items():
+        if isinstance(funcarg, AppliedUndef):
+            x0 = funcarg.args[0]
+            matching_func = [f for f in funcs if f.func == funcarg.func][0]
+            S = sols
+        elif isinstance(funcarg, (Subs, Derivative)):
+            if isinstance(funcarg, Subs):
+                # Make sure it stays a subs. Otherwise subs below will produce
+                # a different looking term.
+                funcarg = funcarg.doit()
+            if isinstance(funcarg, Subs):
+                deriv = funcarg.expr
+                x0 = funcarg.point[0]
+                variables = funcarg.expr.variables
+                matching_func = deriv
+            elif isinstance(funcarg, Derivative):
+                deriv = funcarg
+                x0 = funcarg.variables[0]
+                variables = (x,)*len(funcarg.variables)
+                matching_func = deriv.subs(x0, x)
+            for sol in sols:
+                if sol.has(deriv.expr.func):
+                    diff_sols.append(Eq(sol.lhs.diff(*variables), sol.rhs.diff(*variables)))
+            diff_variables.add(variables)
+            S = diff_sols
+        else:
+            raise NotImplementedError("Unrecognized initial condition")
+
+        for sol in S:
+            if sol.has(matching_func):
+                sol2 = sol
+                sol2 = sol2.subs(x, x0)
+                sol2 = sol2.subs(funcarg, value)
+                # This check is necessary because of issue #15724
+                if not isinstance(sol2, BooleanAtom) or not subs_sols:
+                    subs_sols = [s for s in subs_sols if not isinstance(s, BooleanAtom)]
+                    subs_sols.append(sol2)
+
+    # TODO: Use solveset here
+    try:
+        solved_constants = solve(subs_sols, constants, dict=True)
+    except NotImplementedError:
+        solved_constants = []
+
+    # XXX: We can't differentiate between the solution not existing because of
+    # invalid initial conditions, and not existing because solve is not smart
+    # enough. If we could use solveset, this might be improvable, but for now,
+    # we use NotImplementedError in this case.
+    if not solved_constants:
+        raise ValueError("Couldn't solve for initial conditions")
+
+    if solved_constants == True:
+        raise ValueError("Initial conditions did not produce any solutions for constants. Perhaps they are degenerate.")
+
+    if len(solved_constants) > 1:
+        raise NotImplementedError("Initial conditions produced too many solutions for constants")
+
+    return solved_constants[0]
+
+def classify_ode(eq, func=None, dict=False, ics=None, *, prep=True, xi=None, eta=None, n=None, **kwargs):
+    r"""
+    Returns a tuple of possible :py:meth:`~sympy.solvers.ode.dsolve`
+    classifications for an ODE.
+
+    The tuple is ordered so that first item is the classification that
+    :py:meth:`~sympy.solvers.ode.dsolve` uses to solve the ODE by default.  In
+    general, classifications at the near the beginning of the list will
+    produce better solutions faster than those near the end, thought there are
+    always exceptions.  To make :py:meth:`~sympy.solvers.ode.dsolve` use a
+    different classification, use ``dsolve(ODE, func,
+    hint=<classification>)``.  See also the
+    :py:meth:`~sympy.solvers.ode.dsolve` docstring for different meta-hints
+    you can use.
+
+    If ``dict`` is true, :py:meth:`~sympy.solvers.ode.classify_ode` will
+    return a dictionary of ``hint:match`` expression terms. This is intended
+    for internal use by :py:meth:`~sympy.solvers.ode.dsolve`.  Note that
+    because dictionaries are ordered arbitrarily, this will most likely not be
+    in the same order as the tuple.
+
+    You can get help on different hints by executing
+    ``help(ode.ode_hintname)``, where ``hintname`` is the name of the hint
+    without ``_Integral``.
+
+    See :py:data:`~sympy.solvers.ode.allhints` or the
+    :py:mod:`~sympy.solvers.ode` docstring for a list of all supported hints
+    that can be returned from :py:meth:`~sympy.solvers.ode.classify_ode`.
+
+    Notes
+    =====
+
+    These are remarks on hint names.
+
+    ``_Integral``
+
+        If a classification has ``_Integral`` at the end, it will return the
+        expression with an unevaluated :py:class:`~.Integral`
+        class in it.  Note that a hint may do this anyway if
+        :py:meth:`~sympy.core.expr.Expr.integrate` cannot do the integral,
+        though just using an ``_Integral`` will do so much faster.  Indeed, an
+        ``_Integral`` hint will always be faster than its corresponding hint
+        without ``_Integral`` because
+        :py:meth:`~sympy.core.expr.Expr.integrate` is an expensive routine.
+        If :py:meth:`~sympy.solvers.ode.dsolve` hangs, it is probably because
+        :py:meth:`~sympy.core.expr.Expr.integrate` is hanging on a tough or
+        impossible integral.  Try using an ``_Integral`` hint or
+        ``all_Integral`` to get it return something.
+
+        Note that some hints do not have ``_Integral`` counterparts. This is
+        because :py:func:`~sympy.integrals.integrals.integrate` is not used in
+        solving the ODE for those method. For example, `n`\th order linear
+        homogeneous ODEs with constant coefficients do not require integration
+        to solve, so there is no
+        ``nth_linear_homogeneous_constant_coeff_Integrate`` hint. You can
+        easily evaluate any unevaluated
+        :py:class:`~sympy.integrals.integrals.Integral`\s in an expression by
+        doing ``expr.doit()``.
+
+    Ordinals
+
+        Some hints contain an ordinal such as ``1st_linear``.  This is to help
+        differentiate them from other hints, as well as from other methods
+        that may not be implemented yet. If a hint has ``nth`` in it, such as
+        the ``nth_linear`` hints, this means that the method used to applies
+        to ODEs of any order.
+
+    ``indep`` and ``dep``
+
+        Some hints contain the words ``indep`` or ``dep``.  These reference
+        the independent variable and the dependent function, respectively. For
+        example, if an ODE is in terms of `f(x)`, then ``indep`` will refer to
+        `x` and ``dep`` will refer to `f`.
+
+    ``subs``
+
+        If a hints has the word ``subs`` in it, it means that the ODE is solved
+        by substituting the expression given after the word ``subs`` for a
+        single dummy variable.  This is usually in terms of ``indep`` and
+        ``dep`` as above.  The substituted expression will be written only in
+        characters allowed for names of Python objects, meaning operators will
+        be spelled out.  For example, ``indep``/``dep`` will be written as
+        ``indep_div_dep``.
+
+    ``coeff``
+
+        The word ``coeff`` in a hint refers to the coefficients of something
+        in the ODE, usually of the derivative terms.  See the docstring for
+        the individual methods for more info (``help(ode)``).  This is
+        contrast to ``coefficients``, as in ``undetermined_coefficients``,
+        which refers to the common name of a method.
+
+    ``_best``
+
+        Methods that have more than one fundamental way to solve will have a
+        hint for each sub-method and a ``_best`` meta-classification. This
+        will evaluate all hints and return the best, using the same
+        considerations as the normal ``best`` meta-hint.
+
+
+    Examples
+    ========
+
+    >>> from sympy import Function, classify_ode, Eq
+    >>> from sympy.abc import x
+    >>> f = Function('f')
+    >>> classify_ode(Eq(f(x).diff(x), 0), f(x))
+    ('nth_algebraic',
+    'separable',
+    '1st_exact',
+    '1st_linear',
+    'Bernoulli',
+    '1st_homogeneous_coeff_best',
+    '1st_homogeneous_coeff_subs_indep_div_dep',
+    '1st_homogeneous_coeff_subs_dep_div_indep',
+    '1st_power_series', 'lie_group', 'nth_linear_constant_coeff_homogeneous',
+    'nth_linear_euler_eq_homogeneous',
+    'nth_algebraic_Integral', 'separable_Integral', '1st_exact_Integral',
+    '1st_linear_Integral', 'Bernoulli_Integral',
+    '1st_homogeneous_coeff_subs_indep_div_dep_Integral',
+    '1st_homogeneous_coeff_subs_dep_div_indep_Integral')
+    >>> classify_ode(f(x).diff(x, 2) + 3*f(x).diff(x) + 2*f(x) - 4)
+    ('factorable', 'nth_linear_constant_coeff_undetermined_coefficients',
+    'nth_linear_constant_coeff_variation_of_parameters',
+    'nth_linear_constant_coeff_variation_of_parameters_Integral')
+
+    """
+    ics = sympify(ics)
+
+    if func and len(func.args) != 1:
+        raise ValueError("dsolve() and classify_ode() only "
+        "work with functions of one variable, not %s" % func)
+
+    if isinstance(eq, Equality):
+        eq = eq.lhs - eq.rhs
+
+    # Some methods want the unprocessed equation
+    eq_orig = eq
+
+    if prep or func is None:
+        eq, func_ = _preprocess(eq, func)
+        if func is None:
+            func = func_
+    x = func.args[0]
+    f = func.func
+    y = Dummy('y')
+    terms = 5 if n is None else n
+
+    order = ode_order(eq, f(x))
+    # hint:matchdict or hint:(tuple of matchdicts)
+    # Also will contain "default":<default hint> and "order":order items.
+    matching_hints = {"order": order}
+
+    df = f(x).diff(x)
+    a = Wild('a', exclude=[f(x)])
+    d = Wild('d', exclude=[df, f(x).diff(x, 2)])
+    e = Wild('e', exclude=[df])
+    n = Wild('n', exclude=[x, f(x), df])
+    c1 = Wild('c1', exclude=[x])
+    a3 = Wild('a3', exclude=[f(x), df, f(x).diff(x, 2)])
+    b3 = Wild('b3', exclude=[f(x), df, f(x).diff(x, 2)])
+    c3 = Wild('c3', exclude=[f(x), df, f(x).diff(x, 2)])
+    boundary = {}  # Used to extract initial conditions
+    C1 = Symbol("C1")
+
+    # Preprocessing to get the initial conditions out
+    if ics is not None:
+        for funcarg in ics:
+            # Separating derivatives
+            if isinstance(funcarg, (Subs, Derivative)):
+                # f(x).diff(x).subs(x, 0) is a Subs, but f(x).diff(x).subs(x,
+                # y) is a Derivative
+                if isinstance(funcarg, Subs):
+                    deriv = funcarg.expr
+                    old = funcarg.variables[0]
+                    new = funcarg.point[0]
+                elif isinstance(funcarg, Derivative):
+                    deriv = funcarg
+                    # No information on this. Just assume it was x
+                    old = x
+                    new = funcarg.variables[0]
+
+                if (isinstance(deriv, Derivative) and isinstance(deriv.args[0],
+                    AppliedUndef) and deriv.args[0].func == f and
+                    len(deriv.args[0].args) == 1 and old == x and not
+                    new.has(x) and all(i == deriv.variables[0] for i in
+                    deriv.variables) and x not in ics[funcarg].free_symbols):
+
+                    dorder = ode_order(deriv, x)
+                    temp = 'f' + str(dorder)
+                    boundary.update({temp: new, temp + 'val': ics[funcarg]})
+                else:
+                    raise ValueError("Invalid boundary conditions for Derivatives")
+
+
+            # Separating functions
+            elif isinstance(funcarg, AppliedUndef):
+                if (funcarg.func == f and len(funcarg.args) == 1 and
+                    not funcarg.args[0].has(x) and x not in ics[funcarg].free_symbols):
+                    boundary.update({'f0': funcarg.args[0], 'f0val': ics[funcarg]})
+                else:
+                    raise ValueError("Invalid boundary conditions for Function")
+
+            else:
+                raise ValueError("Enter boundary conditions of the form ics={f(point): value, f(x).diff(x, order).subs(x, point): value}")
+
+    ode = SingleODEProblem(eq_orig, func, x, prep=prep, xi=xi, eta=eta)
+    user_hint = kwargs.get('hint', 'default')
+    # Used when dsolve is called without an explicit hint.
+    # We exit early to return the first valid match
+    early_exit = (user_hint=='default')
+    user_hint = user_hint.removesuffix('_Integral')
+    user_map = solver_map
+    # An explicit hint has been given to dsolve
+    # Skip matching code for other hints
+    if user_hint not in ['default', 'all', 'all_Integral', 'best'] and user_hint in solver_map:
+        user_map = {user_hint: solver_map[user_hint]}
+
+    for hint in user_map:
+        solver = user_map[hint](ode)
+        if solver.matches():
+            matching_hints[hint] = solver
+            if user_map[hint].has_integral:
+                matching_hints[hint + "_Integral"] = solver
+            if dict and early_exit:
+                matching_hints["default"] = hint
+                return matching_hints
+
+    eq = expand(eq)
+    # Precondition to try remove f(x) from highest order derivative
+    reduced_eq = None
+    if eq.is_Add:
+        deriv_coef = eq.coeff(f(x).diff(x, order))
+        if deriv_coef not in (1, 0):
+            r = deriv_coef.match(a*f(x)**c1)
+            if r and r[c1]:
+                den = f(x)**r[c1]
+                reduced_eq = Add(*[arg/den for arg in eq.args])
+    if not reduced_eq:
+        reduced_eq = eq
+
+    if order == 1:
+
+        # NON-REDUCED FORM OF EQUATION matches
+        r = collect(eq, df, exact=True).match(d + e * df)
+        if r:
+            r['d'] = d
+            r['e'] = e
+            r['y'] = y
+            r[d] = r[d].subs(f(x), y)
+            r[e] = r[e].subs(f(x), y)
+
+            # FIRST ORDER POWER SERIES WHICH NEEDS INITIAL CONDITIONS
+            # TODO: Hint first order series should match only if d/e is analytic.
+            # For now, only d/e and (d/e).diff(arg) is checked for existence at
+            # at a given point.
+            # This is currently done internally in ode_1st_power_series.
+            point = boundary.get('f0', 0)
+            value = boundary.get('f0val', C1)
+            check = cancel(r[d]/r[e])
+            check1 = check.subs({x: point, y: value})
+            if not check1.has(oo) and not check1.has(zoo) and \
+                not check1.has(nan) and not check1.has(-oo):
+                check2 = (check1.diff(x)).subs({x: point, y: value})
+                if not check2.has(oo) and not check2.has(zoo) and \
+                    not check2.has(nan) and not check2.has(-oo):
+                    rseries = r.copy()
+                    rseries.update({'terms': terms, 'f0': point, 'f0val': value})
+                    matching_hints["1st_power_series"] = rseries
+
+    elif order == 2:
+        # Homogeneous second order differential equation of the form
+        # a3*f(x).diff(x, 2) + b3*f(x).diff(x) + c3
+        # It has a definite power series solution at point x0 if, b3/a3 and c3/a3
+        # are analytic at x0.
+        deq = a3*(f(x).diff(x, 2)) + b3*df + c3*f(x)
+        r = collect(reduced_eq,
+            [f(x).diff(x, 2), f(x).diff(x), f(x)]).match(deq)
+        ordinary = False
+        if r:
+            if not all(r[key].is_polynomial() for key in r):
+                n, d = reduced_eq.as_numer_denom()
+                reduced_eq = expand(n)
+                r = collect(reduced_eq,
+                    [f(x).diff(x, 2), f(x).diff(x), f(x)]).match(deq)
+        if r and r[a3] != 0:
+            p = cancel(r[b3]/r[a3])  # Used below
+            q = cancel(r[c3]/r[a3])  # Used below
+            point = kwargs.get('x0', 0)
+            check = p.subs(x, point)
+            if not check.has(oo, nan, zoo, -oo):
+                check = q.subs(x, point)
+                if not check.has(oo, nan, zoo, -oo):
+                    ordinary = True
+                    r.update({'a3': a3, 'b3': b3, 'c3': c3, 'x0': point, 'terms': terms})
+                    matching_hints["2nd_power_series_ordinary"] = r
+
+            # Checking if the differential equation has a regular singular point
+            # at x0. It has a regular singular point at x0, if (b3/a3)*(x - x0)
+            # and (c3/a3)*((x - x0)**2) are analytic at x0.
+            if not ordinary:
+                p = cancel((x - point)*p)
+                check = p.subs(x, point)
+                if not check.has(oo, nan, zoo, -oo):
+                    q = cancel(((x - point)**2)*q)
+                    check = q.subs(x, point)
+                    if not check.has(oo, nan, zoo, -oo):
+                        coeff_dict = {'p': p, 'q': q, 'x0': point, 'terms': terms}
+                        matching_hints["2nd_power_series_regular"] = coeff_dict
+
+
+    # Order keys based on allhints.
+    retlist = [i for i in allhints if i in matching_hints]
+    if dict:
+        # Dictionaries are ordered arbitrarily, so make note of which
+        # hint would come first for dsolve().  Use an ordered dict in Py 3.
+        matching_hints["default"] = retlist[0] if retlist else None
+        matching_hints["ordered_hints"] = tuple(retlist)
+        return matching_hints
+    else:
+        return tuple(retlist)
+
+
+def classify_sysode(eq, funcs=None, **kwargs):
+    r"""
+    Returns a dictionary of parameter names and values that define the system
+    of ordinary differential equations in ``eq``.
+    The parameters are further used in
+    :py:meth:`~sympy.solvers.ode.dsolve` for solving that system.
+
+    Some parameter names and values are:
+
+    'is_linear' (boolean), which tells whether the given system is linear.
+    Note that "linear" here refers to the operator: terms such as ``x*diff(x,t)`` are
+    nonlinear, whereas terms like ``sin(t)*diff(x,t)`` are still linear operators.
+
+    'func' (list) contains the :py:class:`~sympy.core.function.Function`s that
+    appear with a derivative in the ODE, i.e. those that we are trying to solve
+    the ODE for.
+
+    'order' (dict) with the maximum derivative for each element of the 'func'
+    parameter.
+
+    'func_coeff' (dict or Matrix) with the coefficient for each triple ``(equation number,
+    function, order)```. The coefficients are those subexpressions that do not
+    appear in 'func', and hence can be considered constant for purposes of ODE
+    solving. The value of this parameter can also be a  Matrix if the system of ODEs are
+    linear first order of the form X' = AX where X is the vector of dependent variables.
+    Here, this function returns the coefficient matrix A.
+
+    'eq' (list) with the equations from ``eq``, sympified and transformed into
+    expressions (we are solving for these expressions to be zero).
+
+    'no_of_equations' (int) is the number of equations (same as ``len(eq)``).
+
+    'type_of_equation' (string) is an internal classification of the type of
+    ODE.
+
+    'is_constant' (boolean), which tells if the system of ODEs is constant coefficient
+    or not. This key is temporary addition for now and is in the match dict only when
+    the system of ODEs is linear first order constant coefficient homogeneous. So, this
+    key's value is True for now if it is available else it does not exist.
+
+    'is_homogeneous' (boolean), which tells if the system of ODEs is homogeneous. Like the
+    key 'is_constant', this key is a temporary addition and it is True since this key value
+    is available only when the system is linear first order constant coefficient homogeneous.
+
+    References
+    ==========
+    -https://eqworld.ipmnet.ru/en/solutions/sysode/sode-toc1.htm
+    -A. D. Polyanin and A. V. Manzhirov, Handbook of Mathematics for Engineers and Scientists
+
+    Examples
+    ========
+
+    >>> from sympy import Function, Eq, symbols, diff
+    >>> from sympy.solvers.ode.ode import classify_sysode
+    >>> from sympy.abc import t
+    >>> f, x, y = symbols('f, x, y', cls=Function)
+    >>> k, l, m, n = symbols('k, l, m, n', Integer=True)
+    >>> x1 = diff(x(t), t) ; y1 = diff(y(t), t)
+    >>> x2 = diff(x(t), t, t) ; y2 = diff(y(t), t, t)
+    >>> eq = (Eq(x1, 12*x(t) - 6*y(t)), Eq(y1, 11*x(t) + 3*y(t)))
+    >>> classify_sysode(eq)
+    {'eq': [-12*x(t) + 6*y(t) + Derivative(x(t), t), -11*x(t) - 3*y(t) + Derivative(y(t), t)], 'func': [x(t), y(t)],
+     'func_coeff': {(0, x(t), 0): -12, (0, x(t), 1): 1, (0, y(t), 0): 6, (0, y(t), 1): 0, (1, x(t), 0): -11, (1, x(t), 1): 0, (1, y(t), 0): -3, (1, y(t), 1): 1}, 'is_linear': True, 'no_of_equation': 2, 'order': {x(t): 1, y(t): 1}, 'type_of_equation': None}
+    >>> eq = (Eq(diff(x(t),t), 5*t*x(t) + t**2*y(t) + 2), Eq(diff(y(t),t), -t**2*x(t) + 5*t*y(t)))
+    >>> classify_sysode(eq)
+    {'eq': [-t**2*y(t) - 5*t*x(t) + Derivative(x(t), t) - 2, t**2*x(t) - 5*t*y(t) + Derivative(y(t), t)],
+     'func': [x(t), y(t)], 'func_coeff': {(0, x(t), 0): -5*t, (0, x(t), 1): 1, (0, y(t), 0): -t**2, (0, y(t), 1): 0,
+     (1, x(t), 0): t**2, (1, x(t), 1): 0, (1, y(t), 0): -5*t, (1, y(t), 1): 1}, 'is_linear': True, 'no_of_equation': 2,
+      'order': {x(t): 1, y(t): 1}, 'type_of_equation': None}
+
+    """
+
+    # Sympify equations and convert iterables of equations into
+    # a list of equations
+    def _sympify(eq):
+        return list(map(sympify, eq if iterable(eq) else [eq]))
+
+    eq, funcs = (_sympify(w) for w in [eq, funcs])
+    for i, fi in enumerate(eq):
+        if isinstance(fi, Equality):
+            eq[i] = fi.lhs - fi.rhs
+
+    t = list(list(eq[0].atoms(Derivative))[0].atoms(Symbol))[0]
+    matching_hints = {"no_of_equation":i+1}
+    matching_hints['eq'] = eq
+    if i==0:
+        raise ValueError("classify_sysode() works for systems of ODEs. "
+        "For scalar ODEs, classify_ode should be used")
+
+    # find all the functions if not given
+    order = {}
+    if funcs==[None]:
+        funcs = _extract_funcs(eq)
+
+    funcs = list(set(funcs))
+    if len(funcs) != len(eq):
+        raise ValueError("Number of functions given is not equal to the number of equations %s" % funcs)
+
+    # This logic of list of lists in funcs to
+    # be replaced later.
+    func_dict = {}
+    for func in funcs:
+        if not order.get(func, False):
+            max_order = 0
+            for i, eqs_ in enumerate(eq):
+                order_ = ode_order(eqs_,func)
+                if max_order < order_:
+                    max_order = order_
+                    eq_no = i
+            if eq_no in func_dict:
+                func_dict[eq_no] = [func_dict[eq_no], func]
+            else:
+                func_dict[eq_no] = func
+            order[func] = max_order
+
+    funcs = [func_dict[i] for i in range(len(func_dict))]
+    matching_hints['func'] = funcs
+    for func in funcs:
+        if isinstance(func, list):
+            for func_elem in func:
+                if len(func_elem.args) != 1:
+                    raise ValueError("dsolve() and classify_sysode() work with "
+                    "functions of one variable only, not %s" % func)
+        else:
+            if func and len(func.args) != 1:
+                raise ValueError("dsolve() and classify_sysode() work with "
+                "functions of one variable only, not %s" % func)
+
+    # find the order of all equation in system of odes
+    matching_hints["order"] = order
+
+    # find coefficients of terms f(t), diff(f(t),t) and higher derivatives
+    # and similarly for other functions g(t), diff(g(t),t) in all equations.
+    # Here j denotes the equation number, funcs[l] denotes the function about
+    # which we are talking about and k denotes the order of function funcs[l]
+    # whose coefficient we are calculating.
+    def linearity_check(eqs, j, func, is_linear_):
+        for k in range(order[func] + 1):
+            func_coef[j, func, k] = collect(eqs.expand(), [diff(func, t, k)]).coeff(diff(func, t, k))
+            if is_linear_ == True:
+                if func_coef[j, func, k] == 0:
+                    if k == 0:
+                        coef = eqs.as_independent(func, as_Add=True)[1]
+                        for xr in range(1, ode_order(eqs,func) + 1):
+                            coef -= eqs.as_independent(diff(func, t, xr), as_Add=True)[1]
+                        if coef != 0:
+                            is_linear_ = False
+                    else:
+                        if eqs.as_independent(diff(func, t, k), as_Add=True)[1]:
+                            is_linear_ = False
+                else:
+                    for func_ in funcs:
+                        if isinstance(func_, list):
+                            for elem_func_ in func_:
+                                dep = func_coef[j, func, k].as_independent(elem_func_, as_Add=True)[1]
+                                if dep != 0:
+                                    is_linear_ = False
+                        else:
+                            dep = func_coef[j, func, k].as_independent(func_, as_Add=True)[1]
+                            if dep != 0:
+                                is_linear_ = False
+        return is_linear_
+
+    func_coef = {}
+    is_linear = True
+    for j, eqs in enumerate(eq):
+        for func in funcs:
+            if isinstance(func, list):
+                for func_elem in func:
+                    is_linear = linearity_check(eqs, j, func_elem, is_linear)
+            else:
+                is_linear = linearity_check(eqs, j, func, is_linear)
+    matching_hints['func_coeff'] = func_coef
+    matching_hints['is_linear'] = is_linear
+
+
+    if len(set(order.values())) == 1:
+        order_eq = list(matching_hints['order'].values())[0]
+        if matching_hints['is_linear'] == True:
+            if matching_hints['no_of_equation'] == 2:
+                if order_eq == 1:
+                    type_of_equation = check_linear_2eq_order1(eq, funcs, func_coef)
+                else:
+                    type_of_equation = None
+            # If the equation does not match up with any of the
+            # general case solvers in systems.py and the number
+            # of equations is greater than 2, then NotImplementedError
+            # should be raised.
+            else:
+                type_of_equation = None
+
+        else:
+            if matching_hints['no_of_equation'] == 2:
+                if order_eq == 1:
+                    type_of_equation = check_nonlinear_2eq_order1(eq, funcs, func_coef)
+                else:
+                    type_of_equation = None
+            elif matching_hints['no_of_equation'] == 3:
+                if order_eq == 1:
+                    type_of_equation = check_nonlinear_3eq_order1(eq, funcs, func_coef)
+                else:
+                    type_of_equation = None
+            else:
+                type_of_equation = None
+    else:
+        type_of_equation = None
+
+    matching_hints['type_of_equation'] = type_of_equation
+
+    return matching_hints
+
+
+def check_linear_2eq_order1(eq, func, func_coef):
+    x = func[0].func
+    y = func[1].func
+    fc = func_coef
+    t = list(list(eq[0].atoms(Derivative))[0].atoms(Symbol))[0]
+    r = {}
+    # for equations Eq(a1*diff(x(t),t), b1*x(t) + c1*y(t) + d1)
+    # and Eq(a2*diff(y(t),t), b2*x(t) + c2*y(t) + d2)
+    r['a1'] = fc[0,x(t),1] ; r['a2'] = fc[1,y(t),1]
+    r['b1'] = -fc[0,x(t),0]/fc[0,x(t),1] ; r['b2'] = -fc[1,x(t),0]/fc[1,y(t),1]
+    r['c1'] = -fc[0,y(t),0]/fc[0,x(t),1] ; r['c2'] = -fc[1,y(t),0]/fc[1,y(t),1]
+    forcing = [S.Zero,S.Zero]
+    for i in range(2):
+        for j in Add.make_args(eq[i]):
+            if not j.has(x(t), y(t)):
+                forcing[i] += j
+    if not (forcing[0].has(t) or forcing[1].has(t)):
+        # We can handle homogeneous case and simple constant forcings
+        r['d1'] = forcing[0]
+        r['d2'] = forcing[1]
+    else:
+        # Issue #9244: nonhomogeneous linear systems are not supported
+        return None
+
+    # Conditions to check for type 6 whose equations are Eq(diff(x(t),t), f(t)*x(t) + g(t)*y(t)) and
+    # Eq(diff(y(t),t), a*[f(t) + a*h(t)]x(t) + a*[g(t) - h(t)]*y(t))
+    p = 0
+    q = 0
+    p1 = cancel(r['b2']/(cancel(r['b2']/r['c2']).as_numer_denom()[0]))
+    p2 = cancel(r['b1']/(cancel(r['b1']/r['c1']).as_numer_denom()[0]))
+    for n, i in enumerate([p1, p2]):
+        for j in Mul.make_args(collect_const(i)):
+            if not j.has(t):
+                q = j
+            if q and n==0:
+                if ((r['b2']/j - r['b1'])/(r['c1'] - r['c2']/j)) == j:
+                    p = 1
+            elif q and n==1:
+                if ((r['b1']/j - r['b2'])/(r['c2'] - r['c1']/j)) == j:
+                    p = 2
+    # End of condition for type 6
+
+    if r['d1']!=0 or r['d2']!=0:
+        return None
+    else:
+        if not any(r[k].has(t) for k in 'a1 a2 b1 b2 c1 c2'.split()):
+            return None
+        else:
+            r['b1'] = r['b1']/r['a1'] ; r['b2'] = r['b2']/r['a2']
+            r['c1'] = r['c1']/r['a1'] ; r['c2'] = r['c2']/r['a2']
+            if p:
+                return "type6"
+            else:
+                # Equations for type 7 are Eq(diff(x(t),t), f(t)*x(t) + g(t)*y(t)) and Eq(diff(y(t),t), h(t)*x(t) + p(t)*y(t))
+                return "type7"
+def check_nonlinear_2eq_order1(eq, func, func_coef):
+    t = list(list(eq[0].atoms(Derivative))[0].atoms(Symbol))[0]
+    f = Wild('f')
+    g = Wild('g')
+    u, v = symbols('u, v', cls=Dummy)
+    def check_type(x, y):
+        r1 = eq[0].match(t*diff(x(t),t) - x(t) + f)
+        r2 = eq[1].match(t*diff(y(t),t) - y(t) + g)
+        if not (r1 and r2):
+            r1 = eq[0].match(diff(x(t),t) - x(t)/t + f/t)
+            r2 = eq[1].match(diff(y(t),t) - y(t)/t + g/t)
+        if not (r1 and r2):
+            r1 = (-eq[0]).match(t*diff(x(t),t) - x(t) + f)
+            r2 = (-eq[1]).match(t*diff(y(t),t) - y(t) + g)
+        if not (r1 and r2):
+            r1 = (-eq[0]).match(diff(x(t),t) - x(t)/t + f/t)
+            r2 = (-eq[1]).match(diff(y(t),t) - y(t)/t + g/t)
+        if r1 and r2 and not (r1[f].subs(diff(x(t),t),u).subs(diff(y(t),t),v).has(t) \
+        or r2[g].subs(diff(x(t),t),u).subs(diff(y(t),t),v).has(t)):
+            return 'type5'
+        else:
+            return None
+    for func_ in func:
+        if isinstance(func_, list):
+            x = func[0][0].func
+            y = func[0][1].func
+            eq_type = check_type(x, y)
+            if not eq_type:
+                eq_type = check_type(y, x)
+            return eq_type
+    x = func[0].func
+    y = func[1].func
+    fc = func_coef
+    n = Wild('n', exclude=[x(t),y(t)])
+    f1 = Wild('f1', exclude=[v,t])
+    f2 = Wild('f2', exclude=[v,t])
+    g1 = Wild('g1', exclude=[u,t])
+    g2 = Wild('g2', exclude=[u,t])
+    for i in range(2):
+        eqs = 0
+        for terms in Add.make_args(eq[i]):
+            eqs += terms/fc[i,func[i],1]
+        eq[i] = eqs
+    r = eq[0].match(diff(x(t),t) - x(t)**n*f)
+    if r:
+        g = (diff(y(t),t) - eq[1])/r[f]
+    if r and not (g.has(x(t)) or g.subs(y(t),v).has(t) or r[f].subs(x(t),u).subs(y(t),v).has(t)):
+        return 'type1'
+    r = eq[0].match(diff(x(t),t) - exp(n*x(t))*f)
+    if r:
+        g = (diff(y(t),t) - eq[1])/r[f]
+    if r and not (g.has(x(t)) or g.subs(y(t),v).has(t) or r[f].subs(x(t),u).subs(y(t),v).has(t)):
+        return 'type2'
+    g = Wild('g')
+    r1 = eq[0].match(diff(x(t),t) - f)
+    r2 = eq[1].match(diff(y(t),t) - g)
+    if r1 and r2 and not (r1[f].subs(x(t),u).subs(y(t),v).has(t) or \
+    r2[g].subs(x(t),u).subs(y(t),v).has(t)):
+        return 'type3'
+    r1 = eq[0].match(diff(x(t),t) - f)
+    r2 = eq[1].match(diff(y(t),t) - g)
+    num, den = (
+        (r1[f].subs(x(t),u).subs(y(t),v))/
+        (r2[g].subs(x(t),u).subs(y(t),v))).as_numer_denom()
+    R1 = num.match(f1*g1)
+    R2 = den.match(f2*g2)
+    # phi = (r1[f].subs(x(t),u).subs(y(t),v))/num
+    if R1 and R2:
+        return 'type4'
+    return None
+
+
+def check_nonlinear_2eq_order2(eq, func, func_coef):
+    return None
+
+def check_nonlinear_3eq_order1(eq, func, func_coef):
+    x = func[0].func
+    y = func[1].func
+    z = func[2].func
+    fc = func_coef
+    t = list(list(eq[0].atoms(Derivative))[0].atoms(Symbol))[0]
+    u, v, w = symbols('u, v, w', cls=Dummy)
+    a = Wild('a', exclude=[x(t), y(t), z(t), t])
+    b = Wild('b', exclude=[x(t), y(t), z(t), t])
+    c = Wild('c', exclude=[x(t), y(t), z(t), t])
+    f = Wild('f')
+    F1 = Wild('F1')
+    F2 = Wild('F2')
+    F3 = Wild('F3')
+    for i in range(3):
+        eqs = 0
+        for terms in Add.make_args(eq[i]):
+            eqs += terms/fc[i,func[i],1]
+        eq[i] = eqs
+    r1 = eq[0].match(diff(x(t),t) - a*y(t)*z(t))
+    r2 = eq[1].match(diff(y(t),t) - b*z(t)*x(t))
+    r3 = eq[2].match(diff(z(t),t) - c*x(t)*y(t))
+    if r1 and r2 and r3:
+        num1, den1 = r1[a].as_numer_denom()
+        num2, den2 = r2[b].as_numer_denom()
+        num3, den3 = r3[c].as_numer_denom()
+        if solve([num1*u-den1*(v-w), num2*v-den2*(w-u), num3*w-den3*(u-v)],[u, v]):
+            return 'type1'
+    r = eq[0].match(diff(x(t),t) - y(t)*z(t)*f)
+    if r:
+        r1 = collect_const(r[f]).match(a*f)
+        r2 = ((diff(y(t),t) - eq[1])/r1[f]).match(b*z(t)*x(t))
+        r3 = ((diff(z(t),t) - eq[2])/r1[f]).match(c*x(t)*y(t))
+    if r1 and r2 and r3:
+        num1, den1 = r1[a].as_numer_denom()
+        num2, den2 = r2[b].as_numer_denom()
+        num3, den3 = r3[c].as_numer_denom()
+        if solve([num1*u-den1*(v-w), num2*v-den2*(w-u), num3*w-den3*(u-v)],[u, v]):
+            return 'type2'
+    r = eq[0].match(diff(x(t),t) - (F2-F3))
+    if r:
+        r1 = collect_const(r[F2]).match(c*F2)
+        r1.update(collect_const(r[F3]).match(b*F3))
+        if r1:
+            if eq[1].has(r1[F2]) and not eq[1].has(r1[F3]):
+                r1[F2], r1[F3] = r1[F3], r1[F2]
+                r1[c], r1[b] = -r1[b], -r1[c]
+            r2 = eq[1].match(diff(y(t),t) - a*r1[F3] + r1[c]*F1)
+        if r2:
+            r3 = (eq[2] == diff(z(t),t) - r1[b]*r2[F1] + r2[a]*r1[F2])
+        if r1 and r2 and r3:
+            return 'type3'
+    r = eq[0].match(diff(x(t),t) - z(t)*F2 + y(t)*F3)
+    if r:
+        r1 = collect_const(r[F2]).match(c*F2)
+        r1.update(collect_const(r[F3]).match(b*F3))
+        if r1:
+            if eq[1].has(r1[F2]) and not eq[1].has(r1[F3]):
+                r1[F2], r1[F3] = r1[F3], r1[F2]
+                r1[c], r1[b] = -r1[b], -r1[c]
+            r2 = (diff(y(t),t) - eq[1]).match(a*x(t)*r1[F3] - r1[c]*z(t)*F1)
+        if r2:
+            r3 = (diff(z(t),t) - eq[2] == r1[b]*y(t)*r2[F1] - r2[a]*x(t)*r1[F2])
+        if r1 and r2 and r3:
+            return 'type4'
+    r = (diff(x(t),t) - eq[0]).match(x(t)*(F2 - F3))
+    if r:
+        r1 = collect_const(r[F2]).match(c*F2)
+        r1.update(collect_const(r[F3]).match(b*F3))
+        if r1:
+            if eq[1].has(r1[F2]) and not eq[1].has(r1[F3]):
+                r1[F2], r1[F3] = r1[F3], r1[F2]
+                r1[c], r1[b] = -r1[b], -r1[c]
+            r2 = (diff(y(t),t) - eq[1]).match(y(t)*(a*r1[F3] - r1[c]*F1))
+        if r2:
+            r3 = (diff(z(t),t) - eq[2] == z(t)*(r1[b]*r2[F1] - r2[a]*r1[F2]))
+        if r1 and r2 and r3:
+            return 'type5'
+    return None
+
+
+def check_nonlinear_3eq_order2(eq, func, func_coef):
+    return None
+
+
+@vectorize(0)
+def odesimp(ode, eq, func, hint):
+    r"""
+    Simplifies solutions of ODEs, including trying to solve for ``func`` and
+    running :py:meth:`~sympy.solvers.ode.constantsimp`.
+
+    It may use knowledge of the type of solution that the hint returns to
+    apply additional simplifications.
+
+    It also attempts to integrate any :py:class:`~sympy.integrals.integrals.Integral`\s
+    in the expression, if the hint is not an ``_Integral`` hint.
+
+    This function should have no effect on expressions returned by
+    :py:meth:`~sympy.solvers.ode.dsolve`, as
+    :py:meth:`~sympy.solvers.ode.dsolve` already calls
+    :py:meth:`~sympy.solvers.ode.ode.odesimp`, but the individual hint functions
+    do not call :py:meth:`~sympy.solvers.ode.ode.odesimp` (because the
+    :py:meth:`~sympy.solvers.ode.dsolve` wrapper does).  Therefore, this
+    function is designed for mainly internal use.
+
+    Examples
+    ========
+
+    >>> from sympy import sin, symbols, dsolve, pprint, Function
+    >>> from sympy.solvers.ode.ode import odesimp
+    >>> x, u2, C1= symbols('x,u2,C1')
+    >>> f = Function('f')
+
+    >>> eq = dsolve(x*f(x).diff(x) - f(x) - x*sin(f(x)/x), f(x),
+    ... hint='1st_homogeneous_coeff_subs_indep_div_dep_Integral',
+    ... simplify=False)
+    >>> pprint(eq, wrap_line=False)
+                            x
+                           ----
+                           f(x)
+                             /
+                            |
+                            |   /        1   \
+                            |  -|u1 + -------|
+                            |   |        /1 \|
+                            |   |     sin|--||
+                            |   \        \u1//
+    log(f(x)) = log(C1) +   |  ---------------- d(u1)
+                            |          2
+                            |        u1
+                            |
+                           /
+
+    >>> pprint(odesimp(eq, f(x), 1, {C1},
+    ... hint='1st_homogeneous_coeff_subs_indep_div_dep'
+    ... )) #doctest: +SKIP
+        x
+    --------- = C1
+       /f(x)\
+    tan|----|
+       \2*x /
+
+    """
+    x = func.args[0]
+    f = func.func
+    C1 = get_numbered_constants(eq, num=1)
+    constants = eq.free_symbols - ode.free_symbols
+
+    # First, integrate if the hint allows it.
+    eq = _handle_Integral(eq, func, hint)
+    if hint.startswith("nth_linear_euler_eq_nonhomogeneous"):
+        eq = simplify(eq)
+    if not isinstance(eq, Equality):
+        raise TypeError("eq should be an instance of Equality")
+
+    # allow simplifications under assumption that symbols are nonzero
+    eq = eq.xreplace((_:={i: Dummy(nonzero=True) for i in constants})).xreplace({_[i]: i for i in _})
+
+    # Second, clean up the arbitrary constants.
+    # Right now, nth linear hints can put as many as 2*order constants in an
+    # expression.  If that number grows with another hint, the third argument
+    # here should be raised accordingly, or constantsimp() rewritten to handle
+    # an arbitrary number of constants.
+    eq = constantsimp(eq, constants)
+
+    # Lastly, now that we have cleaned up the expression, try solving for func.
+    # When CRootOf is implemented in solve(), we will want to return a CRootOf
+    # every time instead of an Equality.
+
+    # Get the f(x) on the left if possible.
+    if eq.rhs == func and not eq.lhs.has(func):
+        eq = [Eq(eq.rhs, eq.lhs)]
+
+    # make sure we are working with lists of solutions in simplified form.
+    if eq.lhs == func and not eq.rhs.has(func):
+        # The solution is already solved
+        eq = [eq]
+
+    else:
+        # The solution is not solved, so try to solve it
+        try:
+            floats = any(i.is_Float for i in eq.atoms(Number))
+            eqsol = solve(eq, func, force=True, rational=False if floats else None)
+            if not eqsol:
+                raise NotImplementedError
+        except (NotImplementedError, PolynomialError):
+            eq = [eq]
+        else:
+            def _expand(expr):
+                numer, denom = expr.as_numer_denom()
+
+                if denom.is_Add:
+                    return expr
+                else:
+                    return powsimp(expr.expand(), combine='exp', deep=True)
+
+            # XXX: the rest of odesimp() expects each ``t`` to be in a
+            # specific normal form: rational expression with numerator
+            # expanded, but with combined exponential functions (at
+            # least in this setup all tests pass).
+            eq = [Eq(f(x), _expand(t)) for t in eqsol]
+
+        # special simplification of the lhs.
+        if hint.startswith("1st_homogeneous_coeff"):
+            for j, eqi in enumerate(eq):
+                newi = logcombine(eqi, force=True)
+                if isinstance(newi.lhs, log) and newi.rhs == 0:
+                    newi = Eq(newi.lhs.args[0]/C1, C1)
+                eq[j] = newi
+
+    # We cleaned up the constants before solving to help the solve engine with
+    # a simpler expression, but the solved expression could have introduced
+    # things like -C1, so rerun constantsimp() one last time before returning.
+    for i, eqi in enumerate(eq):
+        eq[i] = constantsimp(eqi, constants)
+        eq[i] = constant_renumber(eq[i], ode.free_symbols)
+
+    # If there is only 1 solution, return it;
+    # otherwise return the list of solutions.
+    if len(eq) == 1:
+        eq = eq[0]
+    return eq
+
+
+def ode_sol_simplicity(sol, func, trysolving=True):
+    r"""
+    Returns an extended integer representing how simple a solution to an ODE
+    is.
+
+    The following things are considered, in order from most simple to least:
+
+    - ``sol`` is solved for ``func``.
+    - ``sol`` is not solved for ``func``, but can be if passed to solve (e.g.,
+      a solution returned by ``dsolve(ode, func, simplify=False``).
+    - If ``sol`` is not solved for ``func``, then base the result on the
+      length of ``sol``, as computed by ``len(str(sol))``.
+    - If ``sol`` has any unevaluated :py:class:`~sympy.integrals.integrals.Integral`\s,
+      this will automatically be considered less simple than any of the above.
+
+    This function returns an integer such that if solution A is simpler than
+    solution B by above metric, then ``ode_sol_simplicity(sola, func) <
+    ode_sol_simplicity(solb, func)``.
+
+    Currently, the following are the numbers returned, but if the heuristic is
+    ever improved, this may change.  Only the ordering is guaranteed.
+
+    +----------------------------------------------+-------------------+
+    | Simplicity                                   | Return            |
+    +==============================================+===================+
+    | ``sol`` solved for ``func``                  | ``-2``            |
+    +----------------------------------------------+-------------------+
+    | ``sol`` not solved for ``func`` but can be   | ``-1``            |
+    +----------------------------------------------+-------------------+
+    | ``sol`` is not solved nor solvable for       | ``len(str(sol))`` |
+    | ``func``                                     |                   |
+    +----------------------------------------------+-------------------+
+    | ``sol`` contains an                          | ``oo``            |
+    | :obj:`~sympy.integrals.integrals.Integral`   |                   |
+    +----------------------------------------------+-------------------+
+
+    ``oo`` here means the SymPy infinity, which should compare greater than
+    any integer.
+
+    If you already know :py:meth:`~sympy.solvers.solvers.solve` cannot solve
+    ``sol``, you can use ``trysolving=False`` to skip that step, which is the
+    only potentially slow step.  For example,
+    :py:meth:`~sympy.solvers.ode.dsolve` with the ``simplify=False`` flag
+    should do this.
+
+    If ``sol`` is a list of solutions, if the worst solution in the list
+    returns ``oo`` it returns that, otherwise it returns ``len(str(sol))``,
+    that is, the length of the string representation of the whole list.
+
+    Examples
+    ========
+
+    This function is designed to be passed to ``min`` as the key argument,
+    such as ``min(listofsolutions, key=lambda i: ode_sol_simplicity(i,
+    f(x)))``.
+
+    >>> from sympy import symbols, Function, Eq, tan, Integral
+    >>> from sympy.solvers.ode.ode import ode_sol_simplicity
+    >>> x, C1, C2 = symbols('x, C1, C2')
+    >>> f = Function('f')
+
+    >>> ode_sol_simplicity(Eq(f(x), C1*x**2), f(x))
+    -2
+    >>> ode_sol_simplicity(Eq(x**2 + f(x), C1), f(x))
+    -1
+    >>> ode_sol_simplicity(Eq(f(x), C1*Integral(2*x, x)), f(x))
+    oo
+    >>> eq1 = Eq(f(x)/tan(f(x)/(2*x)), C1)
+    >>> eq2 = Eq(f(x)/tan(f(x)/(2*x) + f(x)), C2)
+    >>> [ode_sol_simplicity(eq, f(x)) for eq in [eq1, eq2]]
+    [28, 35]
+    >>> min([eq1, eq2], key=lambda i: ode_sol_simplicity(i, f(x)))
+    Eq(f(x)/tan(f(x)/(2*x)), C1)
+
+    """
+    # TODO: if two solutions are solved for f(x), we still want to be
+    # able to get the simpler of the two
+
+    # See the docstring for the coercion rules.  We check easier (faster)
+    # things here first, to save time.
+
+    if iterable(sol):
+        # See if there are Integrals
+        for i in sol:
+            if ode_sol_simplicity(i, func, trysolving=trysolving) == oo:
+                return oo
+
+        return len(str(sol))
+
+    if sol.has(Integral):
+        return oo
+
+    # Next, try to solve for func.  This code will change slightly when CRootOf
+    # is implemented in solve().  Probably a CRootOf solution should fall
+    # somewhere between a normal solution and an unsolvable expression.
+
+    # First, see if they are already solved
+    if sol.lhs == func and not sol.rhs.has(func) or \
+            sol.rhs == func and not sol.lhs.has(func):
+        return -2
+    # We are not so lucky, try solving manually
+    if trysolving:
+        try:
+            sols = solve(sol, func)
+            if not sols:
+                raise NotImplementedError
+        except NotImplementedError:
+            pass
+        else:
+            return -1
+
+    # Finally, a naive computation based on the length of the string version
+    # of the expression.  This may favor combined fractions because they
+    # will not have duplicate denominators, and may slightly favor expressions
+    # with fewer additions and subtractions, as those are separated by spaces
+    # by the printer.
+
+    # Additional ideas for simplicity heuristics are welcome, like maybe
+    # checking if a equation has a larger domain, or if constantsimp has
+    # introduced arbitrary constants numbered higher than the order of a
+    # given ODE that sol is a solution of.
+    return len(str(sol))
+
+
+def _extract_funcs(eqs):
+    funcs = []
+    for eq in eqs:
+        derivs = [node for node in preorder_traversal(eq) if isinstance(node, Derivative)]
+        func = []
+        for d in derivs:
+            func += list(d.atoms(AppliedUndef))
+        for func_ in func:
+            funcs.append(func_)
+    funcs = list(uniq(funcs))
+
+    return funcs
+
+
+def _get_constant_subexpressions(expr, Cs):
+    Cs = set(Cs)
+    Ces = []
+    def _recursive_walk(expr):
+        expr_syms = expr.free_symbols
+        if expr_syms and expr_syms.issubset(Cs):
+            Ces.append(expr)
+        else:
+            if expr.func == exp:
+                expr = expr.expand(mul=True)
+            if expr.func in (Add, Mul):
+                d = sift(expr.args, lambda i : i.free_symbols.issubset(Cs))
+                if len(d[True]) > 1:
+                    x = expr.func(*d[True])
+                    if not x.is_number:
+                        Ces.append(x)
+            elif isinstance(expr, Integral):
+                if expr.free_symbols.issubset(Cs) and \
+                            all(len(x) == 3 for x in expr.limits):
+                    Ces.append(expr)
+            for i in expr.args:
+                _recursive_walk(i)
+        return
+    _recursive_walk(expr)
+    return Ces
+
+def __remove_linear_redundancies(expr, Cs):
+    cnts = {i: expr.count(i) for i in Cs}
+    Cs = [i for i in Cs if cnts[i] > 0]
+
+    def _linear(expr):
+        if isinstance(expr, Add):
+            xs = [i for i in Cs if expr.count(i)==cnts[i] \
+                and 0 == expr.diff(i, 2)]
+            d = {}
+            for x in xs:
+                y = expr.diff(x)
+                if y not in d:
+                    d[y]=[]
+                d[y].append(x)
+            for y in d:
+                if len(d[y]) > 1:
+                    d[y].sort(key=str)
+                    for x in d[y][1:]:
+                        expr = expr.subs(x, 0)
+        return expr
+
+    def _recursive_walk(expr):
+        if len(expr.args) != 0:
+            expr = expr.func(*[_recursive_walk(i) for i in expr.args])
+        expr = _linear(expr)
+        return expr
+
+    if isinstance(expr, Equality):
+        lhs, rhs = [_recursive_walk(i) for i in expr.args]
+        f = lambda i: isinstance(i, Number) or i in Cs
+        if isinstance(lhs, Symbol) and lhs in Cs:
+            rhs, lhs = lhs, rhs
+        if lhs.func in (Add, Symbol) and rhs.func in (Add, Symbol):
+            dlhs = sift([lhs] if isinstance(lhs, AtomicExpr) else lhs.args, f)
+            drhs = sift([rhs] if isinstance(rhs, AtomicExpr) else rhs.args, f)
+            for i in [True, False]:
+                for hs in [dlhs, drhs]:
+                    if i not in hs:
+                        hs[i] = [0]
+            # this calculation can be simplified
+            lhs = Add(*dlhs[False]) - Add(*drhs[False])
+            rhs = Add(*drhs[True]) - Add(*dlhs[True])
+        elif lhs.func in (Mul, Symbol) and rhs.func in (Mul, Symbol):
+            dlhs = sift([lhs] if isinstance(lhs, AtomicExpr) else lhs.args, f)
+            if True in dlhs:
+                if False not in dlhs:
+                    dlhs[False] = [1]
+                lhs = Mul(*dlhs[False])
+                rhs = rhs/Mul(*dlhs[True])
+        return Eq(lhs, rhs)
+    else:
+        return _recursive_walk(expr)
+
+@vectorize(0)
+def constantsimp(expr, constants):
+    r"""
+    Simplifies an expression with arbitrary constants in it.
+
+    This function is written specifically to work with
+    :py:meth:`~sympy.solvers.ode.dsolve`, and is not intended for general use.
+
+    Simplification is done by "absorbing" the arbitrary constants into other
+    arbitrary constants, numbers, and symbols that they are not independent
+    of.
+
+    The symbols must all have the same name with numbers after it, for
+    example, ``C1``, ``C2``, ``C3``.  The ``symbolname`` here would be
+    '``C``', the ``startnumber`` would be 1, and the ``endnumber`` would be 3.
+    If the arbitrary constants are independent of the variable ``x``, then the
+    independent symbol would be ``x``.  There is no need to specify the
+    dependent function, such as ``f(x)``, because it already has the
+    independent symbol, ``x``, in it.
+
+    Because terms are "absorbed" into arbitrary constants and because
+    constants are renumbered after simplifying, the arbitrary constants in
+    expr are not necessarily equal to the ones of the same name in the
+    returned result.
+
+    If two or more arbitrary constants are added, multiplied, or raised to the
+    power of each other, they are first absorbed together into a single
+    arbitrary constant.  Then the new constant is combined into other terms if
+    necessary.
+
+    Absorption of constants is done with limited assistance:
+
+    1. terms of :py:class:`~sympy.core.add.Add`\s are collected to try join
+       constants so `e^x (C_1 \cos(x) + C_2 \cos(x))` will simplify to `e^x
+       C_1 \cos(x)`;
+
+    2. powers with exponents that are :py:class:`~sympy.core.add.Add`\s are
+       expanded so `e^{C_1 + x}` will be simplified to `C_1 e^x`.
+
+    Use :py:meth:`~sympy.solvers.ode.ode.constant_renumber` to renumber constants
+    after simplification or else arbitrary numbers on constants may appear,
+    e.g. `C_1 + C_3 x`.
+
+    In rare cases, a single constant can be "simplified" into two constants.
+    Every differential equation solution should have as many arbitrary
+    constants as the order of the differential equation.  The result here will
+    be technically correct, but it may, for example, have `C_1` and `C_2` in
+    an expression, when `C_1` is actually equal to `C_2`.  Use your discretion
+    in such situations, and also take advantage of the ability to use hints in
+    :py:meth:`~sympy.solvers.ode.dsolve`.
+
+    Examples
+    ========
+
+    >>> from sympy import symbols
+    >>> from sympy.solvers.ode.ode import constantsimp
+    >>> C1, C2, C3, x, y = symbols('C1, C2, C3, x, y')
+    >>> constantsimp(2*C1*x, {C1, C2, C3})
+    C1*x
+    >>> constantsimp(C1 + 2 + x, {C1, C2, C3})
+    C1 + x
+    >>> constantsimp(C1*C2 + 2 + C2 + C3*x, {C1, C2, C3})
+    C1 + C3*x
+
+    """
+    # This function works recursively.  The idea is that, for Mul,
+    # Add, Pow, and Function, if the class has a constant in it, then
+    # we can simplify it, which we do by recursing down and
+    # simplifying up.  Otherwise, we can skip that part of the
+    # expression.
+
+    Cs = constants
+
+    orig_expr = expr
+
+    constant_subexprs = _get_constant_subexpressions(expr, Cs)
+    for xe in constant_subexprs:
+        xes = list(xe.free_symbols)
+        if not xes:
+            continue
+        if all(expr.count(c) == xe.count(c) for c in xes):
+            xes.sort(key=str)
+            expr = expr.subs(xe, xes[0])
+
+    # try to perform common sub-expression elimination of constant terms
+    try:
+        commons, rexpr = cse(expr)
+        commons.reverse()
+        rexpr = rexpr[0]
+        for s in commons:
+            cs = list(s[1].atoms(Symbol))
+            if len(cs) == 1 and cs[0] in Cs and \
+                cs[0] not in rexpr.atoms(Symbol) and \
+                not any(cs[0] in ex for ex in commons if ex != s):
+                rexpr = rexpr.subs(s[0], cs[0])
+            else:
+                rexpr = rexpr.subs(*s)
+        expr = rexpr
+    except IndexError:
+        pass
+    expr = __remove_linear_redundancies(expr, Cs)
+
+    def _conditional_term_factoring(expr):
+        new_expr = terms_gcd(expr, clear=False, deep=True, expand=False)
+
+        # we do not want to factor exponentials, so handle this separately
+        if new_expr.is_Mul:
+            infac = False
+            asfac = False
+            for m in new_expr.args:
+                if isinstance(m, exp):
+                    asfac = True
+                elif m.is_Add:
+                    infac = any(isinstance(fi, exp) for t in m.args
+                        for fi in Mul.make_args(t))
+                if asfac and infac:
+                    new_expr = expr
+                    break
+        return new_expr
+
+    expr = _conditional_term_factoring(expr)
+
+    # call recursively if more simplification is possible
+    if orig_expr != expr:
+        return constantsimp(expr, Cs)
+    return expr
+
+
+def constant_renumber(expr, variables=None, newconstants=None):
+    r"""
+    Renumber arbitrary constants in ``expr`` to use the symbol names as given
+    in ``newconstants``. In the process, this reorders expression terms in a
+    standard way.
+
+    If ``newconstants`` is not provided then the new constant names will be
+    ``C1``, ``C2`` etc. Otherwise ``newconstants`` should be an iterable
+    giving the new symbols to use for the constants in order.
+
+    The ``variables`` argument is a list of non-constant symbols. All other
+    free symbols found in ``expr`` are assumed to be constants and will be
+    renumbered. If ``variables`` is not given then any numbered symbol
+    beginning with ``C`` (e.g. ``C1``) is assumed to be a constant.
+
+    Symbols are renumbered based on ``.sort_key()``, so they should be
+    numbered roughly in the order that they appear in the final, printed
+    expression.  Note that this ordering is based in part on hashes, so it can
+    produce different results on different machines.
+
+    The structure of this function is very similar to that of
+    :py:meth:`~sympy.solvers.ode.constantsimp`.
+
+    Examples
+    ========
+
+    >>> from sympy import symbols
+    >>> from sympy.solvers.ode.ode import constant_renumber
+    >>> x, C1, C2, C3 = symbols('x,C1:4')
+    >>> expr = C3 + C2*x + C1*x**2
+    >>> expr
+    C1*x**2  + C2*x + C3
+    >>> constant_renumber(expr)
+    C1 + C2*x + C3*x**2
+
+    The ``variables`` argument specifies which are constants so that the
+    other symbols will not be renumbered:
+
+    >>> constant_renumber(expr, [C1, x])
+    C1*x**2  + C2 + C3*x
+
+    The ``newconstants`` argument is used to specify what symbols to use when
+    replacing the constants:
+
+    >>> constant_renumber(expr, [x], newconstants=symbols('E1:4'))
+    E1 + E2*x + E3*x**2
+
+    """
+
+    # System of expressions
+    if isinstance(expr, (set, list, tuple)):
+        return type(expr)(constant_renumber(Tuple(*expr),
+                        variables=variables, newconstants=newconstants))
+
+    # Symbols in solution but not ODE are constants
+    if variables is not None:
+        variables = set(variables)
+        free_symbols = expr.free_symbols
+        constantsymbols = list(free_symbols - variables)
+    # Any Cn is a constant...
+    else:
+        variables = set()
+        isconstant = lambda s: s.startswith('C') and s[1:].isdigit()
+        constantsymbols = [sym for sym in expr.free_symbols if isconstant(sym.name)]
+
+    # Find new constants checking that they aren't already in the ODE
+    if newconstants is None:
+        iter_constants = numbered_symbols(start=1, prefix='C', exclude=variables)
+    else:
+        iter_constants = (sym for sym in newconstants if sym not in variables)
+
+    constants_found = []
+
+    # make a mapping to send all constantsymbols to S.One and use
+    # that to make sure that term ordering is not dependent on
+    # the indexed value of C
+    C_1 = [(ci, S.One) for ci in constantsymbols]
+    sort_key=lambda arg: default_sort_key(arg.subs(C_1))
+
+    def _constant_renumber(expr):
+        r"""
+        We need to have an internal recursive function
+        """
+
+        # For system of expressions
+        if isinstance(expr, Tuple):
+            renumbered = [_constant_renumber(e) for e in expr]
+            return Tuple(*renumbered)
+
+        if isinstance(expr, Equality):
+            return Eq(
+                _constant_renumber(expr.lhs),
+                _constant_renumber(expr.rhs))
+
+        if type(expr) not in (Mul, Add, Pow) and not expr.is_Function and \
+                not expr.has(*constantsymbols):
+            # Base case, as above.  Hope there aren't constants inside
+            # of some other class, because they won't be renumbered.
+            return expr
+        elif expr.is_Piecewise:
+            return expr
+        elif expr in constantsymbols:
+            if expr not in constants_found:
+                constants_found.append(expr)
+            return expr
+        elif expr.is_Function or expr.is_Pow:
+            return expr.func(
+                *[_constant_renumber(x) for x in expr.args])
+        else:
+            sortedargs = list(expr.args)
+            sortedargs.sort(key=sort_key)
+            return expr.func(*[_constant_renumber(x) for x in sortedargs])
+    expr = _constant_renumber(expr)
+
+    # Don't renumber symbols present in the ODE.
+    constants_found = [c for c in constants_found if c not in variables]
+
+    # Renumbering happens here
+    subs_dict = dict(zip(constants_found, iter_constants))
+    expr = expr.subs(subs_dict, simultaneous=True)
+
+    return expr
+
+
+def _handle_Integral(expr, func, hint):
+    r"""
+    Converts a solution with Integrals in it into an actual solution.
+
+    For most hints, this simply runs ``expr.doit()``.
+
+    """
+    if hint == "nth_linear_constant_coeff_homogeneous":
+        sol = expr
+    elif not hint.endswith("_Integral"):
+        sol = expr.doit()
+    else:
+        sol = expr
+    return sol
+
+
+# XXX: Should this function maybe go somewhere else?
+
+
+def homogeneous_order(eq, *symbols):
+    r"""
+    Returns the order `n` if `g` is homogeneous and ``None`` if it is not
+    homogeneous.
+
+    Determines if a function is homogeneous and if so of what order.  A
+    function `f(x, y, \cdots)` is homogeneous of order `n` if `f(t x, t y,
+    \cdots) = t^n f(x, y, \cdots)`.
+
+    If the function is of two variables, `F(x, y)`, then `f` being homogeneous
+    of any order is equivalent to being able to rewrite `F(x, y)` as `G(x/y)`
+    or `H(y/x)`.  This fact is used to solve 1st order ordinary differential
+    equations whose coefficients are homogeneous of the same order (see the
+    docstrings of
+    :obj:`~sympy.solvers.ode.single.HomogeneousCoeffSubsDepDivIndep` and
+    :obj:`~sympy.solvers.ode.single.HomogeneousCoeffSubsIndepDivDep`).
+
+    Symbols can be functions, but every argument of the function must be a
+    symbol, and the arguments of the function that appear in the expression
+    must match those given in the list of symbols.  If a declared function
+    appears with different arguments than given in the list of symbols,
+    ``None`` is returned.
+
+    Examples
+    ========
+
+    >>> from sympy import Function, homogeneous_order, sqrt
+    >>> from sympy.abc import x, y
+    >>> f = Function('f')
+    >>> homogeneous_order(f(x), f(x)) is None
+    True
+    >>> homogeneous_order(f(x,y), f(y, x), x, y) is None
+    True
+    >>> homogeneous_order(f(x), f(x), x)
+    1
+    >>> homogeneous_order(x**2*f(x)/sqrt(x**2+f(x)**2), x, f(x))
+    2
+    >>> homogeneous_order(x**2+f(x), x, f(x)) is None
+    True
+
+    """
+
+    if not symbols:
+        raise ValueError("homogeneous_order: no symbols were given.")
+    symset = set(symbols)
+    eq = sympify(eq)
+
+    # The following are not supported
+    if eq.has(Order, Derivative):
+        return None
+
+    # These are all constants
+    if (eq.is_Number or
+        eq.is_NumberSymbol or
+        eq.is_number
+            ):
+        return S.Zero
+
+    # Replace all functions with dummy variables
+    dum = numbered_symbols(prefix='d', cls=Dummy)
+    newsyms = set()
+    for i in [j for j in symset if getattr(j, 'is_Function')]:
+        iargs = set(i.args)
+        if iargs.difference(symset):
+            return None
+        else:
+            dummyvar = next(dum)
+            eq = eq.subs(i, dummyvar)
+            symset.remove(i)
+            newsyms.add(dummyvar)
+    symset.update(newsyms)
+
+    if not eq.free_symbols & symset:
+        return None
+
+    # assuming order of a nested function can only be equal to zero
+    if isinstance(eq, Function):
+        return None if homogeneous_order(
+            eq.args[0], *tuple(symset)) != 0 else S.Zero
+
+    # make the replacement of x with x*t and see if t can be factored out
+    t = Dummy('t', positive=True)  # It is sufficient that t > 0
+    eqs = separatevars(eq.subs([(i, t*i) for i in symset]), [t], dict=True)[t]
+    if eqs is S.One:
+        return S.Zero  # there was no term with only t
+    i, d = eqs.as_independent(t, as_Add=False)
+    b, e = d.as_base_exp()
+    if b == t:
+        return e
+
+
+def ode_2nd_power_series_ordinary(eq, func, order, match):
+    r"""
+    Gives a power series solution to a second order homogeneous differential
+    equation with polynomial coefficients at an ordinary point. A homogeneous
+    differential equation is of the form
+
+    .. math :: P(x)\frac{d^2y}{dx^2} + Q(x)\frac{dy}{dx} + R(x) y(x) = 0
+
+    For simplicity it is assumed that `P(x)`, `Q(x)` and `R(x)` are polynomials,
+    it is sufficient that `\frac{Q(x)}{P(x)}` and `\frac{R(x)}{P(x)}` exists at
+    `x_{0}`. A recurrence relation is obtained by substituting `y` as `\sum_{n=0}^\infty a_{n}x^{n}`,
+    in the differential equation, and equating the nth term. Using this relation
+    various terms can be generated.
+
+
+    Examples
+    ========
+
+    >>> from sympy import dsolve, Function, pprint
+    >>> from sympy.abc import x
+    >>> f = Function("f")
+    >>> eq = f(x).diff(x, 2) + f(x)
+    >>> pprint(dsolve(eq, hint='2nd_power_series_ordinary'))
+              / 4    2    \        /     2\
+              |x    x     |        |    x |    / 6\
+    f(x) = C2*|-- - -- + 1| + C1*x*|1 - --| + O\x /
+              \24   2     /        \    6 /
+
+
+    References
+    ==========
+    - https://tutorial.math.lamar.edu/Classes/DE/SeriesSolutions.aspx
+    - George E. Simmons, "Differential Equations with Applications and
+      Historical Notes", p.p 176 - 184
+
+    """
+    x = func.args[0]
+    f = func.func
+    C0, C1 = get_numbered_constants(eq, num=2)
+    n = Dummy("n", integer=True)
+    s = Wild("s")
+    k = Wild("k", exclude=[x])
+    x0 = match['x0']
+    terms = match['terms']
+    p = match[match['a3']]
+    q = match[match['b3']]
+    r = match[match['c3']]
+    seriesdict = {}
+    recurr = Function("r")
+
+    # Generating the recurrence relation which works this way:
+    # for the second order term the summation begins at n = 2. The coefficients
+    # p is multiplied with an*(n - 1)*(n - 2)*x**n-2 and a substitution is made such that
+    # the exponent of x becomes n.
+    # For example, if p is x, then the second degree recurrence term is
+    # an*(n - 1)*(n - 2)*x**n-1, substituting (n - 1) as n, it transforms to
+    # an+1*n*(n - 1)*x**n.
+    # A similar process is done with the first order and zeroth order term.
+
+    coefflist = [(recurr(n), r), (n*recurr(n), q), (n*(n - 1)*recurr(n), p)]
+    for index, coeff in enumerate(coefflist):
+        if coeff[1]:
+            f2 = powsimp(expand((coeff[1]*(x - x0)**(n - index)).subs(x, x + x0)))
+            if f2.is_Add:
+                addargs = f2.args
+            else:
+                addargs = [f2]
+            for arg in addargs:
+                powm = arg.match(s*x**k)
+                term = coeff[0]*powm[s]
+                if not powm[k].is_Symbol:
+                    term = term.subs(n, n - powm[k].as_independent(n)[0])
+                startind = powm[k].subs(n, index)
+                # Seeing if the startterm can be reduced further.
+                # If it vanishes for n lesser than startind, it is
+                # equal to summation from n.
+                if startind:
+                    for i in reversed(range(startind)):
+                        if not term.subs(n, i):
+                            seriesdict[term] = i
+                        else:
+                            seriesdict[term] = i + 1
+                            break
+                else:
+                    seriesdict[term] = S.Zero
+
+    # Stripping of terms so that the sum starts with the same number.
+    teq = S.Zero
+    suminit = seriesdict.values()
+    rkeys = seriesdict.keys()
+    req = Add(*rkeys)
+    if any(suminit):
+        maxval = max(suminit)
+        for term in seriesdict:
+            val = seriesdict[term]
+            if val != maxval:
+                for i in range(val, maxval):
+                    teq += term.subs(n, val)
+
+    finaldict = {}
+    if teq:
+        fargs = teq.atoms(AppliedUndef)
+        if len(fargs) == 1:
+            finaldict[fargs.pop()] = 0
+        else:
+            maxf = max(fargs, key = lambda x: x.args[0])
+            sol = solve(teq, maxf)
+            if isinstance(sol, list):
+                sol = sol[0]
+            finaldict[maxf] = sol
+
+    # Finding the recurrence relation in terms of the largest term.
+    fargs = req.atoms(AppliedUndef)
+    maxf = max(fargs, key = lambda x: x.args[0])
+    minf = min(fargs, key = lambda x: x.args[0])
+    if minf.args[0].is_Symbol:
+        startiter = 0
+    else:
+        startiter = -minf.args[0].as_independent(n)[0]
+    lhs = maxf
+    rhs =  solve(req, maxf)
+    if isinstance(rhs, list):
+        rhs = rhs[0]
+
+    # Checking how many values are already present
+    tcounter = len([t for t in finaldict.values() if t])
+
+    for _ in range(tcounter, terms - 3):  # Assuming c0 and c1 to be arbitrary
+        check = rhs.subs(n, startiter)
+        nlhs = lhs.subs(n, startiter)
+        nrhs = check.subs(finaldict)
+        finaldict[nlhs] = nrhs
+        startiter += 1
+
+    # Post processing
+    series = C0 + C1*(x - x0)
+    for term in finaldict:
+        if finaldict[term]:
+            fact = term.args[0]
+            series += (finaldict[term].subs([(recurr(0), C0), (recurr(1), C1)])*(
+                x - x0)**fact)
+    series = collect(expand_mul(series), [C0, C1]) + Order(x**terms)
+    return Eq(f(x), series)
+
+
+def ode_2nd_power_series_regular(eq, func, order, match):
+    r"""
+    Gives a power series solution to a second order homogeneous differential
+    equation with polynomial coefficients at a regular point. A second order
+    homogeneous differential equation is of the form
+
+    .. math :: P(x)\frac{d^2y}{dx^2} + Q(x)\frac{dy}{dx} + R(x) y(x) = 0
+
+    A point is said to regular singular at `x0` if `x - x0\frac{Q(x)}{P(x)}`
+    and `(x - x0)^{2}\frac{R(x)}{P(x)}` are analytic at `x0`. For simplicity
+    `P(x)`, `Q(x)` and `R(x)` are assumed to be polynomials. The algorithm for
+    finding the power series solutions is:
+
+    1.  Try expressing `(x - x0)P(x)` and `((x - x0)^{2})Q(x)` as power series
+        solutions about x0. Find `p0` and `q0` which are the constants of the
+        power series expansions.
+    2.  Solve the indicial equation `f(m) = m(m - 1) + m*p0 + q0`, to obtain the
+        roots `m1` and `m2` of the indicial equation.
+    3.  If `m1 - m2` is a non integer there exists two series solutions. If
+        `m1 = m2`, there exists only one solution. If `m1 - m2` is an integer,
+        then the existence of one solution is confirmed. The other solution may
+        or may not exist.
+
+    The power series solution is of the form `x^{m}\sum_{n=0}^\infty a_{n}x^{n}`. The
+    coefficients are determined by the following recurrence relation.
+    `a_{n} = -\frac{\sum_{k=0}^{n-1} q_{n-k} + (m + k)p_{n-k}}{f(m + n)}`. For the case
+    in which `m1 - m2` is an integer, it can be seen from the recurrence relation
+    that for the lower root `m`, when `n` equals the difference of both the
+    roots, the denominator becomes zero. So if the numerator is not equal to zero,
+    a second series solution exists.
+
+
+    Examples
+    ========
+
+    >>> from sympy import dsolve, Function, pprint
+    >>> from sympy.abc import x
+    >>> f = Function("f")
+    >>> eq = x*(f(x).diff(x, 2)) + 2*(f(x).diff(x)) + x*f(x)
+    >>> pprint(dsolve(eq, hint='2nd_power_series_regular'))
+                                  /   6     4    2    \
+                                  |  x     x    x     |
+              / 4     2    \   C1*|- --- + -- - -- + 1|
+              |x     x     |      \  720   24   2     /    / 6\
+    f(x) = C2*|--- - -- + 1| + ------------------------ + O\x /
+              \120   6     /              x
+
+
+    References
+    ==========
+    - George E. Simmons, "Differential Equations with Applications and
+      Historical Notes", p.p 176 - 184
+
+    """
+    x = func.args[0]
+    f = func.func
+    C0, C1 = get_numbered_constants(eq, num=2)
+    m = Dummy("m")  # for solving the indicial equation
+    x0 = match['x0']
+    terms = match['terms']
+    p = match['p']
+    q = match['q']
+
+    # Generating the indicial equation
+    indicial = []
+    for term in [p, q]:
+        if not term.has(x):
+            indicial.append(term)
+        else:
+            term = series(term, x=x, n=1, x0=x0)
+            if isinstance(term, Order):
+                indicial.append(S.Zero)
+            else:
+                for arg in term.args:
+                    if not arg.has(x):
+                        indicial.append(arg)
+                        break
+
+    p0, q0 = indicial
+    sollist = solve(m*(m - 1) + m*p0 + q0, m)
+    if sollist and isinstance(sollist, list) and all(
+        sol.is_real for sol in sollist):
+        serdict1 = {}
+        serdict2 = {}
+        if len(sollist) == 1:
+            # Only one series solution exists in this case.
+            m1 = m2 = sollist.pop()
+            if terms-m1-1 <= 0:
+                return Eq(f(x), Order(terms))
+            serdict1 = _frobenius(terms-m1-1, m1, p0, q0, p, q, x0, x, C0)
+
+        else:
+            m1 = sollist[0]
+            m2 = sollist[1]
+            if m1 < m2:
+                m1, m2 = m2, m1
+            # Irrespective of whether m1 - m2 is an integer or not, one
+            # Frobenius series solution exists.
+            serdict1 = _frobenius(terms-m1-1, m1, p0, q0, p, q, x0, x, C0)
+            if not (m1 - m2).is_integer:
+                # Second frobenius series solution exists.
+                serdict2 = _frobenius(terms-m2-1, m2, p0, q0, p, q, x0, x, C1)
+            else:
+                # Check if second frobenius series solution exists.
+                serdict2 = _frobenius(terms-m2-1, m2, p0, q0, p, q, x0, x, C1, check=m1)
+
+        if serdict1:
+            finalseries1 = C0
+            for key in serdict1:
+                power = int(key.name[1:])
+                finalseries1 += serdict1[key]*(x - x0)**power
+            finalseries1 = (x - x0)**m1*finalseries1
+            finalseries2 = S.Zero
+            if serdict2:
+                for key in serdict2:
+                    power = int(key.name[1:])
+                    finalseries2 += serdict2[key]*(x - x0)**power
+                finalseries2 += C1
+                finalseries2 = (x - x0)**m2*finalseries2
+            return Eq(f(x), collect(finalseries1 + finalseries2,
+                [C0, C1]) + Order(x**terms))
+
+
+def _frobenius(n, m, p0, q0, p, q, x0, x, c, check=None):
+    r"""
+    Returns a dict with keys as coefficients and values as their values in terms of C0
+    """
+    n = int(n)
+    # In cases where m1 - m2 is not an integer
+    m2 = check
+
+    d = Dummy("d")
+    numsyms = numbered_symbols("C", start=0)
+    numsyms = [next(numsyms) for i in range(n + 1)]
+    serlist = []
+    for ser in [p, q]:
+        # Order term not present
+        if ser.is_polynomial(x) and Poly(ser, x).degree() <= n:
+            if x0:
+                ser = ser.subs(x, x + x0)
+            dict_ = Poly(ser, x).as_dict()
+        # Order term present
+        else:
+            tseries = series(ser, x=x0, n=n+1)
+            # Removing order
+            dict_ = Poly(list(ordered(tseries.args))[: -1], x).as_dict()
+        # Fill in with zeros, if coefficients are zero.
+        for i in range(n + 1):
+            if (i,) not in dict_:
+                dict_[(i,)] = S.Zero
+        serlist.append(dict_)
+
+    pseries = serlist[0]
+    qseries = serlist[1]
+    indicial = d*(d - 1) + d*p0 + q0
+    frobdict = {}
+    for i in range(1, n + 1):
+        num = c*(m*pseries[(i,)] + qseries[(i,)])
+        for j in range(1, i):
+            sym = Symbol("C" + str(j))
+            num += frobdict[sym]*((m + j)*pseries[(i - j,)] + qseries[(i - j,)])
+
+        # Checking for cases when m1 - m2 is an integer. If num equals zero
+        # then a second Frobenius series solution cannot be found. If num is not zero
+        # then set constant as zero and proceed.
+        if m2 is not None and i == m2 - m:
+            if num:
+                return False
+            else:
+                frobdict[numsyms[i]] = S.Zero
+        else:
+            frobdict[numsyms[i]] = -num/(indicial.subs(d, m+i))
+
+    return frobdict
+
+def _remove_redundant_solutions(eq, solns, order, var):
+    r"""
+    Remove redundant solutions from the set of solutions.
+
+    This function is needed because otherwise dsolve can return
+    redundant solutions. As an example consider:
+
+        eq = Eq((f(x).diff(x, 2))*f(x).diff(x), 0)
+
+    There are two ways to find solutions to eq. The first is to solve f(x).diff(x, 2) = 0
+    leading to solution f(x)=C1 + C2*x. The second is to solve the equation f(x).diff(x) = 0
+    leading to the solution f(x) = C1. In this particular case we then see
+    that the second solution is a special case of the first and we do not
+    want to return it.
+
+    This does not always happen. If we have
+
+        eq = Eq((f(x)**2-4)*(f(x).diff(x)-4), 0)
+
+    then we get the algebraic solution f(x) = [-2, 2] and the integral solution
+    f(x) = x + C1 and in this case the two solutions are not equivalent wrt
+    initial conditions so both should be returned.
+    """
+    def is_special_case_of(soln1, soln2):
+        return _is_special_case_of(soln1, soln2, eq, order, var)
+
+    unique_solns = []
+    for soln1 in solns:
+        for soln2 in unique_solns.copy():
+            if is_special_case_of(soln1, soln2):
+                break
+            elif is_special_case_of(soln2, soln1):
+                unique_solns.remove(soln2)
+        else:
+            unique_solns.append(soln1)
+
+    return unique_solns
+
+def _is_special_case_of(soln1, soln2, eq, order, var):
+    r"""
+    True if soln1 is found to be a special case of soln2 wrt some value of the
+    constants that appear in soln2. False otherwise.
+    """
+    # The solutions returned by dsolve may be given explicitly or implicitly.
+    # We will equate the sol1=(soln1.rhs - soln1.lhs), sol2=(soln2.rhs - soln2.lhs)
+    # of the two solutions.
+    #
+    # Since this is supposed to hold for all x it also holds for derivatives.
+    # For an order n ode we should be able to differentiate
+    # each solution n times to get n+1 equations.
+    #
+    # We then try to solve those n+1 equations for the integrations constants
+    # in sol2. If we can find a solution that does not depend on x then it
+    # means that some value of the constants in sol1 is a special case of
+    # sol2 corresponding to a particular choice of the integration constants.
+
+    # In case the solution is in implicit form we subtract the sides
+    soln1 = soln1.rhs - soln1.lhs
+    soln2 = soln2.rhs - soln2.lhs
+
+    # Work for the series solution
+    if soln1.has(Order) and soln2.has(Order):
+        if soln1.getO() == soln2.getO():
+            soln1 = soln1.removeO()
+            soln2 = soln2.removeO()
+        else:
+            return False
+    elif soln1.has(Order) or soln2.has(Order):
+        return False
+
+    constants1 = soln1.free_symbols.difference(eq.free_symbols)
+    constants2 = soln2.free_symbols.difference(eq.free_symbols)
+
+    constants1_new = get_numbered_constants(Tuple(soln1, soln2), len(constants1))
+    if len(constants1) == 1:
+        constants1_new = {constants1_new}
+    for c_old, c_new in zip(constants1, constants1_new):
+        soln1 = soln1.subs(c_old, c_new)
+
+    # n equations for sol1 = sol2, sol1'=sol2', ...
+    lhs = soln1
+    rhs = soln2
+    eqns = [Eq(lhs, rhs)]
+    for n in range(1, order):
+        lhs = lhs.diff(var)
+        rhs = rhs.diff(var)
+        eq = Eq(lhs, rhs)
+        eqns.append(eq)
+
+    # BooleanTrue/False awkwardly show up for trivial equations
+    if any(isinstance(eq, BooleanFalse) for eq in eqns):
+        return False
+    eqns = [eq for eq in eqns if not isinstance(eq, BooleanTrue)]
+
+    try:
+        constant_solns = solve(eqns, constants2)
+    except NotImplementedError:
+        return False
+
+    # Sometimes returns a dict and sometimes a list of dicts
+    if isinstance(constant_solns, dict):
+        constant_solns = [constant_solns]
+
+    # after solving the issue 17418, maybe we don't need the following checksol code.
+    for constant_soln in constant_solns:
+        for eq in eqns:
+            eq=eq.rhs-eq.lhs
+            if checksol(eq, constant_soln) is not True:
+                return False
+
+    # If any solution gives all constants as expressions that don't depend on
+    # x then there exists constants for soln2 that give soln1
+    for constant_soln in constant_solns:
+        if not any(c.has(var) for c in constant_soln.values()):
+            return True
+
+    return False
+
+
+def ode_1st_power_series(eq, func, order, match):
+    r"""
+    The power series solution is a method which gives the Taylor series expansion
+    to the solution of a differential equation.
+
+    For a first order differential equation `\frac{dy}{dx} = h(x, y)`, a power
+    series solution exists at a point `x = x_{0}` if `h(x, y)` is analytic at `x_{0}`.
+    The solution is given by
+
+    .. math:: y(x) = y(x_{0}) + \sum_{n = 1}^{\infty} \frac{F_{n}(x_{0},b)(x - x_{0})^n}{n!},
+
+    where `y(x_{0}) = b` is the value of y at the initial value of `x_{0}`.
+    To compute the values of the `F_{n}(x_{0},b)` the following algorithm is
+    followed, until the required number of terms are generated.
+
+    1. `F_1 = h(x_{0}, b)`
+    2. `F_{n+1} = \frac{\partial F_{n}}{\partial x} + \frac{\partial F_{n}}{\partial y}F_{1}`
+
+    Examples
+    ========
+
+    >>> from sympy import Function, pprint, exp, dsolve
+    >>> from sympy.abc import x
+    >>> f = Function('f')
+    >>> eq = exp(x)*(f(x).diff(x)) - f(x)
+    >>> pprint(dsolve(eq, hint='1st_power_series'))
+                           3       4       5
+                       C1*x    C1*x    C1*x     / 6\
+    f(x) = C1 + C1*x - ----- + ----- + ----- + O\x /
+                         6       24      60
+
+
+    References
+    ==========
+
+    - Travis W. Walker, Analytic power series technique for solving first-order
+      differential equations, p.p 17, 18
+
+    """
+    x = func.args[0]
+    y = match['y']
+    f = func.func
+    h = -match[match['d']]/match[match['e']]
+    point = match['f0']
+    value = match['f0val']
+    terms = match['terms']
+
+    # First term
+    F = h
+    if not h:
+        return Eq(f(x), value)
+
+    # Initialization
+    series = value
+    if terms > 1:
+        hc = h.subs({x: point, y: value})
+        if hc.has(oo) or hc.has(nan) or hc.has(zoo):
+            # Derivative does not exist, not analytic
+            return Eq(f(x), oo)
+        elif hc:
+            series += hc*(x - point)
+
+    for factcount in range(2, terms):
+        Fnew = F.diff(x) + F.diff(y)*h
+        Fnewc = Fnew.subs({x: point, y: value})
+        # Same logic as above
+        if Fnewc.has(oo) or Fnewc.has(nan) or Fnewc.has(-oo) or Fnewc.has(zoo):
+            return Eq(f(x), oo)
+        series += Fnewc*((x - point)**factcount)/factorial(factcount)
+        F = Fnew
+    series += Order(x**terms)
+    return Eq(f(x), series)
+
+
+def checkinfsol(eq, infinitesimals, func=None, order=None):
+    r"""
+    This function is used to check if the given infinitesimals are the
+    actual infinitesimals of the given first order differential equation.
+    This method is specific to the Lie Group Solver of ODEs.
+
+    As of now, it simply checks, by substituting the infinitesimals in the
+    partial differential equation.
+
+
+    .. math:: \frac{\partial \eta}{\partial x} + \left(\frac{\partial \eta}{\partial y}
+                - \frac{\partial \xi}{\partial x}\right)*h
+                - \frac{\partial \xi}{\partial y}*h^{2}
+                - \xi\frac{\partial h}{\partial x} - \eta\frac{\partial h}{\partial y} = 0
+
+
+    where `\eta`, and `\xi` are the infinitesimals and `h(x,y) = \frac{dy}{dx}`
+
+    The infinitesimals should be given in the form of a list of dicts
+    ``[{xi(x, y): inf, eta(x, y): inf}]``, corresponding to the
+    output of the function infinitesimals. It returns a list
+    of values of the form ``[(True/False, sol)]`` where ``sol`` is the value
+    obtained after substituting the infinitesimals in the PDE. If it
+    is ``True``, then ``sol`` would be 0.
+
+    """
+    if isinstance(eq, Equality):
+        eq = eq.lhs - eq.rhs
+    if not func:
+        eq, func = _preprocess(eq)
+    variables = func.args
+    if len(variables) != 1:
+        raise ValueError("ODE's have only one independent variable")
+    else:
+        x = variables[0]
+        if not order:
+            order = ode_order(eq, func)
+        if order != 1:
+            raise NotImplementedError("Lie groups solver has been implemented "
+            "only for first order differential equations")
+        else:
+            df = func.diff(x)
+            a = Wild('a', exclude = [df])
+            b = Wild('b', exclude = [df])
+            match = collect(expand(eq), df).match(a*df + b)
+
+            if match:
+                h = -simplify(match[b]/match[a])
+            else:
+                try:
+                    sol = solve(eq, df)
+                except NotImplementedError:
+                    raise NotImplementedError("Infinitesimals for the "
+                        "first order ODE could not be found")
+                else:
+                    h = sol[0]  # Find infinitesimals for one solution
+
+            y = Dummy('y')
+            h = h.subs(func, y)
+            xi = Function('xi')(x, y)
+            eta = Function('eta')(x, y)
+            dxi = Function('xi')(x, func)
+            deta = Function('eta')(x, func)
+            pde = (eta.diff(x) + (eta.diff(y) - xi.diff(x))*h -
+                (xi.diff(y))*h**2 - xi*(h.diff(x)) - eta*(h.diff(y)))
+            soltup = []
+            for sol in infinitesimals:
+                tsol = {xi: S(sol[dxi]).subs(func, y),
+                    eta: S(sol[deta]).subs(func, y)}
+                sol = simplify(pde.subs(tsol).doit())
+                if sol:
+                    soltup.append((False, sol.subs(y, func)))
+                else:
+                    soltup.append((True, 0))
+            return soltup
+
+
+def sysode_linear_2eq_order1(match_):
+    x = match_['func'][0].func
+    y = match_['func'][1].func
+    func = match_['func']
+    fc = match_['func_coeff']
+    eq = match_['eq']
+    r = {}
+    t = list(list(eq[0].atoms(Derivative))[0].atoms(Symbol))[0]
+    for i in range(2):
+        eq[i] = Add(*[terms/fc[i,func[i],1] for terms in Add.make_args(eq[i])])
+
+    # for equations Eq(a1*diff(x(t),t), a*x(t) + b*y(t) + k1)
+    # and Eq(a2*diff(x(t),t), c*x(t) + d*y(t) + k2)
+    r['a'] = -fc[0,x(t),0]/fc[0,x(t),1]
+    r['c'] = -fc[1,x(t),0]/fc[1,y(t),1]
+    r['b'] = -fc[0,y(t),0]/fc[0,x(t),1]
+    r['d'] = -fc[1,y(t),0]/fc[1,y(t),1]
+    forcing = [S.Zero,S.Zero]
+    for i in range(2):
+        for j in Add.make_args(eq[i]):
+            if not j.has(x(t), y(t)):
+                forcing[i] += j
+    if not (forcing[0].has(t) or forcing[1].has(t)):
+        r['k1'] = forcing[0]
+        r['k2'] = forcing[1]
+    else:
+        raise NotImplementedError("Only homogeneous problems are supported" +
+                                  " (and constant inhomogeneity)")
+
+    if match_['type_of_equation'] == 'type6':
+        sol = _linear_2eq_order1_type6(x, y, t, r, eq)
+    if match_['type_of_equation'] == 'type7':
+        sol = _linear_2eq_order1_type7(x, y, t, r, eq)
+    return sol
+
+def _linear_2eq_order1_type6(x, y, t, r, eq):
+    r"""
+    The equations of this type of ode are .
+
+    .. math:: x' = f(t) x + g(t) y
+
+    .. math:: y' = a [f(t) + a h(t)] x + a [g(t) - h(t)] y
+
+    This is solved by first multiplying the first equation by `-a` and adding
+    it to the second equation to obtain
+
+    .. math:: y' - a x' = -a h(t) (y - a x)
+
+    Setting `U = y - ax` and integrating the equation we arrive at
+
+    .. math:: y - ax = C_1 e^{-a \int h(t) \,dt}
+
+    and on substituting the value of y in first equation give rise to first order ODEs. After solving for
+    `x`, we can obtain `y` by substituting the value of `x` in second equation.
+
+    """
+    C1, C2, C3, C4 = get_numbered_constants(eq, num=4)
+    p = 0
+    q = 0
+    p1 = cancel(r['c']/cancel(r['c']/r['d']).as_numer_denom()[0])
+    p2 = cancel(r['a']/cancel(r['a']/r['b']).as_numer_denom()[0])
+    for n, i in enumerate([p1, p2]):
+        for j in Mul.make_args(collect_const(i)):
+            if not j.has(t):
+                q = j
+            if q!=0 and n==0:
+                if ((r['c']/j - r['a'])/(r['b'] - r['d']/j)) == j:
+                    p = 1
+                    s = j
+                    break
+            if q!=0 and n==1:
+                if ((r['a']/j - r['c'])/(r['d'] - r['b']/j)) == j:
+                    p = 2
+                    s = j
+                    break
+
+    if p == 1:
+        equ = diff(x(t),t) - r['a']*x(t) - r['b']*(s*x(t) + C1*exp(-s*Integral(r['b'] - r['d']/s, t)))
+        hint1 = classify_ode(equ)[1]
+        sol1 = dsolve(equ, hint=hint1+'_Integral').rhs
+        sol2 = s*sol1 + C1*exp(-s*Integral(r['b'] - r['d']/s, t))
+    elif p ==2:
+        equ = diff(y(t),t) - r['c']*y(t) - r['d']*s*y(t) + C1*exp(-s*Integral(r['d'] - r['b']/s, t))
+        hint1 = classify_ode(equ)[1]
+        sol2 = dsolve(equ, hint=hint1+'_Integral').rhs
+        sol1 = s*sol2 + C1*exp(-s*Integral(r['d'] - r['b']/s, t))
+    return [Eq(x(t), sol1), Eq(y(t), sol2)]
+
+def _linear_2eq_order1_type7(x, y, t, r, eq):
+    r"""
+    The equations of this type of ode are .
+
+    .. math:: x' = f(t) x + g(t) y
+
+    .. math:: y' = h(t) x + p(t) y
+
+    Differentiating the first equation and substituting the value of `y`
+    from second equation will give a second-order linear equation
+
+    .. math:: g x'' - (fg + gp + g') x' + (fgp - g^{2} h + f g' - f' g) x = 0
+
+    This above equation can be easily integrated if following conditions are satisfied.
+
+    1. `fgp - g^{2} h + f g' - f' g = 0`
+
+    2. `fgp - g^{2} h + f g' - f' g = ag, fg + gp + g' = bg`
+
+    If first condition is satisfied then it is solved by current dsolve solver and in second case it becomes
+    a constant coefficient differential equation which is also solved by current solver.
+
+    Otherwise if the above condition fails then,
+    a particular solution is assumed as `x = x_0(t)` and `y = y_0(t)`
+    Then the general solution is expressed as
+
+    .. math:: x = C_1 x_0(t) + C_2 x_0(t) \int \frac{g(t) F(t) P(t)}{x_0^{2}(t)} \,dt
+
+    .. math:: y = C_1 y_0(t) + C_2 [\frac{F(t) P(t)}{x_0(t)} + y_0(t) \int \frac{g(t) F(t) P(t)}{x_0^{2}(t)} \,dt]
+
+    where C1 and C2 are arbitrary constants and
+
+    .. math:: F(t) = e^{\int f(t) \,dt}, P(t) = e^{\int p(t) \,dt}
+
+    """
+    C1, C2, C3, C4 = get_numbered_constants(eq, num=4)
+    e1 = r['a']*r['b']*r['c'] - r['b']**2*r['c'] + r['a']*diff(r['b'],t) - diff(r['a'],t)*r['b']
+    e2 = r['a']*r['c']*r['d'] - r['b']*r['c']**2 + diff(r['c'],t)*r['d'] - r['c']*diff(r['d'],t)
+    m1 = r['a']*r['b'] + r['b']*r['d'] + diff(r['b'],t)
+    m2 = r['a']*r['c'] + r['c']*r['d'] + diff(r['c'],t)
+    if e1 == 0:
+        sol1 = dsolve(r['b']*diff(x(t),t,t) - m1*diff(x(t),t)).rhs
+        sol2 = dsolve(diff(y(t),t) - r['c']*sol1 - r['d']*y(t)).rhs
+    elif e2 == 0:
+        sol2 = dsolve(r['c']*diff(y(t),t,t) - m2*diff(y(t),t)).rhs
+        sol1 = dsolve(diff(x(t),t) - r['a']*x(t) - r['b']*sol2).rhs
+    elif not (e1/r['b']).has(t) and not (m1/r['b']).has(t):
+        sol1 = dsolve(diff(x(t),t,t) - (m1/r['b'])*diff(x(t),t) - (e1/r['b'])*x(t)).rhs
+        sol2 = dsolve(diff(y(t),t) - r['c']*sol1 - r['d']*y(t)).rhs
+    elif not (e2/r['c']).has(t) and not (m2/r['c']).has(t):
+        sol2 = dsolve(diff(y(t),t,t) - (m2/r['c'])*diff(y(t),t) - (e2/r['c'])*y(t)).rhs
+        sol1 = dsolve(diff(x(t),t) - r['a']*x(t) - r['b']*sol2).rhs
+    else:
+        x0 = Function('x0')(t)    # x0 and y0 being particular solutions
+        y0 = Function('y0')(t)
+        F = exp(Integral(r['a'],t))
+        P = exp(Integral(r['d'],t))
+        sol1 = C1*x0 + C2*x0*Integral(r['b']*F*P/x0**2, t)
+        sol2 = C1*y0 + C2*(F*P/x0 + y0*Integral(r['b']*F*P/x0**2, t))
+    return [Eq(x(t), sol1), Eq(y(t), sol2)]
+
+
+def sysode_nonlinear_2eq_order1(match_):
+    func = match_['func']
+    eq = match_['eq']
+    fc = match_['func_coeff']
+    t = list(list(eq[0].atoms(Derivative))[0].atoms(Symbol))[0]
+    if match_['type_of_equation'] == 'type5':
+        sol = _nonlinear_2eq_order1_type5(func, t, eq)
+        return sol
+    x = func[0].func
+    y = func[1].func
+    for i in range(2):
+        eqs = 0
+        for terms in Add.make_args(eq[i]):
+            eqs += terms/fc[i,func[i],1]
+        eq[i] = eqs
+    if match_['type_of_equation'] == 'type1':
+        sol = _nonlinear_2eq_order1_type1(x, y, t, eq)
+    elif match_['type_of_equation'] == 'type2':
+        sol = _nonlinear_2eq_order1_type2(x, y, t, eq)
+    elif match_['type_of_equation'] == 'type3':
+        sol = _nonlinear_2eq_order1_type3(x, y, t, eq)
+    elif match_['type_of_equation'] == 'type4':
+        sol = _nonlinear_2eq_order1_type4(x, y, t, eq)
+    return sol
+
+
+def _nonlinear_2eq_order1_type1(x, y, t, eq):
+    r"""
+    Equations:
+
+    .. math:: x' = x^n F(x,y)
+
+    .. math:: y' = g(y) F(x,y)
+
+    Solution:
+
+    .. math:: x = \varphi(y), \int \frac{1}{g(y) F(\varphi(y),y)} \,dy = t + C_2
+
+    where
+
+    if `n \neq 1`
+
+    .. math:: \varphi = [C_1 + (1-n) \int \frac{1}{g(y)} \,dy]^{\frac{1}{1-n}}
+
+    if `n = 1`
+
+    .. math:: \varphi = C_1 e^{\int \frac{1}{g(y)} \,dy}
+
+    where `C_1` and `C_2` are arbitrary constants.
+
+    """
+    C1, C2 = get_numbered_constants(eq, num=2)
+    n = Wild('n', exclude=[x(t),y(t)])
+    f = Wild('f')
+    u, v = symbols('u, v')
+    r = eq[0].match(diff(x(t),t) - x(t)**n*f)
+    g = ((diff(y(t),t) - eq[1])/r[f]).subs(y(t),v)
+    F = r[f].subs(x(t),u).subs(y(t),v)
+    n = r[n]
+    if n!=1:
+        phi = (C1 + (1-n)*Integral(1/g, v))**(1/(1-n))
+    else:
+        phi = C1*exp(Integral(1/g, v))
+    phi = phi.doit()
+    sol2 = solve(Integral(1/(g*F.subs(u,phi)), v).doit() - t - C2, v)
+    sol = []
+    for sols in sol2:
+        sol.append(Eq(x(t),phi.subs(v, sols)))
+        sol.append(Eq(y(t), sols))
+    return sol
+
+def _nonlinear_2eq_order1_type2(x, y, t, eq):
+    r"""
+    Equations:
+
+    .. math:: x' = e^{\lambda x} F(x,y)
+
+    .. math:: y' = g(y) F(x,y)
+
+    Solution:
+
+    .. math:: x = \varphi(y), \int \frac{1}{g(y) F(\varphi(y),y)} \,dy = t + C_2
+
+    where
+
+    if `\lambda \neq 0`
+
+    .. math:: \varphi = -\frac{1}{\lambda} log(C_1 - \lambda \int \frac{1}{g(y)} \,dy)
+
+    if `\lambda = 0`
+
+    .. math:: \varphi = C_1 + \int \frac{1}{g(y)} \,dy
+
+    where `C_1` and `C_2` are arbitrary constants.
+
+    """
+    C1, C2 = get_numbered_constants(eq, num=2)
+    n = Wild('n', exclude=[x(t),y(t)])
+    f = Wild('f')
+    u, v = symbols('u, v')
+    r = eq[0].match(diff(x(t),t) - exp(n*x(t))*f)
+    g = ((diff(y(t),t) - eq[1])/r[f]).subs(y(t),v)
+    F = r[f].subs(x(t),u).subs(y(t),v)
+    n = r[n]
+    if n:
+        phi = -1/n*log(C1 - n*Integral(1/g, v))
+    else:
+        phi = C1 + Integral(1/g, v)
+    phi = phi.doit()
+    sol2 = solve(Integral(1/(g*F.subs(u,phi)), v).doit() - t - C2, v)
+    sol = []
+    for sols in sol2:
+        sol.append(Eq(x(t),phi.subs(v, sols)))
+        sol.append(Eq(y(t), sols))
+    return sol
+
+def _nonlinear_2eq_order1_type3(x, y, t, eq):
+    r"""
+    Autonomous system of general form
+
+    .. math:: x' = F(x,y)
+
+    .. math:: y' = G(x,y)
+
+    Assuming `y = y(x, C_1)` where `C_1` is an arbitrary constant is the general
+    solution of the first-order equation
+
+    .. math:: F(x,y) y'_x = G(x,y)
+
+    Then the general solution of the original system of equations has the form
+
+    .. math:: \int \frac{1}{F(x,y(x,C_1))} \,dx = t + C_1
+
+    """
+    C1, C2, C3, C4 = get_numbered_constants(eq, num=4)
+    v = Function('v')
+    u = Symbol('u')
+    f = Wild('f')
+    g = Wild('g')
+    r1 = eq[0].match(diff(x(t),t) - f)
+    r2 = eq[1].match(diff(y(t),t) - g)
+    F = r1[f].subs(x(t), u).subs(y(t), v(u))
+    G = r2[g].subs(x(t), u).subs(y(t), v(u))
+    sol2r = dsolve(Eq(diff(v(u), u), G/F))
+    if isinstance(sol2r, Equality):
+        sol2r = [sol2r]
+    for sol2s in sol2r:
+        sol1 = solve(Integral(1/F.subs(v(u), sol2s.rhs), u).doit() - t - C2, u)
+    sol = []
+    for sols in sol1:
+        sol.append(Eq(x(t), sols))
+        sol.append(Eq(y(t), (sol2s.rhs).subs(u, sols)))
+    return sol
+
+def _nonlinear_2eq_order1_type4(x, y, t, eq):
+    r"""
+    Equation:
+
+    .. math:: x' = f_1(x) g_1(y) \phi(x,y,t)
+
+    .. math:: y' = f_2(x) g_2(y) \phi(x,y,t)
+
+    First integral:
+
+    .. math:: \int \frac{f_2(x)}{f_1(x)} \,dx - \int \frac{g_1(y)}{g_2(y)} \,dy = C
+
+    where `C` is an arbitrary constant.
+
+    On solving the first integral for `x` (resp., `y` ) and on substituting the
+    resulting expression into either equation of the original solution, one
+    arrives at a first-order equation for determining `y` (resp., `x` ).
+
+    """
+    C1, C2 = get_numbered_constants(eq, num=2)
+    u, v = symbols('u, v')
+    U, V = symbols('U, V', cls=Function)
+    f = Wild('f')
+    g = Wild('g')
+    f1 = Wild('f1', exclude=[v,t])
+    f2 = Wild('f2', exclude=[v,t])
+    g1 = Wild('g1', exclude=[u,t])
+    g2 = Wild('g2', exclude=[u,t])
+    r1 = eq[0].match(diff(x(t),t) - f)
+    r2 = eq[1].match(diff(y(t),t) - g)
+    num, den = (
+        (r1[f].subs(x(t),u).subs(y(t),v))/
+        (r2[g].subs(x(t),u).subs(y(t),v))).as_numer_denom()
+    R1 = num.match(f1*g1)
+    R2 = den.match(f2*g2)
+    phi = (r1[f].subs(x(t),u).subs(y(t),v))/num
+    F1 = R1[f1]; F2 = R2[f2]
+    G1 = R1[g1]; G2 = R2[g2]
+    sol1r = solve(Integral(F2/F1, u).doit() - Integral(G1/G2,v).doit() - C1, u)
+    sol2r = solve(Integral(F2/F1, u).doit() - Integral(G1/G2,v).doit() - C1, v)
+    sol = []
+    for sols in sol1r:
+        sol.append(Eq(y(t), dsolve(diff(V(t),t) - F2.subs(u,sols).subs(v,V(t))*G2.subs(v,V(t))*phi.subs(u,sols).subs(v,V(t))).rhs))
+    for sols in sol2r:
+        sol.append(Eq(x(t), dsolve(diff(U(t),t) - F1.subs(u,U(t))*G1.subs(v,sols).subs(u,U(t))*phi.subs(v,sols).subs(u,U(t))).rhs))
+    return set(sol)
+
+def _nonlinear_2eq_order1_type5(func, t, eq):
+    r"""
+    Clairaut system of ODEs
+
+    .. math:: x = t x' + F(x',y')
+
+    .. math:: y = t y' + G(x',y')
+
+    The following are solutions of the system
+
+    `(i)` straight lines:
+
+    .. math:: x = C_1 t + F(C_1, C_2), y = C_2 t + G(C_1, C_2)
+
+    where `C_1` and `C_2` are arbitrary constants;
+
+    `(ii)` envelopes of the above lines;
+
+    `(iii)` continuously differentiable lines made up from segments of the lines
+    `(i)` and `(ii)`.
+
+    """
+    C1, C2 = get_numbered_constants(eq, num=2)
+    f = Wild('f')
+    g = Wild('g')
+    def check_type(x, y):
+        r1 = eq[0].match(t*diff(x(t),t) - x(t) + f)
+        r2 = eq[1].match(t*diff(y(t),t) - y(t) + g)
+        if not (r1 and r2):
+            r1 = eq[0].match(diff(x(t),t) - x(t)/t + f/t)
+            r2 = eq[1].match(diff(y(t),t) - y(t)/t + g/t)
+        if not (r1 and r2):
+            r1 = (-eq[0]).match(t*diff(x(t),t) - x(t) + f)
+            r2 = (-eq[1]).match(t*diff(y(t),t) - y(t) + g)
+        if not (r1 and r2):
+            r1 = (-eq[0]).match(diff(x(t),t) - x(t)/t + f/t)
+            r2 = (-eq[1]).match(diff(y(t),t) - y(t)/t + g/t)
+        return [r1, r2]
+    for func_ in func:
+        if isinstance(func_, list):
+            x = func[0][0].func
+            y = func[0][1].func
+            [r1, r2] = check_type(x, y)
+            if not (r1 and r2):
+                [r1, r2] = check_type(y, x)
+                x, y = y, x
+    x1 = diff(x(t),t); y1 = diff(y(t),t)
+    return {Eq(x(t), C1*t + r1[f].subs(x1,C1).subs(y1,C2)), Eq(y(t), C2*t + r2[g].subs(x1,C1).subs(y1,C2))}
+
+def sysode_nonlinear_3eq_order1(match_):
+    x = match_['func'][0].func
+    y = match_['func'][1].func
+    z = match_['func'][2].func
+    eq = match_['eq']
+    t = list(list(eq[0].atoms(Derivative))[0].atoms(Symbol))[0]
+    if match_['type_of_equation'] == 'type1':
+        sol = _nonlinear_3eq_order1_type1(x, y, z, t, eq)
+    if match_['type_of_equation'] == 'type2':
+        sol = _nonlinear_3eq_order1_type2(x, y, z, t, eq)
+    if match_['type_of_equation'] == 'type3':
+        sol = _nonlinear_3eq_order1_type3(x, y, z, t, eq)
+    if match_['type_of_equation'] == 'type4':
+        sol = _nonlinear_3eq_order1_type4(x, y, z, t, eq)
+    if match_['type_of_equation'] == 'type5':
+        sol = _nonlinear_3eq_order1_type5(x, y, z, t, eq)
+    return sol
+
+def _nonlinear_3eq_order1_type1(x, y, z, t, eq):
+    r"""
+    Equations:
+
+    .. math:: a x' = (b - c) y z, \enspace b y' = (c - a) z x, \enspace c z' = (a - b) x y
+
+    First Integrals:
+
+    .. math:: a x^{2} + b y^{2} + c z^{2} = C_1
+
+    .. math:: a^{2} x^{2} + b^{2} y^{2} + c^{2} z^{2} = C_2
+
+    where `C_1` and `C_2` are arbitrary constants. On solving the integrals for `y` and
+    `z` and on substituting the resulting expressions into the first equation of the
+    system, we arrives at a separable first-order equation on `x`. Similarly doing that
+    for other two equations, we will arrive at first order equation on `y` and `z` too.
+
+    References
+    ==========
+    -https://eqworld.ipmnet.ru/en/solutions/sysode/sode0401.pdf
+
+    """
+    C1, C2 = get_numbered_constants(eq, num=2)
+    u, v, w = symbols('u, v, w')
+    p = Wild('p', exclude=[x(t), y(t), z(t), t])
+    q = Wild('q', exclude=[x(t), y(t), z(t), t])
+    s = Wild('s', exclude=[x(t), y(t), z(t), t])
+    r = (diff(x(t),t) - eq[0]).match(p*y(t)*z(t))
+    r.update((diff(y(t),t) - eq[1]).match(q*z(t)*x(t)))
+    r.update((diff(z(t),t) - eq[2]).match(s*x(t)*y(t)))
+    n1, d1 = r[p].as_numer_denom()
+    n2, d2 = r[q].as_numer_denom()
+    n3, d3 = r[s].as_numer_denom()
+    val = solve([n1*u-d1*v+d1*w, d2*u+n2*v-d2*w, d3*u-d3*v-n3*w],[u,v])
+    vals = [val[v], val[u]]
+    c = lcm(vals[0].as_numer_denom()[1], vals[1].as_numer_denom()[1])
+    b = vals[0].subs(w, c)
+    a = vals[1].subs(w, c)
+    y_x = sqrt(((c*C1-C2) - a*(c-a)*x(t)**2)/(b*(c-b)))
+    z_x = sqrt(((b*C1-C2) - a*(b-a)*x(t)**2)/(c*(b-c)))
+    z_y = sqrt(((a*C1-C2) - b*(a-b)*y(t)**2)/(c*(a-c)))
+    x_y = sqrt(((c*C1-C2) - b*(c-b)*y(t)**2)/(a*(c-a)))
+    x_z = sqrt(((b*C1-C2) - c*(b-c)*z(t)**2)/(a*(b-a)))
+    y_z = sqrt(((a*C1-C2) - c*(a-c)*z(t)**2)/(b*(a-b)))
+    sol1 = dsolve(a*diff(x(t),t) - (b-c)*y_x*z_x)
+    sol2 = dsolve(b*diff(y(t),t) - (c-a)*z_y*x_y)
+    sol3 = dsolve(c*diff(z(t),t) - (a-b)*x_z*y_z)
+    return [sol1, sol2, sol3]
+
+
+def _nonlinear_3eq_order1_type2(x, y, z, t, eq):
+    r"""
+    Equations:
+
+    .. math:: a x' = (b - c) y z f(x, y, z, t)
+
+    .. math:: b y' = (c - a) z x f(x, y, z, t)
+
+    .. math:: c z' = (a - b) x y f(x, y, z, t)
+
+    First Integrals:
+
+    .. math:: a x^{2} + b y^{2} + c z^{2} = C_1
+
+    .. math:: a^{2} x^{2} + b^{2} y^{2} + c^{2} z^{2} = C_2
+
+    where `C_1` and `C_2` are arbitrary constants. On solving the integrals for `y` and
+    `z` and on substituting the resulting expressions into the first equation of the
+    system, we arrives at a first-order differential equations on `x`. Similarly doing
+    that for other two equations we will arrive at first order equation on `y` and `z`.
+
+    References
+    ==========
+    -https://eqworld.ipmnet.ru/en/solutions/sysode/sode0402.pdf
+
+    """
+    C1, C2 = get_numbered_constants(eq, num=2)
+    u, v, w = symbols('u, v, w')
+    p = Wild('p', exclude=[x(t), y(t), z(t), t])
+    q = Wild('q', exclude=[x(t), y(t), z(t), t])
+    s = Wild('s', exclude=[x(t), y(t), z(t), t])
+    f = Wild('f')
+    r1 = (diff(x(t),t) - eq[0]).match(y(t)*z(t)*f)
+    r = collect_const(r1[f]).match(p*f)
+    r.update(((diff(y(t),t) - eq[1])/r[f]).match(q*z(t)*x(t)))
+    r.update(((diff(z(t),t) - eq[2])/r[f]).match(s*x(t)*y(t)))
+    n1, d1 = r[p].as_numer_denom()
+    n2, d2 = r[q].as_numer_denom()
+    n3, d3 = r[s].as_numer_denom()
+    val = solve([n1*u-d1*v+d1*w, d2*u+n2*v-d2*w, -d3*u+d3*v+n3*w],[u,v])
+    vals = [val[v], val[u]]
+    c = lcm(vals[0].as_numer_denom()[1], vals[1].as_numer_denom()[1])
+    a = vals[0].subs(w, c)
+    b = vals[1].subs(w, c)
+    y_x = sqrt(((c*C1-C2) - a*(c-a)*x(t)**2)/(b*(c-b)))
+    z_x = sqrt(((b*C1-C2) - a*(b-a)*x(t)**2)/(c*(b-c)))
+    z_y = sqrt(((a*C1-C2) - b*(a-b)*y(t)**2)/(c*(a-c)))
+    x_y = sqrt(((c*C1-C2) - b*(c-b)*y(t)**2)/(a*(c-a)))
+    x_z = sqrt(((b*C1-C2) - c*(b-c)*z(t)**2)/(a*(b-a)))
+    y_z = sqrt(((a*C1-C2) - c*(a-c)*z(t)**2)/(b*(a-b)))
+    sol1 = dsolve(a*diff(x(t),t) - (b-c)*y_x*z_x*r[f])
+    sol2 = dsolve(b*diff(y(t),t) - (c-a)*z_y*x_y*r[f])
+    sol3 = dsolve(c*diff(z(t),t) - (a-b)*x_z*y_z*r[f])
+    return [sol1, sol2, sol3]
+
+def _nonlinear_3eq_order1_type3(x, y, z, t, eq):
+    r"""
+    Equations:
+
+    .. math:: x' = c F_2 - b F_3, \enspace y' = a F_3 - c F_1, \enspace z' = b F_1 - a F_2
+
+    where `F_n = F_n(x, y, z, t)`.
+
+    1. First Integral:
+
+    .. math:: a x + b y + c z = C_1,
+
+    where C is an arbitrary constant.
+
+    2. If we assume function `F_n` to be independent of `t`,i.e, `F_n` = `F_n (x, y, z)`
+    Then, on eliminating `t` and `z` from the first two equation of the system, one
+    arrives at the first-order equation
+
+    .. math:: \frac{dy}{dx} = \frac{a F_3 (x, y, z) - c F_1 (x, y, z)}{c F_2 (x, y, z) -
+                b F_3 (x, y, z)}
+
+    where `z = \frac{1}{c} (C_1 - a x - b y)`
+
+    References
+    ==========
+    -https://eqworld.ipmnet.ru/en/solutions/sysode/sode0404.pdf
+
+    """
+    C1 = get_numbered_constants(eq, num=1)
+    u, v, w = symbols('u, v, w')
+    fu, fv, fw = symbols('u, v, w', cls=Function)
+    p = Wild('p', exclude=[x(t), y(t), z(t), t])
+    q = Wild('q', exclude=[x(t), y(t), z(t), t])
+    s = Wild('s', exclude=[x(t), y(t), z(t), t])
+    F1, F2, F3 = symbols('F1, F2, F3', cls=Wild)
+    r1 = (diff(x(t), t) - eq[0]).match(F2-F3)
+    r = collect_const(r1[F2]).match(s*F2)
+    r.update(collect_const(r1[F3]).match(q*F3))
+    if eq[1].has(r[F2]) and not eq[1].has(r[F3]):
+        r[F2], r[F3] = r[F3], r[F2]
+        r[s], r[q] = -r[q], -r[s]
+    r.update((diff(y(t), t) - eq[1]).match(p*r[F3] - r[s]*F1))
+    a = r[p]; b = r[q]; c = r[s]
+    F1 = r[F1].subs(x(t), u).subs(y(t),v).subs(z(t), w)
+    F2 = r[F2].subs(x(t), u).subs(y(t),v).subs(z(t), w)
+    F3 = r[F3].subs(x(t), u).subs(y(t),v).subs(z(t), w)
+    z_xy = (C1-a*u-b*v)/c
+    y_zx = (C1-a*u-c*w)/b
+    x_yz = (C1-b*v-c*w)/a
+    y_x = dsolve(diff(fv(u),u) - ((a*F3-c*F1)/(c*F2-b*F3)).subs(w,z_xy).subs(v,fv(u))).rhs
+    z_x = dsolve(diff(fw(u),u) - ((b*F1-a*F2)/(c*F2-b*F3)).subs(v,y_zx).subs(w,fw(u))).rhs
+    z_y = dsolve(diff(fw(v),v) - ((b*F1-a*F2)/(a*F3-c*F1)).subs(u,x_yz).subs(w,fw(v))).rhs
+    x_y = dsolve(diff(fu(v),v) - ((c*F2-b*F3)/(a*F3-c*F1)).subs(w,z_xy).subs(u,fu(v))).rhs
+    y_z = dsolve(diff(fv(w),w) - ((a*F3-c*F1)/(b*F1-a*F2)).subs(u,x_yz).subs(v,fv(w))).rhs
+    x_z = dsolve(diff(fu(w),w) - ((c*F2-b*F3)/(b*F1-a*F2)).subs(v,y_zx).subs(u,fu(w))).rhs
+    sol1 = dsolve(diff(fu(t),t) - (c*F2 - b*F3).subs(v,y_x).subs(w,z_x).subs(u,fu(t))).rhs
+    sol2 = dsolve(diff(fv(t),t) - (a*F3 - c*F1).subs(u,x_y).subs(w,z_y).subs(v,fv(t))).rhs
+    sol3 = dsolve(diff(fw(t),t) - (b*F1 - a*F2).subs(u,x_z).subs(v,y_z).subs(w,fw(t))).rhs
+    return [sol1, sol2, sol3]
+
+def _nonlinear_3eq_order1_type4(x, y, z, t, eq):
+    r"""
+    Equations:
+
+    .. math:: x' = c z F_2 - b y F_3, \enspace y' = a x F_3 - c z F_1, \enspace z' = b y F_1 - a x F_2
+
+    where `F_n = F_n (x, y, z, t)`
+
+    1. First integral:
+
+    .. math:: a x^{2} + b y^{2} + c z^{2} = C_1
+
+    where `C` is an arbitrary constant.
+
+    2. Assuming the function `F_n` is independent of `t`: `F_n = F_n (x, y, z)`. Then on
+    eliminating `t` and `z` from the first two equations of the system, one arrives at
+    the first-order equation
+
+    .. math:: \frac{dy}{dx} = \frac{a x F_3 (x, y, z) - c z F_1 (x, y, z)}
+                {c z F_2 (x, y, z) - b y F_3 (x, y, z)}
+
+    where `z = \pm \sqrt{\frac{1}{c} (C_1 - a x^{2} - b y^{2})}`
+
+    References
+    ==========
+    -https://eqworld.ipmnet.ru/en/solutions/sysode/sode0405.pdf
+
+    """
+    C1 = get_numbered_constants(eq, num=1)
+    u, v, w = symbols('u, v, w')
+    p = Wild('p', exclude=[x(t), y(t), z(t), t])
+    q = Wild('q', exclude=[x(t), y(t), z(t), t])
+    s = Wild('s', exclude=[x(t), y(t), z(t), t])
+    F1, F2, F3 = symbols('F1, F2, F3', cls=Wild)
+    r1 = eq[0].match(diff(x(t),t) - z(t)*F2 + y(t)*F3)
+    r = collect_const(r1[F2]).match(s*F2)
+    r.update(collect_const(r1[F3]).match(q*F3))
+    if eq[1].has(r[F2]) and not eq[1].has(r[F3]):
+        r[F2], r[F3] = r[F3], r[F2]
+        r[s], r[q] = -r[q], -r[s]
+    r.update((diff(y(t),t) - eq[1]).match(p*x(t)*r[F3] - r[s]*z(t)*F1))
+    a = r[p]; b = r[q]; c = r[s]
+    F1 = r[F1].subs(x(t),u).subs(y(t),v).subs(z(t),w)
+    F2 = r[F2].subs(x(t),u).subs(y(t),v).subs(z(t),w)
+    F3 = r[F3].subs(x(t),u).subs(y(t),v).subs(z(t),w)
+    x_yz = sqrt((C1 - b*v**2 - c*w**2)/a)
+    y_zx = sqrt((C1 - c*w**2 - a*u**2)/b)
+    z_xy = sqrt((C1 - a*u**2 - b*v**2)/c)
+    y_x = dsolve(diff(v(u),u) - ((a*u*F3-c*w*F1)/(c*w*F2-b*v*F3)).subs(w,z_xy).subs(v,v(u))).rhs
+    z_x = dsolve(diff(w(u),u) - ((b*v*F1-a*u*F2)/(c*w*F2-b*v*F3)).subs(v,y_zx).subs(w,w(u))).rhs
+    z_y = dsolve(diff(w(v),v) - ((b*v*F1-a*u*F2)/(a*u*F3-c*w*F1)).subs(u,x_yz).subs(w,w(v))).rhs
+    x_y = dsolve(diff(u(v),v) - ((c*w*F2-b*v*F3)/(a*u*F3-c*w*F1)).subs(w,z_xy).subs(u,u(v))).rhs
+    y_z = dsolve(diff(v(w),w) - ((a*u*F3-c*w*F1)/(b*v*F1-a*u*F2)).subs(u,x_yz).subs(v,v(w))).rhs
+    x_z = dsolve(diff(u(w),w) - ((c*w*F2-b*v*F3)/(b*v*F1-a*u*F2)).subs(v,y_zx).subs(u,u(w))).rhs
+    sol1 = dsolve(diff(u(t),t) - (c*w*F2 - b*v*F3).subs(v,y_x).subs(w,z_x).subs(u,u(t))).rhs
+    sol2 = dsolve(diff(v(t),t) - (a*u*F3 - c*w*F1).subs(u,x_y).subs(w,z_y).subs(v,v(t))).rhs
+    sol3 = dsolve(diff(w(t),t) - (b*v*F1 - a*u*F2).subs(u,x_z).subs(v,y_z).subs(w,w(t))).rhs
+    return [sol1, sol2, sol3]
+
+def _nonlinear_3eq_order1_type5(x, y, z, t, eq):
+    r"""
+    .. math:: x' = x (c F_2 - b F_3), \enspace y' = y (a F_3 - c F_1), \enspace z' = z (b F_1 - a F_2)
+
+    where `F_n = F_n (x, y, z, t)` and are arbitrary functions.
+
+    First Integral:
+
+    .. math:: \left|x\right|^{a} \left|y\right|^{b} \left|z\right|^{c} = C_1
+
+    where `C` is an arbitrary constant. If the function `F_n` is independent of `t`,
+    then, by eliminating `t` and `z` from the first two equations of the system, one
+    arrives at a first-order equation.
+
+    References
+    ==========
+    -https://eqworld.ipmnet.ru/en/solutions/sysode/sode0406.pdf
+
+    """
+    C1 = get_numbered_constants(eq, num=1)
+    u, v, w = symbols('u, v, w')
+    fu, fv, fw = symbols('u, v, w', cls=Function)
+    p = Wild('p', exclude=[x(t), y(t), z(t), t])
+    q = Wild('q', exclude=[x(t), y(t), z(t), t])
+    s = Wild('s', exclude=[x(t), y(t), z(t), t])
+    F1, F2, F3 = symbols('F1, F2, F3', cls=Wild)
+    r1 = eq[0].match(diff(x(t), t) - x(t)*F2 + x(t)*F3)
+    r = collect_const(r1[F2]).match(s*F2)
+    r.update(collect_const(r1[F3]).match(q*F3))
+    if eq[1].has(r[F2]) and not eq[1].has(r[F3]):
+        r[F2], r[F3] = r[F3], r[F2]
+        r[s], r[q] = -r[q], -r[s]
+    r.update((diff(y(t), t) - eq[1]).match(y(t)*(p*r[F3] - r[s]*F1)))
+    a = r[p]; b = r[q]; c = r[s]
+    F1 = r[F1].subs(x(t), u).subs(y(t), v).subs(z(t), w)
+    F2 = r[F2].subs(x(t), u).subs(y(t), v).subs(z(t), w)
+    F3 = r[F3].subs(x(t), u).subs(y(t), v).subs(z(t), w)
+    x_yz = (C1*v**-b*w**-c)**-a
+    y_zx = (C1*w**-c*u**-a)**-b
+    z_xy = (C1*u**-a*v**-b)**-c
+    y_x = dsolve(diff(fv(u), u) - ((v*(a*F3 - c*F1))/(u*(c*F2 - b*F3))).subs(w, z_xy).subs(v, fv(u))).rhs
+    z_x = dsolve(diff(fw(u), u) - ((w*(b*F1 - a*F2))/(u*(c*F2 - b*F3))).subs(v, y_zx).subs(w, fw(u))).rhs
+    z_y = dsolve(diff(fw(v), v) - ((w*(b*F1 - a*F2))/(v*(a*F3 - c*F1))).subs(u, x_yz).subs(w, fw(v))).rhs
+    x_y = dsolve(diff(fu(v), v) - ((u*(c*F2 - b*F3))/(v*(a*F3 - c*F1))).subs(w, z_xy).subs(u, fu(v))).rhs
+    y_z = dsolve(diff(fv(w), w) - ((v*(a*F3 - c*F1))/(w*(b*F1 - a*F2))).subs(u, x_yz).subs(v, fv(w))).rhs
+    x_z = dsolve(diff(fu(w), w) - ((u*(c*F2 - b*F3))/(w*(b*F1 - a*F2))).subs(v, y_zx).subs(u, fu(w))).rhs
+    sol1 = dsolve(diff(fu(t), t) - (u*(c*F2 - b*F3)).subs(v, y_x).subs(w, z_x).subs(u, fu(t))).rhs
+    sol2 = dsolve(diff(fv(t), t) - (v*(a*F3 - c*F1)).subs(u, x_y).subs(w, z_y).subs(v, fv(t))).rhs
+    sol3 = dsolve(diff(fw(t), t) - (w*(b*F1 - a*F2)).subs(u, x_z).subs(v, y_z).subs(w, fw(t))).rhs
+    return [sol1, sol2, sol3]
+
+
+#This import is written at the bottom to avoid circular imports.
+from .single import SingleODEProblem, SingleODESolver, solver_map
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/ode/riccati.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/ode/riccati.py
new file mode 100644
index 0000000000000000000000000000000000000000..2ef66ed0896d39bee8fba1b74a0c93734742fc1f
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/ode/riccati.py
@@ -0,0 +1,893 @@
+r"""
+This module contains :py:meth:`~sympy.solvers.ode.riccati.solve_riccati`,
+a function which gives all rational particular solutions to first order
+Riccati ODEs. A general first order Riccati ODE is given by -
+
+.. math:: y' = b_0(x) + b_1(x)w + b_2(x)w^2
+
+where `b_0, b_1` and `b_2` can be arbitrary rational functions of `x`
+with `b_2 \ne 0`. When `b_2 = 0`, the equation is not a Riccati ODE
+anymore and becomes a Linear ODE. Similarly, when `b_0 = 0`, the equation
+is a Bernoulli ODE. The algorithm presented below can find rational
+solution(s) to all ODEs with `b_2 \ne 0` that have a rational solution,
+or prove that no rational solution exists for the equation.
+
+Background
+==========
+
+A Riccati equation can be transformed to its normal form
+
+.. math:: y' + y^2 = a(x)
+
+using the transformation
+
+.. math:: y = -b_2(x) - \frac{b'_2(x)}{2 b_2(x)} - \frac{b_1(x)}{2}
+
+where `a(x)` is given by
+
+.. math:: a(x) = \frac{1}{4}\left(\frac{b_2'}{b_2} + b_1\right)^2 - \frac{1}{2}\left(\frac{b_2'}{b_2} + b_1\right)' - b_0 b_2
+
+Thus, we can develop an algorithm to solve for the Riccati equation
+in its normal form, which would in turn give us the solution for
+the original Riccati equation.
+
+Algorithm
+=========
+
+The algorithm implemented here is presented in the Ph.D thesis
+"Rational and Algebraic Solutions of First-Order Algebraic ODEs"
+by N. Thieu Vo. The entire thesis can be found here -
+https://www3.risc.jku.at/publications/download/risc_5387/PhDThesisThieu.pdf
+
+We have only implemented the Rational Riccati solver (Algorithm 11,
+Pg 78-82 in Thesis). Before we proceed towards the implementation
+of the algorithm, a few definitions to understand are -
+
+1. Valuation of a Rational Function at `\infty`:
+    The valuation of a rational function `p(x)` at `\infty` is equal
+    to the difference between the degree of the denominator and the
+    numerator of `p(x)`.
+
+    NOTE: A general definition of valuation of a rational function
+    at any value of `x` can be found in Pg 63 of the thesis, but
+    is not of any interest for this algorithm.
+
+2. Zeros and Poles of a Rational Function:
+    Let `a(x) = \frac{S(x)}{T(x)}, T \ne 0` be a rational function
+    of `x`. Then -
+
+    a. The Zeros of `a(x)` are the roots of `S(x)`.
+    b. The Poles of `a(x)` are the roots of `T(x)`. However, `\infty`
+    can also be a pole of a(x). We say that `a(x)` has a pole at
+    `\infty` if `a(\frac{1}{x})` has a pole at 0.
+
+Every pole is associated with an order that is equal to the multiplicity
+of its appearance as a root of `T(x)`. A pole is called a simple pole if
+it has an order 1. Similarly, a pole is called a multiple pole if it has
+an order `\ge` 2.
+
+Necessary Conditions
+====================
+
+For a Riccati equation in its normal form,
+
+.. math:: y' + y^2 = a(x)
+
+we can define
+
+a. A pole is called a movable pole if it is a pole of `y(x)` and is not
+a pole of `a(x)`.
+b. Similarly, a pole is called a non-movable pole if it is a pole of both
+`y(x)` and `a(x)`.
+
+Then, the algorithm states that a rational solution exists only if -
+
+a. Every pole of `a(x)` must be either a simple pole or a multiple pole
+of even order.
+b. The valuation of `a(x)` at `\infty` must be even or be `\ge` 2.
+
+This algorithm finds all possible rational solutions for the Riccati ODE.
+If no rational solutions are found, it means that no rational solutions
+exist.
+
+The algorithm works for Riccati ODEs where the coefficients are rational
+functions in the independent variable `x` with rational number coefficients
+i.e. in `Q(x)`. The coefficients in the rational function cannot be floats,
+irrational numbers, symbols or any other kind of expression. The reasons
+for this are -
+
+1. When using symbols, different symbols could take the same value and this
+would affect the multiplicity of poles if symbols are present here.
+
+2. An integer degree bound is required to calculate a polynomial solution
+to an auxiliary differential equation, which in turn gives the particular
+solution for the original ODE. If symbols/floats/irrational numbers are
+present, we cannot determine if the expression for the degree bound is an
+integer or not.
+
+Solution
+========
+
+With these definitions, we can state a general form for the solution of
+the equation. `y(x)` must have the form -
+
+.. math:: y(x) = \sum_{i=1}^{n} \sum_{j=1}^{r_i} \frac{c_{ij}}{(x - x_i)^j} + \sum_{i=1}^{m} \frac{1}{x - \chi_i} + \sum_{i=0}^{N} d_i x^i
+
+where `x_1, x_2, \dots, x_n` are non-movable poles of `a(x)`,
+`\chi_1, \chi_2, \dots, \chi_m` are movable poles of `a(x)`, and the values
+of `N, n, r_1, r_2, \dots, r_n` can be determined from `a(x)`. The
+coefficient vectors `(d_0, d_1, \dots, d_N)` and `(c_{i1}, c_{i2}, \dots, c_{i r_i})`
+can be determined from `a(x)`. We will have 2 choices each of these vectors
+and part of the procedure is figuring out which of the 2 should be used
+to get the solution correctly.
+
+Implementation
+==============
+
+In this implementation, we use ``Poly`` to represent a rational function
+rather than using ``Expr`` since ``Poly`` is much faster. Since we cannot
+represent rational functions directly using ``Poly``, we instead represent
+a rational function with 2 ``Poly`` objects - one for its numerator and
+the other for its denominator.
+
+The code is written to match the steps given in the thesis (Pg 82)
+
+Step 0 : Match the equation -
+Find `b_0, b_1` and `b_2`. If `b_2 = 0` or no such functions exist, raise
+an error
+
+Step 1 : Transform the equation to its normal form as explained in the
+theory section.
+
+Step 2 : Initialize an empty set of solutions, ``sol``.
+
+Step 3 : If `a(x) = 0`, append `\frac{1}/{(x - C1)}` to ``sol``.
+
+Step 4 : If `a(x)` is a rational non-zero number, append `\pm \sqrt{a}`
+to ``sol``.
+
+Step 5 : Find the poles and their multiplicities of `a(x)`. Let
+the number of poles be `n`. Also find the valuation of `a(x)` at
+`\infty` using ``val_at_inf``.
+
+NOTE: Although the algorithm considers `\infty` as a pole, it is
+not mentioned if it a part of the set of finite poles. `\infty`
+is NOT a part of the set of finite poles. If a pole exists at
+`\infty`, we use its multiplicity to find the laurent series of
+`a(x)` about `\infty`.
+
+Step 6 : Find `n` c-vectors (one for each pole) and 1 d-vector using
+``construct_c`` and ``construct_d``. Now, determine all the ``2**(n + 1)``
+combinations of choosing between 2 choices for each of the `n` c-vectors
+and 1 d-vector.
+
+NOTE: The equation for `d_{-1}` in Case 4 (Pg 80) has a printinig
+mistake. The term `- d_N` must be replaced with `-N d_N`. The same
+has been explained in the code as well.
+
+For each of these above combinations, do
+
+Step 8 : Compute `m` in ``compute_m_ybar``. `m` is the degree bound of
+the polynomial solution we must find for the auxiliary equation.
+
+Step 9 : In ``compute_m_ybar``, compute ybar as well where ``ybar`` is
+one part of y(x) -
+
+.. math:: \overline{y}(x) = \sum_{i=1}^{n} \sum_{j=1}^{r_i} \frac{c_{ij}}{(x - x_i)^j} + \sum_{i=0}^{N} d_i x^i
+
+Step 10 : If `m` is a non-negative integer -
+
+Step 11: Find a polynomial solution of degree `m` for the auxiliary equation.
+
+There are 2 cases possible -
+
+    a. `m` is a non-negative integer: We can solve for the coefficients
+    in `p(x)` using Undetermined Coefficients.
+
+    b. `m` is not a non-negative integer: In this case, we cannot find
+    a polynomial solution to the auxiliary equation, and hence, we ignore
+    this value of `m`.
+
+Step 12 : For each `p(x)` that exists, append `ybar + \frac{p'(x)}{p(x)}`
+to ``sol``.
+
+Step 13 : For each solution in ``sol``, apply an inverse transformation,
+so that the solutions of the original equation are found using the
+solutions of the equation in its normal form.
+"""
+
+
+from itertools import product
+from sympy.core import S
+from sympy.core.add import Add
+from sympy.core.numbers import oo, Float
+from sympy.core.function import count_ops
+from sympy.core.relational import Eq
+from sympy.core.symbol import symbols, Symbol, Dummy
+from sympy.functions import sqrt, exp
+from sympy.functions.elementary.complexes import sign
+from sympy.integrals.integrals import Integral
+from sympy.polys.domains import ZZ
+from sympy.polys.polytools import Poly
+from sympy.polys.polyroots import roots
+from sympy.solvers.solveset import linsolve
+
+
+def riccati_normal(w, x, b1, b2):
+    """
+    Given a solution `w(x)` to the equation
+
+    .. math:: w'(x) = b_0(x) + b_1(x)*w(x) + b_2(x)*w(x)^2
+
+    and rational function coefficients `b_1(x)` and
+    `b_2(x)`, this function transforms the solution to
+    give a solution `y(x)` for its corresponding normal
+    Riccati ODE
+
+    .. math:: y'(x) + y(x)^2 = a(x)
+
+    using the transformation
+
+    .. math:: y(x) = -b_2(x)*w(x) - b'_2(x)/(2*b_2(x)) - b_1(x)/2
+    """
+    return -b2*w - b2.diff(x)/(2*b2) - b1/2
+
+
+def riccati_inverse_normal(y, x, b1, b2, bp=None):
+    """
+    Inverse transforming the solution to the normal
+    Riccati ODE to get the solution to the Riccati ODE.
+    """
+    # bp is the expression which is independent of the solution
+    # and hence, it need not be computed again
+    if bp is None:
+        bp = -b2.diff(x)/(2*b2**2) - b1/(2*b2)
+    # w(x) = -y(x)/b2(x) - b2'(x)/(2*b2(x)^2) - b1(x)/(2*b2(x))
+    return -y/b2 + bp
+
+
+def riccati_reduced(eq, f, x):
+    """
+    Convert a Riccati ODE into its corresponding
+    normal Riccati ODE.
+    """
+    match, funcs = match_riccati(eq, f, x)
+    # If equation is not a Riccati ODE, exit
+    if not match:
+        return False
+    # Using the rational functions, find the expression for a(x)
+    b0, b1, b2 = funcs
+    a = -b0*b2 + b1**2/4 - b1.diff(x)/2 + 3*b2.diff(x)**2/(4*b2**2) + b1*b2.diff(x)/(2*b2) - \
+        b2.diff(x, 2)/(2*b2)
+    # Normal form of Riccati ODE is f'(x) + f(x)^2 = a(x)
+    return f(x).diff(x) + f(x)**2 - a
+
+def linsolve_dict(eq, syms):
+    """
+    Get the output of linsolve as a dict
+    """
+    # Convert tuple type return value of linsolve
+    # to a dictionary for ease of use
+    sol = linsolve(eq, syms)
+    if not sol:
+        return {}
+    return dict(zip(syms, list(sol)[0]))
+
+
+def match_riccati(eq, f, x):
+    """
+    A function that matches and returns the coefficients
+    if an equation is a Riccati ODE
+
+    Parameters
+    ==========
+
+    eq: Equation to be matched
+    f: Dependent variable
+    x: Independent variable
+
+    Returns
+    =======
+
+    match: True if equation is a Riccati ODE, False otherwise
+    funcs: [b0, b1, b2] if match is True, [] otherwise. Here,
+    b0, b1 and b2 are rational functions which match the equation.
+    """
+    # Group terms based on f(x)
+    if isinstance(eq, Eq):
+        eq = eq.lhs - eq.rhs
+    eq = eq.expand().collect(f(x))
+    cf = eq.coeff(f(x).diff(x))
+
+    # There must be an f(x).diff(x) term.
+    # eq must be an Add object since we are using the expanded
+    # equation and it must have atleast 2 terms (b2 != 0)
+    if cf != 0 and isinstance(eq, Add):
+
+        # Divide all coefficients by the coefficient of f(x).diff(x)
+        # and add the terms again to get the same equation
+        eq = Add(*((x/cf).cancel() for x in eq.args)).collect(f(x))
+
+        # Match the equation with the pattern
+        b1 = -eq.coeff(f(x))
+        b2 = -eq.coeff(f(x)**2)
+        b0 = (f(x).diff(x) - b1*f(x) - b2*f(x)**2 - eq).expand()
+        funcs = [b0, b1, b2]
+
+        # Check if coefficients are not symbols and floats
+        if any(len(x.atoms(Symbol)) > 1 or len(x.atoms(Float)) for x in funcs):
+            return False, []
+
+        # If b_0(x) contains f(x), it is not a Riccati ODE
+        if len(b0.atoms(f)) or not all((b2 != 0, b0.is_rational_function(x),
+            b1.is_rational_function(x), b2.is_rational_function(x))):
+            return False, []
+        return True, funcs
+    return False, []
+
+
+def val_at_inf(num, den, x):
+    # Valuation of a rational function at oo = deg(denom) - deg(numer)
+    return den.degree(x) - num.degree(x)
+
+
+def check_necessary_conds(val_inf, muls):
+    """
+    The necessary conditions for a rational solution
+    to exist are as follows -
+
+    i) Every pole of a(x) must be either a simple pole
+    or a multiple pole of even order.
+
+    ii) The valuation of a(x) at infinity must be even
+    or be greater than or equal to 2.
+
+    Here, a simple pole is a pole with multiplicity 1
+    and a multiple pole is a pole with multiplicity
+    greater than 1.
+    """
+    return (val_inf >= 2 or (val_inf <= 0 and val_inf%2 == 0)) and \
+        all(mul == 1 or (mul%2 == 0 and mul >= 2) for mul in muls)
+
+
+def inverse_transform_poly(num, den, x):
+    """
+    A function to make the substitution
+    x -> 1/x in a rational function that
+    is represented using Poly objects for
+    numerator and denominator.
+    """
+    # Declare for reuse
+    one = Poly(1, x)
+    xpoly = Poly(x, x)
+
+    # Check if degree of numerator is same as denominator
+    pwr = val_at_inf(num, den, x)
+    if pwr >= 0:
+        # Denominator has greater degree. Substituting x with
+        # 1/x would make the extra power go to the numerator
+        if num.expr != 0:
+            num = num.transform(one, xpoly) * x**pwr
+            den = den.transform(one, xpoly)
+    else:
+        # Numerator has greater degree. Substituting x with
+        # 1/x would make the extra power go to the denominator
+        num = num.transform(one, xpoly)
+        den = den.transform(one, xpoly) * x**(-pwr)
+    return num.cancel(den, include=True)
+
+
+def limit_at_inf(num, den, x):
+    """
+    Find the limit of a rational function
+    at oo
+    """
+    # pwr = degree(num) - degree(den)
+    pwr = -val_at_inf(num, den, x)
+    # Numerator has a greater degree than denominator
+    # Limit at infinity would depend on the sign of the
+    # leading coefficients of numerator and denominator
+    if pwr > 0:
+        return oo*sign(num.LC()/den.LC())
+    # Degree of numerator is equal to that of denominator
+    # Limit at infinity is just the ratio of leading coeffs
+    elif pwr == 0:
+        return num.LC()/den.LC()
+    # Degree of numerator is less than that of denominator
+    # Limit at infinity is just 0
+    else:
+        return 0
+
+
+def construct_c_case_1(num, den, x, pole):
+    # Find the coefficient of 1/(x - pole)**2 in the
+    # Laurent series expansion of a(x) about pole.
+    num1, den1 = (num*Poly((x - pole)**2, x, extension=True)).cancel(den, include=True)
+    r = (num1.subs(x, pole))/(den1.subs(x, pole))
+
+    # If multiplicity is 2, the coefficient to be added
+    # in the c-vector is c = (1 +- sqrt(1 + 4*r))/2
+    if r != -S(1)/4:
+        return [[(1 + sqrt(1 + 4*r))/2], [(1 - sqrt(1 + 4*r))/2]]
+    return [[S.Half]]
+
+
+def construct_c_case_2(num, den, x, pole, mul):
+    # Generate the coefficients using the recurrence
+    # relation mentioned in (5.14) in the thesis (Pg 80)
+
+    # r_i = mul/2
+    ri = mul//2
+
+    # Find the Laurent series coefficients about the pole
+    ser = rational_laurent_series(num, den, x, pole, mul, 6)
+
+    # Start with an empty memo to store the coefficients
+    # This is for the plus case
+    cplus = [0 for i in range(ri)]
+
+    # Base Case
+    cplus[ri-1] = sqrt(ser[2*ri])
+
+    # Iterate backwards to find all coefficients
+    s = ri - 1
+    sm = 0
+    for s in range(ri-1, 0, -1):
+        sm = 0
+        for j in range(s+1, ri):
+            sm += cplus[j-1]*cplus[ri+s-j-1]
+        if s!= 1:
+            cplus[s-1] = (ser[ri+s] - sm)/(2*cplus[ri-1])
+
+    # Memo for the minus case
+    cminus = [-x for x in cplus]
+
+    # Find the 0th coefficient in the recurrence
+    cplus[0] = (ser[ri+s] - sm - ri*cplus[ri-1])/(2*cplus[ri-1])
+    cminus[0] = (ser[ri+s] - sm  - ri*cminus[ri-1])/(2*cminus[ri-1])
+
+    # Add both the plus and minus cases' coefficients
+    if cplus != cminus:
+        return [cplus, cminus]
+    return cplus
+
+
+def construct_c_case_3():
+    # If multiplicity is 1, the coefficient to be added
+    # in the c-vector is 1 (no choice)
+    return [[1]]
+
+
+def construct_c(num, den, x, poles, muls):
+    """
+    Helper function to calculate the coefficients
+    in the c-vector for each pole.
+    """
+    c = []
+    for pole, mul in zip(poles, muls):
+        c.append([])
+
+        # Case 3
+        if mul == 1:
+            # Add the coefficients from Case 3
+            c[-1].extend(construct_c_case_3())
+
+        # Case 1
+        elif mul == 2:
+            # Add the coefficients from Case 1
+            c[-1].extend(construct_c_case_1(num, den, x, pole))
+
+        # Case 2
+        else:
+            # Add the coefficients from Case 2
+            c[-1].extend(construct_c_case_2(num, den, x, pole, mul))
+
+    return c
+
+
+def construct_d_case_4(ser, N):
+    # Initialize an empty vector
+    dplus = [0 for i in range(N+2)]
+    # d_N = sqrt(a_{2*N})
+    dplus[N] = sqrt(ser[2*N])
+
+    # Use the recurrence relations to find
+    # the value of d_s
+    for s in range(N-1, -2, -1):
+        sm = 0
+        for j in range(s+1, N):
+            sm += dplus[j]*dplus[N+s-j]
+        if s != -1:
+            dplus[s] = (ser[N+s] - sm)/(2*dplus[N])
+
+    # Coefficients for the case of d_N = -sqrt(a_{2*N})
+    dminus = [-x for x in dplus]
+
+    # The third equation in Eq 5.15 of the thesis is WRONG!
+    # d_N must be replaced with N*d_N in that equation.
+    dplus[-1] = (ser[N+s] - N*dplus[N] - sm)/(2*dplus[N])
+    dminus[-1] = (ser[N+s] - N*dminus[N] - sm)/(2*dminus[N])
+
+    if dplus != dminus:
+        return [dplus, dminus]
+    return dplus
+
+
+def construct_d_case_5(ser):
+    # List to store coefficients for plus case
+    dplus = [0, 0]
+
+    # d_0  = sqrt(a_0)
+    dplus[0] = sqrt(ser[0])
+
+    # d_(-1) = a_(-1)/(2*d_0)
+    dplus[-1] = ser[-1]/(2*dplus[0])
+
+    # Coefficients for the minus case are just the negative
+    # of the coefficients for the positive case.
+    dminus = [-x for x in dplus]
+
+    if dplus != dminus:
+        return [dplus, dminus]
+    return dplus
+
+
+def construct_d_case_6(num, den, x):
+    # s_oo = lim x->0 1/x**2 * a(1/x) which is equivalent to
+    # s_oo = lim x->oo x**2 * a(x)
+    s_inf = limit_at_inf(Poly(x**2, x)*num, den, x)
+
+    # d_(-1) = (1 +- sqrt(1 + 4*s_oo))/2
+    if s_inf != -S(1)/4:
+        return [[(1 + sqrt(1 + 4*s_inf))/2], [(1 - sqrt(1 + 4*s_inf))/2]]
+    return [[S.Half]]
+
+
+def construct_d(num, den, x, val_inf):
+    """
+    Helper function to calculate the coefficients
+    in the d-vector based on the valuation of the
+    function at oo.
+    """
+    N = -val_inf//2
+    # Multiplicity of oo as a pole
+    mul = -val_inf if val_inf < 0 else 0
+    ser = rational_laurent_series(num, den, x, oo, mul, 1)
+
+    # Case 4
+    if val_inf < 0:
+        d = construct_d_case_4(ser, N)
+
+    # Case 5
+    elif val_inf == 0:
+        d = construct_d_case_5(ser)
+
+    # Case 6
+    else:
+        d = construct_d_case_6(num, den, x)
+
+    return d
+
+
+def rational_laurent_series(num, den, x, r, m, n):
+    r"""
+    The function computes the Laurent series coefficients
+    of a rational function.
+
+    Parameters
+    ==========
+
+    num: A Poly object that is the numerator of `f(x)`.
+    den: A Poly object that is the denominator of `f(x)`.
+    x: The variable of expansion of the series.
+    r: The point of expansion of the series.
+    m: Multiplicity of r if r is a pole of `f(x)`. Should
+    be zero otherwise.
+    n: Order of the term upto which the series is expanded.
+
+    Returns
+    =======
+
+    series: A dictionary that has power of the term as key
+    and coefficient of that term as value.
+
+    Below is a basic outline of how the Laurent series of a
+    rational function `f(x)` about `x_0` is being calculated -
+
+    1. Substitute `x + x_0` in place of `x`. If `x_0`
+    is a pole of `f(x)`, multiply the expression by `x^m`
+    where `m` is the multiplicity of `x_0`. Denote the
+    the resulting expression as g(x). We do this substitution
+    so that we can now find the Laurent series of g(x) about
+    `x = 0`.
+
+    2. We can then assume that the Laurent series of `g(x)`
+    takes the following form -
+
+    .. math:: g(x) = \frac{num(x)}{den(x)} = \sum_{m = 0}^{\infty} a_m x^m
+
+    where `a_m` denotes the Laurent series coefficients.
+
+    3. Multiply the denominator to the RHS of the equation
+    and form a recurrence relation for the coefficients `a_m`.
+    """
+    one = Poly(1, x, extension=True)
+
+    if r == oo:
+        # Series at x = oo is equal to first transforming
+        # the function from x -> 1/x and finding the
+        # series at x = 0
+        num, den = inverse_transform_poly(num, den, x)
+        r = S(0)
+
+    if r:
+        # For an expansion about a non-zero point, a
+        # transformation from x -> x + r must be made
+        num = num.transform(Poly(x + r, x, extension=True), one)
+        den = den.transform(Poly(x + r, x, extension=True), one)
+
+    # Remove the pole from the denominator if the series
+    # expansion is about one of the poles
+    num, den = (num*x**m).cancel(den, include=True)
+
+    # Equate coefficients for the first terms (base case)
+    maxdegree = 1 + max(num.degree(), den.degree())
+    syms = symbols(f'a:{maxdegree}', cls=Dummy)
+    diff = num - den * Poly(syms[::-1], x)
+    coeff_diffs = diff.all_coeffs()[::-1][:maxdegree]
+    (coeffs, ) = linsolve(coeff_diffs, syms)
+
+    # Use the recursion relation for the rest
+    recursion = den.all_coeffs()[::-1]
+    div, rec_rhs = recursion[0], recursion[1:]
+    series = list(coeffs)
+    while len(series) < n:
+        next_coeff = Add(*(c*series[-1-n] for n, c in enumerate(rec_rhs))) / div
+        series.append(-next_coeff)
+    series = {m - i: val for i, val in enumerate(series)}
+    return series
+
+def compute_m_ybar(x, poles, choice, N):
+    """
+    Helper function to calculate -
+
+    1. m - The degree bound for the polynomial
+    solution that must be found for the auxiliary
+    differential equation.
+
+    2. ybar - Part of the solution which can be
+    computed using the poles, c and d vectors.
+    """
+    ybar = 0
+    m = Poly(choice[-1][-1], x, extension=True)
+
+    # Calculate the first (nested) summation for ybar
+    # as given in Step 9 of the Thesis (Pg 82)
+    dybar = []
+    for i, polei in enumerate(poles):
+        for j, cij in enumerate(choice[i]):
+            dybar.append(cij/(x - polei)**(j + 1))
+        m -=Poly(choice[i][0], x, extension=True)  # can't accumulate Poly and use with Add
+    ybar += Add(*dybar)
+
+    # Calculate the second summation for ybar
+    for i in range(N+1):
+        ybar += choice[-1][i]*x**i
+    return (m.expr, ybar)
+
+
+def solve_aux_eq(numa, dena, numy, deny, x, m):
+    """
+    Helper function to find a polynomial solution
+    of degree m for the auxiliary differential
+    equation.
+    """
+    # Assume that the solution is of the type
+    # p(x) = C_0 + C_1*x + ... + C_{m-1}*x**(m-1) + x**m
+    psyms = symbols(f'C0:{m}', cls=Dummy)
+    K = ZZ[psyms]
+    psol = Poly(K.gens, x, domain=K) + Poly(x**m, x, domain=K)
+
+    # Eq (5.16) in Thesis - Pg 81
+    auxeq = (dena*(numy.diff(x)*deny - numy*deny.diff(x) + numy**2) - numa*deny**2)*psol
+    if m >= 1:
+        px = psol.diff(x)
+        auxeq += px*(2*numy*deny*dena)
+    if m >= 2:
+        auxeq += px.diff(x)*(deny**2*dena)
+    if m != 0:
+        # m is a non-zero integer. Find the constant terms using undetermined coefficients
+        return psol, linsolve_dict(auxeq.all_coeffs(), psyms), True
+    else:
+        # m == 0 . Check if 1 (x**0) is a solution to the auxiliary equation
+        return S.One, auxeq, auxeq == 0
+
+
+def remove_redundant_sols(sol1, sol2, x):
+    """
+    Helper function to remove redundant
+    solutions to the differential equation.
+    """
+    # If y1 and y2 are redundant solutions, there is
+    # some value of the arbitrary constant for which
+    # they will be equal
+
+    syms1 = sol1.atoms(Symbol, Dummy)
+    syms2 = sol2.atoms(Symbol, Dummy)
+    num1, den1 = [Poly(e, x, extension=True) for e in sol1.together().as_numer_denom()]
+    num2, den2 = [Poly(e, x, extension=True) for e in sol2.together().as_numer_denom()]
+    # Cross multiply
+    e = num1*den2 - den1*num2
+    # Check if there are any constants
+    syms = list(e.atoms(Symbol, Dummy))
+    if len(syms):
+        # Find values of constants for which solutions are equal
+        redn = linsolve(e.all_coeffs(), syms)
+        if len(redn):
+            # Return the general solution over a particular solution
+            if len(syms1) > len(syms2):
+                return sol2
+            # If both have constants, return the lesser complex solution
+            elif len(syms1) == len(syms2):
+                return sol1 if count_ops(syms1) >= count_ops(syms2) else sol2
+            else:
+                return sol1
+
+
+def get_gen_sol_from_part_sol(part_sols, a, x):
+    """"
+    Helper function which computes the general
+    solution for a Riccati ODE from its particular
+    solutions.
+
+    There are 3 cases to find the general solution
+    from the particular solutions for a Riccati ODE
+    depending on the number of particular solution(s)
+    we have - 1, 2 or 3.
+
+    For more information, see Section 6 of
+    "Methods of Solution of the Riccati Differential Equation"
+    by D. R. Haaheim and F. M. Stein
+    """
+
+    # If no particular solutions are found, a general
+    # solution cannot be found
+    if len(part_sols) == 0:
+        return []
+
+    # In case of a single particular solution, the general
+    # solution can be found by using the substitution
+    # y = y1 + 1/z and solving a Bernoulli ODE to find z.
+    elif len(part_sols) == 1:
+        y1 = part_sols[0]
+        i = exp(Integral(2*y1, x))
+        z = i * Integral(a/i, x)
+        z = z.doit()
+        if a == 0 or z == 0:
+            return y1
+        return y1 + 1/z
+
+    # In case of 2 particular solutions, the general solution
+    # can be found by solving a separable equation. This is
+    # the most common case, i.e. most Riccati ODEs have 2
+    # rational particular solutions.
+    elif len(part_sols) == 2:
+        y1, y2 = part_sols
+        # One of them already has a constant
+        if len(y1.atoms(Dummy)) + len(y2.atoms(Dummy)) > 0:
+            u = exp(Integral(y2 - y1, x)).doit()
+        # Introduce a constant
+        else:
+            C1 = Dummy('C1')
+            u = C1*exp(Integral(y2 - y1, x)).doit()
+        if u == 1:
+            return y2
+        return (y2*u - y1)/(u - 1)
+
+    # In case of 3 particular solutions, a closed form
+    # of the general solution can be obtained directly
+    else:
+        y1, y2, y3 = part_sols[:3]
+        C1 = Dummy('C1')
+        return (C1 + 1)*y2*(y1 - y3)/(C1*y1 + y2 - (C1 + 1)*y3)
+
+
+def solve_riccati(fx, x, b0, b1, b2, gensol=False):
+    """
+    The main function that gives particular/general
+    solutions to Riccati ODEs that have atleast 1
+    rational particular solution.
+    """
+    # Step 1 : Convert to Normal Form
+    a = -b0*b2 + b1**2/4 - b1.diff(x)/2 + 3*b2.diff(x)**2/(4*b2**2) + b1*b2.diff(x)/(2*b2) - \
+        b2.diff(x, 2)/(2*b2)
+    a_t = a.together()
+    num, den = [Poly(e, x, extension=True) for e in a_t.as_numer_denom()]
+    num, den = num.cancel(den, include=True)
+
+    # Step 2
+    presol = []
+
+    # Step 3 : a(x) is 0
+    if num == 0:
+        presol.append(1/(x + Dummy('C1')))
+
+    # Step 4 : a(x) is a non-zero constant
+    elif x not in num.free_symbols.union(den.free_symbols):
+        presol.extend([sqrt(a), -sqrt(a)])
+
+    # Step 5 : Find poles and valuation at infinity
+    poles = roots(den, x)
+    poles, muls = list(poles.keys()), list(poles.values())
+    val_inf = val_at_inf(num, den, x)
+
+    if len(poles):
+        # Check necessary conditions (outlined in the module docstring)
+        if not check_necessary_conds(val_inf, muls):
+            raise ValueError("Rational Solution doesn't exist")
+
+        # Step 6
+        # Construct c-vectors for each singular point
+        c = construct_c(num, den, x, poles, muls)
+
+        # Construct d vectors for each singular point
+        d = construct_d(num, den, x, val_inf)
+
+        # Step 7 : Iterate over all possible combinations and return solutions
+        # For each possible combination, generate an array of 0's and 1's
+        # where 0 means pick 1st choice and 1 means pick the second choice.
+
+        # NOTE: We could exit from the loop if we find 3 particular solutions,
+        # but it is not implemented here as -
+        #   a. Finding 3 particular solutions is very rare. Most of the time,
+        #      only 2 particular solutions are found.
+        #   b. In case we exit after finding 3 particular solutions, it might
+        #      happen that 1 or 2 of them are redundant solutions. So, instead of
+        #      spending some more time in computing the particular solutions,
+        #      we will end up computing the general solution from a single
+        #      particular solution which is usually slower than computing the
+        #      general solution from 2 or 3 particular solutions.
+        c.append(d)
+        choices = product(*c)
+        for choice in choices:
+            m, ybar = compute_m_ybar(x, poles, choice, -val_inf//2)
+            numy, deny = [Poly(e, x, extension=True) for e in ybar.together().as_numer_denom()]
+            # Step 10 : Check if a valid solution exists. If yes, also check
+            # if m is a non-negative integer
+            if m.is_nonnegative == True and m.is_integer == True:
+
+                # Step 11 : Find polynomial solutions of degree m for the auxiliary equation
+                psol, coeffs, exists = solve_aux_eq(num, den, numy, deny, x, m)
+
+                # Step 12 : If valid polynomial solution exists, append solution.
+                if exists:
+                    # m == 0 case
+                    if psol == 1 and coeffs == 0:
+                        # p(x) = 1, so p'(x)/p(x) term need not be added
+                        presol.append(ybar)
+                    # m is a positive integer and there are valid coefficients
+                    elif len(coeffs):
+                        # Substitute the valid coefficients to get p(x)
+                        psol = psol.xreplace(coeffs)
+                        # y(x) = ybar(x) + p'(x)/p(x)
+                        presol.append(ybar + psol.diff(x)/psol)
+
+    # Remove redundant solutions from the list of existing solutions
+    remove = set()
+    for i in range(len(presol)):
+        for j in range(i+1, len(presol)):
+            rem = remove_redundant_sols(presol[i], presol[j], x)
+            if rem is not None:
+                remove.add(rem)
+    sols = [x for x in presol if x not in remove]
+
+    # Step 15 : Inverse transform the solutions of the equation in normal form
+    bp = -b2.diff(x)/(2*b2**2) - b1/(2*b2)
+
+    # If general solution is required, compute it from the particular solutions
+    if gensol:
+        sols = [get_gen_sol_from_part_sol(sols, a, x)]
+
+    # Inverse transform the particular solutions
+    presol = [Eq(fx, riccati_inverse_normal(y, x, b1, b2, bp).cancel(extension=True)) for y in sols]
+    return presol
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/ode/single.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/ode/single.py
new file mode 100644
index 0000000000000000000000000000000000000000..c4829acf41293c2f6f20af3e9c45d37457802102
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/ode/single.py
@@ -0,0 +1,2977 @@
+#
+# This is the module for ODE solver classes for single ODEs.
+#
+
+from __future__ import annotations
+from typing import ClassVar, Iterator
+
+from .riccati import match_riccati, solve_riccati
+from sympy.core import Add, S, Pow, Rational
+from sympy.core.cache import cached_property
+from sympy.core.exprtools import factor_terms
+from sympy.core.expr import Expr
+from sympy.core.function import AppliedUndef, Derivative, diff, Function, expand, Subs, _mexpand
+from sympy.core.numbers import zoo
+from sympy.core.relational import Equality, Eq
+from sympy.core.symbol import Symbol, Dummy, Wild
+from sympy.core.mul import Mul
+from sympy.functions import exp, tan, log, sqrt, besselj, bessely, cbrt, airyai, airybi
+from sympy.integrals import Integral
+from sympy.polys import Poly
+from sympy.polys.polytools import cancel, factor, degree
+from sympy.simplify import collect, simplify, separatevars, logcombine, posify # type: ignore
+from sympy.simplify.radsimp import fraction
+from sympy.utilities import numbered_symbols
+from sympy.solvers.solvers import solve
+from sympy.solvers.deutils import ode_order, _preprocess
+from sympy.polys.matrices.linsolve import _lin_eq2dict
+from sympy.polys.solvers import PolyNonlinearError
+from .hypergeometric import equivalence_hypergeometric, match_2nd_2F1_hypergeometric, \
+    get_sol_2F1_hypergeometric, match_2nd_hypergeometric
+from .nonhomogeneous import _get_euler_characteristic_eq_sols, _get_const_characteristic_eq_sols, \
+    _solve_undetermined_coefficients, _solve_variation_of_parameters, _test_term, _undetermined_coefficients_match, \
+        _get_simplified_sol
+from .lie_group import _ode_lie_group
+
+
+class ODEMatchError(NotImplementedError):
+    """Raised if a SingleODESolver is asked to solve an ODE it does not match"""
+    pass
+
+
+class SingleODEProblem:
+    """Represents an ordinary differential equation (ODE)
+
+    This class is used internally in the by dsolve and related
+    functions/classes so that properties of an ODE can be computed
+    efficiently.
+
+    Examples
+    ========
+
+    This class is used internally by dsolve. To instantiate an instance
+    directly first define an ODE problem:
+
+    >>> from sympy import Function, Symbol
+    >>> x = Symbol('x')
+    >>> f = Function('f')
+    >>> eq = f(x).diff(x, 2)
+
+    Now you can create a SingleODEProblem instance and query its properties:
+
+    >>> from sympy.solvers.ode.single import SingleODEProblem
+    >>> problem = SingleODEProblem(f(x).diff(x), f(x), x)
+    >>> problem.eq
+    Derivative(f(x), x)
+    >>> problem.func
+    f(x)
+    >>> problem.sym
+    x
+    """
+
+    # Instance attributes:
+    eq: Expr
+    func: AppliedUndef
+    sym: Symbol
+    _order: int
+    _eq_expanded: Expr
+    _eq_preprocessed: Expr
+    _eq_high_order_free = None
+
+    def __init__(self, eq, func, sym, prep=True, **kwargs):
+        assert isinstance(eq, Expr)
+        assert isinstance(func, AppliedUndef)
+        assert isinstance(sym, Symbol)
+        assert isinstance(prep, bool)
+        self.eq = eq
+        self.func = func
+        self.sym = sym
+        self.prep = prep
+        self.params = kwargs
+
+    @cached_property
+    def order(self) -> int:
+        return ode_order(self.eq, self.func)
+
+    @cached_property
+    def eq_preprocessed(self) -> Expr:
+        return self._get_eq_preprocessed()
+
+    @cached_property
+    def eq_high_order_free(self) -> Expr:
+        a = Wild('a', exclude=[self.func])
+        c1 = Wild('c1', exclude=[self.sym])
+        # Precondition to try remove f(x) from highest order derivative
+        reduced_eq = None
+        if self.eq.is_Add:
+            deriv_coef = self.eq.coeff(self.func.diff(self.sym, self.order))
+            if deriv_coef not in (1, 0):
+                r = deriv_coef.match(a*self.func**c1)
+                if r and r[c1]:
+                    den = self.func**r[c1]
+                    reduced_eq = Add(*[arg/den for arg in self.eq.args])
+        if reduced_eq is None:
+            reduced_eq = expand(self.eq)
+        return reduced_eq
+
+    @cached_property
+    def eq_expanded(self) -> Expr:
+        return expand(self.eq_preprocessed)
+
+    def _get_eq_preprocessed(self) -> Expr:
+        if self.prep:
+            process_eq, process_func = _preprocess(self.eq, self.func)
+            if process_func != self.func:
+                raise ValueError
+        else:
+            process_eq = self.eq
+        return process_eq
+
+    def get_numbered_constants(self, num=1, start=1, prefix='C') -> list[Symbol]:
+        """
+        Returns a list of constants that do not occur
+        in eq already.
+        """
+        ncs = self.iter_numbered_constants(start, prefix)
+        Cs = [next(ncs) for i in range(num)]
+        return Cs
+
+    def iter_numbered_constants(self, start=1, prefix='C') -> Iterator[Symbol]:
+        """
+        Returns an iterator of constants that do not occur
+        in eq already.
+        """
+        atom_set = self.eq.free_symbols
+        func_set = self.eq.atoms(Function)
+        if func_set:
+            atom_set |= {Symbol(str(f.func)) for f in func_set}
+        return numbered_symbols(start=start, prefix=prefix, exclude=atom_set)
+
+    @cached_property
+    def is_autonomous(self):
+        u = Dummy('u')
+        x = self.sym
+        syms = self.eq.subs(self.func, u).free_symbols
+        return x not in syms
+
+    def get_linear_coefficients(self, eq, func, order):
+        r"""
+        Matches a differential equation to the linear form:
+
+        .. math:: a_n(x) y^{(n)} + \cdots + a_1(x)y' + a_0(x) y + B(x) = 0
+
+        Returns a dict of order:coeff terms, where order is the order of the
+        derivative on each term, and coeff is the coefficient of that derivative.
+        The key ``-1`` holds the function `B(x)`. Returns ``None`` if the ODE is
+        not linear.  This function assumes that ``func`` has already been checked
+        to be good.
+
+        Examples
+        ========
+
+        >>> from sympy import Function, cos, sin
+        >>> from sympy.abc import x
+        >>> from sympy.solvers.ode.single import SingleODEProblem
+        >>> f = Function('f')
+        >>> eq = f(x).diff(x, 3) + 2*f(x).diff(x) + \
+        ... x*f(x).diff(x, 2) + cos(x)*f(x).diff(x) + x - f(x) - \
+        ... sin(x)
+        >>> obj = SingleODEProblem(eq, f(x), x)
+        >>> obj.get_linear_coefficients(eq, f(x), 3)
+        {-1: x - sin(x), 0: -1, 1: cos(x) + 2, 2: x, 3: 1}
+        >>> eq = f(x).diff(x, 3) + 2*f(x).diff(x) + \
+        ... x*f(x).diff(x, 2) + cos(x)*f(x).diff(x) + x - f(x) - \
+        ... sin(f(x))
+        >>> obj = SingleODEProblem(eq, f(x), x)
+        >>> obj.get_linear_coefficients(eq, f(x), 3) == None
+        True
+
+        """
+        f = func.func
+        x = func.args[0]
+        symset = {Derivative(f(x), x, i) for i in range(order+1)}
+        try:
+            rhs, lhs_terms = _lin_eq2dict(eq, symset)
+        except PolyNonlinearError:
+            return None
+
+        if rhs.has(func) or any(c.has(func) for c in lhs_terms.values()):
+            return None
+        terms = {i: lhs_terms.get(f(x).diff(x, i), S.Zero) for i in range(order+1)}
+        terms[-1] = rhs
+        return terms
+
+    # TODO: Add methods that can be used by many ODE solvers:
+    # order
+    # is_linear()
+    # get_linear_coefficients()
+    # eq_prepared (the ODE in prepared form)
+
+
+class SingleODESolver:
+    """
+    Base class for Single ODE solvers.
+
+    Subclasses should implement the _matches and _get_general_solution
+    methods. This class is not intended to be instantiated directly but its
+    subclasses are as part of dsolve.
+
+    Examples
+    ========
+
+    You can use a subclass of SingleODEProblem to solve a particular type of
+    ODE. We first define a particular ODE problem:
+
+    >>> from sympy import Function, Symbol
+    >>> x = Symbol('x')
+    >>> f = Function('f')
+    >>> eq = f(x).diff(x, 2)
+
+    Now we solve this problem using the NthAlgebraic solver which is a
+    subclass of SingleODESolver:
+
+    >>> from sympy.solvers.ode.single import NthAlgebraic, SingleODEProblem
+    >>> problem = SingleODEProblem(eq, f(x), x)
+    >>> solver = NthAlgebraic(problem)
+    >>> solver.get_general_solution()
+    [Eq(f(x), _C*x + _C)]
+
+    The normal way to solve an ODE is to use dsolve (which would use
+    NthAlgebraic and other solvers internally). When using dsolve a number of
+    other things are done such as evaluating integrals, simplifying the
+    solution and renumbering the constants:
+
+    >>> from sympy import dsolve
+    >>> dsolve(eq, hint='nth_algebraic')
+    Eq(f(x), C1 + C2*x)
+    """
+
+    # Subclasses should store the hint name (the argument to dsolve) in this
+    # attribute
+    hint: ClassVar[str]
+
+    # Subclasses should define this to indicate if they support an _Integral
+    # hint.
+    has_integral: ClassVar[bool]
+
+    # The ODE to be solved
+    ode_problem: SingleODEProblem
+
+    # Cache whether or not the equation has matched the method
+    _matched: bool | None = None
+
+    # Subclasses should store in this attribute the list of order(s) of ODE
+    # that subclass can solve or leave it to None if not specific to any order
+    order: list | None = None
+
+    def __init__(self, ode_problem):
+        self.ode_problem = ode_problem
+
+    def matches(self) -> bool:
+        if self.order is not None and self.ode_problem.order not in self.order:
+            self._matched = False
+            return self._matched
+
+        if self._matched is None:
+            self._matched = self._matches()
+        return self._matched
+
+    def get_general_solution(self, *, simplify: bool = True) -> list[Equality]:
+        if not self.matches():
+            msg = "%s solver cannot solve:\n%s"
+            raise ODEMatchError(msg % (self.hint, self.ode_problem.eq))
+        return self._get_general_solution(simplify_flag=simplify)
+
+    def _matches(self) -> bool:
+        msg = "Subclasses of SingleODESolver should implement matches."
+        raise NotImplementedError(msg)
+
+    def _get_general_solution(self, *, simplify_flag: bool = True) -> list[Equality]:
+        msg = "Subclasses of SingleODESolver should implement get_general_solution."
+        raise NotImplementedError(msg)
+
+
+class SinglePatternODESolver(SingleODESolver):
+    '''Superclass for ODE solvers based on pattern matching'''
+
+    def wilds(self):
+        prob = self.ode_problem
+        f = prob.func.func
+        x = prob.sym
+        order = prob.order
+        return self._wilds(f, x, order)
+
+    def wilds_match(self):
+        match = self._wilds_match
+        return [match.get(w, S.Zero) for w in self.wilds()]
+
+    def _matches(self):
+        eq = self.ode_problem.eq_expanded
+        f = self.ode_problem.func.func
+        x = self.ode_problem.sym
+        order = self.ode_problem.order
+        df = f(x).diff(x, order)
+
+        if order not in [1, 2]:
+            return False
+
+        pattern = self._equation(f(x), x, order)
+
+        if not pattern.coeff(df).has(Wild):
+            eq = expand(eq / eq.coeff(df))
+        eq = eq.collect([f(x).diff(x), f(x)], func = cancel)
+
+        self._wilds_match = match = eq.match(pattern)
+        if match is not None:
+            return self._verify(f(x))
+        return False
+
+    def _verify(self, fx) -> bool:
+        return True
+
+    def _wilds(self, f, x, order):
+        msg = "Subclasses of SingleODESolver should implement _wilds"
+        raise NotImplementedError(msg)
+
+    def _equation(self, fx, x, order):
+        msg = "Subclasses of SingleODESolver should implement _equation"
+        raise NotImplementedError(msg)
+
+
+class NthAlgebraic(SingleODESolver):
+    r"""
+    Solves an `n`\th order ordinary differential equation using algebra and
+    integrals.
+
+    There is no general form for the kind of equation that this can solve. The
+    the equation is solved algebraically treating differentiation as an
+    invertible algebraic function.
+
+    Examples
+    ========
+
+    >>> from sympy import Function, dsolve, Eq
+    >>> from sympy.abc import x
+    >>> f = Function('f')
+    >>> eq = Eq(f(x) * (f(x).diff(x)**2 - 1), 0)
+    >>> dsolve(eq, f(x), hint='nth_algebraic')
+    [Eq(f(x), 0), Eq(f(x), C1 - x), Eq(f(x), C1 + x)]
+
+    Note that this solver can return algebraic solutions that do not have any
+    integration constants (f(x) = 0 in the above example).
+    """
+
+    hint = 'nth_algebraic'
+    has_integral = True  # nth_algebraic_Integral hint
+
+    def _matches(self):
+        r"""
+        Matches any differential equation that nth_algebraic can solve. Uses
+        `sympy.solve` but teaches it how to integrate derivatives.
+
+        This involves calling `sympy.solve` and does most of the work of finding a
+        solution (apart from evaluating the integrals).
+        """
+        eq = self.ode_problem.eq
+        func = self.ode_problem.func
+        var = self.ode_problem.sym
+
+        # Derivative that solve can handle:
+        diffx = self._get_diffx(var)
+
+        # Replace derivatives wrt the independent variable with diffx
+        def replace(eq, var):
+            def expand_diffx(*args):
+                differand, diffs = args[0], args[1:]
+                toreplace = differand
+                for v, n in diffs:
+                    for _ in range(n):
+                        if v == var:
+                            toreplace = diffx(toreplace)
+                        else:
+                            toreplace = Derivative(toreplace, v)
+                return toreplace
+            return eq.replace(Derivative, expand_diffx)
+
+        # Restore derivatives in solution afterwards
+        def unreplace(eq, var):
+            return eq.replace(diffx, lambda e: Derivative(e, var))
+
+        subs_eqn = replace(eq, var)
+        try:
+            # turn off simplification to protect Integrals that have
+            # _t instead of fx in them and would otherwise factor
+            # as t_*Integral(1, x)
+            solns = solve(subs_eqn, func, simplify=False)
+        except NotImplementedError:
+            solns = []
+
+        solns = [simplify(unreplace(soln, var)) for soln in solns]
+        solns = [Equality(func, soln) for soln in solns]
+
+        self.solutions = solns
+        return len(solns) != 0
+
+    def _get_general_solution(self, *, simplify_flag: bool = True):
+        return self.solutions
+
+    # This needs to produce an invertible function but the inverse depends
+    # which variable we are integrating with respect to. Since the class can
+    # be stored in cached results we need to ensure that we always get the
+    # same class back for each particular integration variable so we store these
+    # classes in a global dict:
+    _diffx_stored: dict[Symbol, type[Function]] = {}
+
+    @staticmethod
+    def _get_diffx(var):
+        diffcls = NthAlgebraic._diffx_stored.get(var, None)
+
+        if diffcls is None:
+            # A class that behaves like Derivative wrt var but is "invertible".
+            class diffx(Function):
+                def inverse(self):
+                    # don't use integrate here because fx has been replaced by _t
+                    # in the equation; integrals will not be correct while solve
+                    # is at work.
+                    return lambda expr: Integral(expr, var) + Dummy('C')
+
+            diffcls = NthAlgebraic._diffx_stored.setdefault(var, diffx)
+
+        return diffcls
+
+
+class FirstExact(SinglePatternODESolver):
+    r"""
+    Solves 1st order exact ordinary differential equations.
+
+    A 1st order differential equation is called exact if it is the total
+    differential of a function. That is, the differential equation
+
+    .. math:: P(x, y) \,\partial{}x + Q(x, y) \,\partial{}y = 0
+
+    is exact if there is some function `F(x, y)` such that `P(x, y) =
+    \partial{}F/\partial{}x` and `Q(x, y) = \partial{}F/\partial{}y`.  It can
+    be shown that a necessary and sufficient condition for a first order ODE
+    to be exact is that `\partial{}P/\partial{}y = \partial{}Q/\partial{}x`.
+    Then, the solution will be as given below::
+
+        >>> from sympy import Function, Eq, Integral, symbols, pprint
+        >>> x, y, t, x0, y0, C1= symbols('x,y,t,x0,y0,C1')
+        >>> P, Q, F= map(Function, ['P', 'Q', 'F'])
+        >>> pprint(Eq(Eq(F(x, y), Integral(P(t, y), (t, x0, x)) +
+        ... Integral(Q(x0, t), (t, y0, y))), C1))
+                    x                y
+                    /                /
+                   |                |
+        F(x, y) =  |  P(t, y) dt +  |  Q(x0, t) dt = C1
+                   |                |
+                  /                /
+                  x0               y0
+
+    Where the first partials of `P` and `Q` exist and are continuous in a
+    simply connected region.
+
+    A note: SymPy currently has no way to represent inert substitution on an
+    expression, so the hint ``1st_exact_Integral`` will return an integral
+    with `dy`.  This is supposed to represent the function that you are
+    solving for.
+
+    Examples
+    ========
+
+    >>> from sympy import Function, dsolve, cos, sin
+    >>> from sympy.abc import x
+    >>> f = Function('f')
+    >>> dsolve(cos(f(x)) - (x*sin(f(x)) - f(x)**2)*f(x).diff(x),
+    ... f(x), hint='1st_exact')
+    Eq(x*cos(f(x)) + f(x)**3/3, C1)
+
+    References
+    ==========
+
+    - https://en.wikipedia.org/wiki/Exact_differential_equation
+    - M. Tenenbaum & H. Pollard, "Ordinary Differential Equations",
+      Dover 1963, pp. 73
+
+    # indirect doctest
+
+    """
+    hint = "1st_exact"
+    has_integral = True
+    order = [1]
+
+    def _wilds(self, f, x, order):
+        P = Wild('P', exclude=[f(x).diff(x)])
+        Q = Wild('Q', exclude=[f(x).diff(x)])
+        return P, Q
+
+    def _equation(self, fx, x, order):
+        P, Q = self.wilds()
+        return P + Q*fx.diff(x)
+
+    def _verify(self, fx) -> bool:
+        P, Q = self.wilds()
+        x = self.ode_problem.sym
+        y = Dummy('y')
+
+        m, n = self.wilds_match()
+
+        m = m.subs(fx, y)
+        n = n.subs(fx, y)
+        numerator = cancel(m.diff(y) - n.diff(x))
+
+        if numerator.is_zero:
+            # Is exact
+            return True
+        else:
+            # The following few conditions try to convert a non-exact
+            # differential equation into an exact one.
+            # References:
+            # 1. Differential equations with applications
+            # and historical notes - George E. Simmons
+            # 2. https://math.okstate.edu/people/binegar/2233-S99/2233-l12.pdf
+
+            factor_n = cancel(numerator/n)
+            factor_m = cancel(-numerator/m)
+            if y not in factor_n.free_symbols:
+                # If (dP/dy - dQ/dx) / Q = f(x)
+                # then exp(integral(f(x))*equation becomes exact
+                factor = factor_n
+                integration_variable = x
+            elif x not in factor_m.free_symbols:
+                # If (dP/dy - dQ/dx) / -P = f(y)
+                # then exp(integral(f(y))*equation becomes exact
+                factor = factor_m
+                integration_variable = y
+            else:
+                # Couldn't convert to exact
+                return False
+
+            factor = exp(Integral(factor, integration_variable))
+            m *= factor
+            n *= factor
+            self._wilds_match[P] = m.subs(y, fx)
+            self._wilds_match[Q] = n.subs(y, fx)
+            return True
+
+    def _get_general_solution(self, *, simplify_flag: bool = True):
+        m, n = self.wilds_match()
+        fx = self.ode_problem.func
+        x = self.ode_problem.sym
+        (C1,) = self.ode_problem.get_numbered_constants(num=1)
+        y = Dummy('y')
+
+        m = m.subs(fx, y)
+        n = n.subs(fx, y)
+
+        gen_sol = Eq(Subs(Integral(m, x)
+                          + Integral(n - Integral(m, x).diff(y), y), y, fx), C1)
+        return [gen_sol]
+
+
+class FirstLinear(SinglePatternODESolver):
+    r"""
+    Solves 1st order linear differential equations.
+
+    These are differential equations of the form
+
+    .. math:: dy/dx + P(x) y = Q(x)\text{.}
+
+    These kinds of differential equations can be solved in a general way.  The
+    integrating factor `e^{\int P(x) \,dx}` will turn the equation into a
+    separable equation.  The general solution is::
+
+        >>> from sympy import Function, dsolve, Eq, pprint, diff, sin
+        >>> from sympy.abc import x
+        >>> f, P, Q = map(Function, ['f', 'P', 'Q'])
+        >>> genform = Eq(f(x).diff(x) + P(x)*f(x), Q(x))
+        >>> pprint(genform)
+                    d
+        P(x)*f(x) + --(f(x)) = Q(x)
+                    dx
+        >>> pprint(dsolve(genform, f(x), hint='1st_linear_Integral'))
+                /       /                   \
+                |      |                    |
+                |      |         /          |     /
+                |      |        |           |    |
+                |      |        | P(x) dx   |  - | P(x) dx
+                |      |        |           |    |
+                |      |       /            |   /
+        f(x) = |C1 +  | Q(x)*e           dx|*e
+                |      |                    |
+                \     /                     /
+
+
+    Examples
+    ========
+
+    >>> f = Function('f')
+    >>> pprint(dsolve(Eq(x*diff(f(x), x) - f(x), x**2*sin(x)),
+    ... f(x), '1st_linear'))
+    f(x) = x*(C1 - cos(x))
+
+    References
+    ==========
+
+    - https://en.wikipedia.org/wiki/Linear_differential_equation#First-order_equation_with_variable_coefficients
+    - M. Tenenbaum & H. Pollard, "Ordinary Differential Equations",
+      Dover 1963, pp. 92
+
+    # indirect doctest
+
+    """
+    hint = '1st_linear'
+    has_integral = True
+    order = [1]
+
+    def _wilds(self, f, x, order):
+        P = Wild('P', exclude=[f(x)])
+        Q = Wild('Q', exclude=[f(x), f(x).diff(x)])
+        return P, Q
+
+    def _equation(self, fx, x, order):
+        P, Q = self.wilds()
+        return fx.diff(x) + P*fx - Q
+
+    def _get_general_solution(self, *, simplify_flag: bool = True):
+        P, Q = self.wilds_match()
+        fx = self.ode_problem.func
+        x = self.ode_problem.sym
+        (C1,)  = self.ode_problem.get_numbered_constants(num=1)
+        gensol = Eq(fx, ((C1 + Integral(Q*exp(Integral(P, x)), x))
+            * exp(-Integral(P, x))))
+        return [gensol]
+
+
+class AlmostLinear(SinglePatternODESolver):
+    r"""
+    Solves an almost-linear differential equation.
+
+    The general form of an almost linear differential equation is
+
+    .. math:: a(x) g'(f(x)) f'(x) + b(x) g(f(x)) + c(x)
+
+    Here `f(x)` is the function to be solved for (the dependent variable).
+    The substitution `g(f(x)) = u(x)` leads to a linear differential equation
+    for `u(x)` of the form `a(x) u' + b(x) u + c(x) = 0`. This can be solved
+    for `u(x)` by the `first_linear` hint and then `f(x)` is found by solving
+    `g(f(x)) = u(x)`.
+
+    See Also
+    ========
+    :obj:`sympy.solvers.ode.single.FirstLinear`
+
+    Examples
+    ========
+
+    >>> from sympy import dsolve, Function, pprint, sin, cos
+    >>> from sympy.abc import x
+    >>> f = Function('f')
+    >>> d = f(x).diff(x)
+    >>> eq = x*d + x*f(x) + 1
+    >>> dsolve(eq, f(x), hint='almost_linear')
+    Eq(f(x), (C1 - Ei(x))*exp(-x))
+    >>> pprint(dsolve(eq, f(x), hint='almost_linear'))
+                        -x
+    f(x) = (C1 - Ei(x))*e
+    >>> example = cos(f(x))*f(x).diff(x) + sin(f(x)) + 1
+    >>> pprint(example)
+                        d
+    sin(f(x)) + cos(f(x))*--(f(x)) + 1
+                        dx
+    >>> pprint(dsolve(example, f(x), hint='almost_linear'))
+                    /    -x    \             /    -x    \
+    [f(x) = pi - asin\C1*e   - 1/, f(x) = asin\C1*e   - 1/]
+
+
+    References
+    ==========
+
+    - Joel Moses, "Symbolic Integration - The Stormy Decade", Communications
+      of the ACM, Volume 14, Number 8, August 1971, pp. 558
+    """
+    hint = "almost_linear"
+    has_integral = True
+    order = [1]
+
+    def _wilds(self, f, x, order):
+        P = Wild('P', exclude=[f(x).diff(x)])
+        Q = Wild('Q', exclude=[f(x).diff(x)])
+        return P, Q
+
+    def _equation(self, fx, x, order):
+        P, Q = self.wilds()
+        return P*fx.diff(x) + Q
+
+    def _verify(self, fx):
+        a, b = self.wilds_match()
+        c, b = b.as_independent(fx) if b.is_Add else (S.Zero, b)
+        # a, b and c are the function a(x), b(x) and c(x) respectively.
+        # c(x) is obtained by separating out b as terms with and without fx i.e, l(y)
+        # The following conditions checks if the given equation is an almost-linear differential equation using the fact that
+        # a(x)*(l(y))' / l(y)' is independent of l(y)
+
+        if b.diff(fx) != 0 and not simplify(b.diff(fx)/a).has(fx):
+            self.ly = factor_terms(b).as_independent(fx, as_Add=False)[1] # Gives the term containing fx i.e., l(y)
+            self.ax = a / self.ly.diff(fx)
+            self.cx = -c  # cx is taken as -c(x) to simplify expression in the solution integral
+            self.bx = factor_terms(b) / self.ly
+            return True
+
+        return False
+
+    def _get_general_solution(self, *, simplify_flag: bool = True):
+        x = self.ode_problem.sym
+        (C1,)  = self.ode_problem.get_numbered_constants(num=1)
+        gensol = Eq(self.ly, ((C1 + Integral((self.cx/self.ax)*exp(Integral(self.bx/self.ax, x)), x))
+                * exp(-Integral(self.bx/self.ax, x))))
+
+        return [gensol]
+
+
+class Bernoulli(SinglePatternODESolver):
+    r"""
+    Solves Bernoulli differential equations.
+
+    These are equations of the form
+
+    .. math:: dy/dx + P(x) y = Q(x) y^n\text{, }n \ne 1`\text{.}
+
+    The substitution `w = 1/y^{1-n}` will transform an equation of this form
+    into one that is linear (see the docstring of
+    :obj:`~sympy.solvers.ode.single.FirstLinear`).  The general solution is::
+
+        >>> from sympy import Function, dsolve, Eq, pprint
+        >>> from sympy.abc import x, n
+        >>> f, P, Q = map(Function, ['f', 'P', 'Q'])
+        >>> genform = Eq(f(x).diff(x) + P(x)*f(x), Q(x)*f(x)**n)
+        >>> pprint(genform)
+                    d                n
+        P(x)*f(x) + --(f(x)) = Q(x)*f (x)
+                    dx
+        >>> pprint(dsolve(genform, f(x), hint='Bernoulli_Integral'), num_columns=110)
+                                                                                                                -1
+                                                                                                               -----
+                                                                                                               n - 1
+               //         /                                 /                            \                    \
+               ||        |                                 |                             |                    |
+               ||        |                  /              |                  /          |            /       |
+               ||        |                 |               |                 |           |           |        |
+               ||        |       -(n - 1)* | P(x) dx       |       -(n - 1)* | P(x) dx   |  (n - 1)* | P(x) dx|
+               ||        |                 |               |                 |           |           |        |
+               ||        |                /                |                /            |          /         |
+        f(x) = ||C1 - n* | Q(x)*e                    dx +  | Q(x)*e                    dx|*e                  |
+               ||        |                                 |                             |                    |
+               \\       /                                 /                              /                    /
+
+
+    Note that the equation is separable when `n = 1` (see the docstring of
+    :obj:`~sympy.solvers.ode.single.Separable`).
+
+    >>> pprint(dsolve(Eq(f(x).diff(x) + P(x)*f(x), Q(x)*f(x)), f(x),
+    ... hint='separable_Integral'))
+    f(x)
+        /
+    |                /
+    |  1            |
+    |  - dy = C1 +  | (-P(x) + Q(x)) dx
+    |  y            |
+    |              /
+    /
+
+
+    Examples
+    ========
+
+    >>> from sympy import Function, dsolve, Eq, pprint, log
+    >>> from sympy.abc import x
+    >>> f = Function('f')
+
+    >>> pprint(dsolve(Eq(x*f(x).diff(x) + f(x), log(x)*f(x)**2),
+    ... f(x), hint='Bernoulli'))
+                    1
+    f(x) =  -----------------
+            C1*x + log(x) + 1
+
+    References
+    ==========
+
+    - https://en.wikipedia.org/wiki/Bernoulli_differential_equation
+
+    - M. Tenenbaum & H. Pollard, "Ordinary Differential Equations",
+      Dover 1963, pp. 95
+
+    # indirect doctest
+
+    """
+    hint = "Bernoulli"
+    has_integral = True
+    order = [1]
+
+    def _wilds(self, f, x, order):
+        P = Wild('P', exclude=[f(x)])
+        Q = Wild('Q', exclude=[f(x)])
+        n = Wild('n', exclude=[x, f(x), f(x).diff(x)])
+        return P, Q, n
+
+    def _equation(self, fx, x, order):
+        P, Q, n = self.wilds()
+        return fx.diff(x) + P*fx - Q*fx**n
+
+    def _get_general_solution(self, *, simplify_flag: bool = True):
+        P, Q, n = self.wilds_match()
+        fx = self.ode_problem.func
+        x = self.ode_problem.sym
+        (C1,) = self.ode_problem.get_numbered_constants(num=1)
+        if n==1:
+            gensol = Eq(log(fx), (
+            C1 + Integral((-P + Q), x)
+        ))
+        else:
+            gensol = Eq(fx**(1-n), (
+                (C1 - (n - 1) * Integral(Q*exp(-n*Integral(P, x))
+                            * exp(Integral(P, x)), x)
+                ) * exp(-(1 - n)*Integral(P, x)))
+            )
+        return [gensol]
+
+
+class Factorable(SingleODESolver):
+    r"""
+        Solves equations having a solvable factor.
+
+        This function is used to solve the equation having factors. Factors may be of type algebraic or ode. It
+        will try to solve each factor independently. Factors will be solved by calling dsolve. We will return the
+        list of solutions.
+
+        Examples
+        ========
+
+        >>> from sympy import Function, dsolve, pprint
+        >>> from sympy.abc import x
+        >>> f = Function('f')
+        >>> eq = (f(x)**2-4)*(f(x).diff(x)+f(x))
+        >>> pprint(dsolve(eq, f(x)))
+                                        -x
+        [f(x) = 2, f(x) = -2, f(x) = C1*e  ]
+
+
+        """
+    hint = "factorable"
+    has_integral = False
+
+    def _matches(self):
+        eq_orig = self.ode_problem.eq
+        f = self.ode_problem.func.func
+        x = self.ode_problem.sym
+        df = f(x).diff(x)
+        self.eqs = []
+        eq = eq_orig.collect(f(x), func = cancel)
+        eq = fraction(factor(eq))[0]
+        factors = Mul.make_args(factor(eq))
+        roots = [fac.as_base_exp() for fac in factors if len(fac.args)!=0]
+        if len(roots)>1 or roots[0][1]>1:
+            for base, expo in roots:
+                if base.has(f(x)):
+                    self.eqs.append(base)
+            if len(self.eqs)>0:
+                return True
+        roots = solve(eq, df)
+        if len(roots)>0:
+            self.eqs = [(df - root) for root in roots]
+            # Avoid infinite recursion
+            matches = self.eqs != [eq_orig]
+            return matches
+        for i in factors:
+            if i.has(f(x)):
+                self.eqs.append(i)
+        return len(self.eqs)>0 and len(factors)>1
+
+    def _get_general_solution(self, *, simplify_flag: bool = True):
+        func = self.ode_problem.func.func
+        x = self.ode_problem.sym
+        eqns = self.eqs
+        sols = []
+        for eq in eqns:
+            try:
+                sol = dsolve(eq, func(x))
+            except NotImplementedError:
+                continue
+            else:
+                if isinstance(sol, list):
+                    sols.extend(sol)
+                else:
+                    sols.append(sol)
+
+        if sols == []:
+            raise NotImplementedError("The given ODE " + str(eq) + " cannot be solved by"
+                + " the factorable group method")
+        return sols
+
+
+class RiccatiSpecial(SinglePatternODESolver):
+    r"""
+    The general Riccati equation has the form
+
+    .. math:: dy/dx = f(x) y^2 + g(x) y + h(x)\text{.}
+
+    While it does not have a general solution [1], the "special" form, `dy/dx
+    = a y^2 - b x^c`, does have solutions in many cases [2].  This routine
+    returns a solution for `a(dy/dx) = b y^2 + c y/x + d/x^2` that is obtained
+    by using a suitable change of variables to reduce it to the special form
+    and is valid when neither `a` nor `b` are zero and either `c` or `d` is
+    zero.
+
+    >>> from sympy.abc import x, a, b, c, d
+    >>> from sympy import dsolve, checkodesol, pprint, Function
+    >>> f = Function('f')
+    >>> y = f(x)
+    >>> genform = a*y.diff(x) - (b*y**2 + c*y/x + d/x**2)
+    >>> sol = dsolve(genform, y, hint="Riccati_special_minus2")
+    >>> pprint(sol, wrap_line=False)
+            /                                 /        __________________       \\
+            |           __________________    |       /                2        ||
+            |          /                2     |     \/  4*b*d - (a + c)  *log(x)||
+           -|a + c - \/  4*b*d - (a + c)  *tan|C1 + ----------------------------||
+            \                                 \                 2*a             //
+    f(x) = ------------------------------------------------------------------------
+                                            2*b*x
+
+    >>> checkodesol(genform, sol, order=1)[0]
+    True
+
+    References
+    ==========
+
+    - https://www.maplesoft.com/support/help/Maple/view.aspx?path=odeadvisor/Riccati
+    - https://eqworld.ipmnet.ru/en/solutions/ode/ode0106.pdf -
+      https://eqworld.ipmnet.ru/en/solutions/ode/ode0123.pdf
+    """
+    hint = "Riccati_special_minus2"
+    has_integral = False
+    order = [1]
+
+    def _wilds(self, f, x, order):
+        a = Wild('a', exclude=[x, f(x), f(x).diff(x), 0])
+        b = Wild('b', exclude=[x, f(x), f(x).diff(x), 0])
+        c = Wild('c', exclude=[x, f(x), f(x).diff(x)])
+        d = Wild('d', exclude=[x, f(x), f(x).diff(x)])
+        return a, b, c, d
+
+    def _equation(self, fx, x, order):
+        a, b, c, d = self.wilds()
+        return a*fx.diff(x) + b*fx**2 + c*fx/x + d/x**2
+
+    def _get_general_solution(self, *, simplify_flag: bool = True):
+        a, b, c, d = self.wilds_match()
+        fx = self.ode_problem.func
+        x = self.ode_problem.sym
+        (C1,) = self.ode_problem.get_numbered_constants(num=1)
+        mu = sqrt(4*d*b - (a - c)**2)
+
+        gensol = Eq(fx, (a - c - mu*tan(mu/(2*a)*log(x) + C1))/(2*b*x))
+        return [gensol]
+
+
+class RationalRiccati(SinglePatternODESolver):
+    r"""
+    Gives general solutions to the first order Riccati differential
+    equations that have atleast one rational particular solution.
+
+    .. math :: y' = b_0(x) + b_1(x) y + b_2(x) y^2
+
+    where `b_0`, `b_1` and `b_2` are rational functions of `x`
+    with `b_2 \ne 0` (`b_2 = 0` would make it a Bernoulli equation).
+
+    Examples
+    ========
+
+    >>> from sympy import Symbol, Function, dsolve, checkodesol
+    >>> f = Function('f')
+    >>> x = Symbol('x')
+
+    >>> eq = -x**4*f(x)**2 + x**3*f(x).diff(x) + x**2*f(x) + 20
+    >>> sol = dsolve(eq, hint="1st_rational_riccati")
+    >>> sol
+    Eq(f(x), (4*C1 - 5*x**9 - 4)/(x**2*(C1 + x**9 - 1)))
+    >>> checkodesol(eq, sol)
+    (True, 0)
+
+    References
+    ==========
+
+    - Riccati ODE:  https://en.wikipedia.org/wiki/Riccati_equation
+    - N. Thieu Vo - Rational and Algebraic Solutions of First-Order Algebraic ODEs:
+      Algorithm 11, pp. 78 - https://www3.risc.jku.at/publications/download/risc_5387/PhDThesisThieu.pdf
+    """
+    has_integral = False
+    hint = "1st_rational_riccati"
+    order = [1]
+
+    def _wilds(self, f, x, order):
+        b0 = Wild('b0', exclude=[f(x), f(x).diff(x)])
+        b1 = Wild('b1', exclude=[f(x), f(x).diff(x)])
+        b2 = Wild('b2', exclude=[f(x), f(x).diff(x)])
+        return (b0, b1, b2)
+
+    def _equation(self, fx, x, order):
+        b0, b1, b2 = self.wilds()
+        return fx.diff(x) - b0 - b1*fx - b2*fx**2
+
+    def _matches(self):
+        eq = self.ode_problem.eq_expanded
+        f = self.ode_problem.func.func
+        x = self.ode_problem.sym
+        order = self.ode_problem.order
+
+        if order != 1:
+            return False
+
+        match, funcs = match_riccati(eq, f, x)
+        if not match:
+            return False
+        _b0, _b1, _b2 = funcs
+        b0, b1, b2 = self.wilds()
+        self._wilds_match = match = {b0: _b0, b1: _b1, b2: _b2}
+        return True
+
+    def _get_general_solution(self, *, simplify_flag: bool = True):
+        # Match the equation
+        b0, b1, b2 = self.wilds_match()
+        fx = self.ode_problem.func
+        x = self.ode_problem.sym
+        return solve_riccati(fx, x, b0, b1, b2, gensol=True)
+
+
+class SecondNonlinearAutonomousConserved(SinglePatternODESolver):
+    r"""
+    Gives solution for the autonomous second order nonlinear
+    differential equation of the form
+
+    .. math :: f''(x) = g(f(x))
+
+    The solution for this differential equation can be computed
+    by multiplying by `f'(x)` and integrating on both sides,
+    converting it into a first order differential equation.
+
+    Examples
+    ========
+
+    >>> from sympy import Function, symbols, dsolve
+    >>> f, g = symbols('f g', cls=Function)
+    >>> x = symbols('x')
+
+    >>> eq = f(x).diff(x, 2) - g(f(x))
+    >>> dsolve(eq, simplify=False)
+    [Eq(Integral(1/sqrt(C1 + 2*Integral(g(_u), _u)), (_u, f(x))), C2 + x),
+    Eq(Integral(1/sqrt(C1 + 2*Integral(g(_u), _u)), (_u, f(x))), C2 - x)]
+
+    >>> from sympy import exp, log
+    >>> eq = f(x).diff(x, 2) - exp(f(x)) + log(f(x))
+    >>> dsolve(eq, simplify=False)
+    [Eq(Integral(1/sqrt(-2*_u*log(_u) + 2*_u + C1 + 2*exp(_u)), (_u, f(x))), C2 + x),
+    Eq(Integral(1/sqrt(-2*_u*log(_u) + 2*_u + C1 + 2*exp(_u)), (_u, f(x))), C2 - x)]
+
+    References
+    ==========
+
+    - https://eqworld.ipmnet.ru/en/solutions/ode/ode0301.pdf
+    """
+    hint = "2nd_nonlinear_autonomous_conserved"
+    has_integral = True
+    order = [2]
+
+    def _wilds(self, f, x, order):
+        fy = Wild('fy', exclude=[0, f(x).diff(x), f(x).diff(x, 2)])
+        return (fy, )
+
+    def _equation(self, fx, x, order):
+        fy = self.wilds()[0]
+        return fx.diff(x, 2) + fy
+
+    def _verify(self, fx):
+        return self.ode_problem.is_autonomous
+
+    def _get_general_solution(self, *, simplify_flag: bool = True):
+        g = self.wilds_match()[0]
+        fx = self.ode_problem.func
+        x = self.ode_problem.sym
+        u = Dummy('u')
+        g = g.subs(fx, u)
+        C1, C2 = self.ode_problem.get_numbered_constants(num=2)
+        inside = -2*Integral(g, u) + C1
+        lhs = Integral(1/sqrt(inside), (u, fx))
+        return [Eq(lhs, C2 + x), Eq(lhs, C2 - x)]
+
+
+class Liouville(SinglePatternODESolver):
+    r"""
+    Solves 2nd order Liouville differential equations.
+
+    The general form of a Liouville ODE is
+
+    .. math:: \frac{d^2 y}{dx^2} + g(y) \left(\!
+                \frac{dy}{dx}\!\right)^2 + h(x)
+                \frac{dy}{dx}\text{.}
+
+    The general solution is:
+
+        >>> from sympy import Function, dsolve, Eq, pprint, diff
+        >>> from sympy.abc import x
+        >>> f, g, h = map(Function, ['f', 'g', 'h'])
+        >>> genform = Eq(diff(f(x),x,x) + g(f(x))*diff(f(x),x)**2 +
+        ... h(x)*diff(f(x),x), 0)
+        >>> pprint(genform)
+                          2                    2
+                /d       \         d          d
+        g(f(x))*|--(f(x))|  + h(x)*--(f(x)) + ---(f(x)) = 0
+                \dx      /         dx           2
+                                              dx
+        >>> pprint(dsolve(genform, f(x), hint='Liouville_Integral'))
+                                          f(x)
+                  /                     /
+                 |                     |
+                 |     /               |     /
+                 |    |                |    |
+                 |  - | h(x) dx        |    | g(y) dy
+                 |    |                |    |
+                 |   /                 |   /
+        C1 + C2* | e            dx +   |  e           dy = 0
+                 |                     |
+                /                     /
+
+    Examples
+    ========
+
+    >>> from sympy import Function, dsolve, Eq, pprint
+    >>> from sympy.abc import x
+    >>> f = Function('f')
+    >>> pprint(dsolve(diff(f(x), x, x) + diff(f(x), x)**2/f(x) +
+    ... diff(f(x), x)/x, f(x), hint='Liouville'))
+               ________________           ________________
+    [f(x) = -\/ C1 + C2*log(x) , f(x) = \/ C1 + C2*log(x) ]
+
+    References
+    ==========
+
+    - Goldstein and Braun, "Advanced Methods for the Solution of Differential
+      Equations", pp. 98
+    - https://www.maplesoft.com/support/help/Maple/view.aspx?path=odeadvisor/Liouville
+
+    # indirect doctest
+
+    """
+    hint = "Liouville"
+    has_integral = True
+    order = [2]
+
+    def _wilds(self, f, x, order):
+        d = Wild('d', exclude=[f(x).diff(x), f(x).diff(x, 2)])
+        e = Wild('e', exclude=[f(x).diff(x)])
+        k = Wild('k', exclude=[f(x).diff(x)])
+        return d, e, k
+
+    def _equation(self, fx, x, order):
+        # Liouville ODE in the form
+        # f(x).diff(x, 2) + g(f(x))*(f(x).diff(x))**2 + h(x)*f(x).diff(x)
+        # See Goldstein and Braun, "Advanced Methods for the Solution of
+        # Differential Equations", pg. 98
+        d, e, k = self.wilds()
+        return d*fx.diff(x, 2) + e*fx.diff(x)**2 + k*fx.diff(x)
+
+    def _verify(self, fx):
+        d, e, k = self.wilds_match()
+        self.y = Dummy('y')
+        x = self.ode_problem.sym
+        self.g = simplify(e/d).subs(fx, self.y)
+        self.h = simplify(k/d).subs(fx, self.y)
+        if self.y in self.h.free_symbols or x in self.g.free_symbols:
+            return False
+        return True
+
+    def _get_general_solution(self, *, simplify_flag: bool = True):
+        d, e, k = self.wilds_match()
+        fx = self.ode_problem.func
+        x = self.ode_problem.sym
+        C1, C2 = self.ode_problem.get_numbered_constants(num=2)
+        int = Integral(exp(Integral(self.g, self.y)), (self.y, None, fx))
+        gen_sol = Eq(int + C1*Integral(exp(-Integral(self.h, x)), x) + C2, 0)
+
+        return [gen_sol]
+
+
+class Separable(SinglePatternODESolver):
+    r"""
+    Solves separable 1st order differential equations.
+
+    This is any differential equation that can be written as `P(y)
+    \tfrac{dy}{dx} = Q(x)`.  The solution can then just be found by
+    rearranging terms and integrating: `\int P(y) \,dy = \int Q(x) \,dx`.
+    This hint uses :py:meth:`sympy.simplify.simplify.separatevars` as its back
+    end, so if a separable equation is not caught by this solver, it is most
+    likely the fault of that function.
+    :py:meth:`~sympy.simplify.simplify.separatevars` is
+    smart enough to do most expansion and factoring necessary to convert a
+    separable equation `F(x, y)` into the proper form `P(x)\cdot{}Q(y)`.  The
+    general solution is::
+
+        >>> from sympy import Function, dsolve, Eq, pprint
+        >>> from sympy.abc import x
+        >>> a, b, c, d, f = map(Function, ['a', 'b', 'c', 'd', 'f'])
+        >>> genform = Eq(a(x)*b(f(x))*f(x).diff(x), c(x)*d(f(x)))
+        >>> pprint(genform)
+                     d
+        a(x)*b(f(x))*--(f(x)) = c(x)*d(f(x))
+                     dx
+        >>> pprint(dsolve(genform, f(x), hint='separable_Integral'))
+             f(x)
+           /                  /
+          |                  |
+          |  b(y)            | c(x)
+          |  ---- dy = C1 +  | ---- dx
+          |  d(y)            | a(x)
+          |                  |
+         /                  /
+
+    Examples
+    ========
+
+    >>> from sympy import Function, dsolve, Eq
+    >>> from sympy.abc import x
+    >>> f = Function('f')
+    >>> pprint(dsolve(Eq(f(x)*f(x).diff(x) + x, 3*x*f(x)**2), f(x),
+    ... hint='separable', simplify=False))
+       /   2       \         2
+    log\3*f (x) - 1/        x
+    ---------------- = C1 + --
+           6                2
+
+    References
+    ==========
+
+    - M. Tenenbaum & H. Pollard, "Ordinary Differential Equations",
+      Dover 1963, pp. 52
+
+    # indirect doctest
+
+    """
+    hint = "separable"
+    has_integral = True
+    order = [1]
+
+    def _wilds(self, f, x, order):
+        d = Wild('d', exclude=[f(x).diff(x), f(x).diff(x, 2)])
+        e = Wild('e', exclude=[f(x).diff(x)])
+        return d, e
+
+    def _equation(self, fx, x, order):
+        d, e = self.wilds()
+        return d + e*fx.diff(x)
+
+    def _verify(self, fx):
+        d, e = self.wilds_match()
+        self.y = Dummy('y')
+        x = self.ode_problem.sym
+        d = separatevars(d.subs(fx, self.y))
+        e = separatevars(e.subs(fx, self.y))
+        # m1[coeff]*m1[x]*m1[y] + m2[coeff]*m2[x]*m2[y]*y'
+        self.m1 = separatevars(d, dict=True, symbols=(x, self.y))
+        self.m2 = separatevars(e, dict=True, symbols=(x, self.y))
+        return bool(self.m1 and self.m2)
+
+    def _get_match_object(self):
+        fx = self.ode_problem.func
+        x = self.ode_problem.sym
+        return self.m1, self.m2, x, fx
+
+    def _get_general_solution(self, *, simplify_flag: bool = True):
+        m1, m2, x, fx = self._get_match_object()
+        (C1,) = self.ode_problem.get_numbered_constants(num=1)
+        int = Integral(m2['coeff']*m2[self.y]/m1[self.y],
+        (self.y, None, fx))
+        gen_sol = Eq(int, Integral(-m1['coeff']*m1[x]/
+        m2[x], x) + C1)
+        return [gen_sol]
+
+
+class SeparableReduced(Separable):
+    r"""
+    Solves a differential equation that can be reduced to the separable form.
+
+    The general form of this equation is
+
+    .. math:: y' + (y/x) H(x^n y) = 0\text{}.
+
+    This can be solved by substituting `u(y) = x^n y`.  The equation then
+    reduces to the separable form `\frac{u'}{u (\mathrm{power} - H(u))} -
+    \frac{1}{x} = 0`.
+
+    The general solution is:
+
+        >>> from sympy import Function, dsolve, pprint
+        >>> from sympy.abc import x, n
+        >>> f, g = map(Function, ['f', 'g'])
+        >>> genform = f(x).diff(x) + (f(x)/x)*g(x**n*f(x))
+        >>> pprint(genform)
+                         / n     \
+        d          f(x)*g\x *f(x)/
+        --(f(x)) + ---------------
+        dx                x
+        >>> pprint(dsolve(genform, hint='separable_reduced'))
+         n
+        x *f(x)
+          /
+         |
+         |         1
+         |    ------------ dy = C1 + log(x)
+         |    y*(n - g(y))
+         |
+         /
+
+    See Also
+    ========
+    :obj:`sympy.solvers.ode.single.Separable`
+
+    Examples
+    ========
+
+    >>> from sympy import dsolve, Function, pprint
+    >>> from sympy.abc import x
+    >>> f = Function('f')
+    >>> d = f(x).diff(x)
+    >>> eq = (x - x**2*f(x))*d - f(x)
+    >>> dsolve(eq, hint='separable_reduced')
+    [Eq(f(x), (1 - sqrt(C1*x**2 + 1))/x), Eq(f(x), (sqrt(C1*x**2 + 1) + 1)/x)]
+    >>> pprint(dsolve(eq, hint='separable_reduced'))
+                   ___________            ___________
+                  /     2                /     2
+            1 - \/  C1*x  + 1          \/  C1*x  + 1  + 1
+    [f(x) = ------------------, f(x) = ------------------]
+                    x                          x
+
+    References
+    ==========
+
+    - Joel Moses, "Symbolic Integration - The Stormy Decade", Communications
+      of the ACM, Volume 14, Number 8, August 1971, pp. 558
+    """
+    hint = "separable_reduced"
+    has_integral = True
+    order = [1]
+
+    def _degree(self, expr, x):
+        # Made this function to calculate the degree of
+        # x in an expression. If expr will be of form
+        # x**p*y, (wheare p can be variables/rationals) then it
+        # will return p.
+        for val in expr:
+            if val.has(x):
+                if isinstance(val, Pow) and val.as_base_exp()[0] == x:
+                    return (val.as_base_exp()[1])
+                elif val == x:
+                    return (val.as_base_exp()[1])
+                else:
+                    return self._degree(val.args, x)
+        return 0
+
+    def _powers(self, expr):
+        # this function will return all the different relative power of x w.r.t f(x).
+        # expr = x**p * f(x)**q then it will return {p/q}.
+        pows = set()
+        fx = self.ode_problem.func
+        x = self.ode_problem.sym
+        self.y = Dummy('y')
+        if isinstance(expr, Add):
+            exprs = expr.atoms(Add)
+        elif isinstance(expr, Mul):
+            exprs = expr.atoms(Mul)
+        elif isinstance(expr, Pow):
+            exprs = expr.atoms(Pow)
+        else:
+            exprs = {expr}
+
+        for arg in exprs:
+            if arg.has(x):
+                _, u = arg.as_independent(x, fx)
+                pow = self._degree((u.subs(fx, self.y), ), x)/self._degree((u.subs(fx, self.y), ), self.y)
+                pows.add(pow)
+        return pows
+
+    def _verify(self, fx):
+        num, den = self.wilds_match()
+        x = self.ode_problem.sym
+        factor = simplify(x/fx*num/den)
+        # Try representing factor in terms of x^n*y
+        # where n is lowest power of x in factor;
+        # first remove terms like sqrt(2)*3 from factor.atoms(Mul)
+        num, dem = factor.as_numer_denom()
+        num = expand(num)
+        dem = expand(dem)
+        pows = self._powers(num)
+        pows.update(self._powers(dem))
+        pows = list(pows)
+        if(len(pows)==1) and pows[0]!=zoo:
+            self.t = Dummy('t')
+            self.r2 = {'t': self.t}
+            num = num.subs(x**pows[0]*fx, self.t)
+            dem = dem.subs(x**pows[0]*fx, self.t)
+            test = num/dem
+            free = test.free_symbols
+            if len(free) == 1 and free.pop() == self.t:
+                self.r2.update({'power' : pows[0], 'u' : test})
+                return True
+            return False
+        return False
+
+    def _get_match_object(self):
+        fx = self.ode_problem.func
+        x = self.ode_problem.sym
+        u = self.r2['u'].subs(self.r2['t'], self.y)
+        ycoeff = 1/(self.y*(self.r2['power'] - u))
+        m1 = {self.y: 1, x: -1/x, 'coeff': 1}
+        m2 = {self.y: ycoeff, x: 1, 'coeff': 1}
+        return m1, m2, x, x**self.r2['power']*fx
+
+
+class HomogeneousCoeffSubsDepDivIndep(SinglePatternODESolver):
+    r"""
+    Solves a 1st order differential equation with homogeneous coefficients
+    using the substitution `u_1 = \frac{\text{<dependent
+    variable>}}{\text{<independent variable>}}`.
+
+    This is a differential equation
+
+    .. math:: P(x, y) + Q(x, y) dy/dx = 0
+
+    such that `P` and `Q` are homogeneous and of the same order.  A function
+    `F(x, y)` is homogeneous of order `n` if `F(x t, y t) = t^n F(x, y)`.
+    Equivalently, `F(x, y)` can be rewritten as `G(y/x)` or `H(x/y)`.  See
+    also the docstring of :py:meth:`~sympy.solvers.ode.homogeneous_order`.
+
+    If the coefficients `P` and `Q` in the differential equation above are
+    homogeneous functions of the same order, then it can be shown that the
+    substitution `y = u_1 x` (i.e. `u_1 = y/x`) will turn the differential
+    equation into an equation separable in the variables `x` and `u`.  If
+    `h(u_1)` is the function that results from making the substitution `u_1 =
+    f(x)/x` on `P(x, f(x))` and `g(u_2)` is the function that results from the
+    substitution on `Q(x, f(x))` in the differential equation `P(x, f(x)) +
+    Q(x, f(x)) f'(x) = 0`, then the general solution is::
+
+        >>> from sympy import Function, dsolve, pprint
+        >>> from sympy.abc import x
+        >>> f, g, h = map(Function, ['f', 'g', 'h'])
+        >>> genform = g(f(x)/x) + h(f(x)/x)*f(x).diff(x)
+        >>> pprint(genform)
+         /f(x)\    /f(x)\ d
+        g|----| + h|----|*--(f(x))
+         \ x  /    \ x  / dx
+        >>> pprint(dsolve(genform, f(x),
+        ... hint='1st_homogeneous_coeff_subs_dep_div_indep_Integral'))
+                       f(x)
+                       ----
+                        x
+                         /
+                        |
+                        |       -h(u1)
+        log(x) = C1 +   |  ---------------- d(u1)
+                        |  u1*h(u1) + g(u1)
+                        |
+                       /
+
+    Where `u_1 h(u_1) + g(u_1) \ne 0` and `x \ne 0`.
+
+    See also the docstrings of
+    :obj:`~sympy.solvers.ode.single.HomogeneousCoeffBest` and
+    :obj:`~sympy.solvers.ode.single.HomogeneousCoeffSubsIndepDivDep`.
+
+    Examples
+    ========
+
+    >>> from sympy import Function, dsolve
+    >>> from sympy.abc import x
+    >>> f = Function('f')
+    >>> pprint(dsolve(2*x*f(x) + (x**2 + f(x)**2)*f(x).diff(x), f(x),
+    ... hint='1st_homogeneous_coeff_subs_dep_div_indep', simplify=False))
+                          /          3   \
+                          |3*f(x)   f (x)|
+                       log|------ + -----|
+                          |  x         3 |
+                          \           x  /
+    log(x) = log(C1) - -------------------
+                                3
+
+    References
+    ==========
+
+    - https://en.wikipedia.org/wiki/Homogeneous_differential_equation
+    - M. Tenenbaum & H. Pollard, "Ordinary Differential Equations",
+      Dover 1963, pp. 59
+
+    # indirect doctest
+
+    """
+    hint = "1st_homogeneous_coeff_subs_dep_div_indep"
+    has_integral = True
+    order = [1]
+
+    def _wilds(self, f, x, order):
+        d = Wild('d', exclude=[f(x).diff(x), f(x).diff(x, 2)])
+        e = Wild('e', exclude=[f(x).diff(x)])
+        return d, e
+
+    def _equation(self, fx, x, order):
+        d, e = self.wilds()
+        return d + e*fx.diff(x)
+
+    def _verify(self, fx):
+        self.d, self.e = self.wilds_match()
+        self.y = Dummy('y')
+        x = self.ode_problem.sym
+        self.d = separatevars(self.d.subs(fx, self.y))
+        self.e = separatevars(self.e.subs(fx, self.y))
+        ordera = homogeneous_order(self.d, x, self.y)
+        orderb = homogeneous_order(self.e, x, self.y)
+        if ordera == orderb and ordera is not None:
+            self.u = Dummy('u')
+            if simplify((self.d + self.u*self.e).subs({x: 1, self.y: self.u})) != 0:
+                return True
+            return False
+        return False
+
+    def _get_match_object(self):
+        fx = self.ode_problem.func
+        x = self.ode_problem.sym
+        self.u1 = Dummy('u1')
+        xarg = 0
+        yarg = 0
+        return [self.d, self.e, fx, x, self.u, self.u1, self.y, xarg, yarg]
+
+    def _get_general_solution(self, *, simplify_flag: bool = True):
+        d, e, fx, x, u, u1, y, xarg, yarg = self._get_match_object()
+        (C1,) = self.ode_problem.get_numbered_constants(num=1)
+        int = Integral(
+            (-e/(d + u1*e)).subs({x: 1, y: u1}),
+            (u1, None, fx/x))
+        sol = logcombine(Eq(log(x), int + log(C1)), force=True)
+        gen_sol = sol.subs(fx, u).subs(((u, u - yarg), (x, x - xarg), (u, fx)))
+        return [gen_sol]
+
+
+class HomogeneousCoeffSubsIndepDivDep(SinglePatternODESolver):
+    r"""
+    Solves a 1st order differential equation with homogeneous coefficients
+    using the substitution `u_2 = \frac{\text{<independent
+    variable>}}{\text{<dependent variable>}}`.
+
+    This is a differential equation
+
+    .. math:: P(x, y) + Q(x, y) dy/dx = 0
+
+    such that `P` and `Q` are homogeneous and of the same order.  A function
+    `F(x, y)` is homogeneous of order `n` if `F(x t, y t) = t^n F(x, y)`.
+    Equivalently, `F(x, y)` can be rewritten as `G(y/x)` or `H(x/y)`.  See
+    also the docstring of :py:meth:`~sympy.solvers.ode.homogeneous_order`.
+
+    If the coefficients `P` and `Q` in the differential equation above are
+    homogeneous functions of the same order, then it can be shown that the
+    substitution `x = u_2 y` (i.e. `u_2 = x/y`) will turn the differential
+    equation into an equation separable in the variables `y` and `u_2`.  If
+    `h(u_2)` is the function that results from making the substitution `u_2 =
+    x/f(x)` on `P(x, f(x))` and `g(u_2)` is the function that results from the
+    substitution on `Q(x, f(x))` in the differential equation `P(x, f(x)) +
+    Q(x, f(x)) f'(x) = 0`, then the general solution is:
+
+    >>> from sympy import Function, dsolve, pprint
+    >>> from sympy.abc import x
+    >>> f, g, h = map(Function, ['f', 'g', 'h'])
+    >>> genform = g(x/f(x)) + h(x/f(x))*f(x).diff(x)
+    >>> pprint(genform)
+     / x  \    / x  \ d
+    g|----| + h|----|*--(f(x))
+     \f(x)/    \f(x)/ dx
+    >>> pprint(dsolve(genform, f(x),
+    ... hint='1st_homogeneous_coeff_subs_indep_div_dep_Integral'))
+                 x
+                ----
+                f(x)
+                  /
+                 |
+                 |       -g(u1)
+                 |  ---------------- d(u1)
+                 |  u1*g(u1) + h(u1)
+                 |
+                /
+    <BLANKLINE>
+    f(x) = C1*e
+
+    Where `u_1 g(u_1) + h(u_1) \ne 0` and `f(x) \ne 0`.
+
+    See also the docstrings of
+    :obj:`~sympy.solvers.ode.single.HomogeneousCoeffBest` and
+    :obj:`~sympy.solvers.ode.single.HomogeneousCoeffSubsDepDivIndep`.
+
+    Examples
+    ========
+
+    >>> from sympy import Function, pprint, dsolve
+    >>> from sympy.abc import x
+    >>> f = Function('f')
+    >>> pprint(dsolve(2*x*f(x) + (x**2 + f(x)**2)*f(x).diff(x), f(x),
+    ... hint='1st_homogeneous_coeff_subs_indep_div_dep',
+    ... simplify=False))
+                             /   2     \
+                             |3*x      |
+                          log|----- + 1|
+                             | 2       |
+                             \f (x)    /
+    log(f(x)) = log(C1) - --------------
+                                3
+
+    References
+    ==========
+
+    - https://en.wikipedia.org/wiki/Homogeneous_differential_equation
+    - M. Tenenbaum & H. Pollard, "Ordinary Differential Equations",
+      Dover 1963, pp. 59
+
+    # indirect doctest
+
+    """
+    hint = "1st_homogeneous_coeff_subs_indep_div_dep"
+    has_integral = True
+    order = [1]
+
+    def _wilds(self, f, x, order):
+        d = Wild('d', exclude=[f(x).diff(x), f(x).diff(x, 2)])
+        e = Wild('e', exclude=[f(x).diff(x)])
+        return d, e
+
+    def _equation(self, fx, x, order):
+        d, e = self.wilds()
+        return d + e*fx.diff(x)
+
+    def _verify(self, fx):
+        self.d, self.e = self.wilds_match()
+        self.y = Dummy('y')
+        x = self.ode_problem.sym
+        self.d = separatevars(self.d.subs(fx, self.y))
+        self.e = separatevars(self.e.subs(fx, self.y))
+        ordera = homogeneous_order(self.d, x, self.y)
+        orderb = homogeneous_order(self.e, x, self.y)
+        if ordera == orderb and ordera is not None:
+            self.u = Dummy('u')
+            if simplify((self.e + self.u*self.d).subs({x: self.u, self.y: 1})) != 0:
+                return True
+            return False
+        return False
+
+    def _get_match_object(self):
+        fx = self.ode_problem.func
+        x = self.ode_problem.sym
+        self.u1 = Dummy('u1')
+        xarg = 0
+        yarg = 0
+        return [self.d, self.e, fx, x, self.u, self.u1, self.y, xarg, yarg]
+
+    def _get_general_solution(self, *, simplify_flag: bool = True):
+        d, e, fx, x, u, u1, y, xarg, yarg = self._get_match_object()
+        (C1,) = self.ode_problem.get_numbered_constants(num=1)
+        int = Integral(simplify((-d/(e + u1*d)).subs({x: u1, y: 1})), (u1, None, x/fx)) # type: ignore
+        sol = logcombine(Eq(log(fx), int + log(C1)), force=True)
+        gen_sol = sol.subs(fx, u).subs(((u, u - yarg), (x, x - xarg), (u, fx)))
+        return [gen_sol]
+
+
+class HomogeneousCoeffBest(HomogeneousCoeffSubsIndepDivDep, HomogeneousCoeffSubsDepDivIndep):
+    r"""
+    Returns the best solution to an ODE from the two hints
+    ``1st_homogeneous_coeff_subs_dep_div_indep`` and
+    ``1st_homogeneous_coeff_subs_indep_div_dep``.
+
+    This is as determined by :py:meth:`~sympy.solvers.ode.ode.ode_sol_simplicity`.
+
+    See the
+    :obj:`~sympy.solvers.ode.single.HomogeneousCoeffSubsIndepDivDep`
+    and
+    :obj:`~sympy.solvers.ode.single.HomogeneousCoeffSubsDepDivIndep`
+    docstrings for more information on these hints.  Note that there is no
+    ``ode_1st_homogeneous_coeff_best_Integral`` hint.
+
+    Examples
+    ========
+
+    >>> from sympy import Function, dsolve, pprint
+    >>> from sympy.abc import x
+    >>> f = Function('f')
+    >>> pprint(dsolve(2*x*f(x) + (x**2 + f(x)**2)*f(x).diff(x), f(x),
+    ... hint='1st_homogeneous_coeff_best', simplify=False))
+                             /   2     \
+                             |3*x      |
+                          log|----- + 1|
+                             | 2       |
+                             \f (x)    /
+    log(f(x)) = log(C1) - --------------
+                                3
+
+    References
+    ==========
+
+    - https://en.wikipedia.org/wiki/Homogeneous_differential_equation
+    - M. Tenenbaum & H. Pollard, "Ordinary Differential Equations",
+      Dover 1963, pp. 59
+
+    # indirect doctest
+
+    """
+    hint = "1st_homogeneous_coeff_best"
+    has_integral = False
+    order = [1]
+
+    def _verify(self, fx):
+        return HomogeneousCoeffSubsIndepDivDep._verify(self, fx) and \
+               HomogeneousCoeffSubsDepDivIndep._verify(self, fx)
+
+    def _get_general_solution(self, *, simplify_flag: bool = True):
+        # There are two substitutions that solve the equation, u1=y/x and u2=x/y
+        # # They produce different integrals, so try them both and see which
+        # # one is easier
+        sol1 = HomogeneousCoeffSubsIndepDivDep._get_general_solution(self)
+        sol2 = HomogeneousCoeffSubsDepDivIndep._get_general_solution(self)
+        fx = self.ode_problem.func
+        if simplify_flag:
+            sol1 = odesimp(self.ode_problem.eq, *sol1, fx, "1st_homogeneous_coeff_subs_indep_div_dep")
+            sol2 = odesimp(self.ode_problem.eq, *sol2, fx, "1st_homogeneous_coeff_subs_dep_div_indep")
+        # XXX: not simplify should be not simplify_flag. mypy correctly complains
+        return min([sol1, sol2], key=lambda x: ode_sol_simplicity(x, fx, trysolving=not simplify)) # type: ignore
+
+
+class LinearCoefficients(HomogeneousCoeffBest):
+    r"""
+    Solves a differential equation with linear coefficients.
+
+    The general form of a differential equation with linear coefficients is
+
+    .. math:: y' + F\left(\!\frac{a_1 x + b_1 y + c_1}{a_2 x + b_2 y +
+                c_2}\!\right) = 0\text{,}
+
+    where `a_1`, `b_1`, `c_1`, `a_2`, `b_2`, `c_2` are constants and `a_1 b_2
+    - a_2 b_1 \ne 0`.
+
+    This can be solved by substituting:
+
+    .. math:: x = x' + \frac{b_2 c_1 - b_1 c_2}{a_2 b_1 - a_1 b_2}
+
+              y = y' + \frac{a_1 c_2 - a_2 c_1}{a_2 b_1 - a_1
+                  b_2}\text{.}
+
+    This substitution reduces the equation to a homogeneous differential
+    equation.
+
+    See Also
+    ========
+    :obj:`sympy.solvers.ode.single.HomogeneousCoeffBest`
+    :obj:`sympy.solvers.ode.single.HomogeneousCoeffSubsIndepDivDep`
+    :obj:`sympy.solvers.ode.single.HomogeneousCoeffSubsDepDivIndep`
+
+    Examples
+    ========
+
+    >>> from sympy import dsolve, Function, pprint
+    >>> from sympy.abc import x
+    >>> f = Function('f')
+    >>> df = f(x).diff(x)
+    >>> eq = (x + f(x) + 1)*df + (f(x) - 6*x + 1)
+    >>> dsolve(eq, hint='linear_coefficients')
+    [Eq(f(x), -x - sqrt(C1 + 7*x**2) - 1), Eq(f(x), -x + sqrt(C1 + 7*x**2) - 1)]
+    >>> pprint(dsolve(eq, hint='linear_coefficients'))
+                      ___________                     ___________
+                   /         2                     /         2
+    [f(x) = -x - \/  C1 + 7*x   - 1, f(x) = -x + \/  C1 + 7*x   - 1]
+
+
+    References
+    ==========
+
+    - Joel Moses, "Symbolic Integration - The Stormy Decade", Communications
+      of the ACM, Volume 14, Number 8, August 1971, pp. 558
+    """
+    hint = "linear_coefficients"
+    has_integral = True
+    order = [1]
+
+    def _wilds(self, f, x, order):
+        d = Wild('d', exclude=[f(x).diff(x), f(x).diff(x, 2)])
+        e = Wild('e', exclude=[f(x).diff(x)])
+        return d, e
+
+    def _equation(self, fx, x, order):
+        d, e = self.wilds()
+        return d + e*fx.diff(x)
+
+    def _verify(self, fx):
+        self.d, self.e = self.wilds_match()
+        a, b = self.wilds()
+        F = self.d/self.e
+        x = self.ode_problem.sym
+        params = self._linear_coeff_match(F, fx)
+        if params:
+            self.xarg, self.yarg = params
+            u = Dummy('u')
+            t = Dummy('t')
+            self.y = Dummy('y')
+            # Dummy substitution for df and f(x).
+            dummy_eq = self.ode_problem.eq.subs(((fx.diff(x), t), (fx, u)))
+            reps = ((x, x + self.xarg), (u, u + self.yarg), (t, fx.diff(x)), (u, fx))
+            dummy_eq = simplify(dummy_eq.subs(reps))
+            # get the re-cast values for e and d
+            r2 = collect(expand(dummy_eq), [fx.diff(x), fx]).match(a*fx.diff(x) + b)
+            if r2:
+                self.d, self.e = r2[b], r2[a]
+                orderd = homogeneous_order(self.d, x, fx)
+                ordere = homogeneous_order(self.e, x, fx)
+                if orderd == ordere and orderd is not None:
+                    self.d = self.d.subs(fx, self.y)
+                    self.e = self.e.subs(fx, self.y)
+                    return True
+                return False
+            return False
+
+    def _linear_coeff_match(self, expr, func):
+        r"""
+        Helper function to match hint ``linear_coefficients``.
+
+        Matches the expression to the form `(a_1 x + b_1 f(x) + c_1)/(a_2 x + b_2
+        f(x) + c_2)` where the following conditions hold:
+
+        1. `a_1`, `b_1`, `c_1`, `a_2`, `b_2`, `c_2` are Rationals;
+        2. `c_1` or `c_2` are not equal to zero;
+        3. `a_2 b_1 - a_1 b_2` is not equal to zero.
+
+        Return ``xarg``, ``yarg`` where
+
+        1. ``xarg`` = `(b_2 c_1 - b_1 c_2)/(a_2 b_1 - a_1 b_2)`
+        2. ``yarg`` = `(a_1 c_2 - a_2 c_1)/(a_2 b_1 - a_1 b_2)`
+
+
+        Examples
+        ========
+
+        >>> from sympy import Function, sin
+        >>> from sympy.abc import x
+        >>> from sympy.solvers.ode.single import LinearCoefficients
+        >>> f = Function('f')
+        >>> eq = (-25*f(x) - 8*x + 62)/(4*f(x) + 11*x - 11)
+        >>> obj = LinearCoefficients(eq)
+        >>> obj._linear_coeff_match(eq, f(x))
+        (1/9, 22/9)
+        >>> eq = sin((-5*f(x) - 8*x + 6)/(4*f(x) + x - 1))
+        >>> obj = LinearCoefficients(eq)
+        >>> obj._linear_coeff_match(eq, f(x))
+        (19/27, 2/27)
+        >>> eq = sin(f(x)/x)
+        >>> obj = LinearCoefficients(eq)
+        >>> obj._linear_coeff_match(eq, f(x))
+
+        """
+        f = func.func
+        x = func.args[0]
+        def abc(eq):
+            r'''
+            Internal function of _linear_coeff_match
+            that returns Rationals a, b, c
+            if eq is a*x + b*f(x) + c, else None.
+            '''
+            eq = _mexpand(eq)
+            c = eq.as_independent(x, f(x), as_Add=True)[0]
+            if not c.is_Rational:
+                return
+            a = eq.coeff(x)
+            if not a.is_Rational:
+                return
+            b = eq.coeff(f(x))
+            if not b.is_Rational:
+                return
+            if eq == a*x + b*f(x) + c:
+                return a, b, c
+
+        def match(arg):
+            r'''
+            Internal function of _linear_coeff_match that returns Rationals a1,
+            b1, c1, a2, b2, c2 and a2*b1 - a1*b2 of the expression (a1*x + b1*f(x)
+            + c1)/(a2*x + b2*f(x) + c2) if one of c1 or c2 and a2*b1 - a1*b2 is
+            non-zero, else None.
+            '''
+            n, d = arg.together().as_numer_denom()
+            m = abc(n)
+            if m is not None:
+                a1, b1, c1 = m
+                m = abc(d)
+                if m is not None:
+                    a2, b2, c2 = m
+                    d = a2*b1 - a1*b2
+                    if (c1 or c2) and d:
+                        return a1, b1, c1, a2, b2, c2, d
+
+        m = [fi.args[0] for fi in expr.atoms(Function) if fi.func != f and
+            len(fi.args) == 1 and not fi.args[0].is_Function] or {expr}
+        m1 = match(m.pop())
+        if m1 and all(match(mi) == m1 for mi in m):
+            a1, b1, c1, a2, b2, c2, denom = m1
+            return (b2*c1 - b1*c2)/denom, (a1*c2 - a2*c1)/denom
+
+    def _get_match_object(self):
+        fx = self.ode_problem.func
+        x = self.ode_problem.sym
+        self.u1 = Dummy('u1')
+        u = Dummy('u')
+        return [self.d, self.e, fx, x, u, self.u1, self.y, self.xarg, self.yarg]
+
+
+class NthOrderReducible(SingleODESolver):
+    r"""
+    Solves ODEs that only involve derivatives of the dependent variable using
+    a substitution of the form `f^n(x) = g(x)`.
+
+    For example any second order ODE of the form `f''(x) = h(f'(x), x)` can be
+    transformed into a pair of 1st order ODEs `g'(x) = h(g(x), x)` and
+    `f'(x) = g(x)`. Usually the 1st order ODE for `g` is easier to solve. If
+    that gives an explicit solution for `g` then `f` is found simply by
+    integration.
+
+
+    Examples
+    ========
+
+    >>> from sympy import Function, dsolve, Eq
+    >>> from sympy.abc import x
+    >>> f = Function('f')
+    >>> eq = Eq(x*f(x).diff(x)**2 + f(x).diff(x, 2), 0)
+    >>> dsolve(eq, f(x), hint='nth_order_reducible')
+    ... # doctest: +NORMALIZE_WHITESPACE
+    Eq(f(x), C1 - sqrt(-1/C2)*log(-C2*sqrt(-1/C2) + x) + sqrt(-1/C2)*log(C2*sqrt(-1/C2) + x))
+
+    """
+    hint = "nth_order_reducible"
+    has_integral = False
+
+    def _matches(self):
+        # Any ODE that can be solved with a substitution and
+        # repeated integration e.g.:
+        # `d^2/dx^2(y) + x*d/dx(y) = constant
+        #f'(x) must be finite for this to work
+        eq = self.ode_problem.eq_preprocessed
+        func = self.ode_problem.func
+        x = self.ode_problem.sym
+        r"""
+        Matches any differential equation that can be rewritten with a smaller
+        order. Only derivatives of ``func`` alone, wrt a single variable,
+        are considered, and only in them should ``func`` appear.
+        """
+        # ODE only handles functions of 1 variable so this affirms that state
+        assert len(func.args) == 1
+        vc = [d.variable_count[0] for d in eq.atoms(Derivative)
+            if d.expr == func and len(d.variable_count) == 1]
+        ords = [c for v, c in vc if v == x]
+        if len(ords) < 2:
+            return False
+        self.smallest = min(ords)
+        # make sure func does not appear outside of derivatives
+        D = Dummy()
+        if eq.subs(func.diff(x, self.smallest), D).has(func):
+            return False
+        return True
+
+    def _get_general_solution(self, *, simplify_flag: bool = True):
+        eq = self.ode_problem.eq
+        f = self.ode_problem.func.func
+        x = self.ode_problem.sym
+        n = self.smallest
+        # get a unique function name for g
+        names = [a.name for a in eq.atoms(AppliedUndef)]
+        while True:
+            name = Dummy().name
+            if name not in names:
+                g = Function(name)
+                break
+        w = f(x).diff(x, n)
+        geq = eq.subs(w, g(x))
+        gsol = dsolve(geq, g(x))
+
+        if not isinstance(gsol, list):
+            gsol = [gsol]
+
+        # Might be multiple solutions to the reduced ODE:
+        fsol = []
+        for gsoli in gsol:
+            fsoli = dsolve(gsoli.subs(g(x), w), f(x))  # or do integration n times
+            fsol.append(fsoli)
+
+        return fsol
+
+
+class SecondHypergeometric(SingleODESolver):
+    r"""
+    Solves 2nd order linear differential equations.
+
+    It computes special function solutions which can be expressed using the
+    2F1, 1F1 or 0F1 hypergeometric functions.
+
+    .. math:: y'' + A(x) y' + B(x) y = 0\text{,}
+
+    where `A` and `B` are rational functions.
+
+    These kinds of differential equations have solution of non-Liouvillian form.
+
+    Given linear ODE can be obtained from 2F1 given by
+
+    .. math:: (x^2 - x) y'' + ((a + b + 1) x - c) y' + b a y = 0\text{,}
+
+    where {a, b, c} are arbitrary constants.
+
+    Notes
+    =====
+
+    The algorithm should find any solution of the form
+
+    .. math:: y = P(x) _pF_q(..; ..;\frac{\alpha x^k + \beta}{\gamma x^k + \delta})\text{,}
+
+    where pFq is any of 2F1, 1F1 or 0F1 and `P` is an "arbitrary function".
+    Currently only the 2F1 case is implemented in SymPy but the other cases are
+    described in the paper and could be implemented in future (contributions
+    welcome!).
+
+
+    Examples
+    ========
+
+    >>> from sympy import Function, dsolve, pprint
+    >>> from sympy.abc import x
+    >>> f = Function('f')
+    >>> eq = (x*x - x)*f(x).diff(x,2) + (5*x - 1)*f(x).diff(x) + 4*f(x)
+    >>> pprint(dsolve(eq, f(x), '2nd_hypergeometric'))
+                                        _
+           /        /           4  \\  |_  /-1, -1 |  \
+           |C1 + C2*|log(x) + -----||* |   |       | x|
+           \        \         x + 1// 2  1 \  1    |  /
+    f(x) = --------------------------------------------
+                                    3
+                             (x - 1)
+
+
+    References
+    ==========
+
+    - "Non-Liouvillian solutions for second order linear ODEs" by L. Chan, E.S. Cheb-Terrab
+
+    """
+    hint = "2nd_hypergeometric"
+    has_integral = True
+
+    def _matches(self):
+        eq = self.ode_problem.eq_preprocessed
+        func = self.ode_problem.func
+        r = match_2nd_hypergeometric(eq, func)
+        self.match_object = None
+        if r:
+            A, B = r
+            d = equivalence_hypergeometric(A, B, func)
+            if d:
+                if d['type'] == "2F1":
+                    self.match_object = match_2nd_2F1_hypergeometric(d['I0'], d['k'], d['sing_point'], func)
+                    if self.match_object is not None:
+                        self.match_object.update({'A':A, 'B':B})
+            # We can extend it for 1F1 and 0F1 type also.
+        return self.match_object is not None
+
+    def _get_general_solution(self, *, simplify_flag: bool = True):
+        eq = self.ode_problem.eq
+        func = self.ode_problem.func
+        if self.match_object['type'] == "2F1":
+            sol = get_sol_2F1_hypergeometric(eq, func, self.match_object)
+            if sol is None:
+                raise NotImplementedError("The given ODE " + str(eq) + " cannot be solved by"
+                    + " the hypergeometric method")
+
+        return [sol]
+
+
+class NthLinearConstantCoeffHomogeneous(SingleODESolver):
+    r"""
+    Solves an `n`\th order linear homogeneous differential equation with
+    constant coefficients.
+
+    This is an equation of the form
+
+    .. math:: a_n f^{(n)}(x) + a_{n-1} f^{(n-1)}(x) + \cdots + a_1 f'(x)
+                + a_0 f(x) = 0\text{.}
+
+    These equations can be solved in a general manner, by taking the roots of
+    the characteristic equation `a_n m^n + a_{n-1} m^{n-1} + \cdots + a_1 m +
+    a_0 = 0`.  The solution will then be the sum of `C_n x^i e^{r x}` terms,
+    for each where `C_n` is an arbitrary constant, `r` is a root of the
+    characteristic equation and `i` is one of each from 0 to the multiplicity
+    of the root - 1 (for example, a root 3 of multiplicity 2 would create the
+    terms `C_1 e^{3 x} + C_2 x e^{3 x}`).  The exponential is usually expanded
+    for complex roots using Euler's equation `e^{I x} = \cos(x) + I \sin(x)`.
+    Complex roots always come in conjugate pairs in polynomials with real
+    coefficients, so the two roots will be represented (after simplifying the
+    constants) as `e^{a x} \left(C_1 \cos(b x) + C_2 \sin(b x)\right)`.
+
+    If SymPy cannot find exact roots to the characteristic equation, a
+    :py:class:`~sympy.polys.rootoftools.ComplexRootOf` instance will be return
+    instead.
+
+    >>> from sympy import Function, dsolve
+    >>> from sympy.abc import x
+    >>> f = Function('f')
+    >>> dsolve(f(x).diff(x, 5) + 10*f(x).diff(x) - 2*f(x), f(x),
+    ... hint='nth_linear_constant_coeff_homogeneous')
+    ... # doctest: +NORMALIZE_WHITESPACE
+    Eq(f(x), C5*exp(x*CRootOf(_x**5 + 10*_x - 2, 0))
+    + (C1*sin(x*im(CRootOf(_x**5 + 10*_x - 2, 1)))
+    + C2*cos(x*im(CRootOf(_x**5 + 10*_x - 2, 1))))*exp(x*re(CRootOf(_x**5 + 10*_x - 2, 1)))
+    + (C3*sin(x*im(CRootOf(_x**5 + 10*_x - 2, 3)))
+    + C4*cos(x*im(CRootOf(_x**5 + 10*_x - 2, 3))))*exp(x*re(CRootOf(_x**5 + 10*_x - 2, 3))))
+
+    Note that because this method does not involve integration, there is no
+    ``nth_linear_constant_coeff_homogeneous_Integral`` hint.
+
+    Examples
+    ========
+
+    >>> from sympy import Function, dsolve, pprint
+    >>> from sympy.abc import x
+    >>> f = Function('f')
+    >>> pprint(dsolve(f(x).diff(x, 4) + 2*f(x).diff(x, 3) -
+    ... 2*f(x).diff(x, 2) - 6*f(x).diff(x) + 5*f(x), f(x),
+    ... hint='nth_linear_constant_coeff_homogeneous'))
+                        x                            -2*x
+    f(x) = (C1 + C2*x)*e  + (C3*sin(x) + C4*cos(x))*e
+
+    References
+    ==========
+
+    - https://en.wikipedia.org/wiki/Linear_differential_equation section:
+      Nonhomogeneous_equation_with_constant_coefficients
+    - M. Tenenbaum & H. Pollard, "Ordinary Differential Equations",
+      Dover 1963, pp. 211
+
+    # indirect doctest
+
+    """
+    hint = "nth_linear_constant_coeff_homogeneous"
+    has_integral = False
+
+    def _matches(self):
+        eq = self.ode_problem.eq_high_order_free
+        func = self.ode_problem.func
+        order = self.ode_problem.order
+        x = self.ode_problem.sym
+        self.r = self.ode_problem.get_linear_coefficients(eq, func, order)
+        if order and self.r and not any(self.r[i].has(x) for i in self.r if i >= 0):
+            if not self.r[-1]:
+                return True
+            else:
+                return False
+        return False
+
+    def _get_general_solution(self, *, simplify_flag: bool = True):
+        fx = self.ode_problem.func
+        order = self.ode_problem.order
+        roots, collectterms = _get_const_characteristic_eq_sols(self.r, fx, order)
+        # A generator of constants
+        constants = self.ode_problem.get_numbered_constants(num=len(roots))
+        gsol_rhs = Add(*[i*j for (i, j) in zip(constants, roots)])
+        gsol = Eq(fx, gsol_rhs)
+        if simplify_flag:
+            gsol = _get_simplified_sol([gsol], fx, collectterms)
+
+        return [gsol]
+
+
+class NthLinearConstantCoeffVariationOfParameters(SingleODESolver):
+    r"""
+    Solves an `n`\th order linear differential equation with constant
+    coefficients using the method of variation of parameters.
+
+    This method works on any differential equations of the form
+
+    .. math:: f^{(n)}(x) + a_{n-1} f^{(n-1)}(x) + \cdots + a_1 f'(x) + a_0
+                f(x) = P(x)\text{.}
+
+    This method works by assuming that the particular solution takes the form
+
+    .. math:: \sum_{x=1}^{n} c_i(x) y_i(x)\text{,}
+
+    where `y_i` is the `i`\th solution to the homogeneous equation.  The
+    solution is then solved using Wronskian's and Cramer's Rule.  The
+    particular solution is given by
+
+    .. math:: \sum_{x=1}^n \left( \int \frac{W_i(x)}{W(x)} \,dx
+                \right) y_i(x) \text{,}
+
+    where `W(x)` is the Wronskian of the fundamental system (the system of `n`
+    linearly independent solutions to the homogeneous equation), and `W_i(x)`
+    is the Wronskian of the fundamental system with the `i`\th column replaced
+    with `[0, 0, \cdots, 0, P(x)]`.
+
+    This method is general enough to solve any `n`\th order inhomogeneous
+    linear differential equation with constant coefficients, but sometimes
+    SymPy cannot simplify the Wronskian well enough to integrate it.  If this
+    method hangs, try using the
+    ``nth_linear_constant_coeff_variation_of_parameters_Integral`` hint and
+    simplifying the integrals manually.  Also, prefer using
+    ``nth_linear_constant_coeff_undetermined_coefficients`` when it
+    applies, because it does not use integration, making it faster and more
+    reliable.
+
+    Warning, using simplify=False with
+    'nth_linear_constant_coeff_variation_of_parameters' in
+    :py:meth:`~sympy.solvers.ode.dsolve` may cause it to hang, because it will
+    not attempt to simplify the Wronskian before integrating.  It is
+    recommended that you only use simplify=False with
+    'nth_linear_constant_coeff_variation_of_parameters_Integral' for this
+    method, especially if the solution to the homogeneous equation has
+    trigonometric functions in it.
+
+    Examples
+    ========
+
+    >>> from sympy import Function, dsolve, pprint, exp, log
+    >>> from sympy.abc import x
+    >>> f = Function('f')
+    >>> pprint(dsolve(f(x).diff(x, 3) - 3*f(x).diff(x, 2) +
+    ... 3*f(x).diff(x) - f(x) - exp(x)*log(x), f(x),
+    ... hint='nth_linear_constant_coeff_variation_of_parameters'))
+           /       /       /     x*log(x)   11*x\\\  x
+    f(x) = |C1 + x*|C2 + x*|C3 + -------- - ----|||*e
+           \       \       \        6        36 ///
+
+    References
+    ==========
+
+    - https://en.wikipedia.org/wiki/Variation_of_parameters
+    - https://planetmath.org/VariationOfParameters
+    - M. Tenenbaum & H. Pollard, "Ordinary Differential Equations",
+      Dover 1963, pp. 233
+
+    # indirect doctest
+
+    """
+    hint = "nth_linear_constant_coeff_variation_of_parameters"
+    has_integral = True
+
+    def _matches(self):
+        eq = self.ode_problem.eq_high_order_free
+        func = self.ode_problem.func
+        order = self.ode_problem.order
+        x = self.ode_problem.sym
+        self.r = self.ode_problem.get_linear_coefficients(eq, func, order)
+
+        if order and self.r and not any(self.r[i].has(x) for i in self.r if i >= 0):
+            if self.r[-1]:
+                return True
+            else:
+                return False
+        return False
+
+    def _get_general_solution(self, *, simplify_flag: bool = True):
+        eq = self.ode_problem.eq_high_order_free
+        f = self.ode_problem.func.func
+        x = self.ode_problem.sym
+        order = self.ode_problem.order
+        roots, collectterms = _get_const_characteristic_eq_sols(self.r, f(x), order)
+        # A generator of constants
+        constants = self.ode_problem.get_numbered_constants(num=len(roots))
+        homogen_sol_rhs = Add(*[i*j for (i, j) in zip(constants, roots)])
+        homogen_sol = Eq(f(x), homogen_sol_rhs)
+        homogen_sol = _solve_variation_of_parameters(eq, f(x), roots, homogen_sol, order, self.r, simplify_flag)
+        if simplify_flag:
+            homogen_sol = _get_simplified_sol([homogen_sol], f(x), collectterms)
+        return [homogen_sol]
+
+
+class NthLinearConstantCoeffUndeterminedCoefficients(SingleODESolver):
+    r"""
+    Solves an `n`\th order linear differential equation with constant
+    coefficients using the method of undetermined coefficients.
+
+    This method works on differential equations of the form
+
+    .. math:: a_n f^{(n)}(x) + a_{n-1} f^{(n-1)}(x) + \cdots + a_1 f'(x)
+                + a_0 f(x) = P(x)\text{,}
+
+    where `P(x)` is a function that has a finite number of linearly
+    independent derivatives.
+
+    Functions that fit this requirement are finite sums functions of the form
+    `a x^i e^{b x} \sin(c x + d)` or `a x^i e^{b x} \cos(c x + d)`, where `i`
+    is a non-negative integer and `a`, `b`, `c`, and `d` are constants.  For
+    example any polynomial in `x`, functions like `x^2 e^{2 x}`, `x \sin(x)`,
+    and `e^x \cos(x)` can all be used.  Products of `\sin`'s and `\cos`'s have
+    a finite number of derivatives, because they can be expanded into `\sin(a
+    x)` and `\cos(b x)` terms.  However, SymPy currently cannot do that
+    expansion, so you will need to manually rewrite the expression in terms of
+    the above to use this method.  So, for example, you will need to manually
+    convert `\sin^2(x)` into `(1 + \cos(2 x))/2` to properly apply the method
+    of undetermined coefficients on it.
+
+    This method works by creating a trial function from the expression and all
+    of its linear independent derivatives and substituting them into the
+    original ODE.  The coefficients for each term will be a system of linear
+    equations, which are be solved for and substituted, giving the solution.
+    If any of the trial functions are linearly dependent on the solution to
+    the homogeneous equation, they are multiplied by sufficient `x` to make
+    them linearly independent.
+
+    Examples
+    ========
+
+    >>> from sympy import Function, dsolve, pprint, exp, cos
+    >>> from sympy.abc import x
+    >>> f = Function('f')
+    >>> pprint(dsolve(f(x).diff(x, 2) + 2*f(x).diff(x) + f(x) -
+    ... 4*exp(-x)*x**2 + cos(2*x), f(x),
+    ... hint='nth_linear_constant_coeff_undetermined_coefficients'))
+           /       /      3\\
+           |       |     x ||  -x   4*sin(2*x)   3*cos(2*x)
+    f(x) = |C1 + x*|C2 + --||*e   - ---------- + ----------
+           \       \     3 //           25           25
+
+    References
+    ==========
+
+    - https://en.wikipedia.org/wiki/Method_of_undetermined_coefficients
+    - M. Tenenbaum & H. Pollard, "Ordinary Differential Equations",
+      Dover 1963, pp. 221
+
+    # indirect doctest
+
+    """
+    hint = "nth_linear_constant_coeff_undetermined_coefficients"
+    has_integral = False
+
+    def _matches(self):
+        eq = self.ode_problem.eq_high_order_free
+        func = self.ode_problem.func
+        order = self.ode_problem.order
+        x = self.ode_problem.sym
+        self.r = self.ode_problem.get_linear_coefficients(eq, func, order)
+        does_match = False
+        if order and self.r and not any(self.r[i].has(x) for i in self.r if i >= 0):
+            if self.r[-1]:
+                eq_homogeneous = Add(eq, -self.r[-1])
+                undetcoeff = _undetermined_coefficients_match(self.r[-1], x, func, eq_homogeneous)
+                if undetcoeff['test']:
+                    self.trialset = undetcoeff['trialset']
+                    does_match = True
+        return does_match
+
+    def _get_general_solution(self, *, simplify_flag: bool = True):
+        eq = self.ode_problem.eq
+        f = self.ode_problem.func.func
+        x = self.ode_problem.sym
+        order = self.ode_problem.order
+        roots, collectterms = _get_const_characteristic_eq_sols(self.r, f(x), order)
+        # A generator of constants
+        constants = self.ode_problem.get_numbered_constants(num=len(roots))
+        homogen_sol_rhs = Add(*[i*j for (i, j) in zip(constants, roots)])
+        homogen_sol = Eq(f(x), homogen_sol_rhs)
+        self.r.update({'list': roots, 'sol': homogen_sol, 'simpliy_flag': simplify_flag})
+        gsol = _solve_undetermined_coefficients(eq, f(x), order, self.r, self.trialset)
+        if simplify_flag:
+            gsol = _get_simplified_sol([gsol], f(x), collectterms)
+        return [gsol]
+
+
+class NthLinearEulerEqHomogeneous(SingleODESolver):
+    r"""
+    Solves an `n`\th order linear homogeneous variable-coefficient
+    Cauchy-Euler equidimensional ordinary differential equation.
+
+    This is an equation with form `0 = a_0 f(x) + a_1 x f'(x) + a_2 x^2 f''(x)
+    \cdots`.
+
+    These equations can be solved in a general manner, by substituting
+    solutions of the form `f(x) = x^r`, and deriving a characteristic equation
+    for `r`.  When there are repeated roots, we include extra terms of the
+    form `C_{r k} \ln^k(x) x^r`, where `C_{r k}` is an arbitrary integration
+    constant, `r` is a root of the characteristic equation, and `k` ranges
+    over the multiplicity of `r`.  In the cases where the roots are complex,
+    solutions of the form `C_1 x^a \sin(b \log(x)) + C_2 x^a \cos(b \log(x))`
+    are returned, based on expansions with Euler's formula.  The general
+    solution is the sum of the terms found.  If SymPy cannot find exact roots
+    to the characteristic equation, a
+    :py:obj:`~.ComplexRootOf` instance will be returned
+    instead.
+
+    >>> from sympy import Function, dsolve
+    >>> from sympy.abc import x
+    >>> f = Function('f')
+    >>> dsolve(4*x**2*f(x).diff(x, 2) + f(x), f(x),
+    ... hint='nth_linear_euler_eq_homogeneous')
+    ... # doctest: +NORMALIZE_WHITESPACE
+    Eq(f(x), sqrt(x)*(C1 + C2*log(x)))
+
+    Note that because this method does not involve integration, there is no
+    ``nth_linear_euler_eq_homogeneous_Integral`` hint.
+
+    The following is for internal use:
+
+    - ``returns = 'sol'`` returns the solution to the ODE.
+    - ``returns = 'list'`` returns a list of linearly independent solutions,
+      corresponding to the fundamental solution set, for use with non
+      homogeneous solution methods like variation of parameters and
+      undetermined coefficients.  Note that, though the solutions should be
+      linearly independent, this function does not explicitly check that.  You
+      can do ``assert simplify(wronskian(sollist)) != 0`` to check for linear
+      independence.  Also, ``assert len(sollist) == order`` will need to pass.
+    - ``returns = 'both'``, return a dictionary ``{'sol': <solution to ODE>,
+      'list': <list of linearly independent solutions>}``.
+
+    Examples
+    ========
+
+    >>> from sympy import Function, dsolve, pprint
+    >>> from sympy.abc import x
+    >>> f = Function('f')
+    >>> eq = f(x).diff(x, 2)*x**2 - 4*f(x).diff(x)*x + 6*f(x)
+    >>> pprint(dsolve(eq, f(x),
+    ... hint='nth_linear_euler_eq_homogeneous'))
+            2
+    f(x) = x *(C1 + C2*x)
+
+    References
+    ==========
+
+    - https://en.wikipedia.org/wiki/Cauchy%E2%80%93Euler_equation
+    - C. Bender & S. Orszag, "Advanced Mathematical Methods for Scientists and
+      Engineers", Springer 1999, pp. 12
+
+    # indirect doctest
+
+    """
+    hint = "nth_linear_euler_eq_homogeneous"
+    has_integral = False
+
+    def _matches(self):
+        eq = self.ode_problem.eq_preprocessed
+        f = self.ode_problem.func.func
+        order = self.ode_problem.order
+        x = self.ode_problem.sym
+        match = self.ode_problem.get_linear_coefficients(eq, f(x), order)
+        self.r = None
+        does_match = False
+
+        if order and match:
+            coeff = match[order]
+            factor = x**order / coeff
+            self.r = {i: factor*match[i] for i in match}
+        if self.r and all(_test_term(self.r[i], f(x), i) for i in
+                          self.r if i >= 0):
+            if not self.r[-1]:
+                does_match = True
+        return does_match
+
+    def _get_general_solution(self, *, simplify_flag: bool = True):
+        fx = self.ode_problem.func
+        eq = self.ode_problem.eq
+        homogen_sol = _get_euler_characteristic_eq_sols(eq, fx, self.r)[0]
+        return [homogen_sol]
+
+
+class NthLinearEulerEqNonhomogeneousVariationOfParameters(SingleODESolver):
+    r"""
+    Solves an `n`\th order linear non homogeneous Cauchy-Euler equidimensional
+    ordinary differential equation using variation of parameters.
+
+    This is an equation with form `g(x) = a_0 f(x) + a_1 x f'(x) + a_2 x^2 f''(x)
+    \cdots`.
+
+    This method works by assuming that the particular solution takes the form
+
+    .. math:: \sum_{x=1}^{n} c_i(x) y_i(x) {a_n} {x^n} \text{, }
+
+    where `y_i` is the `i`\th solution to the homogeneous equation.  The
+    solution is then solved using Wronskian's and Cramer's Rule.  The
+    particular solution is given by multiplying eq given below with `a_n x^{n}`
+
+    .. math:: \sum_{x=1}^n \left( \int \frac{W_i(x)}{W(x)} \, dx
+                \right) y_i(x) \text{, }
+
+    where `W(x)` is the Wronskian of the fundamental system (the system of `n`
+    linearly independent solutions to the homogeneous equation), and `W_i(x)`
+    is the Wronskian of the fundamental system with the `i`\th column replaced
+    with `[0, 0, \cdots, 0, \frac{x^{- n}}{a_n} g{\left(x \right)}]`.
+
+    This method is general enough to solve any `n`\th order inhomogeneous
+    linear differential equation, but sometimes SymPy cannot simplify the
+    Wronskian well enough to integrate it.  If this method hangs, try using the
+    ``nth_linear_constant_coeff_variation_of_parameters_Integral`` hint and
+    simplifying the integrals manually.  Also, prefer using
+    ``nth_linear_constant_coeff_undetermined_coefficients`` when it
+    applies, because it does not use integration, making it faster and more
+    reliable.
+
+    Warning, using simplify=False with
+    'nth_linear_constant_coeff_variation_of_parameters' in
+    :py:meth:`~sympy.solvers.ode.dsolve` may cause it to hang, because it will
+    not attempt to simplify the Wronskian before integrating.  It is
+    recommended that you only use simplify=False with
+    'nth_linear_constant_coeff_variation_of_parameters_Integral' for this
+    method, especially if the solution to the homogeneous equation has
+    trigonometric functions in it.
+
+    Examples
+    ========
+
+    >>> from sympy import Function, dsolve, Derivative
+    >>> from sympy.abc import x
+    >>> f = Function('f')
+    >>> eq = x**2*Derivative(f(x), x, x) - 2*x*Derivative(f(x), x) + 2*f(x) - x**4
+    >>> dsolve(eq, f(x),
+    ... hint='nth_linear_euler_eq_nonhomogeneous_variation_of_parameters').expand()
+    Eq(f(x), C1*x + C2*x**2 + x**4/6)
+
+    """
+    hint = "nth_linear_euler_eq_nonhomogeneous_variation_of_parameters"
+    has_integral = True
+
+    def _matches(self):
+        eq = self.ode_problem.eq_preprocessed
+        f = self.ode_problem.func.func
+        order = self.ode_problem.order
+        x = self.ode_problem.sym
+        match = self.ode_problem.get_linear_coefficients(eq, f(x), order)
+        self.r = None
+        does_match = False
+
+        if order and match:
+            coeff = match[order]
+            factor = x**order / coeff
+            self.r = {i: factor*match[i] for i in match}
+        if self.r and all(_test_term(self.r[i], f(x), i) for i in
+                          self.r if i >= 0):
+            if self.r[-1]:
+                does_match = True
+
+        return does_match
+
+    def _get_general_solution(self, *, simplify_flag: bool = True):
+        eq = self.ode_problem.eq
+        f = self.ode_problem.func.func
+        x = self.ode_problem.sym
+        order = self.ode_problem.order
+        homogen_sol, roots = _get_euler_characteristic_eq_sols(eq, f(x), self.r)
+        self.r[-1] = self.r[-1]/self.r[order]
+        sol = _solve_variation_of_parameters(eq, f(x), roots, homogen_sol, order, self.r, simplify_flag)
+
+        return [Eq(f(x), homogen_sol.rhs + (sol.rhs - homogen_sol.rhs)*self.r[order])]
+
+
+class NthLinearEulerEqNonhomogeneousUndeterminedCoefficients(SingleODESolver):
+    r"""
+    Solves an `n`\th order linear non homogeneous Cauchy-Euler equidimensional
+    ordinary differential equation using undetermined coefficients.
+
+    This is an equation with form `g(x) = a_0 f(x) + a_1 x f'(x) + a_2 x^2 f''(x)
+    \cdots`.
+
+    These equations can be solved in a general manner, by substituting
+    solutions of the form `x = exp(t)`, and deriving a characteristic equation
+    of form `g(exp(t)) = b_0 f(t) + b_1 f'(t) + b_2 f''(t) \cdots` which can
+    be then solved by nth_linear_constant_coeff_undetermined_coefficients if
+    g(exp(t)) has finite number of linearly independent derivatives.
+
+    Functions that fit this requirement are finite sums functions of the form
+    `a x^i e^{b x} \sin(c x + d)` or `a x^i e^{b x} \cos(c x + d)`, where `i`
+    is a non-negative integer and `a`, `b`, `c`, and `d` are constants.  For
+    example any polynomial in `x`, functions like `x^2 e^{2 x}`, `x \sin(x)`,
+    and `e^x \cos(x)` can all be used.  Products of `\sin`'s and `\cos`'s have
+    a finite number of derivatives, because they can be expanded into `\sin(a
+    x)` and `\cos(b x)` terms.  However, SymPy currently cannot do that
+    expansion, so you will need to manually rewrite the expression in terms of
+    the above to use this method.  So, for example, you will need to manually
+    convert `\sin^2(x)` into `(1 + \cos(2 x))/2` to properly apply the method
+    of undetermined coefficients on it.
+
+    After replacement of x by exp(t), this method works by creating a trial function
+    from the expression and all of its linear independent derivatives and
+    substituting them into the original ODE.  The coefficients for each term
+    will be a system of linear equations, which are be solved for and
+    substituted, giving the solution. If any of the trial functions are linearly
+    dependent on the solution to the homogeneous equation, they are multiplied
+    by sufficient `x` to make them linearly independent.
+
+    Examples
+    ========
+
+    >>> from sympy import dsolve, Function, Derivative, log
+    >>> from sympy.abc import x
+    >>> f = Function('f')
+    >>> eq = x**2*Derivative(f(x), x, x) - 2*x*Derivative(f(x), x) + 2*f(x) - log(x)
+    >>> dsolve(eq, f(x),
+    ... hint='nth_linear_euler_eq_nonhomogeneous_undetermined_coefficients').expand()
+    Eq(f(x), C1*x + C2*x**2 + log(x)/2 + 3/4)
+
+    """
+    hint = "nth_linear_euler_eq_nonhomogeneous_undetermined_coefficients"
+    has_integral = False
+
+    def _matches(self):
+        eq = self.ode_problem.eq_high_order_free
+        f = self.ode_problem.func.func
+        order = self.ode_problem.order
+        x = self.ode_problem.sym
+        match = self.ode_problem.get_linear_coefficients(eq, f(x), order)
+        self.r = None
+        does_match = False
+
+        if order and match:
+            coeff = match[order]
+            factor = x**order / coeff
+            self.r = {i: factor*match[i] for i in match}
+        if self.r and all(_test_term(self.r[i], f(x), i) for i in
+                          self.r if i >= 0):
+            if self.r[-1]:
+                e, re = posify(self.r[-1].subs(x, exp(x)))
+                undetcoeff = _undetermined_coefficients_match(e.subs(re), x)
+                if undetcoeff['test']:
+                    does_match = True
+        return does_match
+
+    def _get_general_solution(self, *, simplify_flag: bool = True):
+        f = self.ode_problem.func.func
+        x = self.ode_problem.sym
+        chareq, eq, symbol = S.Zero, S.Zero, Dummy('x')
+        for i in self.r.keys():
+            if i >= 0:
+                chareq += (self.r[i]*diff(x**symbol, x, i)*x**-symbol).expand()
+
+        for i in range(1, degree(Poly(chareq, symbol))+1):
+            eq += chareq.coeff(symbol**i)*diff(f(x), x, i)
+
+        if chareq.as_coeff_add(symbol)[0]:
+            eq += chareq.as_coeff_add(symbol)[0]*f(x)
+        e, re = posify(self.r[-1].subs(x, exp(x)))
+        eq += e.subs(re)
+
+        self.const_undet_instance = NthLinearConstantCoeffUndeterminedCoefficients(SingleODEProblem(eq, f(x), x))
+        sol = self.const_undet_instance.get_general_solution(simplify = simplify_flag)[0]
+        sol = sol.subs(x, log(x)) # type: ignore
+        sol = sol.subs(f(log(x)), f(x)).expand() # type: ignore
+
+        return [sol]
+
+
+class SecondLinearBessel(SingleODESolver):
+    r"""
+    Gives solution of the Bessel differential equation
+
+    .. math :: x^2 \frac{d^2y}{dx^2} + x \frac{dy}{dx} y(x) + (x^2-n^2) y(x)
+
+    if `n` is integer then the solution is of the form ``Eq(f(x), C0 besselj(n,x)
+    + C1 bessely(n,x))`` as both the solutions are linearly independent else if
+    `n` is a fraction then the solution is of the form ``Eq(f(x), C0 besselj(n,x)
+    + C1 besselj(-n,x))`` which can also transform into ``Eq(f(x), C0 besselj(n,x)
+    + C1 bessely(n,x))``.
+
+    Examples
+    ========
+
+    >>> from sympy.abc import x
+    >>> from sympy import Symbol
+    >>> v = Symbol('v', positive=True)
+    >>> from sympy import dsolve, Function
+    >>> f = Function('f')
+    >>> y = f(x)
+    >>> genform = x**2*y.diff(x, 2) + x*y.diff(x) + (x**2 - v**2)*y
+    >>> dsolve(genform)
+    Eq(f(x), C1*besselj(v, x) + C2*bessely(v, x))
+
+    References
+    ==========
+
+    https://math24.net/bessel-differential-equation.html
+
+    """
+    hint = "2nd_linear_bessel"
+    has_integral = False
+
+    def _matches(self):
+        eq = self.ode_problem.eq_high_order_free
+        f = self.ode_problem.func
+        order = self.ode_problem.order
+        x = self.ode_problem.sym
+        df = f.diff(x)
+        a = Wild('a', exclude=[f,df])
+        b = Wild('b', exclude=[x, f,df])
+        a4 = Wild('a4', exclude=[x,f,df])
+        b4 = Wild('b4', exclude=[x,f,df])
+        c4 = Wild('c4', exclude=[x,f,df])
+        d4 = Wild('d4', exclude=[x,f,df])
+        a3 = Wild('a3', exclude=[f, df, f.diff(x, 2)])
+        b3 = Wild('b3', exclude=[f, df, f.diff(x, 2)])
+        c3 = Wild('c3', exclude=[f, df, f.diff(x, 2)])
+        deq = a3*(f.diff(x, 2)) + b3*df + c3*f
+        r = collect(eq,
+            [f.diff(x, 2), df, f]).match(deq)
+        if order == 2 and r:
+            if not all(r[key].is_polynomial() for key in r):
+                n, d = eq.as_numer_denom()
+                eq = expand(n)
+                r = collect(eq,
+                    [f.diff(x, 2), df, f]).match(deq)
+
+        if r and r[a3] != 0:
+            # leading coeff of f(x).diff(x, 2)
+            coeff = factor(r[a3]).match(a4*(x-b)**b4)
+
+            if coeff:
+            # if coeff[b4] = 0 means constant coefficient
+                if coeff[b4] == 0:
+                    return False
+                point = coeff[b]
+            else:
+                return False
+
+            if point:
+                r[a3] = simplify(r[a3].subs(x, x+point))
+                r[b3] = simplify(r[b3].subs(x, x+point))
+                r[c3] = simplify(r[c3].subs(x, x+point))
+
+            # making a3 in the form of x**2
+            r[a3] = cancel(r[a3]/(coeff[a4]*(x)**(-2+coeff[b4])))
+            r[b3] = cancel(r[b3]/(coeff[a4]*(x)**(-2+coeff[b4])))
+            r[c3] = cancel(r[c3]/(coeff[a4]*(x)**(-2+coeff[b4])))
+            # checking if b3 is of form c*(x-b)
+            coeff1 = factor(r[b3]).match(a4*(x))
+            if coeff1 is None:
+                return False
+            # c3 maybe of very complex form so I am simply checking (a - b) form
+            # if yes later I will match with the standard form of bessel in a and b
+            # a, b are wild variable defined above.
+            _coeff2 = expand(r[c3]).match(a - b)
+            if _coeff2 is None:
+                return False
+            # matching with standard form for c3
+            coeff2 = factor(_coeff2[a]).match(c4**2*(x)**(2*a4))
+            if coeff2 is None:
+                return False
+
+            if _coeff2[b] == 0:
+                coeff2[d4] = 0
+            else:
+                coeff2[d4] = factor(_coeff2[b]).match(d4**2)[d4]
+
+            self.rn = {'n':coeff2[d4], 'a4':coeff2[c4], 'd4':coeff2[a4]}
+            self.rn['c4'] = coeff1[a4]
+            self.rn['b4'] = point
+            return True
+        return False
+
+    def _get_general_solution(self, *, simplify_flag: bool = True):
+        f = self.ode_problem.func.func
+        x = self.ode_problem.sym
+        n = self.rn['n']
+        a4 = self.rn['a4']
+        c4 = self.rn['c4']
+        d4 = self.rn['d4']
+        b4 = self.rn['b4']
+        n = sqrt(n**2 + Rational(1, 4)*(c4 - 1)**2)
+        (C1, C2) = self.ode_problem.get_numbered_constants(num=2)
+        return [Eq(f(x), ((x**(Rational(1-c4,2)))*(C1*besselj(n/d4,a4*x**d4/d4)
+            + C2*bessely(n/d4,a4*x**d4/d4))).subs(x, x-b4))]
+
+
+class SecondLinearAiry(SingleODESolver):
+    r"""
+    Gives solution of the Airy differential equation
+
+    .. math :: \frac{d^2y}{dx^2} + (a + b x) y(x) = 0
+
+    in terms of Airy special functions airyai and airybi.
+
+    Examples
+    ========
+
+    >>> from sympy import dsolve, Function
+    >>> from sympy.abc import x
+    >>> f = Function("f")
+    >>> eq = f(x).diff(x, 2) - x*f(x)
+    >>> dsolve(eq)
+    Eq(f(x), C1*airyai(x) + C2*airybi(x))
+    """
+    hint = "2nd_linear_airy"
+    has_integral = False
+
+    def _matches(self):
+        eq = self.ode_problem.eq_high_order_free
+        f = self.ode_problem.func
+        order = self.ode_problem.order
+        x = self.ode_problem.sym
+        df = f.diff(x)
+        a4 = Wild('a4', exclude=[x,f,df])
+        b4 = Wild('b4', exclude=[x,f,df])
+        match = self.ode_problem.get_linear_coefficients(eq, f, order)
+        does_match = False
+        if order == 2 and match and match[2] != 0:
+            if match[1].is_zero:
+                self.rn = cancel(match[0]/match[2]).match(a4+b4*x)
+                if self.rn and self.rn[b4] != 0:
+                    self.rn = {'b':self.rn[a4],'m':self.rn[b4]}
+                    does_match = True
+        return does_match
+
+    def _get_general_solution(self, *, simplify_flag: bool = True):
+        f = self.ode_problem.func.func
+        x = self.ode_problem.sym
+        (C1, C2) = self.ode_problem.get_numbered_constants(num=2)
+        b = self.rn['b']
+        m = self.rn['m']
+        if m.is_positive:
+            arg = - b/cbrt(m)**2 - cbrt(m)*x
+        elif m.is_negative:
+            arg = - b/cbrt(-m)**2 + cbrt(-m)*x
+        else:
+            arg = - b/cbrt(-m)**2 + cbrt(-m)*x
+
+        return [Eq(f(x), C1*airyai(arg) + C2*airybi(arg))]
+
+
+class LieGroup(SingleODESolver):
+    r"""
+    This hint implements the Lie group method of solving first order differential
+    equations. The aim is to convert the given differential equation from the
+    given coordinate system into another coordinate system where it becomes
+    invariant under the one-parameter Lie group of translations. The converted
+    ODE can be easily solved by quadrature. It makes use of the
+    :py:meth:`sympy.solvers.ode.infinitesimals` function which returns the
+    infinitesimals of the transformation.
+
+    The coordinates `r` and `s` can be found by solving the following Partial
+    Differential Equations.
+
+    .. math :: \xi\frac{\partial r}{\partial x} + \eta\frac{\partial r}{\partial y}
+                  = 0
+
+    .. math :: \xi\frac{\partial s}{\partial x} + \eta\frac{\partial s}{\partial y}
+                  = 1
+
+    The differential equation becomes separable in the new coordinate system
+
+    .. math :: \frac{ds}{dr} = \frac{\frac{\partial s}{\partial x} +
+                 h(x, y)\frac{\partial s}{\partial y}}{
+                 \frac{\partial r}{\partial x} + h(x, y)\frac{\partial r}{\partial y}}
+
+    After finding the solution by integration, it is then converted back to the original
+    coordinate system by substituting `r` and `s` in terms of `x` and `y` again.
+
+    Examples
+    ========
+
+    >>> from sympy import Function, dsolve, exp, pprint
+    >>> from sympy.abc import x
+    >>> f = Function('f')
+    >>> pprint(dsolve(f(x).diff(x) + 2*x*f(x) - x*exp(-x**2), f(x),
+    ... hint='lie_group'))
+           /      2\    2
+           |     x |  -x
+    f(x) = |C1 + --|*e
+           \     2 /
+
+
+    References
+    ==========
+
+    - Solving differential equations by Symmetry Groups,
+      John Starrett, pp. 1 - pp. 14
+
+    """
+    hint = "lie_group"
+    has_integral = False
+
+    def _has_additional_params(self):
+        return 'xi' in self.ode_problem.params and 'eta' in self.ode_problem.params
+
+    def _matches(self):
+        eq = self.ode_problem.eq
+        f = self.ode_problem.func.func
+        order = self.ode_problem.order
+        x = self.ode_problem.sym
+        df = f(x).diff(x)
+        y = Dummy('y')
+        d = Wild('d', exclude=[df, f(x).diff(x, 2)])
+        e = Wild('e', exclude=[df])
+        does_match = False
+        if self._has_additional_params() and order == 1:
+            xi = self.ode_problem.params['xi']
+            eta = self.ode_problem.params['eta']
+            self.r3 = {'xi': xi, 'eta': eta}
+            r = collect(eq, df, exact=True).match(d + e * df)
+            if r:
+                r['d'] = d
+                r['e'] = e
+                r['y'] = y
+                r[d] = r[d].subs(f(x), y)
+                r[e] = r[e].subs(f(x), y)
+                self.r3.update(r)
+            does_match = True
+        return does_match
+
+    def _get_general_solution(self, *, simplify_flag: bool = True):
+        eq = self.ode_problem.eq
+        x = self.ode_problem.sym
+        func = self.ode_problem.func
+        order = self.ode_problem.order
+        df = func.diff(x)
+
+        try:
+            eqsol = solve(eq, df)
+        except NotImplementedError:
+            eqsol = []
+
+        desols = []
+        for s in eqsol:
+            sol = _ode_lie_group(s, func, order, match=self.r3)
+            if sol:
+                desols.extend(sol)
+
+        if desols == []:
+            raise NotImplementedError("The given ODE " + str(eq) + " cannot be solved by"
+                + " the lie group method")
+        return desols
+
+
+solver_map = {
+    'factorable': Factorable,
+    'nth_linear_constant_coeff_homogeneous': NthLinearConstantCoeffHomogeneous,
+    'nth_linear_euler_eq_homogeneous': NthLinearEulerEqHomogeneous,
+    'nth_linear_constant_coeff_undetermined_coefficients': NthLinearConstantCoeffUndeterminedCoefficients,
+    'nth_linear_euler_eq_nonhomogeneous_undetermined_coefficients': NthLinearEulerEqNonhomogeneousUndeterminedCoefficients,
+    'separable': Separable,
+    '1st_exact': FirstExact,
+    '1st_linear': FirstLinear,
+    'Bernoulli': Bernoulli,
+    'Riccati_special_minus2': RiccatiSpecial,
+    '1st_rational_riccati': RationalRiccati,
+    '1st_homogeneous_coeff_best': HomogeneousCoeffBest,
+    '1st_homogeneous_coeff_subs_indep_div_dep': HomogeneousCoeffSubsIndepDivDep,
+    '1st_homogeneous_coeff_subs_dep_div_indep': HomogeneousCoeffSubsDepDivIndep,
+    'almost_linear': AlmostLinear,
+    'linear_coefficients': LinearCoefficients,
+    'separable_reduced': SeparableReduced,
+    'nth_linear_constant_coeff_variation_of_parameters': NthLinearConstantCoeffVariationOfParameters,
+    'nth_linear_euler_eq_nonhomogeneous_variation_of_parameters': NthLinearEulerEqNonhomogeneousVariationOfParameters,
+    'Liouville': Liouville,
+    '2nd_linear_airy': SecondLinearAiry,
+    '2nd_linear_bessel': SecondLinearBessel,
+    '2nd_hypergeometric': SecondHypergeometric,
+    'nth_order_reducible': NthOrderReducible,
+    '2nd_nonlinear_autonomous_conserved': SecondNonlinearAutonomousConserved,
+    'nth_algebraic': NthAlgebraic,
+    'lie_group': LieGroup,
+    }
+
+# Avoid circular import:
+from .ode import dsolve, ode_sol_simplicity, odesimp, homogeneous_order
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/ode/subscheck.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/ode/subscheck.py
new file mode 100644
index 0000000000000000000000000000000000000000..6ac7fba7d364bf599e928ccf591b5bef096576d0
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/ode/subscheck.py
@@ -0,0 +1,392 @@
+from sympy.core import S, Pow
+from sympy.core.function import (Derivative, AppliedUndef, diff)
+from sympy.core.relational import Equality, Eq
+from sympy.core.symbol import Dummy
+from sympy.core.sympify import sympify
+
+from sympy.logic.boolalg import BooleanAtom
+from sympy.functions import exp
+from sympy.series import Order
+from sympy.simplify.simplify import simplify, posify, besselsimp
+from sympy.simplify.trigsimp import trigsimp
+from sympy.simplify.sqrtdenest import sqrtdenest
+from sympy.solvers import solve
+from sympy.solvers.deutils import _preprocess, ode_order
+from sympy.utilities.iterables import iterable, is_sequence
+
+
+def sub_func_doit(eq, func, new):
+    r"""
+    When replacing the func with something else, we usually want the
+    derivative evaluated, so this function helps in making that happen.
+
+    Examples
+    ========
+
+    >>> from sympy import Derivative, symbols, Function
+    >>> from sympy.solvers.ode.subscheck import sub_func_doit
+    >>> x, z = symbols('x, z')
+    >>> y = Function('y')
+
+    >>> sub_func_doit(3*Derivative(y(x), x) - 1, y(x), x)
+    2
+
+    >>> sub_func_doit(x*Derivative(y(x), x) - y(x)**2 + y(x), y(x),
+    ... 1/(x*(z + 1/x)))
+    x*(-1/(x**2*(z + 1/x)) + 1/(x**3*(z + 1/x)**2)) + 1/(x*(z + 1/x))
+    ...- 1/(x**2*(z + 1/x)**2)
+    """
+    reps= {func: new}
+    for d in eq.atoms(Derivative):
+        if d.expr == func:
+            reps[d] = new.diff(*d.variable_count)
+        else:
+            reps[d] = d.xreplace({func: new}).doit(deep=False)
+    return eq.xreplace(reps)
+
+
+def checkodesol(ode, sol, func=None, order='auto', solve_for_func=True):
+    r"""
+    Substitutes ``sol`` into ``ode`` and checks that the result is ``0``.
+
+    This works when ``func`` is one function, like `f(x)` or a list of
+    functions like `[f(x), g(x)]` when `ode` is a system of ODEs.  ``sol`` can
+    be a single solution or a list of solutions.  Each solution may be an
+    :py:class:`~sympy.core.relational.Equality` that the solution satisfies,
+    e.g. ``Eq(f(x), C1), Eq(f(x) + C1, 0)``; or simply an
+    :py:class:`~sympy.core.expr.Expr`, e.g. ``f(x) - C1``. In most cases it
+    will not be necessary to explicitly identify the function, but if the
+    function cannot be inferred from the original equation it can be supplied
+    through the ``func`` argument.
+
+    If a sequence of solutions is passed, the same sort of container will be
+    used to return the result for each solution.
+
+    It tries the following methods, in order, until it finds zero equivalence:
+
+    1. Substitute the solution for `f` in the original equation.  This only
+       works if ``ode`` is solved for `f`.  It will attempt to solve it first
+       unless ``solve_for_func == False``.
+    2. Take `n` derivatives of the solution, where `n` is the order of
+       ``ode``, and check to see if that is equal to the solution.  This only
+       works on exact ODEs.
+    3. Take the 1st, 2nd, ..., `n`\th derivatives of the solution, each time
+       solving for the derivative of `f` of that order (this will always be
+       possible because `f` is a linear operator). Then back substitute each
+       derivative into ``ode`` in reverse order.
+
+    This function returns a tuple.  The first item in the tuple is ``True`` if
+    the substitution results in ``0``, and ``False`` otherwise. The second
+    item in the tuple is what the substitution results in.  It should always
+    be ``0`` if the first item is ``True``. Sometimes this function will
+    return ``False`` even when an expression is identically equal to ``0``.
+    This happens when :py:meth:`~sympy.simplify.simplify.simplify` does not
+    reduce the expression to ``0``.  If an expression returned by this
+    function vanishes identically, then ``sol`` really is a solution to
+    the ``ode``.
+
+    If this function seems to hang, it is probably because of a hard
+    simplification.
+
+    To use this function to test, test the first item of the tuple.
+
+    Examples
+    ========
+
+    >>> from sympy import (Eq, Function, checkodesol, symbols,
+    ...     Derivative, exp)
+    >>> x, C1, C2 = symbols('x,C1,C2')
+    >>> f, g = symbols('f g', cls=Function)
+    >>> checkodesol(f(x).diff(x), Eq(f(x), C1))
+    (True, 0)
+    >>> assert checkodesol(f(x).diff(x), C1)[0]
+    >>> assert not checkodesol(f(x).diff(x), x)[0]
+    >>> checkodesol(f(x).diff(x, 2), x**2)
+    (False, 2)
+
+    >>> eqs = [Eq(Derivative(f(x), x), f(x)), Eq(Derivative(g(x), x), g(x))]
+    >>> sol = [Eq(f(x), C1*exp(x)), Eq(g(x), C2*exp(x))]
+    >>> checkodesol(eqs, sol)
+    (True, [0, 0])
+
+    """
+    if iterable(ode):
+        return checksysodesol(ode, sol, func=func)
+
+    if not isinstance(ode, Equality):
+        ode = Eq(ode, 0)
+    if func is None:
+        try:
+            _, func = _preprocess(ode.lhs)
+        except ValueError:
+            funcs = [s.atoms(AppliedUndef) for s in (
+                sol if is_sequence(sol, set) else [sol])]
+            funcs = set().union(*funcs)
+            if len(funcs) != 1:
+                raise ValueError(
+                    'must pass func arg to checkodesol for this case.')
+            func = funcs.pop()
+    if not isinstance(func, AppliedUndef) or len(func.args) != 1:
+        raise ValueError(
+            "func must be a function of one variable, not %s" % func)
+    if is_sequence(sol, set):
+        return type(sol)([checkodesol(ode, i, order=order, solve_for_func=solve_for_func) for i in sol])
+
+    if not isinstance(sol, Equality):
+        sol = Eq(func, sol)
+    elif sol.rhs == func:
+        sol = sol.reversed
+
+    if order == 'auto':
+        order = ode_order(ode, func)
+    solved = sol.lhs == func and not sol.rhs.has(func)
+    if solve_for_func and not solved:
+        rhs = solve(sol, func)
+        if rhs:
+            eqs = [Eq(func, t) for t in rhs]
+            if len(rhs) == 1:
+                eqs = eqs[0]
+            return checkodesol(ode, eqs, order=order,
+                solve_for_func=False)
+
+    x = func.args[0]
+
+    # Handle series solutions here
+    if sol.has(Order):
+        assert sol.lhs == func
+        Oterm = sol.rhs.getO()
+        solrhs = sol.rhs.removeO()
+
+        Oexpr = Oterm.expr
+        assert isinstance(Oexpr, Pow)
+        sorder = Oexpr.exp
+        assert Oterm == Order(x**sorder)
+
+        odesubs = (ode.lhs-ode.rhs).subs(func, solrhs).doit().expand()
+
+        neworder = Order(x**(sorder - order))
+        odesubs = odesubs + neworder
+        assert odesubs.getO() == neworder
+        residual = odesubs.removeO()
+
+        return (residual == 0, residual)
+
+    s = True
+    testnum = 0
+    while s:
+        if testnum == 0:
+            # First pass, try substituting a solved solution directly into the
+            # ODE. This has the highest chance of succeeding.
+            ode_diff = ode.lhs - ode.rhs
+
+            if sol.lhs == func:
+                s = sub_func_doit(ode_diff, func, sol.rhs)
+                s = besselsimp(s)
+            else:
+                testnum += 1
+                continue
+            ss = simplify(s.rewrite(exp))
+            if ss:
+                # with the new numer_denom in power.py, if we do a simple
+                # expansion then testnum == 0 verifies all solutions.
+                s = ss.expand(force=True)
+            else:
+                s = 0
+            testnum += 1
+        elif testnum == 1:
+            # Second pass. If we cannot substitute f, try seeing if the nth
+            # derivative is equal, this will only work for odes that are exact,
+            # by definition.
+            s = simplify(
+                trigsimp(diff(sol.lhs, x, order) - diff(sol.rhs, x, order)) -
+                trigsimp(ode.lhs) + trigsimp(ode.rhs))
+            # s2 = simplify(
+            #     diff(sol.lhs, x, order) - diff(sol.rhs, x, order) - \
+            #     ode.lhs + ode.rhs)
+            testnum += 1
+        elif testnum == 2:
+            # Third pass. Try solving for df/dx and substituting that into the
+            # ODE. Thanks to Chris Smith for suggesting this method.  Many of
+            # the comments below are his, too.
+            # The method:
+            # - Take each of 1..n derivatives of the solution.
+            # - Solve each nth derivative for d^(n)f/dx^(n)
+            #   (the differential of that order)
+            # - Back substitute into the ODE in decreasing order
+            #   (i.e., n, n-1, ...)
+            # - Check the result for zero equivalence
+            if sol.lhs == func and not sol.rhs.has(func):
+                diffsols = {0: sol.rhs}
+            elif sol.rhs == func and not sol.lhs.has(func):
+                diffsols = {0: sol.lhs}
+            else:
+                diffsols = {}
+            sol = sol.lhs - sol.rhs
+            for i in range(1, order + 1):
+                # Differentiation is a linear operator, so there should always
+                # be 1 solution. Nonetheless, we test just to make sure.
+                # We only need to solve once.  After that, we automatically
+                # have the solution to the differential in the order we want.
+                if i == 1:
+                    ds = sol.diff(x)
+                    try:
+                        sdf = solve(ds, func.diff(x, i))
+                        if not sdf:
+                            raise NotImplementedError
+                    except NotImplementedError:
+                        testnum += 1
+                        break
+                    else:
+                        diffsols[i] = sdf[0]
+                else:
+                    # This is what the solution says df/dx should be.
+                    diffsols[i] = diffsols[i - 1].diff(x)
+
+            # Make sure the above didn't fail.
+            if testnum > 2:
+                continue
+            else:
+                # Substitute it into ODE to check for self consistency.
+                lhs, rhs = ode.lhs, ode.rhs
+                for i in range(order, -1, -1):
+                    if i == 0 and 0 not in diffsols:
+                        # We can only substitute f(x) if the solution was
+                        # solved for f(x).
+                        break
+                    lhs = sub_func_doit(lhs, func.diff(x, i), diffsols[i])
+                    rhs = sub_func_doit(rhs, func.diff(x, i), diffsols[i])
+                    ode_or_bool = Eq(lhs, rhs)
+                    ode_or_bool = simplify(ode_or_bool)
+
+                    if isinstance(ode_or_bool, (bool, BooleanAtom)):
+                        if ode_or_bool:
+                            lhs = rhs = S.Zero
+                    else:
+                        lhs = ode_or_bool.lhs
+                        rhs = ode_or_bool.rhs
+                # No sense in overworking simplify -- just prove that the
+                # numerator goes to zero
+                num = trigsimp((lhs - rhs).as_numer_denom()[0])
+                # since solutions are obtained using force=True we test
+                # using the same level of assumptions
+                ## replace function with dummy so assumptions will work
+                _func = Dummy('func')
+                num = num.subs(func, _func)
+                ## posify the expression
+                num, reps = posify(num)
+                s = simplify(num).xreplace(reps).xreplace({_func: func})
+                testnum += 1
+        else:
+            break
+
+    if not s:
+        return (True, s)
+    elif s is True:  # The code above never was able to change s
+        raise NotImplementedError("Unable to test if " + str(sol) +
+            " is a solution to " + str(ode) + ".")
+    else:
+        return (False, s)
+
+
+def checksysodesol(eqs, sols, func=None):
+    r"""
+    Substitutes corresponding ``sols`` for each functions into each ``eqs`` and
+    checks that the result of substitutions for each equation is ``0``. The
+    equations and solutions passed can be any iterable.
+
+    This only works when each ``sols`` have one function only, like `x(t)` or `y(t)`.
+    For each function, ``sols`` can have a single solution or a list of solutions.
+    In most cases it will not be necessary to explicitly identify the function,
+    but if the function cannot be inferred from the original equation it
+    can be supplied through the ``func`` argument.
+
+    When a sequence of equations is passed, the same sequence is used to return
+    the result for each equation with each function substituted with corresponding
+    solutions.
+
+    It tries the following method to find zero equivalence for each equation:
+
+    Substitute the solutions for functions, like `x(t)` and `y(t)` into the
+    original equations containing those functions.
+    This function returns a tuple.  The first item in the tuple is ``True`` if
+    the substitution results for each equation is ``0``, and ``False`` otherwise.
+    The second item in the tuple is what the substitution results in.  Each element
+    of the ``list`` should always be ``0`` corresponding to each equation if the
+    first item is ``True``. Note that sometimes this function may return ``False``,
+    but with an expression that is identically equal to ``0``, instead of returning
+    ``True``.  This is because :py:meth:`~sympy.simplify.simplify.simplify` cannot
+    reduce the expression to ``0``.  If an expression returned by each function
+    vanishes identically, then ``sols`` really is a solution to ``eqs``.
+
+    If this function seems to hang, it is probably because of a difficult simplification.
+
+    Examples
+    ========
+
+    >>> from sympy import Eq, diff, symbols, sin, cos, exp, sqrt, S, Function
+    >>> from sympy.solvers.ode.subscheck import checksysodesol
+    >>> C1, C2 = symbols('C1:3')
+    >>> t = symbols('t')
+    >>> x, y = symbols('x, y', cls=Function)
+    >>> eq = (Eq(diff(x(t),t), x(t) + y(t) + 17), Eq(diff(y(t),t), -2*x(t) + y(t) + 12))
+    >>> sol = [Eq(x(t), (C1*sin(sqrt(2)*t) + C2*cos(sqrt(2)*t))*exp(t) - S(5)/3),
+    ... Eq(y(t), (sqrt(2)*C1*cos(sqrt(2)*t) - sqrt(2)*C2*sin(sqrt(2)*t))*exp(t) - S(46)/3)]
+    >>> checksysodesol(eq, sol)
+    (True, [0, 0])
+    >>> eq = (Eq(diff(x(t),t),x(t)*y(t)**4), Eq(diff(y(t),t),y(t)**3))
+    >>> sol = [Eq(x(t), C1*exp(-1/(4*(C2 + t)))), Eq(y(t), -sqrt(2)*sqrt(-1/(C2 + t))/2),
+    ... Eq(x(t), C1*exp(-1/(4*(C2 + t)))), Eq(y(t), sqrt(2)*sqrt(-1/(C2 + t))/2)]
+    >>> checksysodesol(eq, sol)
+    (True, [0, 0])
+
+    """
+    def _sympify(eq):
+        return list(map(sympify, eq if iterable(eq) else [eq]))
+    eqs = _sympify(eqs)
+    for i in range(len(eqs)):
+        if isinstance(eqs[i], Equality):
+            eqs[i] = eqs[i].lhs - eqs[i].rhs
+    if func is None:
+        funcs = []
+        for eq in eqs:
+            derivs = eq.atoms(Derivative)
+            func = set().union(*[d.atoms(AppliedUndef) for d in derivs])
+            funcs.extend(func)
+        funcs = list(set(funcs))
+    if not all(isinstance(func, AppliedUndef) and len(func.args) == 1 for func in funcs)\
+    and len({func.args for func in funcs})!=1:
+        raise ValueError("func must be a function of one variable, not %s" % func)
+    for sol in sols:
+        if len(sol.atoms(AppliedUndef)) != 1:
+            raise ValueError("solutions should have one function only")
+    if len(funcs) != len({sol.lhs for sol in sols}):
+        raise ValueError("number of solutions provided does not match the number of equations")
+    dictsol = {}
+    for sol in sols:
+        func = list(sol.atoms(AppliedUndef))[0]
+        if sol.rhs == func:
+            sol = sol.reversed
+        solved = sol.lhs == func and not sol.rhs.has(func)
+        if not solved:
+            rhs = solve(sol, func)
+            if not rhs:
+                raise NotImplementedError
+        else:
+            rhs = sol.rhs
+        dictsol[func] = rhs
+    checkeq = []
+    for eq in eqs:
+        for func in funcs:
+            eq = sub_func_doit(eq, func, dictsol[func])
+        ss = simplify(eq)
+        if ss != 0:
+            eq = ss.expand(force=True)
+            if eq != 0:
+                eq = sqrtdenest(eq).simplify()
+        else:
+            eq = 0
+        checkeq.append(eq)
+    if len(set(checkeq)) == 1 and list(set(checkeq))[0] == 0:
+        return (True, checkeq)
+    else:
+        return (False, checkeq)
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/ode/systems.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/ode/systems.py
new file mode 100644
index 0000000000000000000000000000000000000000..2d2c9b57a969c7fb5c67c06ce952fa398e22a48d
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/ode/systems.py
@@ -0,0 +1,2135 @@
+from sympy.core import Add, Mul, S
+from sympy.core.containers import Tuple
+from sympy.core.exprtools import factor_terms
+from sympy.core.numbers import I
+from sympy.core.relational import Eq, Equality
+from sympy.core.sorting import default_sort_key, ordered
+from sympy.core.symbol import Dummy, Symbol
+from sympy.core.function import (expand_mul, expand, Derivative,
+                                 AppliedUndef, Function, Subs)
+from sympy.functions import (exp, im, cos, sin, re, Piecewise,
+                             piecewise_fold, sqrt, log)
+from sympy.functions.combinatorial.factorials import factorial
+from sympy.matrices import zeros, Matrix, NonSquareMatrixError, MatrixBase, eye
+from sympy.polys import Poly, together
+from sympy.simplify import collect, radsimp, signsimp # type: ignore
+from sympy.simplify.powsimp import powdenest, powsimp
+from sympy.simplify.ratsimp import ratsimp
+from sympy.simplify.simplify import simplify
+from sympy.sets.sets import FiniteSet
+from sympy.solvers.deutils import ode_order
+from sympy.solvers.solveset import NonlinearError, solveset
+from sympy.utilities.iterables import (connected_components, iterable,
+                                       strongly_connected_components)
+from sympy.utilities.misc import filldedent
+from sympy.integrals.integrals import Integral, integrate
+
+
+def _get_func_order(eqs, funcs):
+    return {func: max(ode_order(eq, func) for eq in eqs) for func in funcs}
+
+
+class ODEOrderError(ValueError):
+    """Raised by linear_ode_to_matrix if the system has the wrong order"""
+    pass
+
+
+class ODENonlinearError(NonlinearError):
+    """Raised by linear_ode_to_matrix if the system is nonlinear"""
+    pass
+
+
+def _simpsol(soleq):
+    lhs = soleq.lhs
+    sol = soleq.rhs
+    sol = powsimp(sol)
+    gens = list(sol.atoms(exp))
+    p = Poly(sol, *gens, expand=False)
+    gens = [factor_terms(g) for g in gens]
+    if not gens:
+        gens = p.gens
+    syms = [Symbol('C1'), Symbol('C2')]
+    terms = []
+    for coeff, monom in zip(p.coeffs(), p.monoms()):
+        coeff = piecewise_fold(coeff)
+        if isinstance(coeff, Piecewise):
+            coeff = Piecewise(*((ratsimp(coef).collect(syms), cond) for coef, cond in coeff.args))
+        else:
+            coeff = ratsimp(coeff).collect(syms)
+        monom = Mul(*(g ** i for g, i in zip(gens, monom)))
+        terms.append(coeff * monom)
+    return Eq(lhs, Add(*terms))
+
+
+def _solsimp(e, t):
+    no_t, has_t = powsimp(expand_mul(e)).as_independent(t)
+
+    no_t = ratsimp(no_t)
+    has_t = has_t.replace(exp, lambda a: exp(factor_terms(a)))
+
+    return no_t + has_t
+
+
+def simpsol(sol, wrt1, wrt2, doit=True):
+    """Simplify solutions from dsolve_system."""
+
+    # The parameter sol is the solution as returned by dsolve (list of Eq).
+    #
+    # The parameters wrt1 and wrt2 are lists of symbols to be collected for
+    # with those in wrt1 being collected for first. This allows for collecting
+    # on any factors involving the independent variable before collecting on
+    # the integration constants or vice versa using e.g.:
+    #
+    #     sol = simpsol(sol, [t], [C1, C2])  # t first, constants after
+    #     sol = simpsol(sol, [C1, C2], [t])  # constants first, t after
+    #
+    # If doit=True (default) then simpsol will begin by evaluating any
+    # unevaluated integrals. Since many integrals will appear multiple times
+    # in the solutions this is done intelligently by computing each integral
+    # only once.
+    #
+    # The strategy is to first perform simple cancellation with factor_terms
+    # and then multiply out all brackets with expand_mul. This gives an Add
+    # with many terms.
+    #
+    # We split each term into two multiplicative factors dep and coeff where
+    # all factors that involve wrt1 are in dep and any constant factors are in
+    # coeff e.g.
+    #         sqrt(2)*C1*exp(t) -> ( exp(t), sqrt(2)*C1 )
+    #
+    # The dep factors are simplified using powsimp to combine expanded
+    # exponential factors e.g.
+    #              exp(a*t)*exp(b*t) -> exp(t*(a+b))
+    #
+    # We then collect coefficients for all terms having the same (simplified)
+    # dep. The coefficients are then simplified using together and ratsimp and
+    # lastly by recursively applying the same transformation to the
+    # coefficients to collect on wrt2.
+    #
+    # Finally the result is recombined into an Add and signsimp is used to
+    # normalise any minus signs.
+
+    def simprhs(rhs, rep, wrt1, wrt2):
+        """Simplify the rhs of an ODE solution"""
+        if rep:
+            rhs = rhs.subs(rep)
+        rhs = factor_terms(rhs)
+        rhs = simp_coeff_dep(rhs, wrt1, wrt2)
+        rhs = signsimp(rhs)
+        return rhs
+
+    def simp_coeff_dep(expr, wrt1, wrt2=None):
+        """Split rhs into terms, split terms into dep and coeff and collect on dep"""
+        add_dep_terms = lambda e: e.is_Add and e.has(*wrt1)
+        expandable = lambda e: e.is_Mul and any(map(add_dep_terms, e.args))
+        expand_func = lambda e: expand_mul(e, deep=False)
+        expand_mul_mod = lambda e: e.replace(expandable, expand_func)
+        terms = Add.make_args(expand_mul_mod(expr))
+        dc = {}
+        for term in terms:
+            coeff, dep = term.as_independent(*wrt1, as_Add=False)
+            # Collect together the coefficients for terms that have the same
+            # dependence on wrt1 (after dep is normalised using simpdep).
+            dep = simpdep(dep, wrt1)
+
+            # See if the dependence on t cancels out...
+            if dep is not S.One:
+                dep2 = factor_terms(dep)
+                if not dep2.has(*wrt1):
+                    coeff *= dep2
+                    dep = S.One
+
+            if dep not in dc:
+                dc[dep] = coeff
+            else:
+                dc[dep] += coeff
+        # Apply the method recursively to the coefficients but this time
+        # collecting on wrt2 rather than wrt2.
+        termpairs = ((simpcoeff(c, wrt2), d) for d, c in dc.items())
+        if wrt2 is not None:
+            termpairs = ((simp_coeff_dep(c, wrt2), d) for c, d in termpairs)
+        return Add(*(c * d for c, d in termpairs))
+
+    def simpdep(term, wrt1):
+        """Normalise factors involving t with powsimp and recombine exp"""
+        def canonicalise(a):
+            # Using factor_terms here isn't quite right because it leads to things
+            # like exp(t*(1+t)) that we don't want. We do want to cancel factors
+            # and pull out a common denominator but ideally the numerator would be
+            # expressed as a standard form polynomial in t so we expand_mul
+            # and collect afterwards.
+            a = factor_terms(a)
+            num, den = a.as_numer_denom()
+            num = expand_mul(num)
+            num = collect(num, wrt1)
+            return num / den
+
+        term = powsimp(term)
+        rep = {e: exp(canonicalise(e.args[0])) for e in term.atoms(exp)}
+        term = term.subs(rep)
+        return term
+
+    def simpcoeff(coeff, wrt2):
+        """Bring to a common fraction and cancel with ratsimp"""
+        coeff = together(coeff)
+        if coeff.is_polynomial():
+            # Calling ratsimp can be expensive. The main reason is to simplify
+            # sums of terms with irrational denominators so we limit ourselves
+            # to the case where the expression is polynomial in any symbols.
+            # Maybe there's a better approach...
+            coeff = ratsimp(radsimp(coeff))
+        # collect on secondary variables first and any remaining symbols after
+        if wrt2 is not None:
+            syms = list(wrt2) + list(ordered(coeff.free_symbols - set(wrt2)))
+        else:
+            syms = list(ordered(coeff.free_symbols))
+        coeff = collect(coeff, syms)
+        coeff = together(coeff)
+        return coeff
+
+    # There are often repeated integrals. Collect unique integrals and
+    # evaluate each once and then substitute into the final result to replace
+    # all occurrences in each of the solution equations.
+    if doit:
+        integrals = set().union(*(s.atoms(Integral) for s in sol))
+        rep = {i: factor_terms(i).doit() for i in integrals}
+    else:
+        rep = {}
+
+    sol = [Eq(s.lhs, simprhs(s.rhs, rep, wrt1, wrt2)) for s in sol]
+    return sol
+
+
+def linodesolve_type(A, t, b=None):
+    r"""
+    Helper function that determines the type of the system of ODEs for solving with :obj:`sympy.solvers.ode.systems.linodesolve()`
+
+    Explanation
+    ===========
+
+    This function takes in the coefficient matrix and/or the non-homogeneous term
+    and returns the type of the equation that can be solved by :obj:`sympy.solvers.ode.systems.linodesolve()`.
+
+    If the system is constant coefficient homogeneous, then "type1" is returned
+
+    If the system is constant coefficient non-homogeneous, then "type2" is returned
+
+    If the system is non-constant coefficient homogeneous, then "type3" is returned
+
+    If the system is non-constant coefficient non-homogeneous, then "type4" is returned
+
+    If the system has a non-constant coefficient matrix which can be factorized into constant
+    coefficient matrix, then "type5" or "type6" is returned for when the system is homogeneous or
+    non-homogeneous respectively.
+
+    Note that, if the system of ODEs is of "type3" or "type4", then along with the type,
+    the commutative antiderivative of the coefficient matrix is also returned.
+
+    If the system cannot be solved by :obj:`sympy.solvers.ode.systems.linodesolve()`, then
+    NotImplementedError is raised.
+
+    Parameters
+    ==========
+
+    A : Matrix
+        Coefficient matrix of the system of ODEs
+    b : Matrix or None
+        Non-homogeneous term of the system. The default value is None.
+        If this argument is None, then the system is assumed to be homogeneous.
+
+    Examples
+    ========
+
+    >>> from sympy import symbols, Matrix
+    >>> from sympy.solvers.ode.systems import linodesolve_type
+    >>> t = symbols("t")
+    >>> A = Matrix([[1, 1], [2, 3]])
+    >>> b = Matrix([t, 1])
+
+    >>> linodesolve_type(A, t)
+    {'antiderivative': None, 'type_of_equation': 'type1'}
+
+    >>> linodesolve_type(A, t, b=b)
+    {'antiderivative': None, 'type_of_equation': 'type2'}
+
+    >>> A_t = Matrix([[1, t], [-t, 1]])
+
+    >>> linodesolve_type(A_t, t)
+    {'antiderivative': Matrix([
+    [      t, t**2/2],
+    [-t**2/2,      t]]), 'type_of_equation': 'type3'}
+
+    >>> linodesolve_type(A_t, t, b=b)
+    {'antiderivative': Matrix([
+    [      t, t**2/2],
+    [-t**2/2,      t]]), 'type_of_equation': 'type4'}
+
+    >>> A_non_commutative = Matrix([[1, t], [t, -1]])
+    >>> linodesolve_type(A_non_commutative, t)
+    Traceback (most recent call last):
+    ...
+    NotImplementedError:
+    The system does not have a commutative antiderivative, it cannot be
+    solved by linodesolve.
+
+    Returns
+    =======
+
+    Dict
+
+    Raises
+    ======
+
+    NotImplementedError
+        When the coefficient matrix does not have a commutative antiderivative
+
+    See Also
+    ========
+
+    linodesolve: Function for which linodesolve_type gets the information
+
+    """
+
+    match = {}
+    is_non_constant = not _matrix_is_constant(A, t)
+    is_non_homogeneous = not (b is None or b.is_zero_matrix)
+    type = "type{}".format(int("{}{}".format(int(is_non_constant), int(is_non_homogeneous)), 2) + 1)
+
+    B = None
+    match.update({"type_of_equation": type, "antiderivative": B})
+
+    if is_non_constant:
+        B, is_commuting = _is_commutative_anti_derivative(A, t)
+        if not is_commuting:
+            raise NotImplementedError(filldedent('''
+                The system does not have a commutative antiderivative, it cannot be solved
+                by linodesolve.
+            '''))
+
+        match['antiderivative'] = B
+        match.update(_first_order_type5_6_subs(A, t, b=b))
+
+    return match
+
+
+def _first_order_type5_6_subs(A, t, b=None):
+    match = {}
+
+    factor_terms = _factor_matrix(A, t)
+    is_homogeneous = b is None or b.is_zero_matrix
+
+    if factor_terms is not None:
+        t_ = Symbol("{}_".format(t))
+        F_t = integrate(factor_terms[0], t)
+        inverse = solveset(Eq(t_, F_t), t)
+
+        # Note: A simple way to check if a function is invertible
+        # or not.
+        if isinstance(inverse, FiniteSet) and not inverse.has(Piecewise)\
+            and len(inverse) == 1:
+
+            A = factor_terms[1]
+            if not is_homogeneous:
+                b = b / factor_terms[0]
+                b = b.subs(t, list(inverse)[0])
+            type = "type{}".format(5 + (not is_homogeneous))
+            match.update({'func_coeff': A, 'tau': F_t,
+                          't_': t_, 'type_of_equation': type, 'rhs': b})
+
+    return match
+
+
+def linear_ode_to_matrix(eqs, funcs, t, order):
+    r"""
+    Convert a linear system of ODEs to matrix form
+
+    Explanation
+    ===========
+
+    Express a system of linear ordinary differential equations as a single
+    matrix differential equation [1]. For example the system $x' = x + y + 1$
+    and $y' = x - y$ can be represented as
+
+    .. math:: A_1 X' = A_0 X + b
+
+    where $A_1$ and $A_0$ are $2 \times 2$ matrices and $b$, $X$ and $X'$ are
+    $2 \times 1$ matrices with $X = [x, y]^T$.
+
+    Higher-order systems are represented with additional matrices e.g. a
+    second-order system would look like
+
+    .. math:: A_2 X'' =  A_1 X' + A_0 X  + b
+
+    Examples
+    ========
+
+    >>> from sympy import Function, Symbol, Matrix, Eq
+    >>> from sympy.solvers.ode.systems import linear_ode_to_matrix
+    >>> t = Symbol('t')
+    >>> x = Function('x')
+    >>> y = Function('y')
+
+    We can create a system of linear ODEs like
+
+    >>> eqs = [
+    ...     Eq(x(t).diff(t), x(t) + y(t) + 1),
+    ...     Eq(y(t).diff(t), x(t) - y(t)),
+    ... ]
+    >>> funcs = [x(t), y(t)]
+    >>> order = 1 # 1st order system
+
+    Now ``linear_ode_to_matrix`` can represent this as a matrix
+    differential equation.
+
+    >>> (A1, A0), b = linear_ode_to_matrix(eqs, funcs, t, order)
+    >>> A1
+    Matrix([
+    [1, 0],
+    [0, 1]])
+    >>> A0
+    Matrix([
+    [1, 1],
+    [1,  -1]])
+    >>> b
+    Matrix([
+    [1],
+    [0]])
+
+    The original equations can be recovered from these matrices:
+
+    >>> eqs_mat = Matrix([eq.lhs - eq.rhs for eq in eqs])
+    >>> X = Matrix(funcs)
+    >>> A1 * X.diff(t) - A0 * X - b == eqs_mat
+    True
+
+    If the system of equations has a maximum order greater than the
+    order of the system specified, a ODEOrderError exception is raised.
+
+    >>> eqs = [Eq(x(t).diff(t, 2), x(t).diff(t) + x(t)), Eq(y(t).diff(t), y(t) + x(t))]
+    >>> linear_ode_to_matrix(eqs, funcs, t, 1)
+    Traceback (most recent call last):
+    ...
+    ODEOrderError: Cannot represent system in 1-order form
+
+    If the system of equations is nonlinear, then ODENonlinearError is
+    raised.
+
+    >>> eqs = [Eq(x(t).diff(t), x(t) + y(t)), Eq(y(t).diff(t), y(t)**2 + x(t))]
+    >>> linear_ode_to_matrix(eqs, funcs, t, 1)
+    Traceback (most recent call last):
+    ...
+    ODENonlinearError: The system of ODEs is nonlinear.
+
+    Parameters
+    ==========
+
+    eqs : list of SymPy expressions or equalities
+        The equations as expressions (assumed equal to zero).
+    funcs : list of applied functions
+        The dependent variables of the system of ODEs.
+    t : symbol
+        The independent variable.
+    order : int
+        The order of the system of ODEs.
+
+    Returns
+    =======
+
+    The tuple ``(As, b)`` where ``As`` is a tuple of matrices and ``b`` is the
+    the matrix representing the rhs of the matrix equation.
+
+    Raises
+    ======
+
+    ODEOrderError
+        When the system of ODEs have an order greater than what was specified
+    ODENonlinearError
+        When the system of ODEs is nonlinear
+
+    See Also
+    ========
+
+    linear_eq_to_matrix: for systems of linear algebraic equations.
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Matrix_differential_equation
+
+    """
+    from sympy.solvers.solveset import linear_eq_to_matrix
+
+    if any(ode_order(eq, func) > order for eq in eqs for func in funcs):
+        msg = "Cannot represent system in {}-order form"
+        raise ODEOrderError(msg.format(order))
+
+    As = []
+
+    for o in range(order, -1, -1):
+        # Work from the highest derivative down
+        syms = [func.diff(t, o) for func in funcs]
+
+        # Ai is the matrix for X(t).diff(t, o)
+        # eqs is minus the remainder of the equations.
+        try:
+            Ai, b = linear_eq_to_matrix(eqs, syms)
+        except NonlinearError:
+            raise ODENonlinearError("The system of ODEs is nonlinear.")
+
+        Ai = Ai.applyfunc(expand_mul)
+
+        As.append(Ai if o == order else -Ai)
+
+        if o:
+            eqs = [-eq for eq in b]
+        else:
+            rhs = b
+
+    return As, rhs
+
+
+def matrix_exp(A, t):
+    r"""
+    Matrix exponential $\exp(A*t)$ for the matrix ``A`` and scalar ``t``.
+
+    Explanation
+    ===========
+
+    This functions returns the $\exp(A*t)$ by doing a simple
+    matrix multiplication:
+
+    .. math:: \exp(A*t) = P * expJ * P^{-1}
+
+    where $expJ$ is $\exp(J*t)$. $J$ is the Jordan normal
+    form of $A$ and $P$ is matrix such that:
+
+    .. math:: A = P * J * P^{-1}
+
+    The matrix exponential $\exp(A*t)$ appears in the solution of linear
+    differential equations. For example if $x$ is a vector and $A$ is a matrix
+    then the initial value problem
+
+    .. math:: \frac{dx(t)}{dt} = A \times x(t),   x(0) = x0
+
+    has the unique solution
+
+    .. math:: x(t) = \exp(A t) x0
+
+    Examples
+    ========
+
+    >>> from sympy import Symbol, Matrix, pprint
+    >>> from sympy.solvers.ode.systems import matrix_exp
+    >>> t = Symbol('t')
+
+    We will consider a 2x2 matrix for comupting the exponential
+
+    >>> A = Matrix([[2, -5], [2, -4]])
+    >>> pprint(A)
+    [2  -5]
+    [     ]
+    [2  -4]
+
+    Now, exp(A*t) is given as follows:
+
+    >>> pprint(matrix_exp(A, t))
+    [   -t           -t                    -t              ]
+    [3*e  *sin(t) + e  *cos(t)         -5*e  *sin(t)       ]
+    [                                                      ]
+    [         -t                     -t           -t       ]
+    [      2*e  *sin(t)         - 3*e  *sin(t) + e  *cos(t)]
+
+    Parameters
+    ==========
+
+    A : Matrix
+        The matrix $A$ in the expression $\exp(A*t)$
+    t : Symbol
+        The independent variable
+
+    See Also
+    ========
+
+    matrix_exp_jordan_form: For exponential of Jordan normal form
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Jordan_normal_form
+    .. [2] https://en.wikipedia.org/wiki/Matrix_exponential
+
+    """
+    P, expJ = matrix_exp_jordan_form(A, t)
+    return P * expJ * P.inv()
+
+
+def matrix_exp_jordan_form(A, t):
+    r"""
+    Matrix exponential $\exp(A*t)$ for the matrix *A* and scalar *t*.
+
+    Explanation
+    ===========
+
+    Returns the Jordan form of the $\exp(A*t)$ along with the matrix $P$ such that:
+
+    .. math::
+        \exp(A*t) = P * expJ * P^{-1}
+
+    Examples
+    ========
+
+    >>> from sympy import Matrix, Symbol
+    >>> from sympy.solvers.ode.systems import matrix_exp, matrix_exp_jordan_form
+    >>> t = Symbol('t')
+
+    We will consider a 2x2 defective matrix. This shows that our method
+    works even for defective matrices.
+
+    >>> A = Matrix([[1, 1], [0, 1]])
+
+    It can be observed that this function gives us the Jordan normal form
+    and the required invertible matrix P.
+
+    >>> P, expJ = matrix_exp_jordan_form(A, t)
+
+    Here, it is shown that P and expJ returned by this function is correct
+    as they satisfy the formula: P * expJ * P_inverse = exp(A*t).
+
+    >>> P * expJ * P.inv() == matrix_exp(A, t)
+    True
+
+    Parameters
+    ==========
+
+    A : Matrix
+        The matrix $A$ in the expression $\exp(A*t)$
+    t : Symbol
+        The independent variable
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Defective_matrix
+    .. [2] https://en.wikipedia.org/wiki/Jordan_matrix
+    .. [3] https://en.wikipedia.org/wiki/Jordan_normal_form
+
+    """
+
+    N, M = A.shape
+    if N != M:
+        raise ValueError('Needed square matrix but got shape (%s, %s)' % (N, M))
+    elif A.has(t):
+        raise ValueError('Matrix A should not depend on t')
+
+    def jordan_chains(A):
+        '''Chains from Jordan normal form analogous to M.eigenvects().
+        Returns a dict with eignevalues as keys like:
+            {e1: [[v111,v112,...], [v121, v122,...]], e2:...}
+        where vijk is the kth vector in the jth chain for eigenvalue i.
+        '''
+        P, blocks = A.jordan_cells()
+        basis = [P[:,i] for i in range(P.shape[1])]
+        n = 0
+        chains = {}
+        for b in blocks:
+            eigval = b[0, 0]
+            size = b.shape[0]
+            if eigval not in chains:
+                chains[eigval] = []
+            chains[eigval].append(basis[n:n+size])
+            n += size
+        return chains
+
+    eigenchains = jordan_chains(A)
+
+    # Needed for consistency across Python versions
+    eigenchains_iter = sorted(eigenchains.items(), key=default_sort_key)
+    isreal = not A.has(I)
+
+    blocks = []
+    vectors = []
+    seen_conjugate = set()
+    for e, chains in eigenchains_iter:
+        for chain in chains:
+            n = len(chain)
+            if isreal and e != e.conjugate() and e.conjugate() in eigenchains:
+                if e in seen_conjugate:
+                    continue
+                seen_conjugate.add(e.conjugate())
+                exprt = exp(re(e) * t)
+                imrt = im(e) * t
+                imblock = Matrix([[cos(imrt), sin(imrt)],
+                                  [-sin(imrt), cos(imrt)]])
+                expJblock2 = Matrix(n, n, lambda i,j:
+                        imblock * t**(j-i) / factorial(j-i) if j >= i
+                        else zeros(2, 2))
+                expJblock = Matrix(2*n, 2*n, lambda i,j: expJblock2[i//2,j//2][i%2,j%2])
+
+                blocks.append(exprt * expJblock)
+                for i in range(n):
+                    vectors.append(re(chain[i]))
+                    vectors.append(im(chain[i]))
+            else:
+                vectors.extend(chain)
+                fun = lambda i,j: t**(j-i)/factorial(j-i) if j >= i else 0
+                expJblock = Matrix(n, n, fun)
+                blocks.append(exp(e * t) * expJblock)
+
+    expJ = Matrix.diag(*blocks)
+    P = Matrix(N, N, lambda i,j: vectors[j][i])
+
+    return P, expJ
+
+
+# Note: To add a docstring example with tau
+def linodesolve(A, t, b=None, B=None, type="auto", doit=False,
+                tau=None):
+    r"""
+    System of n equations linear first-order differential equations
+
+    Explanation
+    ===========
+
+    This solver solves the system of ODEs of the following form:
+
+    .. math::
+        X'(t) = A(t) X(t) +  b(t)
+
+    Here, $A(t)$ is the coefficient matrix, $X(t)$ is the vector of n independent variables,
+    $b(t)$ is the non-homogeneous term and $X'(t)$ is the derivative of $X(t)$
+
+    Depending on the properties of $A(t)$ and $b(t)$, this solver evaluates the solution
+    differently.
+
+    When $A(t)$ is constant coefficient matrix and $b(t)$ is zero vector i.e. system is homogeneous,
+    the system is "type1". The solution is:
+
+    .. math::
+        X(t) = \exp(A t) C
+
+    Here, $C$ is a vector of constants and $A$ is the constant coefficient matrix.
+
+    When $A(t)$ is constant coefficient matrix and $b(t)$ is non-zero i.e. system is non-homogeneous,
+    the system is "type2". The solution is:
+
+    .. math::
+        X(t) = e^{A t} ( \int e^{- A t} b \,dt + C)
+
+    When $A(t)$ is coefficient matrix such that its commutative with its antiderivative $B(t)$ and
+    $b(t)$ is a zero vector i.e. system is homogeneous, the system is "type3". The solution is:
+
+    .. math::
+        X(t) = \exp(B(t)) C
+
+    When $A(t)$ is commutative with its antiderivative $B(t)$ and $b(t)$ is non-zero i.e. system is
+    non-homogeneous, the system is "type4". The solution is:
+
+    .. math::
+        X(t) =  e^{B(t)} ( \int e^{-B(t)} b(t) \,dt + C)
+
+    When $A(t)$ is a coefficient matrix such that it can be factorized into a scalar and a constant
+    coefficient matrix:
+
+    .. math::
+        A(t) = f(t) * A
+
+    Where $f(t)$ is a scalar expression in the independent variable $t$ and $A$ is a constant matrix,
+    then we can do the following substitutions:
+
+    .. math::
+        tau = \int f(t) dt, X(t) = Y(tau), b(t) = b(f^{-1}(tau))
+
+    Here, the substitution for the non-homogeneous term is done only when its non-zero.
+    Using these substitutions, our original system becomes:
+
+    .. math::
+        Y'(tau) = A * Y(tau) + b(tau)/f(tau)
+
+    The above system can be easily solved using the solution for "type1" or "type2" depending
+    on the homogeneity of the system. After we get the solution for $Y(tau)$, we substitute the
+    solution for $tau$ as $t$ to get back $X(t)$
+
+    .. math::
+        X(t) = Y(tau)
+
+    Systems of "type5" and "type6" have a commutative antiderivative but we use this solution
+    because its faster to compute.
+
+    The final solution is the general solution for all the four equations since a constant coefficient
+    matrix is always commutative with its antidervative.
+
+    An additional feature of this function is, if someone wants to substitute for value of the independent
+    variable, they can pass the substitution `tau` and the solution will have the independent variable
+    substituted with the passed expression(`tau`).
+
+    Parameters
+    ==========
+
+    A : Matrix
+        Coefficient matrix of the system of linear first order ODEs.
+    t : Symbol
+        Independent variable in the system of ODEs.
+    b : Matrix or None
+        Non-homogeneous term in the system of ODEs. If None is passed,
+        a homogeneous system of ODEs is assumed.
+    B : Matrix or None
+        Antiderivative of the coefficient matrix. If the antiderivative
+        is not passed and the solution requires the term, then the solver
+        would compute it internally.
+    type : String
+        Type of the system of ODEs passed. Depending on the type, the
+        solution is evaluated. The type values allowed and the corresponding
+        system it solves are: "type1" for constant coefficient homogeneous
+        "type2" for constant coefficient non-homogeneous, "type3" for non-constant
+        coefficient homogeneous, "type4" for non-constant coefficient non-homogeneous,
+        "type5" and "type6" for non-constant coefficient homogeneous and non-homogeneous
+        systems respectively where the coefficient matrix can be factorized to a constant
+        coefficient matrix.
+        The default value is "auto" which will let the solver decide the correct type of
+        the system passed.
+    doit : Boolean
+        Evaluate the solution if True, default value is False
+    tau: Expression
+        Used to substitute for the value of `t` after we get the solution of the system.
+
+    Examples
+    ========
+
+    To solve the system of ODEs using this function directly, several things must be
+    done in the right order. Wrong inputs to the function will lead to incorrect results.
+
+    >>> from sympy import symbols, Function, Eq
+    >>> from sympy.solvers.ode.systems import canonical_odes, linear_ode_to_matrix, linodesolve, linodesolve_type
+    >>> from sympy.solvers.ode.subscheck import checkodesol
+    >>> f, g = symbols("f, g", cls=Function)
+    >>> x, a = symbols("x, a")
+    >>> funcs = [f(x), g(x)]
+    >>> eqs = [Eq(f(x).diff(x) - f(x), a*g(x) + 1), Eq(g(x).diff(x) + g(x), a*f(x))]
+
+    Here, it is important to note that before we derive the coefficient matrix, it is
+    important to get the system of ODEs into the desired form. For that we will use
+    :obj:`sympy.solvers.ode.systems.canonical_odes()`.
+
+    >>> eqs = canonical_odes(eqs, funcs, x)
+    >>> eqs
+    [[Eq(Derivative(f(x), x), a*g(x) + f(x) + 1), Eq(Derivative(g(x), x), a*f(x) - g(x))]]
+
+    Now, we will use :obj:`sympy.solvers.ode.systems.linear_ode_to_matrix()` to get the coefficient matrix and the
+    non-homogeneous term if it is there.
+
+    >>> eqs = eqs[0]
+    >>> (A1, A0), b = linear_ode_to_matrix(eqs, funcs, x, 1)
+    >>> A = A0
+
+    We have the coefficient matrices and the non-homogeneous term ready. Now, we can use
+    :obj:`sympy.solvers.ode.systems.linodesolve_type()` to get the information for the system of ODEs
+    to finally pass it to the solver.
+
+    >>> system_info = linodesolve_type(A, x, b=b)
+    >>> sol_vector = linodesolve(A, x, b=b, B=system_info['antiderivative'], type=system_info['type_of_equation'])
+
+    Now, we can prove if the solution is correct or not by using :obj:`sympy.solvers.ode.checkodesol()`
+
+    >>> sol = [Eq(f, s) for f, s in zip(funcs, sol_vector)]
+    >>> checkodesol(eqs, sol)
+    (True, [0, 0])
+
+    We can also use the doit method to evaluate the solutions passed by the function.
+
+    >>> sol_vector_evaluated = linodesolve(A, x, b=b, type="type2", doit=True)
+
+    Now, we will look at a system of ODEs which is non-constant.
+
+    >>> eqs = [Eq(f(x).diff(x), f(x) + x*g(x)), Eq(g(x).diff(x), -x*f(x) + g(x))]
+
+    The system defined above is already in the desired form, so we do not have to convert it.
+
+    >>> (A1, A0), b = linear_ode_to_matrix(eqs, funcs, x, 1)
+    >>> A = A0
+
+    A user can also pass the commutative antiderivative required for type3 and type4 system of ODEs.
+    Passing an incorrect one will lead to incorrect results. If the coefficient matrix is not commutative
+    with its antiderivative, then :obj:`sympy.solvers.ode.systems.linodesolve_type()` raises a NotImplementedError.
+    If it does have a commutative antiderivative, then the function just returns the information about the system.
+
+    >>> system_info = linodesolve_type(A, x, b=b)
+
+    Now, we can pass the antiderivative as an argument to get the solution. If the system information is not
+    passed, then the solver will compute the required arguments internally.
+
+    >>> sol_vector = linodesolve(A, x, b=b)
+
+    Once again, we can verify the solution obtained.
+
+    >>> sol = [Eq(f, s) for f, s in zip(funcs, sol_vector)]
+    >>> checkodesol(eqs, sol)
+    (True, [0, 0])
+
+    Returns
+    =======
+
+    List
+
+    Raises
+    ======
+
+    ValueError
+        This error is raised when the coefficient matrix, non-homogeneous term
+        or the antiderivative, if passed, are not a matrix or
+        do not have correct dimensions
+    NonSquareMatrixError
+        When the coefficient matrix or its antiderivative, if passed is not a
+        square matrix
+    NotImplementedError
+        If the coefficient matrix does not have a commutative antiderivative
+
+    See Also
+    ========
+
+    linear_ode_to_matrix: Coefficient matrix computation function
+    canonical_odes: System of ODEs representation change
+    linodesolve_type: Getting information about systems of ODEs to pass in this solver
+
+    """
+
+    if not isinstance(A, MatrixBase):
+        raise ValueError(filldedent('''\
+            The coefficients of the system of ODEs should be of type Matrix
+        '''))
+
+    if not A.is_square:
+        raise NonSquareMatrixError(filldedent('''\
+            The coefficient matrix must be a square
+        '''))
+
+    if b is not None:
+        if not isinstance(b, MatrixBase):
+            raise ValueError(filldedent('''\
+                The non-homogeneous terms of the system of ODEs should be of type Matrix
+            '''))
+
+        if A.rows != b.rows:
+            raise ValueError(filldedent('''\
+                The system of ODEs should have the same number of non-homogeneous terms and the number of
+                equations
+            '''))
+
+    if B is not None:
+        if not isinstance(B, MatrixBase):
+            raise ValueError(filldedent('''\
+                The antiderivative of coefficients of the system of ODEs should be of type Matrix
+            '''))
+
+        if not B.is_square:
+            raise NonSquareMatrixError(filldedent('''\
+                The antiderivative of the coefficient matrix must be a square
+            '''))
+
+        if A.rows != B.rows:
+            raise ValueError(filldedent('''\
+                        The coefficient matrix and its antiderivative should have same dimensions
+                    '''))
+
+    if not any(type == "type{}".format(i) for i in range(1, 7)) and not type == "auto":
+        raise ValueError(filldedent('''\
+                    The input type should be a valid one
+                '''))
+
+    n = A.rows
+
+    # constants = numbered_symbols(prefix='C', cls=Dummy, start=const_idx+1)
+    Cvect = Matrix([Dummy() for _ in range(n)])
+
+    if b is None and any(type == typ for typ in ["type2", "type4", "type6"]):
+        b = zeros(n, 1)
+
+    is_transformed = tau is not None
+    passed_type = type
+
+    if type == "auto":
+        system_info = linodesolve_type(A, t, b=b)
+        type = system_info["type_of_equation"]
+        B = system_info["antiderivative"]
+
+    if type in ("type5", "type6"):
+        is_transformed = True
+        if passed_type != "auto":
+            if tau is None:
+                system_info = _first_order_type5_6_subs(A, t, b=b)
+                if not system_info:
+                    raise ValueError(filldedent('''
+                        The system passed isn't {}.
+                    '''.format(type)))
+
+                tau = system_info['tau']
+                t = system_info['t_']
+                A = system_info['A']
+                b = system_info['b']
+
+    intx_wrtt = lambda x: Integral(x, t) if x else 0
+    if type in ("type1", "type2", "type5", "type6"):
+        P, J = matrix_exp_jordan_form(A, t)
+        P = simplify(P)
+
+        if type in ("type1", "type5"):
+            sol_vector = P * (J * Cvect)
+        else:
+            Jinv = J.subs(t, -t)
+            sol_vector = P * J * ((Jinv * P.inv() * b).applyfunc(intx_wrtt) + Cvect)
+    else:
+        if B is None:
+            B, _ = _is_commutative_anti_derivative(A, t)
+
+        if type == "type3":
+            sol_vector = B.exp() * Cvect
+        else:
+            sol_vector = B.exp() * (((-B).exp() * b).applyfunc(intx_wrtt) + Cvect)
+
+    if is_transformed:
+        sol_vector = sol_vector.subs(t, tau)
+
+    gens = sol_vector.atoms(exp)
+
+    if type != "type1":
+        sol_vector = [expand_mul(s) for s in sol_vector]
+
+    sol_vector = [collect(s, ordered(gens), exact=True) for s in sol_vector]
+
+    if doit:
+        sol_vector = [s.doit() for s in sol_vector]
+
+    return sol_vector
+
+
+def _matrix_is_constant(M, t):
+    """Checks if the matrix M is independent of t or not."""
+    return all(coef.as_independent(t, as_Add=True)[1] == 0 for coef in M)
+
+
+def canonical_odes(eqs, funcs, t):
+    r"""
+    Function that solves for highest order derivatives in a system
+
+    Explanation
+    ===========
+
+    This function inputs a system of ODEs and based on the system,
+    the dependent variables and their highest order, returns the system
+    in the following form:
+
+    .. math::
+        X'(t) = A(t) X(t) + b(t)
+
+    Here, $X(t)$ is the vector of dependent variables of lower order, $A(t)$ is
+    the coefficient matrix, $b(t)$ is the non-homogeneous term and $X'(t)$ is the
+    vector of dependent variables in their respective highest order. We use the term
+    canonical form to imply the system of ODEs which is of the above form.
+
+    If the system passed has a non-linear term with multiple solutions, then a list of
+    systems is returned in its canonical form.
+
+    Parameters
+    ==========
+
+    eqs : List
+        List of the ODEs
+    funcs : List
+        List of dependent variables
+    t : Symbol
+        Independent variable
+
+    Examples
+    ========
+
+    >>> from sympy import symbols, Function, Eq, Derivative
+    >>> from sympy.solvers.ode.systems import canonical_odes
+    >>> f, g = symbols("f g", cls=Function)
+    >>> x, y = symbols("x y")
+    >>> funcs = [f(x), g(x)]
+    >>> eqs = [Eq(f(x).diff(x) - 7*f(x), 12*g(x)), Eq(g(x).diff(x) + g(x), 20*f(x))]
+
+    >>> canonical_eqs = canonical_odes(eqs, funcs, x)
+    >>> canonical_eqs
+    [[Eq(Derivative(f(x), x), 7*f(x) + 12*g(x)), Eq(Derivative(g(x), x), 20*f(x) - g(x))]]
+
+    >>> system = [Eq(Derivative(f(x), x)**2 - 2*Derivative(f(x), x) + 1, 4), Eq(-y*f(x) + Derivative(g(x), x), 0)]
+
+    >>> canonical_system = canonical_odes(system, funcs, x)
+    >>> canonical_system
+    [[Eq(Derivative(f(x), x), -1), Eq(Derivative(g(x), x), y*f(x))], [Eq(Derivative(f(x), x), 3), Eq(Derivative(g(x), x), y*f(x))]]
+
+    Returns
+    =======
+
+    List
+
+    """
+    from sympy.solvers.solvers import solve
+
+    order = _get_func_order(eqs, funcs)
+
+    canon_eqs = solve(eqs, *[func.diff(t, order[func]) for func in funcs], dict=True)
+
+    systems = []
+    for eq in canon_eqs:
+        system = [Eq(func.diff(t, order[func]), eq[func.diff(t, order[func])]) for func in funcs]
+        systems.append(system)
+
+    return systems
+
+
+def _is_commutative_anti_derivative(A, t):
+    r"""
+    Helper function for determining if the Matrix passed is commutative with its antiderivative
+
+    Explanation
+    ===========
+
+    This function checks if the Matrix $A$ passed is commutative with its antiderivative with respect
+    to the independent variable $t$.
+
+    .. math::
+        B(t) = \int A(t) dt
+
+    The function outputs two values, first one being the antiderivative $B(t)$, second one being a
+    boolean value, if True, then the matrix $A(t)$ passed is commutative with $B(t)$, else the matrix
+    passed isn't commutative with $B(t)$.
+
+    Parameters
+    ==========
+
+    A : Matrix
+        The matrix which has to be checked
+    t : Symbol
+        Independent variable
+
+    Examples
+    ========
+
+    >>> from sympy import symbols, Matrix
+    >>> from sympy.solvers.ode.systems import _is_commutative_anti_derivative
+    >>> t = symbols("t")
+    >>> A = Matrix([[1, t], [-t, 1]])
+
+    >>> B, is_commuting = _is_commutative_anti_derivative(A, t)
+    >>> is_commuting
+    True
+
+    Returns
+    =======
+
+    Matrix, Boolean
+
+    """
+    B = integrate(A, t)
+    is_commuting = (B*A - A*B).applyfunc(expand).applyfunc(factor_terms).is_zero_matrix
+
+    is_commuting = False if is_commuting is None else is_commuting
+
+    return B, is_commuting
+
+
+def _factor_matrix(A, t):
+    term = None
+    for element in A:
+        temp_term = element.as_independent(t)[1]
+        if temp_term.has(t):
+            term = temp_term
+            break
+
+    if term is not None:
+        A_factored = (A/term).applyfunc(ratsimp)
+        can_factor = _matrix_is_constant(A_factored, t)
+        term = (term, A_factored) if can_factor else None
+
+    return term
+
+
+def _is_second_order_type2(A, t):
+    term = _factor_matrix(A, t)
+    is_type2 = False
+
+    if term is not None:
+        term = 1/term[0]
+        is_type2 = term.is_polynomial()
+
+    if is_type2:
+        poly = Poly(term.expand(), t)
+        monoms = poly.monoms()
+
+        if monoms[0][0] in (2, 4):
+            cs = _get_poly_coeffs(poly, 4)
+            a, b, c, d, e = cs
+
+            a1 = powdenest(sqrt(a), force=True)
+            c1 = powdenest(sqrt(e), force=True)
+            b1 = powdenest(sqrt(c - 2*a1*c1), force=True)
+
+            is_type2 = (b == 2*a1*b1) and (d == 2*b1*c1)
+            term = a1*t**2 + b1*t + c1
+
+        else:
+            is_type2 = False
+
+    return is_type2, term
+
+
+def _get_poly_coeffs(poly, order):
+    cs = [0 for _ in range(order+1)]
+    for c, m in zip(poly.coeffs(), poly.monoms()):
+        cs[-1-m[0]] = c
+    return cs
+
+
+def _match_second_order_type(A1, A0, t, b=None):
+    r"""
+    Works only for second order system in its canonical form.
+
+    Type 0: Constant coefficient matrix, can be simply solved by
+            introducing dummy variables.
+    Type 1: When the substitution: $U = t*X' - X$ works for reducing
+            the second order system to first order system.
+    Type 2: When the system is of the form: $poly * X'' = A*X$ where
+            $poly$ is square of a quadratic polynomial with respect to
+            *t* and $A$ is a constant coefficient matrix.
+
+    """
+    match = {"type_of_equation": "type0"}
+    n = A1.shape[0]
+
+    if _matrix_is_constant(A1, t) and _matrix_is_constant(A0, t):
+        return match
+
+    if (A1 + A0*t).applyfunc(expand_mul).is_zero_matrix:
+        match.update({"type_of_equation": "type1", "A1": A1})
+
+    elif A1.is_zero_matrix and (b is None or b.is_zero_matrix):
+        is_type2, term = _is_second_order_type2(A0, t)
+        if is_type2:
+            a, b, c = _get_poly_coeffs(Poly(term, t), 2)
+            A = (A0*(term**2).expand()).applyfunc(ratsimp) + (b**2/4 - a*c)*eye(n, n)
+            tau = integrate(1/term, t)
+            t_ = Symbol("{}_".format(t))
+            match.update({"type_of_equation": "type2", "A0": A,
+                          "g(t)": sqrt(term), "tau": tau, "is_transformed": True,
+                          "t_": t_})
+
+    return match
+
+
+def _second_order_subs_type1(A, b, funcs, t):
+    r"""
+    For a linear, second order system of ODEs, a particular substitution.
+
+    A system of the below form can be reduced to a linear first order system of
+    ODEs:
+    .. math::
+        X'' = A(t) * (t*X' - X) + b(t)
+
+    By substituting:
+    .. math::  U = t*X' - X
+
+    To get the system:
+    .. math::  U' = t*(A(t)*U + b(t))
+
+    Where $U$ is the vector of dependent variables, $X$ is the vector of dependent
+    variables in `funcs` and $X'$ is the first order derivative of $X$ with respect to
+    $t$. It may or may not reduce the system into linear first order system of ODEs.
+
+    Then a check is made to determine if the system passed can be reduced or not, if
+    this substitution works, then the system is reduced and its solved for the new
+    substitution. After we get the solution for $U$:
+
+    .. math::  U = a(t)
+
+    We substitute and return the reduced system:
+
+    .. math::
+        a(t) = t*X' - X
+
+    Parameters
+    ==========
+
+    A: Matrix
+        Coefficient matrix($A(t)*t$) of the second order system of this form.
+    b: Matrix
+        Non-homogeneous term($b(t)$) of the system of ODEs.
+    funcs: List
+        List of dependent variables
+    t: Symbol
+        Independent variable of the system of ODEs.
+
+    Returns
+    =======
+
+    List
+
+    """
+
+    U = Matrix([t*func.diff(t) - func for func in funcs])
+
+    sol = linodesolve(A, t, t*b)
+    reduced_eqs = [Eq(u, s) for s, u in zip(sol, U)]
+    reduced_eqs = canonical_odes(reduced_eqs, funcs, t)[0]
+
+    return reduced_eqs
+
+
+def _second_order_subs_type2(A, funcs, t_):
+    r"""
+    Returns a second order system based on the coefficient matrix passed.
+
+    Explanation
+    ===========
+
+    This function returns a system of second order ODE of the following form:
+
+    .. math::
+        X'' = A * X
+
+    Here, $X$ is the vector of dependent variables, but a bit modified, $A$ is the
+    coefficient matrix passed.
+
+    Along with returning the second order system, this function also returns the new
+    dependent variables with the new independent variable `t_` passed.
+
+    Parameters
+    ==========
+
+    A: Matrix
+        Coefficient matrix of the system
+    funcs: List
+        List of old dependent variables
+    t_: Symbol
+        New independent variable
+
+    Returns
+    =======
+
+    List, List
+
+    """
+    func_names = [func.func.__name__ for func in funcs]
+    new_funcs = [Function(Dummy("{}_".format(name)))(t_) for name in func_names]
+    rhss = A * Matrix(new_funcs)
+    new_eqs = [Eq(func.diff(t_, 2), rhs) for func, rhs in zip(new_funcs, rhss)]
+
+    return new_eqs, new_funcs
+
+
+def _is_euler_system(As, t):
+    return all(_matrix_is_constant((A*t**i).applyfunc(ratsimp), t) for i, A in enumerate(As))
+
+
+def _classify_linear_system(eqs, funcs, t, is_canon=False):
+    r"""
+    Returns a dictionary with details of the eqs if the system passed is linear
+    and can be classified by this function else returns None
+
+    Explanation
+    ===========
+
+    This function takes the eqs, converts it into a form Ax = b where x is a vector of terms
+    containing dependent variables and their derivatives till their maximum order. If it is
+    possible to convert eqs into Ax = b, then all the equations in eqs are linear otherwise
+    they are non-linear.
+
+    To check if the equations are constant coefficient, we need to check if all the terms in
+    A obtained above are constant or not.
+
+    To check if the equations are homogeneous or not, we need to check if b is a zero matrix
+    or not.
+
+    Parameters
+    ==========
+
+    eqs: List
+        List of ODEs
+    funcs: List
+        List of dependent variables
+    t: Symbol
+        Independent variable of the equations in eqs
+    is_canon: Boolean
+        If True, then this function will not try to get the
+        system in canonical form. Default value is False
+
+    Returns
+    =======
+
+    match = {
+        'no_of_equation': len(eqs),
+        'eq': eqs,
+        'func': funcs,
+        'order': order,
+        'is_linear': is_linear,
+        'is_constant': is_constant,
+        'is_homogeneous': is_homogeneous,
+    }
+
+    Dict or list of Dicts or None
+        Dict with values for keys:
+            1. no_of_equation: Number of equations
+            2. eq: The set of equations
+            3. func: List of dependent variables
+            4. order: A dictionary that gives the order of the
+                      dependent variable in eqs
+            5. is_linear: Boolean value indicating if the set of
+                          equations are linear or not.
+            6. is_constant: Boolean value indicating if the set of
+                          equations have constant coefficients or not.
+            7. is_homogeneous: Boolean value indicating if the set of
+                          equations are homogeneous or not.
+            8. commutative_antiderivative: Antiderivative of the coefficient
+                          matrix if the coefficient matrix is non-constant
+                          and commutative with its antiderivative. This key
+                          may or may not exist.
+            9. is_general: Boolean value indicating if the system of ODEs is
+                           solvable using one of the general case solvers or not.
+            10. rhs: rhs of the non-homogeneous system of ODEs in Matrix form. This
+                     key may or may not exist.
+            11. is_higher_order: True if the system passed has an order greater than 1.
+                                 This key may or may not exist.
+            12. is_second_order: True if the system passed is a second order ODE. This
+                                 key may or may not exist.
+        This Dict is the answer returned if the eqs are linear and constant
+        coefficient. Otherwise, None is returned.
+
+    """
+
+    # Error for i == 0 can be added but isn't for now
+
+    # Check for len(funcs) == len(eqs)
+    if len(funcs) != len(eqs):
+        raise ValueError("Number of functions given is not equal to the number of equations %s" % funcs)
+
+    # ValueError when functions have more than one arguments
+    for func in funcs:
+        if len(func.args) != 1:
+            raise ValueError("dsolve() and classify_sysode() work with "
+            "functions of one variable only, not %s" % func)
+
+    # Getting the func_dict and order using the helper
+    # function
+    order = _get_func_order(eqs, funcs)
+    system_order = max(order[func] for func in funcs)
+    is_higher_order = system_order > 1
+    is_second_order = system_order == 2 and all(order[func] == 2 for func in funcs)
+
+    # Not adding the check if the len(func.args) for
+    # every func in funcs is 1
+
+    # Linearity check
+    try:
+
+        canon_eqs = canonical_odes(eqs, funcs, t) if not is_canon else [eqs]
+        if len(canon_eqs) == 1:
+            As, b = linear_ode_to_matrix(canon_eqs[0], funcs, t, system_order)
+        else:
+
+            match = {
+                'is_implicit': True,
+                'canon_eqs': canon_eqs
+            }
+
+            return match
+
+    # When the system of ODEs is non-linear, an ODENonlinearError is raised.
+    # This function catches the error and None is returned.
+    except ODENonlinearError:
+        return None
+
+    is_linear = True
+
+    # Homogeneous check
+    is_homogeneous = True if b.is_zero_matrix else False
+
+    # Is general key is used to identify if the system of ODEs can be solved by
+    # one of the general case solvers or not.
+    match = {
+        'no_of_equation': len(eqs),
+        'eq': eqs,
+        'func': funcs,
+        'order': order,
+        'is_linear': is_linear,
+        'is_homogeneous': is_homogeneous,
+        'is_general': True
+    }
+
+    if not is_homogeneous:
+        match['rhs'] = b
+
+    is_constant = all(_matrix_is_constant(A_, t) for A_ in As)
+
+    # The match['is_linear'] check will be added in the future when this
+    # function becomes ready to deal with non-linear systems of ODEs
+
+    if not is_higher_order:
+        A = As[1]
+        match['func_coeff'] = A
+
+        # Constant coefficient check
+        is_constant = _matrix_is_constant(A, t)
+        match['is_constant'] = is_constant
+
+        try:
+            system_info = linodesolve_type(A, t, b=b)
+        except NotImplementedError:
+            return None
+
+        match.update(system_info)
+        antiderivative = match.pop("antiderivative")
+
+        if not is_constant:
+            match['commutative_antiderivative'] = antiderivative
+
+        return match
+    else:
+        match['type_of_equation'] = "type0"
+
+        if is_second_order:
+            A1, A0 = As[1:]
+
+            match_second_order = _match_second_order_type(A1, A0, t)
+            match.update(match_second_order)
+
+            match['is_second_order'] = True
+
+        # If system is constant, then no need to check if its in euler
+        # form or not. It will be easier and faster to directly proceed
+        # to solve it.
+        if match['type_of_equation'] == "type0" and not is_constant:
+            is_euler = _is_euler_system(As, t)
+            if is_euler:
+                t_ = Symbol('{}_'.format(t))
+                match.update({'is_transformed': True, 'type_of_equation': 'type1',
+                              't_': t_})
+            else:
+                is_jordan = lambda M: M == Matrix.jordan_block(M.shape[0], M[0, 0])
+                terms = _factor_matrix(As[-1], t)
+                if all(A.is_zero_matrix for A in As[1:-1]) and terms is not None and not is_jordan(terms[1]):
+                    P, J = terms[1].jordan_form()
+                    match.update({'type_of_equation': 'type2', 'J': J,
+                                  'f(t)': terms[0], 'P': P, 'is_transformed': True})
+
+            if match['type_of_equation'] != 'type0' and is_second_order:
+                match.pop('is_second_order', None)
+
+        match['is_higher_order'] = is_higher_order
+
+        return match
+
+def _preprocess_eqs(eqs):
+    processed_eqs = []
+    for eq in eqs:
+        processed_eqs.append(eq if isinstance(eq, Equality) else Eq(eq, 0))
+
+    return processed_eqs
+
+
+def _eqs2dict(eqs, funcs):
+    eqsorig = {}
+    eqsmap = {}
+    funcset = set(funcs)
+    for eq in eqs:
+        f1, = eq.lhs.atoms(AppliedUndef)
+        f2s = (eq.rhs.atoms(AppliedUndef) - {f1}) & funcset
+        eqsmap[f1] = f2s
+        eqsorig[f1] = eq
+    return eqsmap, eqsorig
+
+
+def _dict2graph(d):
+    nodes = list(d)
+    edges = [(f1, f2) for f1, f2s in d.items() for f2 in f2s]
+    G = (nodes, edges)
+    return G
+
+
+def _is_type1(scc, t):
+    eqs, funcs = scc
+
+    try:
+        (A1, A0), b = linear_ode_to_matrix(eqs, funcs, t, 1)
+    except (ODENonlinearError, ODEOrderError):
+        return False
+
+    if _matrix_is_constant(A0, t) and b.is_zero_matrix:
+        return True
+
+    return False
+
+
+def _combine_type1_subsystems(subsystem, funcs, t):
+    indices = [i for i, sys in enumerate(zip(subsystem, funcs)) if _is_type1(sys, t)]
+    remove = set()
+    for ip, i in enumerate(indices):
+        for j in indices[ip+1:]:
+            if any(eq2.has(funcs[i]) for eq2 in subsystem[j]):
+                subsystem[j] = subsystem[i] + subsystem[j]
+                remove.add(i)
+    subsystem = [sys for i, sys in enumerate(subsystem) if i not in remove]
+    return subsystem
+
+
+def _component_division(eqs, funcs, t):
+
+    # Assuming that each eq in eqs is in canonical form,
+    # that is, [f(x).diff(x) = .., g(x).diff(x) = .., etc]
+    # and that the system passed is in its first order
+    eqsmap, eqsorig = _eqs2dict(eqs, funcs)
+
+    subsystems = []
+    for cc in connected_components(_dict2graph(eqsmap)):
+        eqsmap_c = {f: eqsmap[f] for f in cc}
+        sccs = strongly_connected_components(_dict2graph(eqsmap_c))
+        subsystem = [[eqsorig[f] for f in scc] for scc in sccs]
+        subsystem = _combine_type1_subsystems(subsystem, sccs, t)
+        subsystems.append(subsystem)
+
+    return subsystems
+
+
+# Returns: List of equations
+def _linear_ode_solver(match):
+    t = match['t']
+    funcs = match['func']
+
+    rhs = match.get('rhs', None)
+    tau = match.get('tau', None)
+    t = match['t_'] if 't_' in match else t
+    A = match['func_coeff']
+
+    # Note: To make B None when the matrix has constant
+    # coefficient
+    B = match.get('commutative_antiderivative', None)
+    type = match['type_of_equation']
+
+    sol_vector = linodesolve(A, t, b=rhs, B=B,
+                             type=type, tau=tau)
+
+    sol = [Eq(f, s) for f, s in zip(funcs, sol_vector)]
+
+    return sol
+
+
+def _select_equations(eqs, funcs, key=lambda x: x):
+    eq_dict = {e.lhs: e.rhs for e in eqs}
+    return [Eq(f, eq_dict[key(f)]) for f in funcs]
+
+
+def _higher_order_ode_solver(match):
+    eqs = match["eq"]
+    funcs = match["func"]
+    t = match["t"]
+    sysorder = match['order']
+    type = match.get('type_of_equation', "type0")
+
+    is_second_order = match.get('is_second_order', False)
+    is_transformed = match.get('is_transformed', False)
+    is_euler = is_transformed and type == "type1"
+    is_higher_order_type2 = is_transformed and type == "type2" and 'P' in match
+
+    if is_second_order:
+        new_eqs, new_funcs = _second_order_to_first_order(eqs, funcs, t,
+                                                          A1=match.get("A1", None), A0=match.get("A0", None),
+                                                          b=match.get("rhs", None), type=type,
+                                                          t_=match.get("t_", None))
+    else:
+        new_eqs, new_funcs = _higher_order_to_first_order(eqs, sysorder, t, funcs=funcs,
+                                                          type=type, J=match.get('J', None),
+                                                          f_t=match.get('f(t)', None),
+                                                          P=match.get('P', None), b=match.get('rhs', None))
+
+    if is_transformed:
+        t = match.get('t_', t)
+
+    if not is_higher_order_type2:
+        new_eqs = _select_equations(new_eqs, [f.diff(t) for f in new_funcs])
+
+    sol = None
+
+    # NotImplementedError may be raised when the system may be actually
+    # solvable if it can be just divided into sub-systems
+    try:
+        if not is_higher_order_type2:
+            sol = _strong_component_solver(new_eqs, new_funcs, t)
+    except NotImplementedError:
+        sol = None
+
+    # Dividing the system only when it becomes essential
+    if sol is None:
+        try:
+            sol = _component_solver(new_eqs, new_funcs, t)
+        except NotImplementedError:
+            sol = None
+
+    if sol is None:
+        return sol
+
+    is_second_order_type2 = is_second_order and type == "type2"
+
+    underscores = '__' if is_transformed else '_'
+
+    sol = _select_equations(sol, funcs,
+                            key=lambda x: Function(Dummy('{}{}0'.format(x.func.__name__, underscores)))(t))
+
+    if match.get("is_transformed", False):
+        if is_second_order_type2:
+            g_t = match["g(t)"]
+            tau = match["tau"]
+            sol = [Eq(s.lhs, s.rhs.subs(t, tau) * g_t) for s in sol]
+        elif is_euler:
+            t = match['t']
+            tau = match['t_']
+            sol = [s.subs(tau, log(t)) for s in sol]
+        elif is_higher_order_type2:
+            P = match['P']
+            sol_vector = P * Matrix([s.rhs for s in sol])
+            sol = [Eq(f, s) for f, s in zip(funcs, sol_vector)]
+
+    return sol
+
+
+# Returns: List of equations or None
+# If None is returned by this solver, then the system
+# of ODEs cannot be solved directly by dsolve_system.
+def _strong_component_solver(eqs, funcs, t):
+    from sympy.solvers.ode.ode import dsolve, constant_renumber
+
+    match = _classify_linear_system(eqs, funcs, t, is_canon=True)
+    sol = None
+
+    # Assuming that we can't get an implicit system
+    # since we are already canonical equations from
+    # dsolve_system
+    if match:
+        match['t'] = t
+
+        if match.get('is_higher_order', False):
+            sol = _higher_order_ode_solver(match)
+
+        elif match.get('is_linear', False):
+            sol = _linear_ode_solver(match)
+
+        # Note: For now, only linear systems are handled by this function
+        # hence, the match condition is added. This can be removed later.
+        if sol is None and len(eqs) == 1:
+            sol = dsolve(eqs[0], func=funcs[0])
+            variables = Tuple(eqs[0]).free_symbols
+            new_constants = [Dummy() for _ in range(ode_order(eqs[0], funcs[0]))]
+            sol = constant_renumber(sol, variables=variables, newconstants=new_constants)
+            sol = [sol]
+
+        # To add non-linear case here in future
+
+    return sol
+
+
+def _get_funcs_from_canon(eqs):
+    return [eq.lhs.args[0] for eq in eqs]
+
+
+# Returns: List of Equations(a solution)
+def _weak_component_solver(wcc, t):
+
+    # We will divide the systems into sccs
+    # only when the wcc cannot be solved as
+    # a whole
+    eqs = []
+    for scc in wcc:
+        eqs += scc
+    funcs = _get_funcs_from_canon(eqs)
+
+    sol = _strong_component_solver(eqs, funcs, t)
+    if sol:
+        return sol
+
+    sol = []
+
+    for scc in wcc:
+        eqs = scc
+        funcs = _get_funcs_from_canon(eqs)
+
+        # Substituting solutions for the dependent
+        # variables solved in previous SCC, if any solved.
+        comp_eqs = [eq.subs({s.lhs: s.rhs for s in sol}) for eq in eqs]
+        scc_sol = _strong_component_solver(comp_eqs, funcs, t)
+
+        if scc_sol is None:
+            raise NotImplementedError(filldedent('''
+                The system of ODEs passed cannot be solved by dsolve_system.
+            '''))
+
+        # scc_sol: List of equations
+        # scc_sol is a solution
+        sol += scc_sol
+
+    return sol
+
+
+# Returns: List of Equations(a solution)
+def _component_solver(eqs, funcs, t):
+    components = _component_division(eqs, funcs, t)
+    sol = []
+
+    for wcc in components:
+
+        # wcc_sol: List of Equations
+        sol += _weak_component_solver(wcc, t)
+
+    # sol: List of Equations
+    return sol
+
+
+def _second_order_to_first_order(eqs, funcs, t, type="auto", A1=None,
+                                 A0=None, b=None, t_=None):
+    r"""
+    Expects the system to be in second order and in canonical form
+
+    Explanation
+    ===========
+
+    Reduces a second order system into a first order one depending on the type of second
+    order system.
+    1. "type0": If this is passed, then the system will be reduced to first order by
+                introducing dummy variables.
+    2. "type1": If this is passed, then a particular substitution will be used to reduce the
+                the system into first order.
+    3. "type2": If this is passed, then the system will be transformed with new dependent
+                variables and independent variables. This transformation is a part of solving
+                the corresponding system of ODEs.
+
+    `A1` and `A0` are the coefficient matrices from the system and it is assumed that the
+    second order system has the form given below:
+
+    .. math::
+        A2 * X'' = A1 * X' + A0 * X + b
+
+    Here, $A2$ is the coefficient matrix for the vector $X''$ and $b$ is the non-homogeneous
+    term.
+
+    Default value for `b` is None but if `A1` and `A0` are passed and `b` is not passed, then the
+    system will be assumed homogeneous.
+
+    """
+    is_a1 = A1 is None
+    is_a0 = A0 is None
+
+    if (type == "type1" and is_a1) or (type == "type2" and is_a0)\
+        or (type == "auto" and (is_a1 or is_a0)):
+        (A2, A1, A0), b = linear_ode_to_matrix(eqs, funcs, t, 2)
+
+        if not A2.is_Identity:
+            raise ValueError(filldedent('''
+                The system must be in its canonical form.
+            '''))
+
+    if type == "auto":
+        match = _match_second_order_type(A1, A0, t)
+        type = match["type_of_equation"]
+        A1 = match.get("A1", None)
+        A0 = match.get("A0", None)
+
+    sys_order = dict.fromkeys(funcs, 2)
+
+    if type == "type1":
+        if b is None:
+            b = zeros(len(eqs))
+        eqs = _second_order_subs_type1(A1, b, funcs, t)
+        sys_order = dict.fromkeys(funcs, 1)
+
+    if type == "type2":
+        if t_ is None:
+            t_ = Symbol("{}_".format(t))
+        t = t_
+        eqs, funcs = _second_order_subs_type2(A0, funcs, t_)
+        sys_order = dict.fromkeys(funcs, 2)
+
+    return _higher_order_to_first_order(eqs, sys_order, t, funcs=funcs)
+
+
+def _higher_order_type2_to_sub_systems(J, f_t, funcs, t, max_order, b=None, P=None):
+
+    # Note: To add a test for this ValueError
+    if J is None or f_t is None or not _matrix_is_constant(J, t):
+        raise ValueError(filldedent('''
+            Correctly input for args 'A' and 'f_t' for Linear, Higher Order,
+            Type 2
+        '''))
+
+    if P is None and b is not None and not b.is_zero_matrix:
+        raise ValueError(filldedent('''
+            Provide the keyword 'P' for matrix P in A = P * J * P-1.
+        '''))
+
+    new_funcs = Matrix([Function(Dummy('{}__0'.format(f.func.__name__)))(t) for f in funcs])
+    new_eqs = new_funcs.diff(t, max_order) - f_t * J * new_funcs
+
+    if b is not None and not b.is_zero_matrix:
+        new_eqs -= P.inv() * b
+
+    new_eqs = canonical_odes(new_eqs, new_funcs, t)[0]
+
+    return new_eqs, new_funcs
+
+
+def _higher_order_to_first_order(eqs, sys_order, t, funcs=None, type="type0", **kwargs):
+    if funcs is None:
+        funcs = sys_order.keys()
+
+    # Standard Cauchy Euler system
+    if type == "type1":
+        t_ = Symbol('{}_'.format(t))
+        new_funcs = [Function(Dummy('{}_'.format(f.func.__name__)))(t_) for f in funcs]
+        max_order = max(sys_order[func] for func in funcs)
+        subs_dict = dict(zip(funcs, new_funcs))
+        subs_dict[t] = exp(t_)
+
+        free_function = Function(Dummy())
+
+        def _get_coeffs_from_subs_expression(expr):
+            if isinstance(expr, Subs):
+                free_symbol = expr.args[1][0]
+                term = expr.args[0]
+                return {ode_order(term, free_symbol): 1}
+
+            if isinstance(expr, Mul):
+                coeff = expr.args[0]
+                order = list(_get_coeffs_from_subs_expression(expr.args[1]).keys())[0]
+                return {order: coeff}
+
+            if isinstance(expr, Add):
+                coeffs = {}
+                for arg in expr.args:
+
+                    if isinstance(arg, Mul):
+                        coeffs.update(_get_coeffs_from_subs_expression(arg))
+
+                    else:
+                        order = list(_get_coeffs_from_subs_expression(arg).keys())[0]
+                        coeffs[order] = 1
+
+                return coeffs
+
+        for o in range(1, max_order + 1):
+            expr = free_function(log(t_)).diff(t_, o)*t_**o
+            coeff_dict = _get_coeffs_from_subs_expression(expr)
+            coeffs = [coeff_dict[order] if order in coeff_dict else 0 for order in range(o + 1)]
+            expr_to_subs = sum(free_function(t_).diff(t_, i) * c for i, c in
+                        enumerate(coeffs)) / t**o
+            subs_dict.update({f.diff(t, o): expr_to_subs.subs(free_function(t_), nf)
+                              for f, nf in zip(funcs, new_funcs)})
+
+        new_eqs = [eq.subs(subs_dict) for eq in eqs]
+        new_sys_order = {nf: sys_order[f] for f, nf in zip(funcs, new_funcs)}
+
+        new_eqs = canonical_odes(new_eqs, new_funcs, t_)[0]
+
+        return _higher_order_to_first_order(new_eqs, new_sys_order, t_, funcs=new_funcs)
+
+    # Systems of the form: X(n)(t) = f(t)*A*X + b
+    # where X(n)(t) is the nth derivative of the vector of dependent variables
+    # with respect to the independent variable and A is a constant matrix.
+    if type == "type2":
+        J = kwargs.get('J', None)
+        f_t = kwargs.get('f_t', None)
+        b = kwargs.get('b', None)
+        P = kwargs.get('P', None)
+        max_order = max(sys_order[func] for func in funcs)
+
+        return _higher_order_type2_to_sub_systems(J, f_t, funcs, t, max_order, P=P, b=b)
+
+        # Note: To be changed to this after doit option is disabled for default cases
+        # new_sysorder = _get_func_order(new_eqs, new_funcs)
+        #
+        # return _higher_order_to_first_order(new_eqs, new_sysorder, t, funcs=new_funcs)
+
+    new_funcs = []
+
+    for prev_func in funcs:
+        func_name = prev_func.func.__name__
+        func = Function(Dummy('{}_0'.format(func_name)))(t)
+        new_funcs.append(func)
+        subs_dict = {prev_func: func}
+        new_eqs = []
+
+        for i in range(1, sys_order[prev_func]):
+            new_func = Function(Dummy('{}_{}'.format(func_name, i)))(t)
+            subs_dict[prev_func.diff(t, i)] = new_func
+            new_funcs.append(new_func)
+
+            prev_f = subs_dict[prev_func.diff(t, i-1)]
+            new_eq = Eq(prev_f.diff(t), new_func)
+            new_eqs.append(new_eq)
+
+        eqs = [eq.subs(subs_dict) for eq in eqs] + new_eqs
+
+    return eqs, new_funcs
+
+
+def dsolve_system(eqs, funcs=None, t=None, ics=None, doit=False, simplify=True):
+    r"""
+    Solves any(supported) system of Ordinary Differential Equations
+
+    Explanation
+    ===========
+
+    This function takes a system of ODEs as an input, determines if the
+    it is solvable by this function, and returns the solution if found any.
+
+    This function can handle:
+    1. Linear, First Order, Constant coefficient homogeneous system of ODEs
+    2. Linear, First Order, Constant coefficient non-homogeneous system of ODEs
+    3. Linear, First Order, non-constant coefficient homogeneous system of ODEs
+    4. Linear, First Order, non-constant coefficient non-homogeneous system of ODEs
+    5. Any implicit system which can be divided into system of ODEs which is of the above 4 forms
+    6. Any higher order linear system of ODEs that can be reduced to one of the 5 forms of systems described above.
+
+    The types of systems described above are not limited by the number of equations, i.e. this
+    function can solve the above types irrespective of the number of equations in the system passed.
+    But, the bigger the system, the more time it will take to solve the system.
+
+    This function returns a list of solutions. Each solution is a list of equations where LHS is
+    the dependent variable and RHS is an expression in terms of the independent variable.
+
+    Among the non constant coefficient types, not all the systems are solvable by this function. Only
+    those which have either a coefficient matrix with a commutative antiderivative or those systems which
+    may be divided further so that the divided systems may have coefficient matrix with commutative antiderivative.
+
+    Parameters
+    ==========
+
+    eqs : List
+        system of ODEs to be solved
+    funcs : List or None
+        List of dependent variables that make up the system of ODEs
+    t : Symbol or None
+        Independent variable in the system of ODEs
+    ics : Dict or None
+        Set of initial boundary/conditions for the system of ODEs
+    doit : Boolean
+        Evaluate the solutions if True. Default value is True. Can be
+        set to false if the integral evaluation takes too much time and/or
+        is not required.
+    simplify: Boolean
+        Simplify the solutions for the systems. Default value is True.
+        Can be set to false if simplification takes too much time and/or
+        is not required.
+
+    Examples
+    ========
+
+    >>> from sympy import symbols, Eq, Function
+    >>> from sympy.solvers.ode.systems import dsolve_system
+    >>> f, g = symbols("f g", cls=Function)
+    >>> x = symbols("x")
+
+    >>> eqs = [Eq(f(x).diff(x), g(x)), Eq(g(x).diff(x), f(x))]
+    >>> dsolve_system(eqs)
+    [[Eq(f(x), -C1*exp(-x) + C2*exp(x)), Eq(g(x), C1*exp(-x) + C2*exp(x))]]
+
+    You can also pass the initial conditions for the system of ODEs:
+
+    >>> dsolve_system(eqs, ics={f(0): 1, g(0): 0})
+    [[Eq(f(x), exp(x)/2 + exp(-x)/2), Eq(g(x), exp(x)/2 - exp(-x)/2)]]
+
+    Optionally, you can pass the dependent variables and the independent
+    variable for which the system is to be solved:
+
+    >>> funcs = [f(x), g(x)]
+    >>> dsolve_system(eqs, funcs=funcs, t=x)
+    [[Eq(f(x), -C1*exp(-x) + C2*exp(x)), Eq(g(x), C1*exp(-x) + C2*exp(x))]]
+
+    Lets look at an implicit system of ODEs:
+
+    >>> eqs = [Eq(f(x).diff(x)**2, g(x)**2), Eq(g(x).diff(x), g(x))]
+    >>> dsolve_system(eqs)
+    [[Eq(f(x), C1 - C2*exp(x)), Eq(g(x), C2*exp(x))], [Eq(f(x), C1 + C2*exp(x)), Eq(g(x), C2*exp(x))]]
+
+    Returns
+    =======
+
+    List of List of Equations
+
+    Raises
+    ======
+
+    NotImplementedError
+        When the system of ODEs is not solvable by this function.
+    ValueError
+        When the parameters passed are not in the required form.
+
+    """
+    from sympy.solvers.ode.ode import solve_ics, _extract_funcs, constant_renumber
+
+    if not iterable(eqs):
+        raise ValueError(filldedent('''
+            List of equations should be passed. The input is not valid.
+        '''))
+
+    eqs = _preprocess_eqs(eqs)
+
+    if funcs is not None and not isinstance(funcs, list):
+        raise ValueError(filldedent('''
+            Input to the funcs should be a list of functions.
+        '''))
+
+    if funcs is None:
+        funcs = _extract_funcs(eqs)
+
+    if any(len(func.args) != 1 for func in funcs):
+        raise ValueError(filldedent('''
+            dsolve_system can solve a system of ODEs with only one independent
+            variable.
+        '''))
+
+    if len(eqs) != len(funcs):
+        raise ValueError(filldedent('''
+            Number of equations and number of functions do not match
+        '''))
+
+    if t is not None and not isinstance(t, Symbol):
+        raise ValueError(filldedent('''
+            The independent variable must be of type Symbol
+        '''))
+
+    if t is None:
+        t = list(list(eqs[0].atoms(Derivative))[0].atoms(Symbol))[0]
+
+    sols = []
+    canon_eqs = canonical_odes(eqs, funcs, t)
+
+    for canon_eq in canon_eqs:
+        try:
+            sol = _strong_component_solver(canon_eq, funcs, t)
+        except NotImplementedError:
+            sol = None
+
+        if sol is None:
+            sol = _component_solver(canon_eq, funcs, t)
+
+        sols.append(sol)
+
+    if sols:
+        final_sols = []
+        variables = Tuple(*eqs).free_symbols
+
+        for sol in sols:
+
+            sol = _select_equations(sol, funcs)
+            sol = constant_renumber(sol, variables=variables)
+
+            if ics:
+                constants = Tuple(*sol).free_symbols - variables
+                solved_constants = solve_ics(sol, funcs, constants, ics)
+                sol = [s.subs(solved_constants) for s in sol]
+
+            if simplify:
+                constants = Tuple(*sol).free_symbols - variables
+                sol = simpsol(sol, [t], constants, doit=doit)
+
+            final_sols.append(sol)
+
+        sols = final_sols
+
+    return sols
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/ode/tests/__init__.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/ode/tests/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/ode/tests/__pycache__/__init__.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/ode/tests/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c9cf0d48f56ea267f1820831fad062d18da7def7
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/ode/tests/__pycache__/__init__.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/ode/tests/__pycache__/test_lie_group.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/ode/tests/__pycache__/test_lie_group.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a7928e2e3449771ab7579379f402a978344dd87e
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/ode/tests/__pycache__/test_lie_group.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/ode/tests/__pycache__/test_ode.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/ode/tests/__pycache__/test_ode.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..4d95b26009076b72f1f9c05b38efe2dc3e82fcf5
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/ode/tests/__pycache__/test_ode.cpython-312.pyc
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c0a96f4baad08b67b8f9ec08ae2fe0177c145e4763b056232c5507ba438ce630
+size 100680
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/ode/tests/__pycache__/test_riccati.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/ode/tests/__pycache__/test_riccati.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..076036c08474ee3db96687a8df0cc4ecc9b9bdaa
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/ode/tests/__pycache__/test_riccati.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/ode/tests/__pycache__/test_single.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/ode/tests/__pycache__/test_single.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..158b7a3cd290ab7d294de272da3a8bab861597e9
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/ode/tests/__pycache__/test_single.cpython-312.pyc
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0917ce2aa6f36ff330429de5fe6f6be31fc845653a19ab781dd25e1104a283c4
+size 240213
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/ode/tests/__pycache__/test_subscheck.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/ode/tests/__pycache__/test_subscheck.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..8acce68c6d7988b4e6754c6a37550f0f2a7244c3
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/ode/tests/__pycache__/test_subscheck.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/ode/tests/__pycache__/test_systems.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/ode/tests/__pycache__/test_systems.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f45891275c0ed1c02af11ef1d9738b27fc478533
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/ode/tests/__pycache__/test_systems.cpython-312.pyc
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8aa95b99f372996787803d33788118fa3ac93ff72330c528dcb70bd01ef7dda6
+size 314879
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/ode/tests/test_lie_group.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/ode/tests/test_lie_group.py
new file mode 100644
index 0000000000000000000000000000000000000000..153d30ff563773819e49c989f447c1ec7962169b
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/ode/tests/test_lie_group.py
@@ -0,0 +1,152 @@
+from sympy.core.function import Function
+from sympy.core.numbers import Rational
+from sympy.core.relational import Eq
+from sympy.core.symbol import (Symbol, symbols)
+from sympy.functions.elementary.exponential import (exp, log)
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import (atan, sin, tan)
+
+from sympy.solvers.ode import (classify_ode, checkinfsol, dsolve, infinitesimals)
+
+from sympy.solvers.ode.subscheck import checkodesol
+
+from sympy.testing.pytest import XFAIL
+
+
+C1 = Symbol('C1')
+x, y = symbols("x y")
+f = Function('f')
+xi = Function('xi')
+eta = Function('eta')
+
+
+def test_heuristic1():
+    a, b, c, a4, a3, a2, a1, a0 = symbols("a b c a4 a3 a2 a1 a0")
+    df = f(x).diff(x)
+    eq = Eq(df, x**2*f(x))
+    eq1 = f(x).diff(x) + a*f(x) - c*exp(b*x)
+    eq2 = f(x).diff(x) + 2*x*f(x) - x*exp(-x**2)
+    eq3 = (1 + 2*x)*df + 2 - 4*exp(-f(x))
+    eq4 = f(x).diff(x) - (a4*x**4 + a3*x**3 + a2*x**2 + a1*x + a0)**Rational(-1, 2)
+    eq5 = x**2*df - f(x) + x**2*exp(x - (1/x))
+    eqlist = [eq, eq1, eq2, eq3, eq4, eq5]
+
+    i = infinitesimals(eq, hint='abaco1_simple')
+    assert i == [{eta(x, f(x)): exp(x**3/3), xi(x, f(x)): 0},
+        {eta(x, f(x)): f(x), xi(x, f(x)): 0},
+        {eta(x, f(x)): 0, xi(x, f(x)): x**(-2)}]
+    i1 = infinitesimals(eq1, hint='abaco1_simple')
+    assert i1 == [{eta(x, f(x)): exp(-a*x), xi(x, f(x)): 0}]
+    i2 = infinitesimals(eq2, hint='abaco1_simple')
+    assert i2 == [{eta(x, f(x)): exp(-x**2), xi(x, f(x)): 0}]
+    i3 = infinitesimals(eq3, hint='abaco1_simple')
+    assert i3 == [{eta(x, f(x)): 0, xi(x, f(x)): 2*x + 1},
+        {eta(x, f(x)): 0, xi(x, f(x)): 1/(exp(f(x)) - 2)}]
+    i4 = infinitesimals(eq4, hint='abaco1_simple')
+    assert i4 == [{eta(x, f(x)): 1, xi(x, f(x)): 0},
+        {eta(x, f(x)): 0,
+        xi(x, f(x)): sqrt(a0 + a1*x + a2*x**2 + a3*x**3 + a4*x**4)}]
+    i5 = infinitesimals(eq5, hint='abaco1_simple')
+    assert i5 == [{xi(x, f(x)): 0, eta(x, f(x)): exp(-1/x)}]
+
+    ilist = [i, i1, i2, i3, i4, i5]
+    for eq, i in (zip(eqlist, ilist)):
+        check = checkinfsol(eq, i)
+        assert check[0]
+
+    # This ODE can be solved by the Lie Group method, when there are
+    # better assumptions
+    eq6 = df - (f(x)/x)*(x*log(x**2/f(x)) + 2)
+    i = infinitesimals(eq6, hint='abaco1_product')
+    assert i == [{eta(x, f(x)): f(x)*exp(-x), xi(x, f(x)): 0}]
+    assert checkinfsol(eq6, i)[0]
+
+    eq7 = x*(f(x).diff(x)) + 1 - f(x)**2
+    i = infinitesimals(eq7, hint='chi')
+    assert checkinfsol(eq7, i)[0]
+
+
+def test_heuristic3():
+    a, b = symbols("a b")
+    df = f(x).diff(x)
+
+    eq = x**2*df + x*f(x) + f(x)**2 + x**2
+    i = infinitesimals(eq, hint='bivariate')
+    assert i == [{eta(x, f(x)): f(x), xi(x, f(x)): x}]
+    assert checkinfsol(eq, i)[0]
+
+    eq = x**2*(-f(x)**2 + df)- a*x**2*f(x) + 2 - a*x
+    i = infinitesimals(eq, hint='bivariate')
+    assert checkinfsol(eq, i)[0]
+
+
+def test_heuristic_function_sum():
+    eq = f(x).diff(x) - (3*(1 + x**2/f(x)**2)*atan(f(x)/x) + (1 - 2*f(x))/x +
+       (1 - 3*f(x))*(x/f(x)**2))
+    i = infinitesimals(eq, hint='function_sum')
+    assert i == [{eta(x, f(x)): f(x)**(-2) + x**(-2), xi(x, f(x)): 0}]
+    assert checkinfsol(eq, i)[0]
+
+
+def test_heuristic_abaco2_similar():
+    a, b = symbols("a b")
+    F = Function('F')
+    eq = f(x).diff(x) - F(a*x + b*f(x))
+    i = infinitesimals(eq, hint='abaco2_similar')
+    assert i == [{eta(x, f(x)): -a/b, xi(x, f(x)): 1}]
+    assert checkinfsol(eq, i)[0]
+
+    eq = f(x).diff(x) - (f(x)**2 / (sin(f(x) - x) - x**2 + 2*x*f(x)))
+    i = infinitesimals(eq, hint='abaco2_similar')
+    assert i == [{eta(x, f(x)): f(x)**2, xi(x, f(x)): f(x)**2}]
+    assert checkinfsol(eq, i)[0]
+
+
+def test_heuristic_abaco2_unique_unknown():
+
+    a, b = symbols("a b")
+    F = Function('F')
+    eq = f(x).diff(x) - x**(a - 1)*(f(x)**(1 - b))*F(x**a/a + f(x)**b/b)
+    i = infinitesimals(eq, hint='abaco2_unique_unknown')
+    assert i == [{eta(x, f(x)): -f(x)*f(x)**(-b), xi(x, f(x)): x*x**(-a)}]
+    assert checkinfsol(eq, i)[0]
+
+    eq = f(x).diff(x) + tan(F(x**2 + f(x)**2) + atan(x/f(x)))
+    i = infinitesimals(eq, hint='abaco2_unique_unknown')
+    assert i == [{eta(x, f(x)): x, xi(x, f(x)): -f(x)}]
+    assert checkinfsol(eq, i)[0]
+
+    eq = (x*f(x).diff(x) + f(x) + 2*x)**2 -4*x*f(x) -4*x**2 -4*a
+    i = infinitesimals(eq, hint='abaco2_unique_unknown')
+    assert checkinfsol(eq, i)[0]
+
+
+def test_heuristic_linear():
+    a, b, m, n = symbols("a b m n")
+
+    eq = x**(n*(m + 1) - m)*(f(x).diff(x)) - a*f(x)**n -b*x**(n*(m + 1))
+    i = infinitesimals(eq, hint='linear')
+    assert checkinfsol(eq, i)[0]
+
+
+@XFAIL
+def test_kamke():
+    a, b, alpha, c = symbols("a b alpha c")
+    eq = x**2*(a*f(x)**2+(f(x).diff(x))) + b*x**alpha + c
+    i = infinitesimals(eq, hint='sum_function')  # XFAIL
+    assert checkinfsol(eq, i)[0]
+
+
+def test_user_infinitesimals():
+    x = Symbol("x") # assuming x is real generates an error
+    eq = x*(f(x).diff(x)) + 1 - f(x)**2
+    sol = Eq(f(x), (C1 + x**2)/(C1 - x**2))
+    infinitesimals = {'xi':sqrt(f(x) - 1)/sqrt(f(x) + 1), 'eta':0}
+    assert dsolve(eq, hint='lie_group', **infinitesimals) == sol
+    assert checkodesol(eq, sol) == (True, 0)
+
+
+@XFAIL
+def test_lie_group_issue15219():
+    eqn = exp(f(x).diff(x)-f(x))
+    assert 'lie_group' not in classify_ode(eqn, f(x))
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/ode/tests/test_ode.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/ode/tests/test_ode.py
new file mode 100644
index 0000000000000000000000000000000000000000..65e0fa62d52445a4669f3cdc5ef278dbf9c88ea4
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/ode/tests/test_ode.py
@@ -0,0 +1,1105 @@
+from sympy.core.function import (Derivative, Function, Subs, diff)
+from sympy.core.numbers import (E, I, Rational, pi)
+from sympy.core.relational import Eq
+from sympy.core.singleton import S
+from sympy.core.symbol import (Symbol, symbols)
+from sympy.functions.elementary.complexes import (im, re)
+from sympy.functions.elementary.exponential import (exp, log)
+from sympy.functions.elementary.hyperbolic import acosh
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import (atan2, cos, sin, tan)
+from sympy.integrals.integrals import Integral
+from sympy.polys.polytools import Poly
+from sympy.series.order import O
+from sympy.simplify.radsimp import collect
+
+from sympy.solvers.ode import (classify_ode,
+    homogeneous_order, dsolve)
+
+from sympy.solvers.ode.subscheck import checkodesol
+from sympy.solvers.ode.ode import (classify_sysode,
+    constant_renumber, constantsimp, get_numbered_constants, solve_ics)
+
+from sympy.solvers.ode.nonhomogeneous import _undetermined_coefficients_match
+from sympy.solvers.ode.single import LinearCoefficients
+from sympy.solvers.deutils import ode_order
+from sympy.testing.pytest import XFAIL, raises, slow, SKIP
+from sympy.utilities.misc import filldedent
+
+
+C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10 = symbols('C0:11')
+u, x, y, z = symbols('u,x:z', real=True)
+f = Function('f')
+g = Function('g')
+h = Function('h')
+
+# Note: Examples which were specifically testing Single ODE solver are moved to test_single.py
+# and all the system of ode examples are moved to test_systems.py
+# Note: the tests below may fail (but still be correct) if ODE solver,
+# the integral engine, solve(), or even simplify() changes. Also, in
+# differently formatted solutions, the arbitrary constants might not be
+# equal.  Using specific hints in tests can help to avoid this.
+
+# Tests of order higher than 1 should run the solutions through
+# constant_renumber because it will normalize it (constant_renumber causes
+# dsolve() to return different results on different machines)
+
+
+def test_get_numbered_constants():
+    with raises(ValueError):
+        get_numbered_constants(None)
+
+
+def test_dsolve_all_hint():
+    eq = f(x).diff(x)
+    output = dsolve(eq, hint='all')
+
+    # Match the Dummy variables:
+    sol1 = output['separable_Integral']
+    _y = sol1.lhs.args[1][0]
+    sol1 = output['1st_homogeneous_coeff_subs_dep_div_indep_Integral']
+    _u1 = sol1.rhs.args[1].args[1][0]
+
+    expected = {'Bernoulli_Integral': Eq(f(x), C1 + Integral(0, x)),
+        '1st_homogeneous_coeff_best': Eq(f(x), C1),
+        'Bernoulli': Eq(f(x), C1),
+        'nth_algebraic': Eq(f(x), C1),
+        'nth_linear_euler_eq_homogeneous': Eq(f(x), C1),
+        'nth_linear_constant_coeff_homogeneous': Eq(f(x), C1),
+        'separable': Eq(f(x), C1),
+        '1st_homogeneous_coeff_subs_indep_div_dep': Eq(f(x), C1),
+        'nth_algebraic_Integral': Eq(f(x), C1),
+        '1st_linear': Eq(f(x), C1),
+        '1st_linear_Integral': Eq(f(x), C1 + Integral(0, x)),
+        '1st_exact': Eq(f(x), C1),
+        '1st_exact_Integral': Eq(Subs(Integral(0, x) + Integral(1, _y), _y, f(x)), C1),
+        'lie_group': Eq(f(x), C1),
+        '1st_homogeneous_coeff_subs_dep_div_indep': Eq(f(x), C1),
+        '1st_homogeneous_coeff_subs_dep_div_indep_Integral': Eq(log(x), C1 + Integral(-1/_u1, (_u1, f(x)/x))),
+        '1st_power_series': Eq(f(x), C1),
+        'separable_Integral': Eq(Integral(1, (_y, f(x))), C1 + Integral(0, x)),
+        '1st_homogeneous_coeff_subs_indep_div_dep_Integral': Eq(f(x), C1),
+        'best': Eq(f(x), C1),
+        'best_hint': 'nth_algebraic',
+        'default': 'nth_algebraic',
+        'order': 1}
+    assert output == expected
+
+    assert dsolve(eq, hint='best') == Eq(f(x), C1)
+
+
+def test_dsolve_ics():
+    # Maybe this should just use one of the solutions instead of raising...
+    with raises(NotImplementedError):
+        dsolve(f(x).diff(x) - sqrt(f(x)), ics={f(1):1})
+
+
+@slow
+def test_dsolve_options():
+    eq = x*f(x).diff(x) + f(x)
+    a = dsolve(eq, hint='all')
+    b = dsolve(eq, hint='all', simplify=False)
+    c = dsolve(eq, hint='all_Integral')
+    keys = ['1st_exact', '1st_exact_Integral', '1st_homogeneous_coeff_best',
+        '1st_homogeneous_coeff_subs_dep_div_indep',
+        '1st_homogeneous_coeff_subs_dep_div_indep_Integral',
+        '1st_homogeneous_coeff_subs_indep_div_dep',
+        '1st_homogeneous_coeff_subs_indep_div_dep_Integral', '1st_linear',
+        '1st_linear_Integral', 'Bernoulli', 'Bernoulli_Integral',
+        'almost_linear', 'almost_linear_Integral', 'best', 'best_hint',
+        'default', 'factorable', 'lie_group',
+        'nth_linear_euler_eq_homogeneous', 'order',
+        'separable', 'separable_Integral']
+    Integral_keys = ['1st_exact_Integral',
+        '1st_homogeneous_coeff_subs_dep_div_indep_Integral',
+        '1st_homogeneous_coeff_subs_indep_div_dep_Integral', '1st_linear_Integral',
+        'Bernoulli_Integral', 'almost_linear_Integral', 'best', 'best_hint', 'default',
+        'factorable', 'nth_linear_euler_eq_homogeneous',
+        'order', 'separable_Integral']
+    assert sorted(a.keys()) == keys
+    assert a['order'] == ode_order(eq, f(x))
+    assert a['best'] == Eq(f(x), C1/x)
+    assert dsolve(eq, hint='best') == Eq(f(x), C1/x)
+    assert a['default'] == 'factorable'
+    assert a['best_hint'] == 'factorable'
+    assert not a['1st_exact'].has(Integral)
+    assert not a['separable'].has(Integral)
+    assert not a['1st_homogeneous_coeff_best'].has(Integral)
+    assert not a['1st_homogeneous_coeff_subs_dep_div_indep'].has(Integral)
+    assert not a['1st_homogeneous_coeff_subs_indep_div_dep'].has(Integral)
+    assert not a['1st_linear'].has(Integral)
+    assert a['1st_linear_Integral'].has(Integral)
+    assert a['1st_exact_Integral'].has(Integral)
+    assert a['1st_homogeneous_coeff_subs_dep_div_indep_Integral'].has(Integral)
+    assert a['1st_homogeneous_coeff_subs_indep_div_dep_Integral'].has(Integral)
+    assert a['separable_Integral'].has(Integral)
+    assert sorted(b.keys()) == keys
+    assert b['order'] == ode_order(eq, f(x))
+    assert b['best'] == Eq(f(x), C1/x)
+    assert dsolve(eq, hint='best', simplify=False) == Eq(f(x), C1/x)
+    assert b['default'] == 'factorable'
+    assert b['best_hint'] == 'factorable'
+    assert a['separable'] != b['separable']
+    assert a['1st_homogeneous_coeff_subs_dep_div_indep'] != \
+        b['1st_homogeneous_coeff_subs_dep_div_indep']
+    assert a['1st_homogeneous_coeff_subs_indep_div_dep'] != \
+        b['1st_homogeneous_coeff_subs_indep_div_dep']
+    assert not b['1st_exact'].has(Integral)
+    assert not b['separable'].has(Integral)
+    assert not b['1st_homogeneous_coeff_best'].has(Integral)
+    assert not b['1st_homogeneous_coeff_subs_dep_div_indep'].has(Integral)
+    assert not b['1st_homogeneous_coeff_subs_indep_div_dep'].has(Integral)
+    assert not b['1st_linear'].has(Integral)
+    assert b['1st_linear_Integral'].has(Integral)
+    assert b['1st_exact_Integral'].has(Integral)
+    assert b['1st_homogeneous_coeff_subs_dep_div_indep_Integral'].has(Integral)
+    assert b['1st_homogeneous_coeff_subs_indep_div_dep_Integral'].has(Integral)
+    assert b['separable_Integral'].has(Integral)
+    assert sorted(c.keys()) == Integral_keys
+    raises(ValueError, lambda: dsolve(eq, hint='notarealhint'))
+    raises(ValueError, lambda: dsolve(eq, hint='Liouville'))
+    assert dsolve(f(x).diff(x) - 1/f(x)**2, hint='all')['best'] == \
+        dsolve(f(x).diff(x) - 1/f(x)**2, hint='best')
+    assert dsolve(f(x) + f(x).diff(x) + sin(x).diff(x) + 1, f(x),
+                  hint="1st_linear_Integral") == \
+        Eq(f(x), (C1 + Integral((-sin(x).diff(x) - 1)*
+                exp(Integral(1, x)), x))*exp(-Integral(1, x)))
+
+
+def test_classify_ode():
+    assert classify_ode(f(x).diff(x, 2), f(x)) == \
+        (
+        'nth_algebraic',
+        'nth_linear_constant_coeff_homogeneous',
+        'nth_linear_euler_eq_homogeneous',
+        'Liouville',
+        '2nd_power_series_ordinary',
+        'nth_algebraic_Integral',
+        'Liouville_Integral',
+        )
+    assert classify_ode(f(x), f(x)) == ('nth_algebraic', 'nth_algebraic_Integral')
+    assert classify_ode(Eq(f(x).diff(x), 0), f(x)) == (
+        'nth_algebraic',
+        'separable',
+        '1st_exact',
+        '1st_linear',
+        'Bernoulli',
+        '1st_homogeneous_coeff_best',
+        '1st_homogeneous_coeff_subs_indep_div_dep',
+        '1st_homogeneous_coeff_subs_dep_div_indep',
+        '1st_power_series', 'lie_group',
+        'nth_linear_constant_coeff_homogeneous',
+        'nth_linear_euler_eq_homogeneous',
+        'nth_algebraic_Integral',
+        'separable_Integral',
+        '1st_exact_Integral',
+        '1st_linear_Integral',
+        'Bernoulli_Integral',
+        '1st_homogeneous_coeff_subs_indep_div_dep_Integral',
+        '1st_homogeneous_coeff_subs_dep_div_indep_Integral')
+    assert classify_ode(f(x).diff(x)**2, f(x)) == ('factorable',
+         'nth_algebraic',
+         'separable',
+         '1st_exact',
+         '1st_linear',
+         'Bernoulli',
+         '1st_homogeneous_coeff_best',
+         '1st_homogeneous_coeff_subs_indep_div_dep',
+         '1st_homogeneous_coeff_subs_dep_div_indep',
+         '1st_power_series',
+         'lie_group',
+         'nth_linear_euler_eq_homogeneous',
+         'nth_algebraic_Integral',
+         'separable_Integral',
+         '1st_exact_Integral',
+         '1st_linear_Integral',
+         'Bernoulli_Integral',
+         '1st_homogeneous_coeff_subs_indep_div_dep_Integral',
+         '1st_homogeneous_coeff_subs_dep_div_indep_Integral')
+    # issue 4749: f(x) should be cleared from highest derivative before classifying
+    a = classify_ode(Eq(f(x).diff(x) + f(x), x), f(x))
+    b = classify_ode(f(x).diff(x)*f(x) + f(x)*f(x) - x*f(x), f(x))
+    c = classify_ode(f(x).diff(x)/f(x) + f(x)/f(x) - x/f(x), f(x))
+    assert a == ('1st_exact',
+        '1st_linear',
+        'Bernoulli',
+        'almost_linear',
+        '1st_power_series', "lie_group",
+        'nth_linear_constant_coeff_undetermined_coefficients',
+        'nth_linear_constant_coeff_variation_of_parameters',
+        '1st_exact_Integral',
+        '1st_linear_Integral',
+        'Bernoulli_Integral',
+        'almost_linear_Integral',
+        'nth_linear_constant_coeff_variation_of_parameters_Integral')
+    assert b == ('factorable',
+         '1st_linear',
+         'Bernoulli',
+         '1st_power_series',
+         'lie_group',
+         'nth_linear_constant_coeff_undetermined_coefficients',
+         'nth_linear_constant_coeff_variation_of_parameters',
+         '1st_linear_Integral',
+         'Bernoulli_Integral',
+         'nth_linear_constant_coeff_variation_of_parameters_Integral')
+    assert c == ('factorable',
+         '1st_linear',
+         'Bernoulli',
+         '1st_power_series',
+         'lie_group',
+         'nth_linear_constant_coeff_undetermined_coefficients',
+         'nth_linear_constant_coeff_variation_of_parameters',
+         '1st_linear_Integral',
+         'Bernoulli_Integral',
+         'nth_linear_constant_coeff_variation_of_parameters_Integral')
+
+    assert classify_ode(
+        2*x*f(x)*f(x).diff(x) + (1 + x)*f(x)**2 - exp(x), f(x)
+    ) == ('factorable', '1st_exact', 'Bernoulli', 'almost_linear', 'lie_group',
+        '1st_exact_Integral', 'Bernoulli_Integral', 'almost_linear_Integral')
+    assert 'Riccati_special_minus2' in \
+        classify_ode(2*f(x).diff(x) + f(x)**2 - f(x)/x + 3*x**(-2), f(x))
+    raises(ValueError, lambda: classify_ode(x + f(x, y).diff(x).diff(
+        y), f(x, y)))
+    # issue 5176
+    k = Symbol('k')
+    assert classify_ode(f(x).diff(x)/(k*f(x) + k*x*f(x)) + 2*f(x)/(k*f(x) +
+        k*x*f(x)) + x*f(x).diff(x)/(k*f(x) + k*x*f(x)) + z, f(x)) == \
+        ('factorable', 'separable', '1st_exact', '1st_linear', 'Bernoulli',
+        '1st_power_series', 'lie_group', 'separable_Integral', '1st_exact_Integral',
+        '1st_linear_Integral', 'Bernoulli_Integral')
+    # preprocessing
+    ans = ('factorable', 'nth_algebraic', 'separable', '1st_exact', '1st_linear', 'Bernoulli',
+        '1st_homogeneous_coeff_best',
+        '1st_homogeneous_coeff_subs_indep_div_dep',
+        '1st_homogeneous_coeff_subs_dep_div_indep',
+        '1st_power_series', 'lie_group',
+        'nth_linear_constant_coeff_undetermined_coefficients',
+        'nth_linear_euler_eq_nonhomogeneous_undetermined_coefficients',
+        'nth_linear_constant_coeff_variation_of_parameters',
+        'nth_linear_euler_eq_nonhomogeneous_variation_of_parameters',
+        'nth_algebraic_Integral',
+        'separable_Integral', '1st_exact_Integral',
+        '1st_linear_Integral',
+        'Bernoulli_Integral',
+        '1st_homogeneous_coeff_subs_indep_div_dep_Integral',
+        '1st_homogeneous_coeff_subs_dep_div_indep_Integral',
+        'nth_linear_constant_coeff_variation_of_parameters_Integral',
+        'nth_linear_euler_eq_nonhomogeneous_variation_of_parameters_Integral')
+    #     w/o f(x) given
+    assert classify_ode(diff(f(x) + x, x) + diff(f(x), x)) == ans
+    #     w/ f(x) and prep=True
+    assert classify_ode(diff(f(x) + x, x) + diff(f(x), x), f(x),
+                        prep=True) == ans
+
+    assert classify_ode(Eq(2*x**3*f(x).diff(x), 0), f(x)) == \
+        ('factorable', 'nth_algebraic', 'separable', '1st_exact',
+         '1st_linear', 'Bernoulli', '1st_power_series',
+         'lie_group', 'nth_linear_euler_eq_homogeneous',
+         'nth_algebraic_Integral', 'separable_Integral', '1st_exact_Integral',
+         '1st_linear_Integral', 'Bernoulli_Integral')
+
+
+    assert classify_ode(Eq(2*f(x)**3*f(x).diff(x), 0), f(x)) == \
+        ('factorable', 'nth_algebraic', 'separable', '1st_exact', '1st_linear',
+         'Bernoulli', '1st_power_series', 'lie_group', 'nth_algebraic_Integral',
+         'separable_Integral', '1st_exact_Integral', '1st_linear_Integral',
+         'Bernoulli_Integral')
+    # test issue 13864
+    assert classify_ode(Eq(diff(f(x), x) - f(x)**x, 0), f(x)) == \
+        ('1st_power_series', 'lie_group')
+    assert isinstance(classify_ode(Eq(f(x), 5), f(x), dict=True), dict)
+
+    #This is for new behavior of classify_ode when called internally with default, It should
+    # return the first hint which matches therefore, 'ordered_hints' key will not be there.
+    assert sorted(classify_ode(Eq(f(x).diff(x), 0), f(x), dict=True).keys()) == \
+        ['default', 'nth_linear_constant_coeff_homogeneous', 'order']
+    a = classify_ode(2*x*f(x)*f(x).diff(x) + (1 + x)*f(x)**2 - exp(x), f(x), dict=True, hint='Bernoulli')
+    assert sorted(a.keys()) == ['Bernoulli', 'Bernoulli_Integral', 'default', 'order', 'ordered_hints']
+
+    # test issue 22155
+    a = classify_ode(f(x).diff(x) - exp(f(x) - x), f(x))
+    assert a == ('separable',
+        '1st_exact', '1st_power_series',
+        'lie_group', 'separable_Integral',
+        '1st_exact_Integral')
+
+
+def test_classify_ode_ics():
+    # Dummy
+    eq = f(x).diff(x, x) - f(x)
+
+    # Not f(0) or f'(0)
+    ics = {x: 1}
+    raises(ValueError, lambda: classify_ode(eq, f(x), ics=ics))
+
+
+    ############################
+    # f(0) type (AppliedUndef) #
+    ############################
+
+
+    # Wrong function
+    ics = {g(0): 1}
+    raises(ValueError, lambda: classify_ode(eq, f(x), ics=ics))
+
+    # Contains x
+    ics = {f(x): 1}
+    raises(ValueError, lambda: classify_ode(eq, f(x), ics=ics))
+
+    # Too many args
+    ics = {f(0, 0): 1}
+    raises(ValueError, lambda: classify_ode(eq, f(x), ics=ics))
+
+    # point contains x
+    ics = {f(0): f(x)}
+    raises(ValueError, lambda: classify_ode(eq, f(x), ics=ics))
+
+    # Does not raise
+    ics = {f(0): f(0)}
+    classify_ode(eq, f(x), ics=ics)
+
+    # Does not raise
+    ics = {f(0): 1}
+    classify_ode(eq, f(x), ics=ics)
+
+
+    #####################
+    # f'(0) type (Subs) #
+    #####################
+
+    # Wrong function
+    ics = {g(x).diff(x).subs(x, 0): 1}
+    raises(ValueError, lambda: classify_ode(eq, f(x), ics=ics))
+
+    # Contains x
+    ics = {f(y).diff(y).subs(y, x): 1}
+    raises(ValueError, lambda: classify_ode(eq, f(x), ics=ics))
+
+    # Wrong variable
+    ics = {f(y).diff(y).subs(y, 0): 1}
+    raises(ValueError, lambda: classify_ode(eq, f(x), ics=ics))
+
+    # Too many args
+    ics = {f(x, y).diff(x).subs(x, 0): 1}
+    raises(ValueError, lambda: classify_ode(eq, f(x), ics=ics))
+
+    # Derivative wrt wrong vars
+    ics = {Derivative(f(x), x, y).subs(x, 0): 1}
+    raises(ValueError, lambda: classify_ode(eq, f(x), ics=ics))
+
+    # point contains x
+    ics = {f(x).diff(x).subs(x, 0): f(x)}
+    raises(ValueError, lambda: classify_ode(eq, f(x), ics=ics))
+
+    # Does not raise
+    ics = {f(x).diff(x).subs(x, 0): f(x).diff(x).subs(x, 0)}
+    classify_ode(eq, f(x), ics=ics)
+
+    # Does not raise
+    ics = {f(x).diff(x).subs(x, 0): 1}
+    classify_ode(eq, f(x), ics=ics)
+
+    ###########################
+    # f'(y) type (Derivative) #
+    ###########################
+
+    # Wrong function
+    ics = {g(x).diff(x).subs(x, y): 1}
+    raises(ValueError, lambda: classify_ode(eq, f(x), ics=ics))
+
+    # Contains x
+    ics = {f(y).diff(y).subs(y, x): 1}
+    raises(ValueError, lambda: classify_ode(eq, f(x), ics=ics))
+
+    # Too many args
+    ics = {f(x, y).diff(x).subs(x, y): 1}
+    raises(ValueError, lambda: classify_ode(eq, f(x), ics=ics))
+
+    # Derivative wrt wrong vars
+    ics = {Derivative(f(x), x, z).subs(x, y): 1}
+    raises(ValueError, lambda: classify_ode(eq, f(x), ics=ics))
+
+    # point contains x
+    ics = {f(x).diff(x).subs(x, y): f(x)}
+    raises(ValueError, lambda: classify_ode(eq, f(x), ics=ics))
+
+    # Does not raise
+    ics = {f(x).diff(x).subs(x, 0): f(0)}
+    classify_ode(eq, f(x), ics=ics)
+
+    # Does not raise
+    ics = {f(x).diff(x).subs(x, y): 1}
+    classify_ode(eq, f(x), ics=ics)
+
+def test_classify_sysode():
+    # Here x is assumed to be x(t) and y as y(t) for simplicity.
+    # Similarly diff(x,t) and diff(y,y) is assumed to be x1 and y1 respectively.
+    k, l, m, n = symbols('k, l, m, n', Integer=True)
+    k1, k2, k3, l1, l2, l3, m1, m2, m3 = symbols('k1, k2, k3, l1, l2, l3, m1, m2, m3', Integer=True)
+    P, Q, R, p, q, r = symbols('P, Q, R, p, q, r', cls=Function)
+    P1, P2, P3, Q1, Q2, R1, R2 = symbols('P1, P2, P3, Q1, Q2, R1, R2', cls=Function)
+    x, y, z = symbols('x, y, z', cls=Function)
+    t = symbols('t')
+    x1 = diff(x(t),t)
+    y1 = diff(y(t),t)
+
+    eq6 = (Eq(x1, exp(k*x(t))*P(x(t),y(t))), Eq(y1,r(y(t))*P(x(t),y(t))))
+    sol6 = {'no_of_equation': 2, 'func_coeff': {(0, x(t), 0): 0, (1, x(t), 1): 0, (0, x(t), 1): 1, (1, y(t), 0): 0, \
+    (1, x(t), 0): 0, (0, y(t), 1): 0, (0, y(t), 0): 0, (1, y(t), 1): 1}, 'type_of_equation': 'type2', 'func': \
+    [x(t), y(t)], 'is_linear': False, 'eq': [-P(x(t), y(t))*exp(k*x(t)) + Derivative(x(t), t), -P(x(t), \
+    y(t))*r(y(t)) + Derivative(y(t), t)], 'order': {y(t): 1, x(t): 1}}
+    assert classify_sysode(eq6) == sol6
+
+    eq7 = (Eq(x1, x(t)**2+y(t)/x(t)), Eq(y1, x(t)/y(t)))
+    sol7 = {'no_of_equation': 2, 'func_coeff': {(0, x(t), 0): 0, (1, x(t), 1): 0, (0, x(t), 1): 1, (1, y(t), 0): 0, \
+    (1, x(t), 0): -1/y(t), (0, y(t), 1): 0, (0, y(t), 0): -1/x(t), (1, y(t), 1): 1}, 'type_of_equation': 'type3', \
+    'func': [x(t), y(t)], 'is_linear': False, 'eq': [-x(t)**2 + Derivative(x(t), t) - y(t)/x(t), -x(t)/y(t) + \
+    Derivative(y(t), t)], 'order': {y(t): 1, x(t): 1}}
+    assert classify_sysode(eq7) == sol7
+
+    eq8 = (Eq(x1, P1(x(t))*Q1(y(t))*R(x(t),y(t),t)), Eq(y1, P1(x(t))*Q1(y(t))*R(x(t),y(t),t)))
+    sol8 = {'func': [x(t), y(t)], 'is_linear': False, 'type_of_equation': 'type4', 'eq': \
+    [-P1(x(t))*Q1(y(t))*R(x(t), y(t), t) + Derivative(x(t), t), -P1(x(t))*Q1(y(t))*R(x(t), y(t), t) + \
+    Derivative(y(t), t)], 'func_coeff': {(0, y(t), 1): 0, (1, y(t), 1): 1, (1, x(t), 1): 0, (0, y(t), 0): 0, \
+    (1, x(t), 0): 0, (0, x(t), 0): 0, (1, y(t), 0): 0, (0, x(t), 1): 1}, 'order': {y(t): 1, x(t): 1}, 'no_of_equation': 2}
+    assert classify_sysode(eq8) == sol8
+
+    eq11 = (Eq(x1,x(t)*y(t)**3), Eq(y1,y(t)**5))
+    sol11 = {'no_of_equation': 2, 'func_coeff': {(0, x(t), 0): -y(t)**3, (1, x(t), 1): 0, (0, x(t), 1): 1, \
+    (1, y(t), 0): 0, (1, x(t), 0): 0, (0, y(t), 1): 0, (0, y(t), 0): 0, (1, y(t), 1): 1}, 'type_of_equation': \
+    'type1', 'func': [x(t), y(t)], 'is_linear': False, 'eq': [-x(t)*y(t)**3 + Derivative(x(t), t), \
+    -y(t)**5 + Derivative(y(t), t)], 'order': {y(t): 1, x(t): 1}}
+    assert classify_sysode(eq11) == sol11
+
+    eq13 = (Eq(x1,x(t)*y(t)*sin(t)**2), Eq(y1,y(t)**2*sin(t)**2))
+    sol13 = {'no_of_equation': 2, 'func_coeff': {(0, x(t), 0): -y(t)*sin(t)**2, (1, x(t), 1): 0, (0, x(t), 1): 1, \
+    (1, y(t), 0): 0, (1, x(t), 0): 0, (0, y(t), 1): 0, (0, y(t), 0): -x(t)*sin(t)**2, (1, y(t), 1): 1}, \
+    'type_of_equation': 'type4', 'func': [x(t), y(t)], 'is_linear': False, 'eq': [-x(t)*y(t)*sin(t)**2 + \
+    Derivative(x(t), t), -y(t)**2*sin(t)**2 + Derivative(y(t), t)], 'order': {y(t): 1, x(t): 1}}
+    assert classify_sysode(eq13) == sol13
+
+
+def test_solve_ics():
+    # Basic tests that things work from dsolve.
+    assert dsolve(f(x).diff(x) - 1/f(x), f(x), ics={f(1): 2}) == \
+        Eq(f(x), sqrt(2 * x + 2))
+    assert dsolve(f(x).diff(x) - f(x), f(x), ics={f(0): 1}) == Eq(f(x), exp(x))
+    assert dsolve(f(x).diff(x) - f(x), f(x), ics={f(x).diff(x).subs(x, 0): 1}) == Eq(f(x), exp(x))
+    assert dsolve(f(x).diff(x, x) + f(x), f(x), ics={f(0): 1,
+        f(x).diff(x).subs(x, 0): 1}) == Eq(f(x), sin(x) + cos(x))
+    assert dsolve([f(x).diff(x) - f(x) + g(x), g(x).diff(x) - g(x) - f(x)],
+        [f(x), g(x)], ics={f(0): 1, g(0): 0}) == [Eq(f(x), exp(x)*cos(x)), Eq(g(x), exp(x)*sin(x))]
+
+    # Test cases where dsolve returns two solutions.
+    eq = (x**2*f(x)**2 - x).diff(x)
+    assert dsolve(eq, f(x), ics={f(1): 0}) == [Eq(f(x),
+        -sqrt(x - 1)/x), Eq(f(x), sqrt(x - 1)/x)]
+    assert dsolve(eq, f(x), ics={f(x).diff(x).subs(x, 1): 0}) == [Eq(f(x),
+        -sqrt(x - S.Half)/x), Eq(f(x), sqrt(x - S.Half)/x)]
+
+    eq = cos(f(x)) - (x*sin(f(x)) - f(x)**2)*f(x).diff(x)
+    assert dsolve(eq, f(x),
+        ics={f(0):1}, hint='1st_exact', simplify=False) == Eq(x*cos(f(x)) + f(x)**3/3, Rational(1, 3))
+    assert dsolve(eq, f(x),
+        ics={f(0):1}, hint='1st_exact', simplify=True) == Eq(x*cos(f(x)) + f(x)**3/3, Rational(1, 3))
+
+    assert solve_ics([Eq(f(x), C1*exp(x))], [f(x)], [C1], {f(0): 1}) == {C1: 1}
+    assert solve_ics([Eq(f(x), C1*sin(x) + C2*cos(x))], [f(x)], [C1, C2],
+        {f(0): 1, f(pi/2): 1}) == {C1: 1, C2: 1}
+
+    assert solve_ics([Eq(f(x), C1*sin(x) + C2*cos(x))], [f(x)], [C1, C2],
+        {f(0): 1, f(x).diff(x).subs(x, 0): 1}) == {C1: 1, C2: 1}
+
+    assert solve_ics([Eq(f(x), C1*sin(x) + C2*cos(x))], [f(x)], [C1, C2], {f(0): 1}) == \
+        {C2: 1}
+
+    # Some more complicated tests Refer to PR #16098
+
+    assert set(dsolve(f(x).diff(x)*(f(x).diff(x, 2)-x), ics={f(0):0, f(x).diff(x).subs(x, 1):0})) == \
+        {Eq(f(x), 0), Eq(f(x), x ** 3 / 6 - x / 2)}
+    assert set(dsolve(f(x).diff(x)*(f(x).diff(x, 2)-x), ics={f(0):0})) == \
+        {Eq(f(x), 0), Eq(f(x), C2*x + x**3/6)}
+
+    K, r, f0 = symbols('K r f0')
+    sol = Eq(f(x), K*f0*exp(r*x)/((-K + f0)*(f0*exp(r*x)/(-K + f0) - 1)))
+    assert (dsolve(Eq(f(x).diff(x), r * f(x) * (1 - f(x) / K)), f(x), ics={f(0): f0})) == sol
+
+
+    #Order dependent issues Refer to PR #16098
+    assert set(dsolve(f(x).diff(x)*(f(x).diff(x, 2)-x), ics={f(x).diff(x).subs(x,0):0, f(0):0})) == \
+        {Eq(f(x), 0), Eq(f(x), x ** 3 / 6)}
+    assert set(dsolve(f(x).diff(x)*(f(x).diff(x, 2)-x), ics={f(0):0, f(x).diff(x).subs(x,0):0})) == \
+        {Eq(f(x), 0), Eq(f(x), x ** 3 / 6)}
+
+    # XXX: Ought to be ValueError
+    raises(ValueError, lambda: solve_ics([Eq(f(x), C1*sin(x) + C2*cos(x))], [f(x)], [C1, C2], {f(0): 1, f(pi): 1}))
+
+    # Degenerate case. f'(0) is identically 0.
+    raises(ValueError, lambda: solve_ics([Eq(f(x), sqrt(C1 - x**2))], [f(x)], [C1], {f(x).diff(x).subs(x, 0): 0}))
+
+    EI, q, L = symbols('EI q L')
+
+    # eq = Eq(EI*diff(f(x), x, 4), q)
+    sols = [Eq(f(x), C1 + C2*x + C3*x**2 + C4*x**3 + q*x**4/(24*EI))]
+    funcs = [f(x)]
+    constants = [C1, C2, C3, C4]
+    # Test both cases, Derivative (the default from f(x).diff(x).subs(x, L)),
+    # and Subs
+    ics1 = {f(0): 0,
+        f(x).diff(x).subs(x, 0): 0,
+        f(L).diff(L, 2): 0,
+        f(L).diff(L, 3): 0}
+    ics2 = {f(0): 0,
+        f(x).diff(x).subs(x, 0): 0,
+        Subs(f(x).diff(x, 2), x, L): 0,
+        Subs(f(x).diff(x, 3), x, L): 0}
+
+    solved_constants1 = solve_ics(sols, funcs, constants, ics1)
+    solved_constants2 = solve_ics(sols, funcs, constants, ics2)
+    assert solved_constants1 == solved_constants2 == {
+        C1: 0,
+        C2: 0,
+        C3: L**2*q/(4*EI),
+        C4: -L*q/(6*EI)}
+
+    # Allow the ics to refer to f
+    ics = {f(0): f(0)}
+    assert dsolve(f(x).diff(x) - f(x), f(x), ics=ics) == Eq(f(x), f(0)*exp(x))
+
+    ics = {f(x).diff(x).subs(x, 0): f(x).diff(x).subs(x, 0), f(0): f(0)}
+    assert dsolve(f(x).diff(x, x) + f(x), f(x), ics=ics) == \
+        Eq(f(x), f(0)*cos(x) + f(x).diff(x).subs(x, 0)*sin(x))
+
+def test_ode_order():
+    f = Function('f')
+    g = Function('g')
+    x = Symbol('x')
+    assert ode_order(3*x*exp(f(x)), f(x)) == 0
+    assert ode_order(x*diff(f(x), x) + 3*x*f(x) - sin(x)/x, f(x)) == 1
+    assert ode_order(x**2*f(x).diff(x, x) + x*diff(f(x), x) - f(x), f(x)) == 2
+    assert ode_order(diff(x*exp(f(x)), x, x), f(x)) == 2
+    assert ode_order(diff(x*diff(x*exp(f(x)), x, x), x), f(x)) == 3
+    assert ode_order(diff(f(x), x, x), g(x)) == 0
+    assert ode_order(diff(f(x), x, x)*diff(g(x), x), f(x)) == 2
+    assert ode_order(diff(f(x), x, x)*diff(g(x), x), g(x)) == 1
+    assert ode_order(diff(x*diff(x*exp(f(x)), x, x), x), g(x)) == 0
+    # issue 5835: ode_order has to also work for unevaluated derivatives
+    # (ie, without using doit()).
+    assert ode_order(Derivative(x*f(x), x), f(x)) == 1
+    assert ode_order(x*sin(Derivative(x*f(x)**2, x, x)), f(x)) == 2
+    assert ode_order(Derivative(x*Derivative(x*exp(f(x)), x, x), x), g(x)) == 0
+    assert ode_order(Derivative(f(x), x, x), g(x)) == 0
+    assert ode_order(Derivative(x*exp(f(x)), x, x), f(x)) == 2
+    assert ode_order(Derivative(f(x), x, x)*Derivative(g(x), x), g(x)) == 1
+    assert ode_order(Derivative(x*Derivative(f(x), x, x), x), f(x)) == 3
+    assert ode_order(
+        x*sin(Derivative(x*Derivative(f(x), x)**2, x, x)), f(x)) == 3
+
+
+def test_homogeneous_order():
+    assert homogeneous_order(exp(y/x) + tan(y/x), x, y) == 0
+    assert homogeneous_order(x**2 + sin(x)*cos(y), x, y) is None
+    assert homogeneous_order(x - y - x*sin(y/x), x, y) == 1
+    assert homogeneous_order((x*y + sqrt(x**4 + y**4) + x**2*(log(x) - log(y)))/
+        (pi*x**Rational(2, 3)*sqrt(y)**3), x, y) == Rational(-1, 6)
+    assert homogeneous_order(y/x*cos(y/x) - x/y*sin(y/x) + cos(y/x), x, y) == 0
+    assert homogeneous_order(f(x), x, f(x)) == 1
+    assert homogeneous_order(f(x)**2, x, f(x)) == 2
+    assert homogeneous_order(x*y*z, x, y) == 2
+    assert homogeneous_order(x*y*z, x, y, z) == 3
+    assert homogeneous_order(x**2*f(x)/sqrt(x**2 + f(x)**2), f(x)) is None
+    assert homogeneous_order(f(x, y)**2, x, f(x, y), y) == 2
+    assert homogeneous_order(f(x, y)**2, x, f(x), y) is None
+    assert homogeneous_order(f(x, y)**2, x, f(x, y)) is None
+    assert homogeneous_order(f(y, x)**2, x, y, f(x, y)) is None
+    assert homogeneous_order(f(y), f(x), x) is None
+    assert homogeneous_order(-f(x)/x + 1/sin(f(x)/ x), f(x), x) == 0
+    assert homogeneous_order(log(1/y) + log(x**2), x, y) is None
+    assert homogeneous_order(log(1/y) + log(x), x, y) == 0
+    assert homogeneous_order(log(x/y), x, y) == 0
+    assert homogeneous_order(2*log(1/y) + 2*log(x), x, y) == 0
+    a = Symbol('a')
+    assert homogeneous_order(a*log(1/y) + a*log(x), x, y) == 0
+    assert homogeneous_order(f(x).diff(x), x, y) is None
+    assert homogeneous_order(-f(x).diff(x) + x, x, y) is None
+    assert homogeneous_order(O(x), x, y) is None
+    assert homogeneous_order(x + O(x**2), x, y) is None
+    assert homogeneous_order(x**pi, x) == pi
+    assert homogeneous_order(x**x, x) is None
+    raises(ValueError, lambda: homogeneous_order(x*y))
+
+
+@XFAIL
+def test_noncircularized_real_imaginary_parts():
+    # If this passes, lines numbered 3878-3882 (at the time of this commit)
+    # of sympy/solvers/ode.py for nth_linear_constant_coeff_homogeneous
+    # should be removed.
+    y = sqrt(1+x)
+    i, r = im(y), re(y)
+    assert not (i.has(atan2) and r.has(atan2))
+
+
+def test_collect_respecting_exponentials():
+    # If this test passes, lines 1306-1311 (at the time of this commit)
+    # of sympy/solvers/ode.py should be removed.
+    sol = 1 + exp(x/2)
+    assert sol == collect( sol, exp(x/3))
+
+
+def test_undetermined_coefficients_match():
+    assert _undetermined_coefficients_match(g(x), x) == {'test': False}
+    assert _undetermined_coefficients_match(sin(2*x + sqrt(5)), x) == \
+        {'test': True, 'trialset':
+            {cos(2*x + sqrt(5)), sin(2*x + sqrt(5))}}
+    assert _undetermined_coefficients_match(sin(x)*cos(x), x) == \
+        {'test': False}
+    s = {cos(x), x*cos(x), x**2*cos(x), x**2*sin(x), x*sin(x), sin(x)}
+    assert _undetermined_coefficients_match(sin(x)*(x**2 + x + 1), x) == \
+        {'test': True, 'trialset': s}
+    assert _undetermined_coefficients_match(
+        sin(x)*x**2 + sin(x)*x + sin(x), x) == {'test': True, 'trialset': s}
+    assert _undetermined_coefficients_match(
+        exp(2*x)*sin(x)*(x**2 + x + 1), x
+    ) == {
+        'test': True, 'trialset': {exp(2*x)*sin(x), x**2*exp(2*x)*sin(x),
+        cos(x)*exp(2*x), x**2*cos(x)*exp(2*x), x*cos(x)*exp(2*x),
+        x*exp(2*x)*sin(x)}}
+    assert _undetermined_coefficients_match(1/sin(x), x) == {'test': False}
+    assert _undetermined_coefficients_match(log(x), x) == {'test': False}
+    assert _undetermined_coefficients_match(2**(x)*(x**2 + x + 1), x) == \
+        {'test': True, 'trialset': {2**x, x*2**x, x**2*2**x}}
+    assert _undetermined_coefficients_match(x**y, x) == {'test': False}
+    assert _undetermined_coefficients_match(exp(x)*exp(2*x + 1), x) == \
+        {'test': True, 'trialset': {exp(1 + 3*x)}}
+    assert _undetermined_coefficients_match(sin(x)*(x**2 + x + 1), x) == \
+        {'test': True, 'trialset': {x*cos(x), x*sin(x), x**2*cos(x),
+        x**2*sin(x), cos(x), sin(x)}}
+    assert _undetermined_coefficients_match(sin(x)*(x + sin(x)), x) == \
+        {'test': False}
+    assert _undetermined_coefficients_match(sin(x)*(x + sin(2*x)), x) == \
+        {'test': False}
+    assert _undetermined_coefficients_match(sin(x)*tan(x), x) == \
+        {'test': False}
+    assert _undetermined_coefficients_match(
+        x**2*sin(x)*exp(x) + x*sin(x) + x, x
+    ) == {
+        'test': True, 'trialset': {x**2*cos(x)*exp(x), x, cos(x), S.One,
+        exp(x)*sin(x), sin(x), x*exp(x)*sin(x), x*cos(x), x*cos(x)*exp(x),
+        x*sin(x), cos(x)*exp(x), x**2*exp(x)*sin(x)}}
+    assert _undetermined_coefficients_match(4*x*sin(x - 2), x) == {
+        'trialset': {x*cos(x - 2), x*sin(x - 2), cos(x - 2), sin(x - 2)},
+        'test': True,
+    }
+    assert _undetermined_coefficients_match(2**x*x, x) == \
+        {'test': True, 'trialset': {2**x, x*2**x}}
+    assert _undetermined_coefficients_match(2**x*exp(2*x), x) == \
+        {'test': True, 'trialset': {2**x*exp(2*x)}}
+    assert _undetermined_coefficients_match(exp(-x)/x, x) == \
+        {'test': False}
+    # Below are from Ordinary Differential Equations,
+    #                Tenenbaum and Pollard, pg. 231
+    assert _undetermined_coefficients_match(S(4), x) == \
+        {'test': True, 'trialset': {S.One}}
+    assert _undetermined_coefficients_match(12*exp(x), x) == \
+        {'test': True, 'trialset': {exp(x)}}
+    assert _undetermined_coefficients_match(exp(I*x), x) == \
+        {'test': True, 'trialset': {exp(I*x)}}
+    assert _undetermined_coefficients_match(sin(x), x) == \
+        {'test': True, 'trialset': {cos(x), sin(x)}}
+    assert _undetermined_coefficients_match(cos(x), x) == \
+        {'test': True, 'trialset': {cos(x), sin(x)}}
+    assert _undetermined_coefficients_match(8 + 6*exp(x) + 2*sin(x), x) == \
+        {'test': True, 'trialset': {S.One, cos(x), sin(x), exp(x)}}
+    assert _undetermined_coefficients_match(x**2, x) == \
+        {'test': True, 'trialset': {S.One, x, x**2}}
+    assert _undetermined_coefficients_match(9*x*exp(x) + exp(-x), x) == \
+        {'test': True, 'trialset': {x*exp(x), exp(x), exp(-x)}}
+    assert _undetermined_coefficients_match(2*exp(2*x)*sin(x), x) == \
+        {'test': True, 'trialset': {exp(2*x)*sin(x), cos(x)*exp(2*x)}}
+    assert _undetermined_coefficients_match(x - sin(x), x) == \
+        {'test': True, 'trialset': {S.One, x, cos(x), sin(x)}}
+    assert _undetermined_coefficients_match(x**2 + 2*x, x) == \
+        {'test': True, 'trialset': {S.One, x, x**2}}
+    assert _undetermined_coefficients_match(4*x*sin(x), x) == \
+        {'test': True, 'trialset': {x*cos(x), x*sin(x), cos(x), sin(x)}}
+    assert _undetermined_coefficients_match(x*sin(2*x), x) == \
+        {'test': True, 'trialset':
+            {x*cos(2*x), x*sin(2*x), cos(2*x), sin(2*x)}}
+    assert _undetermined_coefficients_match(x**2*exp(-x), x) == \
+        {'test': True, 'trialset': {x*exp(-x), x**2*exp(-x), exp(-x)}}
+    assert _undetermined_coefficients_match(2*exp(-x) - x**2*exp(-x), x) == \
+        {'test': True, 'trialset': {x*exp(-x), x**2*exp(-x), exp(-x)}}
+    assert _undetermined_coefficients_match(exp(-2*x) + x**2, x) == \
+        {'test': True, 'trialset': {S.One, x, x**2, exp(-2*x)}}
+    assert _undetermined_coefficients_match(x*exp(-x), x) == \
+        {'test': True, 'trialset': {x*exp(-x), exp(-x)}}
+    assert _undetermined_coefficients_match(x + exp(2*x), x) == \
+        {'test': True, 'trialset': {S.One, x, exp(2*x)}}
+    assert _undetermined_coefficients_match(sin(x) + exp(-x), x) == \
+        {'test': True, 'trialset': {cos(x), sin(x), exp(-x)}}
+    assert _undetermined_coefficients_match(exp(x), x) == \
+        {'test': True, 'trialset': {exp(x)}}
+    # converted from sin(x)**2
+    assert _undetermined_coefficients_match(S.Half - cos(2*x)/2, x) == \
+        {'test': True, 'trialset': {S.One, cos(2*x), sin(2*x)}}
+    # converted from exp(2*x)*sin(x)**2
+    assert _undetermined_coefficients_match(
+        exp(2*x)*(S.Half + cos(2*x)/2), x
+    ) == {
+        'test': True, 'trialset': {exp(2*x)*sin(2*x), cos(2*x)*exp(2*x),
+        exp(2*x)}}
+    assert _undetermined_coefficients_match(2*x + sin(x) + cos(x), x) == \
+        {'test': True, 'trialset': {S.One, x, cos(x), sin(x)}}
+    # converted from sin(2*x)*sin(x)
+    assert _undetermined_coefficients_match(cos(x)/2 - cos(3*x)/2, x) == \
+        {'test': True, 'trialset': {cos(x), cos(3*x), sin(x), sin(3*x)}}
+    assert _undetermined_coefficients_match(cos(x**2), x) == {'test': False}
+    assert _undetermined_coefficients_match(2**(x**2), x) == {'test': False}
+
+
+def test_issue_4785_22462():
+    from sympy.abc import A
+    eq = x + A*(x + diff(f(x), x) + f(x)) + diff(f(x), x) + f(x) + 2
+    assert classify_ode(eq, f(x)) == ('factorable', '1st_exact', '1st_linear',
+        'Bernoulli', 'almost_linear', '1st_power_series', 'lie_group',
+        'nth_linear_constant_coeff_undetermined_coefficients',
+        'nth_linear_constant_coeff_variation_of_parameters',
+        '1st_exact_Integral', '1st_linear_Integral', 'Bernoulli_Integral',
+        'almost_linear_Integral',
+        'nth_linear_constant_coeff_variation_of_parameters_Integral')
+    # issue 4864
+    eq = (x**2 + f(x)**2)*f(x).diff(x) - 2*x*f(x)
+    assert classify_ode(eq, f(x)) == ('factorable', '1st_exact',
+        '1st_homogeneous_coeff_best',
+        '1st_homogeneous_coeff_subs_indep_div_dep',
+        '1st_homogeneous_coeff_subs_dep_div_indep',
+        '1st_power_series',
+        'lie_group', '1st_exact_Integral',
+        '1st_homogeneous_coeff_subs_indep_div_dep_Integral',
+        '1st_homogeneous_coeff_subs_dep_div_indep_Integral')
+
+
+def test_issue_4825():
+    raises(ValueError, lambda: dsolve(f(x, y).diff(x) - y*f(x, y), f(x)))
+    assert classify_ode(f(x, y).diff(x) - y*f(x, y), f(x), dict=True) == \
+        {'order': 0, 'default': None, 'ordered_hints': ()}
+    # See also issue 3793, test Z13.
+    raises(ValueError, lambda: dsolve(f(x).diff(x), f(y)))
+    assert classify_ode(f(x).diff(x), f(y), dict=True) == \
+        {'order': 0, 'default': None, 'ordered_hints': ()}
+
+
+def test_constant_renumber_order_issue_5308():
+    from sympy.utilities.iterables import variations
+
+    assert constant_renumber(C1*x + C2*y) == \
+        constant_renumber(C1*y + C2*x) == \
+        C1*x + C2*y
+    e = C1*(C2 + x)*(C3 + y)
+    for a, b, c in variations([C1, C2, C3], 3):
+        assert constant_renumber(a*(b + x)*(c + y)) == e
+
+
+def test_constant_renumber():
+    e1, e2, x, y = symbols("e1:3 x y")
+    exprs = [e2*x, e1*x + e2*y]
+
+    assert constant_renumber(exprs[0]) == e2*x
+    assert constant_renumber(exprs[0], variables=[x]) == C1*x
+    assert constant_renumber(exprs[0], variables=[x], newconstants=[C2]) == C2*x
+    assert constant_renumber(exprs, variables=[x, y]) == [C1*x, C1*y + C2*x]
+    assert constant_renumber(exprs, variables=[x, y], newconstants=symbols("C3:5")) == [C3*x, C3*y + C4*x]
+
+
+def test_issue_5770():
+    k = Symbol("k", real=True)
+    t = Symbol('t')
+    w = Function('w')
+    sol = dsolve(w(t).diff(t, 6) - k**6*w(t), w(t))
+    assert len([s for s in sol.free_symbols if s.name.startswith('C')]) == 6
+    assert constantsimp((C1*cos(x) + C2*cos(x))*exp(x), {C1, C2}) == \
+        C1*cos(x)*exp(x)
+    assert constantsimp(C1*cos(x) + C2*cos(x) + C3*sin(x), {C1, C2, C3}) == \
+        C1*cos(x) + C3*sin(x)
+    assert constantsimp(exp(C1 + x), {C1}) == C1*exp(x)
+    assert constantsimp(x + C1 + y, {C1, y}) == C1 + x
+    assert constantsimp(x + C1 + Integral(x, (x, 1, 2)), {C1}) == C1 + x
+
+
+def test_issue_5112_5430():
+    assert homogeneous_order(-log(x) + acosh(x), x) is None
+    assert homogeneous_order(y - log(x), x, y) is None
+
+
+def test_issue_5095():
+    f = Function('f')
+    raises(ValueError, lambda: dsolve(f(x).diff(x)**2, f(x), 'fdsjf'))
+
+
+def test_homogeneous_function():
+    f = Function('f')
+    eq1 = tan(x + f(x))
+    eq2 = sin((3*x)/(4*f(x)))
+    eq3 = cos(x*f(x)*Rational(3, 4))
+    eq4 = log((3*x + 4*f(x))/(5*f(x) + 7*x))
+    eq5 = exp((2*x**2)/(3*f(x)**2))
+    eq6 = log((3*x + 4*f(x))/(5*f(x) + 7*x) + exp((2*x**2)/(3*f(x)**2)))
+    eq7 = sin((3*x)/(5*f(x) + x**2))
+    assert homogeneous_order(eq1, x, f(x)) == None
+    assert homogeneous_order(eq2, x, f(x)) == 0
+    assert homogeneous_order(eq3, x, f(x)) == None
+    assert homogeneous_order(eq4, x, f(x)) == 0
+    assert homogeneous_order(eq5, x, f(x)) == 0
+    assert homogeneous_order(eq6, x, f(x)) == 0
+    assert homogeneous_order(eq7, x, f(x)) == None
+
+
+def test_linear_coeff_match():
+    n, d = z*(2*x + 3*f(x) + 5), z*(7*x + 9*f(x) + 11)
+    rat = n/d
+    eq1 = sin(rat) + cos(rat.expand())
+    obj1 = LinearCoefficients(eq1)
+    eq2 = rat
+    obj2 = LinearCoefficients(eq2)
+    eq3 = log(sin(rat))
+    obj3 = LinearCoefficients(eq3)
+    ans = (4, Rational(-13, 3))
+    assert obj1._linear_coeff_match(eq1, f(x)) == ans
+    assert obj2._linear_coeff_match(eq2, f(x)) == ans
+    assert obj3._linear_coeff_match(eq3, f(x)) == ans
+
+    # no c
+    eq4 = (3*x)/f(x)
+    obj4 = LinearCoefficients(eq4)
+    # not x and f(x)
+    eq5 = (3*x + 2)/x
+    obj5 = LinearCoefficients(eq5)
+    # denom will be zero
+    eq6 = (3*x + 2*f(x) + 1)/(3*x + 2*f(x) + 5)
+    obj6 = LinearCoefficients(eq6)
+    # not rational coefficient
+    eq7 = (3*x + 2*f(x) + sqrt(2))/(3*x + 2*f(x) + 5)
+    obj7 = LinearCoefficients(eq7)
+    assert obj4._linear_coeff_match(eq4, f(x)) is None
+    assert obj5._linear_coeff_match(eq5, f(x)) is None
+    assert obj6._linear_coeff_match(eq6, f(x)) is None
+    assert obj7._linear_coeff_match(eq7, f(x)) is None
+
+
+def test_constantsimp_take_problem():
+    c = exp(C1) + 2
+    assert len(Poly(constantsimp(exp(C1) + c + c*x, [C1])).gens) == 2
+
+
+def test_series():
+    C1 = Symbol("C1")
+    eq = f(x).diff(x) - f(x)
+    sol = Eq(f(x), C1 + C1*x + C1*x**2/2 + C1*x**3/6 + C1*x**4/24 +
+            C1*x**5/120 + O(x**6))
+    assert dsolve(eq, hint='1st_power_series') == sol
+    assert checkodesol(eq, sol, order=1)[0]
+
+    eq = f(x).diff(x) - x*f(x)
+    sol = Eq(f(x), C1*x**4/8 + C1*x**2/2 + C1 + O(x**6))
+    assert dsolve(eq, hint='1st_power_series') == sol
+    assert checkodesol(eq, sol, order=1)[0]
+
+    eq = f(x).diff(x) - sin(x*f(x))
+    sol = Eq(f(x), (x - 2)**2*(1+ sin(4))*cos(4) + (x - 2)*sin(4) + 2 + O(x**3))
+    assert dsolve(eq, hint='1st_power_series', ics={f(2): 2}, n=3) == sol
+    # FIXME: The solution here should be O((x-2)**3) so is incorrect
+    #assert checkodesol(eq, sol, order=1)[0]
+
+
+@slow
+def test_2nd_power_series_ordinary():
+    C1, C2 = symbols("C1 C2")
+
+    eq = f(x).diff(x, 2) - x*f(x)
+    assert classify_ode(eq) == ('2nd_linear_airy', '2nd_power_series_ordinary')
+    sol = Eq(f(x), C2*(x**3/6 + 1) + C1*x*(x**3/12 + 1) + O(x**6))
+    assert dsolve(eq, hint='2nd_power_series_ordinary') == sol
+    assert checkodesol(eq, sol) == (True, 0)
+
+    sol = Eq(f(x), C2*((x + 2)**4/6 + (x + 2)**3/6 - (x + 2)**2 + 1)
+        + C1*(x + (x + 2)**4/12 - (x + 2)**3/3 + S(2))
+        + O(x**6))
+    assert dsolve(eq, hint='2nd_power_series_ordinary', x0=-2) == sol
+    # FIXME: Solution should be O((x+2)**6)
+    # assert checkodesol(eq, sol) == (True, 0)
+
+    sol = Eq(f(x), C2*x + C1 + O(x**2))
+    assert dsolve(eq, hint='2nd_power_series_ordinary', n=2) == sol
+    assert checkodesol(eq, sol) == (True, 0)
+
+    eq = (1 + x**2)*(f(x).diff(x, 2)) + 2*x*(f(x).diff(x)) -2*f(x)
+    assert classify_ode(eq) == ('factorable', '2nd_hypergeometric', '2nd_hypergeometric_Integral',
+    '2nd_power_series_ordinary')
+
+    sol = Eq(f(x), C2*(-x**4/3 + x**2 + 1) + C1*x + O(x**6))
+    assert dsolve(eq, hint='2nd_power_series_ordinary') == sol
+    assert checkodesol(eq, sol) == (True, 0)
+
+    eq = f(x).diff(x, 2) + x*(f(x).diff(x)) + f(x)
+    assert classify_ode(eq) == ('factorable', '2nd_power_series_ordinary',)
+    sol = Eq(f(x), C2*(x**4/8 - x**2/2 + 1) + C1*x*(-x**2/3 + 1) + O(x**6))
+    assert dsolve(eq) == sol
+    # FIXME: checkodesol fails for this solution...
+    # assert checkodesol(eq, sol) == (True, 0)
+
+    eq = f(x).diff(x, 2) + f(x).diff(x) - x*f(x)
+    assert classify_ode(eq) == ('2nd_power_series_ordinary',)
+    sol = Eq(f(x), C2*(-x**4/24 + x**3/6 + 1)
+            + C1*x*(x**3/24 + x**2/6 - x/2 + 1) + O(x**6))
+    assert dsolve(eq) == sol
+    # FIXME: checkodesol fails for this solution...
+    # assert checkodesol(eq, sol) == (True, 0)
+
+    eq = f(x).diff(x, 2) + x*f(x)
+    assert classify_ode(eq) == ('2nd_linear_airy', '2nd_power_series_ordinary')
+    sol = Eq(f(x), C2*(x**6/180 - x**3/6 + 1) + C1*x*(-x**3/12 + 1) + O(x**7))
+    assert dsolve(eq, hint='2nd_power_series_ordinary', n=7) == sol
+    assert checkodesol(eq, sol) == (True, 0)
+
+
+def test_2nd_power_series_regular():
+    C1, C2, a = symbols("C1 C2 a")
+    eq = x**2*(f(x).diff(x, 2)) - 3*x*(f(x).diff(x)) + (4*x + 4)*f(x)
+    sol = Eq(f(x), C1*x**2*(-16*x**3/9 + 4*x**2 - 4*x + 1) + O(x**6))
+    assert dsolve(eq, hint='2nd_power_series_regular') == sol
+    assert checkodesol(eq, sol) == (True, 0)
+
+    eq = 4*x**2*(f(x).diff(x, 2)) -8*x**2*(f(x).diff(x)) + (4*x**2 +
+        1)*f(x)
+    sol = Eq(f(x), C1*sqrt(x)*(x**4/24 + x**3/6 + x**2/2 + x + 1) + O(x**6))
+    assert dsolve(eq, hint='2nd_power_series_regular') == sol
+    assert checkodesol(eq, sol) == (True, 0)
+
+    eq = x**2*(f(x).diff(x, 2)) - x**2*(f(x).diff(x)) + (
+        x**2 - 2)*f(x)
+    sol = Eq(f(x), C1*(-x**6/720 - 3*x**5/80 - x**4/8 + x**2/2 + x/2 + 1)/x +
+            C2*x**2*(-x**3/60 + x**2/20 + x/2 + 1) + O(x**6))
+    assert dsolve(eq) == sol
+    assert checkodesol(eq, sol) == (True, 0)
+
+    eq = x**2*(f(x).diff(x, 2)) + x*(f(x).diff(x)) + (x**2 - Rational(1, 4))*f(x)
+    sol = Eq(f(x), C1*(x**4/24 - x**2/2 + 1)/sqrt(x) +
+        C2*sqrt(x)*(x**4/120 - x**2/6 + 1) + O(x**6))
+    assert dsolve(eq, hint='2nd_power_series_regular') == sol
+    assert checkodesol(eq, sol) == (True, 0)
+
+    eq = x*f(x).diff(x, 2) + f(x).diff(x) - a*x*f(x)
+    sol = Eq(f(x), C1*(a**2*x**4/64 + a*x**2/4 + 1) + O(x**6))
+    assert dsolve(eq, f(x), hint="2nd_power_series_regular") == sol
+    assert checkodesol(eq, sol) == (True, 0)
+
+    eq = f(x).diff(x, 2) + ((1 - x)/x)*f(x).diff(x) + (a/x)*f(x)
+    sol = Eq(f(x), C1*(-a*x**5*(a - 4)*(a - 3)*(a - 2)*(a - 1)/14400 + \
+        a*x**4*(a - 3)*(a - 2)*(a - 1)/576 - a*x**3*(a - 2)*(a - 1)/36 + \
+        a*x**2*(a - 1)/4 - a*x + 1) + O(x**6))
+    assert dsolve(eq, f(x), hint="2nd_power_series_regular") == sol
+    assert checkodesol(eq, sol) == (True, 0)
+
+
+def test_issue_15056():
+    t = Symbol('t')
+    C3 = Symbol('C3')
+    assert get_numbered_constants(Symbol('C1') * Function('C2')(t)) == C3
+
+
+def test_issue_15913():
+    eq = -C1/x - 2*x*f(x) - f(x) + Derivative(f(x), x)
+    sol = C2*exp(x**2 + x) + exp(x**2 + x)*Integral(C1*exp(-x**2 - x)/x, x)
+    assert checkodesol(eq, sol) == (True, 0)
+    sol = C1 + C2*exp(-x*y)
+    eq = Derivative(y*f(x), x) + f(x).diff(x, 2)
+    assert checkodesol(eq, sol, f(x)) == (True, 0)
+
+
+def test_issue_16146():
+    raises(ValueError, lambda: dsolve([f(x).diff(x), g(x).diff(x)], [f(x), g(x), h(x)]))
+    raises(ValueError, lambda: dsolve([f(x).diff(x), g(x).diff(x)], [f(x)]))
+
+
+def test_dsolve_remove_redundant_solutions():
+
+    eq = (f(x)-2)*f(x).diff(x)
+    sol = Eq(f(x), C1)
+    assert dsolve(eq) == sol
+
+    eq = (f(x)-sin(x))*(f(x).diff(x, 2))
+    sol = {Eq(f(x), C1 + C2*x), Eq(f(x), sin(x))}
+    assert set(dsolve(eq)) == sol
+
+    eq = (f(x)**2-2*f(x)+1)*f(x).diff(x, 3)
+    sol = Eq(f(x), C1 + C2*x + C3*x**2)
+    assert dsolve(eq) == sol
+
+
+def test_issue_13060():
+    A, B = symbols("A B", cls=Function)
+    t = Symbol("t")
+    eq = [Eq(Derivative(A(t), t), A(t)*B(t)), Eq(Derivative(B(t), t), A(t)*B(t))]
+    sol = dsolve(eq)
+    assert checkodesol(eq, sol) == (True, [0, 0])
+
+
+def test_issue_22523():
+    N, s = symbols('N s')
+    rho = Function('rho')
+    # intentionally use 4.0 to confirm issue with nfloat
+    # works here
+    eqn = 4.0*N*sqrt(N - 1)*rho(s) + (4*s**2*(N - 1) + (N - 2*s*(N - 1))**2
+        )*Derivative(rho(s), (s, 2))
+    match = classify_ode(eqn, dict=True, hint='all')
+    assert match['2nd_power_series_ordinary']['terms'] == 5
+    C1, C2 = symbols('C1,C2')
+    sol = dsolve(eqn, hint='2nd_power_series_ordinary')
+    # there is no r(2.0) in this result
+    assert filldedent(sol) == filldedent(str('''
+        Eq(rho(s), C2*(1 - 4.0*s**4*sqrt(N - 1.0)/N + 0.666666666666667*s**4/N
+        - 2.66666666666667*s**3*sqrt(N - 1.0)/N - 2.0*s**2*sqrt(N - 1.0)/N +
+        9.33333333333333*s**4*sqrt(N - 1.0)/N**2 - 0.666666666666667*s**4/N**2
+        + 2.66666666666667*s**3*sqrt(N - 1.0)/N**2 -
+        5.33333333333333*s**4*sqrt(N - 1.0)/N**3) + C1*s*(1.0 -
+        1.33333333333333*s**3*sqrt(N - 1.0)/N - 0.666666666666667*s**2*sqrt(N
+        - 1.0)/N + 1.33333333333333*s**3*sqrt(N - 1.0)/N**2) + O(s**6))'''))
+
+
+def test_issue_22604():
+    x1, x2 = symbols('x1, x2', cls = Function)
+    t, k1, k2, m1, m2 = symbols('t k1 k2 m1 m2', real = True)
+    k1, k2, m1, m2 = 1, 1, 1, 1
+    eq1 = Eq(m1*diff(x1(t), t, 2) + k1*x1(t) - k2*(x2(t) - x1(t)), 0)
+    eq2 = Eq(m2*diff(x2(t), t, 2) + k2*(x2(t) - x1(t)), 0)
+    eqs = [eq1, eq2]
+    [x1sol, x2sol] = dsolve(eqs, [x1(t), x2(t)], ics = {x1(0):0, x1(t).diff().subs(t,0):0, \
+                                                        x2(0):1, x2(t).diff().subs(t,0):0})
+    assert x1sol == Eq(x1(t), sqrt(3 - sqrt(5))*(sqrt(10) + 5*sqrt(2))*cos(sqrt(2)*t*sqrt(3 - sqrt(5))/2)/20 + \
+                       (-5*sqrt(2) + sqrt(10))*sqrt(sqrt(5) + 3)*cos(sqrt(2)*t*sqrt(sqrt(5) + 3)/2)/20)
+    assert x2sol == Eq(x2(t), (sqrt(5) + 5)*cos(sqrt(2)*t*sqrt(3 - sqrt(5))/2)/10 + (5 - sqrt(5))*cos(sqrt(2)*t*sqrt(sqrt(5) + 3)/2)/10)
+
+
+def test_issue_22462():
+    for de in [
+            Eq(f(x).diff(x), -20*f(x)**2 - 500*f(x)/7200),
+            Eq(f(x).diff(x), -2*f(x)**2 - 5*f(x)/7)]:
+        assert 'Bernoulli' in classify_ode(de, f(x))
+
+
+def test_issue_23425():
+    x = symbols('x')
+    y = Function('y')
+    eq = Eq(-E**x*y(x).diff().diff() + y(x).diff(), 0)
+    assert classify_ode(eq) == \
+        ('Liouville', 'nth_order_reducible', \
+        '2nd_power_series_ordinary', 'Liouville_Integral')
+
+
+@SKIP("too slow for @slow")
+def test_issue_25820():
+    x = Symbol('x')
+    y = Function('y')
+    eq = y(x)**3*y(x).diff(x, 2) + 49
+    assert dsolve(eq, y(x)) is not None  # doesn't raise
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/ode/tests/test_riccati.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/ode/tests/test_riccati.py
new file mode 100644
index 0000000000000000000000000000000000000000..548a1ee5b5e82d88f1b0aa319af09b8b9d1d9bfe
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/ode/tests/test_riccati.py
@@ -0,0 +1,877 @@
+from sympy.core.random import randint
+from sympy.core.function import Function
+from sympy.core.mul import Mul
+from sympy.core.numbers import (I, Rational, oo)
+from sympy.core.relational import Eq
+from sympy.core.singleton import S
+from sympy.core.symbol import (Dummy, symbols)
+from sympy.functions.elementary.exponential import (exp, log)
+from sympy.functions.elementary.hyperbolic import tanh
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import sin
+from sympy.polys.polytools import Poly
+from sympy.simplify.ratsimp import ratsimp
+from sympy.solvers.ode.subscheck import checkodesol
+from sympy.testing.pytest import slow
+from sympy.solvers.ode.riccati import (riccati_normal, riccati_inverse_normal,
+    riccati_reduced, match_riccati, inverse_transform_poly, limit_at_inf,
+    check_necessary_conds, val_at_inf, construct_c_case_1,
+    construct_c_case_2, construct_c_case_3, construct_d_case_4,
+    construct_d_case_5, construct_d_case_6, rational_laurent_series,
+    solve_riccati)
+
+f = Function('f')
+x = symbols('x')
+
+# These are the functions used to generate the tests
+# SHOULD NOT BE USED DIRECTLY IN TESTS
+
+def rand_rational(maxint):
+    return Rational(randint(-maxint, maxint), randint(1, maxint))
+
+
+def rand_poly(x, degree, maxint):
+    return Poly([rand_rational(maxint) for _ in range(degree+1)], x)
+
+
+def rand_rational_function(x, degree, maxint):
+    degnum = randint(1, degree)
+    degden = randint(1, degree)
+    num = rand_poly(x, degnum, maxint)
+    den = rand_poly(x, degden, maxint)
+    while den == Poly(0, x):
+        den = rand_poly(x, degden, maxint)
+    return num / den
+
+
+def find_riccati_ode(ratfunc, x, yf):
+    y = ratfunc
+    yp = y.diff(x)
+    q1 = rand_rational_function(x, 1, 3)
+    q2 = rand_rational_function(x, 1, 3)
+    while q2 == 0:
+        q2 = rand_rational_function(x, 1, 3)
+    q0 = ratsimp(yp - q1*y - q2*y**2)
+    eq = Eq(yf.diff(), q0 + q1*yf + q2*yf**2)
+    sol = Eq(yf, y)
+    assert checkodesol(eq, sol) == (True, 0)
+    return eq, q0, q1, q2
+
+
+# Testing functions start
+
+def test_riccati_transformation():
+    """
+    This function tests the transformation of the
+    solution of a Riccati ODE to the solution of
+    its corresponding normal Riccati ODE.
+
+    Each test case 4 values -
+
+    1. w - The solution to be transformed
+    2. b1 - The coefficient of f(x) in the ODE.
+    3. b2 - The coefficient of f(x)**2 in the ODE.
+    4. y - The solution to the normal Riccati ODE.
+    """
+    tests = [
+    (
+        x/(x - 1),
+        (x**2 + 7)/3*x,
+        x,
+        -x**2/(x - 1) - x*(x**2/3 + S(7)/3)/2 - 1/(2*x)
+    ),
+    (
+        (2*x + 3)/(2*x + 2),
+        (3 - 3*x)/(x + 1),
+        5*x,
+        -5*x*(2*x + 3)/(2*x + 2) - (3 - 3*x)/(Mul(2, x + 1, evaluate=False)) - 1/(2*x)
+    ),
+    (
+        -1/(2*x**2 - 1),
+        0,
+        (2 - x)/(4*x - 2),
+        (2 - x)/((4*x - 2)*(2*x**2 - 1)) - (4*x - 2)*(Mul(-4, 2 - x, evaluate=False)/(4*x - \
+        2)**2 - 1/(4*x - 2))/(Mul(2, 2 - x, evaluate=False))
+    ),
+    (
+        x,
+        (8*x - 12)/(12*x + 9),
+        x**3/(6*x - 9),
+        -x**4/(6*x - 9) - (8*x - 12)/(Mul(2, 12*x + 9, evaluate=False)) - (6*x - 9)*(-6*x**3/(6*x \
+        - 9)**2 + 3*x**2/(6*x - 9))/(2*x**3)
+    )]
+    for w, b1, b2, y in tests:
+        assert y == riccati_normal(w, x, b1, b2)
+        assert w == riccati_inverse_normal(y, x, b1, b2).cancel()
+
+    # Test bp parameter in riccati_inverse_normal
+    tests = [
+    (
+        (-2*x - 1)/(2*x**2 + 2*x - 2),
+        -2/x,
+        (-x - 1)/(4*x),
+        8*x**2*(1/(4*x) + (-x - 1)/(4*x**2))/(-x - 1)**2 + 4/(-x - 1),
+        -2*x*(-1/(4*x) - (-x - 1)/(4*x**2))/(-x - 1) - (-2*x - 1)*(-x - 1)/(4*x*(2*x**2 + 2*x \
+        - 2)) + 1/x
+    ),
+    (
+        3/(2*x**2),
+        -2/x,
+        (-x - 1)/(4*x),
+        8*x**2*(1/(4*x) + (-x - 1)/(4*x**2))/(-x - 1)**2 + 4/(-x - 1),
+        -2*x*(-1/(4*x) - (-x - 1)/(4*x**2))/(-x - 1) + 1/x - Mul(3, -x - 1, evaluate=False)/(8*x**3)
+    )]
+    for w, b1, b2, bp, y in tests:
+        assert y == riccati_normal(w, x, b1, b2)
+        assert w == riccati_inverse_normal(y, x, b1, b2, bp).cancel()
+
+
+def test_riccati_reduced():
+    """
+    This function tests the transformation of a
+    Riccati ODE to its normal Riccati ODE.
+
+    Each test case 2 values -
+
+    1. eq - A Riccati ODE.
+    2. normal_eq - The normal Riccati ODE of eq.
+    """
+    tests = [
+    (
+        f(x).diff(x) - x**2 - x*f(x) - x*f(x)**2,
+
+        f(x).diff(x) + f(x)**2 + x**3 - x**2/4 - 3/(4*x**2)
+    ),
+    (
+        6*x/(2*x + 9) + f(x).diff(x) - (x + 1)*f(x)**2/x,
+
+        -3*x**2*(1/x + (-x - 1)/x**2)**2/(4*(-x - 1)**2) + Mul(6, \
+        -x - 1, evaluate=False)/(2*x + 9) + f(x)**2 + f(x).diff(x) \
+        - (-1 + (x + 1)/x)/(x*(-x - 1))
+    ),
+    (
+        f(x)**2 + f(x).diff(x) - (x - 1)*f(x)/(-x - S(1)/2),
+
+        -(2*x - 2)**2/(4*(2*x + 1)**2) + (2*x - 2)/(2*x + 1)**2 + \
+        f(x)**2 + f(x).diff(x) - 1/(2*x + 1)
+    ),
+    (
+        f(x).diff(x) - f(x)**2/x,
+
+        f(x)**2 + f(x).diff(x) + 1/(4*x**2)
+    ),
+    (
+        -3*(-x**2 - x + 1)/(x**2 + 6*x + 1) + f(x).diff(x) + f(x)**2/x,
+
+        f(x)**2 + f(x).diff(x) + (3*x**2/(x**2 + 6*x + 1) + 3*x/(x**2 \
+        + 6*x + 1) - 3/(x**2 + 6*x + 1))/x + 1/(4*x**2)
+    ),
+    (
+        6*x/(2*x + 9) + f(x).diff(x) - (x + 1)*f(x)/x,
+
+        False
+    ),
+    (
+        f(x)*f(x).diff(x) - 1/x + f(x)/3 + f(x)**2/(x**2 - 2),
+
+        False
+    )]
+    for eq, normal_eq in tests:
+        assert normal_eq == riccati_reduced(eq, f, x)
+
+
+def test_match_riccati():
+    """
+    This function tests if an ODE is Riccati or not.
+
+    Each test case has 5 values -
+
+    1. eq - The Riccati ODE.
+    2. match - Boolean indicating if eq is a Riccati ODE.
+    3. b0 -
+    4. b1 - Coefficient of f(x) in eq.
+    5. b2 - Coefficient of f(x)**2 in eq.
+    """
+    tests = [
+    # Test Rational Riccati ODEs
+    (
+        f(x).diff(x) - (405*x**3 - 882*x**2 - 78*x + 92)/(243*x**4 \
+        - 945*x**3 + 846*x**2 + 180*x - 72) - 2 - f(x)**2/(3*x + 1) \
+        - (S(1)/3 - x)*f(x)/(S(1)/3 - 3*x/2),
+
+        True,
+
+        45*x**3/(27*x**4 - 105*x**3 + 94*x**2 + 20*x - 8) - 98*x**2/ \
+        (27*x**4 - 105*x**3 + 94*x**2 + 20*x - 8) - 26*x/(81*x**4 - \
+        315*x**3 + 282*x**2 + 60*x - 24) + 2 + 92/(243*x**4 - 945*x**3 \
+        + 846*x**2 + 180*x - 72),
+
+        Mul(-1, 2 - 6*x, evaluate=False)/(9*x - 2),
+
+        1/(3*x + 1)
+    ),
+    (
+        f(x).diff(x) + 4*x/27 - (x/3 - 1)*f(x)**2 - (2*x/3 + \
+        1)*f(x)/(3*x + 2) - S(10)/27 - (265*x**2 + 423*x + 162) \
+        /(324*x**3 + 216*x**2),
+
+        True,
+
+        -4*x/27 + S(10)/27 + 3/(6*x**3 + 4*x**2) + 47/(36*x**2 \
+        + 24*x) + 265/(324*x + 216),
+
+        Mul(-1, -2*x - 3, evaluate=False)/(9*x + 6),
+
+        x/3 - 1
+    ),
+    (
+        f(x).diff(x) - (304*x**5 - 745*x**4 + 631*x**3 - 876*x**2 \
+        + 198*x - 108)/(36*x**6 - 216*x**5 + 477*x**4 - 567*x**3 + \
+        360*x**2 - 108*x) - S(17)/9 - (x - S(3)/2)*f(x)/(x/2 - \
+        S(3)/2) - (x/3 - 3)*f(x)**2/(3*x),
+
+        True,
+
+        304*x**4/(36*x**5 - 216*x**4 + 477*x**3 - 567*x**2 + 360*x - \
+        108) - 745*x**3/(36*x**5 - 216*x**4 + 477*x**3 - 567*x**2 + \
+        360*x - 108) + 631*x**2/(36*x**5 - 216*x**4 + 477*x**3 - 567* \
+        x**2 + 360*x - 108) - 292*x/(12*x**5 - 72*x**4 + 159*x**3 - \
+        189*x**2 + 120*x - 36) + S(17)/9 - 12/(4*x**6 - 24*x**5 + \
+        53*x**4 - 63*x**3 + 40*x**2 - 12*x) + 22/(4*x**5 - 24*x**4 \
+        + 53*x**3 - 63*x**2 + 40*x - 12),
+
+        Mul(-1, 3 - 2*x, evaluate=False)/(x - 3),
+
+        Mul(-1, 9 - x, evaluate=False)/(9*x)
+    ),
+    # Test Non-Rational Riccati ODEs
+    (
+        f(x).diff(x) - x**(S(3)/2)/(x**(S(1)/2) - 2) + x**2*f(x) + \
+        x*f(x)**2/(x**(S(3)/4)),
+        False, 0, 0, 0
+    ),
+    (
+        f(x).diff(x) - sin(x**2) + exp(x)*f(x) + log(x)*f(x)**2,
+        False, 0, 0, 0
+    ),
+    (
+        f(x).diff(x) - tanh(x + sqrt(x)) + f(x) + x**4*f(x)**2,
+        False, 0, 0, 0
+    ),
+    # Test Non-Riccati ODEs
+    (
+        (1 - x**2)*f(x).diff(x, 2) - 2*x*f(x).diff(x) + 20*f(x),
+        False, 0, 0, 0
+    ),
+    (
+        f(x).diff(x) - x**2 + x**3*f(x) + (x**2/(x + 1))*f(x)**3,
+        False, 0, 0, 0
+    ),
+    (
+        f(x).diff(x)*f(x)**2 + (x**2 - 1)/(x**3 + 1)*f(x) + 1/(2*x \
+        + 3) + f(x)**2,
+        False, 0, 0, 0
+    )]
+    for eq, res, b0, b1, b2 in tests:
+        match, funcs = match_riccati(eq, f, x)
+        assert match == res
+        if res:
+            assert [b0, b1, b2] == funcs
+
+
+def test_val_at_inf():
+    """
+    This function tests the valuation of rational
+    function at oo.
+
+    Each test case has 3 values -
+
+    1. num - Numerator of rational function.
+    2. den - Denominator of rational function.
+    3. val_inf - Valuation of rational function at oo
+    """
+    tests = [
+    # degree(denom) > degree(numer)
+    (
+        Poly(10*x**3 + 8*x**2 - 13*x + 6, x),
+        Poly(-13*x**10 - x**9 + 5*x**8 + 7*x**7 + 10*x**6 + 6*x**5 - 7*x**4 + 11*x**3 - 8*x**2 + 5*x + 13, x),
+         7
+    ),
+    (
+        Poly(1, x),
+        Poly(-9*x**4 + 3*x**3 + 15*x**2 - 6*x - 14, x),
+         4
+    ),
+    # degree(denom) == degree(numer)
+    (
+        Poly(-6*x**3 - 8*x**2 + 8*x - 6, x),
+        Poly(-5*x**3 + 12*x**2 - 6*x - 9, x),
+         0
+    ),
+    # degree(denom) < degree(numer)
+    (
+        Poly(12*x**8 - 12*x**7 - 11*x**6 + 8*x**5 + 3*x**4 - x**3 + x**2 - 11*x, x),
+        Poly(-14*x**2 + x, x),
+         -6
+    ),
+    (
+        Poly(5*x**6 + 9*x**5 - 11*x**4 - 9*x**3 + x**2 - 4*x + 4, x),
+        Poly(15*x**4 + 3*x**3 - 8*x**2 + 15*x + 12, x),
+         -2
+    )]
+    for num, den, val in tests:
+        assert val_at_inf(num, den, x) == val
+
+
+def test_necessary_conds():
+    """
+    This function tests the necessary conditions for
+    a Riccati ODE to have a rational particular solution.
+    """
+    # Valuation at Infinity is an odd negative integer
+    assert check_necessary_conds(-3, [1, 2, 4]) == False
+    # Valuation at Infinity is a positive integer lesser than 2
+    assert check_necessary_conds(1, [1, 2, 4]) == False
+    # Multiplicity of a pole is an odd integer greater than 1
+    assert check_necessary_conds(2, [3, 1, 6]) == False
+    # All values are correct
+    assert check_necessary_conds(-10, [1, 2, 8, 12]) == True
+
+
+def test_inverse_transform_poly():
+    """
+    This function tests the substitution x -> 1/x
+    in rational functions represented using Poly.
+    """
+    fns = [
+    (15*x**3 - 8*x**2 - 2*x - 6)/(18*x + 6),
+
+    (180*x**5 + 40*x**4 + 80*x**3 + 30*x**2 - 60*x - 80)/(180*x**3 - 150*x**2 + 75*x + 12),
+
+    (-15*x**5 - 36*x**4 + 75*x**3 - 60*x**2 - 80*x - 60)/(80*x**4 + 60*x**3 + 60*x**2 + 60*x - 80),
+
+    (60*x**7 + 24*x**6 - 15*x**5 - 20*x**4 + 30*x**2 + 100*x - 60)/(240*x**2 - 20*x - 30),
+
+    (30*x**6 - 12*x**5 + 15*x**4 - 15*x**2 + 10*x + 60)/(3*x**10 - 45*x**9 + 15*x**5 + 15*x**4 - 5*x**3 \
+    + 15*x**2 + 45*x - 15)
+    ]
+    for f in fns:
+        num, den = [Poly(e, x) for e in f.as_numer_denom()]
+        num, den = inverse_transform_poly(num, den, x)
+        assert f.subs(x, 1/x).cancel() == num/den
+
+
+def test_limit_at_inf():
+    """
+    This function tests the limit at oo of a
+    rational function.
+
+    Each test case has 3 values -
+
+    1. num - Numerator of rational function.
+    2. den - Denominator of rational function.
+    3. limit_at_inf - Limit of rational function at oo
+    """
+    tests = [
+    # deg(denom) > deg(numer)
+    (
+        Poly(-12*x**2 + 20*x + 32, x),
+        Poly(32*x**3 + 72*x**2 + 3*x - 32, x),
+        0
+    ),
+    # deg(denom) < deg(numer)
+    (
+        Poly(1260*x**4 - 1260*x**3 - 700*x**2 - 1260*x + 1400, x),
+        Poly(6300*x**3 - 1575*x**2 + 756*x - 540, x),
+        oo
+    ),
+    # deg(denom) < deg(numer), one of the leading coefficients is negative
+    (
+        Poly(-735*x**8 - 1400*x**7 + 1680*x**6 - 315*x**5 - 600*x**4 + 840*x**3 - 525*x**2 \
+        + 630*x + 3780, x),
+        Poly(1008*x**7 - 2940*x**6 - 84*x**5 + 2940*x**4 - 420*x**3 + 1512*x**2 + 105*x + 168, x),
+        -oo
+    ),
+    # deg(denom) == deg(numer)
+    (
+        Poly(105*x**7 - 960*x**6 + 60*x**5 + 60*x**4 - 80*x**3 + 45*x**2 + 120*x + 15, x),
+        Poly(735*x**7 + 525*x**6 + 720*x**5 + 720*x**4 - 8400*x**3 - 2520*x**2 + 2800*x + 280, x),
+        S(1)/7
+    ),
+    (
+        Poly(288*x**4 - 450*x**3 + 280*x**2 - 900*x - 90, x),
+        Poly(607*x**4 + 840*x**3 - 1050*x**2 + 420*x + 420, x),
+        S(288)/607
+    )]
+    for num, den, lim in tests:
+        assert limit_at_inf(num, den, x) == lim
+
+
+def test_construct_c_case_1():
+    """
+    This function tests the Case 1 in the step
+    to calculate coefficients of c-vectors.
+
+    Each test case has 4 values -
+
+    1. num - Numerator of the rational function a(x).
+    2. den - Denominator of the rational function a(x).
+    3. pole - Pole of a(x) for which c-vector is being
+       calculated.
+    4. c - The c-vector for the pole.
+    """
+    tests = [
+    (
+        Poly(-3*x**3 + 3*x**2 + 4*x - 5, x, extension=True),
+        Poly(4*x**8 + 16*x**7 + 9*x**5 + 12*x**4 + 6*x**3 + 12*x**2, x, extension=True),
+        S(0),
+        [[S(1)/2 + sqrt(6)*I/6], [S(1)/2 - sqrt(6)*I/6]]
+    ),
+    (
+        Poly(1200*x**3 + 1440*x**2 + 816*x + 560, x, extension=True),
+        Poly(128*x**5 - 656*x**4 + 1264*x**3 - 1125*x**2 + 385*x + 49, x, extension=True),
+        S(7)/4,
+        [[S(1)/2 + sqrt(16367978)/634], [S(1)/2 - sqrt(16367978)/634]]
+    ),
+    (
+        Poly(4*x + 2, x, extension=True),
+        Poly(18*x**4 + (2 - 18*sqrt(3))*x**3 + (14 - 11*sqrt(3))*x**2 + (4 - 6*sqrt(3))*x \
+            + 8*sqrt(3) + 16, x, domain='QQ<sqrt(3)>'),
+        (S(1) + sqrt(3))/2,
+        [[S(1)/2 + sqrt(Mul(4, 2*sqrt(3) + 4, evaluate=False)/(19*sqrt(3) + 44) + 1)/2], \
+            [S(1)/2 - sqrt(Mul(4, 2*sqrt(3) + 4, evaluate=False)/(19*sqrt(3) + 44) + 1)/2]]
+    )]
+    for num, den, pole, c in tests:
+        assert construct_c_case_1(num, den, x, pole) == c
+
+
+def test_construct_c_case_2():
+    """
+    This function tests the Case 2 in the step
+    to calculate coefficients of c-vectors.
+
+    Each test case has 5 values -
+
+    1. num - Numerator of the rational function a(x).
+    2. den - Denominator of the rational function a(x).
+    3. pole - Pole of a(x) for which c-vector is being
+       calculated.
+    4. mul - The multiplicity of the pole.
+    5. c - The c-vector for the pole.
+    """
+    tests = [
+    # Testing poles with multiplicity 2
+    (
+        Poly(1, x, extension=True),
+        Poly((x - 1)**2*(x - 2), x, extension=True),
+        1, 2,
+        [[-I*(-1 - I)/2], [I*(-1 + I)/2]]
+    ),
+    (
+        Poly(3*x**5 - 12*x**4 - 7*x**3 + 1, x, extension=True),
+        Poly((3*x - 1)**2*(x + 2)**2, x, extension=True),
+        S(1)/3, 2,
+        [[-S(89)/98], [-S(9)/98]]
+    ),
+    # Testing poles with multiplicity 4
+    (
+        Poly(x**3 - x**2 + 4*x, x, extension=True),
+        Poly((x - 2)**4*(x + 5)**2, x, extension=True),
+        2, 4,
+        [[7*sqrt(3)*(S(60)/343 - 4*sqrt(3)/7)/12, 2*sqrt(3)/7], \
+        [-7*sqrt(3)*(S(60)/343 + 4*sqrt(3)/7)/12, -2*sqrt(3)/7]]
+    ),
+    (
+        Poly(3*x**5 + x**4 + 3, x, extension=True),
+        Poly((4*x + 1)**4*(x + 2), x, extension=True),
+        -S(1)/4, 4,
+        [[128*sqrt(439)*(-sqrt(439)/128 - S(55)/14336)/439, sqrt(439)/256], \
+        [-128*sqrt(439)*(sqrt(439)/128 - S(55)/14336)/439, -sqrt(439)/256]]
+    ),
+    # Testing poles with multiplicity 6
+    (
+        Poly(x**3 + 2, x, extension=True),
+        Poly((3*x - 1)**6*(x**2 + 1), x, extension=True),
+        S(1)/3, 6,
+        [[27*sqrt(66)*(-sqrt(66)/54 - S(131)/267300)/22, -2*sqrt(66)/1485, sqrt(66)/162], \
+        [-27*sqrt(66)*(sqrt(66)/54 - S(131)/267300)/22, 2*sqrt(66)/1485, -sqrt(66)/162]]
+    ),
+    (
+        Poly(x**2 + 12, x, extension=True),
+        Poly((x - sqrt(2))**6, x, extension=True),
+        sqrt(2), 6,
+        [[sqrt(14)*(S(6)/7 - 3*sqrt(14))/28, sqrt(7)/7, sqrt(14)], \
+        [-sqrt(14)*(S(6)/7 + 3*sqrt(14))/28, -sqrt(7)/7, -sqrt(14)]]
+    )]
+    for num, den, pole, mul, c in tests:
+        assert construct_c_case_2(num, den, x, pole, mul) == c
+
+
+def test_construct_c_case_3():
+    """
+    This function tests the Case 3 in the step
+    to calculate coefficients of c-vectors.
+    """
+    assert construct_c_case_3() == [[1]]
+
+
+def test_construct_d_case_4():
+    """
+    This function tests the Case 4 in the step
+    to calculate coefficients of the d-vector.
+
+    Each test case has 4 values -
+
+    1. num - Numerator of the rational function a(x).
+    2. den - Denominator of the rational function a(x).
+    3. mul - Multiplicity of oo as a pole.
+    4. d - The d-vector.
+    """
+    tests = [
+    # Tests with multiplicity at oo = 2
+    (
+        Poly(-x**5 - 2*x**4 + 4*x**3 + 2*x + 5, x, extension=True),
+        Poly(9*x**3 - 2*x**2 + 10*x - 2, x, extension=True),
+        2,
+        [[10*I/27, I/3, -3*I*(S(158)/243 - I/3)/2], \
+        [-10*I/27, -I/3, 3*I*(S(158)/243 + I/3)/2]]
+    ),
+    (
+        Poly(-x**6 + 9*x**5 + 5*x**4 + 6*x**3 + 5*x**2 + 6*x + 7, x, extension=True),
+        Poly(x**4 + 3*x**3 + 12*x**2 - x + 7, x, extension=True),
+        2,
+        [[-6*I, I, -I*(17 - I)/2], [6*I, -I, I*(17 + I)/2]]
+    ),
+    # Tests with multiplicity at oo = 4
+    (
+        Poly(-2*x**6 - x**5 - x**4 - 2*x**3 - x**2 - 3*x - 3, x, extension=True),
+        Poly(3*x**2 + 10*x + 7, x, extension=True),
+        4,
+        [[269*sqrt(6)*I/288, -17*sqrt(6)*I/36, sqrt(6)*I/3, -sqrt(6)*I*(S(16969)/2592 \
+        - 2*sqrt(6)*I/3)/4], [-269*sqrt(6)*I/288, 17*sqrt(6)*I/36, -sqrt(6)*I/3, \
+        sqrt(6)*I*(S(16969)/2592 + 2*sqrt(6)*I/3)/4]]
+    ),
+    (
+        Poly(-3*x**5 - 3*x**4 - 3*x**3 - x**2 - 1, x, extension=True),
+        Poly(12*x - 2, x, extension=True),
+        4,
+        [[41*I/192, 7*I/24, I/2, -I*(-S(59)/6912 - I)], \
+        [-41*I/192, -7*I/24, -I/2, I*(-S(59)/6912 + I)]]
+    ),
+    # Tests with multiplicity at oo = 4
+    (
+        Poly(-x**7 - x**5 - x**4 - x**2 - x, x, extension=True),
+        Poly(x + 2, x, extension=True),
+        6,
+        [[-5*I/2, 2*I, -I, I, -I*(-9 - 3*I)/2], [5*I/2, -2*I, I, -I, I*(-9 + 3*I)/2]]
+    ),
+    (
+        Poly(-x**7 - x**6 - 2*x**5 - 2*x**4 - x**3 - x**2 + 2*x - 2, x, extension=True),
+        Poly(2*x - 2, x, extension=True),
+        6,
+        [[3*sqrt(2)*I/4, 3*sqrt(2)*I/4, sqrt(2)*I/2, sqrt(2)*I/2, -sqrt(2)*I*(-S(7)/8 - \
+        3*sqrt(2)*I/2)/2], [-3*sqrt(2)*I/4, -3*sqrt(2)*I/4, -sqrt(2)*I/2, -sqrt(2)*I/2, \
+        sqrt(2)*I*(-S(7)/8 + 3*sqrt(2)*I/2)/2]]
+    )]
+    for num, den, mul, d in tests:
+        ser = rational_laurent_series(num, den, x, oo, mul, 1)
+        assert construct_d_case_4(ser, mul//2) == d
+
+
+def test_construct_d_case_5():
+    """
+    This function tests the Case 5 in the step
+    to calculate coefficients of the d-vector.
+
+    Each test case has 3 values -
+
+    1. num - Numerator of the rational function a(x).
+    2. den - Denominator of the rational function a(x).
+    3. d - The d-vector.
+    """
+    tests = [
+    (
+        Poly(2*x**3 + x**2 + x - 2, x, extension=True),
+        Poly(9*x**3 + 5*x**2 + 2*x - 1, x, extension=True),
+        [[sqrt(2)/3, -sqrt(2)/108], [-sqrt(2)/3, sqrt(2)/108]]
+    ),
+    (
+        Poly(3*x**5 + x**4 - x**3 + x**2 - 2*x - 2, x, domain='ZZ'),
+        Poly(9*x**5 + 7*x**4 + 3*x**3 + 2*x**2 + 5*x + 7, x, domain='ZZ'),
+        [[sqrt(3)/3, -2*sqrt(3)/27], [-sqrt(3)/3, 2*sqrt(3)/27]]
+    ),
+    (
+        Poly(x**2 - x + 1, x, domain='ZZ'),
+        Poly(3*x**2 + 7*x + 3, x, domain='ZZ'),
+        [[sqrt(3)/3, -5*sqrt(3)/9], [-sqrt(3)/3, 5*sqrt(3)/9]]
+    )]
+    for num, den, d in tests:
+        # Multiplicity of oo is 0
+        ser = rational_laurent_series(num, den, x, oo, 0, 1)
+        assert construct_d_case_5(ser) == d
+
+
+def test_construct_d_case_6():
+    """
+    This function tests the Case 6 in the step
+    to calculate coefficients of the d-vector.
+
+    Each test case has 3 values -
+
+    1. num - Numerator of the rational function a(x).
+    2. den - Denominator of the rational function a(x).
+    3. d - The d-vector.
+    """
+    tests = [
+    (
+        Poly(-2*x**2 - 5, x, domain='ZZ'),
+        Poly(4*x**4 + 2*x**2 + 10*x + 2, x, domain='ZZ'),
+        [[S(1)/2 + I/2], [S(1)/2 - I/2]]
+    ),
+    (
+        Poly(-2*x**3 - 4*x**2 - 2*x - 5, x, domain='ZZ'),
+        Poly(x**6 - x**5 + 2*x**4 - 4*x**3 - 5*x**2 - 5*x + 9, x, domain='ZZ'),
+        [[1], [0]]
+    ),
+    (
+        Poly(-5*x**3 + x**2 + 11*x + 12, x, domain='ZZ'),
+        Poly(6*x**8 - 26*x**7 - 27*x**6 - 10*x**5 - 44*x**4 - 46*x**3 - 34*x**2 \
+        - 27*x - 42, x, domain='ZZ'),
+        [[1], [0]]
+    )]
+    for num, den, d in tests:
+        assert construct_d_case_6(num, den, x) == d
+
+
+def test_rational_laurent_series():
+    """
+    This function tests the computation of coefficients
+    of Laurent series of a rational function.
+
+    Each test case has 5 values -
+
+    1. num - Numerator of the rational function.
+    2. den - Denominator of the rational function.
+    3. x0 - Point about which Laurent series is to
+       be calculated.
+    4. mul - Multiplicity of x0 if x0 is a pole of
+       the rational function (0 otherwise).
+    5. n - Number of terms upto which the series
+       is to be calculated.
+    """
+    tests = [
+    # Laurent series about simple pole (Multiplicity = 1)
+    (
+        Poly(x**2 - 3*x + 9, x, extension=True),
+        Poly(x**2 - x, x, extension=True),
+        S(1), 1, 6,
+        {1: 7, 0: -8, -1: 9, -2: -9, -3: 9, -4: -9}
+    ),
+    # Laurent series about multiple pole (Multiplicity > 1)
+    (
+        Poly(64*x**3 - 1728*x + 1216, x, extension=True),
+        Poly(64*x**4 - 80*x**3 - 831*x**2 + 1809*x - 972, x, extension=True),
+        S(9)/8, 2, 3,
+        {0: S(32177152)/46521675, 2: S(1019)/984, -1: S(11947565056)/28610830125, \
+        1: S(209149)/75645}
+    ),
+    (
+        Poly(1, x, extension=True),
+        Poly(x**5 + (-4*sqrt(2) - 1)*x**4 + (4*sqrt(2) + 12)*x**3 + (-12 - 8*sqrt(2))*x**2 \
+        + (4 + 8*sqrt(2))*x - 4, x, extension=True),
+        sqrt(2), 4, 6,
+        {4: 1 + sqrt(2), 3: -3 - 2*sqrt(2), 2: Mul(-1, -3 - 2*sqrt(2), evaluate=False)/(-1 \
+        + sqrt(2)), 1: (-3 - 2*sqrt(2))/(-1 + sqrt(2))**2, 0: Mul(-1, -3 - 2*sqrt(2), evaluate=False \
+        )/(-1 + sqrt(2))**3, -1: (-3 - 2*sqrt(2))/(-1 + sqrt(2))**4}
+    ),
+    # Laurent series about oo
+    (
+        Poly(x**5 - 4*x**3 + 6*x**2 + 10*x - 13, x, extension=True),
+        Poly(x**2 - 5, x, extension=True),
+        oo, 3, 6,
+        {3: 1, 2: 0, 1: 1, 0: 6, -1: 15, -2: 17}
+    ),
+    # Laurent series at x0 where x0 is not a pole of the function
+    # Using multiplicity as 0 (as x0 will not be a pole)
+    (
+        Poly(3*x**3 + 6*x**2 - 2*x + 5, x, extension=True),
+        Poly(9*x**4 - x**3 - 3*x**2 + 4*x + 4, x, extension=True),
+        S(2)/5, 0, 1,
+        {0: S(3345)/3304, -1: S(399325)/2729104, -2: S(3926413375)/4508479808, \
+        -3: S(-5000852751875)/1862002160704, -4: S(-6683640101653125)/6152055138966016}
+    ),
+    (
+        Poly(-7*x**2 + 2*x - 4, x, extension=True),
+        Poly(7*x**5 + 9*x**4 + 8*x**3 + 3*x**2 + 6*x + 9, x, extension=True),
+        oo, 0, 6,
+        {0: 0, -2: 0, -5: -S(71)/49, -1: 0, -3: -1, -4: S(11)/7}
+    )]
+    for num, den, x0, mul, n, ser in tests:
+        assert ser == rational_laurent_series(num, den, x, x0, mul, n)
+
+
+def check_dummy_sol(eq, solse, dummy_sym):
+    """
+    Helper function to check if actual solution
+    matches expected solution if actual solution
+    contains dummy symbols.
+    """
+    if isinstance(eq, Eq):
+        eq = eq.lhs - eq.rhs
+    _, funcs = match_riccati(eq, f, x)
+
+    sols = solve_riccati(f(x), x, *funcs)
+    C1 = Dummy('C1')
+    sols = [sol.subs(C1, dummy_sym) for sol in sols]
+
+    assert all(x[0] for x in checkodesol(eq, sols))
+    assert all(s1.dummy_eq(s2, dummy_sym) for s1, s2 in zip(sols, solse))
+
+
+def test_solve_riccati():
+    """
+    This function tests the computation of rational
+    particular solutions for a Riccati ODE.
+
+    Each test case has 2 values -
+
+    1. eq - Riccati ODE to be solved.
+    2. sol - Expected solution to the equation.
+
+    Some examples have been taken from the paper - "Statistical Investigation of
+    First-Order Algebraic ODEs and their Rational General Solutions" by
+    Georg Grasegger, N. Thieu Vo, Franz Winkler
+
+    https://www3.risc.jku.at/publications/download/risc_5197/RISCReport15-19.pdf
+    """
+    C0 = Dummy('C0')
+    # Type: 1st Order Rational Riccati, dy/dx = a + b*y + c*y**2,
+    # a, b, c are rational functions of x
+
+    tests = [
+    # a(x) is a constant
+    (
+        Eq(f(x).diff(x) + f(x)**2 - 2, 0),
+        [Eq(f(x), sqrt(2)), Eq(f(x), -sqrt(2))]
+    ),
+    # a(x) is a constant
+    (
+        f(x)**2 + f(x).diff(x) + 4*f(x)/x + 2/x**2,
+        [Eq(f(x), (-2*C0 - x)/(C0*x + x**2))]
+    ),
+    # a(x) is a constant
+    (
+        2*x**2*f(x).diff(x) - x*(4*f(x) + f(x).diff(x) - 4) + (f(x) - 1)*f(x),
+        [Eq(f(x), (C0 + 2*x**2)/(C0 + x))]
+    ),
+    # Pole with multiplicity 1
+    (
+        Eq(f(x).diff(x), -f(x)**2 - 2/(x**3 - x**2)),
+        [Eq(f(x), 1/(x**2 - x))]
+    ),
+    # One pole of multiplicity 2
+    (
+        x**2 - (2*x + 1/x)*f(x) + f(x)**2 + f(x).diff(x),
+        [Eq(f(x), (C0*x + x**3 + 2*x)/(C0 + x**2)), Eq(f(x), x)]
+    ),
+    (
+        x**4*f(x).diff(x) + x**2 - x*(2*f(x)**2 + f(x).diff(x)) + f(x),
+        [Eq(f(x), (C0*x**2 + x)/(C0 + x**2)), Eq(f(x), x**2)]
+    ),
+    # Multiple poles of multiplicity 2
+    (
+        -f(x)**2 + f(x).diff(x) + (15*x**2 - 20*x + 7)/((x - 1)**2*(2*x \
+            - 1)**2),
+        [Eq(f(x), (9*C0*x - 6*C0 - 15*x**5 + 60*x**4 - 94*x**3 + 72*x**2 \
+        - 30*x + 6)/(6*C0*x**2 - 9*C0*x + 3*C0 + 6*x**6 - 29*x**5 + \
+        57*x**4 - 58*x**3 + 30*x**2 - 6*x)), Eq(f(x), (3*x - 2)/(2*x**2 \
+        - 3*x + 1))]
+    ),
+    # Regression: Poles with even multiplicity > 2 fixed
+    (
+        f(x)**2 + f(x).diff(x) - (4*x**6 - 8*x**5 + 12*x**4 + 4*x**3 + \
+            7*x**2 - 20*x + 4)/(4*x**4),
+        [Eq(f(x), (2*x**5 - 2*x**4 - x**3 + 4*x**2 + 3*x - 2)/(2*x**4 \
+            - 2*x**2))]
+    ),
+    # Regression: Poles with even multiplicity > 2 fixed
+    (
+        Eq(f(x).diff(x), (-x**6 + 15*x**4 - 40*x**3 + 45*x**2 - 24*x + 4)/\
+            (x**12 - 12*x**11 + 66*x**10 - 220*x**9 + 495*x**8 - 792*x**7 + 924*x**6 - \
+            792*x**5 + 495*x**4 - 220*x**3 + 66*x**2 - 12*x + 1) + f(x)**2 + f(x)),
+        [Eq(f(x), 1/(x**6 - 6*x**5 + 15*x**4 - 20*x**3 + 15*x**2 - 6*x + 1))]
+    ),
+    # More than 2 poles with multiplicity 2
+    # Regression: Fixed mistake in necessary conditions
+    (
+        Eq(f(x).diff(x), x*f(x) + 2*x + (3*x - 2)*f(x)**2/(4*x + 2) + \
+            (8*x**2 - 7*x + 26)/(16*x**3 - 24*x**2 + 8) - S(3)/2),
+        [Eq(f(x), (1 - 4*x)/(2*x - 2))]
+    ),
+    # Regression: Fixed mistake in necessary conditions
+    (
+        Eq(f(x).diff(x), (-12*x**2 - 48*x - 15)/(24*x**3 - 40*x**2 + 8*x + 8) \
+            + 3*f(x)**2/(6*x + 2)),
+        [Eq(f(x), (2*x + 1)/(2*x - 2))]
+    ),
+    # Imaginary poles
+    (
+        f(x).diff(x) + (3*x**2 + 1)*f(x)**2/x + (6*x**2 - x + 3)*f(x)/(x*(x \
+            - 1)) + (3*x**2 - 2*x + 2)/(x*(x - 1)**2),
+        [Eq(f(x), (-C0 - x**3 + x**2 - 2*x)/(C0*x - C0 + x**4 - x**3 + x**2 \
+            - x)), Eq(f(x), -1/(x - 1))],
+    ),
+    # Imaginary coefficients in equation
+    (
+        f(x).diff(x) - 2*I*(f(x)**2 + 1)/x,
+        [Eq(f(x), (-I*C0 + I*x**4)/(C0 + x**4)), Eq(f(x), -I)]
+    ),
+    # Regression: linsolve returning empty solution
+    # Large value of m (> 10)
+    (
+        Eq(f(x).diff(x), x*f(x)/(S(3)/2 - 2*x) + (x/2 - S(1)/3)*f(x)**2/\
+            (2*x/3 - S(1)/2) - S(5)/4 + (281*x**2 - 1260*x + 756)/(16*x**3 - 12*x**2)),
+        [Eq(f(x), (9 - x)/x), Eq(f(x), (40*x**14 + 28*x**13 + 420*x**12 + 2940*x**11 + \
+            18480*x**10 + 103950*x**9 + 519750*x**8 + 2286900*x**7 + 8731800*x**6 + 28378350*\
+            x**5 + 76403250*x**4 + 163721250*x**3 + 261954000*x**2 + 278326125*x + 147349125)/\
+            ((24*x**14 + 140*x**13 + 840*x**12 + 4620*x**11 + 23100*x**10 + 103950*x**9 + \
+            415800*x**8 + 1455300*x**7 + 4365900*x**6 + 10914750*x**5 + 21829500*x**4 + 32744250\
+            *x**3 + 32744250*x**2 + 16372125*x)))]
+    ),
+    # Regression: Fixed bug due to a typo in paper
+    (
+        Eq(f(x).diff(x), 18*x**3 + 18*x**2 + (-x/2 - S(1)/2)*f(x)**2 + 6),
+        [Eq(f(x), 6*x)]
+    ),
+    # Regression: Fixed bug due to a typo in paper
+    (
+        Eq(f(x).diff(x), -3*x**3/4 + 15*x/2 + (x/3 - S(4)/3)*f(x)**2 \
+            + 9 + (1 - x)*f(x)/x + 3/x),
+        [Eq(f(x), -3*x/2 - 3)]
+    )]
+    for eq, sol in tests:
+        check_dummy_sol(eq, sol, C0)
+
+
+@slow
+def test_solve_riccati_slow():
+    """
+    This function tests the computation of rational
+    particular solutions for a Riccati ODE.
+
+    Each test case has 2 values -
+
+    1. eq - Riccati ODE to be solved.
+    2. sol - Expected solution to the equation.
+    """
+    C0 = Dummy('C0')
+    tests = [
+    # Very large values of m (989 and 991)
+    (
+        Eq(f(x).diff(x), (1 - x)*f(x)/(x - 3) + (2 - 12*x)*f(x)**2/(2*x - 9) + \
+            (54924*x**3 - 405264*x**2 + 1084347*x - 1087533)/(8*x**4 - 132*x**3 + 810*x**2 - \
+            2187*x + 2187) + 495),
+        [Eq(f(x), (18*x + 6)/(2*x - 9))]
+    )]
+    for eq, sol in tests:
+        check_dummy_sol(eq, sol, C0)
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/ode/tests/test_single.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/ode/tests/test_single.py
new file mode 100644
index 0000000000000000000000000000000000000000..45b38029e97b9e74236c45f2f3efb6aa87c26e5c
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/ode/tests/test_single.py
@@ -0,0 +1,2902 @@
+#
+# The main tests for the code in single.py are currently located in
+# sympy/solvers/tests/test_ode.py
+#
+r"""
+This File contains test functions for the individual hints used for solving ODEs.
+
+Examples of each solver will be returned by _get_examples_ode_sol_name_of_solver.
+
+Examples should have a key 'XFAIL' which stores the list of hints if they are
+expected to fail for that hint.
+
+Functions that are for internal use:
+
+1) _ode_solver_test(ode_examples) - It takes a dictionary of examples returned by
+   _get_examples method and tests them with their respective hints.
+
+2) _test_particular_example(our_hint, example_name) - It tests the ODE example corresponding
+   to the hint provided.
+
+3) _test_all_hints(runxfail=False) - It is used to test all the examples with all the hints
+  currently implemented. It calls _test_all_examples_for_one_hint() which outputs whether the
+  given hint functions properly if it classifies the ODE example.
+  If runxfail flag is set to True then it will only test the examples which are expected to fail.
+
+  Everytime the ODE of a particular solver is added, _test_all_hints() is to be executed to find
+  the possible failures of different solver hints.
+
+4) _test_all_examples_for_one_hint(our_hint, all_examples) - It takes hint as argument and checks
+   this hint against all the ODE examples and gives output as the number of ODEs matched, number
+   of ODEs which were solved correctly, list of ODEs which gives incorrect solution and list of
+   ODEs which raises exception.
+
+"""
+from sympy.core.function import (Derivative, diff)
+from sympy.core.mul import Mul
+from sympy.core.numbers import (E, I, Rational, pi)
+from sympy.core.relational import (Eq, Ne)
+from sympy.core.singleton import S
+from sympy.core.symbol import (Dummy, symbols)
+from sympy.functions.elementary.complexes import (im, re)
+from sympy.functions.elementary.exponential import (LambertW, exp, log)
+from sympy.functions.elementary.hyperbolic import (asinh, cosh, sinh, tanh)
+from sympy.functions.elementary.miscellaneous import (cbrt, sqrt)
+from sympy.functions.elementary.piecewise import Piecewise
+from sympy.functions.elementary.trigonometric import (acos, asin, atan, cos, sec, sin, tan)
+from sympy.functions.special.error_functions import (Ei, erfi)
+from sympy.functions.special.hyper import hyper
+from sympy.integrals.integrals import (Integral, integrate)
+from sympy.polys.rootoftools import rootof
+
+from sympy.core import Function, Symbol
+from sympy.functions import airyai, airybi, besselj, bessely, lowergamma
+from sympy.integrals.risch import NonElementaryIntegral
+from sympy.solvers.ode import classify_ode, dsolve
+from sympy.solvers.ode.ode import allhints, _remove_redundant_solutions
+from sympy.solvers.ode.single import (FirstLinear, ODEMatchError,
+    SingleODEProblem, SingleODESolver, NthOrderReducible)
+
+from sympy.solvers.ode.subscheck import checkodesol
+
+from sympy.testing.pytest import raises, slow
+import traceback
+
+
+x = Symbol('x')
+u = Symbol('u')
+_u = Dummy('u')
+y = Symbol('y')
+f = Function('f')
+g = Function('g')
+C1, C2, C3, C4, C5, C6, C7, C8, C9, C10  = symbols('C1:11')
+a, b, c = symbols('a b c')
+
+
+hint_message = """\
+Hint did not match the example {example}.
+
+The ODE is:
+{eq}.
+
+The expected hint was
+{our_hint}\
+"""
+
+expected_sol_message = """\
+Different solution found from dsolve for example {example}.
+
+The ODE is:
+{eq}
+
+The expected solution was
+{sol}
+
+What dsolve returned is:
+{dsolve_sol}\
+"""
+
+checkodesol_msg = """\
+solution found is not correct for example {example}.
+
+The ODE is:
+{eq}\
+"""
+
+dsol_incorrect_msg = """\
+solution returned by dsolve is incorrect when using {hint}.
+
+The ODE is:
+{eq}
+
+The expected solution was
+{sol}
+
+what dsolve returned is:
+{dsolve_sol}
+
+You can test this with:
+
+eq = {eq}
+sol = dsolve(eq, hint='{hint}')
+print(sol)
+print(checkodesol(eq, sol))
+
+"""
+
+exception_msg = """\
+dsolve raised exception : {e}
+
+when using {hint} for the example {example}
+
+You can test this with:
+
+from sympy.solvers.ode.tests.test_single import _test_an_example
+
+_test_an_example('{hint}', example_name = '{example}')
+
+The ODE is:
+{eq}
+
+\
+"""
+
+check_hint_msg = """\
+Tested hint was : {hint}
+
+Total of {matched} examples matched with this hint.
+
+Out of which {solve} gave correct results.
+
+Examples which gave incorrect results are {unsolve}.
+
+Examples which raised exceptions are {exceptions}
+\
+"""
+
+
+def _add_example_keys(func):
+    def inner():
+        solver=func()
+        examples=[]
+        for example in solver['examples']:
+            temp={
+                'eq': solver['examples'][example]['eq'],
+                'sol': solver['examples'][example]['sol'],
+                'XFAIL': solver['examples'][example].get('XFAIL', []),
+                'func': solver['examples'][example].get('func',solver['func']),
+                'example_name': example,
+                'slow': solver['examples'][example].get('slow', False),
+                'simplify_flag':solver['examples'][example].get('simplify_flag',True),
+                'checkodesol_XFAIL': solver['examples'][example].get('checkodesol_XFAIL', False),
+                'dsolve_too_slow':solver['examples'][example].get('dsolve_too_slow',False),
+                'checkodesol_too_slow':solver['examples'][example].get('checkodesol_too_slow',False),
+                'hint': solver['hint']
+            }
+            examples.append(temp)
+        return examples
+    return inner()
+
+
+def _ode_solver_test(ode_examples, run_slow_test=False):
+    for example in ode_examples:
+        if ((not run_slow_test) and example['slow']) or (run_slow_test and (not example['slow'])):
+            continue
+
+        result = _test_particular_example(example['hint'], example, solver_flag=True)
+        if result['xpass_msg'] != "":
+            print(result['xpass_msg'])
+
+
+def _test_all_hints(runxfail=False):
+    all_hints = list(allhints)+["default"]
+    all_examples = _get_all_examples()
+
+    for our_hint in all_hints:
+        if our_hint.endswith('_Integral') or 'series' in our_hint:
+            continue
+        _test_all_examples_for_one_hint(our_hint, all_examples, runxfail)
+
+
+def _test_dummy_sol(expected_sol,dsolve_sol):
+    if type(dsolve_sol)==list:
+        return any(expected_sol.dummy_eq(sub_dsol) for sub_dsol in dsolve_sol)
+    else:
+        return expected_sol.dummy_eq(dsolve_sol)
+
+
+def _test_an_example(our_hint, example_name):
+    all_examples = _get_all_examples()
+    for example in all_examples:
+        if example['example_name'] == example_name:
+            _test_particular_example(our_hint, example)
+
+
+def _test_particular_example(our_hint, ode_example, solver_flag=False):
+    eq = ode_example['eq']
+    expected_sol = ode_example['sol']
+    example = ode_example['example_name']
+    xfail = our_hint in ode_example['XFAIL']
+    func = ode_example['func']
+    result = {'msg': '', 'xpass_msg': ''}
+    simplify_flag=ode_example['simplify_flag']
+    checkodesol_XFAIL = ode_example['checkodesol_XFAIL']
+    dsolve_too_slow = ode_example['dsolve_too_slow']
+    checkodesol_too_slow = ode_example['checkodesol_too_slow']
+    xpass = True
+    if solver_flag:
+        if our_hint not in classify_ode(eq, func):
+            message = hint_message.format(example=example, eq=eq, our_hint=our_hint)
+            raise AssertionError(message)
+
+    if our_hint in classify_ode(eq, func):
+        result['match_list'] = example
+        try:
+            if not (dsolve_too_slow):
+                dsolve_sol = dsolve(eq, func, simplify=simplify_flag,hint=our_hint)
+            else:
+                if len(expected_sol)==1:
+                    dsolve_sol = expected_sol[0]
+                else:
+                    dsolve_sol = expected_sol
+
+        except Exception as e:
+            dsolve_sol = []
+            result['exception_list'] = example
+            if not solver_flag:
+                traceback.print_exc()
+            result['msg'] = exception_msg.format(e=str(e), hint=our_hint, example=example, eq=eq)
+            if solver_flag and not xfail:
+                print(result['msg'])
+                raise
+            xpass = False
+
+        if solver_flag and dsolve_sol!=[]:
+            expect_sol_check = False
+            if type(dsolve_sol)==list:
+                for sub_sol in expected_sol:
+                    if sub_sol.has(Dummy):
+                        expect_sol_check = not _test_dummy_sol(sub_sol, dsolve_sol)
+                    else:
+                        expect_sol_check = sub_sol not in dsolve_sol
+                    if expect_sol_check:
+                        break
+            else:
+                expect_sol_check = dsolve_sol not in expected_sol
+                for sub_sol in expected_sol:
+                    if sub_sol.has(Dummy):
+                        expect_sol_check = not _test_dummy_sol(sub_sol, dsolve_sol)
+
+            if expect_sol_check:
+                message = expected_sol_message.format(example=example, eq=eq, sol=expected_sol, dsolve_sol=dsolve_sol)
+                raise AssertionError(message)
+
+            expected_checkodesol = [(True, 0) for i in range(len(expected_sol))]
+            if len(expected_sol) == 1:
+                expected_checkodesol = (True, 0)
+
+            if not checkodesol_too_slow:
+                if not checkodesol_XFAIL:
+                    if checkodesol(eq, dsolve_sol, func, solve_for_func=False) != expected_checkodesol:
+                        result['unsolve_list'] = example
+                        xpass = False
+                        message = dsol_incorrect_msg.format(hint=our_hint, eq=eq, sol=expected_sol,dsolve_sol=dsolve_sol)
+                        if solver_flag:
+                            message = checkodesol_msg.format(example=example, eq=eq)
+                            raise AssertionError(message)
+                        else:
+                            result['msg'] = 'AssertionError: ' + message
+
+        if xpass and xfail:
+            result['xpass_msg'] = example + "is now passing for the hint" + our_hint
+    return result
+
+
+def _test_all_examples_for_one_hint(our_hint, all_examples=[], runxfail=None):
+    if all_examples == []:
+        all_examples = _get_all_examples()
+    match_list, unsolve_list, exception_list = [], [], []
+    for ode_example in all_examples:
+        xfail = our_hint in ode_example['XFAIL']
+        if runxfail and not xfail:
+            continue
+        if xfail:
+            continue
+        result = _test_particular_example(our_hint, ode_example)
+        match_list += result.get('match_list',[])
+        unsolve_list += result.get('unsolve_list',[])
+        exception_list += result.get('exception_list',[])
+        if runxfail is not None:
+            msg = result['msg']
+            if msg!='':
+                print(result['msg'])
+            # print(result.get('xpass_msg',''))
+    if runxfail is None:
+        match_count = len(match_list)
+        solved = len(match_list)-len(unsolve_list)-len(exception_list)
+        msg = check_hint_msg.format(hint=our_hint, matched=match_count, solve=solved, unsolve=unsolve_list, exceptions=exception_list)
+        print(msg)
+
+
+def test_SingleODESolver():
+    # Test that not implemented methods give NotImplementedError
+    # Subclasses should override these methods.
+    problem = SingleODEProblem(f(x).diff(x), f(x), x)
+    solver = SingleODESolver(problem)
+    raises(NotImplementedError, lambda: solver.matches())
+    raises(NotImplementedError, lambda: solver.get_general_solution())
+    raises(NotImplementedError, lambda: solver._matches())
+    raises(NotImplementedError, lambda: solver._get_general_solution())
+
+    # This ODE can not be solved by the FirstLinear solver. Here we test that
+    # it does not match and the asking for a general solution gives
+    # ODEMatchError
+
+    problem = SingleODEProblem(f(x).diff(x) + f(x)*f(x), f(x), x)
+
+    solver = FirstLinear(problem)
+    raises(ODEMatchError, lambda: solver.get_general_solution())
+
+    solver = FirstLinear(problem)
+    assert solver.matches() is False
+
+    #These are just test for order of ODE
+
+    problem = SingleODEProblem(f(x).diff(x) + f(x), f(x), x)
+    assert problem.order == 1
+
+    problem = SingleODEProblem(f(x).diff(x,4) + f(x).diff(x,2) - f(x).diff(x,3), f(x), x)
+    assert problem.order == 4
+
+    problem = SingleODEProblem(f(x).diff(x, 3) + f(x).diff(x, 2) - f(x)**2, f(x), x)
+    assert problem.is_autonomous == True
+
+    problem = SingleODEProblem(f(x).diff(x, 3) + x*f(x).diff(x, 2) - f(x)**2, f(x), x)
+    assert problem.is_autonomous == False
+
+
+def test_linear_coefficients():
+    _ode_solver_test(_get_examples_ode_sol_linear_coefficients)
+
+
+@slow
+def test_1st_homogeneous_coeff_ode():
+    #These were marked as test_1st_homogeneous_coeff_corner_case
+    eq1 = f(x).diff(x) - f(x)/x
+    c1 = classify_ode(eq1, f(x))
+    eq2 = x*f(x).diff(x) - f(x)
+    c2 = classify_ode(eq2, f(x))
+    sdi = "1st_homogeneous_coeff_subs_dep_div_indep"
+    sid = "1st_homogeneous_coeff_subs_indep_div_dep"
+    assert sid not in c1 and sdi not in c1
+    assert sid not in c2 and sdi not in c2
+    _ode_solver_test(_get_examples_ode_sol_1st_homogeneous_coeff_subs_dep_div_indep)
+    _ode_solver_test(_get_examples_ode_sol_1st_homogeneous_coeff_best)
+
+
+@slow
+def test_slow_examples_1st_homogeneous_coeff_ode():
+    _ode_solver_test(_get_examples_ode_sol_1st_homogeneous_coeff_subs_dep_div_indep, run_slow_test=True)
+    _ode_solver_test(_get_examples_ode_sol_1st_homogeneous_coeff_best, run_slow_test=True)
+
+
+@slow
+def test_nth_linear_constant_coeff_homogeneous():
+    _ode_solver_test(_get_examples_ode_sol_nth_linear_constant_coeff_homogeneous)
+
+
+@slow
+def test_slow_examples_nth_linear_constant_coeff_homogeneous():
+    _ode_solver_test(_get_examples_ode_sol_nth_linear_constant_coeff_homogeneous, run_slow_test=True)
+
+
+def test_Airy_equation():
+    _ode_solver_test(_get_examples_ode_sol_2nd_linear_airy)
+
+
+@slow
+def test_lie_group():
+    _ode_solver_test(_get_examples_ode_sol_lie_group)
+
+
+@slow
+def test_separable_reduced():
+    df = f(x).diff(x)
+    eq = (x / f(x))*df  + tan(x**2*f(x) / (x**2*f(x) - 1))
+    assert classify_ode(eq) == ('factorable', 'separable_reduced', 'lie_group',
+        'separable_reduced_Integral')
+    _ode_solver_test(_get_examples_ode_sol_separable_reduced)
+
+
+@slow
+def test_slow_examples_separable_reduced():
+    _ode_solver_test(_get_examples_ode_sol_separable_reduced, run_slow_test=True)
+
+
+@slow
+def test_2nd_2F1_hypergeometric():
+    _ode_solver_test(_get_examples_ode_sol_2nd_2F1_hypergeometric)
+
+
+def test_2nd_2F1_hypergeometric_integral():
+    eq = x*(x-1)*f(x).diff(x, 2) + (-1+ S(7)/2*x)*f(x).diff(x) + f(x)
+    sol = Eq(f(x), (C1 + C2*Integral(exp(Integral((1 - x/2)/(x*(x - 1)), x))/(1 -
+          x/2)**2, x))*exp(Integral(1/(x - 1), x)/4)*exp(-Integral(7/(x -
+          1), x)/4)*hyper((S(1)/2, -1), (1,), x))
+    assert sol == dsolve(eq, hint='2nd_hypergeometric_Integral')
+    assert checkodesol(eq, sol) == (True, 0)
+
+
+@slow
+def test_2nd_nonlinear_autonomous_conserved():
+    _ode_solver_test(_get_examples_ode_sol_2nd_nonlinear_autonomous_conserved)
+
+
+def test_2nd_nonlinear_autonomous_conserved_integral():
+    eq = f(x).diff(x, 2) + asin(f(x))
+    actual = [Eq(Integral(1/sqrt(C1 - 2*Integral(asin(_u), _u)), (_u, f(x))), C2 + x),
+    Eq(Integral(1/sqrt(C1 - 2*Integral(asin(_u), _u)), (_u, f(x))), C2 - x)]
+    solved = dsolve(eq, hint='2nd_nonlinear_autonomous_conserved_Integral', simplify=False)
+    for a,s in zip(actual, solved):
+        assert a.dummy_eq(s)
+    # checkodesol unable to simplify solutions with f(x) in an integral equation
+    assert checkodesol(eq, [s.doit() for s in solved]) == [(True, 0), (True, 0)]
+
+
+@slow
+def test_2nd_linear_bessel_equation():
+    _ode_solver_test(_get_examples_ode_sol_2nd_linear_bessel)
+
+
+@slow
+def test_nth_algebraic():
+    eqn = f(x) + f(x)*f(x).diff(x)
+    solns = [Eq(f(x), exp(x)),
+             Eq(f(x), C1*exp(C2*x))]
+    solns_final =  _remove_redundant_solutions(eqn, solns, 2, x)
+    assert solns_final == [Eq(f(x), C1*exp(C2*x))]
+
+    _ode_solver_test(_get_examples_ode_sol_nth_algebraic)
+
+
+@slow
+def test_slow_examples_nth_linear_constant_coeff_var_of_parameters():
+    _ode_solver_test(_get_examples_ode_sol_nth_linear_var_of_parameters, run_slow_test=True)
+
+
+def test_nth_linear_constant_coeff_var_of_parameters():
+    _ode_solver_test(_get_examples_ode_sol_nth_linear_var_of_parameters)
+
+
+@slow
+def test_nth_linear_constant_coeff_variation_of_parameters__integral():
+    # solve_variation_of_parameters shouldn't attempt to simplify the
+    # Wronskian if simplify=False.  If wronskian() ever gets good enough
+    # to simplify the result itself, this test might fail.
+    our_hint = 'nth_linear_constant_coeff_variation_of_parameters_Integral'
+    eq = f(x).diff(x, 5) + 2*f(x).diff(x, 3) + f(x).diff(x) - 2*x - exp(I*x)
+    sol_simp = dsolve(eq, f(x), hint=our_hint, simplify=True)
+    sol_nsimp = dsolve(eq, f(x), hint=our_hint, simplify=False)
+    assert sol_simp != sol_nsimp
+    assert checkodesol(eq, sol_simp, order=5, solve_for_func=False) == (True, 0)
+    assert checkodesol(eq, sol_simp, order=5, solve_for_func=False) == (True, 0)
+
+
+@slow
+def test_slow_examples_1st_exact():
+    _ode_solver_test(_get_examples_ode_sol_1st_exact, run_slow_test=True)
+
+
+@slow
+def test_1st_exact():
+    _ode_solver_test(_get_examples_ode_sol_1st_exact)
+
+
+def test_1st_exact_integral():
+    eq = cos(f(x)) - (x*sin(f(x)) - f(x)**2)*f(x).diff(x)
+    sol_1 = dsolve(eq, f(x), simplify=False, hint='1st_exact_Integral')
+    assert checkodesol(eq, sol_1, order=1, solve_for_func=False)
+
+
+@slow
+def test_slow_examples_nth_order_reducible():
+    _ode_solver_test(_get_examples_ode_sol_nth_order_reducible, run_slow_test=True)
+
+
+@slow
+def test_slow_examples_nth_linear_constant_coeff_undetermined_coefficients():
+    _ode_solver_test(_get_examples_ode_sol_nth_linear_undetermined_coefficients, run_slow_test=True)
+
+
+@slow
+def test_slow_examples_separable():
+    _ode_solver_test(_get_examples_ode_sol_separable, run_slow_test=True)
+
+
+@slow
+def test_nth_linear_constant_coeff_undetermined_coefficients():
+    #issue-https://github.com/sympy/sympy/issues/5787
+    # This test case is to show the classification of imaginary constants under
+    # nth_linear_constant_coeff_undetermined_coefficients
+    eq = Eq(diff(f(x), x), I*f(x) + S.Half - I)
+    our_hint = 'nth_linear_constant_coeff_undetermined_coefficients'
+    assert our_hint in classify_ode(eq)
+    _ode_solver_test(_get_examples_ode_sol_nth_linear_undetermined_coefficients)
+
+
+def test_nth_order_reducible():
+    F = lambda eq: NthOrderReducible(SingleODEProblem(eq, f(x), x))._matches()
+    D = Derivative
+    assert F(D(y*f(x), x, y) + D(f(x), x)) == False
+    assert F(D(y*f(y), y, y) + D(f(y), y)) == False
+    assert F(f(x)*D(f(x), x) + D(f(x), x, 2))== False
+    assert F(D(x*f(y), y, 2) + D(u*y*f(x), x, 3)) == False  # no simplification by design
+    assert F(D(f(y), y, 2) + D(f(y), y, 3) + D(f(x), x, 4)) == False
+    assert F(D(f(x), x, 2) + D(f(x), x, 3)) == True
+    _ode_solver_test(_get_examples_ode_sol_nth_order_reducible)
+
+
+@slow
+def test_separable():
+    _ode_solver_test(_get_examples_ode_sol_separable)
+
+
+@slow
+def test_factorable():
+    assert integrate(-asin(f(2*x)+pi), x) == -Integral(asin(pi + f(2*x)), x)
+    _ode_solver_test(_get_examples_ode_sol_factorable)
+
+
+@slow
+def test_slow_examples_factorable():
+    _ode_solver_test(_get_examples_ode_sol_factorable, run_slow_test=True)
+
+
+def test_Riccati_special_minus2():
+    _ode_solver_test(_get_examples_ode_sol_riccati)
+
+
+@slow
+def test_1st_rational_riccati():
+    _ode_solver_test(_get_examples_ode_sol_1st_rational_riccati)
+
+
+def test_Bernoulli():
+    _ode_solver_test(_get_examples_ode_sol_bernoulli)
+
+
+def test_1st_linear():
+    _ode_solver_test(_get_examples_ode_sol_1st_linear)
+
+
+def test_almost_linear():
+    _ode_solver_test(_get_examples_ode_sol_almost_linear)
+
+
+@slow
+def test_Liouville_ODE():
+    hint = 'Liouville'
+    not_Liouville1 = classify_ode(diff(f(x), x)/x + f(x)*diff(f(x), x, x)/2 -
+        diff(f(x), x)**2/2, f(x))
+    not_Liouville2 = classify_ode(diff(f(x), x)/x + diff(f(x), x, x)/2 -
+        x*diff(f(x), x)**2/2, f(x))
+    assert hint not in not_Liouville1
+    assert hint not in not_Liouville2
+    assert hint + '_Integral' not in not_Liouville1
+    assert hint + '_Integral' not in not_Liouville2
+
+    _ode_solver_test(_get_examples_ode_sol_liouville)
+
+
+def test_nth_order_linear_euler_eq_homogeneous():
+    x, t, a, b, c = symbols('x t a b c')
+    y = Function('y')
+    our_hint = "nth_linear_euler_eq_homogeneous"
+
+    eq = diff(f(t), t, 4)*t**4 - 13*diff(f(t), t, 2)*t**2 + 36*f(t)
+    assert our_hint in classify_ode(eq)
+
+    eq = a*y(t) + b*t*diff(y(t), t) + c*t**2*diff(y(t), t, 2)
+    assert our_hint in classify_ode(eq)
+
+    _ode_solver_test(_get_examples_ode_sol_euler_homogeneous)
+
+
+def test_nth_order_linear_euler_eq_nonhomogeneous_undetermined_coefficients():
+    x, t = symbols('x t')
+    a, b, c, d = symbols('a b c d', integer=True)
+    our_hint = "nth_linear_euler_eq_nonhomogeneous_undetermined_coefficients"
+
+    eq = x**4*diff(f(x), x, 4) - 13*x**2*diff(f(x), x, 2) + 36*f(x) + x
+    assert our_hint in classify_ode(eq, f(x))
+
+    eq = a*x**2*diff(f(x), x, 2) + b*x*diff(f(x), x) + c*f(x) + d*log(x)
+    assert our_hint in classify_ode(eq, f(x))
+
+    _ode_solver_test(_get_examples_ode_sol_euler_undetermined_coeff)
+
+
+@slow
+def test_nth_order_linear_euler_eq_nonhomogeneous_variation_of_parameters():
+    x, t = symbols('x, t')
+    a, b, c, d = symbols('a, b, c, d', integer=True)
+    our_hint = "nth_linear_euler_eq_nonhomogeneous_variation_of_parameters"
+
+    eq = Eq(x**2*diff(f(x),x,2) - 8*x*diff(f(x),x) + 12*f(x), x**2)
+    assert our_hint in classify_ode(eq, f(x))
+
+    eq = Eq(a*x**3*diff(f(x),x,3) + b*x**2*diff(f(x),x,2) + c*x*diff(f(x),x) + d*f(x), x*log(x))
+    assert our_hint in classify_ode(eq, f(x))
+
+    _ode_solver_test(_get_examples_ode_sol_euler_var_para)
+
+
+@_add_example_keys
+def _get_examples_ode_sol_euler_homogeneous():
+    r1, r2, r3, r4, r5 = [rootof(x**5 - 14*x**4 + 71*x**3 - 154*x**2 + 120*x - 1, n) for n in range(5)]
+    return {
+            'hint': "nth_linear_euler_eq_homogeneous",
+            'func': f(x),
+            'examples':{
+    'euler_hom_01': {
+        'eq': Eq(-3*diff(f(x), x)*x + 2*x**2*diff(f(x), x, x), 0),
+        'sol': [Eq(f(x), C1 + C2*x**Rational(5, 2))],
+    },
+
+    'euler_hom_02': {
+        'eq': Eq(3*f(x) - 5*diff(f(x), x)*x + 2*x**2*diff(f(x), x, x), 0),
+        'sol': [Eq(f(x), C1*sqrt(x) + C2*x**3)]
+    },
+
+    'euler_hom_03': {
+        'eq': Eq(4*f(x) + 5*diff(f(x), x)*x + x**2*diff(f(x), x, x), 0),
+        'sol': [Eq(f(x), (C1 + C2*log(x))/x**2)]
+    },
+
+    'euler_hom_04': {
+        'eq': Eq(6*f(x) - 6*diff(f(x), x)*x + 1*x**2*diff(f(x), x, x) + x**3*diff(f(x), x, x, x), 0),
+        'sol': [Eq(f(x), C1/x**2 + C2*x + C3*x**3)]
+    },
+
+    'euler_hom_05': {
+        'eq': Eq(-125*f(x) + 61*diff(f(x), x)*x - 12*x**2*diff(f(x), x, x) + x**3*diff(f(x), x, x, x), 0),
+        'sol': [Eq(f(x), x**5*(C1 + C2*log(x) + C3*log(x)**2))]
+    },
+
+    'euler_hom_06': {
+        'eq': x**2*diff(f(x), x, 2) + x*diff(f(x), x) - 9*f(x),
+        'sol': [Eq(f(x), C1*x**-3 + C2*x**3)]
+    },
+
+    'euler_hom_07': {
+        'eq': sin(x)*x**2*f(x).diff(x, 2) + sin(x)*x*f(x).diff(x) + sin(x)*f(x),
+        'sol': [Eq(f(x), C1*sin(log(x)) + C2*cos(log(x)))],
+        'XFAIL': ['2nd_power_series_regular','nth_linear_euler_eq_nonhomogeneous_undetermined_coefficients']
+    },
+
+    'euler_hom_08': {
+        'eq': x**6 * f(x).diff(x, 6) - x*f(x).diff(x) + f(x),
+        'sol': [Eq(f(x), C1*x + C2*x**r1 + C3*x**r2 + C4*x**r3 + C5*x**r4 + C6*x**r5)],
+        'checkodesol_XFAIL':True
+    },
+
+     #This example is from issue: https://github.com/sympy/sympy/issues/15237 #This example is from issue:
+     #  https://github.com/sympy/sympy/issues/15237
+    'euler_hom_09': {
+        'eq': Derivative(x*f(x), x, x, x),
+        'sol': [Eq(f(x), C1 + C2/x + C3*x)],
+    },
+    }
+    }
+
+
+@_add_example_keys
+def _get_examples_ode_sol_euler_undetermined_coeff():
+    return {
+            'hint': "nth_linear_euler_eq_nonhomogeneous_undetermined_coefficients",
+            'func': f(x),
+            'examples':{
+    'euler_undet_01': {
+        'eq': Eq(x**2*diff(f(x), x, x) + x*diff(f(x), x), 1),
+        'sol': [Eq(f(x), C1 + C2*log(x) + log(x)**2/2)]
+    },
+
+    'euler_undet_02': {
+        'eq': Eq(x**2*diff(f(x), x, x) - 2*x*diff(f(x), x) + 2*f(x), x**3),
+        'sol': [Eq(f(x), x*(C1 + C2*x + Rational(1, 2)*x**2))]
+    },
+
+    'euler_undet_03': {
+        'eq': Eq(x**2*diff(f(x), x, x) - x*diff(f(x), x) - 3*f(x), log(x)/x),
+        'sol': [Eq(f(x), (C1 + C2*x**4 - log(x)**2/8 - log(x)/16)/x)]
+    },
+
+    'euler_undet_04': {
+        'eq': Eq(x**2*diff(f(x), x, x) + 3*x*diff(f(x), x) - 8*f(x), log(x)**3 - log(x)),
+        'sol': [Eq(f(x), C1/x**4 + C2*x**2 - Rational(1,8)*log(x)**3 - Rational(3,32)*log(x)**2 - Rational(1,64)*log(x) - Rational(7, 256))]
+    },
+
+    'euler_undet_05': {
+        'eq': Eq(x**3*diff(f(x), x, x, x) - 3*x**2*diff(f(x), x, x) + 6*x*diff(f(x), x) - 6*f(x), log(x)),
+        'sol': [Eq(f(x), C1*x + C2*x**2 + C3*x**3 - Rational(1, 6)*log(x) - Rational(11, 36))]
+    },
+
+    #Below examples were added for the issue: https://github.com/sympy/sympy/issues/5096
+    'euler_undet_06': {
+        'eq': 2*x**2*f(x).diff(x, 2) + f(x) + sqrt(2*x)*sin(log(2*x)/2),
+        'sol': [Eq(f(x), sqrt(x)*(C1*sin(log(x)/2) + C2*cos(log(x)/2) + sqrt(2)*log(x)*cos(log(2*x)/2)/2))]
+    },
+
+    'euler_undet_07': {
+        'eq': 2*x**2*f(x).diff(x, 2) + f(x) + sin(log(2*x)/2),
+        'sol': [Eq(f(x), C1*sqrt(x)*sin(log(x)/2) + C2*sqrt(x)*cos(log(x)/2) - 2*sin(log(2*x)/2)/5 - 4*cos(log(2*x)/2)/5)]
+    },
+    }
+    }
+
+
+@_add_example_keys
+def _get_examples_ode_sol_euler_var_para():
+    return {
+            'hint': "nth_linear_euler_eq_nonhomogeneous_variation_of_parameters",
+            'func': f(x),
+            'examples':{
+    'euler_var_01': {
+        'eq': Eq(x**2*Derivative(f(x), x, x) - 2*x*Derivative(f(x), x) + 2*f(x), x**4),
+        'sol': [Eq(f(x), x*(C1 + C2*x + x**3/6))]
+    },
+
+    'euler_var_02': {
+        'eq': Eq(3*x**2*diff(f(x), x, x) + 6*x*diff(f(x), x) - 6*f(x), x**3*exp(x)),
+        'sol': [Eq(f(x), C1/x**2 + C2*x + x*exp(x)/3 - 4*exp(x)/3 + 8*exp(x)/(3*x) - 8*exp(x)/(3*x**2))]
+    },
+
+    'euler_var_03': {
+        'eq': Eq(x**2*Derivative(f(x), x, x) - 2*x*Derivative(f(x), x) + 2*f(x), x**4*exp(x)),
+        'sol':  [Eq(f(x), x*(C1 + C2*x + x*exp(x) - 2*exp(x)))]
+    },
+
+    'euler_var_04': {
+        'eq': x**2*Derivative(f(x), x, x) - 2*x*Derivative(f(x), x) + 2*f(x) - log(x),
+        'sol': [Eq(f(x), C1*x + C2*x**2 + log(x)/2 + Rational(3, 4))]
+    },
+
+    'euler_var_05': {
+        'eq': -exp(x) + (x*Derivative(f(x), (x, 2)) + Derivative(f(x), x))/x,
+        'sol': [Eq(f(x), C1 + C2*log(x) + exp(x) - Ei(x))]
+    },
+
+    'euler_var_06': {
+        'eq': x**2 * f(x).diff(x, 2) + x * f(x).diff(x) + 4 * f(x) - 1/x,
+        'sol': [Eq(f(x), C1*sin(2*log(x)) + C2*cos(2*log(x)) + 1/(5*x))]
+    },
+    }
+    }
+
+
+@_add_example_keys
+def _get_examples_ode_sol_bernoulli():
+    # Type: Bernoulli, f'(x) + p(x)*f(x) == q(x)*f(x)**n
+    return {
+            'hint': "Bernoulli",
+            'func': f(x),
+            'examples':{
+    'bernoulli_01': {
+        'eq': Eq(x*f(x).diff(x) + f(x) - f(x)**2, 0),
+        'sol': [Eq(f(x), 1/(C1*x + 1))],
+        'XFAIL': ['separable_reduced']
+    },
+
+    'bernoulli_02': {
+        'eq': f(x).diff(x) - y*f(x),
+        'sol': [Eq(f(x), C1*exp(x*y))]
+    },
+
+    'bernoulli_03': {
+        'eq': f(x)*f(x).diff(x) - 1,
+        'sol': [Eq(f(x), -sqrt(C1 + 2*x)), Eq(f(x), sqrt(C1 + 2*x))]
+    },
+    }
+    }
+
+
+@_add_example_keys
+def _get_examples_ode_sol_riccati():
+    # Type: Riccati special alpha = -2, a*dy/dx + b*y**2 + c*y/x +d/x**2
+    return {
+            'hint': "Riccati_special_minus2",
+            'func': f(x),
+            'examples':{
+    'riccati_01': {
+        'eq': 2*f(x).diff(x) + f(x)**2 - f(x)/x + 3*x**(-2),
+        'sol': [Eq(f(x), (-sqrt(3)*tan(C1 + sqrt(3)*log(x)/4) + 3)/(2*x))],
+    },
+    },
+    }
+
+
+@_add_example_keys
+def _get_examples_ode_sol_1st_rational_riccati():
+    # Type: 1st Order Rational Riccati, dy/dx = a + b*y + c*y**2,
+    # a, b, c are rational functions of x
+    return {
+            'hint': "1st_rational_riccati",
+            'func': f(x),
+            'examples':{
+    # a(x) is a constant
+    "rational_riccati_01": {
+        "eq": Eq(f(x).diff(x) + f(x)**2 - 2, 0),
+        "sol": [Eq(f(x), sqrt(2)*(-C1 - exp(2*sqrt(2)*x))/(C1 - exp(2*sqrt(2)*x)))]
+    },
+    # a(x) is a constant
+    "rational_riccati_02": {
+        "eq": f(x)**2 + Derivative(f(x), x) + 4*f(x)/x + 2/x**2,
+        "sol": [Eq(f(x), (-2*C1 - x)/(x*(C1 + x)))]
+    },
+    # a(x) is a constant
+    "rational_riccati_03": {
+        "eq": 2*x**2*Derivative(f(x), x) - x*(4*f(x) + Derivative(f(x), x) - 4) + (f(x) - 1)*f(x),
+        "sol": [Eq(f(x), (C1 + 2*x**2)/(C1 + x))]
+    },
+    # Constant coefficients
+    "rational_riccati_04": {
+        "eq": f(x).diff(x) - 6 - 5*f(x) - f(x)**2,
+        "sol": [Eq(f(x), (-2*C1 + 3*exp(x))/(C1 - exp(x)))]
+    },
+    # One pole of multiplicity 2
+    "rational_riccati_05": {
+        "eq": x**2 - (2*x + 1/x)*f(x) + f(x)**2 + Derivative(f(x), x),
+        "sol": [Eq(f(x), x*(C1 + x**2 + 1)/(C1 + x**2 - 1))]
+    },
+    # One pole of multiplicity 2
+    "rational_riccati_06": {
+        "eq": x**4*Derivative(f(x), x) + x**2 - x*(2*f(x)**2 + Derivative(f(x), x)) + f(x),
+        "sol": [Eq(f(x), x*(C1*x - x + 1)/(C1 + x**2 - 1))]
+    },
+    # Multiple poles of multiplicity 2
+    "rational_riccati_07": {
+        "eq": -f(x)**2 + Derivative(f(x), x) + (15*x**2 - 20*x + 7)/((x - 1)**2*(2*x \
+            - 1)**2),
+        "sol": [Eq(f(x), (9*C1*x - 6*C1 - 15*x**5 + 60*x**4 - 94*x**3 + 72*x**2 - \
+            33*x + 8)/(6*C1*x**2 - 9*C1*x + 3*C1 + 6*x**6 - 29*x**5 + 57*x**4 - \
+            58*x**3 + 28*x**2 - 3*x - 1))]
+    },
+    # Imaginary poles
+    "rational_riccati_08": {
+        "eq": Derivative(f(x), x) + (3*x**2 + 1)*f(x)**2/x + (6*x**2 - x + 3)*f(x)/(x*(x \
+            - 1)) + (3*x**2 - 2*x + 2)/(x*(x - 1)**2),
+        "sol": [Eq(f(x), (-C1 - x**3 + x**2 - 2*x + 1)/(C1*x - C1 + x**4 - x**3 + x**2 - \
+            2*x + 1))],
+    },
+    # Imaginary coefficients in equation
+    "rational_riccati_09": {
+        "eq": Derivative(f(x), x) - 2*I*(f(x)**2 + 1)/x,
+        "sol": [Eq(f(x), (-I*C1 + I*x**4 + I)/(C1 + x**4 - 1))]
+    },
+    # Regression: linsolve returning empty solution
+    # Large value of m (> 10)
+    "rational_riccati_10": {
+        "eq": Eq(Derivative(f(x), x), x*f(x)/(S(3)/2 - 2*x) + (x/2 - S(1)/3)*f(x)**2/\
+            (2*x/3 - S(1)/2) - S(5)/4 + (281*x**2 - 1260*x + 756)/(16*x**3 - 12*x**2)),
+        "sol": [Eq(f(x), (40*C1*x**14 + 28*C1*x**13 + 420*C1*x**12 + 2940*C1*x**11 + \
+            18480*C1*x**10 + 103950*C1*x**9 + 519750*C1*x**8 + 2286900*C1*x**7 + \
+            8731800*C1*x**6 + 28378350*C1*x**5 + 76403250*C1*x**4 + 163721250*C1*x**3 \
+            + 261954000*C1*x**2 + 278326125*C1*x + 147349125*C1 + x*exp(2*x) - 9*exp(2*x) \
+            )/(x*(24*C1*x**13 + 140*C1*x**12 + 840*C1*x**11 + 4620*C1*x**10 + 23100*C1*x**9 \
+            + 103950*C1*x**8 + 415800*C1*x**7 + 1455300*C1*x**6 + 4365900*C1*x**5 + \
+            10914750*C1*x**4 + 21829500*C1*x**3 + 32744250*C1*x**2 + 32744250*C1*x + \
+            16372125*C1 - exp(2*x))))]
+    }
+    }
+    }
+
+
+
+@_add_example_keys
+def _get_examples_ode_sol_1st_linear():
+    # Type: first order linear form f'(x)+p(x)f(x)=q(x)
+    return {
+            'hint': "1st_linear",
+            'func': f(x),
+            'examples':{
+    'linear_01': {
+        'eq': Eq(f(x).diff(x) + x*f(x), x**2),
+        'sol': [Eq(f(x), (C1 + x*exp(x**2/2)- sqrt(2)*sqrt(pi)*erfi(sqrt(2)*x/2)/2)*exp(-x**2/2))],
+    },
+    },
+    }
+
+
+@_add_example_keys
+def _get_examples_ode_sol_factorable():
+    """ some hints are marked as xfail for examples because they missed additional algebraic solution
+    which could be found by Factorable hint. Fact_01 raise exception for
+    nth_linear_constant_coeff_undetermined_coefficients"""
+
+    y = Dummy('y')
+    a0,a1,a2,a3,a4 = symbols('a0, a1, a2, a3, a4')
+    return {
+            'hint': "factorable",
+            'func': f(x),
+            'examples':{
+    'fact_01': {
+        'eq': f(x) + f(x)*f(x).diff(x),
+        'sol': [Eq(f(x), 0), Eq(f(x), C1 - x)],
+        'XFAIL': ['separable', '1st_exact', '1st_linear', 'Bernoulli', '1st_homogeneous_coeff_best',
+        '1st_homogeneous_coeff_subs_indep_div_dep', '1st_homogeneous_coeff_subs_dep_div_indep',
+        'lie_group', 'nth_linear_euler_eq_nonhomogeneous_undetermined_coefficients',
+        'nth_linear_constant_coeff_variation_of_parameters',
+        'nth_linear_euler_eq_nonhomogeneous_variation_of_parameters',
+        'nth_linear_constant_coeff_undetermined_coefficients']
+    },
+
+    'fact_02': {
+        'eq': f(x)*(f(x).diff(x)+f(x)*x+2),
+        'sol': [Eq(f(x), (C1 - sqrt(2)*sqrt(pi)*erfi(sqrt(2)*x/2))*exp(-x**2/2)), Eq(f(x), 0)],
+        'XFAIL': ['Bernoulli', '1st_linear', 'lie_group']
+    },
+
+    'fact_03': {
+        'eq': (f(x).diff(x)+f(x)*x**2)*(f(x).diff(x, 2) + x*f(x)),
+        'sol':  [Eq(f(x), C1*airyai(-x) + C2*airybi(-x)),Eq(f(x), C1*exp(-x**3/3))]
+    },
+
+    'fact_04': {
+        'eq': (f(x).diff(x)+f(x)*x**2)*(f(x).diff(x, 2) + f(x)),
+        'sol': [Eq(f(x), C1*exp(-x**3/3)), Eq(f(x), C1*sin(x) + C2*cos(x))]
+    },
+
+    'fact_05': {
+        'eq': (f(x).diff(x)**2-1)*(f(x).diff(x)**2-4),
+        'sol': [Eq(f(x), C1 - x), Eq(f(x), C1 + x), Eq(f(x), C1 + 2*x), Eq(f(x), C1 - 2*x)]
+    },
+
+    'fact_06': {
+        'eq': (f(x).diff(x, 2)-exp(f(x)))*f(x).diff(x),
+        'sol': [
+            Eq(f(x), log(-C1/(cos(sqrt(-C1)*(C2 + x)) + 1))),
+            Eq(f(x), log(-C1/(cos(sqrt(-C1)*(C2 - x)) + 1))),
+            Eq(f(x), C1)
+        ],
+        'slow': True,
+    },
+
+    'fact_07': {
+        'eq': (f(x).diff(x)**2-1)*(f(x)*f(x).diff(x)-1),
+        'sol': [Eq(f(x), C1 - x), Eq(f(x), -sqrt(C1 + 2*x)),Eq(f(x), sqrt(C1 + 2*x)), Eq(f(x), C1 + x)]
+    },
+
+    'fact_08': {
+        'eq': Derivative(f(x), x)**4 - 2*Derivative(f(x), x)**2 + 1,
+        'sol': [Eq(f(x), C1 - x), Eq(f(x), C1 + x)]
+    },
+
+    'fact_09': {
+        'eq': f(x)**2*Derivative(f(x), x)**6 - 2*f(x)**2*Derivative(f(x),
+         x)**4 + f(x)**2*Derivative(f(x), x)**2 - 2*f(x)*Derivative(f(x),
+         x)**5 + 4*f(x)*Derivative(f(x), x)**3 - 2*f(x)*Derivative(f(x),
+         x) + Derivative(f(x), x)**4 - 2*Derivative(f(x), x)**2 + 1,
+        'sol': [
+            Eq(f(x), C1 - x), Eq(f(x), -sqrt(C1 + 2*x)),
+            Eq(f(x), sqrt(C1 + 2*x)), Eq(f(x), C1 + x)
+        ]
+    },
+
+    'fact_10': {
+        'eq': x**4*f(x)**2 + 2*x**4*f(x)*Derivative(f(x), (x, 2)) + x**4*Derivative(f(x),
+         (x, 2))**2  + 2*x**3*f(x)*Derivative(f(x), x) + 2*x**3*Derivative(f(x),
+         x)*Derivative(f(x), (x, 2)) - 7*x**2*f(x)**2 - 7*x**2*f(x)*Derivative(f(x),
+         (x, 2)) + x**2*Derivative(f(x), x)**2 - 7*x*f(x)*Derivative(f(x), x) + 12*f(x)**2,
+        'sol': [
+            Eq(f(x), C1*besselj(2, x) + C2*bessely(2, x)),
+            Eq(f(x), C1*besselj(sqrt(3), x) + C2*bessely(sqrt(3), x))
+        ],
+        'slow': True,
+    },
+
+    'fact_11': {
+        'eq': (f(x).diff(x, 2)-exp(f(x)))*(f(x).diff(x, 2)+exp(f(x))),
+        'sol': [
+            Eq(f(x), log(C1/(cos(C1*sqrt(-1/C1)*(C2 + x)) - 1))),
+            Eq(f(x), log(C1/(cos(C1*sqrt(-1/C1)*(C2 - x)) - 1))),
+            Eq(f(x), log(C1/(1 - cos(C1*sqrt(-1/C1)*(C2 + x))))),
+            Eq(f(x), log(C1/(1 - cos(C1*sqrt(-1/C1)*(C2 - x)))))
+        ],
+        'dsolve_too_slow': True,
+    },
+
+    #Below examples were added for the issue: https://github.com/sympy/sympy/issues/15889
+    'fact_12': {
+        'eq': exp(f(x).diff(x))-f(x)**2,
+        'sol': [Eq(NonElementaryIntegral(1/log(y**2), (y, f(x))), C1 + x)],
+        'XFAIL': ['lie_group'] #It shows not implemented error for lie_group.
+    },
+
+    'fact_13': {
+        'eq': f(x).diff(x)**2 - f(x)**3,
+        'sol': [Eq(f(x), 4/(C1**2 - 2*C1*x + x**2))],
+        'XFAIL': ['lie_group'] #It shows not implemented error for lie_group.
+    },
+
+    'fact_14': {
+        'eq': f(x).diff(x)**2 - f(x),
+        'sol': [Eq(f(x), C1**2/4 - C1*x/2 + x**2/4)]
+    },
+
+    'fact_15': {
+        'eq': f(x).diff(x)**2 - f(x)**2,
+        'sol': [Eq(f(x), C1*exp(x)), Eq(f(x), C1*exp(-x))]
+    },
+
+    'fact_16': {
+        'eq': f(x).diff(x)**2 - f(x)**3,
+        'sol': [Eq(f(x), 4/(C1**2 - 2*C1*x + x**2))],
+    },
+
+    # kamke ode 1.1
+    'fact_17': {
+        'eq': f(x).diff(x)-(a4*x**4 + a3*x**3 + a2*x**2 + a1*x + a0)**(-1/2),
+        'sol': [Eq(f(x), C1 + Integral(1/sqrt(a0 + a1*x + a2*x**2 + a3*x**3 + a4*x**4), x))],
+        'slow': True
+    },
+
+    # This is from issue: https://github.com/sympy/sympy/issues/9446
+    'fact_18':{
+        'eq': Eq(f(2 * x), sin(Derivative(f(x)))),
+        'sol': [Eq(f(x), C1 + Integral(pi - asin(f(2*x)), x)), Eq(f(x), C1 + Integral(asin(f(2*x)), x))],
+        'checkodesol_XFAIL':True
+    },
+
+    # This is from issue: https://github.com/sympy/sympy/issues/7093
+    'fact_19': {
+        'eq': Derivative(f(x), x)**2 - x**3,
+        'sol': [Eq(f(x), C1 - 2*x**Rational(5,2)/5), Eq(f(x), C1 + 2*x**Rational(5,2)/5)],
+    },
+
+    'fact_20': {
+        'eq': x*f(x).diff(x, 2) - x*f(x),
+        'sol': [Eq(f(x), C1*exp(-x) + C2*exp(x))],
+    },
+    }
+    }
+
+
+
+@_add_example_keys
+def _get_examples_ode_sol_almost_linear():
+    from sympy.functions.special.error_functions import Ei
+    A = Symbol('A', positive=True)
+    f = Function('f')
+    d = f(x).diff(x)
+
+    return {
+            'hint': "almost_linear",
+            'func': f(x),
+            'examples':{
+    'almost_lin_01': {
+        'eq': x**2*f(x)**2*d + f(x)**3 + 1,
+        'sol': [Eq(f(x), (C1*exp(3/x) - 1)**Rational(1, 3)),
+        Eq(f(x), (-1 - sqrt(3)*I)*(C1*exp(3/x) - 1)**Rational(1, 3)/2),
+        Eq(f(x), (-1 + sqrt(3)*I)*(C1*exp(3/x) - 1)**Rational(1, 3)/2)],
+
+    },
+
+    'almost_lin_02': {
+        'eq': x*f(x)*d + 2*x*f(x)**2 + 1,
+        'sol': [Eq(f(x), -sqrt((C1 - 2*Ei(4*x))*exp(-4*x))), Eq(f(x), sqrt((C1 - 2*Ei(4*x))*exp(-4*x)))]
+    },
+
+    'almost_lin_03': {
+        'eq':  x*d + x*f(x) + 1,
+        'sol': [Eq(f(x), (C1 - Ei(x))*exp(-x))]
+    },
+
+    'almost_lin_04': {
+        'eq': x*exp(f(x))*d + exp(f(x)) + 3*x,
+        'sol': [Eq(f(x), log(C1/x - x*Rational(3, 2)))],
+    },
+
+    'almost_lin_05': {
+        'eq': x + A*(x + diff(f(x), x) + f(x)) + diff(f(x), x) + f(x) + 2,
+        'sol': [Eq(f(x), (C1 + Piecewise(
+        (x, Eq(A + 1, 0)), ((-A*x + A - x - 1)*exp(x)/(A + 1), True)))*exp(-x))],
+    },
+    }
+    }
+
+
+@_add_example_keys
+def _get_examples_ode_sol_liouville():
+    n = Symbol('n')
+    _y = Dummy('y')
+    return {
+            'hint': "Liouville",
+            'func': f(x),
+            'examples':{
+    'liouville_01': {
+        'eq': diff(f(x), x)/x + diff(f(x), x, x)/2 - diff(f(x), x)**2/2,
+        'sol': [Eq(f(x), log(x/(C1 + C2*x)))],
+
+    },
+
+    'liouville_02': {
+        'eq': diff(x*exp(-f(x)), x, x),
+        'sol': [Eq(f(x), log(x/(C1 + C2*x)))]
+    },
+
+    'liouville_03': {
+        'eq':  ((diff(f(x), x)/x + diff(f(x), x, x)/2 - diff(f(x), x)**2/2)*exp(-f(x))/exp(f(x))).expand(),
+        'sol': [Eq(f(x), log(x/(C1 + C2*x)))]
+    },
+
+    'liouville_04': {
+        'eq': diff(f(x), x, x) + 1/f(x)*(diff(f(x), x))**2 + 1/x*diff(f(x), x),
+        'sol': [Eq(f(x), -sqrt(C1 + C2*log(x))), Eq(f(x), sqrt(C1 + C2*log(x)))],
+    },
+
+    'liouville_05': {
+        'eq': x*diff(f(x), x, x) + x/f(x)*diff(f(x), x)**2 + x*diff(f(x), x),
+        'sol': [Eq(f(x), -sqrt(C1 + C2*exp(-x))), Eq(f(x), sqrt(C1 + C2*exp(-x)))],
+    },
+
+    'liouville_06': {
+        'eq': Eq((x*exp(f(x))).diff(x, x), 0),
+        'sol': [Eq(f(x), log(C1 + C2/x))],
+    },
+
+    'liouville_07': {
+        'eq': (diff(f(x), x)/x + diff(f(x), x, x)/2 - diff(f(x), x)**2/2)*exp(-f(x))/exp(f(x)),
+        'sol': [Eq(f(x), log(x/(C1 + C2*x)))],
+    },
+
+    'liouville_08': {
+        'eq': x**2*diff(f(x),x) + (n*f(x) + f(x)**2)*diff(f(x),x)**2 + diff(f(x), (x, 2)),
+        'sol': [Eq(C1 + C2*lowergamma(Rational(1,3), x**3/3) + NonElementaryIntegral(exp(_y**3/3)*exp(_y**2*n/2), (_y, f(x))), 0)],
+    },
+    }
+    }
+
+
+@_add_example_keys
+def _get_examples_ode_sol_nth_algebraic():
+    M, m, r, t = symbols('M m r t')
+    phi = Function('phi')
+    k = Symbol('k')
+    # This one needs a substitution f' = g.
+    # 'algeb_12': {
+    #     'eq': -exp(x) + (x*Derivative(f(x), (x, 2)) + Derivative(f(x), x))/x,
+    #     'sol': [Eq(f(x), C1 + C2*log(x) + exp(x) - Ei(x))],
+    # },
+    return {
+            'hint': "nth_algebraic",
+            'func': f(x),
+            'examples':{
+    'algeb_01': {
+        'eq': f(x) * f(x).diff(x) * f(x).diff(x, x) * (f(x) - 1) * (f(x).diff(x) - x),
+        'sol': [Eq(f(x), C1 + x**2/2), Eq(f(x), C1 + C2*x)]
+    },
+
+    'algeb_02': {
+        'eq': f(x) * f(x).diff(x) * f(x).diff(x, x) * (f(x) - 1),
+        'sol': [Eq(f(x), C1 + C2*x)]
+    },
+
+    'algeb_03': {
+        'eq': f(x) * f(x).diff(x) * f(x).diff(x, x),
+        'sol': [Eq(f(x), C1 + C2*x)]
+    },
+
+    'algeb_04': {
+        'eq': Eq(-M * phi(t).diff(t),
+         Rational(3, 2) * m * r**2 * phi(t).diff(t) * phi(t).diff(t,t)),
+        'sol': [Eq(phi(t), C1), Eq(phi(t), C1 + C2*t - M*t**2/(3*m*r**2))],
+        'func': phi(t)
+    },
+
+    'algeb_05': {
+        'eq': (1 - sin(f(x))) * f(x).diff(x),
+        'sol': [Eq(f(x), C1)],
+        'XFAIL': ['separable']  #It raised exception.
+    },
+
+    'algeb_06': {
+        'eq': (diff(f(x)) - x)*(diff(f(x)) + x),
+        'sol': [Eq(f(x), C1 - x**2/2), Eq(f(x), C1 + x**2/2)]
+    },
+
+    'algeb_07': {
+        'eq': Eq(Derivative(f(x), x), Derivative(g(x), x)),
+        'sol': [Eq(f(x), C1 + g(x))],
+    },
+
+    'algeb_08': {
+        'eq': f(x).diff(x) - C1,   #this example is from issue 15999
+        'sol': [Eq(f(x), C1*x + C2)],
+    },
+
+    'algeb_09': {
+        'eq': f(x)*f(x).diff(x),
+        'sol': [Eq(f(x), C1)],
+    },
+
+    'algeb_10': {
+        'eq': (diff(f(x)) - x)*(diff(f(x)) + x),
+        'sol': [Eq(f(x), C1 - x**2/2), Eq(f(x), C1 + x**2/2)],
+    },
+
+    'algeb_11': {
+        'eq': f(x) + f(x)*f(x).diff(x),
+        'sol': [Eq(f(x), 0), Eq(f(x), C1 - x)],
+        'XFAIL': ['separable', '1st_exact', '1st_linear', 'Bernoulli', '1st_homogeneous_coeff_best',
+         '1st_homogeneous_coeff_subs_indep_div_dep', '1st_homogeneous_coeff_subs_dep_div_indep',
+         'lie_group', 'nth_linear_constant_coeff_undetermined_coefficients',
+         'nth_linear_euler_eq_nonhomogeneous_undetermined_coefficients',
+         'nth_linear_constant_coeff_variation_of_parameters',
+         'nth_linear_euler_eq_nonhomogeneous_variation_of_parameters']
+         #nth_linear_constant_coeff_undetermined_coefficients raises exception rest all of them misses a solution.
+    },
+
+    'algeb_12': {
+        'eq': Derivative(x*f(x), x, x, x),
+        'sol': [Eq(f(x), (C1 + C2*x + C3*x**2) / x)],
+        'XFAIL': ['nth_algebraic']  # It passes only when prep=False is set in dsolve.
+    },
+
+    'algeb_13': {
+        'eq': Eq(Derivative(x*Derivative(f(x), x), x)/x, exp(x)),
+        'sol': [Eq(f(x), C1 + C2*log(x) + exp(x) - Ei(x))],
+        'XFAIL': ['nth_algebraic']  # It passes only when prep=False is set in dsolve.
+    },
+
+     # These are simple tests from the old ode module example 14-18
+    'algeb_14': {
+        'eq': Eq(f(x).diff(x), 0),
+        'sol': [Eq(f(x), C1)],
+    },
+
+    'algeb_15': {
+        'eq': Eq(3*f(x).diff(x) - 5, 0),
+        'sol': [Eq(f(x), C1 + x*Rational(5, 3))],
+    },
+
+    'algeb_16': {
+        'eq': Eq(3*f(x).diff(x), 5),
+        'sol': [Eq(f(x), C1 + x*Rational(5, 3))],
+    },
+
+    # Type: 2nd order, constant coefficients (two complex roots)
+    'algeb_17': {
+        'eq': Eq(3*f(x).diff(x) - 1, 0),
+        'sol': [Eq(f(x), C1 + x/3)],
+    },
+
+    'algeb_18': {
+        'eq': Eq(x*f(x).diff(x) - 1, 0),
+        'sol': [Eq(f(x), C1 + log(x))],
+    },
+
+    # https://github.com/sympy/sympy/issues/6989
+    'algeb_19': {
+        'eq': f(x).diff(x) - x*exp(-k*x),
+        'sol': [Eq(f(x), C1 + Piecewise(((-k*x - 1)*exp(-k*x)/k**2, Ne(k**2, 0)),(x**2/2, True)))],
+    },
+
+    'algeb_20': {
+        'eq': -f(x).diff(x) + x*exp(-k*x),
+        'sol': [Eq(f(x), C1 + Piecewise(((-k*x - 1)*exp(-k*x)/k**2, Ne(k**2, 0)),(x**2/2, True)))],
+    },
+
+    # https://github.com/sympy/sympy/issues/10867
+    'algeb_21': {
+        'eq': Eq(g(x).diff(x).diff(x), (x-2)**2 + (x-3)**3),
+        'sol': [Eq(g(x), C1 + C2*x + x**5/20 - 2*x**4/3 + 23*x**3/6 - 23*x**2/2)],
+        'func': g(x),
+    },
+
+    # https://github.com/sympy/sympy/issues/13691
+    'algeb_22': {
+        'eq': f(x).diff(x) - C1*g(x).diff(x),
+        'sol': [Eq(f(x), C2 + C1*g(x))],
+        'func': f(x),
+    },
+
+    # https://github.com/sympy/sympy/issues/4838
+    'algeb_23': {
+        'eq': f(x).diff(x) - 3*C1 - 3*x**2,
+        'sol': [Eq(f(x), C2 + 3*C1*x + x**3)],
+    },
+    }
+    }
+
+
+@_add_example_keys
+def _get_examples_ode_sol_nth_order_reducible():
+    return {
+            'hint': "nth_order_reducible",
+            'func': f(x),
+            'examples':{
+    'reducible_01': {
+        'eq': Eq(x*Derivative(f(x), x)**2 + Derivative(f(x), x, 2), 0),
+        'sol': [Eq(f(x),C1 - sqrt(-1/C2)*log(-C2*sqrt(-1/C2) + x) +
+        sqrt(-1/C2)*log(C2*sqrt(-1/C2) + x))],
+        'slow': True,
+    },
+
+    'reducible_02': {
+        'eq': -exp(x) + (x*Derivative(f(x), (x, 2)) + Derivative(f(x), x))/x,
+        'sol': [Eq(f(x), C1 + C2*log(x) + exp(x) - Ei(x))],
+        'slow': True,
+    },
+
+    'reducible_03': {
+        'eq': Eq(sqrt(2) * f(x).diff(x,x,x) + f(x).diff(x), 0),
+        'sol': [Eq(f(x), C1 + C2*sin(2**Rational(3, 4)*x/2) + C3*cos(2**Rational(3, 4)*x/2))],
+        'slow': True,
+    },
+
+    'reducible_04': {
+        'eq': f(x).diff(x, 2) + 2*f(x).diff(x),
+        'sol': [Eq(f(x), C1 + C2*exp(-2*x))],
+    },
+
+    'reducible_05': {
+        'eq': f(x).diff(x, 3) + f(x).diff(x, 2) - 6*f(x).diff(x),
+        'sol': [Eq(f(x), C1 + C2*exp(-3*x) + C3*exp(2*x))],
+        'slow': True,
+    },
+
+    'reducible_06': {
+        'eq': f(x).diff(x, 4) - f(x).diff(x, 3) - 4*f(x).diff(x, 2) + \
+        4*f(x).diff(x),
+        'sol': [Eq(f(x), C1 + C2*exp(-2*x) + C3*exp(x) + C4*exp(2*x))],
+        'slow': True,
+    },
+
+    'reducible_07': {
+        'eq': f(x).diff(x, 4) + 3*f(x).diff(x, 3),
+        'sol': [Eq(f(x), C1 + C2*x + C3*x**2 + C4*exp(-3*x))],
+        'slow': True,
+    },
+
+    'reducible_08': {
+        'eq': f(x).diff(x, 4) - 2*f(x).diff(x, 2),
+        'sol': [Eq(f(x), C1 + C2*x + C3*exp(-sqrt(2)*x) + C4*exp(sqrt(2)*x))],
+        'slow': True,
+    },
+
+    'reducible_09': {
+        'eq': f(x).diff(x, 4) + 4*f(x).diff(x, 2),
+        'sol': [Eq(f(x), C1 + C2*x + C3*sin(2*x) + C4*cos(2*x))],
+        'slow': True,
+    },
+
+    'reducible_10': {
+        'eq': f(x).diff(x, 5) + 2*f(x).diff(x, 3) + f(x).diff(x),
+        'sol': [Eq(f(x), C1 + C2*x*sin(x) + C2*cos(x) - C3*x*cos(x) + C3*sin(x) + C4*sin(x) + C5*cos(x))],
+        'slow': True,
+    },
+
+    'reducible_11': {
+        'eq': f(x).diff(x, 2) - f(x).diff(x)**3,
+        'sol': [Eq(f(x), C1 - sqrt(2)*sqrt(-1/(C2 + x))*(C2 + x)),
+        Eq(f(x), C1 + sqrt(2)*sqrt(-1/(C2 + x))*(C2 + x))],
+        'slow': True,
+    },
+
+    # Needs to be a way to know how to combine derivatives in the expression
+    'reducible_12': {
+        'eq': Derivative(x*f(x), x, x, x) + Derivative(f(x), x, x, x),
+        'sol': [Eq(f(x), C1 + C3/Mul(2, (x**2 + 2*x + 1), evaluate=False) +
+        x*(C2 + C3/Mul(2, (x**2 + 2*x + 1), evaluate=False)))], # 2-arg Mul!
+        'slow': True,
+    },
+    }
+    }
+
+
+
+@_add_example_keys
+def _get_examples_ode_sol_nth_linear_undetermined_coefficients():
+    # examples 3-27 below are from Ordinary Differential Equations,
+    #                     Tenenbaum and Pollard, pg. 231
+    g = exp(-x)
+    f2 = f(x).diff(x, 2)
+    c = 3*f(x).diff(x, 3) + 5*f2 + f(x).diff(x) - f(x) - x
+    t = symbols("t")
+    u = symbols("u",cls=Function)
+    R, L, C, E_0, alpha = symbols("R L C E_0 alpha",positive=True)
+    omega = Symbol('omega')
+    return {
+            'hint': "nth_linear_constant_coeff_undetermined_coefficients",
+            'func': f(x),
+            'examples':{
+    'undet_01': {
+        'eq': c - x*g,
+        'sol': [Eq(f(x), C3*exp(x/3) - x + (C1 + x*(C2 - x**2/24 - 3*x/32))*exp(-x) - 1)],
+        'slow': True,
+    },
+
+    'undet_02': {
+        'eq': c - g,
+        'sol': [Eq(f(x), C3*exp(x/3) - x + (C1 + x*(C2 - x/8))*exp(-x) - 1)],
+        'slow': True,
+    },
+
+    'undet_03': {
+        'eq': f2 + 3*f(x).diff(x) + 2*f(x) - 4,
+        'sol': [Eq(f(x), C1*exp(-2*x) + C2*exp(-x) + 2)],
+        'slow': True,
+    },
+
+    'undet_04': {
+        'eq': f2 + 3*f(x).diff(x) + 2*f(x) - 12*exp(x),
+        'sol': [Eq(f(x), C1*exp(-2*x) + C2*exp(-x) + 2*exp(x))],
+        'slow': True,
+    },
+
+    'undet_05': {
+        'eq': f2 + 3*f(x).diff(x) + 2*f(x) - exp(I*x),
+        'sol': [Eq(f(x), (S(3)/10 + I/10)*(C1*exp(-2*x) + C2*exp(-x) - I*exp(I*x)))],
+        'slow': True,
+    },
+
+    'undet_06': {
+        'eq': f2 + 3*f(x).diff(x) + 2*f(x) - sin(x),
+        'sol': [Eq(f(x), C1*exp(-2*x) + C2*exp(-x) + sin(x)/10 - 3*cos(x)/10)],
+        'slow': True,
+    },
+
+    'undet_07': {
+        'eq': f2 + 3*f(x).diff(x) + 2*f(x) - cos(x),
+        'sol': [Eq(f(x), C1*exp(-2*x) + C2*exp(-x) + 3*sin(x)/10 + cos(x)/10)],
+        'slow': True,
+    },
+
+    'undet_08': {
+        'eq': f2 + 3*f(x).diff(x) + 2*f(x) - (8 + 6*exp(x) + 2*sin(x)),
+        'sol': [Eq(f(x), C1*exp(-2*x) + C2*exp(-x) + exp(x) + sin(x)/5 - 3*cos(x)/5 + 4)],
+        'slow': True,
+    },
+
+    'undet_09': {
+        'eq': f2 + f(x).diff(x) + f(x) - x**2,
+        'sol': [Eq(f(x), -2*x + x**2 + (C1*sin(x*sqrt(3)/2) + C2*cos(x*sqrt(3)/2))*exp(-x/2))],
+        'slow': True,
+    },
+
+    'undet_10': {
+        'eq': f2 - 2*f(x).diff(x) - 8*f(x) - 9*x*exp(x) - 10*exp(-x),
+        'sol': [Eq(f(x), -x*exp(x) - 2*exp(-x) + C1*exp(-2*x) + C2*exp(4*x))],
+        'slow': True,
+    },
+
+    'undet_11': {
+        'eq': f2 - 3*f(x).diff(x) - 2*exp(2*x)*sin(x),
+        'sol': [Eq(f(x), C1 + C2*exp(3*x) - 3*exp(2*x)*sin(x)/5 - exp(2*x)*cos(x)/5)],
+        'slow': True,
+    },
+
+    'undet_12': {
+        'eq': f(x).diff(x, 4) - 2*f2 + f(x) - x + sin(x),
+        'sol': [Eq(f(x), x - sin(x)/4 + (C1 + C2*x)*exp(-x) + (C3 + C4*x)*exp(x))],
+        'slow': True,
+    },
+
+    'undet_13': {
+        'eq': f2 + f(x).diff(x) - x**2 - 2*x,
+        'sol': [Eq(f(x), C1 + x**3/3 + C2*exp(-x))],
+        'slow': True,
+    },
+
+    'undet_14': {
+        'eq': f2 + f(x).diff(x) - x - sin(2*x),
+        'sol': [Eq(f(x), C1 - x - sin(2*x)/5 - cos(2*x)/10 + x**2/2 + C2*exp(-x))],
+        'slow': True,
+    },
+
+    'undet_15': {
+        'eq': f2 + f(x) - 4*x*sin(x),
+        'sol': [Eq(f(x), (C1 - x**2)*cos(x) + (C2 + x)*sin(x))],
+        'slow': True,
+    },
+
+    'undet_16': {
+        'eq': f2 + 4*f(x) - x*sin(2*x),
+        'sol': [Eq(f(x), (C1 - x**2/8)*cos(2*x) + (C2 + x/16)*sin(2*x))],
+        'slow': True,
+    },
+
+    'undet_17': {
+        'eq': f2 + 2*f(x).diff(x) + f(x) - x**2*exp(-x),
+        'sol': [Eq(f(x), (C1 + x*(C2 + x**3/12))*exp(-x))],
+        'slow': True,
+    },
+
+    'undet_18': {
+        'eq': f(x).diff(x, 3) + 3*f2 + 3*f(x).diff(x) + f(x) - 2*exp(-x) + \
+        x**2*exp(-x),
+        'sol': [Eq(f(x), (C1 + x*(C2 + x*(C3 - x**3/60 + x/3)))*exp(-x))],
+        'slow': True,
+    },
+
+    'undet_19': {
+        'eq': f2 + 3*f(x).diff(x) + 2*f(x) - exp(-2*x) - x**2,
+        'sol': [Eq(f(x), C2*exp(-x) + x**2/2 - x*Rational(3,2) + (C1 - x)*exp(-2*x) + Rational(7,4))],
+        'slow': True,
+    },
+
+    'undet_20': {
+        'eq': f2 - 3*f(x).diff(x) + 2*f(x) - x*exp(-x),
+        'sol': [Eq(f(x), C1*exp(x) + C2*exp(2*x) + (6*x + 5)*exp(-x)/36)],
+        'slow': True,
+    },
+
+    'undet_21': {
+        'eq': f2 + f(x).diff(x) - 6*f(x) - x - exp(2*x),
+        'sol': [Eq(f(x), Rational(-1, 36) - x/6 + C2*exp(-3*x) + (C1 + x/5)*exp(2*x))],
+        'slow': True,
+    },
+
+    'undet_22': {
+        'eq': f2 + f(x) - sin(x) - exp(-x),
+        'sol': [Eq(f(x), C2*sin(x) + (C1 - x/2)*cos(x) + exp(-x)/2)],
+        'slow': True,
+    },
+
+    'undet_23': {
+        'eq': f(x).diff(x, 3) - 3*f2 + 3*f(x).diff(x) - f(x) - exp(x),
+        'sol': [Eq(f(x), (C1 + x*(C2 + x*(C3 + x/6)))*exp(x))],
+        'slow': True,
+    },
+
+    'undet_24': {
+        'eq': f2 + f(x) - S.Half - cos(2*x)/2,
+        'sol': [Eq(f(x), S.Half - cos(2*x)/6 + C1*sin(x) + C2*cos(x))],
+        'slow': True,
+    },
+
+    'undet_25': {
+        'eq': f(x).diff(x, 3) - f(x).diff(x) - exp(2*x)*(S.Half - cos(2*x)/2),
+        'sol': [Eq(f(x), C1 + C2*exp(-x) + C3*exp(x) + (-21*sin(2*x) + 27*cos(2*x) + 130)*exp(2*x)/1560)],
+        'slow': True,
+    },
+
+    #Note: 'undet_26' is referred in 'undet_37'
+    'undet_26': {
+        'eq': (f(x).diff(x, 5) + 2*f(x).diff(x, 3) + f(x).diff(x) - 2*x -
+        sin(x) - cos(x)),
+        'sol': [Eq(f(x), C1 + x**2 + (C2 + x*(C3 - x/8))*sin(x) + (C4 + x*(C5 + x/8))*cos(x))],
+        'slow': True,
+    },
+
+    'undet_27': {
+        'eq': f2 + f(x) - cos(x)/2 + cos(3*x)/2,
+        'sol': [Eq(f(x), cos(3*x)/16 + C2*cos(x) + (C1 + x/4)*sin(x))],
+        'slow': True,
+    },
+
+    'undet_28': {
+        'eq': f(x).diff(x) - 1,
+        'sol': [Eq(f(x), C1 + x)],
+        'slow': True,
+    },
+
+    # https://github.com/sympy/sympy/issues/19358
+    'undet_29': {
+        'eq': f2 + f(x).diff(x) + exp(x-C1),
+        'sol': [Eq(f(x), C2 + C3*exp(-x) - exp(-C1 + x)/2)],
+        'slow': True,
+    },
+
+    # https://github.com/sympy/sympy/issues/18408
+    'undet_30': {
+        'eq': f(x).diff(x, 3) - f(x).diff(x) - sinh(x),
+        'sol': [Eq(f(x), C1 + C2*exp(-x) + C3*exp(x) + x*sinh(x)/2)],
+    },
+
+    'undet_31': {
+        'eq': f(x).diff(x, 2) - 49*f(x) - sinh(3*x),
+        'sol': [Eq(f(x), C1*exp(-7*x) + C2*exp(7*x) - sinh(3*x)/40)],
+    },
+
+    'undet_32': {
+        'eq': f(x).diff(x, 3) - f(x).diff(x) - sinh(x) - exp(x),
+        'sol': [Eq(f(x), C1 + C3*exp(-x) + x*sinh(x)/2 + (C2 + x/2)*exp(x))],
+    },
+
+    # https://github.com/sympy/sympy/issues/5096
+    'undet_33': {
+        'eq': f(x).diff(x, x) + f(x) - x*sin(x - 2),
+        'sol': [Eq(f(x), C1*sin(x) + C2*cos(x) - x**2*cos(x - 2)/4 + x*sin(x - 2)/4)],
+    },
+
+    'undet_34': {
+        'eq': f(x).diff(x, 2) + f(x) - x**4*sin(x-1),
+        'sol': [ Eq(f(x), C1*sin(x) + C2*cos(x) - x**5*cos(x - 1)/10 + x**4*sin(x - 1)/4 + x**3*cos(x - 1)/2 - 3*x**2*sin(x - 1)/4 - 3*x*cos(x - 1)/4)],
+    },
+
+    'undet_35': {
+        'eq': f(x).diff(x, 2) - f(x) - exp(x - 1),
+        'sol': [Eq(f(x), C2*exp(-x) + (C1 + x*exp(-1)/2)*exp(x))],
+    },
+
+    'undet_36': {
+        'eq': f(x).diff(x, 2)+f(x)-(sin(x-2)+1),
+        'sol': [Eq(f(x), C1*sin(x) + C2*cos(x) - x*cos(x - 2)/2 + 1)],
+    },
+
+    # Equivalent to example_name 'undet_26'.
+    # This previously failed because the algorithm for undetermined coefficients
+    # didn't know to multiply exp(I*x) by sufficient x because it is linearly
+    # dependent on sin(x) and cos(x).
+    'undet_37': {
+        'eq': f(x).diff(x, 5) + 2*f(x).diff(x, 3) + f(x).diff(x) - 2*x - exp(I*x),
+        'sol': [Eq(f(x), C1 + x**2*(I*exp(I*x)/8 + 1) + (C2 + C3*x)*sin(x) + (C4 + C5*x)*cos(x))],
+    },
+
+    # https://github.com/sympy/sympy/issues/12623
+    'undet_38': {
+        'eq': Eq( u(t).diff(t,t) + R /L*u(t).diff(t) + 1/(L*C)*u(t), alpha),
+        'sol': [Eq(u(t), C*L*alpha + C2*exp(-t*(R + sqrt(C*R**2 - 4*L)/sqrt(C))/(2*L))
+        + C1*exp(t*(-R + sqrt(C*R**2 - 4*L)/sqrt(C))/(2*L)))],
+        'func': u(t)
+    },
+
+    'undet_39': {
+        'eq': Eq( L*C*u(t).diff(t,t) + R*C*u(t).diff(t) + u(t), E_0*exp(I*omega*t) ),
+        'sol': [Eq(u(t), C2*exp(-t*(R + sqrt(C*R**2 - 4*L)/sqrt(C))/(2*L))
+        + C1*exp(t*(-R + sqrt(C*R**2 - 4*L)/sqrt(C))/(2*L))
+        - E_0*exp(I*omega*t)/(C*L*omega**2 - I*C*R*omega - 1))],
+        'func': u(t),
+    },
+
+    # https://github.com/sympy/sympy/issues/6879
+    'undet_40': {
+        'eq': Eq(Derivative(f(x), x, 2) - 2*Derivative(f(x), x) + f(x), sin(x)),
+        'sol': [Eq(f(x), (C1 + C2*x)*exp(x) + cos(x)/2)],
+    },
+    }
+    }
+
+
+@_add_example_keys
+def _get_examples_ode_sol_separable():
+    # test_separable1-5 are from Ordinary Differential Equations, Tenenbaum and
+    # Pollard, pg. 55
+    t,a = symbols('a,t')
+    m = 96
+    g = 9.8
+    k = .2
+    f1 = g * m
+    v = Function('v')
+    return {
+            'hint': "separable",
+            'func': f(x),
+            'examples':{
+    'separable_01': {
+        'eq': f(x).diff(x) - f(x),
+        'sol': [Eq(f(x), C1*exp(x))],
+    },
+
+    'separable_02': {
+        'eq': x*f(x).diff(x) - f(x),
+        'sol': [Eq(f(x), C1*x)],
+    },
+
+    'separable_03': {
+        'eq': f(x).diff(x) + sin(x),
+        'sol': [Eq(f(x), C1 + cos(x))],
+    },
+
+    'separable_04': {
+        'eq': f(x)**2 + 1 - (x**2 + 1)*f(x).diff(x),
+        'sol': [Eq(f(x), tan(C1 + atan(x)))],
+    },
+
+    'separable_05': {
+        'eq': f(x).diff(x)/tan(x) - f(x) - 2,
+        'sol': [Eq(f(x), C1/cos(x) - 2)],
+    },
+
+    'separable_06': {
+        'eq': f(x).diff(x) * (1 - sin(f(x))) - 1,
+        'sol': [Eq(-x + f(x) + cos(f(x)), C1)],
+    },
+
+    'separable_07': {
+        'eq': f(x)*x**2*f(x).diff(x) - f(x)**3 - 2*x**2*f(x).diff(x),
+        'sol': [Eq(f(x), (-x - sqrt(x*(4*C1*x + x - 4)))/(C1*x - 1)/2),
+                Eq(f(x), (-x + sqrt(x*(4*C1*x + x - 4)))/(C1*x - 1)/2)],
+        'slow': True,
+    },
+
+    'separable_08': {
+        'eq': f(x)**2 - 1 - (2*f(x) + x*f(x))*f(x).diff(x),
+        'sol': [Eq(f(x), -sqrt(C1*x**2 + 4*C1*x + 4*C1 + 1)),
+        Eq(f(x), sqrt(C1*x**2 + 4*C1*x + 4*C1 + 1))],
+        'slow': True,
+    },
+
+    'separable_09': {
+        'eq': x*log(x)*f(x).diff(x) + sqrt(1 + f(x)**2),
+        'sol': [Eq(f(x), sinh(C1 - log(log(x))))],  #One more solution is f(x)=I
+        'slow': True,
+        'checkodesol_XFAIL': True,
+    },
+
+    'separable_10': {
+        'eq': exp(x + 1)*tan(f(x)) + cos(f(x))*f(x).diff(x),
+        'sol': [Eq(E*exp(x) + log(cos(f(x)) - 1)/2 - log(cos(f(x)) + 1)/2 + cos(f(x)), C1)],
+        'slow': True,
+    },
+
+    'separable_11': {
+        'eq': (x*cos(f(x)) + x**2*sin(f(x))*f(x).diff(x) - a**2*sin(f(x))*f(x).diff(x)),
+        'sol': [
+            Eq(f(x), -acos(C1*sqrt(-a**2 + x**2)) + 2*pi),
+            Eq(f(x), acos(C1*sqrt(-a**2 + x**2)))
+        ],
+        'slow': True,
+    },
+
+    'separable_12': {
+        'eq': f(x).diff(x) - f(x)*tan(x),
+        'sol': [Eq(f(x), C1/cos(x))],
+    },
+
+    'separable_13': {
+        'eq': (x - 1)*cos(f(x))*f(x).diff(x) - 2*x*sin(f(x)),
+        'sol': [
+            Eq(f(x), pi - asin(C1*(x**2 - 2*x + 1)*exp(2*x))),
+            Eq(f(x), asin(C1*(x**2 - 2*x + 1)*exp(2*x)))
+        ],
+    },
+
+    'separable_14': {
+        'eq': f(x).diff(x) - f(x)*log(f(x))/tan(x),
+        'sol': [Eq(f(x), exp(C1*sin(x)))],
+    },
+
+    'separable_15': {
+        'eq': x*f(x).diff(x) + (1 + f(x)**2)*atan(f(x)),
+        'sol': [Eq(f(x), tan(C1/x))],  #Two more solutions are f(x)=0 and f(x)=I
+        'slow': True,
+        'checkodesol_XFAIL': True,
+    },
+
+    'separable_16': {
+        'eq': f(x).diff(x) + x*(f(x) + 1),
+        'sol': [Eq(f(x), -1 + C1*exp(-x**2/2))],
+    },
+
+    'separable_17': {
+        'eq': exp(f(x)**2)*(x**2 + 2*x + 1) + (x*f(x) + f(x))*f(x).diff(x),
+        'sol': [
+            Eq(f(x), -sqrt(log(1/(C1 + x**2 + 2*x)))),
+            Eq(f(x), sqrt(log(1/(C1 + x**2 + 2*x))))
+        ],
+    },
+
+    'separable_18': {
+        'eq': f(x).diff(x) + f(x),
+        'sol': [Eq(f(x), C1*exp(-x))],
+    },
+
+    'separable_19': {
+        'eq': sin(x)*cos(2*f(x)) + cos(x)*sin(2*f(x))*f(x).diff(x),
+        'sol': [Eq(f(x), pi - acos(C1/cos(x)**2)/2), Eq(f(x), acos(C1/cos(x)**2)/2)],
+    },
+
+    'separable_20': {
+        'eq': (1 - x)*f(x).diff(x) - x*(f(x) + 1),
+        'sol': [Eq(f(x), (C1*exp(-x) - x + 1)/(x - 1))],
+    },
+
+    'separable_21': {
+        'eq': f(x)*diff(f(x), x) + x - 3*x*f(x)**2,
+        'sol': [Eq(f(x), -sqrt(3)*sqrt(C1*exp(3*x**2) + 1)/3),
+        Eq(f(x), sqrt(3)*sqrt(C1*exp(3*x**2) + 1)/3)],
+    },
+
+    'separable_22': {
+        'eq': f(x).diff(x) - exp(x + f(x)),
+        'sol': [Eq(f(x), log(-1/(C1 + exp(x))))],
+        'XFAIL': ['lie_group'] #It shows 'NoneType' object is not subscriptable for lie_group.
+    },
+
+    # https://github.com/sympy/sympy/issues/7081
+    'separable_23': {
+        'eq': x*(f(x).diff(x)) + 1 - f(x)**2,
+        'sol': [Eq(f(x), (-C1 - x**2)/(-C1 + x**2))],
+    },
+
+    # https://github.com/sympy/sympy/issues/10379
+    'separable_24': {
+        'eq': f(t).diff(t)-(1-51.05*y*f(t)),
+        'sol': [Eq(f(t), (0.019588638589618023*exp(y*(C1 - 51.049999999999997*t)) + 0.019588638589618023)/y)],
+        'func': f(t),
+    },
+
+    # https://github.com/sympy/sympy/issues/15999
+    'separable_25': {
+        'eq': f(x).diff(x) - C1*f(x),
+        'sol': [Eq(f(x), C2*exp(C1*x))],
+    },
+
+    'separable_26': {
+        'eq': f1 - k * (v(t) ** 2) - m * Derivative(v(t)),
+        'sol': [Eq(v(t), -68.585712797928991/tanh(C1 - 0.14288690166235204*t))],
+        'func': v(t),
+        'checkodesol_XFAIL': True,
+    },
+
+    #https://github.com/sympy/sympy/issues/22155
+    'separable_27': {
+        'eq': f(x).diff(x) - exp(f(x) - x),
+        'sol': [Eq(f(x), log(-exp(x)/(C1*exp(x) - 1)))],
+    }
+    }
+    }
+
+
+@_add_example_keys
+def _get_examples_ode_sol_1st_exact():
+    # Type: Exact differential equation, p(x,f) + q(x,f)*f' == 0,
+    # where dp/df == dq/dx
+    '''
+    Example 7 is an exact equation that fails under the exact engine. It is caught
+    by first order homogeneous albeit with a much contorted solution.  The
+    exact engine fails because of a poorly simplified integral of q(0,y)dy,
+    where q is the function multiplying f'.  The solutions should be
+    Eq(sqrt(x**2+f(x)**2)**3+y**3, C1).  The equation below is
+    equivalent, but it is so complex that checkodesol fails, and takes a long
+    time to do so.
+    '''
+    return {
+            'hint': "1st_exact",
+            'func': f(x),
+            'examples':{
+    '1st_exact_01': {
+        'eq': sin(x)*cos(f(x)) + cos(x)*sin(f(x))*f(x).diff(x),
+        'sol': [Eq(f(x), -acos(C1/cos(x)) + 2*pi), Eq(f(x), acos(C1/cos(x)))],
+        'slow': True,
+    },
+
+    '1st_exact_02': {
+        'eq': (2*x*f(x) + 1)/f(x) + (f(x) - x)/f(x)**2*f(x).diff(x),
+        'sol': [Eq(f(x), exp(C1 - x**2 + LambertW(-x*exp(-C1 + x**2))))],
+        'XFAIL': ['lie_group'], #It shows dsolve raises an exception: List index out of range for lie_group
+        'slow': True,
+        'checkodesol_XFAIL':True
+    },
+
+    '1st_exact_03': {
+        'eq': 2*x + f(x)*cos(x) + (2*f(x) + sin(x) - sin(f(x)))*f(x).diff(x),
+        'sol': [Eq(f(x)*sin(x) + cos(f(x)) + x**2 + f(x)**2, C1)],
+        'XFAIL': ['lie_group'], #It goes into infinite loop for lie_group.
+        'slow': True,
+    },
+
+    '1st_exact_04': {
+        'eq': cos(f(x)) - (x*sin(f(x)) - f(x)**2)*f(x).diff(x),
+        'sol': [Eq(x*cos(f(x)) + f(x)**3/3, C1)],
+        'slow': True,
+    },
+
+    '1st_exact_05': {
+        'eq': 2*x*f(x) + (x**2 + f(x)**2)*f(x).diff(x),
+        'sol': [Eq(x**2*f(x) + f(x)**3/3, C1)],
+        'slow': True,
+        'simplify_flag':False
+    },
+
+    # This was from issue: https://github.com/sympy/sympy/issues/11290
+    '1st_exact_06': {
+        'eq': cos(f(x)) - (x*sin(f(x)) - f(x)**2)*f(x).diff(x),
+        'sol': [Eq(x*cos(f(x)) + f(x)**3/3, C1)],
+        'simplify_flag':False
+    },
+
+    '1st_exact_07': {
+        'eq': x*sqrt(x**2 + f(x)**2) - (x**2*f(x)/(f(x) - sqrt(x**2 + f(x)**2)))*f(x).diff(x),
+        'sol': [Eq(log(x),
+        C1 - 9*sqrt(1 + f(x)**2/x**2)*asinh(f(x)/x)/(-27*f(x)/x +
+        27*sqrt(1 + f(x)**2/x**2)) - 9*sqrt(1 + f(x)**2/x**2)*
+        log(1 - sqrt(1 + f(x)**2/x**2)*f(x)/x + 2*f(x)**2/x**2)/
+        (-27*f(x)/x + 27*sqrt(1 + f(x)**2/x**2)) +
+        9*asinh(f(x)/x)*f(x)/(x*(-27*f(x)/x + 27*sqrt(1 + f(x)**2/x**2))) +
+        9*f(x)*log(1 - sqrt(1 + f(x)**2/x**2)*f(x)/x + 2*f(x)**2/x**2)/
+        (x*(-27*f(x)/x + 27*sqrt(1 + f(x)**2/x**2))))],
+        'slow': True,
+        'dsolve_too_slow':True
+    },
+
+    # Type: a(x)f'(x)+b(x)*f(x)+c(x)=0
+    '1st_exact_08': {
+        'eq': Eq(x**2*f(x).diff(x) + 3*x*f(x) - sin(x)/x, 0),
+        'sol': [Eq(f(x), (C1 - cos(x))/x**3)],
+    },
+
+    # these examples are from test_exact_enhancement
+    '1st_exact_09': {
+        'eq': f(x)/x**2 + ((f(x)*x - 1)/x)*f(x).diff(x),
+        'sol': [Eq(f(x), (i*sqrt(C1*x**2 + 1) + 1)/x) for i in (-1, 1)],
+    },
+
+    '1st_exact_10': {
+        'eq': (x*f(x) - 1) + f(x).diff(x)*(x**2 - x*f(x)),
+        'sol': [Eq(f(x), x - sqrt(C1 + x**2 - 2*log(x))), Eq(f(x), x + sqrt(C1 + x**2 - 2*log(x)))],
+    },
+
+    '1st_exact_11': {
+        'eq': (x + 2)*sin(f(x)) + f(x).diff(x)*x*cos(f(x)),
+        'sol': [Eq(f(x), -asin(C1*exp(-x)/x**2) + pi), Eq(f(x), asin(C1*exp(-x)/x**2))],
+    },
+    }
+    }
+
+
+@_add_example_keys
+def _get_examples_ode_sol_nth_linear_var_of_parameters():
+    g = exp(-x)
+    f2 = f(x).diff(x, 2)
+    c = 3*f(x).diff(x, 3) + 5*f2 + f(x).diff(x) - f(x) - x
+    return {
+            'hint': "nth_linear_constant_coeff_variation_of_parameters",
+            'func': f(x),
+            'examples':{
+    'var_of_parameters_01': {
+        'eq': c - x*g,
+        'sol': [Eq(f(x), C3*exp(x/3) - x + (C1 + x*(C2 - x**2/24 - 3*x/32))*exp(-x) - 1)],
+        'slow': True,
+    },
+
+    'var_of_parameters_02': {
+        'eq': c - g,
+        'sol': [Eq(f(x), C3*exp(x/3) - x + (C1 + x*(C2 - x/8))*exp(-x) - 1)],
+        'slow': True,
+    },
+
+    'var_of_parameters_03': {
+        'eq': f(x).diff(x) - 1,
+        'sol': [Eq(f(x), C1 + x)],
+        'slow': True,
+    },
+
+    'var_of_parameters_04': {
+        'eq': f2 + 3*f(x).diff(x) + 2*f(x) - 4,
+        'sol': [Eq(f(x), C1*exp(-2*x) + C2*exp(-x) + 2)],
+        'slow': True,
+    },
+
+    'var_of_parameters_05': {
+        'eq': f2 + 3*f(x).diff(x) + 2*f(x) - 12*exp(x),
+        'sol': [Eq(f(x), C1*exp(-2*x) + C2*exp(-x) + 2*exp(x))],
+        'slow': True,
+    },
+
+    'var_of_parameters_06': {
+        'eq': f2 - 2*f(x).diff(x) - 8*f(x) - 9*x*exp(x) - 10*exp(-x),
+        'sol': [Eq(f(x), -x*exp(x) - 2*exp(-x) + C1*exp(-2*x) + C2*exp(4*x))],
+        'slow': True,
+    },
+
+    'var_of_parameters_07': {
+        'eq': f2 + 2*f(x).diff(x) + f(x) - x**2*exp(-x),
+        'sol': [Eq(f(x), (C1 + x*(C2 + x**3/12))*exp(-x))],
+        'slow': True,
+    },
+
+    'var_of_parameters_08': {
+        'eq': f2 - 3*f(x).diff(x) + 2*f(x) - x*exp(-x),
+        'sol': [Eq(f(x), C1*exp(x) + C2*exp(2*x) + (6*x + 5)*exp(-x)/36)],
+        'slow': True,
+    },
+
+    'var_of_parameters_09': {
+        'eq': f(x).diff(x, 3) - 3*f2 + 3*f(x).diff(x) - f(x) - exp(x),
+        'sol': [Eq(f(x), (C1 + x*(C2 + x*(C3 + x/6)))*exp(x))],
+        'slow': True,
+    },
+
+    'var_of_parameters_10': {
+        'eq': f2 + 2*f(x).diff(x) + f(x) - exp(-x)/x,
+        'sol': [Eq(f(x), (C1 + x*(C2 + log(x)))*exp(-x))],
+        'slow': True,
+    },
+
+    'var_of_parameters_11': {
+        'eq': f2 + f(x) - 1/sin(x)*1/cos(x),
+        'sol': [Eq(f(x), (C1 + log(sin(x) - 1)/2 - log(sin(x) + 1)/2
+        )*cos(x) + (C2 + log(cos(x) - 1)/2 - log(cos(x) + 1)/2)*sin(x))],
+        'slow': True,
+    },
+
+    'var_of_parameters_12': {
+        'eq': f(x).diff(x, 4) - 1/x,
+        'sol': [Eq(f(x), C1 + C2*x + C3*x**2 + x**3*(C4 + log(x)/6))],
+        'slow': True,
+    },
+
+    # These were from issue: https://github.com/sympy/sympy/issues/15996
+    'var_of_parameters_13': {
+        'eq': f(x).diff(x, 5) + 2*f(x).diff(x, 3) + f(x).diff(x) - 2*x - exp(I*x),
+        'sol': [Eq(f(x), C1 + x**2 + (C2 + x*(C3 - x/8 + 3*exp(I*x)/2 + 3*exp(-I*x)/2) + 5*exp(2*I*x)/16 + 2*I*exp(I*x) - 2*I*exp(-I*x))*sin(x) + (C4 + x*(C5 + I*x/8 + 3*I*exp(I*x)/2 - 3*I*exp(-I*x)/2)
+        + 5*I*exp(2*I*x)/16 - 2*exp(I*x) - 2*exp(-I*x))*cos(x) - I*exp(I*x))],
+    },
+
+    'var_of_parameters_14': {
+        'eq': f(x).diff(x, 5) + 2*f(x).diff(x, 3) + f(x).diff(x) - exp(I*x),
+        'sol': [Eq(f(x), C1 + (C2 + x*(C3 - x/8) + 5*exp(2*I*x)/16)*sin(x) + (C4 + x*(C5 + I*x/8) + 5*I*exp(2*I*x)/16)*cos(x) - I*exp(I*x))],
+    },
+
+    # https://github.com/sympy/sympy/issues/14395
+    'var_of_parameters_15': {
+        'eq': Derivative(f(x), x, x) + 9*f(x) - sec(x),
+        'sol': [Eq(f(x), (C1 - x/3 + sin(2*x)/3)*sin(3*x) + (C2 + log(cos(x))
+        - 2*log(cos(x)**2)/3 + 2*cos(x)**2/3)*cos(3*x))],
+        'slow': True,
+    },
+    }
+    }
+
+
+@_add_example_keys
+def _get_examples_ode_sol_2nd_linear_bessel():
+    return {
+            'hint': "2nd_linear_bessel",
+            'func': f(x),
+            'examples':{
+    '2nd_lin_bessel_01': {
+        'eq': x**2*(f(x).diff(x, 2)) + x*(f(x).diff(x)) + (x**2 - 4)*f(x),
+        'sol': [Eq(f(x), C1*besselj(2, x) + C2*bessely(2, x))],
+    },
+
+    '2nd_lin_bessel_02': {
+        'eq': x**2*(f(x).diff(x, 2)) + x*(f(x).diff(x)) + (x**2 +25)*f(x),
+        'sol': [Eq(f(x), C1*besselj(5*I, x) + C2*bessely(5*I, x))],
+    },
+
+    '2nd_lin_bessel_03': {
+        'eq': x**2*(f(x).diff(x, 2)) + x*(f(x).diff(x)) + (x**2)*f(x),
+        'sol': [Eq(f(x), C1*besselj(0, x) + C2*bessely(0, x))],
+    },
+
+    '2nd_lin_bessel_04': {
+        'eq': x**2*(f(x).diff(x, 2)) + x*(f(x).diff(x)) + (81*x**2 -S(1)/9)*f(x),
+        'sol': [Eq(f(x), C1*besselj(S(1)/3, 9*x) + C2*bessely(S(1)/3, 9*x))],
+    },
+
+    '2nd_lin_bessel_05': {
+        'eq': x**2*(f(x).diff(x, 2)) + x*(f(x).diff(x)) + (x**4 - 4)*f(x),
+        'sol': [Eq(f(x), C1*besselj(1, x**2/2) + C2*bessely(1, x**2/2))],
+    },
+
+    '2nd_lin_bessel_06': {
+        'eq': x**2*(f(x).diff(x, 2)) + 2*x*(f(x).diff(x)) + (x**4 - 4)*f(x),
+        'sol': [Eq(f(x), (C1*besselj(sqrt(17)/4, x**2/2) + C2*bessely(sqrt(17)/4, x**2/2))/sqrt(x))],
+    },
+
+    '2nd_lin_bessel_07': {
+        'eq': x**2*(f(x).diff(x, 2)) + x*(f(x).diff(x)) + (x**2 - S(1)/4)*f(x),
+        'sol': [Eq(f(x), C1*besselj(S(1)/2, x) + C2*bessely(S(1)/2, x))],
+    },
+
+    '2nd_lin_bessel_08': {
+        'eq': x**2*(f(x).diff(x, 2)) - 3*x*(f(x).diff(x)) + (4*x + 4)*f(x),
+        'sol': [Eq(f(x), x**2*(C1*besselj(0, 4*sqrt(x)) + C2*bessely(0, 4*sqrt(x))))],
+    },
+
+    '2nd_lin_bessel_09': {
+        'eq': x*(f(x).diff(x, 2)) - f(x).diff(x) + 4*x**3*f(x),
+        'sol': [Eq(f(x), x*(C1*besselj(S(1)/2, x**2) + C2*bessely(S(1)/2, x**2)))],
+    },
+
+    '2nd_lin_bessel_10': {
+        'eq': (x-2)**2*(f(x).diff(x, 2)) - (x-2)*f(x).diff(x) + 4*(x-2)**2*f(x),
+        'sol': [Eq(f(x), (x - 2)*(C1*besselj(1, 2*x - 4) + C2*bessely(1, 2*x - 4)))],
+    },
+
+    # https://github.com/sympy/sympy/issues/4414
+    '2nd_lin_bessel_11': {
+        'eq': f(x).diff(x, x) + 2/x*f(x).diff(x) + f(x),
+        'sol': [Eq(f(x), (C1*besselj(S(1)/2, x) + C2*bessely(S(1)/2, x))/sqrt(x))],
+    },
+    '2nd_lin_bessel_12': {
+        'eq': x**2*f(x).diff(x, 2) + x*f(x).diff(x) + (a**2*x**2/c**2 - b**2)*f(x),
+        'sol': [Eq(f(x), C1*besselj(sqrt(b**2), x*sqrt(a**2/c**2)) + C2*bessely(sqrt(b**2), x*sqrt(a**2/c**2)))],
+    },
+    }
+    }
+
+
+@_add_example_keys
+def _get_examples_ode_sol_2nd_2F1_hypergeometric():
+    return {
+            'hint': "2nd_hypergeometric",
+            'func': f(x),
+            'examples':{
+    '2nd_2F1_hyper_01': {
+        'eq': x*(x-1)*f(x).diff(x, 2) + (S(3)/2 -2*x)*f(x).diff(x) + 2*f(x),
+        'sol': [Eq(f(x), C1*x**(S(5)/2)*hyper((S(3)/2, S(1)/2), (S(7)/2,), x) + C2*hyper((-1, -2), (-S(3)/2,), x))],
+    },
+
+    '2nd_2F1_hyper_02': {
+        'eq': x*(x-1)*f(x).diff(x, 2) + (S(7)/2*x)*f(x).diff(x) + f(x),
+        'sol': [Eq(f(x), (C1*(1 - x)**(S(5)/2)*hyper((S(1)/2, 2), (S(7)/2,), 1 - x) +
+          C2*hyper((-S(1)/2, -2), (-S(3)/2,), 1 - x))/(x - 1)**(S(5)/2))],
+    },
+
+    '2nd_2F1_hyper_03': {
+        'eq': x*(x-1)*f(x).diff(x, 2) + (S(3)+ S(7)/2*x)*f(x).diff(x) + f(x),
+        'sol': [Eq(f(x), (C1*(1 - x)**(S(11)/2)*hyper((S(1)/2, 2), (S(13)/2,), 1 - x) +
+          C2*hyper((-S(7)/2, -5), (-S(9)/2,), 1 - x))/(x - 1)**(S(11)/2))],
+    },
+
+    '2nd_2F1_hyper_04': {
+        'eq': -x**(S(5)/7)*(-416*x**(S(9)/7)/9 - 2385*x**(S(5)/7)/49 + S(298)*x/3)*f(x)/(196*(-x**(S(6)/7) +
+         x)**2*(x**(S(6)/7) + x)**2) + Derivative(f(x), (x, 2)),
+        'sol': [Eq(f(x), x**(S(45)/98)*(C1*x**(S(4)/49)*hyper((S(1)/3, -S(1)/2), (S(9)/7,), x**(S(2)/7)) +
+          C2*hyper((S(1)/21, -S(11)/14), (S(5)/7,), x**(S(2)/7)))/(x**(S(2)/7) - 1)**(S(19)/84))],
+        'checkodesol_XFAIL':True,
+    },
+    }
+    }
+
+@_add_example_keys
+def _get_examples_ode_sol_2nd_nonlinear_autonomous_conserved():
+    return {
+            'hint': "2nd_nonlinear_autonomous_conserved",
+            'func': f(x),
+            'examples': {
+    '2nd_nonlinear_autonomous_conserved_01': {
+        'eq': f(x).diff(x, 2) + exp(f(x)) + log(f(x)),
+        'sol': [
+            Eq(Integral(1/sqrt(C1 - 2*_u*log(_u) + 2*_u - 2*exp(_u)), (_u, f(x))), C2 + x),
+            Eq(Integral(1/sqrt(C1 - 2*_u*log(_u) + 2*_u - 2*exp(_u)), (_u, f(x))), C2 - x)
+        ],
+        'simplify_flag': False,
+    },
+    '2nd_nonlinear_autonomous_conserved_02': {
+        'eq': f(x).diff(x, 2) + cbrt(f(x)) + 1/f(x),
+        'sol': [
+            Eq(sqrt(2)*Integral(1/sqrt(2*C1 - 3*_u**Rational(4, 3) - 4*log(_u)), (_u, f(x))), C2 + x),
+            Eq(sqrt(2)*Integral(1/sqrt(2*C1 - 3*_u**Rational(4, 3) - 4*log(_u)), (_u, f(x))), C2 - x)
+        ],
+        'simplify_flag': False,
+    },
+    '2nd_nonlinear_autonomous_conserved_03': {
+        'eq': f(x).diff(x, 2) + sin(f(x)),
+        'sol': [
+            Eq(Integral(1/sqrt(C1 + 2*cos(_u)), (_u, f(x))), C2 + x),
+            Eq(Integral(1/sqrt(C1 + 2*cos(_u)), (_u, f(x))), C2 - x)
+        ],
+        'simplify_flag': False,
+    },
+    '2nd_nonlinear_autonomous_conserved_04': {
+        'eq': f(x).diff(x, 2) + cosh(f(x)),
+        'sol': [
+            Eq(Integral(1/sqrt(C1 - 2*sinh(_u)), (_u, f(x))), C2 + x),
+            Eq(Integral(1/sqrt(C1 - 2*sinh(_u)), (_u, f(x))), C2 - x)
+        ],
+        'simplify_flag': False,
+    },
+    '2nd_nonlinear_autonomous_conserved_05': {
+        'eq': f(x).diff(x, 2) + asin(f(x)),
+        'sol': [
+            Eq(Integral(1/sqrt(C1 - 2*_u*asin(_u) - 2*sqrt(1 - _u**2)), (_u, f(x))), C2 + x),
+            Eq(Integral(1/sqrt(C1 - 2*_u*asin(_u) - 2*sqrt(1 - _u**2)), (_u, f(x))), C2 - x)
+        ],
+        'simplify_flag': False,
+        'XFAIL': ['2nd_nonlinear_autonomous_conserved_Integral']
+    }
+    }
+    }
+
+
+@_add_example_keys
+def _get_examples_ode_sol_separable_reduced():
+    df = f(x).diff(x)
+    return {
+            'hint': "separable_reduced",
+            'func': f(x),
+            'examples':{
+    'separable_reduced_01': {
+        'eq': x* df  + f(x)* (1 / (x**2*f(x) - 1)),
+        'sol': [Eq(log(x**2*f(x))/3 + log(x**2*f(x) - Rational(3, 2))/6, C1 + log(x))],
+        'simplify_flag': False,
+        'XFAIL': ['lie_group'], #It hangs.
+    },
+
+    #Note: 'separable_reduced_02' is referred in 'separable_reduced_11'
+    'separable_reduced_02': {
+        'eq': f(x).diff(x) + (f(x) / (x**4*f(x) - x)),
+        'sol': [Eq(log(x**3*f(x))/4 + log(x**3*f(x) - Rational(4,3))/12, C1 + log(x))],
+        'simplify_flag': False,
+        'checkodesol_XFAIL':True, #It hangs for this.
+    },
+
+    'separable_reduced_03': {
+        'eq': x*df + f(x)*(x**2*f(x)),
+        'sol': [Eq(log(x**2*f(x))/2 - log(x**2*f(x) - 2)/2, C1 + log(x))],
+        'simplify_flag': False,
+    },
+
+    'separable_reduced_04': {
+        'eq': Eq(f(x).diff(x) + f(x)/x * (1 + (x**(S(2)/3)*f(x))**2), 0),
+        'sol': [Eq(-3*log(x**(S(2)/3)*f(x)) + 3*log(3*x**(S(4)/3)*f(x)**2 + 1)/2, C1 + log(x))],
+        'simplify_flag': False,
+    },
+
+    'separable_reduced_05': {
+        'eq': Eq(f(x).diff(x) + f(x)/x * (1 + (x*f(x))**2), 0),
+        'sol': [Eq(f(x), -sqrt(2)*sqrt(1/(C1 + log(x)))/(2*x)),\
+                   Eq(f(x), sqrt(2)*sqrt(1/(C1 + log(x)))/(2*x))],
+    },
+
+    'separable_reduced_06': {
+        'eq': Eq(f(x).diff(x) + (x**4*f(x)**2 + x**2*f(x))*f(x)/(x*(x**6*f(x)**3 + x**4*f(x)**2)), 0),
+        'sol': [Eq(f(x), C1 + 1/(2*x**2))],
+    },
+
+    'separable_reduced_07': {
+        'eq': Eq(f(x).diff(x) + (f(x)**2)*f(x)/(x), 0),
+        'sol': [
+            Eq(f(x), -sqrt(2)*sqrt(1/(C1 + log(x)))/2),
+            Eq(f(x), sqrt(2)*sqrt(1/(C1 + log(x)))/2)
+        ],
+    },
+
+    'separable_reduced_08': {
+        'eq': Eq(f(x).diff(x) + (f(x)+3)*f(x)/(x*(f(x)+2)), 0),
+        'sol': [Eq(-log(f(x) + 3)/3 - 2*log(f(x))/3, C1 + log(x))],
+        'simplify_flag': False,
+        'XFAIL': ['lie_group'], #It hangs.
+    },
+
+    'separable_reduced_09': {
+        'eq': Eq(f(x).diff(x) + (f(x)+3)*f(x)/x, 0),
+        'sol': [Eq(f(x), 3/(C1*x**3 - 1))],
+    },
+
+    'separable_reduced_10': {
+        'eq': Eq(f(x).diff(x) + (f(x)**2+f(x))*f(x)/(x), 0),
+        'sol': [Eq(- log(x) - log(f(x) + 1) + log(f(x)) + 1/f(x), C1)],
+        'XFAIL': ['lie_group'],#No algorithms are implemented to solve equation -C1 + x*(_y + 1)*exp(-1/_y)/_y
+
+    },
+
+    # Equivalent to example_name 'separable_reduced_02'. Only difference is testing with simplify=True
+    'separable_reduced_11': {
+        'eq': f(x).diff(x) + (f(x) / (x**4*f(x) - x)),
+        'sol': [Eq(f(x), -sqrt(2)*sqrt(3*3**Rational(1,3)*(sqrt((3*exp(12*C1) + x**(-12))*exp(24*C1)) - exp(12*C1)/x**6)**Rational(1,3)
+- 3*3**Rational(2,3)*exp(12*C1)/(sqrt((3*exp(12*C1) + x**(-12))*exp(24*C1)) - exp(12*C1)/x**6)**Rational(1,3) + 2/x**6)/6
+- sqrt(2)*sqrt(-3*3**Rational(1,3)*(sqrt((3*exp(12*C1) + x**(-12))*exp(24*C1)) - exp(12*C1)/x**6)**Rational(1,3)
++ 3*3**Rational(2,3)*exp(12*C1)/(sqrt((3*exp(12*C1) + x**(-12))*exp(24*C1)) - exp(12*C1)/x**6)**Rational(1,3) + 4/x**6
+- 4*sqrt(2)/(x**9*sqrt(3*3**Rational(1,3)*(sqrt((3*exp(12*C1) + x**(-12))*exp(24*C1)) - exp(12*C1)/x**6)**Rational(1,3)
+- 3*3**Rational(2,3)*exp(12*C1)/(sqrt((3*exp(12*C1) + x**(-12))*exp(24*C1)) - exp(12*C1)/x**6)**Rational(1,3) + 2/x**6)))/6 + 1/(3*x**3)),
+Eq(f(x), -sqrt(2)*sqrt(3*3**Rational(1,3)*(sqrt((3*exp(12*C1) + x**(-12))*exp(24*C1)) - exp(12*C1)/x**6)**Rational(1,3)
+- 3*3**Rational(2,3)*exp(12*C1)/(sqrt((3*exp(12*C1) + x**(-12))*exp(24*C1)) - exp(12*C1)/x**6)**Rational(1,3) + 2/x**6)/6
++ sqrt(2)*sqrt(-3*3**Rational(1,3)*(sqrt((3*exp(12*C1) + x**(-12))*exp(24*C1)) - exp(12*C1)/x**6)**Rational(1,3)
++ 3*3**Rational(2,3)*exp(12*C1)/(sqrt((3*exp(12*C1) + x**(-12))*exp(24*C1)) - exp(12*C1)/x**6)**Rational(1,3) + 4/x**6
+- 4*sqrt(2)/(x**9*sqrt(3*3**Rational(1,3)*(sqrt((3*exp(12*C1) + x**(-12))*exp(24*C1)) - exp(12*C1)/x**6)**Rational(1,3)
+- 3*3**Rational(2,3)*exp(12*C1)/(sqrt((3*exp(12*C1) + x**(-12))*exp(24*C1)) - exp(12*C1)/x**6)**Rational(1,3) + 2/x**6)))/6 + 1/(3*x**3)),
+Eq(f(x), sqrt(2)*sqrt(3*3**Rational(1,3)*(sqrt((3*exp(12*C1) + x**(-12))*exp(24*C1)) - exp(12*C1)/x**6)**Rational(1,3)
+- 3*3**Rational(2,3)*exp(12*C1)/(sqrt((3*exp(12*C1) + x**(-12))*exp(24*C1)) - exp(12*C1)/x**6)**Rational(1,3) + 2/x**6)/6
+- sqrt(2)*sqrt(-3*3**Rational(1,3)*(sqrt((3*exp(12*C1) + x**(-12))*exp(24*C1)) - exp(12*C1)/x**6)**Rational(1,3)
++ 3*3**Rational(2,3)*exp(12*C1)/(sqrt((3*exp(12*C1) + x**(-12))*exp(24*C1)) - exp(12*C1)/x**6)**Rational(1,3)
++ 4/x**6 + 4*sqrt(2)/(x**9*sqrt(3*3**Rational(1,3)*(sqrt((3*exp(12*C1) + x**(-12))*exp(24*C1)) - exp(12*C1)/x**6)**Rational(1,3)
+- 3*3**Rational(2,3)*exp(12*C1)/(sqrt((3*exp(12*C1) + x**(-12))*exp(24*C1)) - exp(12*C1)/x**6)**Rational(1,3) + 2/x**6)))/6 + 1/(3*x**3)),
+Eq(f(x), sqrt(2)*sqrt(3*3**Rational(1,3)*(sqrt((3*exp(12*C1) + x**(-12))*exp(24*C1)) - exp(12*C1)/x**6)**Rational(1,3)
+- 3*3**Rational(2,3)*exp(12*C1)/(sqrt((3*exp(12*C1) + x**(-12))*exp(24*C1)) - exp(12*C1)/x**6)**Rational(1,3) + 2/x**6)/6
++ sqrt(2)*sqrt(-3*3**Rational(1,3)*(sqrt((3*exp(12*C1) + x**(-12))*exp(24*C1)) - exp(12*C1)/x**6)**Rational(1,3) + 3*3**Rational(2,3)*exp(12*C1)/(sqrt((3*exp(12*C1)
++ x**(-12))*exp(24*C1)) - exp(12*C1)/x**6)**Rational(1,3) + 4/x**6 + 4*sqrt(2)/(x**9*sqrt(3*3**Rational(1,3)*(sqrt((3*exp(12*C1) + x**(-12))*exp(24*C1))
+- exp(12*C1)/x**6)**Rational(1,3) - 3*3**Rational(2,3)*exp(12*C1)/(sqrt((3*exp(12*C1) + x**(-12))*exp(24*C1)) - exp(12*C1)/x**6)**Rational(1,3) + 2/x**6)))/6 + 1/(3*x**3))],
+        'checkodesol_XFAIL':True, #It hangs for this.
+        'slow': True,
+    },
+
+    #These were from issue: https://github.com/sympy/sympy/issues/6247
+    'separable_reduced_12': {
+        'eq': x**2*f(x)**2 + x*Derivative(f(x), x),
+        'sol': [Eq(f(x), 2*C1/(C1*x**2 - 1))],
+    },
+    }
+    }
+
+
+@_add_example_keys
+def _get_examples_ode_sol_lie_group():
+    a, b, c = symbols("a b c")
+    return {
+            'hint': "lie_group",
+            'func': f(x),
+            'examples':{
+    #Example 1-4 and 19-20 were from issue: https://github.com/sympy/sympy/issues/17322
+    'lie_group_01': {
+        'eq': x*f(x).diff(x)*(f(x)+4) + (f(x)**2) -2*f(x)-2*x,
+        'sol': [],
+        'dsolve_too_slow': True,
+        'checkodesol_too_slow': True,
+    },
+
+    'lie_group_02': {
+        'eq': x*f(x).diff(x)*(f(x)+4) + (f(x)**2) -2*f(x)-2*x,
+        'sol': [],
+        'dsolve_too_slow': True,
+    },
+
+    'lie_group_03': {
+        'eq': Eq(x**7*Derivative(f(x), x) + 5*x**3*f(x)**2 - (2*x**2 + 2)*f(x)**3, 0),
+        'sol': [],
+        'dsolve_too_slow': True,
+    },
+
+    'lie_group_04': {
+        'eq': f(x).diff(x) - (f(x) - x*log(x))**2/x**2 + log(x),
+        'sol': [],
+        'XFAIL': ['lie_group'],
+    },
+
+    'lie_group_05': {
+        'eq': f(x).diff(x)**2,
+        'sol': [Eq(f(x), C1)],
+        'XFAIL': ['factorable'],  #It raises Not Implemented error
+    },
+
+    'lie_group_06': {
+        'eq': Eq(f(x).diff(x), x**2*f(x)),
+        'sol': [Eq(f(x), C1*exp(x**3)**Rational(1, 3))],
+    },
+
+    'lie_group_07': {
+        'eq': f(x).diff(x) + a*f(x) - c*exp(b*x),
+        'sol': [Eq(f(x), Piecewise(((-C1*(a + b) + c*exp(x*(a + b)))*exp(-a*x)/(a + b),\
+        Ne(a, -b)), ((-C1 + c*x)*exp(-a*x), True)))],
+    },
+
+    'lie_group_08': {
+        'eq': f(x).diff(x) + 2*x*f(x) - x*exp(-x**2),
+        'sol': [Eq(f(x), (C1 + x**2/2)*exp(-x**2))],
+    },
+
+    'lie_group_09': {
+        'eq': (1 + 2*x)*(f(x).diff(x)) + 2 - 4*exp(-f(x)),
+        'sol': [Eq(f(x), log(C1/(2*x + 1) + 2))],
+    },
+
+    'lie_group_10': {
+        'eq': x**2*(f(x).diff(x)) - f(x) + x**2*exp(x - (1/x)),
+        'sol': [Eq(f(x), (C1 - exp(x))*exp(-1/x))],
+        'XFAIL': ['factorable'], #It raises Recursion Error (maixmum depth exceeded)
+    },
+
+    'lie_group_11': {
+        'eq': x**2*f(x)**2 + x*Derivative(f(x), x),
+        'sol': [Eq(f(x), 2/(C1 + x**2))],
+    },
+
+    'lie_group_12': {
+        'eq': diff(f(x),x) + 2*x*f(x) - x*exp(-x**2),
+        'sol': [Eq(f(x), exp(-x**2)*(C1 + x**2/2))],
+    },
+
+    'lie_group_13': {
+        'eq': diff(f(x),x) + f(x)*cos(x) - exp(2*x),
+        'sol': [Eq(f(x), exp(-sin(x))*(C1 + Integral(exp(2*x)*exp(sin(x)), x)))],
+    },
+
+    'lie_group_14': {
+        'eq': diff(f(x),x) + f(x)*cos(x) - sin(2*x)/2,
+        'sol': [Eq(f(x), C1*exp(-sin(x)) + sin(x) - 1)],
+    },
+
+    'lie_group_15': {
+        'eq': x*diff(f(x),x) + f(x) - x*sin(x),
+        'sol': [Eq(f(x), (C1 - x*cos(x) + sin(x))/x)],
+    },
+
+    'lie_group_16': {
+        'eq': x*diff(f(x),x) - f(x) - x/log(x),
+        'sol': [Eq(f(x), x*(C1 + log(log(x))))],
+    },
+
+    'lie_group_17': {
+        'eq': (f(x).diff(x)-f(x)) * (f(x).diff(x)+f(x)),
+        'sol': [Eq(f(x), C1*exp(x)), Eq(f(x), C1*exp(-x))],
+    },
+
+    'lie_group_18': {
+        'eq': f(x).diff(x) * (f(x).diff(x) - f(x)),
+        'sol': [Eq(f(x), C1*exp(x)), Eq(f(x), C1)],
+    },
+
+    'lie_group_19': {
+        'eq': (f(x).diff(x)-f(x)) * (f(x).diff(x)+f(x)),
+        'sol': [Eq(f(x), C1*exp(-x)), Eq(f(x), C1*exp(x))],
+    },
+
+    'lie_group_20': {
+        'eq': f(x).diff(x)*(f(x).diff(x)+f(x)),
+        'sol': [Eq(f(x), C1), Eq(f(x), C1*exp(-x))],
+    },
+    }
+    }
+
+
+@_add_example_keys
+def _get_examples_ode_sol_2nd_linear_airy():
+    return {
+            'hint': "2nd_linear_airy",
+            'func': f(x),
+            'examples':{
+    '2nd_lin_airy_01': {
+        'eq': f(x).diff(x, 2) - x*f(x),
+        'sol': [Eq(f(x), C1*airyai(x) + C2*airybi(x))],
+    },
+
+    '2nd_lin_airy_02': {
+        'eq': f(x).diff(x, 2) + 2*x*f(x),
+        'sol': [Eq(f(x), C1*airyai(-2**(S(1)/3)*x) + C2*airybi(-2**(S(1)/3)*x))],
+    },
+    }
+    }
+
+
+@_add_example_keys
+def _get_examples_ode_sol_nth_linear_constant_coeff_homogeneous():
+    # From Exercise 20, in Ordinary Differential Equations,
+    #                      Tenenbaum and Pollard, pg. 220
+    a = Symbol('a', positive=True)
+    k = Symbol('k', real=True)
+    r1, r2, r3, r4, r5 = [rootof(x**5 + 11*x - 2, n) for n in range(5)]
+    r6, r7, r8, r9, r10 = [rootof(x**5 - 3*x + 1, n) for n in range(5)]
+    r11, r12, r13, r14, r15 = [rootof(x**5 - 100*x**3 + 1000*x + 1, n) for n in range(5)]
+    r16, r17, r18, r19, r20 = [rootof(x**5 - x**4 + 10, n) for n in range(5)]
+    r21, r22, r23, r24, r25 = [rootof(x**5 - x + 1, n) for n in range(5)]
+    E = exp(1)
+    return {
+            'hint': "nth_linear_constant_coeff_homogeneous",
+            'func': f(x),
+            'examples':{
+    'lin_const_coeff_hom_01': {
+        'eq': f(x).diff(x, 2) + 2*f(x).diff(x),
+        'sol': [Eq(f(x), C1 + C2*exp(-2*x))],
+    },
+
+    'lin_const_coeff_hom_02': {
+        'eq': f(x).diff(x, 2) - 3*f(x).diff(x) + 2*f(x),
+        'sol': [Eq(f(x), (C1 + C2*exp(x))*exp(x))],
+    },
+
+    'lin_const_coeff_hom_03': {
+        'eq': f(x).diff(x, 2) - f(x),
+        'sol': [Eq(f(x), C1*exp(-x) + C2*exp(x))],
+    },
+
+    'lin_const_coeff_hom_04': {
+        'eq': f(x).diff(x, 3) + f(x).diff(x, 2) - 6*f(x).diff(x),
+        'sol': [Eq(f(x), C1 + C2*exp(-3*x) + C3*exp(2*x))],
+        'slow': True,
+    },
+
+    'lin_const_coeff_hom_05': {
+        'eq': 6*f(x).diff(x, 2) - 11*f(x).diff(x) + 4*f(x),
+        'sol': [Eq(f(x), C1*exp(x/2) + C2*exp(x*Rational(4, 3)))],
+        'slow': True,
+    },
+
+    'lin_const_coeff_hom_06': {
+        'eq': Eq(f(x).diff(x, 2) + 2*f(x).diff(x) - f(x), 0),
+        'sol': [Eq(f(x), C1*exp(x*(-1 + sqrt(2))) + C2*exp(-x*(sqrt(2) + 1)))],
+        'slow': True,
+    },
+
+    'lin_const_coeff_hom_07': {
+        'eq': diff(f(x), x, 3) + diff(f(x), x, 2) - 10*diff(f(x), x) - 6*f(x),
+        'sol': [Eq(f(x), C1*exp(3*x) + C3*exp(-x*(2 + sqrt(2))) + C2*exp(x*(-2 + sqrt(2))))],
+        'slow': True,
+    },
+
+    'lin_const_coeff_hom_08': {
+        'eq': f(x).diff(x, 4) - f(x).diff(x, 3) - 4*f(x).diff(x, 2) + \
+        4*f(x).diff(x),
+        'sol': [Eq(f(x), C1 + C2*exp(-2*x) + C3*exp(x) + C4*exp(2*x))],
+        'slow': True,
+    },
+
+    'lin_const_coeff_hom_09': {
+        'eq': f(x).diff(x, 4) + 4*f(x).diff(x, 3) + f(x).diff(x, 2) - \
+        4*f(x).diff(x) - 2*f(x),
+        'sol': [Eq(f(x), C3*exp(-x) + C4*exp(x) + (C1*exp(-sqrt(2)*x) + C2*exp(sqrt(2)*x))*exp(-2*x))],
+        'slow': True,
+    },
+
+    'lin_const_coeff_hom_10': {
+        'eq': f(x).diff(x, 4) - a**2*f(x),
+        'sol': [Eq(f(x), C1*exp(-sqrt(a)*x) + C2*exp(sqrt(a)*x) + C3*sin(sqrt(a)*x) + C4*cos(sqrt(a)*x))],
+        'slow': True,
+    },
+
+    'lin_const_coeff_hom_11': {
+        'eq': f(x).diff(x, 2) - 2*k*f(x).diff(x) - 2*f(x),
+        'sol': [Eq(f(x), C1*exp(x*(k - sqrt(k**2 + 2))) + C2*exp(x*(k + sqrt(k**2 + 2))))],
+        'slow': True,
+    },
+
+    'lin_const_coeff_hom_12': {
+        'eq': f(x).diff(x, 2) + 4*k*f(x).diff(x) - 12*k**2*f(x),
+        'sol': [Eq(f(x), C1*exp(-6*k*x) + C2*exp(2*k*x))],
+        'slow': True,
+    },
+
+    'lin_const_coeff_hom_13': {
+        'eq': f(x).diff(x, 4),
+        'sol': [Eq(f(x), C1 + C2*x + C3*x**2 + C4*x**3)],
+        'slow': True,
+    },
+
+    'lin_const_coeff_hom_14': {
+        'eq': f(x).diff(x, 2) + 4*f(x).diff(x) + 4*f(x),
+        'sol': [Eq(f(x), (C1 + C2*x)*exp(-2*x))],
+        'slow': True,
+    },
+
+    'lin_const_coeff_hom_15': {
+        'eq': 3*f(x).diff(x, 3) + 5*f(x).diff(x, 2) + f(x).diff(x) - f(x),
+        'sol': [Eq(f(x), (C1 + C2*x)*exp(-x) + C3*exp(x/3))],
+        'slow': True,
+    },
+
+    'lin_const_coeff_hom_16': {
+        'eq': f(x).diff(x, 3) - 6*f(x).diff(x, 2) + 12*f(x).diff(x) - 8*f(x),
+        'sol': [Eq(f(x), (C1 + x*(C2 + C3*x))*exp(2*x))],
+        'slow': True,
+    },
+
+    'lin_const_coeff_hom_17': {
+        'eq': f(x).diff(x, 2) - 2*a*f(x).diff(x) + a**2*f(x),
+        'sol': [Eq(f(x), (C1 + C2*x)*exp(a*x))],
+        'slow': True,
+    },
+
+    'lin_const_coeff_hom_18': {
+        'eq': f(x).diff(x, 4) + 3*f(x).diff(x, 3),
+        'sol': [Eq(f(x), C1 + C2*x + C3*x**2 + C4*exp(-3*x))],
+        'slow': True,
+    },
+
+    'lin_const_coeff_hom_19': {
+        'eq': f(x).diff(x, 4) - 2*f(x).diff(x, 2),
+        'sol': [Eq(f(x), C1 + C2*x + C3*exp(-sqrt(2)*x) + C4*exp(sqrt(2)*x))],
+        'slow': True,
+    },
+
+    'lin_const_coeff_hom_20': {
+        'eq': f(x).diff(x, 4) + 2*f(x).diff(x, 3) - 11*f(x).diff(x, 2) - \
+        12*f(x).diff(x) + 36*f(x),
+        'sol': [Eq(f(x), (C1 + C2*x)*exp(-3*x) + (C3 + C4*x)*exp(2*x))],
+        'slow': True,
+    },
+
+    'lin_const_coeff_hom_21': {
+        'eq': 36*f(x).diff(x, 4) - 37*f(x).diff(x, 2) + 4*f(x).diff(x) + 5*f(x),
+        'sol': [Eq(f(x), C1*exp(-x) + C2*exp(-x/3) + C3*exp(x/2) + C4*exp(x*Rational(5, 6)))],
+        'slow': True,
+    },
+
+    'lin_const_coeff_hom_22': {
+        'eq': f(x).diff(x, 4) - 8*f(x).diff(x, 2) + 16*f(x),
+        'sol': [Eq(f(x), (C1 + C2*x)*exp(-2*x) + (C3 + C4*x)*exp(2*x))],
+        'slow': True,
+    },
+
+    'lin_const_coeff_hom_23': {
+        'eq': f(x).diff(x, 2) - 2*f(x).diff(x) + 5*f(x),
+        'sol': [Eq(f(x), (C1*sin(2*x) + C2*cos(2*x))*exp(x))],
+        'slow': True,
+    },
+
+    'lin_const_coeff_hom_24': {
+        'eq': f(x).diff(x, 2) - f(x).diff(x) + f(x),
+        'sol': [Eq(f(x), (C1*sin(x*sqrt(3)/2) + C2*cos(x*sqrt(3)/2))*exp(x/2))],
+        'slow': True,
+    },
+
+    'lin_const_coeff_hom_25': {
+        'eq': f(x).diff(x, 4) + 5*f(x).diff(x, 2) + 6*f(x),
+        'sol': [Eq(f(x),
+        C1*sin(sqrt(2)*x) + C2*sin(sqrt(3)*x) + C3*cos(sqrt(2)*x) + C4*cos(sqrt(3)*x))],
+        'slow': True,
+    },
+
+    'lin_const_coeff_hom_26': {
+        'eq': f(x).diff(x, 2) - 4*f(x).diff(x) + 20*f(x),
+        'sol': [Eq(f(x), (C1*sin(4*x) + C2*cos(4*x))*exp(2*x))],
+        'slow': True,
+    },
+
+    'lin_const_coeff_hom_27': {
+        'eq': f(x).diff(x, 4) + 4*f(x).diff(x, 2) + 4*f(x),
+        'sol': [Eq(f(x), (C1 + C2*x)*sin(x*sqrt(2)) + (C3 + C4*x)*cos(x*sqrt(2)))],
+        'slow': True,
+    },
+
+    'lin_const_coeff_hom_28': {
+        'eq': f(x).diff(x, 3) + 8*f(x),
+        'sol': [Eq(f(x), (C1*sin(x*sqrt(3)) + C2*cos(x*sqrt(3)))*exp(x) + C3*exp(-2*x))],
+        'slow': True,
+    },
+
+    'lin_const_coeff_hom_29': {
+        'eq': f(x).diff(x, 4) + 4*f(x).diff(x, 2),
+        'sol': [Eq(f(x), C1 + C2*x + C3*sin(2*x) + C4*cos(2*x))],
+        'slow': True,
+    },
+
+    'lin_const_coeff_hom_30': {
+        'eq': f(x).diff(x, 5) + 2*f(x).diff(x, 3) + f(x).diff(x),
+        'sol': [Eq(f(x), C1 + (C2 + C3*x)*sin(x) + (C4 + C5*x)*cos(x))],
+        'slow': True,
+    },
+
+    'lin_const_coeff_hom_31': {
+        'eq': f(x).diff(x, 4) + f(x).diff(x, 2) + f(x),
+        'sol': [Eq(f(x), (C1*sin(sqrt(3)*x/2) + C2*cos(sqrt(3)*x/2))*exp(-x/2)
+        + (C3*sin(sqrt(3)*x/2) + C4*cos(sqrt(3)*x/2))*exp(x/2))],
+        'slow': True,
+    },
+
+    'lin_const_coeff_hom_32': {
+        'eq': f(x).diff(x, 4) + 4*f(x).diff(x, 2) + f(x),
+        'sol': [Eq(f(x), C1*sin(x*sqrt(-sqrt(3) + 2)) + C2*sin(x*sqrt(sqrt(3) + 2))
+        + C3*cos(x*sqrt(-sqrt(3) + 2)) + C4*cos(x*sqrt(sqrt(3) + 2)))],
+        'slow': True,
+    },
+
+    # One real root, two complex conjugate pairs
+    'lin_const_coeff_hom_33': {
+        'eq': f(x).diff(x, 5) + 11*f(x).diff(x) - 2*f(x),
+        'sol': [Eq(f(x),
+        C5*exp(r1*x) + exp(re(r2)*x) * (C1*sin(im(r2)*x) + C2*cos(im(r2)*x))
+        + exp(re(r4)*x) * (C3*sin(im(r4)*x) + C4*cos(im(r4)*x)))],
+        'checkodesol_XFAIL':True,  #It Hangs
+    },
+
+    # Three real roots, one complex conjugate pair
+    'lin_const_coeff_hom_34': {
+        'eq': f(x).diff(x,5) - 3*f(x).diff(x) + f(x),
+        'sol': [Eq(f(x),
+        C3*exp(r6*x) + C4*exp(r7*x) + C5*exp(r8*x)
+        + exp(re(r9)*x) * (C1*sin(im(r9)*x) + C2*cos(im(r9)*x)))],
+        'checkodesol_XFAIL':True, #It Hangs
+    },
+
+    # Five distinct real roots
+    'lin_const_coeff_hom_35': {
+        'eq': f(x).diff(x,5) - 100*f(x).diff(x,3) + 1000*f(x).diff(x) + f(x),
+        'sol': [Eq(f(x), C1*exp(r11*x) + C2*exp(r12*x) + C3*exp(r13*x) + C4*exp(r14*x) + C5*exp(r15*x))],
+        'checkodesol_XFAIL':True, #It Hangs
+    },
+
+    # Rational root and unsolvable quintic
+    'lin_const_coeff_hom_36': {
+        'eq': f(x).diff(x, 6) - 6*f(x).diff(x, 5) + 5*f(x).diff(x, 4) + 10*f(x).diff(x) - 50 * f(x),
+        'sol': [Eq(f(x),
+        C5*exp(5*x)
+        + C6*exp(x*r16)
+        + exp(re(r17)*x) * (C1*sin(im(r17)*x) + C2*cos(im(r17)*x))
+        + exp(re(r19)*x) * (C3*sin(im(r19)*x) + C4*cos(im(r19)*x)))],
+        'checkodesol_XFAIL':True, #It Hangs
+    },
+
+    # Five double roots (this is (x**5 - x + 1)**2)
+    'lin_const_coeff_hom_37': {
+        'eq': f(x).diff(x, 10) - 2*f(x).diff(x, 6) + 2*f(x).diff(x, 5)
+        + f(x).diff(x, 2) - 2*f(x).diff(x, 1) + f(x),
+        'sol': [Eq(f(x), (C1 + C2*x)*exp(x*r21) + (-((C3 + C4*x)*sin(x*im(r22)))
+        + (C5 + C6*x)*cos(x*im(r22)))*exp(x*re(r22)) + (-((C7 + C8*x)*sin(x*im(r24)))
+        + (C10*x + C9)*cos(x*im(r24)))*exp(x*re(r24)))],
+        'checkodesol_XFAIL':True, #It Hangs
+    },
+
+    'lin_const_coeff_hom_38': {
+        'eq': Eq(sqrt(2) * f(x).diff(x,x,x) + f(x).diff(x), 0),
+        'sol': [Eq(f(x), C1 + C2*sin(2**Rational(3, 4)*x/2) + C3*cos(2**Rational(3, 4)*x/2))],
+    },
+
+    'lin_const_coeff_hom_39': {
+        'eq': Eq(E * f(x).diff(x,x,x) + f(x).diff(x), 0),
+        'sol': [Eq(f(x), C1 + C2*sin(x/sqrt(E)) + C3*cos(x/sqrt(E)))],
+    },
+
+    'lin_const_coeff_hom_40': {
+        'eq': Eq(pi * f(x).diff(x,x,x) + f(x).diff(x), 0),
+        'sol': [Eq(f(x), C1 + C2*sin(x/sqrt(pi)) + C3*cos(x/sqrt(pi)))],
+    },
+
+    'lin_const_coeff_hom_41': {
+        'eq': Eq(I * f(x).diff(x,x,x) + f(x).diff(x), 0),
+        'sol': [Eq(f(x), C1 + C2*exp(-sqrt(I)*x) + C3*exp(sqrt(I)*x))],
+    },
+
+    'lin_const_coeff_hom_42': {
+        'eq': f(x).diff(x, x) + y*f(x),
+        'sol': [Eq(f(x), C1*exp(-x*sqrt(-y)) + C2*exp(x*sqrt(-y)))],
+    },
+
+    'lin_const_coeff_hom_43': {
+        'eq': Eq(9*f(x).diff(x, x) + f(x), 0),
+        'sol': [Eq(f(x), C1*sin(x/3) + C2*cos(x/3))],
+    },
+
+    'lin_const_coeff_hom_44': {
+        'eq': Eq(9*f(x).diff(x, x), f(x)),
+        'sol': [Eq(f(x), C1*exp(-x/3) + C2*exp(x/3))],
+    },
+
+    'lin_const_coeff_hom_45': {
+        'eq': Eq(f(x).diff(x, x) - 3*diff(f(x), x) + 2*f(x), 0),
+        'sol': [Eq(f(x), (C1 + C2*exp(x))*exp(x))],
+    },
+
+    'lin_const_coeff_hom_46': {
+        'eq': Eq(f(x).diff(x, x) - 4*diff(f(x), x) + 4*f(x), 0),
+        'sol': [Eq(f(x), (C1 + C2*x)*exp(2*x))],
+    },
+
+    # Type: 2nd order, constant coefficients (two real equal roots)
+    'lin_const_coeff_hom_47': {
+        'eq': Eq(f(x).diff(x, x) + 2*diff(f(x), x) + 3*f(x), 0),
+        'sol': [Eq(f(x), (C1*sin(x*sqrt(2)) + C2*cos(x*sqrt(2)))*exp(-x))],
+    },
+
+    #These were from issue: https://github.com/sympy/sympy/issues/6247
+    'lin_const_coeff_hom_48': {
+        'eq': f(x).diff(x, x) + 4*f(x),
+        'sol': [Eq(f(x), C1*sin(2*x) + C2*cos(2*x))],
+    },
+    }
+    }
+
+
+@_add_example_keys
+def _get_examples_ode_sol_1st_homogeneous_coeff_subs_dep_div_indep():
+    return {
+            'hint': "1st_homogeneous_coeff_subs_dep_div_indep",
+            'func': f(x),
+            'examples':{
+    'dep_div_indep_01': {
+        'eq': f(x)/x*cos(f(x)/x) - (x/f(x)*sin(f(x)/x) + cos(f(x)/x))*f(x).diff(x),
+        'sol': [Eq(log(x), C1 - log(f(x)*sin(f(x)/x)/x))],
+        'slow': True
+    },
+
+    #indep_div_dep actually has a simpler solution for example 2 but it runs too slow.
+    'dep_div_indep_02': {
+        'eq': x*f(x).diff(x) - f(x) - x*sin(f(x)/x),
+        'sol': [Eq(log(x), log(C1) + log(cos(f(x)/x) - 1)/2 - log(cos(f(x)/x) + 1)/2)],
+        'simplify_flag':False,
+    },
+
+    'dep_div_indep_03': {
+        'eq': x*exp(f(x)/x) - f(x)*sin(f(x)/x) + x*sin(f(x)/x)*f(x).diff(x),
+        'sol': [Eq(log(x), C1 + exp(-f(x)/x)*sin(f(x)/x)/2 + exp(-f(x)/x)*cos(f(x)/x)/2)],
+        'slow': True
+    },
+
+    'dep_div_indep_04': {
+        'eq': f(x).diff(x) - f(x)/x + 1/sin(f(x)/x),
+        'sol': [Eq(f(x), x*(-acos(C1 + log(x)) + 2*pi)), Eq(f(x), x*acos(C1 + log(x)))],
+        'slow': True
+    },
+
+    # previous code was testing with these other solution:
+    # example5_solb = Eq(f(x), log(log(C1/x)**(-x)))
+    'dep_div_indep_05': {
+        'eq': x*exp(f(x)/x) + f(x) - x*f(x).diff(x),
+        'sol': [Eq(f(x), log((1/(C1 - log(x)))**x))],
+        'checkodesol_XFAIL':True, #(because of **x?)
+    },
+    }
+    }
+
+@_add_example_keys
+def _get_examples_ode_sol_linear_coefficients():
+    return {
+            'hint': "linear_coefficients",
+            'func': f(x),
+            'examples':{
+    'linear_coeff_01': {
+        'eq': f(x).diff(x) + (3 + 2*f(x))/(x + 3),
+        'sol': [Eq(f(x), C1/(x**2 + 6*x + 9) - Rational(3, 2))],
+    },
+    }
+    }
+
+@_add_example_keys
+def _get_examples_ode_sol_1st_homogeneous_coeff_best():
+    return {
+            'hint': "1st_homogeneous_coeff_best",
+            'func': f(x),
+            'examples':{
+    # previous code was testing this with other solution:
+    # example1_solb = Eq(-f(x)/(1 + log(x/f(x))), C1)
+    '1st_homogeneous_coeff_best_01': {
+        'eq': f(x) + (x*log(f(x)/x) - 2*x)*diff(f(x), x),
+        'sol': [Eq(f(x), -exp(C1)*LambertW(-x*exp(-C1 + 1)))],
+        'checkodesol_XFAIL':True, #(because of LambertW?)
+    },
+
+    '1st_homogeneous_coeff_best_02': {
+        'eq': 2*f(x)*exp(x/f(x)) + f(x)*f(x).diff(x) - 2*x*exp(x/f(x))*f(x).diff(x),
+        'sol': [Eq(log(f(x)), C1 - 2*exp(x/f(x)))],
+    },
+
+    # previous code was testing this with other solution:
+    # example3_solb = Eq(log(C1*x*sqrt(1/x)*sqrt(f(x))) + x**2/(2*f(x)**2), 0)
+    '1st_homogeneous_coeff_best_03': {
+        'eq': 2*x**2*f(x) + f(x)**3 + (x*f(x)**2 - 2*x**3)*f(x).diff(x),
+        'sol': [Eq(f(x), exp(2*C1 + LambertW(-2*x**4*exp(-4*C1))/2)/x)],
+        'checkodesol_XFAIL':True,  #(because of LambertW?)
+    },
+
+    '1st_homogeneous_coeff_best_04': {
+        'eq': (x + sqrt(f(x)**2 - x*f(x)))*f(x).diff(x) - f(x),
+        'sol': [Eq(log(f(x)), C1 - 2*sqrt(-x/f(x) + 1))],
+        'slow': True,
+    },
+
+    '1st_homogeneous_coeff_best_05': {
+        'eq': x + f(x) - (x - f(x))*f(x).diff(x),
+        'sol': [Eq(log(x), C1 - log(sqrt(1 + f(x)**2/x**2)) + atan(f(x)/x))],
+    },
+
+    '1st_homogeneous_coeff_best_06': {
+        'eq': x*f(x).diff(x) - f(x) - x*sin(f(x)/x),
+        'sol': [Eq(f(x), 2*x*atan(C1*x))],
+    },
+
+    '1st_homogeneous_coeff_best_07': {
+        'eq': x**2 + f(x)**2 - 2*x*f(x)*f(x).diff(x),
+        'sol': [Eq(f(x), -sqrt(x*(C1 + x))), Eq(f(x), sqrt(x*(C1 + x)))],
+    },
+
+    '1st_homogeneous_coeff_best_08': {
+        'eq': f(x)**2 + (x*sqrt(f(x)**2 - x**2) - x*f(x))*f(x).diff(x),
+        'sol': [Eq(f(x), -C1*sqrt(-x/(x - 2*C1))), Eq(f(x), C1*sqrt(-x/(x - 2*C1)))],
+        'checkodesol_XFAIL': True  # solutions are valid in a range
+    },
+    }
+    }
+
+
+def _get_all_examples():
+    all_examples = _get_examples_ode_sol_euler_homogeneous + \
+    _get_examples_ode_sol_euler_undetermined_coeff + \
+    _get_examples_ode_sol_euler_var_para + \
+    _get_examples_ode_sol_factorable + \
+    _get_examples_ode_sol_bernoulli + \
+    _get_examples_ode_sol_nth_algebraic + \
+    _get_examples_ode_sol_riccati + \
+    _get_examples_ode_sol_1st_linear + \
+    _get_examples_ode_sol_1st_exact + \
+    _get_examples_ode_sol_almost_linear + \
+    _get_examples_ode_sol_nth_order_reducible + \
+    _get_examples_ode_sol_nth_linear_undetermined_coefficients + \
+    _get_examples_ode_sol_liouville + \
+    _get_examples_ode_sol_separable + \
+    _get_examples_ode_sol_1st_rational_riccati + \
+    _get_examples_ode_sol_nth_linear_var_of_parameters + \
+    _get_examples_ode_sol_2nd_linear_bessel + \
+    _get_examples_ode_sol_2nd_2F1_hypergeometric + \
+    _get_examples_ode_sol_2nd_nonlinear_autonomous_conserved + \
+    _get_examples_ode_sol_separable_reduced + \
+    _get_examples_ode_sol_lie_group + \
+    _get_examples_ode_sol_2nd_linear_airy + \
+    _get_examples_ode_sol_nth_linear_constant_coeff_homogeneous +\
+    _get_examples_ode_sol_1st_homogeneous_coeff_best +\
+    _get_examples_ode_sol_1st_homogeneous_coeff_subs_dep_div_indep +\
+    _get_examples_ode_sol_linear_coefficients
+
+    return all_examples
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/ode/tests/test_subscheck.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/ode/tests/test_subscheck.py
new file mode 100644
index 0000000000000000000000000000000000000000..799c2854e878208721b600767de350cda08cd7e5
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/ode/tests/test_subscheck.py
@@ -0,0 +1,203 @@
+from sympy.core.function import (Derivative, Function, diff)
+from sympy.core.numbers import (I, Rational, pi)
+from sympy.core.relational import Eq
+from sympy.core.symbol import (Symbol, symbols)
+from sympy.functions.elementary.exponential import (exp, log)
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import (cos, sin)
+from sympy.functions.special.error_functions import (Ei, erf, erfi)
+from sympy.integrals.integrals import Integral
+
+from sympy.solvers.ode.subscheck import checkodesol, checksysodesol
+
+from sympy.functions import besselj, bessely
+
+from sympy.testing.pytest import raises, slow
+
+
+C0, C1, C2, C3, C4 = symbols('C0:5')
+u, x, y, z = symbols('u,x:z', real=True)
+f = Function('f')
+g = Function('g')
+h = Function('h')
+
+
+@slow
+def test_checkodesol():
+    # For the most part, checkodesol is well tested in the tests below.
+    # These tests only handle cases not checked below.
+    raises(ValueError, lambda: checkodesol(f(x, y).diff(x), Eq(f(x, y), x)))
+    raises(ValueError, lambda: checkodesol(f(x).diff(x), Eq(f(x, y),
+           x), f(x, y)))
+    assert checkodesol(f(x).diff(x), Eq(f(x, y), x)) == \
+        (False, -f(x).diff(x) + f(x, y).diff(x) - 1)
+    assert checkodesol(f(x).diff(x), Eq(f(x), x)) is not True
+    assert checkodesol(f(x).diff(x), Eq(f(x), x)) == (False, 1)
+    sol1 = Eq(f(x)**5 + 11*f(x) - 2*f(x) + x, 0)
+    assert checkodesol(diff(sol1.lhs, x), sol1) == (True, 0)
+    assert checkodesol(diff(sol1.lhs, x)*exp(f(x)), sol1) == (True, 0)
+    assert checkodesol(diff(sol1.lhs, x, 2), sol1) == (True, 0)
+    assert checkodesol(diff(sol1.lhs, x, 2)*exp(f(x)), sol1) == (True, 0)
+    assert checkodesol(diff(sol1.lhs, x, 3), sol1) == (True, 0)
+    assert checkodesol(diff(sol1.lhs, x, 3)*exp(f(x)), sol1) == (True, 0)
+    assert checkodesol(diff(sol1.lhs, x, 3), Eq(f(x), x*log(x))) == \
+        (False, 60*x**4*((log(x) + 1)**2 + log(x))*(
+        log(x) + 1)*log(x)**2 - 5*x**4*log(x)**4 - 9)
+    assert checkodesol(diff(exp(f(x)) + x, x)*x, Eq(exp(f(x)) + x, 0)) == \
+        (True, 0)
+    assert checkodesol(diff(exp(f(x)) + x, x)*x, Eq(exp(f(x)) + x, 0),
+        solve_for_func=False) == (True, 0)
+    assert checkodesol(f(x).diff(x, 2), [Eq(f(x), C1 + C2*x),
+        Eq(f(x), C2 + C1*x), Eq(f(x), C1*x + C2*x**2)]) == \
+        [(True, 0), (True, 0), (False, C2)]
+    assert checkodesol(f(x).diff(x, 2), {Eq(f(x), C1 + C2*x),
+        Eq(f(x), C2 + C1*x), Eq(f(x), C1*x + C2*x**2)}) == \
+        {(True, 0), (True, 0), (False, C2)}
+    assert checkodesol(f(x).diff(x) - 1/f(x)/2, Eq(f(x)**2, x)) == \
+        [(True, 0), (True, 0)]
+    assert checkodesol(f(x).diff(x) - f(x), Eq(C1*exp(x), f(x))) == (True, 0)
+    # Based on test_1st_homogeneous_coeff_ode2_eq3sol.  Make sure that
+    # checkodesol tries back substituting f(x) when it can.
+    eq3 = x*exp(f(x)/x) + f(x) - x*f(x).diff(x)
+    sol3 = Eq(f(x), log(log(C1/x)**(-x)))
+    assert not checkodesol(eq3, sol3)[1].has(f(x))
+    # This case was failing intermittently depending on hash-seed:
+    eqn = Eq(Derivative(x*Derivative(f(x), x), x)/x, exp(x))
+    sol = Eq(f(x), C1 + C2*log(x) + exp(x) - Ei(x))
+    assert checkodesol(eqn, sol, order=2, solve_for_func=False)[0]
+    eq = x**2*(f(x).diff(x, 2)) + x*(f(x).diff(x)) + (2*x**2 +25)*f(x)
+    sol = Eq(f(x), C1*besselj(5*I, sqrt(2)*x) + C2*bessely(5*I, sqrt(2)*x))
+    assert checkodesol(eq, sol) == (True, 0)
+
+    eqs = [Eq(f(x).diff(x), f(x) + g(x)), Eq(g(x).diff(x), f(x) + g(x))]
+    sol = [Eq(f(x), -C1 + C2*exp(2*x)), Eq(g(x), C1 + C2*exp(2*x))]
+    assert checkodesol(eqs, sol) == (True, [0, 0])
+
+
+def test_checksysodesol():
+    x, y, z = symbols('x, y, z', cls=Function)
+    t = Symbol('t')
+    eq = (Eq(diff(x(t),t), 9*y(t)), Eq(diff(y(t),t), 12*x(t)))
+    sol = [Eq(x(t), 9*C1*exp(-6*sqrt(3)*t) + 9*C2*exp(6*sqrt(3)*t)), \
+    Eq(y(t), -6*sqrt(3)*C1*exp(-6*sqrt(3)*t) + 6*sqrt(3)*C2*exp(6*sqrt(3)*t))]
+    assert checksysodesol(eq, sol) == (True, [0, 0])
+
+    eq = (Eq(diff(x(t),t), 2*x(t) + 4*y(t)), Eq(diff(y(t),t), 12*x(t) + 41*y(t)))
+    sol = [Eq(x(t), 4*C1*exp(t*(-sqrt(1713)/2 + Rational(43, 2))) + 4*C2*exp(t*(sqrt(1713)/2 + \
+    Rational(43, 2)))), Eq(y(t), C1*(-sqrt(1713)/2 + Rational(39, 2))*exp(t*(-sqrt(1713)/2 + \
+    Rational(43, 2))) + C2*(Rational(39, 2) + sqrt(1713)/2)*exp(t*(sqrt(1713)/2 + Rational(43, 2))))]
+    assert checksysodesol(eq, sol) == (True, [0, 0])
+
+    eq = (Eq(diff(x(t),t), x(t) + y(t)), Eq(diff(y(t),t), -2*x(t) + 2*y(t)))
+    sol = [Eq(x(t), (C1*sin(sqrt(7)*t/2) + C2*cos(sqrt(7)*t/2))*exp(t*Rational(3, 2))), \
+    Eq(y(t), ((C1/2 - sqrt(7)*C2/2)*sin(sqrt(7)*t/2) + (sqrt(7)*C1/2 + \
+    C2/2)*cos(sqrt(7)*t/2))*exp(t*Rational(3, 2)))]
+    assert checksysodesol(eq, sol) == (True, [0, 0])
+
+    eq = (Eq(diff(x(t),t), x(t) + y(t) + 9), Eq(diff(y(t),t), 2*x(t) + 5*y(t) + 23))
+    sol = [Eq(x(t), C1*exp(t*(-sqrt(6) + 3)) + C2*exp(t*(sqrt(6) + 3)) - \
+    Rational(22, 3)), Eq(y(t), C1*(-sqrt(6) + 2)*exp(t*(-sqrt(6) + 3)) + C2*(2 + \
+    sqrt(6))*exp(t*(sqrt(6) + 3)) - Rational(5, 3))]
+    assert checksysodesol(eq, sol) == (True, [0, 0])
+
+    eq = (Eq(diff(x(t),t), x(t) + y(t) + 81), Eq(diff(y(t),t), -2*x(t) + y(t) + 23))
+    sol = [Eq(x(t), (C1*sin(sqrt(2)*t) + C2*cos(sqrt(2)*t))*exp(t) - Rational(58, 3)), \
+    Eq(y(t), (sqrt(2)*C1*cos(sqrt(2)*t) - sqrt(2)*C2*sin(sqrt(2)*t))*exp(t) - Rational(185, 3))]
+    assert checksysodesol(eq, sol) == (True, [0, 0])
+
+    eq = (Eq(diff(x(t),t), 5*t*x(t) + 2*y(t)), Eq(diff(y(t),t), 2*x(t) + 5*t*y(t)))
+    sol = [Eq(x(t), (C1*exp(Integral(2, t).doit()) + C2*exp(-(Integral(2, t)).doit()))*\
+    exp((Integral(5*t, t)).doit())), Eq(y(t), (C1*exp((Integral(2, t)).doit()) - \
+    C2*exp(-(Integral(2, t)).doit()))*exp((Integral(5*t, t)).doit()))]
+    assert checksysodesol(eq, sol) == (True, [0, 0])
+
+    eq = (Eq(diff(x(t),t), 5*t*x(t) + t**2*y(t)), Eq(diff(y(t),t), -t**2*x(t) + 5*t*y(t)))
+    sol = [Eq(x(t), (C1*cos((Integral(t**2, t)).doit()) + C2*sin((Integral(t**2, t)).doit()))*\
+    exp((Integral(5*t, t)).doit())), Eq(y(t), (-C1*sin((Integral(t**2, t)).doit()) + \
+    C2*cos((Integral(t**2, t)).doit()))*exp((Integral(5*t, t)).doit()))]
+    assert checksysodesol(eq, sol) == (True, [0, 0])
+
+    eq = (Eq(diff(x(t),t), 5*t*x(t) + t**2*y(t)), Eq(diff(y(t),t), -t**2*x(t) + (5*t+9*t**2)*y(t)))
+    sol = [Eq(x(t), (C1*exp((-sqrt(77)/2 + Rational(9, 2))*(Integral(t**2, t)).doit()) + \
+    C2*exp((sqrt(77)/2 + Rational(9, 2))*(Integral(t**2, t)).doit()))*exp((Integral(5*t, t)).doit())), \
+    Eq(y(t), (C1*(-sqrt(77)/2 + Rational(9, 2))*exp((-sqrt(77)/2 + Rational(9, 2))*(Integral(t**2, t)).doit()) + \
+    C2*(sqrt(77)/2 + Rational(9, 2))*exp((sqrt(77)/2 + Rational(9, 2))*(Integral(t**2, t)).doit()))*exp((Integral(5*t, t)).doit()))]
+    assert checksysodesol(eq, sol) == (True, [0, 0])
+
+    eq = (Eq(diff(x(t),t,t), 5*x(t) + 43*y(t)), Eq(diff(y(t),t,t), x(t) + 9*y(t)))
+    root0 = -sqrt(-sqrt(47) + 7)
+    root1 = sqrt(-sqrt(47) + 7)
+    root2 = -sqrt(sqrt(47) + 7)
+    root3 = sqrt(sqrt(47) + 7)
+    sol = [Eq(x(t), 43*C1*exp(t*root0) + 43*C2*exp(t*root1) + 43*C3*exp(t*root2) + 43*C4*exp(t*root3)), \
+    Eq(y(t), C1*(root0**2 - 5)*exp(t*root0) + C2*(root1**2 - 5)*exp(t*root1) + \
+    C3*(root2**2 - 5)*exp(t*root2) + C4*(root3**2 - 5)*exp(t*root3))]
+    assert checksysodesol(eq, sol) == (True, [0, 0])
+
+    eq = (Eq(diff(x(t),t,t), 8*x(t)+3*y(t)+31), Eq(diff(y(t),t,t), 9*x(t)+7*y(t)+12))
+    root0 = -sqrt(-sqrt(109)/2 + Rational(15, 2))
+    root1 = sqrt(-sqrt(109)/2 + Rational(15, 2))
+    root2 = -sqrt(sqrt(109)/2 + Rational(15, 2))
+    root3 = sqrt(sqrt(109)/2 + Rational(15, 2))
+    sol = [Eq(x(t), 3*C1*exp(t*root0) + 3*C2*exp(t*root1) + 3*C3*exp(t*root2) + 3*C4*exp(t*root3) - Rational(181, 29)), \
+    Eq(y(t), C1*(root0**2 - 8)*exp(t*root0) + C2*(root1**2 - 8)*exp(t*root1) + \
+    C3*(root2**2 - 8)*exp(t*root2) + C4*(root3**2 - 8)*exp(t*root3) + Rational(183, 29))]
+    assert checksysodesol(eq, sol) == (True, [0, 0])
+
+    eq = (Eq(diff(x(t),t,t) - 9*diff(y(t),t) + 7*x(t),0), Eq(diff(y(t),t,t) + 9*diff(x(t),t) + 7*y(t),0))
+    sol = [Eq(x(t), C1*cos(t*(Rational(9, 2) + sqrt(109)/2)) + C2*sin(t*(Rational(9, 2) + sqrt(109)/2)) + \
+    C3*cos(t*(-sqrt(109)/2 + Rational(9, 2))) + C4*sin(t*(-sqrt(109)/2 + Rational(9, 2)))), Eq(y(t), -C1*sin(t*(Rational(9, 2) + sqrt(109)/2)) \
+    + C2*cos(t*(Rational(9, 2) + sqrt(109)/2)) - C3*sin(t*(-sqrt(109)/2 + Rational(9, 2))) + C4*cos(t*(-sqrt(109)/2 + Rational(9, 2))))]
+    assert checksysodesol(eq, sol) == (True, [0, 0])
+
+    eq = (Eq(diff(x(t),t,t), 9*t*diff(y(t),t)-9*y(t)), Eq(diff(y(t),t,t),7*t*diff(x(t),t)-7*x(t)))
+    I1 = sqrt(6)*7**Rational(1, 4)*sqrt(pi)*erfi(sqrt(6)*7**Rational(1, 4)*t/2)/2 - exp(3*sqrt(7)*t**2/2)/t
+    I2 = -sqrt(6)*7**Rational(1, 4)*sqrt(pi)*erf(sqrt(6)*7**Rational(1, 4)*t/2)/2 - exp(-3*sqrt(7)*t**2/2)/t
+    sol = [Eq(x(t), C3*t + t*(9*C1*I1 + 9*C2*I2)), Eq(y(t), C4*t + t*(3*sqrt(7)*C1*I1 - 3*sqrt(7)*C2*I2))]
+    assert checksysodesol(eq, sol) == (True, [0, 0])
+
+    eq = (Eq(diff(x(t),t), 21*x(t)), Eq(diff(y(t),t), 17*x(t)+3*y(t)), Eq(diff(z(t),t), 5*x(t)+7*y(t)+9*z(t)))
+    sol = [Eq(x(t), C1*exp(21*t)), Eq(y(t), 17*C1*exp(21*t)/18 + C2*exp(3*t)), \
+    Eq(z(t), 209*C1*exp(21*t)/216 - 7*C2*exp(3*t)/6 + C3*exp(9*t))]
+    assert checksysodesol(eq, sol) == (True, [0, 0, 0])
+
+    eq = (Eq(diff(x(t),t),3*y(t)-11*z(t)),Eq(diff(y(t),t),7*z(t)-3*x(t)),Eq(diff(z(t),t),11*x(t)-7*y(t)))
+    sol = [Eq(x(t), 7*C0 + sqrt(179)*C1*cos(sqrt(179)*t) + (77*C1/3 + 130*C2/3)*sin(sqrt(179)*t)), \
+    Eq(y(t), 11*C0 + sqrt(179)*C2*cos(sqrt(179)*t) + (-58*C1/3 - 77*C2/3)*sin(sqrt(179)*t)), \
+    Eq(z(t), 3*C0 + sqrt(179)*(-7*C1/3 - 11*C2/3)*cos(sqrt(179)*t) + (11*C1 - 7*C2)*sin(sqrt(179)*t))]
+    assert checksysodesol(eq, sol) == (True, [0, 0, 0])
+
+    eq = (Eq(3*diff(x(t),t),4*5*(y(t)-z(t))),Eq(4*diff(y(t),t),3*5*(z(t)-x(t))),Eq(5*diff(z(t),t),3*4*(x(t)-y(t))))
+    sol = [Eq(x(t), C0 + 5*sqrt(2)*C1*cos(5*sqrt(2)*t) + (12*C1/5 + 164*C2/15)*sin(5*sqrt(2)*t)), \
+    Eq(y(t), C0 + 5*sqrt(2)*C2*cos(5*sqrt(2)*t) + (-51*C1/10 - 12*C2/5)*sin(5*sqrt(2)*t)), \
+    Eq(z(t), C0 + 5*sqrt(2)*(-9*C1/25 - 16*C2/25)*cos(5*sqrt(2)*t) + (12*C1/5 - 12*C2/5)*sin(5*sqrt(2)*t))]
+    assert checksysodesol(eq, sol) == (True, [0, 0, 0])
+
+    eq = (Eq(diff(x(t),t),4*x(t) - z(t)),Eq(diff(y(t),t),2*x(t)+2*y(t)-z(t)),Eq(diff(z(t),t),3*x(t)+y(t)))
+    sol = [Eq(x(t), C1*exp(2*t) + C2*t*exp(2*t) + C2*exp(2*t) + C3*t**2*exp(2*t)/2 + C3*t*exp(2*t) + C3*exp(2*t)), \
+    Eq(y(t), C1*exp(2*t) + C2*t*exp(2*t) + C2*exp(2*t) + C3*t**2*exp(2*t)/2 + C3*t*exp(2*t)), \
+    Eq(z(t), 2*C1*exp(2*t) + 2*C2*t*exp(2*t) + C2*exp(2*t) + C3*t**2*exp(2*t) + C3*t*exp(2*t) + C3*exp(2*t))]
+    assert checksysodesol(eq, sol) == (True, [0, 0, 0])
+
+    eq = (Eq(diff(x(t),t),4*x(t) - y(t) - 2*z(t)),Eq(diff(y(t),t),2*x(t) + y(t)- 2*z(t)),Eq(diff(z(t),t),5*x(t)-3*z(t)))
+    sol = [Eq(x(t), C1*exp(2*t) + C2*(-sin(t) + 3*cos(t)) + C3*(3*sin(t) + cos(t))), \
+    Eq(y(t), C2*(-sin(t) + 3*cos(t)) + C3*(3*sin(t) + cos(t))), Eq(z(t), C1*exp(2*t) + 5*C2*cos(t) + 5*C3*sin(t))]
+    assert checksysodesol(eq, sol) == (True, [0, 0, 0])
+
+    eq = (Eq(diff(x(t),t),x(t)*y(t)**3), Eq(diff(y(t),t),y(t)**5))
+    sol = [Eq(x(t), C1*exp((-1/(4*C2 + 4*t))**(Rational(-1, 4)))), Eq(y(t), -(-1/(4*C2 + 4*t))**Rational(1, 4)), \
+    Eq(x(t), C1*exp(-1/(-1/(4*C2 + 4*t))**Rational(1, 4))), Eq(y(t), (-1/(4*C2 + 4*t))**Rational(1, 4)), \
+    Eq(x(t), C1*exp(-I/(-1/(4*C2 + 4*t))**Rational(1, 4))), Eq(y(t), -I*(-1/(4*C2 + 4*t))**Rational(1, 4)), \
+    Eq(x(t), C1*exp(I/(-1/(4*C2 + 4*t))**Rational(1, 4))), Eq(y(t), I*(-1/(4*C2 + 4*t))**Rational(1, 4))]
+    assert checksysodesol(eq, sol) == (True, [0, 0])
+
+    eq = (Eq(diff(x(t),t), exp(3*x(t))*y(t)**3),Eq(diff(y(t),t), y(t)**5))
+    sol = [Eq(x(t), -log(C1 - 3/(-1/(4*C2 + 4*t))**Rational(1, 4))/3), Eq(y(t), -(-1/(4*C2 + 4*t))**Rational(1, 4)), \
+    Eq(x(t), -log(C1 + 3/(-1/(4*C2 + 4*t))**Rational(1, 4))/3), Eq(y(t), (-1/(4*C2 + 4*t))**Rational(1, 4)), \
+    Eq(x(t), -log(C1 + 3*I/(-1/(4*C2 + 4*t))**Rational(1, 4))/3), Eq(y(t), -I*(-1/(4*C2 + 4*t))**Rational(1, 4)), \
+    Eq(x(t), -log(C1 - 3*I/(-1/(4*C2 + 4*t))**Rational(1, 4))/3), Eq(y(t), I*(-1/(4*C2 + 4*t))**Rational(1, 4))]
+    assert checksysodesol(eq, sol) == (True, [0, 0])
+
+    eq = (Eq(x(t),t*diff(x(t),t)+diff(x(t),t)*diff(y(t),t)), Eq(y(t),t*diff(y(t),t)+diff(y(t),t)**2))
+    sol = {Eq(x(t), C1*C2 + C1*t), Eq(y(t), C2**2 + C2*t)}
+    assert checksysodesol(eq, sol) == (True, [0, 0])
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/ode/tests/test_systems.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/ode/tests/test_systems.py
new file mode 100644
index 0000000000000000000000000000000000000000..9d206129dfcf38c7b8c2e0ab42bd875003253f35
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/ode/tests/test_systems.py
@@ -0,0 +1,2544 @@
+from sympy.core.function import (Derivative, Function, diff)
+from sympy.core.mul import Mul
+from sympy.core.numbers import (I, Rational, pi)
+from sympy.core.relational import Eq
+from sympy.core.singleton import S
+from sympy.core.symbol import (Symbol, symbols)
+from sympy.functions.elementary.hyperbolic import sinh
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.matrices.dense import Matrix
+from sympy.core.containers import Tuple
+from sympy.functions import exp, cos, sin, log, Ci, Si, erf, erfi
+from sympy.matrices import dotprodsimp, NonSquareMatrixError
+from sympy.solvers.ode import dsolve
+from sympy.solvers.ode.ode import constant_renumber
+from sympy.solvers.ode.subscheck import checksysodesol
+from sympy.solvers.ode.systems import (_classify_linear_system, linear_ode_to_matrix,
+                                       ODEOrderError, ODENonlinearError, _simpsol,
+                                       _is_commutative_anti_derivative, linodesolve,
+                                       canonical_odes, dsolve_system, _component_division,
+                                       _eqs2dict, _dict2graph)
+from sympy.functions import airyai, airybi
+from sympy.integrals.integrals import Integral
+from sympy.simplify.ratsimp import ratsimp
+from sympy.testing.pytest import raises, slow, tooslow, XFAIL
+
+
+C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10 = symbols('C0:11')
+x = symbols('x')
+f = Function('f')
+g = Function('g')
+h = Function('h')
+
+
+def test_linear_ode_to_matrix():
+    f, g, h = symbols("f, g, h", cls=Function)
+    t = Symbol("t")
+    funcs = [f(t), g(t), h(t)]
+    f1 = f(t).diff(t)
+    g1 = g(t).diff(t)
+    h1 = h(t).diff(t)
+    f2 = f(t).diff(t, 2)
+    g2 = g(t).diff(t, 2)
+    h2 = h(t).diff(t, 2)
+
+    eqs_1 = [Eq(f1, g(t)), Eq(g1, f(t))]
+    sol_1 = ([Matrix([[1, 0], [0, 1]]), Matrix([[ 0, 1], [1,  0]])], Matrix([[0],[0]]))
+    assert linear_ode_to_matrix(eqs_1, funcs[:-1], t, 1) == sol_1
+
+    eqs_2 = [Eq(f1, f(t) + 2*g(t)), Eq(g1, h(t)), Eq(h1, g(t) + h(t) + f(t))]
+    sol_2 = ([Matrix([[1, 0, 0], [0, 1, 0], [0, 0, 1]]), Matrix([[1, 2,  0], [ 0,  0, 1], [1, 1, 1]])],
+             Matrix([[0], [0], [0]]))
+    assert linear_ode_to_matrix(eqs_2, funcs, t, 1) == sol_2
+
+    eqs_3 = [Eq(2*f1 + 3*h1, f(t) + g(t)), Eq(4*h1 + 5*g1, f(t) + h(t)), Eq(5*f1 + 4*g1, g(t) + h(t))]
+    sol_3 = ([Matrix([[2, 0, 3], [0, 5, 4], [5, 4, 0]]), Matrix([[1, 1,  0], [1,  0, 1], [0, 1, 1]])],
+             Matrix([[0], [0], [0]]))
+    assert linear_ode_to_matrix(eqs_3, funcs, t, 1) == sol_3
+
+    eqs_4 = [Eq(f2 + h(t), f1 + g(t)), Eq(2*h2 + g2 + g1 + g(t), 0), Eq(3*h1, 4)]
+    sol_4 = ([Matrix([[1, 0, 0], [0, 1, 2], [0, 0, 0]]), Matrix([[1, 0, 0], [0, -1, 0], [0, 0, -3]]),
+              Matrix([[0, 1, -1], [0,  -1, 0], [0, 0, 0]])], Matrix([[0], [0], [4]]))
+    assert linear_ode_to_matrix(eqs_4, funcs, t, 2) == sol_4
+
+    eqs_5 = [Eq(f2, g(t)), Eq(f1 + g1, f(t))]
+    raises(ODEOrderError, lambda: linear_ode_to_matrix(eqs_5, funcs[:-1], t, 1))
+
+    eqs_6 = [Eq(f1, f(t)**2), Eq(g1, f(t) + g(t))]
+    raises(ODENonlinearError, lambda: linear_ode_to_matrix(eqs_6, funcs[:-1], t, 1))
+
+
+def test__classify_linear_system():
+    x, y, z, w = symbols('x, y, z, w', cls=Function)
+    t, k, l = symbols('t k l')
+    x1 = diff(x(t), t)
+    y1 = diff(y(t), t)
+    z1 = diff(z(t), t)
+    w1 = diff(w(t), t)
+    x2 = diff(x(t), t, t)
+    y2 = diff(y(t), t, t)
+    funcs = [x(t), y(t)]
+    funcs_2 = funcs + [z(t), w(t)]
+
+    eqs_1 = (5 * x1 + 12 * x(t) - 6 * (y(t)), (2 * y1 - 11 * t * x(t) + 3 * y(t) + t))
+    assert _classify_linear_system(eqs_1, funcs, t) is None
+
+    eqs_2 = (5 * (x1**2) + 12 * x(t) - 6 * (y(t)), (2 * y1 - 11 * t * x(t) + 3 * y(t) + t))
+    sol2 = {'is_implicit': True,
+            'canon_eqs': [[Eq(Derivative(x(t), t), -sqrt(-12*x(t)/5 + 6*y(t)/5)),
+            Eq(Derivative(y(t), t), 11*t*x(t)/2 - t/2 - 3*y(t)/2)],
+            [Eq(Derivative(x(t), t), sqrt(-12*x(t)/5 + 6*y(t)/5)),
+            Eq(Derivative(y(t), t), 11*t*x(t)/2 - t/2 - 3*y(t)/2)]]}
+    assert _classify_linear_system(eqs_2, funcs, t) == sol2
+
+    eqs_2_1 = [Eq(Derivative(x(t), t), -sqrt(-12*x(t)/5 + 6*y(t)/5)),
+            Eq(Derivative(y(t), t), 11*t*x(t)/2 - t/2 - 3*y(t)/2)]
+    assert _classify_linear_system(eqs_2_1, funcs, t) is None
+
+    eqs_2_2 = [Eq(Derivative(x(t), t), sqrt(-12*x(t)/5 + 6*y(t)/5)),
+            Eq(Derivative(y(t), t), 11*t*x(t)/2 - t/2 - 3*y(t)/2)]
+    assert _classify_linear_system(eqs_2_2, funcs, t) is None
+
+    eqs_3 = (5 * x1 + 12 * x(t) - 6 * (y(t)), (2 * y1 - 11 * x(t) + 3 * y(t)), (5 * w1 + z(t)), (z1 + w(t)))
+    answer_3 = {'no_of_equation': 4,
+     'eq': (12*x(t) - 6*y(t) + 5*Derivative(x(t), t),
+      -11*x(t) + 3*y(t) + 2*Derivative(y(t), t),
+      z(t) + 5*Derivative(w(t), t),
+      w(t) + Derivative(z(t), t)),
+     'func': [x(t), y(t), z(t), w(t)],
+     'order': {x(t): 1, y(t): 1, z(t): 1, w(t): 1},
+     'is_linear': True,
+     'is_constant': True,
+     'is_homogeneous': True,
+     'func_coeff': -Matrix([
+     [Rational(12, 5), Rational(-6, 5), 0, 0],
+     [Rational(-11, 2),  Rational(3, 2),   0, 0],
+     [0, 0, 0, 1],
+     [0, 0, Rational(1, 5), 0]]),
+     'type_of_equation': 'type1',
+     'is_general': True}
+    assert _classify_linear_system(eqs_3, funcs_2, t) == answer_3
+
+    eqs_4 = (5 * x1 + 12 * x(t) - 6 * (y(t)), (2 * y1 - 11 * x(t) + 3 * y(t)), (z1 - w(t)), (w1 - z(t)))
+    answer_4 = {'no_of_equation': 4,
+     'eq': (12 * x(t) - 6 * y(t) + 5 * Derivative(x(t), t),
+            -11 * x(t) + 3 * y(t) + 2 * Derivative(y(t), t),
+            -w(t) + Derivative(z(t), t),
+            -z(t) + Derivative(w(t), t)),
+     'func': [x(t), y(t), z(t), w(t)],
+     'order': {x(t): 1, y(t): 1, z(t): 1, w(t): 1},
+     'is_linear': True,
+     'is_constant': True,
+     'is_homogeneous': True,
+     'func_coeff': -Matrix([
+         [Rational(12, 5), Rational(-6, 5), 0, 0],
+         [Rational(-11, 2), Rational(3, 2), 0, 0],
+         [0, 0, 0, -1],
+         [0, 0, -1, 0]]),
+     'type_of_equation': 'type1',
+     'is_general': True}
+    assert _classify_linear_system(eqs_4, funcs_2, t) == answer_4
+
+    eqs_5 = (5*x1 + 12*x(t) - 6*(y(t)) + x2, (2*y1 - 11*x(t) + 3*y(t)), (z1 - w(t)), (w1 - z(t)))
+    answer_5 = {'no_of_equation': 4, 'eq': (12*x(t) - 6*y(t) + 5*Derivative(x(t), t) + Derivative(x(t), (t, 2)),
+                -11*x(t) + 3*y(t) + 2*Derivative(y(t), t), -w(t) + Derivative(z(t), t), -z(t) + Derivative(w(t),
+                t)), 'func': [x(t), y(t), z(t), w(t)], 'order': {x(t): 2, y(t): 1, z(t): 1, w(t): 1}, 'is_linear':
+                True, 'is_homogeneous': True, 'is_general': True, 'type_of_equation': 'type0', 'is_higher_order': True}
+    assert _classify_linear_system(eqs_5, funcs_2, t) == answer_5
+
+    eqs_6 = (Eq(x1, 3*y(t) - 11*z(t)), Eq(y1, 7*z(t) - 3*x(t)), Eq(z1, 11*x(t) - 7*y(t)))
+    answer_6 = {'no_of_equation': 3, 'eq': (Eq(Derivative(x(t), t), 3*y(t) - 11*z(t)), Eq(Derivative(y(t), t), -3*x(t) + 7*z(t)),
+            Eq(Derivative(z(t), t), 11*x(t) - 7*y(t))), 'func': [x(t), y(t), z(t)], 'order': {x(t): 1, y(t): 1, z(t): 1},
+            'is_linear': True, 'is_constant': True, 'is_homogeneous': True,
+            'func_coeff': -Matrix([
+                         [  0, -3, 11],
+                         [  3,  0, -7],
+                         [-11,  7,  0]]),
+            'type_of_equation': 'type1', 'is_general': True}
+
+    assert _classify_linear_system(eqs_6, funcs_2[:-1], t) == answer_6
+
+    eqs_7 = (Eq(x1, y(t)), Eq(y1, x(t)))
+    answer_7 = {'no_of_equation': 2, 'eq': (Eq(Derivative(x(t), t), y(t)), Eq(Derivative(y(t), t), x(t))),
+                'func': [x(t), y(t)], 'order': {x(t): 1, y(t): 1}, 'is_linear': True, 'is_constant': True,
+                'is_homogeneous': True, 'func_coeff': -Matrix([
+                                                        [ 0, -1],
+                                                        [-1,  0]]),
+                'type_of_equation': 'type1', 'is_general': True}
+    assert _classify_linear_system(eqs_7, funcs, t) == answer_7
+
+    eqs_8 = (Eq(x1, 21*x(t)), Eq(y1, 17*x(t) + 3*y(t)), Eq(z1, 5*x(t) + 7*y(t) + 9*z(t)))
+    answer_8 = {'no_of_equation': 3, 'eq': (Eq(Derivative(x(t), t), 21*x(t)), Eq(Derivative(y(t), t), 17*x(t) + 3*y(t)),
+            Eq(Derivative(z(t), t), 5*x(t) + 7*y(t) + 9*z(t))), 'func': [x(t), y(t), z(t)], 'order': {x(t): 1, y(t): 1, z(t): 1},
+            'is_linear': True, 'is_constant': True, 'is_homogeneous': True,
+            'func_coeff': -Matrix([
+                            [-21,  0,  0],
+                            [-17, -3,  0],
+                            [ -5, -7, -9]]),
+            'type_of_equation': 'type1', 'is_general': True}
+
+    assert _classify_linear_system(eqs_8, funcs_2[:-1], t) == answer_8
+
+    eqs_9 = (Eq(x1, 4*x(t) + 5*y(t) + 2*z(t)), Eq(y1, x(t) + 13*y(t) + 9*z(t)), Eq(z1, 32*x(t) + 41*y(t) + 11*z(t)))
+    answer_9 = {'no_of_equation': 3, 'eq': (Eq(Derivative(x(t), t), 4*x(t) + 5*y(t) + 2*z(t)),
+                Eq(Derivative(y(t), t), x(t) + 13*y(t) + 9*z(t)), Eq(Derivative(z(t), t), 32*x(t) + 41*y(t) + 11*z(t))),
+                'func': [x(t), y(t), z(t)], 'order': {x(t): 1, y(t): 1, z(t): 1}, 'is_linear': True,
+                'is_constant': True, 'is_homogeneous': True,
+                'func_coeff': -Matrix([
+                            [ -4,  -5,  -2],
+                            [ -1, -13,  -9],
+                            [-32, -41, -11]]),
+                'type_of_equation': 'type1', 'is_general': True}
+    assert _classify_linear_system(eqs_9, funcs_2[:-1], t) == answer_9
+
+    eqs_10 = (Eq(3*x1, 4*5*(y(t) - z(t))), Eq(4*y1, 3*5*(z(t) - x(t))), Eq(5*z1, 3*4*(x(t) - y(t))))
+    answer_10 = {'no_of_equation': 3, 'eq': (Eq(3*Derivative(x(t), t), 20*y(t) - 20*z(t)),
+                Eq(4*Derivative(y(t), t), -15*x(t) + 15*z(t)), Eq(5*Derivative(z(t), t), 12*x(t) - 12*y(t))),
+                'func': [x(t), y(t), z(t)], 'order': {x(t): 1, y(t): 1, z(t): 1}, 'is_linear': True,
+                'is_constant': True, 'is_homogeneous': True,
+                'func_coeff': -Matrix([
+                                [  0, Rational(-20, 3),  Rational(20, 3)],
+                                [Rational(15, 4),     0, Rational(-15, 4)],
+                                [Rational(-12, 5), Rational(12, 5),  0]]),
+                'type_of_equation': 'type1', 'is_general': True}
+    assert _classify_linear_system(eqs_10, funcs_2[:-1], t) == answer_10
+
+    eq11 = (Eq(x1, 3*y(t) - 11*z(t)), Eq(y1, 7*z(t) - 3*x(t)), Eq(z1, 11*x(t) - 7*y(t)))
+    sol11 = {'no_of_equation': 3, 'eq': (Eq(Derivative(x(t), t), 3*y(t) - 11*z(t)), Eq(Derivative(y(t), t), -3*x(t) + 7*z(t)),
+            Eq(Derivative(z(t), t), 11*x(t) - 7*y(t))), 'func': [x(t), y(t), z(t)], 'order': {x(t): 1, y(t): 1, z(t): 1},
+            'is_linear': True, 'is_constant': True, 'is_homogeneous': True, 'func_coeff': -Matrix([
+            [  0, -3, 11], [  3,  0, -7], [-11,  7,  0]]), 'type_of_equation': 'type1', 'is_general': True}
+    assert _classify_linear_system(eq11, funcs_2[:-1], t) == sol11
+
+    eq12 = (Eq(Derivative(x(t), t), y(t)), Eq(Derivative(y(t), t), x(t)))
+    sol12 = {'no_of_equation': 2, 'eq': (Eq(Derivative(x(t), t), y(t)), Eq(Derivative(y(t), t), x(t))),
+             'func': [x(t), y(t)], 'order': {x(t): 1, y(t): 1}, 'is_linear': True, 'is_constant': True,
+             'is_homogeneous': True, 'func_coeff': -Matrix([
+            [0, -1],
+            [-1, 0]]), 'type_of_equation': 'type1', 'is_general': True}
+    assert _classify_linear_system(eq12, [x(t), y(t)], t) == sol12
+
+    eq13 = (Eq(Derivative(x(t), t), 21*x(t)), Eq(Derivative(y(t), t), 17*x(t) + 3*y(t)),
+            Eq(Derivative(z(t), t), 5*x(t) + 7*y(t) + 9*z(t)))
+    sol13 = {'no_of_equation': 3, 'eq': (
+    Eq(Derivative(x(t), t), 21 * x(t)), Eq(Derivative(y(t), t), 17 * x(t) + 3 * y(t)),
+    Eq(Derivative(z(t), t), 5 * x(t) + 7 * y(t) + 9 * z(t))), 'func': [x(t), y(t), z(t)],
+             'order': {x(t): 1, y(t): 1, z(t): 1}, 'is_linear': True, 'is_constant': True, 'is_homogeneous': True,
+             'func_coeff': -Matrix([
+                 [-21, 0, 0],
+                 [-17, -3, 0],
+                 [-5, -7, -9]]), 'type_of_equation': 'type1', 'is_general': True}
+    assert _classify_linear_system(eq13, [x(t), y(t), z(t)], t) == sol13
+
+    eq14 = (
+        Eq(Derivative(x(t), t), 4*x(t) + 5*y(t) + 2*z(t)), Eq(Derivative(y(t), t), x(t) + 13*y(t) + 9*z(t)),
+        Eq(Derivative(z(t), t), 32*x(t) + 41*y(t) + 11*z(t)))
+    sol14 = {'no_of_equation': 3, 'eq': (
+    Eq(Derivative(x(t), t), 4 * x(t) + 5 * y(t) + 2 * z(t)), Eq(Derivative(y(t), t), x(t) + 13 * y(t) + 9 * z(t)),
+    Eq(Derivative(z(t), t), 32 * x(t) + 41 * y(t) + 11 * z(t))), 'func': [x(t), y(t), z(t)],
+             'order': {x(t): 1, y(t): 1, z(t): 1}, 'is_linear': True, 'is_constant': True, 'is_homogeneous': True,
+             'func_coeff': -Matrix([
+                 [-4, -5, -2],
+                 [-1, -13, -9],
+                 [-32, -41, -11]]), 'type_of_equation': 'type1', 'is_general': True}
+    assert _classify_linear_system(eq14, [x(t), y(t), z(t)], t) == sol14
+
+    eq15 = (Eq(3*Derivative(x(t), t), 20*y(t) - 20*z(t)), Eq(4*Derivative(y(t), t), -15*x(t) + 15*z(t)),
+            Eq(5*Derivative(z(t), t), 12*x(t) - 12*y(t)))
+    sol15 = {'no_of_equation': 3, 'eq': (
+    Eq(3 * Derivative(x(t), t), 20 * y(t) - 20 * z(t)), Eq(4 * Derivative(y(t), t), -15 * x(t) + 15 * z(t)),
+    Eq(5 * Derivative(z(t), t), 12 * x(t) - 12 * y(t))), 'func': [x(t), y(t), z(t)],
+             'order': {x(t): 1, y(t): 1, z(t): 1}, 'is_linear': True, 'is_constant': True, 'is_homogeneous': True,
+             'func_coeff': -Matrix([
+                 [0, Rational(-20, 3), Rational(20, 3)],
+                 [Rational(15, 4), 0, Rational(-15, 4)],
+                 [Rational(-12, 5), Rational(12, 5), 0]]), 'type_of_equation': 'type1', 'is_general': True}
+    assert _classify_linear_system(eq15, [x(t), y(t), z(t)], t) == sol15
+
+    # Constant coefficient homogeneous ODEs
+    eq1 = (Eq(diff(x(t), t), x(t) + y(t) + 9), Eq(diff(y(t), t), 2*x(t) + 5*y(t) + 23))
+    sol1 = {'no_of_equation': 2, 'eq': (Eq(Derivative(x(t), t), x(t) + y(t) + 9),
+        Eq(Derivative(y(t), t), 2*x(t) + 5*y(t) + 23)), 'func': [x(t), y(t)],
+        'order': {x(t): 1, y(t): 1}, 'is_linear': True, 'is_constant': True, 'is_homogeneous': False, 'is_general': True,
+        'func_coeff': -Matrix([[-1, -1], [-2, -5]]), 'rhs': Matrix([[ 9], [23]]), 'type_of_equation': 'type2'}
+    assert _classify_linear_system(eq1, funcs, t) == sol1
+
+    # Non constant coefficient homogeneous ODEs
+    eq1 = (Eq(diff(x(t), t), 5*t*x(t) + 2*y(t)), Eq(diff(y(t), t), 2*x(t) + 5*t*y(t)))
+    sol1 = {'no_of_equation': 2, 'eq': (Eq(Derivative(x(t), t), 5*t*x(t) + 2*y(t)), Eq(Derivative(y(t), t), 5*t*y(t) + 2*x(t))),
+            'func': [x(t), y(t)], 'order': {x(t): 1, y(t): 1}, 'is_linear': True, 'is_constant': False,
+            'is_homogeneous': True, 'func_coeff': -Matrix([ [-5*t,   -2], [  -2, -5*t]]), 'commutative_antiderivative': Matrix([
+            [5*t**2/2,      2*t], [     2*t, 5*t**2/2]]), 'type_of_equation': 'type3', 'is_general': True}
+    assert _classify_linear_system(eq1, funcs, t) == sol1
+
+    # Non constant coefficient non-homogeneous ODEs
+    eq1 = [Eq(x1, x(t) + t*y(t) + t), Eq(y1, t*x(t) + y(t))]
+    sol1 = {'no_of_equation': 2, 'eq': [Eq(Derivative(x(t), t), t*y(t) + t + x(t)), Eq(Derivative(y(t), t),
+            t*x(t) + y(t))], 'func': [x(t), y(t)], 'order': {x(t): 1, y(t): 1}, 'is_linear': True,
+            'is_constant': False, 'is_homogeneous': False, 'is_general': True, 'func_coeff': -Matrix([ [-1, -t],
+            [-t, -1]]), 'commutative_antiderivative': Matrix([ [     t, t**2/2], [t**2/2,      t]]), 'rhs':
+            Matrix([ [t], [0]]), 'type_of_equation': 'type4'}
+    assert _classify_linear_system(eq1, funcs, t) == sol1
+
+    eq2 = [Eq(x1, t*x(t) + t*y(t) + t), Eq(y1, t*x(t) + t*y(t) + cos(t))]
+    sol2 = {'no_of_equation': 2, 'eq': [Eq(Derivative(x(t), t), t*x(t) + t*y(t) + t), Eq(Derivative(y(t), t),
+            t*x(t) + t*y(t) + cos(t))], 'func': [x(t), y(t)], 'order': {x(t): 1, y(t): 1}, 'is_linear': True,
+            'is_homogeneous': False, 'is_general': True, 'rhs': Matrix([ [     t], [cos(t)]]), 'func_coeff':
+            Matrix([ [t, t], [t, t]]), 'is_constant': False, 'type_of_equation': 'type4',
+            'commutative_antiderivative': Matrix([ [t**2/2, t**2/2], [t**2/2, t**2/2]])}
+    assert _classify_linear_system(eq2, funcs, t) == sol2
+
+    eq3 = [Eq(x1, t*(x(t) + y(t) + z(t) + 1)), Eq(y1, t*(x(t) + y(t) + z(t))), Eq(z1, t*(x(t) + y(t) + z(t)))]
+    sol3 = {'no_of_equation': 3, 'eq': [Eq(Derivative(x(t), t), t*(x(t) + y(t) + z(t) + 1)),
+            Eq(Derivative(y(t), t), t*(x(t) + y(t) + z(t))), Eq(Derivative(z(t), t), t*(x(t) + y(t) + z(t)))],
+            'func': [x(t), y(t), z(t)], 'order': {x(t): 1, y(t): 1, z(t): 1}, 'is_linear': True, 'is_constant':
+            False, 'is_homogeneous': False, 'is_general': True, 'func_coeff': -Matrix([ [-t, -t, -t], [-t, -t,
+            -t], [-t, -t, -t]]), 'commutative_antiderivative': Matrix([ [t**2/2, t**2/2, t**2/2], [t**2/2,
+            t**2/2, t**2/2], [t**2/2, t**2/2, t**2/2]]), 'rhs': Matrix([ [t], [0], [0]]), 'type_of_equation':
+            'type4'}
+    assert _classify_linear_system(eq3, funcs_2[:-1], t) == sol3
+
+    eq4 = [Eq(x1, x(t) + y(t) + t*z(t) + 1), Eq(y1, x(t) + t*y(t) + z(t) + 10), Eq(z1, t*x(t) + y(t) + z(t) + t)]
+    sol4 = {'no_of_equation': 3, 'eq': [Eq(Derivative(x(t), t), t*z(t) + x(t) + y(t) + 1), Eq(Derivative(y(t),
+            t), t*y(t) + x(t) + z(t) + 10), Eq(Derivative(z(t), t), t*x(t) + t + y(t) + z(t))], 'func': [x(t),
+            y(t), z(t)], 'order': {x(t): 1, y(t): 1, z(t): 1}, 'is_linear': True, 'is_constant': False,
+            'is_homogeneous': False, 'is_general': True, 'func_coeff': -Matrix([ [-1, -1, -t], [-1, -t, -1], [-t,
+            -1, -1]]), 'commutative_antiderivative': Matrix([ [     t,      t, t**2/2], [     t, t**2/2,
+            t], [t**2/2,      t,      t]]), 'rhs': Matrix([ [ 1], [10], [ t]]), 'type_of_equation': 'type4'}
+    assert _classify_linear_system(eq4, funcs_2[:-1], t) == sol4
+
+    sum_terms = t*(x(t) + y(t) + z(t) + w(t))
+    eq5 = [Eq(x1, sum_terms), Eq(y1, sum_terms), Eq(z1, sum_terms + 1), Eq(w1, sum_terms)]
+    sol5 = {'no_of_equation': 4, 'eq': [Eq(Derivative(x(t), t), t*(w(t) + x(t) + y(t) + z(t))),
+            Eq(Derivative(y(t), t), t*(w(t) + x(t) + y(t) + z(t))), Eq(Derivative(z(t), t), t*(w(t) + x(t) +
+            y(t) + z(t)) + 1), Eq(Derivative(w(t), t), t*(w(t) + x(t) + y(t) + z(t)))], 'func': [x(t), y(t),
+            z(t), w(t)], 'order': {x(t): 1, y(t): 1, z(t): 1, w(t): 1}, 'is_linear': True, 'is_constant': False,
+            'is_homogeneous': False, 'is_general': True, 'func_coeff': -Matrix([ [-t, -t, -t, -t], [-t, -t, -t,
+            -t], [-t, -t, -t, -t], [-t, -t, -t, -t]]), 'commutative_antiderivative': Matrix([ [t**2/2, t**2/2,
+            t**2/2, t**2/2], [t**2/2, t**2/2, t**2/2, t**2/2], [t**2/2, t**2/2, t**2/2, t**2/2], [t**2/2,
+            t**2/2, t**2/2, t**2/2]]), 'rhs': Matrix([ [0], [0], [1], [0]]), 'type_of_equation': 'type4'}
+    assert _classify_linear_system(eq5, funcs_2, t) == sol5
+
+    # Second Order
+    t_ = symbols("t_")
+
+    eq1 = (Eq(9*x(t) + 7*y(t) + 4*Derivative(x(t), t) + Derivative(x(t), (t, 2)) + 3*Derivative(y(t), t), 11*exp(I*t)),
+           Eq(3*x(t) + 12*y(t) + 5*Derivative(x(t), t) + 8*Derivative(y(t), t) + Derivative(y(t), (t, 2)), 2*exp(I*t)))
+    sol1 = {'no_of_equation': 2, 'eq': (Eq(9*x(t) + 7*y(t) + 4*Derivative(x(t), t) + Derivative(x(t), (t, 2)) +
+            3*Derivative(y(t), t), 11*exp(I*t)), Eq(3*x(t) + 12*y(t) + 5*Derivative(x(t), t) +
+            8*Derivative(y(t), t) + Derivative(y(t), (t, 2)), 2*exp(I*t))), 'func': [x(t), y(t)], 'order':
+            {x(t): 2, y(t): 2}, 'is_linear': True, 'is_homogeneous': False, 'is_general': True, 'rhs': Matrix([
+            [11*exp(I*t)], [ 2*exp(I*t)]]), 'type_of_equation': 'type0', 'is_second_order': True,
+            'is_higher_order': True}
+    assert _classify_linear_system(eq1, funcs, t) == sol1
+
+    eq2 = (Eq((4*t**2 + 7*t + 1)**2*Derivative(x(t), (t, 2)), 5*x(t) + 35*y(t)),
+           Eq((4*t**2 + 7*t + 1)**2*Derivative(y(t), (t, 2)), x(t) + 9*y(t)))
+    sol2 = {'no_of_equation': 2, 'eq': (Eq((4*t**2 + 7*t + 1)**2*Derivative(x(t), (t, 2)), 5*x(t) + 35*y(t)),
+            Eq((4*t**2 + 7*t + 1)**2*Derivative(y(t), (t, 2)), x(t) + 9*y(t))), 'func': [x(t), y(t)], 'order':
+            {x(t): 2, y(t): 2}, 'is_linear': True, 'is_homogeneous': True, 'is_general': True,
+            'type_of_equation': 'type2', 'A0': Matrix([ [Rational(53, 4),   35], [   1, Rational(69, 4)]]), 'g(t)': sqrt(4*t**2 + 7*t
+            + 1), 'tau': sqrt(33)*log(t - sqrt(33)/8 + Rational(7, 8))/33 - sqrt(33)*log(t + sqrt(33)/8 + Rational(7, 8))/33,
+            'is_transformed': True, 't_': t_, 'is_second_order': True, 'is_higher_order': True}
+    assert _classify_linear_system(eq2, funcs, t) == sol2
+
+    eq3 = ((t*Derivative(x(t), t) - x(t))*log(t) + (t*Derivative(y(t), t) - y(t))*exp(t) + Derivative(x(t), (t, 2)),
+            t**2*(t*Derivative(x(t), t) - x(t)) + t*(t*Derivative(y(t), t) - y(t)) + Derivative(y(t), (t, 2)))
+    sol3 = {'no_of_equation': 2, 'eq': ((t*Derivative(x(t), t) - x(t))*log(t) + (t*Derivative(y(t), t) -
+            y(t))*exp(t) + Derivative(x(t), (t, 2)), t**2*(t*Derivative(x(t), t) - x(t)) + t*(t*Derivative(y(t),
+            t) - y(t)) + Derivative(y(t), (t, 2))), 'func': [x(t), y(t)], 'order': {x(t): 2, y(t): 2},
+            'is_linear': True, 'is_homogeneous': True, 'is_general': True, 'type_of_equation': 'type1', 'A1':
+            Matrix([ [-t*log(t), -t*exp(t)], [    -t**3,     -t**2]]), 'is_second_order': True,
+            'is_higher_order': True}
+    assert _classify_linear_system(eq3, funcs, t) == sol3
+
+    eq4 = (Eq(x2, k*x(t) - l*y1), Eq(y2, l*x1 + k*y(t)))
+    sol4 = {'no_of_equation': 2, 'eq': (Eq(Derivative(x(t), (t, 2)), k*x(t) - l*Derivative(y(t), t)),
+            Eq(Derivative(y(t), (t, 2)), k*y(t) + l*Derivative(x(t), t))), 'func': [x(t), y(t)], 'order': {x(t):
+            2, y(t): 2}, 'is_linear': True, 'is_homogeneous': True, 'is_general': True, 'type_of_equation':
+            'type0', 'is_second_order': True, 'is_higher_order': True}
+    assert _classify_linear_system(eq4, funcs, t) == sol4
+
+
+    # Multiple matches
+
+    f, g = symbols("f g", cls=Function)
+    y, t_ = symbols("y t_")
+    funcs = [f(t), g(t)]
+
+    eq1 = [Eq(Derivative(f(t), t)**2 - 2*Derivative(f(t), t) + 1, 4),
+            Eq(-y*f(t) + Derivative(g(t), t), 0)]
+    sol1 = {'is_implicit': True,
+             'canon_eqs': [[Eq(Derivative(f(t), t), -1), Eq(Derivative(g(t), t), y*f(t))],
+              [Eq(Derivative(f(t), t), 3), Eq(Derivative(g(t), t), y*f(t))]]}
+    assert _classify_linear_system(eq1, funcs, t) == sol1
+
+    raises(ValueError, lambda: _classify_linear_system(eq1, funcs[:1], t))
+
+    eq2 = [Eq(Derivative(f(t), t), (2*f(t) + g(t) + 1)/t), Eq(Derivative(g(t), t), (f(t) + 2*g(t))/t)]
+    sol2 = {'no_of_equation': 2, 'eq': [Eq(Derivative(f(t), t), (2*f(t) + g(t) + 1)/t), Eq(Derivative(g(t), t),
+            (f(t) + 2*g(t))/t)], 'func': [f(t), g(t)], 'order': {f(t): 1, g(t): 1}, 'is_linear': True,
+            'is_homogeneous': False, 'is_general': True, 'rhs': Matrix([ [1], [0]]), 'func_coeff': Matrix([ [2,
+            1], [1, 2]]), 'is_constant': False, 'type_of_equation': 'type6', 't_': t_, 'tau': log(t),
+            'commutative_antiderivative': Matrix([ [2*log(t),   log(t)], [  log(t), 2*log(t)]])}
+    assert _classify_linear_system(eq2, funcs, t) == sol2
+
+    eq3 = [Eq(Derivative(f(t), t), (2*f(t) + g(t))/t), Eq(Derivative(g(t), t), (f(t) + 2*g(t))/t)]
+    sol3 = {'no_of_equation': 2, 'eq': [Eq(Derivative(f(t), t), (2*f(t) + g(t))/t), Eq(Derivative(g(t), t),
+            (f(t) + 2*g(t))/t)], 'func': [f(t), g(t)], 'order': {f(t): 1, g(t): 1}, 'is_linear': True,
+            'is_homogeneous': True, 'is_general': True, 'func_coeff': Matrix([ [2, 1], [1, 2]]), 'is_constant':
+            False, 'type_of_equation': 'type5', 't_': t_, 'rhs': Matrix([ [0], [0]]), 'tau': log(t),
+            'commutative_antiderivative': Matrix([ [2*log(t),   log(t)], [  log(t), 2*log(t)]])}
+    assert _classify_linear_system(eq3, funcs, t) == sol3
+
+
+def test_matrix_exp():
+    from sympy.matrices.dense import Matrix, eye, zeros
+    from sympy.solvers.ode.systems import matrix_exp
+    t = Symbol('t')
+
+    for n in range(1, 6+1):
+        assert matrix_exp(zeros(n), t) == eye(n)
+
+    for n in range(1, 6+1):
+        A = eye(n)
+        expAt = exp(t) * eye(n)
+        assert matrix_exp(A, t) == expAt
+
+    for n in range(1, 6+1):
+        A = Matrix(n, n, lambda i,j: i+1 if i==j else 0)
+        expAt = Matrix(n, n, lambda i,j: exp((i+1)*t) if i==j else 0)
+        assert matrix_exp(A, t) == expAt
+
+    A = Matrix([[0, 1], [-1, 0]])
+    expAt = Matrix([[cos(t), sin(t)], [-sin(t), cos(t)]])
+    assert matrix_exp(A, t) == expAt
+
+    A = Matrix([[2, -5], [2, -4]])
+    expAt = Matrix([
+            [3*exp(-t)*sin(t) + exp(-t)*cos(t), -5*exp(-t)*sin(t)],
+            [2*exp(-t)*sin(t), -3*exp(-t)*sin(t) + exp(-t)*cos(t)]
+            ])
+    assert matrix_exp(A, t) == expAt
+
+    A = Matrix([[21, 17, 6], [-5, -1, -6], [4, 4, 16]])
+    # TO update this.
+    # expAt = Matrix([
+    #     [(8*t*exp(12*t) + 5*exp(12*t) - 1)*exp(4*t)/4,
+    #      (8*t*exp(12*t) + 5*exp(12*t) - 5)*exp(4*t)/4,
+    #      (exp(12*t) - 1)*exp(4*t)/2],
+    #     [(-8*t*exp(12*t) - exp(12*t) + 1)*exp(4*t)/4,
+    #      (-8*t*exp(12*t) - exp(12*t) + 5)*exp(4*t)/4,
+    #      (-exp(12*t) + 1)*exp(4*t)/2],
+    #     [4*t*exp(16*t), 4*t*exp(16*t), exp(16*t)]])
+    expAt = Matrix([
+        [2*t*exp(16*t) + 5*exp(16*t)/4 - exp(4*t)/4, 2*t*exp(16*t) + 5*exp(16*t)/4 - 5*exp(4*t)/4,  exp(16*t)/2 - exp(4*t)/2],
+        [ -2*t*exp(16*t) - exp(16*t)/4 + exp(4*t)/4,  -2*t*exp(16*t) - exp(16*t)/4 + 5*exp(4*t)/4, -exp(16*t)/2 + exp(4*t)/2],
+        [                             4*t*exp(16*t),                                4*t*exp(16*t),                 exp(16*t)]
+        ])
+    assert matrix_exp(A, t) == expAt
+
+    A = Matrix([[1, 1, 0, 0],
+                [0, 1, 1, 0],
+                [0, 0, 1, -S(1)/8],
+                [0, 0, S(1)/2, S(1)/2]])
+    expAt = Matrix([
+        [exp(t), t*exp(t), 4*t*exp(3*t/4) + 8*t*exp(t) + 48*exp(3*t/4) - 48*exp(t),
+                            -2*t*exp(3*t/4) - 2*t*exp(t) - 16*exp(3*t/4) + 16*exp(t)],
+        [0, exp(t), -t*exp(3*t/4) - 8*exp(3*t/4) + 8*exp(t), t*exp(3*t/4)/2 + 2*exp(3*t/4) - 2*exp(t)],
+        [0, 0, t*exp(3*t/4)/4 + exp(3*t/4), -t*exp(3*t/4)/8],
+        [0, 0, t*exp(3*t/4)/2, -t*exp(3*t/4)/4 + exp(3*t/4)]
+        ])
+    assert matrix_exp(A, t) == expAt
+
+    A = Matrix([
+    [ 0, 1,  0, 0],
+    [-1, 0,  0, 0],
+    [ 0, 0,  0, 1],
+    [ 0, 0, -1, 0]])
+
+    expAt = Matrix([
+    [ cos(t), sin(t),         0,        0],
+    [-sin(t), cos(t),         0,        0],
+    [      0,      0,    cos(t),   sin(t)],
+    [      0,      0,   -sin(t),   cos(t)]])
+    assert matrix_exp(A, t) == expAt
+
+    A = Matrix([
+    [ 0, 1,  1, 0],
+    [-1, 0,  0, 1],
+    [ 0, 0,  0, 1],
+    [ 0, 0, -1, 0]])
+
+    expAt = Matrix([
+    [ cos(t), sin(t),  t*cos(t), t*sin(t)],
+    [-sin(t), cos(t), -t*sin(t), t*cos(t)],
+    [      0,      0,    cos(t),   sin(t)],
+    [      0,      0,   -sin(t),   cos(t)]])
+    assert matrix_exp(A, t) == expAt
+
+    # This case is unacceptably slow right now but should be solvable...
+    #a, b, c, d, e, f = symbols('a b c d e f')
+    #A = Matrix([
+    #[-a,  b,          c,  d],
+    #[ a, -b,          e,  0],
+    #[ 0,  0, -c - e - f,  0],
+    #[ 0,  0,          f, -d]])
+
+    A = Matrix([[0, I], [I, 0]])
+    expAt = Matrix([
+    [exp(I*t)/2 + exp(-I*t)/2, exp(I*t)/2 - exp(-I*t)/2],
+    [exp(I*t)/2 - exp(-I*t)/2, exp(I*t)/2 + exp(-I*t)/2]])
+    assert matrix_exp(A, t) == expAt
+
+    # Testing Errors
+    M = Matrix([[1, 2, 3], [4, 5, 6], [7, 7, 7]])
+    M1 = Matrix([[t, 1], [1, 1]])
+
+    raises(ValueError, lambda: matrix_exp(M[:, :2], t))
+    raises(ValueError, lambda: matrix_exp(M[:2, :], t))
+    raises(ValueError, lambda: matrix_exp(M1, t))
+    raises(ValueError, lambda: matrix_exp(M1[:1, :1], t))
+
+
+def test_canonical_odes():
+    f, g, h = symbols('f g h', cls=Function)
+    x = symbols('x')
+    funcs = [f(x), g(x), h(x)]
+
+    eqs1 = [Eq(f(x).diff(x, x), f(x) + 2*g(x)), Eq(g(x) + 1, g(x).diff(x) + f(x))]
+    sol1 = [[Eq(Derivative(f(x), (x, 2)), f(x) + 2*g(x)), Eq(Derivative(g(x), x), -f(x) + g(x) + 1)]]
+    assert canonical_odes(eqs1, funcs[:2], x) == sol1
+
+    eqs2 = [Eq(f(x).diff(x), h(x).diff(x) + f(x)), Eq(g(x).diff(x)**2, f(x) + h(x)), Eq(h(x).diff(x), f(x))]
+    sol2 = [[Eq(Derivative(f(x), x), 2*f(x)), Eq(Derivative(g(x), x), -sqrt(f(x) + h(x))), Eq(Derivative(h(x), x), f(x))],
+            [Eq(Derivative(f(x), x), 2*f(x)), Eq(Derivative(g(x), x), sqrt(f(x) + h(x))), Eq(Derivative(h(x), x), f(x))]]
+    assert canonical_odes(eqs2, funcs, x) == sol2
+
+
+def test_sysode_linear_neq_order1_type1():
+
+    f, g, x, y, h = symbols('f g x y h', cls=Function)
+    a, b, c, t = symbols('a b c t')
+
+    eqs1 = [Eq(Derivative(x(t), t), x(t)),
+            Eq(Derivative(y(t), t), y(t))]
+    sol1 = [Eq(x(t), C1*exp(t)),
+            Eq(y(t), C2*exp(t))]
+    assert dsolve(eqs1) == sol1
+    assert checksysodesol(eqs1, sol1) == (True, [0, 0])
+
+    eqs2 = [Eq(Derivative(x(t), t), 2*x(t)),
+            Eq(Derivative(y(t), t), 3*y(t))]
+    sol2 = [Eq(x(t), C1*exp(2*t)),
+            Eq(y(t), C2*exp(3*t))]
+    assert dsolve(eqs2) == sol2
+    assert checksysodesol(eqs2, sol2) == (True, [0, 0])
+
+    eqs3 = [Eq(Derivative(x(t), t), a*x(t)),
+            Eq(Derivative(y(t), t), a*y(t))]
+    sol3 = [Eq(x(t), C1*exp(a*t)),
+            Eq(y(t), C2*exp(a*t))]
+    assert dsolve(eqs3) == sol3
+    assert checksysodesol(eqs3, sol3) == (True, [0, 0])
+
+    # Regression test case for issue #15474
+    # https://github.com/sympy/sympy/issues/15474
+    eqs4 = [Eq(Derivative(x(t), t), a*x(t)),
+            Eq(Derivative(y(t), t), b*y(t))]
+    sol4 = [Eq(x(t), C1*exp(a*t)),
+            Eq(y(t), C2*exp(b*t))]
+    assert dsolve(eqs4) == sol4
+    assert checksysodesol(eqs4, sol4) == (True, [0, 0])
+
+    eqs5 = [Eq(Derivative(x(t), t), -y(t)),
+            Eq(Derivative(y(t), t), x(t))]
+    sol5 = [Eq(x(t), -C1*sin(t) - C2*cos(t)),
+            Eq(y(t), C1*cos(t) - C2*sin(t))]
+    assert dsolve(eqs5) == sol5
+    assert checksysodesol(eqs5, sol5) == (True, [0, 0])
+
+    eqs6 = [Eq(Derivative(x(t), t), -2*y(t)),
+            Eq(Derivative(y(t), t), 2*x(t))]
+    sol6 = [Eq(x(t), -C1*sin(2*t) - C2*cos(2*t)),
+            Eq(y(t), C1*cos(2*t) - C2*sin(2*t))]
+    assert dsolve(eqs6) == sol6
+    assert checksysodesol(eqs6, sol6) == (True, [0, 0])
+
+    eqs7 = [Eq(Derivative(x(t), t), I*y(t)),
+            Eq(Derivative(y(t), t), I*x(t))]
+    sol7 = [Eq(x(t), -C1*exp(-I*t) + C2*exp(I*t)),
+            Eq(y(t), C1*exp(-I*t) + C2*exp(I*t))]
+    assert dsolve(eqs7) == sol7
+    assert checksysodesol(eqs7, sol7) == (True, [0, 0])
+
+    eqs8 = [Eq(Derivative(x(t), t), -a*y(t)),
+            Eq(Derivative(y(t), t), a*x(t))]
+    sol8 = [Eq(x(t), -I*C1*exp(-I*a*t) + I*C2*exp(I*a*t)),
+            Eq(y(t), C1*exp(-I*a*t) + C2*exp(I*a*t))]
+    assert dsolve(eqs8) == sol8
+    assert checksysodesol(eqs8, sol8) == (True, [0, 0])
+
+    eqs9 = [Eq(Derivative(x(t), t), x(t) + y(t)),
+            Eq(Derivative(y(t), t), x(t) - y(t))]
+    sol9 = [Eq(x(t), C1*(1 - sqrt(2))*exp(-sqrt(2)*t) + C2*(1 + sqrt(2))*exp(sqrt(2)*t)),
+            Eq(y(t), C1*exp(-sqrt(2)*t) + C2*exp(sqrt(2)*t))]
+    assert dsolve(eqs9) == sol9
+    assert checksysodesol(eqs9, sol9) == (True, [0, 0])
+
+    eqs10 = [Eq(Derivative(x(t), t), x(t) + y(t)),
+             Eq(Derivative(y(t), t), x(t) + y(t))]
+    sol10 = [Eq(x(t), -C1 + C2*exp(2*t)),
+             Eq(y(t), C1 + C2*exp(2*t))]
+    assert dsolve(eqs10) == sol10
+    assert checksysodesol(eqs10, sol10) == (True, [0, 0])
+
+    eqs11 = [Eq(Derivative(x(t), t), 2*x(t) + y(t)),
+             Eq(Derivative(y(t), t), -x(t) + 2*y(t))]
+    sol11 = [Eq(x(t), C1*exp(2*t)*sin(t) + C2*exp(2*t)*cos(t)),
+             Eq(y(t), C1*exp(2*t)*cos(t) - C2*exp(2*t)*sin(t))]
+    assert dsolve(eqs11) == sol11
+    assert checksysodesol(eqs11, sol11) == (True, [0, 0])
+
+    eqs12 = [Eq(Derivative(x(t), t), x(t) + 2*y(t)),
+             Eq(Derivative(y(t), t), 2*x(t) + y(t))]
+    sol12 = [Eq(x(t), -C1*exp(-t) + C2*exp(3*t)),
+             Eq(y(t), C1*exp(-t) + C2*exp(3*t))]
+    assert dsolve(eqs12) == sol12
+    assert checksysodesol(eqs12, sol12) == (True, [0, 0])
+
+    eqs13 = [Eq(Derivative(x(t), t), 4*x(t) + y(t)),
+             Eq(Derivative(y(t), t), -x(t) + 2*y(t))]
+    sol13 = [Eq(x(t), C2*t*exp(3*t) + (C1 + C2)*exp(3*t)),
+             Eq(y(t), -C1*exp(3*t) - C2*t*exp(3*t))]
+    assert dsolve(eqs13) == sol13
+    assert checksysodesol(eqs13, sol13) == (True, [0, 0])
+
+    eqs14 = [Eq(Derivative(x(t), t), a*y(t)),
+             Eq(Derivative(y(t), t), a*x(t))]
+    sol14 = [Eq(x(t), -C1*exp(-a*t) + C2*exp(a*t)),
+             Eq(y(t), C1*exp(-a*t) + C2*exp(a*t))]
+    assert dsolve(eqs14) == sol14
+    assert checksysodesol(eqs14, sol14) == (True, [0, 0])
+
+    eqs15 = [Eq(Derivative(x(t), t), a*y(t)),
+             Eq(Derivative(y(t), t), b*x(t))]
+    sol15 = [Eq(x(t), -C1*a*exp(-t*sqrt(a*b))/sqrt(a*b) + C2*a*exp(t*sqrt(a*b))/sqrt(a*b)),
+             Eq(y(t), C1*exp(-t*sqrt(a*b)) + C2*exp(t*sqrt(a*b)))]
+    assert dsolve(eqs15) == sol15
+    assert checksysodesol(eqs15, sol15) == (True, [0, 0])
+
+    eqs16 = [Eq(Derivative(x(t), t), a*x(t) + b*y(t)),
+             Eq(Derivative(y(t), t), c*x(t))]
+    sol16 = [Eq(x(t), -2*C1*b*exp(t*(a + sqrt(a**2 + 4*b*c))/2)/(a - sqrt(a**2 + 4*b*c)) - 2*C2*b*exp(t*(a -
+              sqrt(a**2 + 4*b*c))/2)/(a + sqrt(a**2 + 4*b*c))),
+             Eq(y(t), C1*exp(t*(a + sqrt(a**2 + 4*b*c))/2) + C2*exp(t*(a - sqrt(a**2 + 4*b*c))/2))]
+    assert dsolve(eqs16) == sol16
+    assert checksysodesol(eqs16, sol16) == (True, [0, 0])
+
+    # Regression test case for issue #18562
+    # https://github.com/sympy/sympy/issues/18562
+    eqs17 = [Eq(Derivative(x(t), t), a*y(t) + x(t)),
+            Eq(Derivative(y(t), t), a*x(t) - y(t))]
+    sol17 = [Eq(x(t), C1*a*exp(t*sqrt(a**2 + 1))/(sqrt(a**2 + 1) - 1) - C2*a*exp(-t*sqrt(a**2 + 1))/(sqrt(a**2 +
+              1) + 1)),
+            Eq(y(t), C1*exp(t*sqrt(a**2 + 1)) + C2*exp(-t*sqrt(a**2 + 1)))]
+    assert dsolve(eqs17) == sol17
+    assert checksysodesol(eqs17, sol17) == (True, [0, 0])
+
+    eqs18 = [Eq(Derivative(x(t), t), 0),
+            Eq(Derivative(y(t), t), 0)]
+    sol18 = [Eq(x(t), C1),
+            Eq(y(t), C2)]
+    assert dsolve(eqs18) == sol18
+    assert checksysodesol(eqs18, sol18) == (True, [0, 0])
+
+    eqs19 = [Eq(Derivative(x(t), t), 2*x(t) - y(t)),
+            Eq(Derivative(y(t), t), x(t))]
+    sol19 = [Eq(x(t), C2*t*exp(t) + (C1 + C2)*exp(t)),
+            Eq(y(t), C1*exp(t) + C2*t*exp(t))]
+    assert dsolve(eqs19) == sol19
+    assert checksysodesol(eqs19, sol19) == (True, [0, 0])
+
+    eqs20 = [Eq(Derivative(x(t), t), x(t)),
+            Eq(Derivative(y(t), t), x(t) + y(t))]
+    sol20 = [Eq(x(t), C1*exp(t)),
+            Eq(y(t), C1*t*exp(t) + C2*exp(t))]
+    assert dsolve(eqs20) == sol20
+    assert checksysodesol(eqs20, sol20) == (True, [0, 0])
+
+    eqs21 = [Eq(Derivative(x(t), t), 3*x(t)),
+            Eq(Derivative(y(t), t), x(t) + y(t))]
+    sol21 = [Eq(x(t), 2*C1*exp(3*t)),
+            Eq(y(t), C1*exp(3*t) + C2*exp(t))]
+    assert dsolve(eqs21) == sol21
+    assert checksysodesol(eqs21, sol21) == (True, [0, 0])
+
+    eqs22 = [Eq(Derivative(x(t), t), 3*x(t)),
+            Eq(Derivative(y(t), t), y(t))]
+    sol22 = [Eq(x(t), C1*exp(3*t)),
+            Eq(y(t), C2*exp(t))]
+    assert dsolve(eqs22) == sol22
+    assert checksysodesol(eqs22, sol22) == (True, [0, 0])
+
+
+@slow
+def test_sysode_linear_neq_order1_type1_slow():
+
+    t = Symbol('t')
+    Z0 = Function('Z0')
+    Z1 = Function('Z1')
+    Z2 = Function('Z2')
+    Z3 = Function('Z3')
+
+    k01, k10, k20, k21, k23, k30 = symbols('k01 k10 k20 k21 k23 k30')
+
+    eqs1 = [Eq(Derivative(Z0(t), t), -k01*Z0(t) + k10*Z1(t) + k20*Z2(t) + k30*Z3(t)),
+            Eq(Derivative(Z1(t), t), k01*Z0(t) - k10*Z1(t) + k21*Z2(t)),
+            Eq(Derivative(Z2(t), t), (-k20 - k21 - k23)*Z2(t)),
+            Eq(Derivative(Z3(t), t), k23*Z2(t) - k30*Z3(t))]
+    sol1 = [Eq(Z0(t), C1*k10/k01 - C2*(k10 - k30)*exp(-k30*t)/(k01 + k10 - k30) - C3*(k10*(k20 + k21 - k30) -
+             k20**2 - k20*(k21 + k23 - k30) + k23*k30)*exp(-t*(k20 + k21 + k23))/(k23*(-k01 - k10 + k20 + k21 +
+             k23)) - C4*exp(-t*(k01 + k10))),
+            Eq(Z1(t), C1 - C2*k01*exp(-k30*t)/(k01 + k10 - k30) + C3*(-k01*(k20 + k21 - k30) + k20*k21 + k21**2
+             + k21*(k23 - k30))*exp(-t*(k20 + k21 + k23))/(k23*(-k01 - k10 + k20 + k21 + k23)) + C4*exp(-t*(k01 +
+             k10))),
+            Eq(Z2(t), -C3*(k20 + k21 + k23 - k30)*exp(-t*(k20 + k21 + k23))/k23),
+            Eq(Z3(t), C2*exp(-k30*t) + C3*exp(-t*(k20 + k21 + k23)))]
+    assert dsolve(eqs1) == sol1
+    assert checksysodesol(eqs1, sol1) == (True, [0, 0, 0, 0])
+
+    x, y, z, u, v, w = symbols('x y z u v w', cls=Function)
+    k2, k3 = symbols('k2 k3')
+    a_b, a_c = symbols('a_b a_c', real=True)
+
+    eqs2 = [Eq(Derivative(z(t), t), k2*y(t)),
+            Eq(Derivative(x(t), t), k3*y(t)),
+            Eq(Derivative(y(t), t), (-k2 - k3)*y(t))]
+    sol2 = [Eq(z(t), C1 - C2*k2*exp(-t*(k2 + k3))/(k2 + k3)),
+            Eq(x(t), -C2*k3*exp(-t*(k2 + k3))/(k2 + k3) + C3),
+            Eq(y(t), C2*exp(-t*(k2 + k3)))]
+    assert dsolve(eqs2) == sol2
+    assert checksysodesol(eqs2, sol2) == (True, [0, 0, 0])
+
+    eqs3 = [4*u(t) - v(t) - 2*w(t) + Derivative(u(t), t),
+            2*u(t) + v(t) - 2*w(t) + Derivative(v(t), t),
+            5*u(t) + v(t) - 3*w(t) + Derivative(w(t), t)]
+    sol3 = [Eq(u(t), C3*exp(-2*t) + (C1/2 + sqrt(3)*C2/6)*cos(sqrt(3)*t) + sin(sqrt(3)*t)*(sqrt(3)*C1/6 +
+             C2*Rational(-1, 2))),
+            Eq(v(t), (C1/2 + sqrt(3)*C2/6)*cos(sqrt(3)*t) + sin(sqrt(3)*t)*(sqrt(3)*C1/6 + C2*Rational(-1, 2))),
+            Eq(w(t), C1*cos(sqrt(3)*t) - C2*sin(sqrt(3)*t) + C3*exp(-2*t))]
+    assert dsolve(eqs3) == sol3
+    assert checksysodesol(eqs3, sol3) == (True, [0, 0, 0])
+
+    eqs4 = [Eq(Derivative(x(t), t), w(t)*Rational(-2, 9) + 2*x(t) + y(t) + z(t)*Rational(-8, 9)),
+            Eq(Derivative(y(t), t), w(t)*Rational(4, 9) + 2*y(t) + z(t)*Rational(16, 9)),
+            Eq(Derivative(z(t), t), w(t)*Rational(-2, 9) + z(t)*Rational(37, 9)),
+            Eq(Derivative(w(t), t), w(t)*Rational(44, 9) + z(t)*Rational(-4, 9))]
+    sol4 = [Eq(x(t), C1*exp(2*t) + C2*t*exp(2*t)),
+            Eq(y(t), C2*exp(2*t) + 2*C3*exp(4*t)),
+            Eq(z(t), 2*C3*exp(4*t) + C4*exp(5*t)*Rational(-1, 4)),
+            Eq(w(t), C3*exp(4*t) + C4*exp(5*t))]
+    assert dsolve(eqs4) == sol4
+    assert checksysodesol(eqs4, sol4) == (True, [0, 0, 0, 0])
+
+    # Regression test case for issue #15574
+    # https://github.com/sympy/sympy/issues/15574
+    eq5 = [Eq(x(t).diff(t), x(t)), Eq(y(t).diff(t), y(t)), Eq(z(t).diff(t), z(t)), Eq(w(t).diff(t), w(t))]
+    sol5 = [Eq(x(t), C1*exp(t)), Eq(y(t), C2*exp(t)), Eq(z(t), C3*exp(t)), Eq(w(t), C4*exp(t))]
+    assert dsolve(eq5) == sol5
+    assert checksysodesol(eq5, sol5) == (True, [0, 0, 0, 0])
+
+    eqs6 = [Eq(Derivative(x(t), t), x(t) + y(t)),
+            Eq(Derivative(y(t), t), y(t) + z(t)),
+            Eq(Derivative(z(t), t), w(t)*Rational(-1, 8) + z(t)),
+            Eq(Derivative(w(t), t), w(t)/2 + z(t)/2)]
+    sol6 = [Eq(x(t), C1*exp(t) + C2*t*exp(t) + 4*C4*t*exp(t*Rational(3, 4)) + (4*C3 + 48*C4)*exp(t*Rational(3,
+             4))),
+            Eq(y(t), C2*exp(t) - C4*t*exp(t*Rational(3, 4)) - (C3 + 8*C4)*exp(t*Rational(3, 4))),
+            Eq(z(t), C4*t*exp(t*Rational(3, 4))/4 + (C3/4 + C4)*exp(t*Rational(3, 4))),
+            Eq(w(t), C3*exp(t*Rational(3, 4))/2 + C4*t*exp(t*Rational(3, 4))/2)]
+    assert dsolve(eqs6) == sol6
+    assert checksysodesol(eqs6, sol6) == (True, [0, 0, 0, 0])
+
+    # Regression test case for issue #15574
+    # https://github.com/sympy/sympy/issues/15574
+    eq7 = [Eq(Derivative(x(t), t), x(t)), Eq(Derivative(y(t), t), y(t)), Eq(Derivative(z(t), t), z(t)),
+           Eq(Derivative(w(t), t), w(t)), Eq(Derivative(u(t), t), u(t))]
+    sol7 = [Eq(x(t), C1*exp(t)), Eq(y(t), C2*exp(t)), Eq(z(t), C3*exp(t)), Eq(w(t), C4*exp(t)),
+            Eq(u(t), C5*exp(t))]
+    assert dsolve(eq7) == sol7
+    assert checksysodesol(eq7, sol7) == (True, [0, 0, 0, 0, 0])
+
+    eqs8 = [Eq(Derivative(x(t), t), 2*x(t) + y(t)),
+            Eq(Derivative(y(t), t), 2*y(t)),
+            Eq(Derivative(z(t), t), 4*z(t)),
+            Eq(Derivative(w(t), t), u(t) + 5*w(t)),
+            Eq(Derivative(u(t), t), 5*u(t))]
+    sol8 = [Eq(x(t), C1*exp(2*t) + C2*t*exp(2*t)),
+            Eq(y(t), C2*exp(2*t)),
+            Eq(z(t), C3*exp(4*t)),
+            Eq(w(t), C4*exp(5*t) + C5*t*exp(5*t)),
+            Eq(u(t), C5*exp(5*t))]
+    assert dsolve(eqs8) == sol8
+    assert checksysodesol(eqs8, sol8) == (True, [0, 0, 0, 0, 0])
+
+    # Regression test case for issue #15574
+    # https://github.com/sympy/sympy/issues/15574
+    eq9 = [Eq(Derivative(x(t), t), x(t)), Eq(Derivative(y(t), t), y(t)), Eq(Derivative(z(t), t), z(t))]
+    sol9 = [Eq(x(t), C1*exp(t)), Eq(y(t), C2*exp(t)), Eq(z(t), C3*exp(t))]
+    assert dsolve(eq9) == sol9
+    assert checksysodesol(eq9, sol9) == (True, [0, 0, 0])
+
+    # Regression test case for issue #15407
+    # https://github.com/sympy/sympy/issues/15407
+    eqs10 = [Eq(Derivative(x(t), t), (-a_b - a_c)*x(t)),
+             Eq(Derivative(y(t), t), a_b*y(t)),
+             Eq(Derivative(z(t), t), a_c*x(t))]
+    sol10 = [Eq(x(t), -C1*(a_b + a_c)*exp(-t*(a_b + a_c))/a_c),
+             Eq(y(t), C2*exp(a_b*t)),
+             Eq(z(t), C1*exp(-t*(a_b + a_c)) + C3)]
+    assert dsolve(eqs10) == sol10
+    assert checksysodesol(eqs10, sol10) == (True, [0, 0, 0])
+
+    # Regression test case for issue #14312
+    # https://github.com/sympy/sympy/issues/14312
+    eqs11 = [Eq(Derivative(x(t), t), k3*y(t)),
+             Eq(Derivative(y(t), t), (-k2 - k3)*y(t)),
+             Eq(Derivative(z(t), t), k2*y(t))]
+    sol11 = [Eq(x(t), C1 + C2*k3*exp(-t*(k2 + k3))/k2),
+             Eq(y(t), -C2*(k2 + k3)*exp(-t*(k2 + k3))/k2),
+             Eq(z(t), C2*exp(-t*(k2 + k3)) + C3)]
+    assert dsolve(eqs11) == sol11
+    assert checksysodesol(eqs11, sol11) == (True, [0, 0, 0])
+
+    # Regression test case for issue #14312
+    # https://github.com/sympy/sympy/issues/14312
+    eqs12 = [Eq(Derivative(z(t), t), k2*y(t)),
+             Eq(Derivative(x(t), t), k3*y(t)),
+             Eq(Derivative(y(t), t), (-k2 - k3)*y(t))]
+    sol12 = [Eq(z(t), C1 - C2*k2*exp(-t*(k2 + k3))/(k2 + k3)),
+             Eq(x(t), -C2*k3*exp(-t*(k2 + k3))/(k2 + k3) + C3),
+             Eq(y(t), C2*exp(-t*(k2 + k3)))]
+    assert dsolve(eqs12) == sol12
+    assert checksysodesol(eqs12, sol12) == (True, [0, 0, 0])
+
+    f, g, h = symbols('f, g, h', cls=Function)
+    a, b, c = symbols('a, b, c')
+
+    # Regression test case for issue #15474
+    # https://github.com/sympy/sympy/issues/15474
+    eqs13 = [Eq(Derivative(f(t), t), 2*f(t) + g(t)),
+             Eq(Derivative(g(t), t), a*f(t))]
+    sol13 = [Eq(f(t), C1*exp(t*(sqrt(a + 1) + 1))/(sqrt(a + 1) - 1) - C2*exp(-t*(sqrt(a + 1) - 1))/(sqrt(a + 1) +
+              1)),
+             Eq(g(t), C1*exp(t*(sqrt(a + 1) + 1)) + C2*exp(-t*(sqrt(a + 1) - 1)))]
+    assert dsolve(eqs13) == sol13
+    assert checksysodesol(eqs13, sol13) == (True, [0, 0])
+
+    eqs14 = [Eq(Derivative(f(t), t), 2*g(t) - 3*h(t)),
+             Eq(Derivative(g(t), t), -2*f(t) + 4*h(t)),
+             Eq(Derivative(h(t), t), 3*f(t) - 4*g(t))]
+    sol14 = [Eq(f(t), 2*C1 - sin(sqrt(29)*t)*(sqrt(29)*C2*Rational(3, 25) + C3*Rational(-8, 25)) -
+              cos(sqrt(29)*t)*(C2*Rational(8, 25) + sqrt(29)*C3*Rational(3, 25))),
+             Eq(g(t), C1*Rational(3, 2) + sin(sqrt(29)*t)*(sqrt(29)*C2*Rational(4, 25) + C3*Rational(6, 25)) -
+              cos(sqrt(29)*t)*(C2*Rational(6, 25) + sqrt(29)*C3*Rational(-4, 25))),
+             Eq(h(t), C1 + C2*cos(sqrt(29)*t) - C3*sin(sqrt(29)*t))]
+    assert dsolve(eqs14) == sol14
+    assert checksysodesol(eqs14, sol14) == (True, [0, 0, 0])
+
+    eqs15 = [Eq(2*Derivative(f(t), t), 12*g(t) - 12*h(t)),
+             Eq(3*Derivative(g(t), t), -8*f(t) + 8*h(t)),
+             Eq(4*Derivative(h(t), t), 6*f(t) - 6*g(t))]
+    sol15 = [Eq(f(t), C1 - sin(sqrt(29)*t)*(sqrt(29)*C2*Rational(6, 13) + C3*Rational(-16, 13)) -
+              cos(sqrt(29)*t)*(C2*Rational(16, 13) + sqrt(29)*C3*Rational(6, 13))),
+             Eq(g(t), C1 + sin(sqrt(29)*t)*(sqrt(29)*C2*Rational(8, 39) + C3*Rational(16, 13)) -
+              cos(sqrt(29)*t)*(C2*Rational(16, 13) + sqrt(29)*C3*Rational(-8, 39))),
+             Eq(h(t), C1 + C2*cos(sqrt(29)*t) - C3*sin(sqrt(29)*t))]
+    assert dsolve(eqs15) == sol15
+    assert checksysodesol(eqs15, sol15) == (True, [0, 0, 0])
+
+    eq16 = (Eq(diff(x(t), t), 21*x(t)), Eq(diff(y(t), t), 17*x(t) + 3*y(t)),
+            Eq(diff(z(t), t), 5*x(t) + 7*y(t) + 9*z(t)))
+    sol16 = [Eq(x(t), 216*C1*exp(21*t)/209),
+             Eq(y(t), 204*C1*exp(21*t)/209 - 6*C2*exp(3*t)/7),
+             Eq(z(t), C1*exp(21*t) + C2*exp(3*t) + C3*exp(9*t))]
+    assert dsolve(eq16) == sol16
+    assert checksysodesol(eq16, sol16) == (True, [0, 0, 0])
+
+    eqs17 = [Eq(Derivative(x(t), t), 3*y(t) - 11*z(t)),
+             Eq(Derivative(y(t), t), -3*x(t) + 7*z(t)),
+             Eq(Derivative(z(t), t), 11*x(t) - 7*y(t))]
+    sol17 = [Eq(x(t), C1*Rational(7, 3) - sin(sqrt(179)*t)*(sqrt(179)*C2*Rational(11, 170) + C3*Rational(-21,
+              170)) - cos(sqrt(179)*t)*(C2*Rational(21, 170) + sqrt(179)*C3*Rational(11, 170))),
+             Eq(y(t), C1*Rational(11, 3) + sin(sqrt(179)*t)*(sqrt(179)*C2*Rational(7, 170) + C3*Rational(33,
+              170)) - cos(sqrt(179)*t)*(C2*Rational(33, 170) + sqrt(179)*C3*Rational(-7, 170))),
+             Eq(z(t), C1 + C2*cos(sqrt(179)*t) - C3*sin(sqrt(179)*t))]
+    assert dsolve(eqs17) == sol17
+    assert checksysodesol(eqs17, sol17) == (True, [0, 0, 0])
+
+    eqs18 = [Eq(3*Derivative(x(t), t), 20*y(t) - 20*z(t)),
+             Eq(4*Derivative(y(t), t), -15*x(t) + 15*z(t)),
+             Eq(5*Derivative(z(t), t), 12*x(t) - 12*y(t))]
+    sol18 = [Eq(x(t), C1 - sin(5*sqrt(2)*t)*(sqrt(2)*C2*Rational(4, 3) - C3) - cos(5*sqrt(2)*t)*(C2 +
+              sqrt(2)*C3*Rational(4, 3))),
+             Eq(y(t), C1 + sin(5*sqrt(2)*t)*(sqrt(2)*C2*Rational(3, 4) + C3) - cos(5*sqrt(2)*t)*(C2 +
+              sqrt(2)*C3*Rational(-3, 4))),
+             Eq(z(t), C1 + C2*cos(5*sqrt(2)*t) - C3*sin(5*sqrt(2)*t))]
+    assert dsolve(eqs18) == sol18
+    assert checksysodesol(eqs18, sol18) == (True, [0, 0, 0])
+
+    eqs19 = [Eq(Derivative(x(t), t), 4*x(t) - z(t)),
+             Eq(Derivative(y(t), t), 2*x(t) + 2*y(t) - z(t)),
+             Eq(Derivative(z(t), t), 3*x(t) + y(t))]
+    sol19 = [Eq(x(t), C2*t**2*exp(2*t)/2 + t*(2*C2 + C3)*exp(2*t) + (C1 + C2 + 2*C3)*exp(2*t)),
+             Eq(y(t), C2*t**2*exp(2*t)/2 + t*(2*C2 + C3)*exp(2*t) + (C1 + 2*C3)*exp(2*t)),
+             Eq(z(t), C2*t**2*exp(2*t) + t*(3*C2 + 2*C3)*exp(2*t) + (2*C1 + 3*C3)*exp(2*t))]
+    assert dsolve(eqs19) == sol19
+    assert checksysodesol(eqs19, sol19) == (True, [0, 0, 0])
+
+    eqs20 = [Eq(Derivative(x(t), t), 4*x(t) - y(t) - 2*z(t)),
+             Eq(Derivative(y(t), t), 2*x(t) + y(t) - 2*z(t)),
+             Eq(Derivative(z(t), t), 5*x(t) - 3*z(t))]
+    sol20 = [Eq(x(t), C1*exp(2*t) - sin(t)*(C2*Rational(3, 5) + C3/5) - cos(t)*(C2/5 + C3*Rational(-3, 5))),
+             Eq(y(t), -sin(t)*(C2*Rational(3, 5) + C3/5) - cos(t)*(C2/5 + C3*Rational(-3, 5))),
+             Eq(z(t), C1*exp(2*t) - C2*sin(t) + C3*cos(t))]
+    assert dsolve(eqs20) == sol20
+    assert checksysodesol(eqs20, sol20) == (True, [0, 0, 0])
+
+    eq21 = (Eq(diff(x(t), t), 9*y(t)), Eq(diff(y(t), t), 12*x(t)))
+    sol21 = [Eq(x(t), -sqrt(3)*C1*exp(-6*sqrt(3)*t)/2 + sqrt(3)*C2*exp(6*sqrt(3)*t)/2),
+             Eq(y(t), C1*exp(-6*sqrt(3)*t) + C2*exp(6*sqrt(3)*t))]
+
+    assert dsolve(eq21) == sol21
+    assert checksysodesol(eq21, sol21) == (True, [0, 0])
+
+    eqs22 = [Eq(Derivative(x(t), t), 2*x(t) + 4*y(t)),
+             Eq(Derivative(y(t), t), 12*x(t) + 41*y(t))]
+    sol22 = [Eq(x(t), C1*(39 - sqrt(1713))*exp(t*(sqrt(1713) + 43)/2)*Rational(-1, 24) + C2*(39 +
+              sqrt(1713))*exp(t*(43 - sqrt(1713))/2)*Rational(-1, 24)),
+             Eq(y(t), C1*exp(t*(sqrt(1713) + 43)/2) + C2*exp(t*(43 - sqrt(1713))/2))]
+    assert dsolve(eqs22) == sol22
+    assert checksysodesol(eqs22, sol22) == (True, [0, 0])
+
+    eqs23 = [Eq(Derivative(x(t), t), x(t) + y(t)),
+             Eq(Derivative(y(t), t), -2*x(t) + 2*y(t))]
+    sol23 = [Eq(x(t), (C1/4 + sqrt(7)*C2/4)*cos(sqrt(7)*t/2)*exp(t*Rational(3, 2)) +
+              sin(sqrt(7)*t/2)*(sqrt(7)*C1/4 + C2*Rational(-1, 4))*exp(t*Rational(3, 2))),
+             Eq(y(t), C1*cos(sqrt(7)*t/2)*exp(t*Rational(3, 2)) - C2*sin(sqrt(7)*t/2)*exp(t*Rational(3, 2)))]
+    assert dsolve(eqs23) == sol23
+    assert checksysodesol(eqs23, sol23) == (True, [0, 0])
+
+    # Regression test case for issue #15474
+    # https://github.com/sympy/sympy/issues/15474
+    a = Symbol("a", real=True)
+    eq24 = [x(t).diff(t) - a*y(t), y(t).diff(t) + a*x(t)]
+    sol24 = [Eq(x(t), C1*sin(a*t) + C2*cos(a*t)), Eq(y(t), C1*cos(a*t) - C2*sin(a*t))]
+    assert dsolve(eq24) == sol24
+    assert checksysodesol(eq24, sol24) == (True, [0, 0])
+
+    # Regression test case for issue #19150
+    # https://github.com/sympy/sympy/issues/19150
+    eqs25 = [Eq(Derivative(f(t), t), 0),
+             Eq(Derivative(g(t), t), (f(t) - 2*g(t) + x(t))/(b*c)),
+             Eq(Derivative(x(t), t), (g(t) - 2*x(t) + y(t))/(b*c)),
+             Eq(Derivative(y(t), t), (h(t) + x(t) - 2*y(t))/(b*c)),
+             Eq(Derivative(h(t), t), 0)]
+    sol25 = [Eq(f(t), -3*C1 + 4*C2),
+             Eq(g(t), -2*C1 + 3*C2 - C3*exp(-2*t/(b*c)) + C4*exp(-t*(sqrt(2) + 2)/(b*c)) + C5*exp(-t*(2 -
+              sqrt(2))/(b*c))),
+             Eq(x(t), -C1 + 2*C2 - sqrt(2)*C4*exp(-t*(sqrt(2) + 2)/(b*c)) + sqrt(2)*C5*exp(-t*(2 -
+              sqrt(2))/(b*c))),
+             Eq(y(t), C2 + C3*exp(-2*t/(b*c)) + C4*exp(-t*(sqrt(2) + 2)/(b*c)) + C5*exp(-t*(2 - sqrt(2))/(b*c))),
+             Eq(h(t), C1)]
+    assert dsolve(eqs25) == sol25
+    assert checksysodesol(eqs25, sol25) == (True, [0, 0, 0, 0, 0])
+
+    eq26 = [Eq(Derivative(f(t), t), 2*f(t)), Eq(Derivative(g(t), t), 3*f(t) + 7*g(t))]
+    sol26 = [Eq(f(t), -5*C1*exp(2*t)/3), Eq(g(t), C1*exp(2*t) + C2*exp(7*t))]
+    assert dsolve(eq26) == sol26
+    assert checksysodesol(eq26, sol26) == (True, [0, 0])
+
+    eq27 = [Eq(Derivative(f(t), t), -9*I*f(t) - 4*g(t)), Eq(Derivative(g(t), t), -4*I*g(t))]
+    sol27 = [Eq(f(t), 4*I*C1*exp(-4*I*t)/5 + C2*exp(-9*I*t)), Eq(g(t), C1*exp(-4*I*t))]
+    assert dsolve(eq27) == sol27
+    assert checksysodesol(eq27, sol27) == (True, [0, 0])
+
+    eq28 = [Eq(Derivative(f(t), t), -9*I*f(t)), Eq(Derivative(g(t), t), -4*I*g(t))]
+    sol28 = [Eq(f(t), C1*exp(-9*I*t)), Eq(g(t), C2*exp(-4*I*t))]
+    assert dsolve(eq28) == sol28
+    assert checksysodesol(eq28, sol28) == (True, [0, 0])
+
+    eq29 = [Eq(Derivative(f(t), t), 0), Eq(Derivative(g(t), t), 0)]
+    sol29 = [Eq(f(t), C1), Eq(g(t), C2)]
+    assert dsolve(eq29) == sol29
+    assert checksysodesol(eq29, sol29) == (True, [0, 0])
+
+    eq30 = [Eq(Derivative(f(t), t), f(t)), Eq(Derivative(g(t), t), 0)]
+    sol30 = [Eq(f(t), C1*exp(t)), Eq(g(t), C2)]
+    assert dsolve(eq30) == sol30
+    assert checksysodesol(eq30, sol30) == (True, [0, 0])
+
+    eq31 = [Eq(Derivative(f(t), t), g(t)), Eq(Derivative(g(t), t), 0)]
+    sol31 = [Eq(f(t), C1 + C2*t), Eq(g(t), C2)]
+    assert dsolve(eq31) == sol31
+    assert checksysodesol(eq31, sol31) == (True, [0, 0])
+
+    eq32 = [Eq(Derivative(f(t), t), 0), Eq(Derivative(g(t), t), f(t))]
+    sol32 = [Eq(f(t), C1), Eq(g(t), C1*t + C2)]
+    assert dsolve(eq32) == sol32
+    assert checksysodesol(eq32, sol32) == (True, [0, 0])
+
+    eq33 = [Eq(Derivative(f(t), t), 0), Eq(Derivative(g(t), t), g(t))]
+    sol33 = [Eq(f(t), C1), Eq(g(t), C2*exp(t))]
+    assert dsolve(eq33) == sol33
+    assert checksysodesol(eq33, sol33) == (True, [0, 0])
+
+    eq34 = [Eq(Derivative(f(t), t), f(t)), Eq(Derivative(g(t), t), I*g(t))]
+    sol34 = [Eq(f(t), C1*exp(t)), Eq(g(t), C2*exp(I*t))]
+    assert dsolve(eq34) == sol34
+    assert checksysodesol(eq34, sol34) == (True, [0, 0])
+
+    eq35 = [Eq(Derivative(f(t), t), I*f(t)), Eq(Derivative(g(t), t), -I*g(t))]
+    sol35 = [Eq(f(t), C1*exp(I*t)), Eq(g(t), C2*exp(-I*t))]
+    assert dsolve(eq35) == sol35
+    assert checksysodesol(eq35, sol35) == (True, [0, 0])
+
+    eq36 = [Eq(Derivative(f(t), t), I*g(t)), Eq(Derivative(g(t), t), 0)]
+    sol36 = [Eq(f(t), I*C1 + I*C2*t), Eq(g(t), C2)]
+    assert dsolve(eq36) == sol36
+    assert checksysodesol(eq36, sol36) == (True, [0, 0])
+
+    eq37 = [Eq(Derivative(f(t), t), I*g(t)), Eq(Derivative(g(t), t), I*f(t))]
+    sol37 = [Eq(f(t), -C1*exp(-I*t) + C2*exp(I*t)), Eq(g(t), C1*exp(-I*t) + C2*exp(I*t))]
+    assert dsolve(eq37) == sol37
+    assert checksysodesol(eq37, sol37) == (True, [0, 0])
+
+    # Multiple systems
+    eq1 = [Eq(Derivative(f(t), t)**2, g(t)**2), Eq(-f(t) + Derivative(g(t), t), 0)]
+    sol1 = [[Eq(f(t), -C1*sin(t) - C2*cos(t)),
+             Eq(g(t), C1*cos(t) - C2*sin(t))],
+            [Eq(f(t), -C1*exp(-t) + C2*exp(t)),
+             Eq(g(t), C1*exp(-t) + C2*exp(t))]]
+    assert dsolve(eq1) == sol1
+    for sol in sol1:
+        assert checksysodesol(eq1, sol) == (True, [0, 0])
+
+
+def test_sysode_linear_neq_order1_type2():
+
+    f, g, h, k = symbols('f g h k', cls=Function)
+    x, t, a, b, c, d, y = symbols('x t a b c d y')
+    k1, k2 = symbols('k1 k2')
+
+
+    eqs1 = [Eq(Derivative(f(x), x), f(x) + g(x) + 5),
+            Eq(Derivative(g(x), x), -f(x) - g(x) + 7)]
+    sol1 = [Eq(f(x), C1 + C2 + 6*x**2 + x*(C2 + 5)),
+            Eq(g(x), -C1 - 6*x**2 - x*(C2 - 7))]
+    assert dsolve(eqs1) == sol1
+    assert checksysodesol(eqs1, sol1) == (True, [0, 0])
+
+    eqs2 = [Eq(Derivative(f(x), x), f(x) + g(x) + 5),
+            Eq(Derivative(g(x), x), f(x) + g(x) + 7)]
+    sol2 = [Eq(f(x), -C1 + C2*exp(2*x) - x - 3),
+            Eq(g(x), C1 + C2*exp(2*x) + x - 3)]
+    assert dsolve(eqs2) == sol2
+    assert checksysodesol(eqs2, sol2) == (True, [0, 0])
+
+    eqs3 = [Eq(Derivative(f(x), x), f(x) + 5),
+            Eq(Derivative(g(x), x), f(x) + 7)]
+    sol3 = [Eq(f(x), C1*exp(x) - 5),
+            Eq(g(x), C1*exp(x) + C2 + 2*x - 5)]
+    assert dsolve(eqs3) == sol3
+    assert checksysodesol(eqs3, sol3) == (True, [0, 0])
+
+    eqs4 = [Eq(Derivative(f(x), x), f(x) + exp(x)),
+            Eq(Derivative(g(x), x), x*exp(x) + f(x) + g(x))]
+    sol4 = [Eq(f(x), C1*exp(x) + x*exp(x)),
+            Eq(g(x), C1*x*exp(x) + C2*exp(x) + x**2*exp(x))]
+    assert dsolve(eqs4) == sol4
+    assert checksysodesol(eqs4, sol4) == (True, [0, 0])
+
+    eqs5 = [Eq(Derivative(f(x), x), 5*x + f(x) + g(x)),
+            Eq(Derivative(g(x), x), f(x) - g(x))]
+    sol5 = [Eq(f(x), C1*(1 + sqrt(2))*exp(sqrt(2)*x) + C2*(1 - sqrt(2))*exp(-sqrt(2)*x) + x*Rational(-5, 2) +
+             Rational(-5, 2)),
+            Eq(g(x), C1*exp(sqrt(2)*x) + C2*exp(-sqrt(2)*x) + x*Rational(-5, 2))]
+    assert dsolve(eqs5) == sol5
+    assert checksysodesol(eqs5, sol5) == (True, [0, 0])
+
+    eqs6 = [Eq(Derivative(f(x), x), -9*f(x) - 4*g(x)),
+            Eq(Derivative(g(x), x), -4*g(x)),
+            Eq(Derivative(h(x), x), h(x) + exp(x))]
+    sol6 = [Eq(f(x), C2*exp(-4*x)*Rational(-4, 5) + C1*exp(-9*x)),
+            Eq(g(x), C2*exp(-4*x)),
+            Eq(h(x), C3*exp(x) + x*exp(x))]
+    assert dsolve(eqs6) == sol6
+    assert checksysodesol(eqs6, sol6) == (True, [0, 0, 0])
+
+    # Regression test case for issue #8859
+    # https://github.com/sympy/sympy/issues/8859
+    eqs7 = [Eq(Derivative(f(t), t), 3*t + f(t)),
+            Eq(Derivative(g(t), t), g(t))]
+    sol7 = [Eq(f(t), C1*exp(t) - 3*t - 3),
+            Eq(g(t), C2*exp(t))]
+    assert dsolve(eqs7) == sol7
+    assert checksysodesol(eqs7, sol7) == (True, [0, 0])
+
+    # Regression test case for issue #8567
+    # https://github.com/sympy/sympy/issues/8567
+    eqs8 = [Eq(Derivative(f(t), t), f(t) + 2*g(t)),
+            Eq(Derivative(g(t), t), -2*f(t) + g(t) + 2*exp(t))]
+    sol8 = [Eq(f(t), C1*exp(t)*sin(2*t) + C2*exp(t)*cos(2*t)
+                + exp(t)*sin(2*t)**2 + exp(t)*cos(2*t)**2),
+            Eq(g(t), C1*exp(t)*cos(2*t) - C2*exp(t)*sin(2*t))]
+    assert dsolve(eqs8) == sol8
+    assert checksysodesol(eqs8, sol8) == (True, [0, 0])
+
+    # Regression test case for issue #19150
+    # https://github.com/sympy/sympy/issues/19150
+    eqs9 = [Eq(Derivative(f(t), t), (c - 2*f(t) + g(t))/(a*b)),
+            Eq(Derivative(g(t), t), (f(t) - 2*g(t) + h(t))/(a*b)),
+            Eq(Derivative(h(t), t), (d + g(t) - 2*h(t))/(a*b))]
+    sol9 = [Eq(f(t), -C1*exp(-2*t/(a*b)) + C2*exp(-t*(sqrt(2) + 2)/(a*b)) + C3*exp(-t*(2 - sqrt(2))/(a*b)) +
+             Mul(Rational(1, 4), 3*c + d, evaluate=False)),
+            Eq(g(t), -sqrt(2)*C2*exp(-t*(sqrt(2) + 2)/(a*b)) + sqrt(2)*C3*exp(-t*(2 - sqrt(2))/(a*b)) +
+             Mul(Rational(1, 2), c + d, evaluate=False)),
+            Eq(h(t), C1*exp(-2*t/(a*b)) + C2*exp(-t*(sqrt(2) + 2)/(a*b)) + C3*exp(-t*(2 - sqrt(2))/(a*b)) +
+             Mul(Rational(1, 4), c + 3*d, evaluate=False))]
+    assert dsolve(eqs9) == sol9
+    assert checksysodesol(eqs9, sol9) == (True, [0, 0, 0])
+
+    # Regression test case for issue #16635
+    # https://github.com/sympy/sympy/issues/16635
+    eqs10 = [Eq(Derivative(f(t), t), 15*t + f(t) - g(t) - 10),
+             Eq(Derivative(g(t), t), -15*t + f(t) - g(t) - 5)]
+    sol10 = [Eq(f(t), C1 + C2 + 5*t**3 + 5*t**2 + t*(C2 - 10)),
+             Eq(g(t), C1 + 5*t**3 - 10*t**2 + t*(C2 - 5))]
+    assert dsolve(eqs10) == sol10
+    assert checksysodesol(eqs10, sol10) == (True, [0, 0])
+
+    # Multiple solutions
+    eqs11 = [Eq(Derivative(f(t), t)**2 - 2*Derivative(f(t), t) + 1, 4),
+             Eq(-y*f(t) + Derivative(g(t), t), 0)]
+    sol11 = [[Eq(f(t), C1 - t), Eq(g(t), C1*t*y + C2*y + t**2*y*Rational(-1, 2))],
+             [Eq(f(t), C1 + 3*t), Eq(g(t), C1*t*y + C2*y + t**2*y*Rational(3, 2))]]
+    assert dsolve(eqs11) == sol11
+    for s11 in sol11:
+        assert checksysodesol(eqs11, s11) == (True, [0, 0])
+
+    # test case for issue #19831
+    # https://github.com/sympy/sympy/issues/19831
+    n = symbols('n', positive=True)
+    x0 = symbols('x_0')
+    t0 = symbols('t_0')
+    x_0 = symbols('x_0')
+    t_0 = symbols('t_0')
+    t = symbols('t')
+    x = Function('x')
+    y = Function('y')
+    T = symbols('T')
+
+    eqs12 = [Eq(Derivative(y(t), t), x(t)),
+             Eq(Derivative(x(t), t), n*(y(t) + 1))]
+    sol12 = [Eq(y(t), C1*exp(sqrt(n)*t)*n**Rational(-1, 2) - C2*exp(-sqrt(n)*t)*n**Rational(-1, 2) - 1),
+             Eq(x(t), C1*exp(sqrt(n)*t) + C2*exp(-sqrt(n)*t))]
+    assert dsolve(eqs12) == sol12
+    assert checksysodesol(eqs12, sol12) == (True, [0, 0])
+
+    sol12b = [
+        Eq(y(t), (T*exp(-sqrt(n)*t_0)/2 + exp(-sqrt(n)*t_0)/2 +
+            x_0*exp(-sqrt(n)*t_0)/(2*sqrt(n)))*exp(sqrt(n)*t) +
+            (T*exp(sqrt(n)*t_0)/2 + exp(sqrt(n)*t_0)/2 -
+                x_0*exp(sqrt(n)*t_0)/(2*sqrt(n)))*exp(-sqrt(n)*t) - 1),
+        Eq(x(t), (T*sqrt(n)*exp(-sqrt(n)*t_0)/2 + sqrt(n)*exp(-sqrt(n)*t_0)/2
+            + x_0*exp(-sqrt(n)*t_0)/2)*exp(sqrt(n)*t)
+                - (T*sqrt(n)*exp(sqrt(n)*t_0)/2 + sqrt(n)*exp(sqrt(n)*t_0)/2 -
+                    x_0*exp(sqrt(n)*t_0)/2)*exp(-sqrt(n)*t))
+          ]
+    assert dsolve(eqs12, ics={y(t0): T, x(t0): x0}) == sol12b
+    assert checksysodesol(eqs12, sol12b) == (True, [0, 0])
+
+    #Test cases added for the issue 19763
+    #https://github.com/sympy/sympy/issues/19763
+
+    eq13 = [Eq(Derivative(f(t), t), f(t) + g(t) + 9),
+            Eq(Derivative(g(t), t), 2*f(t) + 5*g(t) + 23)]
+    sol13 = [Eq(f(t), -C1*(2 + sqrt(6))*exp(t*(3 - sqrt(6)))/2 - C2*(2 - sqrt(6))*exp(t*(sqrt(6) + 3))/2 -
+              Rational(22,3)),
+             Eq(g(t), C1*exp(t*(3 - sqrt(6))) + C2*exp(t*(sqrt(6) + 3)) - Rational(5,3))]
+    assert dsolve(eq13) == sol13
+    assert checksysodesol(eq13, sol13) == (True, [0, 0])
+
+    eq14 = [Eq(Derivative(f(t), t), f(t) + g(t) + 81),
+            Eq(Derivative(g(t), t), -2*f(t) + g(t) + 23)]
+    sol14 = [Eq(f(t), sqrt(2)*C1*exp(t)*sin(sqrt(2)*t)/2
+                    + sqrt(2)*C2*exp(t)*cos(sqrt(2)*t)/2
+                    - 58*sin(sqrt(2)*t)**2/3 - 58*cos(sqrt(2)*t)**2/3),
+             Eq(g(t), C1*exp(t)*cos(sqrt(2)*t) - C2*exp(t)*sin(sqrt(2)*t)
+                    - 185*sin(sqrt(2)*t)**2/3 - 185*cos(sqrt(2)*t)**2/3)]
+    assert dsolve(eq14) == sol14
+    assert checksysodesol(eq14, sol14) == (True, [0,0])
+
+    eq15 = [Eq(Derivative(f(t), t), f(t) + 2*g(t) + k1),
+            Eq(Derivative(g(t), t), 3*f(t) + 4*g(t) + k2)]
+    sol15 = [Eq(f(t), -C1*(3 - sqrt(33))*exp(t*(5 + sqrt(33))/2)/6 -
+              C2*(3 + sqrt(33))*exp(t*(5 - sqrt(33))/2)/6 + 2*k1 - k2),
+             Eq(g(t), C1*exp(t*(5 + sqrt(33))/2) + C2*exp(t*(5 - sqrt(33))/2) -
+              Mul(Rational(1,2), 3*k1 - k2, evaluate = False))]
+    assert dsolve(eq15) == sol15
+    assert checksysodesol(eq15, sol15) == (True, [0,0])
+
+    eq16 = [Eq(Derivative(f(t), t), k1),
+            Eq(Derivative(g(t), t), k2)]
+    sol16 = [Eq(f(t), C1 + k1*t),
+             Eq(g(t), C2 + k2*t)]
+    assert dsolve(eq16) == sol16
+    assert checksysodesol(eq16, sol16) == (True, [0,0])
+
+    eq17 = [Eq(Derivative(f(t), t), 0),
+            Eq(Derivative(g(t), t), c*f(t) + k2)]
+    sol17 = [Eq(f(t), C1),
+             Eq(g(t), C2*c + t*(C1*c + k2))]
+    assert dsolve(eq17) == sol17
+    assert checksysodesol(eq17 , sol17) == (True , [0,0])
+
+    eq18 = [Eq(Derivative(f(t), t), k1),
+            Eq(Derivative(g(t), t), f(t) + k2)]
+    sol18 = [Eq(f(t), C1 + k1*t),
+             Eq(g(t), C2 + k1*t**2/2 + t*(C1 + k2))]
+    assert dsolve(eq18) == sol18
+    assert checksysodesol(eq18 , sol18) == (True , [0,0])
+
+    eq19 = [Eq(Derivative(f(t), t), k1),
+            Eq(Derivative(g(t), t), f(t) + 2*g(t) + k2)]
+    sol19 = [Eq(f(t), -2*C1 + k1*t),
+            Eq(g(t), C1 + C2*exp(2*t) - k1*t/2 - Mul(Rational(1,4), k1 + 2*k2 , evaluate = False))]
+    assert dsolve(eq19) == sol19
+    assert checksysodesol(eq19 , sol19) == (True , [0,0])
+
+    eq20 = [Eq(diff(f(t), t), f(t) + k1),
+            Eq(diff(g(t), t), k2)]
+    sol20 = [Eq(f(t), C1*exp(t) - k1),
+            Eq(g(t), C2 + k2*t)]
+    assert dsolve(eq20) == sol20
+    assert checksysodesol(eq20 , sol20) == (True , [0,0])
+
+    eq21 = [Eq(diff(f(t), t), g(t) + k1),
+            Eq(diff(g(t), t), 0)]
+    sol21 = [Eq(f(t), C1 + t*(C2 + k1)),
+            Eq(g(t), C2)]
+    assert dsolve(eq21) == sol21
+    assert checksysodesol(eq21 , sol21) == (True , [0,0])
+
+    eq22 = [Eq(Derivative(f(t), t), f(t) + 2*g(t) + k1),
+            Eq(Derivative(g(t), t), k2)]
+    sol22 = [Eq(f(t), -2*C1 + C2*exp(t) - k1 - 2*k2*t - 2*k2),
+            Eq(g(t), C1 + k2*t)]
+    assert dsolve(eq22) == sol22
+    assert checksysodesol(eq22 , sol22) == (True , [0,0])
+
+    eq23 = [Eq(Derivative(f(t), t), g(t) + k1),
+            Eq(Derivative(g(t), t), 2*g(t) + k2)]
+    sol23 = [Eq(f(t), C1 + C2*exp(2*t)/2 - k2/4 + t*(2*k1 - k2)/2),
+            Eq(g(t), C2*exp(2*t) - k2/2)]
+    assert dsolve(eq23) == sol23
+    assert checksysodesol(eq23 , sol23) == (True , [0,0])
+
+    eq24 = [Eq(Derivative(f(t), t), f(t) + k1),
+            Eq(Derivative(g(t), t), 2*f(t) + k2)]
+    sol24 = [Eq(f(t), C1*exp(t)/2 - k1),
+            Eq(g(t), C1*exp(t) + C2 - 2*k1 - t*(2*k1 - k2))]
+    assert dsolve(eq24) == sol24
+    assert checksysodesol(eq24 , sol24) == (True , [0,0])
+
+    eq25 = [Eq(Derivative(f(t), t), f(t) + 2*g(t) + k1),
+            Eq(Derivative(g(t), t), 3*f(t) + 6*g(t) + k2)]
+    sol25 = [Eq(f(t), -2*C1 + C2*exp(7*t)/3 + 2*t*(3*k1 - k2)/7 -
+              Mul(Rational(1,49), k1 + 2*k2 , evaluate = False)),
+             Eq(g(t), C1 + C2*exp(7*t) - t*(3*k1 - k2)/7 -
+              Mul(Rational(3,49), k1 + 2*k2 , evaluate = False))]
+    assert dsolve(eq25) == sol25
+    assert checksysodesol(eq25 , sol25) == (True , [0,0])
+
+    eq26 = [Eq(Derivative(f(t), t), 2*f(t) - g(t) + k1),
+            Eq(Derivative(g(t), t), 4*f(t) - 2*g(t) + 2*k1)]
+    sol26 = [Eq(f(t), C1 + 2*C2 + t*(2*C1 + k1)),
+            Eq(g(t), 4*C2 + t*(4*C1 + 2*k1))]
+    assert dsolve(eq26) == sol26
+    assert checksysodesol(eq26 , sol26) == (True , [0,0])
+
+    # Test Case added for issue #22715
+    # https://github.com/sympy/sympy/issues/22715
+
+    eq27 = [Eq(diff(x(t),t),-1*y(t)+10), Eq(diff(y(t),t),5*x(t)-2*y(t)+3)]
+    sol27 = [Eq(x(t), (C1/5 - 2*C2/5)*exp(-t)*cos(2*t)
+                    - (2*C1/5 + C2/5)*exp(-t)*sin(2*t)
+                    + 17*sin(2*t)**2/5 + 17*cos(2*t)**2/5),
+            Eq(y(t), C1*exp(-t)*cos(2*t) - C2*exp(-t)*sin(2*t)
+                    + 10*sin(2*t)**2 + 10*cos(2*t)**2)]
+    assert dsolve(eq27) == sol27
+    assert checksysodesol(eq27 , sol27) == (True , [0,0])
+
+
+def test_sysode_linear_neq_order1_type3():
+
+    f, g, h, k, x0 , y0 = symbols('f g h k x0 y0', cls=Function)
+    x, t, a = symbols('x t a')
+    r = symbols('r', real=True)
+
+    eqs1 = [Eq(Derivative(f(r), r), r*g(r) + f(r)),
+            Eq(Derivative(g(r), r), -r*f(r) + g(r))]
+    sol1 = [Eq(f(r), C1*exp(r)*sin(r**2/2) + C2*exp(r)*cos(r**2/2)),
+            Eq(g(r), C1*exp(r)*cos(r**2/2) - C2*exp(r)*sin(r**2/2))]
+    assert dsolve(eqs1) == sol1
+    assert checksysodesol(eqs1, sol1) == (True, [0, 0])
+
+    eqs2 = [Eq(Derivative(f(x), x), x**2*g(x) + x*f(x)),
+            Eq(Derivative(g(x), x), 2*x**2*f(x) + (3*x**2 + x)*g(x))]
+    sol2 = [Eq(f(x), (sqrt(17)*C1/17 + C2*(17 - 3*sqrt(17))/34)*exp(x**3*(3 + sqrt(17))/6 + x**2/2) -
+             exp(x**3*(3 - sqrt(17))/6 + x**2/2)*(sqrt(17)*C1/17 + C2*(3*sqrt(17) + 17)*Rational(-1, 34))),
+            Eq(g(x), exp(x**3*(3 - sqrt(17))/6 + x**2/2)*(C1*(17 - 3*sqrt(17))/34 + sqrt(17)*C2*Rational(-2,
+             17)) + exp(x**3*(3 + sqrt(17))/6 + x**2/2)*(C1*(3*sqrt(17) + 17)/34 + sqrt(17)*C2*Rational(2, 17)))]
+    assert dsolve(eqs2) == sol2
+    assert checksysodesol(eqs2, sol2) == (True, [0, 0])
+
+    eqs3 = [Eq(f(x).diff(x), x*f(x) + g(x)),
+            Eq(g(x).diff(x), -f(x) + x*g(x))]
+    sol3 = [Eq(f(x), (C1/2 + I*C2/2)*exp(x**2/2 - I*x) + exp(x**2/2 + I*x)*(C1/2 + I*C2*Rational(-1, 2))),
+            Eq(g(x), (I*C1/2 + C2/2)*exp(x**2/2 + I*x) - exp(x**2/2 - I*x)*(I*C1/2 + C2*Rational(-1, 2)))]
+    assert dsolve(eqs3) == sol3
+    assert checksysodesol(eqs3, sol3) == (True, [0, 0])
+
+    eqs4 = [Eq(f(x).diff(x), x*(f(x) + g(x) + h(x))), Eq(g(x).diff(x), x*(f(x) + g(x) + h(x))),
+            Eq(h(x).diff(x), x*(f(x) + g(x) + h(x)))]
+    sol4 = [Eq(f(x), -C1/3 - C2/3 + 2*C3/3 + (C1/3 + C2/3 + C3/3)*exp(3*x**2/2)),
+            Eq(g(x), 2*C1/3 - C2/3 - C3/3 + (C1/3 + C2/3 + C3/3)*exp(3*x**2/2)),
+            Eq(h(x), -C1/3 + 2*C2/3 - C3/3 + (C1/3 + C2/3 + C3/3)*exp(3*x**2/2))]
+    assert dsolve(eqs4) == sol4
+    assert checksysodesol(eqs4, sol4) == (True, [0, 0, 0])
+
+    eqs5 = [Eq(f(x).diff(x), x**2*(f(x) + g(x) + h(x))), Eq(g(x).diff(x), x**2*(f(x) + g(x) + h(x))),
+            Eq(h(x).diff(x), x**2*(f(x) + g(x) + h(x)))]
+    sol5 = [Eq(f(x), -C1/3 - C2/3 + 2*C3/3 + (C1/3 + C2/3 + C3/3)*exp(x**3)),
+            Eq(g(x), 2*C1/3 - C2/3 - C3/3 + (C1/3 + C2/3 + C3/3)*exp(x**3)),
+            Eq(h(x), -C1/3 + 2*C2/3 - C3/3 + (C1/3 + C2/3 + C3/3)*exp(x**3))]
+    assert dsolve(eqs5) == sol5
+    assert checksysodesol(eqs5, sol5) == (True, [0, 0, 0])
+
+    eqs6 = [Eq(Derivative(f(x), x), x*(f(x) + g(x) + h(x) + k(x))),
+            Eq(Derivative(g(x), x), x*(f(x) + g(x) + h(x) + k(x))),
+            Eq(Derivative(h(x), x), x*(f(x) + g(x) + h(x) + k(x))),
+            Eq(Derivative(k(x), x), x*(f(x) + g(x) + h(x) + k(x)))]
+    sol6 = [Eq(f(x), -C1/4 - C2/4 - C3/4 + 3*C4/4 + (C1/4 + C2/4 + C3/4 + C4/4)*exp(2*x**2)),
+            Eq(g(x), 3*C1/4 - C2/4 - C3/4 - C4/4 + (C1/4 + C2/4 + C3/4 + C4/4)*exp(2*x**2)),
+            Eq(h(x), -C1/4 + 3*C2/4 - C3/4 - C4/4 + (C1/4 + C2/4 + C3/4 + C4/4)*exp(2*x**2)),
+            Eq(k(x), -C1/4 - C2/4 + 3*C3/4 - C4/4 + (C1/4 + C2/4 + C3/4 + C4/4)*exp(2*x**2))]
+    assert dsolve(eqs6) == sol6
+    assert checksysodesol(eqs6, sol6) == (True, [0, 0, 0, 0])
+
+    y = symbols("y", real=True)
+
+    eqs7 = [Eq(Derivative(f(y), y), y*f(y) + g(y)),
+            Eq(Derivative(g(y), y), y*g(y) - f(y))]
+    sol7 = [Eq(f(y), C1*exp(y**2/2)*sin(y) + C2*exp(y**2/2)*cos(y)),
+            Eq(g(y), C1*exp(y**2/2)*cos(y) - C2*exp(y**2/2)*sin(y))]
+    assert dsolve(eqs7) == sol7
+    assert checksysodesol(eqs7, sol7) == (True, [0, 0])
+
+    #Test cases added for the issue 19763
+    #https://github.com/sympy/sympy/issues/19763
+
+    eqs8 = [Eq(Derivative(f(t), t), 5*t*f(t) + 2*h(t)),
+            Eq(Derivative(h(t), t), 2*f(t) + 5*t*h(t))]
+    sol8 = [Eq(f(t), Mul(-1, (C1/2 - C2/2), evaluate = False)*exp(5*t**2/2 - 2*t) + (C1/2 + C2/2)*exp(5*t**2/2 + 2*t)),
+            Eq(h(t), (C1/2 - C2/2)*exp(5*t**2/2 - 2*t) + (C1/2 + C2/2)*exp(5*t**2/2 + 2*t))]
+    assert dsolve(eqs8) == sol8
+    assert checksysodesol(eqs8, sol8) == (True, [0, 0])
+
+    eqs9 = [Eq(diff(f(t), t), 5*t*f(t) + t**2*g(t)),
+            Eq(diff(g(t), t), -t**2*f(t) + 5*t*g(t))]
+    sol9 = [Eq(f(t), (C1/2 - I*C2/2)*exp(I*t**3/3 + 5*t**2/2) + (C1/2 + I*C2/2)*exp(-I*t**3/3 + 5*t**2/2)),
+            Eq(g(t), Mul(-1, (I*C1/2 - C2/2) , evaluate = False)*exp(-I*t**3/3 + 5*t**2/2) + (I*C1/2 + C2/2)*exp(I*t**3/3 + 5*t**2/2))]
+    assert dsolve(eqs9) == sol9
+    assert checksysodesol(eqs9 , sol9) == (True , [0,0])
+
+    eqs10 = [Eq(diff(f(t), t), t**2*g(t) + 5*t*f(t)),
+             Eq(diff(g(t), t), -t**2*f(t) + (9*t**2 + 5*t)*g(t))]
+    sol10 = [Eq(f(t), (C1*(77 - 9*sqrt(77))/154 + sqrt(77)*C2/77)*exp(t**3*(sqrt(77) + 9)/6 + 5*t**2/2) + (C1*(77 + 9*sqrt(77))/154 - sqrt(77)*C2/77)*exp(t**3*(9 - sqrt(77))/6 + 5*t**2/2)),
+             Eq(g(t), (sqrt(77)*C1/77 + C2*(77 - 9*sqrt(77))/154)*exp(t**3*(9 - sqrt(77))/6 + 5*t**2/2) - (sqrt(77)*C1/77 - C2*(77 + 9*sqrt(77))/154)*exp(t**3*(sqrt(77) + 9)/6 + 5*t**2/2))]
+    assert dsolve(eqs10) == sol10
+    assert checksysodesol(eqs10 , sol10) == (True , [0,0])
+
+    eqs11 = [Eq(diff(f(t), t), 5*t*f(t) + t**2*g(t)),
+             Eq(diff(g(t), t), (1-t**2)*f(t) + (5*t + 9*t**2)*g(t))]
+    sol11 = [Eq(f(t), C1*x0(t) + C2*x0(t)*Integral(t**2*exp(Integral(5*t, t))*exp(Integral(9*t**2 + 5*t, t))/x0(t)**2, t)),
+             Eq(g(t), C1*y0(t) + C2*(y0(t)*Integral(t**2*exp(Integral(5*t, t))*exp(Integral(9*t**2 + 5*t, t))/x0(t)**2, t) + exp(Integral(5*t, t))*exp(Integral(9*t**2 + 5*t, t))/x0(t)))]
+    assert dsolve(eqs11) == sol11
+
+@slow
+def test_sysode_linear_neq_order1_type4():
+
+    f, g, h, k = symbols('f g h k', cls=Function)
+    x, t, a = symbols('x t a')
+    r = symbols('r', real=True)
+
+    eqs1 = [Eq(diff(f(r), r), f(r) + r*g(r) + r**2), Eq(diff(g(r), r), -r*f(r) + g(r) + r)]
+    sol1 = [Eq(f(r), C1*exp(r)*sin(r**2/2) + C2*exp(r)*cos(r**2/2) + exp(r)*sin(r**2/2)*Integral(r**2*exp(-r)*sin(r**2/2) +
+                r*exp(-r)*cos(r**2/2), r) + exp(r)*cos(r**2/2)*Integral(r**2*exp(-r)*cos(r**2/2) - r*exp(-r)*sin(r**2/2), r)),
+            Eq(g(r), C1*exp(r)*cos(r**2/2) - C2*exp(r)*sin(r**2/2) - exp(r)*sin(r**2/2)*Integral(r**2*exp(-r)*cos(r**2/2) -
+                r*exp(-r)*sin(r**2/2), r) + exp(r)*cos(r**2/2)*Integral(r**2*exp(-r)*sin(r**2/2) + r*exp(-r)*cos(r**2/2), r))]
+    assert dsolve(eqs1) == sol1
+    assert checksysodesol(eqs1, sol1) == (True, [0, 0])
+
+    eqs2 = [Eq(diff(f(r), r), f(r) + r*g(r) + r), Eq(diff(g(r), r), -r*f(r) + g(r) + log(r))]
+    sol2 = [Eq(f(r), C1*exp(r)*sin(r**2/2) + C2*exp(r)*cos(r**2/2) + exp(r)*sin(r**2/2)*Integral(r*exp(-r)*sin(r**2/2) +
+                exp(-r)*log(r)*cos(r**2/2), r) + exp(r)*cos(r**2/2)*Integral(r*exp(-r)*cos(r**2/2) - exp(-r)*log(r)*sin(
+                r**2/2), r)),
+            Eq(g(r), C1*exp(r)*cos(r**2/2) - C2*exp(r)*sin(r**2/2) - exp(r)*sin(r**2/2)*Integral(r*exp(-r)*cos(r**2/2) -
+                exp(-r)*log(r)*sin(r**2/2), r) + exp(r)*cos(r**2/2)*Integral(r*exp(-r)*sin(r**2/2) + exp(-r)*log(r)*cos(
+                r**2/2), r))]
+    # XXX: dsolve hangs for this in integration
+    assert dsolve_system(eqs2, simplify=False, doit=False) == [sol2]
+    assert checksysodesol(eqs2, sol2) == (True, [0, 0])
+
+    eqs3 = [Eq(Derivative(f(x), x), x*(f(x) + g(x) + h(x)) + x),
+            Eq(Derivative(g(x), x), x*(f(x) + g(x) + h(x)) + x),
+            Eq(Derivative(h(x), x), x*(f(x) + g(x) + h(x)) + 1)]
+    sol3 = [Eq(f(x), C1*Rational(-1, 3) + C2*Rational(-1, 3) + C3*Rational(2, 3) + x**2/6 + x*Rational(-1, 3) +
+             (C1/3 + C2/3 + C3/3)*exp(x**2*Rational(3, 2)) +
+             sqrt(6)*sqrt(pi)*erf(sqrt(6)*x/2)*exp(x**2*Rational(3, 2))/18 + Rational(-2, 9)),
+            Eq(g(x), C1*Rational(2, 3) + C2*Rational(-1, 3) + C3*Rational(-1, 3) + x**2/6 + x*Rational(-1, 3) +
+             (C1/3 + C2/3 + C3/3)*exp(x**2*Rational(3, 2)) +
+             sqrt(6)*sqrt(pi)*erf(sqrt(6)*x/2)*exp(x**2*Rational(3, 2))/18 + Rational(-2, 9)),
+            Eq(h(x), C1*Rational(-1, 3) + C2*Rational(2, 3) + C3*Rational(-1, 3) + x**2*Rational(-1, 3) +
+             x*Rational(2, 3) + (C1/3 + C2/3 + C3/3)*exp(x**2*Rational(3, 2)) +
+             sqrt(6)*sqrt(pi)*erf(sqrt(6)*x/2)*exp(x**2*Rational(3, 2))/18 + Rational(-2, 9))]
+    assert dsolve(eqs3) == sol3
+    assert checksysodesol(eqs3, sol3) == (True, [0, 0, 0])
+
+    eqs4 = [Eq(Derivative(f(x), x), x*(f(x) + g(x) + h(x)) + sin(x)),
+            Eq(Derivative(g(x), x), x*(f(x) + g(x) + h(x)) + sin(x)),
+            Eq(Derivative(h(x), x), x*(f(x) + g(x) + h(x)) + sin(x))]
+    sol4 = [Eq(f(x), C1*Rational(-1, 3) + C2*Rational(-1, 3) + C3*Rational(2, 3) + (C1/3 + C2/3 +
+             C3/3)*exp(x**2*Rational(3, 2)) + Integral(sin(x)*exp(x**2*Rational(-3, 2)), x)*exp(x**2*Rational(3,
+             2))),
+            Eq(g(x), C1*Rational(2, 3) + C2*Rational(-1, 3) + C3*Rational(-1, 3) + (C1/3 + C2/3 +
+             C3/3)*exp(x**2*Rational(3, 2)) + Integral(sin(x)*exp(x**2*Rational(-3, 2)), x)*exp(x**2*Rational(3,
+             2))),
+            Eq(h(x), C1*Rational(-1, 3) + C2*Rational(2, 3) + C3*Rational(-1, 3) + (C1/3 + C2/3 +
+             C3/3)*exp(x**2*Rational(3, 2)) + Integral(sin(x)*exp(x**2*Rational(-3, 2)), x)*exp(x**2*Rational(3,
+             2)))]
+    assert dsolve(eqs4) == sol4
+    assert checksysodesol(eqs4, sol4) == (True, [0, 0, 0])
+
+    eqs5 = [Eq(Derivative(f(x), x), x*(f(x) + g(x) + h(x) + k(x) + 1)),
+            Eq(Derivative(g(x), x), x*(f(x) + g(x) + h(x) + k(x) + 1)),
+            Eq(Derivative(h(x), x), x*(f(x) + g(x) + h(x) + k(x) + 1)),
+            Eq(Derivative(k(x), x), x*(f(x) + g(x) + h(x) + k(x) + 1))]
+    sol5 = [Eq(f(x), C1*Rational(-1, 4) + C2*Rational(-1, 4) + C3*Rational(-1, 4) + C4*Rational(3, 4) + (C1/4 +
+             C2/4 + C3/4 + C4/4)*exp(2*x**2) + Rational(-1, 4)),
+            Eq(g(x), C1*Rational(3, 4) + C2*Rational(-1, 4) + C3*Rational(-1, 4) + C4*Rational(-1, 4) + (C1/4 +
+             C2/4 + C3/4 + C4/4)*exp(2*x**2) + Rational(-1, 4)),
+            Eq(h(x), C1*Rational(-1, 4) + C2*Rational(3, 4) + C3*Rational(-1, 4) + C4*Rational(-1, 4) + (C1/4 +
+             C2/4 + C3/4 + C4/4)*exp(2*x**2) + Rational(-1, 4)),
+            Eq(k(x), C1*Rational(-1, 4) + C2*Rational(-1, 4) + C3*Rational(3, 4) + C4*Rational(-1, 4) + (C1/4 +
+             C2/4 + C3/4 + C4/4)*exp(2*x**2) + Rational(-1, 4))]
+    assert dsolve(eqs5) == sol5
+    assert checksysodesol(eqs5, sol5) == (True, [0, 0, 0, 0])
+
+    eqs6 = [Eq(Derivative(f(x), x), x**2*(f(x) + g(x) + h(x) + k(x) + 1)),
+            Eq(Derivative(g(x), x), x**2*(f(x) + g(x) + h(x) + k(x) + 1)),
+            Eq(Derivative(h(x), x), x**2*(f(x) + g(x) + h(x) + k(x) + 1)),
+            Eq(Derivative(k(x), x), x**2*(f(x) + g(x) + h(x) + k(x) + 1))]
+    sol6 = [Eq(f(x), C1*Rational(-1, 4) + C2*Rational(-1, 4) + C3*Rational(-1, 4) + C4*Rational(3, 4) + (C1/4 +
+             C2/4 + C3/4 + C4/4)*exp(x**3*Rational(4, 3)) + Rational(-1, 4)),
+            Eq(g(x), C1*Rational(3, 4) + C2*Rational(-1, 4) + C3*Rational(-1, 4) + C4*Rational(-1, 4) + (C1/4 +
+             C2/4 + C3/4 + C4/4)*exp(x**3*Rational(4, 3)) + Rational(-1, 4)),
+            Eq(h(x), C1*Rational(-1, 4) + C2*Rational(3, 4) + C3*Rational(-1, 4) + C4*Rational(-1, 4) + (C1/4 +
+             C2/4 + C3/4 + C4/4)*exp(x**3*Rational(4, 3)) + Rational(-1, 4)),
+            Eq(k(x), C1*Rational(-1, 4) + C2*Rational(-1, 4) + C3*Rational(3, 4) + C4*Rational(-1, 4) + (C1/4 +
+             C2/4 + C3/4 + C4/4)*exp(x**3*Rational(4, 3)) + Rational(-1, 4))]
+    assert dsolve(eqs6) == sol6
+    assert checksysodesol(eqs6, sol6) == (True, [0, 0, 0, 0])
+
+    eqs7 = [Eq(Derivative(f(x), x), (f(x) + g(x) + h(x))*log(x) + sin(x)), Eq(Derivative(g(x), x), (f(x) + g(x)
+            + h(x))*log(x) + sin(x)), Eq(Derivative(h(x), x), (f(x) + g(x) + h(x))*log(x) + sin(x))]
+    sol7 = [Eq(f(x), -C1/3 - C2/3 + 2*C3/3 + (C1/3 + C2/3 +
+                C3/3)*exp(x*(3*log(x) - 3)) + exp(x*(3*log(x) -
+                    3))*Integral(exp(3*x)*exp(-3*x*log(x))*sin(x), x)),
+            Eq(g(x), 2*C1/3 - C2/3 - C3/3 + (C1/3 + C2/3 +
+                C3/3)*exp(x*(3*log(x) - 3)) + exp(x*(3*log(x) -
+                    3))*Integral(exp(3*x)*exp(-3*x*log(x))*sin(x), x)),
+            Eq(h(x), -C1/3 + 2*C2/3 - C3/3 + (C1/3 + C2/3 +
+                C3/3)*exp(x*(3*log(x) - 3)) + exp(x*(3*log(x) -
+                    3))*Integral(exp(3*x)*exp(-3*x*log(x))*sin(x), x))]
+    with dotprodsimp(True):
+        assert dsolve(eqs7, simplify=False, doit=False) == sol7
+    assert checksysodesol(eqs7, sol7) == (True, [0, 0, 0])
+
+    eqs8 = [Eq(Derivative(f(x), x), (f(x) + g(x) + h(x) + k(x))*log(x) + sin(x)), Eq(Derivative(g(x), x), (f(x)
+            + g(x) + h(x) + k(x))*log(x) + sin(x)), Eq(Derivative(h(x), x), (f(x) + g(x) + h(x) + k(x))*log(x) +
+            sin(x)), Eq(Derivative(k(x), x), (f(x) + g(x) + h(x) + k(x))*log(x) + sin(x))]
+    sol8 = [Eq(f(x), -C1/4 - C2/4 - C3/4 + 3*C4/4 + (C1/4 + C2/4 + C3/4 +
+                C4/4)*exp(x*(4*log(x) - 4)) + exp(x*(4*log(x) -
+                    4))*Integral(exp(4*x)*exp(-4*x*log(x))*sin(x), x)),
+            Eq(g(x), 3*C1/4 - C2/4 - C3/4 - C4/4 + (C1/4 + C2/4 + C3/4 +
+                C4/4)*exp(x*(4*log(x) - 4)) + exp(x*(4*log(x) -
+                    4))*Integral(exp(4*x)*exp(-4*x*log(x))*sin(x), x)),
+            Eq(h(x), -C1/4 + 3*C2/4 - C3/4 - C4/4 + (C1/4 + C2/4 + C3/4 +
+                C4/4)*exp(x*(4*log(x) - 4)) + exp(x*(4*log(x) -
+                    4))*Integral(exp(4*x)*exp(-4*x*log(x))*sin(x), x)),
+            Eq(k(x), -C1/4 - C2/4 + 3*C3/4 - C4/4 + (C1/4 + C2/4 + C3/4 +
+                C4/4)*exp(x*(4*log(x) - 4)) + exp(x*(4*log(x) -
+                    4))*Integral(exp(4*x)*exp(-4*x*log(x))*sin(x), x))]
+    with dotprodsimp(True):
+        assert dsolve(eqs8) == sol8
+    assert checksysodesol(eqs8, sol8) == (True, [0, 0, 0, 0])
+
+
+def test_sysode_linear_neq_order1_type5_type6():
+    f, g = symbols("f g", cls=Function)
+    x, x_ = symbols("x x_")
+
+    # Type 5
+    eqs1 = [Eq(Derivative(f(x), x), (2*f(x) + g(x))/x), Eq(Derivative(g(x), x), (f(x) + 2*g(x))/x)]
+    sol1 = [Eq(f(x), -C1*x + C2*x**3), Eq(g(x), C1*x + C2*x**3)]
+    assert dsolve(eqs1) == sol1
+    assert checksysodesol(eqs1, sol1) == (True, [0, 0])
+
+    # Type 6
+    eqs2 = [Eq(Derivative(f(x), x), (2*f(x) + g(x) + 1)/x),
+            Eq(Derivative(g(x), x), (x + f(x) + 2*g(x))/x)]
+    sol2 = [Eq(f(x), C2*x**3 - x*(C1 + Rational(1, 4)) + x*log(x)*Rational(-1, 2) + Rational(-2, 3)),
+            Eq(g(x), C2*x**3 + x*log(x)/2 + x*(C1 + Rational(-1, 4)) + Rational(1, 3))]
+    assert dsolve(eqs2) == sol2
+    assert checksysodesol(eqs2, sol2) == (True, [0, 0])
+
+
+def test_higher_order_to_first_order():
+    f, g = symbols('f g', cls=Function)
+    x = symbols('x')
+
+    eqs1 = [Eq(Derivative(f(x), (x, 2)), 2*f(x) + g(x)),
+            Eq(Derivative(g(x), (x, 2)), -f(x))]
+    sol1 = [Eq(f(x), -C2*x*exp(-x) + C3*x*exp(x) - (C1 - C2)*exp(-x) + (C3 + C4)*exp(x)),
+            Eq(g(x), C2*x*exp(-x) - C3*x*exp(x) + (C1 + C2)*exp(-x) + (C3 - C4)*exp(x))]
+    assert dsolve(eqs1) == sol1
+    assert checksysodesol(eqs1, sol1) == (True, [0, 0])
+
+    eqs2 = [Eq(f(x).diff(x, 2), 0), Eq(g(x).diff(x, 2), f(x))]
+    sol2 = [Eq(f(x), C1 + C2*x), Eq(g(x), C1*x**2/2 + C2*x**3/6 + C3 + C4*x)]
+    assert dsolve(eqs2) == sol2
+    assert checksysodesol(eqs2, sol2) == (True, [0, 0])
+
+    eqs3 = [Eq(Derivative(f(x), (x, 2)), 2*f(x)),
+            Eq(Derivative(g(x), (x, 2)), -f(x) + 2*g(x))]
+    sol3 = [Eq(f(x), 4*C1*exp(-sqrt(2)*x) + 4*C2*exp(sqrt(2)*x)),
+            Eq(g(x), sqrt(2)*C1*x*exp(-sqrt(2)*x) - sqrt(2)*C2*x*exp(sqrt(2)*x) + (C1 +
+             sqrt(2)*C4)*exp(-sqrt(2)*x) + (C2 - sqrt(2)*C3)*exp(sqrt(2)*x))]
+    assert dsolve(eqs3) == sol3
+    assert checksysodesol(eqs3, sol3) == (True, [0, 0])
+
+    eqs4 = [Eq(Derivative(f(x), (x, 2)), 2*f(x) + g(x)),
+            Eq(Derivative(g(x), (x, 2)), 2*g(x))]
+    sol4 = [Eq(f(x), C1*x*exp(sqrt(2)*x)/4 + C3*x*exp(-sqrt(2)*x)/4 + (C2/4 + sqrt(2)*C3/8)*exp(-sqrt(2)*x) -
+             exp(sqrt(2)*x)*(sqrt(2)*C1/8 + C4*Rational(-1, 4))),
+            Eq(g(x), sqrt(2)*C1*exp(sqrt(2)*x)/2 + sqrt(2)*C3*exp(-sqrt(2)*x)*Rational(-1, 2))]
+    assert dsolve(eqs4) == sol4
+    assert checksysodesol(eqs4, sol4) == (True, [0, 0])
+
+    eqs5 = [Eq(f(x).diff(x, 2), f(x)), Eq(g(x).diff(x, 2), f(x))]
+    sol5 = [Eq(f(x), -C1*exp(-x) + C2*exp(x)), Eq(g(x), -C1*exp(-x) + C2*exp(x) + C3 + C4*x)]
+    assert dsolve(eqs5) == sol5
+    assert checksysodesol(eqs5, sol5) == (True, [0, 0])
+
+    eqs6 = [Eq(Derivative(f(x), (x, 2)), f(x) + g(x)),
+            Eq(Derivative(g(x), (x, 2)), -f(x) - g(x))]
+    sol6 = [Eq(f(x), C1 + C2*x**2/2 + C2 + C4*x**3/6 + x*(C3 + C4)),
+            Eq(g(x), -C1 + C2*x**2*Rational(-1, 2) - C3*x + C4*x**3*Rational(-1, 6))]
+    assert dsolve(eqs6) == sol6
+    assert checksysodesol(eqs6, sol6) == (True, [0, 0])
+
+    eqs7 = [Eq(Derivative(f(x), (x, 2)), f(x) + g(x) + 1),
+            Eq(Derivative(g(x), (x, 2)), f(x) + g(x) + 1)]
+    sol7 = [Eq(f(x), -C1 - C2*x + sqrt(2)*C3*exp(sqrt(2)*x)/2 + sqrt(2)*C4*exp(-sqrt(2)*x)*Rational(-1, 2) +
+             Rational(-1, 2)),
+            Eq(g(x), C1 + C2*x + sqrt(2)*C3*exp(sqrt(2)*x)/2 + sqrt(2)*C4*exp(-sqrt(2)*x)*Rational(-1, 2) +
+             Rational(-1, 2))]
+    assert dsolve(eqs7) == sol7
+    assert checksysodesol(eqs7, sol7) == (True, [0, 0])
+
+    eqs8 = [Eq(Derivative(f(x), (x, 2)), f(x) + g(x) + 1),
+            Eq(Derivative(g(x), (x, 2)), -f(x) - g(x) + 1)]
+    sol8 = [Eq(f(x), C1 + C2 + C4*x**3/6 + x**4/12 + x**2*(C2/2 + Rational(1, 2)) + x*(C3 + C4)),
+            Eq(g(x), -C1 - C3*x + C4*x**3*Rational(-1, 6) + x**4*Rational(-1, 12) - x**2*(C2/2 + Rational(-1,
+             2)))]
+    assert dsolve(eqs8) == sol8
+    assert checksysodesol(eqs8, sol8) == (True, [0, 0])
+
+    x, y = symbols('x, y', cls=Function)
+    t, l = symbols('t, l')
+
+    eqs10 = [Eq(Derivative(x(t), (t, 2)), 5*x(t) + 43*y(t)),
+             Eq(Derivative(y(t), (t, 2)), x(t) + 9*y(t))]
+    sol10 = [Eq(x(t), C1*(61 - 9*sqrt(47))*sqrt(sqrt(47) + 7)*exp(-t*sqrt(sqrt(47) + 7))/2 + C2*sqrt(7 -
+              sqrt(47))*(61 + 9*sqrt(47))*exp(-t*sqrt(7 - sqrt(47)))/2 + C3*(61 - 9*sqrt(47))*sqrt(sqrt(47) +
+              7)*exp(t*sqrt(sqrt(47) + 7))*Rational(-1, 2) + C4*sqrt(7 - sqrt(47))*(61 + 9*sqrt(47))*exp(t*sqrt(7
+              - sqrt(47)))*Rational(-1, 2)),
+             Eq(y(t), C1*(7 - sqrt(47))*sqrt(sqrt(47) + 7)*exp(-t*sqrt(sqrt(47) + 7))*Rational(-1, 2) + C2*sqrt(7
+              - sqrt(47))*(sqrt(47) + 7)*exp(-t*sqrt(7 - sqrt(47)))*Rational(-1, 2) + C3*(7 -
+              sqrt(47))*sqrt(sqrt(47) + 7)*exp(t*sqrt(sqrt(47) + 7))/2 + C4*sqrt(7 - sqrt(47))*(sqrt(47) +
+              7)*exp(t*sqrt(7 - sqrt(47)))/2)]
+    assert dsolve(eqs10) == sol10
+    assert checksysodesol(eqs10, sol10) == (True, [0, 0])
+
+    eqs11 = [Eq(7*x(t) + Derivative(x(t), (t, 2)) - 9*Derivative(y(t), t), 0),
+             Eq(7*y(t) + 9*Derivative(x(t), t) + Derivative(y(t), (t, 2)), 0)]
+    sol11 = [Eq(y(t), C1*(9 - sqrt(109))*sin(sqrt(2)*t*sqrt(9*sqrt(109) + 95)/2)/14 + C2*(9 -
+              sqrt(109))*cos(sqrt(2)*t*sqrt(9*sqrt(109) + 95)/2)*Rational(-1, 14) + C3*(9 +
+              sqrt(109))*sin(sqrt(2)*t*sqrt(95 - 9*sqrt(109))/2)/14 + C4*(9 + sqrt(109))*cos(sqrt(2)*t*sqrt(95 -
+              9*sqrt(109))/2)*Rational(-1, 14)),
+             Eq(x(t), C1*(9 - sqrt(109))*cos(sqrt(2)*t*sqrt(9*sqrt(109) + 95)/2)*Rational(-1, 14) + C2*(9 -
+              sqrt(109))*sin(sqrt(2)*t*sqrt(9*sqrt(109) + 95)/2)*Rational(-1, 14) + C3*(9 +
+              sqrt(109))*cos(sqrt(2)*t*sqrt(95 - 9*sqrt(109))/2)/14 + C4*(9 + sqrt(109))*sin(sqrt(2)*t*sqrt(95 -
+              9*sqrt(109))/2)/14)]
+    assert dsolve(eqs11) == sol11
+    assert checksysodesol(eqs11, sol11) == (True, [0, 0])
+
+    # Euler Systems
+    # Note: To add examples of euler systems solver with non-homogeneous term.
+    eqs13 = [Eq(Derivative(f(t), (t, 2)), Derivative(f(t), t)/t + f(t)/t**2 + g(t)/t**2),
+             Eq(Derivative(g(t), (t, 2)), g(t)/t**2)]
+    sol13 = [Eq(f(t), C1*(sqrt(5) + 3)*Rational(-1, 2)*t**(Rational(1, 2) +
+                sqrt(5)*Rational(-1, 2)) + C2*t**(Rational(1, 2) +
+                sqrt(5)/2)*(3 - sqrt(5))*Rational(-1, 2) - C3*t**(1 -
+                sqrt(2))*(1 + sqrt(2)) - C4*t**(1 + sqrt(2))*(1 - sqrt(2))),
+             Eq(g(t), C1*(1 + sqrt(5))*Rational(-1, 2)*t**(Rational(1, 2) +
+                 sqrt(5)*Rational(-1, 2)) + C2*t**(Rational(1, 2) +
+                     sqrt(5)/2)*(1 - sqrt(5))*Rational(-1, 2))]
+    assert dsolve(eqs13) == sol13
+    assert checksysodesol(eqs13, sol13) == (True, [0, 0])
+
+    # Solving systems using dsolve separately
+    eqs14 = [Eq(Derivative(f(t), (t, 2)), t*f(t)),
+         Eq(Derivative(g(t), (t, 2)), t*g(t))]
+    sol14 = [Eq(f(t), C1*airyai(t) + C2*airybi(t)),
+         Eq(g(t), C3*airyai(t) + C4*airybi(t))]
+    assert dsolve(eqs14) == sol14
+    assert checksysodesol(eqs14, sol14) == (True, [0, 0])
+
+
+    eqs15 = [Eq(Derivative(x(t), (t, 2)), t*(4*Derivative(x(t), t) + 8*Derivative(y(t), t))),
+             Eq(Derivative(y(t), (t, 2)), t*(12*Derivative(x(t), t) - 6*Derivative(y(t), t)))]
+    sol15 = [Eq(x(t), C1 - erf(sqrt(6)*t)*(sqrt(6)*sqrt(pi)*C2/33 + sqrt(6)*sqrt(pi)*C3*Rational(-1, 44)) +
+              erfi(sqrt(5)*t)*(sqrt(5)*sqrt(pi)*C2*Rational(2, 55) + sqrt(5)*sqrt(pi)*C3*Rational(4, 55))),
+             Eq(y(t), C4 + erf(sqrt(6)*t)*(sqrt(6)*sqrt(pi)*C2*Rational(2, 33) + sqrt(6)*sqrt(pi)*C3*Rational(-1,
+              22)) + erfi(sqrt(5)*t)*(sqrt(5)*sqrt(pi)*C2*Rational(3, 110) + sqrt(5)*sqrt(pi)*C3*Rational(3, 55)))]
+    assert dsolve(eqs15) == sol15
+    assert checksysodesol(eqs15, sol15) == (True, [0, 0])
+
+
+@slow
+def test_higher_order_to_first_order_9():
+    f, g = symbols('f g', cls=Function)
+    x = symbols('x')
+
+    eqs9 = [f(x) + g(x) - 2*exp(I*x) + 2*Derivative(f(x), x) + Derivative(f(x), (x, 2)),
+            f(x) + g(x) - 2*exp(I*x) + 2*Derivative(g(x), x) + Derivative(g(x), (x, 2))]
+    sol9 =  [Eq(f(x), -C1 + C4*exp(-2*x)/2 - (C2/2 - C3/2)*exp(-x)*cos(x)
+                    + (C2/2 + C3/2)*exp(-x)*sin(x) + 2*((1 - 2*I)*exp(I*x)*sin(x)**2/5)
+                    + 2*((1 - 2*I)*exp(I*x)*cos(x)**2/5)),
+            Eq(g(x), C1 - C4*exp(-2*x)/2 - (C2/2 - C3/2)*exp(-x)*cos(x)
+                    + (C2/2 + C3/2)*exp(-x)*sin(x) + 2*((1 - 2*I)*exp(I*x)*sin(x)**2/5)
+                    + 2*((1 - 2*I)*exp(I*x)*cos(x)**2/5))]
+    assert dsolve(eqs9) == sol9
+    assert checksysodesol(eqs9, sol9) == (True, [0, 0])
+
+
+def test_higher_order_to_first_order_12():
+    f, g = symbols('f g', cls=Function)
+    x = symbols('x')
+
+    x, y = symbols('x, y', cls=Function)
+    t, l = symbols('t, l')
+
+    eqs12 = [Eq(4*x(t) + Derivative(x(t), (t, 2)) + 8*Derivative(y(t), t), 0),
+             Eq(4*y(t) - 8*Derivative(x(t), t) + Derivative(y(t), (t, 2)), 0)]
+    sol12 = [Eq(y(t), C1*(2 - sqrt(5))*sin(2*t*sqrt(4*sqrt(5) + 9))*Rational(-1, 2) + C2*(2 -
+              sqrt(5))*cos(2*t*sqrt(4*sqrt(5) + 9))/2 + C3*(2 + sqrt(5))*sin(2*t*sqrt(9 - 4*sqrt(5)))*Rational(-1,
+              2) + C4*(2 + sqrt(5))*cos(2*t*sqrt(9 - 4*sqrt(5)))/2),
+             Eq(x(t), C1*(2 - sqrt(5))*cos(2*t*sqrt(4*sqrt(5) + 9))*Rational(-1, 2) + C2*(2 -
+              sqrt(5))*sin(2*t*sqrt(4*sqrt(5) + 9))*Rational(-1, 2) + C3*(2 + sqrt(5))*cos(2*t*sqrt(9 -
+              4*sqrt(5)))/2 + C4*(2 + sqrt(5))*sin(2*t*sqrt(9 - 4*sqrt(5)))/2)]
+    assert dsolve(eqs12) == sol12
+    assert checksysodesol(eqs12, sol12) == (True, [0, 0])
+
+
+def test_second_order_to_first_order_2():
+    f, g = symbols("f g", cls=Function)
+    x, t, x_, t_, d, a, m = symbols("x t x_ t_ d a m")
+
+    eqs2 = [Eq(f(x).diff(x, 2), 2*(x*g(x).diff(x) - g(x))),
+            Eq(g(x).diff(x, 2),-2*(x*f(x).diff(x) - f(x)))]
+    sol2 = [Eq(f(x), C1*x + x*Integral(C2*exp(-x_)*exp(I*exp(2*x_))/2 + C2*exp(-x_)*exp(-I*exp(2*x_))/2 -
+                I*C3*exp(-x_)*exp(I*exp(2*x_))/2 + I*C3*exp(-x_)*exp(-I*exp(2*x_))/2, (x_, log(x)))),
+            Eq(g(x), C4*x + x*Integral(I*C2*exp(-x_)*exp(I*exp(2*x_))/2 - I*C2*exp(-x_)*exp(-I*exp(2*x_))/2 +
+                C3*exp(-x_)*exp(I*exp(2*x_))/2 + C3*exp(-x_)*exp(-I*exp(2*x_))/2, (x_, log(x))))]
+    # XXX: dsolve hangs for this in integration
+    assert dsolve_system(eqs2, simplify=False, doit=False) == [sol2]
+    assert checksysodesol(eqs2, sol2) == (True, [0, 0])
+
+    eqs3 = (Eq(diff(f(t),t,t), 9*t*diff(g(t),t)-9*g(t)), Eq(diff(g(t),t,t),7*t*diff(f(t),t)-7*f(t)))
+    sol3 = [Eq(f(t), C1*t + t*Integral(C2*exp(-t_)*exp(3*sqrt(7)*exp(2*t_)/2)/2 + C2*exp(-t_)*
+                exp(-3*sqrt(7)*exp(2*t_)/2)/2 + 3*sqrt(7)*C3*exp(-t_)*exp(3*sqrt(7)*exp(2*t_)/2)/14 -
+                3*sqrt(7)*C3*exp(-t_)*exp(-3*sqrt(7)*exp(2*t_)/2)/14, (t_, log(t)))),
+            Eq(g(t), C4*t + t*Integral(sqrt(7)*C2*exp(-t_)*exp(3*sqrt(7)*exp(2*t_)/2)/6 - sqrt(7)*C2*exp(-t_)*
+                exp(-3*sqrt(7)*exp(2*t_)/2)/6 + C3*exp(-t_)*exp(3*sqrt(7)*exp(2*t_)/2)/2 + C3*exp(-t_)*exp(-3*sqrt(7)*
+                exp(2*t_)/2)/2, (t_, log(t))))]
+    # XXX: dsolve hangs for this in integration
+    assert dsolve_system(eqs3, simplify=False, doit=False) == [sol3]
+    assert checksysodesol(eqs3, sol3) == (True, [0, 0])
+
+    # Regression Test case for sympy#19238
+    # https://github.com/sympy/sympy/issues/19238
+    # Note: When the doit method is removed, these particular types of systems
+    # can be divided first so that we have lesser number of big matrices.
+    eqs5 = [Eq(Derivative(g(t), (t, 2)), a*m),
+            Eq(Derivative(f(t), (t, 2)), 0)]
+    sol5 = [Eq(g(t), C1 + C2*t + a*m*t**2/2),
+            Eq(f(t), C3 + C4*t)]
+    assert dsolve(eqs5) == sol5
+    assert checksysodesol(eqs5, sol5) == (True, [0, 0])
+
+    # Type 2
+    eqs6 = [Eq(Derivative(f(t), (t, 2)), f(t)/t**4),
+            Eq(Derivative(g(t), (t, 2)), d*g(t)/t**4)]
+    sol6 = [Eq(f(t), C1*sqrt(t**2)*exp(-1/t) - C2*sqrt(t**2)*exp(1/t)),
+            Eq(g(t), C3*sqrt(t**2)*exp(-sqrt(d)/t)*d**Rational(-1, 2) -
+             C4*sqrt(t**2)*exp(sqrt(d)/t)*d**Rational(-1, 2))]
+    assert dsolve(eqs6) == sol6
+    assert checksysodesol(eqs6, sol6) == (True, [0, 0])
+
+
+@slow
+def test_second_order_to_first_order_slow1():
+    f, g = symbols("f g", cls=Function)
+    x, t, x_, t_, d, a, m = symbols("x t x_ t_ d a m")
+
+    # Type 1
+
+    eqs1 = [Eq(f(x).diff(x, 2), 2/x *(x*g(x).diff(x) - g(x))),
+           Eq(g(x).diff(x, 2),-2/x *(x*f(x).diff(x) - f(x)))]
+    sol1 = [Eq(f(x), C1*x + 2*C2*x*Ci(2*x) - C2*sin(2*x) - 2*C3*x*Si(2*x) - C3*cos(2*x)),
+            Eq(g(x), -2*C2*x*Si(2*x) - C2*cos(2*x) - 2*C3*x*Ci(2*x) + C3*sin(2*x) + C4*x)]
+    assert dsolve(eqs1) == sol1
+    assert checksysodesol(eqs1, sol1) == (True, [0, 0])
+
+
+def test_second_order_to_first_order_slow4():
+    f, g = symbols("f g", cls=Function)
+    x, t, x_, t_, d, a, m = symbols("x t x_ t_ d a m")
+
+    eqs4 = [Eq(Derivative(f(t), (t, 2)), t*sin(t)*Derivative(g(t), t) - g(t)*sin(t)),
+            Eq(Derivative(g(t), (t, 2)), t*sin(t)*Derivative(f(t), t) - f(t)*sin(t))]
+    sol4 = [Eq(f(t), C1*t + t*Integral(C2*exp(-t_)*exp(exp(t_)*cos(exp(t_)))*exp(-sin(exp(t_)))/2 +
+                C2*exp(-t_)*exp(-exp(t_)*cos(exp(t_)))*exp(sin(exp(t_)))/2 - C3*exp(-t_)*exp(exp(t_)*cos(exp(t_)))*
+                exp(-sin(exp(t_)))/2 +
+                C3*exp(-t_)*exp(-exp(t_)*cos(exp(t_)))*exp(sin(exp(t_)))/2, (t_, log(t)))),
+            Eq(g(t), C4*t + t*Integral(-C2*exp(-t_)*exp(exp(t_)*cos(exp(t_)))*exp(-sin(exp(t_)))/2 +
+                C2*exp(-t_)*exp(-exp(t_)*cos(exp(t_)))*exp(sin(exp(t_)))/2 + C3*exp(-t_)*exp(exp(t_)*cos(exp(t_)))*
+                exp(-sin(exp(t_)))/2 + C3*exp(-t_)*exp(-exp(t_)*cos(exp(t_)))*exp(sin(exp(t_)))/2, (t_, log(t))))]
+    # XXX: dsolve hangs for this in integration
+    assert dsolve_system(eqs4, simplify=False, doit=False) == [sol4]
+    assert checksysodesol(eqs4, sol4) == (True, [0, 0])
+
+
+def test_component_division():
+    f, g, h, k = symbols('f g h k', cls=Function)
+    x = symbols("x")
+    funcs = [f(x), g(x), h(x), k(x)]
+
+    eqs1 = [Eq(Derivative(f(x), x), 2*f(x)),
+            Eq(Derivative(g(x), x), f(x)),
+            Eq(Derivative(h(x), x), h(x)),
+            Eq(Derivative(k(x), x), h(x)**4 + k(x))]
+    sol1 = [Eq(f(x), 2*C1*exp(2*x)),
+            Eq(g(x), C1*exp(2*x) + C2),
+            Eq(h(x), C3*exp(x)),
+            Eq(k(x), C3**4*exp(4*x)/3 + C4*exp(x))]
+    assert dsolve(eqs1) == sol1
+    assert checksysodesol(eqs1, sol1) == (True, [0, 0, 0, 0])
+
+    components1 = {((Eq(Derivative(f(x), x), 2*f(x)),), (Eq(Derivative(g(x), x), f(x)),)),
+                   ((Eq(Derivative(h(x), x), h(x)),), (Eq(Derivative(k(x), x), h(x)**4 + k(x)),))}
+    eqsdict1 = ({f(x): set(), g(x): {f(x)}, h(x): set(), k(x): {h(x)}},
+                {f(x): Eq(Derivative(f(x), x), 2*f(x)),
+                g(x): Eq(Derivative(g(x), x), f(x)),
+                h(x): Eq(Derivative(h(x), x), h(x)),
+                k(x): Eq(Derivative(k(x), x), h(x)**4 + k(x))})
+    graph1 = [{f(x), g(x), h(x), k(x)}, {(g(x), f(x)), (k(x), h(x))}]
+    assert {tuple(tuple(scc) for scc in wcc) for wcc in _component_division(eqs1, funcs, x)} == components1
+    assert _eqs2dict(eqs1, funcs) == eqsdict1
+    assert [set(element) for element in _dict2graph(eqsdict1[0])] == graph1
+
+    eqs2 = [Eq(Derivative(f(x), x), 2*f(x)),
+            Eq(Derivative(g(x), x), f(x)),
+            Eq(Derivative(h(x), x), h(x)),
+            Eq(Derivative(k(x), x), f(x)**4 + k(x))]
+    sol2 = [Eq(f(x), C1*exp(2*x)),
+            Eq(g(x), C1*exp(2*x)/2 + C2),
+            Eq(h(x), C3*exp(x)),
+            Eq(k(x), C1**4*exp(8*x)/7 + C4*exp(x))]
+    assert dsolve(eqs2) == sol2
+    assert checksysodesol(eqs2, sol2) == (True, [0, 0, 0, 0])
+
+    components2 = {frozenset([(Eq(Derivative(f(x), x), 2*f(x)),),
+                    (Eq(Derivative(g(x), x), f(x)),),
+                    (Eq(Derivative(k(x), x), f(x)**4 + k(x)),)]),
+                   frozenset([(Eq(Derivative(h(x), x), h(x)),)])}
+    eqsdict2 = ({f(x): set(), g(x): {f(x)}, h(x): set(), k(x): {f(x)}},
+                 {f(x): Eq(Derivative(f(x), x), 2*f(x)),
+                  g(x): Eq(Derivative(g(x), x), f(x)),
+                  h(x): Eq(Derivative(h(x), x), h(x)),
+                  k(x): Eq(Derivative(k(x), x), f(x)**4 + k(x))})
+    graph2 = [{f(x), g(x), h(x), k(x)}, {(g(x), f(x)), (k(x), f(x))}]
+    assert {frozenset(tuple(scc) for scc in wcc) for wcc in _component_division(eqs2, funcs, x)} == components2
+    assert _eqs2dict(eqs2, funcs) == eqsdict2
+    assert [set(element) for element in _dict2graph(eqsdict2[0])] == graph2
+
+    eqs3 = [Eq(Derivative(f(x), x), 2*f(x)),
+            Eq(Derivative(g(x), x), x + f(x)),
+            Eq(Derivative(h(x), x), h(x)),
+            Eq(Derivative(k(x), x), f(x)**4 + k(x))]
+    sol3 = [Eq(f(x), C1*exp(2*x)),
+            Eq(g(x), C1*exp(2*x)/2 + C2 + x**2/2),
+            Eq(h(x), C3*exp(x)),
+            Eq(k(x), C1**4*exp(8*x)/7 + C4*exp(x))]
+    assert dsolve(eqs3) == sol3
+    assert checksysodesol(eqs3, sol3) == (True, [0, 0, 0, 0])
+
+    components3 = {frozenset([(Eq(Derivative(f(x), x), 2*f(x)),),
+                    (Eq(Derivative(g(x), x), x + f(x)),),
+                    (Eq(Derivative(k(x), x), f(x)**4 + k(x)),)]),
+                    frozenset([(Eq(Derivative(h(x), x), h(x)),),])}
+    eqsdict3 = ({f(x): set(), g(x): {f(x)}, h(x): set(), k(x): {f(x)}},
+                {f(x): Eq(Derivative(f(x), x), 2*f(x)),
+                g(x): Eq(Derivative(g(x), x), x + f(x)),
+                h(x): Eq(Derivative(h(x), x), h(x)),
+                k(x): Eq(Derivative(k(x), x), f(x)**4 + k(x))})
+    graph3 = [{f(x), g(x), h(x), k(x)}, {(g(x), f(x)), (k(x), f(x))}]
+    assert {frozenset(tuple(scc) for scc in wcc) for wcc in _component_division(eqs3, funcs, x)} == components3
+    assert _eqs2dict(eqs3, funcs) == eqsdict3
+    assert [set(l) for l in _dict2graph(eqsdict3[0])] == graph3
+
+    # Note: To be uncommented when the default option to call dsolve first for
+    # single ODE system can be rearranged. This can be done after the doit
+    # option in dsolve is made False by default.
+
+    eqs4 = [Eq(Derivative(f(x), x), x*f(x) + 2*g(x)),
+            Eq(Derivative(g(x), x), f(x) + x*g(x) + x),
+            Eq(Derivative(h(x), x), h(x)),
+            Eq(Derivative(k(x), x), f(x)**4 + k(x))]
+    sol4 = [Eq(f(x), (C1/2 - sqrt(2)*C2/2 - sqrt(2)*Integral(x*exp(-x**2/2 - sqrt(2)*x)/2 + x*exp(-x**2/2 +\
+                sqrt(2)*x)/2, x)/2 + Integral(sqrt(2)*x*exp(-x**2/2 - sqrt(2)*x)/2 - sqrt(2)*x*exp(-x**2/2 +\
+                sqrt(2)*x)/2, x)/2)*exp(x**2/2 - sqrt(2)*x) + (C1/2 + sqrt(2)*C2/2 + sqrt(2)*Integral(x*exp(-x**2/2
+                - sqrt(2)*x)/2 + x*exp(-x**2/2 + sqrt(2)*x)/2, x)/2 + Integral(sqrt(2)*x*exp(-x**2/2 - sqrt(2)*x)/2
+                - sqrt(2)*x*exp(-x**2/2 + sqrt(2)*x)/2, x)/2)*exp(x**2/2 + sqrt(2)*x)),
+            Eq(g(x), (-sqrt(2)*C1/4 + C2/2 + Integral(x*exp(-x**2/2 - sqrt(2)*x)/2 + x*exp(-x**2/2 + sqrt(2)*x)/2, x)/2 -\
+                sqrt(2)*Integral(sqrt(2)*x*exp(-x**2/2 - sqrt(2)*x)/2 - sqrt(2)*x*exp(-x**2/2 + sqrt(2)*x)/2,
+                x)/4)*exp(x**2/2 - sqrt(2)*x) + (sqrt(2)*C1/4 + C2/2 + Integral(x*exp(-x**2/2 - sqrt(2)*x)/2 +
+                x*exp(-x**2/2 + sqrt(2)*x)/2, x)/2 + sqrt(2)*Integral(sqrt(2)*x*exp(-x**2/2 - sqrt(2)*x)/2 -
+                sqrt(2)*x*exp(-x**2/2 + sqrt(2)*x)/2, x)/4)*exp(x**2/2 + sqrt(2)*x)),
+            Eq(h(x), C3*exp(x)),
+            Eq(k(x), C4*exp(x) + exp(x)*Integral((C1*exp(x**2/2 - sqrt(2)*x)/2 + C1*exp(x**2/2 + sqrt(2)*x)/2 -
+                sqrt(2)*C2*exp(x**2/2 - sqrt(2)*x)/2 + sqrt(2)*C2*exp(x**2/2 + sqrt(2)*x)/2 - sqrt(2)*exp(x**2/2 -
+                sqrt(2)*x)*Integral(x*exp(-x**2/2 - sqrt(2)*x)/2 + x*exp(-x**2/2 + sqrt(2)*x)/2, x)/2 + exp(x**2/2 -
+                sqrt(2)*x)*Integral(sqrt(2)*x*exp(-x**2/2 - sqrt(2)*x)/2 - sqrt(2)*x*exp(-x**2/2 + sqrt(2)*x)/2,
+                x)/2 + sqrt(2)*exp(x**2/2 + sqrt(2)*x)*Integral(x*exp(-x**2/2 - sqrt(2)*x)/2 + x*exp(-x**2/2 +
+                sqrt(2)*x)/2, x)/2 + exp(x**2/2 + sqrt(2)*x)*Integral(sqrt(2)*x*exp(-x**2/2 - sqrt(2)*x)/2 -
+                sqrt(2)*x*exp(-x**2/2 + sqrt(2)*x)/2, x)/2)**4*exp(-x), x))]
+    components4 = {(frozenset([Eq(Derivative(f(x), x), x*f(x) + 2*g(x)),
+                    Eq(Derivative(g(x), x), x*g(x) + x + f(x))]),
+                    frozenset([Eq(Derivative(k(x), x), f(x)**4 + k(x)),])),
+                    (frozenset([Eq(Derivative(h(x), x), h(x)),]),)}
+    eqsdict4 = ({f(x): {g(x)}, g(x): {f(x)}, h(x): set(), k(x): {f(x)}},
+                {f(x): Eq(Derivative(f(x), x), x*f(x) + 2*g(x)),
+                g(x): Eq(Derivative(g(x), x), x*g(x) + x + f(x)),
+                h(x): Eq(Derivative(h(x), x), h(x)),
+                k(x): Eq(Derivative(k(x), x), f(x)**4 + k(x))})
+    graph4 = [{f(x), g(x), h(x), k(x)}, {(f(x), g(x)), (g(x), f(x)), (k(x), f(x))}]
+    assert {tuple(frozenset(scc) for scc in wcc) for wcc in _component_division(eqs4, funcs, x)} == components4
+    assert _eqs2dict(eqs4, funcs) == eqsdict4
+    assert [set(element) for element in _dict2graph(eqsdict4[0])] == graph4
+    # XXX: dsolve hangs in integration here:
+    assert dsolve_system(eqs4, simplify=False, doit=False) == [sol4]
+    assert checksysodesol(eqs4, sol4) == (True, [0, 0, 0, 0])
+
+    eqs5 = [Eq(Derivative(f(x), x), x*f(x) + 2*g(x)),
+            Eq(Derivative(g(x), x), x*g(x) + f(x)),
+            Eq(Derivative(h(x), x), h(x)),
+            Eq(Derivative(k(x), x), f(x)**4 + k(x))]
+    sol5 = [Eq(f(x), (C1/2 - sqrt(2)*C2/2)*exp(x**2/2 - sqrt(2)*x) + (C1/2 + sqrt(2)*C2/2)*exp(x**2/2 + sqrt(2)*x)),
+            Eq(g(x), (-sqrt(2)*C1/4 + C2/2)*exp(x**2/2 - sqrt(2)*x) + (sqrt(2)*C1/4 + C2/2)*exp(x**2/2 + sqrt(2)*x)),
+            Eq(h(x), C3*exp(x)),
+            Eq(k(x), C4*exp(x) + exp(x)*Integral((C1*exp(x**2/2 - sqrt(2)*x)/2 + C1*exp(x**2/2 + sqrt(2)*x)/2 -
+                sqrt(2)*C2*exp(x**2/2 - sqrt(2)*x)/2 + sqrt(2)*C2*exp(x**2/2 + sqrt(2)*x)/2)**4*exp(-x), x))]
+    components5 = {(frozenset([Eq(Derivative(f(x), x), x*f(x) + 2*g(x)),
+                    Eq(Derivative(g(x), x), x*g(x) + f(x))]),
+                    frozenset([Eq(Derivative(k(x), x), f(x)**4 + k(x)),])),
+                    (frozenset([Eq(Derivative(h(x), x), h(x)),]),)}
+    eqsdict5 = ({f(x): {g(x)}, g(x): {f(x)}, h(x): set(), k(x): {f(x)}},
+                {f(x): Eq(Derivative(f(x), x), x*f(x) + 2*g(x)),
+                g(x): Eq(Derivative(g(x), x), x*g(x) + f(x)),
+                h(x): Eq(Derivative(h(x), x), h(x)),
+                k(x): Eq(Derivative(k(x), x), f(x)**4 + k(x))})
+    graph5 = [{f(x), g(x), h(x), k(x)}, {(f(x), g(x)), (g(x), f(x)), (k(x), f(x))}]
+    assert {tuple(frozenset(scc) for scc in wcc) for wcc in _component_division(eqs5, funcs, x)} == components5
+    assert _eqs2dict(eqs5, funcs) == eqsdict5
+    assert [set(element) for element in _dict2graph(eqsdict5[0])] == graph5
+    # XXX: dsolve hangs in integration here:
+    assert dsolve_system(eqs5, simplify=False, doit=False) == [sol5]
+    assert checksysodesol(eqs5, sol5) == (True, [0, 0, 0, 0])
+
+
+def test_linodesolve():
+    t, x, a = symbols("t x a")
+    f, g, h = symbols("f g h", cls=Function)
+
+    # Testing the Errors
+    raises(ValueError, lambda: linodesolve(1, t))
+    raises(ValueError, lambda: linodesolve(a, t))
+
+    A1 = Matrix([[1, 2], [2, 4], [4, 6]])
+    raises(NonSquareMatrixError, lambda: linodesolve(A1, t))
+
+    A2 = Matrix([[1, 2, 1], [3, 1, 2]])
+    raises(NonSquareMatrixError, lambda: linodesolve(A2, t))
+
+    # Testing auto functionality
+    func = [f(t), g(t)]
+    eq = [Eq(f(t).diff(t) + g(t).diff(t), g(t)), Eq(g(t).diff(t), f(t))]
+    ceq = canonical_odes(eq, func, t)
+    (A1, A0), b = linear_ode_to_matrix(ceq[0], func, t, 1)
+    A = A0
+    sol = [C1*(-Rational(1, 2) + sqrt(5)/2)*exp(t*(-Rational(1, 2) + sqrt(5)/2)) + C2*(-sqrt(5)/2 - Rational(1, 2))*
+           exp(t*(-sqrt(5)/2 - Rational(1, 2))),
+           C1*exp(t*(-Rational(1, 2) + sqrt(5)/2)) + C2*exp(t*(-sqrt(5)/2 - Rational(1, 2)))]
+    assert constant_renumber(linodesolve(A, t), variables=Tuple(*eq).free_symbols) == sol
+
+    # Testing the Errors
+    raises(ValueError, lambda: linodesolve(1, t, b=Matrix([t+1])))
+    raises(ValueError, lambda: linodesolve(a, t, b=Matrix([log(t) + sin(t)])))
+
+    raises(ValueError, lambda: linodesolve(Matrix([7]), t, b=t**2))
+    raises(ValueError, lambda: linodesolve(Matrix([a+10]), t, b=log(t)*cos(t)))
+
+    raises(ValueError, lambda: linodesolve(7, t, b=t**2))
+    raises(ValueError, lambda: linodesolve(a, t, b=log(t) + sin(t)))
+
+    A1 = Matrix([[1, 2], [2, 4], [4, 6]])
+    b1 = Matrix([t, 1, t**2])
+    raises(NonSquareMatrixError, lambda: linodesolve(A1, t, b=b1))
+
+    A2 = Matrix([[1, 2, 1], [3, 1, 2]])
+    b2 = Matrix([t, t**2])
+    raises(NonSquareMatrixError, lambda: linodesolve(A2, t, b=b2))
+
+    raises(ValueError, lambda: linodesolve(A1[:2, :], t, b=b1))
+    raises(ValueError, lambda: linodesolve(A1[:2, :], t, b=b1[:1]))
+
+    # DOIT check
+    A1 = Matrix([[1, -1], [1, -1]])
+    b1 = Matrix([15*t - 10, -15*t - 5])
+    sol1 = [C1 + C2*t + C2 - 10*t**3 + 10*t**2 + t*(15*t**2 - 5*t) - 10*t,
+            C1 + C2*t - 10*t**3 - 5*t**2 + t*(15*t**2 - 5*t) - 5*t]
+    assert constant_renumber(linodesolve(A1, t, b=b1, type="type2", doit=True),
+                             variables=[t]) == sol1
+
+    # Testing auto functionality
+    func = [f(t), g(t)]
+    eq = [Eq(f(t).diff(t) + g(t).diff(t), g(t) + t), Eq(g(t).diff(t), f(t))]
+    ceq = canonical_odes(eq, func, t)
+    (A1, A0), b = linear_ode_to_matrix(ceq[0], func, t, 1)
+    A = A0
+    sol = [-C1*exp(-t/2 + sqrt(5)*t/2)/2 + sqrt(5)*C1*exp(-t/2 + sqrt(5)*t/2)/2 - sqrt(5)*C2*exp(-sqrt(5)*t/2 -
+          t/2)/2 - C2*exp(-sqrt(5)*t/2 - t/2)/2 - exp(-t/2 + sqrt(5)*t/2)*Integral(t*exp(-sqrt(5)*t/2 +
+          t/2)/(-5 + sqrt(5)) - sqrt(5)*t*exp(-sqrt(5)*t/2 + t/2)/(-5 + sqrt(5)), t)/2 + sqrt(5)*exp(-t/2 +
+          sqrt(5)*t/2)*Integral(t*exp(-sqrt(5)*t/2 + t/2)/(-5 + sqrt(5)) - sqrt(5)*t*exp(-sqrt(5)*t/2 +
+          t/2)/(-5 + sqrt(5)), t)/2 - sqrt(5)*exp(-sqrt(5)*t/2 - t/2)*Integral(-sqrt(5)*t*exp(t/2 +
+          sqrt(5)*t/2)/5, t)/2 - exp(-sqrt(5)*t/2 - t/2)*Integral(-sqrt(5)*t*exp(t/2 + sqrt(5)*t/2)/5, t)/2,
+         C1*exp(-t/2 + sqrt(5)*t/2) + C2*exp(-sqrt(5)*t/2 - t/2) + exp(-t/2 +
+          sqrt(5)*t/2)*Integral(t*exp(-sqrt(5)*t/2 + t/2)/(-5 + sqrt(5)) - sqrt(5)*t*exp(-sqrt(5)*t/2 +
+          t/2)/(-5 + sqrt(5)), t) + exp(-sqrt(5)*t/2 -
+              t/2)*Integral(-sqrt(5)*t*exp(t/2 + sqrt(5)*t/2)/5, t)]
+    assert constant_renumber(linodesolve(A, t, b=b), variables=[t]) == sol
+
+    # non-homogeneous term assumed to be 0
+    sol1 = [-C1*exp(-t/2 + sqrt(5)*t/2)/2 + sqrt(5)*C1*exp(-t/2 + sqrt(5)*t/2)/2 - sqrt(5)*C2*exp(-sqrt(5)*t/2
+                - t/2)/2 - C2*exp(-sqrt(5)*t/2 - t/2)/2,
+            C1*exp(-t/2 + sqrt(5)*t/2) + C2*exp(-sqrt(5)*t/2 - t/2)]
+    assert constant_renumber(linodesolve(A, t, type="type2"), variables=[t]) == sol1
+
+    # Testing the Errors
+    raises(ValueError, lambda: linodesolve(t+10, t))
+    raises(ValueError, lambda: linodesolve(a*t, t))
+
+    A1 = Matrix([[1, t], [-t, 1]])
+    B1, _ = _is_commutative_anti_derivative(A1, t)
+    raises(NonSquareMatrixError, lambda: linodesolve(A1[:, :1], t, B=B1))
+    raises(ValueError, lambda: linodesolve(A1, t, B=1))
+
+    A2 = Matrix([[t, t, t], [t, t, t], [t, t, t]])
+    B2, _ = _is_commutative_anti_derivative(A2, t)
+    raises(NonSquareMatrixError, lambda: linodesolve(A2, t, B=B2[:2, :]))
+    raises(ValueError, lambda: linodesolve(A2, t, B=2))
+    raises(ValueError, lambda: linodesolve(A2, t, B=B2, type="type31"))
+
+    raises(ValueError, lambda: linodesolve(A1, t, B=B2))
+    raises(ValueError, lambda: linodesolve(A2, t, B=B1))
+
+    # Testing auto functionality
+    func = [f(t), g(t)]
+    eq = [Eq(f(t).diff(t), f(t) + t*g(t)), Eq(g(t).diff(t), -t*f(t) + g(t))]
+    ceq = canonical_odes(eq, func, t)
+    (A1, A0), b = linear_ode_to_matrix(ceq[0], func, t, 1)
+    A = A0
+    sol = [(C1/2 - I*C2/2)*exp(I*t**2/2 + t) + (C1/2 + I*C2/2)*exp(-I*t**2/2 + t),
+           (-I*C1/2 + C2/2)*exp(-I*t**2/2 + t) + (I*C1/2 + C2/2)*exp(I*t**2/2 + t)]
+    assert constant_renumber(linodesolve(A, t), variables=Tuple(*eq).free_symbols) == sol
+    assert constant_renumber(linodesolve(A, t, type="type3"), variables=Tuple(*eq).free_symbols) == sol
+
+    A1 = Matrix([[t, 1], [t, -1]])
+    raises(NotImplementedError, lambda: linodesolve(A1, t))
+
+    # Testing the Errors
+    raises(ValueError, lambda: linodesolve(t+10, t, b=Matrix([t+1])))
+    raises(ValueError, lambda: linodesolve(a*t, t, b=Matrix([log(t) + sin(t)])))
+
+    raises(ValueError, lambda: linodesolve(Matrix([7*t]), t, b=t**2))
+    raises(ValueError, lambda: linodesolve(Matrix([a + 10*log(t)]), t, b=log(t)*cos(t)))
+
+    raises(ValueError, lambda: linodesolve(7*t, t, b=t**2))
+    raises(ValueError, lambda: linodesolve(a*t**2, t, b=log(t) + sin(t)))
+
+    A1 = Matrix([[1, t], [-t, 1]])
+    b1 = Matrix([t, t ** 2])
+    B1, _ = _is_commutative_anti_derivative(A1, t)
+    raises(NonSquareMatrixError, lambda: linodesolve(A1[:, :1], t, b=b1))
+
+    A2 = Matrix([[t, t, t], [t, t, t], [t, t, t]])
+    b2 = Matrix([t, 1, t**2])
+    B2, _ = _is_commutative_anti_derivative(A2, t)
+    raises(NonSquareMatrixError, lambda: linodesolve(A2[:2, :], t, b=b2))
+
+    raises(ValueError, lambda: linodesolve(A1, t, b=b2))
+    raises(ValueError, lambda: linodesolve(A2, t, b=b1))
+
+    raises(ValueError, lambda: linodesolve(A1, t, b=b1, B=B2))
+    raises(ValueError, lambda: linodesolve(A2, t, b=b2, B=B1))
+
+    # Testing auto functionality
+    func = [f(x), g(x), h(x)]
+    eq = [Eq(f(x).diff(x), x*(f(x) + g(x) + h(x)) + x),
+          Eq(g(x).diff(x), x*(f(x) + g(x) + h(x)) + x),
+          Eq(h(x).diff(x), x*(f(x) + g(x) + h(x)) + 1)]
+    ceq = canonical_odes(eq, func, x)
+    (A1, A0), b = linear_ode_to_matrix(ceq[0], func, x, 1)
+    A = A0
+    _x1 = exp(-3*x**2/2)
+    _x2 = exp(3*x**2/2)
+    _x3 = Integral(2*_x1*x/3 + _x1/3 + x/3 - Rational(1, 3), x)
+    _x4 = 2*_x2*_x3/3
+    _x5 = Integral(2*_x1*x/3 + _x1/3 - 2*x/3 + Rational(2, 3), x)
+    sol = [
+        C1*_x2/3 - C1/3 + C2*_x2/3 - C2/3 + C3*_x2/3 + 2*C3/3 + _x2*_x5/3 + _x3/3 + _x4 - _x5/3,
+        C1*_x2/3 + 2*C1/3 + C2*_x2/3 - C2/3 + C3*_x2/3 - C3/3 + _x2*_x5/3 + _x3/3 + _x4 - _x5/3,
+        C1*_x2/3 - C1/3 + C2*_x2/3 + 2*C2/3 + C3*_x2/3 - C3/3 + _x2*_x5/3 - 2*_x3/3 + _x4 + 2*_x5/3,
+    ]
+    assert constant_renumber(linodesolve(A, x, b=b), variables=Tuple(*eq).free_symbols) == sol
+    assert constant_renumber(linodesolve(A, x, b=b, type="type4"),
+                             variables=Tuple(*eq).free_symbols) == sol
+
+    A1 = Matrix([[t, 1], [t, -1]])
+    raises(NotImplementedError, lambda: linodesolve(A1, t, b=b1))
+
+    # non-homogeneous term not passed
+    sol1 = [-C1/3 - C2/3 + 2*C3/3 + (C1/3 + C2/3 + C3/3)*exp(3*x**2/2), 2*C1/3 - C2/3 - C3/3 + (C1/3 + C2/3 + C3/3)*exp(3*x**2/2),
+            -C1/3 + 2*C2/3 - C3/3 + (C1/3 + C2/3 + C3/3)*exp(3*x**2/2)]
+    assert constant_renumber(linodesolve(A, x, type="type4", doit=True), variables=Tuple(*eq).free_symbols) == sol1
+
+
+@slow
+def test_linear_3eq_order1_type4_slow():
+    x, y, z = symbols('x, y, z', cls=Function)
+    t = Symbol('t')
+
+    f = t ** 3 + log(t)
+    g = t ** 2 + sin(t)
+    eq1 = (Eq(diff(x(t), t), (4 * f + g) * x(t) - f * y(t) - 2 * f * z(t)),
+                Eq(diff(y(t), t), 2 * f * x(t) + (f + g) * y(t) - 2 * f * z(t)), Eq(diff(z(t), t), 5 * f * x(t) + f * y(
+        t) + (-3 * f + g) * z(t)))
+    with dotprodsimp(True):
+        dsolve(eq1)
+
+
+@slow
+def test_linear_neq_order1_type2_slow1():
+    i, r1, c1, r2, c2, t = symbols('i, r1, c1, r2, c2, t')
+    x1 = Function('x1')
+    x2 = Function('x2')
+
+    eq1 = r1*c1*Derivative(x1(t), t) + x1(t) - x2(t) - r1*i
+    eq2 = r2*c1*Derivative(x1(t), t) + r2*c2*Derivative(x2(t), t) + x2(t) - r2*i
+    eq = [eq1, eq2]
+
+    # XXX: Solution is too complicated
+    [sol] = dsolve_system(eq, simplify=False, doit=False)
+    assert checksysodesol(eq, sol) == (True, [0, 0])
+
+
+# Regression test case for issue #9204
+# https://github.com/sympy/sympy/issues/9204
+@tooslow
+def test_linear_new_order1_type2_de_lorentz_slow_check():
+    m = Symbol("m", real=True)
+    q = Symbol("q", real=True)
+    t = Symbol("t", real=True)
+
+    e1, e2, e3 = symbols("e1:4", real=True)
+    b1, b2, b3 = symbols("b1:4", real=True)
+    v1, v2, v3 = symbols("v1:4", cls=Function, real=True)
+
+    eqs = [
+        -e1*q + m*Derivative(v1(t), t) - q*(-b2*v3(t) + b3*v2(t)),
+        -e2*q + m*Derivative(v2(t), t) - q*(b1*v3(t) - b3*v1(t)),
+        -e3*q + m*Derivative(v3(t), t) - q*(-b1*v2(t) + b2*v1(t))
+    ]
+    sol = dsolve(eqs)
+    assert checksysodesol(eqs, sol) == (True, [0, 0, 0])
+
+
+# Regression test case for issue #14001
+# https://github.com/sympy/sympy/issues/14001
+@slow
+def test_linear_neq_order1_type2_slow_check():
+    RC, t, C, Vs, L, R1, V0, I0 = symbols("RC t C Vs L R1 V0 I0")
+    V = Function("V")
+    I = Function("I")
+    system = [Eq(V(t).diff(t), -1/RC*V(t) + I(t)/C), Eq(I(t).diff(t), -R1/L*I(t) - 1/L*V(t) + Vs/L)]
+    [sol] = dsolve_system(system, simplify=False, doit=False)
+
+    assert checksysodesol(system, sol) == (True, [0, 0])
+
+
+def _linear_3eq_order1_type4_long():
+    x, y, z = symbols('x, y, z', cls=Function)
+    t = Symbol('t')
+
+    f = t ** 3 + log(t)
+    g = t ** 2 + sin(t)
+
+    eq1 = (Eq(diff(x(t), t), (4*f + g)*x(t) - f*y(t) - 2*f*z(t)),
+           Eq(diff(y(t), t), 2*f*x(t) + (f + g)*y(t) - 2*f*z(t)), Eq(diff(z(t), t), 5*f*x(t) + f*y(
+        t) + (-3*f + g)*z(t)))
+
+    dsolve_sol = dsolve(eq1)
+    dsolve_sol1 = [_simpsol(sol) for sol in dsolve_sol]
+
+    x_1 = sqrt(-t**6 - 8*t**3*log(t) + 8*t**3 - 16*log(t)**2 + 32*log(t) - 16)
+    x_2 = sqrt(3)
+    x_3 = 8324372644*C1*x_1*x_2 + 4162186322*C2*x_1*x_2 - 8324372644*C3*x_1*x_2
+    x_4 = 1 / (1903457163*t**3 + 3825881643*x_1*x_2 + 7613828652*log(t) - 7613828652)
+    x_5 = exp(t**3/3 + t*x_1*x_2/4 - cos(t))
+    x_6 = exp(t**3/3 - t*x_1*x_2/4 - cos(t))
+    x_7 = exp(t**4/2 + t**3/3 + 2*t*log(t) - 2*t - cos(t))
+    x_8 = 91238*C1*x_1*x_2 + 91238*C2*x_1*x_2 - 91238*C3*x_1*x_2
+    x_9 = 1 / (66049*t**3 - 50629*x_1*x_2 + 264196*log(t) - 264196)
+    x_10 = 50629 * C1 / 25189 + 37909*C2/25189 - 50629*C3/25189 - x_3*x_4
+    x_11 = -50629*C1/25189 - 12720*C2/25189 + 50629*C3/25189 + x_3*x_4
+    sol = [Eq(x(t), x_10*x_5 + x_11*x_6 + x_7*(C1 - C2)), Eq(y(t), x_10*x_5 + x_11*x_6), Eq(z(t), x_5*(
+            -424*C1/257 - 167*C2/257 + 424*C3/257 - x_8*x_9) + x_6*(167*C1/257 + 424*C2/257 -
+            167*C3/257 + x_8*x_9) + x_7*(C1 - C2))]
+
+    assert dsolve_sol1 == sol
+    assert checksysodesol(eq1, dsolve_sol1) == (True, [0, 0, 0])
+
+
+@slow
+def test_neq_order1_type4_slow_check1():
+    f, g = symbols("f g", cls=Function)
+    x = symbols("x")
+
+    eqs = [Eq(diff(f(x), x), x*f(x) + x**2*g(x) + x),
+           Eq(diff(g(x), x), 2*x**2*f(x) + (x + 3*x**2)*g(x) + 1)]
+    sol = dsolve(eqs)
+    assert checksysodesol(eqs, sol) == (True, [0, 0])
+
+
+@slow
+def test_neq_order1_type4_slow_check2():
+    f, g, h = symbols("f, g, h", cls=Function)
+    x = Symbol("x")
+
+    eqs = [
+        Eq(Derivative(f(x), x), x*h(x) + f(x) + g(x) + 1),
+        Eq(Derivative(g(x), x), x*g(x) + f(x) + h(x) + 10),
+        Eq(Derivative(h(x), x), x*f(x) + x + g(x) + h(x))
+    ]
+    with dotprodsimp(True):
+        sol = dsolve(eqs)
+    assert checksysodesol(eqs, sol) == (True, [0, 0, 0])
+
+
+def _neq_order1_type4_slow3():
+    f, g = symbols("f g", cls=Function)
+    x = symbols("x")
+
+    eqs = [
+        Eq(Derivative(f(x), x), x*f(x) + g(x) + sin(x)),
+        Eq(Derivative(g(x), x), x**2 + x*g(x) - f(x))
+    ]
+    sol = [
+        Eq(f(x), (C1/2 - I*C2/2 - I*Integral(x**2*exp(-x**2/2 - I*x)/2 +
+            x**2*exp(-x**2/2 + I*x)/2 + I*exp(-x**2/2 - I*x)*sin(x)/2 -
+            I*exp(-x**2/2 + I*x)*sin(x)/2, x)/2 + Integral(-I*x**2*exp(-x**2/2
+            - I*x)/2 + I*x**2*exp(-x**2/2 + I*x)/2 + exp(-x**2/2 -
+            I*x)*sin(x)/2 + exp(-x**2/2 + I*x)*sin(x)/2, x)/2)*exp(x**2/2 +
+            I*x) + (C1/2 + I*C2/2 + I*Integral(x**2*exp(-x**2/2 - I*x)/2 +
+            x**2*exp(-x**2/2 + I*x)/2 + I*exp(-x**2/2 - I*x)*sin(x)/2 -
+            I*exp(-x**2/2 + I*x)*sin(x)/2, x)/2 + Integral(-I*x**2*exp(-x**2/2
+            - I*x)/2 + I*x**2*exp(-x**2/2 + I*x)/2 + exp(-x**2/2 -
+            I*x)*sin(x)/2 + exp(-x**2/2 + I*x)*sin(x)/2, x)/2)*exp(x**2/2 -
+            I*x)),
+        Eq(g(x), (-I*C1/2 + C2/2 + Integral(x**2*exp(-x**2/2 - I*x)/2 +
+            x**2*exp(-x**2/2 + I*x)/2 + I*exp(-x**2/2 - I*x)*sin(x)/2 -
+            I*exp(-x**2/2 + I*x)*sin(x)/2, x)/2 -
+            I*Integral(-I*x**2*exp(-x**2/2 - I*x)/2 + I*x**2*exp(-x**2/2 +
+            I*x)/2 + exp(-x**2/2 - I*x)*sin(x)/2 + exp(-x**2/2 +
+            I*x)*sin(x)/2, x)/2)*exp(x**2/2 - I*x) + (I*C1/2 + C2/2 +
+            Integral(x**2*exp(-x**2/2 - I*x)/2 + x**2*exp(-x**2/2 + I*x)/2 +
+            I*exp(-x**2/2 - I*x)*sin(x)/2 - I*exp(-x**2/2 + I*x)*sin(x)/2,
+            x)/2 + I*Integral(-I*x**2*exp(-x**2/2 - I*x)/2 +
+            I*x**2*exp(-x**2/2 + I*x)/2 + exp(-x**2/2 - I*x)*sin(x)/2 +
+            exp(-x**2/2 + I*x)*sin(x)/2, x)/2)*exp(x**2/2 + I*x))
+    ]
+
+    return eqs, sol
+
+
+def test_neq_order1_type4_slow3():
+    eqs, sol = _neq_order1_type4_slow3()
+    assert dsolve_system(eqs, simplify=False, doit=False) == [sol]
+    # XXX: dsolve gives an error in integration:
+    #     assert dsolve(eqs) == sol
+    # https://github.com/sympy/sympy/issues/20155
+
+
+@slow
+def test_neq_order1_type4_slow_check3():
+    eqs, sol = _neq_order1_type4_slow3()
+    assert checksysodesol(eqs, sol) == (True, [0, 0])
+
+
+@tooslow
+@XFAIL
+def test_linear_3eq_order1_type4_long_dsolve_slow_xfail():
+    eq, sol = _linear_3eq_order1_type4_long()
+
+    dsolve_sol = dsolve(eq)
+    dsolve_sol1 = [_simpsol(sol) for sol in dsolve_sol]
+
+    assert dsolve_sol1 == sol
+
+
+@tooslow
+def test_linear_3eq_order1_type4_long_dsolve_dotprodsimp():
+    eq, sol = _linear_3eq_order1_type4_long()
+
+    # XXX: Only works with dotprodsimp see
+    # test_linear_3eq_order1_type4_long_dsolve_slow_xfail which is too slow
+    with dotprodsimp(True):
+        dsolve_sol = dsolve(eq)
+
+    dsolve_sol1 = [_simpsol(sol) for sol in dsolve_sol]
+    assert dsolve_sol1 == sol
+
+
+@tooslow
+def test_linear_3eq_order1_type4_long_check():
+    eq, sol = _linear_3eq_order1_type4_long()
+    assert checksysodesol(eq, sol) == (True, [0, 0, 0])
+
+
+def test_dsolve_system():
+    f, g = symbols("f g", cls=Function)
+    x = symbols("x")
+    eqs = [Eq(f(x).diff(x), f(x) + g(x)), Eq(g(x).diff(x), f(x) + g(x))]
+    funcs = [f(x), g(x)]
+
+    sol = [[Eq(f(x), -C1 + C2*exp(2*x)), Eq(g(x), C1 + C2*exp(2*x))]]
+    assert dsolve_system(eqs, funcs=funcs, t=x, doit=True) == sol
+
+    raises(ValueError, lambda: dsolve_system(1))
+    raises(ValueError, lambda: dsolve_system(eqs, 1))
+    raises(ValueError, lambda: dsolve_system(eqs, funcs, 1))
+    raises(ValueError, lambda: dsolve_system(eqs, funcs[:1], x))
+
+    eq = (Eq(f(x).diff(x), 12 * f(x) - 6 * g(x)), Eq(g(x).diff(x) ** 2, 11 * f(x) + 3 * g(x)))
+    raises(NotImplementedError, lambda: dsolve_system(eq) == ([], []))
+
+    raises(NotImplementedError, lambda: dsolve_system(eq, funcs=[f(x), g(x)]) == ([], []))
+    raises(NotImplementedError, lambda: dsolve_system(eq, funcs=[f(x), g(x)], t=x) == ([], []))
+    raises(NotImplementedError, lambda: dsolve_system(eq, funcs=[f(x), g(x)], t=x, ics={f(0): 1, g(0): 1}) == ([], []))
+    raises(NotImplementedError, lambda: dsolve_system(eq, t=x, ics={f(0): 1, g(0): 1}) == ([], []))
+    raises(NotImplementedError, lambda: dsolve_system(eq, ics={f(0): 1, g(0): 1}) == ([], []))
+    raises(NotImplementedError, lambda: dsolve_system(eq, funcs=[f(x), g(x)], ics={f(0): 1, g(0): 1}) == ([], []))
+
+def test_dsolve():
+
+    f, g = symbols('f g', cls=Function)
+    x, y = symbols('x y')
+
+    eqs = [f(x).diff(x) - x, f(x).diff(x) + x]
+    with raises(ValueError):
+        dsolve(eqs)
+
+    eqs = [f(x, y).diff(x)]
+    with raises(ValueError):
+        dsolve(eqs)
+
+    eqs = [f(x, y).diff(x)+g(x).diff(x), g(x).diff(x)]
+    with raises(ValueError):
+        dsolve(eqs)
+
+
+@slow
+def test_higher_order1_slow1():
+    x, y = symbols("x y", cls=Function)
+    t = symbols("t")
+
+    eq = [
+        Eq(diff(x(t),t,t), (log(t)+t**2)*diff(x(t),t)+(log(t)+t**2)*3*diff(y(t),t)),
+        Eq(diff(y(t),t,t), (log(t)+t**2)*2*diff(x(t),t)+(log(t)+t**2)*9*diff(y(t),t))
+    ]
+    sol, = dsolve_system(eq, simplify=False, doit=False)
+    # The solution is too long to write out explicitly and checkodesol is too
+    # slow so we test for particular values of t:
+    for e in eq:
+        res = (e.lhs - e.rhs).subs({sol[0].lhs:sol[0].rhs, sol[1].lhs:sol[1].rhs})
+        res = res.subs({d: d.doit(deep=False) for d in res.atoms(Derivative)})
+        assert ratsimp(res.subs(t, 1)) == 0
+
+
+def test_second_order_type2_slow1():
+    x, y, z = symbols('x, y, z', cls=Function)
+    t, l = symbols('t, l')
+
+    eqs1 = [Eq(Derivative(x(t), (t, 2)), t*(2*x(t) + y(t))),
+            Eq(Derivative(y(t), (t, 2)), t*(-x(t) + 2*y(t)))]
+    sol1 = [Eq(x(t), I*C1*airyai(t*(2 - I)**(S(1)/3)) + I*C2*airybi(t*(2 - I)**(S(1)/3)) - I*C3*airyai(t*(2 +
+             I)**(S(1)/3)) - I*C4*airybi(t*(2 + I)**(S(1)/3))),
+            Eq(y(t), C1*airyai(t*(2 - I)**(S(1)/3)) + C2*airybi(t*(2 - I)**(S(1)/3)) + C3*airyai(t*(2 + I)**(S(1)/3)) +
+             C4*airybi(t*(2 + I)**(S(1)/3)))]
+    assert dsolve(eqs1) == sol1
+    assert checksysodesol(eqs1, sol1) == (True, [0, 0])
+
+
+@tooslow
+@XFAIL
+def test_nonlinear_3eq_order1_type1():
+    a, b, c = symbols('a b c')
+
+    eqs = [
+        a * f(x).diff(x) - (b - c) * g(x) * h(x),
+        b * g(x).diff(x) - (c - a) * h(x) * f(x),
+        c * h(x).diff(x) - (a - b) * f(x) * g(x),
+    ]
+
+    assert dsolve(eqs) # NotImplementedError
+
+
+@XFAIL
+def test_nonlinear_3eq_order1_type4():
+    eqs = [
+        Eq(f(x).diff(x), (2*h(x)*g(x) - 3*g(x)*h(x))),
+        Eq(g(x).diff(x), (4*f(x)*h(x) - 2*h(x)*f(x))),
+        Eq(h(x).diff(x), (3*g(x)*f(x) - 4*f(x)*g(x))),
+    ]
+    dsolve(eqs)  # KeyError when matching
+    # sol = ?
+    # assert dsolve_sol == sol
+    # assert checksysodesol(eqs, dsolve_sol) == (True, [0, 0, 0])
+
+
+@tooslow
+@XFAIL
+def test_nonlinear_3eq_order1_type3():
+    eqs = [
+        Eq(f(x).diff(x), (2*f(x)**2 - 3        )),
+        Eq(g(x).diff(x), (4         - 2*h(x)   )),
+        Eq(h(x).diff(x), (3*h(x)    - 4*f(x)**2)),
+    ]
+    dsolve(eqs)  # Not sure if this finishes...
+    # sol = ?
+    # assert dsolve_sol == sol
+    # assert checksysodesol(eqs, dsolve_sol) == (True, [0, 0, 0])
+
+
+@XFAIL
+def test_nonlinear_3eq_order1_type5():
+    eqs = [
+        Eq(f(x).diff(x), f(x)*(2*f(x) - 3*g(x))),
+        Eq(g(x).diff(x), g(x)*(4*g(x) - 2*h(x))),
+        Eq(h(x).diff(x), h(x)*(3*h(x) - 4*f(x))),
+    ]
+    dsolve(eqs)  # KeyError
+    # sol = ?
+    # assert dsolve_sol == sol
+    # assert checksysodesol(eqs, dsolve_sol) == (True, [0, 0, 0])
+
+
+def test_linear_2eq_order1():
+    x, y, z = symbols('x, y, z', cls=Function)
+    k, l, m, n = symbols('k, l, m, n', Integer=True)
+    t = Symbol('t')
+    x0, y0 = symbols('x0, y0', cls=Function)
+
+    eq1 = (Eq(diff(x(t),t), x(t) + y(t) + 9), Eq(diff(y(t),t), 2*x(t) + 5*y(t) + 23))
+    sol1 = [Eq(x(t), C1*exp(t*(sqrt(6) + 3)) + C2*exp(t*(-sqrt(6) + 3)) - Rational(22, 3)), \
+    Eq(y(t), C1*(2 + sqrt(6))*exp(t*(sqrt(6) + 3)) + C2*(-sqrt(6) + 2)*exp(t*(-sqrt(6) + 3)) - Rational(5, 3))]
+    assert checksysodesol(eq1, sol1) == (True, [0, 0])
+
+    eq2 = (Eq(diff(x(t),t), x(t) + y(t) + 81), Eq(diff(y(t),t), -2*x(t) + y(t) + 23))
+    sol2 = [Eq(x(t), (C1*cos(sqrt(2)*t) + C2*sin(sqrt(2)*t))*exp(t) - Rational(58, 3)), \
+    Eq(y(t), (-sqrt(2)*C1*sin(sqrt(2)*t) + sqrt(2)*C2*cos(sqrt(2)*t))*exp(t) - Rational(185, 3))]
+    assert checksysodesol(eq2, sol2) == (True, [0, 0])
+
+    eq3 = (Eq(diff(x(t),t), 5*t*x(t) + 2*y(t)), Eq(diff(y(t),t), 2*x(t) + 5*t*y(t)))
+    sol3 = [Eq(x(t), (C1*exp(2*t) + C2*exp(-2*t))*exp(Rational(5, 2)*t**2)), \
+    Eq(y(t), (C1*exp(2*t) - C2*exp(-2*t))*exp(Rational(5, 2)*t**2))]
+    assert checksysodesol(eq3, sol3) == (True, [0, 0])
+
+    eq4 = (Eq(diff(x(t),t), 5*t*x(t) + t**2*y(t)), Eq(diff(y(t),t), -t**2*x(t) + 5*t*y(t)))
+    sol4 = [Eq(x(t), (C1*cos((t**3)/3) + C2*sin((t**3)/3))*exp(Rational(5, 2)*t**2)), \
+    Eq(y(t), (-C1*sin((t**3)/3) + C2*cos((t**3)/3))*exp(Rational(5, 2)*t**2))]
+    assert checksysodesol(eq4, sol4) == (True, [0, 0])
+
+    eq5 = (Eq(diff(x(t),t), 5*t*x(t) + t**2*y(t)), Eq(diff(y(t),t), -t**2*x(t) + (5*t+9*t**2)*y(t)))
+    sol5 = [Eq(x(t), (C1*exp((sqrt(77)/2 + Rational(9, 2))*(t**3)/3) + \
+    C2*exp((-sqrt(77)/2 + Rational(9, 2))*(t**3)/3))*exp(Rational(5, 2)*t**2)), \
+    Eq(y(t), (C1*(sqrt(77)/2 + Rational(9, 2))*exp((sqrt(77)/2 + Rational(9, 2))*(t**3)/3) + \
+    C2*(-sqrt(77)/2 + Rational(9, 2))*exp((-sqrt(77)/2 + Rational(9, 2))*(t**3)/3))*exp(Rational(5, 2)*t**2))]
+    assert checksysodesol(eq5, sol5) == (True, [0, 0])
+
+    eq6 = (Eq(diff(x(t),t), 5*t*x(t) + t**2*y(t)), Eq(diff(y(t),t), (1-t**2)*x(t) + (5*t+9*t**2)*y(t)))
+    sol6 = [Eq(x(t), C1*x0(t) + C2*x0(t)*Integral(t**2*exp(Integral(5*t, t))*exp(Integral(9*t**2 + 5*t, t))/x0(t)**2, t)), \
+    Eq(y(t), C1*y0(t) + C2*(y0(t)*Integral(t**2*exp(Integral(5*t, t))*exp(Integral(9*t**2 + 5*t, t))/x0(t)**2, t) + \
+    exp(Integral(5*t, t))*exp(Integral(9*t**2 + 5*t, t))/x0(t)))]
+    s = dsolve(eq6)
+    assert s == sol6   # too complicated to test with subs and simplify
+    # assert checksysodesol(eq10, sol10) == (True, [0, 0])  # this one fails
+
+
+def test_nonlinear_2eq_order1():
+    x, y, z = symbols('x, y, z', cls=Function)
+    t = Symbol('t')
+    eq1 = (Eq(diff(x(t),t),x(t)*y(t)**3), Eq(diff(y(t),t),y(t)**5))
+    sol1 = [
+        Eq(x(t), C1*exp((-1/(4*C2 + 4*t))**(Rational(-1, 4)))),
+        Eq(y(t), -(-1/(4*C2 + 4*t))**Rational(1, 4)),
+        Eq(x(t), C1*exp(-1/(-1/(4*C2 + 4*t))**Rational(1, 4))),
+        Eq(y(t), (-1/(4*C2 + 4*t))**Rational(1, 4)),
+        Eq(x(t), C1*exp(-I/(-1/(4*C2 + 4*t))**Rational(1, 4))),
+        Eq(y(t), -I*(-1/(4*C2 + 4*t))**Rational(1, 4)),
+        Eq(x(t), C1*exp(I/(-1/(4*C2 + 4*t))**Rational(1, 4))),
+        Eq(y(t), I*(-1/(4*C2 + 4*t))**Rational(1, 4))]
+    assert dsolve(eq1) == sol1
+    assert checksysodesol(eq1, sol1) == (True, [0, 0])
+
+    eq2 = (Eq(diff(x(t),t), exp(3*x(t))*y(t)**3),Eq(diff(y(t),t), y(t)**5))
+    sol2 = [
+        Eq(x(t), -log(C1 - 3/(-1/(4*C2 + 4*t))**Rational(1, 4))/3),
+        Eq(y(t), -(-1/(4*C2 + 4*t))**Rational(1, 4)),
+        Eq(x(t), -log(C1 + 3/(-1/(4*C2 + 4*t))**Rational(1, 4))/3),
+        Eq(y(t), (-1/(4*C2 + 4*t))**Rational(1, 4)),
+        Eq(x(t), -log(C1 + 3*I/(-1/(4*C2 + 4*t))**Rational(1, 4))/3),
+        Eq(y(t), -I*(-1/(4*C2 + 4*t))**Rational(1, 4)),
+        Eq(x(t), -log(C1 - 3*I/(-1/(4*C2 + 4*t))**Rational(1, 4))/3),
+        Eq(y(t), I*(-1/(4*C2 + 4*t))**Rational(1, 4))]
+    assert dsolve(eq2) == sol2
+    assert checksysodesol(eq2, sol2) == (True, [0, 0])
+
+    eq3 = (Eq(diff(x(t),t), y(t)*x(t)), Eq(diff(y(t),t), x(t)**3))
+    tt = Rational(2, 3)
+    sol3 = [
+        Eq(x(t), 6**tt/(6*(-sinh(sqrt(C1)*(C2 + t)/2)/sqrt(C1))**tt)),
+        Eq(y(t), sqrt(C1 + C1/sinh(sqrt(C1)*(C2 + t)/2)**2)/3)]
+    assert dsolve(eq3) == sol3
+    # FIXME: assert checksysodesol(eq3, sol3) == (True, [0, 0])
+
+    eq4 = (Eq(diff(x(t),t),x(t)*y(t)*sin(t)**2), Eq(diff(y(t),t),y(t)**2*sin(t)**2))
+    sol4 = {Eq(x(t), -2*exp(C1)/(C2*exp(C1) + t - sin(2*t)/2)), Eq(y(t), -2/(C1 + t - sin(2*t)/2))}
+    assert dsolve(eq4) == sol4
+    # FIXME: assert checksysodesol(eq4, sol4) == (True, [0, 0])
+
+    eq5 = (Eq(x(t),t*diff(x(t),t)+diff(x(t),t)*diff(y(t),t)), Eq(y(t),t*diff(y(t),t)+diff(y(t),t)**2))
+    sol5 = {Eq(x(t), C1*C2 + C1*t), Eq(y(t), C2**2 + C2*t)}
+    assert dsolve(eq5) == sol5
+    assert checksysodesol(eq5, sol5) == (True, [0, 0])
+
+    eq6 = (Eq(diff(x(t),t),x(t)**2*y(t)**3), Eq(diff(y(t),t),y(t)**5))
+    sol6 = [
+        Eq(x(t), 1/(C1 - 1/(-1/(4*C2 + 4*t))**Rational(1, 4))),
+        Eq(y(t), -(-1/(4*C2 + 4*t))**Rational(1, 4)),
+        Eq(x(t), 1/(C1 + (-1/(4*C2 + 4*t))**(Rational(-1, 4)))),
+        Eq(y(t), (-1/(4*C2 + 4*t))**Rational(1, 4)),
+        Eq(x(t), 1/(C1 + I/(-1/(4*C2 + 4*t))**Rational(1, 4))),
+        Eq(y(t), -I*(-1/(4*C2 + 4*t))**Rational(1, 4)),
+        Eq(x(t), 1/(C1 - I/(-1/(4*C2 + 4*t))**Rational(1, 4))),
+        Eq(y(t), I*(-1/(4*C2 + 4*t))**Rational(1, 4))]
+    assert dsolve(eq6) == sol6
+    assert checksysodesol(eq6, sol6) == (True, [0, 0])
+
+
+@slow
+def test_nonlinear_3eq_order1():
+    x, y, z = symbols('x, y, z', cls=Function)
+    t, u = symbols('t u')
+    eq1 = (4*diff(x(t),t) + 2*y(t)*z(t), 3*diff(y(t),t) - z(t)*x(t), 5*diff(z(t),t) - x(t)*y(t))
+    sol1 = [Eq(4*Integral(1/(sqrt(-4*u**2 - 3*C1 + C2)*sqrt(-4*u**2 + 5*C1 - C2)), (u, x(t))),
+        C3 - sqrt(15)*t/15), Eq(3*Integral(1/(sqrt(-6*u**2 - C1 + 5*C2)*sqrt(3*u**2 + C1 - 4*C2)),
+        (u, y(t))), C3 + sqrt(5)*t/10), Eq(5*Integral(1/(sqrt(-10*u**2 - 3*C1 + C2)*
+        sqrt(5*u**2 + 4*C1 - C2)), (u, z(t))), C3 + sqrt(3)*t/6)]
+    assert [i.dummy_eq(j) for i, j in zip(dsolve(eq1), sol1)]
+    # FIXME: assert checksysodesol(eq1, sol1) == (True, [0, 0, 0])
+
+    eq2 = (4*diff(x(t),t) + 2*y(t)*z(t)*sin(t), 3*diff(y(t),t) - z(t)*x(t)*sin(t), 5*diff(z(t),t) - x(t)*y(t)*sin(t))
+    sol2 = [Eq(3*Integral(1/(sqrt(-6*u**2 - C1 + 5*C2)*sqrt(3*u**2 + C1 - 4*C2)), (u, x(t))), C3 +
+        sqrt(5)*cos(t)/10), Eq(4*Integral(1/(sqrt(-4*u**2 - 3*C1 + C2)*sqrt(-4*u**2 + 5*C1 - C2)),
+        (u, y(t))), C3 - sqrt(15)*cos(t)/15), Eq(5*Integral(1/(sqrt(-10*u**2 - 3*C1 + C2)*
+        sqrt(5*u**2 + 4*C1 - C2)), (u, z(t))), C3 + sqrt(3)*cos(t)/6)]
+    assert [i.dummy_eq(j) for i, j in zip(dsolve(eq2), sol2)]
+    # FIXME: assert checksysodesol(eq2, sol2) == (True, [0, 0, 0])
+
+
+def test_C1_function_9239():
+    t = Symbol('t')
+    C1 = Function('C1')
+    C2 = Function('C2')
+    C3 = Symbol('C3')
+    C4 = Symbol('C4')
+    eq = (Eq(diff(C1(t), t), 9*C2(t)), Eq(diff(C2(t), t), 12*C1(t)))
+    sol = [Eq(C1(t), 9*C3*exp(6*sqrt(3)*t) + 9*C4*exp(-6*sqrt(3)*t)),
+           Eq(C2(t), 6*sqrt(3)*C3*exp(6*sqrt(3)*t) - 6*sqrt(3)*C4*exp(-6*sqrt(3)*t))]
+    assert checksysodesol(eq, sol) == (True, [0, 0])
+
+
+def test_dsolve_linsystem_symbol():
+    eps = Symbol('epsilon', positive=True)
+    eq1 = (Eq(diff(f(x), x), -eps*g(x)), Eq(diff(g(x), x), eps*f(x)))
+    sol1 = [Eq(f(x), -C1*eps*cos(eps*x) - C2*eps*sin(eps*x)),
+            Eq(g(x), -C1*eps*sin(eps*x) + C2*eps*cos(eps*x))]
+    assert checksysodesol(eq1, sol1) == (True, [0, 0])
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/tests/__init__.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/tests/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/tests/__pycache__/__init__.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/tests/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a64cc588c23cfe8160a7234996d93ff1e00d1920
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/tests/__pycache__/__init__.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/tests/__pycache__/test_constantsimp.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/tests/__pycache__/test_constantsimp.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..61314809141d08aa3daabe41fdca67d793415899
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/tests/__pycache__/test_constantsimp.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/tests/__pycache__/test_decompogen.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/tests/__pycache__/test_decompogen.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b570f47e36e950424f752e49194a4e2ebd6c3cf0
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/tests/__pycache__/test_decompogen.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/tests/__pycache__/test_inequalities.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/tests/__pycache__/test_inequalities.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c275c81adb410c4098e21a3e1d3be93d6e0a1ea3
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/tests/__pycache__/test_inequalities.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/tests/__pycache__/test_numeric.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/tests/__pycache__/test_numeric.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..29ccddc511a139c7e2b0c356bfd6132a0dda401a
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/tests/__pycache__/test_numeric.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/tests/__pycache__/test_pde.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/tests/__pycache__/test_pde.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..63e5f6729f9779701e9b1bb8385ed5a1c11028e9
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/tests/__pycache__/test_pde.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/tests/__pycache__/test_polysys.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/tests/__pycache__/test_polysys.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..2695c4634cf91a23c51c06dfeab543a4323d20dd
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/tests/__pycache__/test_polysys.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/tests/__pycache__/test_recurr.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/tests/__pycache__/test_recurr.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..911f99378a58f3cb16f344daf4074f7101d6f940
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/tests/__pycache__/test_recurr.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/tests/__pycache__/test_simplex.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/tests/__pycache__/test_simplex.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..1e4e374f88c28b7b3765ef34ad3d328c59eef70d
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/tests/__pycache__/test_simplex.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/tests/__pycache__/test_solvers.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/tests/__pycache__/test_solvers.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..dc7df87bac55e3a99f521e387657d1c0365b9463
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/tests/__pycache__/test_solvers.cpython-312.pyc
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9ce60d2b72cfe11906cbe9d93eb79cbcc2d57c78946aae1d0d2090a0083ccebd
+size 254356
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/tests/__pycache__/test_solveset.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/tests/__pycache__/test_solveset.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..dc1e78aa92f8ecc4515b8387f33e6ee82022c211
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/tests/__pycache__/test_solveset.cpython-312.pyc
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2d595350ce74dc02717812f4320c4796dd8c1405302ba3ea0d3df7666b3de510
+size 364677
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/tests/test_constantsimp.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/tests/test_constantsimp.py
new file mode 100644
index 0000000000000000000000000000000000000000..efb966a4c8c2f93558d05e7c330f06530e69180c
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/tests/test_constantsimp.py
@@ -0,0 +1,179 @@
+"""
+If the arbitrary constant class from issue 4435 is ever implemented, this
+should serve as a set of test cases.
+"""
+
+from sympy.core.function import Function
+from sympy.core.numbers import I
+from sympy.core.power import Pow
+from sympy.core.relational import Eq
+from sympy.core.singleton import S
+from sympy.core.symbol import Symbol
+from sympy.functions.elementary.exponential import (exp, log)
+from sympy.functions.elementary.hyperbolic import (cosh, sinh)
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import (acos, cos, sin)
+from sympy.integrals.integrals import Integral
+from sympy.solvers.ode.ode import constantsimp, constant_renumber
+from sympy.testing.pytest import XFAIL
+
+
+x = Symbol('x')
+y = Symbol('y')
+z = Symbol('z')
+u2 = Symbol('u2')
+_a = Symbol('_a')
+C1 = Symbol('C1')
+C2 = Symbol('C2')
+C3 = Symbol('C3')
+f = Function('f')
+
+
+def test_constant_mul():
+    # We want C1 (Constant) below to absorb the y's, but not the x's
+    assert constant_renumber(constantsimp(y*C1, [C1])) == C1*y
+    assert constant_renumber(constantsimp(C1*y, [C1])) == C1*y
+    assert constant_renumber(constantsimp(x*C1, [C1])) == x*C1
+    assert constant_renumber(constantsimp(C1*x, [C1])) == x*C1
+    assert constant_renumber(constantsimp(2*C1, [C1])) == C1
+    assert constant_renumber(constantsimp(C1*2, [C1])) == C1
+    assert constant_renumber(constantsimp(y*C1*x, [C1, y])) == C1*x
+    assert constant_renumber(constantsimp(x*y*C1, [C1, y])) == x*C1
+    assert constant_renumber(constantsimp(y*x*C1, [C1, y])) == x*C1
+    assert constant_renumber(constantsimp(C1*x*y, [C1, y])) == C1*x
+    assert constant_renumber(constantsimp(x*C1*y, [C1, y])) == x*C1
+    assert constant_renumber(constantsimp(C1*y*(y + 1), [C1])) == C1*y*(y+1)
+    assert constant_renumber(constantsimp(y*C1*(y + 1), [C1])) == C1*y*(y+1)
+    assert constant_renumber(constantsimp(x*(y*C1), [C1])) == x*y*C1
+    assert constant_renumber(constantsimp(x*(C1*y), [C1])) == x*y*C1
+    assert constant_renumber(constantsimp(C1*(x*y), [C1, y])) == C1*x
+    assert constant_renumber(constantsimp((x*y)*C1, [C1, y])) == x*C1
+    assert constant_renumber(constantsimp((y*x)*C1, [C1, y])) == x*C1
+    assert constant_renumber(constantsimp(y*(y + 1)*C1, [C1, y])) == C1
+    assert constant_renumber(constantsimp((C1*x)*y, [C1, y])) == C1*x
+    assert constant_renumber(constantsimp(y*(x*C1), [C1, y])) == x*C1
+    assert constant_renumber(constantsimp((x*C1)*y, [C1, y])) == x*C1
+    assert constant_renumber(constantsimp(C1*x*y*x*y*2, [C1, y])) == C1*x**2
+    assert constant_renumber(constantsimp(C1*x*y*z, [C1, y, z])) == C1*x
+    assert constant_renumber(constantsimp(C1*x*y**2*sin(z), [C1, y, z])) == C1*x
+    assert constant_renumber(constantsimp(C1*C1, [C1])) == C1
+    assert constant_renumber(constantsimp(C1*C2, [C1, C2])) == C1
+    assert constant_renumber(constantsimp(C2*C2, [C1, C2])) == C1
+    assert constant_renumber(constantsimp(C1*C1*C2, [C1, C2])) == C1
+    assert constant_renumber(constantsimp(C1*x*2**x, [C1])) == C1*x*2**x
+
+def test_constant_add():
+    assert constant_renumber(constantsimp(C1 + C1, [C1])) == C1
+    assert constant_renumber(constantsimp(C1 + 2, [C1])) == C1
+    assert constant_renumber(constantsimp(2 + C1, [C1])) == C1
+    assert constant_renumber(constantsimp(C1 + y, [C1, y])) == C1
+    assert constant_renumber(constantsimp(C1 + x, [C1])) == C1 + x
+    assert constant_renumber(constantsimp(C1 + C1, [C1])) == C1
+    assert constant_renumber(constantsimp(C1 + C2, [C1, C2])) == C1
+    assert constant_renumber(constantsimp(C2 + C1, [C1, C2])) == C1
+    assert constant_renumber(constantsimp(C1 + C2 + C1, [C1, C2])) == C1
+
+
+def test_constant_power_as_base():
+    assert constant_renumber(constantsimp(C1**C1, [C1])) == C1
+    assert constant_renumber(constantsimp(Pow(C1, C1), [C1])) == C1
+    assert constant_renumber(constantsimp(C1**C1, [C1])) == C1
+    assert constant_renumber(constantsimp(C1**C2, [C1, C2])) == C1
+    assert constant_renumber(constantsimp(C2**C1, [C1, C2])) == C1
+    assert constant_renumber(constantsimp(C2**C2, [C1, C2])) == C1
+    assert constant_renumber(constantsimp(C1**y, [C1, y])) == C1
+    assert constant_renumber(constantsimp(C1**x, [C1])) == C1**x
+    assert constant_renumber(constantsimp(C1**2, [C1])) == C1
+    assert constant_renumber(
+        constantsimp(C1**(x*y), [C1])) == C1**(x*y)
+
+
+def test_constant_power_as_exp():
+    assert constant_renumber(constantsimp(x**C1, [C1])) == x**C1
+    assert constant_renumber(constantsimp(y**C1, [C1, y])) == C1
+    assert constant_renumber(constantsimp(x**y**C1, [C1, y])) == x**C1
+    assert constant_renumber(
+        constantsimp((x**y)**C1, [C1])) == (x**y)**C1
+    assert constant_renumber(
+        constantsimp(x**(y**C1), [C1, y])) == x**C1
+    assert constant_renumber(constantsimp(x**C1**y, [C1, y])) == x**C1
+    assert constant_renumber(
+        constantsimp(x**(C1**y), [C1, y])) == x**C1
+    assert constant_renumber(
+        constantsimp((x**C1)**y, [C1])) == (x**C1)**y
+    assert constant_renumber(constantsimp(2**C1, [C1])) == C1
+    assert constant_renumber(constantsimp(S(2)**C1, [C1])) == C1
+    assert constant_renumber(constantsimp(exp(C1), [C1])) == C1
+    assert constant_renumber(
+        constantsimp(exp(C1 + x), [C1])) == C1*exp(x)
+    assert constant_renumber(constantsimp(Pow(2, C1), [C1])) == C1
+
+
+def test_constant_function():
+    assert constant_renumber(constantsimp(sin(C1), [C1])) == C1
+    assert constant_renumber(constantsimp(f(C1), [C1])) == C1
+    assert constant_renumber(constantsimp(f(C1, C1), [C1])) == C1
+    assert constant_renumber(constantsimp(f(C1, C2), [C1, C2])) == C1
+    assert constant_renumber(constantsimp(f(C2, C1), [C1, C2])) == C1
+    assert constant_renumber(constantsimp(f(C2, C2), [C1, C2])) == C1
+    assert constant_renumber(
+        constantsimp(f(C1, x), [C1])) == f(C1, x)
+    assert constant_renumber(constantsimp(f(C1, y), [C1, y])) == C1
+    assert constant_renumber(constantsimp(f(y, C1), [C1, y])) == C1
+    assert constant_renumber(constantsimp(f(C1, y, C2), [C1, C2, y])) == C1
+
+
+def test_constant_function_multiple():
+    # The rules to not renumber in this case would be too complicated, and
+    # dsolve is not likely to ever encounter anything remotely like this.
+    assert constant_renumber(
+        constantsimp(f(C1, C1, x), [C1])) == f(C1, C1, x)
+
+
+def test_constant_multiple():
+    assert constant_renumber(constantsimp(C1*2 + 2, [C1])) == C1
+    assert constant_renumber(constantsimp(x*2/C1, [C1])) == C1*x
+    assert constant_renumber(constantsimp(C1**2*2 + 2, [C1])) == C1
+    assert constant_renumber(
+        constantsimp(sin(2*C1) + x + sqrt(2), [C1])) == C1 + x
+    assert constant_renumber(constantsimp(2*C1 + C2, [C1, C2])) == C1
+
+def test_constant_repeated():
+    assert C1 + C1*x == constant_renumber( C1 + C1*x)
+
+def test_ode_solutions():
+    # only a few examples here, the rest will be tested in the actual dsolve tests
+    assert constant_renumber(constantsimp(C1*exp(2*x) + exp(x)*(C2 + C3), [C1, C2, C3])) == \
+        constant_renumber(C1*exp(x) + C2*exp(2*x))
+    assert constant_renumber(
+        constantsimp(Eq(f(x), I*C1*sinh(x/3) + C2*cosh(x/3)), [C1, C2])
+        ) == constant_renumber(Eq(f(x), C1*sinh(x/3) + C2*cosh(x/3)))
+    assert constant_renumber(constantsimp(Eq(f(x), acos((-C1)/cos(x))), [C1])) == \
+        Eq(f(x), acos(C1/cos(x)))
+    assert constant_renumber(
+        constantsimp(Eq(log(f(x)/C1) + 2*exp(x/f(x)), 0), [C1])
+        ) == Eq(log(C1*f(x)) + 2*exp(x/f(x)), 0)
+    assert constant_renumber(constantsimp(Eq(log(x*sqrt(2)*sqrt(1/x)*sqrt(f(x))
+        /C1) + x**2/(2*f(x)**2), 0), [C1])) == \
+        Eq(log(C1*sqrt(x)*sqrt(f(x))) + x**2/(2*f(x)**2), 0)
+    assert constant_renumber(constantsimp(Eq(-exp(-f(x)/x)*sin(f(x)/x)/2 + log(x/C1) -
+        cos(f(x)/x)*exp(-f(x)/x)/2, 0), [C1])) == \
+        Eq(-exp(-f(x)/x)*sin(f(x)/x)/2 + log(C1*x) - cos(f(x)/x)*
+           exp(-f(x)/x)/2, 0)
+    assert constant_renumber(constantsimp(Eq(-Integral(-1/(sqrt(1 - u2**2)*u2),
+        (u2, _a, x/f(x))) + log(f(x)/C1), 0), [C1])) == \
+        Eq(-Integral(-1/(u2*sqrt(1 - u2**2)), (u2, _a, x/f(x))) +
+        log(C1*f(x)), 0)
+    assert [constantsimp(i, [C1]) for i in [Eq(f(x), sqrt(-C1*x + x**2)), Eq(f(x), -sqrt(-C1*x + x**2))]] == \
+        [Eq(f(x), sqrt(x*(C1 + x))), Eq(f(x), -sqrt(x*(C1 + x)))]
+
+
+@XFAIL
+def test_nonlocal_simplification():
+    assert constantsimp(C1 + C2+x*C2, [C1, C2]) == C1 + C2*x
+
+
+def test_constant_Eq():
+    # C1 on the rhs is well-tested, but the lhs is only tested here
+    assert constantsimp(Eq(C1, 3 + f(x)*x), [C1]) == Eq(x*f(x), C1)
+    assert constantsimp(Eq(C1, 3 * f(x)*x), [C1]) == Eq(f(x)*x, C1)
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/tests/test_decompogen.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/tests/test_decompogen.py
new file mode 100644
index 0000000000000000000000000000000000000000..1ba03f4b42558231b626b6ed169f8b0a81a72bf9
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/tests/test_decompogen.py
@@ -0,0 +1,59 @@
+from sympy.solvers.decompogen import decompogen, compogen
+from sympy.core.symbol import symbols
+from sympy.functions.elementary.complexes import Abs
+from sympy.functions.elementary.exponential import exp
+from sympy.functions.elementary.miscellaneous import sqrt, Max
+from sympy.functions.elementary.trigonometric import (cos, sin)
+from sympy.testing.pytest import XFAIL, raises
+
+x, y = symbols('x y')
+
+
+def test_decompogen():
+    assert decompogen(sin(cos(x)), x) == [sin(x), cos(x)]
+    assert decompogen(sin(x)**2 + sin(x) + 1, x) == [x**2 + x + 1, sin(x)]
+    assert decompogen(sqrt(6*x**2 - 5), x) == [sqrt(x), 6*x**2 - 5]
+    assert decompogen(sin(sqrt(cos(x**2 + 1))), x) == [sin(x), sqrt(x), cos(x), x**2 + 1]
+    assert decompogen(Abs(cos(x)**2 + 3*cos(x) - 4), x) == [Abs(x), x**2 + 3*x - 4, cos(x)]
+    assert decompogen(sin(x)**2 + sin(x) - sqrt(3)/2, x) == [x**2 + x - sqrt(3)/2, sin(x)]
+    assert decompogen(Abs(cos(y)**2 + 3*cos(x) - 4), x) == [Abs(x), 3*x + cos(y)**2 - 4, cos(x)]
+    assert decompogen(x, y) == [x]
+    assert decompogen(1, x) == [1]
+    assert decompogen(Max(3, x), x) == [Max(3, x)]
+    raises(TypeError, lambda: decompogen(x < 5, x))
+    u = 2*x + 3
+    assert decompogen(Max(sqrt(u),(u)**2), x) == [Max(sqrt(x), x**2), u]
+    assert decompogen(Max(u, u**2, y), x) == [Max(x, x**2, y), u]
+    assert decompogen(Max(sin(x), u), x) == [Max(2*x + 3, sin(x))]
+
+
+def test_decompogen_poly():
+    assert decompogen(x**4 + 2*x**2 + 1, x) == [x**2 + 2*x + 1, x**2]
+    assert decompogen(x**4 + 2*x**3 - x - 1, x) == [x**2 - x - 1, x**2 + x]
+
+
+@XFAIL
+def test_decompogen_fails():
+    A = lambda x: x**2 + 2*x + 3
+    B = lambda x: 4*x**2 + 5*x + 6
+    assert decompogen(A(x*exp(x)), x) == [x**2 + 2*x + 3, x*exp(x)]
+    assert decompogen(A(B(x)), x) == [x**2 + 2*x + 3, 4*x**2 + 5*x + 6]
+    assert decompogen(A(1/x + 1/x**2), x) == [x**2 + 2*x + 3, 1/x + 1/x**2]
+    assert decompogen(A(1/x + 2/(x + 1)), x) == [x**2 + 2*x + 3, 1/x + 2/(x + 1)]
+
+
+def test_compogen():
+    assert compogen([sin(x), cos(x)], x) == sin(cos(x))
+    assert compogen([x**2 + x + 1, sin(x)], x) == sin(x)**2 + sin(x) + 1
+    assert compogen([sqrt(x), 6*x**2 - 5], x) == sqrt(6*x**2 - 5)
+    assert compogen([sin(x), sqrt(x), cos(x), x**2 + 1], x) == sin(sqrt(
+                                                                cos(x**2 + 1)))
+    assert compogen([Abs(x), x**2 + 3*x - 4, cos(x)], x) == Abs(cos(x)**2 +
+                                                                3*cos(x) - 4)
+    assert compogen([x**2 + x - sqrt(3)/2, sin(x)], x) == (sin(x)**2 + sin(x) -
+                                                           sqrt(3)/2)
+    assert compogen([Abs(x), 3*x + cos(y)**2 - 4, cos(x)], x) == \
+        Abs(3*cos(x) + cos(y)**2 - 4)
+    assert compogen([x**2 + 2*x + 1, x**2], x) == x**4 + 2*x**2 + 1
+    # the result is in unsimplified form
+    assert compogen([x**2 - x - 1, x**2 + x], x) == -x**2 - x + (x**2 + x)**2 - 1
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/tests/test_inequalities.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/tests/test_inequalities.py
new file mode 100644
index 0000000000000000000000000000000000000000..6ce6f4520b52d8714102c95457c90d44543c685c
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/tests/test_inequalities.py
@@ -0,0 +1,500 @@
+"""Tests for tools for solving inequalities and systems of inequalities. """
+
+from sympy.concrete.summations import Sum
+from sympy.core.function import Function
+from sympy.core.numbers import I, Rational, oo, pi
+from sympy.core.relational import Eq, Ge, Gt, Le, Lt, Ne
+from sympy.core.singleton import S
+from sympy.core.symbol import (Dummy, Symbol)
+from sympy.functions.elementary.complexes import Abs
+from sympy.functions.elementary.exponential import exp, log
+from sympy.functions.elementary.miscellaneous import root, sqrt
+from sympy.functions.elementary.piecewise import Piecewise
+from sympy.functions.elementary.trigonometric import cos, sin, tan
+from sympy.integrals.integrals import Integral
+from sympy.logic.boolalg import And, Or
+from sympy.polys.polytools import Poly, PurePoly
+from sympy.sets.sets import FiniteSet, Interval, Union
+from sympy.solvers.inequalities import (reduce_inequalities,
+                                        solve_poly_inequality as psolve,
+                                        reduce_rational_inequalities,
+                                        solve_univariate_inequality as isolve,
+                                        reduce_abs_inequality,
+                                        _solve_inequality)
+from sympy.polys.rootoftools import rootof
+from sympy.solvers.solvers import solve
+from sympy.solvers.solveset import solveset
+from sympy.core.mod import Mod
+from sympy.abc import x, y
+
+from sympy.testing.pytest import raises, XFAIL
+
+
+inf = oo.evalf()
+
+
+def test_solve_poly_inequality():
+    assert psolve(Poly(0, x), '==') == [S.Reals]
+    assert psolve(Poly(1, x), '==') == [S.EmptySet]
+    assert psolve(PurePoly(x + 1, x), ">") == [Interval(-1, oo, True, False)]
+
+
+def test_reduce_poly_inequalities_real_interval():
+    assert reduce_rational_inequalities(
+        [[Eq(x**2, 0)]], x, relational=False) == FiniteSet(0)
+    assert reduce_rational_inequalities(
+        [[Le(x**2, 0)]], x, relational=False) == FiniteSet(0)
+    assert reduce_rational_inequalities(
+        [[Lt(x**2, 0)]], x, relational=False) == S.EmptySet
+    assert reduce_rational_inequalities(
+        [[Ge(x**2, 0)]], x, relational=False) == \
+        S.Reals if x.is_real else Interval(-oo, oo)
+    assert reduce_rational_inequalities(
+        [[Gt(x**2, 0)]], x, relational=False) == \
+        FiniteSet(0).complement(S.Reals)
+    assert reduce_rational_inequalities(
+        [[Ne(x**2, 0)]], x, relational=False) == \
+        FiniteSet(0).complement(S.Reals)
+
+    assert reduce_rational_inequalities(
+        [[Eq(x**2, 1)]], x, relational=False) == FiniteSet(-1, 1)
+    assert reduce_rational_inequalities(
+        [[Le(x**2, 1)]], x, relational=False) == Interval(-1, 1)
+    assert reduce_rational_inequalities(
+        [[Lt(x**2, 1)]], x, relational=False) == Interval(-1, 1, True, True)
+    assert reduce_rational_inequalities(
+        [[Ge(x**2, 1)]], x, relational=False) == \
+        Union(Interval(-oo, -1), Interval(1, oo))
+    assert reduce_rational_inequalities(
+        [[Gt(x**2, 1)]], x, relational=False) == \
+        Interval(-1, 1).complement(S.Reals)
+    assert reduce_rational_inequalities(
+        [[Ne(x**2, 1)]], x, relational=False) == \
+        FiniteSet(-1, 1).complement(S.Reals)
+    assert reduce_rational_inequalities([[Eq(
+        x**2, 1.0)]], x, relational=False) == FiniteSet(-1.0, 1.0).evalf()
+    assert reduce_rational_inequalities(
+        [[Le(x**2, 1.0)]], x, relational=False) == Interval(-1.0, 1.0)
+    assert reduce_rational_inequalities([[Lt(
+        x**2, 1.0)]], x, relational=False) == Interval(-1.0, 1.0, True, True)
+    assert reduce_rational_inequalities(
+        [[Ge(x**2, 1.0)]], x, relational=False) == \
+        Union(Interval(-inf, -1.0), Interval(1.0, inf))
+    assert reduce_rational_inequalities(
+        [[Gt(x**2, 1.0)]], x, relational=False) == \
+        Union(Interval(-inf, -1.0, right_open=True),
+        Interval(1.0, inf, left_open=True))
+    assert reduce_rational_inequalities([[Ne(
+        x**2, 1.0)]], x, relational=False) == \
+        FiniteSet(-1.0, 1.0).complement(S.Reals)
+
+    s = sqrt(2)
+
+    assert reduce_rational_inequalities([[Lt(
+        x**2 - 1, 0), Gt(x**2 - 1, 0)]], x, relational=False) == S.EmptySet
+    assert reduce_rational_inequalities([[Le(x**2 - 1, 0), Ge(
+        x**2 - 1, 0)]], x, relational=False) == FiniteSet(-1, 1)
+    assert reduce_rational_inequalities(
+        [[Le(x**2 - 2, 0), Ge(x**2 - 1, 0)]], x, relational=False
+        ) == Union(Interval(-s, -1, False, False), Interval(1, s, False, False))
+    assert reduce_rational_inequalities(
+        [[Le(x**2 - 2, 0), Gt(x**2 - 1, 0)]], x, relational=False
+        ) == Union(Interval(-s, -1, False, True), Interval(1, s, True, False))
+    assert reduce_rational_inequalities(
+        [[Lt(x**2 - 2, 0), Ge(x**2 - 1, 0)]], x, relational=False
+        ) == Union(Interval(-s, -1, True, False), Interval(1, s, False, True))
+    assert reduce_rational_inequalities(
+        [[Lt(x**2 - 2, 0), Gt(x**2 - 1, 0)]], x, relational=False
+        ) == Union(Interval(-s, -1, True, True), Interval(1, s, True, True))
+    assert reduce_rational_inequalities(
+        [[Lt(x**2 - 2, 0), Ne(x**2 - 1, 0)]], x, relational=False
+        ) == Union(Interval(-s, -1, True, True), Interval(-1, 1, True, True),
+        Interval(1, s, True, True))
+
+    assert reduce_rational_inequalities([[Lt(x**2, -1.)]], x) is S.false
+
+
+def test_reduce_poly_inequalities_complex_relational():
+    assert reduce_rational_inequalities(
+        [[Eq(x**2, 0)]], x, relational=True) == Eq(x, 0)
+    assert reduce_rational_inequalities(
+        [[Le(x**2, 0)]], x, relational=True) == Eq(x, 0)
+    assert reduce_rational_inequalities(
+        [[Lt(x**2, 0)]], x, relational=True) == False
+    assert reduce_rational_inequalities(
+        [[Ge(x**2, 0)]], x, relational=True) == And(Lt(-oo, x), Lt(x, oo))
+    assert reduce_rational_inequalities(
+        [[Gt(x**2, 0)]], x, relational=True) == \
+        And(Gt(x, -oo), Lt(x, oo), Ne(x, 0))
+    assert reduce_rational_inequalities(
+        [[Ne(x**2, 0)]], x, relational=True) == \
+        And(Gt(x, -oo), Lt(x, oo), Ne(x, 0))
+
+    for one in (S.One, S(1.0)):
+        inf = one*oo
+        assert reduce_rational_inequalities(
+            [[Eq(x**2, one)]], x, relational=True) == \
+            Or(Eq(x, -one), Eq(x, one))
+        assert reduce_rational_inequalities(
+            [[Le(x**2, one)]], x, relational=True) == \
+            And(And(Le(-one, x), Le(x, one)))
+        assert reduce_rational_inequalities(
+            [[Lt(x**2, one)]], x, relational=True) == \
+            And(And(Lt(-one, x), Lt(x, one)))
+        assert reduce_rational_inequalities(
+            [[Ge(x**2, one)]], x, relational=True) == \
+            And(Or(And(Le(one, x), Lt(x, inf)), And(Le(x, -one), Lt(-inf, x))))
+        assert reduce_rational_inequalities(
+            [[Gt(x**2, one)]], x, relational=True) == \
+            And(Or(And(Lt(-inf, x), Lt(x, -one)), And(Lt(one, x), Lt(x, inf))))
+        assert reduce_rational_inequalities(
+            [[Ne(x**2, one)]], x, relational=True) == \
+            Or(And(Lt(-inf, x), Lt(x, -one)),
+               And(Lt(-one, x), Lt(x, one)),
+               And(Lt(one, x), Lt(x, inf)))
+
+
+def test_reduce_rational_inequalities_real_relational():
+    assert reduce_rational_inequalities([], x) == False
+    assert reduce_rational_inequalities(
+        [[(x**2 + 3*x + 2)/(x**2 - 16) >= 0]], x, relational=False) == \
+        Union(Interval.open(-oo, -4), Interval(-2, -1), Interval.open(4, oo))
+
+    assert reduce_rational_inequalities(
+        [[((-2*x - 10)*(3 - x))/((x**2 + 5)*(x - 2)**2) < 0]], x,
+        relational=False) == \
+        Union(Interval.open(-5, 2), Interval.open(2, 3))
+
+    assert reduce_rational_inequalities([[(x + 1)/(x - 5) <= 0]], x,
+        relational=False) == \
+        Interval.Ropen(-1, 5)
+
+    assert reduce_rational_inequalities([[(x**2 + 4*x + 3)/(x - 1) > 0]], x,
+        relational=False) == \
+        Union(Interval.open(-3, -1), Interval.open(1, oo))
+
+    assert reduce_rational_inequalities([[(x**2 - 16)/(x - 1)**2 < 0]], x,
+        relational=False) == \
+        Union(Interval.open(-4, 1), Interval.open(1, 4))
+
+    assert reduce_rational_inequalities([[(3*x + 1)/(x + 4) >= 1]], x,
+        relational=False) == \
+        Union(Interval.open(-oo, -4), Interval.Ropen(Rational(3, 2), oo))
+
+    assert reduce_rational_inequalities([[(x - 8)/x <= 3 - x]], x,
+        relational=False) == \
+        Union(Interval.Lopen(-oo, -2), Interval.Lopen(0, 4))
+
+    # issue sympy/sympy#10237
+    assert reduce_rational_inequalities(
+        [[x < oo, x >= 0, -oo < x]], x, relational=False) == Interval(0, oo)
+
+
+def test_reduce_abs_inequalities():
+    e = abs(x - 5) < 3
+    ans = And(Lt(2, x), Lt(x, 8))
+    assert reduce_inequalities(e) == ans
+    assert reduce_inequalities(e, x) == ans
+    assert reduce_inequalities(abs(x - 5)) == Eq(x, 5)
+    assert reduce_inequalities(
+        abs(2*x + 3) >= 8) == Or(And(Le(Rational(5, 2), x), Lt(x, oo)),
+        And(Le(x, Rational(-11, 2)), Lt(-oo, x)))
+    assert reduce_inequalities(abs(x - 4) + abs(
+        3*x - 5) < 7) == And(Lt(S.Half, x), Lt(x, 4))
+    assert reduce_inequalities(abs(x - 4) + abs(3*abs(x) - 5) < 7) == \
+        Or(And(S(-2) < x, x < -1), And(S.Half < x, x < 4))
+
+    nr = Symbol('nr', extended_real=False)
+    raises(TypeError, lambda: reduce_inequalities(abs(nr - 5) < 3))
+    assert reduce_inequalities(x < 3, symbols=[x, nr]) == And(-oo < x, x < 3)
+
+
+def test_reduce_inequalities_general():
+    assert reduce_inequalities(Ge(sqrt(2)*x, 1)) == And(sqrt(2)/2 <= x, x < oo)
+    assert reduce_inequalities(x + 1 > 0) == And(S.NegativeOne < x, x < oo)
+
+
+def test_reduce_inequalities_boolean():
+    assert reduce_inequalities(
+        [Eq(x**2, 0), True]) == Eq(x, 0)
+    assert reduce_inequalities([Eq(x**2, 0), False]) == False
+    assert reduce_inequalities(x**2 >= 0) is S.true  # issue 10196
+
+
+def test_reduce_inequalities_multivariate():
+    assert reduce_inequalities([Ge(x**2, 1), Ge(y**2, 1)]) == And(
+        Or(And(Le(S.One, x), Lt(x, oo)), And(Le(x, -1), Lt(-oo, x))),
+        Or(And(Le(S.One, y), Lt(y, oo)), And(Le(y, -1), Lt(-oo, y))))
+
+
+def test_reduce_inequalities_errors():
+    raises(NotImplementedError, lambda: reduce_inequalities(Ge(sin(x) + x, 1)))
+    raises(NotImplementedError, lambda: reduce_inequalities(Ge(x**2*y + y, 1)))
+
+
+def test__solve_inequalities():
+    assert reduce_inequalities(x + y < 1, symbols=[x]) == (x < 1 - y)
+    assert reduce_inequalities(x + y >= 1, symbols=[x]) == (x < oo) & (x >= -y + 1)
+    assert reduce_inequalities(Eq(0, x - y), symbols=[x]) == Eq(x, y)
+    assert reduce_inequalities(Ne(0, x - y), symbols=[x]) == Ne(x, y)
+
+
+def test_issue_6343():
+    eq = -3*x**2/2 - x*Rational(45, 4) + Rational(33, 2) > 0
+    assert reduce_inequalities(eq) == \
+        And(x < Rational(-15, 4) + sqrt(401)/4, -sqrt(401)/4 - Rational(15, 4) < x)
+
+
+def test_issue_8235():
+    assert reduce_inequalities(x**2 - 1 < 0) == \
+        And(S.NegativeOne < x, x < 1)
+    assert reduce_inequalities(x**2 - 1 <= 0) == \
+        And(S.NegativeOne <= x, x <= 1)
+    assert reduce_inequalities(x**2 - 1 > 0) == \
+        Or(And(-oo < x, x < -1), And(x < oo, S.One < x))
+    assert reduce_inequalities(x**2 - 1 >= 0) == \
+        Or(And(-oo < x, x <= -1), And(S.One <= x, x < oo))
+
+    eq = x**8 + x - 9  # we want CRootOf solns here
+    sol = solve(eq >= 0)
+    tru = Or(And(rootof(eq, 1) <= x, x < oo), And(-oo < x, x <= rootof(eq, 0)))
+    assert sol == tru
+
+    # recast vanilla as real
+    assert solve(sqrt((-x + 1)**2) < 1) == And(S.Zero < x, x < 2)
+
+
+def test_issue_5526():
+    assert reduce_inequalities(0 <=
+        x + Integral(y**2, (y, 1, 3)) - 1, [x]) == \
+        (x >= -Integral(y**2, (y, 1, 3)) + 1)
+    f = Function('f')
+    e = Sum(f(x), (x, 1, 3))
+    assert reduce_inequalities(0 <= x + e + y**2, [x]) == \
+        (x >= -y**2 - Sum(f(x), (x, 1, 3)))
+
+
+def test_solve_univariate_inequality():
+    assert isolve(x**2 >= 4, x, relational=False) == Union(Interval(-oo, -2),
+        Interval(2, oo))
+    assert isolve(x**2 >= 4, x) == Or(And(Le(2, x), Lt(x, oo)), And(Le(x, -2),
+        Lt(-oo, x)))
+    assert isolve((x - 1)*(x - 2)*(x - 3) >= 0, x, relational=False) == \
+        Union(Interval(1, 2), Interval(3, oo))
+    assert isolve((x - 1)*(x - 2)*(x - 3) >= 0, x) == \
+        Or(And(Le(1, x), Le(x, 2)), And(Le(3, x), Lt(x, oo)))
+    assert isolve((x - 1)*(x - 2)*(x - 4) < 0, x, domain = FiniteSet(0, 3)) == \
+        Or(Eq(x, 0), Eq(x, 3))
+    # issue 2785:
+    assert isolve(x**3 - 2*x - 1 > 0, x, relational=False) == \
+        Union(Interval(-1, -sqrt(5)/2 + S.Half, True, True),
+              Interval(S.Half + sqrt(5)/2, oo, True, True))
+    # issue 2794:
+    assert isolve(x**3 - x**2 + x - 1 > 0, x, relational=False) == \
+        Interval(1, oo, True)
+    #issue 13105
+    assert isolve((x + I)*(x + 2*I) < 0, x) == Eq(x, 0)
+    assert isolve(((x - 1)*(x - 2) + I)*((x - 1)*(x - 2) + 2*I) < 0, x) == Or(Eq(x, 1), Eq(x, 2))
+    assert isolve((((x - 1)*(x - 2) + I)*((x - 1)*(x - 2) + 2*I))/(x - 2) > 0, x) == Eq(x, 1)
+    raises (ValueError, lambda: isolve((x**2 - 3*x*I + 2)/x < 0, x))
+
+    # numerical testing in valid() is needed
+    assert isolve(x**7 - x - 2 > 0, x) == \
+        And(rootof(x**7 - x - 2, 0) < x, x < oo)
+
+    # handle numerator and denominator; although these would be handled as
+    # rational inequalities, these test confirm that the right thing is done
+    # when the domain is EX (e.g. when 2 is replaced with sqrt(2))
+    assert isolve(1/(x - 2) > 0, x) == And(S(2) < x, x < oo)
+    den = ((x - 1)*(x - 2)).expand()
+    assert isolve((x - 1)/den <= 0, x) == \
+        (x > -oo) & (x < 2) & Ne(x, 1)
+
+    n = Dummy('n')
+    raises(NotImplementedError, lambda: isolve(Abs(x) <= n, x, relational=False))
+    c1 = Dummy("c1", positive=True)
+    raises(NotImplementedError, lambda: isolve(n/c1 < 0, c1))
+    n = Dummy('n', negative=True)
+    assert isolve(n/c1 > -2, c1) == (-n/2 < c1)
+    assert isolve(n/c1 < 0, c1) == True
+    assert isolve(n/c1 > 0, c1) == False
+
+    zero = cos(1)**2 + sin(1)**2 - 1
+    raises(NotImplementedError, lambda: isolve(x**2 < zero, x))
+    raises(NotImplementedError, lambda: isolve(
+        x**2 < zero*I, x))
+    raises(NotImplementedError, lambda: isolve(1/(x - y) < 2, x))
+    raises(NotImplementedError, lambda: isolve(1/(x - y) < 0, x))
+    raises(TypeError, lambda: isolve(x - I < 0, x))
+
+    zero = x**2 + x - x*(x + 1)
+    assert isolve(zero < 0, x, relational=False) is S.EmptySet
+    assert isolve(zero <= 0, x, relational=False) is S.Reals
+
+    # make sure iter_solutions gets a default value
+    raises(NotImplementedError, lambda: isolve(
+        Eq(cos(x)**2 + sin(x)**2, 1), x))
+
+
+def test_trig_inequalities():
+    # all the inequalities are solved in a periodic interval.
+    assert isolve(sin(x) < S.Half, x, relational=False) == \
+        Union(Interval(0, pi/6, False, True), Interval.open(pi*Rational(5, 6), 2*pi))
+    assert isolve(sin(x) > S.Half, x, relational=False) == \
+        Interval(pi/6, pi*Rational(5, 6), True, True)
+    assert isolve(cos(x) < S.Zero, x, relational=False) == \
+        Interval(pi/2, pi*Rational(3, 2), True, True)
+    assert isolve(cos(x) >= S.Zero, x, relational=False) == \
+        Union(Interval(0, pi/2), Interval.Ropen(pi*Rational(3, 2), 2*pi))
+
+    assert isolve(tan(x) < S.One, x, relational=False) == \
+        Union(Interval.Ropen(0, pi/4), Interval.open(pi/2, pi))
+
+    assert isolve(sin(x) <= S.Zero, x, relational=False) == \
+        Union(FiniteSet(S.Zero), Interval.Ropen(pi, 2*pi))
+
+    assert isolve(sin(x) <= S.One, x, relational=False) == S.Reals
+    assert isolve(cos(x) < S(-2), x, relational=False) == S.EmptySet
+    assert isolve(sin(x) >= S.NegativeOne, x, relational=False) == S.Reals
+    assert isolve(cos(x) > S.One, x, relational=False) == S.EmptySet
+
+
+def test_issue_9954():
+    assert isolve(x**2 >= 0, x, relational=False) == S.Reals
+    assert isolve(x**2 >= 0, x, relational=True) == S.Reals.as_relational(x)
+    assert isolve(x**2 < 0, x, relational=False) == S.EmptySet
+    assert isolve(x**2 < 0, x, relational=True) == S.EmptySet.as_relational(x)
+
+
+@XFAIL
+def test_slow_general_univariate():
+    r = rootof(x**5 - x**2 + 1, 0)
+    assert solve(sqrt(x) + 1/root(x, 3) > 1) == \
+        Or(And(0 < x, x < r**6), And(r**6 < x, x < oo))
+
+
+def test_issue_8545():
+    eq = 1 - x - abs(1 - x)
+    ans = And(Lt(1, x), Lt(x, oo))
+    assert reduce_abs_inequality(eq, '<', x) == ans
+    eq = 1 - x - sqrt((1 - x)**2)
+    assert reduce_inequalities(eq < 0) == ans
+
+
+def test_issue_8974():
+    assert isolve(-oo < x, x) == And(-oo < x, x < oo)
+    assert isolve(oo > x, x) == And(-oo < x, x < oo)
+
+
+def test_issue_10198():
+    assert reduce_inequalities(
+        -1 + 1/abs(1/x - 1) < 0) == (x > -oo) & (x < S(1)/2) & Ne(x, 0)
+
+    assert reduce_inequalities(abs(1/sqrt(x)) - 1, x) == Eq(x, 1)
+    assert reduce_abs_inequality(-3 + 1/abs(1 - 1/x), '<', x) == \
+        Or(And(-oo < x, x < 0),
+        And(S.Zero < x, x < Rational(3, 4)), And(Rational(3, 2) < x, x < oo))
+    raises(ValueError,lambda: reduce_abs_inequality(-3 + 1/abs(
+        1 - 1/sqrt(x)), '<', x))
+
+
+def test_issue_10047():
+    # issue 10047: this must remain an inequality, not True, since if x
+    # is not real the inequality is invalid
+    # assert solve(sin(x) < 2) == (x <= oo)
+
+    # with PR 16956, (x <= oo) autoevaluates when x is extended_real
+    # which is assumed in the current implementation of inequality solvers
+    assert solve(sin(x) < 2) == True
+    assert solveset(sin(x) < 2, domain=S.Reals) == S.Reals
+
+
+def test_issue_10268():
+    assert solve(log(x) < 1000) == And(S.Zero < x, x < exp(1000))
+
+
+@XFAIL
+def test_isolve_Sets():
+    n = Dummy('n')
+    assert isolve(Abs(x) <= n, x, relational=False) == \
+        Piecewise((S.EmptySet, n < 0), (Interval(-n, n), True))
+
+
+def test_integer_domain_relational_isolve():
+
+    dom = FiniteSet(0, 3)
+    x = Symbol('x',zero=False)
+    assert isolve((x - 1)*(x - 2)*(x - 4) < 0, x, domain=dom) == Eq(x, 3)
+
+    x = Symbol('x')
+    assert isolve(x + 2 < 0, x, domain=S.Integers) == \
+           (x <= -3) & (x > -oo) & Eq(Mod(x, 1), 0)
+    assert isolve(2 * x + 3 > 0, x, domain=S.Integers) == \
+           (x >= -1) & (x < oo)  & Eq(Mod(x, 1), 0)
+    assert isolve((x ** 2 + 3 * x - 2) < 0, x, domain=S.Integers) == \
+           (x >= -3) & (x <= 0)  & Eq(Mod(x, 1), 0)
+    assert isolve((x ** 2 + 3 * x - 2) > 0, x, domain=S.Integers) == \
+           ((x >= 1) & (x < oo)  & Eq(Mod(x, 1), 0)) | (
+               (x <= -4) & (x > -oo)  & Eq(Mod(x, 1), 0))
+
+
+def test_issue_10671_12466():
+    assert solveset(sin(y), y, Interval(0, pi)) == FiniteSet(0, pi)
+    i = Interval(1, 10)
+    assert solveset((1/x).diff(x) < 0, x, i) == i
+    assert solveset((log(x - 6)/x) <= 0, x, S.Reals) == \
+        Interval.Lopen(6, 7)
+
+
+def test__solve_inequality():
+    for op in (Gt, Lt, Le, Ge, Eq, Ne):
+        assert _solve_inequality(op(x, 1), x).lhs == x
+        assert _solve_inequality(op(S.One, x), x).lhs == x
+    # don't get tricked by symbol on right: solve it
+    assert _solve_inequality(Eq(2*x - 1, x), x) == Eq(x, 1)
+    ie = Eq(S.One, y)
+    assert _solve_inequality(ie, x) == ie
+    for fx in (x**2, exp(x), sin(x) + cos(x), x*(1 + x)):
+        for c in (0, 1):
+            e = 2*fx - c > 0
+            assert _solve_inequality(e, x, linear=True) == (
+                fx > c/S(2))
+    assert _solve_inequality(2*x**2 + 2*x - 1 < 0, x, linear=True) == (
+        x*(x + 1) < S.Half)
+    assert _solve_inequality(Eq(x*y, 1), x) == Eq(x*y, 1)
+    nz = Symbol('nz', nonzero=True)
+    assert _solve_inequality(Eq(x*nz, 1), x) == Eq(x, 1/nz)
+    assert _solve_inequality(x*nz < 1, x) == (x*nz < 1)
+    a = Symbol('a', positive=True)
+    assert _solve_inequality(a/x > 1, x) == (S.Zero < x) & (x < a)
+    assert _solve_inequality(a/x > 1, x, linear=True) == (1/x > 1/a)
+    # make sure to include conditions under which solution is valid
+    e = Eq(1 - x, x*(1/x - 1))
+    assert _solve_inequality(e, x) == Ne(x, 0)
+    assert _solve_inequality(x < x*(1/x - 1), x) == (x < S.Half) & Ne(x, 0)
+
+
+def test__pt():
+    from sympy.solvers.inequalities import _pt
+    assert _pt(-oo, oo) == 0
+    assert _pt(S.One, S(3)) == 2
+    assert _pt(S.One, oo) == _pt(oo, S.One) == 2
+    assert _pt(S.One, -oo) == _pt(-oo, S.One) == S.Half
+    assert _pt(S.NegativeOne, oo) == _pt(oo, S.NegativeOne) == Rational(-1, 2)
+    assert _pt(S.NegativeOne, -oo) == _pt(-oo, S.NegativeOne) == -2
+    assert _pt(x, oo) == _pt(oo, x) == x + 1
+    assert _pt(x, -oo) == _pt(-oo, x) == x - 1
+    raises(ValueError, lambda: _pt(Dummy('i', infinite=True), S.One))
+
+
+def test_issue_25697():
+    assert _solve_inequality(log(x, 3) <= 2, x) == (x <= 9) & (S.Zero < x)
+
+
+def test_issue_25738():
+    assert reduce_inequalities(3 < abs(x)
+        ) == reduce_inequalities(pi < abs(x)).subs(pi, 3)
+
+
+def test_issue_25983():
+    assert(reduce_inequalities(pi/Abs(x) <= 1) == ((pi <= x) & (x < oo)) | ((-oo < x) & (x <= -pi)))
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/tests/test_numeric.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/tests/test_numeric.py
new file mode 100644
index 0000000000000000000000000000000000000000..12abd38c80f07279ed41aefc7952762da0f9f430
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/tests/test_numeric.py
@@ -0,0 +1,139 @@
+from sympy.core.function import nfloat
+from sympy.core.numbers import (Float, I, Rational, pi)
+from sympy.core.relational import Eq
+from sympy.core.symbol import (Symbol, symbols)
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.piecewise import Piecewise
+from sympy.functions.elementary.trigonometric import sin
+from sympy.integrals.integrals import Integral
+from sympy.matrices.dense import Matrix
+from mpmath import mnorm, mpf
+from sympy.solvers import nsolve
+from sympy.utilities.lambdify import lambdify
+from sympy.testing.pytest import raises, XFAIL
+from sympy.utilities.decorator import conserve_mpmath_dps
+
+@XFAIL
+def test_nsolve_fail():
+    x = symbols('x')
+    # Sometimes it is better to use the numerator (issue 4829)
+    # but sometimes it is not (issue 11768) so leave this to
+    # the discretion of the user
+    ans = nsolve(x**2/(1 - x)/(1 - 2*x)**2 - 100, x, 0)
+    assert ans > 0.46 and ans < 0.47
+
+
+def test_nsolve_denominator():
+    x = symbols('x')
+    # Test that nsolve uses the full expression (numerator and denominator).
+    ans = nsolve((x**2 + 3*x + 2)/(x + 2), -2.1)
+    # The root -2 was divided out, so make sure we don't find it.
+    assert ans == -1.0
+
+def test_nsolve():
+    # onedimensional
+    x = Symbol('x')
+    assert nsolve(sin(x), 2) - pi.evalf() < 1e-15
+    assert nsolve(Eq(2*x, 2), x, -10) == nsolve(2*x - 2, -10)
+    # Testing checks on number of inputs
+    raises(TypeError, lambda: nsolve(Eq(2*x, 2)))
+    raises(TypeError, lambda: nsolve(Eq(2*x, 2), x, 1, 2))
+    # multidimensional
+    x1 = Symbol('x1')
+    x2 = Symbol('x2')
+    f1 = 3 * x1**2 - 2 * x2**2 - 1
+    f2 = x1**2 - 2 * x1 + x2**2 + 2 * x2 - 8
+    f = Matrix((f1, f2)).T
+    F = lambdify((x1, x2), f.T, modules='mpmath')
+    for x0 in [(-1, 1), (1, -2), (4, 4), (-4, -4)]:
+        x = nsolve(f, (x1, x2), x0, tol=1.e-8)
+        assert mnorm(F(*x), 1) <= 1.e-10
+    # The Chinese mathematician Zhu Shijie was the very first to solve this
+    # nonlinear system 700 years ago (z was added to make it 3-dimensional)
+    x = Symbol('x')
+    y = Symbol('y')
+    z = Symbol('z')
+    f1 = -x + 2*y
+    f2 = (x**2 + x*(y**2 - 2) - 4*y) / (x + 4)
+    f3 = sqrt(x**2 + y**2)*z
+    f = Matrix((f1, f2, f3)).T
+    F = lambdify((x, y, z), f.T, modules='mpmath')
+
+    def getroot(x0):
+        root = nsolve(f, (x, y, z), x0)
+        assert mnorm(F(*root), 1) <= 1.e-8
+        return root
+    assert list(map(round, getroot((1, 1, 1)))) == [2, 1, 0]
+    assert nsolve([Eq(
+        f1, 0), Eq(f2, 0), Eq(f3, 0)], [x, y, z], (1, 1, 1))  # just see that it works
+    a = Symbol('a')
+    assert abs(nsolve(1/(0.001 + a)**3 - 6/(0.9 - a)**3, a, 0.3) -
+        mpf('0.31883011387318591')) < 1e-15
+
+
+def test_issue_6408():
+    x = Symbol('x')
+    assert nsolve(Piecewise((x, x < 1), (x**2, True)), x, 2) == 0
+
+
+def test_issue_6408_integral():
+    x, y = symbols('x y')
+    assert nsolve(Integral(x*y, (x, 0, 5)), y, 2) == 0
+
+
+@conserve_mpmath_dps
+def test_increased_dps():
+    # Issue 8564
+    import mpmath
+    mpmath.mp.dps = 128
+    x = Symbol('x')
+    e1 = x**2 - pi
+    q = nsolve(e1, x, 3.0)
+
+    assert abs(sqrt(pi).evalf(128) - q) < 1e-128
+
+def test_nsolve_precision():
+    x, y = symbols('x y')
+    sol = nsolve(x**2 - pi, x, 3, prec=128)
+    assert abs(sqrt(pi).evalf(128) - sol) < 1e-128
+    assert isinstance(sol, Float)
+
+    sols = nsolve((y**2 - x, x**2 - pi), (x, y), (3, 3), prec=128)
+    assert isinstance(sols, Matrix)
+    assert sols.shape == (2, 1)
+    assert abs(sqrt(pi).evalf(128) - sols[0]) < 1e-128
+    assert abs(sqrt(sqrt(pi)).evalf(128) - sols[1]) < 1e-128
+    assert all(isinstance(i, Float) for i in sols)
+
+def test_nsolve_complex():
+    x, y = symbols('x y')
+
+    assert nsolve(x**2 + 2, 1j) == sqrt(2.)*I
+    assert nsolve(x**2 + 2, I) == sqrt(2.)*I
+
+    assert nsolve([x**2 + 2, y**2 + 2], [x, y], [I, I]) == Matrix([sqrt(2.)*I, sqrt(2.)*I])
+    assert nsolve([x**2 + 2, y**2 + 2], [x, y], [I, I]) == Matrix([sqrt(2.)*I, sqrt(2.)*I])
+
+def test_nsolve_dict_kwarg():
+    x, y = symbols('x y')
+    # one variable
+    assert nsolve(x**2 - 2, 1, dict = True) == \
+        [{x: sqrt(2.)}]
+    # one variable with complex solution
+    assert nsolve(x**2 + 2, I, dict = True) == \
+        [{x: sqrt(2.)*I}]
+    # two variables
+    assert nsolve([x**2 + y**2 - 5, x**2 - y**2 + 1], [x, y], [1, 1], dict = True) == \
+        [{x: sqrt(2.), y: sqrt(3.)}]
+
+def test_nsolve_rational():
+    x = symbols('x')
+    assert nsolve(x - Rational(1, 3), 0, prec=100) == Rational(1, 3).evalf(100)
+
+
+def test_issue_14950():
+    x = Matrix(symbols('t s'))
+    x0 = Matrix([17, 23])
+    eqn = x + x0
+    assert nsolve(eqn, x, x0) == nfloat(-x0)
+    assert nsolve(eqn.T, x.T, x0.T) == nfloat(-x0)
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/tests/test_pde.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/tests/test_pde.py
new file mode 100644
index 0000000000000000000000000000000000000000..948d90c7be21a9e0e03753e723ef04f1fb08a5d6
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/tests/test_pde.py
@@ -0,0 +1,239 @@
+from sympy.core.function import (Derivative as D, Function)
+from sympy.core.relational import Eq
+from sympy.core.symbol import (Symbol, symbols)
+from sympy.functions.elementary.exponential import (exp, log)
+from sympy.functions.elementary.trigonometric import (cos, sin)
+from sympy.core import S
+from sympy.solvers.pde import (pde_separate, pde_separate_add, pde_separate_mul,
+    pdsolve, classify_pde, checkpdesol)
+from sympy.testing.pytest import raises
+
+
+a, b, c, x, y = symbols('a b c x y')
+
+def test_pde_separate_add():
+    x, y, z, t = symbols("x,y,z,t")
+    F, T, X, Y, Z, u = map(Function, 'FTXYZu')
+
+    eq = Eq(D(u(x, t), x), D(u(x, t), t)*exp(u(x, t)))
+    res = pde_separate_add(eq, u(x, t), [X(x), T(t)])
+    assert res == [D(X(x), x)*exp(-X(x)), D(T(t), t)*exp(T(t))]
+
+
+def test_pde_separate():
+    x, y, z, t = symbols("x,y,z,t")
+    F, T, X, Y, Z, u = map(Function, 'FTXYZu')
+
+    eq = Eq(D(u(x, t), x), D(u(x, t), t)*exp(u(x, t)))
+    raises(ValueError, lambda: pde_separate(eq, u(x, t), [X(x), T(t)], 'div'))
+
+
+def test_pde_separate_mul():
+    x, y, z, t = symbols("x,y,z,t")
+    c = Symbol("C", real=True)
+    Phi = Function('Phi')
+    F, R, T, X, Y, Z, u = map(Function, 'FRTXYZu')
+    r, theta, z = symbols('r,theta,z')
+
+    # Something simple :)
+    eq = Eq(D(F(x, y, z), x) + D(F(x, y, z), y) + D(F(x, y, z), z), 0)
+
+    # Duplicate arguments in functions
+    raises(
+        ValueError, lambda: pde_separate_mul(eq, F(x, y, z), [X(x), u(z, z)]))
+    # Wrong number of arguments
+    raises(ValueError, lambda: pde_separate_mul(eq, F(x, y, z), [X(x), Y(y)]))
+    # Wrong variables: [x, y] -> [x, z]
+    raises(
+        ValueError, lambda: pde_separate_mul(eq, F(x, y, z), [X(t), Y(x, y)]))
+
+    assert pde_separate_mul(eq, F(x, y, z), [Y(y), u(x, z)]) == \
+        [D(Y(y), y)/Y(y), -D(u(x, z), x)/u(x, z) - D(u(x, z), z)/u(x, z)]
+    assert pde_separate_mul(eq, F(x, y, z), [X(x), Y(y), Z(z)]) == \
+        [D(X(x), x)/X(x), -D(Z(z), z)/Z(z) - D(Y(y), y)/Y(y)]
+
+    # wave equation
+    wave = Eq(D(u(x, t), t, t), c**2*D(u(x, t), x, x))
+    res = pde_separate_mul(wave, u(x, t), [X(x), T(t)])
+    assert res == [D(X(x), x, x)/X(x), D(T(t), t, t)/(c**2*T(t))]
+
+    # Laplace equation in cylindrical coords
+    eq = Eq(1/r * D(Phi(r, theta, z), r) + D(Phi(r, theta, z), r, 2) +
+            1/r**2 * D(Phi(r, theta, z), theta, 2) + D(Phi(r, theta, z), z, 2), 0)
+    # Separate z
+    res = pde_separate_mul(eq, Phi(r, theta, z), [Z(z), u(theta, r)])
+    assert res == [D(Z(z), z, z)/Z(z),
+            -D(u(theta, r), r, r)/u(theta, r) -
+        D(u(theta, r), r)/(r*u(theta, r)) -
+        D(u(theta, r), theta, theta)/(r**2*u(theta, r))]
+    # Lets use the result to create a new equation...
+    eq = Eq(res[1], c)
+    # ...and separate theta...
+    res = pde_separate_mul(eq, u(theta, r), [T(theta), R(r)])
+    assert res == [D(T(theta), theta, theta)/T(theta),
+            -r*D(R(r), r)/R(r) - r**2*D(R(r), r, r)/R(r) - c*r**2]
+    # ...or r...
+    res = pde_separate_mul(eq, u(theta, r), [R(r), T(theta)])
+    assert res == [r*D(R(r), r)/R(r) + r**2*D(R(r), r, r)/R(r) + c*r**2,
+            -D(T(theta), theta, theta)/T(theta)]
+
+
+def test_issue_11726():
+    x, t = symbols("x t")
+    f  = symbols("f", cls=Function)
+    X, T = symbols("X T", cls=Function)
+
+    u = f(x, t)
+    eq = u.diff(x, 2) - u.diff(t, 2)
+    res = pde_separate(eq, u, [T(x), X(t)])
+    assert res == [D(T(x), x, x)/T(x),D(X(t), t, t)/X(t)]
+
+
+def test_pde_classify():
+    # When more number of hints are added, add tests for classifying here.
+    f = Function('f')
+    eq1 = a*f(x,y) + b*f(x,y).diff(x) + c*f(x,y).diff(y)
+    eq2 = 3*f(x,y) + 2*f(x,y).diff(x) + f(x,y).diff(y)
+    eq3 = a*f(x,y) + b*f(x,y).diff(x) + 2*f(x,y).diff(y)
+    eq4 = x*f(x,y) + f(x,y).diff(x) + 3*f(x,y).diff(y)
+    eq5 = x**2*f(x,y) + x*f(x,y).diff(x) + x*y*f(x,y).diff(y)
+    eq6 = y*x**2*f(x,y) + y*f(x,y).diff(x) + f(x,y).diff(y)
+    for eq in [eq1, eq2, eq3]:
+        assert classify_pde(eq) == ('1st_linear_constant_coeff_homogeneous',)
+    for eq in [eq4, eq5, eq6]:
+        assert classify_pde(eq) == ('1st_linear_variable_coeff',)
+
+
+def test_checkpdesol():
+    f, F = map(Function, ['f', 'F'])
+    eq1 = a*f(x,y) + b*f(x,y).diff(x) + c*f(x,y).diff(y)
+    eq2 = 3*f(x,y) + 2*f(x,y).diff(x) + f(x,y).diff(y)
+    eq3 = a*f(x,y) + b*f(x,y).diff(x) + 2*f(x,y).diff(y)
+    for eq in [eq1, eq2, eq3]:
+        assert checkpdesol(eq, pdsolve(eq))[0]
+    eq4 = x*f(x,y) + f(x,y).diff(x) + 3*f(x,y).diff(y)
+    eq5 = 2*f(x,y) + 1*f(x,y).diff(x) + 3*f(x,y).diff(y)
+    eq6 = f(x,y) + 1*f(x,y).diff(x) + 3*f(x,y).diff(y)
+    assert checkpdesol(eq4, [pdsolve(eq5), pdsolve(eq6)]) == [
+        (False, (x - 2)*F(3*x - y)*exp(-x/S(5) - 3*y/S(5))),
+         (False, (x - 1)*F(3*x - y)*exp(-x/S(10) - 3*y/S(10)))]
+    for eq in [eq4, eq5, eq6]:
+        assert checkpdesol(eq, pdsolve(eq))[0]
+    sol = pdsolve(eq4)
+    sol4 = Eq(sol.lhs - sol.rhs, 0)
+    raises(NotImplementedError, lambda:
+        checkpdesol(eq4, sol4, solve_for_func=False))
+
+
+def test_solvefun():
+    f, F, G, H = map(Function, ['f', 'F', 'G', 'H'])
+    eq1 = f(x,y) + f(x,y).diff(x) + f(x,y).diff(y)
+    assert pdsolve(eq1) == Eq(f(x, y), F(x - y)*exp(-x/2 - y/2))
+    assert pdsolve(eq1, solvefun=G) == Eq(f(x, y), G(x - y)*exp(-x/2 - y/2))
+    assert pdsolve(eq1, solvefun=H) == Eq(f(x, y), H(x - y)*exp(-x/2 - y/2))
+
+
+def test_pde_1st_linear_constant_coeff_homogeneous():
+    f, F = map(Function, ['f', 'F'])
+    u = f(x, y)
+    eq = 2*u + u.diff(x) + u.diff(y)
+    assert classify_pde(eq) == ('1st_linear_constant_coeff_homogeneous',)
+    sol = pdsolve(eq)
+    assert sol == Eq(u, F(x - y)*exp(-x - y))
+    assert checkpdesol(eq, sol)[0]
+
+    eq = 4 + (3*u.diff(x)/u) + (2*u.diff(y)/u)
+    assert classify_pde(eq) == ('1st_linear_constant_coeff_homogeneous',)
+    sol = pdsolve(eq)
+    assert sol == Eq(u, F(2*x - 3*y)*exp(-S(12)*x/13 - S(8)*y/13))
+    assert checkpdesol(eq, sol)[0]
+
+    eq = u + (6*u.diff(x)) + (7*u.diff(y))
+    assert classify_pde(eq) == ('1st_linear_constant_coeff_homogeneous',)
+    sol = pdsolve(eq)
+    assert sol == Eq(u, F(7*x - 6*y)*exp(-6*x/S(85) - 7*y/S(85)))
+    assert checkpdesol(eq, sol)[0]
+
+    eq = a*u + b*u.diff(x) + c*u.diff(y)
+    sol = pdsolve(eq)
+    assert checkpdesol(eq, sol)[0]
+
+
+def test_pde_1st_linear_constant_coeff():
+    f, F = map(Function, ['f', 'F'])
+    u = f(x,y)
+    eq = -2*u.diff(x) + 4*u.diff(y) + 5*u - exp(x + 3*y)
+    sol = pdsolve(eq)
+    assert sol == Eq(f(x,y),
+    (F(4*x + 2*y)*exp(x/2) + exp(x + 4*y)/15)*exp(-y))
+    assert classify_pde(eq) == ('1st_linear_constant_coeff',
+    '1st_linear_constant_coeff_Integral')
+    assert checkpdesol(eq, sol)[0]
+
+    eq = (u.diff(x)/u) + (u.diff(y)/u) + 1 - (exp(x + y)/u)
+    sol = pdsolve(eq)
+    assert sol == Eq(f(x, y), F(x - y)*exp(-x/2 - y/2) + exp(x + y)/3)
+    assert classify_pde(eq) == ('1st_linear_constant_coeff',
+    '1st_linear_constant_coeff_Integral')
+    assert checkpdesol(eq, sol)[0]
+
+    eq = 2*u + -u.diff(x) + 3*u.diff(y) + sin(x)
+    sol = pdsolve(eq)
+    assert sol == Eq(f(x, y),
+         F(3*x + y)*exp(x/5 - 3*y/5) - 2*sin(x)/5 - cos(x)/5)
+    assert classify_pde(eq) == ('1st_linear_constant_coeff',
+    '1st_linear_constant_coeff_Integral')
+    assert checkpdesol(eq, sol)[0]
+
+    eq = u + u.diff(x) + u.diff(y) + x*y
+    sol = pdsolve(eq)
+    assert sol.expand() == Eq(f(x, y),
+        x + y + (x - y)**2/4 - (x + y)**2/4 + F(x - y)*exp(-x/2 - y/2) - 2).expand()
+    assert classify_pde(eq) == ('1st_linear_constant_coeff',
+    '1st_linear_constant_coeff_Integral')
+    assert checkpdesol(eq, sol)[0]
+    eq = u + u.diff(x) + u.diff(y) + log(x)
+    assert classify_pde(eq) == ('1st_linear_constant_coeff',
+    '1st_linear_constant_coeff_Integral')
+
+
+def test_pdsolve_all():
+    f, F = map(Function, ['f', 'F'])
+    u = f(x,y)
+    eq = u + u.diff(x) + u.diff(y) + x**2*y
+    sol = pdsolve(eq, hint = 'all')
+    keys = ['1st_linear_constant_coeff',
+        '1st_linear_constant_coeff_Integral', 'default', 'order']
+    assert sorted(sol.keys()) == keys
+    assert sol['order'] == 1
+    assert sol['default'] == '1st_linear_constant_coeff'
+    assert sol['1st_linear_constant_coeff'].expand() == Eq(f(x, y),
+        -x**2*y + x**2 + 2*x*y - 4*x - 2*y + F(x - y)*exp(-x/2 - y/2) + 6).expand()
+
+
+def test_pdsolve_variable_coeff():
+    f, F = map(Function, ['f', 'F'])
+    u = f(x, y)
+    eq = x*(u.diff(x)) - y*(u.diff(y)) + y**2*u - y**2
+    sol = pdsolve(eq, hint="1st_linear_variable_coeff")
+    assert sol == Eq(u, F(x*y)*exp(y**2/2) + 1)
+    assert checkpdesol(eq, sol)[0]
+
+    eq = x**2*u + x*u.diff(x) + x*y*u.diff(y)
+    sol = pdsolve(eq, hint='1st_linear_variable_coeff')
+    assert sol == Eq(u, F(y*exp(-x))*exp(-x**2/2))
+    assert checkpdesol(eq, sol)[0]
+
+    eq = y*x**2*u + y*u.diff(x) + u.diff(y)
+    sol = pdsolve(eq, hint='1st_linear_variable_coeff')
+    assert sol == Eq(u, F(-2*x + y**2)*exp(-x**3/3))
+    assert checkpdesol(eq, sol)[0]
+
+    eq = exp(x)**2*(u.diff(x)) + y
+    sol = pdsolve(eq, hint='1st_linear_variable_coeff')
+    assert sol == Eq(u, y*exp(-2*x)/2 + F(y))
+    assert checkpdesol(eq, sol)[0]
+
+    eq = exp(2*x)*(u.diff(y)) + y*u - u
+    sol = pdsolve(eq, hint='1st_linear_variable_coeff')
+    assert sol == Eq(u, F(x)*exp(-y*(y - 2)*exp(-2*x)/2))
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/tests/test_polysys.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/tests/test_polysys.py
new file mode 100644
index 0000000000000000000000000000000000000000..a119591a0354ba377a18767eae6e8b7812810a0d
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/tests/test_polysys.py
@@ -0,0 +1,462 @@
+"""Tests for solvers of systems of polynomial equations. """
+from sympy.polys.domains import  ZZ, QQ_I
+from sympy.core.numbers import (I, Integer, Rational)
+from sympy.core.singleton import S
+from sympy.core.symbol import symbols
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.polys.domains.rationalfield import QQ
+from sympy.polys.polyerrors import UnsolvableFactorError
+from sympy.polys.polyoptions import Options
+from sympy.polys.polytools import Poly
+from sympy.polys.rootoftools import CRootOf
+from sympy.solvers.solvers import solve
+from sympy.utilities.iterables import flatten
+from sympy.abc import a, b, c, x, y, z
+from sympy.polys import PolynomialError
+from sympy.solvers.polysys import (solve_poly_system,
+                                   solve_triangulated,
+                                   solve_biquadratic, SolveFailed,
+                                   solve_generic, factor_system_bool,
+                                   factor_system_cond, factor_system_poly,
+                                   factor_system, _factor_sets, _factor_sets_slow)
+from sympy.polys.polytools import parallel_poly_from_expr
+from sympy.testing.pytest import raises
+from sympy.core.relational import Eq
+from sympy.functions.elementary.trigonometric import sin, cos
+
+from sympy.functions.elementary.exponential import exp
+
+
+def test_solve_poly_system():
+    assert solve_poly_system([x - 1], x) == [(S.One,)]
+
+    assert solve_poly_system([y - x, y - x - 1], x, y) is None
+
+    assert solve_poly_system([y - x**2, y + x**2], x, y) == [(S.Zero, S.Zero)]
+
+    assert solve_poly_system([2*x - 3, y*Rational(3, 2) - 2*x, z - 5*y], x, y, z) == \
+        [(Rational(3, 2), Integer(2), Integer(10))]
+
+    assert solve_poly_system([x*y - 2*y, 2*y**2 - x**2], x, y) == \
+        [(0, 0), (2, -sqrt(2)), (2, sqrt(2))]
+
+    assert solve_poly_system([y - x**2, y + x**2 + 1], x, y) == \
+        [(-I*sqrt(S.Half), Rational(-1, 2)), (I*sqrt(S.Half), Rational(-1, 2))]
+
+    f_1 = x**2 + y + z - 1
+    f_2 = x + y**2 + z - 1
+    f_3 = x + y + z**2 - 1
+
+    a, b = sqrt(2) - 1, -sqrt(2) - 1
+
+    assert solve_poly_system([f_1, f_2, f_3], x, y, z) == \
+        [(0, 0, 1), (0, 1, 0), (1, 0, 0), (a, a, a), (b, b, b)]
+
+    solution = [(1, -1), (1, 1)]
+
+    assert solve_poly_system([Poly(x**2 - y**2), Poly(x - 1)]) == solution
+    assert solve_poly_system([x**2 - y**2, x - 1], x, y) == solution
+    assert solve_poly_system([x**2 - y**2, x - 1]) == solution
+
+    assert solve_poly_system(
+        [x + x*y - 3, y + x*y - 4], x, y) == [(-3, -2), (1, 2)]
+
+    raises(NotImplementedError, lambda: solve_poly_system([x**3 - y**3], x, y))
+    raises(NotImplementedError, lambda: solve_poly_system(
+        [z, -2*x*y**2 + x + y**2*z, y**2*(-z - 4) + 2]))
+    raises(PolynomialError, lambda: solve_poly_system([1/x], x))
+
+    raises(NotImplementedError, lambda: solve_poly_system(
+          [x-1,], (x, y)))
+    raises(NotImplementedError, lambda: solve_poly_system(
+          [y-1,], (x, y)))
+
+    # solve_poly_system should ideally construct solutions using
+    # CRootOf for the following four tests
+    assert solve_poly_system([x**5 - x + 1], [x], strict=False) == []
+    raises(UnsolvableFactorError, lambda: solve_poly_system(
+        [x**5 - x + 1], [x], strict=True))
+
+    assert solve_poly_system([(x - 1)*(x**5 - x + 1), y**2 - 1], [x, y],
+                             strict=False) == [(1, -1), (1, 1)]
+    raises(UnsolvableFactorError,
+           lambda: solve_poly_system([(x - 1)*(x**5 - x + 1), y**2-1],
+                                     [x, y], strict=True))
+
+
+def test_solve_generic():
+    NewOption = Options((x, y), {'domain': 'ZZ'})
+    assert solve_generic([x**2 - 2*y**2, y**2 - y + 1], NewOption) == \
+           [(-sqrt(-1 - sqrt(3)*I), Rational(1, 2) - sqrt(3)*I/2),
+            (sqrt(-1 - sqrt(3)*I), Rational(1, 2) - sqrt(3)*I/2),
+            (-sqrt(-1 + sqrt(3)*I), Rational(1, 2) + sqrt(3)*I/2),
+            (sqrt(-1 + sqrt(3)*I), Rational(1, 2) + sqrt(3)*I/2)]
+
+    # solve_generic should ideally construct solutions using
+    # CRootOf for the following two tests
+    assert solve_generic(
+        [2*x - y, (y - 1)*(y**5 - y + 1)], NewOption, strict=False) == \
+        [(Rational(1, 2), 1)]
+    raises(UnsolvableFactorError, lambda: solve_generic(
+        [2*x - y, (y - 1)*(y**5 - y + 1)], NewOption, strict=True))
+
+
+def test_solve_biquadratic():
+    x0, y0, x1, y1, r = symbols('x0 y0 x1 y1 r')
+
+    f_1 = (x - 1)**2 + (y - 1)**2 - r**2
+    f_2 = (x - 2)**2 + (y - 2)**2 - r**2
+    s = sqrt(2*r**2 - 1)
+    a = (3 - s)/2
+    b = (3 + s)/2
+    assert solve_poly_system([f_1, f_2], x, y) == [(a, b), (b, a)]
+
+    f_1 = (x - 1)**2 + (y - 2)**2 - r**2
+    f_2 = (x - 1)**2 + (y - 1)**2 - r**2
+
+    assert solve_poly_system([f_1, f_2], x, y) == \
+        [(1 - sqrt((2*r - 1)*(2*r + 1))/2, Rational(3, 2)),
+         (1 + sqrt((2*r - 1)*(2*r + 1))/2, Rational(3, 2))]
+
+    query = lambda expr: expr.is_Pow and expr.exp is S.Half
+
+    f_1 = (x - 1 )**2 + (y - 2)**2 - r**2
+    f_2 = (x - x1)**2 + (y - 1)**2 - r**2
+
+    result = solve_poly_system([f_1, f_2], x, y)
+
+    assert len(result) == 2 and all(len(r) == 2 for r in result)
+    assert all(r.count(query) == 1 for r in flatten(result))
+
+    f_1 = (x - x0)**2 + (y - y0)**2 - r**2
+    f_2 = (x - x1)**2 + (y - y1)**2 - r**2
+
+    result = solve_poly_system([f_1, f_2], x, y)
+
+    assert len(result) == 2 and all(len(r) == 2 for r in result)
+    assert all(len(r.find(query)) == 1 for r in flatten(result))
+
+    s1 = (x*y - y, x**2 - x)
+    assert solve(s1) == [{x: 1}, {x: 0, y: 0}]
+    s2 = (x*y - x, y**2 - y)
+    assert solve(s2) == [{y: 1}, {x: 0, y: 0}]
+    gens = (x, y)
+    for seq in (s1, s2):
+        (f, g), opt = parallel_poly_from_expr(seq, *gens)
+        raises(SolveFailed, lambda: solve_biquadratic(f, g, opt))
+    seq = (x**2 + y**2 - 2, y**2 - 1)
+    (f, g), opt = parallel_poly_from_expr(seq, *gens)
+    assert solve_biquadratic(f, g, opt) == [
+        (-1, -1), (-1, 1), (1, -1), (1, 1)]
+    ans = [(0, -1), (0, 1)]
+    seq = (x**2 + y**2 - 1, y**2 - 1)
+    (f, g), opt = parallel_poly_from_expr(seq, *gens)
+    assert solve_biquadratic(f, g, opt) == ans
+    seq = (x**2 + y**2 - 1, x**2 - x + y**2 - 1)
+    (f, g), opt = parallel_poly_from_expr(seq, *gens)
+    assert solve_biquadratic(f, g, opt) == ans
+
+
+def test_solve_triangulated():
+    f_1 = x**2 + y + z - 1
+    f_2 = x + y**2 + z - 1
+    f_3 = x + y + z**2 - 1
+
+    a, b = sqrt(2) - 1, -sqrt(2) - 1
+
+    assert solve_triangulated([f_1, f_2, f_3], x, y, z) == \
+        [(0, 0, 1), (0, 1, 0), (1, 0, 0)]
+
+    dom = QQ.algebraic_field(sqrt(2))
+
+    assert solve_triangulated([f_1, f_2, f_3], x, y, z, domain=dom) == \
+        [(0, 0, 1), (0, 1, 0), (1, 0, 0), (a, a, a), (b, b, b)]
+
+    a, b = CRootOf(z**2 + 2*z - 1, 0), CRootOf(z**2 + 2*z - 1, 1)
+    assert solve_triangulated([f_1, f_2, f_3], x, y, z, extension=True) == \
+        [(0, 0, 1), (0, 1, 0), (1, 0, 0), (a, a, a), (b, b, b)]
+
+
+def test_solve_issue_3686():
+    roots = solve_poly_system([((x - 5)**2/250000 + (y - Rational(5, 10))**2/250000) - 1, x], x, y)
+    assert roots == [(0, S.Half - 15*sqrt(1111)), (0, S.Half + 15*sqrt(1111))]
+
+    roots = solve_poly_system([((x - 5)**2/250000 + (y - 5.0/10)**2/250000) - 1, x], x, y)
+    # TODO: does this really have to be so complicated?!
+    assert len(roots) == 2
+    assert roots[0][0] == 0
+    assert roots[0][1].epsilon_eq(-499.474999374969, 1e12)
+    assert roots[1][0] == 0
+    assert roots[1][1].epsilon_eq(500.474999374969, 1e12)
+
+
+def test_factor_system():
+
+    assert factor_system([x**2 + 2*x + 1]) ==  [[x + 1]]
+    assert factor_system([x**2 + 2*x + 1, y**2 + 2*y + 1]) ==  [[x + 1, y + 1]]
+    assert factor_system([x**2 + 1]) ==  [[x**2 + 1]]
+    assert factor_system([]) == [[]]
+
+    assert factor_system([x**2 + y**2 + 2*x*y, x**2 - 2], extension=sqrt(2)) == [
+        [x + y, x + sqrt(2)],
+        [x + y, x - sqrt(2)],
+    ]
+
+    assert factor_system([x**2 + 1, y**2 + 1], gaussian=True) == [
+        [x + I, y + I],
+        [x + I, y - I],
+        [x - I, y + I],
+        [x - I, y - I],
+    ]
+
+    assert factor_system([x**2 + 1, y**2 + 1], domain=QQ_I) == [
+        [x + I, y + I],
+        [x + I, y - I],
+        [x - I, y + I],
+        [x - I, y - I],
+    ]
+
+    assert factor_system([0]) == [[]]
+    assert factor_system([1]) == []
+    assert factor_system([0 , x]) == [[x]]
+    assert factor_system([1, 0, x]) == []
+
+    assert factor_system([x**4 - 1, y**6 - 1]) == [
+        [x**2 + 1, y**2 + y + 1],
+        [x**2 + 1, y**2 - y + 1],
+        [x**2 + 1, y + 1],
+        [x**2 + 1, y - 1],
+        [x + 1, y**2 + y + 1],
+        [x + 1, y**2 - y + 1],
+        [x - 1, y**2 + y + 1],
+        [x - 1, y**2 - y + 1],
+        [x + 1, y + 1],
+        [x + 1, y - 1],
+        [x - 1, y + 1],
+        [x - 1, y - 1],
+    ]
+
+    assert factor_system([(x - 1)*(y - 2), (y - 2)*(z - 3)]) == [
+        [x - 1, z - 3],
+        [y - 2]
+    ]
+
+    assert factor_system([sin(x)**2 + cos(x)**2 - 1, x]) == [
+        [x, sin(x)**2 + cos(x)**2 - 1],
+    ]
+
+    assert factor_system([sin(x)**2 + cos(x)**2 - 1]) == [
+        [sin(x)**2 + cos(x)**2 - 1]
+    ]
+
+    assert factor_system([sin(x)**2 + cos(x)**2]) == [
+        [sin(x)**2 + cos(x)**2]
+    ]
+
+    assert factor_system([a*x, y, a]) == [[y, a]]
+
+    assert factor_system([a*x, y, a], [x, y]) == []
+
+    assert factor_system([a ** 2 * x, y], [x, y]) == [[x, y]]
+
+    assert factor_system([a*x*(x - 1), b*y, c], [x, y]) == []
+
+    assert factor_system([a*x*(x - 1), b*y, c], [x, y, c]) == [
+        [x - 1, y, c],
+        [x, y, c],
+    ]
+
+    assert factor_system([a*x*(x - 1), b*y, c]) == [
+        [x - 1, y, c],
+        [x, y, c],
+        [x - 1, b, c],
+        [x, b, c],
+        [y, a, c],
+        [a, b, c],
+    ]
+
+    assert factor_system([x**2 - 2], [y]) == []
+
+    assert factor_system([x**2 - 2], [x]) == [[x**2 - 2]]
+
+    assert factor_system([cos(x)**2 - sin(x)**2, cos(x)**2 + sin(x)**2 - 1]) == [
+        [sin(x)**2 + cos(x)**2 - 1, sin(x) + cos(x)],
+        [sin(x)**2 + cos(x)**2 - 1, -sin(x) + cos(x)],
+    ]
+
+    assert factor_system([(cos(x) + sin(x))**2 - 1, cos(x)**2 - sin(x)**2 - cos(2*x)]) == [
+        [sin(x)**2 - cos(x)**2 + cos(2*x), sin(x) + cos(x) + 1],
+        [sin(x)**2 - cos(x)**2 + cos(2*x), sin(x) + cos(x) - 1],
+    ]
+
+    assert factor_system([(cos(x) + sin(x))*exp(y) - 1, (cos(x) - sin(x))*exp(y) - 1]) == [
+        [exp(y)*sin(x) + exp(y)*cos(x) - 1, -exp(y)*sin(x) + exp(y)*cos(x) - 1]
+    ]
+
+
+def test_factor_system_poly():
+
+    px = lambda e: Poly(e, x)
+    pxab = lambda e: Poly(e, x, domain=ZZ[a, b])
+    pxI = lambda e: Poly(e, x, domain=QQ_I)
+    pxyz = lambda e: Poly(e, (x, y, z))
+
+    assert factor_system_poly([px(x**2 - 1), px(x**2 - 4)]) == [
+        [px(x + 2), px(x + 1)],
+        [px(x + 2), px(x - 1)],
+        [px(x + 1), px(x - 2)],
+        [px(x - 1), px(x - 2)],
+    ]
+
+    assert factor_system_poly([px(x**2 - 1)]) == [[px(x + 1)], [px(x - 1)]]
+
+    assert factor_system_poly([pxyz(x**2*y - y), pxyz(x**2*z - z)]) == [
+        [pxyz(x + 1)],
+        [pxyz(x - 1)],
+        [pxyz(y), pxyz(z)],
+    ]
+
+    assert factor_system_poly([px(x**2*(x - 1)**2), px(x*(x - 1))]) == [
+        [px(x)],
+        [px(x - 1)],
+    ]
+
+    assert factor_system_poly([pxyz(x**2 + y*x), pxyz(x**2 + z*x)]) == [
+        [pxyz(x + y), pxyz(x + z)],
+        [pxyz(x)],
+    ]
+
+    assert factor_system_poly([pxab((a - 1)*(x - 2)), pxab((b - 3)*(x - 2))]) == [
+        [pxab(x - 2)],
+        [pxab(a - 1), pxab(b - 3)],
+    ]
+
+    assert factor_system_poly([pxI(x**2 + 1)]) == [[pxI(x + I)], [pxI(x - I)]]
+
+    assert factor_system_poly([]) == [[]]
+
+    assert factor_system_poly([px(1)]) == []
+    assert factor_system_poly([px(0), px(x)]) == [[px(x)]]
+
+
+def test_factor_system_cond():
+
+    assert factor_system_cond([x ** 2 - 1, x ** 2 - 4]) == [
+        [x + 2, x + 1],
+        [x + 2, x - 1],
+        [x + 1, x - 2],
+        [x - 1, x - 2],
+    ]
+
+    assert factor_system_cond([1]) == []
+    assert factor_system_cond([0]) == [[]]
+    assert factor_system_cond([1, x]) == []
+    assert factor_system_cond([0, x]) == [[x]]
+    assert factor_system_cond([]) == [[]]
+
+    assert factor_system_cond([x**2 + y*x]) == [[x + y], [x]]
+
+    assert factor_system_cond([(a - 1)*(x - 2), (b - 3)*(x - 2)], [x]) == [
+        [x - 2],
+        [a - 1, b - 3],
+    ]
+
+    assert factor_system_cond([a * (x - 1), b], [x]) == [[x - 1, b], [a, b]]
+
+    assert factor_system_cond([a*x*(x-1), b*y, c], [x, y]) == [
+        [x - 1, y, c],
+        [x, y, c],
+        [x - 1, b, c],
+        [x, b, c],
+        [y, a, c],
+        [a, b, c],
+    ]
+
+    assert factor_system_cond([x*(x-1), y], [x, y]) == [[x - 1, y], [x, y]]
+
+    assert factor_system_cond([a*x, y, a], [x, y]) == [[y, a]]
+
+    assert factor_system_cond([a*x, b*x], [x, y]) == [[x], [a, b]]
+
+    assert factor_system_cond([a*b*x, y], [x, y]) == [[x, y], [y, a*b]]
+
+    assert factor_system_cond([a*b*x, y]) == [[x, y], [y, a], [y, b]]
+
+    assert factor_system_cond([a**2*x, y], [x, y]) == [[x, y], [y, a]]
+
+def test_factor_system_bool():
+
+    eqs = [a*(x - 1)*(y - 1), b*(x - 2)*(y - 1)*(y - 2)]
+    assert factor_system_bool(eqs, [x, y]) == (
+        Eq(y - 1, 0)
+        | (Eq(a, 0) & Eq(b, 0))
+        | (Eq(a, 0) & Eq(x - 2, 0))
+        | (Eq(a, 0) & Eq(y - 2, 0))
+        | (Eq(b, 0) & Eq(x - 1, 0))
+        | (Eq(x - 2, 0) & Eq(x - 1, 0))
+        | (Eq(x - 1, 0) & Eq(y - 2, 0))
+    )
+
+    assert factor_system_bool([x - 1], [x]) == Eq(x - 1, 0)
+
+    assert factor_system_bool([(x - 1)*(x - 2)], [x]) == Eq(x - 2, 0) | Eq(x - 1, 0)
+
+    assert factor_system_bool([], [x]) == True
+    assert factor_system_bool([0], [x]) == True
+    assert factor_system_bool([1], [x]) == False
+    assert factor_system_bool([a], [x]) == Eq(a, 0)
+
+    assert factor_system_bool([a * x, y, a], [x, y]) == Eq(a, 0) & Eq(y, 0)
+
+    assert (factor_system_bool([a*x, b*y*x, a], [x, y]) == (
+        Eq(a, 0) & Eq(b, 0))
+        | (Eq(a, 0) & Eq(x, 0))
+        | (Eq(a, 0) & Eq(y, 0)))
+
+    assert (factor_system_bool([a*x, b*x], [x, y]) == Eq(x, 0) |
+            (Eq(a, 0) & Eq(b, 0)))
+
+    assert (factor_system_bool([a*b*x, y], [x, y]) == (
+        Eq(x, 0) & Eq(y, 0)) |
+        (Eq(y, 0) & Eq(a*b, 0)))
+
+    assert (factor_system_bool([a**2*x, y], [x, y]) == (
+        Eq(a, 0) & Eq(y, 0)) |
+        (Eq(x, 0) & Eq(y, 0)))
+
+    assert factor_system_bool([a*x*y, b*y*z], [x, y, z]) == (
+        Eq(y, 0)
+        | (Eq(a, 0) & Eq(b, 0))
+        | (Eq(a, 0) & Eq(z, 0))
+        | (Eq(b, 0) & Eq(x, 0))
+        | (Eq(x, 0) & Eq(z, 0))
+    )
+
+    assert factor_system_bool([a*(x - 1), b], [x]) == (
+        (Eq(a, 0) & Eq(b, 0))
+        | (Eq(x - 1, 0) & Eq(b, 0))
+    )
+
+
+def test_factor_sets():
+    #
+    from random import randint
+
+    def generate_random_system(n_eqs=3, n_factors=2, max_val=10):
+        return [
+            [randint(0, max_val) for _ in range(randint(1, n_factors))]
+            for _ in range(n_eqs)
+        ]
+
+    test_cases = [
+        [[1, 2], [1, 3]],
+        [[1, 2], [3, 4]],
+        [[1], [1, 2], [2]],
+    ]
+
+    for case in test_cases:
+        assert _factor_sets(case) == _factor_sets_slow(case)
+
+    for _ in range(100):
+        system = generate_random_system()
+        assert _factor_sets(system) == _factor_sets_slow(system)
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/tests/test_recurr.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/tests/test_recurr.py
new file mode 100644
index 0000000000000000000000000000000000000000..5a6306b51a5cf33ccd9fae131430a24690d540a7
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/tests/test_recurr.py
@@ -0,0 +1,295 @@
+from sympy.core.function import (Function, Lambda, expand)
+from sympy.core.numbers import (I, Rational)
+from sympy.core.relational import Eq
+from sympy.core.singleton import S
+from sympy.core.symbol import (Symbol, symbols)
+from sympy.functions.combinatorial.factorials import (rf, binomial, factorial)
+from sympy.functions.elementary.complexes import Abs
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import (cos, sin)
+from sympy.polys.polytools import factor
+from sympy.solvers.recurr import rsolve, rsolve_hyper, rsolve_poly, rsolve_ratio
+from sympy.testing.pytest import raises, slow, XFAIL
+from sympy.abc import a, b
+
+y = Function('y')
+n, k = symbols('n,k', integer=True)
+C0, C1, C2 = symbols('C0,C1,C2')
+
+
+def test_rsolve_poly():
+    assert rsolve_poly([-1, -1, 1], 0, n) == 0
+    assert rsolve_poly([-1, -1, 1], 1, n) == -1
+
+    assert rsolve_poly([-1, n + 1], n, n) == 1
+    assert rsolve_poly([-1, 1], n, n) == C0 + (n**2 - n)/2
+    assert rsolve_poly([-n - 1, n], 1, n) == C0*n - 1
+    assert rsolve_poly([-4*n - 2, 1], 4*n + 1, n) == -1
+
+    assert rsolve_poly([-1, 1], n**5 + n**3, n) == \
+        C0 - n**3 / 2 - n**5 / 2 + n**2 / 6 + n**6 / 6 + 2*n**4 / 3
+
+
+def test_rsolve_ratio():
+    solution = rsolve_ratio([-2*n**3 + n**2 + 2*n - 1, 2*n**3 + n**2 - 6*n,
+        -2*n**3 - 11*n**2 - 18*n - 9, 2*n**3 + 13*n**2 + 22*n + 8], 0, n)
+    assert solution == C0*(2*n - 3)/(n**2 - 1)/2
+
+
+def test_rsolve_hyper():
+    assert rsolve_hyper([-1, -1, 1], 0, n) in [
+        C0*(S.Half - S.Half*sqrt(5))**n + C1*(S.Half + S.Half*sqrt(5))**n,
+        C1*(S.Half - S.Half*sqrt(5))**n + C0*(S.Half + S.Half*sqrt(5))**n,
+    ]
+
+    assert rsolve_hyper([n**2 - 2, -2*n - 1, 1], 0, n) in [
+        C0*rf(sqrt(2), n) + C1*rf(-sqrt(2), n),
+        C1*rf(sqrt(2), n) + C0*rf(-sqrt(2), n),
+    ]
+
+    assert rsolve_hyper([n**2 - k, -2*n - 1, 1], 0, n) in [
+        C0*rf(sqrt(k), n) + C1*rf(-sqrt(k), n),
+        C1*rf(sqrt(k), n) + C0*rf(-sqrt(k), n),
+    ]
+
+    assert rsolve_hyper(
+        [2*n*(n + 1), -n**2 - 3*n + 2, n - 1], 0, n) == C1*factorial(n) + C0*2**n
+
+    assert rsolve_hyper(
+        [n + 2, -(2*n + 3)*(17*n**2 + 51*n + 39), n + 1], 0, n) == 0
+
+    assert rsolve_hyper([-n - 1, -1, 1], 0, n) == 0
+
+    assert rsolve_hyper([-1, 1], n, n).expand() == C0 + n**2/2 - n/2
+
+    assert rsolve_hyper([-1, 1], 1 + n, n).expand() == C0 + n**2/2 + n/2
+
+    assert rsolve_hyper([-1, 1], 3*(n + n**2), n).expand() == C0 + n**3 - n
+
+    assert rsolve_hyper([-a, 1],0,n).expand() == C0*a**n
+
+    assert rsolve_hyper([-a, 0, 1], 0, n).expand() == (-1)**n*C1*a**(n/2) + C0*a**(n/2)
+
+    assert rsolve_hyper([1, 1, 1], 0, n).expand() == \
+        C0*(Rational(-1, 2) - sqrt(3)*I/2)**n + C1*(Rational(-1, 2) + sqrt(3)*I/2)**n
+
+    assert rsolve_hyper([1, -2*n/a - 2/a, 1], 0, n) == 0
+
+
+@XFAIL
+def test_rsolve_ratio_missed():
+    # this arises during computation
+    # assert rsolve_hyper([-1, 1], 3*(n + n**2), n).expand() == C0 + n**3 - n
+    assert rsolve_ratio([-n, n + 2], n, n) is not None
+
+
+def recurrence_term(c, f):
+    """Compute RHS of recurrence in f(n) with coefficients in c."""
+    return sum(c[i]*f.subs(n, n + i) for i in range(len(c)))
+
+
+def test_rsolve_bulk():
+    """Some bulk-generated tests."""
+    funcs = [ n, n + 1, n**2, n**3, n**4, n + n**2, 27*n + 52*n**2 - 3*
+        n**3 + 12*n**4 - 52*n**5 ]
+    coeffs = [ [-2, 1], [-2, -1, 1], [-1, 1, 1, -1, 1], [-n, 1], [n**2 -
+        n + 12, 1] ]
+    for p in funcs:
+        # compute difference
+        for c in coeffs:
+            q = recurrence_term(c, p)
+            if p.is_polynomial(n):
+                assert rsolve_poly(c, q, n) == p
+            # See issue 3956:
+            if p.is_hypergeometric(n) and len(c) <= 3:
+                assert rsolve_hyper(c, q, n).subs(zip(symbols('C:3'), [0, 0, 0])).expand() == p
+
+
+def test_rsolve_0_sol_homogeneous():
+    # fixed by cherry-pick from
+    # https://github.com/diofant/diofant/commit/e1d2e52125199eb3df59f12e8944f8a5f24b00a5
+    assert rsolve_hyper([n**2 - n + 12, 1], n*(n**2 - n + 12) + n + 1, n) == n
+
+
+def test_rsolve():
+    f = y(n + 2) - y(n + 1) - y(n)
+    h = sqrt(5)*(S.Half + S.Half*sqrt(5))**n \
+        - sqrt(5)*(S.Half - S.Half*sqrt(5))**n
+
+    assert rsolve(f, y(n)) in [
+        C0*(S.Half - S.Half*sqrt(5))**n + C1*(S.Half + S.Half*sqrt(5))**n,
+        C1*(S.Half - S.Half*sqrt(5))**n + C0*(S.Half + S.Half*sqrt(5))**n,
+    ]
+
+    assert rsolve(f, y(n), [0, 5]) == h
+    assert rsolve(f, y(n), {0: 0, 1: 5}) == h
+    assert rsolve(f, y(n), {y(0): 0, y(1): 5}) == h
+    assert rsolve(y(n) - y(n - 1) - y(n - 2), y(n), [0, 5]) == h
+    assert rsolve(Eq(y(n), y(n - 1) + y(n - 2)), y(n), [0, 5]) == h
+
+    assert f.subs(y, Lambda(k, rsolve(f, y(n)).subs(n, k))).simplify() == 0
+
+    f = (n - 1)*y(n + 2) - (n**2 + 3*n - 2)*y(n + 1) + 2*n*(n + 1)*y(n)
+    g = C1*factorial(n) + C0*2**n
+    h = -3*factorial(n) + 3*2**n
+
+    assert rsolve(f, y(n)) == g
+    assert rsolve(f, y(n), []) == g
+    assert rsolve(f, y(n), {}) == g
+
+    assert rsolve(f, y(n), [0, 3]) == h
+    assert rsolve(f, y(n), {0: 0, 1: 3}) == h
+    assert rsolve(f, y(n), {y(0): 0, y(1): 3}) == h
+
+    assert f.subs(y, Lambda(k, rsolve(f, y(n)).subs(n, k))).simplify() == 0
+
+    f = y(n) - y(n - 1) - 2
+
+    assert rsolve(f, y(n), {y(0): 0}) == 2*n
+    assert rsolve(f, y(n), {y(0): 1}) == 2*n + 1
+    assert rsolve(f, y(n), {y(0): 0, y(1): 1}) is None
+
+    assert f.subs(y, Lambda(k, rsolve(f, y(n)).subs(n, k))).simplify() == 0
+
+    f = 3*y(n - 1) - y(n) - 1
+
+    assert rsolve(f, y(n), {y(0): 0}) == -3**n/2 + S.Half
+    assert rsolve(f, y(n), {y(0): 1}) == 3**n/2 + S.Half
+    assert rsolve(f, y(n), {y(0): 2}) == 3*3**n/2 + S.Half
+
+    assert f.subs(y, Lambda(k, rsolve(f, y(n)).subs(n, k))).simplify() == 0
+
+    f = y(n) - 1/n*y(n - 1)
+    assert rsolve(f, y(n)) == C0/factorial(n)
+    assert f.subs(y, Lambda(k, rsolve(f, y(n)).subs(n, k))).simplify() == 0
+
+    f = y(n) - 1/n*y(n - 1) - 1
+    assert rsolve(f, y(n)) is None
+
+    f = 2*y(n - 1) + (1 - n)*y(n)/n
+
+    assert rsolve(f, y(n), {y(1): 1}) == 2**(n - 1)*n
+    assert rsolve(f, y(n), {y(1): 2}) == 2**(n - 1)*n*2
+    assert rsolve(f, y(n), {y(1): 3}) == 2**(n - 1)*n*3
+
+    assert f.subs(y, Lambda(k, rsolve(f, y(n)).subs(n, k))).simplify() == 0
+
+    f = (n - 1)*(n - 2)*y(n + 2) - (n + 1)*(n + 2)*y(n)
+
+    assert rsolve(f, y(n), {y(3): 6, y(4): 24}) == n*(n - 1)*(n - 2)
+    assert rsolve(
+        f, y(n), {y(3): 6, y(4): -24}) == -n*(n - 1)*(n - 2)*(-1)**(n)
+
+    assert f.subs(y, Lambda(k, rsolve(f, y(n)).subs(n, k))).simplify() == 0
+
+    assert rsolve(Eq(y(n + 1), a*y(n)), y(n), {y(1): a}).simplify() == a**n
+
+    assert rsolve(y(n) - a*y(n-2),y(n), \
+            {y(1): sqrt(a)*(a + b), y(2): a*(a - b)}).simplify() == \
+            a**(n/2 + 1) - b*(-sqrt(a))**n
+
+    f = (-16*n**2 + 32*n - 12)*y(n - 1) + (4*n**2 - 12*n + 9)*y(n)
+
+    yn = rsolve(f, y(n), {y(1): binomial(2*n + 1, 3)})
+    sol = 2**(2*n)*n*(2*n - 1)**2*(2*n + 1)/12
+    assert factor(expand(yn, func=True)) == sol
+
+    sol = rsolve(y(n) + a*(y(n + 1) + y(n - 1))/2, y(n))
+    assert str(sol) == 'C0*((-sqrt(1 - a**2) - 1)/a)**n + C1*((sqrt(1 - a**2) - 1)/a)**n'
+
+    assert rsolve((k + 1)*y(k), y(k)) is None
+    assert (rsolve((k + 1)*y(k) + (k + 3)*y(k + 1) + (k + 5)*y(k + 2), y(k))
+            is None)
+
+    assert rsolve(y(n) + y(n + 1) + 2**n + 3**n, y(n)) == (-1)**n*C0 - 2**n/3 - 3**n/4
+
+
+def test_rsolve_raises():
+    x = Function('x')
+    raises(ValueError, lambda: rsolve(y(n) - y(k + 1), y(n)))
+    raises(ValueError, lambda: rsolve(y(n) - y(n + 1), x(n)))
+    raises(ValueError, lambda: rsolve(y(n) - x(n + 1), y(n)))
+    raises(ValueError, lambda: rsolve(y(n) - sqrt(n)*y(n + 1), y(n)))
+    raises(ValueError, lambda: rsolve(y(n) - y(n + 1), y(n), {x(0): 0}))
+    raises(ValueError, lambda: rsolve(y(n) + y(n + 1) + 2**n + cos(n), y(n)))
+
+
+def test_issue_6844():
+    f = y(n + 2) - y(n + 1) + y(n)/4
+    assert rsolve(f, y(n)) == 2**(-n + 1)*C1*n + 2**(-n)*C0
+    assert rsolve(f, y(n), {y(0): 0, y(1): 1}) == 2**(1 - n)*n
+
+
+def test_issue_18751():
+    r = Symbol('r', positive=True)
+    theta = Symbol('theta', real=True)
+    f = y(n) - 2 * r * cos(theta) * y(n - 1) + r**2 * y(n - 2)
+    assert rsolve(f, y(n)) == \
+        C0*(r*(cos(theta) - I*Abs(sin(theta))))**n + C1*(r*(cos(theta) + I*Abs(sin(theta))))**n
+
+
+def test_constant_naming():
+    #issue 8697
+    assert rsolve(y(n+3) - y(n+2) - y(n+1) + y(n), y(n)) == (-1)**n*C1 + C0 + C2*n
+    assert rsolve(y(n+3)+3*y(n+2)+3*y(n+1)+y(n), y(n)).expand() == (-1)**n*C0 - (-1)**n*C1*n - (-1)**n*C2*n**2
+    assert rsolve(y(n) - 2*y(n - 3) + 5*y(n - 2) - 4*y(n - 1),y(n),[1,3,8]) == 3*2**n - n - 2
+
+    #issue 19630
+    assert rsolve(y(n+3) - 3*y(n+1) + 2*y(n), y(n), {y(1):0, y(2):8, y(3):-2}) == (-2)**n + 2*n
+
+
+@slow
+def test_issue_15751():
+    f = y(n) + 21*y(n + 1) - 273*y(n + 2) - 1092*y(n + 3) + 1820*y(n + 4) + 1092*y(n + 5) - 273*y(n + 6) - 21*y(n + 7) + y(n + 8)
+    assert rsolve(f, y(n)) is not None
+
+
+def test_issue_17990():
+    f = -10*y(n) + 4*y(n + 1) + 6*y(n + 2) + 46*y(n + 3)
+    sol = rsolve(f, y(n))
+    expected = C0*((86*18**(S(1)/3)/69 + (-12 + (-1 + sqrt(3)*I)*(290412 +
+        3036*sqrt(9165))**(S(1)/3))*(1 - sqrt(3)*I)*(24201 + 253*sqrt(9165))**
+        (S(1)/3)/276)/((1 - sqrt(3)*I)*(24201 + 253*sqrt(9165))**(S(1)/3))
+        )**n + C1*((86*18**(S(1)/3)/69 + (-12 + (-1 - sqrt(3)*I)*(290412 + 3036
+        *sqrt(9165))**(S(1)/3))*(1 + sqrt(3)*I)*(24201 + 253*sqrt(9165))**
+        (S(1)/3)/276)/((1 + sqrt(3)*I)*(24201 + 253*sqrt(9165))**(S(1)/3))
+        )**n + C2*(-43*18**(S(1)/3)/(69*(24201 + 253*sqrt(9165))**(S(1)/3)) -
+        S(1)/23 + (290412 + 3036*sqrt(9165))**(S(1)/3)/138)**n
+    assert sol == expected
+    e = sol.subs({C0: 1, C1: 1, C2: 1, n: 1}).evalf()
+    assert abs(e + 0.130434782608696) < 1e-13
+
+
+def test_issue_8697():
+    a = Function('a')
+    eq = a(n + 3) - a(n + 2) - a(n + 1) + a(n)
+    assert rsolve(eq, a(n)) == (-1)**n*C1 + C0 + C2*n
+    eq2 = a(n + 3) + 3*a(n + 2) + 3*a(n + 1) + a(n)
+    assert (rsolve(eq2, a(n)) ==
+            (-1)**n*C0 + (-1)**(n + 1)*C1*n + (-1)**(n + 1)*C2*n**2)
+
+    assert rsolve(a(n) - 2*a(n - 3) + 5*a(n - 2) - 4*a(n - 1),
+                  a(n), {a(0): 1, a(1): 3, a(2): 8}) == 3*2**n - n - 2
+
+    # From issue thread (but fixed by https://github.com/diofant/diofant/commit/da9789c6cd7d0c2ceeea19fbf59645987125b289):
+    assert rsolve(a(n) - 2*a(n - 1) - n, a(n), {a(0): 1}) == 3*2**n - n - 2
+
+
+def test_diofantissue_294():
+    f = y(n) - y(n - 1) - 2*y(n - 2) - 2*n
+    assert rsolve(f, y(n)) == (-1)**n*C0 + 2**n*C1 - n - Rational(5, 2)
+    # issue sympy/sympy#11261
+    assert rsolve(f, y(n), {y(0): -1, y(1): 1}) == (-(-1)**n/2 + 2*2**n -
+                                                    n - Rational(5, 2))
+    # issue sympy/sympy#7055
+    assert rsolve(-2*y(n) + y(n + 1) + n - 1, y(n)) == 2**n*C0 + n
+
+
+def test_issue_15553():
+    f = Function("f")
+    assert rsolve(Eq(f(n), 2*f(n - 1) + n), f(n)) == 2**n*C0 - n - 2
+    assert rsolve(Eq(f(n + 1), 2*f(n) + n**2 + 1), f(n)) == 2**n*C0 - n**2 - 2*n - 4
+    assert rsolve(Eq(f(n + 1), 2*f(n) + n**2 + 1), f(n), {f(1): 0}) == 7*2**n/2 - n**2 - 2*n - 4
+    assert rsolve(Eq(f(n), 2*f(n - 1) + 3*n**2), f(n)) == 2**n*C0 - 3*n**2 - 12*n - 18
+    assert rsolve(Eq(f(n), 2*f(n - 1) + n**2), f(n)) == 2**n*C0 - n**2 - 4*n - 6
+    assert rsolve(Eq(f(n), 2*f(n - 1) + n), f(n), {f(0): 1}) == 3*2**n - n - 2
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/tests/test_simplex.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/tests/test_simplex.py
new file mode 100644
index 0000000000000000000000000000000000000000..611205f5df009a6d0de6e687501695b63bb932c9
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/tests/test_simplex.py
@@ -0,0 +1,254 @@
+from sympy.core.numbers import Rational
+from sympy.core.relational import Eq, Ne
+from sympy.core.symbol import symbols
+from sympy.core.sympify import sympify
+from sympy.core.singleton import S
+from sympy.core.random import random, choice
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.ntheory.generate import randprime
+from sympy.matrices.dense import Matrix
+from sympy.solvers.solveset import linear_eq_to_matrix
+from sympy.solvers.simplex import (_lp as lp, _primal_dual,
+    UnboundedLPError, InfeasibleLPError, lpmin, lpmax,
+    _m, _abcd, _simplex, linprog)
+
+from sympy.external.importtools import import_module
+
+from sympy.testing.pytest import raises
+
+from sympy.abc import x, y, z
+
+
+np = import_module("numpy")
+scipy = import_module("scipy")
+
+
+def test_lp():
+    r1 = y + 2*z <= 3
+    r2 = -x - 3*z <= -2
+    r3 = 2*x + y + 7*z <= 5
+    constraints = [r1, r2, r3, x >= 0, y >= 0, z >= 0]
+    objective = -x - y - 5 * z
+    ans = optimum, argmax = lp(max, objective, constraints)
+    assert ans == lpmax(objective, constraints)
+    assert objective.subs(argmax) == optimum
+    for constr in constraints:
+        assert constr.subs(argmax) == True
+
+    r1 = x - y + 2*z <= 3
+    r2 = -x + 2*y - 3*z <= -2
+    r3 = 2*x + y - 7*z <= -5
+    constraints = [r1, r2, r3, x >= 0, y >= 0, z >= 0]
+    objective = -x - y - 5*z
+    ans = optimum, argmax = lp(max, objective, constraints)
+    assert ans == lpmax(objective, constraints)
+    assert objective.subs(argmax) == optimum
+    for constr in constraints:
+        assert constr.subs(argmax) == True
+
+    r1 = x - y + 2*z <= -4
+    r2 = -x + 2*y - 3*z <= 8
+    r3 = 2*x + y - 7*z <= 10
+    constraints = [r1, r2, r3, x >= 0, y >= 0, z >= 0]
+    const = 2
+    objective = -x-y-5*z+const # has constant term
+    ans = optimum, argmax = lp(max, objective, constraints)
+    assert ans == lpmax(objective, constraints)
+    assert objective.subs(argmax) == optimum
+    for constr in constraints:
+        assert constr.subs(argmax) == True
+
+    # Section 4 Problem 1 from
+    # http://web.tecnico.ulisboa.pt/mcasquilho/acad/or/ftp/FergusonUCLA_LP.pdf
+    # answer on page 55
+    v = x1, x2, x3, x4 = symbols('x1 x2 x3 x4')
+    r1 = x1 - x2 - 2*x3 - x4 <= 4
+    r2 = 2*x1 + x3 -4*x4 <= 2
+    r3 = -2*x1 + x2 + x4 <= 1
+    objective, constraints = x1 - 2*x2 - 3*x3 - x4, [r1, r2, r3] + [
+        i >= 0 for i in v]
+    ans = optimum, argmax = lp(max, objective, constraints)
+    assert ans == lpmax(objective, constraints)
+    assert ans == (4, {x1: 7, x2: 0, x3: 0, x4: 3})
+
+    # input contains Floats
+    r1 = x - y + 2.0*z <= -4
+    r2 = -x + 2*y - 3.0*z <= 8
+    r3 = 2*x + y - 7*z <= 10
+    constraints = [r1, r2, r3] + [i >= 0 for i in (x, y, z)]
+    objective = -x-y-5*z
+    optimum, argmax = lp(max, objective, constraints)
+    assert objective.subs(argmax) == optimum
+    for constr in constraints:
+        assert constr.subs(argmax) == True
+
+    # input contains non-float or non-Rational
+    r1 = x - y + sqrt(2) * z <= -4
+    r2 = -x + 2*y - 3*z <= 8
+    r3 = 2*x + y - 7*z <= 10
+    raises(TypeError, lambda: lp(max, -x-y-5*z, [r1, r2, r3]))
+
+    r1 = x >= 0
+    raises(UnboundedLPError, lambda: lp(max, x, [r1]))
+    r2 = x <= -1
+    raises(InfeasibleLPError, lambda: lp(max, x, [r1, r2]))
+
+    # strict inequalities are not allowed
+    r1 = x > 0
+    raises(TypeError, lambda: lp(max, x, [r1]))
+
+    # not equals not allowed
+    r1 = Ne(x, 0)
+    raises(TypeError, lambda: lp(max, x, [r1]))
+
+    def make_random_problem(nvar=2, num_constraints=2, sparsity=.1):
+        def rand():
+            if random() < sparsity:
+                return sympify(0)
+            int1, int2 = [randprime(0, 200) for _ in range(2)]
+            return Rational(int1, int2)*choice([-1, 1])
+        variables = symbols('x1:%s' % (nvar + 1))
+        constraints = [(sum(rand()*x for x in variables) <= rand())
+                       for _ in range(num_constraints)]
+        objective = sum(rand() * x for x in variables)
+        return objective, constraints, variables
+
+    # equality
+    r1 = Eq(x, y)
+    r2 = Eq(y, z)
+    r3 = z <= 3
+    constraints = [r1, r2, r3]
+    objective = x
+    ans = optimum, argmax = lp(max, objective, constraints)
+    assert ans == lpmax(objective, constraints)
+    assert objective.subs(argmax) == optimum
+    for constr in constraints:
+        assert constr.subs(argmax) == True
+
+
+def test_simplex():
+    L = [
+        [[1, 1], [-1, 1], [0, 1], [-1, 0]],
+        [5, 1, 2, -1],
+        [[1, 1]],
+        [-1]]
+    A, B, C, D = _abcd(_m(*L), list=False)
+    assert _simplex(A, B, -C, -D) == (-6, [3, 2], [1, 0, 0, 0])
+    assert _simplex(A, B, -C, -D, dual=True) == (-6,
+        [1, 0, 0, 0], [5, 0])
+
+    assert _simplex([[]],[],[[1]],[0]) == (0, [0], [])
+
+    # handling of Eq (or Eq-like x<=y, x>=y conditions)
+    assert lpmax(x - y, [x <= y + 2, x >= y + 2, x >= 0, y >= 0]
+        ) == (2, {x: 2, y: 0})
+    assert lpmax(x - y, [x <= y + 2, Eq(x, y + 2), x >= 0, y >= 0]
+        ) == (2, {x: 2, y: 0})
+    assert lpmax(x - y, [x <= y + 2, Eq(x, 2)]) == (2, {x: 2, y: 0})
+    assert lpmax(y, [Eq(y, 2)]) == (2, {y: 2})
+
+    # the conditions are equivalent to Eq(x, y + 2)
+    assert lpmin(y, [x <= y + 2, x >= y + 2, y >= 0]
+        ) == (0, {x: 2, y: 0})
+    # equivalent to Eq(y, -2)
+    assert lpmax(y, [0 <= y + 2, 0 >= y + 2]) == (-2, {y: -2})
+    assert lpmax(y, [0 <= y + 2, 0 >= y + 2, y <= 0]
+        ) == (-2, {y: -2})
+
+    # extra symbols symbols
+    assert lpmin(x, [y >= 1, x >= y]) == (1, {x: 1, y: 1})
+    assert lpmin(x, [y >= 1, x >= y + z, x >= 0, z >= 0]
+        ) == (1, {x: 1, y: 1, z: 0})
+
+    # detect oscillation
+    # o1
+    v = x1, x2, x3, x4 = symbols('x1 x2 x3 x4')
+    raises(InfeasibleLPError, lambda: lpmin(
+        9*x2 - 8*x3 + 3*x4 + 6,
+        [5*x2 - 2*x3 <= 0,
+        -x1 - 8*x2 + 9*x3 <= -3,
+        10*x1 - x2+ 9*x4 <= -4] + [i >= 0 for i in v]))
+    # o2 - equations fed to lpmin are changed into a matrix
+    # system that doesn't oscillate and has the same solution
+    # as below
+    M = linear_eq_to_matrix
+    f = 5*x2 + x3 + 4*x4 - x1
+    L = 5*x2 + 2*x3 + 5*x4 - (x1 + 5)
+    cond = [L <= 0] + [Eq(3*x2 + x4, 2), Eq(-x1 + x3 + 2*x4, 1)]
+    c, d = M(f, v)
+    a, b = M(L, v)
+    aeq, beq = M(cond[1:], v)
+    ans = (S(9)/2, [0, S(1)/2, 0, S(1)/2])
+    assert linprog(c, a, b, aeq, beq, bounds=(0, 1)) == ans
+    lpans = lpmin(f, cond + [x1 >= 0, x1 <= 1,
+        x2 >= 0, x2 <= 1, x3 >= 0, x3 <= 1, x4 >= 0, x4 <= 1])
+    assert (lpans[0], list(lpans[1].values())) == ans
+
+
+def test_lpmin_lpmax():
+    v = x1, x2, y1, y2 = symbols('x1 x2 y1 y2')
+    L = [[1, -1]], [1], [[1, 1]], [2]
+    a, b, c, d = [Matrix(i) for i in L]
+    m = Matrix([[a, b], [c, d]])
+    f, constr = _primal_dual(m)[0]
+    ans = lpmin(f, constr + [i >= 0 for i in v[:2]])
+    assert ans == (-1, {x1: 1, x2: 0}),ans
+
+    L = [[1, -1], [1, 1]], [1, 1], [[1, 1]], [2]
+    a, b, c, d = [Matrix(i) for i in L]
+    m = Matrix([[a, b], [c, d]])
+    f, constr = _primal_dual(m)[1]
+    ans = lpmax(f, constr + [i >= 0 for i in v[-2:]])
+    assert ans == (-1, {y1: 1, y2: 0})
+
+
+def test_linprog():
+    for do in range(2):
+        if not do:
+            M = lambda a, b: linear_eq_to_matrix(a, b)
+        else:
+            # check matrices as list
+            M = lambda a, b: tuple([
+                i.tolist() for i in linear_eq_to_matrix(a, b)])
+
+        v = x, y, z = symbols('x1:4')
+        f = x + y - 2*z
+        c = M(f, v)[0]
+        ineq = [7*x + 4*y - 7*z <= 3,
+            3*x - y + 10*z <= 6,
+            x >= 0, y >= 0, z >= 0]
+        ab = M([i.lts - i.gts for i in ineq], v)
+        ans = (-S(6)/5, [0, 0, S(3)/5])
+        assert lpmin(f, ineq) == (ans[0], dict(zip(v, ans[1])))
+        assert linprog(c, *ab) == ans
+
+        f += 1
+        c = M(f, v)[0]
+        eq = [Eq(y - 9*x, 1)]
+        abeq = M([i.lhs - i.rhs for i in eq], v)
+        ans = (1 - S(2)/5, [0, 1, S(7)/10])
+        assert lpmin(f, ineq + eq) == (ans[0], dict(zip(v, ans[1])))
+        assert linprog(c, *ab, *abeq) == (ans[0] - 1, ans[1])
+
+        eq = [z - y <= S.Half]
+        abeq = M([i.lhs - i.rhs for i in eq], v)
+        ans = (1 - S(10)/9, [0, S(1)/9, S(11)/18])
+        assert lpmin(f, ineq + eq) == (ans[0], dict(zip(v, ans[1])))
+        assert linprog(c, *ab, *abeq) == (ans[0] - 1, ans[1])
+
+        bounds = [(0, None), (0, None), (None, S.Half)]
+        ans = (0, [0, 0, S.Half])
+        assert lpmin(f, ineq + [z <= S.Half]) == (
+            ans[0], dict(zip(v, ans[1])))
+        assert linprog(c, *ab, bounds=bounds) == (ans[0] - 1, ans[1])
+        assert linprog(c, *ab, bounds={v.index(z): bounds[-1]}
+            ) == (ans[0] - 1, ans[1])
+        eq = [z - y <= S.Half]
+
+    assert linprog([[1]], [], [], bounds=(2, 3)) == (2, [2])
+    assert linprog([1], [], [], bounds=(2, 3)) == (2, [2])
+    assert linprog([1], bounds=(2, 3)) == (2, [2])
+    assert linprog([1, -1], [[1, 1]], [2], bounds={1:(None, None)}
+        ) == (-2, [0, 2])
+    assert linprog([1, -1], [[1, 1]], [5], bounds={1:(3, None)}
+        ) == (-5, [0, 5])
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/tests/test_solvers.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/tests/test_solvers.py
new file mode 100644
index 0000000000000000000000000000000000000000..ac9550ad404c2ec7592caf6afd2910f425138987
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/tests/test_solvers.py
@@ -0,0 +1,2725 @@
+from sympy.assumptions.ask import (Q, ask)
+from sympy.core.add import Add
+from sympy.core.containers import Tuple
+from sympy.core.function import (Derivative, Function, diff)
+from sympy.core.mod import Mod
+from sympy.core.mul import Mul
+from sympy.core import (GoldenRatio, TribonacciConstant)
+from sympy.core.numbers import (E, Float, I, Rational, oo, pi)
+from sympy.core.relational import (Eq, Gt, Lt, Ne)
+from sympy.core.singleton import S
+from sympy.core.symbol import (Dummy, Symbol, Wild, symbols)
+from sympy.core.sympify import sympify
+from sympy.functions.combinatorial.factorials import binomial
+from sympy.functions.elementary.complexes import (Abs, arg, conjugate, im, re)
+from sympy.functions.elementary.exponential import (LambertW, exp, log)
+from sympy.functions.elementary.hyperbolic import (atanh, cosh, sinh, tanh)
+from sympy.functions.elementary.integers import floor
+from sympy.functions.elementary.miscellaneous import (cbrt, root, sqrt)
+from sympy.functions.elementary.piecewise import Piecewise
+from sympy.functions.elementary.trigonometric import (acos, asin, atan, atan2, cos, sec, sin, tan)
+from sympy.functions.special.error_functions import (erf, erfc, erfcinv, erfinv)
+from sympy.integrals.integrals import Integral
+from sympy.logic.boolalg import (And, Or)
+from sympy.matrices.dense import Matrix
+from sympy.matrices import MatrixSymbol, SparseMatrix
+from sympy.polys.polytools import Poly, groebner
+from sympy.printing.str import sstr
+from sympy.simplify.radsimp import denom
+from sympy.solvers.solvers import (nsolve, solve, solve_linear)
+
+from sympy.core.function import nfloat
+from sympy.solvers import solve_linear_system, solve_linear_system_LU, \
+    solve_undetermined_coeffs
+from sympy.solvers.bivariate import _filtered_gens, _solve_lambert, _lambert
+from sympy.solvers.solvers import _invert, unrad, checksol, posify, _ispow, \
+    det_quick, det_perm, det_minor, _simple_dens, denoms
+
+from sympy.physics.units import cm
+from sympy.polys.rootoftools import CRootOf
+
+from sympy.testing.pytest import slow, XFAIL, SKIP, raises
+from sympy.core.random import verify_numerically as tn
+
+from sympy.abc import a, b, c, d, e, k, h, p, x, y, z, t, q, m, R
+
+
+def NS(e, n=15, **options):
+    return sstr(sympify(e).evalf(n, **options), full_prec=True)
+
+
+def test_swap_back():
+    f, g = map(Function, 'fg')
+    fx, gx = f(x), g(x)
+    assert solve([fx + y - 2, fx - gx - 5], fx, y, gx) == \
+        {fx: gx + 5, y: -gx - 3}
+    assert solve(fx + gx*x - 2, [fx, gx], dict=True) == [{fx: 2, gx: 0}]
+    assert solve(fx + gx**2*x - y, [fx, gx], dict=True) == [{fx: y, gx: 0}]
+    assert solve([f(1) - 2, x + 2], dict=True) == [{x: -2, f(1): 2}]
+
+
+def guess_solve_strategy(eq, symbol):
+    try:
+        solve(eq, symbol)
+        return True
+    except (TypeError, NotImplementedError):
+        return False
+
+
+def test_guess_poly():
+    # polynomial equations
+    assert guess_solve_strategy( S(4), x )  # == GS_POLY
+    assert guess_solve_strategy( x, x )  # == GS_POLY
+    assert guess_solve_strategy( x + a, x )  # == GS_POLY
+    assert guess_solve_strategy( 2*x, x )  # == GS_POLY
+    assert guess_solve_strategy( x + sqrt(2), x)  # == GS_POLY
+    assert guess_solve_strategy( x + 2**Rational(1, 4), x)  # == GS_POLY
+    assert guess_solve_strategy( x**2 + 1, x )  # == GS_POLY
+    assert guess_solve_strategy( x**2 - 1, x )  # == GS_POLY
+    assert guess_solve_strategy( x*y + y, x )  # == GS_POLY
+    assert guess_solve_strategy( x*exp(y) + y, x)  # == GS_POLY
+    assert guess_solve_strategy(
+        (x - y**3)/(y**2*sqrt(1 - y**2)), x)  # == GS_POLY
+
+
+def test_guess_poly_cv():
+    # polynomial equations via a change of variable
+    assert guess_solve_strategy( sqrt(x) + 1, x )  # == GS_POLY_CV_1
+    assert guess_solve_strategy(
+        x**Rational(1, 3) + sqrt(x) + 1, x )  # == GS_POLY_CV_1
+    assert guess_solve_strategy( 4*x*(1 - sqrt(x)), x )  # == GS_POLY_CV_1
+
+    # polynomial equation multiplying both sides by x**n
+    assert guess_solve_strategy( x + 1/x + y, x )  # == GS_POLY_CV_2
+
+
+def test_guess_rational_cv():
+    # rational functions
+    assert guess_solve_strategy( (x + 1)/(x**2 + 2), x)  # == GS_RATIONAL
+    assert guess_solve_strategy(
+        (x - y**3)/(y**2*sqrt(1 - y**2)), y)  # == GS_RATIONAL_CV_1
+
+    # rational functions via the change of variable y -> x**n
+    assert guess_solve_strategy( (sqrt(x) + 1)/(x**Rational(1, 3) + sqrt(x) + 1), x ) \
+        #== GS_RATIONAL_CV_1
+
+
+def test_guess_transcendental():
+    #transcendental functions
+    assert guess_solve_strategy( exp(x) + 1, x )  # == GS_TRANSCENDENTAL
+    assert guess_solve_strategy( 2*cos(x) - y, x )  # == GS_TRANSCENDENTAL
+    assert guess_solve_strategy(
+        exp(x) + exp(-x) - y, x )  # == GS_TRANSCENDENTAL
+    assert guess_solve_strategy(3**x - 10, x)  # == GS_TRANSCENDENTAL
+    assert guess_solve_strategy(-3**x + 10, x)  # == GS_TRANSCENDENTAL
+
+    assert guess_solve_strategy(a*x**b - y, x)  # == GS_TRANSCENDENTAL
+
+
+def test_solve_args():
+    # equation container, issue 5113
+    ans = {x: -3, y: 1}
+    eqs = (x + 5*y - 2, -3*x + 6*y - 15)
+    assert all(solve(container(eqs), x, y) == ans for container in
+        (tuple, list, set, frozenset))
+    assert solve(Tuple(*eqs), x, y) == ans
+    # implicit symbol to solve for
+    assert set(solve(x**2 - 4)) == {S(2), -S(2)}
+    assert solve([x + y - 3, x - y - 5]) == {x: 4, y: -1}
+    assert solve(x - exp(x), x, implicit=True) == [exp(x)]
+    # no symbol to solve for
+    assert solve(42) == solve(42, x) == []
+    assert solve([1, 2]) == []
+    assert solve([sqrt(2)],[x]) == []
+    # duplicate symbols raises
+    raises(ValueError, lambda: solve((x - 3, y + 2), x, y, x))
+    raises(ValueError, lambda: solve(x, x, x))
+    # no error in exclude
+    assert solve(x, x, exclude=[y, y]) == [0]
+    # duplicate symbols raises
+    raises(ValueError, lambda: solve((x - 3, y + 2), x, y, x))
+    raises(ValueError, lambda: solve(x, x, x))
+    # no error in exclude
+    assert solve(x, x, exclude=[y, y]) == [0]
+    # unordered symbols
+    # only 1
+    assert solve(y - 3, {y}) == [3]
+    # more than 1
+    assert solve(y - 3, {x, y}) == [{y: 3}]
+    # multiple symbols: take the first linear solution+
+    # - return as tuple with values for all requested symbols
+    assert solve(x + y - 3, [x, y]) == [(3 - y, y)]
+    # - unless dict is True
+    assert solve(x + y - 3, [x, y], dict=True) == [{x: 3 - y}]
+    # - or no symbols are given
+    assert solve(x + y - 3) == [{x: 3 - y}]
+    # multiple symbols might represent an undetermined coefficients system
+    assert solve(a + b*x - 2, [a, b]) == {a: 2, b: 0}
+    assert solve((a + b)*x + b - c, [a, b]) == {a: -c, b: c}
+    eq = a*x**2 + b*x + c - ((x - h)**2 + 4*p*k)/4/p
+    # - check that flags are obeyed
+    sol = solve(eq, [h, p, k], exclude=[a, b, c])
+    assert sol == {h: -b/(2*a), k: (4*a*c - b**2)/(4*a), p: 1/(4*a)}
+    assert solve(eq, [h, p, k], dict=True) == [sol]
+    assert solve(eq, [h, p, k], set=True) == \
+        ([h, p, k], {(-b/(2*a), 1/(4*a), (4*a*c - b**2)/(4*a))})
+    # issue 23889 - polysys not simplified
+    assert solve(eq, [h, p, k], exclude=[a, b, c], simplify=False) == \
+        {h: -b/(2*a), k: (4*a*c - b**2)/(4*a), p: 1/(4*a)}
+    # but this only happens when system has a single solution
+    args = (a + b)*x - b**2 + 2, a, b
+    assert solve(*args) == [((b**2 - b*x - 2)/x, b)]
+    # and if the system has a solution; the following doesn't so
+    # an algebraic solution is returned
+    assert solve(a*x + b**2/(x + 4) - 3*x - 4/x, a, b, dict=True) == \
+        [{a: (-b**2*x + 3*x**3 + 12*x**2 + 4*x + 16)/(x**2*(x + 4))}]
+    # failed single equation
+    assert solve(1/(1/x - y + exp(y))) == []
+    raises(
+        NotImplementedError, lambda: solve(exp(x) + sin(x) + exp(y) + sin(y)))
+    # failed system
+    # --  when no symbols given, 1 fails
+    assert solve([y, exp(x) + x]) == [{x: -LambertW(1), y: 0}]
+    #     both fail
+    assert solve(
+        (exp(x) - x, exp(y) - y)) == [{x: -LambertW(-1), y: -LambertW(-1)}]
+    # --  when symbols given
+    assert solve([y, exp(x) + x], x, y) == [(-LambertW(1), 0)]
+    # symbol is a number
+    assert solve(x**2 - pi, pi) == [x**2]
+    # no equations
+    assert solve([], [x]) == []
+    # nonlinear system
+    assert solve((x**2 - 4, y - 2), x, y) == [(-2, 2), (2, 2)]
+    assert solve((x**2 - 4, y - 2), y, x) == [(2, -2), (2, 2)]
+    assert solve((x**2 - 4 + z, y - 2 - z), a, z, y, x, set=True
+        ) == ([a, z, y, x], {
+        (a, z, z + 2, -sqrt(4 - z)),
+        (a, z, z + 2, sqrt(4 - z))})
+    # overdetermined system
+    # - nonlinear
+    assert solve([(x + y)**2 - 4, x + y - 2]) == [{x: -y + 2}]
+    # - linear
+    assert solve((x + y - 2, 2*x + 2*y - 4)) == {x: -y + 2}
+    # When one or more args are Boolean
+    assert solve(Eq(x**2, 0.0)) == [0.0]  # issue 19048
+    assert solve([True, Eq(x, 0)], [x], dict=True) == [{x: 0}]
+    assert solve([Eq(x, x), Eq(x, 0), Eq(x, x+1)], [x], dict=True) == []
+    assert not solve([Eq(x, x+1), x < 2], x)
+    assert solve([Eq(x, 0), x+1<2]) == Eq(x, 0)
+    assert solve([Eq(x, x), Eq(x, x+1)], x) == []
+    assert solve(True, x) == []
+    assert solve([x - 1, False], [x], set=True) == ([], set())
+    assert solve([-y*(x + y - 1)/2, (y - 1)/x/y + 1/y],
+        set=True, check=False) == ([x, y], {(1 - y, y), (x, 0)})
+    # ordering should be canonical, fastest to order by keys instead
+    # of by size
+    assert list(solve((y - 1, x - sqrt(3)*z)).keys()) == [x, y]
+    # as set always returns as symbols, set even if no solution
+    assert solve([x - 1, x], (y, x), set=True) == ([y, x], set())
+    assert solve([x - 1, x], {y, x}, set=True) == ([x, y], set())
+
+
+def test_solve_polynomial1():
+    assert solve(3*x - 2, x) == [Rational(2, 3)]
+    assert solve(Eq(3*x, 2), x) == [Rational(2, 3)]
+
+    assert set(solve(x**2 - 1, x)) == {-S.One, S.One}
+    assert set(solve(Eq(x**2, 1), x)) == {-S.One, S.One}
+
+    assert solve(x - y**3, x) == [y**3]
+    rx = root(x, 3)
+    assert solve(x - y**3, y) == [
+        rx, -rx/2 - sqrt(3)*I*rx/2, -rx/2 +  sqrt(3)*I*rx/2]
+    a11, a12, a21, a22, b1, b2 = symbols('a11,a12,a21,a22,b1,b2')
+
+    assert solve([a11*x + a12*y - b1, a21*x + a22*y - b2], x, y) == \
+        {
+            x: (a22*b1 - a12*b2)/(a11*a22 - a12*a21),
+            y: (a11*b2 - a21*b1)/(a11*a22 - a12*a21),
+        }
+
+    solution = {x: S.Zero, y: S.Zero}
+
+    assert solve((x - y, x + y), x, y ) == solution
+    assert solve((x - y, x + y), (x, y)) == solution
+    assert solve((x - y, x + y), [x, y]) == solution
+
+    assert set(solve(x**3 - 15*x - 4, x)) == {
+        -2 + 3**S.Half,
+        S(4),
+        -2 - 3**S.Half
+    }
+
+    assert set(solve((x**2 - 1)**2 - a, x)) == \
+        {sqrt(1 + sqrt(a)), -sqrt(1 + sqrt(a)),
+             sqrt(1 - sqrt(a)), -sqrt(1 - sqrt(a))}
+
+
+def test_solve_polynomial2():
+    assert solve(4, x) == []
+
+
+def test_solve_polynomial_cv_1a():
+    """
+    Test for solving on equations that can be converted to a polynomial equation
+    using the change of variable y -> x**Rational(p, q)
+    """
+    assert solve( sqrt(x) - 1, x) == [1]
+    assert solve( sqrt(x) - 2, x) == [4]
+    assert solve( x**Rational(1, 4) - 2, x) == [16]
+    assert solve( x**Rational(1, 3) - 3, x) == [27]
+    assert solve(sqrt(x) + x**Rational(1, 3) + x**Rational(1, 4), x) == [0]
+
+
+def test_solve_polynomial_cv_1b():
+    assert set(solve(4*x*(1 - a*sqrt(x)), x)) == {S.Zero, 1/a**2}
+    assert set(solve(x*(root(x, 3) - 3), x)) == {S.Zero, S(27)}
+
+
+def test_solve_polynomial_cv_2():
+    """
+    Test for solving on equations that can be converted to a polynomial equation
+    multiplying both sides of the equation by x**m
+    """
+    assert solve(x + 1/x - 1, x) in \
+        [[ S.Half + I*sqrt(3)/2, S.Half - I*sqrt(3)/2],
+         [ S.Half - I*sqrt(3)/2, S.Half + I*sqrt(3)/2]]
+
+
+def test_quintics_1():
+    f = x**5 - 110*x**3 - 55*x**2 + 2310*x + 979
+    s = solve(f, check=False)
+    for r in s:
+        res = f.subs(x, r.n()).n()
+        assert tn(res, 0)
+
+    f = x**5 - 15*x**3 - 5*x**2 + 10*x + 20
+    s = solve(f)
+    for r in s:
+        assert r.func == CRootOf
+
+    # if one uses solve to get the roots of a polynomial that has a CRootOf
+    # solution, make sure that the use of nfloat during the solve process
+    # doesn't fail. Note: if you want numerical solutions to a polynomial
+    # it is *much* faster to use nroots to get them than to solve the
+    # equation only to get RootOf solutions which are then numerically
+    # evaluated. So for eq = x**5 + 3*x + 7 do Poly(eq).nroots() rather
+    # than [i.n() for i in solve(eq)] to get the numerical roots of eq.
+    assert nfloat(solve(x**5 + 3*x**3 + 7)[0], exponent=False) == \
+        CRootOf(x**5 + 3*x**3 + 7, 0).n()
+
+
+def test_quintics_2():
+    f = x**5 + 15*x + 12
+    s = solve(f, check=False)
+    for r in s:
+        res = f.subs(x, r.n()).n()
+        assert tn(res, 0)
+
+    f = x**5 - 15*x**3 - 5*x**2 + 10*x + 20
+    s = solve(f)
+    for r in s:
+        assert r.func == CRootOf
+
+    assert solve(x**5 - 6*x**3 - 6*x**2 + x - 6) == [
+        CRootOf(x**5 - 6*x**3 - 6*x**2 + x - 6, 0),
+        CRootOf(x**5 - 6*x**3 - 6*x**2 + x - 6, 1),
+        CRootOf(x**5 - 6*x**3 - 6*x**2 + x - 6, 2),
+        CRootOf(x**5 - 6*x**3 - 6*x**2 + x - 6, 3),
+        CRootOf(x**5 - 6*x**3 - 6*x**2 + x - 6, 4)]
+
+def test_quintics_3():
+    y = x**5 + x**3 - 2**Rational(1, 3)
+    assert solve(y) == solve(-y) == []
+
+
+def test_highorder_poly():
+    # just testing that the uniq generator is unpacked
+    sol = solve(x**6 - 2*x + 2)
+    assert all(isinstance(i, CRootOf) for i in sol) and len(sol) == 6
+
+
+def test_solve_rational():
+    """Test solve for rational functions"""
+    assert solve( ( x - y**3 )/( (y**2)*sqrt(1 - y**2) ), x) == [y**3]
+
+
+def test_solve_conjugate():
+    """Test solve for simple conjugate functions"""
+    assert solve(conjugate(x) -3 + I) == [3 + I]
+
+
+def test_solve_nonlinear():
+    assert solve(x**2 - y**2, x, y, dict=True) == [{x: -y}, {x: y}]
+    assert solve(x**2 - y**2/exp(x), y, x, dict=True) == [{y: -x*sqrt(exp(x))},
+                                                          {y: x*sqrt(exp(x))}]
+
+
+def test_issue_8666():
+    x = symbols('x')
+    assert solve(Eq(x**2 - 1/(x**2 - 4), 4 - 1/(x**2 - 4)), x) == []
+    assert solve(Eq(x + 1/x, 1/x), x) == []
+
+
+def test_issue_7228():
+    assert solve(4**(2*(x**2) + 2*x) - 8, x) == [Rational(-3, 2), S.Half]
+
+
+def test_issue_7190():
+    assert solve(log(x-3) + log(x+3), x) == [sqrt(10)]
+
+
+def test_issue_21004():
+    x = symbols('x')
+    f = x/sqrt(x**2+1)
+    f_diff = f.diff(x)
+    assert solve(f_diff, x) == []
+
+
+def test_issue_24650():
+    x = symbols('x')
+    r = solve(Eq(Piecewise((x, Eq(x, 0) | (x > 1))), 0))
+    assert r == [0]
+    r = checksol(Eq(Piecewise((x, Eq(x, 0) | (x > 1))), 0), x, sol=0)
+    assert r is True
+
+
+def test_linear_system():
+    x, y, z, t, n = symbols('x, y, z, t, n')
+
+    assert solve([x - 1, x - y, x - 2*y, y - 1], [x, y]) == []
+
+    assert solve([x - 1, x - y, x - 2*y, x - 1], [x, y]) == []
+    assert solve([x - 1, x - 1, x - y, x - 2*y], [x, y]) == []
+
+    assert solve([x + 5*y - 2, -3*x + 6*y - 15], x, y) == {x: -3, y: 1}
+
+    M = Matrix([[0, 0, n*(n + 1), (n + 1)**2, 0],
+                [n + 1, n + 1, -2*n - 1, -(n + 1), 0],
+                [-1, 0, 1, 0, 0]])
+
+    assert solve_linear_system(M, x, y, z, t) == \
+        {x: t*(-n-1)/n, y: 0, z: t*(-n-1)/n}
+
+    assert solve([x + y + z + t, -z - t], x, y, z, t) == {x: -y, z: -t}
+
+
+@XFAIL
+def test_linear_system_xfail():
+    # https://github.com/sympy/sympy/issues/6420
+    M = Matrix([[0,    15.0, 10.0, 700.0],
+                [1,    1,    1,    100.0],
+                [0,    10.0, 5.0,  200.0],
+                [-5.0, 0,    0,    0    ]])
+
+    assert solve_linear_system(M, x, y, z) == {x: 0, y: -60.0, z: 160.0}
+
+
+def test_linear_system_function():
+    a = Function('a')
+    assert solve([a(0, 0) + a(0, 1) + a(1, 0) + a(1, 1), -a(1, 0) - a(1, 1)],
+        a(0, 0), a(0, 1), a(1, 0), a(1, 1)) == {a(1, 0): -a(1, 1), a(0, 0): -a(0, 1)}
+
+
+def test_linear_system_symbols_doesnt_hang_1():
+
+    def _mk_eqs(wy):
+        # Equations for fitting a wy*2 - 1 degree polynomial between two points,
+        # at end points derivatives are known up to order: wy - 1
+        order = 2*wy - 1
+        x, x0, x1 = symbols('x, x0, x1', real=True)
+        y0s = symbols('y0_:{}'.format(wy), real=True)
+        y1s = symbols('y1_:{}'.format(wy), real=True)
+        c = symbols('c_:{}'.format(order+1), real=True)
+
+        expr = sum(coeff*x**o for o, coeff in enumerate(c))
+        eqs = []
+        for i in range(wy):
+            eqs.append(expr.diff(x, i).subs({x: x0}) - y0s[i])
+            eqs.append(expr.diff(x, i).subs({x: x1}) - y1s[i])
+        return eqs, c
+
+    #
+    # The purpose of this test is just to see that these calls don't hang. The
+    # expressions returned are complicated so are not included here. Testing
+    # their correctness takes longer than solving the system.
+    #
+
+    for n in range(1, 7+1):
+        eqs, c = _mk_eqs(n)
+        solve(eqs, c)
+
+
+def test_linear_system_symbols_doesnt_hang_2():
+
+    M = Matrix([
+        [66, 24, 39, 50, 88, 40, 37, 96, 16, 65, 31, 11, 37, 72, 16, 19, 55, 37, 28, 76],
+        [10, 93, 34, 98, 59, 44, 67, 74, 74, 94, 71, 61, 60, 23,  6,  2, 57,  8, 29, 78],
+        [19, 91, 57, 13, 64, 65, 24, 53, 77, 34, 85, 58, 87, 39, 39,  7, 36, 67, 91,  3],
+        [74, 70, 15, 53, 68, 43, 86, 83, 81, 72, 25, 46, 67, 17, 59, 25, 78, 39, 63,  6],
+        [69, 40, 67, 21, 67, 40, 17, 13, 93, 44, 46, 89, 62, 31, 30, 38, 18, 20, 12, 81],
+        [50, 22, 74, 76, 34, 45, 19, 76, 28, 28, 11, 99, 97, 82,  8, 46, 99, 57, 68, 35],
+        [58, 18, 45, 88, 10, 64,  9, 34, 90, 82, 17, 41, 43, 81, 45, 83, 22, 88, 24, 39],
+        [42, 21, 70, 68,  6, 33, 64, 81, 83, 15, 86, 75, 86, 17, 77, 34, 62, 72, 20, 24],
+        [ 7,  8,  2, 72, 71, 52, 96,  5, 32, 51, 31, 36, 79, 88, 25, 77, 29, 26, 33, 13],
+        [19, 31, 30, 85, 81, 39, 63, 28, 19, 12, 16, 49, 37, 66, 38, 13,  3, 71, 61, 51],
+        [29, 82, 80, 49, 26, 85,  1, 37,  2, 74, 54, 82, 26, 47, 54,  9, 35,  0, 99, 40],
+        [15, 49, 82, 91, 93, 57, 45, 25, 45, 97, 15, 98, 48, 52, 66, 24, 62, 54, 97, 37],
+        [62, 23, 73, 53, 52, 86, 28, 38,  0, 74, 92, 38, 97, 70, 71, 29, 26, 90, 67, 45],
+        [ 2, 32, 23, 24, 71, 37, 25, 71,  5, 41, 97, 65, 93, 13, 65, 45, 25, 88, 69, 50],
+        [40, 56,  1, 29, 79, 98, 79, 62, 37, 28, 45, 47,  3,  1, 32, 74, 98, 35, 84, 32],
+        [33, 15, 87, 79, 65,  9, 14, 63, 24, 19, 46, 28, 74, 20, 29, 96, 84, 91, 93,  1],
+        [97, 18, 12, 52,  1,  2, 50, 14, 52, 76, 19, 82, 41, 73, 51, 79, 13,  3, 82, 96],
+        [40, 28, 52, 10, 10, 71, 56, 78, 82,  5, 29, 48,  1, 26, 16, 18, 50, 76, 86, 52],
+        [38, 89, 83, 43, 29, 52, 90, 77, 57,  0, 67, 20, 81, 88, 48, 96, 88, 58, 14,  3]])
+
+    syms = x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18 = symbols('x:19')
+
+    sol = {
+        x0:  -S(1967374186044955317099186851240896179)/3166636564687820453598895768302256588,
+        x1:  -S(84268280268757263347292368432053826)/791659141171955113399723942075564147,
+        x2:  -S(229962957341664730974463872411844965)/1583318282343910226799447884151128294,
+        x3:   S(990156781744251750886760432229180537)/6333273129375640907197791536604513176,
+        x4:  -S(2169830351210066092046760299593096265)/18999819388126922721593374609813539528,
+        x5:   S(4680868883477577389628494526618745355)/9499909694063461360796687304906769764,
+        x6:  -S(1590820774344371990683178396480879213)/3166636564687820453598895768302256588,
+        x7:  -S(54104723404825537735226491634383072)/339282489073695048599881689460956063,
+        x8:   S(3182076494196560075964847771774733847)/6333273129375640907197791536604513176,
+        x9:  -S(10870817431029210431989147852497539675)/18999819388126922721593374609813539528,
+        x10: -S(13118019242576506476316318268573312603)/18999819388126922721593374609813539528,
+        x11: -S(5173852969886775824855781403820641259)/4749954847031730680398343652453384882,
+        x12:  S(4261112042731942783763341580651820563)/4749954847031730680398343652453384882,
+        x13: -S(821833082694661608993818117038209051)/6333273129375640907197791536604513176,
+        x14:  S(906881575107250690508618713632090559)/904753304196520129599684505229216168,
+        x15: -S(732162528717458388995329317371283987)/6333273129375640907197791536604513176,
+        x16:  S(4524215476705983545537087360959896817)/9499909694063461360796687304906769764,
+        x17: -S(3898571347562055611881270844646055217)/6333273129375640907197791536604513176,
+        x18:  S(7513502486176995632751685137907442269)/18999819388126922721593374609813539528
+    }
+
+    eqs = list(M * Matrix(syms + (1,)))
+    assert solve(eqs, syms) == sol
+
+    y = Symbol('y')
+    eqs = list(y * M * Matrix(syms + (1,)))
+    assert solve(eqs, syms) == sol
+
+
+def test_linear_systemLU():
+    n = Symbol('n')
+
+    M = Matrix([[1, 2, 0, 1], [1, 3, 2*n, 1], [4, -1, n**2, 1]])
+
+    assert solve_linear_system_LU(M, [x, y, z]) == {z: -3/(n**2 + 18*n),
+                                                  x: 1 - 12*n/(n**2 + 18*n),
+                                                  y: 6*n/(n**2 + 18*n)}
+
+# Note: multiple solutions exist for some of these equations, so the tests
+# should be expected to break if the implementation of the solver changes
+# in such a way that a different branch is chosen
+
+@slow
+def test_solve_transcendental():
+    from sympy.abc import a, b
+
+    assert solve(exp(x) - 3, x) == [log(3)]
+    assert set(solve((a*x + b)*(exp(x) - 3), x)) == {-b/a, log(3)}
+    assert solve(cos(x) - y, x) == [-acos(y) + 2*pi, acos(y)]
+    assert solve(2*cos(x) - y, x) == [-acos(y/2) + 2*pi, acos(y/2)]
+    assert solve(Eq(cos(x), sin(x)), x) == [pi/4]
+
+    assert set(solve(exp(x) + exp(-x) - y, x)) in [{
+        log(y/2 - sqrt(y**2 - 4)/2),
+        log(y/2 + sqrt(y**2 - 4)/2),
+    }, {
+        log(y - sqrt(y**2 - 4)) - log(2),
+        log(y + sqrt(y**2 - 4)) - log(2)},
+    {
+        log(y/2 - sqrt((y - 2)*(y + 2))/2),
+        log(y/2 + sqrt((y - 2)*(y + 2))/2)}]
+    assert solve(exp(x) - 3, x) == [log(3)]
+    assert solve(Eq(exp(x), 3), x) == [log(3)]
+    assert solve(log(x) - 3, x) == [exp(3)]
+    assert solve(sqrt(3*x) - 4, x) == [Rational(16, 3)]
+    assert solve(3**(x + 2), x) == []
+    assert solve(3**(2 - x), x) == []
+    assert solve(x + 2**x, x) == [-LambertW(log(2))/log(2)]
+    assert solve(2*x + 5 + log(3*x - 2), x) == \
+        [Rational(2, 3) + LambertW(2*exp(Rational(-19, 3))/3)/2]
+    assert solve(3*x + log(4*x), x) == [LambertW(Rational(3, 4))/3]
+    assert set(solve((2*x + 8)*(8 + exp(x)), x)) == {S(-4), log(8) + pi*I}
+    eq = 2*exp(3*x + 4) - 3
+    ans = solve(eq, x)  # this generated a failure in flatten
+    assert len(ans) == 3 and all(eq.subs(x, a).n(chop=True) == 0 for a in ans)
+    assert solve(2*log(3*x + 4) - 3, x) == [(exp(Rational(3, 2)) - 4)/3]
+    assert solve(exp(x) + 1, x) == [pi*I]
+
+    eq = 2*(3*x + 4)**5 - 6*7**(3*x + 9)
+    result = solve(eq, x)
+    x0 = -log(2401)
+    x1 = 3**Rational(1, 5)
+    x2 = log(7**(7*x1/20))
+    x3 = sqrt(2)
+    x4 = sqrt(5)
+    x5 = x3*sqrt(x4 - 5)
+    x6 = x4 + 1
+    x7 = 1/(3*log(7))
+    x8 = -x4
+    x9 = x3*sqrt(x8 - 5)
+    x10 = x8 + 1
+    ans = [x7*(x0 - 5*LambertW(x2*(-x5 + x6))),
+           x7*(x0 - 5*LambertW(x2*(x5 + x6))),
+           x7*(x0 - 5*LambertW(x2*(x10 - x9))),
+           x7*(x0 - 5*LambertW(x2*(x10 + x9))),
+           x7*(x0 - 5*LambertW(-log(7**(7*x1/5))))]
+    assert result == ans, result
+    # it works if expanded, too
+    assert solve(eq.expand(), x) == result
+
+    assert solve(z*cos(x) - y, x) == [-acos(y/z) + 2*pi, acos(y/z)]
+    assert solve(z*cos(2*x) - y, x) == [-acos(y/z)/2 + pi, acos(y/z)/2]
+    assert solve(z*cos(sin(x)) - y, x) == [
+        pi - asin(acos(y/z)), asin(acos(y/z) - 2*pi) + pi,
+        -asin(acos(y/z) - 2*pi), asin(acos(y/z))]
+
+    assert solve(z*cos(x), x) == [pi/2, pi*Rational(3, 2)]
+
+    # issue 4508
+    assert solve(y - b*x/(a + x), x) in [[-a*y/(y - b)], [a*y/(b - y)]]
+    assert solve(y - b*exp(a/x), x) == [a/log(y/b)]
+    # issue 4507
+    assert solve(y - b/(1 + a*x), x) in [[(b - y)/(a*y)], [-((y - b)/(a*y))]]
+    # issue 4506
+    assert solve(y - a*x**b, x) == [(y/a)**(1/b)]
+    # issue 4505
+    assert solve(z**x - y, x) == [log(y)/log(z)]
+    # issue 4504
+    assert solve(2**x - 10, x) == [1 + log(5)/log(2)]
+    # issue 6744
+    assert solve(x*y) == [{x: 0}, {y: 0}]
+    assert solve([x*y]) == [{x: 0}, {y: 0}]
+    assert solve(x**y - 1) == [{x: 1}, {y: 0}]
+    assert solve([x**y - 1]) == [{x: 1}, {y: 0}]
+    assert solve(x*y*(x**2 - y**2)) == [{x: 0}, {x: -y}, {x: y}, {y: 0}]
+    assert solve([x*y*(x**2 - y**2)]) == [{x: 0}, {x: -y}, {x: y}, {y: 0}]
+    # issue 4739
+    assert solve(exp(log(5)*x) - 2**x, x) == [0]
+    # issue 14791
+    assert solve(exp(log(5)*x) - exp(log(2)*x), x) == [0]
+    f = Function('f')
+    assert solve(y*f(log(5)*x) - y*f(log(2)*x), x) == [0]
+    assert solve(f(x) - f(0), x) == [0]
+    assert solve(f(x) - f(2 - x), x) == [1]
+    raises(NotImplementedError, lambda: solve(f(x, y) - f(1, 2), x))
+    raises(NotImplementedError, lambda: solve(f(x, y) - f(2 - x, 2), x))
+    raises(ValueError, lambda: solve(f(x, y) - f(1 - x), x))
+    raises(ValueError, lambda: solve(f(x, y) - f(1), x))
+
+    # misc
+    # make sure that the right variables is picked up in tsolve
+    # shouldn't generate a GeneratorsNeeded error in _tsolve when the NaN is generated
+    # for eq_down. Actual answers, as determined numerically are approx. +/- 0.83
+    raises(NotImplementedError, lambda:
+        solve(sinh(x)*sinh(sinh(x)) + cosh(x)*cosh(sinh(x)) - 3))
+
+    # watch out for recursive loop in tsolve
+    raises(NotImplementedError, lambda: solve((x + 2)**y*x - 3, x))
+
+    # issue 7245
+    assert solve(sin(sqrt(x))) == [0, pi**2]
+
+    # issue 7602
+    a, b = symbols('a, b', real=True, negative=False)
+    assert str(solve(Eq(a, 0.5 - cos(pi*b)/2), b)) == \
+        '[2.0 - 0.318309886183791*acos(1.0 - 2.0*a), 0.318309886183791*acos(1.0 - 2.0*a)]'
+
+    # issue 15325
+    assert solve(y**(1/x) - z, x) == [log(y)/log(z)]
+
+    # issue 25685 (basic trig identities should give simple solutions)
+    for yi in [cos(2*x),sin(2*x),cos(x - pi/3)]:
+        sol = solve([cos(x) - S(3)/5, yi - y])
+        assert (sol[0][y] + sol[1][y]).is_Rational, (yi,sol)
+    # don't allow massive expansion
+    assert solve(cos(1000*x) - S.Half) == [pi/3000, pi/600]
+    assert solve(cos(x - 1000*y) - 1, x) == [1000*y, 1000*y + 2*pi]
+    assert solve(cos(x + y + z) - 1, x) == [-y - z, -y - z + 2*pi]
+
+    # issue 26008
+    assert solve(sin(x + pi/6)) == [-pi/6, 5*pi/6]
+
+
+def test_solve_for_functions_derivatives():
+    t = Symbol('t')
+    x = Function('x')(t)
+    y = Function('y')(t)
+    a11, a12, a21, a22, b1, b2 = symbols('a11,a12,a21,a22,b1,b2')
+
+    soln = solve([a11*x + a12*y - b1, a21*x + a22*y - b2], x, y)
+    assert soln == {
+        x: (a22*b1 - a12*b2)/(a11*a22 - a12*a21),
+        y: (a11*b2 - a21*b1)/(a11*a22 - a12*a21),
+    }
+
+    assert solve(x - 1, x) == [1]
+    assert solve(3*x - 2, x) == [Rational(2, 3)]
+
+    soln = solve([a11*x.diff(t) + a12*y.diff(t) - b1, a21*x.diff(t) +
+            a22*y.diff(t) - b2], x.diff(t), y.diff(t))
+    assert soln == { y.diff(t): (a11*b2 - a21*b1)/(a11*a22 - a12*a21),
+            x.diff(t): (a22*b1 - a12*b2)/(a11*a22 - a12*a21) }
+
+    assert solve(x.diff(t) - 1, x.diff(t)) == [1]
+    assert solve(3*x.diff(t) - 2, x.diff(t)) == [Rational(2, 3)]
+
+    eqns = {3*x - 1, 2*y - 4}
+    assert solve(eqns, {x, y}) == { x: Rational(1, 3), y: 2 }
+    x = Symbol('x')
+    f = Function('f')
+    F = x**2 + f(x)**2 - 4*x - 1
+    assert solve(F.diff(x), diff(f(x), x)) == [(-x + 2)/f(x)]
+
+    # Mixed cased with a Symbol and a Function
+    x = Symbol('x')
+    y = Function('y')(t)
+
+    soln = solve([a11*x + a12*y.diff(t) - b1, a21*x +
+            a22*y.diff(t) - b2], x, y.diff(t))
+    assert soln == { y.diff(t): (a11*b2 - a21*b1)/(a11*a22 - a12*a21),
+            x: (a22*b1 - a12*b2)/(a11*a22 - a12*a21) }
+
+    # issue 13263
+    x = Symbol('x')
+    f = Function('f')
+    soln = solve([f(x).diff(x) + f(x).diff(x, 2) - 1, f(x).diff(x) - f(x).diff(x, 2)],
+            f(x).diff(x), f(x).diff(x, 2))
+    assert soln == { f(x).diff(x, 2): S(1)/2, f(x).diff(x): S(1)/2 }
+
+    soln = solve([f(x).diff(x, 2) + f(x).diff(x, 3) - 1, 1 - f(x).diff(x, 2) -
+            f(x).diff(x, 3), 1 - f(x).diff(x,3)], f(x).diff(x, 2), f(x).diff(x, 3))
+    assert soln == { f(x).diff(x, 2): 0, f(x).diff(x, 3): 1 }
+
+
+def test_issue_3725():
+    f = Function('f')
+    F = x**2 + f(x)**2 - 4*x - 1
+    e = F.diff(x)
+    assert solve(e, f(x).diff(x)) in [[(2 - x)/f(x)], [-((x - 2)/f(x))]]
+
+
+def test_solve_Matrix():
+    # https://github.com/sympy/sympy/issues/3870
+    a, b, c, d = symbols('a b c d')
+    A = Matrix(2, 2, [a, b, c, d])
+    B = Matrix(2, 2, [0, 2, -3, 0])
+    C = Matrix(2, 2, [1, 2, 3, 4])
+
+    assert solve(A*B - C, [a, b, c, d]) == {a: 1, b: Rational(-1, 3), c: 2, d: -1}
+    assert solve([A*B - C], [a, b, c, d]) == {a: 1, b: Rational(-1, 3), c: 2, d: -1}
+    assert solve(Eq(A*B, C), [a, b, c, d]) == {a: 1, b: Rational(-1, 3), c: 2, d: -1}
+
+    assert solve([A*B - B*A], [a, b, c, d]) == {a: d, b: Rational(-2, 3)*c}
+    assert solve([A*C - C*A], [a, b, c, d]) == {a: d - c, b: Rational(2, 3)*c}
+    assert solve([A*B - B*A, A*C - C*A], [a, b, c, d]) == {a: d, b: 0, c: 0}
+
+    assert solve([Eq(A*B, B*A)], [a, b, c, d]) == {a: d, b: Rational(-2, 3)*c}
+    assert solve([Eq(A*C, C*A)], [a, b, c, d]) == {a: d - c, b: Rational(2, 3)*c}
+    assert solve([Eq(A*B, B*A), Eq(A*C, C*A)], [a, b, c, d]) == {a: d, b: 0, c: 0}
+
+    # https://github.com/sympy/sympy/issues/27854
+    m, n = symbols("m n")
+    A = MatrixSymbol("A", m, n)
+    x = MatrixSymbol("x", n, 1)
+    b = MatrixSymbol('b', m, 1)
+    r = A * x - b
+    f = r.T * r
+    grad_f = f.diff(x)
+    raises(ValueError, lambda: solve(grad_f, x))
+
+
+def test_solve_linear():
+    w = Wild('w')
+    assert solve_linear(x, x) == (0, 1)
+    assert solve_linear(x, exclude=[x]) == (0, 1)
+    assert solve_linear(x, symbols=[w]) == (0, 1)
+    assert solve_linear(x, y - 2*x) in [(x, y/3), (y, 3*x)]
+    assert solve_linear(x, y - 2*x, exclude=[x]) == (y, 3*x)
+    assert solve_linear(3*x - y, 0) in [(x, y/3), (y, 3*x)]
+    assert solve_linear(3*x - y, 0, [x]) == (x, y/3)
+    assert solve_linear(3*x - y, 0, [y]) == (y, 3*x)
+    assert solve_linear(x**2/y, 1) == (y, x**2)
+    assert solve_linear(w, x) in [(w, x), (x, w)]
+    assert solve_linear(cos(x)**2 + sin(x)**2 + 2 + y) == \
+        (y, -2 - cos(x)**2 - sin(x)**2)
+    assert solve_linear(cos(x)**2 + sin(x)**2 + 2 + y, symbols=[x]) == (0, 1)
+    assert solve_linear(Eq(x, 3)) == (x, 3)
+    assert solve_linear(1/(1/x - 2)) == (0, 0)
+    assert solve_linear((x + 1)*exp(-x), symbols=[x]) == (x, -1)
+    assert solve_linear((x + 1)*exp(x), symbols=[x]) == ((x + 1)*exp(x), 1)
+    assert solve_linear(x*exp(-x**2), symbols=[x]) == (x, 0)
+    assert solve_linear(0**x - 1) == (0**x - 1, 1)
+    assert solve_linear(1 + 1/(x - 1)) == (x, 0)
+    eq = y*cos(x)**2 + y*sin(x)**2 - y  # = y*(1 - 1) = 0
+    assert solve_linear(eq) == (0, 1)
+    eq = cos(x)**2 + sin(x)**2  # = 1
+    assert solve_linear(eq) == (0, 1)
+    raises(ValueError, lambda: solve_linear(Eq(x, 3), 3))
+
+
+def test_solve_undetermined_coeffs():
+    assert solve_undetermined_coeffs(
+        a*x**2 + b*x**2 + b*x + 2*c*x + c + 1, [a, b, c], x
+        ) == {a: -2, b: 2, c: -1}
+    # Test that rational functions work
+    assert solve_undetermined_coeffs(a/x + b/(x + 1)
+        - (2*x + 1)/(x**2 + x), [a, b], x) == {a: 1, b: 1}
+    # Test cancellation in rational functions
+    assert solve_undetermined_coeffs(
+        ((c + 1)*a*x**2 + (c + 1)*b*x**2 +
+        (c + 1)*b*x + (c + 1)*2*c*x + (c + 1)**2)/(c + 1),
+        [a, b, c], x) == \
+        {a: -2, b: 2, c: -1}
+    # multivariate
+    X, Y, Z = y, x**y, y*x**y
+    eq = a*X + b*Y + c*Z - X - 2*Y - 3*Z
+    coeffs = a, b, c
+    syms = x, y
+    assert solve_undetermined_coeffs(eq, coeffs) == {
+        a: 1, b: 2, c: 3}
+    assert solve_undetermined_coeffs(eq, coeffs, syms) == {
+        a: 1, b: 2, c: 3}
+    assert solve_undetermined_coeffs(eq, coeffs, *syms) == {
+        a: 1, b: 2, c: 3}
+    # check output format
+    assert solve_undetermined_coeffs(a*x + a - 2, [a]) == []
+    assert solve_undetermined_coeffs(a**2*x - 4*x, [a]) == [
+        {a: -2}, {a: 2}]
+    assert solve_undetermined_coeffs(0, [a]) == []
+    assert solve_undetermined_coeffs(0, [a], dict=True) == []
+    assert solve_undetermined_coeffs(0, [a], set=True) == ([], {})
+    assert solve_undetermined_coeffs(1, [a]) == []
+    abeq = a*x - 2*x + b - 3
+    s = {b, a}
+    assert solve_undetermined_coeffs(abeq, s, x) == {a: 2, b: 3}
+    assert solve_undetermined_coeffs(abeq, s, x, set=True) == ([a, b], {(2, 3)})
+    assert solve_undetermined_coeffs(sin(a*x) - sin(2*x), (a,)) is None
+    assert solve_undetermined_coeffs(a*x + b*x - 2*x, (a, b)) == {a: 2 - b}
+
+
+def test_solve_inequalities():
+    x = Symbol('x')
+    sol = And(S.Zero < x, x < oo)
+    assert solve(x + 1 > 1) == sol
+    assert solve([x + 1 > 1]) == sol
+    assert solve([x + 1 > 1], x) == sol
+    assert solve([x + 1 > 1], [x]) == sol
+
+    system = [Lt(x**2 - 2, 0), Gt(x**2 - 1, 0)]
+    assert solve(system) == \
+        And(Or(And(Lt(-sqrt(2), x), Lt(x, -1)),
+               And(Lt(1, x), Lt(x, sqrt(2)))), Eq(0, 0))
+
+    x = Symbol('x', real=True)
+    system = [Lt(x**2 - 2, 0), Gt(x**2 - 1, 0)]
+    assert solve(system) == \
+        Or(And(Lt(-sqrt(2), x), Lt(x, -1)), And(Lt(1, x), Lt(x, sqrt(2))))
+
+    # issues 6627, 3448
+    assert solve((x - 3)/(x - 2) < 0, x) == And(Lt(2, x), Lt(x, 3))
+    assert solve(x/(x + 1) > 1, x) == And(Lt(-oo, x), Lt(x, -1))
+
+    assert solve(sin(x) > S.Half) == And(pi/6 < x, x < pi*Rational(5, 6))
+
+    assert solve(Eq(False, x < 1)) == (S.One <= x) & (x < oo)
+    assert solve(Eq(True, x < 1)) == (-oo < x) & (x < 1)
+    assert solve(Eq(x < 1, False)) == (S.One <= x) & (x < oo)
+    assert solve(Eq(x < 1, True)) == (-oo < x) & (x < 1)
+
+    assert solve(Eq(False, x)) == False
+    assert solve(Eq(0, x)) == [0]
+    assert solve(Eq(True, x)) == True
+    assert solve(Eq(1, x)) == [1]
+    assert solve(Eq(False, ~x)) == True
+    assert solve(Eq(True, ~x)) == False
+    assert solve(Ne(True, x)) == False
+    assert solve(Ne(1, x)) == (x > -oo) & (x < oo) & Ne(x, 1)
+
+
+def test_issue_4793():
+    assert solve(1/x) == []
+    assert solve(x*(1 - 5/x)) == [5]
+    assert solve(x + sqrt(x) - 2) == [1]
+    assert solve(-(1 + x)/(2 + x)**2 + 1/(2 + x)) == []
+    assert solve(-x**2 - 2*x + (x + 1)**2 - 1) == []
+    assert solve((x/(x + 1) + 3)**(-2)) == []
+    assert solve(x/sqrt(x**2 + 1), x) == [0]
+    assert solve(exp(x) - y, x) == [log(y)]
+    assert solve(exp(x)) == []
+    assert solve(x**2 + x + sin(y)**2 + cos(y)**2 - 1, x) in [[0, -1], [-1, 0]]
+    eq = 4*3**(5*x + 2) - 7
+    ans = solve(eq, x)
+    assert len(ans) == 5 and all(eq.subs(x, a).n(chop=True) == 0 for a in ans)
+    assert solve(log(x**2) - y**2/exp(x), x, y, set=True) == (
+        [x, y],
+        {(x, sqrt(exp(x) * log(x ** 2))), (x, -sqrt(exp(x) * log(x ** 2)))})
+    assert solve(x**2*z**2 - z**2*y**2) == [{x: -y}, {x: y}, {z: 0}]
+    assert solve((x - 1)/(1 + 1/(x - 1))) == []
+    assert solve(x**(y*z) - x, x) == [1]
+    raises(NotImplementedError, lambda: solve(log(x) - exp(x), x))
+    raises(NotImplementedError, lambda: solve(2**x - exp(x) - 3))
+
+
+def test_PR1964():
+    # issue 5171
+    assert solve(sqrt(x)) == solve(sqrt(x**3)) == [0]
+    assert solve(sqrt(x - 1)) == [1]
+    # issue 4462
+    a = Symbol('a')
+    assert solve(-3*a/sqrt(x), x) == []
+    # issue 4486
+    assert solve(2*x/(x + 2) - 1, x) == [2]
+    # issue 4496
+    assert set(solve((x**2/(7 - x)).diff(x))) == {S.Zero, S(14)}
+    # issue 4695
+    f = Function('f')
+    assert solve((3 - 5*x/f(x))*f(x), f(x)) == [x*Rational(5, 3)]
+    # issue 4497
+    assert solve(1/root(5 + x, 5) - 9, x) == [Rational(-295244, 59049)]
+
+    assert solve(sqrt(x) + sqrt(sqrt(x)) - 4) == [(Rational(-1, 2) + sqrt(17)/2)**4]
+    assert set(solve(Poly(sqrt(exp(x)) + sqrt(exp(-x)) - 4))) in \
+        [
+            {log((-sqrt(3) + 2)**2), log((sqrt(3) + 2)**2)},
+            {2*log(-sqrt(3) + 2), 2*log(sqrt(3) + 2)},
+            {log(-4*sqrt(3) + 7), log(4*sqrt(3) + 7)},
+        ]
+    assert set(solve(Poly(exp(x) + exp(-x) - 4))) == \
+        {log(-sqrt(3) + 2), log(sqrt(3) + 2)}
+    assert set(solve(x**y + x**(2*y) - 1, x)) == \
+        {(Rational(-1, 2) + sqrt(5)/2)**(1/y), (Rational(-1, 2) - sqrt(5)/2)**(1/y)}
+
+    assert solve(exp(x/y)*exp(-z/y) - 2, y) == [(x - z)/log(2)]
+    assert solve(
+        x**z*y**z - 2, z) in [[log(2)/(log(x) + log(y))], [log(2)/(log(x*y))]]
+    # if you do inversion too soon then multiple roots (as for the following)
+    # will be missed, e.g. if exp(3*x) = exp(3) -> 3*x = 3
+    E = S.Exp1
+    assert solve(exp(3*x) - exp(3), x) in [
+        [1, log(E*(Rational(-1, 2) - sqrt(3)*I/2)), log(E*(Rational(-1, 2) + sqrt(3)*I/2))],
+        [1, log(-E/2 - sqrt(3)*E*I/2), log(-E/2 + sqrt(3)*E*I/2)],
+        ]
+
+    # coverage test
+    p = Symbol('p', positive=True)
+    assert solve((1/p + 1)**(p + 1)) == []
+
+
+def test_issue_5197():
+    x = Symbol('x', real=True)
+    assert solve(x**2 + 1, x) == []
+    n = Symbol('n', integer=True, positive=True)
+    assert solve((n - 1)*(n + 2)*(2*n - 1), n) == [1]
+    x = Symbol('x', positive=True)
+    y = Symbol('y')
+    assert solve([x + 5*y - 2, -3*x + 6*y - 15], x, y) == []
+                 # not {x: -3, y: 1} b/c x is positive
+    # The solution following should not contain (-sqrt(2), sqrt(2))
+    assert solve([(x + y), 2 - y**2], x, y) == [(sqrt(2), -sqrt(2))]
+    y = Symbol('y', positive=True)
+    # The solution following should not contain {y: -x*exp(x/2)}
+    assert solve(x**2 - y**2/exp(x), y, x, dict=True) == [{y: x*exp(x/2)}]
+    x, y, z = symbols('x y z', positive=True)
+    assert solve(z**2*x**2 - z**2*y**2/exp(x), y, x, z, dict=True) == [{y: x*exp(x/2)}]
+
+
+def test_checking():
+    assert set(
+        solve(x*(x - y/x), x, check=False)) == {sqrt(y), S.Zero, -sqrt(y)}
+    assert set(solve(x*(x - y/x), x, check=True)) == {sqrt(y), -sqrt(y)}
+    # {x: 0, y: 4} sets denominator to 0 in the following so system should return None
+    assert solve((1/(1/x + 2), 1/(y - 3) - 1)) == []
+    # 0 sets denominator of 1/x to zero so None is returned
+    assert solve(1/(1/x + 2)) == []
+
+
+def test_issue_4671_4463_4467():
+    assert solve(sqrt(x**2 - 1) - 2) in ([sqrt(5), -sqrt(5)],
+                                           [-sqrt(5), sqrt(5)])
+    assert solve((2**exp(y**2/x) + 2)/(x**2 + 15), y) == [
+        -sqrt(x*log(1 + I*pi/log(2))), sqrt(x*log(1 + I*pi/log(2)))]
+
+    C1, C2 = symbols('C1 C2')
+    f = Function('f')
+    assert solve(C1 + C2/x**2 - exp(-f(x)), f(x)) == [log(x**2/(C1*x**2 + C2))]
+    a = Symbol('a')
+    E = S.Exp1
+    assert solve(1 - log(a + 4*x**2), x) in (
+        [-sqrt(-a + E)/2, sqrt(-a + E)/2],
+        [sqrt(-a + E)/2, -sqrt(-a + E)/2]
+    )
+    assert solve(log(a**(-3) - x**2)/a, x) in (
+        [-sqrt(-1 + a**(-3)), sqrt(-1 + a**(-3))],
+        [sqrt(-1 + a**(-3)), -sqrt(-1 + a**(-3))],)
+    assert solve(1 - log(a + 4*x**2), x) in (
+        [-sqrt(-a + E)/2, sqrt(-a + E)/2],
+        [sqrt(-a + E)/2, -sqrt(-a + E)/2],)
+    assert solve((a**2 + 1)*(sin(a*x) + cos(a*x)), x) == [-pi/(4*a)]
+    assert solve(3 - (sinh(a*x) + cosh(a*x)), x) == [log(3)/a]
+    assert set(solve(3 - (sinh(a*x) + cosh(a*x)**2), x)) == \
+        {log(-2 + sqrt(5))/a, log(-sqrt(2) + 1)/a,
+        log(-sqrt(5) - 2)/a, log(1 + sqrt(2))/a}
+    assert solve(atan(x) - 1) == [tan(1)]
+
+
+def test_issue_5132():
+    r, t = symbols('r,t')
+    assert set(solve([r - x**2 - y**2, tan(t) - y/x], [x, y])) == \
+        {(
+            -sqrt(r*cos(t)**2), -1*sqrt(r*cos(t)**2)*tan(t)),
+            (sqrt(r*cos(t)**2), sqrt(r*cos(t)**2)*tan(t))}
+    assert solve([exp(x) - sin(y), 1/y - 3], [x, y]) == \
+        [(log(sin(Rational(1, 3))), Rational(1, 3))]
+    assert solve([exp(x) - sin(y), 1/exp(y) - 3], [x, y]) == \
+        [(log(-sin(log(3))), -log(3))]
+    assert set(solve([exp(x) - sin(y), y**2 - 4], [x, y])) == \
+        {(log(-sin(2)), -S(2)), (log(sin(2)), S(2))}
+    eqs = [exp(x)**2 - sin(y) + z**2, 1/exp(y) - 3]
+    assert solve(eqs, set=True) == \
+        ([y, z], {
+        (-log(3), sqrt(-exp(2*x) - sin(log(3)))),
+        (-log(3), -sqrt(-exp(2*x) - sin(log(3))))})
+    assert solve(eqs, x, z, set=True) == (
+        [x, z],
+        {(x, sqrt(-exp(2*x) + sin(y))), (x, -sqrt(-exp(2*x) + sin(y)))})
+    assert set(solve(eqs, x, y)) == \
+        {
+            (log(-sqrt(-z**2 - sin(log(3)))), -log(3)),
+        (log(-z**2 - sin(log(3)))/2, -log(3))}
+    assert set(solve(eqs, y, z)) == \
+        {
+            (-log(3), -sqrt(-exp(2*x) - sin(log(3)))),
+        (-log(3), sqrt(-exp(2*x) - sin(log(3))))}
+    eqs = [exp(x)**2 - sin(y) + z, 1/exp(y) - 3]
+    assert solve(eqs, set=True) == ([y, z], {
+        (-log(3), -exp(2*x) - sin(log(3)))})
+    assert solve(eqs, x, z, set=True) == (
+        [x, z], {(x, -exp(2*x) + sin(y))})
+    assert set(solve(eqs, x, y)) == {
+            (log(-sqrt(-z - sin(log(3)))), -log(3)),
+            (log(-z - sin(log(3)))/2, -log(3))}
+    assert solve(eqs, z, y) == \
+        [(-exp(2*x) - sin(log(3)), -log(3))]
+    assert solve((sqrt(x**2 + y**2) - sqrt(10), x + y - 4), set=True) == (
+        [x, y], {(S.One, S(3)), (S(3), S.One)})
+    assert set(solve((sqrt(x**2 + y**2) - sqrt(10), x + y - 4), x, y)) == \
+        {(S.One, S(3)), (S(3), S.One)}
+
+
+def test_issue_5335():
+    lam, a0, conc = symbols('lam a0 conc')
+    a = 0.005
+    b = 0.743436700916726
+    eqs = [lam + 2*y - a0*(1 - x/2)*x - a*x/2*x,
+           a0*(1 - x/2)*x - 1*y - b*y,
+           x + y - conc]
+    sym = [x, y, a0]
+    # there are 4 solutions obtained manually but only two are valid
+    assert len(solve(eqs, sym, manual=True, minimal=True)) == 2
+    assert len(solve(eqs, sym)) == 2  # cf below with rational=False
+
+
+@SKIP("Hangs")
+def _test_issue_5335_float():
+    # gives ZeroDivisionError: polynomial division
+    lam, a0, conc = symbols('lam a0 conc')
+    a = 0.005
+    b = 0.743436700916726
+    eqs = [lam + 2*y - a0*(1 - x/2)*x - a*x/2*x,
+           a0*(1 - x/2)*x - 1*y - b*y,
+           x + y - conc]
+    sym = [x, y, a0]
+    assert len(solve(eqs, sym, rational=False)) == 2
+
+
+def test_issue_5767():
+    assert set(solve([x**2 + y + 4], [x])) == \
+        {(-sqrt(-y - 4),), (sqrt(-y - 4),)}
+
+
+def _make_example_24609():
+    D, R, H, B_g, V, D_c = symbols("D, R, H, B_g, V, D_c", real=True, positive=True)
+    Sigma_f, Sigma_a, nu = symbols("Sigma_f, Sigma_a, nu", real=True, positive=True)
+    x = symbols("x", real=True, positive=True)
+    eq = (
+        2**(S(2)/3)*pi**(S(2)/3)*D_c*(S(231361)/10000 + pi**2/x**2)
+        /(6*V**(S(2)/3)*x**(S(1)/3))
+      - 2**(S(2)/3)*pi**(S(8)/3)*D_c/(2*V**(S(2)/3)*x**(S(7)/3))
+    )
+    expected = 100*sqrt(2)*pi/481
+    return eq, expected, x
+
+
+def test_issue_24609():
+    # https://github.com/sympy/sympy/issues/24609
+    eq, expected, x = _make_example_24609()
+    assert solve(eq, x, simplify=True) == [expected]
+    [solapprox] = solve(eq.n(), x)
+    assert abs(solapprox - expected.n()) < 1e-14
+
+
+@XFAIL
+def test_issue_24609_xfail():
+    #
+    # This returns 5 solutions when it should be 1 (with x positive).
+    # Simplification reveals all solutions to be equivalent. It is expected
+    # that solve without simplify=True returns duplicate solutions in some
+    # cases but the core of this equation is a simple quadratic that can easily
+    # be solved without introducing any redundant solutions:
+    #
+    #     >>> print(factor_terms(eq.as_numer_denom()[0]))
+    #     2**(2/3)*pi**(2/3)*D_c*V**(2/3)*x**(7/3)*(231361*x**2 - 20000*pi**2)
+    #
+    eq, expected, x = _make_example_24609()
+    assert len(solve(eq, x)) == [expected]
+    #
+    # We do not want to pass this test just by using simplify so if the above
+    # passes then uncomment the additional test below:
+    #
+    # assert len(solve(eq, x, simplify=False)) == 1
+
+
+def test_polysys():
+    assert set(solve([x**2 + 2/y - 2, x + y - 3], [x, y])) == \
+        {(S.One, S(2)), (1 + sqrt(5), 2 - sqrt(5)),
+        (1 - sqrt(5), 2 + sqrt(5))}
+    assert solve([x**2 + y - 2, x**2 + y]) == []
+    # the ordering should be whatever the user requested
+    assert solve([x**2 + y - 3, x - y - 4], (x, y)) != solve([x**2 +
+                 y - 3, x - y - 4], (y, x))
+
+
+@slow
+def test_unrad1():
+    raises(NotImplementedError, lambda:
+        unrad(sqrt(x) + sqrt(x + 1) + sqrt(1 - sqrt(x)) + 3))
+    raises(NotImplementedError, lambda:
+        unrad(sqrt(x) + (x + 1)**Rational(1, 3) + 2*sqrt(y)))
+
+    s = symbols('s', cls=Dummy)
+
+    # checkers to deal with possibility of answer coming
+    # back with a sign change (cf issue 5203)
+    def check(rv, ans):
+        assert bool(rv[1]) == bool(ans[1])
+        if ans[1]:
+            return s_check(rv, ans)
+        e = rv[0].expand()
+        a = ans[0].expand()
+        return e in [a, -a] and rv[1] == ans[1]
+
+    def s_check(rv, ans):
+        # get the dummy
+        rv = list(rv)
+        d = rv[0].atoms(Dummy)
+        reps = list(zip(d, [s]*len(d)))
+        # replace s with this dummy
+        rv = (rv[0].subs(reps).expand(), [rv[1][0].subs(reps), rv[1][1].subs(reps)])
+        ans = (ans[0].subs(reps).expand(), [ans[1][0].subs(reps), ans[1][1].subs(reps)])
+        return str(rv[0]) in [str(ans[0]), str(-ans[0])] and \
+            str(rv[1]) == str(ans[1])
+
+    assert unrad(1) is None
+    assert check(unrad(sqrt(x)),
+        (x, []))
+    assert check(unrad(sqrt(x) + 1),
+        (x - 1, []))
+    assert check(unrad(sqrt(x) + root(x, 3) + 2),
+        (s**3 + s**2 + 2, [s, s**6 - x]))
+    assert check(unrad(sqrt(x)*root(x, 3) + 2),
+        (x**5 - 64, []))
+    assert check(unrad(sqrt(x) + (x + 1)**Rational(1, 3)),
+        (x**3 - (x + 1)**2, []))
+    assert check(unrad(sqrt(x) + sqrt(x + 1) + sqrt(2*x)),
+        (-2*sqrt(2)*x - 2*x + 1, []))
+    assert check(unrad(sqrt(x) + sqrt(x + 1) + 2),
+        (16*x - 9, []))
+    assert check(unrad(sqrt(x) + sqrt(x + 1) + sqrt(1 - x)),
+        (5*x**2 - 4*x, []))
+    assert check(unrad(a*sqrt(x) + b*sqrt(x) + c*sqrt(y) + d*sqrt(y)),
+        ((a*sqrt(x) + b*sqrt(x))**2 - (c*sqrt(y) + d*sqrt(y))**2, []))
+    assert check(unrad(sqrt(x) + sqrt(1 - x)),
+        (2*x - 1, []))
+    assert check(unrad(sqrt(x) + sqrt(1 - x) - 3),
+        (x**2 - x + 16, []))
+    assert check(unrad(sqrt(x) + sqrt(1 - x) + sqrt(2 + x)),
+        (5*x**2 - 2*x + 1, []))
+    assert unrad(sqrt(x) + sqrt(1 - x) + sqrt(2 + x) - 3) in [
+        (25*x**4 + 376*x**3 + 1256*x**2 - 2272*x + 784, []),
+        (25*x**8 - 476*x**6 + 2534*x**4 - 1468*x**2 + 169, [])]
+    assert unrad(sqrt(x) + sqrt(1 - x) + sqrt(2 + x) - sqrt(1 - 2*x)) == \
+        (41*x**4 + 40*x**3 + 232*x**2 - 160*x + 16, [])  # orig root at 0.487
+    assert check(unrad(sqrt(x) + sqrt(x + 1)), (S.One, []))
+
+    eq = sqrt(x) + sqrt(x + 1) + sqrt(1 - sqrt(x))
+    assert check(unrad(eq),
+        (16*x**2 - 9*x, []))
+    assert set(solve(eq, check=False)) == {S.Zero, Rational(9, 16)}
+    assert solve(eq) == []
+    # but this one really does have those solutions
+    assert set(solve(sqrt(x) - sqrt(x + 1) + sqrt(1 - sqrt(x)))) == \
+        {S.Zero, Rational(9, 16)}
+
+    assert check(unrad(sqrt(x) + root(x + 1, 3) + 2*sqrt(y), y),
+        (S('2*sqrt(x)*(x + 1)**(1/3) + x - 4*y + (x + 1)**(2/3)'), []))
+    assert check(unrad(sqrt(x/(1 - x)) + (x + 1)**Rational(1, 3)),
+        (x**5 - x**4 - x**3 + 2*x**2 + x - 1, []))
+    assert check(unrad(sqrt(x/(1 - x)) + 2*sqrt(y), y),
+        (4*x*y + x - 4*y, []))
+    assert check(unrad(sqrt(x)*sqrt(1 - x) + 2, x),
+        (x**2 - x + 4, []))
+
+    # http://tutorial.math.lamar.edu/
+    #        Classes/Alg/SolveRadicalEqns.aspx#Solve_Rad_Ex2_a
+    assert solve(Eq(x, sqrt(x + 6))) == [3]
+    assert solve(Eq(x + sqrt(x - 4), 4)) == [4]
+    assert solve(Eq(1, x + sqrt(2*x - 3))) == []
+    assert set(solve(Eq(sqrt(5*x + 6) - 2, x))) == {-S.One, S(2)}
+    assert set(solve(Eq(sqrt(2*x - 1) - sqrt(x - 4), 2))) == {S(5), S(13)}
+    assert solve(Eq(sqrt(x + 7) + 2, sqrt(3 - x))) == [-6]
+    # http://www.purplemath.com/modules/solverad.htm
+    assert solve((2*x - 5)**Rational(1, 3) - 3) == [16]
+    assert set(solve(x + 1 - root(x**4 + 4*x**3 - x, 4))) == \
+        {Rational(-1, 2), Rational(-1, 3)}
+    assert set(solve(sqrt(2*x**2 - 7) - (3 - x))) == {-S(8), S(2)}
+    assert solve(sqrt(2*x + 9) - sqrt(x + 1) - sqrt(x + 4)) == [0]
+    assert solve(sqrt(x + 4) + sqrt(2*x - 1) - 3*sqrt(x - 1)) == [5]
+    assert solve(sqrt(x)*sqrt(x - 7) - 12) == [16]
+    assert solve(sqrt(x - 3) + sqrt(x) - 3) == [4]
+    assert solve(sqrt(9*x**2 + 4) - (3*x + 2)) == [0]
+    assert solve(sqrt(x) - 2 - 5) == [49]
+    assert solve(sqrt(x - 3) - sqrt(x) - 3) == []
+    assert solve(sqrt(x - 1) - x + 7) == [10]
+    assert solve(sqrt(x - 2) - 5) == [27]
+    assert solve(sqrt(17*x - sqrt(x**2 - 5)) - 7) == [3]
+    assert solve(sqrt(x) - sqrt(x - 1) + sqrt(sqrt(x))) == []
+
+    # don't posify the expression in unrad and do use _mexpand
+    z = sqrt(2*x + 1)/sqrt(x) - sqrt(2 + 1/x)
+    p = posify(z)[0]
+    assert solve(p) == []
+    assert solve(z) == []
+    assert solve(z + 6*I) == [Rational(-1, 11)]
+    assert solve(p + 6*I) == []
+    # issue 8622
+    assert unrad(root(x + 1, 5) - root(x, 3)) == (
+        -(x**5 - x**3 - 3*x**2 - 3*x - 1), [])
+    # issue #8679
+    assert check(unrad(x + root(x, 3) + root(x, 3)**2 + sqrt(y), x),
+        (s**3 + s**2 + s + sqrt(y), [s, s**3 - x]))
+
+    # for coverage
+    assert check(unrad(sqrt(x) + root(x, 3) + y),
+        (s**3 + s**2 + y, [s, s**6 - x]))
+    assert solve(sqrt(x) + root(x, 3) - 2) == [1]
+    raises(NotImplementedError, lambda:
+        solve(sqrt(x) + root(x, 3) + root(x + 1, 5) - 2))
+    # fails through a different code path
+    raises(NotImplementedError, lambda: solve(-sqrt(2) + cosh(x)/x))
+    # unrad some
+    assert solve(sqrt(x + root(x, 3))+root(x - y, 5), y) == [
+        x + (x**Rational(1, 3) + x)**Rational(5, 2)]
+    assert check(unrad(sqrt(x) - root(x + 1, 3)*sqrt(x + 2) + 2),
+        (s**10 + 8*s**8 + 24*s**6 - 12*s**5 - 22*s**4 - 160*s**3 - 212*s**2 -
+        192*s - 56, [s, s**2 - x]))
+    e = root(x + 1, 3) + root(x, 3)
+    assert unrad(e) == (2*x + 1, [])
+    eq = (sqrt(x) + sqrt(x + 1) + sqrt(1 - x) - 6*sqrt(5)/5)
+    assert check(unrad(eq),
+        (15625*x**4 + 173000*x**3 + 355600*x**2 - 817920*x + 331776, []))
+    assert check(unrad(root(x, 4) + root(x, 4)**3 - 1),
+        (s**3 + s - 1, [s, s**4 - x]))
+    assert check(unrad(root(x, 2) + root(x, 2)**3 - 1),
+        (x**3 + 2*x**2 + x - 1, []))
+    assert unrad(x**0.5) is None
+    assert check(unrad(t + root(x + y, 5) + root(x + y, 5)**3),
+        (s**3 + s + t, [s, s**5 - x - y]))
+    assert check(unrad(x + root(x + y, 5) + root(x + y, 5)**3, y),
+        (s**3 + s + x, [s, s**5 - x - y]))
+    assert check(unrad(x + root(x + y, 5) + root(x + y, 5)**3, x),
+        (s**5 + s**3 + s - y, [s, s**5 - x - y]))
+    assert check(unrad(root(x - 1, 3) + root(x + 1, 5) + root(2, 5)),
+        (s**5 + 5*2**Rational(1, 5)*s**4 + s**3 + 10*2**Rational(2, 5)*s**3 +
+        10*2**Rational(3, 5)*s**2 + 5*2**Rational(4, 5)*s + 4, [s, s**3 - x + 1]))
+    raises(NotImplementedError, lambda:
+        unrad((root(x, 2) + root(x, 3) + root(x, 4)).subs(x, x**5 - x + 1)))
+
+    # the simplify flag should be reset to False for unrad results;
+    # if it's not then this next test will take a long time
+    assert solve(root(x, 3) + root(x, 5) - 2) == [1]
+    eq = (sqrt(x) + sqrt(x + 1) + sqrt(1 - x) - 6*sqrt(5)/5)
+    assert check(unrad(eq),
+        ((5*x - 4)*(3125*x**3 + 37100*x**2 + 100800*x - 82944), []))
+    ans = S('''
+        [4/5, -1484/375 + 172564/(140625*(114*sqrt(12657)/78125 +
+        12459439/52734375)**(1/3)) +
+        4*(114*sqrt(12657)/78125 + 12459439/52734375)**(1/3)]''')
+    assert solve(eq) == ans
+    # duplicate radical handling
+    assert check(unrad(sqrt(x + root(x + 1, 3)) - root(x + 1, 3) - 2),
+        (s**3 - s**2 - 3*s - 5, [s, s**3 - x - 1]))
+    # cov post-processing
+    e = root(x**2 + 1, 3) - root(x**2 - 1, 5) - 2
+    assert check(unrad(e),
+        (s**5 - 10*s**4 + 39*s**3 - 80*s**2 + 80*s - 30,
+        [s, s**3 - x**2 - 1]))
+
+    e = sqrt(x + root(x + 1, 2)) - root(x + 1, 3) - 2
+    assert check(unrad(e),
+        (s**6 - 2*s**5 - 7*s**4 - 3*s**3 + 26*s**2 + 40*s + 25,
+        [s, s**3 - x - 1]))
+    assert check(unrad(e, _reverse=True),
+        (s**6 - 14*s**5 + 73*s**4 - 187*s**3 + 276*s**2 - 228*s + 89,
+        [s, s**2 - x - sqrt(x + 1)]))
+    # this one needs r0, r1 reversal to work
+    assert check(unrad(sqrt(x + sqrt(root(x, 3) - 1)) - root(x, 6) - 2),
+        (s**12 - 2*s**8 - 8*s**7 - 8*s**6 + s**4 + 8*s**3 + 23*s**2 +
+        32*s + 17, [s, s**6 - x]))
+
+    # why does this pass
+    assert unrad(root(cosh(x), 3)/x*root(x + 1, 5) - 1) == (
+        -(x**15 - x**3*cosh(x)**5 - 3*x**2*cosh(x)**5 - 3*x*cosh(x)**5
+        - cosh(x)**5), [])
+    # and this fail?
+    #assert unrad(sqrt(cosh(x)/x) + root(x + 1, 3)*sqrt(x) - 1) == (
+    #    -s**6 + 6*s**5 - 15*s**4 + 20*s**3 - 15*s**2 + 6*s + x**5 +
+    #    2*x**4 + x**3 - 1, [s, s**2 - cosh(x)/x])
+
+    # watch for symbols in exponents
+    assert unrad(S('(x+y)**(2*y/3) + (x+y)**(1/3) + 1')) is None
+    assert check(unrad(S('(x+y)**(2*y/3) + (x+y)**(1/3) + 1'), x),
+        (s**(2*y) + s + 1, [s, s**3 - x - y]))
+    # should _Q be so lenient?
+    assert unrad(x**(S.Half/y) + y, x) == (x**(1/y) - y**2, [])
+
+    # This tests two things: that if full unrad is attempted and fails
+    # the solution should still be found; also it tests that the use of
+    # composite
+    assert len(solve(sqrt(y)*x + x**3 - 1, x)) == 3
+    assert len(solve(-512*y**3 + 1344*(x + 2)**Rational(1, 3)*y**2 -
+        1176*(x + 2)**Rational(2, 3)*y - 169*x + 686, y, _unrad=False)) == 3
+
+    # watch out for when the cov doesn't involve the symbol of interest
+    eq = S('-x + (7*y/8 - (27*x/2 + 27*sqrt(x**2)/2)**(1/3)/3)**3 - 1')
+    assert solve(eq, y) == [
+        2**(S(2)/3)*(27*x + 27*sqrt(x**2))**(S(1)/3)*S(4)/21 + (512*x/343 +
+        S(512)/343)**(S(1)/3)*(-S(1)/2 - sqrt(3)*I/2), 2**(S(2)/3)*(27*x +
+        27*sqrt(x**2))**(S(1)/3)*S(4)/21 + (512*x/343 +
+        S(512)/343)**(S(1)/3)*(-S(1)/2 + sqrt(3)*I/2), 2**(S(2)/3)*(27*x +
+        27*sqrt(x**2))**(S(1)/3)*S(4)/21 + (512*x/343 + S(512)/343)**(S(1)/3)]
+
+    eq = root(x + 1, 3) - (root(x, 3) + root(x, 5))
+    assert check(unrad(eq),
+        (3*s**13 + 3*s**11 + s**9 - 1, [s, s**15 - x]))
+    assert check(unrad(eq - 2),
+        (3*s**13 + 3*s**11 + 6*s**10 + s**9 + 12*s**8 + 6*s**6 + 12*s**5 +
+        12*s**3 + 7, [s, s**15 - x]))
+    assert check(unrad(root(x, 3) - root(x + 1, 4)/2 + root(x + 2, 3)),
+        (s*(4096*s**9 + 960*s**8 + 48*s**7 - s**6 - 1728),
+        [s, s**4 - x - 1]))  # orig expr has two real roots: -1, -.389
+    assert check(unrad(root(x, 3) + root(x + 1, 4) - root(x + 2, 3)/2),
+        (343*s**13 + 2904*s**12 + 1344*s**11 + 512*s**10 - 1323*s**9 -
+        3024*s**8 - 1728*s**7 + 1701*s**5 + 216*s**4 - 729*s, [s, s**4 - x -
+        1]))  # orig expr has one real root: -0.048
+    assert check(unrad(root(x, 3)/2 - root(x + 1, 4) + root(x + 2, 3)),
+        (729*s**13 - 216*s**12 + 1728*s**11 - 512*s**10 + 1701*s**9 -
+        3024*s**8 + 1344*s**7 + 1323*s**5 - 2904*s**4 + 343*s, [s, s**4 - x -
+        1]))  # orig expr has 2 real roots: -0.91, -0.15
+    assert check(unrad(root(x, 3)/2 - root(x + 1, 4) + root(x + 2, 3) - 2),
+        (729*s**13 + 1242*s**12 + 18496*s**10 + 129701*s**9 + 388602*s**8 +
+        453312*s**7 - 612864*s**6 - 3337173*s**5 - 6332418*s**4 - 7134912*s**3
+        - 5064768*s**2 - 2111913*s - 398034, [s, s**4 - x - 1]))
+        # orig expr has 1 real root: 19.53
+
+    ans = solve(sqrt(x) + sqrt(x + 1) -
+                sqrt(1 - x) - sqrt(2 + x))
+    assert len(ans) == 1 and NS(ans[0])[:4] == '0.73'
+    # the fence optimization problem
+    # https://github.com/sympy/sympy/issues/4793#issuecomment-36994519
+    F = Symbol('F')
+    eq = F - (2*x + 2*y + sqrt(x**2 + y**2))
+    ans = F*Rational(2, 7) - sqrt(2)*F/14
+    X = solve(eq, x, check=False)
+    for xi in reversed(X):  # reverse since currently, ans is the 2nd one
+        Y = solve((x*y).subs(x, xi).diff(y), y, simplify=False, check=False)
+        if any((a - ans).expand().is_zero for a in Y):
+            break
+    else:
+        assert None  # no answer was found
+    assert solve(sqrt(x + 1) + root(x, 3) - 2) == S('''
+        [(-11/(9*(47/54 + sqrt(93)/6)**(1/3)) + 1/3 + (47/54 +
+        sqrt(93)/6)**(1/3))**3]''')
+    assert solve(sqrt(sqrt(x + 1)) + x**Rational(1, 3) - 2) == S('''
+        [(-sqrt(-2*(-1/16 + sqrt(6913)/16)**(1/3) + 6/(-1/16 +
+        sqrt(6913)/16)**(1/3) + 17/2 + 121/(4*sqrt(-6/(-1/16 +
+        sqrt(6913)/16)**(1/3) + 2*(-1/16 + sqrt(6913)/16)**(1/3) + 17/4)))/2 +
+        sqrt(-6/(-1/16 + sqrt(6913)/16)**(1/3) + 2*(-1/16 +
+        sqrt(6913)/16)**(1/3) + 17/4)/2 + 9/4)**3]''')
+    assert solve(sqrt(x) + root(sqrt(x) + 1, 3) - 2) == S('''
+        [(-(81/2 + 3*sqrt(741)/2)**(1/3)/3 + (81/2 + 3*sqrt(741)/2)**(-1/3) +
+        2)**2]''')
+    eq = S('''
+        -x + (1/2 - sqrt(3)*I/2)*(3*x**3/2 - x*(3*x**2 - 34)/2 + sqrt((-3*x**3
+        + x*(3*x**2 - 34) + 90)**2/4 - 39304/27) - 45)**(1/3) + 34/(3*(1/2 -
+        sqrt(3)*I/2)*(3*x**3/2 - x*(3*x**2 - 34)/2 + sqrt((-3*x**3 + x*(3*x**2
+        - 34) + 90)**2/4 - 39304/27) - 45)**(1/3))''')
+    assert check(unrad(eq),
+        (s*-(-s**6 + sqrt(3)*s**6*I - 153*2**Rational(2, 3)*3**Rational(1, 3)*s**4 +
+        51*12**Rational(1, 3)*s**4 - 102*2**Rational(2, 3)*3**Rational(5, 6)*s**4*I - 1620*s**3 +
+        1620*sqrt(3)*s**3*I + 13872*18**Rational(1, 3)*s**2 - 471648 +
+        471648*sqrt(3)*I), [s, s**3 - 306*x - sqrt(3)*sqrt(31212*x**2 -
+        165240*x + 61484) + 810]))
+
+    assert solve(eq) == [] # not other code errors
+    eq = root(x, 3) - root(y, 3) + root(x, 5)
+    assert check(unrad(eq),
+           (s**15 + 3*s**13 + 3*s**11 + s**9 - y, [s, s**15 - x]))
+    eq = root(x, 3) + root(y, 3) + root(x*y, 4)
+    assert check(unrad(eq),
+                 (s*y*(-s**12 - 3*s**11*y - 3*s**10*y**2 - s**9*y**3 -
+                       3*s**8*y**2 + 21*s**7*y**3 - 3*s**6*y**4 - 3*s**4*y**4 -
+                       3*s**3*y**5 - y**6), [s, s**4 - x*y]))
+    raises(NotImplementedError,
+           lambda: unrad(root(x, 3) + root(y, 3) + root(x*y, 5)))
+
+    # Test unrad with an Equality
+    eq = Eq(-x**(S(1)/5) + x**(S(1)/3), -3**(S(1)/3) - (-1)**(S(3)/5)*3**(S(1)/5))
+    assert check(unrad(eq),
+        (-s**5 + s**3 - 3**(S(1)/3) - (-1)**(S(3)/5)*3**(S(1)/5), [s, s**15 - x]))
+
+    # make sure buried radicals are exposed
+    s = sqrt(x) - 1
+    assert unrad(s**2 - s**3) == (x**3 - 6*x**2 + 9*x - 4, [])
+    # make sure numerators which are already polynomial are rejected
+    assert unrad((x/(x + 1) + 3)**(-2), x) is None
+
+    # https://github.com/sympy/sympy/issues/23707
+    eq = sqrt(x - y)*exp(t*sqrt(x - y)) - exp(t*sqrt(x - y))
+    assert solve(eq, y) == [x - 1]
+    assert unrad(eq) is None
+
+
+@slow
+def test_unrad_slow():
+    # this has roots with multiplicity > 1; there should be no
+    # repeats in roots obtained, however
+    eq = (sqrt(1 + sqrt(1 - 4*x**2)) - x*(1 + sqrt(1 + 2*sqrt(1 - 4*x**2))))
+    assert solve(eq) == [S.Half]
+
+
+@XFAIL
+def test_unrad_fail():
+    # this only works if we check real_root(eq.subs(x, Rational(1, 3)))
+    # but checksol doesn't work like that
+    assert solve(root(x**3 - 3*x**2, 3) + 1 - x) == [Rational(1, 3)]
+    assert solve(root(x + 1, 3) + root(x**2 - 2, 5) + 1) == [
+        -1, -1 + CRootOf(x**5 + x**4 + 5*x**3 + 8*x**2 + 10*x + 5, 0)**3]
+
+
+def test_checksol():
+    x, y, r, t = symbols('x, y, r, t')
+    eq = r - x**2 - y**2
+    dict_var_soln = {y: - sqrt(r) / sqrt(tan(t)**2 + 1),
+        x: -sqrt(r)*tan(t)/sqrt(tan(t)**2 + 1)}
+    assert checksol(eq, dict_var_soln) == True
+    assert checksol(Eq(x, False), {x: False}) is True
+    assert checksol(Ne(x, False), {x: False}) is False
+    assert checksol(Eq(x < 1, True), {x: 0}) is True
+    assert checksol(Eq(x < 1, True), {x: 1}) is False
+    assert checksol(Eq(x < 1, False), {x: 1}) is True
+    assert checksol(Eq(x < 1, False), {x: 0}) is False
+    assert checksol(Eq(x + 1, x**2 + 1), {x: 1}) is True
+    assert checksol([x - 1, x**2 - 1], x, 1) is True
+    assert checksol([x - 1, x**2 - 2], x, 1) is False
+    assert checksol(Poly(x**2 - 1), x, 1) is True
+    assert checksol(0, {}) is True
+    assert checksol([1e-10, x - 2], x, 2) is False
+    assert checksol([0.5, 0, x], x, 0) is False
+    assert checksol(y, x, 2) is False
+    assert checksol(x+1e-10, x, 0, numerical=True) is True
+    assert checksol(x+1e-10, x, 0, numerical=False) is False
+    assert checksol(exp(92*x), {x: log(sqrt(2)/2)}) is False
+    assert checksol(exp(92*x), {x: log(sqrt(2)/2) + I*pi}) is False
+    assert checksol(1/x**5, x, 1000) is False
+    raises(ValueError, lambda: checksol(x, 1))
+    raises(ValueError, lambda: checksol([], x, 1))
+
+
+def test__invert():
+    assert _invert(x - 2) == (2, x)
+    assert _invert(2) == (2, 0)
+    assert _invert(exp(1/x) - 3, x) == (1/log(3), x)
+    assert _invert(exp(1/x + a/x) - 3, x) == ((a + 1)/log(3), x)
+    assert _invert(a, x) == (a, 0)
+
+
+def test_issue_4463():
+    assert solve(-a*x + 2*x*log(x), x) == [exp(a/2)]
+    assert solve(x**x) == []
+    assert solve(x**x - 2) == [exp(LambertW(log(2)))]
+    assert solve(((x - 3)*(x - 2))**((x - 3)*(x - 4))) == [2]
+
+@slow
+def test_issue_5114_solvers():
+    a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r = symbols('a:r')
+
+    # there is no 'a' in the equation set but this is how the
+    # problem was originally posed
+    syms = a, b, c, f, h, k, n
+    eqs = [b + r/d - c/d,
+    c*(1/d + 1/e + 1/g) - f/g - r/d,
+        f*(1/g + 1/i + 1/j) - c/g - h/i,
+        h*(1/i + 1/l + 1/m) - f/i - k/m,
+        k*(1/m + 1/o + 1/p) - h/m - n/p,
+        n*(1/p + 1/q) - k/p]
+    assert len(solve(eqs, syms, manual=True, check=False, simplify=False)) == 1
+
+
+def test_issue_5849():
+    #
+    # XXX: This system does not have a solution for most values of the
+    # parameters. Generally solve returns the empty set for systems that are
+    # generically inconsistent.
+    #
+    I1, I2, I3, I4, I5, I6 = symbols('I1:7')
+    dI1, dI4, dQ2, dQ4, Q2, Q4 = symbols('dI1,dI4,dQ2,dQ4,Q2,Q4')
+
+    e = (
+        I1 - I2 - I3,
+        I3 - I4 - I5,
+        I4 + I5 - I6,
+        -I1 + I2 + I6,
+        -2*I1 - 2*I3 - 2*I5 - 3*I6 - dI1/2 + 12,
+        -I4 + dQ4,
+        -I2 + dQ2,
+        2*I3 + 2*I5 + 3*I6 - Q2,
+        I4 - 2*I5 + 2*Q4 + dI4
+    )
+
+    ans = [{
+    I1: I2 + I3,
+    dI1: -4*I2 - 8*I3 - 4*I5 - 6*I6 + 24,
+    I4: I3 - I5,
+    dQ4: I3 - I5,
+    Q4: -I3/2 + 3*I5/2 - dI4/2,
+    dQ2: I2,
+    Q2: 2*I3 + 2*I5 + 3*I6}]
+
+    v = I1, I4, Q2, Q4, dI1, dI4, dQ2, dQ4
+    assert solve(e, *v, manual=True, check=False, dict=True) == ans
+    assert solve(e, *v, manual=True, check=False) == [
+        tuple([a.get(i, i) for i in v]) for a in ans]
+    assert solve(e, *v, manual=True) == []
+    assert solve(e, *v) == []
+
+    # the matrix solver (tested below) doesn't like this because it produces
+    # a zero row in the matrix. Is this related to issue 4551?
+    assert [ei.subs(
+        ans[0]) for ei in e] == [0, 0, I3 - I6, -I3 + I6, 0, 0, 0, 0, 0]
+
+
+def test_issue_5849_matrix():
+    '''Same as test_issue_5849 but solved with the matrix solver.
+
+    A solution only exists if I3 == I6 which is not generically true,
+    but `solve` does not return conditions under which the solution is
+    valid, only a solution that is canonical and consistent with the input.
+    '''
+    # a simple example with the same issue
+    # assert solve([x+y+z, x+y], [x, y]) == {x: y}
+    # the longer example
+    I1, I2, I3, I4, I5, I6 = symbols('I1:7')
+    dI1, dI4, dQ2, dQ4, Q2, Q4 = symbols('dI1,dI4,dQ2,dQ4,Q2,Q4')
+
+    e = (
+        I1 - I2 - I3,
+        I3 - I4 - I5,
+        I4 + I5 - I6,
+        -I1 + I2 + I6,
+        -2*I1 - 2*I3 - 2*I5 - 3*I6 - dI1/2 + 12,
+        -I4 + dQ4,
+        -I2 + dQ2,
+        2*I3 + 2*I5 + 3*I6 - Q2,
+        I4 - 2*I5 + 2*Q4 + dI4
+    )
+    assert solve(e, I1, I4, Q2, Q4, dI1, dI4, dQ2, dQ4) == []
+
+
+def test_issue_21882():
+
+    a, b, c, d, f, g, k = unknowns = symbols('a, b, c, d, f, g, k')
+
+    equations = [
+        -k*a + b + 5*f/6 + 2*c/9 + 5*d/6 + 4*a/3,
+        -k*f + 4*f/3 + d/2,
+        -k*d + f/6 + d,
+        13*b/18 + 13*c/18 + 13*a/18,
+        -k*c + b/2 + 20*c/9 + a,
+        -k*b + b + c/18 + a/6,
+        5*b/3 + c/3 + a,
+        2*b/3 + 2*c + 4*a/3,
+        -g,
+    ]
+
+    answer = [
+        {a: 0, f: 0, b: 0, d: 0, c: 0, g: 0},
+        {a: 0, f: -d, b: 0, k: S(5)/6, c: 0, g: 0},
+        {a: -2*c, f: 0, b: c, d: 0, k: S(13)/18, g: 0}]
+    # but not {a: 0, f: 0, b: 0, k: S(3)/2, c: 0, d: 0, g: 0}
+    # since this is already covered by the first solution
+    got = solve(equations, unknowns, dict=True)
+    assert got == answer, (got,answer)
+
+
+def test_issue_5901():
+    f, g, h = map(Function, 'fgh')
+    a = Symbol('a')
+    D = Derivative(f(x), x)
+    G = Derivative(g(a), a)
+    assert solve(f(x) + f(x).diff(x), f(x)) == \
+        [-D]
+    assert solve(f(x) - 3, f(x)) == \
+        [3]
+    assert solve(f(x) - 3*f(x).diff(x), f(x)) == \
+        [3*D]
+    assert solve([f(x) - 3*f(x).diff(x)], f(x)) == \
+        {f(x): 3*D}
+    assert solve([f(x) - 3*f(x).diff(x), f(x)**2 - y + 4], f(x), y) == \
+        [(3*D, 9*D**2 + 4)]
+    assert solve(-f(a)**2*g(a)**2 + f(a)**2*h(a)**2 + g(a).diff(a),
+                h(a), g(a), set=True) == \
+        ([h(a), g(a)], {
+        (-sqrt(f(a)**2*g(a)**2 - G)/f(a), g(a)),
+        (sqrt(f(a)**2*g(a)**2 - G)/f(a), g(a))}), solve(-f(a)**2*g(a)**2 + f(a)**2*h(a)**2 + g(a).diff(a),
+                h(a), g(a), set=True)
+    args = [[f(x).diff(x, 2)*(f(x) + g(x)), 2 - g(x)**2], f(x), g(x)]
+    assert solve(*args, set=True)[1] == \
+        {(-sqrt(2), sqrt(2)), (sqrt(2), -sqrt(2))}
+    eqs = [f(x)**2 + g(x) - 2*f(x).diff(x), g(x)**2 - 4]
+    assert solve(eqs, f(x), g(x), set=True) == \
+        ([f(x), g(x)], {
+        (-sqrt(2*D - 2), S(2)),
+        (sqrt(2*D - 2), S(2)),
+        (-sqrt(2*D + 2), -S(2)),
+        (sqrt(2*D + 2), -S(2))})
+
+    # the underlying problem was in solve_linear that was not masking off
+    # anything but a Mul or Add; it now raises an error if it gets anything
+    # but a symbol and solve handles the substitutions necessary so solve_linear
+    # won't make this error
+    raises(
+        ValueError, lambda: solve_linear(f(x) + f(x).diff(x), symbols=[f(x)]))
+    assert solve_linear(f(x) + f(x).diff(x), symbols=[x]) == \
+        (f(x) + Derivative(f(x), x), 1)
+    assert solve_linear(f(x) + Integral(x, (x, y)), symbols=[x]) == \
+        (f(x) + Integral(x, (x, y)), 1)
+    assert solve_linear(f(x) + Integral(x, (x, y)) + x, symbols=[x]) == \
+        (x + f(x) + Integral(x, (x, y)), 1)
+    assert solve_linear(f(y) + Integral(x, (x, y)) + x, symbols=[x]) == \
+        (x, -f(y) - Integral(x, (x, y)))
+    assert solve_linear(x - f(x)/a + (f(x) - 1)/a, symbols=[x]) == \
+        (x, 1/a)
+    assert solve_linear(x + Derivative(2*x, x)) == \
+        (x, -2)
+    assert solve_linear(x + Integral(x, y), symbols=[x]) == \
+        (x, 0)
+    assert solve_linear(x + Integral(x, y) - 2, symbols=[x]) == \
+        (x, 2/(y + 1))
+
+    assert set(solve(x + exp(x)**2, exp(x))) == \
+        {-sqrt(-x), sqrt(-x)}
+    assert solve(x + exp(x), x, implicit=True) == \
+        [-exp(x)]
+    assert solve(cos(x) - sin(x), x, implicit=True) == []
+    assert solve(x - sin(x), x, implicit=True) == \
+        [sin(x)]
+    assert solve(x**2 + x - 3, x, implicit=True) == \
+        [-x**2 + 3]
+    assert solve(x**2 + x - 3, x**2, implicit=True) == \
+        [-x + 3]
+
+
+def test_issue_5912():
+    assert set(solve(x**2 - x - 0.1, rational=True)) == \
+        {S.Half + sqrt(35)/10, -sqrt(35)/10 + S.Half}
+    ans = solve(x**2 - x - 0.1, rational=False)
+    assert len(ans) == 2 and all(a.is_Number for a in ans)
+    ans = solve(x**2 - x - 0.1)
+    assert len(ans) == 2 and all(a.is_Number for a in ans)
+
+
+def test_float_handling():
+    def test(e1, e2):
+        return len(e1.atoms(Float)) == len(e2.atoms(Float))
+    assert solve(x - 0.5, rational=True)[0].is_Rational
+    assert solve(x - 0.5, rational=False)[0].is_Float
+    assert solve(x - S.Half, rational=False)[0].is_Rational
+    assert solve(x - 0.5, rational=None)[0].is_Float
+    assert solve(x - S.Half, rational=None)[0].is_Rational
+    assert test(nfloat(1 + 2*x), 1.0 + 2.0*x)
+    for contain in [list, tuple, set]:
+        ans = nfloat(contain([1 + 2*x]))
+        assert type(ans) is contain and test(list(ans)[0], 1.0 + 2.0*x)
+    k, v = list(nfloat({2*x: [1 + 2*x]}).items())[0]
+    assert test(k, 2*x) and test(v[0], 1.0 + 2.0*x)
+    assert test(nfloat(cos(2*x)), cos(2.0*x))
+    assert test(nfloat(3*x**2), 3.0*x**2)
+    assert test(nfloat(3*x**2, exponent=True), 3.0*x**2.0)
+    assert test(nfloat(exp(2*x)), exp(2.0*x))
+    assert test(nfloat(x/3), x/3.0)
+    assert test(nfloat(x**4 + 2*x + cos(Rational(1, 3)) + 1),
+            x**4 + 2.0*x + 1.94495694631474)
+    # don't call nfloat if there is no solution
+    tot = 100 + c + z + t
+    assert solve(((.7 + c)/tot - .6, (.2 + z)/tot - .3, t/tot - .1)) == []
+
+
+def test_check_assumptions():
+    x = symbols('x', positive=True)
+    assert solve(x**2 - 1) == [1]
+
+
+def test_issue_6056():
+    assert solve(tanh(x + 3)*tanh(x - 3) - 1) == []
+    assert solve(tanh(x - 1)*tanh(x + 1) + 1) == \
+            [I*pi*Rational(-3, 4), -I*pi/4, I*pi/4, I*pi*Rational(3, 4)]
+    assert solve((tanh(x + 3)*tanh(x - 3) + 1)**2) == \
+            [I*pi*Rational(-3, 4), -I*pi/4, I*pi/4, I*pi*Rational(3, 4)]
+
+
+def test_issue_5673():
+    eq = -x + exp(exp(LambertW(log(x)))*LambertW(log(x)))
+    assert checksol(eq, x, 2) is True
+    assert checksol(eq, x, 2, numerical=False) is None
+
+
+def test_exclude():
+    R, C, Ri, Vout, V1, Vminus, Vplus, s = \
+        symbols('R, C, Ri, Vout, V1, Vminus, Vplus, s')
+    Rf = symbols('Rf', positive=True)  # to eliminate Rf = 0 soln
+    eqs = [C*V1*s + Vplus*(-2*C*s - 1/R),
+           Vminus*(-1/Ri - 1/Rf) + Vout/Rf,
+           C*Vplus*s + V1*(-C*s - 1/R) + Vout/R,
+           -Vminus + Vplus]
+    assert solve(eqs, exclude=s*C*R) == [
+        {
+            Rf: Ri*(C*R*s + 1)**2/(C*R*s),
+            Vminus: Vplus,
+            V1: 2*Vplus + Vplus/(C*R*s),
+            Vout: C*R*Vplus*s + 3*Vplus + Vplus/(C*R*s)},
+        {
+            Vplus: 0,
+            Vminus: 0,
+            V1: 0,
+            Vout: 0},
+    ]
+
+    # TODO: Investigate why currently solution [0] is preferred over [1].
+    assert solve(eqs, exclude=[Vplus, s, C]) in [[{
+        Vminus: Vplus,
+        V1: Vout/2 + Vplus/2 + sqrt((Vout - 5*Vplus)*(Vout - Vplus))/2,
+        R: (Vout - 3*Vplus - sqrt(Vout**2 - 6*Vout*Vplus + 5*Vplus**2))/(2*C*Vplus*s),
+        Rf: Ri*(Vout - Vplus)/Vplus,
+    }, {
+        Vminus: Vplus,
+        V1: Vout/2 + Vplus/2 - sqrt((Vout - 5*Vplus)*(Vout - Vplus))/2,
+        R: (Vout - 3*Vplus + sqrt(Vout**2 - 6*Vout*Vplus + 5*Vplus**2))/(2*C*Vplus*s),
+        Rf: Ri*(Vout - Vplus)/Vplus,
+    }], [{
+        Vminus: Vplus,
+        Vout: (V1**2 - V1*Vplus - Vplus**2)/(V1 - 2*Vplus),
+        Rf: Ri*(V1 - Vplus)**2/(Vplus*(V1 - 2*Vplus)),
+        R: Vplus/(C*s*(V1 - 2*Vplus)),
+    }]]
+
+
+def test_high_order_roots():
+    s = x**5 + 4*x**3 + 3*x**2 + Rational(7, 4)
+    assert set(solve(s)) == set(Poly(s*4, domain='ZZ').all_roots())
+
+
+def test_minsolve_linear_system():
+    pqt = {"quick": True, "particular": True}
+    pqf = {"quick": False, "particular": True}
+    assert solve([x + y - 5, 2*x - y - 1], **pqt) == {x: 2, y: 3}
+    assert solve([x + y - 5, 2*x - y - 1], **pqf) == {x: 2, y: 3}
+    def count(dic):
+        return len([x for x in dic.values() if x == 0])
+    assert count(solve([x + y + z, y + z + a + t], **pqt)) == 3
+    assert count(solve([x + y + z, y + z + a + t], **pqf)) == 3
+    assert count(solve([x + y + z, y + z + a], **pqt)) == 1
+    assert count(solve([x + y + z, y + z + a], **pqf)) == 2
+    # issue 22718
+    A = Matrix([
+        [ 1,  1,  1,  0,  1,  1,  0,  1,  0,  0,  1,  1,  1,  0],
+        [ 1,  1,  0,  1,  1,  0,  1,  0,  1,  0, -1, -1,  0,  0],
+        [-1, -1,  0,  0, -1,  0,  0,  0,  0,  0,  1,  1,  0,  1],
+        [ 1,  0,  1,  1,  0,  1,  1,  0,  0,  1, -1,  0, -1,  0],
+        [-1,  0, -1,  0,  0, -1,  0,  0,  0,  0,  1,  0,  1,  1],
+        [-1,  0,  0, -1,  0,  0, -1,  0,  0,  0, -1,  0,  0, -1],
+        [ 0,  1,  1,  1,  0,  0,  0,  1,  1,  1,  0, -1, -1,  0],
+        [ 0, -1, -1,  0,  0,  0,  0, -1,  0,  0,  0,  1,  1,  1],
+        [ 0, -1,  0, -1,  0,  0,  0,  0, -1,  0,  0, -1,  0, -1],
+        [ 0,  0, -1, -1,  0,  0,  0,  0,  0, -1,  0,  0, -1, -1],
+        [ 0,  0,  0,  0,  1,  1,  1,  1,  1,  1,  0,  0,  0,  0],
+        [ 0,  0,  0,  0, -1, -1,  0, -1,  0,  0,  0,  0,  0,  0]])
+    v = Matrix(symbols("v:14", integer=True))
+    B = Matrix([[2], [-2], [0], [0], [0], [0], [0], [0], [0],
+        [0], [0], [0]])
+    eqs = A@v-B
+    assert solve(eqs) == []
+    assert solve(eqs, particular=True) == []  # assumption violated
+    assert all(v for v in solve([x + y + z, y + z + a]).values())
+    for _q in (True, False):
+        assert not all(v for v in solve(
+            [x + y + z, y + z + a], quick=_q,
+            particular=True).values())
+        # raise error if quick used w/o particular=True
+        raises(ValueError, lambda: solve([x + 1], quick=_q))
+        raises(ValueError, lambda: solve([x + 1], quick=_q, particular=False))
+    # and give a good error message if someone tries to use
+    # particular with a single equation
+    raises(ValueError, lambda: solve(x + 1, particular=True))
+
+
+def test_real_roots():
+    # cf. issue 6650
+    x = Symbol('x', real=True)
+    assert len(solve(x**5 + x**3 + 1)) == 1
+
+
+def test_issue_6528():
+    eqs = [
+        327600995*x**2 - 37869137*x + 1809975124*y**2 - 9998905626,
+        895613949*x**2 - 273830224*x*y + 530506983*y**2 - 10000000000]
+    # two expressions encountered are > 1400 ops long so if this hangs
+    # it is likely because simplification is being done
+    assert len(solve(eqs, y, x, check=False)) == 4
+
+
+def test_overdetermined():
+    x = symbols('x', real=True)
+    eqs = [Abs(4*x - 7) - 5, Abs(3 - 8*x) - 1]
+    assert solve(eqs, x) == [(S.Half,)]
+    assert solve(eqs, x, manual=True) == [(S.Half,)]
+    assert solve(eqs, x, manual=True, check=False) == [(S.Half,), (S(3),)]
+
+
+def test_issue_6605():
+    x = symbols('x')
+    assert solve(4**(x/2) - 2**(x/3)) == [0, 3*I*pi/log(2)]
+    # while the first one passed, this one failed
+    x = symbols('x', real=True)
+    assert solve(5**(x/2) - 2**(x/3)) == [0]
+    b = sqrt(6)*sqrt(log(2))/sqrt(log(5))
+    assert solve(5**(x/2) - 2**(3/x)) == [-b, b]
+
+
+def test__ispow():
+    assert _ispow(x**2)
+    assert not _ispow(x)
+    assert not _ispow(True)
+
+
+def test_issue_6644():
+    eq = -sqrt((m - q)**2 + (-m/(2*q) + S.Half)**2) + sqrt((-m**2/2 - sqrt(
+    4*m**4 - 4*m**2 + 8*m + 1)/4 - Rational(1, 4))**2 + (m**2/2 - m - sqrt(
+    4*m**4 - 4*m**2 + 8*m + 1)/4 - Rational(1, 4))**2)
+    sol = solve(eq, q, simplify=False, check=False)
+    assert len(sol) == 5
+
+
+def test_issue_6752():
+    assert solve([a**2 + a, a - b], [a, b]) == [(-1, -1), (0, 0)]
+    assert solve([a**2 + a*c, a - b], [a, b]) == [(0, 0), (-c, -c)]
+
+
+def test_issue_6792():
+    assert solve(x*(x - 1)**2*(x + 1)*(x**6 - x + 1)) == [
+        -1, 0, 1, CRootOf(x**6 - x + 1, 0), CRootOf(x**6 - x + 1, 1),
+         CRootOf(x**6 - x + 1, 2), CRootOf(x**6 - x + 1, 3),
+         CRootOf(x**6 - x + 1, 4), CRootOf(x**6 - x + 1, 5)]
+
+
+def test_issues_6819_6820_6821_6248_8692_25777_25779():
+    # issue 6821
+    x, y = symbols('x y', real=True)
+    assert solve(abs(x + 3) - 2*abs(x - 3)) == [1, 9]
+    assert solve([abs(x) - 2, arg(x) - pi], x) == [(-2,)]
+    assert set(solve(abs(x - 7) - 8)) == {-S.One, S(15)}
+
+    # issue 8692
+    assert solve(Eq(Abs(x + 1) + Abs(x**2 - 7), 9), x) == [
+        Rational(-1, 2) + sqrt(61)/2, -sqrt(69)/2 + S.Half]
+
+    # issue 7145
+    assert solve(2*abs(x) - abs(x - 1)) == [-1, Rational(1, 3)]
+
+    # 25777
+    assert solve(abs(x**3 + x + 2)/(x + 1)) == []
+
+    # 25779
+    assert solve(abs(x)) == [0]
+    assert solve(Eq(abs(x**2 - 2*x), 4), x) == [
+        1 - sqrt(5), 1 + sqrt(5)]
+    nn = symbols('nn', nonnegative=True)
+    assert solve(abs(sqrt(nn))) == [0]
+    nz = symbols('nz', nonzero=True)
+    assert solve(Eq(Abs(4 + 1 / (4*nz)), 0)) == [-Rational(1, 16)]
+
+    x = symbols('x')
+    assert solve([re(x) - 1, im(x) - 2], x) == [
+        {x: 1 + 2*I, re(x): 1, im(x): 2}]
+
+    # check for 'dict' handling of solution
+    eq = sqrt(re(x)**2 + im(x)**2) - 3
+    assert solve(eq) == solve(eq, x)
+
+    i = symbols('i', imaginary=True)
+    assert solve(abs(i) - 3) == [-3*I, 3*I]
+    raises(NotImplementedError, lambda: solve(abs(x) - 3))
+
+    w = symbols('w', integer=True)
+    assert solve(2*x**w - 4*y**w, w) == solve((x/y)**w - 2, w)
+
+    x, y = symbols('x y', real=True)
+    assert solve(x + y*I + 3) == {y: 0, x: -3}
+    # issue 2642
+    assert solve(x*(1 + I)) == [0]
+
+    x, y = symbols('x y', imaginary=True)
+    assert solve(x + y*I + 3 + 2*I) == {x: -2*I, y: 3*I}
+
+    x = symbols('x', real=True)
+    assert solve(x + y + 3 + 2*I) == {x: -3, y: -2*I}
+
+    # issue 6248
+    f = Function('f')
+    assert solve(f(x + 1) - f(2*x - 1)) == [2]
+    assert solve(log(x + 1) - log(2*x - 1)) == [2]
+
+    x = symbols('x')
+    assert solve(2**x + 4**x) == [I*pi/log(2)]
+
+def test_issue_17638():
+
+    assert solve(((2-exp(2*x))*exp(x))/(exp(2*x)+2)**2 > 0, x) == (-oo < x) & (x < log(2)/2)
+    assert solve(((2-exp(2*x)+2)*exp(x+2))/(exp(x)+2)**2 > 0, x) == (-oo < x) & (x < log(4)/2)
+    assert solve((exp(x)+2+x**2)*exp(2*x+2)/(exp(x)+2)**2 > 0, x) == (-oo < x) & (x < oo)
+
+
+
+def test_issue_14607():
+    # issue 14607
+    s, tau_c, tau_1, tau_2, phi, K = symbols(
+        's, tau_c, tau_1, tau_2, phi, K')
+
+    target = (s**2*tau_1*tau_2 + s*tau_1 + s*tau_2 + 1)/(K*s*(-phi + tau_c))
+
+    K_C, tau_I, tau_D = symbols('K_C, tau_I, tau_D',
+                                positive=True, nonzero=True)
+    PID = K_C*(1 + 1/(tau_I*s) + tau_D*s)
+
+    eq = (target - PID).together()
+    eq *= denom(eq).simplify()
+    eq = Poly(eq, s)
+    c = eq.coeffs()
+
+    vars = [K_C, tau_I, tau_D]
+    s = solve(c, vars, dict=True)
+
+    assert len(s) == 1
+
+    knownsolution = {K_C: -(tau_1 + tau_2)/(K*(phi - tau_c)),
+                     tau_I: tau_1 + tau_2,
+                     tau_D: tau_1*tau_2/(tau_1 + tau_2)}
+
+    for var in vars:
+        assert s[0][var].simplify() == knownsolution[var].simplify()
+
+
+def test_lambert_multivariate():
+    from sympy.abc import x, y
+    assert _filtered_gens(Poly(x + 1/x + exp(x) + y), x) == {x, exp(x)}
+    assert _lambert(x, x) == []
+    assert solve((x**2 - 2*x + 1).subs(x, log(x) + 3*x)) == [LambertW(3*S.Exp1)/3]
+    assert solve((x**2 - 2*x + 1).subs(x, (log(x) + 3*x)**2 - 1)) == \
+          [LambertW(3*exp(-sqrt(2)))/3, LambertW(3*exp(sqrt(2)))/3]
+    assert solve((x**2 - 2*x - 2).subs(x, log(x) + 3*x)) == \
+          [LambertW(3*exp(1 - sqrt(3)))/3, LambertW(3*exp(1 + sqrt(3)))/3]
+    eq = (x*exp(x) - 3).subs(x, x*exp(x))
+    assert solve(eq) == [LambertW(3*exp(-LambertW(3)))]
+    # coverage test
+    raises(NotImplementedError, lambda: solve(x - sin(x)*log(y - x), x))
+    ans = [3, -3*LambertW(-log(3)/3)/log(3)]  # 3 and 2.478...
+    assert solve(x**3 - 3**x, x) == ans
+    assert set(solve(3*log(x) - x*log(3))) == set(ans)
+    assert solve(LambertW(2*x) - y, x) == [y*exp(y)/2]
+
+
+@XFAIL
+def test_other_lambert():
+    assert solve(3*sin(x) - x*sin(3), x) == [3]
+    assert set(solve(x**a - a**x), x) == {
+        a, -a*LambertW(-log(a)/a)/log(a)}
+
+
+@slow
+def test_lambert_bivariate():
+    # tests passing current implementation
+    assert solve((x**2 + x)*exp(x**2 + x) - 1) == [
+        Rational(-1, 2) + sqrt(1 + 4*LambertW(1))/2,
+        Rational(-1, 2) - sqrt(1 + 4*LambertW(1))/2]
+    assert solve((x**2 + x)*exp((x**2 + x)*2) - 1) == [
+        Rational(-1, 2) + sqrt(1 + 2*LambertW(2))/2,
+        Rational(-1, 2) - sqrt(1 + 2*LambertW(2))/2]
+    assert solve(a/x + exp(x/2), x) == [2*LambertW(-a/2)]
+    assert solve((a/x + exp(x/2)).diff(x), x) == \
+            [4*LambertW(-sqrt(2)*sqrt(a)/4), 4*LambertW(sqrt(2)*sqrt(a)/4)]
+    assert solve((1/x + exp(x/2)).diff(x), x) == \
+        [4*LambertW(-sqrt(2)/4),
+        4*LambertW(sqrt(2)/4),  # nsimplifies as 2*2**(141/299)*3**(206/299)*5**(205/299)*7**(37/299)/21
+        4*LambertW(-sqrt(2)/4, -1)]
+    assert solve(x*log(x) + 3*x + 1, x) == \
+            [exp(-3 + LambertW(-exp(3)))]
+    assert solve(-x**2 + 2**x, x) == [2, 4, -2*LambertW(log(2)/2)/log(2)]
+    assert solve(x**2 - 2**x, x) == [2, 4, -2*LambertW(log(2)/2)/log(2)]
+    ans = solve(3*x + 5 + 2**(-5*x + 3), x)
+    assert len(ans) == 1 and ans[0].expand() == \
+        Rational(-5, 3) + LambertW(-10240*root(2, 3)*log(2)/3)/(5*log(2))
+    assert solve(5*x - 1 + 3*exp(2 - 7*x), x) == \
+        [Rational(1, 5) + LambertW(-21*exp(Rational(3, 5))/5)/7]
+    assert solve((log(x) + x).subs(x, x**2 + 1)) == [
+        -I*sqrt(-LambertW(1) + 1), sqrt(-1 + LambertW(1))]
+    # check collection
+    ax = a**(3*x + 5)
+    ans = solve(3*log(ax) + b*log(ax) + ax, x)
+    x0 = 1/log(a)
+    x1 = sqrt(3)*I
+    x2 = b + 3
+    x3 = x2*LambertW(1/x2)/a**5
+    x4 = x3**Rational(1, 3)/2
+    assert ans == [
+        x0*log(x4*(-x1 - 1)),
+        x0*log(x4*(x1 - 1)),
+        x0*log(x3)/3]
+    x1 = LambertW(Rational(1, 3))
+    x2 = a**(-5)
+    x3 = -3**Rational(1, 3)
+    x4 = 3**Rational(5, 6)*I
+    x5 = x1**Rational(1, 3)*x2**Rational(1, 3)/2
+    ans = solve(3*log(ax) + ax, x)
+    assert ans == [
+        x0*log(3*x1*x2)/3,
+        x0*log(x5*(x3 - x4)),
+        x0*log(x5*(x3 + x4))]
+    # coverage
+    p = symbols('p', positive=True)
+    eq = 4*2**(2*p + 3) - 2*p - 3
+    assert _solve_lambert(eq, p, _filtered_gens(Poly(eq), p)) == [
+        Rational(-3, 2) - LambertW(-4*log(2))/(2*log(2))]
+    assert set(solve(3**cos(x) - cos(x)**3)) == {
+        acos(3), acos(-3*LambertW(-log(3)/3)/log(3))}
+    # should give only one solution after using `uniq`
+    assert solve(2*log(x) - 2*log(z) + log(z + log(x) + log(z)), x) == [
+        exp(-z + LambertW(2*z**4*exp(2*z))/2)/z]
+    # cases when p != S.One
+    # issue 4271
+    ans = solve((a/x + exp(x/2)).diff(x, 2), x)
+    x0 = (-a)**Rational(1, 3)
+    x1 = sqrt(3)*I
+    x2 = x0/6
+    assert ans == [
+        6*LambertW(x0/3),
+        6*LambertW(x2*(-x1 - 1)),
+        6*LambertW(x2*(x1 - 1))]
+    assert solve((1/x + exp(x/2)).diff(x, 2), x) == \
+                [6*LambertW(Rational(-1, 3)), 6*LambertW(Rational(1, 6) - sqrt(3)*I/6), \
+                6*LambertW(Rational(1, 6) + sqrt(3)*I/6), 6*LambertW(Rational(-1, 3), -1)]
+    assert solve(x**2 - y**2/exp(x), x, y, dict=True) == \
+                [{x: 2*LambertW(-y/2)}, {x: 2*LambertW(y/2)}]
+    # this is slow but not exceedingly slow
+    assert solve((x**3)**(x/2) + pi/2, x) == [
+        exp(LambertW(-2*log(2)/3 + 2*log(pi)/3 + I*pi*Rational(2, 3)))]
+
+    # issue 23253
+    assert solve((1/log(sqrt(x) + 2)**2 - 1/x)) == [
+        (LambertW(-exp(-2), -1) + 2)**2]
+    assert solve((1/log(1/sqrt(x) + 2)**2 - x)) == [
+        (LambertW(-exp(-2), -1) + 2)**-2]
+    assert solve((1/log(x**2 + 2)**2 - x**-4)) == [
+        -I*sqrt(2 - LambertW(exp(2))),
+        -I*sqrt(LambertW(-exp(-2)) + 2),
+        sqrt(-2 - LambertW(-exp(-2))),
+        sqrt(-2 + LambertW(exp(2))),
+        -sqrt(-2 - LambertW(-exp(-2), -1)),
+        sqrt(-2 - LambertW(-exp(-2), -1))]
+
+
+def test_rewrite_trig():
+    assert solve(sin(x) + tan(x)) == [0, -pi, pi, 2*pi]
+    assert solve(sin(x) + sec(x)) == [
+        -2*atan(Rational(-1, 2) + sqrt(2)*sqrt(1 - sqrt(3)*I)/2 + sqrt(3)*I/2),
+        2*atan(S.Half - sqrt(2)*sqrt(1 + sqrt(3)*I)/2 + sqrt(3)*I/2), 2*atan(S.Half
+        + sqrt(2)*sqrt(1 + sqrt(3)*I)/2 + sqrt(3)*I/2), 2*atan(S.Half -
+        sqrt(3)*I/2 + sqrt(2)*sqrt(1 - sqrt(3)*I)/2)]
+    assert solve(sinh(x) + tanh(x)) == [0, I*pi]
+
+    # issue 6157
+    assert solve(2*sin(x) - cos(x), x) == [atan(S.Half)]
+
+
+@XFAIL
+def test_rewrite_trigh():
+    # if this import passes then the test below should also pass
+    from sympy.functions.elementary.hyperbolic import sech
+    assert solve(sinh(x) + sech(x)) == [
+        2*atanh(Rational(-1, 2) + sqrt(5)/2 - sqrt(-2*sqrt(5) + 2)/2),
+        2*atanh(Rational(-1, 2) + sqrt(5)/2 + sqrt(-2*sqrt(5) + 2)/2),
+        2*atanh(-sqrt(5)/2 - S.Half + sqrt(2 + 2*sqrt(5))/2),
+        2*atanh(-sqrt(2 + 2*sqrt(5))/2 - sqrt(5)/2 - S.Half)]
+
+
+def test_uselogcombine():
+    eq = z - log(x) + log(y/(x*(-1 + y**2/x**2)))
+    assert solve(eq, x, force=True) == [-sqrt(y*(y - exp(z))), sqrt(y*(y - exp(z)))]
+    assert solve(log(x + 3) + log(1 + 3/x) - 3) in [
+        [-3 + sqrt(-12 + exp(3))*exp(Rational(3, 2))/2 + exp(3)/2,
+        -sqrt(-12 + exp(3))*exp(Rational(3, 2))/2 - 3 + exp(3)/2],
+        [-3 + sqrt(-36 + (-exp(3) + 6)**2)/2 + exp(3)/2,
+        -3 - sqrt(-36 + (-exp(3) + 6)**2)/2 + exp(3)/2],
+        ]
+    assert solve(log(exp(2*x) + 1) + log(-tanh(x) + 1) - log(2)) == []
+
+
+def test_atan2():
+    assert solve(atan2(x, 2) - pi/3, x) == [2*sqrt(3)]
+
+
+def test_errorinverses():
+    assert solve(erf(x) - y, x) == [erfinv(y)]
+    assert solve(erfinv(x) - y, x) == [erf(y)]
+    assert solve(erfc(x) - y, x) == [erfcinv(y)]
+    assert solve(erfcinv(x) - y, x) == [erfc(y)]
+
+
+def test_issue_2725():
+    R = Symbol('R')
+    eq = sqrt(2)*R*sqrt(1/(R + 1)) + (R + 1)*(sqrt(2)*sqrt(1/(R + 1)) - 1)
+    sol = solve(eq, R, set=True)[1]
+    assert sol == {(Rational(5, 3) + (Rational(-1, 2) - sqrt(3)*I/2)*(Rational(251, 27) +
+        sqrt(111)*I/9)**Rational(1, 3) + 40/(9*((Rational(-1, 2) - sqrt(3)*I/2)*(Rational(251, 27) +
+        sqrt(111)*I/9)**Rational(1, 3))),), (Rational(5, 3) + 40/(9*(Rational(251, 27) +
+        sqrt(111)*I/9)**Rational(1, 3)) + (Rational(251, 27) + sqrt(111)*I/9)**Rational(1, 3),)}
+
+
+def test_issue_5114_6611():
+    # See that it doesn't hang; this solves in about 2 seconds.
+    # Also check that the solution is relatively small.
+    # Note: the system in issue 6611 solves in about 5 seconds and has
+    # an op-count of 138336 (with simplify=False).
+    b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r = symbols('b:r')
+    eqs = Matrix([
+        [b - c/d + r/d], [c*(1/g + 1/e + 1/d) - f/g - r/d],
+        [-c/g + f*(1/j + 1/i + 1/g) - h/i], [-f/i + h*(1/m + 1/l + 1/i) - k/m],
+        [-h/m + k*(1/p + 1/o + 1/m) - n/p], [-k/p + n*(1/q + 1/p)]])
+    v = Matrix([f, h, k, n, b, c])
+    ans = solve(list(eqs), list(v), simplify=False)
+    # If time is taken to simplify then then 2617 below becomes
+    # 1168 and the time is about 50 seconds instead of 2.
+    assert sum(s.count_ops() for s in ans.values()) <= 3270
+
+
+def test_det_quick():
+    m = Matrix(3, 3, symbols('a:9'))
+    assert m.det() == det_quick(m)  # calls det_perm
+    m[0, 0] = 1
+    assert m.det() == det_quick(m)  # calls det_minor
+    m = Matrix(3, 3, list(range(9)))
+    assert m.det() == det_quick(m)  # defaults to .det()
+    # make sure they work with Sparse
+    s = SparseMatrix(2, 2, (1, 2, 1, 4))
+    assert det_perm(s) == det_minor(s) == s.det()
+
+
+def test_real_imag_splitting():
+    a, b = symbols('a b', real=True)
+    assert solve(sqrt(a**2 + b**2) - 3, a) == \
+        [-sqrt(-b**2 + 9), sqrt(-b**2 + 9)]
+    a, b = symbols('a b', imaginary=True)
+    assert solve(sqrt(a**2 + b**2) - 3, a) == []
+
+
+def test_issue_7110():
+    y = -2*x**3 + 4*x**2 - 2*x + 5
+    assert any(ask(Q.real(i)) for i in solve(y))
+
+
+def test_units():
+    assert solve(1/x - 1/(2*cm)) == [2*cm]
+
+
+def test_issue_7547():
+    A, B, V = symbols('A,B,V')
+    eq1 = Eq(630.26*(V - 39.0)*V*(V + 39) - A + B, 0)
+    eq2 = Eq(B, 1.36*10**8*(V - 39))
+    eq3 = Eq(A, 5.75*10**5*V*(V + 39.0))
+    sol = Matrix(nsolve(Tuple(eq1, eq2, eq3), [A, B, V], (0, 0, 0)))
+    assert str(sol) == str(Matrix(
+        [['4442890172.68209'],
+         ['4289299466.1432'],
+         ['70.5389666628177']]))
+
+
+def test_issue_7895():
+    r = symbols('r', real=True)
+    assert solve(sqrt(r) - 2) == [4]
+
+
+def test_issue_2777():
+    # the equations represent two circles
+    x, y = symbols('x y', real=True)
+    e1, e2 = sqrt(x**2 + y**2) - 10, sqrt(y**2 + (-x + 10)**2) - 3
+    a, b = Rational(191, 20), 3*sqrt(391)/20
+    ans = [(a, -b), (a, b)]
+    assert solve((e1, e2), (x, y)) == ans
+    assert solve((e1, e2/(x - a)), (x, y)) == []
+    # make the 2nd circle's radius be -3
+    e2 += 6
+    assert solve((e1, e2), (x, y)) == []
+    assert solve((e1, e2), (x, y), check=False) == ans
+
+
+def test_issue_7322():
+    number = 5.62527e-35
+    assert solve(x - number, x)[0] == number
+
+
+def test_nsolve():
+    raises(ValueError, lambda: nsolve(x, (-1, 1), method='bisect'))
+    raises(TypeError, lambda: nsolve((x - y + 3,x + y,z - y),(x,y,z),(-50,50)))
+    raises(TypeError, lambda: nsolve((x + y, x - y), (0, 1)))
+    raises(TypeError, lambda: nsolve(x < 0.5, x, 1))
+
+
+@slow
+def test_high_order_multivariate():
+    assert len(solve(a*x**3 - x + 1, x)) == 3
+    assert len(solve(a*x**4 - x + 1, x)) == 4
+    assert solve(a*x**5 - x + 1, x) == []  # incomplete solution allowed
+    raises(NotImplementedError, lambda:
+        solve(a*x**5 - x + 1, x, incomplete=False))
+
+    # result checking must always consider the denominator and CRootOf
+    # must be checked, too
+    d = x**5 - x + 1
+    assert solve(d*(1 + 1/d)) == [CRootOf(d + 1, i) for i in range(5)]
+    d = x - 1
+    assert solve(d*(2 + 1/d)) == [S.Half]
+
+
+def test_base_0_exp_0():
+    assert solve(0**x - 1) == [0]
+    assert solve(0**(x - 2) - 1) == [2]
+    assert solve(S('x*(1/x**0 - x)', evaluate=False)) == \
+        [0, 1]
+
+
+def test__simple_dens():
+    assert _simple_dens(1/x**0, [x]) == set()
+    assert _simple_dens(1/x**y, [x]) == {x**y}
+    assert _simple_dens(1/root(x, 3), [x]) == {x}
+
+
+def test_issue_8755():
+    # This tests two things: that if full unrad is attempted and fails
+    # the solution should still be found; also it tests the use of
+    # keyword `composite`.
+    assert len(solve(sqrt(y)*x + x**3 - 1, x)) == 3
+    assert len(solve(-512*y**3 + 1344*(x + 2)**Rational(1, 3)*y**2 -
+        1176*(x + 2)**Rational(2, 3)*y - 169*x + 686, y, _unrad=False)) == 3
+
+
+@slow
+def test_issue_8828():
+    x1 = 0
+    y1 = -620
+    r1 = 920
+    x2 = 126
+    y2 = 276
+    x3 = 51
+    y3 = 205
+    r3 = 104
+    v = x, y, z
+
+    f1 = (x - x1)**2 + (y - y1)**2 - (r1 - z)**2
+    f2 = (x - x2)**2 + (y - y2)**2 - z**2
+    f3 = (x - x3)**2 + (y - y3)**2 - (r3 - z)**2
+    F = f1,f2,f3
+
+    g1 = sqrt((x - x1)**2 + (y - y1)**2) + z - r1
+    g2 = f2
+    g3 = sqrt((x - x3)**2 + (y - y3)**2) + z - r3
+    G = g1,g2,g3
+
+    A = solve(F, v)
+    B = solve(G, v)
+    C = solve(G, v, manual=True)
+
+    p, q, r = [{tuple(i.evalf(2) for i in j) for j in R} for R in [A, B, C]]
+    assert p == q == r
+
+
+def test_issue_2840_8155():
+    # with parameter-free solutions (i.e. no `n`), we want to avoid
+    # excessive periodic solutions
+    assert solve(sin(3*x) + sin(6*x)) == [0, -2*pi/9, 2*pi/9]
+    assert solve(sin(300*x) + sin(600*x)) == [0, -pi/450, pi/450]
+    assert solve(2*sin(x) - 2*sin(2*x)) == [0, -pi/3, pi/3]
+
+
+def test_issue_9567():
+    assert solve(1 + 1/(x - 1)) == [0]
+
+
+def test_issue_11538():
+    assert solve(x + E) == [-E]
+    assert solve(x**2 + E) == [-I*sqrt(E), I*sqrt(E)]
+    assert solve(x**3 + 2*E) == [
+        -cbrt(2 * E),
+        cbrt(2)*cbrt(E)/2 - cbrt(2)*sqrt(3)*I*cbrt(E)/2,
+        cbrt(2)*cbrt(E)/2 + cbrt(2)*sqrt(3)*I*cbrt(E)/2]
+    assert solve([x + 4, y + E], x, y) == {x: -4, y: -E}
+    assert solve([x**2 + 4, y + E], x, y) == [
+        (-2*I, -E), (2*I, -E)]
+
+    e1 = x - y**3 + 4
+    e2 = x + y + 4 + 4 * E
+    assert len(solve([e1, e2], x, y)) == 3
+
+
+@slow
+def test_issue_12114():
+    a, b, c, d, e, f, g = symbols('a,b,c,d,e,f,g')
+    terms = [1 + a*b + d*e, 1 + a*c + d*f, 1 + b*c + e*f,
+             g - a**2 - d**2, g - b**2 - e**2, g - c**2 - f**2]
+    sol = solve(terms, [a, b, c, d, e, f, g], dict=True)
+    s = sqrt(-f**2 - 1)
+    s2 = sqrt(2 - f**2)
+    s3 = sqrt(6 - 3*f**2)
+    s4 = sqrt(3)*f
+    s5 = sqrt(3)*s2
+    assert sol == [
+        {a: -s, b: -s, c: -s, d: f, e: f, g: -1},
+        {a: s, b: s, c: s, d: f, e: f, g: -1},
+        {a: -s4/2 - s2/2, b: s4/2 - s2/2, c: s2,
+            d: -f/2 + s3/2, e: -f/2 - s5/2, g: 2},
+        {a: -s4/2 + s2/2, b: s4/2 + s2/2, c: -s2,
+            d: -f/2 - s3/2, e: -f/2 + s5/2, g: 2},
+        {a: s4/2 - s2/2, b: -s4/2 - s2/2, c: s2,
+            d: -f/2 - s3/2, e: -f/2 + s5/2, g: 2},
+        {a: s4/2 + s2/2, b: -s4/2 + s2/2, c: -s2,
+            d: -f/2 + s3/2, e: -f/2 - s5/2, g: 2}]
+
+
+def test_inf():
+    assert solve(1 - oo*x) == []
+    assert solve(oo*x, x) == []
+    assert solve(oo*x - oo, x) == []
+
+
+def test_issue_12448():
+    f = Function('f')
+    fun = [f(i) for i in range(15)]
+    sym = symbols('x:15')
+    reps = dict(zip(fun, sym))
+
+    (x, y, z), c = sym[:3], sym[3:]
+    ssym = solve([c[4*i]*x + c[4*i + 1]*y + c[4*i + 2]*z + c[4*i + 3]
+        for i in range(3)], (x, y, z))
+
+    (x, y, z), c = fun[:3], fun[3:]
+    sfun = solve([c[4*i]*x + c[4*i + 1]*y + c[4*i + 2]*z + c[4*i + 3]
+        for i in range(3)], (x, y, z))
+
+    assert sfun[fun[0]].xreplace(reps).count_ops() == \
+        ssym[sym[0]].count_ops()
+
+
+def test_denoms():
+    assert denoms(x/2 + 1/y) == {2, y}
+    assert denoms(x/2 + 1/y, y) == {y}
+    assert denoms(x/2 + 1/y, [y]) == {y}
+    assert denoms(1/x + 1/y + 1/z, [x, y]) == {x, y}
+    assert denoms(1/x + 1/y + 1/z, x, y) == {x, y}
+    assert denoms(1/x + 1/y + 1/z, {x, y}) == {x, y}
+
+
+def test_issue_12476():
+    x0, x1, x2, x3, x4, x5 = symbols('x0 x1 x2 x3 x4 x5')
+    eqns = [x0**2 - x0, x0*x1 - x1, x0*x2 - x2, x0*x3 - x3, x0*x4 - x4, x0*x5 - x5,
+            x0*x1 - x1, -x0/3 + x1**2 - 2*x2/3, x1*x2 - x1/3 - x2/3 - x3/3,
+            x1*x3 - x2/3 - x3/3 - x4/3, x1*x4 - 2*x3/3 - x5/3, x1*x5 - x4, x0*x2 - x2,
+            x1*x2 - x1/3 - x2/3 - x3/3, -x0/6 - x1/6 + x2**2 - x2/6 - x3/3 - x4/6,
+            -x1/6 + x2*x3 - x2/3 - x3/6 - x4/6 - x5/6, x2*x4 - x2/3 - x3/3 - x4/3,
+            x2*x5 - x3, x0*x3 - x3, x1*x3 - x2/3 - x3/3 - x4/3,
+            -x1/6 + x2*x3 - x2/3 - x3/6 - x4/6 - x5/6,
+            -x0/6 - x1/6 - x2/6 + x3**2 - x3/3 - x4/6, -x1/3 - x2/3 + x3*x4 - x3/3,
+            -x2 + x3*x5, x0*x4 - x4, x1*x4 - 2*x3/3 - x5/3, x2*x4 - x2/3 - x3/3 - x4/3,
+            -x1/3 - x2/3 + x3*x4 - x3/3, -x0/3 - 2*x2/3 + x4**2, -x1 + x4*x5, x0*x5 - x5,
+            x1*x5 - x4, x2*x5 - x3, -x2 + x3*x5, -x1 + x4*x5, -x0 + x5**2, x0 - 1]
+    sols = [{x0: 1, x3: Rational(1, 6), x2: Rational(1, 6), x4: Rational(-2, 3), x1: Rational(-2, 3), x5: 1},
+            {x0: 1, x3: S.Half, x2: Rational(-1, 2), x4: 0, x1: 0, x5: -1},
+            {x0: 1, x3: Rational(-1, 3), x2: Rational(-1, 3), x4: Rational(1, 3), x1: Rational(1, 3), x5: 1},
+            {x0: 1, x3: 1, x2: 1, x4: 1, x1: 1, x5: 1},
+            {x0: 1, x3: Rational(-1, 3), x2: Rational(1, 3), x4: sqrt(5)/3, x1: -sqrt(5)/3, x5: -1},
+            {x0: 1, x3: Rational(-1, 3), x2: Rational(1, 3), x4: -sqrt(5)/3, x1: sqrt(5)/3, x5: -1}]
+
+    assert solve(eqns) == sols
+
+
+def test_issue_13849():
+    t = symbols('t')
+    assert solve((t*(sqrt(5) + sqrt(2)) - sqrt(2), t), t) == []
+
+
+def test_issue_14860():
+    from sympy.physics.units import newton, kilo
+    assert solve(8*kilo*newton + x + y, x) == [-8000*newton - y]
+
+
+def test_issue_14721():
+    k, h, a, b = symbols(':4')
+    assert solve([
+        -1 + (-k + 1)**2/b**2 + (-h - 1)**2/a**2,
+        -1 + (-k + 1)**2/b**2 + (-h + 1)**2/a**2,
+        h, k + 2], h, k, a, b) == [
+        (0, -2, -b*sqrt(1/(b**2 - 9)), b),
+        (0, -2, b*sqrt(1/(b**2 - 9)), b)]
+    assert solve([
+        h, h/a + 1/b**2 - 2, -h/2 + 1/b**2 - 2], a, h, b) == [
+        (a, 0, -sqrt(2)/2), (a, 0, sqrt(2)/2)]
+    assert solve((a + b**2 - 1, a + b**2 - 2)) == []
+
+
+def test_issue_14779():
+    x = symbols('x', real=True)
+    assert solve(sqrt(x**4 - 130*x**2 + 1089) + sqrt(x**4 - 130*x**2
+                 + 3969) - 96*Abs(x)/x,x) == [sqrt(130)]
+
+
+def test_issue_15307():
+    assert solve((y - 2, Mul(x + 3,x - 2, evaluate=False))) == \
+        [{x: -3, y: 2}, {x: 2, y: 2}]
+    assert solve((y - 2, Mul(3, x - 2, evaluate=False))) == \
+        {x: 2, y: 2}
+    assert solve((y - 2, Add(x + 4, x - 2, evaluate=False))) == \
+        {x: -1, y: 2}
+    eq1 = Eq(12513*x + 2*y - 219093, -5726*x - y)
+    eq2 = Eq(-2*x + 8, 2*x - 40)
+    assert solve([eq1, eq2]) == {x:12, y:75}
+
+
+def test_issue_15415():
+    assert solve(x - 3, x) == [3]
+    assert solve([x - 3], x) == {x:3}
+    assert solve(Eq(y + 3*x**2/2, y + 3*x), y) == []
+    assert solve([Eq(y + 3*x**2/2, y + 3*x)], y) == []
+    assert solve([Eq(y + 3*x**2/2, y + 3*x), Eq(x, 1)], y) == []
+
+
+@slow
+def test_issue_15731():
+    # f(x)**g(x)=c
+    assert solve(Eq((x**2 - 7*x + 11)**(x**2 - 13*x + 42), 1)) == [2, 3, 4, 5, 6, 7]
+    assert solve((x)**(x + 4) - 4) == [-2]
+    assert solve((-x)**(-x + 4) - 4) == [2]
+    assert solve((x**2 - 6)**(x**2 - 2) - 4) == [-2, 2]
+    assert solve((x**2 - 2*x - 1)**(x**2 - 3) - 1/(1 - 2*sqrt(2))) == [sqrt(2)]
+    assert solve(x**(x + S.Half) - 4*sqrt(2)) == [S(2)]
+    assert solve((x**2 + 1)**x - 25) == [2]
+    assert solve(x**(2/x) - 2) == [2, 4]
+    assert solve((x/2)**(2/x) - sqrt(2)) == [4, 8]
+    assert solve(x**(x + S.Half) - Rational(9, 4)) == [Rational(3, 2)]
+    # a**g(x)=c
+    assert solve((-sqrt(sqrt(2)))**x - 2) == [4, log(2)/(log(2**Rational(1, 4)) + I*pi)]
+    assert solve((sqrt(2))**x - sqrt(sqrt(2))) == [S.Half]
+    assert solve((-sqrt(2))**x + 2*(sqrt(2))) == [3,
+            (3*log(2)**2 + 4*pi**2 - 4*I*pi*log(2))/(log(2)**2 + 4*pi**2)]
+    assert solve((sqrt(2))**x - 2*(sqrt(2))) == [3]
+    assert solve(I**x + 1) == [2]
+    assert solve((1 + I)**x - 2*I) == [2]
+    assert solve((sqrt(2) + sqrt(3))**x - (2*sqrt(6) + 5)**Rational(1, 3)) == [Rational(2, 3)]
+    # bases of both sides are equal
+    b = Symbol('b')
+    assert solve(b**x - b**2, x) == [2]
+    assert solve(b**x - 1/b, x) == [-1]
+    assert solve(b**x - b, x) == [1]
+    b = Symbol('b', positive=True)
+    assert solve(b**x - b**2, x) == [2]
+    assert solve(b**x - 1/b, x) == [-1]
+
+
+def test_issue_10933():
+    assert solve(x**4 + y*(x + 0.1), x)  # doesn't fail
+    assert solve(I*x**4 + x**3 + x**2 + 1.)  # doesn't fail
+
+
+def test_Abs_handling():
+    x = symbols('x', real=True)
+    assert solve(abs(x/y), x) == [0]
+
+
+def test_issue_7982():
+    x = Symbol('x')
+    # Test that no exception happens
+    assert solve([2*x**2 + 5*x + 20 <= 0, x >= 1.5], x) is S.false
+    # From #8040
+    assert solve([x**3 - 8.08*x**2 - 56.48*x/5 - 106 >= 0, x - 1 <= 0], [x]) is S.false
+
+
+def test_issue_14645():
+    x, y = symbols('x y')
+    assert solve([x*y - x - y, x*y - x - y], [x, y]) == [(y/(y - 1), y)]
+
+
+def test_issue_12024():
+    x, y = symbols('x y')
+    assert solve(Piecewise((0.0, x < 0.1), (x, x >= 0.1)) - y) == \
+        [{y: Piecewise((0.0, x < 0.1), (x, True))}]
+
+
+def test_issue_17452():
+    assert solve((7**x)**x + pi, x) == [-sqrt(log(pi) + I*pi)/sqrt(log(7)),
+                                        sqrt(log(pi) + I*pi)/sqrt(log(7))]
+    assert solve(x**(x/11) + pi/11, x) == [exp(LambertW(-11*log(11) + 11*log(pi) + 11*I*pi))]
+
+
+def test_issue_17799():
+    assert solve(-erf(x**(S(1)/3))**pi + I, x) == []
+
+
+def test_issue_17650():
+    x = Symbol('x', real=True)
+    assert solve(abs(abs(x**2 - 1) - x) - x) == [1, -1 + sqrt(2), 1 + sqrt(2)]
+
+
+def test_issue_17882():
+    eq = -8*x**2/(9*(x**2 - 1)**(S(4)/3)) + 4/(3*(x**2 - 1)**(S(1)/3))
+    assert unrad(eq) is None
+
+
+def test_issue_17949():
+    assert solve(exp(+x+x**2), x) == []
+    assert solve(exp(-x+x**2), x) == []
+    assert solve(exp(+x-x**2), x) == []
+    assert solve(exp(-x-x**2), x) == []
+
+
+def test_issue_10993():
+    assert solve(Eq(binomial(x, 2), 3)) == [-2, 3]
+    assert solve(Eq(pow(x, 2) + binomial(x, 3), x)) == [-4, 0, 1]
+    assert solve(Eq(binomial(x, 2), 0)) == [0, 1]
+    assert solve(a+binomial(x, 3), a) == [-binomial(x, 3)]
+    assert solve(x-binomial(a, 3) + binomial(y, 2) + sin(a), x) == [-sin(a) + binomial(a, 3) - binomial(y, 2)]
+    assert solve((x+1)-binomial(x+1, 3), x) == [-2, -1, 3]
+
+
+def test_issue_11553():
+    eq1 = x + y + 1
+    eq2 = x + GoldenRatio
+    assert solve([eq1, eq2], x, y) == {x: -GoldenRatio, y: -1 + GoldenRatio}
+    eq3 = x + 2 + TribonacciConstant
+    assert solve([eq1, eq3], x, y) == {x: -2 - TribonacciConstant, y: 1 + TribonacciConstant}
+
+
+def test_issue_19113_19102():
+    t = S(1)/3
+    solve(cos(x)**5-sin(x)**5)
+    assert solve(4*cos(x)**3 - 2*sin(x)**3) == [
+        atan(2**(t)), -atan(2**(t)*(1 - sqrt(3)*I)/2),
+        -atan(2**(t)*(1 + sqrt(3)*I)/2)]
+    h = S.Half
+    assert solve(cos(x)**2 + sin(x)) == [
+        2*atan(-h + sqrt(5)/2 + sqrt(2)*sqrt(1 - sqrt(5))/2),
+        -2*atan(h + sqrt(5)/2 + sqrt(2)*sqrt(1 + sqrt(5))/2),
+        -2*atan(-sqrt(5)/2 + h + sqrt(2)*sqrt(1 - sqrt(5))/2),
+        -2*atan(-sqrt(2)*sqrt(1 + sqrt(5))/2 + h + sqrt(5)/2)]
+    assert solve(3*cos(x) - sin(x)) == [atan(3)]
+
+
+def test_issue_19509():
+    a = S(3)/4
+    b = S(5)/8
+    c = sqrt(5)/8
+    d = sqrt(5)/4
+    assert solve(1/(x -1)**5 - 1) == [2,
+        -d + a - sqrt(-b + c),
+        -d + a + sqrt(-b + c),
+        d + a - sqrt(-b - c),
+        d + a + sqrt(-b - c)]
+
+def test_issue_20747():
+    THT, HT, DBH, dib, c0, c1, c2, c3, c4  = symbols('THT HT DBH dib c0 c1 c2 c3 c4')
+    f = DBH*c3 + THT*c4 + c2
+    rhs = 1 - ((HT - 1)/(THT - 1))**c1*(1 - exp(c0/f))
+    eq = dib - DBH*(c0 - f*log(rhs))
+    term = ((1 - exp((DBH*c0 - dib)/(DBH*(DBH*c3 + THT*c4 + c2))))
+            / (1 - exp(c0/(DBH*c3 + THT*c4 + c2))))
+    sol = [THT*term**(1/c1) - term**(1/c1) + 1]
+    assert solve(eq, HT) == sol
+
+
+def test_issue_27001():
+    assert solve((x, x**2), (x, y, z), dict=True) == [{x: 0}]
+    s = a1, a2, a3, a4, a5 = symbols('a1:6')
+    eqs = [8*a1**4*a2 + 4*a1**2*a2**3 - 8*a1**2*a2*a4 + a2**5/2 - 2*a2**3*a4 +
+        8*a2*a3**2 + 2*a2*a4**2 + 8*a2*a5, 12*a1**4 + 6*a1**2*a2**2 -
+        8*a1**2*a4 + 3*a2**4/4 - 2*a2**2*a4 + 4*a3**2 + a4**2 + 4*a5, 16*a1**3
+        + 4*a1*a2**2 - 8*a1*a4, -8*a1**2*a2 - 2*a2**3 + 4*a2*a4]
+    sol = [{a4: 2*a1**2 + a2**2/2, a5: -a3**2}, {a1: 0, a2: 0, a5: -a3**2 - a4**2/4}]
+    assert solve(eqs, s, dict=True) == sol
+    assert (g:=solve(groebner(eqs, s), dict=True)) == sol, g
+
+
+def test_issue_20902():
+    f = (t / ((1 + t) ** 2))
+    assert solve(f.subs({t: 3 * x + 2}).diff(x) > 0, x) == (S(-1) < x) & (x < S(-1)/3)
+    assert solve(f.subs({t: 3 * x + 3}).diff(x) > 0, x) == (S(-4)/3 < x) & (x < S(-2)/3)
+    assert solve(f.subs({t: 3 * x + 4}).diff(x) > 0, x) == (S(-5)/3 < x) & (x < S(-1))
+    assert solve(f.subs({t: 3 * x + 2}).diff(x) > 0, x) == (S(-1) < x) & (x < S(-1)/3)
+
+
+def test_issue_21034():
+    a = symbols('a', real=True)
+    system = [x - cosh(cos(4)), y - sinh(cos(a)), z - tanh(x)]
+    # constants inside hyperbolic functions should not be rewritten in terms of exp
+    assert solve(system, x, y, z) == [(cosh(cos(4)), sinh(cos(a)), tanh(cosh(cos(4))))]
+    # but if the variable of interest is present in a hyperbolic function,
+    # then it should be rewritten in terms of exp and solved further
+    newsystem = [(exp(x) - exp(-x)) - tanh(x)*(exp(x) + exp(-x)) + x - 5]
+    assert solve(newsystem, x) == {x: 5}
+
+
+def test_issue_4886():
+    z = a*sqrt(R**2*a**2 + R**2*b**2 - c**2)/(a**2 + b**2)
+    t = b*c/(a**2 + b**2)
+    sol = [((b*(t - z) - c)/(-a), t - z), ((b*(t + z) - c)/(-a), t + z)]
+    assert solve([x**2 + y**2 - R**2, a*x + b*y - c], x, y) == sol
+
+
+def test_issue_6819():
+    a, b, c, d = symbols('a b c d', positive=True)
+    assert solve(a*b**x - c*d**x, x) == [log(c/a)/log(b/d)]
+
+
+def test_issue_17454():
+    x = Symbol('x')
+    assert solve((1 - x - I)**4, x) == [1 - I]
+
+
+def test_issue_21852():
+    solution = [21 - 21*sqrt(2)/2]
+    assert solve(2*x + sqrt(2*x**2) - 21) == solution
+
+
+def test_issue_21942():
+    eq = -d + (a*c**(1 - e) + b**(1 - e)*(1 - a))**(1/(1 - e))
+    sol = solve(eq, c, simplify=False, check=False)
+    assert sol == [((a*b**(1 - e) - b**(1 - e) +
+        d**(1 - e))/a)**(1/(1 - e))]
+
+
+def test_solver_flags():
+    root = solve(x**5 + x**2 - x - 1, cubics=False)
+    rad = solve(x**5 + x**2 - x - 1, cubics=True)
+    assert root != rad
+
+
+def test_issue_22768():
+    eq = 2*x**3 - 16*(y - 1)**6*z**3
+    assert solve(eq.expand(), x, simplify=False
+        ) == [2*z*(y - 1)**2, z*(-1 + sqrt(3)*I)*(y - 1)**2,
+        -z*(1 + sqrt(3)*I)*(y - 1)**2]
+
+
+def test_issue_22717():
+    assert solve((-y**2 + log(y**2/x) + 2, -2*x*y + 2*x/y)) == [
+        {y: -1, x: E}, {y: 1, x: E}]
+
+
+def test_issue_25176():
+    eq = (x - 5)**-8 - 3
+    sol = solve(eq)
+    assert not any(eq.subs(x, i) for i in sol)
+
+
+def test_issue_10169():
+    eq = S(-8*a - x**5*(a + b + c + e) - x**4*(4*a - 2**Rational(3,4)*c + 4*c +
+        d + 2**Rational(3,4)*e + 4*e + k) - x**3*(-4*2**Rational(3,4)*c + sqrt(2)*c -
+        2**Rational(3,4)*d + 4*d + sqrt(2)*e + 4*2**Rational(3,4)*e + 2**Rational(3,4)*k + 4*k) -
+        x**2*(4*sqrt(2)*c - 4*2**Rational(3,4)*d + sqrt(2)*d + 4*sqrt(2)*e +
+        sqrt(2)*k + 4*2**Rational(3,4)*k) - x*(2*a + 2*b + 4*sqrt(2)*d +
+        4*sqrt(2)*k) + 5)
+    assert solve_undetermined_coeffs(eq, [a, b, c, d, e, k], x) == {
+        a: Rational(5,8),
+        b: Rational(-5,1032),
+        c: Rational(-40,129) - 5*2**Rational(3,4)/129 + 5*2**Rational(1,4)/1032,
+        d: -20*2**Rational(3,4)/129 - 10*sqrt(2)/129 - 5*2**Rational(1,4)/258,
+        e: Rational(-40,129) - 5*2**Rational(1,4)/1032 + 5*2**Rational(3,4)/129,
+        k: -10*sqrt(2)/129 + 5*2**Rational(1,4)/258 + 20*2**Rational(3,4)/129
+    }
+
+
+def test_solve_undetermined_coeffs_issue_23927():
+    A, B, r, phi = symbols('A, B, r, phi')
+    e = Eq(A*sin(t) + B*cos(t), r*sin(t - phi))
+    eq = (e.lhs - e.rhs).expand(trig=True)
+    soln = solve_undetermined_coeffs(eq, (r, phi), t)
+    assert soln == [{
+        phi: 2*atan((A - sqrt(A**2 + B**2))/B),
+        r: (-A**2 + A*sqrt(A**2 + B**2) - B**2)/(A - sqrt(A**2 + B**2))
+        }, {
+        phi: 2*atan((A + sqrt(A**2 + B**2))/B),
+        r: (A**2 + A*sqrt(A**2 + B**2) + B**2)/(A + sqrt(A**2 + B**2))/-1
+        }]
+
+def test_issue_24368():
+    # Ideally these would produce a solution, but for now just check that they
+    # don't fail with a RuntimeError
+    raises(NotImplementedError, lambda: solve(Mod(x**2, 49), x))
+    s2 = Symbol('s2', integer=True, positive=True)
+    f = floor(s2/2 - S(1)/2)
+    raises(NotImplementedError, lambda: solve((Mod(f**2/(f + 1) + 2*f/(f + 1) + 1/(f + 1), 1))*f + Mod(f**2/(f + 1) + 2*f/(f + 1) + 1/(f + 1), 1), s2))
+
+
+def test_solve_Piecewise():
+    assert [S(10)/3] == solve(3*Piecewise(
+        (S.NaN, x <= 0),
+        (20*x - 3*(x - 6)**2/2 - 176, (x >= 0) & (x >= 2) & (x>= 4) & (x >= 6) & (x < 10)),
+        (100 - 26*x, (x >= 0) & (x >= 2) & (x >= 4) & (x < 10)),
+        (16*x - 3*(x - 6)**2/2 - 176, (x >= 2) & (x >= 4) & (x >= 6) & (x < 10)),
+        (100 - 30*x, (x >= 2) & (x >= 4) & (x < 10)),
+        (30*x - 3*(x - 6)**2/2 - 196, (x>= 0) & (x >= 4) & (x >= 6) & (x < 10)),
+        (80 - 16*x, (x >= 0) & (x >= 4) & (x < 10)),
+        (26*x - 3*(x - 6)**2/2 - 196, (x >= 4) & (x >= 6) & (x < 10)),
+        (80 - 20*x, (x >= 4) & (x < 10)),
+        (40*x - 3*(x - 6)**2/2 - 256, (x >= 0) & (x >= 2) & (x >= 6) & (x < 10)),
+        (20 - 6*x, (x >= 0) & (x >= 2) & (x < 10)),
+        (36*x - 3*(x - 6)**2/2 - 256, (x >= 2) & (x >= 6) & (x < 10)),
+        (20 - 10*x, (x >= 2) & (x < 10)),
+        (50*x - 3*(x - 6)**2/2 - 276, (x >= 0) & (x >= 6) & (x < 10)),
+        (4*x, (x >= 0) & (x < 10)),
+        (46*x - 3*(x - 6)**2/2 - 276, (x >= 6) & (x < 10)),
+        (0, x < 10),  # this will simplify away
+        (S.NaN,True)))
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/tests/test_solveset.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/tests/test_solveset.py
new file mode 100644
index 0000000000000000000000000000000000000000..a1ba7a11e68ed518c4d83c050947b78756ade181
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/solvers/tests/test_solveset.py
@@ -0,0 +1,3548 @@
+from math import isclose
+
+from sympy.calculus.util import stationary_points
+from sympy.core.containers import Tuple
+from sympy.core.function import (Function, Lambda, nfloat, diff)
+from sympy.core.mod import Mod
+from sympy.core.numbers import (E, I, Rational, oo, pi, Integer, all_close)
+from sympy.core.relational import (Eq, Gt, Ne, Ge)
+from sympy.core.singleton import S
+from sympy.core.sorting import ordered
+from sympy.core.symbol import (Dummy, Symbol, symbols)
+from sympy.core.sympify import sympify
+from sympy.functions.elementary.complexes import (Abs, arg, im, re, sign, conjugate)
+from sympy.functions.elementary.exponential import (LambertW, exp, log)
+from sympy.functions.elementary.hyperbolic import (HyperbolicFunction,
+    sinh, cosh, tanh, coth, sech, csch, asinh, acosh, atanh, acoth, asech, acsch)
+from sympy.functions.elementary.miscellaneous import sqrt, Min, Max
+from sympy.functions.elementary.piecewise import Piecewise
+from sympy.functions.elementary.trigonometric import (
+    TrigonometricFunction, acos, acot, acsc, asec, asin, atan, atan2,
+    cos, cot, csc, sec, sin, tan)
+from sympy.functions.special.error_functions import (erf, erfc,
+    erfcinv, erfinv)
+from sympy.logic.boolalg import And
+from sympy.matrices.dense import MutableDenseMatrix as Matrix
+from sympy.matrices.immutable import ImmutableDenseMatrix
+from sympy.polys.polytools import Poly
+from sympy.polys.rootoftools import CRootOf
+from sympy.sets.contains import Contains
+from sympy.sets.conditionset import ConditionSet
+from sympy.sets.fancysets import ImageSet, Range
+from sympy.sets.sets import (Complement, FiniteSet,
+    Intersection, Interval, Union, imageset, ProductSet)
+from sympy.simplify import simplify
+from sympy.tensor.indexed import Indexed
+from sympy.utilities.iterables import numbered_symbols
+
+from sympy.testing.pytest import (XFAIL, raises, skip, slow, SKIP, _both_exp_pow)
+from sympy.core.random import verify_numerically as tn
+from sympy.physics.units import cm
+
+from sympy.solvers import solve
+from sympy.solvers.solveset import (
+    solveset_real, domain_check, solveset_complex, linear_eq_to_matrix,
+    linsolve, _is_function_class_equation, invert_real, invert_complex,
+    _invert_trig_hyp_real, solveset, solve_decomposition, substitution,
+    nonlinsolve, solvify,
+    _is_finite_with_finite_vars, _transolve, _is_exponential,
+    _solve_exponential, _is_logarithmic, _is_lambert,
+    _solve_logarithm, _term_factors, _is_modular, NonlinearError)
+
+from sympy.abc import (a, b, c, d, e, f, g, h, i, j, k, l, m, n, q, r,
+    t, w, x, y, z)
+
+
+def dumeq(i, j):
+    if type(i) in (list, tuple):
+        return all(dumeq(i, j) for i, j in zip(i, j))
+    return i == j or i.dummy_eq(j)
+
+
+def assert_close_ss(sol1, sol2):
+    """Test solutions with floats from solveset are close"""
+    sol1 = sympify(sol1)
+    sol2 = sympify(sol2)
+    assert isinstance(sol1, FiniteSet)
+    assert isinstance(sol2, FiniteSet)
+    assert len(sol1) == len(sol2)
+    assert all(isclose(v1, v2) for v1, v2 in zip(sol1, sol2))
+
+
+def assert_close_nl(sol1, sol2):
+    """Test solutions with floats from nonlinsolve are close"""
+    sol1 = sympify(sol1)
+    sol2 = sympify(sol2)
+    assert isinstance(sol1, FiniteSet)
+    assert isinstance(sol2, FiniteSet)
+    assert len(sol1) == len(sol2)
+    for s1, s2 in zip(sol1, sol2):
+        assert len(s1) == len(s2)
+        assert all(isclose(v1, v2) for v1, v2 in zip(s1, s2))
+
+
+@_both_exp_pow
+def test_invert_real():
+    x = Symbol('x', real=True)
+
+    def ireal(x, s=S.Reals):
+        return Intersection(s, x)
+
+    assert invert_real(exp(x), z, x) == (x, ireal(FiniteSet(log(z))))
+
+    y = Symbol('y', positive=True)
+    n = Symbol('n', real=True)
+    assert invert_real(x + 3, y, x) == (x, FiniteSet(y - 3))
+    assert invert_real(x*3, y, x) == (x, FiniteSet(y / 3))
+
+    assert invert_real(exp(x), y, x) == (x, FiniteSet(log(y)))
+    assert invert_real(exp(3*x), y, x) == (x, FiniteSet(log(y) / 3))
+    assert invert_real(exp(x + 3), y, x) == (x, FiniteSet(log(y) - 3))
+
+    assert invert_real(exp(x) + 3, y, x) == (x, ireal(FiniteSet(log(y - 3))))
+    assert invert_real(exp(x)*3, y, x) == (x, FiniteSet(log(y / 3)))
+
+    assert invert_real(log(x), y, x) == (x, FiniteSet(exp(y)))
+    assert invert_real(log(3*x), y, x) == (x, FiniteSet(exp(y) / 3))
+    assert invert_real(log(x + 3), y, x) == (x, FiniteSet(exp(y) - 3))
+
+    assert invert_real(Abs(x), y, x) == (x, FiniteSet(y, -y))
+
+    assert invert_real(2**x, y, x) == (x, FiniteSet(log(y)/log(2)))
+    assert invert_real(2**exp(x), y, x) == (x, ireal(FiniteSet(log(log(y)/log(2)))))
+
+    assert invert_real(x**2, y, x) == (x, FiniteSet(sqrt(y), -sqrt(y)))
+    assert invert_real(x**S.Half, y, x) == (x, FiniteSet(y**2))
+
+    raises(ValueError, lambda: invert_real(x, x, x))
+
+    # issue 21236
+    assert invert_real(x**pi, y, x) == (x, FiniteSet(y**(1/pi)))
+    assert invert_real(x**pi, -E, x) == (x, S.EmptySet)
+    assert invert_real(x**Rational(3/2), 1000, x) == (x, FiniteSet(100))
+    assert invert_real(x**1.0, 1, x) == (x**1.0, FiniteSet(1))
+
+    raises(ValueError, lambda: invert_real(S.One, y, x))
+
+    assert invert_real(x**31 + x, y, x) == (x**31 + x, FiniteSet(y))
+
+    lhs = x**31 + x
+    base_values =  FiniteSet(y - 1, -y - 1)
+    assert invert_real(Abs(x**31 + x + 1), y, x) == (lhs, base_values)
+
+    assert dumeq(invert_real(sin(x), y, x), (x,
+        ConditionSet(x, (S(-1) <= y) & (y <= S(1)), Union(
+            ImageSet(Lambda(n, 2*n*pi + asin(y)), S.Integers),
+            ImageSet(Lambda(n, pi*2*n + pi - asin(y)), S.Integers)))))
+
+    assert dumeq(invert_real(sin(exp(x)), y, x), (x,
+        ConditionSet(x, (S(-1) <= y) & (y <= S(1)), Union(
+            ImageSet(Lambda(n, log(2*n*pi + asin(y))), S.Integers),
+            ImageSet(Lambda(n, log(pi*2*n + pi - asin(y))), S.Integers)))))
+
+    assert dumeq(invert_real(csc(x), y, x), (x,
+        ConditionSet(x, ((S(1) <= y) & (y < oo)) | ((-oo < y) & (y <= S(-1))),
+            Union(ImageSet(Lambda(n, 2*n*pi + acsc(y)), S.Integers),
+                ImageSet(Lambda(n, 2*n*pi - acsc(y) + pi), S.Integers)))))
+
+    assert dumeq(invert_real(csc(exp(x)), y, x), (x,
+        ConditionSet(x, ((S(1) <= y) & (y < oo)) | ((-oo < y) & (y <= S(-1))),
+            Union(ImageSet(Lambda(n, log(2*n*pi + acsc(y))), S.Integers),
+                ImageSet(Lambda(n, log(2*n*pi - acsc(y) + pi)), S.Integers)))))
+
+    assert dumeq(invert_real(cos(x), y, x), (x,
+        ConditionSet(x, (S(-1) <= y) & (y <= S(1)), Union(
+            ImageSet(Lambda(n, 2*n*pi + acos(y)), S.Integers),
+            ImageSet(Lambda(n, 2*n*pi - acos(y)), S.Integers)))))
+
+    assert dumeq(invert_real(cos(exp(x)), y, x), (x,
+        ConditionSet(x, (S(-1) <= y) & (y <= S(1)), Union(
+            ImageSet(Lambda(n, log(2*n*pi + acos(y))), S.Integers),
+            ImageSet(Lambda(n, log(2*n*pi - acos(y))), S.Integers)))))
+
+    assert dumeq(invert_real(sec(x), y, x), (x,
+        ConditionSet(x, ((S(1) <= y) & (y < oo)) | ((-oo < y) & (y <= S(-1))),
+            Union(ImageSet(Lambda(n, 2*n*pi + asec(y)), S.Integers), \
+                ImageSet(Lambda(n, 2*n*pi - asec(y)), S.Integers)))))
+
+    assert dumeq(invert_real(sec(exp(x)), y, x), (x,
+        ConditionSet(x, ((S(1) <= y) & (y < oo)) | ((-oo < y) & (y <= S(-1))),
+            Union(ImageSet(Lambda(n, log(2*n*pi - asec(y))), S.Integers),
+                ImageSet(Lambda(n, log(2*n*pi + asec(y))), S.Integers)))))
+
+    assert dumeq(invert_real(tan(x), y, x), (x,
+        ConditionSet(x, (-oo < y) & (y < oo),
+            ImageSet(Lambda(n, n*pi + atan(y)), S.Integers))))
+
+    assert dumeq(invert_real(tan(exp(x)), y, x), (x,
+        ConditionSet(x, (-oo < y) & (y < oo),
+            ImageSet(Lambda(n, log(n*pi + atan(y))), S.Integers))))
+
+    assert dumeq(invert_real(cot(x), y, x), (x,
+        ConditionSet(x, (-oo < y) & (y < oo),
+            ImageSet(Lambda(n, n*pi + acot(y)), S.Integers))))
+
+    assert dumeq(invert_real(cot(exp(x)), y, x), (x,
+        ConditionSet(x, (-oo < y) & (y < oo),
+            ImageSet(Lambda(n, log(n*pi + acot(y))), S.Integers))))
+
+    assert dumeq(invert_real(tan(tan(x)), y, x),
+        (x, ConditionSet(x, Eq(tan(tan(x)), y), S.Reals)))
+        # slight regression compared to previous result:
+        # (tan(x), imageset(Lambda(n, n*pi + atan(y)), S.Integers)))
+
+    x = Symbol('x', positive=True)
+    assert invert_real(x**pi, y, x) == (x, FiniteSet(y**(1/pi)))
+
+    r = Symbol('r', real=True)
+    p = Symbol('p', positive=True)
+    assert invert_real(sinh(x), r, x) == (x, FiniteSet(asinh(r)))
+    assert invert_real(sinh(log(x)), p, x) == (x, FiniteSet(exp(asinh(p))))
+
+    assert invert_real(cosh(x), r, x) == (x, Intersection(
+        FiniteSet(-acosh(r), acosh(r)), S.Reals))
+    assert invert_real(cosh(x), p + 1, x) == (x,
+        FiniteSet(-acosh(p + 1), acosh(p + 1)))
+
+    assert invert_real(tanh(x), r, x) == (x, Intersection(FiniteSet(atanh(r)), S.Reals))
+    assert invert_real(coth(x), p+1, x) == (x, FiniteSet(acoth(p+1)))
+    assert invert_real(sech(x), r, x) == (x, Intersection(
+        FiniteSet(-asech(r), asech(r)), S.Reals))
+    assert invert_real(csch(x), p, x) == (x, FiniteSet(acsch(p)))
+
+    assert dumeq(invert_real(tanh(sin(x)), r, x), (x,
+        ConditionSet(x, (S(-1) <= atanh(r)) & (atanh(r) <= S(1)), Union(
+            ImageSet(Lambda(n, 2*n*pi + asin(atanh(r))), S.Integers),
+            ImageSet(Lambda(n, 2*n*pi - asin(atanh(r)) + pi), S.Integers)))))
+
+
+def test_invert_trig_hyp_real():
+    # check some codepaths that are not as easily reached otherwise
+    n = Dummy('n')
+    assert _invert_trig_hyp_real(cosh(x), Range(-5, 10, 1), x)[1].dummy_eq(Union(
+        ImageSet(Lambda(n, -acosh(n)), Range(1, 10, 1)),
+        ImageSet(Lambda(n, acosh(n)), Range(1, 10, 1))))
+    assert _invert_trig_hyp_real(coth(x), Interval(-3, 2), x) == (x, Union(
+        Interval(-oo, -acoth(3)), Interval(acoth(2), oo)))
+    assert _invert_trig_hyp_real(tanh(x), Interval(-S.Half, 1), x) == (x,
+        Interval(-atanh(S.Half), oo))
+    assert _invert_trig_hyp_real(sech(x), imageset(n, S.Half + n/3, S.Naturals0), x) == \
+        (x, FiniteSet(-asech(S(1)/2), asech(S(1)/2), -asech(S(5)/6), asech(S(5)/6)))
+    assert _invert_trig_hyp_real(csch(x), S.Reals, x) == (x,
+        Union(Interval.open(-oo, 0), Interval.open(0, oo)))
+
+
+def test_invert_complex():
+    assert invert_complex(x + 3, y, x) == (x, FiniteSet(y - 3))
+    assert invert_complex(x*3, y, x) == (x, FiniteSet(y / 3))
+    assert invert_complex((x - 1)**3, 0, x) == (x, FiniteSet(1))
+
+    assert dumeq(invert_complex(exp(x), y, x),
+        (x, imageset(Lambda(n, I*(2*pi*n + arg(y)) + log(Abs(y))), S.Integers)))
+
+    assert invert_complex(log(x), y, x) == (x, FiniteSet(exp(y)))
+
+    raises(ValueError, lambda: invert_real(1, y, x))
+    raises(ValueError, lambda: invert_complex(x, x, x))
+    raises(ValueError, lambda: invert_complex(x, x, 1))
+
+    assert dumeq(invert_complex(sin(x), I, x), (x, Union(
+        ImageSet(Lambda(n, 2*n*pi + I*log(1 + sqrt(2))), S.Integers),
+        ImageSet(Lambda(n, 2*n*pi + pi - I*log(1 + sqrt(2))), S.Integers))))
+    assert dumeq(invert_complex(cos(x), 1+I, x), (x, Union(
+        ImageSet(Lambda(n, 2*n*pi - acos(1 + I)), S.Integers),
+        ImageSet(Lambda(n, 2*n*pi + acos(1 + I)), S.Integers))))
+    assert dumeq(invert_complex(tan(2*x), 1, x), (x,
+        ImageSet(Lambda(n, n*pi/2 + pi/8), S.Integers)))
+    assert dumeq(invert_complex(cot(x), 2*I, x), (x,
+        ImageSet(Lambda(n, n*pi - I*acoth(2)), S.Integers)))
+
+    assert dumeq(invert_complex(sinh(x), 0, x), (x, Union(
+        ImageSet(Lambda(n, 2*n*I*pi), S.Integers),
+        ImageSet(Lambda(n, 2*n*I*pi + I*pi), S.Integers))))
+    assert dumeq(invert_complex(cosh(x), 0, x), (x, Union(
+        ImageSet(Lambda(n, 2*n*I*pi + I*pi/2), S.Integers),
+        ImageSet(Lambda(n, 2*n*I*pi + 3*I*pi/2), S.Integers))))
+    assert invert_complex(tanh(x), 1, x) == (x, S.EmptySet)
+    assert dumeq(invert_complex(tanh(x), a, x), (x,
+        ConditionSet(x, Ne(a, -1) & Ne(a, 1),
+        ImageSet(Lambda(n, n*I*pi + atanh(a)), S.Integers))))
+    assert invert_complex(coth(x), 1, x) == (x, S.EmptySet)
+    assert dumeq(invert_complex(coth(x), a, x), (x,
+        ConditionSet(x, Ne(a, -1) & Ne(a, 1),
+        ImageSet(Lambda(n, n*I*pi + acoth(a)), S.Integers))))
+    assert dumeq(invert_complex(sech(x), 2, x), (x, Union(
+        ImageSet(Lambda(n, 2*n*I*pi + I*pi/3), S.Integers),
+        ImageSet(Lambda(n, 2*n*I*pi + 5*I*pi/3), S.Integers))))
+
+
+def test_domain_check():
+    assert domain_check(1/(1 + (1/(x+1))**2), x, -1) is False
+    assert domain_check(x**2, x, 0) is True
+    assert domain_check(x, x, oo) is False
+    assert domain_check(0, x, oo) is False
+
+
+def test_issue_11536():
+    assert solveset(0**x - 100, x, S.Reals) == S.EmptySet
+    assert solveset(0**x - 1, x, S.Reals) == FiniteSet(0)
+
+
+def test_issue_17479():
+    f = (x**2 + y**2)**2 + (x**2 + z**2)**2 - 2*(2*x**2 + y**2 + z**2)
+    fx = f.diff(x)
+    fy = f.diff(y)
+    fz = f.diff(z)
+    sol = nonlinsolve([fx, fy, fz], [x, y, z])
+    assert len(sol) >= 4 and len(sol) <= 20
+    # nonlinsolve has been giving a varying number of solutions
+    # (originally 18, then 20, now 19) due to various internal changes.
+    # Unfortunately not all the solutions are actually valid and some are
+    # redundant. Since the original issue was that an exception was raised,
+    # this first test only checks that nonlinsolve returns a "plausible"
+    # solution set. The next test checks the result for correctness.
+
+
+@XFAIL
+def test_issue_18449():
+    x, y, z = symbols("x, y, z")
+    f = (x**2 + y**2)**2 + (x**2 + z**2)**2 - 2*(2*x**2 + y**2 + z**2)
+    fx = diff(f, x)
+    fy = diff(f, y)
+    fz = diff(f, z)
+    sol = nonlinsolve([fx, fy, fz], [x, y, z])
+    for (xs, ys, zs) in sol:
+        d = {x: xs, y: ys, z: zs}
+        assert tuple(_.subs(d).simplify() for _ in (fx, fy, fz)) == (0, 0, 0)
+    # After simplification and removal of duplicate elements, there should
+    # only be 4 parametric solutions left:
+    # simplifiedsolutions = FiniteSet((sqrt(1 - z**2), z, z),
+    #                                 (-sqrt(1 - z**2), z, z),
+    #                                 (sqrt(1 - z**2), -z, z),
+    #                                 (-sqrt(1 - z**2), -z, z))
+    # TODO: Is the above solution set definitely complete?
+
+
+def test_issue_21047():
+    f = (2 - x)**2 + (sqrt(x - 1) - 1)**6
+    assert solveset(f, x, S.Reals) == FiniteSet(2)
+
+    f = (sqrt(x)-1)**2 + (sqrt(x)+1)**2 -2*x**2 + sqrt(2)
+    assert solveset(f, x, S.Reals) == FiniteSet(
+        S.Half - sqrt(2*sqrt(2) + 5)/2, S.Half + sqrt(2*sqrt(2) + 5)/2)
+
+
+def test_is_function_class_equation():
+    assert _is_function_class_equation(TrigonometricFunction,
+                                       tan(x), x) is True
+    assert _is_function_class_equation(TrigonometricFunction,
+                                       tan(x) - 1, x) is True
+    assert _is_function_class_equation(TrigonometricFunction,
+                                       tan(x) + sin(x), x) is True
+    assert _is_function_class_equation(TrigonometricFunction,
+                                       tan(x) + sin(x) - a, x) is True
+    assert _is_function_class_equation(TrigonometricFunction,
+                                       sin(x)*tan(x) + sin(x), x) is True
+    assert _is_function_class_equation(TrigonometricFunction,
+                                       sin(x)*tan(x + a) + sin(x), x) is True
+    assert _is_function_class_equation(TrigonometricFunction,
+                                       sin(x)*tan(x*a) + sin(x), x) is True
+    assert _is_function_class_equation(TrigonometricFunction,
+                                       a*tan(x) - 1, x) is True
+    assert _is_function_class_equation(TrigonometricFunction,
+                                       tan(x)**2 + sin(x) - 1, x) is True
+    assert _is_function_class_equation(TrigonometricFunction,
+                                       tan(x) + x, x) is False
+    assert _is_function_class_equation(TrigonometricFunction,
+                                       tan(x**2), x) is False
+    assert _is_function_class_equation(TrigonometricFunction,
+                                       tan(x**2) + sin(x), x) is False
+    assert _is_function_class_equation(TrigonometricFunction,
+                                       tan(x)**sin(x), x) is False
+    assert _is_function_class_equation(TrigonometricFunction,
+                                       tan(sin(x)) + sin(x), x) is False
+    assert _is_function_class_equation(HyperbolicFunction,
+                                       tanh(x), x) is True
+    assert _is_function_class_equation(HyperbolicFunction,
+                                       tanh(x) - 1, x) is True
+    assert _is_function_class_equation(HyperbolicFunction,
+                                       tanh(x) + sinh(x), x) is True
+    assert _is_function_class_equation(HyperbolicFunction,
+                                       tanh(x) + sinh(x) - a, x) is True
+    assert _is_function_class_equation(HyperbolicFunction,
+                                       sinh(x)*tanh(x) + sinh(x), x) is True
+    assert _is_function_class_equation(HyperbolicFunction,
+                                       sinh(x)*tanh(x + a) + sinh(x), x) is True
+    assert _is_function_class_equation(HyperbolicFunction,
+                                       sinh(x)*tanh(x*a) + sinh(x), x) is True
+    assert _is_function_class_equation(HyperbolicFunction,
+                                       a*tanh(x) - 1, x) is True
+    assert _is_function_class_equation(HyperbolicFunction,
+                                       tanh(x)**2 + sinh(x) - 1, x) is True
+    assert _is_function_class_equation(HyperbolicFunction,
+                                       tanh(x) + x, x) is False
+    assert _is_function_class_equation(HyperbolicFunction,
+                                       tanh(x**2), x) is False
+    assert _is_function_class_equation(HyperbolicFunction,
+                                       tanh(x**2) + sinh(x), x) is False
+    assert _is_function_class_equation(HyperbolicFunction,
+                                       tanh(x)**sinh(x), x) is False
+    assert _is_function_class_equation(HyperbolicFunction,
+                                       tanh(sinh(x)) + sinh(x), x) is False
+
+
+def test_garbage_input():
+    raises(ValueError, lambda: solveset_real([y], y))
+    x = Symbol('x', real=True)
+    assert solveset_real(x, 1) == S.EmptySet
+    assert solveset_real(x - 1, 1) == FiniteSet(x)
+    assert solveset_real(x, pi) == S.EmptySet
+    assert solveset_real(x, x**2) == S.EmptySet
+
+    raises(ValueError, lambda: solveset_complex([x], x))
+    assert solveset_complex(x, pi) == S.EmptySet
+
+    raises(ValueError, lambda: solveset((x, y), x))
+    raises(ValueError, lambda: solveset(x + 1, S.Reals))
+    raises(ValueError, lambda: solveset(x + 1, x, 2))
+
+
+def test_solve_mul():
+    assert solveset_real((a*x + b)*(exp(x) - 3), x) == \
+        Union({log(3)}, Intersection({-b/a}, S.Reals))
+    anz = Symbol('anz', nonzero=True)
+    bb = Symbol('bb', real=True)
+    assert solveset_real((anz*x + bb)*(exp(x) - 3), x) == \
+        FiniteSet(-bb/anz, log(3))
+    assert solveset_real((2*x + 8)*(8 + exp(x)), x) == FiniteSet(S(-4))
+    assert solveset_real(x/log(x), x) is S.EmptySet
+
+
+def test_solve_invert():
+    assert solveset_real(exp(x) - 3, x) == FiniteSet(log(3))
+    assert solveset_real(log(x) - 3, x) == FiniteSet(exp(3))
+
+    assert solveset_real(3**(x + 2), x) == FiniteSet()
+    assert solveset_real(3**(2 - x), x) == FiniteSet()
+
+    assert solveset_real(y - b*exp(a/x), x) == Intersection(
+        S.Reals, FiniteSet(a/log(y/b)))
+
+    # issue 4504
+    assert solveset_real(2**x - 10, x) == FiniteSet(1 + log(5)/log(2))
+
+
+def test_issue_25768():
+    assert dumeq(solveset_real(sin(x) - S.Half, x), Union(
+        ImageSet(Lambda(n, pi*2*n + pi/6), S.Integers),
+        ImageSet(Lambda(n, pi*2*n + pi*5/6), S.Integers)))
+    n1 = solveset_real(sin(x) - 0.5, x).n(5)
+    n2 = solveset_real(sin(x) - S.Half, x).n(5)
+    # help pass despite fp differences
+    eq = [i.replace(
+        lambda x:x.is_Float,
+        lambda x:Rational(x).limit_denominator(1000)) for i in (n1, n2)]
+    assert dumeq(*eq),(n1,n2)
+
+
+def test_errorinverses():
+    assert solveset_real(erf(x) - S.Half, x) == \
+        FiniteSet(erfinv(S.Half))
+    assert solveset_real(erfinv(x) - 2, x) == \
+        FiniteSet(erf(2))
+    assert solveset_real(erfc(x) - S.One, x) == \
+        FiniteSet(erfcinv(S.One))
+    assert solveset_real(erfcinv(x) - 2, x) == FiniteSet(erfc(2))
+
+
+def test_solve_polynomial():
+    x = Symbol('x', real=True)
+    y = Symbol('y', real=True)
+    assert solveset_real(3*x - 2, x) == FiniteSet(Rational(2, 3))
+
+    assert solveset_real(x**2 - 1, x) == FiniteSet(-S.One, S.One)
+    assert solveset_real(x - y**3, x) == FiniteSet(y ** 3)
+
+    assert solveset_real(x**3 - 15*x - 4, x) == FiniteSet(
+        -2 + 3 ** S.Half,
+        S(4),
+        -2 - 3 ** S.Half)
+
+    assert solveset_real(sqrt(x) - 1, x) == FiniteSet(1)
+    assert solveset_real(sqrt(x) - 2, x) == FiniteSet(4)
+    assert solveset_real(x**Rational(1, 4) - 2, x) == FiniteSet(16)
+    assert solveset_real(x**Rational(1, 3) - 3, x) == FiniteSet(27)
+    assert len(solveset_real(x**5 + x**3 + 1, x)) == 1
+    assert len(solveset_real(-2*x**3 + 4*x**2 - 2*x + 6, x)) > 0
+    assert solveset_real(x**6 + x**4 + I, x) is S.EmptySet
+
+
+def test_return_root_of():
+    f = x**5 - 15*x**3 - 5*x**2 + 10*x + 20
+    s = list(solveset_complex(f, x))
+    for root in s:
+        assert root.func == CRootOf
+
+    # if one uses solve to get the roots of a polynomial that has a CRootOf
+    # solution, make sure that the use of nfloat during the solve process
+    # doesn't fail. Note: if you want numerical solutions to a polynomial
+    # it is *much* faster to use nroots to get them than to solve the
+    # equation only to get CRootOf solutions which are then numerically
+    # evaluated. So for eq = x**5 + 3*x + 7 do Poly(eq).nroots() rather
+    # than [i.n() for i in solve(eq)] to get the numerical roots of eq.
+    assert nfloat(list(solveset_complex(x**5 + 3*x**3 + 7, x))[0],
+                  exponent=False) == CRootOf(x**5 + 3*x**3 + 7, 0).n()
+
+    sol = list(solveset_complex(x**6 - 2*x + 2, x))
+    assert all(isinstance(i, CRootOf) for i in sol) and len(sol) == 6
+
+    f = x**5 - 15*x**3 - 5*x**2 + 10*x + 20
+    s = list(solveset_complex(f, x))
+    for root in s:
+        assert root.func == CRootOf
+
+    s = x**5 + 4*x**3 + 3*x**2 + Rational(7, 4)
+    assert solveset_complex(s, x) == \
+        FiniteSet(*Poly(s*4, domain='ZZ').all_roots())
+
+    # Refer issue #7876
+    eq = x*(x - 1)**2*(x + 1)*(x**6 - x + 1)
+    assert solveset_complex(eq, x) == \
+        FiniteSet(-1, 0, 1, CRootOf(x**6 - x + 1, 0),
+                       CRootOf(x**6 - x + 1, 1),
+                       CRootOf(x**6 - x + 1, 2),
+                       CRootOf(x**6 - x + 1, 3),
+                       CRootOf(x**6 - x + 1, 4),
+                       CRootOf(x**6 - x + 1, 5))
+
+
+def test_solveset_sqrt_1():
+    assert solveset_real(sqrt(5*x + 6) - 2 - x, x) == \
+        FiniteSet(-S.One, S(2))
+    assert solveset_real(sqrt(x - 1) - x + 7, x) == FiniteSet(10)
+    assert solveset_real(sqrt(x - 2) - 5, x) == FiniteSet(27)
+    assert solveset_real(sqrt(x) - 2 - 5, x) == FiniteSet(49)
+    assert solveset_real(sqrt(x**3), x) == FiniteSet(0)
+    assert solveset_real(sqrt(x - 1), x) == FiniteSet(1)
+    assert solveset_real(sqrt((x-3)/x), x) == FiniteSet(3)
+    assert solveset_real(sqrt((x-3)/x)-Rational(1, 2), x) == \
+        FiniteSet(4)
+
+def test_solveset_sqrt_2():
+    x = Symbol('x', real=True)
+    y = Symbol('y', real=True)
+    # http://tutorial.math.lamar.edu/Classes/Alg/SolveRadicalEqns.aspx#Solve_Rad_Ex2_a
+    assert solveset_real(sqrt(2*x - 1) - sqrt(x - 4) - 2, x) == \
+        FiniteSet(S(5), S(13))
+    assert solveset_real(sqrt(x + 7) + 2 - sqrt(3 - x), x) == \
+        FiniteSet(-6)
+
+    # http://www.purplemath.com/modules/solverad.htm
+    assert solveset_real(sqrt(17*x - sqrt(x**2 - 5)) - 7, x) == \
+        FiniteSet(3)
+
+    eq = x + 1 - (x**4 + 4*x**3 - x)**Rational(1, 4)
+    assert solveset_real(eq, x) == FiniteSet(Rational(-1, 2), Rational(-1, 3))
+
+    eq = sqrt(2*x + 9) - sqrt(x + 1) - sqrt(x + 4)
+    assert solveset_real(eq, x) == FiniteSet(0)
+
+    eq = sqrt(x + 4) + sqrt(2*x - 1) - 3*sqrt(x - 1)
+    assert solveset_real(eq, x) == FiniteSet(5)
+
+    eq = sqrt(x)*sqrt(x - 7) - 12
+    assert solveset_real(eq, x) == FiniteSet(16)
+
+    eq = sqrt(x - 3) + sqrt(x) - 3
+    assert solveset_real(eq, x) == FiniteSet(4)
+
+    eq = sqrt(2*x**2 - 7) - (3 - x)
+    assert solveset_real(eq, x) == FiniteSet(-S(8), S(2))
+
+    # others
+    eq = sqrt(9*x**2 + 4) - (3*x + 2)
+    assert solveset_real(eq, x) == FiniteSet(0)
+
+    assert solveset_real(sqrt(x - 3) - sqrt(x) - 3, x) == FiniteSet()
+
+    eq = (2*x - 5)**Rational(1, 3) - 3
+    assert solveset_real(eq, x) == FiniteSet(16)
+
+    assert solveset_real(sqrt(x) + sqrt(sqrt(x)) - 4, x) == \
+        FiniteSet((Rational(-1, 2) + sqrt(17)/2)**4)
+
+    eq = sqrt(x) - sqrt(x - 1) + sqrt(sqrt(x))
+    assert solveset_real(eq, x) == FiniteSet()
+
+    eq = (x - 4)**2 + (sqrt(x) - 2)**4
+    assert solveset_real(eq, x) == FiniteSet(-4, 4)
+
+    eq = (sqrt(x) + sqrt(x + 1) + sqrt(1 - x) - 6*sqrt(5)/5)
+    ans = solveset_real(eq, x)
+    ra = S('''-1484/375 - 4*(-S(1)/2 + sqrt(3)*I/2)*(-12459439/52734375 +
+    114*sqrt(12657)/78125)**(S(1)/3) - 172564/(140625*(-S(1)/2 +
+    sqrt(3)*I/2)*(-12459439/52734375 + 114*sqrt(12657)/78125)**(S(1)/3))''')
+    rb = Rational(4, 5)
+    assert all(abs(eq.subs(x, i).n()) < 1e-10 for i in (ra, rb)) and \
+        len(ans) == 2 and \
+        {i.n(chop=True) for i in ans} == \
+        {i.n(chop=True) for i in (ra, rb)}
+
+    assert solveset_real(sqrt(x) + x**Rational(1, 3) +
+                                 x**Rational(1, 4), x) == FiniteSet(0)
+
+    assert solveset_real(x/sqrt(x**2 + 1), x) == FiniteSet(0)
+
+    eq = (x - y**3)/((y**2)*sqrt(1 - y**2))
+    assert solveset_real(eq, x) == FiniteSet(y**3)
+
+    # issue 4497
+    assert solveset_real(1/(5 + x)**Rational(1, 5) - 9, x) == \
+        FiniteSet(Rational(-295244, 59049))
+
+
+@XFAIL
+def test_solve_sqrt_fail():
+    # this only works if we check real_root(eq.subs(x, Rational(1, 3)))
+    # but checksol doesn't work like that
+    eq = (x**3 - 3*x**2)**Rational(1, 3) + 1 - x
+    assert solveset_real(eq, x) == FiniteSet(Rational(1, 3))
+
+
+@slow
+def test_solve_sqrt_3():
+    R = Symbol('R')
+    eq = sqrt(2)*R*sqrt(1/(R + 1)) + (R + 1)*(sqrt(2)*sqrt(1/(R + 1)) - 1)
+    sol = solveset_complex(eq, R)
+    fset = [Rational(5, 3) + 4*sqrt(10)*cos(atan(3*sqrt(111)/251)/3)/3,
+            -sqrt(10)*cos(atan(3*sqrt(111)/251)/3)/3 +
+            40*re(1/((Rational(-1, 2) - sqrt(3)*I/2)*(Rational(251, 27) + sqrt(111)*I/9)**Rational(1, 3)))/9 +
+            sqrt(30)*sin(atan(3*sqrt(111)/251)/3)/3 + Rational(5, 3) +
+            I*(-sqrt(30)*cos(atan(3*sqrt(111)/251)/3)/3 -
+               sqrt(10)*sin(atan(3*sqrt(111)/251)/3)/3 +
+               40*im(1/((Rational(-1, 2) - sqrt(3)*I/2)*(Rational(251, 27) + sqrt(111)*I/9)**Rational(1, 3)))/9)]
+    cset = [40*re(1/((Rational(-1, 2) + sqrt(3)*I/2)*(Rational(251, 27) + sqrt(111)*I/9)**Rational(1, 3)))/9 -
+            sqrt(10)*cos(atan(3*sqrt(111)/251)/3)/3 - sqrt(30)*sin(atan(3*sqrt(111)/251)/3)/3 +
+            Rational(5, 3) +
+            I*(40*im(1/((Rational(-1, 2) + sqrt(3)*I/2)*(Rational(251, 27) + sqrt(111)*I/9)**Rational(1, 3)))/9 -
+               sqrt(10)*sin(atan(3*sqrt(111)/251)/3)/3 +
+               sqrt(30)*cos(atan(3*sqrt(111)/251)/3)/3)]
+
+    fs = FiniteSet(*fset)
+    cs = ConditionSet(R, Eq(eq, 0), FiniteSet(*cset))
+    assert sol == (fs - {-1}) | (cs - {-1})
+
+    # the number of real roots will depend on the value of m: for m=1 there are 4
+    # and for m=-1 there are none.
+    eq = -sqrt((m - q)**2 + (-m/(2*q) + S.Half)**2) + sqrt((-m**2/2 - sqrt(
+        4*m**4 - 4*m**2 + 8*m + 1)/4 - Rational(1, 4))**2 + (m**2/2 - m - sqrt(
+            4*m**4 - 4*m**2 + 8*m + 1)/4 - Rational(1, 4))**2)
+    unsolved_object = ConditionSet(q, Eq(sqrt((m - q)**2 + (-m/(2*q) + S.Half)**2) -
+        sqrt((-m**2/2 - sqrt(4*m**4 - 4*m**2 + 8*m + 1)/4 - Rational(1, 4))**2 + (m**2/2 - m -
+        sqrt(4*m**4 - 4*m**2 + 8*m + 1)/4 - Rational(1, 4))**2), 0), S.Reals)
+    assert solveset_real(eq, q) == unsolved_object
+
+
+def test_solve_polynomial_symbolic_param():
+    assert solveset_complex((x**2 - 1)**2 - a, x) == \
+        FiniteSet(sqrt(1 + sqrt(a)), -sqrt(1 + sqrt(a)),
+                  sqrt(1 - sqrt(a)), -sqrt(1 - sqrt(a)))
+
+    # issue 4507
+    assert solveset_complex(y - b/(1 + a*x), x) == \
+        FiniteSet((b/y - 1)/a) - FiniteSet(-1/a)
+
+    # issue 4508
+    assert solveset_complex(y - b*x/(a + x), x) == \
+        FiniteSet(-a*y/(y - b)) - FiniteSet(-a)
+
+
+def test_solve_rational():
+    assert solveset_real(1/x + 1, x) == FiniteSet(-S.One)
+    assert solveset_real(1/exp(x) - 1, x) == FiniteSet(0)
+    assert solveset_real(x*(1 - 5/x), x) == FiniteSet(5)
+    assert solveset_real(2*x/(x + 2) - 1, x) == FiniteSet(2)
+    assert solveset_real((x**2/(7 - x)).diff(x), x) == \
+        FiniteSet(S.Zero, S(14))
+
+
+def test_solveset_real_gen_is_pow():
+    assert solveset_real(sqrt(1) + 1, x) is S.EmptySet
+
+
+def test_no_sol():
+    assert solveset(1 - oo*x) is S.EmptySet
+    assert solveset(oo*x, x) is S.EmptySet
+    assert solveset(oo*x - oo, x) is S.EmptySet
+    assert solveset_real(4, x) is S.EmptySet
+    assert solveset_real(exp(x), x) is S.EmptySet
+    assert solveset_real(x**2 + 1, x) is S.EmptySet
+    assert solveset_real(-3*a/sqrt(x), x) is S.EmptySet
+    assert solveset_real(1/x, x) is S.EmptySet
+    assert solveset_real(-(1 + x)/(2 + x)**2 + 1/(2 + x), x
+        ) is S.EmptySet
+
+
+def test_sol_zero_real():
+    assert solveset_real(0, x) == S.Reals
+    assert solveset(0, x, Interval(1, 2)) == Interval(1, 2)
+    assert solveset_real(-x**2 - 2*x + (x + 1)**2 - 1, x) == S.Reals
+
+
+def test_no_sol_rational_extragenous():
+    assert solveset_real((x/(x + 1) + 3)**(-2), x) is S.EmptySet
+    assert solveset_real((x - 1)/(1 + 1/(x - 1)), x) is S.EmptySet
+
+
+def test_solve_polynomial_cv_1a():
+    """
+    Test for solving on equations that can be converted to
+    a polynomial equation using the change of variable y -> x**Rational(p, q)
+    """
+    assert solveset_real(sqrt(x) - 1, x) == FiniteSet(1)
+    assert solveset_real(sqrt(x) - 2, x) == FiniteSet(4)
+    assert solveset_real(x**Rational(1, 4) - 2, x) == FiniteSet(16)
+    assert solveset_real(x**Rational(1, 3) - 3, x) == FiniteSet(27)
+    assert solveset_real(x*(x**(S.One / 3) - 3), x) == \
+        FiniteSet(S.Zero, S(27))
+
+
+def test_solveset_real_rational():
+    """Test solveset_real for rational functions"""
+    x = Symbol('x', real=True)
+    y = Symbol('y', real=True)
+    assert solveset_real((x - y**3) / ((y**2)*sqrt(1 - y**2)), x) \
+        == FiniteSet(y**3)
+    # issue 4486
+    assert solveset_real(2*x/(x + 2) - 1, x) == FiniteSet(2)
+
+
+def test_solveset_real_log():
+    assert solveset_real(log((x-1)*(x+1)), x) == \
+        FiniteSet(sqrt(2), -sqrt(2))
+
+
+def test_poly_gens():
+    assert solveset_real(4**(2*(x**2) + 2*x) - 8, x) == \
+        FiniteSet(Rational(-3, 2), S.Half)
+
+
+def test_solve_abs():
+    n = Dummy('n')
+    raises(ValueError, lambda: solveset(Abs(x) - 1, x))
+    assert solveset(Abs(x) - n, x, S.Reals).dummy_eq(
+        ConditionSet(x, Contains(n, Interval(0, oo)), {-n, n}))
+    assert solveset_real(Abs(x) - 2, x) == FiniteSet(-2, 2)
+    assert solveset_real(Abs(x) + 2, x) is S.EmptySet
+    assert solveset_real(Abs(x + 3) - 2*Abs(x - 3), x) == \
+        FiniteSet(1, 9)
+    assert solveset_real(2*Abs(x) - Abs(x - 1), x) == \
+        FiniteSet(-1, Rational(1, 3))
+
+    sol = ConditionSet(
+            x,
+            And(
+                Contains(b, Interval(0, oo)),
+                Contains(a + b, Interval(0, oo)),
+                Contains(a - b, Interval(0, oo))),
+            FiniteSet(-a - b - 3, -a + b - 3, a - b - 3, a + b - 3))
+    eq = Abs(Abs(x + 3) - a) - b
+    assert invert_real(eq, 0, x)[1] == sol
+    reps = {a: 3, b: 1}
+    eqab = eq.subs(reps)
+    for si in sol.subs(reps):
+        assert not eqab.subs(x, si)
+    assert dumeq(solveset(Eq(sin(Abs(x)), 1), x, domain=S.Reals), Union(
+        Intersection(Interval(0, oo), Union(
+        Intersection(ImageSet(Lambda(n, 2*n*pi + 3*pi/2), S.Integers),
+            Interval(-oo, 0)),
+        Intersection(ImageSet(Lambda(n, 2*n*pi + pi/2), S.Integers),
+            Interval(0, oo))))))
+
+
+def test_issue_9824():
+    assert dumeq(solveset(sin(x)**2 - 2*sin(x) + 1, x), ImageSet(Lambda(n, 2*n*pi + pi/2), S.Integers))
+    assert dumeq(solveset(cos(x)**2 - 2*cos(x) + 1, x), ImageSet(Lambda(n, 2*n*pi), S.Integers))
+
+
+def test_issue_9565():
+    assert solveset_real(Abs((x - 1)/(x - 5)) <= Rational(1, 3), x) == Interval(-1, 2)
+
+
+def test_issue_10069():
+    eq = abs(1/(x - 1)) - 1 > 0
+    assert solveset_real(eq, x) == Union(
+        Interval.open(0, 1), Interval.open(1, 2))
+
+
+def test_real_imag_splitting():
+    a, b = symbols('a b', real=True)
+    assert solveset_real(sqrt(a**2 - b**2) - 3, a) == \
+        FiniteSet(-sqrt(b**2 + 9), sqrt(b**2 + 9))
+    assert solveset_real(sqrt(a**2 + b**2) - 3, a) != \
+        S.EmptySet
+
+
+def test_units():
+    assert solveset_real(1/x - 1/(2*cm), x) == FiniteSet(2*cm)
+
+
+def test_solve_only_exp_1():
+    y = Symbol('y', positive=True)
+    assert solveset_real(exp(x) - y, x) == FiniteSet(log(y))
+    assert solveset_real(exp(x) + exp(-x) - 4, x) == \
+        FiniteSet(log(-sqrt(3) + 2), log(sqrt(3) + 2))
+    assert solveset_real(exp(x) + exp(-x) - y, x) != S.EmptySet
+
+
+def test_atan2():
+    # The .inverse() method on atan2 works only if x.is_real is True and the
+    # second argument is a real constant
+    assert solveset_real(atan2(x, 2) - pi/3, x) == FiniteSet(2*sqrt(3))
+
+
+def test_piecewise_solveset():
+    eq = Piecewise((x - 2, Gt(x, 2)), (2 - x, True)) - 3
+    assert set(solveset_real(eq, x)) == set(FiniteSet(-1, 5))
+
+    absxm3 = Piecewise(
+        (x - 3, 0 <= x - 3),
+        (3 - x, 0 > x - 3))
+    y = Symbol('y', positive=True)
+    assert solveset_real(absxm3 - y, x) == FiniteSet(-y + 3, y + 3)
+
+    f = Piecewise(((x - 2)**2, x >= 0), (0, True))
+    assert solveset(f, x, domain=S.Reals) == Union(FiniteSet(2), Interval(-oo, 0, True, True))
+
+    assert solveset(
+        Piecewise((x + 1, x > 0), (I, True)) - I, x, S.Reals
+        ) == Interval(-oo, 0)
+
+    assert solveset(Piecewise((x - 1, Ne(x, I)), (x, True)), x) == FiniteSet(1)
+
+    # issue 19718
+    g = Piecewise((1, x > 10), (0, True))
+    assert solveset(g > 0, x, S.Reals) == Interval.open(10, oo)
+
+    from sympy.logic.boolalg import BooleanTrue
+    f = BooleanTrue()
+    assert solveset(f, x, domain=Interval(-3, 10)) == Interval(-3, 10)
+
+    # issue 20552
+    f = Piecewise((0, Eq(x, 0)), (x**2/Abs(x), True))
+    g = Piecewise((0, Eq(x, pi)), ((x - pi)/sin(x), True))
+    assert solveset(f, x, domain=S.Reals) == FiniteSet(0)
+    assert solveset(g) == FiniteSet(pi)
+
+
+def test_solveset_complex_polynomial():
+    assert solveset_complex(a*x**2 + b*x + c, x) == \
+        FiniteSet(-b/(2*a) - sqrt(-4*a*c + b**2)/(2*a),
+                  -b/(2*a) + sqrt(-4*a*c + b**2)/(2*a))
+
+    assert solveset_complex(x - y**3, y) == FiniteSet(
+        (-x**Rational(1, 3))/2 + I*sqrt(3)*x**Rational(1, 3)/2,
+        x**Rational(1, 3),
+        (-x**Rational(1, 3))/2 - I*sqrt(3)*x**Rational(1, 3)/2)
+
+    assert solveset_complex(x + 1/x - 1, x) == \
+        FiniteSet(S.Half + I*sqrt(3)/2, S.Half - I*sqrt(3)/2)
+
+
+def test_sol_zero_complex():
+    assert solveset_complex(0, x) is S.Complexes
+
+
+def test_solveset_complex_rational():
+    assert solveset_complex((x - 1)*(x - I)/(x - 3), x) == \
+        FiniteSet(1, I)
+
+    assert solveset_complex((x - y**3)/((y**2)*sqrt(1 - y**2)), x) == \
+        FiniteSet(y**3)
+    assert solveset_complex(-x**2 - I, x) == \
+        FiniteSet(-sqrt(2)/2 + sqrt(2)*I/2, sqrt(2)/2 - sqrt(2)*I/2)
+
+
+def test_solve_quintics():
+    skip("This test is too slow")
+    f = x**5 - 110*x**3 - 55*x**2 + 2310*x + 979
+    s = solveset_complex(f, x)
+    for root in s:
+        res = f.subs(x, root.n()).n()
+        assert tn(res, 0)
+
+    f = x**5 + 15*x + 12
+    s = solveset_complex(f, x)
+    for root in s:
+        res = f.subs(x, root.n()).n()
+        assert tn(res, 0)
+
+
+def test_solveset_complex_exp():
+    assert dumeq(solveset_complex(exp(x) - 1, x),
+        imageset(Lambda(n, I*2*n*pi), S.Integers))
+    assert dumeq(solveset_complex(exp(x) - I, x),
+        imageset(Lambda(n, I*(2*n*pi + pi/2)), S.Integers))
+    assert solveset_complex(1/exp(x), x) == S.EmptySet
+    assert dumeq(solveset_complex(sinh(x).rewrite(exp), x),
+        imageset(Lambda(n, n*pi*I), S.Integers))
+
+
+def test_solveset_real_exp():
+    assert solveset(Eq((-2)**x, 4), x, S.Reals) == FiniteSet(2)
+    assert solveset(Eq(-2**x, 4), x, S.Reals) == S.EmptySet
+    assert solveset(Eq((-3)**x, 27), x, S.Reals) == S.EmptySet
+    assert solveset(Eq((-5)**(x+1), 625), x, S.Reals) == FiniteSet(3)
+    assert solveset(Eq(2**(x-3), -16), x, S.Reals) == S.EmptySet
+    assert solveset(Eq((-3)**(x - 3), -3**39), x, S.Reals) == FiniteSet(42)
+    assert solveset(Eq(2**x, y), x, S.Reals) == Intersection(S.Reals, FiniteSet(log(y)/log(2)))
+
+    assert invert_real((-2)**(2*x) - 16, 0, x) == (x, FiniteSet(2))
+
+
+def test_solve_complex_log():
+    assert solveset_complex(log(x), x) == FiniteSet(1)
+    assert solveset_complex(1 - log(a + 4*x**2), x) == \
+        FiniteSet(-sqrt(-a + E)/2, sqrt(-a + E)/2)
+
+
+def test_solve_complex_sqrt():
+    assert solveset_complex(sqrt(5*x + 6) - 2 - x, x) == \
+        FiniteSet(-S.One, S(2))
+    assert solveset_complex(sqrt(5*x + 6) - (2 + 2*I) - x, x) == \
+        FiniteSet(-S(2), 3 - 4*I)
+    assert solveset_complex(4*x*(1 - a * sqrt(x)), x) == \
+        FiniteSet(S.Zero, 1 / a ** 2)
+
+
+def test_solveset_complex_tan():
+    s = solveset_complex(tan(x).rewrite(exp), x)
+    assert dumeq(s, imageset(Lambda(n, pi*n), S.Integers) - \
+        imageset(Lambda(n, pi*n + pi/2), S.Integers))
+
+
+@_both_exp_pow
+def test_solve_trig():
+    assert dumeq(solveset_real(sin(x), x),
+        Union(imageset(Lambda(n, 2*pi*n), S.Integers),
+              imageset(Lambda(n, 2*pi*n + pi), S.Integers)))
+
+    assert dumeq(solveset_real(sin(x) - 1, x),
+        imageset(Lambda(n, 2*pi*n + pi/2), S.Integers))
+
+    assert dumeq(solveset_real(cos(x), x),
+        Union(imageset(Lambda(n, 2*pi*n + pi/2), S.Integers),
+              imageset(Lambda(n, 2*pi*n + pi*Rational(3, 2)), S.Integers)))
+
+    assert dumeq(solveset_real(sin(x) + cos(x), x),
+        Union(imageset(Lambda(n, 2*n*pi + pi*Rational(3, 4)), S.Integers),
+              imageset(Lambda(n, 2*n*pi + pi*Rational(7, 4)), S.Integers)))
+
+    assert solveset_real(sin(x)**2 + cos(x)**2, x) == S.EmptySet
+
+    assert dumeq(solveset_complex(cos(x) - S.Half, x),
+        Union(imageset(Lambda(n, 2*n*pi + pi*Rational(5, 3)), S.Integers),
+              imageset(Lambda(n, 2*n*pi + pi/3), S.Integers)))
+
+    assert dumeq(solveset(sin(y + a) - sin(y), a, domain=S.Reals),
+        ConditionSet(a, (S(-1) <= sin(y)) & (sin(y) <= S(1)), Union(
+            ImageSet(Lambda(n, 2*n*pi - y + asin(sin(y))), S.Integers),
+            ImageSet(Lambda(n, 2*n*pi - y - asin(sin(y)) + pi), S.Integers))))
+
+    assert dumeq(solveset_real(sin(2*x)*cos(x) + cos(2*x)*sin(x)-1, x),
+        ImageSet(Lambda(n, n*pi*Rational(2, 3) + pi/6), S.Integers))
+
+    assert dumeq(solveset_real(2*tan(x)*sin(x) + 1, x), Union(
+        ImageSet(Lambda(n, 2*n*pi + atan(sqrt(2)*sqrt(-1 + sqrt(17))/
+            (1 - sqrt(17))) + pi), S.Integers),
+        ImageSet(Lambda(n, 2*n*pi - atan(sqrt(2)*sqrt(-1 + sqrt(17))/
+            (1 - sqrt(17))) + pi), S.Integers)))
+
+    assert dumeq(solveset_real(cos(2*x)*cos(4*x) - 1, x),
+                            ImageSet(Lambda(n, n*pi), S.Integers))
+
+    assert dumeq(solveset(sin(x/10) + Rational(3, 4)), Union(
+        ImageSet(Lambda(n, 20*n*pi - 10*asin(S(3)/4) + 20*pi), S.Integers),
+        ImageSet(Lambda(n, 20*n*pi + 10*asin(S(3)/4) + 10*pi), S.Integers)))
+
+    assert dumeq(solveset(cos(x/15) + cos(x/5)), Union(
+        ImageSet(Lambda(n, 30*n*pi + 15*pi/2), S.Integers),
+        ImageSet(Lambda(n, 30*n*pi + 45*pi/2), S.Integers),
+        ImageSet(Lambda(n, 30*n*pi + 75*pi/4), S.Integers),
+        ImageSet(Lambda(n, 30*n*pi + 45*pi/4), S.Integers),
+        ImageSet(Lambda(n, 30*n*pi + 105*pi/4), S.Integers),
+        ImageSet(Lambda(n, 30*n*pi + 15*pi/4), S.Integers)))
+
+    assert dumeq(solveset(sec(sqrt(2)*x/3) + 5), Union(
+        ImageSet(Lambda(n, 3*sqrt(2)*(2*n*pi - asec(-5))/2), S.Integers),
+        ImageSet(Lambda(n, 3*sqrt(2)*(2*n*pi + asec(-5))/2), S.Integers)))
+
+    assert dumeq(simplify(solveset(tan(pi*x) - cot(pi/2*x))), Union(
+        ImageSet(Lambda(n, 4*n + 1), S.Integers),
+        ImageSet(Lambda(n, 4*n + 3), S.Integers),
+        ImageSet(Lambda(n, 4*n + Rational(7, 3)), S.Integers),
+        ImageSet(Lambda(n, 4*n + Rational(5, 3)), S.Integers),
+        ImageSet(Lambda(n, 4*n + Rational(11, 3)), S.Integers),
+        ImageSet(Lambda(n, 4*n + Rational(1, 3)), S.Integers)))
+
+    assert dumeq(solveset(cos(9*x)), Union(
+        ImageSet(Lambda(n, 2*n*pi/9 + pi/18), S.Integers),
+        ImageSet(Lambda(n, 2*n*pi/9 + pi/6), S.Integers)))
+
+    assert dumeq(solveset(sin(8*x) + cot(12*x), x, S.Reals), Union(
+        ImageSet(Lambda(n, n*pi/2 + pi/8), S.Integers),
+        ImageSet(Lambda(n, n*pi/2 + 3*pi/8), S.Integers),
+        ImageSet(Lambda(n, n*pi/2 + 5*pi/16), S.Integers),
+        ImageSet(Lambda(n, n*pi/2 + 3*pi/16), S.Integers),
+        ImageSet(Lambda(n, n*pi/2 + 7*pi/16), S.Integers),
+        ImageSet(Lambda(n, n*pi/2 + pi/16), S.Integers)))
+
+    # This is the only remaining solveset test that actually ends up being solved
+    # by _solve_trig2(). All others are handled by the improved _solve_trig1.
+    assert dumeq(solveset_real(2*cos(x)*cos(2*x) - 1, x),
+          Union(ImageSet(Lambda(n, 2*n*pi + 2*atan(sqrt(-2*2**Rational(1, 3)*(67 +
+                  9*sqrt(57))**Rational(2, 3) + 8*2**Rational(2, 3) + 11*(67 +
+                  9*sqrt(57))**Rational(1, 3))/(3*(67 + 9*sqrt(57))**Rational(1, 6)))), S.Integers),
+                  ImageSet(Lambda(n, 2*n*pi - 2*atan(sqrt(-2*2**Rational(1, 3)*(67 +
+                  9*sqrt(57))**Rational(2, 3) + 8*2**Rational(2, 3) + 11*(67 +
+                  9*sqrt(57))**Rational(1, 3))/(3*(67 + 9*sqrt(57))**Rational(1, 6))) +
+                  2*pi), S.Integers)))
+
+    # issue #16870
+    assert dumeq(simplify(solveset(sin(x/180*pi) - S.Half, x, S.Reals)), Union(
+        ImageSet(Lambda(n, 360*n + 150), S.Integers),
+        ImageSet(Lambda(n, 360*n + 30), S.Integers)))
+
+
+def test_solve_trig_hyp_by_inversion():
+    n = Dummy('n')
+    assert solveset_real(sin(2*x + 3) - S(1)/2, x).dummy_eq(Union(
+        ImageSet(Lambda(n, n*pi - S(3)/2 + 13*pi/12), S.Integers),
+        ImageSet(Lambda(n, n*pi - S(3)/2 + 17*pi/12), S.Integers)))
+    assert solveset_complex(sin(2*x + 3) - S(1)/2, x).dummy_eq(Union(
+        ImageSet(Lambda(n, n*pi - S(3)/2 + 13*pi/12), S.Integers),
+        ImageSet(Lambda(n, n*pi - S(3)/2 + 17*pi/12), S.Integers)))
+    assert solveset_real(tan(x) - tan(pi/10), x).dummy_eq(
+        ImageSet(Lambda(n, n*pi + pi/10), S.Integers))
+    assert solveset_complex(tan(x) - tan(pi/10), x).dummy_eq(
+        ImageSet(Lambda(n, n*pi + pi/10), S.Integers))
+
+    assert solveset_real(3*cosh(2*x) - 5, x) == FiniteSet(
+        -acosh(S(5)/3)/2, acosh(S(5)/3)/2)
+    assert solveset_complex(3*cosh(2*x) - 5, x).dummy_eq(Union(
+        ImageSet(Lambda(n, n*I*pi - acosh(S(5)/3)/2), S.Integers),
+        ImageSet(Lambda(n, n*I*pi + acosh(S(5)/3)/2), S.Integers)))
+    assert solveset_real(sinh(x - 3) - 2, x) == FiniteSet(
+        asinh(2) + 3)
+    assert solveset_complex(sinh(x - 3) - 2, x).dummy_eq(Union(
+        ImageSet(Lambda(n, 2*n*I*pi + asinh(2) + 3), S.Integers),
+        ImageSet(Lambda(n, 2*n*I*pi - asinh(2) + 3 + I*pi), S.Integers)))
+
+    assert solveset_real(cos(sinh(x))-cos(pi/12), x).dummy_eq(Union(
+        ImageSet(Lambda(n, asinh(2*n*pi + pi/12)), S.Integers),
+        ImageSet(Lambda(n, asinh(2*n*pi + 23*pi/12)), S.Integers)))
+    assert solveset(cos(sinh(x))-cos(pi/12), x, Interval(2,3)) == \
+        FiniteSet(asinh(23*pi/12), asinh(25*pi/12))
+    assert solveset_real(cosh(x**2-1)-2, x) == FiniteSet(
+        -sqrt(1 + acosh(2)), sqrt(1 + acosh(2)))
+
+    assert solveset_real(sin(x) - 2, x) == S.EmptySet   # issue #17334
+    assert solveset_real(cos(x) + 2, x) == S.EmptySet
+    assert solveset_real(sec(x), x) == S.EmptySet
+    assert solveset_real(csc(x), x) == S.EmptySet
+    assert solveset_real(cosh(x) + 1, x) == S.EmptySet
+    assert solveset_real(coth(x), x) == S.EmptySet
+    assert solveset_real(sech(x) - 2, x) == S.EmptySet
+    assert solveset_real(sech(x), x) == S.EmptySet
+    assert solveset_real(tanh(x) + 1, x) == S.EmptySet
+    assert solveset_complex(tanh(x), 1) == S.EmptySet
+    assert solveset_complex(coth(x), -1) == S.EmptySet
+    assert solveset_complex(sech(x), 0) == S.EmptySet
+    assert solveset_complex(csch(x), 0) == S.EmptySet
+
+    assert solveset_real(abs(csch(x)) - 3, x) == FiniteSet(-acsch(3), acsch(3))
+
+    assert solveset_real(tanh(x**2 - 1) - exp(-9), x) == FiniteSet(
+        -sqrt(atanh(exp(-9)) + 1), sqrt(atanh(exp(-9)) + 1))
+
+    assert solveset_real(coth(log(x)) + 2, x) == FiniteSet(exp(-acoth(2)))
+    assert solveset_real(coth(exp(x)) + 2, x) == S.EmptySet
+
+    assert solveset_complex(sinh(x) - I/2, x).dummy_eq(Union(
+        ImageSet(Lambda(n, 2*I*pi*n + 5*I*pi/6), S.Integers),
+        ImageSet(Lambda(n, 2*I*pi*n + I*pi/6), S.Integers)))
+    assert solveset_complex(sinh(x/10) + Rational(3, 4), x).dummy_eq(Union(
+        ImageSet(Lambda(n, 20*n*I*pi - 10*asinh(S(3)/4)), S.Integers),
+        ImageSet(Lambda(n, 20*n*I*pi + 10*asinh(S(3)/4) + 10*I*pi), S.Integers)))
+    assert solveset_complex(sech(sqrt(2)*x/3) + 5, x).dummy_eq(Union(
+        ImageSet(Lambda(n, 3*sqrt(2)*(2*n*I*pi - asech(-5))/2), S.Integers),
+        ImageSet(Lambda(n, 3*sqrt(2)*(2*n*I*pi + asech(-5))/2), S.Integers)))
+    assert solveset_complex(cosh(9*x), x).dummy_eq(Union(
+        ImageSet(Lambda(n, 2*n*I*pi/9 + I*pi/18), S.Integers),
+        ImageSet(Lambda(n, 2*n*I*pi/9 + I*pi/6), S.Integers)))
+
+    eq = (x**5 -4*x + 1).subs(x, coth(z))
+    assert solveset(eq, z, S.Complexes).dummy_eq(Union(
+        ImageSet(Lambda(n, n*I*pi + acoth(CRootOf(x**5 -4*x + 1, 0))), S.Integers),
+        ImageSet(Lambda(n, n*I*pi + acoth(CRootOf(x**5 -4*x + 1, 1))), S.Integers),
+        ImageSet(Lambda(n, n*I*pi + acoth(CRootOf(x**5 -4*x + 1, 2))), S.Integers),
+        ImageSet(Lambda(n, n*I*pi + acoth(CRootOf(x**5 -4*x + 1, 3))), S.Integers),
+        ImageSet(Lambda(n, n*I*pi + acoth(CRootOf(x**5 -4*x + 1, 4))), S.Integers)))
+    assert solveset(eq, z, S.Reals) == FiniteSet(
+        acoth(CRootOf(x**5 - 4*x + 1, 0)), acoth(CRootOf(x**5 - 4*x + 1, 2)))
+
+    eq = ((x-sqrt(3)/2)*(x+2)).expand().subs(x, cos(x))
+    assert solveset(eq, x, S.Complexes).dummy_eq(Union(
+        ImageSet(Lambda(n, 2*n*pi - acos(-2)), S.Integers),
+        ImageSet(Lambda(n, 2*n*pi + acos(-2)), S.Integers),
+        ImageSet(Lambda(n, 2*n*pi + pi/6), S.Integers),
+        ImageSet(Lambda(n, 2*n*pi + 11*pi/6), S.Integers)))
+    assert solveset(eq, x, S.Reals).dummy_eq(Union(
+        ImageSet(Lambda(n, 2*n*pi + pi/6), S.Integers),
+        ImageSet(Lambda(n, 2*n*pi + 11*pi/6), S.Integers)))
+
+    assert solveset((1+sec(sqrt(3)*x+4)**2)/(1-sec(sqrt(3)*x+4))).dummy_eq(Union(
+        ImageSet(Lambda(n, sqrt(3)*(2*n*pi - 4 - asec(I))/3), S.Integers),
+        ImageSet(Lambda(n, sqrt(3)*(2*n*pi - 4 + asec(I))/3), S.Integers),
+        ImageSet(Lambda(n, sqrt(3)*(2*n*pi - 4 - asec(-I))/3), S.Integers),
+        ImageSet(Lambda(n, sqrt(3)*(2*n*pi - 4 + asec(-I))/3), S.Integers)))
+
+    assert all_close(solveset(tan(3.14*x)**(S(3)/2)-5.678, x, Interval(0, 3)),
+        FiniteSet(0.403301114561067, 0.403301114561067 + 0.318471337579618*pi,
+                0.403301114561067 + 0.636942675159236*pi))
+
+
+def test_old_trig_issues():
+    # issues #9606 / #9531:
+    assert solveset(sinh(x), x, S.Reals) == FiniteSet(0)
+    assert solveset(sinh(x), x, S.Complexes).dummy_eq(Union(
+        ImageSet(Lambda(n, 2*n*I*pi), S.Integers),
+        ImageSet(Lambda(n, 2*n*I*pi + I*pi), S.Integers)))
+
+    # issues #11218 / #18427
+    assert solveset(sin(pi*x), x, S.Reals).dummy_eq(Union(
+        ImageSet(Lambda(n, (2*n*pi + pi)/pi), S.Integers),
+        ImageSet(Lambda(n, 2*n), S.Integers)))
+    assert solveset(sin(pi*x), x).dummy_eq(Union(
+        ImageSet(Lambda(n, (2*n*pi + pi)/pi), S.Integers),
+        ImageSet(Lambda(n, 2*n), S.Integers)))
+
+    # issue #17543
+    assert solveset(I*cot(8*x - 8*E), x).dummy_eq(
+        ImageSet(Lambda(n, pi*n/8 - 13*pi/16 + E), S.Integers))
+
+    # issue #20798
+    assert all_close(solveset(cos(2*x) - 0.5, x, Interval(0, 2*pi)), FiniteSet(
+        0.523598775598299, -0.523598775598299 + pi,
+        -0.523598775598299 + 2*pi, 0.523598775598299 + pi))
+    sol = Union(ImageSet(Lambda(n, n*pi - 0.523598775598299), S.Integers),
+                ImageSet(Lambda(n, n*pi + 0.523598775598299), S.Integers))
+    ret = solveset(cos(2*x) - 0.5, x, S.Reals)
+    # replace Dummy n by the regular Symbol n to allow all_close comparison.
+    ret = ret.subs(ret.atoms(Dummy).pop(), n)
+    assert all_close(ret, sol)
+    ret = solveset(cos(2*x) - 0.5, x, S.Complexes)
+    ret = ret.subs(ret.atoms(Dummy).pop(), n)
+    assert all_close(ret, sol)
+
+    # issue #21296 / #17667
+    assert solveset(tan(x)-sqrt(2), x, Interval(0, pi/2)) == FiniteSet(atan(sqrt(2)))
+    assert solveset(tan(x)-pi, x, Interval(0, pi/2)) == FiniteSet(atan(pi))
+
+    # issue #17667
+    # not yet working properly:
+    # solveset(cos(x)-y, x, Interval(0, pi))
+    assert solveset(cos(x)-y, x, S.Reals).dummy_eq(
+        ConditionSet(x,(S(-1) <= y) & (y <= S(1)), Union(
+            ImageSet(Lambda(n, 2*n*pi - acos(y)), S.Integers),
+            ImageSet(Lambda(n, 2*n*pi + acos(y)), S.Integers))))
+
+    # issue #17579
+    # Valid result, but the intersection could potentially be simplified.
+    assert solveset(sin(log(x)), x, Interval(0,1, True, False)).dummy_eq(
+        Union(Intersection(ImageSet(Lambda(n, exp(2*n*pi)), S.Integers), Interval.Lopen(0, 1)),
+              Intersection(ImageSet(Lambda(n, exp(2*n*pi + pi)), S.Integers), Interval.Lopen(0, 1))))
+
+    # issue #17334
+    assert solveset(sin(x) - sin(1), x, S.Reals).dummy_eq(Union(
+        ImageSet(Lambda(n, 2*n*pi + 1), S.Integers),
+        ImageSet(Lambda(n, 2*n*pi - 1 + pi), S.Integers)))
+    assert solveset(sin(x) - sqrt(5)/3, x, S.Reals).dummy_eq(Union(
+        ImageSet(Lambda(n, 2*n*pi + asin(sqrt(5)/3)), S.Integers),
+        ImageSet(Lambda(n, 2*n*pi - asin(sqrt(5)/3) + pi), S.Integers)))
+    assert solveset(sinh(x)-cosh(2), x, S.Reals) == FiniteSet(asinh(cosh(2)))
+
+    # issue 9825
+    assert solveset(Eq(tan(x), y), x, domain=S.Reals).dummy_eq(
+        ConditionSet(x, (-oo < y) & (y < oo),
+                     ImageSet(Lambda(n, n*pi + atan(y)), S.Integers)))
+    r = Symbol('r', real=True)
+    assert solveset(Eq(tan(x), r), x, domain=S.Reals).dummy_eq(
+        ImageSet(Lambda(n, n*pi + atan(r)), S.Integers))
+
+
+def test_solve_hyperbolic():
+    # actual solver: _solve_trig1
+    n = Dummy('n')
+    assert solveset(sinh(x) + cosh(x), x) == S.EmptySet
+    assert solveset(sinh(x) + cos(x), x) == ConditionSet(x,
+        Eq(cos(x) + sinh(x), 0), S.Complexes)
+    assert solveset_real(sinh(x) + sech(x), x) == FiniteSet(
+        log(sqrt(sqrt(5) - 2)))
+    assert solveset_real(cosh(2*x) + 2*sinh(x) - 5, x) == FiniteSet(
+        log(-2 + sqrt(5)), log(1 + sqrt(2)))
+    assert solveset_real((coth(x) + sinh(2*x))/cosh(x) - 3, x) == FiniteSet(
+        log(S.Half + sqrt(5)/2), log(1 + sqrt(2)))
+    assert solveset_real(cosh(x)*sinh(x) - 2, x) == FiniteSet(
+        log(4 + sqrt(17))/2)
+    assert solveset_real(sinh(x) + tanh(x) - 1, x) == FiniteSet(
+        log(sqrt(2)/2 + sqrt(-S(1)/2 + sqrt(2))))
+
+    assert dumeq(solveset_complex(sinh(x) + sech(x), x), Union(
+        ImageSet(Lambda(n, 2*n*I*pi + log(sqrt(-2 + sqrt(5)))), S.Integers),
+        ImageSet(Lambda(n, I*(2*n*pi + pi/2) + log(sqrt(2 + sqrt(5)))), S.Integers),
+        ImageSet(Lambda(n, I*(2*n*pi + pi) + log(sqrt(-2 + sqrt(5)))), S.Integers),
+        ImageSet(Lambda(n, I*(2*n*pi - pi/2) + log(sqrt(2 + sqrt(5)))), S.Integers)))
+
+    assert dumeq(solveset(cosh(x/15) + cosh(x/5)), Union(
+        ImageSet(Lambda(n, 15*I*(2*n*pi + pi/2)), S.Integers),
+        ImageSet(Lambda(n, 15*I*(2*n*pi - pi/2)), S.Integers),
+        ImageSet(Lambda(n, 15*I*(2*n*pi - 3*pi/4)), S.Integers),
+        ImageSet(Lambda(n, 15*I*(2*n*pi + 3*pi/4)), S.Integers),
+        ImageSet(Lambda(n, 15*I*(2*n*pi - pi/4)), S.Integers),
+        ImageSet(Lambda(n, 15*I*(2*n*pi + pi/4)), S.Integers)))
+
+    assert dumeq(solveset(tanh(pi*x) - coth(pi/2*x)), Union(
+        ImageSet(Lambda(n, 2*I*(2*n*pi + pi/2)/pi), S.Integers),
+        ImageSet(Lambda(n, 2*I*(2*n*pi - pi/2)/pi), S.Integers)))
+
+    # issues #18490 / #19489
+    assert solveset(cosh(x) + cosh(3*x) - cosh(5*x), x, S.Reals
+        ).dummy_eq(ConditionSet(x,
+        Eq(cosh(x) + cosh(3*x) - cosh(5*x), 0), S.Reals))
+    assert solveset(sinh(8*x) + coth(12*x)).dummy_eq(
+        ConditionSet(x, Eq(sinh(8*x) + coth(12*x), 0), S.Complexes))
+
+
+def test_solve_trig_hyp_symbolic():
+    # actual solver: invert_trig_hyp
+    assert dumeq(solveset(sin(a*x), x), ConditionSet(x, Ne(a, 0), Union(
+        ImageSet(Lambda(n, (2*n*pi + pi)/a), S.Integers),
+        ImageSet(Lambda(n, 2*n*pi/a), S.Integers))))
+
+    assert dumeq(solveset(cosh(x/a), x), ConditionSet(x, Ne(a, 0), Union(
+        ImageSet(Lambda(n, a*(2*n*I*pi + I*pi/2)), S.Integers),
+        ImageSet(Lambda(n, a*(2*n*I*pi + 3*I*pi/2)), S.Integers))))
+
+    assert dumeq(solveset(sin(2*sqrt(3)/3*a**2/(b*pi)*x)
+        + cos(4*sqrt(3)/3*a**2/(b*pi)*x), x),
+       ConditionSet(x, Ne(b, 0) & Ne(a**2, 0), Union(
+           ImageSet(Lambda(n, sqrt(3)*pi*b*(2*n*pi + pi/2)/(2*a**2)), S.Integers),
+           ImageSet(Lambda(n, sqrt(3)*pi*b*(2*n*pi - 5*pi/6)/(2*a**2)), S.Integers),
+           ImageSet(Lambda(n, sqrt(3)*pi*b*(2*n*pi - pi/6)/(2*a**2)), S.Integers))))
+
+    assert dumeq(solveset(cosh((a**2 + 1)*x) - 3, x), ConditionSet(
+        x, Ne(a**2 + 1, 0), Union(
+            ImageSet(Lambda(n, (2*n*I*pi - acosh(3))/(a**2 + 1)), S.Integers),
+            ImageSet(Lambda(n, (2*n*I*pi + acosh(3))/(a**2 + 1)), S.Integers))))
+
+    ar = Symbol('ar', real=True)
+    assert solveset(cosh((ar**2 + 1)*x) - 2, x, S.Reals) == FiniteSet(
+        -acosh(2)/(ar**2 + 1), acosh(2)/(ar**2 + 1))
+
+    # actual solver: _solve_trig1
+    assert dumeq(simplify(solveset(cot((1 + I)*x) - cot((3 + 3*I)*x), x)), Union(
+        ImageSet(Lambda(n, pi*(1 - I)*(4*n + 1)/4), S.Integers),
+        ImageSet(Lambda(n, pi*(1 - I)*(4*n - 1)/4), S.Integers)))
+
+
+def test_issue_9616():
+    assert dumeq(solveset(sinh(x) + tanh(x) - 1, x), Union(
+        ImageSet(Lambda(n, 2*n*I*pi + log(sqrt(2)/2 + sqrt(-S.Half + sqrt(2)))), S.Integers),
+        ImageSet(Lambda(n, I*(2*n*pi - atan(sqrt(2)*sqrt(S.Half + sqrt(2))) + pi)
+            + log(sqrt(1 + sqrt(2)))), S.Integers),
+        ImageSet(Lambda(n, I*(2*n*pi + pi) + log(-sqrt(2)/2 + sqrt(-S.Half + sqrt(2)))), S.Integers),
+        ImageSet(Lambda(n, I*(2*n*pi - pi + atan(sqrt(2)*sqrt(S.Half + sqrt(2))))
+            + log(sqrt(1 + sqrt(2)))), S.Integers)))
+    f1 = (sinh(x)).rewrite(exp)
+    f2 = (tanh(x)).rewrite(exp)
+    assert dumeq(solveset(f1 + f2 - 1, x), Union(
+        Complement(ImageSet(
+            Lambda(n, I*(2*n*pi + pi) + log(-sqrt(2)/2 + sqrt(-S.Half + sqrt(2)))), S.Integers),
+            ImageSet(Lambda(n, I*(2*n*pi + pi)/2), S.Integers)),
+        Complement(ImageSet(Lambda(n, I*(2*n*pi - pi + atan(sqrt(2)*sqrt(S.Half + sqrt(2))))
+                + log(sqrt(1 + sqrt(2)))), S.Integers),
+            ImageSet(Lambda(n, I*(2*n*pi + pi)/2), S.Integers)),
+        Complement(ImageSet(Lambda(n, I*(2*n*pi - atan(sqrt(2)*sqrt(S.Half + sqrt(2))) + pi)
+                + log(sqrt(1 + sqrt(2)))), S.Integers),
+            ImageSet(Lambda(n, I*(2*n*pi + pi)/2), S.Integers)),
+        Complement(
+            ImageSet(Lambda(n, 2*n*I*pi + log(sqrt(2)/2 + sqrt(-S.Half + sqrt(2)))), S.Integers),
+            ImageSet(Lambda(n, I*(2*n*pi + pi)/2), S.Integers))))
+
+
+def test_solve_invalid_sol():
+    assert 0 not in solveset_real(sin(x)/x, x)
+    assert 0 not in solveset_complex((exp(x) - 1)/x, x)
+
+
+@XFAIL
+def test_solve_trig_simplified():
+    n = Dummy('n')
+    assert dumeq(solveset_real(sin(x), x),
+        imageset(Lambda(n, n*pi), S.Integers))
+
+    assert dumeq(solveset_real(cos(x), x),
+        imageset(Lambda(n, n*pi + pi/2), S.Integers))
+
+    assert dumeq(solveset_real(cos(x) + sin(x), x),
+        imageset(Lambda(n, n*pi - pi/4), S.Integers))
+
+
+@XFAIL
+def test_solve_lambert():
+    assert solveset_real(x*exp(x) - 1, x) == FiniteSet(LambertW(1))
+    assert solveset_real(exp(x) + x, x) == FiniteSet(-LambertW(1))
+    assert solveset_real(x + 2**x, x) == \
+        FiniteSet(-LambertW(log(2))/log(2))
+
+    # issue 4739
+    ans = solveset_real(3*x + 5 + 2**(-5*x + 3), x)
+    assert ans == FiniteSet(Rational(-5, 3) +
+                            LambertW(-10240*2**Rational(1, 3)*log(2)/3)/(5*log(2)))
+
+    eq = 2*(3*x + 4)**5 - 6*7**(3*x + 9)
+    result = solveset_real(eq, x)
+    ans = FiniteSet((log(2401) +
+                     5*LambertW(-log(7**(7*3**Rational(1, 5)/5))))/(3*log(7))/-1)
+    assert result == ans
+    assert solveset_real(eq.expand(), x) == result
+
+    assert solveset_real(5*x - 1 + 3*exp(2 - 7*x), x) == \
+        FiniteSet(Rational(1, 5) + LambertW(-21*exp(Rational(3, 5))/5)/7)
+
+    assert solveset_real(2*x + 5 + log(3*x - 2), x) == \
+        FiniteSet(Rational(2, 3) + LambertW(2*exp(Rational(-19, 3))/3)/2)
+
+    assert solveset_real(3*x + log(4*x), x) == \
+        FiniteSet(LambertW(Rational(3, 4))/3)
+
+    assert solveset_real(x**x - 2) == FiniteSet(exp(LambertW(log(2))))
+
+    a = Symbol('a')
+    assert solveset_real(-a*x + 2*x*log(x), x) == FiniteSet(exp(a/2))
+    a = Symbol('a', real=True)
+    assert solveset_real(a/x + exp(x/2), x) == \
+        FiniteSet(2*LambertW(-a/2))
+    assert solveset_real((a/x + exp(x/2)).diff(x), x) == \
+        FiniteSet(4*LambertW(sqrt(2)*sqrt(a)/4))
+
+    # coverage test
+    assert solveset_real(tanh(x + 3)*tanh(x - 3) - 1, x) is S.EmptySet
+
+    assert solveset_real((x**2 - 2*x + 1).subs(x, log(x) + 3*x), x) == \
+        FiniteSet(LambertW(3*S.Exp1)/3)
+    assert solveset_real((x**2 - 2*x + 1).subs(x, (log(x) + 3*x)**2 - 1), x) == \
+        FiniteSet(LambertW(3*exp(-sqrt(2)))/3, LambertW(3*exp(sqrt(2)))/3)
+    assert solveset_real((x**2 - 2*x - 2).subs(x, log(x) + 3*x), x) == \
+        FiniteSet(LambertW(3*exp(1 + sqrt(3)))/3, LambertW(3*exp(-sqrt(3) + 1))/3)
+    assert solveset_real(x*log(x) + 3*x + 1, x) == \
+        FiniteSet(exp(-3 + LambertW(-exp(3))))
+    eq = (x*exp(x) - 3).subs(x, x*exp(x))
+    assert solveset_real(eq, x) == \
+        FiniteSet(LambertW(3*exp(-LambertW(3))))
+
+    assert solveset_real(3*log(a**(3*x + 5)) + a**(3*x + 5), x) == \
+        FiniteSet(-((log(a**5) + LambertW(Rational(1, 3)))/(3*log(a))))
+    p = symbols('p', positive=True)
+    assert solveset_real(3*log(p**(3*x + 5)) + p**(3*x + 5), x) == \
+        FiniteSet(
+        log((-3**Rational(1, 3) - 3**Rational(5, 6)*I)*LambertW(Rational(1, 3))**Rational(1, 3)/(2*p**Rational(5, 3)))/log(p),
+        log((-3**Rational(1, 3) + 3**Rational(5, 6)*I)*LambertW(Rational(1, 3))**Rational(1, 3)/(2*p**Rational(5, 3)))/log(p),
+        log((3*LambertW(Rational(1, 3))/p**5)**(1/(3*log(p)))),)  # checked numerically
+    # check collection
+    b = Symbol('b')
+    eq = 3*log(a**(3*x + 5)) + b*log(a**(3*x + 5)) + a**(3*x + 5)
+    assert solveset_real(eq, x) == FiniteSet(
+        -((log(a**5) + LambertW(1/(b + 3)))/(3*log(a))))
+
+    # issue 4271
+    assert solveset_real((a/x + exp(x/2)).diff(x, 2), x) == FiniteSet(
+        6*LambertW((-1)**Rational(1, 3)*a**Rational(1, 3)/3))
+
+    assert solveset_real(x**3 - 3**x, x) == \
+        FiniteSet(-3/log(3)*LambertW(-log(3)/3))
+    assert solveset_real(3**cos(x) - cos(x)**3) == FiniteSet(
+        acos(-3*LambertW(-log(3)/3)/log(3)))
+
+    assert solveset_real(x**2 - 2**x, x) == \
+        solveset_real(-x**2 + 2**x, x)
+
+    assert solveset_real(3*log(x) - x*log(3)) == FiniteSet(
+        -3*LambertW(-log(3)/3)/log(3),
+        -3*LambertW(-log(3)/3, -1)/log(3))
+
+    assert solveset_real(LambertW(2*x) - y) == FiniteSet(
+        y*exp(y)/2)
+
+
+@XFAIL
+def test_other_lambert():
+    a = Rational(6, 5)
+    assert solveset_real(x**a - a**x, x) == FiniteSet(
+        a, -a*LambertW(-log(a)/a)/log(a))
+
+
+@_both_exp_pow
+def test_solveset():
+    f = Function('f')
+    raises(ValueError, lambda: solveset(x + y))
+    assert solveset(x, 1) == S.EmptySet
+    assert solveset(f(1)**2 + y + 1, f(1)
+        ) == FiniteSet(-sqrt(-y - 1), sqrt(-y - 1))
+    assert solveset(f(1)**2 - 1, f(1), S.Reals) == FiniteSet(-1, 1)
+    assert solveset(f(1)**2 + 1, f(1)) == FiniteSet(-I, I)
+    assert solveset(x - 1, 1) == FiniteSet(x)
+    assert solveset(sin(x) - cos(x), sin(x)) == FiniteSet(cos(x))
+
+    assert solveset(0, domain=S.Reals) == S.Reals
+    assert solveset(1) == S.EmptySet
+    assert solveset(True, domain=S.Reals) == S.Reals  # issue 10197
+    assert solveset(False, domain=S.Reals) == S.EmptySet
+
+    assert solveset(exp(x) - 1, domain=S.Reals) == FiniteSet(0)
+    assert solveset(exp(x) - 1, x, S.Reals) == FiniteSet(0)
+    assert solveset(Eq(exp(x), 1), x, S.Reals) == FiniteSet(0)
+    assert solveset(exp(x) - 1, exp(x), S.Reals) == FiniteSet(1)
+    A = Indexed('A', x)
+    assert solveset(A - 1, A, S.Reals) == FiniteSet(1)
+
+    assert solveset(x - 1 >= 0, x, S.Reals) == Interval(1, oo)
+    assert solveset(exp(x) - 1 >= 0, x, S.Reals) == Interval(0, oo)
+
+    assert dumeq(solveset(exp(x) - 1, x), imageset(Lambda(n, 2*I*pi*n), S.Integers))
+    assert dumeq(solveset(Eq(exp(x), 1), x), imageset(Lambda(n, 2*I*pi*n),
+                                                  S.Integers))
+    # issue 13825
+    assert solveset(x**2 + f(0) + 1, x) == {-sqrt(-f(0) - 1), sqrt(-f(0) - 1)}
+
+    # issue 19977
+    assert solveset(atan(log(x)) > 0, x, domain=Interval.open(0, oo)) == Interval.open(1, oo)
+
+
+@_both_exp_pow
+def test_multi_exp():
+    k1, k2, k3 = symbols('k1, k2, k3')
+    assert dumeq(solveset(exp(exp(x)) - 5, x),\
+         imageset(Lambda(((k1, n),), I*(2*k1*pi + arg(2*n*I*pi + log(5))) + log(Abs(2*n*I*pi + log(5)))),\
+             ProductSet(S.Integers, S.Integers)))
+    assert dumeq(solveset((d*exp(exp(a*x + b)) + c), x),\
+        imageset(Lambda(x, (-b + x)/a), ImageSet(Lambda(((k1, n),), \
+            I*(2*k1*pi + arg(I*(2*n*pi + arg(-c/d)) + log(Abs(c/d)))) + log(Abs(I*(2*n*pi + arg(-c/d)) + log(Abs(c/d))))), \
+                ProductSet(S.Integers, S.Integers))))
+
+    assert dumeq(solveset((d*exp(exp(exp(a*x + b))) + c), x),\
+        imageset(Lambda(x, (-b + x)/a), ImageSet(Lambda(((k2, k1, n),), \
+            I*(2*k2*pi + arg(I*(2*k1*pi + arg(I*(2*n*pi + arg(-c/d)) + log(Abs(c/d)))) + \
+                log(Abs(I*(2*n*pi + arg(-c/d)) + log(Abs(c/d)))))) + log(Abs(I*(2*k1*pi + arg(I*(2*n*pi + arg(-c/d)) + \
+                    log(Abs(c/d)))) + log(Abs(I*(2*n*pi + arg(-c/d)) + log(Abs(c/d))))))), \
+                        ProductSet(S.Integers, S.Integers, S.Integers))))
+
+    assert dumeq(solveset((d*exp(exp(exp(exp(a*x + b)))) + c), x),\
+        ImageSet(Lambda(x, (-b + x)/a), ImageSet(Lambda(((k3, k2, k1, n),), \
+            I*(2*k3*pi + arg(I*(2*k2*pi + arg(I*(2*k1*pi + arg(I*(2*n*pi + arg(-c/d)) + log(Abs(c/d)))) + \
+                log(Abs(I*(2*n*pi + arg(-c/d)) + log(Abs(c/d)))))) + log(Abs(I*(2*k1*pi + arg(I*(2*n*pi + arg(-c/d)) + \
+                    log(Abs(c/d)))) + log(Abs(I*(2*n*pi + arg(-c/d)) + log(Abs(c/d)))))))) + log(Abs(I*(2*k2*pi + \
+                        arg(I*(2*k1*pi + arg(I*(2*n*pi + arg(-c/d)) + log(Abs(c/d)))) + log(Abs(I*(2*n*pi + arg(-c/d)) + log(Abs(c/d)))))) + \
+                            log(Abs(I*(2*k1*pi + arg(I*(2*n*pi + arg(-c/d)) + log(Abs(c/d)))) + log(Abs(I*(2*n*pi + arg(-c/d)) + log(Abs(c/d))))))))), \
+             ProductSet(S.Integers, S.Integers, S.Integers, S.Integers))))
+
+
+def test__solveset_multi():
+    from sympy.solvers.solveset import _solveset_multi
+    from sympy.sets import Reals
+
+    # Basic univariate case:
+    assert _solveset_multi([x**2-1], [x], [S.Reals]) == FiniteSet((1,), (-1,))
+
+    # Linear systems of two equations
+    assert _solveset_multi([x+y, x+1], [x, y], [Reals, Reals]) == FiniteSet((-1, 1))
+    assert _solveset_multi([x+y, x+1], [y, x], [Reals, Reals]) == FiniteSet((1, -1))
+    assert _solveset_multi([x+y, x-y-1], [x, y], [Reals, Reals]) == FiniteSet((S(1)/2, -S(1)/2))
+    assert _solveset_multi([x-1, y-2], [x, y], [Reals, Reals]) == FiniteSet((1, 2))
+    # assert dumeq(_solveset_multi([x+y], [x, y], [Reals, Reals]), ImageSet(Lambda(x, (x, -x)), Reals))
+    assert dumeq(_solveset_multi([x+y], [x, y], [Reals, Reals]), Union(
+            ImageSet(Lambda(((x,),), (x, -x)), ProductSet(Reals)),
+            ImageSet(Lambda(((y,),), (-y, y)), ProductSet(Reals))))
+    assert _solveset_multi([x+y, x+y+1], [x, y], [Reals, Reals]) == S.EmptySet
+    assert _solveset_multi([x+y, x-y, x-1], [x, y], [Reals, Reals]) == S.EmptySet
+    assert _solveset_multi([x+y, x-y, x-1], [y, x], [Reals, Reals]) == S.EmptySet
+
+    # Systems of three equations:
+    assert _solveset_multi([x+y+z-1, x+y-z-2, x-y-z-3], [x, y, z], [Reals,
+        Reals, Reals]) == FiniteSet((2, -S.Half, -S.Half))
+
+    # Nonlinear systems:
+    from sympy.abc import theta
+    assert _solveset_multi([x**2+y**2-2, x+y], [x, y], [Reals, Reals]) == FiniteSet((-1, 1), (1, -1))
+    assert _solveset_multi([x**2-1, y], [x, y], [Reals, Reals]) == FiniteSet((1, 0), (-1, 0))
+    #assert _solveset_multi([x**2-y**2], [x, y], [Reals, Reals]) == Union(
+    #        ImageSet(Lambda(x, (x, -x)), Reals), ImageSet(Lambda(x, (x, x)), Reals))
+    assert dumeq(_solveset_multi([x**2-y**2], [x, y], [Reals, Reals]), Union(
+            ImageSet(Lambda(((x,),), (x, -Abs(x))), ProductSet(Reals)),
+            ImageSet(Lambda(((x,),), (x, Abs(x))), ProductSet(Reals)),
+            ImageSet(Lambda(((y,),), (-Abs(y), y)), ProductSet(Reals)),
+            ImageSet(Lambda(((y,),), (Abs(y), y)), ProductSet(Reals))))
+    assert _solveset_multi([r*cos(theta)-1, r*sin(theta)], [theta, r],
+            [Interval(0, pi), Interval(-1, 1)]) == FiniteSet((0, 1), (pi, -1))
+    assert _solveset_multi([r*cos(theta)-1, r*sin(theta)], [r, theta],
+            [Interval(0, 1), Interval(0, pi)]) == FiniteSet((1, 0))
+    assert _solveset_multi([r*cos(theta)-r, r*sin(theta)], [r, theta],
+           [Interval(0, 1), Interval(0, pi)]) == Union(
+           ImageSet(Lambda(((r,),), (r, 0)),
+           ImageSet(Lambda(r, (r,)), Interval(0, 1))),
+           ImageSet(Lambda(((theta,),), (0, theta)),
+           ImageSet(Lambda(theta, (theta,)), Interval(0, pi))))
+
+
+def test_conditionset():
+    assert solveset(Eq(sin(x)**2 + cos(x)**2, 1), x, domain=S.Reals
+        ) is S.Reals
+
+    assert solveset(Eq(x**2 + x*sin(x), 1), x, domain=S.Reals
+        ).dummy_eq(ConditionSet(x, Eq(x**2 + x*sin(x) - 1, 0), S.Reals))
+
+    assert dumeq(solveset(Eq(-I*(exp(I*x) - exp(-I*x))/2, 1), x
+        ), imageset(Lambda(n, 2*n*pi + pi/2), S.Integers))
+
+    assert solveset(x + sin(x) > 1, x, domain=S.Reals
+        ).dummy_eq(ConditionSet(x, x + sin(x) > 1, S.Reals))
+
+    assert solveset(Eq(sin(Abs(x)), x), x, domain=S.Reals
+        ).dummy_eq(ConditionSet(x, Eq(-x + sin(Abs(x)), 0), S.Reals))
+
+    assert solveset(y**x-z, x, S.Reals
+        ).dummy_eq(ConditionSet(x, Eq(y**x - z, 0), S.Reals))
+
+
+@XFAIL
+def test_conditionset_equality():
+    ''' Checking equality of different representations of ConditionSet'''
+    assert solveset(Eq(tan(x), y), x) == ConditionSet(x, Eq(tan(x), y), S.Complexes)
+
+
+def test_solveset_domain():
+    assert solveset(x**2 - x - 6, x, Interval(0, oo)) == FiniteSet(3)
+    assert solveset(x**2 - 1, x, Interval(0, oo)) == FiniteSet(1)
+    assert solveset(x**4 - 16, x, Interval(0, 10)) == FiniteSet(2)
+
+
+def test_improve_coverage():
+    solution = solveset(exp(x) + sin(x), x, S.Reals)
+    unsolved_object = ConditionSet(x, Eq(exp(x) + sin(x), 0), S.Reals)
+    assert solution.dummy_eq(unsolved_object)
+
+
+def test_issue_9522():
+    expr1 = Eq(1/(x**2 - 4) + x, 1/(x**2 - 4) + 2)
+    expr2 = Eq(1/x + x, 1/x)
+
+    assert solveset(expr1, x, S.Reals) is S.EmptySet
+    assert solveset(expr2, x, S.Reals) is S.EmptySet
+
+
+def test_solvify():
+    assert solvify(x**2 + 10, x, S.Reals) == []
+    assert solvify(x**3 + 1, x, S.Complexes) == [-1, S.Half - sqrt(3)*I/2,
+                                                 S.Half + sqrt(3)*I/2]
+    assert solvify(log(x), x, S.Reals) == [1]
+    assert solvify(cos(x), x, S.Reals) == [pi/2, pi*Rational(3, 2)]
+    assert solvify(sin(x) + 1, x, S.Reals) == [pi*Rational(3, 2)]
+    raises(NotImplementedError, lambda: solvify(sin(exp(x)), x, S.Complexes))
+
+
+def test_solvify_piecewise():
+    p1 = Piecewise((0, x < -1), (x**2, x <= 1), (log(x), True))
+    p2 = Piecewise((0, x < -10), (x**2 + 5*x - 6, x >= -9))
+    p3 = Piecewise((0, Eq(x, 0)), (x**2/Abs(x), True))
+    p4 = Piecewise((0, Eq(x, pi)), ((x - pi)/sin(x), True))
+
+    # issue 21079
+    assert solvify(p1, x, S.Reals) == [0]
+    assert solvify(p2, x, S.Reals) == [-6, 1]
+    assert solvify(p3, x, S.Reals) == [0]
+    assert solvify(p4, x, S.Reals) == [pi]
+
+
+def test_abs_invert_solvify():
+
+    x = Symbol('x',positive=True)
+    assert solvify(sin(Abs(x)), x, S.Reals) == [0, pi]
+    x = Symbol('x')
+    assert solvify(sin(Abs(x)), x, S.Reals) is None
+
+
+def test_linear_eq_to_matrix():
+    assert linear_eq_to_matrix(0, x) == (Matrix([[0]]), Matrix([[0]]))
+    assert linear_eq_to_matrix(1, x) == (Matrix([[0]]), Matrix([[-1]]))
+
+    # integer coefficients
+    eqns1 = [2*x + y - 2*z - 3, x - y - z, x + y + 3*z - 12]
+    eqns2 = [Eq(3*x + 2*y - z, 1), Eq(2*x - 2*y + 4*z, -2), -2*x + y - 2*z]
+
+    A, B = linear_eq_to_matrix(eqns1, x, y, z)
+    assert A == Matrix([[2, 1, -2], [1, -1, -1], [1, 1, 3]])
+    assert B == Matrix([[3], [0], [12]])
+
+    A, B = linear_eq_to_matrix(eqns2, x, y, z)
+    assert A == Matrix([[3, 2, -1], [2, -2, 4], [-2, 1, -2]])
+    assert B == Matrix([[1], [-2], [0]])
+
+    # Pure symbolic coefficients
+    eqns3 = [a*b*x + b*y + c*z - d, e*x + d*x + f*y + g*z - h, i*x + j*y + k*z - l]
+    A, B = linear_eq_to_matrix(eqns3, x, y, z)
+    assert A == Matrix([[a*b, b, c], [d + e, f, g], [i, j, k]])
+    assert B == Matrix([[d], [h], [l]])
+
+    # raise Errors if
+    # 1) no symbols are given
+    raises(ValueError, lambda: linear_eq_to_matrix(eqns3))
+    # 2) there are duplicates
+    raises(ValueError, lambda: linear_eq_to_matrix(eqns3, [x, x, y]))
+    # 3) a nonlinear term is detected in the original expression
+    raises(NonlinearError, lambda: linear_eq_to_matrix(Eq(1/x + x, 1/x), [x]))
+    raises(NonlinearError, lambda: linear_eq_to_matrix([x**2], [x]))
+    raises(NonlinearError, lambda: linear_eq_to_matrix([x*y], [x, y]))
+    # 4) Eq being used to represent equations autoevaluates
+    # (use unevaluated Eq instead)
+    raises(ValueError, lambda: linear_eq_to_matrix(Eq(x, x), x))
+    raises(ValueError, lambda: linear_eq_to_matrix(Eq(x, x + 1), x))
+
+
+    # if non-symbols are passed, the user is responsible for interpreting
+    assert linear_eq_to_matrix([x], [1/x]) == (Matrix([[0]]), Matrix([[-x]]))
+
+    # issue 15195
+    assert linear_eq_to_matrix(x + y*(z*(3*x + 2) + 3), x) == (
+        Matrix([[3*y*z + 1]]), Matrix([[-y*(2*z + 3)]]))
+    assert linear_eq_to_matrix(Matrix(
+        [[a*x + b*y - 7], [5*x + 6*y - c]]), x, y) == (
+        Matrix([[a, b], [5, 6]]), Matrix([[7], [c]]))
+
+    # issue 15312
+    assert linear_eq_to_matrix(Eq(x + 2, 1), x) == (
+        Matrix([[1]]), Matrix([[-1]]))
+
+    # issue 25423
+    raises(TypeError, lambda: linear_eq_to_matrix([], {x, y}))
+    raises(TypeError, lambda: linear_eq_to_matrix([x + y], {x, y}))
+    raises(ValueError, lambda: linear_eq_to_matrix({x + y}, (x, y)))
+
+
+def test_issue_16577():
+    assert linear_eq_to_matrix(Eq(a*(2*x + 3*y) + 4*y, 5), x, y) == (
+        Matrix([[2*a, 3*a + 4]]), Matrix([[5]]))
+
+
+def test_issue_10085():
+    assert invert_real(exp(x),0,x) == (x, S.EmptySet)
+
+
+def test_linsolve():
+    x1, x2, x3, x4 = symbols('x1, x2, x3, x4')
+
+    # Test for different input forms
+
+    M = Matrix([[1, 2, 1, 1, 7], [1, 2, 2, -1, 12], [2, 4, 0, 6, 4]])
+    system1 = A, B = M[:, :-1], M[:, -1]
+    Eqns = [x1 + 2*x2 + x3 + x4 - 7, x1 + 2*x2 + 2*x3 - x4 - 12,
+            2*x1 + 4*x2 + 6*x4 - 4]
+
+    sol = FiniteSet((-2*x2 - 3*x4 + 2, x2, 2*x4 + 5, x4))
+    assert linsolve(Eqns, (x1, x2, x3, x4)) == sol
+    assert linsolve(Eqns, *(x1, x2, x3, x4)) == sol
+    assert linsolve(system1, (x1, x2, x3, x4)) == sol
+    assert linsolve(system1, *(x1, x2, x3, x4)) == sol
+    # issue 9667 - symbols can be Dummy symbols
+    x1, x2, x3, x4 = symbols('x:4', cls=Dummy)
+    assert linsolve(system1, x1, x2, x3, x4) == FiniteSet(
+        (-2*x2 - 3*x4 + 2, x2, 2*x4 + 5, x4))
+
+    # raise ValueError for garbage value
+    raises(ValueError, lambda: linsolve(Eqns))
+    raises(ValueError, lambda: linsolve(x1))
+    raises(ValueError, lambda: linsolve(x1, x2))
+    raises(ValueError, lambda: linsolve((A,), x1, x2))
+    raises(ValueError, lambda: linsolve(A, B, x1, x2))
+    raises(ValueError, lambda: linsolve([x1], x1, x1))
+    raises(ValueError, lambda: linsolve([x1], (i for i in (x1, x1))))
+
+    #raise ValueError if equations are non-linear in given variables
+    raises(NonlinearError, lambda: linsolve([x + y - 1, x ** 2 + y - 3], [x, y]))
+    raises(NonlinearError, lambda: linsolve([cos(x) + y, x + y], [x, y]))
+    assert linsolve([x + z - 1, x ** 2 + y - 3], [z, y]) == {(-x + 1, -x**2 + 3)}
+
+    # Fully symbolic test
+    A = Matrix([[a, b], [c, d]])
+    B = Matrix([[e], [g]])
+    system2 = (A, B)
+    sol = FiniteSet(((-b*g + d*e)/(a*d - b*c), (a*g - c*e)/(a*d - b*c)))
+    assert linsolve(system2, [x, y]) == sol
+
+    # No solution
+    A = Matrix([[1, 2, 3], [2, 4, 6], [3, 6, 9]])
+    B = Matrix([0, 0, 1])
+    assert linsolve((A, B), (x, y, z)) is S.EmptySet
+
+    # Issue #10056
+    A, B, J1, J2 = symbols('A B J1 J2')
+    Augmatrix = Matrix([
+        [2*I*J1, 2*I*J2, -2/J1],
+        [-2*I*J2, -2*I*J1, 2/J2],
+        [0, 2, 2*I/(J1*J2)],
+        [2, 0,  0],
+        ])
+
+    assert linsolve(Augmatrix, A, B) == FiniteSet((0, I/(J1*J2)))
+
+    # Issue #10121 - Assignment of free variables
+    Augmatrix = Matrix([[0, 1, 0, 0, 0, 0], [0, 0, 0, 1, 0, 0]])
+    assert linsolve(Augmatrix, a, b, c, d, e) == FiniteSet((a, 0, c, 0, e))
+    #raises(IndexError, lambda: linsolve(Augmatrix, a, b, c))
+
+    x0, x1, x2, _x0 = symbols('tau0 tau1 tau2 _tau0')
+    assert linsolve(Matrix([[0, 1, 0, 0, 0, 0], [0, 0, 0, 1, 0, _x0]])
+        ) == FiniteSet((x0, 0, x1, _x0, x2))
+    x0, x1, x2, _x0 = symbols('tau00 tau01 tau02 tau0')
+    assert linsolve(Matrix([[0, 1, 0, 0, 0, 0], [0, 0, 0, 1, 0, _x0]])
+        ) == FiniteSet((x0, 0, x1, _x0, x2))
+    x0, x1, x2, _x0 = symbols('tau00 tau01 tau02 tau1')
+    assert linsolve(Matrix([[0, 1, 0, 0, 0, 0], [0, 0, 0, 1, 0, _x0]])
+        ) == FiniteSet((x0, 0, x1, _x0, x2))
+    # symbols can be given as generators
+    x0, x2, x4 = symbols('x0, x2, x4')
+    assert linsolve(Augmatrix, numbered_symbols('x')
+        ) == FiniteSet((x0, 0, x2, 0, x4))
+    Augmatrix[-1, -1] = x0
+    # use Dummy to avoid clash; the names may clash but the symbols
+    # will not
+    Augmatrix[-1, -1] = symbols('_x0')
+    assert len(linsolve(
+        Augmatrix, numbered_symbols('x', cls=Dummy)).free_symbols) == 4
+
+    # Issue #12604
+    f = Function('f')
+    assert linsolve([f(x) - 5], f(x)) == FiniteSet((5,))
+
+    # Issue #14860
+    from sympy.physics.units import meter, newton, kilo
+    kN = kilo*newton
+    Eqns = [8*kN + x + y, 28*kN*meter + 3*x*meter]
+    assert linsolve(Eqns, x, y) == {
+            (kilo*newton*Rational(-28, 3), kN*Rational(4, 3))}
+
+    # linsolve does not allow expansion (real or implemented)
+    # to remove singularities, but it will cancel linear terms
+    assert linsolve([Eq(x, x + y)], [x, y]) == {(x, 0)}
+    assert linsolve([Eq(x + x*y, 1 + y)], [x]) == {(1,)}
+    assert linsolve([Eq(1 + y, x + x*y)], [x]) == {(1,)}
+    raises(NonlinearError, lambda:
+        linsolve([Eq(x**2, x**2 + y)], [x, y]))
+
+    # corner cases
+    #
+    # XXX: The case below should give the same as for [0]
+    # assert linsolve([], [x]) == {(x,)}
+    assert linsolve([], [x]) is S.EmptySet
+    assert linsolve([0], [x]) == {(x,)}
+    assert linsolve([x], [x, y]) == {(0, y)}
+    assert linsolve([x, 0], [x, y]) == {(0, y)}
+
+
+def test_linsolve_large_sparse():
+    #
+    # This is mainly a performance test
+    #
+
+    def _mk_eqs_sol(n):
+        xs = symbols('x:{}'.format(n))
+        ys = symbols('y:{}'.format(n))
+        syms = xs + ys
+        eqs = []
+        sol = (-S.Half,) * n + (S.Half,) * n
+        for xi, yi in zip(xs, ys):
+            eqs.extend([xi + yi, xi - yi + 1])
+        return eqs, syms, FiniteSet(sol)
+
+    n = 500
+    eqs, syms, sol = _mk_eqs_sol(n)
+    assert linsolve(eqs, syms) == sol
+
+
+def test_linsolve_immutable():
+    A = ImmutableDenseMatrix([[1, 1, 2], [0, 1, 2], [0, 0, 1]])
+    B = ImmutableDenseMatrix([2, 1, -1])
+    assert linsolve([A, B], (x, y, z)) == FiniteSet((1, 3, -1))
+
+    A = ImmutableDenseMatrix([[1, 1, 7], [1, -1, 3]])
+    assert linsolve(A) == FiniteSet((5, 2))
+
+
+def test_solve_decomposition():
+    n = Dummy('n')
+
+    f1 = exp(3*x) - 6*exp(2*x) + 11*exp(x) - 6
+    f2 = sin(x)**2 - 2*sin(x) + 1
+    f3 = sin(x)**2 - sin(x)
+    f4 = sin(x + 1)
+    f5 = exp(x + 2) - 1
+    f6 = 1/log(x)
+    f7 = 1/x
+
+    s1 = ImageSet(Lambda(n, 2*n*pi), S.Integers)
+    s2 = ImageSet(Lambda(n, 2*n*pi + pi), S.Integers)
+    s3 = ImageSet(Lambda(n, 2*n*pi + pi/2), S.Integers)
+    s4 = ImageSet(Lambda(n, 2*n*pi - 1), S.Integers)
+    s5 = ImageSet(Lambda(n, 2*n*pi - 1 + pi), S.Integers)
+
+    assert solve_decomposition(f1, x, S.Reals) == FiniteSet(0, log(2), log(3))
+    assert dumeq(solve_decomposition(f2, x, S.Reals), s3)
+    assert dumeq(solve_decomposition(f3, x, S.Reals), Union(s1, s2, s3))
+    assert dumeq(solve_decomposition(f4, x, S.Reals), Union(s4, s5))
+    assert solve_decomposition(f5, x, S.Reals) == FiniteSet(-2)
+    assert solve_decomposition(f6, x, S.Reals) == S.EmptySet
+    assert solve_decomposition(f7, x, S.Reals) == S.EmptySet
+    assert solve_decomposition(x, x, Interval(1, 2)) == S.EmptySet
+
+
+# nonlinsolve testcases
+def test_nonlinsolve_basic():
+    assert nonlinsolve([],[]) == S.EmptySet
+    assert nonlinsolve([],[x, y]) == S.EmptySet
+
+    system = [x, y - x - 5]
+    assert nonlinsolve([x],[x, y]) == FiniteSet((0, y))
+    assert nonlinsolve(system, [y]) == S.EmptySet
+    soln = (ImageSet(Lambda(n, 2*n*pi + pi/2), S.Integers),)
+    assert dumeq(nonlinsolve([sin(x) - 1], [x]), FiniteSet(tuple(soln)))
+    soln = ((ImageSet(Lambda(n, 2*n*pi + pi), S.Integers), 1),
+            (ImageSet(Lambda(n, 2*n*pi), S.Integers), 1))
+    assert dumeq(nonlinsolve([sin(x), y - 1], [x, y]), FiniteSet(*soln))
+    assert nonlinsolve([x**2 - 1], [x]) == FiniteSet((-1,), (1,))
+
+    soln = FiniteSet((y, y))
+    assert nonlinsolve([x - y, 0], x, y) == soln
+    assert nonlinsolve([0, x - y], x, y) == soln
+    assert nonlinsolve([x - y, x - y], x, y) == soln
+    assert nonlinsolve([x, 0], x, y) == FiniteSet((0, y))
+    f = Function('f')
+    assert nonlinsolve([f(x), 0], f(x), y) == FiniteSet((0, y))
+    assert nonlinsolve([f(x), 0], f(x), f(y)) == FiniteSet((0, f(y)))
+    A = Indexed('A', x)
+    assert nonlinsolve([A, 0], A, y) == FiniteSet((0, y))
+    assert nonlinsolve([x**2 -1], [sin(x)]) == FiniteSet((S.EmptySet,))
+    assert nonlinsolve([x**2 -1], sin(x)) == FiniteSet((S.EmptySet,))
+    assert nonlinsolve([x**2 -1], 1) == FiniteSet((x**2,))
+    assert nonlinsolve([x**2 -1], x + y) == FiniteSet((S.EmptySet,))
+    assert nonlinsolve([Eq(1, x + y), Eq(1, -x + y - 1), Eq(1, -x + y - 1)], x, y) == FiniteSet(
+        (-S.Half, 3*S.Half))
+
+
+def test_nonlinsolve_abs():
+    soln = FiniteSet((y, y), (-y, y))
+    assert nonlinsolve([Abs(x) - y], x, y) == soln
+
+
+def test_raise_exception_nonlinsolve():
+    raises(IndexError, lambda: nonlinsolve([x**2 -1], []))
+    raises(ValueError, lambda: nonlinsolve([x**2 -1]))
+
+
+def test_trig_system():
+    # TODO: add more simple testcases when solveset returns
+    # simplified soln for Trig eq
+    assert nonlinsolve([sin(x) - 1, cos(x) -1 ], x) == S.EmptySet
+    soln1 = (ImageSet(Lambda(n, 2*n*pi + pi/2), S.Integers),)
+    soln = FiniteSet(soln1)
+    assert dumeq(nonlinsolve([sin(x) - 1, cos(x)], x), soln)
+
+
+@XFAIL
+def test_trig_system_fail():
+    # fails because solveset trig solver is not much smart.
+    sys = [x + y - pi/2, sin(x) + sin(y) - 1]
+    # solveset returns conditionset for sin(x) + sin(y) - 1
+    soln_1 = (ImageSet(Lambda(n, n*pi + pi/2), S.Integers),
+        ImageSet(Lambda(n, n*pi), S.Integers))
+    soln_1 = FiniteSet(soln_1)
+    soln_2 = (ImageSet(Lambda(n, n*pi), S.Integers),
+        ImageSet(Lambda(n, n*pi+ pi/2), S.Integers))
+    soln_2 = FiniteSet(soln_2)
+    soln = soln_1 + soln_2
+    assert dumeq(nonlinsolve(sys, [x, y]), soln)
+
+    # Add more cases from here
+    # http://www.vitutor.com/geometry/trigonometry/equations_systems.html#uno
+    sys = [sin(x) + sin(y) - (sqrt(3)+1)/2, sin(x) - sin(y) - (sqrt(3) - 1)/2]
+    soln_x = Union(ImageSet(Lambda(n, 2*n*pi + pi/3), S.Integers),
+        ImageSet(Lambda(n, 2*n*pi + pi*Rational(2, 3)), S.Integers))
+    soln_y = Union(ImageSet(Lambda(n, 2*n*pi + pi/6), S.Integers),
+        ImageSet(Lambda(n, 2*n*pi + pi*Rational(5, 6)), S.Integers))
+    assert dumeq(nonlinsolve(sys, [x, y]), FiniteSet((soln_x, soln_y)))
+
+
+def test_nonlinsolve_positive_dimensional():
+    x, y, a, b, c, d = symbols('x, y, a, b, c, d', extended_real=True)
+    assert nonlinsolve([x*y, x*y - x], [x, y]) == FiniteSet((0, y))
+
+    system = [a**2 + a*c, a - b]
+    assert nonlinsolve(system, [a, b]) == FiniteSet((0, 0), (-c, -c))
+    # here (a= 0, b = 0) is independent soln so both is printed.
+    # if symbols = [a, b, c] then only {a : -c ,b : -c}
+
+    eq1 =  a + b + c + d
+    eq2 = a*b + b*c + c*d + d*a
+    eq3 = a*b*c + b*c*d + c*d*a + d*a*b
+    eq4 = a*b*c*d - 1
+    system = [eq1, eq2, eq3, eq4]
+    sol1 = (-1/d, -d, 1/d, FiniteSet(d) - FiniteSet(0))
+    sol2 = (1/d, -d, -1/d, FiniteSet(d) - FiniteSet(0))
+    soln = FiniteSet(sol1, sol2)
+    assert nonlinsolve(system, [a, b, c, d]) == soln
+
+    assert nonlinsolve([x**4 - 3*x**2 + y*x, x*z**2, y*z - 1], [x, y, z]) == \
+           {(0, 1/z, z)}
+
+
+def test_nonlinsolve_polysys():
+    x, y, z = symbols('x, y, z', real=True)
+    assert nonlinsolve([x**2 + y - 2, x**2 + y], [x, y]) == S.EmptySet
+
+    s = (-y + 2, y)
+    assert nonlinsolve([(x + y)**2 - 4, x + y - 2], [x, y]) == FiniteSet(s)
+
+    system = [x**2 - y**2]
+    soln_real = FiniteSet((-y, y), (y, y))
+    soln_complex = FiniteSet((-Abs(y), y), (Abs(y), y))
+    soln =soln_real + soln_complex
+    assert nonlinsolve(system, [x, y]) == soln
+
+    system = [x**2 - y**2]
+    soln_real= FiniteSet((y, -y), (y, y))
+    soln_complex = FiniteSet((y, -Abs(y)), (y, Abs(y)))
+    soln = soln_real + soln_complex
+    assert nonlinsolve(system, [y, x]) == soln
+
+    system = [x**2 + y - 3, x - y - 4]
+    assert nonlinsolve(system, (x, y)) != nonlinsolve(system, (y, x))
+
+    assert nonlinsolve([-x**2 - y**2 + z, -2*x, -2*y, S.One], [x, y, z]) == S.EmptySet
+    assert nonlinsolve([x + y + z, S.One, S.One, S.One], [x, y, z]) == S.EmptySet
+
+    system = [-x**2*z**2 + x*y*z + y**4, -2*x*z**2 + y*z, x*z + 4*y**3, -2*x**2*z + x*y]
+    assert nonlinsolve(system, [x, y, z]) == FiniteSet((0, 0, z), (x, 0, 0))
+
+
+def test_nonlinsolve_using_substitution():
+    x, y, z, n = symbols('x, y, z, n', real = True)
+    system = [(x + y)*n - y**2 + 2]
+    s_x = (n*y - y**2 + 2)/n
+    soln = (-s_x, y)
+    assert nonlinsolve(system, [x, y]) == FiniteSet(soln)
+
+    system = [z**2*x**2 - z**2*y**2/exp(x)]
+    soln_real_1 = (y, x, 0)
+    soln_real_2 = (-exp(x/2)*Abs(x), x, z)
+    soln_real_3 = (exp(x/2)*Abs(x), x, z)
+    soln_complex_1 = (-x*exp(x/2), x, z)
+    soln_complex_2 = (x*exp(x/2), x, z)
+    syms = [y, x, z]
+    soln = FiniteSet(soln_real_1, soln_complex_1, soln_complex_2,\
+        soln_real_2, soln_real_3)
+    assert nonlinsolve(system,syms) == soln
+
+
+def test_nonlinsolve_complex():
+    n = Dummy('n')
+    assert dumeq(nonlinsolve([exp(x) - sin(y), 1/y - 3], [x, y]), {
+        (ImageSet(Lambda(n, 2*n*I*pi + log(sin(Rational(1, 3)))), S.Integers), Rational(1, 3))})
+
+    system = [exp(x) - sin(y), 1/exp(y) - 3]
+    assert dumeq(nonlinsolve(system, [x, y]), {
+        (ImageSet(Lambda(n, I*(2*n*pi + pi)
+                         + log(sin(log(3)))), S.Integers), -log(3)),
+        (ImageSet(Lambda(n, I*(2*n*pi + arg(sin(2*n*I*pi - log(3))))
+                         + log(Abs(sin(2*n*I*pi - log(3))))), S.Integers),
+        ImageSet(Lambda(n, 2*n*I*pi - log(3)), S.Integers))})
+
+    system = [exp(x) - sin(y), y**2 - 4]
+    assert dumeq(nonlinsolve(system, [x, y]), {
+        (ImageSet(Lambda(n, I*(2*n*pi + pi) + log(sin(2))), S.Integers), -2),
+        (ImageSet(Lambda(n, 2*n*I*pi + log(sin(2))), S.Integers), 2)})
+
+    system = [exp(x) - 2, y ** 2 - 2]
+    assert dumeq(nonlinsolve(system, [x, y]), {
+        (log(2), -sqrt(2)), (log(2), sqrt(2)),
+        (ImageSet(Lambda(n, 2*n*I*pi + log(2)), S.Integers), -sqrt(2)),
+        (ImageSet(Lambda(n, 2 * n * I * pi + log(2)), S.Integers), sqrt(2))})
+
+
+def test_nonlinsolve_radical():
+    assert nonlinsolve([sqrt(y) - x - z, y - 1], [x, y, z]) == {(1 - z, 1, z)}
+
+
+def test_nonlinsolve_inexact():
+    sol = [(-1.625, -1.375), (1.625, 1.375)]
+    res = nonlinsolve([(x + y)**2 - 9, x**2 - y**2 - 0.75], [x, y])
+    assert all(abs(res.args[i][j]-sol[i][j]) < 1e-9
+               for i in range(2) for j in range(2))
+
+    assert nonlinsolve([(x + y)**2 - 9, (x + y)**2 - 0.75], [x, y]) == S.EmptySet
+
+    assert nonlinsolve([y**2 + (x - 0.5)**2 - 0.0625, 2*x - 1.0, 2*y], [x, y]) == \
+           S.EmptySet
+
+    res = nonlinsolve([x**2 + y - 0.5, (x + y)**2, log(z)], [x, y, z])
+    sol = [(-0.366025403784439, 0.366025403784439, 1),
+           (-0.366025403784439, 0.366025403784439, 1),
+           (1.36602540378444, -1.36602540378444, 1)]
+    assert all(abs(res.args[i][j]-sol[i][j]) < 1e-9
+               for i in range(3) for j in range(3))
+
+    res = nonlinsolve([y - x**2, x**5 - x + 1.0], [x, y])
+    sol = [(-1.16730397826142, 1.36259857766493),
+           (-0.181232444469876 - 1.08395410131771*I,
+            -1.14211129483496 + 0.392895302949911*I),
+           (-0.181232444469876 + 1.08395410131771*I,
+            -1.14211129483496 - 0.392895302949911*I),
+           (0.764884433600585 - 0.352471546031726*I,
+            0.460812006002492 - 0.539199997693599*I),
+           (0.764884433600585 + 0.352471546031726*I,
+            0.460812006002492 + 0.539199997693599*I)]
+    assert all(abs(res.args[i][j] - sol[i][j]) < 1e-9
+               for i in range(5) for j in range(2))
+
+@XFAIL
+def test_solve_nonlinear_trans():
+    # After the transcendental equation solver these will work
+    x, y = symbols('x, y', real=True)
+    soln1 = FiniteSet((2*LambertW(y/2), y))
+    soln2 = FiniteSet((-x*sqrt(exp(x)), y), (x*sqrt(exp(x)), y))
+    soln3 = FiniteSet((x*exp(x/2), x))
+    soln4 = FiniteSet(2*LambertW(y/2), y)
+    assert nonlinsolve([x**2 - y**2/exp(x)], [x, y]) == soln1
+    assert nonlinsolve([x**2 - y**2/exp(x)], [y, x]) == soln2
+    assert nonlinsolve([x**2 - y**2/exp(x)], [y, x]) == soln3
+    assert nonlinsolve([x**2 - y**2/exp(x)], [x, y]) == soln4
+
+
+def test_nonlinsolve_issue_25182():
+    a1, b1, c1, ca, cb, cg = symbols('a1, b1, c1, ca, cb, cg')
+    eq1 = a1*a1 + b1*b1 - 2.*a1*b1*cg - c1*c1
+    eq2 = a1*a1 + c1*c1 - 2.*a1*c1*cb - b1*b1
+    eq3 = b1*b1 + c1*c1 - 2.*b1*c1*ca - a1*a1
+    assert nonlinsolve([eq1, eq2, eq3], [c1, cb, cg]) == FiniteSet(
+        (1.0*b1*ca - 1.0*sqrt(a1**2 + b1**2*ca**2 - b1**2),
+        -1.0*sqrt(a1**2 + b1**2*ca**2 - b1**2)/a1,
+        -1.0*b1*(ca - 1)*(ca + 1)/a1 + 1.0*ca*sqrt(a1**2 + b1**2*ca**2 - b1**2)/a1),
+        (1.0*b1*ca + 1.0*sqrt(a1**2 + b1**2*ca**2 - b1**2),
+        1.0*sqrt(a1**2 + b1**2*ca**2 - b1**2)/a1,
+        -1.0*b1*(ca - 1)*(ca + 1)/a1 - 1.0*ca*sqrt(a1**2 + b1**2*ca**2 - b1**2)/a1))
+
+
+def test_issue_14642():
+    x = Symbol('x')
+    n1 = 0.5*x**3+x**2+0.5+I #add I in the Polynomials
+    solution = solveset(n1, x)
+    assert abs(solution.args[0] - (-2.28267560928153 - 0.312325580497716*I)) <= 1e-9
+    assert abs(solution.args[1] - (-0.297354141679308 + 1.01904778618762*I)) <= 1e-9
+    assert abs(solution.args[2] - (0.580029750960839 - 0.706722205689907*I)) <= 1e-9
+
+    # Symbolic
+    n1 = S.Half*x**3+x**2+S.Half+I
+    res = FiniteSet(-((3*sqrt(3)*31985**(S(1)/4)*sin(atan(S(172)/49)/2)/2 +
+            S(43)/2)**2 + (27 + 3*sqrt(3)*31985**(S(1)/4)*cos(atan(S(172)/49)
+            /2)/2)**2)**(S(1)/6)*cos(atan((27 + 3*sqrt(3)*31985**(S(1)/4)*
+            cos(atan(S(172)/49)/2)/2)/(3*sqrt(3)*31985**(S(1)/4)*sin(atan(
+            S(172)/49)/2)/2 + S(43)/2))/3)/3 - S(2)/3 - 4*cos(atan((27 +
+            3*sqrt(3)*31985**(S(1)/4)*cos(atan(S(172)/49)/2)/2)/(3*sqrt(3)*
+            31985**(S(1)/4)*sin(atan(S(172)/49)/2)/2 + S(43)/2))/3)/(3*((3*
+            sqrt(3)*31985**(S(1)/4)*sin(atan(S(172)/49)/2)/2 + S(43)/2)**2 +
+            (27 + 3*sqrt(3)*31985**(S(1)/4)*cos(atan(S(172)/49)/2)/2)**2)**(S(1)/
+            6)) + I*(-((3*sqrt(3)*31985**(S(1)/4)*sin(atan(S(172)/49)/2)/2 +
+            S(43)/2)**2 + (27 + 3*sqrt(3)*31985**(S(1)/4)*cos(atan(S(172)/49)/
+            2)/2)**2)**(S(1)/6)*sin(atan((27 + 3*sqrt(3)*31985**(S(1)/4)*cos(
+            atan(S(172)/49)/2)/2)/(3*sqrt(3)*31985**(S(1)/4)*sin(atan(S(172)/49)
+            /2)/2 + S(43)/2))/3)/3 + 4*sin(atan((27 + 3*sqrt(3)*31985**(S(1)/4)*
+            cos(atan(S(172)/49)/2)/2)/(3*sqrt(3)*31985**(S(1)/4)*sin(atan(S(172)
+            /49)/2)/2 + S(43)/2))/3)/(3*((3*sqrt(3)*31985**(S(1)/4)*sin(atan(
+            S(172)/49)/2)/2 + S(43)/2)**2 + (27 + 3*sqrt(3)*31985**(S(1)/4)*
+            cos(atan(S(172)/49)/2)/2)**2)**(S(1)/6))), -S(2)/3 - sqrt(3)*((3*
+            sqrt(3)*31985**(S(1)/4)*sin(atan(S(172)/49)/2)/2 + S(43)/2)**2 +
+            (27 + 3*sqrt(3)*31985**(S(1)/4)*cos(atan(S(172)/49)/2)/2)**2)**(S(1)
+            /6)*sin(atan((27 + 3*sqrt(3)*31985**(S(1)/4)*cos(atan(S(172)/49)/2)
+            /2)/(3*sqrt(3)*31985**(S(1)/4)*sin(atan(S(172)/49)/2)/2 + S(43)/2))
+            /3)/6 - 4*re(1/((-S(1)/2 - sqrt(3)*I/2)*(S(43)/2 + 27*I + sqrt(-256 +
+            (43 + 54*I)**2)/2)**(S(1)/3)))/3 + ((3*sqrt(3)*31985**(S(1)/4)*sin(
+            atan(S(172)/49)/2)/2 + S(43)/2)**2 + (27 + 3*sqrt(3)*31985**(S(1)/4)*
+            cos(atan(S(172)/49)/2)/2)**2)**(S(1)/6)*cos(atan((27 + 3*sqrt(3)*
+            31985**(S(1)/4)*cos(atan(S(172)/49)/2)/2)/(3*sqrt(3)*31985**(S(1)/4)*
+            sin(atan(S(172)/49)/2)/2 + S(43)/2))/3)/6 + I*(-4*im(1/((-S(1)/2 -
+            sqrt(3)*I/2)*(S(43)/2 + 27*I + sqrt(-256 + (43 + 54*I)**2)/2)**(S(1)/
+            3)))/3 + ((3*sqrt(3)*31985**(S(1)/4)*sin(atan(S(172)/49)/2)/2 +
+            S(43)/2)**2 + (27 + 3*sqrt(3)*31985**(S(1)/4)*cos(atan(S(172)/49)/2)
+            /2)**2)**(S(1)/6)*sin(atan((27 + 3*sqrt(3)*31985**(S(1)/4)*cos(atan(
+            S(172)/49)/2)/2)/(3*sqrt(3)*31985**(S(1)/4)*sin(atan(S(172)/49)/2)/2 +
+            S(43)/2))/3)/6 + sqrt(3)*((3*sqrt(3)*31985**(S(1)/4)*sin(atan(S(172)/
+            49)/2)/2 + S(43)/2)**2 + (27 + 3*sqrt(3)*31985**(S(1)/4)*cos(atan(
+            S(172)/49)/2)/2)**2)**(S(1)/6)*cos(atan((27 + 3*sqrt(3)*31985**(S(1)/
+            4)*cos(atan(S(172)/49)/2)/2)/(3*sqrt(3)*31985**(S(1)/4)*sin(atan(
+            S(172)/49)/2)/2 + S(43)/2))/3)/6), -S(2)/3 - 4*re(1/((-S(1)/2 +
+            sqrt(3)*I/2)*(S(43)/2 + 27*I + sqrt(-256 + (43 + 54*I)**2)/2)**(S(1)
+            /3)))/3 + sqrt(3)*((3*sqrt(3)*31985**(S(1)/4)*sin(atan(S(172)/49)/2)/2 +
+            S(43)/2)**2 + (27 + 3*sqrt(3)*31985**(S(1)/4)*cos(atan(S(172)/49)/2)
+            /2)**2)**(S(1)/6)*sin(atan((27 + 3*sqrt(3)*31985**(S(1)/4)*cos(atan(
+            S(172)/49)/2)/2)/(3*sqrt(3)*31985**(S(1)/4)*sin(atan(S(172)/49)/2)/2 +
+            S(43)/2))/3)/6 + ((3*sqrt(3)*31985**(S(1)/4)*sin(atan(S(172)/49)/2)/2 +
+            S(43)/2)**2 + (27 + 3*sqrt(3)*31985**(S(1)/4)*cos(atan(S(172)/49)/2)
+            /2)**2)**(S(1)/6)*cos(atan((27 + 3*sqrt(3)*31985**(S(1)/4)*cos(atan(
+            S(172)/49)/2)/2)/(3*sqrt(3)*31985**(S(1)/4)*sin(atan(S(172)/49)/2)/2 +
+            S(43)/2))/3)/6 + I*(-sqrt(3)*((3*sqrt(3)*31985**(S(1)/4)*sin(atan(
+            S(172)/49)/2)/2 + S(43)/2)**2 + (27 + 3*sqrt(3)*31985**(S(1)/4)*cos(
+            atan(S(172)/49)/2)/2)**2)**(S(1)/6)*cos(atan((27 + 3*sqrt(3)*31985**(
+            S(1)/4)*cos(atan(S(172)/49)/2)/2)/(3*sqrt(3)*31985**(S(1)/4)*sin(
+            atan(S(172)/49)/2)/2 + S(43)/2))/3)/6 + ((3*sqrt(3)*31985**(S(1)/4)*
+            sin(atan(S(172)/49)/2)/2 + S(43)/2)**2 + (27 + 3*sqrt(3)*31985**(S(1)/4)*
+            cos(atan(S(172)/49)/2)/2)**2)**(S(1)/6)*sin(atan((27 + 3*sqrt(3)*31985**(
+            S(1)/4)*cos(atan(S(172)/49)/2)/2)/(3*sqrt(3)*31985**(S(1)/4)*sin(
+            atan(S(172)/49)/2)/2 + S(43)/2))/3)/6 - 4*im(1/((-S(1)/2 + sqrt(3)*I/2)*
+            (S(43)/2 + 27*I + sqrt(-256 + (43 + 54*I)**2)/2)**(S(1)/3)))/3))
+
+    assert solveset(n1, x) == res
+
+
+def test_issue_13961():
+    V = (ax, bx, cx, gx, jx, lx, mx, nx, q) = symbols('ax bx cx gx jx lx mx nx q')
+    S = (ax*q - lx*q - mx, ax - gx*q - lx, bx*q**2 + cx*q - jx*q - nx, q*(-ax*q + lx*q + mx), q*(-ax + gx*q + lx))
+
+    sol = FiniteSet((lx + mx/q, (-cx*q + jx*q + nx)/q**2, cx, mx/q**2, jx, lx, mx, nx, Complement({q}, {0})),
+                    (lx + mx/q, (cx*q - jx*q - nx)/q**2*-1, cx, mx/q**2, jx, lx, mx, nx, Complement({q}, {0})))
+    assert nonlinsolve(S, *V) == sol
+    # The two solutions are in fact identical, so even better if only one is returned
+
+
+def test_issue_14541():
+    solutions = solveset(sqrt(-x**2 - 2.0), x)
+    assert abs(solutions.args[0]+1.4142135623731*I) <= 1e-9
+    assert abs(solutions.args[1]-1.4142135623731*I) <= 1e-9
+
+
+def test_issue_13396():
+    expr = -2*y*exp(-x**2 - y**2)*Abs(x)
+    sol = FiniteSet(0)
+
+    assert solveset(expr, y, domain=S.Reals) == sol
+
+    # Related type of equation also solved here
+    assert solveset(atan(x**2 - y**2)-pi/2, y, S.Reals) is S.EmptySet
+
+
+def test_issue_12032():
+    sol = FiniteSet(-sqrt(-2/(3*(Rational(1, 16) + sqrt(849)/144)**(Rational(1, 3))) +
+                          2*(Rational(1, 16) + sqrt(849)/144)**(Rational(1, 3)))/2 +
+                    sqrt(Abs(-2*(Rational(1, 16) + sqrt(849)/144)**(Rational(1, 3)) +
+                             2/(3*(Rational(1, 16) + sqrt(849)/144)**(Rational(1, 3))) +
+                             2/sqrt(-2/(3*(Rational(1, 16) + sqrt(849)/144)**(Rational(1, 3))) +
+                                    2*(Rational(1, 16) + sqrt(849)/144)**(Rational(1, 3)))))/2,
+                    -sqrt(Abs(-2*(Rational(1, 16) + sqrt(849)/144)**(Rational(1, 3)) +
+                              2/(3*(Rational(1, 16) + sqrt(849)/144)**(Rational(1, 3))) +
+                              2/sqrt(-2/(3*(Rational(1, 16) + sqrt(849)/144)**(Rational(1, 3))) +
+                                     2*(Rational(1, 16) + sqrt(849)/144)**(Rational(1, 3)))))/2 -
+                    sqrt(-2/(3*(Rational(1, 16) + sqrt(849)/144)**(Rational(1, 3))) +
+                         2*(Rational(1, 16) + sqrt(849)/144)**(Rational(1, 3)))/2,
+                    sqrt(-2/(3*(Rational(1, 16) + sqrt(849)/144)**(Rational(1, 3))) +
+                         2*(Rational(1, 16) + sqrt(849)/144)**(Rational(1, 3)))/2 -
+                    I*sqrt(Abs(-2/sqrt(-2/(3*(Rational(1, 16) + sqrt(849)/144)**(Rational(1, 3))) +
+                                       2*(Rational(1, 16) + sqrt(849)/144)**(Rational(1, 3))) -
+                               2*(Rational(1, 16) + sqrt(849)/144)**(Rational(1, 3)) +
+                               2/(3*(Rational(1, 16) + sqrt(849)/144)**(Rational(1, 3)))))/2,
+                    sqrt(-2/(3*(Rational(1, 16) + sqrt(849)/144)**(Rational(1, 3))) +
+                         2*(Rational(1, 16) + sqrt(849)/144)**(Rational(1, 3)))/2 +
+                    I*sqrt(Abs(-2/sqrt(-2/(3*(Rational(1, 16) + sqrt(849)/144)**(Rational(1, 3))) +
+                                       2*(Rational(1, 16) + sqrt(849)/144)**(Rational(1, 3))) -
+                               2*(Rational(1, 16) + sqrt(849)/144)**(Rational(1, 3)) +
+                               2/(3*(Rational(1, 16) + sqrt(849)/144)**(Rational(1,3)))))/2)
+    assert solveset(x**4 + x - 1, x) == sol
+
+
+def test_issue_10876():
+    assert solveset(1/sqrt(x), x) == S.EmptySet
+
+
+def test_issue_19050():
+    # test_issue_19050 --> TypeError removed
+    assert dumeq(nonlinsolve([x + y, sin(y)], [x, y]),
+        FiniteSet((ImageSet(Lambda(n, -2*n*pi), S.Integers), ImageSet(Lambda(n, 2*n*pi), S.Integers)),\
+             (ImageSet(Lambda(n, -2*n*pi - pi), S.Integers), ImageSet(Lambda(n, 2*n*pi + pi), S.Integers))))
+    assert dumeq(nonlinsolve([x + y, sin(y) + cos(y)], [x, y]),
+        FiniteSet((ImageSet(Lambda(n, -2*n*pi - 3*pi/4), S.Integers), ImageSet(Lambda(n, 2*n*pi + 3*pi/4), S.Integers)), \
+            (ImageSet(Lambda(n, -2*n*pi - 7*pi/4), S.Integers), ImageSet(Lambda(n, 2*n*pi + 7*pi/4), S.Integers))))
+
+
+def test_issue_16618():
+    eqn = [sin(x)*sin(y), cos(x)*cos(y) - 1]
+    # nonlinsolve's answer is still suspicious since it contains only three
+    # distinct Dummys instead of 4. (Both 'x' ImageSets share the same Dummy.)
+    ans = FiniteSet((ImageSet(Lambda(n, 2*n*pi), S.Integers), ImageSet(Lambda(n, 2*n*pi), S.Integers)),
+        (ImageSet(Lambda(n, 2*n*pi + pi), S.Integers), ImageSet(Lambda(n, 2*n*pi + pi), S.Integers)))
+    sol = nonlinsolve(eqn, [x, y])
+
+    for i0, j0 in zip(ordered(sol), ordered(ans)):
+        assert len(i0) == len(j0) == 2
+        assert all(a.dummy_eq(b) for a, b in zip(i0, j0))
+    assert len(sol) == len(ans)
+
+
+def test_issue_17566():
+    assert nonlinsolve([32*(2**x)/2**(-y) - 4**y, 27*(3**x) - S(1)/3**y], x, y) ==\
+        FiniteSet((-log(81)/log(3), 1))
+
+
+def test_issue_16643():
+    n = Dummy('n')
+    assert solveset(x**2*sin(x), x).dummy_eq(Union(ImageSet(Lambda(n, 2*n*pi + pi), S.Integers),
+                                                   ImageSet(Lambda(n, 2*n*pi), S.Integers)))
+
+
+def test_issue_19587():
+    n,m = symbols('n m')
+    assert nonlinsolve([32*2**m*2**n - 4**n, 27*3**m - 3**(-n)], m, n) ==\
+        FiniteSet((-log(81)/log(3), 1))
+
+
+def test_issue_5132_1():
+    system = [sqrt(x**2 + y**2) - sqrt(10), x + y - 4]
+    assert nonlinsolve(system, [x, y]) == FiniteSet((1, 3), (3, 1))
+
+    n = Dummy('n')
+    eqs = [exp(x)**2 - sin(y) + z**2, 1/exp(y) - 3]
+    s_real_y = -log(3)
+    s_real_z = sqrt(-exp(2*x) - sin(log(3)))
+    soln_real = FiniteSet((s_real_y, s_real_z), (s_real_y, -s_real_z))
+    lam = Lambda(n, 2*n*I*pi + -log(3))
+    s_complex_y = ImageSet(lam, S.Integers)
+    lam = Lambda(n, sqrt(-exp(2*x) + sin(2*n*I*pi + -log(3))))
+    s_complex_z_1 = ImageSet(lam, S.Integers)
+    lam = Lambda(n, -sqrt(-exp(2*x) + sin(2*n*I*pi + -log(3))))
+    s_complex_z_2 = ImageSet(lam, S.Integers)
+    soln_complex = FiniteSet(
+                                            (s_complex_y, s_complex_z_1),
+                                            (s_complex_y, s_complex_z_2)
+                                        )
+    soln = soln_real + soln_complex
+    assert dumeq(nonlinsolve(eqs, [y, z]), soln)
+
+
+def test_issue_5132_2():
+    x, y = symbols('x, y', real=True)
+    eqs = [exp(x)**2 - sin(y) + z**2]
+    n = Dummy('n')
+    soln_real = (log(-z**2 + sin(y))/2, z)
+    lam = Lambda( n, I*(2*n*pi + arg(-z**2 + sin(y)))/2 + log(Abs(z**2 - sin(y)))/2)
+    img = ImageSet(lam, S.Integers)
+    # not sure about the complex soln. But it looks correct.
+    soln_complex = (img, z)
+    soln = FiniteSet(soln_real, soln_complex)
+    assert dumeq(nonlinsolve(eqs, [x, z]), soln)
+
+    system = [r - x**2 - y**2, tan(t) - y/x]
+    s_x = sqrt(r/(tan(t)**2 + 1))
+    s_y = sqrt(r/(tan(t)**2 + 1))*tan(t)
+    soln = FiniteSet((s_x, s_y), (-s_x, -s_y))
+    assert nonlinsolve(system, [x, y]) == soln
+
+
+def test_issue_6752():
+    a, b = symbols('a, b', real=True)
+    assert nonlinsolve([a**2 + a, a - b], [a, b]) == {(-1, -1), (0, 0)}
+
+
+@SKIP("slow")
+def test_issue_5114_solveset():
+    # slow testcase
+    from sympy.abc import o, p
+
+    # there is no 'a' in the equation set but this is how the
+    # problem was originally posed
+    syms = [a, b, c, f, h, k, n]
+    eqs = [b + r/d - c/d,
+    c*(1/d + 1/e + 1/g) - f/g - r/d,
+        f*(1/g + 1/i + 1/j) - c/g - h/i,
+        h*(1/i + 1/l + 1/m) - f/i - k/m,
+        k*(1/m + 1/o + 1/p) - h/m - n/p,
+        n*(1/p + 1/q) - k/p]
+    assert len(nonlinsolve(eqs, syms)) == 1
+
+
+@SKIP("Hangs")
+def _test_issue_5335():
+    # Not able to check zero dimensional system.
+    # is_zero_dimensional Hangs
+    lam, a0, conc = symbols('lam a0 conc')
+    eqs = [lam + 2*y - a0*(1 - x/2)*x - 0.005*x/2*x,
+           a0*(1 - x/2)*x - 1*y - 0.743436700916726*y,
+           x + y - conc]
+    sym = [x, y, a0]
+    # there are 4 solutions but only two are valid
+    assert len(nonlinsolve(eqs, sym)) == 2
+    # float
+    eqs = [lam + 2*y - a0*(1 - x/2)*x - 0.005*x/2*x,
+           a0*(1 - x/2)*x - 1*y - 0.743436700916726*y,
+           x + y - conc]
+    sym = [x, y, a0]
+    assert len(nonlinsolve(eqs, sym)) == 2
+
+
+def test_issue_2777():
+    # the equations represent two circles
+    x, y = symbols('x y', real=True)
+    e1, e2 = sqrt(x**2 + y**2) - 10, sqrt(y**2 + (-x + 10)**2) - 3
+    a, b = Rational(191, 20), 3*sqrt(391)/20
+    ans = {(a, -b), (a, b)}
+    assert nonlinsolve((e1, e2), (x, y)) == ans
+    assert nonlinsolve((e1, e2/(x - a)), (x, y)) == S.EmptySet
+    # make the 2nd circle's radius be -3
+    e2 += 6
+    assert nonlinsolve((e1, e2), (x, y)) == S.EmptySet
+
+
+def test_issue_8828():
+    x1 = 0
+    y1 = -620
+    r1 = 920
+    x2 = 126
+    y2 = 276
+    x3 = 51
+    y3 = 205
+    r3 = 104
+    v = [x, y, z]
+
+    f1 = (x - x1)**2 + (y - y1)**2 - (r1 - z)**2
+    f2 = (x2 - x)**2 + (y2 - y)**2 - z**2
+    f3 = (x - x3)**2 + (y - y3)**2 - (r3 - z)**2
+    F = [f1, f2, f3]
+
+    g1 = sqrt((x - x1)**2 + (y - y1)**2) + z - r1
+    g2 = f2
+    g3 = sqrt((x - x3)**2 + (y - y3)**2) + z - r3
+    G = [g1, g2, g3]
+
+    # both soln same
+    A = nonlinsolve(F, v)
+    B = nonlinsolve(G, v)
+    assert A == B
+
+
+def test_nonlinsolve_conditionset():
+    # when solveset failed to solve all the eq
+    # return conditionset
+    f = Function('f')
+    f1 = f(x) - pi/2
+    f2 = f(y) - pi*Rational(3, 2)
+    intermediate_system = Eq(2*f(x) - pi, 0) & Eq(2*f(y) - 3*pi, 0)
+    syms = Tuple(x, y)
+    soln = ConditionSet(
+        syms,
+        intermediate_system,
+        S.Complexes**2)
+    assert nonlinsolve([f1, f2], [x, y]) == soln
+
+
+def test_substitution_basic():
+    assert substitution([], [x, y]) == S.EmptySet
+    assert substitution([], []) == S.EmptySet
+    system = [2*x**2 + 3*y**2 - 30, 3*x**2 - 2*y**2 - 19]
+    soln = FiniteSet((-3, -2), (-3, 2), (3, -2), (3, 2))
+    assert substitution(system, [x, y]) == soln
+
+    soln = FiniteSet((-1, 1))
+    assert substitution([x + y], [x], [{y: 1}], [y], set(), [x, y]) == soln
+    assert substitution(
+        [x + y], [x], [{y: 1}], [y],
+        {x + 1}, [y, x]) == S.EmptySet
+
+
+def test_substitution_incorrect():
+    # the solutions in the following two tests are incorrect. The
+    # correct result is EmptySet in both cases.
+    assert substitution([h - 1, k - 1, f - 2, f - 4, -2 * k],
+                        [h, k, f]) == {(1, 1, f)}
+    assert substitution([x + y + z, S.One, S.One, S.One], [x, y, z]) == \
+                        {(-y - z, y, z)}
+
+    # the correct result in the test below is {(-I, I, I, -I),
+    # (I, -I, -I, I)}
+    assert substitution([a - d, b + d, c + d, d**2 + 1], [a, b, c, d]) == \
+                        {(d, -d, -d, d)}
+
+    # the result in the test below is incomplete. The complete result
+    # is {(0, b), (log(2), 2)}
+    assert substitution([a*(a - log(b)), a*(b - 2)], [a, b]) == \
+           {(0, b)}
+
+    # The system in the test below is zero-dimensional, so the result
+    # should have no free symbols
+    assert substitution([-k*y + 6*x - 4*y, -81*k + 49*y**2 - 270,
+                         -3*k*z + k + z**3, k**2 - 2*k + 4],
+                        [x, y, z, k]).free_symbols == {z}
+
+
+def test_substitution_redundant():
+    # the third and fourth solutions are redundant in the test below
+    assert substitution([x**2 - y**2, z - 1], [x, z]) == \
+           {(-y, 1), (y, 1), (-sqrt(y**2), 1), (sqrt(y**2), 1)}
+
+    # the system below has three solutions. Two of the solutions
+    # returned by substitution are redundant.
+    res = substitution([x - y, y**3 - 3*y**2 + 1], [x, y])
+    assert len(res) == 5
+
+
+def test_issue_5132_substitution():
+    x, y, z, r, t = symbols('x, y, z, r, t', real=True)
+    system = [r - x**2 - y**2, tan(t) - y/x]
+    s_x_1 = Complement(FiniteSet(-sqrt(r/(tan(t)**2 + 1))), FiniteSet(0))
+    s_x_2 = Complement(FiniteSet(sqrt(r/(tan(t)**2 + 1))), FiniteSet(0))
+    s_y = sqrt(r/(tan(t)**2 + 1))*tan(t)
+    soln = FiniteSet((s_x_2, s_y)) + FiniteSet((s_x_1, -s_y))
+    assert substitution(system, [x, y]) == soln
+
+    n = Dummy('n')
+    eqs = [exp(x)**2 - sin(y) + z**2, 1/exp(y) - 3]
+    s_real_y = -log(3)
+    s_real_z = sqrt(-exp(2*x) - sin(log(3)))
+    soln_real = FiniteSet((s_real_y, s_real_z), (s_real_y, -s_real_z))
+    lam = Lambda(n, 2*n*I*pi + -log(3))
+    s_complex_y = ImageSet(lam, S.Integers)
+    lam = Lambda(n, sqrt(-exp(2*x) + sin(2*n*I*pi + -log(3))))
+    s_complex_z_1 = ImageSet(lam, S.Integers)
+    lam = Lambda(n, -sqrt(-exp(2*x) + sin(2*n*I*pi + -log(3))))
+    s_complex_z_2 = ImageSet(lam, S.Integers)
+    soln_complex = FiniteSet(
+        (s_complex_y, s_complex_z_1),
+        (s_complex_y, s_complex_z_2))
+    soln = soln_real + soln_complex
+    assert dumeq(substitution(eqs, [y, z]), soln)
+
+
+def test_raises_substitution():
+    raises(ValueError, lambda: substitution([x**2 -1], []))
+    raises(TypeError, lambda: substitution([x**2 -1]))
+    raises(ValueError, lambda: substitution([x**2 -1], [sin(x)]))
+    raises(TypeError, lambda: substitution([x**2 -1], x))
+    raises(TypeError, lambda: substitution([x**2 -1], 1))
+
+
+def test_issue_21022():
+    from sympy.core.sympify import sympify
+
+    eqs = [
+    'k-16',
+    'p-8',
+    'y*y+z*z-x*x',
+    'd - x + p',
+    'd*d+k*k-y*y',
+    'z*z-p*p-k*k',
+    'abc-efg',
+    ]
+    efg = Symbol('efg')
+    eqs = [sympify(x) for x in eqs]
+
+    syb = list(ordered(set.union(*[x.free_symbols for x in eqs])))
+    res = nonlinsolve(eqs, syb)
+
+    ans = FiniteSet(
+    (efg, 32, efg, 16, 8, 40, -16*sqrt(5), -8*sqrt(5)),
+    (efg, 32, efg, 16, 8, 40, -16*sqrt(5), 8*sqrt(5)),
+    (efg, 32, efg, 16, 8, 40, 16*sqrt(5), -8*sqrt(5)),
+    (efg, 32, efg, 16, 8, 40, 16*sqrt(5), 8*sqrt(5)),
+    )
+    assert len(res) == len(ans) == 4
+    assert res == ans
+    for result in res.args:
+        assert len(result) == 8
+
+
+def test_issue_17940():
+    n = Dummy('n')
+    k1 = Dummy('k1')
+    sol = ImageSet(Lambda(((k1, n),), I*(2*k1*pi + arg(2*n*I*pi + log(5)))
+                          + log(Abs(2*n*I*pi + log(5)))),
+                   ProductSet(S.Integers, S.Integers))
+    assert solveset(exp(exp(x)) - 5, x).dummy_eq(sol)
+
+
+def test_issue_17906():
+    assert solveset(7**(x**2 - 80) - 49**x, x) == FiniteSet(-8, 10)
+
+
+@XFAIL
+def test_issue_17933():
+    eq1 = x*sin(45) - y*cos(q)
+    eq2 = x*cos(45) - y*sin(q)
+    eq3 = 9*x*sin(45)/10 + y*cos(q)
+    eq4 = 9*x*cos(45)/10 + y*sin(z) - z
+    assert nonlinsolve([eq1, eq2, eq3, eq4], x, y, z, q) ==\
+        FiniteSet((0, 0, 0, q))
+
+def test_issue_17933_bis():
+    # nonlinsolve's result depends on the 'default_sort_key' ordering of
+    # the unknowns.
+    eq1 = x*sin(45) - y*cos(q)
+    eq2 = x*cos(45) - y*sin(q)
+    eq3 = 9*x*sin(45)/10 + y*cos(q)
+    eq4 = 9*x*cos(45)/10 + y*sin(z) - z
+    zz = Symbol('zz')
+    eqs = [e.subs(q, zz) for e in (eq1, eq2, eq3, eq4)]
+    assert nonlinsolve(eqs, x, y, z, zz) == FiniteSet((0, 0, 0, zz))
+
+
+def test_issue_14565():
+    # removed redundancy
+    assert dumeq(nonlinsolve([k + m, k + m*exp(-2*pi*k)], [k, m]) ,
+        FiniteSet((-n*I, ImageSet(Lambda(n, n*I), S.Integers))))
+
+
+# end of tests for nonlinsolve
+
+
+def test_issue_9556():
+    b = Symbol('b', positive=True)
+
+    assert solveset(Abs(x) + 1, x, S.Reals) is S.EmptySet
+    assert solveset(Abs(x) + b, x, S.Reals) is S.EmptySet
+    assert solveset(Eq(b, -1), b, S.Reals) is S.EmptySet
+
+
+def test_issue_9611():
+    assert solveset(Eq(x - x + a, a), x, S.Reals) == S.Reals
+    assert solveset(Eq(y - y + a, a), y) == S.Complexes
+
+
+def test_issue_9557():
+    assert solveset(x**2 + a, x, S.Reals) == Intersection(S.Reals,
+        FiniteSet(-sqrt(-a), sqrt(-a)))
+
+
+def test_issue_9778():
+    x = Symbol('x', real=True)
+    y = Symbol('y', real=True)
+    assert solveset(x**3 + 1, x, S.Reals) == FiniteSet(-1)
+    assert solveset(x**Rational(3, 5) + 1, x, S.Reals) == S.EmptySet
+    assert solveset(x**3 + y, x, S.Reals) == \
+        FiniteSet(-Abs(y)**Rational(1, 3)*sign(y))
+
+
+def test_issue_10214():
+    assert solveset(x**Rational(3, 2) + 4, x, S.Reals) == S.EmptySet
+    assert solveset(x**(Rational(-3, 2)) + 4, x, S.Reals) == S.EmptySet
+
+    ans = FiniteSet(-2**Rational(2, 3))
+    assert solveset(x**(S(3)) + 4, x, S.Reals) == ans
+    assert (x**(S(3)) + 4).subs(x,list(ans)[0]) == 0 # substituting ans and verifying the result.
+    assert (x**(S(3)) + 4).subs(x,-(-2)**Rational(2, 3)) == 0
+
+
+def test_issue_9849():
+    assert solveset(Abs(sin(x)) + 1, x, S.Reals) == S.EmptySet
+
+
+def test_issue_9953():
+    assert linsolve([ ], x) == S.EmptySet
+
+
+def test_issue_9913():
+    assert solveset(2*x + 1/(x - 10)**2, x, S.Reals) == \
+        FiniteSet(-(3*sqrt(24081)/4 + Rational(4027, 4))**Rational(1, 3)/3 - 100/
+                (3*(3*sqrt(24081)/4 + Rational(4027, 4))**Rational(1, 3)) + Rational(20, 3))
+
+
+def test_issue_10397():
+    assert solveset(sqrt(x), x, S.Complexes) == FiniteSet(0)
+
+
+def test_issue_14987():
+    raises(ValueError, lambda: linear_eq_to_matrix(
+        [x**2], x))
+    raises(ValueError, lambda: linear_eq_to_matrix(
+        [x*(-3/x + 1) + 2*y - a], [x, y]))
+    raises(ValueError, lambda: linear_eq_to_matrix(
+        [(x**2 - 3*x)/(x - 3) - 3], x))
+    raises(ValueError, lambda: linear_eq_to_matrix(
+        [(x + 1)**3 - x**3 - 3*x**2 + 7], x))
+    raises(ValueError, lambda: linear_eq_to_matrix(
+        [x*(1/x + 1) + y], [x, y]))
+    raises(ValueError, lambda: linear_eq_to_matrix(
+        [(x + 1)*y], [x, y]))
+    raises(ValueError, lambda: linear_eq_to_matrix(
+        [Eq(1/x, 1/x + y)], [x, y]))
+    raises(ValueError, lambda: linear_eq_to_matrix(
+        [Eq(y/x, y/x + y)], [x, y]))
+    raises(ValueError, lambda: linear_eq_to_matrix(
+        [Eq(x*(x + 1), x**2 + y)], [x, y]))
+
+
+def test_simplification():
+    eq = x + (a - b)/(-2*a + 2*b)
+    assert solveset(eq, x) == FiniteSet(S.Half)
+    assert solveset(eq, x, S.Reals) == Intersection({-((a - b)/(-2*a + 2*b))}, S.Reals)
+    # So that ap - bn is not zero:
+    ap = Symbol('ap', positive=True)
+    bn = Symbol('bn', negative=True)
+    eq = x + (ap - bn)/(-2*ap + 2*bn)
+    assert solveset(eq, x) == FiniteSet(S.Half)
+    assert solveset(eq, x, S.Reals) == FiniteSet(S.Half)
+
+
+def test_integer_domain_relational():
+    eq1 = 2*x + 3 > 0
+    eq2 = x**2 + 3*x - 2 >= 0
+    eq3 = x + 1/x > -2 + 1/x
+    eq4 = x + sqrt(x**2 - 5) > 0
+    eq = x + 1/x > -2 + 1/x
+    eq5 = eq.subs(x,log(x))
+    eq6 = log(x)/x <= 0
+    eq7 = log(x)/x < 0
+    eq8 = x/(x-3) < 3
+    eq9 = x/(x**2-3) < 3
+
+    assert solveset(eq1, x, S.Integers) == Range(-1, oo, 1)
+    assert solveset(eq2, x, S.Integers) == Union(Range(-oo, -3, 1), Range(1, oo, 1))
+    assert solveset(eq3, x, S.Integers) == Union(Range(-1, 0, 1), Range(1, oo, 1))
+    assert solveset(eq4, x, S.Integers) == Range(3, oo, 1)
+    assert solveset(eq5, x, S.Integers) == Range(2, oo, 1)
+    assert solveset(eq6, x, S.Integers) == Range(1, 2, 1)
+    assert solveset(eq7, x, S.Integers) == S.EmptySet
+    assert solveset(eq8, x, domain=Range(0,5)) == Range(0, 3, 1)
+    assert solveset(eq9, x, domain=Range(0,5)) == Union(Range(0, 2, 1), Range(2, 5, 1))
+
+    # test_issue_19794
+    assert solveset(x + 2 < 0, x, S.Integers) == Range(-oo, -2, 1)
+
+
+def test_issue_10555():
+    f = Function('f')
+    g = Function('g')
+    assert solveset(f(x) - pi/2, x, S.Reals).dummy_eq(
+        ConditionSet(x, Eq(f(x) - pi/2, 0), S.Reals))
+    assert solveset(f(g(x)) - pi/2, g(x), S.Reals).dummy_eq(
+        ConditionSet(g(x), Eq(f(g(x)) - pi/2, 0), S.Reals))
+
+
+def test_issue_8715():
+    eq = x + 1/x > -2 + 1/x
+    assert solveset(eq, x, S.Reals) == \
+        (Interval.open(-2, oo) - FiniteSet(0))
+    assert solveset(eq.subs(x,log(x)), x, S.Reals) == \
+        Interval.open(exp(-2), oo) - FiniteSet(1)
+
+
+def test_issue_11174():
+    eq = z**2 + exp(2*x) - sin(y)
+    soln = Intersection(S.Reals, FiniteSet(log(-z**2 + sin(y))/2))
+    assert solveset(eq, x, S.Reals) == soln
+
+    eq = sqrt(r)*Abs(tan(t))/sqrt(tan(t)**2 + 1) + x*tan(t)
+    s = -sqrt(r)*Abs(tan(t))/(sqrt(tan(t)**2 + 1)*tan(t))
+    soln = Intersection(S.Reals, FiniteSet(s))
+    assert solveset(eq, x, S.Reals) == soln
+
+
+def test_issue_11534():
+    # eq1 and eq2 should not have the same solutions because squaring both
+    # sides of the radical equation introduces a spurious solution branch.
+    # The equations have a symbolic parameter y and it is easy to see that for
+    # y != 0 the solution s1 will not be valid for eq1.
+    x = Symbol('x', real=True)
+    y = Symbol('y', real=True)
+    eq1 = -y + x/sqrt(-x**2 + 1)
+    eq2 = -y**2 + x**2/(-x**2 + 1)
+
+    # We get a ConditionSet here because s1 works in eq1 if y is equal to zero
+    # although not for any other value of y. That case is redundant though
+    # because if y=0 then s1=s2 so the solution for eq1 could just be returned
+    # as s2 - {-1, 1}. In fact we have
+    #   |y/sqrt(y**2 + 1)| < 1
+    # So the complements are not needed either. The ideal output here would be
+    #   sol1 = s2
+    #   sol2 = s1 | s2.
+    s1, s2 = FiniteSet(-y/sqrt(y**2 + 1)), FiniteSet(y/sqrt(y**2 + 1))
+    cset = ConditionSet(x, Eq(eq1, 0), s1)
+    sol1 = (s2 - {-1, 1}) | (cset - {-1, 1})
+    sol2 = (s1 | s2) - {-1, 1}
+
+    assert solveset(eq1, x, S.Reals) == sol1
+    assert solveset(eq2, x, S.Reals) == sol2
+
+
+def test_issue_10477():
+    assert solveset((x**2 + 4*x - 3)/x < 2, x, S.Reals) == \
+        Union(Interval.open(-oo, -3), Interval.open(0, 1))
+
+
+def test_issue_10671():
+    assert solveset(sin(y), y, Interval(0, pi)) == FiniteSet(0, pi)
+    i = Interval(1, 10)
+    assert solveset((1/x).diff(x) < 0, x, i) == i
+
+
+def test_issue_11064():
+    eq = x + sqrt(x**2 - 5)
+    assert solveset(eq > 0, x, S.Reals) == \
+        Interval(sqrt(5), oo)
+    assert solveset(eq < 0, x, S.Reals) == \
+        Interval(-oo, -sqrt(5))
+    assert solveset(eq > sqrt(5), x, S.Reals) == \
+        Interval.Lopen(sqrt(5), oo)
+
+
+def test_issue_12478():
+    eq = sqrt(x - 2) + 2
+    soln = solveset_real(eq, x)
+    assert soln is S.EmptySet
+    assert solveset(eq < 0, x, S.Reals) is S.EmptySet
+    assert solveset(eq > 0, x, S.Reals) == Interval(2, oo)
+
+
+def test_issue_12429():
+    eq = solveset(log(x)/x <= 0, x, S.Reals)
+    sol = Interval.Lopen(0, 1)
+    assert eq == sol
+
+
+def test_issue_19506():
+    eq = arg(x + I)
+    C = Dummy('C')
+    assert solveset(eq).dummy_eq(Intersection(ConditionSet(C, Eq(im(C) + 1, 0), S.Complexes),
+                                                 ConditionSet(C, re(C) > 0, S.Complexes)))
+
+
+def test_solveset_arg():
+    assert solveset(arg(x), x, S.Reals)  == Interval.open(0, oo)
+    assert solveset(arg(4*x -3), x, S.Reals) == Interval.open(Rational(3, 4), oo)
+
+
+def test__is_finite_with_finite_vars():
+    f = _is_finite_with_finite_vars
+    # issue 12482
+    assert all(f(1/x) is None for x in (
+        Dummy(), Dummy(real=True), Dummy(complex=True)))
+    assert f(1/Dummy(real=False)) is True  # b/c it's finite but not 0
+
+
+def test_issue_13550():
+    assert solveset(x**2 - 2*x - 15, symbol = x, domain = Interval(-oo, 0)) == FiniteSet(-3)
+
+
+def test_issue_13849():
+    assert nonlinsolve((t*(sqrt(5) + sqrt(2)) - sqrt(2), t), t) is S.EmptySet
+
+
+def test_issue_14223():
+    assert solveset((Abs(x + Min(x, 2)) - 2).rewrite(Piecewise), x,
+        S.Reals) == FiniteSet(-1, 1)
+    assert solveset((Abs(x + Min(x, 2)) - 2).rewrite(Piecewise), x,
+        Interval(0, 2)) == FiniteSet(1)
+    assert solveset(x, x, FiniteSet(1, 2)) is S.EmptySet
+
+
+def test_issue_10158():
+    dom = S.Reals
+    assert solveset(x*Max(x, 15) - 10, x, dom) == FiniteSet(Rational(2, 3))
+    assert solveset(x*Min(x, 15) - 10, x, dom) == FiniteSet(-sqrt(10), sqrt(10))
+    assert solveset(Max(Abs(x - 3) - 1, x + 2) - 3, x, dom) == FiniteSet(-1, 1)
+    assert solveset(Abs(x - 1) - Abs(y), x, dom) == FiniteSet(-Abs(y) + 1, Abs(y) + 1)
+    assert solveset(Abs(x + 4*Abs(x + 1)), x, dom) == FiniteSet(Rational(-4, 3), Rational(-4, 5))
+    assert solveset(2*Abs(x + Abs(x + Max(3, x))) - 2, x, S.Reals) == FiniteSet(-1, -2)
+    dom = S.Complexes
+    raises(ValueError, lambda: solveset(x*Max(x, 15) - 10, x, dom))
+    raises(ValueError, lambda: solveset(x*Min(x, 15) - 10, x, dom))
+    raises(ValueError, lambda: solveset(Max(Abs(x - 3) - 1, x + 2) - 3, x, dom))
+    raises(ValueError, lambda: solveset(Abs(x - 1) - Abs(y), x, dom))
+    raises(ValueError, lambda: solveset(Abs(x + 4*Abs(x + 1)), x, dom))
+
+
+def test_issue_14300():
+    f = 1 - exp(-18000000*x) - y
+    a1 = FiniteSet(-log(-y + 1)/18000000)
+
+    assert solveset(f, x, S.Reals) == \
+        Intersection(S.Reals, a1)
+    assert dumeq(solveset(f, x),
+        ImageSet(Lambda(n, -I*(2*n*pi + arg(-y + 1))/18000000 -
+            log(Abs(y - 1))/18000000), S.Integers))
+
+
+def test_issue_14454():
+    number = CRootOf(x**4 + x - 1, 2)
+    raises(ValueError, lambda: invert_real(number, 0, x))
+    assert invert_real(x**2, number, x)  # no error
+
+
+def test_issue_17882():
+    assert solveset(-8*x**2/(9*(x**2 - 1)**(S(4)/3)) + 4/(3*(x**2 - 1)**(S(1)/3)), x, S.Complexes) == \
+        FiniteSet(sqrt(3), -sqrt(3))
+
+
+def test_term_factors():
+    assert list(_term_factors(3**x - 2)) == [-2, 3**x]
+    expr = 4**(x + 1) + 4**(x + 2) + 4**(x - 1) - 3**(x + 2) - 3**(x + 3)
+    assert set(_term_factors(expr)) == {
+        3**(x + 2), 4**(x + 2), 3**(x + 3), 4**(x - 1), -1, 4**(x + 1)}
+
+
+#################### tests for transolve and its helpers ###############
+
+def test_transolve():
+
+    assert _transolve(3**x, x, S.Reals) == S.EmptySet
+    assert _transolve(3**x - 9**(x + 5), x, S.Reals) == FiniteSet(-10)
+
+
+def test_issue_21276():
+    eq = (2*x*(y - z) - y*erf(y - z) - y + z*erf(y - z) + z)**2
+    assert solveset(eq.expand(), y) == FiniteSet(z, z + erfinv(2*x - 1))
+
+
+# exponential tests
+def test_exponential_real():
+    from sympy.abc import y
+
+    e1 = 3**(2*x) - 2**(x + 3)
+    e2 = 4**(5 - 9*x) - 8**(2 - x)
+    e3 = 2**x + 4**x
+    e4 = exp(log(5)*x) - 2**x
+    e5 = exp(x/y)*exp(-z/y) - 2
+    e6 = 5**(x/2) - 2**(x/3)
+    e7 = 4**(x + 1) + 4**(x + 2) + 4**(x - 1) - 3**(x + 2) - 3**(x + 3)
+    e8 = -9*exp(-2*x + 5) + 4*exp(3*x + 1)
+    e9 = 2**x + 4**x + 8**x - 84
+    e10 = 29*2**(x + 1)*615**(x) - 123*2726**(x)
+
+    assert solveset(e1, x, S.Reals) == FiniteSet(
+        -3*log(2)/(-2*log(3) + log(2)))
+    assert solveset(e2, x, S.Reals) == FiniteSet(Rational(4, 15))
+    assert solveset(e3, x, S.Reals) == S.EmptySet
+    assert solveset(e4, x, S.Reals) == FiniteSet(0)
+    assert solveset(e5, x, S.Reals) == Intersection(
+        S.Reals, FiniteSet(y*log(2*exp(z/y))))
+    assert solveset(e6, x, S.Reals) == FiniteSet(0)
+    assert solveset(e7, x, S.Reals) == FiniteSet(2)
+    assert solveset(e8, x, S.Reals) == FiniteSet(-2*log(2)/5 + 2*log(3)/5 + Rational(4, 5))
+    assert solveset(e9, x, S.Reals) == FiniteSet(2)
+    assert solveset(e10,x, S.Reals) == FiniteSet((-log(29) - log(2) + log(123))/(-log(2726) + log(2) + log(615)))
+
+    assert solveset_real(-9*exp(-2*x + 5) + 2**(x + 1), x) == FiniteSet(
+        -((-5 - 2*log(3) + log(2))/(log(2) + 2)))
+    assert solveset_real(4**(x/2) - 2**(x/3), x) == FiniteSet(0)
+    b = sqrt(6)*sqrt(log(2))/sqrt(log(5))
+    assert solveset_real(5**(x/2) - 2**(3/x), x) == FiniteSet(-b, b)
+
+    # coverage test
+    C1, C2 = symbols('C1 C2')
+    f = Function('f')
+    assert solveset_real(C1 + C2/x**2 - exp(-f(x)), f(x)) == Intersection(
+        S.Reals, FiniteSet(-log(C1 + C2/x**2)))
+    y = symbols('y', positive=True)
+    assert solveset_real(x**2 - y**2/exp(x), y) == Intersection(
+        S.Reals, FiniteSet(-sqrt(x**2*exp(x)), sqrt(x**2*exp(x))))
+    p = Symbol('p', positive=True)
+    assert solveset_real((1/p + 1)**(p + 1), p).dummy_eq(
+        ConditionSet(x, Eq((1 + 1/x)**(x + 1), 0), S.Reals))
+    assert solveset(2**x - 4**x + 12, x, S.Reals) == {2}
+    assert solveset(2**x - 2**(2*x) + 12, x, S.Reals) == {2}
+
+
+@XFAIL
+def test_exponential_complex():
+    n = Dummy('n')
+
+    assert dumeq(solveset_complex(2**x + 4**x, x),imageset(
+        Lambda(n, I*(2*n*pi + pi)/log(2)), S.Integers))
+    assert solveset_complex(x**z*y**z - 2, z) == FiniteSet(
+        log(2)/(log(x) + log(y)))
+    assert dumeq(solveset_complex(4**(x/2) - 2**(x/3), x), imageset(
+        Lambda(n, 3*n*I*pi/log(2)), S.Integers))
+    assert dumeq(solveset(2**x + 32, x), imageset(
+        Lambda(n, (I*(2*n*pi + pi) + 5*log(2))/log(2)), S.Integers))
+
+    eq = (2**exp(y**2/x) + 2)/(x**2 + 15)
+    a = sqrt(x)*sqrt(-log(log(2)) + log(log(2) + 2*n*I*pi))
+    assert solveset_complex(eq, y) == FiniteSet(-a, a)
+
+    union1 = imageset(Lambda(n, I*(2*n*pi - pi*Rational(2, 3))/log(2)), S.Integers)
+    union2 = imageset(Lambda(n, I*(2*n*pi + pi*Rational(2, 3))/log(2)), S.Integers)
+    assert dumeq(solveset(2**x + 4**x + 8**x, x), Union(union1, union2))
+
+    eq = 4**(x + 1) + 4**(x + 2) + 4**(x - 1) - 3**(x + 2) - 3**(x + 3)
+    res = solveset(eq, x)
+    num = 2*n*I*pi - 4*log(2) + 2*log(3)
+    den = -2*log(2) + log(3)
+    ans = imageset(Lambda(n, num/den), S.Integers)
+    assert dumeq(res, ans)
+
+
+def test_expo_conditionset():
+
+    f1 = (exp(x) + 1)**x - 2
+    f2 = (x + 2)**y*x - 3
+    f3 = 2**x - exp(x) - 3
+    f4 = log(x) - exp(x)
+    f5 = 2**x + 3**x - 5**x
+
+    assert solveset(f1, x, S.Reals).dummy_eq(ConditionSet(
+        x, Eq((exp(x) + 1)**x - 2, 0), S.Reals))
+    assert solveset(f2, x, S.Reals).dummy_eq(ConditionSet(
+        x, Eq(x*(x + 2)**y - 3, 0), S.Reals))
+    assert solveset(f3, x, S.Reals).dummy_eq(ConditionSet(
+        x, Eq(2**x - exp(x) - 3, 0), S.Reals))
+    assert solveset(f4, x, S.Reals).dummy_eq(ConditionSet(
+        x, Eq(-exp(x) + log(x), 0), S.Reals))
+    assert solveset(f5, x, S.Reals).dummy_eq(ConditionSet(
+        x, Eq(2**x + 3**x - 5**x, 0), S.Reals))
+
+
+def test_exponential_symbols():
+    x, y, z = symbols('x y z', positive=True)
+    xr, zr = symbols('xr, zr', real=True)
+
+    assert solveset(z**x - y, x, S.Reals) == Intersection(
+        S.Reals, FiniteSet(log(y)/log(z)))
+
+    f1 = 2*x**w - 4*y**w
+    f2 = (x/y)**w - 2
+    sol1 = Intersection({log(2)/(log(x) - log(y))}, S.Reals)
+    sol2 = Intersection({log(2)/log(x/y)}, S.Reals)
+    assert solveset(f1, w, S.Reals) == sol1, solveset(f1, w, S.Reals)
+    assert solveset(f2, w, S.Reals) == sol2, solveset(f2, w, S.Reals)
+
+    assert solveset(x**x, x, Interval.Lopen(0,oo)).dummy_eq(
+        ConditionSet(w, Eq(w**w, 0), Interval.open(0, oo)))
+    assert solveset(x**y - 1, y, S.Reals) == FiniteSet(0)
+    assert solveset(exp(x/y)*exp(-z/y) - 2, y, S.Reals) == \
+    Complement(ConditionSet(y, Eq(im(x)/y, 0) & Eq(im(z)/y, 0), \
+    Complement(Intersection(FiniteSet((x - z)/log(2)), S.Reals), FiniteSet(0))), FiniteSet(0))
+    assert solveset(exp(xr/y)*exp(-zr/y) - 2, y, S.Reals) == \
+        Complement(FiniteSet((xr - zr)/log(2)), FiniteSet(0))
+
+    assert solveset(a**x - b**x, x).dummy_eq(ConditionSet(
+        w, Ne(a, 0) & Ne(b, 0), FiniteSet(0)))
+
+
+def test_ignore_assumptions():
+    # make sure assumptions are ignored
+    xpos = symbols('x', positive=True)
+    x = symbols('x')
+    assert solveset_complex(xpos**2 - 4, xpos
+        ) == solveset_complex(x**2 - 4, x)
+
+
+@XFAIL
+def test_issue_10864():
+    assert solveset(x**(y*z) - x, x, S.Reals) == FiniteSet(1)
+
+
+@XFAIL
+def test_solve_only_exp_2():
+    assert solveset_real(sqrt(exp(x)) + sqrt(exp(-x)) - 4, x) == \
+        FiniteSet(2*log(-sqrt(3) + 2), 2*log(sqrt(3) + 2))
+
+
+def test_is_exponential():
+    assert _is_exponential(y, x) is False
+    assert _is_exponential(3**x - 2, x) is True
+    assert _is_exponential(5**x - 7**(2 - x), x) is True
+    assert _is_exponential(sin(2**x) - 4*x, x) is False
+    assert _is_exponential(x**y - z, y) is True
+    assert _is_exponential(x**y - z, x) is False
+    assert _is_exponential(2**x + 4**x - 1, x) is True
+    assert _is_exponential(x**(y*z) - x, x) is False
+    assert _is_exponential(x**(2*x) - 3**x, x) is False
+    assert _is_exponential(x**y - y*z, y) is False
+    assert _is_exponential(x**y - x*z, y) is True
+
+
+def test_solve_exponential():
+    assert _solve_exponential(3**(2*x) - 2**(x + 3), 0, x, S.Reals) == \
+        FiniteSet(-3*log(2)/(-2*log(3) + log(2)))
+    assert _solve_exponential(2**y + 4**y, 1, y, S.Reals) == \
+        FiniteSet(log(Rational(-1, 2) + sqrt(5)/2)/log(2))
+    assert _solve_exponential(2**y + 4**y, 0, y, S.Reals) == \
+        S.EmptySet
+    assert _solve_exponential(2**x + 3**x - 5**x, 0, x, S.Reals) == \
+        ConditionSet(x, Eq(2**x + 3**x - 5**x, 0), S.Reals)
+
+# end of exponential tests
+
+
+# logarithmic tests
+def test_logarithmic():
+    assert solveset_real(log(x - 3) + log(x + 3), x) == FiniteSet(
+        -sqrt(10), sqrt(10))
+    assert solveset_real(log(x + 1) - log(2*x - 1), x) == FiniteSet(2)
+    assert solveset_real(log(x + 3) + log(1 + 3/x) - 3, x) == FiniteSet(
+        -3 + sqrt(-12 + exp(3))*exp(Rational(3, 2))/2 + exp(3)/2,
+        -sqrt(-12 + exp(3))*exp(Rational(3, 2))/2 - 3 + exp(3)/2)
+
+    eq = z - log(x) + log(y/(x*(-1 + y**2/x**2)))
+    assert solveset_real(eq, x) == \
+        Intersection(S.Reals, FiniteSet(-sqrt(y**2 - y*exp(z)),
+            sqrt(y**2 - y*exp(z)))) - \
+        Intersection(S.Reals, FiniteSet(-sqrt(y**2), sqrt(y**2)))
+    assert solveset_real(
+        log(3*x) - log(-x + 1) - log(4*x + 1), x) == FiniteSet(Rational(-1, 2), S.Half)
+    assert solveset(log(x**y) - y*log(x), x, S.Reals) == S.Reals
+
+@XFAIL
+def test_uselogcombine_2():
+    eq = log(exp(2*x) + 1) + log(-tanh(x) + 1) - log(2)
+    assert solveset_real(eq, x) is S.EmptySet
+    eq = log(8*x) - log(sqrt(x) + 1) - 2
+    assert solveset_real(eq, x) is S.EmptySet
+
+
+def test_is_logarithmic():
+    assert _is_logarithmic(y, x) is False
+    assert _is_logarithmic(log(x), x) is True
+    assert _is_logarithmic(log(x) - 3, x) is True
+    assert _is_logarithmic(log(x)*log(y), x) is True
+    assert _is_logarithmic(log(x)**2, x) is False
+    assert _is_logarithmic(log(x - 3) + log(x + 3), x) is True
+    assert _is_logarithmic(log(x**y) - y*log(x), x) is True
+    assert _is_logarithmic(sin(log(x)), x) is False
+    assert _is_logarithmic(x + y, x) is False
+    assert _is_logarithmic(log(3*x) - log(1 - x) + 4, x) is True
+    assert _is_logarithmic(log(x) + log(y) + x, x) is False
+    assert _is_logarithmic(log(log(x - 3)) + log(x - 3), x) is True
+    assert _is_logarithmic(log(log(3) + x) + log(x), x) is True
+    assert _is_logarithmic(log(x)*(y + 3) + log(x), y) is False
+
+
+def test_solve_logarithm():
+    y = Symbol('y')
+    assert _solve_logarithm(log(x**y) - y*log(x), 0, x, S.Reals) == S.Reals
+    y = Symbol('y', positive=True)
+    assert _solve_logarithm(log(x)*log(y), 0, x, S.Reals) == FiniteSet(1)
+
+# end of logarithmic tests
+
+
+# lambert tests
+def test_is_lambert():
+    a, b, c = symbols('a,b,c')
+    assert _is_lambert(x**2, x) is False
+    assert _is_lambert(a**x**2+b*x+c, x) is True
+    assert _is_lambert(E**2, x) is False
+    assert _is_lambert(x*E**2, x) is False
+    assert _is_lambert(3*log(x) - x*log(3), x) is True
+    assert _is_lambert(log(log(x - 3)) + log(x-3), x) is True
+    assert _is_lambert(5*x - 1 + 3*exp(2 - 7*x), x) is True
+    assert _is_lambert((a/x + exp(x/2)).diff(x, 2), x) is True
+    assert _is_lambert((x**2 - 2*x + 1).subs(x, (log(x) + 3*x)**2 - 1), x) is True
+    assert _is_lambert(x*sinh(x) - 1, x) is True
+    assert _is_lambert(x*cos(x) - 5, x) is True
+    assert _is_lambert(tanh(x) - 5*x, x) is True
+    assert _is_lambert(cosh(x) - sinh(x), x) is False
+
+# end of lambert tests
+
+
+def test_linear_coeffs():
+    from sympy.solvers.solveset import linear_coeffs
+    assert linear_coeffs(0, x) == [0, 0]
+    assert all(i is S.Zero for i in linear_coeffs(0, x))
+    assert linear_coeffs(x + 2*y + 3, x, y) == [1, 2, 3]
+    assert linear_coeffs(x + 2*y + 3, y, x) == [2, 1, 3]
+    assert linear_coeffs(x + 2*x**2 + 3, x, x**2) == [1, 2, 3]
+    raises(ValueError, lambda:
+        linear_coeffs(x + 2*x**2 + x**3, x, x**2))
+    raises(ValueError, lambda:
+        linear_coeffs(1/x*(x - 1) + 1/x, x))
+    raises(ValueError, lambda:
+        linear_coeffs(x, x, x))
+    assert linear_coeffs(a*(x + y), x, y) == [a, a, 0]
+    assert linear_coeffs(1.0, x, y) == [0, 0, 1.0]
+    # don't include coefficients of 0
+    assert linear_coeffs(Eq(x, x + y), x, y, dict=True) == {y: -1}
+    assert linear_coeffs(0, x, y, dict=True) == {}
+
+
+def test_is_modular():
+    assert _is_modular(y, x) is False
+    assert _is_modular(Mod(x, 3) - 1, x) is True
+    assert _is_modular(Mod(x**3 - 3*x**2 - x + 1, 3) - 1, x) is True
+    assert _is_modular(Mod(exp(x + y), 3) - 2, x) is True
+    assert _is_modular(Mod(exp(x + y), 3) - log(x), x) is True
+    assert _is_modular(Mod(x, 3) - 1, y) is False
+    assert _is_modular(Mod(x, 3)**2 - 5, x) is False
+    assert _is_modular(Mod(x, 3)**2 - y, x) is False
+    assert _is_modular(exp(Mod(x, 3)) - 1, x) is False
+    assert _is_modular(Mod(3, y) - 1, y) is False
+
+
+def test_invert_modular():
+    n = Dummy('n', integer=True)
+    from sympy.solvers.solveset import _invert_modular as invert_modular
+
+    # no solutions
+    assert invert_modular(Mod(x, 12), S(1)/2, n, x) == (x, S.EmptySet)
+    # non invertible cases
+    assert invert_modular(Mod(sin(x), 7), S(5), n, x) == (Mod(sin(x), 7), 5)
+    assert invert_modular(Mod(exp(x), 7), S(5), n, x) == (Mod(exp(x), 7), 5)
+    assert invert_modular(Mod(log(x), 7), S(5), n, x) == (Mod(log(x), 7), 5)
+    # a is symbol
+    assert dumeq(invert_modular(Mod(x, 7), S(5), n, x),
+            (x, ImageSet(Lambda(n, 7*n + 5), S.Integers)))
+    # a.is_Add
+    assert dumeq(invert_modular(Mod(x + 8, 7), S(5), n, x),
+            (x, ImageSet(Lambda(n, 7*n + 4), S.Integers)))
+    assert invert_modular(Mod(x**2 + x, 7), S(5), n, x) == \
+            (Mod(x**2 + x, 7), 5)
+    # a.is_Mul
+    assert dumeq(invert_modular(Mod(3*x, 7), S(5), n, x),
+            (x, ImageSet(Lambda(n, 7*n + 4), S.Integers)))
+    assert invert_modular(Mod((x + 1)*(x + 2), 7), S(5), n, x) == \
+            (Mod((x + 1)*(x + 2), 7), 5)
+    # a.is_Pow
+    assert invert_modular(Mod(x**4, 7), S(5), n, x) == \
+            (x, S.EmptySet)
+    assert dumeq(invert_modular(Mod(3**x, 4), S(3), n, x),
+            (x, ImageSet(Lambda(n, 2*n + 1), S.Naturals0)))
+    assert dumeq(invert_modular(Mod(2**(x**2 + x + 1), 7), S(2), n, x),
+            (x**2 + x + 1, ImageSet(Lambda(n, 3*n + 1), S.Naturals0)))
+    assert invert_modular(Mod(sin(x)**4, 7), S(5), n, x) == (x, S.EmptySet)
+
+
+def test_solve_modular():
+    n = Dummy('n', integer=True)
+    # if rhs has symbol (need to be implemented in future).
+    assert solveset(Mod(x, 4) - x, x, S.Integers
+        ).dummy_eq(
+            ConditionSet(x, Eq(-x + Mod(x, 4), 0),
+            S.Integers))
+    # when _invert_modular fails to invert
+    assert solveset(3 - Mod(sin(x), 7), x, S.Integers
+        ).dummy_eq(
+            ConditionSet(x, Eq(Mod(sin(x), 7) - 3, 0), S.Integers))
+    assert solveset(3 - Mod(log(x), 7), x, S.Integers
+        ).dummy_eq(
+            ConditionSet(x, Eq(Mod(log(x), 7) - 3, 0), S.Integers))
+    assert solveset(3 - Mod(exp(x), 7), x, S.Integers
+        ).dummy_eq(ConditionSet(x, Eq(Mod(exp(x), 7) - 3, 0),
+        S.Integers))
+    # EmptySet solution definitely
+    assert solveset(7 - Mod(x, 5), x, S.Integers) is S.EmptySet
+    assert solveset(5 - Mod(x, 5), x, S.Integers) is S.EmptySet
+    # Negative m
+    assert dumeq(solveset(2 + Mod(x, -3), x, S.Integers),
+            ImageSet(Lambda(n, -3*n - 2), S.Integers))
+    assert solveset(4 + Mod(x, -3), x, S.Integers) is S.EmptySet
+    # linear expression in Mod
+    assert dumeq(solveset(3 - Mod(x, 5), x, S.Integers),
+        ImageSet(Lambda(n, 5*n + 3), S.Integers))
+    assert dumeq(solveset(3 - Mod(5*x - 8, 7), x, S.Integers),
+                ImageSet(Lambda(n, 7*n + 5), S.Integers))
+    assert dumeq(solveset(3 - Mod(5*x, 7), x, S.Integers),
+                ImageSet(Lambda(n, 7*n + 2), S.Integers))
+    # higher degree expression in Mod
+    assert dumeq(solveset(Mod(x**2, 160) - 9, x, S.Integers),
+            Union(ImageSet(Lambda(n, 160*n + 3), S.Integers),
+            ImageSet(Lambda(n, 160*n + 13), S.Integers),
+            ImageSet(Lambda(n, 160*n + 67), S.Integers),
+            ImageSet(Lambda(n, 160*n + 77), S.Integers),
+            ImageSet(Lambda(n, 160*n + 83), S.Integers),
+            ImageSet(Lambda(n, 160*n + 93), S.Integers),
+            ImageSet(Lambda(n, 160*n + 147), S.Integers),
+            ImageSet(Lambda(n, 160*n + 157), S.Integers)))
+    assert solveset(3 - Mod(x**4, 7), x, S.Integers) is S.EmptySet
+    assert dumeq(solveset(Mod(x**4, 17) - 13, x, S.Integers),
+            Union(ImageSet(Lambda(n, 17*n + 3), S.Integers),
+            ImageSet(Lambda(n, 17*n + 5), S.Integers),
+            ImageSet(Lambda(n, 17*n + 12), S.Integers),
+            ImageSet(Lambda(n, 17*n + 14), S.Integers)))
+    # a.is_Pow tests
+    assert dumeq(solveset(Mod(7**x, 41) - 15, x, S.Integers),
+            ImageSet(Lambda(n, 40*n + 3), S.Naturals0))
+    assert dumeq(solveset(Mod(12**x, 21) - 18, x, S.Integers),
+            ImageSet(Lambda(n, 6*n + 2), S.Naturals0))
+    assert dumeq(solveset(Mod(3**x, 4) - 3, x, S.Integers),
+            ImageSet(Lambda(n, 2*n + 1), S.Naturals0))
+    assert dumeq(solveset(Mod(2**x, 7) - 2 , x, S.Integers),
+            ImageSet(Lambda(n, 3*n + 1), S.Naturals0))
+    assert dumeq(solveset(Mod(3**(3**x), 4) - 3, x, S.Integers),
+            Intersection(ImageSet(Lambda(n, Intersection({log(2*n + 1)/log(3)},
+            S.Integers)), S.Naturals0), S.Integers))
+    # Implemented for m without primitive root
+    assert solveset(Mod(x**3, 7) - 2, x, S.Integers) is S.EmptySet
+    assert dumeq(solveset(Mod(x**3, 8) - 1, x, S.Integers),
+            ImageSet(Lambda(n, 8*n + 1), S.Integers))
+    assert dumeq(solveset(Mod(x**4, 9) - 4, x, S.Integers),
+            Union(ImageSet(Lambda(n, 9*n + 4), S.Integers),
+            ImageSet(Lambda(n, 9*n + 5), S.Integers)))
+    # domain intersection
+    assert dumeq(solveset(3 - Mod(5*x - 8, 7), x, S.Naturals0),
+            Intersection(ImageSet(Lambda(n, 7*n + 5), S.Integers), S.Naturals0))
+    # Complex args
+    assert solveset(Mod(x, 3) - I, x, S.Integers) == \
+            S.EmptySet
+    assert solveset(Mod(I*x, 3) - 2, x, S.Integers
+        ).dummy_eq(
+            ConditionSet(x, Eq(Mod(I*x, 3) - 2, 0), S.Integers))
+    assert solveset(Mod(I + x, 3) - 2, x, S.Integers
+        ).dummy_eq(
+            ConditionSet(x, Eq(Mod(x + I, 3) - 2, 0), S.Integers))
+
+    # issue 17373 (https://github.com/sympy/sympy/issues/17373)
+    assert dumeq(solveset(Mod(x**4, 14) - 11, x, S.Integers),
+            Union(ImageSet(Lambda(n, 14*n + 3), S.Integers),
+            ImageSet(Lambda(n, 14*n + 11), S.Integers)))
+    assert dumeq(solveset(Mod(x**31, 74) - 43, x, S.Integers),
+            ImageSet(Lambda(n, 74*n + 31), S.Integers))
+
+    # issue 13178
+    n = symbols('n', integer=True)
+    a = 742938285
+    b = 1898888478
+    m = 2**31 - 1
+    c = 20170816
+    assert dumeq(solveset(c - Mod(a**n*b, m), n, S.Integers),
+            ImageSet(Lambda(n, 2147483646*n + 100), S.Naturals0))
+    assert dumeq(solveset(c - Mod(a**n*b, m), n, S.Naturals0),
+            Intersection(ImageSet(Lambda(n, 2147483646*n + 100), S.Naturals0),
+            S.Naturals0))
+    assert dumeq(solveset(c - Mod(a**(2*n)*b, m), n, S.Integers),
+            Intersection(ImageSet(Lambda(n, 1073741823*n + 50), S.Naturals0),
+            S.Integers))
+    assert solveset(c - Mod(a**(2*n + 7)*b, m), n, S.Integers) is S.EmptySet
+    assert dumeq(solveset(c - Mod(a**(n - 4)*b, m), n, S.Integers),
+            Intersection(ImageSet(Lambda(n, 2147483646*n + 104), S.Naturals0),
+            S.Integers))
+
+# end of modular tests
+
+def test_issue_17276():
+    assert nonlinsolve([Eq(x, 5**(S(1)/5)), Eq(x*y, 25*sqrt(5))], x, y) == \
+     FiniteSet((5**(S(1)/5), 25*5**(S(3)/10)))
+
+
+def test_issue_10426():
+    x = Dummy('x')
+    a = Symbol('a')
+    n = Dummy('n')
+    assert (solveset(sin(x + a) - sin(x), a)).dummy_eq(Dummy('x')) == (Union(
+        ImageSet(Lambda(n, 2*n*pi), S.Integers),
+        Intersection(S.Complexes, ImageSet(Lambda(n, -I*(I*(2*n*pi + arg(-exp(-2*I*x))) + 2*im(x))),
+        S.Integers)))).dummy_eq(Dummy('x,n'))
+
+
+def test_solveset_conjugate():
+    """Test solveset for simple conjugate functions"""
+    assert solveset(conjugate(x) -3 + I) == FiniteSet(3 + I)
+
+
+def test_issue_18208():
+    variables = symbols('x0:16') + symbols('y0:12')
+    x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15,\
+    y0, y1, y2, y3, y4, y5, y6, y7, y8, y9, y10, y11 = variables
+
+    eqs = [x0 + x1 + x2 + x3 - 51,
+           x0 + x1 + x4 + x5 - 46,
+           x2 + x3 + x6 + x7 - 39,
+           x0 + x3 + x4 + x7 - 50,
+           x1 + x2 + x5 + x6 - 35,
+           x4 + x5 + x6 + x7 - 34,
+           x4 + x5 + x8 + x9 - 46,
+           x10 + x11 + x6 + x7 - 23,
+           x11 + x4 + x7 + x8 - 25,
+           x10 + x5 + x6 + x9 - 44,
+           x10 + x11 + x8 + x9 - 35,
+           x12 + x13 + x8 + x9 - 35,
+           x10 + x11 + x14 + x15 - 29,
+           x11 + x12 + x15 + x8 - 35,
+           x10 + x13 + x14 + x9 - 29,
+           x12 + x13 + x14 + x15 - 29,
+           y0 + y1 + y2 + y3 - 55,
+           y0 + y1 + y4 + y5 - 53,
+           y2 + y3 + y6 + y7 - 56,
+           y0 + y3 + y4 + y7 - 57,
+           y1 + y2 + y5 + y6 - 52,
+           y4 + y5 + y6 + y7 - 54,
+           y4 + y5 + y8 + y9 - 48,
+           y10 + y11 + y6 + y7 - 60,
+           y11 + y4 + y7 + y8 - 51,
+           y10 + y5 + y6 + y9 - 57,
+           y10 + y11 + y8 + y9 - 54,
+           x10 - 2,
+           x11 - 5,
+           x12 - 1,
+           x13 - 6,
+           x14 - 1,
+           x15 - 21,
+           y0 - 12,
+           y1 - 20]
+
+    expected = [38 - x3, x3 - 10, 23 - x3, x3, 12 - x7, x7 + 6, 16 - x7, x7,
+                8, 20, 2, 5, 1, 6, 1, 21, 12, 20, -y11 + y9 + 2, y11 - y9 + 21,
+                -y11 - y7 + y9 + 24, y11 + y7 - y9 - 3, 33 - y7, y7, 27 - y9, y9,
+                27 - y11, y11]
+
+    A, b = linear_eq_to_matrix(eqs, variables)
+
+    # solve
+    solve_expected = {v:eq for v, eq in zip(variables, expected) if v != eq}
+
+    assert solve(eqs, variables) == solve_expected
+
+    # linsolve
+    linsolve_expected = FiniteSet(Tuple(*expected))
+
+    assert linsolve(eqs, variables) == linsolve_expected
+    assert linsolve((A, b), variables) == linsolve_expected
+
+    # gauss_jordan_solve
+    gj_solve, new_vars = A.gauss_jordan_solve(b)
+    gj_solve = list(gj_solve)
+
+    gj_expected = linsolve_expected.subs(zip([x3, x7, y7, y9, y11], new_vars))
+
+    assert FiniteSet(Tuple(*gj_solve)) == gj_expected
+
+    # nonlinsolve
+    # The solution set of nonlinsolve is currently equivalent to linsolve and is
+    # also correct. However, we would prefer to use the same symbols as parameters
+    # for the solution to the underdetermined system in all cases if possible.
+    # We want a solution that is not just equivalent but also given in the same form.
+    # This test may be changed should nonlinsolve be modified in this way.
+
+    nonlinsolve_expected = FiniteSet((38 - x3, x3 - 10, 23 - x3, x3, 12 - x7, x7 + 6,
+                                      16 - x7, x7, 8, 20, 2, 5, 1, 6, 1, 21, 12, 20,
+                                      -y5 + y7 - 1, y5 - y7 + 24, 21 - y5, y5, 33 - y7,
+                                      y7, 27 - y9, y9, -y5 + y7 - y9 + 24, y5 - y7 + y9 + 3))
+
+    assert nonlinsolve(eqs, variables) == nonlinsolve_expected
+
+
+def test_substitution_with_infeasible_solution():
+    a00, a01, a10, a11, l0, l1, l2, l3, m0, m1, m2, m3, m4, m5, m6, m7, c00, c01, c10, c11, p00, p01, p10, p11 = symbols(
+        'a00, a01, a10, a11, l0, l1, l2, l3, m0, m1, m2, m3, m4, m5, m6, m7, c00, c01, c10, c11, p00, p01, p10, p11'
+    )
+    solvefor = [p00, p01, p10, p11, c00, c01, c10, c11, m0, m1, m3, l0, l1, l2, l3]
+    system = [
+        -l0 * c00 - l1 * c01 + m0 + c00 + c01,
+        -l0 * c10 - l1 * c11 + m1,
+        -l2 * c00 - l3 * c01 + c00 + c01,
+        -l2 * c10 - l3 * c11 + m3,
+        -l0 * p00 - l2 * p10 + p00 + p10,
+        -l1 * p00 - l3 * p10 + p00 + p10,
+        -l0 * p01 - l2 * p11,
+        -l1 * p01 - l3 * p11,
+        -a00 + c00 * p00 + c10 * p01,
+        -a01 + c01 * p00 + c11 * p01,
+        -a10 + c00 * p10 + c10 * p11,
+        -a11 + c01 * p10 + c11 * p11,
+        -m0 * p00,
+        -m1 * p01,
+        -m2 * p10,
+        -m3 * p11,
+        -m4 * c00,
+        -m5 * c01,
+        -m6 * c10,
+        -m7 * c11,
+        m2,
+        m4,
+        m5,
+        m6,
+        m7
+    ]
+    sol = FiniteSet(
+        (0, Complement(FiniteSet(p01), FiniteSet(0)), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, l2, l3),
+        (p00, Complement(FiniteSet(p01), FiniteSet(0)), 0, p11, 0, 0, 0, 0, 0, 0, 0, 1, 1, -p01/p11, -p01/p11),
+        (0, Complement(FiniteSet(p01), FiniteSet(0)), 0, p11, 0, 0, 0, 0, 0, 0, 0, 1, -l3*p11/p01, -p01/p11, l3),
+        (0, Complement(FiniteSet(p01), FiniteSet(0)), 0, p11, 0, 0, 0, 0, 0, 0, 0, -l2*p11/p01, -l3*p11/p01, l2, l3),
+    )
+    assert sol != nonlinsolve(system, solvefor)
+
+
+def test_issue_20097():
+    assert solveset(1/sqrt(x)) is S.EmptySet
+
+
+def test_issue_15350():
+    assert solveset(diff(sqrt(1/x+x))) == FiniteSet(-1, 1)
+
+
+def test_issue_18359():
+    c1 = Piecewise((0, x < 0), (Min(1, x)/2 - Min(2, x)/2 + Min(3, x)/2, True))
+    c2 = Piecewise((Piecewise((0, x < 0), (Min(1, x)/2 - Min(2, x)/2 + Min(3, x)/2, True)), x >= 0), (0, True))
+    correct_result = Interval(1, 2)
+    result1 = solveset(c1 - Rational(1, 2), x, Interval(0, 3))
+    result2 = solveset(c2 - Rational(1, 2), x, Interval(0, 3))
+    assert result1 == correct_result
+    assert result2 == correct_result
+
+
+def test_issue_17604():
+    lhs = -2**(3*x/11)*exp(x/11) + pi**(x/11)
+    assert _is_exponential(lhs, x)
+    assert _solve_exponential(lhs, 0, x, S.Complexes) == FiniteSet(0)
+
+
+def test_issue_17580():
+    assert solveset(1/(1 - x**3)**2, x, S.Reals) is S.EmptySet
+
+
+def test_issue_17566_actual():
+    sys = [2**x + 2**y - 3, 4**x + 9**y - 5]
+    # Not clear this is the correct result, but at least no recursion error
+    assert nonlinsolve(sys, x, y) == FiniteSet((log(3 - 2**y)/log(2), y))
+
+
+def test_issue_17565():
+    eq = Ge(2*(x - 2)**2/(3*(x + 1)**(Integer(1)/3)) + 2*(x - 2)*(x + 1)**(Integer(2)/3), 0)
+    res = Union(Interval.Lopen(-1, -Rational(1, 4)), Interval(2, oo))
+    assert solveset(eq, x, S.Reals) == res
+
+
+def test_issue_15024():
+    function = (x + 5)/sqrt(-x**2 - 10*x)
+    assert solveset(function, x, S.Reals) == FiniteSet(Integer(-5))
+
+
+def test_issue_16877():
+    assert dumeq(nonlinsolve([x - 1, sin(y)], x, y),
+                 FiniteSet((1, ImageSet(Lambda(n, 2*n*pi), S.Integers)),
+                           (1, ImageSet(Lambda(n, 2*n*pi + pi), S.Integers))))
+    # Even better if (1, ImageSet(Lambda(n, n*pi), S.Integers)) is obtained
+
+
+def test_issue_16876():
+    assert dumeq(nonlinsolve([sin(x), 2*x - 4*y], x, y),
+                 FiniteSet((ImageSet(Lambda(n, 2*n*pi), S.Integers),
+                            ImageSet(Lambda(n, n*pi), S.Integers)),
+                           (ImageSet(Lambda(n, 2*n*pi + pi), S.Integers),
+                            ImageSet(Lambda(n, n*pi + pi/2), S.Integers))))
+    # Even better if (ImageSet(Lambda(n, n*pi), S.Integers),
+    #                 ImageSet(Lambda(n, n*pi/2), S.Integers)) is obtained
+
+def test_issue_21236():
+    x, z = symbols("x z")
+    y = symbols('y', rational=True)
+    assert solveset(x**y - z, x, S.Reals) == ConditionSet(x, Eq(x**y - z, 0), S.Reals)
+    e1, e2 = symbols('e1 e2', even=True)
+    y = e1/e2  # don't know if num or den will be odd and the other even
+    assert solveset(x**y - z, x, S.Reals) == ConditionSet(x, Eq(x**y - z, 0), S.Reals)
+
+
+def test_issue_21908():
+    assert nonlinsolve([(x**2 + 2*x - y**2)*exp(x), -2*y*exp(x)], x, y
+                      ) == {(-2, 0), (0, 0)}
+
+
+def test_issue_19144():
+    # test case 1
+    expr1 = [x + y - 1, y**2 + 1]
+    eq1 = [Eq(i, 0) for i in expr1]
+    soln1 = {(1 - I, I), (1 + I, -I)}
+    soln_expr1 = nonlinsolve(expr1, [x, y])
+    soln_eq1 = nonlinsolve(eq1, [x, y])
+    assert soln_eq1 == soln_expr1 == soln1
+    # test case 2 - with denoms
+    expr2 = [x/y - 1, y**2 + 1]
+    eq2 = [Eq(i, 0) for i in expr2]
+    soln2 = {(-I, -I), (I, I)}
+    soln_expr2 = nonlinsolve(expr2, [x, y])
+    soln_eq2 = nonlinsolve(eq2, [x, y])
+    assert soln_eq2 == soln_expr2 == soln2
+    # denominators that cancel in expression
+    assert nonlinsolve([Eq(x + 1/x, 1/x)], [x]) == FiniteSet((S.EmptySet,))
+
+
+def test_issue_22413():
+    res =  nonlinsolve((4*y*(2*x + 2*exp(y) + 1)*exp(2*x),
+                         4*x*exp(2*x) + 4*y*exp(2*x + y) + 4*exp(2*x + y) + 1),
+                        x, y)
+    # First solution is not correct, but the issue was an exception
+    sols = FiniteSet((x, S.Zero), (-exp(y) - S.Half, y))
+    assert res == sols
+
+
+def test_issue_23318():
+    eqs_eq = [
+        Eq(53.5780461486929, x * log(y / (5.0 - y) + 1) / y),
+        Eq(x, 0.0015 * z),
+        Eq(0.0015, 7845.32 * y / z),
+    ]
+    eqs_expr = [eq.lhs - eq.rhs for eq in eqs_eq]
+
+    sol = {(266.97755814852, 0.0340301680681629, 177985.03876568)}
+
+    assert_close_nl(nonlinsolve(eqs_eq, [x, y, z]), sol)
+    assert_close_nl(nonlinsolve(eqs_expr, [x, y, z]), sol)
+
+    logterm = log(1.91196789933362e-7*z/(5.0 - 1.91196789933362e-7*z) + 1)
+    eq = -0.0015*z*logterm + 1.02439504345316e-5*z
+    assert_close_ss(solveset(eq, z), {0, 177985.038765679})
+
+
+def test_issue_19814():
+    assert nonlinsolve([ 2**m - 2**(2*n), 4*2**m - 2**(4*n)], m, n
+                      ) == FiniteSet((log(2**(2*n))/log(2), S.Complexes))
+
+
+def test_issue_22058():
+    sol = solveset(-sqrt(t)*x**2 + 2*x + sqrt(t), x, S.Reals)
+    # doesn't fail (and following numerical check)
+    assert sol.xreplace({t: 1}) == {1 - sqrt(2), 1 + sqrt(2)}, sol.xreplace({t: 1})
+
+
+def test_issue_11184():
+    assert solveset(20*sqrt(y**2 + (sqrt(-(y - 10)*(y + 10)) + 10)**2) - 60, y, S.Reals) is S.EmptySet
+
+
+def test_issue_21890():
+    e = S(2)/3
+    assert nonlinsolve([4*x**3*y**4 - 2*y, 4*x**4*y**3 - 2*x], x, y) == {
+        (2**e/(2*y), y), ((-2**e/4 - 2**e*sqrt(3)*I/4)/y, y),
+        ((-2**e/4 + 2**e*sqrt(3)*I/4)/y, y)}
+    assert nonlinsolve([(1 - 4*x**2)*exp(-2*x**2 - 2*y**2),
+        -4*x*y*exp(-2*x**2)*exp(-2*y**2)], x, y) == {(-S(1)/2, 0), (S(1)/2, 0)}
+    rx, ry = symbols('x y', real=True)
+    sol = nonlinsolve([4*rx**3*ry**4 - 2*ry, 4*rx**4*ry**3 - 2*rx], rx, ry)
+    ans = {(2**(S(2)/3)/(2*ry), ry),
+        ((-2**(S(2)/3)/4 - 2**(S(2)/3)*sqrt(3)*I/4)/ry, ry),
+        ((-2**(S(2)/3)/4 + 2**(S(2)/3)*sqrt(3)*I/4)/ry, ry)}
+    assert sol == ans
+
+
+def test_issue_22628():
+    assert nonlinsolve([h - 1, k - 1, f - 2, f - 4, -2*k], h, k, f) == S.EmptySet
+    assert nonlinsolve([x**3 - 1, x + y, x**2 - 4], [x, y]) == S.EmptySet
+
+
+def test_issue_25781():
+    assert solve(sqrt(x/2) - x) == [0, S.Half]
+
+
+def test_issue_26077():
+    _n = Symbol('_n')
+    function = x*cot(5*x)
+    critical_points = stationary_points(function, x, S.Reals)
+    excluded_points = Union(
+        ImageSet(Lambda(_n, 2*_n*pi/5), S.Integers),
+        ImageSet(Lambda(_n, 2*_n*pi/5 + pi/5), S.Integers)
+    )
+    solution = ConditionSet(x,
+        Eq(x*(-5*cot(5*x)**2 - 5) + cot(5*x), 0),
+        Complement(S.Reals, excluded_points)
+    )
+    assert solution.as_dummy() == critical_points.as_dummy()
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/__pycache__/__init__.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..159c3d489a3875b5328aa7c6962684a7a46f9593
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/__pycache__/__init__.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/__pycache__/compound_rv.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/__pycache__/compound_rv.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..bb57bf3fc5dabcd48cd7da66b3620131e0965438
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/__pycache__/compound_rv.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/__pycache__/crv.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/__pycache__/crv.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..302336e9739cac1c92a89ffed04985e9bdb67bee
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/__pycache__/crv.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/__pycache__/crv_types.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/__pycache__/crv_types.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..60111eea51a534f35763261efc032a205d72726f
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/__pycache__/crv_types.cpython-312.pyc
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d95cbce706b627b74609256f9e78ac03f45a35a31133932117908d48e4875bdc
+size 167681
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/__pycache__/drv.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/__pycache__/drv.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..eb3c8a930caf5a00efff8f750bf4fa9bc2d91300
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/__pycache__/drv.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/__pycache__/drv_types.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/__pycache__/drv_types.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ccb31aa23576b4d735637dc911ed7006bb123865
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/__pycache__/drv_types.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/__pycache__/error_prop.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/__pycache__/error_prop.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..27af757906b18bd1ea8c76b69fe731adc1f7b581
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/__pycache__/error_prop.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/__pycache__/frv.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/__pycache__/frv.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..bf38f88e588ec7560044f4bba2a4d8588762e253
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/__pycache__/frv.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/__pycache__/frv_types.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/__pycache__/frv_types.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..65853d8a44f460dc3ba0e4441c2891d9055e2fb9
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/__pycache__/frv_types.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/__pycache__/joint_rv.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/__pycache__/joint_rv.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ba80e3aa56371cc66d1e8bd08e689cdd17e787c6
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/__pycache__/joint_rv.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/__pycache__/joint_rv_types.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/__pycache__/joint_rv_types.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..330e0fdf143faea1175655359e0aff9cf790c04c
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/__pycache__/joint_rv_types.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/__pycache__/matrix_distributions.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/__pycache__/matrix_distributions.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..8fc50752570bbe984d3caa57d9f4cef145d2366b
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/__pycache__/matrix_distributions.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/__pycache__/random_matrix.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/__pycache__/random_matrix.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..7d6e8fa7fc8401485f2da148fd5e79306046e28a
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/__pycache__/random_matrix.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/__pycache__/random_matrix_models.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/__pycache__/random_matrix_models.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a07de14ea20b748107ffeaaf22ed2acf8818f12f
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/__pycache__/random_matrix_models.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/__pycache__/rv.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/__pycache__/rv.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..992ecb0d6f1a76ed0b310bce85fb854309214dc8
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/__pycache__/rv.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/__pycache__/rv_interface.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/__pycache__/rv_interface.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..7c302937e71f6ae16ad6b485dc381245fd209c1a
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/__pycache__/rv_interface.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/__pycache__/stochastic_process.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/__pycache__/stochastic_process.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..99c05a59cceea286213b7cf082dbdd0d73f042ac
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/__pycache__/stochastic_process.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/__pycache__/stochastic_process_types.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/__pycache__/stochastic_process_types.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..3a6d1e904a0e1511c9f6718a8d13b44b05936ca9
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/__pycache__/stochastic_process_types.cpython-312.pyc
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e9e1e85c811fef81d6626de1a72be6459da74602f85bea35e4e269c053c2b9ad
+size 112515
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/__pycache__/symbolic_multivariate_probability.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/__pycache__/symbolic_multivariate_probability.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ca113fab7504edd9f7f833acbbfe7ef349e787b8
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/__pycache__/symbolic_multivariate_probability.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/__pycache__/symbolic_probability.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/__pycache__/symbolic_probability.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..025806941350310f2c0cc6870374a1d84ee099c3
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/__pycache__/symbolic_probability.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/sampling/__init__.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/sampling/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/sampling/__pycache__/__init__.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/sampling/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..3dab83f829620b414133d521220bb33208d7afd4
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/sampling/__pycache__/__init__.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/sampling/__pycache__/sample_numpy.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/sampling/__pycache__/sample_numpy.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a1c47e63ee7d42f8c04fc8bcc488a85fe7627ec5
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/sampling/__pycache__/sample_numpy.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/sampling/__pycache__/sample_pymc.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/sampling/__pycache__/sample_pymc.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..7fd63518548b7ccd331a927e058ffea6068b3dcf
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/sampling/__pycache__/sample_pymc.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/sampling/__pycache__/sample_scipy.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/sampling/__pycache__/sample_scipy.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..cf57235447795d3e8cbdd8c154e757054202a7bc
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/sampling/__pycache__/sample_scipy.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/sampling/sample_numpy.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/sampling/sample_numpy.py
new file mode 100644
index 0000000000000000000000000000000000000000..d65417945449ed8b62d2547215d8908f84820a9b
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/sampling/sample_numpy.py
@@ -0,0 +1,105 @@
+from functools import singledispatch
+
+from sympy.external import import_module
+from sympy.stats.crv_types import BetaDistribution, ChiSquaredDistribution, ExponentialDistribution, GammaDistribution, \
+    LogNormalDistribution, NormalDistribution, ParetoDistribution, UniformDistribution, FDistributionDistribution, GumbelDistribution, LaplaceDistribution, \
+    LogisticDistribution, RayleighDistribution, TriangularDistribution
+from sympy.stats.drv_types import GeometricDistribution, PoissonDistribution, ZetaDistribution
+from sympy.stats.frv_types import BinomialDistribution, HypergeometricDistribution
+
+
+numpy = import_module('numpy')
+
+
+@singledispatch
+def do_sample_numpy(dist, size, rand_state):
+    return None
+
+
+# CRV:
+
+@do_sample_numpy.register(BetaDistribution)
+def _(dist: BetaDistribution, size, rand_state):
+    return rand_state.beta(a=float(dist.alpha), b=float(dist.beta), size=size)
+
+
+@do_sample_numpy.register(ChiSquaredDistribution)
+def _(dist: ChiSquaredDistribution, size, rand_state):
+    return rand_state.chisquare(df=float(dist.k), size=size)
+
+
+@do_sample_numpy.register(ExponentialDistribution)
+def _(dist: ExponentialDistribution, size, rand_state):
+    return rand_state.exponential(1 / float(dist.rate), size=size)
+
+@do_sample_numpy.register(FDistributionDistribution)
+def _(dist: FDistributionDistribution, size, rand_state):
+    return rand_state.f(dfnum = float(dist.d1), dfden = float(dist.d2), size=size)
+
+@do_sample_numpy.register(GammaDistribution)
+def _(dist: GammaDistribution, size, rand_state):
+    return rand_state.gamma(shape = float(dist.k), scale = float(dist.theta), size=size)
+
+@do_sample_numpy.register(GumbelDistribution)
+def _(dist: GumbelDistribution, size, rand_state):
+    return rand_state.gumbel(loc = float(dist.mu), scale = float(dist.beta), size=size)
+
+@do_sample_numpy.register(LaplaceDistribution)
+def _(dist: LaplaceDistribution, size, rand_state):
+    return rand_state.laplace(loc = float(dist.mu), scale = float(dist.b), size=size)
+
+@do_sample_numpy.register(LogisticDistribution)
+def _(dist: LogisticDistribution, size, rand_state):
+    return rand_state.logistic(loc = float(dist.mu), scale = float(dist.s), size=size)
+
+@do_sample_numpy.register(LogNormalDistribution)
+def _(dist: LogNormalDistribution, size, rand_state):
+    return rand_state.lognormal(mean = float(dist.mean), sigma = float(dist.std), size=size)
+
+@do_sample_numpy.register(NormalDistribution)
+def _(dist: NormalDistribution, size, rand_state):
+    return rand_state.normal(loc = float(dist.mean), scale = float(dist.std), size=size)
+
+@do_sample_numpy.register(RayleighDistribution)
+def _(dist: RayleighDistribution, size, rand_state):
+    return rand_state.rayleigh(scale = float(dist.sigma), size=size)
+
+@do_sample_numpy.register(ParetoDistribution)
+def _(dist: ParetoDistribution, size, rand_state):
+    return (numpy.random.pareto(a=float(dist.alpha), size=size) + 1) * float(dist.xm)
+
+@do_sample_numpy.register(TriangularDistribution)
+def _(dist: TriangularDistribution, size, rand_state):
+    return rand_state.triangular(left = float(dist.a), mode = float(dist.b), right = float(dist.c), size=size)
+
+@do_sample_numpy.register(UniformDistribution)
+def _(dist: UniformDistribution, size, rand_state):
+    return rand_state.uniform(low=float(dist.left), high=float(dist.right), size=size)
+
+
+# DRV:
+
+@do_sample_numpy.register(GeometricDistribution)
+def _(dist: GeometricDistribution, size, rand_state):
+    return rand_state.geometric(p=float(dist.p), size=size)
+
+
+@do_sample_numpy.register(PoissonDistribution)
+def _(dist: PoissonDistribution, size, rand_state):
+    return rand_state.poisson(lam=float(dist.lamda), size=size)
+
+
+@do_sample_numpy.register(ZetaDistribution)
+def _(dist: ZetaDistribution, size, rand_state):
+    return rand_state.zipf(a=float(dist.s), size=size)
+
+
+# FRV:
+
+@do_sample_numpy.register(BinomialDistribution)
+def _(dist: BinomialDistribution, size, rand_state):
+    return rand_state.binomial(n=int(dist.n), p=float(dist.p), size=size)
+
+@do_sample_numpy.register(HypergeometricDistribution)
+def _(dist: HypergeometricDistribution, size, rand_state):
+    return rand_state.hypergeometric(ngood = int(dist.N), nbad = int(dist.m), nsample = int(dist.n), size=size)
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/sampling/sample_pymc.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/sampling/sample_pymc.py
new file mode 100644
index 0000000000000000000000000000000000000000..546f02a3092815af2e54b4a164463f62ece7a024
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/sampling/sample_pymc.py
@@ -0,0 +1,99 @@
+from functools import singledispatch
+from sympy.external import import_module
+from sympy.stats.crv_types import BetaDistribution, CauchyDistribution, ChiSquaredDistribution, ExponentialDistribution, \
+    GammaDistribution, LogNormalDistribution, NormalDistribution, ParetoDistribution, UniformDistribution, \
+    GaussianInverseDistribution
+from sympy.stats.drv_types import PoissonDistribution, GeometricDistribution, NegativeBinomialDistribution
+from sympy.stats.frv_types import BinomialDistribution, BernoulliDistribution
+
+
+try:
+    import pymc
+except ImportError:
+    pymc = import_module('pymc3')
+
+@singledispatch
+def do_sample_pymc(dist):
+    return None
+
+
+# CRV:
+
+@do_sample_pymc.register(BetaDistribution)
+def _(dist: BetaDistribution):
+    return pymc.Beta('X', alpha=float(dist.alpha), beta=float(dist.beta))
+
+
+@do_sample_pymc.register(CauchyDistribution)
+def _(dist: CauchyDistribution):
+    return pymc.Cauchy('X', alpha=float(dist.x0), beta=float(dist.gamma))
+
+
+@do_sample_pymc.register(ChiSquaredDistribution)
+def _(dist: ChiSquaredDistribution):
+    return pymc.ChiSquared('X', nu=float(dist.k))
+
+
+@do_sample_pymc.register(ExponentialDistribution)
+def _(dist: ExponentialDistribution):
+    return pymc.Exponential('X', lam=float(dist.rate))
+
+
+@do_sample_pymc.register(GammaDistribution)
+def _(dist: GammaDistribution):
+    return pymc.Gamma('X', alpha=float(dist.k), beta=1 / float(dist.theta))
+
+
+@do_sample_pymc.register(LogNormalDistribution)
+def _(dist: LogNormalDistribution):
+    return pymc.Lognormal('X', mu=float(dist.mean), sigma=float(dist.std))
+
+
+@do_sample_pymc.register(NormalDistribution)
+def _(dist: NormalDistribution):
+    return pymc.Normal('X', float(dist.mean), float(dist.std))
+
+
+@do_sample_pymc.register(GaussianInverseDistribution)
+def _(dist: GaussianInverseDistribution):
+    return pymc.Wald('X', mu=float(dist.mean), lam=float(dist.shape))
+
+
+@do_sample_pymc.register(ParetoDistribution)
+def _(dist: ParetoDistribution):
+    return pymc.Pareto('X', alpha=float(dist.alpha), m=float(dist.xm))
+
+
+@do_sample_pymc.register(UniformDistribution)
+def _(dist: UniformDistribution):
+    return pymc.Uniform('X', lower=float(dist.left), upper=float(dist.right))
+
+
+# DRV:
+
+@do_sample_pymc.register(GeometricDistribution)
+def _(dist: GeometricDistribution):
+    return pymc.Geometric('X', p=float(dist.p))
+
+
+@do_sample_pymc.register(NegativeBinomialDistribution)
+def _(dist: NegativeBinomialDistribution):
+    return pymc.NegativeBinomial('X', mu=float((dist.p * dist.r) / (1 - dist.p)),
+                                  alpha=float(dist.r))
+
+
+@do_sample_pymc.register(PoissonDistribution)
+def _(dist: PoissonDistribution):
+    return pymc.Poisson('X', mu=float(dist.lamda))
+
+
+# FRV:
+
+@do_sample_pymc.register(BernoulliDistribution)
+def _(dist: BernoulliDistribution):
+    return pymc.Bernoulli('X', p=float(dist.p))
+
+
+@do_sample_pymc.register(BinomialDistribution)
+def _(dist: BinomialDistribution):
+    return pymc.Binomial('X', n=int(dist.n), p=float(dist.p))
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/sampling/sample_scipy.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/sampling/sample_scipy.py
new file mode 100644
index 0000000000000000000000000000000000000000..f12508f68844488e9a14b1476005164eb422796e
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/sampling/sample_scipy.py
@@ -0,0 +1,167 @@
+from functools import singledispatch
+
+from sympy.core.symbol import Dummy
+from sympy.functions.elementary.exponential import exp
+from sympy.utilities.lambdify import lambdify
+from sympy.external import import_module
+from sympy.stats import DiscreteDistributionHandmade
+from sympy.stats.crv import SingleContinuousDistribution
+from sympy.stats.crv_types import ChiSquaredDistribution, ExponentialDistribution, GammaDistribution, \
+    LogNormalDistribution, NormalDistribution, ParetoDistribution, UniformDistribution, BetaDistribution, \
+    StudentTDistribution, CauchyDistribution
+from sympy.stats.drv_types import GeometricDistribution, LogarithmicDistribution, NegativeBinomialDistribution, \
+    PoissonDistribution, SkellamDistribution, YuleSimonDistribution, ZetaDistribution
+from sympy.stats.frv import SingleFiniteDistribution
+
+
+scipy = import_module("scipy", import_kwargs={'fromlist':['stats']})
+
+
+@singledispatch
+def do_sample_scipy(dist, size, seed):
+    return None
+
+
+# CRV
+
+@do_sample_scipy.register(SingleContinuousDistribution)
+def _(dist: SingleContinuousDistribution, size, seed):
+    # if we don't need to make a handmade pdf, we won't
+    import scipy.stats
+
+    z = Dummy('z')
+    handmade_pdf = lambdify(z, dist.pdf(z), ['numpy', 'scipy'])
+
+    class scipy_pdf(scipy.stats.rv_continuous):
+        def _pdf(dist, x):
+            return handmade_pdf(x)
+
+    scipy_rv = scipy_pdf(a=float(dist.set._inf),
+                         b=float(dist.set._sup), name='scipy_pdf')
+    return scipy_rv.rvs(size=size, random_state=seed)
+
+
+@do_sample_scipy.register(ChiSquaredDistribution)
+def _(dist: ChiSquaredDistribution, size, seed):
+    # same parametrisation
+    return scipy.stats.chi2.rvs(df=float(dist.k), size=size, random_state=seed)
+
+
+@do_sample_scipy.register(ExponentialDistribution)
+def _(dist: ExponentialDistribution, size, seed):
+    # https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.expon.html#scipy.stats.expon
+    return scipy.stats.expon.rvs(scale=1 / float(dist.rate), size=size, random_state=seed)
+
+
+@do_sample_scipy.register(GammaDistribution)
+def _(dist: GammaDistribution, size, seed):
+    # https://stackoverflow.com/questions/42150965/how-to-plot-gamma-distribution-with-alpha-and-beta-parameters-in-python
+    return scipy.stats.gamma.rvs(a=float(dist.k), scale=float(dist.theta), size=size, random_state=seed)
+
+
+@do_sample_scipy.register(LogNormalDistribution)
+def _(dist: LogNormalDistribution, size, seed):
+    # https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.lognorm.html
+    return scipy.stats.lognorm.rvs(scale=float(exp(dist.mean)), s=float(dist.std), size=size, random_state=seed)
+
+
+@do_sample_scipy.register(NormalDistribution)
+def _(dist: NormalDistribution, size, seed):
+    return scipy.stats.norm.rvs(loc=float(dist.mean), scale=float(dist.std), size=size, random_state=seed)
+
+
+@do_sample_scipy.register(ParetoDistribution)
+def _(dist: ParetoDistribution, size, seed):
+    # https://stackoverflow.com/questions/42260519/defining-pareto-distribution-in-python-scipy
+    return scipy.stats.pareto.rvs(b=float(dist.alpha), scale=float(dist.xm), size=size, random_state=seed)
+
+
+@do_sample_scipy.register(StudentTDistribution)
+def _(dist: StudentTDistribution, size, seed):
+    return scipy.stats.t.rvs(df=float(dist.nu), size=size, random_state=seed)
+
+
+@do_sample_scipy.register(UniformDistribution)
+def _(dist: UniformDistribution, size, seed):
+    # https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.uniform.html
+    return scipy.stats.uniform.rvs(loc=float(dist.left), scale=float(dist.right - dist.left), size=size, random_state=seed)
+
+
+@do_sample_scipy.register(BetaDistribution)
+def _(dist: BetaDistribution, size, seed):
+    # same parametrisation
+    return scipy.stats.beta.rvs(a=float(dist.alpha), b=float(dist.beta), size=size, random_state=seed)
+
+
+@do_sample_scipy.register(CauchyDistribution)
+def _(dist: CauchyDistribution, size, seed):
+    return scipy.stats.cauchy.rvs(loc=float(dist.x0), scale=float(dist.gamma), size=size, random_state=seed)
+
+
+# DRV:
+
+@do_sample_scipy.register(DiscreteDistributionHandmade)
+def _(dist: DiscreteDistributionHandmade, size, seed):
+    from scipy.stats import rv_discrete
+
+    z = Dummy('z')
+    handmade_pmf = lambdify(z, dist.pdf(z), ['numpy', 'scipy'])
+
+    class scipy_pmf(rv_discrete):
+        def _pmf(dist, x):
+            return handmade_pmf(x)
+
+    scipy_rv = scipy_pmf(a=float(dist.set._inf), b=float(dist.set._sup),
+                         name='scipy_pmf')
+    return scipy_rv.rvs(size=size, random_state=seed)
+
+
+@do_sample_scipy.register(GeometricDistribution)
+def _(dist: GeometricDistribution, size, seed):
+    return scipy.stats.geom.rvs(p=float(dist.p), size=size, random_state=seed)
+
+
+@do_sample_scipy.register(LogarithmicDistribution)
+def _(dist: LogarithmicDistribution, size, seed):
+    return scipy.stats.logser.rvs(p=float(dist.p), size=size, random_state=seed)
+
+
+@do_sample_scipy.register(NegativeBinomialDistribution)
+def _(dist: NegativeBinomialDistribution, size, seed):
+    return scipy.stats.nbinom.rvs(n=float(dist.r), p=float(dist.p), size=size, random_state=seed)
+
+
+@do_sample_scipy.register(PoissonDistribution)
+def _(dist: PoissonDistribution, size, seed):
+    return scipy.stats.poisson.rvs(mu=float(dist.lamda), size=size, random_state=seed)
+
+
+@do_sample_scipy.register(SkellamDistribution)
+def _(dist: SkellamDistribution, size, seed):
+    return scipy.stats.skellam.rvs(mu1=float(dist.mu1), mu2=float(dist.mu2), size=size, random_state=seed)
+
+
+@do_sample_scipy.register(YuleSimonDistribution)
+def _(dist: YuleSimonDistribution, size, seed):
+    return scipy.stats.yulesimon.rvs(alpha=float(dist.rho), size=size, random_state=seed)
+
+
+@do_sample_scipy.register(ZetaDistribution)
+def _(dist: ZetaDistribution, size, seed):
+    return scipy.stats.zipf.rvs(a=float(dist.s), size=size, random_state=seed)
+
+
+# FRV:
+
+@do_sample_scipy.register(SingleFiniteDistribution)
+def _(dist: SingleFiniteDistribution, size, seed):
+    # scipy can handle with custom distributions
+
+    from scipy.stats import rv_discrete
+    density_ = dist.dict
+    x, y = [], []
+    for k, v in density_.items():
+        x.append(int(k))
+        y.append(float(v))
+    scipy_rv = rv_discrete(name='scipy_rv', values=(x, y))
+    return scipy_rv.rvs(size=size, random_state=seed)
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/sampling/tests/__init__.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/sampling/tests/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/sampling/tests/__pycache__/__init__.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/sampling/tests/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..661d1ffac4be6a2a9dd203a32e308646c0a975c8
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/sampling/tests/__pycache__/__init__.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/sampling/tests/__pycache__/test_sample_continuous_rv.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/sampling/tests/__pycache__/test_sample_continuous_rv.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..e6cd15d904c5b8623f6416c1b9085a1f09a78efa
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/sampling/tests/__pycache__/test_sample_continuous_rv.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/sampling/tests/__pycache__/test_sample_discrete_rv.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/sampling/tests/__pycache__/test_sample_discrete_rv.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..9152436d84c53598830c28d3b7a47f2fefe9ccc2
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/sampling/tests/__pycache__/test_sample_discrete_rv.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/sampling/tests/__pycache__/test_sample_finite_rv.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/sampling/tests/__pycache__/test_sample_finite_rv.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b8684b335727a284d7941c3113b8f891800c02d1
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/sampling/tests/__pycache__/test_sample_finite_rv.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/sampling/tests/test_sample_continuous_rv.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/sampling/tests/test_sample_continuous_rv.py
new file mode 100644
index 0000000000000000000000000000000000000000..953bb602df5e63da2882ee118de9dbf24b6f7804
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/sampling/tests/test_sample_continuous_rv.py
@@ -0,0 +1,181 @@
+from sympy.core.numbers import oo
+from sympy.core.symbol import Symbol
+from sympy.functions.elementary.exponential import exp
+from sympy.sets.sets import Interval
+from sympy.external import import_module
+from sympy.stats import Beta, Chi, Normal, Gamma, Exponential, LogNormal, Pareto, ChiSquared, Uniform, sample, \
+    BetaPrime, Cauchy, GammaInverse, GaussianInverse, StudentT, Weibull, density, ContinuousRV, FDistribution, \
+    Gumbel, Laplace, Logistic, Rayleigh, Triangular
+from sympy.testing.pytest import skip, raises
+
+
+def test_sample_numpy():
+    distribs_numpy = [
+        Beta("B", 1, 1),
+        Normal("N", 0, 1),
+        Gamma("G", 2, 7),
+        Exponential("E", 2),
+        LogNormal("LN", 0, 1),
+        Pareto("P", 1, 1),
+        ChiSquared("CS", 2),
+        Uniform("U", 0, 1),
+        FDistribution("FD", 1, 2),
+        Gumbel("GB", 1, 2),
+        Laplace("L", 1, 2),
+        Logistic("LO", 1, 2),
+        Rayleigh("R", 1),
+        Triangular("T", 1, 2, 2),
+    ]
+    size = 3
+    numpy = import_module('numpy')
+    if not numpy:
+        skip('Numpy is not installed. Abort tests for _sample_numpy.')
+    else:
+        for X in distribs_numpy:
+            samps = sample(X, size=size, library='numpy')
+            for sam in samps:
+                assert sam in X.pspace.domain.set
+        raises(NotImplementedError,
+               lambda: sample(Chi("C", 1), library='numpy'))
+    raises(NotImplementedError,
+           lambda: Chi("C", 1).pspace.distribution.sample(library='tensorflow'))
+
+
+def test_sample_scipy():
+    distribs_scipy = [
+        Beta("B", 1, 1),
+        BetaPrime("BP", 1, 1),
+        Cauchy("C", 1, 1),
+        Chi("C", 1),
+        Normal("N", 0, 1),
+        Gamma("G", 2, 7),
+        GammaInverse("GI", 1, 1),
+        GaussianInverse("GUI", 1, 1),
+        Exponential("E", 2),
+        LogNormal("LN", 0, 1),
+        Pareto("P", 1, 1),
+        StudentT("S", 2),
+        ChiSquared("CS", 2),
+        Uniform("U", 0, 1)
+    ]
+    size = 3
+    scipy = import_module('scipy')
+    if not scipy:
+        skip('Scipy is not installed. Abort tests for _sample_scipy.')
+    else:
+        for X in distribs_scipy:
+            samps = sample(X, size=size, library='scipy')
+            samps2 = sample(X, size=(2, 2), library='scipy')
+            for sam in samps:
+                assert sam in X.pspace.domain.set
+            for i in range(2):
+                for j in range(2):
+                    assert samps2[i][j] in X.pspace.domain.set
+
+
+def test_sample_pymc():
+    distribs_pymc = [
+        Beta("B", 1, 1),
+        Cauchy("C", 1, 1),
+        Normal("N", 0, 1),
+        Gamma("G", 2, 7),
+        GaussianInverse("GI", 1, 1),
+        Exponential("E", 2),
+        LogNormal("LN", 0, 1),
+        Pareto("P", 1, 1),
+        ChiSquared("CS", 2),
+        Uniform("U", 0, 1)
+    ]
+    size = 3
+    pymc = import_module('pymc')
+    if not pymc:
+        skip('PyMC is not installed. Abort tests for _sample_pymc.')
+    else:
+        for X in distribs_pymc:
+            samps = sample(X, size=size, library='pymc')
+            for sam in samps:
+                assert sam in X.pspace.domain.set
+        raises(NotImplementedError,
+               lambda: sample(Chi("C", 1), library='pymc'))
+
+
+def test_sampling_gamma_inverse():
+    scipy = import_module('scipy')
+    if not scipy:
+        skip('Scipy not installed. Abort tests for sampling of gamma inverse.')
+    X = GammaInverse("x", 1, 1)
+    assert sample(X) in X.pspace.domain.set
+
+
+def test_lognormal_sampling():
+    # Right now, only density function and sampling works
+    scipy = import_module('scipy')
+    if not scipy:
+        skip('Scipy is not installed. Abort tests')
+    for i in range(3):
+        X = LogNormal('x', i, 1)
+        assert sample(X) in X.pspace.domain.set
+
+    size = 5
+    samps = sample(X, size=size)
+    for samp in samps:
+        assert samp in X.pspace.domain.set
+
+
+def test_sampling_gaussian_inverse():
+    scipy = import_module('scipy')
+    if not scipy:
+        skip('Scipy not installed. Abort tests for sampling of Gaussian inverse.')
+    X = GaussianInverse("x", 1, 1)
+    assert sample(X, library='scipy') in X.pspace.domain.set
+
+
+def test_prefab_sampling():
+    scipy = import_module('scipy')
+    if not scipy:
+        skip('Scipy is not installed. Abort tests')
+    N = Normal('X', 0, 1)
+    L = LogNormal('L', 0, 1)
+    E = Exponential('Ex', 1)
+    P = Pareto('P', 1, 3)
+    W = Weibull('W', 1, 1)
+    U = Uniform('U', 0, 1)
+    B = Beta('B', 2, 5)
+    G = Gamma('G', 1, 3)
+
+    variables = [N, L, E, P, W, U, B, G]
+    niter = 10
+    size = 5
+    for var in variables:
+        for _ in range(niter):
+            assert sample(var) in var.pspace.domain.set
+            samps = sample(var, size=size)
+            for samp in samps:
+                assert samp in var.pspace.domain.set
+
+
+def test_sample_continuous():
+    z = Symbol('z')
+    Z = ContinuousRV(z, exp(-z), set=Interval(0, oo))
+    assert density(Z)(-1) == 0
+
+    scipy = import_module('scipy')
+    if not scipy:
+        skip('Scipy is not installed. Abort tests')
+    assert sample(Z) in Z.pspace.domain.set
+    sym, val = list(Z.pspace.sample().items())[0]
+    assert sym == Z and val in Interval(0, oo)
+
+    libraries = ['scipy', 'numpy', 'pymc']
+    for lib in libraries:
+        try:
+            imported_lib = import_module(lib)
+            if imported_lib:
+                s0, s1, s2 = [], [], []
+                s0 = sample(Z, size=10, library=lib, seed=0)
+                s1 = sample(Z, size=10, library=lib, seed=0)
+                s2 = sample(Z, size=10, library=lib, seed=1)
+                assert all(s0 == s1)
+                assert all(s1 != s2)
+        except NotImplementedError:
+            continue
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/sampling/tests/test_sample_discrete_rv.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/sampling/tests/test_sample_discrete_rv.py
new file mode 100644
index 0000000000000000000000000000000000000000..90d385cd599222fd7da7c1559b619bafbeb01831
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/sampling/tests/test_sample_discrete_rv.py
@@ -0,0 +1,109 @@
+from sympy.core.singleton import S
+from sympy.core.symbol import Symbol
+from sympy.external import import_module
+from sympy.stats import (
+    Geometric,
+    Poisson,
+    Zeta,
+    sample,
+    Skellam,
+    Logarithmic,
+    NegativeBinomial,
+    YuleSimon,
+    DiscreteRV,
+)
+from sympy.testing.pytest import skip, raises, slow
+
+
+def test_sample_numpy():
+    distribs_numpy = [
+        Geometric('G', 0.5),
+        Poisson('P', 1),
+        Zeta('Z', 2)
+    ]
+    size = 3
+    numpy = import_module('numpy')
+    if not numpy:
+        skip('Numpy is not installed. Abort tests for _sample_numpy.')
+    else:
+        for X in distribs_numpy:
+            samps = sample(X, size=size, library='numpy')
+            for sam in samps:
+                assert sam in X.pspace.domain.set
+        raises(NotImplementedError,
+               lambda: sample(Skellam('S', 1, 1), library='numpy'))
+    raises(NotImplementedError,
+           lambda: Skellam('S', 1, 1).pspace.distribution.sample(library='tensorflow'))
+
+
+def test_sample_scipy():
+    p = S(2)/3
+    x = Symbol('x', integer=True, positive=True)
+    pdf = p*(1 - p)**(x - 1) # pdf of Geometric Distribution
+    distribs_scipy = [
+        DiscreteRV(x, pdf, set=S.Naturals),
+        Geometric('G', 0.5),
+        Logarithmic('L', 0.5),
+        NegativeBinomial('N', 5, 0.4),
+        Poisson('P', 1),
+        Skellam('S', 1, 1),
+        YuleSimon('Y', 1),
+        Zeta('Z', 2)
+    ]
+    size = 3
+    scipy = import_module('scipy')
+    if not scipy:
+        skip('Scipy is not installed. Abort tests for _sample_scipy.')
+    else:
+        for X in distribs_scipy:
+            samps = sample(X, size=size, library='scipy')
+            samps2 = sample(X, size=(2, 2), library='scipy')
+            for sam in samps:
+                assert sam in X.pspace.domain.set
+            for i in range(2):
+                for j in range(2):
+                    assert samps2[i][j] in X.pspace.domain.set
+
+
+def test_sample_pymc():
+    distribs_pymc = [
+        Geometric('G', 0.5),
+        Poisson('P', 1),
+        NegativeBinomial('N', 5, 0.4)
+    ]
+    size = 3
+    pymc = import_module('pymc')
+    if not pymc:
+        skip('PyMC is not installed. Abort tests for _sample_pymc.')
+    else:
+        for X in distribs_pymc:
+            samps = sample(X, size=size, library='pymc')
+            for sam in samps:
+                assert sam in X.pspace.domain.set
+        raises(NotImplementedError,
+               lambda: sample(Skellam('S', 1, 1), library='pymc'))
+
+@slow
+def test_sample_discrete():
+    X = Geometric('X', S.Half)
+    scipy = import_module('scipy')
+    if not scipy:
+        skip('Scipy not installed. Abort tests')
+    assert sample(X) in X.pspace.domain.set
+    samps = sample(X, size=2) # This takes long time if ran without scipy
+    for samp in samps:
+        assert samp in X.pspace.domain.set
+
+    libraries = ['scipy', 'numpy', 'pymc']
+    for lib in libraries:
+        try:
+            imported_lib = import_module(lib)
+            if imported_lib:
+                s0, s1, s2 = [], [], []
+                s0 = sample(X, size=10, library=lib, seed=0)
+                s1 = sample(X, size=10, library=lib, seed=0)
+                s2 = sample(X, size=10, library=lib, seed=1)
+                assert all(s0 == s1)
+                assert not all(s1 == s2)
+        except NotImplementedError:
+            continue
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/sampling/tests/test_sample_finite_rv.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/sampling/tests/test_sample_finite_rv.py
new file mode 100644
index 0000000000000000000000000000000000000000..96cabe0ff4aaa5977e16600217fbbdeb08b962ae
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/sampling/tests/test_sample_finite_rv.py
@@ -0,0 +1,94 @@
+from sympy.core.numbers import Rational
+from sympy.core.singleton import S
+from sympy.external import import_module
+from sympy.stats import Binomial, sample, Die, FiniteRV, DiscreteUniform, Bernoulli, BetaBinomial, Hypergeometric, \
+    Rademacher
+from sympy.testing.pytest import skip, raises
+
+def test_given_sample():
+    X = Die('X', 6)
+    scipy = import_module('scipy')
+    if not scipy:
+        skip('Scipy is not installed. Abort tests')
+    assert sample(X, X > 5) == 6
+
+def test_sample_numpy():
+    distribs_numpy = [
+        Binomial("B", 5, 0.4),
+        Hypergeometric("H", 2, 1, 1)
+    ]
+    size = 3
+    numpy = import_module('numpy')
+    if not numpy:
+        skip('Numpy is not installed. Abort tests for _sample_numpy.')
+    else:
+        for X in distribs_numpy:
+            samps = sample(X, size=size, library='numpy')
+            for sam in samps:
+                assert sam in X.pspace.domain.set
+        raises(NotImplementedError,
+               lambda: sample(Die("D"), library='numpy'))
+    raises(NotImplementedError,
+           lambda: Die("D").pspace.sample(library='tensorflow'))
+
+
+def test_sample_scipy():
+    distribs_scipy = [
+        FiniteRV('F', {1: S.Half, 2: Rational(1, 4), 3: Rational(1, 4)}),
+        DiscreteUniform("Y", list(range(5))),
+        Die("D"),
+        Bernoulli("Be", 0.3),
+        Binomial("Bi", 5, 0.4),
+        BetaBinomial("Bb", 2, 1, 1),
+        Hypergeometric("H", 1, 1, 1),
+        Rademacher("R")
+    ]
+
+    size = 3
+    scipy = import_module('scipy')
+    if not scipy:
+        skip('Scipy not installed. Abort tests for _sample_scipy.')
+    else:
+        for X in distribs_scipy:
+            samps = sample(X, size=size)
+            samps2 = sample(X, size=(2, 2))
+            for sam in samps:
+                assert sam in X.pspace.domain.set
+            for i in range(2):
+                for j in range(2):
+                    assert samps2[i][j] in X.pspace.domain.set
+
+
+def test_sample_pymc():
+    distribs_pymc = [
+        Bernoulli('B', 0.2),
+        Binomial('N', 5, 0.4)
+    ]
+    size = 3
+    pymc = import_module('pymc')
+    if not pymc:
+        skip('PyMC is not installed. Abort tests for _sample_pymc.')
+    else:
+        for X in distribs_pymc:
+            samps = sample(X, size=size, library='pymc')
+            for sam in samps:
+                assert sam in X.pspace.domain.set
+        raises(NotImplementedError,
+                          lambda: (sample(Die("D"), library='pymc')))
+
+
+def test_sample_seed():
+    F = FiniteRV('F', {1: S.Half, 2: Rational(1, 4), 3: Rational(1, 4)})
+    size = 10
+    libraries = ['scipy', 'numpy', 'pymc']
+    for lib in libraries:
+        try:
+            imported_lib = import_module(lib)
+            if imported_lib:
+                s0 = sample(F, size=size, library=lib, seed=0)
+                s1 = sample(F, size=size, library=lib, seed=0)
+                s2 = sample(F, size=size, library=lib, seed=1)
+                assert all(s0 == s1)
+                assert not all(s1 == s2)
+        except NotImplementedError:
+            continue
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/tests/__init__.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/tests/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/tests/__pycache__/__init__.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/tests/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..0d3962cc04a653082abecfaa5262546aa5caae1b
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/tests/__pycache__/__init__.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/tests/__pycache__/test_compound_rv.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/tests/__pycache__/test_compound_rv.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..98f263d3dd22a284632793045d0e690adaf12274
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/tests/__pycache__/test_compound_rv.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/tests/__pycache__/test_continuous_rv.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/tests/__pycache__/test_continuous_rv.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..74915768b7d82e86dee61f1a7f9352751affd95d
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/tests/__pycache__/test_continuous_rv.cpython-312.pyc
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b78d948e50b79978e1f6da3a29a5584ff0f1763e5eece02868c50c5ad2c8d5f3
+size 125809
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/tests/__pycache__/test_discrete_rv.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/tests/__pycache__/test_discrete_rv.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5a0056843c301be145901f72452cb8e510b311da
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/tests/__pycache__/test_discrete_rv.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/tests/__pycache__/test_error_prop.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/tests/__pycache__/test_error_prop.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..29e8251e6f89be3b4b775c4b86d123c860a22e6c
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/tests/__pycache__/test_error_prop.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/tests/__pycache__/test_finite_rv.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/tests/__pycache__/test_finite_rv.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..9d38e4fc4febed1e71c3fd0521873722f0666585
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/tests/__pycache__/test_finite_rv.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/tests/__pycache__/test_joint_rv.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/tests/__pycache__/test_joint_rv.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..2cbf4730b0ff2795164adb0c16eb62aeb361b967
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/tests/__pycache__/test_joint_rv.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/tests/__pycache__/test_matrix_distributions.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/tests/__pycache__/test_matrix_distributions.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..2ad157cb5da98ce7adcb0f4418859e3f3d1050fb
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/tests/__pycache__/test_matrix_distributions.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/tests/__pycache__/test_mix.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/tests/__pycache__/test_mix.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5c84f2faf644109de4d45ffee25e8d7f417fc230
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/tests/__pycache__/test_mix.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/tests/__pycache__/test_random_matrix.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/tests/__pycache__/test_random_matrix.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..58fa27ea59f6e9eddbf9f372b4ad7e936d0fa5d1
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/tests/__pycache__/test_random_matrix.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/tests/__pycache__/test_rv.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/tests/__pycache__/test_rv.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..7b7b64c8c57bfbbe6d64f371774b0e2e980866dc
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/tests/__pycache__/test_rv.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/tests/__pycache__/test_stochastic_process.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/tests/__pycache__/test_stochastic_process.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..1d8e515b9061424063b1a6213fa20df414ba1e32
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/tests/__pycache__/test_stochastic_process.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/tests/__pycache__/test_symbolic_multivariate.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/tests/__pycache__/test_symbolic_multivariate.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..fad5ac0104c93f922aea33c2aafd7fe9f929a195
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/tests/__pycache__/test_symbolic_multivariate.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/tests/__pycache__/test_symbolic_probability.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/tests/__pycache__/test_symbolic_probability.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..18c9760f3719d5512c3e988b1a5da21c9f330977
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/tests/__pycache__/test_symbolic_probability.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/tests/test_compound_rv.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/tests/test_compound_rv.py
new file mode 100644
index 0000000000000000000000000000000000000000..573ba364b686738e56bb1c4615acd2a9bc8bf3ae
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/tests/test_compound_rv.py
@@ -0,0 +1,159 @@
+from sympy.concrete.summations import Sum
+from sympy.core.numbers import (oo, pi)
+from sympy.core.relational import Eq
+from sympy.core.singleton import S
+from sympy.core.symbol import symbols
+from sympy.functions.combinatorial.factorials import factorial
+from sympy.functions.elementary.exponential import exp
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.piecewise import Piecewise
+from sympy.functions.special.beta_functions import beta
+from sympy.functions.special.error_functions import erf
+from sympy.functions.special.gamma_functions import gamma
+from sympy.integrals.integrals import Integral
+from sympy.sets.sets import Interval
+from sympy.stats import (Normal, P, E, density, Gamma, Poisson, Rayleigh,
+                        variance, Bernoulli, Beta, Uniform, cdf)
+from sympy.stats.compound_rv import CompoundDistribution, CompoundPSpace
+from sympy.stats.crv_types import NormalDistribution
+from sympy.stats.drv_types import PoissonDistribution
+from sympy.stats.frv_types import BernoulliDistribution
+from sympy.testing.pytest import raises, ignore_warnings
+from sympy.stats.joint_rv_types import MultivariateNormalDistribution
+
+from sympy.abc import x
+
+
+# helpers for testing troublesome unevaluated expressions
+flat = lambda s: ''.join(str(s).split())
+streq = lambda *a: len(set(map(flat, a))) == 1
+assert streq(x, x)
+assert streq(x, 'x')
+assert not streq(x, x + 1)
+
+
+def test_normal_CompoundDist():
+    X = Normal('X', 1, 2)
+    Y = Normal('X', X, 4)
+    assert density(Y)(x).simplify() == sqrt(10)*exp(-x**2/40 + x/20 - S(1)/40)/(20*sqrt(pi))
+    assert E(Y) == 1 # it is always equal to mean of X
+    assert P(Y > 1) == S(1)/2 # as 1 is the mean
+    assert P(Y > 5).simplify() ==  S(1)/2 - erf(sqrt(10)/5)/2
+    assert variance(Y) == variance(X) + 4**2 # 2**2 + 4**2
+    # https://math.stackexchange.com/questions/1484451/
+    # (Contains proof of E and variance computation)
+
+
+def test_poisson_CompoundDist():
+    k, t, y = symbols('k t y', positive=True, real=True)
+    G = Gamma('G', k, t)
+    D = Poisson('P', G)
+    assert density(D)(y).simplify() == t**y*(t + 1)**(-k - y)*gamma(k + y)/(gamma(k)*gamma(y + 1))
+    # https://en.wikipedia.org/wiki/Negative_binomial_distribution#Gamma%E2%80%93Poisson_mixture
+    assert E(D).simplify() == k*t # mean of NegativeBinomialDistribution
+
+
+def test_bernoulli_CompoundDist():
+    X = Beta('X', 1, 2)
+    Y = Bernoulli('Y', X)
+    assert density(Y).dict == {0: S(2)/3, 1: S(1)/3}
+    assert E(Y) == P(Eq(Y, 1)) == S(1)/3
+    assert variance(Y) == S(2)/9
+    assert cdf(Y) == {0: S(2)/3, 1: 1}
+
+    # test issue 8128
+    a = Bernoulli('a', S(1)/2)
+    b = Bernoulli('b', a)
+    assert density(b).dict == {0: S(1)/2, 1: S(1)/2}
+    assert P(b > 0.5) == S(1)/2
+
+    X = Uniform('X', 0, 1)
+    Y = Bernoulli('Y', X)
+    assert E(Y) == S(1)/2
+    assert P(Eq(Y, 1)) == E(Y)
+
+
+def test_unevaluated_CompoundDist():
+    # these tests need to be removed once they work with evaluation as they are currently not
+    # evaluated completely in sympy.
+    R = Rayleigh('R', 4)
+    X = Normal('X', 3, R)
+    ans = '''
+        Piecewise(((-sqrt(pi)*sinh(x/4 - 3/4) + sqrt(pi)*cosh(x/4 - 3/4))/(
+        8*sqrt(pi)), Abs(arg(x - 3)) <= pi/4), (Integral(sqrt(2)*exp(-(x - 3)
+        **2/(2*R**2))*exp(-R**2/32)/(32*sqrt(pi)), (R, 0, oo)), True))'''
+    assert streq(density(X)(x), ans)
+
+    expre = '''
+        Integral(X*Integral(sqrt(2)*exp(-(X-3)**2/(2*R**2))*exp(-R**2/32)/(32*
+        sqrt(pi)),(R,0,oo)),(X,-oo,oo))'''
+    with ignore_warnings(UserWarning): ### TODO: Restore tests once warnings are removed
+        assert streq(E(X, evaluate=False).rewrite(Integral), expre)
+
+    X = Poisson('X', 1)
+    Y = Poisson('Y', X)
+    Z = Poisson('Z', Y)
+    exprd = Sum(exp(-Y)*Y**x*Sum(exp(-1)*exp(-X)*X**Y/(factorial(X)*factorial(Y)
+                ), (X, 0, oo))/factorial(x), (Y, 0, oo))
+    assert density(Z)(x) == exprd
+
+    N = Normal('N', 1, 2)
+    M = Normal('M', 3, 4)
+    D = Normal('D', M, N)
+    exprd = '''
+        Integral(sqrt(2)*exp(-(N-1)**2/8)*Integral(exp(-(x-M)**2/(2*N**2))*exp
+        (-(M-3)**2/32)/(8*pi*N),(M,-oo,oo))/(4*sqrt(pi)),(N,-oo,oo))'''
+    assert streq(density(D, evaluate=False)(x), exprd)
+
+
+def test_Compound_Distribution():
+    X = Normal('X', 2, 4)
+    N = NormalDistribution(X, 4)
+    C = CompoundDistribution(N)
+    assert C.is_Continuous
+    assert C.set == Interval(-oo, oo)
+    assert C.pdf(x, evaluate=True).simplify() == exp(-x**2/64 + x/16 - S(1)/16)/(8*sqrt(pi))
+
+    assert not isinstance(CompoundDistribution(NormalDistribution(2, 3)),
+                            CompoundDistribution)
+    M = MultivariateNormalDistribution([1, 2], [[2, 1], [1, 2]])
+    raises(NotImplementedError, lambda: CompoundDistribution(M))
+
+    X = Beta('X', 2, 4)
+    B = BernoulliDistribution(X, 1, 0)
+    C = CompoundDistribution(B)
+    assert C.is_Finite
+    assert C.set == {0, 1}
+    y = symbols('y', negative=False, integer=True)
+    assert C.pdf(y, evaluate=True) == Piecewise((S(1)/(30*beta(2, 4)), Eq(y, 0)),
+                (S(1)/(60*beta(2, 4)), Eq(y, 1)), (0, True))
+
+    k, t, z = symbols('k t z', positive=True, real=True)
+    G = Gamma('G', k, t)
+    X = PoissonDistribution(G)
+    C = CompoundDistribution(X)
+    assert C.is_Discrete
+    assert C.set == S.Naturals0
+    assert C.pdf(z, evaluate=True).simplify() == t**z*(t + 1)**(-k - z)*gamma(k \
+                    + z)/(gamma(k)*gamma(z + 1))
+
+
+def test_compound_pspace():
+    X = Normal('X', 2, 4)
+    Y = Normal('Y', 3, 6)
+    assert not isinstance(Y.pspace, CompoundPSpace)
+    N = NormalDistribution(1, 2)
+    D = PoissonDistribution(3)
+    B = BernoulliDistribution(0.2, 1, 0)
+    pspace1 = CompoundPSpace('N', N)
+    pspace2 = CompoundPSpace('D', D)
+    pspace3 = CompoundPSpace('B', B)
+    assert not isinstance(pspace1, CompoundPSpace)
+    assert not isinstance(pspace2, CompoundPSpace)
+    assert not isinstance(pspace3, CompoundPSpace)
+    M = MultivariateNormalDistribution([1, 2], [[2, 1], [1, 2]])
+    raises(ValueError, lambda: CompoundPSpace('M', M))
+    Y = Normal('Y', X, 6)
+    assert isinstance(Y.pspace, CompoundPSpace)
+    assert Y.pspace.distribution == CompoundDistribution(NormalDistribution(X, 6))
+    assert Y.pspace.domain.set == Interval(-oo, oo)
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/tests/test_continuous_rv.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/tests/test_continuous_rv.py
new file mode 100644
index 0000000000000000000000000000000000000000..b2c4206b5c29ffd3194d1ae05e57c51c9c1b6d78
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/tests/test_continuous_rv.py
@@ -0,0 +1,1583 @@
+from sympy.concrete.summations import Sum
+from sympy.core.function import (Lambda, diff, expand_func)
+from sympy.core.mul import Mul
+from sympy.core import EulerGamma
+from sympy.core.numbers import (E as e, I, Rational, pi)
+from sympy.core.relational import (Eq, Ne)
+from sympy.core.singleton import S
+from sympy.core.symbol import (Dummy, Symbol, symbols)
+from sympy.functions.combinatorial.factorials import (binomial, factorial)
+from sympy.functions.elementary.complexes import (Abs, im, re, sign)
+from sympy.functions.elementary.exponential import (exp, log)
+from sympy.functions.elementary.hyperbolic import (cosh, sinh)
+from sympy.functions.elementary.integers import floor
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.piecewise import Piecewise
+from sympy.functions.elementary.trigonometric import (asin, atan, cos, sin, tan)
+from sympy.functions.special.bessel import (besseli, besselj, besselk)
+from sympy.functions.special.beta_functions import beta
+from sympy.functions.special.error_functions import (erf, erfc, erfi, expint)
+from sympy.functions.special.gamma_functions import (gamma, lowergamma, uppergamma)
+from sympy.functions.special.zeta_functions import zeta
+from sympy.functions.special.hyper import hyper
+from sympy.integrals.integrals import Integral
+from sympy.logic.boolalg import (And, Or)
+from sympy.sets.sets import Interval
+from sympy.simplify.simplify import simplify
+from sympy.utilities.lambdify import lambdify
+from sympy.functions.special.error_functions import erfinv
+from sympy.functions.special.hyper import meijerg
+from sympy.sets.sets import FiniteSet, Complement, Intersection
+from sympy.stats import (P, E, where, density, variance, covariance, skewness, kurtosis, median,
+                         given, pspace, cdf, characteristic_function, moment_generating_function,
+                         ContinuousRV, Arcsin, Benini, Beta, BetaNoncentral, BetaPrime,
+                         Cauchy, Chi, ChiSquared, ChiNoncentral, Dagum, Davis, Erlang, ExGaussian,
+                         Exponential, ExponentialPower, FDistribution, FisherZ, Frechet, Gamma,
+                         GammaInverse, Gompertz, Gumbel, Kumaraswamy, Laplace, Levy, Logistic, LogCauchy,
+                         LogLogistic, LogitNormal, LogNormal, Maxwell, Moyal, Nakagami, Normal, GaussianInverse,
+                         Pareto, PowerFunction, QuadraticU, RaisedCosine, Rayleigh, Reciprocal, ShiftedGompertz, StudentT,
+                         Trapezoidal, Triangular, Uniform, UniformSum, VonMises, Weibull, coskewness,
+                         WignerSemicircle, Wald, correlation, moment, cmoment, smoment, quantile,
+                         Lomax, BoundedPareto)
+
+from sympy.stats.crv_types import NormalDistribution, ExponentialDistribution, ContinuousDistributionHandmade
+from sympy.stats.joint_rv_types import MultivariateLaplaceDistribution, MultivariateNormalDistribution
+from sympy.stats.crv import SingleContinuousPSpace, SingleContinuousDomain
+from sympy.stats.compound_rv import CompoundPSpace
+from sympy.stats.symbolic_probability import Probability
+from sympy.testing.pytest import raises, XFAIL, slow, ignore_warnings
+from sympy.core.random import verify_numerically as tn
+
+oo = S.Infinity
+
+x, y, z = map(Symbol, 'xyz')
+
+def test_single_normal():
+    mu = Symbol('mu', real=True)
+    sigma = Symbol('sigma', positive=True)
+    X = Normal('x', 0, 1)
+    Y = X*sigma + mu
+
+    assert E(Y) == mu
+    assert variance(Y) == sigma**2
+    pdf = density(Y)
+    x = Symbol('x', real=True)
+    assert (pdf(x) ==
+            2**S.Half*exp(-(x - mu)**2/(2*sigma**2))/(2*pi**S.Half*sigma))
+
+    assert P(X**2 < 1) == erf(2**S.Half/2)
+    ans = quantile(Y)(x)
+    assert ans == Complement(Intersection(FiniteSet(
+        sqrt(2)*sigma*(sqrt(2)*mu/(2*sigma)+ erfinv(2*x - 1))),
+        Interval(-oo, oo)), FiniteSet(mu))
+    assert E(X, Eq(X, mu)) == mu
+
+    assert median(X) == FiniteSet(0)
+    # issue 8248
+    assert X.pspace.compute_expectation(1).doit() == 1
+
+
+def test_conditional_1d():
+    X = Normal('x', 0, 1)
+    Y = given(X, X >= 0)
+    z = Symbol('z')
+
+    assert density(Y)(z) == 2 * density(X)(z)
+
+    assert Y.pspace.domain.set == Interval(0, oo)
+    assert E(Y) == sqrt(2) / sqrt(pi)
+
+    assert E(X**2) == E(Y**2)
+
+
+def test_ContinuousDomain():
+    X = Normal('x', 0, 1)
+    assert where(X**2 <= 1).set == Interval(-1, 1)
+    assert where(X**2 <= 1).symbol == X.symbol
+    assert where(And(X**2 <= 1, X >= 0)).set == Interval(0, 1)
+    raises(ValueError, lambda: where(sin(X) > 1))
+
+    Y = given(X, X >= 0)
+
+    assert Y.pspace.domain.set == Interval(0, oo)
+
+
+def test_multiple_normal():
+    X, Y = Normal('x', 0, 1), Normal('y', 0, 1)
+    p = Symbol("p", positive=True)
+
+    assert E(X + Y) == 0
+    assert variance(X + Y) == 2
+    assert variance(X + X) == 4
+    assert covariance(X, Y) == 0
+    assert covariance(2*X + Y, -X) == -2*variance(X)
+    assert skewness(X) == 0
+    assert skewness(X + Y) == 0
+    assert kurtosis(X) == 3
+    assert kurtosis(X+Y) == 3
+    assert correlation(X, Y) == 0
+    assert correlation(X, X + Y) == correlation(X, X - Y)
+    assert moment(X, 2) == 1
+    assert cmoment(X, 3) == 0
+    assert moment(X + Y, 4) == 12
+    assert cmoment(X, 2) == variance(X)
+    assert smoment(X*X, 2) == 1
+    assert smoment(X + Y, 3) == skewness(X + Y)
+    assert smoment(X + Y, 4) == kurtosis(X + Y)
+    assert E(X, Eq(X + Y, 0)) == 0
+    assert variance(X, Eq(X + Y, 0)) == S.Half
+    assert quantile(X)(p) == sqrt(2)*erfinv(2*p - S.One)
+
+
+def test_symbolic():
+    mu1, mu2 = symbols('mu1 mu2', real=True)
+    s1, s2 = symbols('sigma1 sigma2', positive=True)
+    rate = Symbol('lambda', positive=True)
+    X = Normal('x', mu1, s1)
+    Y = Normal('y', mu2, s2)
+    Z = Exponential('z', rate)
+    a, b, c = symbols('a b c', real=True)
+
+    assert E(X) == mu1
+    assert E(X + Y) == mu1 + mu2
+    assert E(a*X + b) == a*E(X) + b
+    assert variance(X) == s1**2
+    assert variance(X + a*Y + b) == variance(X) + a**2*variance(Y)
+
+    assert E(Z) == 1/rate
+    assert E(a*Z + b) == a*E(Z) + b
+    assert E(X + a*Z + b) == mu1 + a/rate + b
+    assert median(X) == FiniteSet(mu1)
+
+
+def test_cdf():
+    X = Normal('x', 0, 1)
+
+    d = cdf(X)
+    assert P(X < 1) == d(1).rewrite(erfc)
+    assert d(0) == S.Half
+
+    d = cdf(X, X > 0)  # given X>0
+    assert d(0) == 0
+
+    Y = Exponential('y', 10)
+    d = cdf(Y)
+    assert d(-5) == 0
+    assert P(Y > 3) == 1 - d(3)
+
+    raises(ValueError, lambda: cdf(X + Y))
+
+    Z = Exponential('z', 1)
+    f = cdf(Z)
+    assert f(z) == Piecewise((1 - exp(-z), z >= 0), (0, True))
+
+
+def test_characteristic_function():
+    X = Uniform('x', 0, 1)
+
+    cf = characteristic_function(X)
+    assert cf(1) == -I*(-1 + exp(I))
+
+    Y = Normal('y', 1, 1)
+    cf = characteristic_function(Y)
+    assert cf(0) == 1
+    assert cf(1) == exp(I - S.Half)
+
+    Z = Exponential('z', 5)
+    cf = characteristic_function(Z)
+    assert cf(0) == 1
+    assert cf(1).expand() == Rational(25, 26) + I*5/26
+
+    X = GaussianInverse('x', 1, 1)
+    cf = characteristic_function(X)
+    assert cf(0) == 1
+    assert cf(1) == exp(1 - sqrt(1 - 2*I))
+
+    X = ExGaussian('x', 0, 1, 1)
+    cf = characteristic_function(X)
+    assert cf(0) == 1
+    assert cf(1) == (1 + I)*exp(Rational(-1, 2))/2
+
+    L = Levy('x', 0, 1)
+    cf = characteristic_function(L)
+    assert cf(0) == 1
+    assert cf(1) == exp(-sqrt(2)*sqrt(-I))
+
+
+def test_moment_generating_function():
+    t = symbols('t', positive=True)
+
+    # Symbolic tests
+    a, b, c = symbols('a b c')
+
+    mgf = moment_generating_function(Beta('x', a, b))(t)
+    assert mgf == hyper((a,), (a + b,), t)
+
+    mgf = moment_generating_function(Chi('x', a))(t)
+    assert mgf == sqrt(2)*t*gamma(a/2 + S.Half)*\
+        hyper((a/2 + S.Half,), (Rational(3, 2),), t**2/2)/gamma(a/2) +\
+        hyper((a/2,), (S.Half,), t**2/2)
+
+    mgf = moment_generating_function(ChiSquared('x', a))(t)
+    assert mgf == (1 - 2*t)**(-a/2)
+
+    mgf = moment_generating_function(Erlang('x', a, b))(t)
+    assert mgf == (1 - t/b)**(-a)
+
+    mgf = moment_generating_function(ExGaussian("x", a, b, c))(t)
+    assert mgf == exp(a*t + b**2*t**2/2)/(1 - t/c)
+
+    mgf = moment_generating_function(Exponential('x', a))(t)
+    assert mgf == a/(a - t)
+
+    mgf = moment_generating_function(Gamma('x', a, b))(t)
+    assert mgf == (-b*t + 1)**(-a)
+
+    mgf = moment_generating_function(Gumbel('x', a, b))(t)
+    assert mgf == exp(b*t)*gamma(-a*t + 1)
+
+    mgf = moment_generating_function(Gompertz('x', a, b))(t)
+    assert mgf == b*exp(b)*expint(t/a, b)
+
+    mgf = moment_generating_function(Laplace('x', a, b))(t)
+    assert mgf == exp(a*t)/(-b**2*t**2 + 1)
+
+    mgf = moment_generating_function(Logistic('x', a, b))(t)
+    assert mgf == exp(a*t)*beta(-b*t + 1, b*t + 1)
+
+    mgf = moment_generating_function(Normal('x', a, b))(t)
+    assert mgf == exp(a*t + b**2*t**2/2)
+
+    mgf = moment_generating_function(Pareto('x', a, b))(t)
+    assert mgf == b*(-a*t)**b*uppergamma(-b, -a*t)
+
+    mgf = moment_generating_function(QuadraticU('x', a, b))(t)
+    assert str(mgf) == ("(3*(t*(-4*b + (a + b)**2) + 4)*exp(b*t) - "
+    "3*(t*(a**2 + 2*a*(b - 2) + b**2) + 4)*exp(a*t))/(t**2*(a - b)**3)")
+
+    mgf = moment_generating_function(RaisedCosine('x', a, b))(t)
+    assert mgf == pi**2*exp(a*t)*sinh(b*t)/(b*t*(b**2*t**2 + pi**2))
+
+    mgf = moment_generating_function(Rayleigh('x', a))(t)
+    assert mgf == sqrt(2)*sqrt(pi)*a*t*(erf(sqrt(2)*a*t/2) + 1)\
+        *exp(a**2*t**2/2)/2 + 1
+
+    mgf = moment_generating_function(Triangular('x', a, b, c))(t)
+    assert str(mgf) == ("(-2*(-a + b)*exp(c*t) + 2*(-a + c)*exp(b*t) + "
+    "2*(b - c)*exp(a*t))/(t**2*(-a + b)*(-a + c)*(b - c))")
+
+    mgf = moment_generating_function(Uniform('x', a, b))(t)
+    assert mgf == (-exp(a*t) + exp(b*t))/(t*(-a + b))
+
+    mgf = moment_generating_function(UniformSum('x', a))(t)
+    assert mgf == ((exp(t) - 1)/t)**a
+
+    mgf = moment_generating_function(WignerSemicircle('x', a))(t)
+    assert mgf == 2*besseli(1, a*t)/(a*t)
+
+    # Numeric tests
+
+    mgf = moment_generating_function(Beta('x', 1, 1))(t)
+    assert mgf.diff(t).subs(t, 1) == hyper((2,), (3,), 1)/2
+
+    mgf = moment_generating_function(Chi('x', 1))(t)
+    assert mgf.diff(t).subs(t, 1) == sqrt(2)*hyper((1,), (Rational(3, 2),), S.Half
+    )/sqrt(pi) + hyper((Rational(3, 2),), (Rational(3, 2),), S.Half) + 2*sqrt(2)*hyper((2,),
+    (Rational(5, 2),), S.Half)/(3*sqrt(pi))
+
+    mgf = moment_generating_function(ChiSquared('x', 1))(t)
+    assert mgf.diff(t).subs(t, 1) == I
+
+    mgf = moment_generating_function(Erlang('x', 1, 1))(t)
+    assert mgf.diff(t).subs(t, 0) == 1
+
+    mgf = moment_generating_function(ExGaussian("x", 0, 1, 1))(t)
+    assert mgf.diff(t).subs(t, 2) == -exp(2)
+
+    mgf = moment_generating_function(Exponential('x', 1))(t)
+    assert mgf.diff(t).subs(t, 0) == 1
+
+    mgf = moment_generating_function(Gamma('x', 1, 1))(t)
+    assert mgf.diff(t).subs(t, 0) == 1
+
+    mgf = moment_generating_function(Gumbel('x', 1, 1))(t)
+    assert mgf.diff(t).subs(t, 0) == EulerGamma + 1
+
+    mgf = moment_generating_function(Gompertz('x', 1, 1))(t)
+    assert mgf.diff(t).subs(t, 1) == -e*meijerg(((), (1, 1)),
+    ((0, 0, 0), ()), 1)
+
+    mgf = moment_generating_function(Laplace('x', 1, 1))(t)
+    assert mgf.diff(t).subs(t, 0) == 1
+
+    mgf = moment_generating_function(Logistic('x', 1, 1))(t)
+    assert mgf.diff(t).subs(t, 0) == beta(1, 1)
+
+    mgf = moment_generating_function(Normal('x', 0, 1))(t)
+    assert mgf.diff(t).subs(t, 1) == exp(S.Half)
+
+    mgf = moment_generating_function(Pareto('x', 1, 1))(t)
+    assert mgf.diff(t).subs(t, 0) == expint(1, 0)
+
+    mgf = moment_generating_function(QuadraticU('x', 1, 2))(t)
+    assert mgf.diff(t).subs(t, 1) == -12*e - 3*exp(2)
+
+    mgf = moment_generating_function(RaisedCosine('x', 1, 1))(t)
+    assert mgf.diff(t).subs(t, 1) == -2*e*pi**2*sinh(1)/\
+    (1 + pi**2)**2 + e*pi**2*cosh(1)/(1 + pi**2)
+
+    mgf = moment_generating_function(Rayleigh('x', 1))(t)
+    assert mgf.diff(t).subs(t, 0) == sqrt(2)*sqrt(pi)/2
+
+    mgf = moment_generating_function(Triangular('x', 1, 3, 2))(t)
+    assert mgf.diff(t).subs(t, 1) == -e + exp(3)
+
+    mgf = moment_generating_function(Uniform('x', 0, 1))(t)
+    assert mgf.diff(t).subs(t, 1) == 1
+
+    mgf = moment_generating_function(UniformSum('x', 1))(t)
+    assert mgf.diff(t).subs(t, 1) == 1
+
+    mgf = moment_generating_function(WignerSemicircle('x', 1))(t)
+    assert mgf.diff(t).subs(t, 1) == -2*besseli(1, 1) + besseli(2, 1) +\
+        besseli(0, 1)
+
+
+def test_ContinuousRV():
+    pdf = sqrt(2)*exp(-x**2/2)/(2*sqrt(pi))  # Normal distribution
+    # X and Y should be equivalent
+    X = ContinuousRV(x, pdf, check=True)
+    Y = Normal('y', 0, 1)
+
+    assert variance(X) == variance(Y)
+    assert P(X > 0) == P(Y > 0)
+    Z = ContinuousRV(z, exp(-z), set=Interval(0, oo))
+    assert Z.pspace.domain.set == Interval(0, oo)
+    assert E(Z) == 1
+    assert P(Z > 5) == exp(-5)
+    raises(ValueError, lambda: ContinuousRV(z, exp(-z), set=Interval(0, 10), check=True))
+
+    # the correct pdf for Gamma(k, theta) but the integral in `check`
+    # integrates to something equivalent to 1 and not to 1 exactly
+    _x, k, theta = symbols("x k theta", positive=True)
+    pdf = 1/(gamma(k)*theta**k)*_x**(k-1)*exp(-_x/theta)
+    X = ContinuousRV(_x, pdf, set=Interval(0, oo))
+    Y = Gamma('y', k, theta)
+    assert (E(X) - E(Y)).simplify() == 0
+    assert (variance(X) - variance(Y)).simplify() == 0
+
+
+def test_arcsin():
+
+    a = Symbol("a", real=True)
+    b = Symbol("b", real=True)
+
+    X = Arcsin('x', a, b)
+    assert density(X)(x) == 1/(pi*sqrt((-x + b)*(x - a)))
+    assert cdf(X)(x) == Piecewise((0, a > x),
+                            (2*asin(sqrt((-a + x)/(-a + b)))/pi, b >= x),
+                            (1, True))
+    assert pspace(X).domain.set == Interval(a, b)
+
+def test_benini():
+    alpha = Symbol("alpha", positive=True)
+    beta = Symbol("beta", positive=True)
+    sigma = Symbol("sigma", positive=True)
+    X = Benini('x', alpha, beta, sigma)
+
+    assert density(X)(x) == ((alpha/x + 2*beta*log(x/sigma)/x)
+                          *exp(-alpha*log(x/sigma) - beta*log(x/sigma)**2))
+
+    assert pspace(X).domain.set == Interval(sigma, oo)
+    raises(NotImplementedError, lambda: moment_generating_function(X))
+    alpha = Symbol("alpha", nonpositive=True)
+    raises(ValueError, lambda: Benini('x', alpha, beta, sigma))
+
+    beta = Symbol("beta", nonpositive=True)
+    raises(ValueError, lambda: Benini('x', alpha, beta, sigma))
+
+    alpha = Symbol("alpha", positive=True)
+    raises(ValueError, lambda: Benini('x', alpha, beta, sigma))
+
+    beta = Symbol("beta", positive=True)
+    sigma = Symbol("sigma", nonpositive=True)
+    raises(ValueError, lambda: Benini('x', alpha, beta, sigma))
+
+def test_beta():
+    a, b = symbols('alpha beta', positive=True)
+    B = Beta('x', a, b)
+
+    assert pspace(B).domain.set == Interval(0, 1)
+    assert characteristic_function(B)(x) == hyper((a,), (a + b,), I*x)
+    assert density(B)(x) == x**(a - 1)*(1 - x)**(b - 1)/beta(a, b)
+
+    assert simplify(E(B)) == a / (a + b)
+    assert simplify(variance(B)) == a*b / (a**3 + 3*a**2*b + a**2 + 3*a*b**2 + 2*a*b + b**3 + b**2)
+
+    # Full symbolic solution is too much, test with numeric version
+    a, b = 1, 2
+    B = Beta('x', a, b)
+    assert expand_func(E(B)) == a / S(a + b)
+    assert expand_func(variance(B)) == (a*b) / S((a + b)**2 * (a + b + 1))
+    assert median(B) == FiniteSet(1 - 1/sqrt(2))
+
+def test_beta_noncentral():
+    a, b = symbols('a b', positive=True)
+    c = Symbol('c', nonnegative=True)
+    _k = Dummy('k')
+
+    X = BetaNoncentral('x', a, b, c)
+
+    assert pspace(X).domain.set == Interval(0, 1)
+
+    dens = density(X)
+    z = Symbol('z')
+
+    res = Sum( z**(_k + a - 1)*(c/2)**_k*(1 - z)**(b - 1)*exp(-c/2)/
+               (beta(_k + a, b)*factorial(_k)), (_k, 0, oo))
+    assert dens(z).dummy_eq(res)
+
+    # BetaCentral should not raise if the assumptions
+    # on the symbols can not be determined
+    a, b, c = symbols('a b c')
+    assert BetaNoncentral('x', a, b, c)
+
+    a = Symbol('a', positive=False, real=True)
+    raises(ValueError, lambda: BetaNoncentral('x', a, b, c))
+
+    a = Symbol('a', positive=True)
+    b = Symbol('b', positive=False, real=True)
+    raises(ValueError, lambda: BetaNoncentral('x', a, b, c))
+
+    a = Symbol('a', positive=True)
+    b = Symbol('b', positive=True)
+    c = Symbol('c', nonnegative=False, real=True)
+    raises(ValueError, lambda: BetaNoncentral('x', a, b, c))
+
+def test_betaprime():
+    alpha = Symbol("alpha", positive=True)
+
+    betap = Symbol("beta", positive=True)
+
+    X = BetaPrime('x', alpha, betap)
+    assert density(X)(x) == x**(alpha - 1)*(x + 1)**(-alpha - betap)/beta(alpha, betap)
+
+    alpha = Symbol("alpha", nonpositive=True)
+    raises(ValueError, lambda: BetaPrime('x', alpha, betap))
+
+    alpha = Symbol("alpha", positive=True)
+    betap = Symbol("beta", nonpositive=True)
+    raises(ValueError, lambda: BetaPrime('x', alpha, betap))
+    X = BetaPrime('x', 1, 1)
+    assert median(X) == FiniteSet(1)
+
+
+def test_BoundedPareto():
+    L, H = symbols('L, H', negative=True)
+    raises(ValueError, lambda: BoundedPareto('X', 1, L, H))
+    L, H = symbols('L, H', real=False)
+    raises(ValueError, lambda: BoundedPareto('X', 1, L, H))
+    L, H = symbols('L, H', positive=True)
+    raises(ValueError, lambda: BoundedPareto('X', -1, L, H))
+
+    X = BoundedPareto('X', 2, L, H)
+    assert X.pspace.domain.set == Interval(L, H)
+    assert density(X)(x) == 2*L**2/(x**3*(1 - L**2/H**2))
+    assert cdf(X)(x) == Piecewise((-H**2*L**2/(x**2*(H**2 - L**2)) \
+                            + H**2/(H**2 - L**2), L <= x), (0, True))
+    assert E(X).simplify() == 2*H*L/(H + L)
+    X = BoundedPareto('X', 1, 2, 4)
+    assert E(X).simplify() == log(16)
+    assert median(X) == FiniteSet(Rational(8, 3))
+    assert variance(X).simplify() == 8 - 16*log(2)**2
+
+
+def test_cauchy():
+    x0 = Symbol("x0", real=True)
+    gamma = Symbol("gamma", positive=True)
+    p = Symbol("p", positive=True)
+
+    X = Cauchy('x', x0, gamma)
+    # Tests the characteristic function
+    assert characteristic_function(X)(x) == exp(-gamma*Abs(x) + I*x*x0)
+    raises(NotImplementedError, lambda: moment_generating_function(X))
+    assert density(X)(x) == 1/(pi*gamma*(1 + (x - x0)**2/gamma**2))
+    assert diff(cdf(X)(x), x) == density(X)(x)
+    assert quantile(X)(p) == gamma*tan(pi*(p - S.Half)) + x0
+
+    x1 = Symbol("x1", real=False)
+    raises(ValueError, lambda: Cauchy('x', x1, gamma))
+    gamma = Symbol("gamma", nonpositive=True)
+    raises(ValueError, lambda: Cauchy('x', x0, gamma))
+    assert median(X) == FiniteSet(x0)
+
+def test_chi():
+    from sympy.core.numbers import I
+    k = Symbol("k", integer=True)
+
+    X = Chi('x', k)
+    assert density(X)(x) == 2**(-k/2 + 1)*x**(k - 1)*exp(-x**2/2)/gamma(k/2)
+
+    # Tests the characteristic function
+    assert characteristic_function(X)(x) == sqrt(2)*I*x*gamma(k/2 + S(1)/2)*hyper((k/2 + S(1)/2,),
+                                            (S(3)/2,), -x**2/2)/gamma(k/2) + hyper((k/2,), (S(1)/2,), -x**2/2)
+
+    # Tests the moment generating function
+    assert moment_generating_function(X)(x) == sqrt(2)*x*gamma(k/2 + S(1)/2)*hyper((k/2 + S(1)/2,),
+                                                (S(3)/2,), x**2/2)/gamma(k/2) + hyper((k/2,), (S(1)/2,), x**2/2)
+
+    k = Symbol("k", integer=True, positive=False)
+    raises(ValueError, lambda: Chi('x', k))
+
+    k = Symbol("k", integer=False, positive=True)
+    raises(ValueError, lambda: Chi('x', k))
+
+def test_chi_noncentral():
+    k = Symbol("k", integer=True)
+    l = Symbol("l")
+
+    X = ChiNoncentral("x", k, l)
+    assert density(X)(x) == (x**k*l*(x*l)**(-k/2)*
+                          exp(-x**2/2 - l**2/2)*besseli(k/2 - 1, x*l))
+
+    k = Symbol("k", integer=True, positive=False)
+    raises(ValueError, lambda: ChiNoncentral('x', k, l))
+
+    k = Symbol("k", integer=True, positive=True)
+    l = Symbol("l", nonpositive=True)
+    raises(ValueError, lambda: ChiNoncentral('x', k, l))
+
+    k = Symbol("k", integer=False)
+    l = Symbol("l", positive=True)
+    raises(ValueError, lambda: ChiNoncentral('x', k, l))
+
+
+def test_chi_squared():
+    k = Symbol("k", integer=True)
+    X = ChiSquared('x', k)
+
+    # Tests the characteristic function
+    assert characteristic_function(X)(x) == ((-2*I*x + 1)**(-k/2))
+
+    assert density(X)(x) == 2**(-k/2)*x**(k/2 - 1)*exp(-x/2)/gamma(k/2)
+    assert cdf(X)(x) == Piecewise((lowergamma(k/2, x/2)/gamma(k/2), x >= 0), (0, True))
+    assert E(X) == k
+    assert variance(X) == 2*k
+
+    X = ChiSquared('x', 15)
+    assert cdf(X)(3) == -14873*sqrt(6)*exp(Rational(-3, 2))/(5005*sqrt(pi)) + erf(sqrt(6)/2)
+
+    k = Symbol("k", integer=True, positive=False)
+    raises(ValueError, lambda: ChiSquared('x', k))
+
+    k = Symbol("k", integer=False, positive=True)
+    raises(ValueError, lambda: ChiSquared('x', k))
+
+
+def test_dagum():
+    p = Symbol("p", positive=True)
+    b = Symbol("b", positive=True)
+    a = Symbol("a", positive=True)
+
+    X = Dagum('x', p, a, b)
+    assert density(X)(x) == a*p*(x/b)**(a*p)*((x/b)**a + 1)**(-p - 1)/x
+    assert cdf(X)(x) == Piecewise(((1 + (x/b)**(-a))**(-p), x >= 0),
+                                    (0, True))
+
+    p = Symbol("p", nonpositive=True)
+    raises(ValueError, lambda: Dagum('x', p, a, b))
+
+    p = Symbol("p", positive=True)
+    b = Symbol("b", nonpositive=True)
+    raises(ValueError, lambda: Dagum('x', p, a, b))
+
+    b = Symbol("b", positive=True)
+    a = Symbol("a", nonpositive=True)
+    raises(ValueError, lambda: Dagum('x', p, a, b))
+    X = Dagum('x', 1, 1, 1)
+    assert median(X) == FiniteSet(1)
+
+def test_davis():
+    b = Symbol("b", positive=True)
+    n = Symbol("n", positive=True)
+    mu = Symbol("mu", positive=True)
+
+    X = Davis('x', b, n, mu)
+    dividend = b**n*(x - mu)**(-1-n)
+    divisor = (exp(b/(x-mu))-1)*(gamma(n)*zeta(n))
+    assert density(X)(x) == dividend/divisor
+
+
+def test_erlang():
+    k = Symbol("k", integer=True, positive=True)
+    l = Symbol("l", positive=True)
+
+    X = Erlang("x", k, l)
+    assert density(X)(x) == x**(k - 1)*l**k*exp(-x*l)/gamma(k)
+    assert cdf(X)(x) == Piecewise((lowergamma(k, l*x)/gamma(k), x > 0),
+                               (0, True))
+
+
+def test_exgaussian():
+    m, z = symbols("m, z")
+    s, l = symbols("s, l", positive=True)
+    X = ExGaussian("x", m, s, l)
+
+    assert density(X)(z) == l*exp(l*(l*s**2 + 2*m - 2*z)/2) *\
+        erfc(sqrt(2)*(l*s**2 + m - z)/(2*s))/2
+
+    # Note: actual_output simplifies to expected_output.
+    # Ideally cdf(X)(z) would return expected_output
+    # expected_output = (erf(sqrt(2)*(l*s**2 + m - z)/(2*s)) - 1)*exp(l*(l*s**2 + 2*m - 2*z)/2)/2 - erf(sqrt(2)*(m - z)/(2*s))/2 + S.Half
+    u = l*(z - m)
+    v = l*s
+    GaussianCDF1 = cdf(Normal('x', 0, v))(u)
+    GaussianCDF2 = cdf(Normal('x', v**2, v))(u)
+    actual_output = GaussianCDF1 - exp(-u + (v**2/2) + log(GaussianCDF2))
+    assert cdf(X)(z) == actual_output
+    # assert simplify(actual_output) == expected_output
+
+    assert variance(X).expand() == s**2 + l**(-2)
+
+    assert skewness(X).expand() == 2/(l**3*s**2*sqrt(s**2 + l**(-2)) + l *
+                                      sqrt(s**2 + l**(-2)))
+
+
+@slow
+def test_exponential():
+    rate = Symbol('lambda', positive=True)
+    X = Exponential('x', rate)
+    p = Symbol("p", positive=True, real=True)
+
+    assert E(X) == 1/rate
+    assert variance(X) == 1/rate**2
+    assert skewness(X) == 2
+    assert skewness(X) == smoment(X, 3)
+    assert kurtosis(X) == 9
+    assert kurtosis(X) == smoment(X, 4)
+    assert smoment(2*X, 4) == smoment(X, 4)
+    assert moment(X, 3) == 3*2*1/rate**3
+    assert P(X > 0) is S.One
+    assert P(X > 1) == exp(-rate)
+    assert P(X > 10) == exp(-10*rate)
+    assert quantile(X)(p) == -log(1-p)/rate
+
+    assert where(X <= 1).set == Interval(0, 1)
+    Y = Exponential('y', 1)
+    assert median(Y) == FiniteSet(log(2))
+    #Test issue 9970
+    z = Dummy('z')
+    assert P(X > z) == exp(-z*rate)
+    assert P(X < z) == 0
+    #Test issue 10076 (Distribution with interval(0,oo))
+    x = Symbol('x')
+    _z = Dummy('_z')
+    b = SingleContinuousPSpace(x, ExponentialDistribution(2))
+
+    with ignore_warnings(UserWarning): ### TODO: Restore tests once warnings are removed
+        expected1 = Integral(2*exp(-2*_z), (_z, 3, oo))
+        assert b.probability(x > 3, evaluate=False).rewrite(Integral).dummy_eq(expected1)
+
+        expected2 = Integral(2*exp(-2*_z), (_z, 0, 4))
+        assert b.probability(x < 4, evaluate=False).rewrite(Integral).dummy_eq(expected2)
+    Y = Exponential('y', 2*rate)
+    assert coskewness(X, X, X) == skewness(X)
+    assert coskewness(X, Y + rate*X, Y + 2*rate*X) == \
+                        4/(sqrt(1 + 1/(4*rate**2))*sqrt(4 + 1/(4*rate**2)))
+    assert coskewness(X + 2*Y, Y + X, Y + 2*X, X > 3) == \
+                        sqrt(170)*Rational(9, 85)
+
+def test_exponential_power():
+    mu = Symbol('mu')
+    z = Symbol('z')
+    alpha = Symbol('alpha', positive=True)
+    beta = Symbol('beta', positive=True)
+
+    X = ExponentialPower('x', mu, alpha, beta)
+
+    assert density(X)(z) == beta*exp(-(Abs(mu - z)/alpha)
+                                     ** beta)/(2*alpha*gamma(1/beta))
+    assert cdf(X)(z) == S.Half + lowergamma(1/beta,
+                            (Abs(mu - z)/alpha)**beta)*sign(-mu + z)/\
+                                (2*gamma(1/beta))
+
+
+def test_f_distribution():
+    d1 = Symbol("d1", positive=True)
+    d2 = Symbol("d2", positive=True)
+
+    X = FDistribution("x", d1, d2)
+
+    assert density(X)(x) == (d2**(d2/2)*sqrt((d1*x)**d1*(d1*x + d2)**(-d1 - d2))
+                             /(x*beta(d1/2, d2/2)))
+
+    raises(NotImplementedError, lambda: moment_generating_function(X))
+    d1 = Symbol("d1", nonpositive=True)
+    raises(ValueError, lambda: FDistribution('x', d1, d1))
+
+    d1 = Symbol("d1", positive=True, integer=False)
+    raises(ValueError, lambda: FDistribution('x', d1, d1))
+
+    d1 = Symbol("d1", positive=True)
+    d2 = Symbol("d2", nonpositive=True)
+    raises(ValueError, lambda: FDistribution('x', d1, d2))
+
+    d2 = Symbol("d2", positive=True, integer=False)
+    raises(ValueError, lambda: FDistribution('x', d1, d2))
+
+
+def test_fisher_z():
+    d1 = Symbol("d1", positive=True)
+    d2 = Symbol("d2", positive=True)
+
+    X = FisherZ("x", d1, d2)
+    assert density(X)(x) == (2*d1**(d1/2)*d2**(d2/2)*(d1*exp(2*x) + d2)
+                             **(-d1/2 - d2/2)*exp(d1*x)/beta(d1/2, d2/2))
+
+def test_frechet():
+    a = Symbol("a", positive=True)
+    s = Symbol("s", positive=True)
+    m = Symbol("m", real=True)
+
+    X = Frechet("x", a, s=s, m=m)
+    assert density(X)(x) == a*((x - m)/s)**(-a - 1)*exp(-((x - m)/s)**(-a))/s
+    assert cdf(X)(x) == Piecewise((exp(-((-m + x)/s)**(-a)), m <= x), (0, True))
+
+@slow
+def test_gamma():
+    k = Symbol("k", positive=True)
+    theta = Symbol("theta", positive=True)
+
+    X = Gamma('x', k, theta)
+
+    # Tests characteristic function
+    assert characteristic_function(X)(x) == ((-I*theta*x + 1)**(-k))
+
+    assert density(X)(x) == x**(k - 1)*theta**(-k)*exp(-x/theta)/gamma(k)
+    assert cdf(X, meijerg=True)(z) == Piecewise(
+            (-k*lowergamma(k, 0)/gamma(k + 1) +
+                k*lowergamma(k, z/theta)/gamma(k + 1), z >= 0),
+            (0, True))
+
+    # assert simplify(variance(X)) == k*theta**2  # handled numerically below
+    assert E(X) == moment(X, 1)
+
+    k, theta = symbols('k theta', positive=True)
+    X = Gamma('x', k, theta)
+    assert E(X) == k*theta
+    assert variance(X) == k*theta**2
+    assert skewness(X).expand() == 2/sqrt(k)
+    assert kurtosis(X).expand() == 3 + 6/k
+
+    Y = Gamma('y', 2*k, 3*theta)
+    assert coskewness(X, theta*X + Y, k*X + Y).simplify() == \
+        2*531441**(-k)*sqrt(k)*theta*(3*3**(12*k) - 2*531441**k) \
+        /(sqrt(k**2 + 18)*sqrt(theta**2 + 18))
+
+def test_gamma_inverse():
+    a = Symbol("a", positive=True)
+    b = Symbol("b", positive=True)
+    X = GammaInverse("x", a, b)
+    assert density(X)(x) == x**(-a - 1)*b**a*exp(-b/x)/gamma(a)
+    assert cdf(X)(x) == Piecewise((uppergamma(a, b/x)/gamma(a), x > 0), (0, True))
+    assert characteristic_function(X)(x) == 2 * (-I*b*x)**(a/2) \
+            * besselk(a, 2*sqrt(b)*sqrt(-I*x))/gamma(a)
+    raises(NotImplementedError, lambda: moment_generating_function(X))
+
+def test_gompertz():
+    b = Symbol("b", positive=True)
+    eta = Symbol("eta", positive=True)
+
+    X = Gompertz("x", b, eta)
+
+    assert density(X)(x) == b*eta*exp(eta)*exp(b*x)*exp(-eta*exp(b*x))
+    assert cdf(X)(x) == 1 - exp(eta)*exp(-eta*exp(b*x))
+    assert diff(cdf(X)(x), x) == density(X)(x)
+
+
+def test_gumbel():
+    beta = Symbol("beta", positive=True)
+    mu = Symbol("mu")
+    x = Symbol("x")
+    y = Symbol("y")
+    X = Gumbel("x", beta, mu)
+    Y = Gumbel("y", beta, mu, minimum=True)
+    assert density(X)(x).expand() == \
+    exp(mu/beta)*exp(-x/beta)*exp(-exp(mu/beta)*exp(-x/beta))/beta
+    assert density(Y)(y).expand() == \
+    exp(-mu/beta)*exp(y/beta)*exp(-exp(-mu/beta)*exp(y/beta))/beta
+    assert cdf(X)(x).expand() == \
+    exp(-exp(mu/beta)*exp(-x/beta))
+    assert characteristic_function(X)(x) == exp(I*mu*x)*gamma(-I*beta*x + 1)
+
+def test_kumaraswamy():
+    a = Symbol("a", positive=True)
+    b = Symbol("b", positive=True)
+
+    X = Kumaraswamy("x", a, b)
+    assert density(X)(x) == x**(a - 1)*a*b*(-x**a + 1)**(b - 1)
+    assert cdf(X)(x) == Piecewise((0, x < 0),
+                                (-(-x**a + 1)**b + 1, x <= 1),
+                                (1, True))
+
+
+def test_laplace():
+    mu = Symbol("mu")
+    b = Symbol("b", positive=True)
+
+    X = Laplace('x', mu, b)
+
+    #Tests characteristic_function
+    assert characteristic_function(X)(x) == (exp(I*mu*x)/(b**2*x**2 + 1))
+
+    assert density(X)(x) == exp(-Abs(x - mu)/b)/(2*b)
+    assert cdf(X)(x) == Piecewise((exp((-mu + x)/b)/2, mu > x),
+                            (-exp((mu - x)/b)/2 + 1, True))
+    X = Laplace('x', [1, 2], [[1, 0], [0, 1]])
+    assert isinstance(pspace(X).distribution, MultivariateLaplaceDistribution)
+
+def test_levy():
+    mu = Symbol("mu", real=True)
+    c = Symbol("c", positive=True)
+
+    X = Levy('x', mu, c)
+    assert X.pspace.domain.set == Interval(mu, oo)
+    assert density(X)(x) == sqrt(c/(2*pi))*exp(-c/(2*(x - mu)))/((x - mu)**(S.One + S.Half))
+    assert cdf(X)(x) == erfc(sqrt(c/(2*(x - mu))))
+
+    raises(NotImplementedError, lambda: moment_generating_function(X))
+    mu = Symbol("mu", real=False)
+    raises(ValueError, lambda: Levy('x',mu,c))
+
+    c = Symbol("c", nonpositive=True)
+    raises(ValueError, lambda: Levy('x',mu,c))
+
+    mu = Symbol("mu", real=True)
+    raises(ValueError, lambda: Levy('x',mu,c))
+
+def test_logcauchy():
+    mu = Symbol("mu", positive=True)
+    sigma = Symbol("sigma", positive=True)
+
+    X = LogCauchy("x", mu, sigma)
+
+    assert density(X)(x) == sigma/(x*pi*(sigma**2 + (-mu + log(x))**2))
+    assert cdf(X)(x) == atan((log(x) - mu)/sigma)/pi + S.Half
+
+
+def test_logistic():
+    mu = Symbol("mu", real=True)
+    s = Symbol("s", positive=True)
+    p = Symbol("p", positive=True)
+
+    X = Logistic('x', mu, s)
+
+    #Tests characteristics_function
+    assert characteristic_function(X)(x) == \
+           (Piecewise((pi*s*x*exp(I*mu*x)/sinh(pi*s*x), Ne(x, 0)), (1, True)))
+
+    assert density(X)(x) == exp((-x + mu)/s)/(s*(exp((-x + mu)/s) + 1)**2)
+    assert cdf(X)(x) == 1/(exp((mu - x)/s) + 1)
+    assert quantile(X)(p) == mu - s*log(-S.One + 1/p)
+
+def test_loglogistic():
+    a, b = symbols('a b')
+    assert LogLogistic('x', a, b)
+
+    a = Symbol('a', negative=True)
+    b = Symbol('b', positive=True)
+    raises(ValueError, lambda: LogLogistic('x', a, b))
+
+    a = Symbol('a', positive=True)
+    b = Symbol('b', negative=True)
+    raises(ValueError, lambda: LogLogistic('x', a, b))
+
+    a, b, z, p = symbols('a b z p', positive=True)
+    X = LogLogistic('x', a, b)
+    assert density(X)(z) == b*(z/a)**(b - 1)/(a*((z/a)**b + 1)**2)
+    assert cdf(X)(z) == 1/(1 + (z/a)**(-b))
+    assert quantile(X)(p) == a*(p/(1 - p))**(1/b)
+
+    # Expectation
+    assert E(X) == Piecewise((S.NaN, b <= 1), (pi*a/(b*sin(pi/b)), True))
+    b = symbols('b', prime=True) # b > 1
+    X = LogLogistic('x', a, b)
+    assert E(X) == pi*a/(b*sin(pi/b))
+    X = LogLogistic('x', 1, 2)
+    assert median(X) == FiniteSet(1)
+
+def test_logitnormal():
+    mu = Symbol('mu', real=True)
+    s = Symbol('s', positive=True)
+    X = LogitNormal('x', mu, s)
+    x = Symbol('x')
+
+    assert density(X)(x) == sqrt(2)*exp(-(-mu + log(x/(1 - x)))**2/(2*s**2))/(2*sqrt(pi)*s*x*(1 - x))
+    assert cdf(X)(x) == erf(sqrt(2)*(-mu + log(x/(1 - x)))/(2*s))/2 + S(1)/2
+
+def test_lognormal():
+    mean = Symbol('mu', real=True)
+    std = Symbol('sigma', positive=True)
+    X = LogNormal('x', mean, std)
+    # The sympy integrator can't do this too well
+    #assert E(X) == exp(mean+std**2/2)
+    #assert variance(X) == (exp(std**2)-1) * exp(2*mean + std**2)
+
+    # The sympy integrator can't do this too well
+    #assert E(X) ==
+    raises(NotImplementedError, lambda: moment_generating_function(X))
+    mu = Symbol("mu", real=True)
+    sigma = Symbol("sigma", positive=True)
+
+    X = LogNormal('x', mu, sigma)
+    assert density(X)(x) == (sqrt(2)*exp(-(-mu + log(x))**2
+                                    /(2*sigma**2))/(2*x*sqrt(pi)*sigma))
+    # Tests cdf
+    assert cdf(X)(x) == Piecewise(
+                        (erf(sqrt(2)*(-mu + log(x))/(2*sigma))/2
+                        + S(1)/2, x > 0), (0, True))
+
+    X = LogNormal('x', 0, 1)  # Mean 0, standard deviation 1
+    assert density(X)(x) == sqrt(2)*exp(-log(x)**2/2)/(2*x*sqrt(pi))
+
+
+def test_Lomax():
+    a, l = symbols('a, l', negative=True)
+    raises(ValueError, lambda: Lomax('X', a, l))
+    a, l = symbols('a, l', real=False)
+    raises(ValueError, lambda: Lomax('X', a, l))
+
+    a, l = symbols('a, l', positive=True)
+    X = Lomax('X', a, l)
+    assert X.pspace.domain.set == Interval(0, oo)
+    assert density(X)(x) == a*(1 + x/l)**(-a - 1)/l
+    assert cdf(X)(x) == Piecewise((1 - (1 + x/l)**(-a), x >= 0), (0, True))
+    a = 3
+    X = Lomax('X', a, l)
+    assert E(X) == l/2
+    assert median(X) == FiniteSet(l*(-1 + 2**Rational(1, 3)))
+    assert variance(X) == 3*l**2/4
+
+
+def test_maxwell():
+    a = Symbol("a", positive=True)
+
+    X = Maxwell('x', a)
+
+    assert density(X)(x) == (sqrt(2)*x**2*exp(-x**2/(2*a**2))/
+        (sqrt(pi)*a**3))
+    assert E(X) == 2*sqrt(2)*a/sqrt(pi)
+    assert variance(X) == -8*a**2/pi + 3*a**2
+    assert cdf(X)(x) == erf(sqrt(2)*x/(2*a)) - sqrt(2)*x*exp(-x**2/(2*a**2))/(sqrt(pi)*a)
+    assert diff(cdf(X)(x), x) == density(X)(x)
+
+
+@slow
+def test_Moyal():
+    mu = Symbol('mu',real=False)
+    sigma = Symbol('sigma', positive=True)
+    raises(ValueError, lambda: Moyal('M',mu, sigma))
+
+    mu = Symbol('mu', real=True)
+    sigma = Symbol('sigma', negative=True)
+    raises(ValueError, lambda: Moyal('M',mu, sigma))
+
+    sigma = Symbol('sigma', positive=True)
+    M = Moyal('M', mu, sigma)
+    assert density(M)(z) == sqrt(2)*exp(-exp((mu - z)/sigma)/2
+                        - (-mu + z)/(2*sigma))/(2*sqrt(pi)*sigma)
+    assert cdf(M)(z).simplify() == 1 - erf(sqrt(2)*exp((mu - z)/(2*sigma))/2)
+    assert characteristic_function(M)(z) == 2**(-I*sigma*z)*exp(I*mu*z) \
+                        *gamma(-I*sigma*z + Rational(1, 2))/sqrt(pi)
+    assert E(M) == mu + EulerGamma*sigma + sigma*log(2)
+    assert moment_generating_function(M)(z) == 2**(-sigma*z)*exp(mu*z) \
+                        *gamma(-sigma*z + Rational(1, 2))/sqrt(pi)
+
+
+def test_nakagami():
+    mu = Symbol("mu", positive=True)
+    omega = Symbol("omega", positive=True)
+
+    X = Nakagami('x', mu, omega)
+    assert density(X)(x) == (2*x**(2*mu - 1)*mu**mu*omega**(-mu)
+                                *exp(-x**2*mu/omega)/gamma(mu))
+    assert simplify(E(X)) == (sqrt(mu)*sqrt(omega)
+                                            *gamma(mu + S.Half)/gamma(mu + 1))
+    assert simplify(variance(X)) == (
+    omega - omega*gamma(mu + S.Half)**2/(gamma(mu)*gamma(mu + 1)))
+    assert cdf(X)(x) == Piecewise(
+                                (lowergamma(mu, mu*x**2/omega)/gamma(mu), x > 0),
+                                (0, True))
+    X = Nakagami('x', 1, 1)
+    assert median(X) == FiniteSet(sqrt(log(2)))
+
+def test_gaussian_inverse():
+    # test for symbolic parameters
+    a, b = symbols('a b')
+    assert GaussianInverse('x', a, b)
+
+    # Inverse Gaussian distribution is also known as Wald distribution
+    # `GaussianInverse` can also be referred by the name `Wald`
+    a, b, z = symbols('a b z')
+    X = Wald('x', a, b)
+    assert density(X)(z) == sqrt(2)*sqrt(b/z**3)*exp(-b*(-a + z)**2/(2*a**2*z))/(2*sqrt(pi))
+
+    a, b = symbols('a b', positive=True)
+    z = Symbol('z', positive=True)
+
+    X = GaussianInverse('x', a, b)
+    assert density(X)(z) == sqrt(2)*sqrt(b)*sqrt(z**(-3))*exp(-b*(-a + z)**2/(2*a**2*z))/(2*sqrt(pi))
+    assert E(X) == a
+    assert variance(X).expand() == a**3/b
+    assert cdf(X)(z) == (S.Half - erf(sqrt(2)*sqrt(b)*(1 + z/a)/(2*sqrt(z)))/2)*exp(2*b/a) +\
+         erf(sqrt(2)*sqrt(b)*(-1 + z/a)/(2*sqrt(z)))/2 + S.Half
+
+    a = symbols('a', nonpositive=True)
+    raises(ValueError, lambda: GaussianInverse('x', a, b))
+
+    a = symbols('a', positive=True)
+    b = symbols('b', nonpositive=True)
+    raises(ValueError, lambda: GaussianInverse('x', a, b))
+
+def test_pareto():
+    xm, beta = symbols('xm beta', positive=True)
+    alpha = beta + 5
+    X = Pareto('x', xm, alpha)
+
+    dens = density(X)
+
+    #Tests cdf function
+    assert cdf(X)(x) == \
+           Piecewise((-x**(-beta - 5)*xm**(beta + 5) + 1, x >= xm), (0, True))
+
+    #Tests characteristic_function
+    assert characteristic_function(X)(x) == \
+           ((-I*x*xm)**(beta + 5)*(beta + 5)*uppergamma(-beta - 5, -I*x*xm))
+
+    assert dens(x) == x**(-(alpha + 1))*xm**(alpha)*(alpha)
+
+    assert simplify(E(X)) == alpha*xm/(alpha-1)
+
+    # computation of taylor series for MGF still too slow
+    #assert simplify(variance(X)) == xm**2*alpha / ((alpha-1)**2*(alpha-2))
+
+
+def test_pareto_numeric():
+    xm, beta = 3, 2
+    alpha = beta + 5
+    X = Pareto('x', xm, alpha)
+
+    assert E(X) == alpha*xm/S(alpha - 1)
+    assert variance(X) == xm**2*alpha / S((alpha - 1)**2*(alpha - 2))
+    assert median(X) == FiniteSet(3*2**Rational(1, 7))
+    # Skewness tests too slow. Try shortcutting function?
+
+
+def test_PowerFunction():
+    alpha = Symbol("alpha", nonpositive=True)
+    a, b = symbols('a, b', real=True)
+    raises (ValueError, lambda: PowerFunction('x', alpha, a, b))
+
+    a, b = symbols('a, b', real=False)
+    raises (ValueError, lambda: PowerFunction('x', alpha, a, b))
+
+    alpha = Symbol("alpha", positive=True)
+    a, b = symbols('a, b', real=True)
+    raises (ValueError, lambda: PowerFunction('x', alpha, 5, 2))
+
+    X = PowerFunction('X', 2, a, b)
+    assert density(X)(z) == (-2*a + 2*z)/(-a + b)**2
+    assert cdf(X)(z) == Piecewise((a**2/(a**2 - 2*a*b + b**2) -
+        2*a*z/(a**2 - 2*a*b + b**2) + z**2/(a**2 - 2*a*b + b**2), a <= z), (0, True))
+
+    X = PowerFunction('X', 2, 0, 1)
+    assert density(X)(z) == 2*z
+    assert cdf(X)(z) == Piecewise((z**2, z >= 0), (0,True))
+    assert E(X) == Rational(2,3)
+    assert P(X < 0) == 0
+    assert P(X < 1) == 1
+    assert median(X) == FiniteSet(1/sqrt(2))
+
+def test_raised_cosine():
+    mu = Symbol("mu", real=True)
+    s = Symbol("s", positive=True)
+
+    X = RaisedCosine("x", mu, s)
+
+    assert pspace(X).domain.set == Interval(mu - s, mu + s)
+    #Tests characteristics_function
+    assert characteristic_function(X)(x) == \
+           Piecewise((exp(-I*pi*mu/s)/2, Eq(x, -pi/s)), (exp(I*pi*mu/s)/2, Eq(x, pi/s)), (pi**2*exp(I*mu*x)*sin(s*x)/(s*x*(-s**2*x**2 + pi**2)), True))
+
+    assert density(X)(x) == (Piecewise(((cos(pi*(x - mu)/s) + 1)/(2*s),
+                          And(x <= mu + s, mu - s <= x)), (0, True)))
+
+
+def test_rayleigh():
+    sigma = Symbol("sigma", positive=True)
+
+    X = Rayleigh('x', sigma)
+
+    #Tests characteristic_function
+    assert characteristic_function(X)(x) == (-sqrt(2)*sqrt(pi)*sigma*x*(erfi(sqrt(2)*sigma*x/2) - I)*exp(-sigma**2*x**2/2)/2 + 1)
+
+    assert density(X)(x) ==  x*exp(-x**2/(2*sigma**2))/sigma**2
+    assert E(X) == sqrt(2)*sqrt(pi)*sigma/2
+    assert variance(X) == -pi*sigma**2/2 + 2*sigma**2
+    assert cdf(X)(x) == 1 - exp(-x**2/(2*sigma**2))
+    assert diff(cdf(X)(x), x) == density(X)(x)
+
+def test_reciprocal():
+    a = Symbol("a", real=True)
+    b = Symbol("b", real=True)
+
+    X = Reciprocal('x', a, b)
+    assert density(X)(x) == 1/(x*(-log(a) + log(b)))
+    assert cdf(X)(x) == Piecewise((log(a)/(log(a) - log(b)) - log(x)/(log(a) - log(b)), a <= x), (0, True))
+    X = Reciprocal('x', 5, 30)
+
+    assert E(X) == 25/(log(30) - log(5))
+    assert P(X < 4) == S.Zero
+    assert P(X < 20) == log(20) / (log(30) - log(5)) - log(5) / (log(30) - log(5))
+    assert cdf(X)(10) == log(10) / (log(30) - log(5)) - log(5) / (log(30) - log(5))
+
+    a = symbols('a', nonpositive=True)
+    raises(ValueError, lambda: Reciprocal('x', a, b))
+
+    a = symbols('a', positive=True)
+    b = symbols('b', positive=True)
+    raises(ValueError, lambda: Reciprocal('x', a + b, a))
+
+def test_shiftedgompertz():
+    b = Symbol("b", positive=True)
+    eta = Symbol("eta", positive=True)
+    X = ShiftedGompertz("x", b, eta)
+    assert density(X)(x) == b*(eta*(1 - exp(-b*x)) + 1)*exp(-b*x)*exp(-eta*exp(-b*x))
+
+
+def test_studentt():
+    nu = Symbol("nu", positive=True)
+
+    X = StudentT('x', nu)
+    assert density(X)(x) == (1 + x**2/nu)**(-nu/2 - S.Half)/(sqrt(nu)*beta(S.Half, nu/2))
+    assert cdf(X)(x) == S.Half + x*gamma(nu/2 + S.Half)*hyper((S.Half, nu/2 + S.Half),
+                                (Rational(3, 2),), -x**2/nu)/(sqrt(pi)*sqrt(nu)*gamma(nu/2))
+    raises(NotImplementedError, lambda: moment_generating_function(X))
+
+def test_trapezoidal():
+    a = Symbol("a", real=True)
+    b = Symbol("b", real=True)
+    c = Symbol("c", real=True)
+    d = Symbol("d", real=True)
+
+    X = Trapezoidal('x', a, b, c, d)
+    assert density(X)(x) == Piecewise(((-2*a + 2*x)/((-a + b)*(-a - b + c + d)), (a <= x) & (x < b)),
+                                      (2/(-a - b + c + d), (b <= x) & (x < c)),
+                                      ((2*d - 2*x)/((-c + d)*(-a - b + c + d)), (c <= x) & (x <= d)),
+                                      (0, True))
+
+    X = Trapezoidal('x', 0, 1, 2, 3)
+    assert E(X) == Rational(3, 2)
+    assert variance(X) == Rational(5, 12)
+    assert P(X < 2) == Rational(3, 4)
+    assert median(X) == FiniteSet(Rational(3, 2))
+
+def test_triangular():
+    a = Symbol("a")
+    b = Symbol("b")
+    c = Symbol("c")
+
+    X = Triangular('x', a, b, c)
+    assert pspace(X).domain.set == Interval(a, b)
+    assert str(density(X)(x)) == ("Piecewise(((-2*a + 2*x)/((-a + b)*(-a + c)), (a <= x) & (c > x)), "
+    "(2/(-a + b), Eq(c, x)), ((2*b - 2*x)/((-a + b)*(b - c)), (b >= x) & (c < x)), (0, True))")
+
+    #Tests moment_generating_function
+    assert moment_generating_function(X)(x).expand() == \
+    ((-2*(-a + b)*exp(c*x) + 2*(-a + c)*exp(b*x) + 2*(b - c)*exp(a*x))/(x**2*(-a + b)*(-a + c)*(b - c))).expand()
+    assert str(characteristic_function(X)(x)) == \
+    '(2*(-a + b)*exp(I*c*x) - 2*(-a + c)*exp(I*b*x) - 2*(b - c)*exp(I*a*x))/(x**2*(-a + b)*(-a + c)*(b - c))'
+
+def test_quadratic_u():
+    a = Symbol("a", real=True)
+    b = Symbol("b", real=True)
+
+    X = QuadraticU("x", a, b)
+    Y = QuadraticU("x", 1, 2)
+
+    assert pspace(X).domain.set == Interval(a, b)
+    # Tests _moment_generating_function
+    assert moment_generating_function(Y)(1)  == -15*exp(2) + 27*exp(1)
+    assert moment_generating_function(Y)(2) == -9*exp(4)/2 + 21*exp(2)/2
+
+    assert characteristic_function(Y)(1) == 3*I*(-1 + 4*I)*exp(I*exp(2*I))
+    assert density(X)(x) == (Piecewise((12*(x - a/2 - b/2)**2/(-a + b)**3,
+                          And(x <= b, a <= x)), (0, True)))
+
+
+def test_uniform():
+    l = Symbol('l', real=True)
+    w = Symbol('w', positive=True)
+    X = Uniform('x', l, l + w)
+
+    assert E(X) == l + w/2
+    assert variance(X).expand() == w**2/12
+
+    # With numbers all is well
+    X = Uniform('x', 3, 5)
+    assert P(X < 3) == 0 and P(X > 5) == 0
+    assert P(X < 4) == P(X > 4) == S.Half
+    assert median(X) == FiniteSet(4)
+
+    z = Symbol('z')
+    p = density(X)(z)
+    assert p.subs(z, 3.7) == S.Half
+    assert p.subs(z, -1) == 0
+    assert p.subs(z, 6) == 0
+
+    c = cdf(X)
+    assert c(2) == 0 and c(3) == 0
+    assert c(Rational(7, 2)) == Rational(1, 4)
+    assert c(5) == 1 and c(6) == 1
+
+
+@XFAIL
+@slow
+def test_uniform_P():
+    """ This stopped working because SingleContinuousPSpace.compute_density no
+    longer calls integrate on a DiracDelta but rather just solves directly.
+    integrate used to call UniformDistribution.expectation which special-cased
+    subsed out the Min and Max terms that Uniform produces
+
+    I decided to regress on this class for general cleanliness (and I suspect
+    speed) of the algorithm.
+    """
+    l = Symbol('l', real=True)
+    w = Symbol('w', positive=True)
+    X = Uniform('x', l, l + w)
+    assert P(X < l) == 0 and P(X > l + w) == 0
+
+
+def test_uniformsum():
+    n = Symbol("n", integer=True)
+    _k = Dummy("k")
+    x = Symbol("x")
+
+    X = UniformSum('x', n)
+    res = Sum((-1)**_k*(-_k + x)**(n - 1)*binomial(n, _k), (_k, 0, floor(x)))/factorial(n - 1)
+    assert density(X)(x).dummy_eq(res)
+
+    #Tests set functions
+    assert X.pspace.domain.set == Interval(0, n)
+
+    #Tests the characteristic_function
+    assert characteristic_function(X)(x) == (-I*(exp(I*x) - 1)/x)**n
+
+    #Tests the moment_generating_function
+    assert moment_generating_function(X)(x) == ((exp(x) - 1)/x)**n
+
+
+def test_von_mises():
+    mu = Symbol("mu")
+    k = Symbol("k", positive=True)
+
+    X = VonMises("x", mu, k)
+    assert density(X)(x) == exp(k*cos(x - mu))/(2*pi*besseli(0, k))
+
+
+def test_weibull():
+    a, b = symbols('a b', positive=True)
+    # FIXME: simplify(E(X)) seems to hang without extended_positive=True
+    # On a Linux machine this had a rapid memory leak...
+    # a, b = symbols('a b', positive=True)
+    X = Weibull('x', a, b)
+
+    assert E(X).expand() == a * gamma(1 + 1/b)
+    assert variance(X).expand() == (a**2 * gamma(1 + 2/b) - E(X)**2).expand()
+    assert simplify(skewness(X)) == (2*gamma(1 + 1/b)**3 - 3*gamma(1 + 1/b)*gamma(1 + 2/b) + gamma(1 + 3/b))/(-gamma(1 + 1/b)**2 + gamma(1 + 2/b))**Rational(3, 2)
+    assert simplify(kurtosis(X)) == (-3*gamma(1 + 1/b)**4 +\
+        6*gamma(1 + 1/b)**2*gamma(1 + 2/b) - 4*gamma(1 + 1/b)*gamma(1 + 3/b) + gamma(1 + 4/b))/(gamma(1 + 1/b)**2 - gamma(1 + 2/b))**2
+
+def test_weibull_numeric():
+    # Test for integers and rationals
+    a = 1
+    bvals = [S.Half, 1, Rational(3, 2), 5]
+    for b in bvals:
+        X = Weibull('x', a, b)
+        assert simplify(E(X)) == expand_func(a * gamma(1 + 1/S(b)))
+        assert simplify(variance(X)) == simplify(
+            a**2 * gamma(1 + 2/S(b)) - E(X)**2)
+        # Not testing Skew... it's slow with int/frac values > 3/2
+
+
+def test_wignersemicircle():
+    R = Symbol("R", positive=True)
+
+    X = WignerSemicircle('x', R)
+    assert pspace(X).domain.set == Interval(-R, R)
+    assert density(X)(x) == 2*sqrt(-x**2 + R**2)/(pi*R**2)
+    assert E(X) == 0
+
+
+    #Tests ChiNoncentralDistribution
+    assert characteristic_function(X)(x) == \
+           Piecewise((2*besselj(1, R*x)/(R*x), Ne(x, 0)), (1, True))
+
+
+def test_input_value_assertions():
+    a, b = symbols('a b')
+    p, q = symbols('p q', positive=True)
+    m, n = symbols('m n', positive=False, real=True)
+
+    raises(ValueError, lambda: Normal('x', 3, 0))
+    raises(ValueError, lambda: Normal('x', m, n))
+    Normal('X', a, p)  # No error raised
+    raises(ValueError, lambda: Exponential('x', m))
+    Exponential('Ex', p)  # No error raised
+    for fn in [Pareto, Weibull, Beta, Gamma]:
+        raises(ValueError, lambda: fn('x', m, p))
+        raises(ValueError, lambda: fn('x', p, n))
+        fn('x', p, q)  # No error raised
+
+
+def test_unevaluated():
+    X = Normal('x', 0, 1)
+    k = Dummy('k')
+    expr1 = Integral(sqrt(2)*k*exp(-k**2/2)/(2*sqrt(pi)), (k, -oo, oo))
+    expr2 = Integral(sqrt(2)*exp(-k**2/2)/(2*sqrt(pi)), (k, 0, oo))
+    with ignore_warnings(UserWarning): ### TODO: Restore tests once warnings are removed
+        assert E(X, evaluate=False).rewrite(Integral).dummy_eq(expr1)
+        assert E(X + 1, evaluate=False).rewrite(Integral).dummy_eq(expr1 + 1)
+        assert P(X > 0, evaluate=False).rewrite(Integral).dummy_eq(expr2)
+
+    assert P(X > 0, X**2 < 1) == S.Half
+
+
+def test_probability_unevaluated():
+    T = Normal('T', 30, 3)
+    with ignore_warnings(UserWarning): ### TODO: Restore tests once warnings are removed
+        assert type(P(T > 33, evaluate=False)) == Probability
+
+
+def test_density_unevaluated():
+    X = Normal('X', 0, 1)
+    Y = Normal('Y', 0, 2)
+    assert isinstance(density(X+Y, evaluate=False)(z), Integral)
+
+
+def test_NormalDistribution():
+    nd = NormalDistribution(0, 1)
+    x = Symbol('x')
+    assert nd.cdf(x) == erf(sqrt(2)*x/2)/2 + S.Half
+    assert nd.expectation(1, x) == 1
+    assert nd.expectation(x, x) == 0
+    assert nd.expectation(x**2, x) == 1
+    #Test issue 10076
+    a = SingleContinuousPSpace(x, NormalDistribution(2, 4))
+    _z = Dummy('_z')
+
+    expected1 = Integral(sqrt(2)*exp(-(_z - 2)**2/32)/(8*sqrt(pi)),(_z, -oo, 1))
+    assert a.probability(x < 1, evaluate=False).dummy_eq(expected1) is True
+
+    expected2 = Integral(sqrt(2)*exp(-(_z - 2)**2/32)/(8*sqrt(pi)),(_z, 1, oo))
+    assert a.probability(x > 1, evaluate=False).dummy_eq(expected2) is True
+
+    b = SingleContinuousPSpace(x, NormalDistribution(1, 9))
+
+    expected3 = Integral(sqrt(2)*exp(-(_z - 1)**2/162)/(18*sqrt(pi)),(_z, 6, oo))
+    assert b.probability(x > 6, evaluate=False).dummy_eq(expected3) is True
+
+    expected4 = Integral(sqrt(2)*exp(-(_z - 1)**2/162)/(18*sqrt(pi)),(_z, -oo, 6))
+    assert b.probability(x < 6, evaluate=False).dummy_eq(expected4) is True
+
+
+def test_random_parameters():
+    mu = Normal('mu', 2, 3)
+    meas = Normal('T', mu, 1)
+    assert density(meas, evaluate=False)(z)
+    assert isinstance(pspace(meas), CompoundPSpace)
+    X = Normal('x', [1, 2], [[1, 0], [0, 1]])
+    assert isinstance(pspace(X).distribution, MultivariateNormalDistribution)
+    assert density(meas)(z).simplify() == sqrt(5)*exp(-z**2/20 + z/5 - S(1)/5)/(10*sqrt(pi))
+
+
+def test_random_parameters_given():
+    mu = Normal('mu', 2, 3)
+    meas = Normal('T', mu, 1)
+    assert given(meas, Eq(mu, 5)) == Normal('T', 5, 1)
+
+
+def test_conjugate_priors():
+    mu = Normal('mu', 2, 3)
+    x = Normal('x', mu, 1)
+    assert isinstance(simplify(density(mu, Eq(x, y), evaluate=False)(z)),
+            Mul)
+
+
+def test_difficult_univariate():
+    """ Since using solve in place of deltaintegrate we're able to perform
+    substantially more complex density computations on single continuous random
+    variables """
+    x = Normal('x', 0, 1)
+    assert density(x**3)
+    assert density(exp(x**2))
+    assert density(log(x))
+
+
+def test_issue_10003():
+    X = Exponential('x', 3)
+    G = Gamma('g', 1, 2)
+    assert P(X < -1) is S.Zero
+    assert P(G < -1) is S.Zero
+
+
+def test_precomputed_cdf():
+    x = symbols("x", real=True)
+    mu = symbols("mu", real=True)
+    sigma, xm, alpha = symbols("sigma xm alpha", positive=True)
+    n = symbols("n", integer=True, positive=True)
+    distribs = [
+            Normal("X", mu, sigma),
+            Pareto("P", xm, alpha),
+            ChiSquared("C", n),
+            Exponential("E", sigma),
+            # LogNormal("L", mu, sigma),
+    ]
+    for X in distribs:
+        compdiff = cdf(X)(x) - simplify(X.pspace.density.compute_cdf()(x))
+        compdiff = simplify(compdiff.rewrite(erfc))
+        assert compdiff == 0
+
+
+@slow
+def test_precomputed_characteristic_functions():
+    import mpmath
+
+    def test_cf(dist, support_lower_limit, support_upper_limit):
+        pdf = density(dist)
+        t = Symbol('t')
+
+        # first function is the hardcoded CF of the distribution
+        cf1 = lambdify([t], characteristic_function(dist)(t), 'mpmath')
+
+        # second function is the Fourier transform of the density function
+        f = lambdify([x, t], pdf(x)*exp(I*x*t), 'mpmath')
+        cf2 = lambda t: mpmath.quad(lambda x: f(x, t), [support_lower_limit, support_upper_limit], maxdegree=10)
+
+        # compare the two functions at various points
+        for test_point in [2, 5, 8, 11]:
+            n1 = cf1(test_point)
+            n2 = cf2(test_point)
+
+            assert abs(re(n1) - re(n2)) < 1e-12
+            assert abs(im(n1) - im(n2)) < 1e-12
+
+    test_cf(Beta('b', 1, 2), 0, 1)
+    test_cf(Chi('c', 3), 0, mpmath.inf)
+    test_cf(ChiSquared('c', 2), 0, mpmath.inf)
+    test_cf(Exponential('e', 6), 0, mpmath.inf)
+    test_cf(Logistic('l', 1, 2), -mpmath.inf, mpmath.inf)
+    test_cf(Normal('n', -1, 5), -mpmath.inf, mpmath.inf)
+    test_cf(RaisedCosine('r', 3, 1), 2, 4)
+    test_cf(Rayleigh('r', 0.5), 0, mpmath.inf)
+    test_cf(Uniform('u', -1, 1), -1, 1)
+    test_cf(WignerSemicircle('w', 3), -3, 3)
+
+
+def test_long_precomputed_cdf():
+    x = symbols("x", real=True)
+    distribs = [
+            Arcsin("A", -5, 9),
+            Dagum("D", 4, 10, 3),
+            Erlang("E", 14, 5),
+            Frechet("F", 2, 6, -3),
+            Gamma("G", 2, 7),
+            GammaInverse("GI", 3, 5),
+            Kumaraswamy("K", 6, 8),
+            Laplace("LA", -5, 4),
+            Logistic("L", -6, 7),
+            Nakagami("N", 2, 7),
+            StudentT("S", 4)
+            ]
+    for distr in distribs:
+        for _ in range(5):
+            assert tn(diff(cdf(distr)(x), x), density(distr)(x), x, a=0, b=0, c=1, d=0)
+
+    US = UniformSum("US", 5)
+    pdf01 = density(US)(x).subs(floor(x), 0).doit()   # pdf on (0, 1)
+    cdf01 = cdf(US, evaluate=False)(x).subs(floor(x), 0).doit()   # cdf on (0, 1)
+    assert tn(diff(cdf01, x), pdf01, x, a=0, b=0, c=1, d=0)
+
+
+def test_issue_13324():
+    X = Uniform('X', 0, 1)
+    assert E(X, X > S.Half) == Rational(3, 4)
+    assert E(X, X > 0) == S.Half
+
+def test_issue_20756():
+    X = Uniform('X', -1, +1)
+    Y = Uniform('Y', -1, +1)
+    assert E(X * Y) == S.Zero
+    assert E(X * ((Y + 1) - 1)) == S.Zero
+    assert E(Y * (X*(X + 1) - X*X)) == S.Zero
+
+def test_FiniteSet_prob():
+    E = Exponential('E', 3)
+    N = Normal('N', 5, 7)
+    assert P(Eq(E, 1)) is S.Zero
+    assert P(Eq(N, 2)) is S.Zero
+    assert P(Eq(N, x)) is S.Zero
+
+def test_prob_neq():
+    E = Exponential('E', 4)
+    X = ChiSquared('X', 4)
+    assert P(Ne(E, 2)) == 1
+    assert P(Ne(X, 4)) == 1
+    assert P(Ne(X, 4)) == 1
+    assert P(Ne(X, 5)) == 1
+    assert P(Ne(E, x)) == 1
+
+def test_union():
+    N = Normal('N', 3, 2)
+    assert simplify(P(N**2 - N > 2)) == \
+        -erf(sqrt(2))/2 - erfc(sqrt(2)/4)/2 + Rational(3, 2)
+    assert simplify(P(N**2 - 4 > 0)) == \
+        -erf(5*sqrt(2)/4)/2 - erfc(sqrt(2)/4)/2 + Rational(3, 2)
+
+def test_Or():
+    N = Normal('N', 0, 1)
+    assert simplify(P(Or(N > 2, N < 1))) == \
+        -erf(sqrt(2))/2 - erfc(sqrt(2)/2)/2 + Rational(3, 2)
+    assert P(Or(N < 0, N < 1)) == P(N < 1)
+    assert P(Or(N > 0, N < 0)) == 1
+
+
+def test_conditional_eq():
+    E = Exponential('E', 1)
+    assert P(Eq(E, 1), Eq(E, 1)) == 1
+    assert P(Eq(E, 1), Eq(E, 2)) == 0
+    assert P(E > 1, Eq(E, 2)) == 1
+    assert P(E < 1, Eq(E, 2)) == 0
+
+def test_ContinuousDistributionHandmade():
+    x = Symbol('x')
+    z = Dummy('z')
+    dens = Lambda(x, Piecewise((S.Half, (0<=x)&(x<1)), (0, (x>=1)&(x<2)),
+        (S.Half, (x>=2)&(x<3)), (0, True)))
+    dens = ContinuousDistributionHandmade(dens, set=Interval(0, 3))
+    space = SingleContinuousPSpace(z, dens)
+    assert dens.pdf == Lambda(x, Piecewise((S(1)/2, (x >= 0) & (x < 1)),
+        (0, (x >= 1) & (x < 2)), (S(1)/2, (x >= 2) & (x < 3)), (0, True)))
+    assert median(space.value) == Interval(1, 2)
+    assert E(space.value) == Rational(3, 2)
+    assert variance(space.value) == Rational(13, 12)
+
+
+def test_issue_16318():
+    # test compute_expectation function of the SingleContinuousDomain
+    N = SingleContinuousDomain(x, Interval(0, 1))
+    raises(ValueError, lambda: SingleContinuousDomain.compute_expectation(N, x+1, {x, y}))
+
+def test_compute_density():
+    X = Normal('X', 0, Symbol("sigma")**2)
+    raises(ValueError, lambda: density(X**5 + X))
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/tests/test_discrete_rv.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/tests/test_discrete_rv.py
new file mode 100644
index 0000000000000000000000000000000000000000..39650a1a08e42840aaf8b06c1eb6e60c92a57f23
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/tests/test_discrete_rv.py
@@ -0,0 +1,312 @@
+from sympy.concrete.summations import Sum
+from sympy.core.numbers import (I, Rational, oo, pi)
+from sympy.core.singleton import S
+from sympy.core.symbol import Symbol
+from sympy.functions.elementary.complexes import (im, re)
+from sympy.functions.elementary.exponential import log
+from sympy.functions.elementary.integers import floor
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.piecewise import Piecewise
+from sympy.functions.special.bessel import besseli
+from sympy.functions.special.beta_functions import beta
+from sympy.functions.special.zeta_functions import zeta
+from sympy.sets.sets import FiniteSet
+from sympy.simplify.simplify import simplify
+from sympy.utilities.lambdify import lambdify
+from sympy.core.relational import Eq, Ne
+from sympy.functions.elementary.exponential import exp
+from sympy.logic.boolalg import Or
+from sympy.sets.fancysets import Range
+from sympy.stats import (P, E, variance, density, characteristic_function,
+                         where, moment_generating_function, skewness, cdf,
+                         kurtosis, coskewness)
+from sympy.stats.drv_types import (PoissonDistribution, GeometricDistribution,
+                                   FlorySchulz, Poisson, Geometric, Hermite, Logarithmic,
+                                    NegativeBinomial, Skellam, YuleSimon, Zeta,
+                                    DiscreteRV)
+from sympy.testing.pytest import slow, nocache_fail, raises, skip
+from sympy.stats.symbolic_probability import Expectation
+from sympy.functions.combinatorial.factorials import FallingFactorial
+
+x = Symbol('x')
+
+
+def test_PoissonDistribution():
+    l = 3
+    p = PoissonDistribution(l)
+    assert abs(p.cdf(10).evalf() - 1) < .001
+    assert abs(p.cdf(10.4).evalf() - 1) < .001
+    assert p.expectation(x, x) == l
+    assert p.expectation(x**2, x) - p.expectation(x, x)**2 == l
+
+
+def test_Poisson():
+    l = 3
+    x = Poisson('x', l)
+    assert E(x) == l
+    assert E(2*x) == 2*l
+    assert variance(x) == l
+    assert density(x) == PoissonDistribution(l)
+    assert isinstance(E(x, evaluate=False), Expectation)
+    assert isinstance(E(2*x, evaluate=False), Expectation)
+    # issue 8248
+    assert x.pspace.compute_expectation(1) == 1
+    # issue 27344
+    try:
+        import numpy as np
+    except ImportError:
+        skip("numpy not installed")
+    y = Poisson('y', np.float64(4.72544290380919e-11))
+    assert E(y) == 4.72544290380919e-11
+    y = Poisson('y', np.float64(4.725442903809197e-11))
+    assert E(y) == 4.725442903809197e-11
+    l2 = 5
+    z = Poisson('z', l2)
+    assert E(z) == l2
+    assert E(FallingFactorial(z, 3)) == l2**3
+    assert E(z**2) == l2 + l2**2
+
+
+def test_FlorySchulz():
+    a = Symbol("a")
+    z = Symbol("z")
+    x = FlorySchulz('x', a)
+    assert E(x) == (2 - a)/a
+    assert (variance(x) - 2*(1 - a)/a**2).simplify() == S(0)
+    assert density(x)(z) == a**2*z*(1 - a)**(z - 1)
+
+
+@slow
+def test_GeometricDistribution():
+    p = S.One / 5
+    d = GeometricDistribution(p)
+    assert d.expectation(x, x) == 1/p
+    assert d.expectation(x**2, x) - d.expectation(x, x)**2 == (1-p)/p**2
+    assert abs(d.cdf(20000).evalf() - 1) < .001
+    assert abs(d.cdf(20000.8).evalf() - 1) < .001
+    G = Geometric('G', p=S(1)/4)
+    assert cdf(G)(S(7)/2) == P(G <= S(7)/2)
+
+    X = Geometric('X', Rational(1, 5))
+    Y = Geometric('Y', Rational(3, 10))
+    assert coskewness(X, X + Y, X + 2*Y).simplify() == sqrt(230)*Rational(81, 1150)
+
+
+def test_Hermite():
+    a1 = Symbol("a1", positive=True)
+    a2 = Symbol("a2", negative=True)
+    raises(ValueError, lambda: Hermite("H", a1, a2))
+
+    a1 = Symbol("a1", negative=True)
+    a2 = Symbol("a2", positive=True)
+    raises(ValueError, lambda: Hermite("H", a1, a2))
+
+    a1 = Symbol("a1", positive=True)
+    x = Symbol("x")
+    H = Hermite("H", a1, a2)
+    assert moment_generating_function(H)(x) == exp(a1*(exp(x) - 1)
+                                            + a2*(exp(2*x) - 1))
+    assert characteristic_function(H)(x) == exp(a1*(exp(I*x) - 1)
+                                            + a2*(exp(2*I*x) - 1))
+    assert E(H) == a1 + 2*a2
+
+    H = Hermite("H", a1=5, a2=4)
+    assert density(H)(2) == 33*exp(-9)/2
+    assert E(H) == 13
+    assert variance(H) == 21
+    assert kurtosis(H) == Rational(464,147)
+    assert skewness(H) == 37*sqrt(21)/441
+
+def test_Logarithmic():
+    p = S.Half
+    x = Logarithmic('x', p)
+    assert E(x) == -p / ((1 - p) * log(1 - p))
+    assert variance(x) == -1/log(2)**2 + 2/log(2)
+    assert E(2*x**2 + 3*x + 4) == 4 + 7 / log(2)
+    assert isinstance(E(x, evaluate=False), Expectation)
+
+
+@nocache_fail
+def test_negative_binomial():
+    r = 5
+    p = S.One / 3
+    x = NegativeBinomial('x', r, p)
+    assert E(x) == r * (1 - p) / p
+    # This hangs when run with the cache disabled:
+    assert variance(x) == r * (1 - p) / p**2
+    assert E(x**5 + 2*x + 3) == E(x**5) + 2*E(x) + 3 == Rational(796473, 1)
+    assert isinstance(E(x, evaluate=False), Expectation)
+
+
+def test_skellam():
+    mu1 = Symbol('mu1')
+    mu2 = Symbol('mu2')
+    z = Symbol('z')
+    X = Skellam('x', mu1, mu2)
+
+    assert density(X)(z) == (mu1/mu2)**(z/2) * \
+        exp(-mu1 - mu2)*besseli(z, 2*sqrt(mu1*mu2))
+    assert skewness(X).expand() == mu1/(mu1*sqrt(mu1 + mu2) + mu2 *
+                sqrt(mu1 + mu2)) - mu2/(mu1*sqrt(mu1 + mu2) + mu2*sqrt(mu1 + mu2))
+    assert variance(X).expand() == mu1 + mu2
+    assert E(X) == mu1 - mu2
+    assert characteristic_function(X)(z) == exp(
+        mu1*exp(I*z) - mu1 - mu2 + mu2*exp(-I*z))
+    assert moment_generating_function(X)(z) == exp(
+        mu1*exp(z) - mu1 - mu2 + mu2*exp(-z))
+
+
+def test_yule_simon():
+    from sympy.core.singleton import S
+    rho = S(3)
+    x = YuleSimon('x', rho)
+    assert simplify(E(x)) == rho / (rho - 1)
+    assert simplify(variance(x)) == rho**2 / ((rho - 1)**2 * (rho - 2))
+    assert isinstance(E(x, evaluate=False), Expectation)
+    # To test the cdf function
+    assert cdf(x)(x) == Piecewise((-beta(floor(x), 4)*floor(x) + 1, x >= 1), (0, True))
+
+
+def test_zeta():
+    s = S(5)
+    x = Zeta('x', s)
+    assert E(x) == zeta(s-1) / zeta(s)
+    assert simplify(variance(x)) == (
+        zeta(s) * zeta(s-2) - zeta(s-1)**2) / zeta(s)**2
+
+
+def test_discrete_probability():
+    X = Geometric('X', Rational(1, 5))
+    Y = Poisson('Y', 4)
+    G = Geometric('e', x)
+    assert P(Eq(X, 3)) == Rational(16, 125)
+    assert P(X < 3) == Rational(9, 25)
+    assert P(X > 3) == Rational(64, 125)
+    assert P(X >= 3) == Rational(16, 25)
+    assert P(X <= 3) == Rational(61, 125)
+    assert P(Ne(X, 3)) == Rational(109, 125)
+    assert P(Eq(Y, 3)) == 32*exp(-4)/3
+    assert P(Y < 3) == 13*exp(-4)
+    assert P(Y > 3).equals(32*(Rational(-71, 32) + 3*exp(4)/32)*exp(-4)/3)
+    assert P(Y >= 3).equals(32*(Rational(-39, 32) + 3*exp(4)/32)*exp(-4)/3)
+    assert P(Y <= 3) == 71*exp(-4)/3
+    assert P(Ne(Y, 3)).equals(
+        13*exp(-4) + 32*(Rational(-71, 32) + 3*exp(4)/32)*exp(-4)/3)
+    assert P(X < S.Infinity) is S.One
+    assert P(X > S.Infinity) is S.Zero
+    assert P(G < 3) == x*(2-x)
+    assert P(Eq(G, 3)) == x*(-x + 1)**2
+
+
+def test_DiscreteRV():
+    p = S(1)/2
+    x = Symbol('x', integer=True, positive=True)
+    pdf = p*(1 - p)**(x - 1) # pdf of Geometric Distribution
+    D = DiscreteRV(x, pdf, set=S.Naturals, check=True)
+    assert E(D) == E(Geometric('G', S(1)/2)) == 2
+    assert P(D > 3) == S(1)/8
+    assert D.pspace.domain.set == S.Naturals
+    raises(ValueError, lambda: DiscreteRV(x, x, FiniteSet(*range(4)), check=True))
+
+    # purposeful invalid pmf but it should not raise since check=False
+    # see test_drv_types.test_ContinuousRV for explanation
+    X = DiscreteRV(x, 1/x, S.Naturals)
+    assert P(X < 2) == 1
+    assert E(X) == oo
+
+def test_precomputed_characteristic_functions():
+    import mpmath
+
+    def test_cf(dist, support_lower_limit, support_upper_limit):
+        pdf = density(dist)
+        t = S('t')
+        x = S('x')
+
+        # first function is the hardcoded CF of the distribution
+        cf1 = lambdify([t], characteristic_function(dist)(t), 'mpmath')
+
+        # second function is the Fourier transform of the density function
+        f = lambdify([x, t], pdf(x)*exp(I*x*t), 'mpmath')
+        cf2 = lambda t: mpmath.nsum(lambda x: f(x, t), [
+            support_lower_limit, support_upper_limit], maxdegree=10)
+
+        # compare the two functions at various points
+        for test_point in [2, 5, 8, 11]:
+            n1 = cf1(test_point)
+            n2 = cf2(test_point)
+
+            assert abs(re(n1) - re(n2)) < 1e-12
+            assert abs(im(n1) - im(n2)) < 1e-12
+
+    test_cf(Geometric('g', Rational(1, 3)), 1, mpmath.inf)
+    test_cf(Logarithmic('l', Rational(1, 5)), 1, mpmath.inf)
+    test_cf(NegativeBinomial('n', 5, Rational(1, 7)), 0, mpmath.inf)
+    test_cf(Poisson('p', 5), 0, mpmath.inf)
+    test_cf(YuleSimon('y', 5), 1, mpmath.inf)
+    test_cf(Zeta('z', 5), 1, mpmath.inf)
+
+
+def test_moment_generating_functions():
+    t = S('t')
+
+    geometric_mgf = moment_generating_function(Geometric('g', S.Half))(t)
+    assert geometric_mgf.diff(t).subs(t, 0) == 2
+
+    logarithmic_mgf = moment_generating_function(Logarithmic('l', S.Half))(t)
+    assert logarithmic_mgf.diff(t).subs(t, 0) == 1/log(2)
+
+    negative_binomial_mgf = moment_generating_function(
+        NegativeBinomial('n', 5, Rational(1, 3)))(t)
+    assert negative_binomial_mgf.diff(t).subs(t, 0) == Rational(10, 1)
+
+    poisson_mgf = moment_generating_function(Poisson('p', 5))(t)
+    assert poisson_mgf.diff(t).subs(t, 0) == 5
+
+    skellam_mgf = moment_generating_function(Skellam('s', 1, 1))(t)
+    assert skellam_mgf.diff(t).subs(
+        t, 2) == (-exp(-2) + exp(2))*exp(-2 + exp(-2) + exp(2))
+
+    yule_simon_mgf = moment_generating_function(YuleSimon('y', 3))(t)
+    assert simplify(yule_simon_mgf.diff(t).subs(t, 0)) == Rational(3, 2)
+
+    zeta_mgf = moment_generating_function(Zeta('z', 5))(t)
+    assert zeta_mgf.diff(t).subs(t, 0) == pi**4/(90*zeta(5))
+
+
+def test_Or():
+    X = Geometric('X', S.Half)
+    assert P(Or(X < 3, X > 4)) == Rational(13, 16)
+    assert P(Or(X > 2, X > 1)) == P(X > 1)
+    assert P(Or(X >= 3, X < 3)) == 1
+
+
+def test_where():
+    X = Geometric('X', Rational(1, 5))
+    Y = Poisson('Y', 4)
+    assert where(X**2 > 4).set == Range(3, S.Infinity, 1)
+    assert where(X**2 >= 4).set == Range(2, S.Infinity, 1)
+    assert where(Y**2 < 9).set == Range(0, 3, 1)
+    assert where(Y**2 <= 9).set == Range(0, 4, 1)
+
+
+def test_conditional():
+    X = Geometric('X', Rational(2, 3))
+    Y = Poisson('Y', 3)
+    assert P(X > 2, X > 3) == 1
+    assert P(X > 3, X > 2) == Rational(1, 3)
+    assert P(Y > 2, Y < 2) == 0
+    assert P(Eq(Y, 3), Y >= 0) == 9*exp(-3)/2
+    assert P(Eq(Y, 3), Eq(Y, 2)) == 0
+    assert P(X < 2, Eq(X, 2)) == 0
+    assert P(X > 2, Eq(X, 3)) == 1
+
+
+def test_product_spaces():
+    X1 = Geometric('X1', S.Half)
+    X2 = Geometric('X2', Rational(1, 3))
+    assert str(P(X1 + X2 < 3).rewrite(Sum)) == (
+        "Sum(Piecewise((1/(4*2**n), n >= -1), (0, True)), (n, -oo, -1))/3")
+    assert str(P(X1 + X2 > 3).rewrite(Sum)) == (
+        'Sum(Piecewise((2**(X2 - n - 2)*(2/3)**(X2 - 1)/6, '
+        'X2 - n <= 2), (0, True)), (X2, 1, oo), (n, 1, oo))')
+    assert P(Eq(X1 + X2, 3)) == Rational(1, 12)
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/tests/test_error_prop.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/tests/test_error_prop.py
new file mode 100644
index 0000000000000000000000000000000000000000..483fb4c36e202d744faeb355606ff9803a516873
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/tests/test_error_prop.py
@@ -0,0 +1,60 @@
+from sympy.core.function import Function
+from sympy.core.symbol import symbols
+from sympy.functions.elementary.exponential import exp
+from sympy.stats.error_prop import variance_prop
+from sympy.stats.symbolic_probability import (RandomSymbol, Variance,
+        Covariance)
+
+
+def test_variance_prop():
+    x, y, z = symbols('x y z')
+    phi, t = consts = symbols('phi t')
+    a = RandomSymbol(x)
+    var_x = Variance(a)
+    var_y = Variance(RandomSymbol(y))
+    var_z = Variance(RandomSymbol(z))
+    f = Function('f')(x)
+    cases = {
+        x + y: var_x + var_y,
+        a + y: var_x + var_y,
+        x + y + z: var_x + var_y + var_z,
+        2*x: 4*var_x,
+        x*y: var_x*y**2 + var_y*x**2,
+        1/x: var_x/x**4,
+        x/y: (var_x*y**2 + var_y*x**2)/y**4,
+        exp(x): var_x*exp(2*x),
+        exp(2*x): 4*var_x*exp(4*x),
+        exp(-x*t): t**2*var_x*exp(-2*t*x),
+        f: Variance(f),
+        }
+    for inp, out in cases.items():
+        obs = variance_prop(inp, consts=consts)
+        assert out == obs
+
+def test_variance_prop_with_covar():
+    x, y, z = symbols('x y z')
+    phi, t = consts = symbols('phi t')
+    a = RandomSymbol(x)
+    var_x = Variance(a)
+    b = RandomSymbol(y)
+    var_y = Variance(b)
+    c = RandomSymbol(z)
+    var_z = Variance(c)
+    covar_x_y = Covariance(a, b)
+    covar_x_z = Covariance(a, c)
+    covar_y_z = Covariance(b, c)
+    cases = {
+        x + y: var_x + var_y + 2*covar_x_y,
+        a + y: var_x + var_y + 2*covar_x_y,
+        x + y + z: var_x + var_y + var_z + \
+                   2*covar_x_y + 2*covar_x_z + 2*covar_y_z,
+        2*x: 4*var_x,
+        x*y: var_x*y**2 + var_y*x**2 + 2*covar_x_y/(x*y),
+        1/x: var_x/x**4,
+        exp(x): var_x*exp(2*x),
+        exp(2*x): 4*var_x*exp(4*x),
+        exp(-x*t): t**2*var_x*exp(-2*t*x),
+        }
+    for inp, out in cases.items():
+        obs = variance_prop(inp, consts=consts, include_covar=True)
+        assert out == obs
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/tests/test_finite_rv.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/tests/test_finite_rv.py
new file mode 100644
index 0000000000000000000000000000000000000000..93bf0211a26ecc32d7f18c7e2d8236859857e445
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/tests/test_finite_rv.py
@@ -0,0 +1,509 @@
+from sympy.concrete.summations import Sum
+from sympy.core.containers import (Dict, Tuple)
+from sympy.core.function import Function
+from sympy.core.numbers import (I, Rational, nan)
+from sympy.core.relational import Eq
+from sympy.core.singleton import S
+from sympy.core.symbol import (Dummy, Symbol, symbols)
+from sympy.core.sympify import sympify
+from sympy.functions.combinatorial.factorials import binomial
+from sympy.functions.combinatorial.numbers import harmonic
+from sympy.functions.elementary.exponential import exp
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.piecewise import Piecewise
+from sympy.functions.elementary.trigonometric import cos
+from sympy.functions.special.beta_functions import beta
+from sympy.logic.boolalg import (And, Or)
+from sympy.polys.polytools import cancel
+from sympy.sets.sets import FiniteSet
+from sympy.simplify.simplify import simplify
+from sympy.matrices import Matrix
+from sympy.stats import (DiscreteUniform, Die, Bernoulli, Coin, Binomial, BetaBinomial,
+                         Hypergeometric, Rademacher, IdealSoliton, RobustSoliton, P, E, variance,
+                         covariance, skewness, density, where, FiniteRV, pspace, cdf,
+                         correlation, moment, cmoment, smoment, characteristic_function,
+                         moment_generating_function, quantile,  kurtosis, median, coskewness)
+from sympy.stats.frv_types import DieDistribution, BinomialDistribution, \
+    HypergeometricDistribution
+from sympy.stats.rv import Density
+from sympy.testing.pytest import raises
+
+
+def BayesTest(A, B):
+    assert P(A, B) == P(And(A, B)) / P(B)
+    assert P(A, B) == P(B, A) * P(A) / P(B)
+
+
+def test_discreteuniform():
+    # Symbolic
+    a, b, c, t = symbols('a b c t')
+    X = DiscreteUniform('X', [a, b, c])
+
+    assert E(X) == (a + b + c)/3
+    assert simplify(variance(X)
+                    - ((a**2 + b**2 + c**2)/3 - (a/3 + b/3 + c/3)**2)) == 0
+    assert P(Eq(X, a)) == P(Eq(X, b)) == P(Eq(X, c)) == S('1/3')
+
+    Y = DiscreteUniform('Y', range(-5, 5))
+
+    # Numeric
+    assert E(Y) == S('-1/2')
+    assert variance(Y) == S('33/4')
+    assert median(Y) == FiniteSet(-1, 0)
+
+    for x in range(-5, 5):
+        assert P(Eq(Y, x)) == S('1/10')
+        assert P(Y <= x) == S(x + 6)/10
+        assert P(Y >= x) == S(5 - x)/10
+
+    assert dict(density(Die('D', 6)).items()) == \
+           dict(density(DiscreteUniform('U', range(1, 7))).items())
+
+    assert characteristic_function(X)(t) == exp(I*a*t)/3 + exp(I*b*t)/3 + exp(I*c*t)/3
+    assert moment_generating_function(X)(t) == exp(a*t)/3 + exp(b*t)/3 + exp(c*t)/3
+    # issue 18611
+    raises(ValueError, lambda: DiscreteUniform('Z', [a, a, a, b, b, c]))
+
+def test_dice():
+    # TODO: Make iid method!
+    X, Y, Z = Die('X', 6), Die('Y', 6), Die('Z', 6)
+    a, b, t, p = symbols('a b t p')
+
+    assert E(X) == 3 + S.Half
+    assert variance(X) == Rational(35, 12)
+    assert E(X + Y) == 7
+    assert E(X + X) == 7
+    assert E(a*X + b) == a*E(X) + b
+    assert variance(X + Y) == variance(X) + variance(Y) == cmoment(X + Y, 2)
+    assert variance(X + X) == 4 * variance(X) == cmoment(X + X, 2)
+    assert cmoment(X, 0) == 1
+    assert cmoment(4*X, 3) == 64*cmoment(X, 3)
+    assert covariance(X, Y) is S.Zero
+    assert covariance(X, X + Y) == variance(X)
+    assert density(Eq(cos(X*S.Pi), 1))[True] == S.Half
+    assert correlation(X, Y) == 0
+    assert correlation(X, Y) == correlation(Y, X)
+    assert smoment(X + Y, 3) == skewness(X + Y)
+    assert smoment(X + Y, 4) == kurtosis(X + Y)
+    assert smoment(X, 0) == 1
+    assert P(X > 3) == S.Half
+    assert P(2*X > 6) == S.Half
+    assert P(X > Y) == Rational(5, 12)
+    assert P(Eq(X, Y)) == P(Eq(X, 1))
+
+    assert E(X, X > 3) == 5 == moment(X, 1, 0, X > 3)
+    assert E(X, Y > 3) == E(X) == moment(X, 1, 0, Y > 3)
+    assert E(X + Y, Eq(X, Y)) == E(2*X)
+    assert moment(X, 0) == 1
+    assert moment(5*X, 2) == 25*moment(X, 2)
+    assert quantile(X)(p) == Piecewise((nan, (p > 1) | (p < 0)),\
+        (S.One, p <= Rational(1, 6)), (S(2), p <= Rational(1, 3)), (S(3), p <= S.Half),\
+        (S(4), p <= Rational(2, 3)), (S(5), p <= Rational(5, 6)), (S(6), p <= 1))
+
+    assert P(X > 3, X > 3) is S.One
+    assert P(X > Y, Eq(Y, 6)) is S.Zero
+    assert P(Eq(X + Y, 12)) == Rational(1, 36)
+    assert P(Eq(X + Y, 12), Eq(X, 6)) == Rational(1, 6)
+
+    assert density(X + Y) == density(Y + Z) != density(X + X)
+    d = density(2*X + Y**Z)
+    assert d[S(22)] == Rational(1, 108) and d[S(4100)] == Rational(1, 216) and S(3130) not in d
+
+    assert pspace(X).domain.as_boolean() == Or(
+        *[Eq(X.symbol, i) for i in [1, 2, 3, 4, 5, 6]])
+
+    assert where(X > 3).set == FiniteSet(4, 5, 6)
+
+    assert characteristic_function(X)(t) == exp(6*I*t)/6 + exp(5*I*t)/6 + exp(4*I*t)/6 + exp(3*I*t)/6 + exp(2*I*t)/6 + exp(I*t)/6
+    assert moment_generating_function(X)(t) == exp(6*t)/6 + exp(5*t)/6 + exp(4*t)/6 + exp(3*t)/6 + exp(2*t)/6 + exp(t)/6
+    assert median(X) == FiniteSet(3, 4)
+    D = Die('D', 7)
+    assert median(D) == FiniteSet(4)
+    # Bayes test for die
+    BayesTest(X > 3, X + Y < 5)
+    BayesTest(Eq(X - Y, Z), Z > Y)
+    BayesTest(X > 3, X > 2)
+
+    # arg test for die
+    raises(ValueError, lambda: Die('X', -1))  # issue 8105: negative sides.
+    raises(ValueError, lambda: Die('X', 0))
+    raises(ValueError, lambda: Die('X', 1.5))  # issue 8103: non integer sides.
+
+    # symbolic test for die
+    n, k = symbols('n, k', positive=True)
+    D = Die('D', n)
+    dens = density(D).dict
+    assert dens == Density(DieDistribution(n))
+    assert set(dens.subs(n, 4).doit().keys()) == {1, 2, 3, 4}
+    assert set(dens.subs(n, 4).doit().values()) == {Rational(1, 4)}
+    k = Dummy('k', integer=True)
+    assert E(D).dummy_eq(
+        Sum(Piecewise((k/n, k <= n), (0, True)), (k, 1, n)))
+    assert variance(D).subs(n, 6).doit() == Rational(35, 12)
+
+    ki = Dummy('ki')
+    cumuf = cdf(D)(k)
+    assert cumuf.dummy_eq(
+    Sum(Piecewise((1/n, (ki >= 1) & (ki <= n)), (0, True)), (ki, 1, k)))
+    assert cumuf.subs({n: 6, k: 2}).doit() == Rational(1, 3)
+
+    t = Dummy('t')
+    cf = characteristic_function(D)(t)
+    assert cf.dummy_eq(
+    Sum(Piecewise((exp(ki*I*t)/n, (ki >= 1) & (ki <= n)), (0, True)), (ki, 1, n)))
+    assert cf.subs(n, 3).doit() == exp(3*I*t)/3 + exp(2*I*t)/3 + exp(I*t)/3
+    mgf = moment_generating_function(D)(t)
+    assert mgf.dummy_eq(
+    Sum(Piecewise((exp(ki*t)/n, (ki >= 1) & (ki <= n)), (0, True)), (ki, 1, n)))
+    assert mgf.subs(n, 3).doit() == exp(3*t)/3 + exp(2*t)/3 + exp(t)/3
+
+def test_given():
+    X = Die('X', 6)
+    assert density(X, X > 5) == {S(6): S.One}
+    assert where(X > 2, X > 5).as_boolean() == Eq(X.symbol, 6)
+
+
+def test_domains():
+    X, Y = Die('x', 6), Die('y', 6)
+    x, y = X.symbol, Y.symbol
+    # Domains
+    d = where(X > Y)
+    assert d.condition == (x > y)
+    d = where(And(X > Y, Y > 3))
+    assert d.as_boolean() == Or(And(Eq(x, 5), Eq(y, 4)), And(Eq(x, 6),
+        Eq(y, 5)), And(Eq(x, 6), Eq(y, 4)))
+    assert len(d.elements) == 3
+
+    assert len(pspace(X + Y).domain.elements) == 36
+
+    Z = Die('x', 4)
+
+    raises(ValueError, lambda: P(X > Z))  # Two domains with same internal symbol
+
+    assert pspace(X + Y).domain.set == FiniteSet(1, 2, 3, 4, 5, 6)**2
+
+    assert where(X > 3).set == FiniteSet(4, 5, 6)
+    assert X.pspace.domain.dict == FiniteSet(
+        *[Dict({X.symbol: i}) for i in range(1, 7)])
+
+    assert where(X > Y).dict == FiniteSet(*[Dict({X.symbol: i, Y.symbol: j})
+            for i in range(1, 7) for j in range(1, 7) if i > j])
+
+def test_bernoulli():
+    p, a, b, t = symbols('p a b t')
+    X = Bernoulli('B', p, a, b)
+
+    assert E(X) == a*p + b*(-p + 1)
+    assert density(X)[a] == p
+    assert density(X)[b] == 1 - p
+    assert characteristic_function(X)(t) == p * exp(I * a * t) + (-p + 1) * exp(I * b * t)
+    assert moment_generating_function(X)(t) == p * exp(a * t) + (-p + 1) * exp(b * t)
+
+    X = Bernoulli('B', p, 1, 0)
+    z = Symbol("z")
+
+    assert E(X) == p
+    assert simplify(variance(X)) == p*(1 - p)
+    assert E(a*X + b) == a*E(X) + b
+    assert simplify(variance(a*X + b)) == simplify(a**2 * variance(X))
+    assert quantile(X)(z) == Piecewise((nan, (z > 1) | (z < 0)), (0, z <= 1 - p), (1, z <= 1))
+    Y = Bernoulli('Y', Rational(1, 2))
+    assert median(Y) == FiniteSet(0, 1)
+    Z = Bernoulli('Z', Rational(2, 3))
+    assert median(Z) == FiniteSet(1)
+    raises(ValueError, lambda: Bernoulli('B', 1.5))
+    raises(ValueError, lambda: Bernoulli('B', -0.5))
+
+    #issue 8248
+    assert X.pspace.compute_expectation(1) == 1
+
+    p = Rational(1, 5)
+    X = Binomial('X', 5, p)
+    Y = Binomial('Y', 7, 2*p)
+    Z = Binomial('Z', 9, 3*p)
+    assert coskewness(Y + Z, X + Y, X + Z).simplify() == 0
+    assert coskewness(Y + 2*X + Z, X + 2*Y + Z, X + 2*Z + Y).simplify() == \
+                        sqrt(1529)*Rational(12, 16819)
+    assert coskewness(Y + 2*X + Z, X + 2*Y + Z, X + 2*Z + Y, X < 2).simplify() \
+                        == -sqrt(357451121)*Rational(2812, 4646864573)
+
+def test_cdf():
+    D = Die('D', 6)
+    o = S.One
+
+    assert cdf(
+        D) == sympify({1: o/6, 2: o/3, 3: o/2, 4: 2*o/3, 5: 5*o/6, 6: o})
+
+
+def test_coins():
+    C, D = Coin('C'), Coin('D')
+    H, T = symbols('H, T')
+    assert P(Eq(C, D)) == S.Half
+    assert density(Tuple(C, D)) == {(H, H): Rational(1, 4), (H, T): Rational(1, 4),
+            (T, H): Rational(1, 4), (T, T): Rational(1, 4)}
+    assert dict(density(C).items()) == {H: S.Half, T: S.Half}
+
+    F = Coin('F', Rational(1, 10))
+    assert P(Eq(F, H)) == Rational(1, 10)
+
+    d = pspace(C).domain
+
+    assert d.as_boolean() == Or(Eq(C.symbol, H), Eq(C.symbol, T))
+
+    raises(ValueError, lambda: P(C > D))  # Can't intelligently compare H to T
+
+def test_binomial_verify_parameters():
+    raises(ValueError, lambda: Binomial('b', .2, .5))
+    raises(ValueError, lambda: Binomial('b', 3, 1.5))
+
+def test_binomial_numeric():
+    nvals = range(5)
+    pvals = [0, Rational(1, 4), S.Half, Rational(3, 4), 1]
+
+    for n in nvals:
+        for p in pvals:
+            X = Binomial('X', n, p)
+            assert E(X) == n*p
+            assert variance(X) == n*p*(1 - p)
+            if n > 0 and 0 < p < 1:
+                assert skewness(X) == (1 - 2*p)/sqrt(n*p*(1 - p))
+                assert kurtosis(X) == 3 + (1 - 6*p*(1 - p))/(n*p*(1 - p))
+            for k in range(n + 1):
+                assert P(Eq(X, k)) == binomial(n, k)*p**k*(1 - p)**(n - k)
+
+def test_binomial_quantile():
+    X = Binomial('X', 50, S.Half)
+    assert quantile(X)(0.95) == S(31)
+    assert median(X) == FiniteSet(25)
+
+    X = Binomial('X', 5, S.Half)
+    p = Symbol("p", positive=True)
+    assert quantile(X)(p) == Piecewise((nan, p > S.One), (S.Zero, p <= Rational(1, 32)),\
+        (S.One, p <= Rational(3, 16)), (S(2), p <= S.Half), (S(3), p <= Rational(13, 16)),\
+        (S(4), p <= Rational(31, 32)), (S(5), p <= S.One))
+    assert median(X) == FiniteSet(2, 3)
+
+
+def test_binomial_symbolic():
+    n = 2
+    p = symbols('p', positive=True)
+    X = Binomial('X', n, p)
+    t = Symbol('t')
+
+    assert simplify(E(X)) == n*p == simplify(moment(X, 1))
+    assert simplify(variance(X)) == n*p*(1 - p) == simplify(cmoment(X, 2))
+    assert cancel(skewness(X) - (1 - 2*p)/sqrt(n*p*(1 - p))) == 0
+    assert cancel((kurtosis(X)) - (3 + (1 - 6*p*(1 - p))/(n*p*(1 - p)))) == 0
+    assert characteristic_function(X)(t) == p ** 2 * exp(2 * I * t) + 2 * p * (-p + 1) * exp(I * t) + (-p + 1) ** 2
+    assert moment_generating_function(X)(t) == p ** 2 * exp(2 * t) + 2 * p * (-p + 1) * exp(t) + (-p + 1) ** 2
+
+    # Test ability to change success/failure winnings
+    H, T = symbols('H T')
+    Y = Binomial('Y', n, p, succ=H, fail=T)
+    assert simplify(E(Y) - (n*(H*p + T*(1 - p)))) == 0
+
+    # test symbolic dimensions
+    n = symbols('n')
+    B = Binomial('B', n, p)
+    raises(NotImplementedError, lambda: P(B > 2))
+    assert density(B).dict == Density(BinomialDistribution(n, p, 1, 0))
+    assert set(density(B).dict.subs(n, 4).doit().keys()) == \
+    {S.Zero, S.One, S(2), S(3), S(4)}
+    assert set(density(B).dict.subs(n, 4).doit().values()) == \
+    {(1 - p)**4, 4*p*(1 - p)**3, 6*p**2*(1 - p)**2, 4*p**3*(1 - p), p**4}
+    k = Dummy('k', integer=True)
+    assert E(B > 2).dummy_eq(
+        Sum(Piecewise((k*p**k*(1 - p)**(-k + n)*binomial(n, k), (k >= 0)
+        & (k <= n) & (k > 2)), (0, True)), (k, 0, n)))
+
+def test_beta_binomial():
+    # verify parameters
+    raises(ValueError, lambda: BetaBinomial('b', .2, 1, 2))
+    raises(ValueError, lambda: BetaBinomial('b', 2, -1, 2))
+    raises(ValueError, lambda: BetaBinomial('b', 2, 1, -2))
+    assert BetaBinomial('b', 2, 1, 1)
+
+    # test numeric values
+    nvals = range(1,5)
+    alphavals = [Rational(1, 4), S.Half, Rational(3, 4), 1, 10]
+    betavals = [Rational(1, 4), S.Half, Rational(3, 4), 1, 10]
+
+    for n in nvals:
+        for a in alphavals:
+            for b in betavals:
+                X = BetaBinomial('X', n, a, b)
+                assert E(X) == moment(X, 1)
+                assert variance(X) == cmoment(X, 2)
+
+    # test symbolic
+    n, a, b = symbols('a b n')
+    assert BetaBinomial('x', n, a, b)
+    n = 2 # Because we're using for loops, can't do symbolic n
+    a, b = symbols('a b', positive=True)
+    X = BetaBinomial('X', n, a, b)
+    t = Symbol('t')
+
+    assert E(X).expand() == moment(X, 1).expand()
+    assert variance(X).expand() == cmoment(X, 2).expand()
+    assert skewness(X) == smoment(X, 3)
+    assert characteristic_function(X)(t) == exp(2*I*t)*beta(a + 2, b)/beta(a, b) +\
+         2*exp(I*t)*beta(a + 1, b + 1)/beta(a, b) + beta(a, b + 2)/beta(a, b)
+    assert moment_generating_function(X)(t) == exp(2*t)*beta(a + 2, b)/beta(a, b) +\
+         2*exp(t)*beta(a + 1, b + 1)/beta(a, b) + beta(a, b + 2)/beta(a, b)
+
+def test_hypergeometric_numeric():
+    for N in range(1, 5):
+        for m in range(0, N + 1):
+            for n in range(1, N + 1):
+                X = Hypergeometric('X', N, m, n)
+                N, m, n = map(sympify, (N, m, n))
+                assert sum(density(X).values()) == 1
+                assert E(X) == n * m / N
+                if N > 1:
+                    assert variance(X) == n*(m/N)*(N - m)/N*(N - n)/(N - 1)
+                # Only test for skewness when defined
+                if N > 2 and 0 < m < N and n < N:
+                    assert skewness(X) == simplify((N - 2*m)*sqrt(N - 1)*(N - 2*n)
+                        / (sqrt(n*m*(N - m)*(N - n))*(N - 2)))
+
+def test_hypergeometric_symbolic():
+    N, m, n = symbols('N, m, n')
+    H = Hypergeometric('H', N, m, n)
+    dens = density(H).dict
+    expec = E(H > 2)
+    assert dens == Density(HypergeometricDistribution(N, m, n))
+    assert dens.subs(N, 5).doit() == Density(HypergeometricDistribution(5, m, n))
+    assert set(dens.subs({N: 3, m: 2, n: 1}).doit().keys()) == {S.Zero, S.One}
+    assert set(dens.subs({N: 3, m: 2, n: 1}).doit().values()) == {Rational(1, 3), Rational(2, 3)}
+    k = Dummy('k', integer=True)
+    assert expec.dummy_eq(
+        Sum(Piecewise((k*binomial(m, k)*binomial(N - m, -k + n)
+        /binomial(N, n), k > 2), (0, True)), (k, 0, n)))
+
+def test_rademacher():
+    X = Rademacher('X')
+    t = Symbol('t')
+
+    assert E(X) == 0
+    assert variance(X) == 1
+    assert density(X)[-1] == S.Half
+    assert density(X)[1] == S.Half
+    assert characteristic_function(X)(t) == exp(I*t)/2 + exp(-I*t)/2
+    assert moment_generating_function(X)(t) == exp(t) / 2 + exp(-t) / 2
+
+def test_ideal_soliton():
+    raises(ValueError, lambda : IdealSoliton('sol', -12))
+    raises(ValueError, lambda : IdealSoliton('sol', 13.2))
+    raises(ValueError, lambda : IdealSoliton('sol', 0))
+    f = Function('f')
+    raises(ValueError, lambda : density(IdealSoliton('sol', 10)).pmf(f))
+
+    k = Symbol('k', integer=True, positive=True)
+    x = Symbol('x', integer=True, positive=True)
+    t = Symbol('t')
+    sol = IdealSoliton('sol', k)
+    assert density(sol).low == S.One
+    assert density(sol).high == k
+    assert density(sol).dict == Density(density(sol))
+    assert density(sol).pmf(x) == Piecewise((1/k, Eq(x, 1)), (1/(x*(x - 1)), k >= x), (0, True))
+
+    k_vals = [5, 20, 50, 100, 1000]
+    for i in k_vals:
+        assert E(sol.subs(k, i)) == harmonic(i) == moment(sol.subs(k, i), 1)
+        assert variance(sol.subs(k, i)) == (i - 1) + harmonic(i) - harmonic(i)**2 == cmoment(sol.subs(k, i),2)
+        assert skewness(sol.subs(k, i)) == smoment(sol.subs(k, i), 3)
+        assert kurtosis(sol.subs(k, i)) == smoment(sol.subs(k, i), 4)
+
+    assert exp(I*t)/10 + Sum(exp(I*t*x)/(x*x - x), (x, 2, k)).subs(k, 10).doit() == characteristic_function(sol.subs(k, 10))(t)
+    assert exp(t)/10 + Sum(exp(t*x)/(x*x - x), (x, 2, k)).subs(k, 10).doit() == moment_generating_function(sol.subs(k, 10))(t)
+
+def test_robust_soliton():
+    raises(ValueError, lambda : RobustSoliton('robSol', -12, 0.1, 0.02))
+    raises(ValueError, lambda : RobustSoliton('robSol', 13, 1.89, 0.1))
+    raises(ValueError, lambda : RobustSoliton('robSol', 15, 0.6, -2.31))
+    f = Function('f')
+    raises(ValueError, lambda : density(RobustSoliton('robSol', 15, 0.6, 0.1)).pmf(f))
+
+    k = Symbol('k', integer=True, positive=True)
+    delta = Symbol('delta', positive=True)
+    c = Symbol('c', positive=True)
+    robSol = RobustSoliton('robSol', k, delta, c)
+    assert density(robSol).low == 1
+    assert density(robSol).high == k
+
+    k_vals = [10, 20, 50]
+    delta_vals = [0.2, 0.4, 0.6]
+    c_vals = [0.01, 0.03, 0.05]
+    for x in k_vals:
+        for y in delta_vals:
+            for z in c_vals:
+                assert E(robSol.subs({k: x, delta: y, c: z})) == moment(robSol.subs({k: x, delta: y, c: z}), 1)
+                assert variance(robSol.subs({k: x, delta: y, c: z})) == cmoment(robSol.subs({k: x, delta: y, c: z}), 2)
+                assert skewness(robSol.subs({k: x, delta: y, c: z})) == smoment(robSol.subs({k: x, delta: y, c: z}), 3)
+                assert kurtosis(robSol.subs({k: x, delta: y, c: z})) == smoment(robSol.subs({k: x, delta: y, c: z}), 4)
+
+def test_FiniteRV():
+    F = FiniteRV('F', {1: S.Half, 2: Rational(1, 4), 3: Rational(1, 4)}, check=True)
+    p = Symbol("p", positive=True)
+
+    assert dict(density(F).items()) == {S.One: S.Half, S(2): Rational(1, 4), S(3): Rational(1, 4)}
+    assert P(F >= 2) == S.Half
+    assert quantile(F)(p) == Piecewise((nan, p > S.One), (S.One, p <= S.Half),\
+        (S(2), p <= Rational(3, 4)),(S(3), True))
+
+    assert pspace(F).domain.as_boolean() == Or(
+        *[Eq(F.symbol, i) for i in [1, 2, 3]])
+
+    assert F.pspace.domain.set == FiniteSet(1, 2, 3)
+    raises(ValueError, lambda: FiniteRV('F', {1: S.Half, 2: S.Half, 3: S.Half}, check=True))
+    raises(ValueError, lambda: FiniteRV('F', {1: S.Half, 2: Rational(-1, 2), 3: S.One}, check=True))
+    raises(ValueError, lambda: FiniteRV('F', {1: S.One, 2: Rational(3, 2), 3: S.Zero,\
+        4: Rational(-1, 2), 5: Rational(-3, 4), 6: Rational(-1, 4)}, check=True))
+
+    # purposeful invalid pmf but it should not raise since check=False
+    # see test_drv_types.test_ContinuousRV for explanation
+    X = FiniteRV('X', {1: 1, 2: 2})
+    assert E(X) == 5
+    assert P(X <= 2) + P(X > 2) != 1
+
+def test_density_call():
+    from sympy.abc import p
+    x = Bernoulli('x', p)
+    d = density(x)
+    assert d(0) == 1 - p
+    assert d(S.Zero) == 1 - p
+    assert d(5) == 0
+
+    assert 0 in d
+    assert 5 not in d
+    assert d(S.Zero) == d[S.Zero]
+
+
+def test_DieDistribution():
+    from sympy.abc import x
+    X = DieDistribution(6)
+    assert X.pmf(S.Half) is S.Zero
+    assert X.pmf(x).subs({x: 1}).doit() == Rational(1, 6)
+    assert X.pmf(x).subs({x: 7}).doit() == 0
+    assert X.pmf(x).subs({x: -1}).doit() == 0
+    assert X.pmf(x).subs({x: Rational(1, 3)}).doit() == 0
+    raises(ValueError, lambda: X.pmf(Matrix([0, 0])))
+    raises(ValueError, lambda: X.pmf(x**2 - 1))
+
+def test_FinitePSpace():
+    X = Die('X', 6)
+    space = pspace(X)
+    assert space.density == DieDistribution(6)
+
+def test_symbolic_conditions():
+    B = Bernoulli('B', Rational(1, 4))
+    D = Die('D', 4)
+    b, n = symbols('b, n')
+    Y = P(Eq(B, b))
+    Z = E(D > n)
+    assert Y == \
+    Piecewise((Rational(1, 4), Eq(b, 1)), (0, True)) + \
+    Piecewise((Rational(3, 4), Eq(b, 0)), (0, True))
+    assert Z == \
+    Piecewise((Rational(1, 4), n < 1), (0, True)) + Piecewise((S.Half, n < 2), (0, True)) + \
+    Piecewise((Rational(3, 4), n < 3), (0, True)) + Piecewise((S.One, n < 4), (0, True))
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/tests/test_joint_rv.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/tests/test_joint_rv.py
new file mode 100644
index 0000000000000000000000000000000000000000..057fc313dfbb31826b07fd1315205d22b86a7f96
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/tests/test_joint_rv.py
@@ -0,0 +1,436 @@
+from sympy.concrete.products import Product
+from sympy.concrete.summations import Sum
+from sympy.core.numbers import (Rational, oo, pi)
+from sympy.core.relational import Eq
+from sympy.core.singleton import S
+from sympy.core.symbol import symbols
+from sympy.functions.combinatorial.factorials import (RisingFactorial, factorial)
+from sympy.functions.elementary.complexes import polar_lift
+from sympy.functions.elementary.exponential import exp
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.piecewise import Piecewise
+from sympy.functions.special.bessel import besselk
+from sympy.functions.special.gamma_functions import gamma
+from sympy.matrices.dense import eye
+from sympy.matrices.expressions.determinant import Determinant
+from sympy.sets.fancysets import Range
+from sympy.sets.sets import (Interval, ProductSet)
+from sympy.simplify.simplify import simplify
+from sympy.tensor.indexed import (Indexed, IndexedBase)
+from sympy.core.numbers import comp
+from sympy.integrals.integrals import integrate
+from sympy.matrices import Matrix, MatrixSymbol
+from sympy.matrices.expressions.matexpr import MatrixElement
+from sympy.stats import density, median, marginal_distribution, Normal, Laplace, E, sample
+from sympy.stats.joint_rv_types import (JointRV, MultivariateNormalDistribution,
+                JointDistributionHandmade, MultivariateT, NormalGamma,
+                GeneralizedMultivariateLogGammaOmega as GMVLGO, MultivariateBeta,
+                GeneralizedMultivariateLogGamma as GMVLG, MultivariateEwens,
+                Multinomial, NegativeMultinomial, MultivariateNormal,
+                MultivariateLaplace)
+from sympy.testing.pytest import raises, XFAIL, skip, slow
+from sympy.external import import_module
+
+from sympy.abc import x, y
+
+
+
+def test_Normal():
+    m = Normal('A', [1, 2], [[1, 0], [0, 1]])
+    A = MultivariateNormal('A', [1, 2], [[1, 0], [0, 1]])
+    assert m == A
+    assert density(m)(1, 2) == 1/(2*pi)
+    assert m.pspace.distribution.set == ProductSet(S.Reals, S.Reals)
+    raises (ValueError, lambda:m[2])
+    n = Normal('B', [1, 2, 3], [[1, 0, 0], [0, 1, 0], [0, 0, 1]])
+    p = Normal('C',  Matrix([1, 2]), Matrix([[1, 0], [0, 1]]))
+    assert density(m)(x, y) == density(p)(x, y)
+    assert marginal_distribution(n, 0, 1)(1, 2) == 1/(2*pi)
+    raises(ValueError, lambda: marginal_distribution(m))
+    assert integrate(density(m)(x, y), (x, -oo, oo), (y, -oo, oo)).evalf() == 1.0
+    N = Normal('N', [1, 2], [[x, 0], [0, y]])
+    assert density(N)(0, 0) == exp(-((4*x + y)/(2*x*y)))/(2*pi*sqrt(x*y))
+
+    raises (ValueError, lambda: Normal('M', [1, 2], [[1, 1], [1, -1]]))
+    # symbolic
+    n = symbols('n', integer=True, positive=True)
+    mu = MatrixSymbol('mu', n, 1)
+    sigma = MatrixSymbol('sigma', n, n)
+    X = Normal('X', mu, sigma)
+    assert density(X) == MultivariateNormalDistribution(mu, sigma)
+    raises (NotImplementedError, lambda: median(m))
+    # Below tests should work after issue #17267 is resolved
+    # assert E(X) == mu
+    # assert variance(X) == sigma
+
+    # test symbolic multivariate normal densities
+    n = 3
+
+    Sg = MatrixSymbol('Sg', n, n)
+    mu = MatrixSymbol('mu', n, 1)
+    obs = MatrixSymbol('obs', n, 1)
+
+    X = MultivariateNormal('X', mu, Sg)
+    density_X = density(X)
+
+    eval_a = density_X(obs).subs({Sg: eye(3),
+        mu: Matrix([0, 0, 0]), obs: Matrix([0, 0, 0])}).doit()
+    eval_b = density_X(0, 0, 0).subs({Sg: eye(3), mu: Matrix([0, 0, 0])}).doit()
+
+    assert eval_a == sqrt(2)/(4*pi**Rational(3/2))
+    assert eval_b == sqrt(2)/(4*pi**Rational(3/2))
+
+    n = symbols('n', integer=True, positive=True)
+
+    Sg = MatrixSymbol('Sg', n, n)
+    mu = MatrixSymbol('mu', n, 1)
+    obs = MatrixSymbol('obs', n, 1)
+
+    X = MultivariateNormal('X', mu, Sg)
+    density_X_at_obs = density(X)(obs)
+
+    expected_density = MatrixElement(
+        exp((S(1)/2) * (mu.T - obs.T) * Sg**(-1) * (-mu + obs)) / \
+        sqrt((2*pi)**n * Determinant(Sg)), 0, 0)
+
+    assert density_X_at_obs == expected_density
+
+
+def test_MultivariateTDist():
+    t1 = MultivariateT('T', [0, 0], [[1, 0], [0, 1]], 2)
+    assert(density(t1))(1, 1) == 1/(8*pi)
+    assert t1.pspace.distribution.set == ProductSet(S.Reals, S.Reals)
+    assert integrate(density(t1)(x, y), (x, -oo, oo), \
+        (y, -oo, oo)).evalf() == 1.0
+    raises(ValueError, lambda: MultivariateT('T', [1, 2], [[1, 1], [1, -1]], 1))
+    t2 = MultivariateT('t2', [1, 2], [[x, 0], [0, y]], 1)
+    assert density(t2)(1, 2) == 1/(2*pi*sqrt(x*y))
+
+
+def test_multivariate_laplace():
+    raises(ValueError, lambda: Laplace('T', [1, 2], [[1, 2], [2, 1]]))
+    L = Laplace('L', [1, 0], [[1, 0], [0, 1]])
+    L2 = MultivariateLaplace('L2', [1, 0], [[1, 0], [0, 1]])
+    assert density(L)(2, 3) == exp(2)*besselk(0, sqrt(39))/pi
+    L1 = Laplace('L1', [1, 2], [[x, 0], [0, y]])
+    assert density(L1)(0, 1) == \
+        exp(2/y)*besselk(0, sqrt((2 + 4/y + 1/x)/y))/(pi*sqrt(x*y))
+    assert L.pspace.distribution.set == ProductSet(S.Reals, S.Reals)
+    assert L.pspace.distribution == L2.pspace.distribution
+
+
+def test_NormalGamma():
+    ng = NormalGamma('G', 1, 2, 3, 4)
+    assert density(ng)(1, 1) == 32*exp(-4)/sqrt(pi)
+    assert ng.pspace.distribution.set == ProductSet(S.Reals, Interval(0, oo))
+    raises(ValueError, lambda:NormalGamma('G', 1, 2, 3, -1))
+    assert marginal_distribution(ng, 0)(1) == \
+        3*sqrt(10)*gamma(Rational(7, 4))/(10*sqrt(pi)*gamma(Rational(5, 4)))
+    assert marginal_distribution(ng, y)(1) == exp(Rational(-1, 4))/128
+    assert marginal_distribution(ng,[0,1])(x) == x**2*exp(-x/4)/128
+
+
+def test_GeneralizedMultivariateLogGammaDistribution():
+    h = S.Half
+    omega = Matrix([[1, h, h, h],
+                     [h, 1, h, h],
+                     [h, h, 1, h],
+                     [h, h, h, 1]])
+    v, l, mu = (4, [1, 2, 3, 4], [1, 2, 3, 4])
+    y_1, y_2, y_3, y_4 = symbols('y_1:5', real=True)
+    delta = symbols('d', positive=True)
+    G = GMVLGO('G', omega, v, l, mu)
+    Gd = GMVLG('Gd', delta, v, l, mu)
+    dend = ("d**4*Sum(4*24**(-n - 4)*(1 - d)**n*exp((n + 4)*(y_1 + 2*y_2 + 3*y_3 "
+            "+ 4*y_4) - exp(y_1) - exp(2*y_2)/2 - exp(3*y_3)/3 - exp(4*y_4)/4)/"
+            "(gamma(n + 1)*gamma(n + 4)**3), (n, 0, oo))")
+    assert str(density(Gd)(y_1, y_2, y_3, y_4)) == dend
+    den = ("5*2**(2/3)*5**(1/3)*Sum(4*24**(-n - 4)*(-2**(2/3)*5**(1/3)/4 + 1)**n*"
+          "exp((n + 4)*(y_1 + 2*y_2 + 3*y_3 + 4*y_4) - exp(y_1) - exp(2*y_2)/2 - "
+          "exp(3*y_3)/3 - exp(4*y_4)/4)/(gamma(n + 1)*gamma(n + 4)**3), (n, 0, oo))/64")
+    assert str(density(G)(y_1, y_2, y_3, y_4)) == den
+    marg = ("5*2**(2/3)*5**(1/3)*exp(4*y_1)*exp(-exp(y_1))*Integral(exp(-exp(4*G[3])"
+            "/4)*exp(16*G[3])*Integral(exp(-exp(3*G[2])/3)*exp(12*G[2])*Integral(exp("
+            "-exp(2*G[1])/2)*exp(8*G[1])*Sum((-1/4)**n*(-4 + 2**(2/3)*5**(1/3"
+            "))**n*exp(n*y_1)*exp(2*n*G[1])*exp(3*n*G[2])*exp(4*n*G[3])/(24**n*gamma(n + 1)"
+            "*gamma(n + 4)**3), (n, 0, oo)), (G[1], -oo, oo)), (G[2], -oo, oo)), (G[3]"
+            ", -oo, oo))/5308416")
+    assert str(marginal_distribution(G, G[0])(y_1)) == marg
+    omega_f1 = Matrix([[1, h, h]])
+    omega_f2 = Matrix([[1, h, h, h],
+                     [h, 1, 2, h],
+                     [h, h, 1, h],
+                     [h, h, h, 1]])
+    omega_f3 = Matrix([[6, h, h, h],
+                     [h, 1, 2, h],
+                     [h, h, 1, h],
+                     [h, h, h, 1]])
+    v_f = symbols("v_f", positive=False, real=True)
+    l_f = [1, 2, v_f, 4]
+    m_f = [v_f, 2, 3, 4]
+    omega_f4 = Matrix([[1, h, h, h, h],
+                     [h, 1, h, h, h],
+                     [h, h, 1, h, h],
+                     [h, h, h, 1, h],
+                     [h, h, h, h, 1]])
+    l_f1 = [1, 2, 3, 4, 5]
+    omega_f5 = Matrix([[1]])
+    mu_f5 = l_f5 = [1]
+
+    raises(ValueError, lambda: GMVLGO('G', omega_f1, v, l, mu))
+    raises(ValueError, lambda: GMVLGO('G', omega_f2, v, l, mu))
+    raises(ValueError, lambda: GMVLGO('G', omega_f3, v, l, mu))
+    raises(ValueError, lambda: GMVLGO('G', omega, v_f, l, mu))
+    raises(ValueError, lambda: GMVLGO('G', omega, v, l_f, mu))
+    raises(ValueError, lambda: GMVLGO('G', omega, v, l, m_f))
+    raises(ValueError, lambda: GMVLGO('G', omega_f4, v, l, mu))
+    raises(ValueError, lambda: GMVLGO('G', omega, v, l_f1, mu))
+    raises(ValueError, lambda: GMVLGO('G', omega_f5, v, l_f5, mu_f5))
+    raises(ValueError, lambda: GMVLG('G', Rational(3, 2), v, l, mu))
+
+
+def test_MultivariateBeta():
+    a1, a2 = symbols('a1, a2', positive=True)
+    a1_f, a2_f = symbols('a1, a2', positive=False, real=True)
+    mb = MultivariateBeta('B', [a1, a2])
+    mb_c = MultivariateBeta('C', a1, a2)
+    assert density(mb)(1, 2) == S(2)**(a2 - 1)*gamma(a1 + a2)/\
+                                (gamma(a1)*gamma(a2))
+    assert marginal_distribution(mb_c, 0)(3) == S(3)**(a1 - 1)*gamma(a1 + a2)/\
+                                                (a2*gamma(a1)*gamma(a2))
+    raises(ValueError, lambda: MultivariateBeta('b1', [a1_f, a2]))
+    raises(ValueError, lambda: MultivariateBeta('b2', [a1, a2_f]))
+    raises(ValueError, lambda: MultivariateBeta('b3', [0, 0]))
+    raises(ValueError, lambda: MultivariateBeta('b4', [a1_f, a2_f]))
+    assert mb.pspace.distribution.set == ProductSet(Interval(0, 1), Interval(0, 1))
+
+
+def test_MultivariateEwens():
+    n, theta, i = symbols('n theta i', positive=True)
+
+    # tests for integer dimensions
+    theta_f = symbols('t_f', negative=True)
+    a = symbols('a_1:4', positive = True, integer = True)
+    ed = MultivariateEwens('E', 3, theta)
+    assert density(ed)(a[0], a[1], a[2]) == Piecewise((6*2**(-a[1])*3**(-a[2])*
+                                            theta**a[0]*theta**a[1]*theta**a[2]/
+                                            (theta*(theta + 1)*(theta + 2)*
+                                            factorial(a[0])*factorial(a[1])*
+                                            factorial(a[2])), Eq(a[0] + 2*a[1] +
+                                            3*a[2], 3)), (0, True))
+    assert marginal_distribution(ed, ed[1])(a[1]) == Piecewise((6*2**(-a[1])*
+                                                    theta**a[1]/((theta + 1)*
+                                                    (theta + 2)*factorial(a[1])),
+                                                    Eq(2*a[1] + 1, 3)), (0, True))
+    raises(ValueError, lambda: MultivariateEwens('e1', 5, theta_f))
+    assert ed.pspace.distribution.set == ProductSet(Range(0, 4, 1),
+                                            Range(0, 2, 1), Range(0, 2, 1))
+
+    # tests for symbolic dimensions
+    eds = MultivariateEwens('E', n, theta)
+    a = IndexedBase('a')
+    j, k = symbols('j, k')
+    den = Piecewise((factorial(n)*Product(theta**a[j]*(j + 1)**(-a[j])/
+           factorial(a[j]), (j, 0, n - 1))/RisingFactorial(theta, n),
+            Eq(n, Sum((k + 1)*a[k], (k, 0, n - 1)))), (0, True))
+    assert density(eds)(a).dummy_eq(den)
+
+
+def test_Multinomial():
+    n, x1, x2, x3, x4 = symbols('n, x1, x2, x3, x4', nonnegative=True, integer=True)
+    p1, p2, p3, p4 = symbols('p1, p2, p3, p4', positive=True)
+    p1_f, n_f = symbols('p1_f, n_f', negative=True)
+    M = Multinomial('M', n, [p1, p2, p3, p4])
+    C = Multinomial('C', 3, p1, p2, p3)
+    f = factorial
+    assert density(M)(x1, x2, x3, x4) == Piecewise((p1**x1*p2**x2*p3**x3*p4**x4*
+                                            f(n)/(f(x1)*f(x2)*f(x3)*f(x4)),
+                                            Eq(n, x1 + x2 + x3 + x4)), (0, True))
+    assert marginal_distribution(C, C[0])(x1).subs(x1, 1) ==\
+                                                            3*p1*p2**2 +\
+                                                            6*p1*p2*p3 +\
+                                                            3*p1*p3**2
+    raises(ValueError, lambda: Multinomial('b1', 5, [p1, p2, p3, p1_f]))
+    raises(ValueError, lambda: Multinomial('b2', n_f, [p1, p2, p3, p4]))
+    raises(ValueError, lambda: Multinomial('b3', n, 0.5, 0.4, 0.3, 0.1))
+
+
+def test_NegativeMultinomial():
+    k0, x1, x2, x3, x4 = symbols('k0, x1, x2, x3, x4', nonnegative=True, integer=True)
+    p1, p2, p3, p4 = symbols('p1, p2, p3, p4', positive=True)
+    p1_f = symbols('p1_f', negative=True)
+    N = NegativeMultinomial('N', 4, [p1, p2, p3, p4])
+    C = NegativeMultinomial('C', 4, 0.1, 0.2, 0.3)
+    g = gamma
+    f = factorial
+    assert simplify(density(N)(x1, x2, x3, x4) -
+            p1**x1*p2**x2*p3**x3*p4**x4*(-p1 - p2 - p3 - p4 + 1)**4*g(x1 + x2 +
+            x3 + x4 + 4)/(6*f(x1)*f(x2)*f(x3)*f(x4))) is S.Zero
+    assert comp(marginal_distribution(C, C[0])(1).evalf(), 0.33, .01)
+    raises(ValueError, lambda: NegativeMultinomial('b1', 5, [p1, p2, p3, p1_f]))
+    raises(ValueError, lambda: NegativeMultinomial('b2', k0, 0.5, 0.4, 0.3, 0.4))
+    assert N.pspace.distribution.set == ProductSet(Range(0, oo, 1),
+                    Range(0, oo, 1), Range(0, oo, 1), Range(0, oo, 1))
+
+
+@slow
+def test_JointPSpace_marginal_distribution():
+    T = MultivariateT('T', [0, 0], [[1, 0], [0, 1]], 2)
+    got = marginal_distribution(T, T[1])(x)
+    ans = sqrt(2)*(x**2/2 + 1)/(4*polar_lift(x**2/2 + 1)**(S(5)/2))
+    assert got == ans, got
+    assert integrate(marginal_distribution(T, 1)(x), (x, -oo, oo)) == 1
+
+    t = MultivariateT('T', [0, 0, 0], [[1, 0, 0], [0, 1, 0], [0, 0, 1]], 3)
+    assert comp(marginal_distribution(t, 0)(1).evalf(), 0.2, .01)
+
+
+def test_JointRV():
+    x1, x2 = (Indexed('x', i) for i in (1, 2))
+    pdf = exp(-x1**2/2 + x1 - x2**2/2 - S.Half)/(2*pi)
+    X = JointRV('x', pdf)
+    assert density(X)(1, 2) == exp(-2)/(2*pi)
+    assert isinstance(X.pspace.distribution, JointDistributionHandmade)
+    assert marginal_distribution(X, 0)(2) == sqrt(2)*exp(Rational(-1, 2))/(2*sqrt(pi))
+
+
+def test_expectation():
+    m = Normal('A', [x, y], [[1, 0], [0, 1]])
+    assert simplify(E(m[1])) == y
+
+
+@XFAIL
+def test_joint_vector_expectation():
+    m = Normal('A', [x, y], [[1, 0], [0, 1]])
+    assert E(m) == (x, y)
+
+
+def test_sample_numpy():
+    distribs_numpy = [
+        MultivariateNormal("M", [3, 4], [[2, 1], [1, 2]]),
+        MultivariateBeta("B", [0.4, 5, 15, 50, 203]),
+        Multinomial("N", 50, [0.3, 0.2, 0.1, 0.25, 0.15])
+    ]
+    size = 3
+    numpy = import_module('numpy')
+    if not numpy:
+        skip('Numpy is not installed. Abort tests for _sample_numpy.')
+    else:
+        for X in distribs_numpy:
+            samps = sample(X, size=size, library='numpy')
+            for sam in samps:
+                assert tuple(sam) in X.pspace.distribution.set
+        N_c = NegativeMultinomial('N', 3, 0.1, 0.1, 0.1)
+        raises(NotImplementedError, lambda: sample(N_c, library='numpy'))
+
+
+def test_sample_scipy():
+    distribs_scipy = [
+        MultivariateNormal("M", [0, 0], [[0.1, 0.025], [0.025, 0.1]]),
+        MultivariateBeta("B", [0.4, 5, 15]),
+        Multinomial("N", 8, [0.3, 0.2, 0.1, 0.4])
+    ]
+
+    size = 3
+    scipy = import_module('scipy')
+    if not scipy:
+        skip('Scipy not installed. Abort tests for _sample_scipy.')
+    else:
+        for X in distribs_scipy:
+            samps = sample(X, size=size)
+            samps2 = sample(X, size=(2, 2))
+            for sam in samps:
+                assert tuple(sam) in X.pspace.distribution.set
+            for i in range(2):
+                for j in range(2):
+                    assert tuple(samps2[i][j]) in X.pspace.distribution.set
+        N_c = NegativeMultinomial('N', 3, 0.1, 0.1, 0.1)
+        raises(NotImplementedError, lambda: sample(N_c))
+
+
+def test_sample_pymc():
+    distribs_pymc = [
+        MultivariateNormal("M", [5, 2], [[1, 0], [0, 1]]),
+        MultivariateBeta("B", [0.4, 5, 15]),
+        Multinomial("N", 4, [0.3, 0.2, 0.1, 0.4])
+    ]
+    size = 3
+    pymc = import_module('pymc')
+    if not pymc:
+        skip('PyMC is not installed. Abort tests for _sample_pymc.')
+    else:
+        for X in distribs_pymc:
+            samps = sample(X, size=size, library='pymc')
+            for sam in samps:
+                assert tuple(sam.flatten()) in X.pspace.distribution.set
+        N_c = NegativeMultinomial('N', 3, 0.1, 0.1, 0.1)
+        raises(NotImplementedError, lambda: sample(N_c, library='pymc'))
+
+
+def test_sample_seed():
+    x1, x2 = (Indexed('x', i) for i in (1, 2))
+    pdf = exp(-x1**2/2 + x1 - x2**2/2 - S.Half)/(2*pi)
+    X = JointRV('x', pdf)
+
+    libraries = ['scipy', 'numpy', 'pymc']
+    for lib in libraries:
+        try:
+            imported_lib = import_module(lib)
+            if imported_lib:
+                s0, s1, s2 = [], [], []
+                s0 = sample(X, size=10, library=lib, seed=0)
+                s1 = sample(X, size=10, library=lib, seed=0)
+                s2 = sample(X, size=10, library=lib, seed=1)
+                assert all(s0 == s1)
+                assert all(s1 != s2)
+        except NotImplementedError:
+            continue
+
+#
+# XXX: This fails for pymc. Previously the test appeared to pass but that is
+# just because the library argument was not passed so the test always used
+# scipy.
+#
+def test_issue_21057():
+    m = Normal("x", [0, 0], [[0, 0], [0, 0]])
+    n = MultivariateNormal("x", [0, 0], [[0, 0], [0, 0]])
+    p = Normal("x", [0, 0], [[0, 0], [0, 1]])
+    assert m == n
+    libraries = ('scipy', 'numpy')  # , 'pymc')  # <-- pymc fails
+    for library in libraries:
+        try:
+            imported_lib = import_module(library)
+            if imported_lib:
+                s1 = sample(m, size=8, library=library)
+                s2 = sample(n, size=8, library=library)
+                s3 = sample(p, size=8, library=library)
+                assert tuple(s1.flatten()) == tuple(s2.flatten())
+                for s in s3:
+                    assert tuple(s.flatten()) in p.pspace.distribution.set
+        except NotImplementedError:
+            continue
+
+
+#
+# When this passes the pymc part can be uncommented in test_issue_21057 above
+# and this can be deleted.
+#
+@XFAIL
+def test_issue_21057_pymc():
+    m = Normal("x", [0, 0], [[0, 0], [0, 0]])
+    n = MultivariateNormal("x", [0, 0], [[0, 0], [0, 0]])
+    p = Normal("x", [0, 0], [[0, 0], [0, 1]])
+    assert m == n
+    libraries = ('pymc',)
+    for library in libraries:
+        try:
+            imported_lib = import_module(library)
+            if imported_lib:
+                s1 = sample(m, size=8, library=library)
+                s2 = sample(n, size=8, library=library)
+                s3 = sample(p, size=8, library=library)
+                assert tuple(s1.flatten()) == tuple(s2.flatten())
+                for s in s3:
+                    assert tuple(s.flatten()) in p.pspace.distribution.set
+        except NotImplementedError:
+            continue
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/tests/test_matrix_distributions.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/tests/test_matrix_distributions.py
new file mode 100644
index 0000000000000000000000000000000000000000..a2a2dcdd853793d9f77e1a88adf63158ed68e3ba
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/tests/test_matrix_distributions.py
@@ -0,0 +1,186 @@
+from sympy.concrete.products import Product
+from sympy.core.numbers import pi
+from sympy.core.singleton import S
+from sympy.core.symbol import (Dummy, symbols)
+from sympy.functions.elementary.exponential import exp
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.special.gamma_functions import gamma
+from sympy.matrices import Determinant, Matrix, Trace, MatrixSymbol, MatrixSet
+from sympy.stats import density, sample
+from sympy.stats.matrix_distributions import (MatrixGammaDistribution,
+                MatrixGamma, MatrixPSpace, Wishart, MatrixNormal, MatrixStudentT)
+from sympy.testing.pytest import raises, skip
+from sympy.external import import_module
+
+
+def test_MatrixPSpace():
+    M = MatrixGammaDistribution(1, 2, [[2, 1], [1, 2]])
+    MP = MatrixPSpace('M', M, 2, 2)
+    assert MP.distribution == M
+    raises(ValueError, lambda: MatrixPSpace('M', M, 1.2, 2))
+
+def test_MatrixGamma():
+    M = MatrixGamma('M', 1, 2, [[1, 0], [0, 1]])
+    assert M.pspace.distribution.set == MatrixSet(2, 2, S.Reals)
+    assert isinstance(density(M), MatrixGammaDistribution)
+    X = MatrixSymbol('X', 2, 2)
+    num = exp(Trace(Matrix([[-S(1)/2, 0], [0, -S(1)/2]])*X))
+    assert density(M)(X).doit() == num/(4*pi*sqrt(Determinant(X)))
+    assert density(M)([[2, 1], [1, 2]]).doit() == sqrt(3)*exp(-2)/(12*pi)
+    X = MatrixSymbol('X', 1, 2)
+    Y = MatrixSymbol('Y', 1, 2)
+    assert density(M)([X, Y]).doit() == exp(-X[0, 0]/2 - Y[0, 1]/2)/(4*pi*sqrt(
+                                X[0, 0]*Y[0, 1] - X[0, 1]*Y[0, 0]))
+    # symbolic
+    a, b = symbols('a b', positive=True)
+    d = symbols('d', positive=True, integer=True)
+    Y = MatrixSymbol('Y', d, d)
+    Z = MatrixSymbol('Z', 2, 2)
+    SM = MatrixSymbol('SM', d, d)
+    M2 = MatrixGamma('M2', a, b, SM)
+    M3 = MatrixGamma('M3', 2, 3, [[2, 1], [1, 2]])
+    k = Dummy('k')
+    exprd = pi**(-d*(d - 1)/4)*b**(-a*d)*exp(Trace((-1/b)*SM**(-1)*Y)
+        )*Determinant(SM)**(-a)*Determinant(Y)**(a - d/2 - S(1)/2)/Product(
+        gamma(-k/2 + a + S(1)/2), (k, 1, d))
+    assert density(M2)(Y).dummy_eq(exprd)
+    raises(NotImplementedError, lambda: density(M3 + M)(Z))
+    raises(ValueError, lambda: density(M)(1))
+    raises(ValueError, lambda: MatrixGamma('M', -1, 2, [[1, 0], [0, 1]]))
+    raises(ValueError, lambda: MatrixGamma('M', -1, -2, [[1, 0], [0, 1]]))
+    raises(ValueError, lambda: MatrixGamma('M', -1, 2, [[1, 0], [2, 1]]))
+    raises(ValueError, lambda: MatrixGamma('M', -1, 2, [[1, 0], [0]]))
+
+def test_Wishart():
+    W = Wishart('W', 5, [[1, 0], [0, 1]])
+    assert W.pspace.distribution.set == MatrixSet(2, 2, S.Reals)
+    X = MatrixSymbol('X', 2, 2)
+    term1 = exp(Trace(Matrix([[-S(1)/2, 0], [0, -S(1)/2]])*X))
+    assert density(W)(X).doit() == term1 * Determinant(X)/(24*pi)
+    assert density(W)([[2, 1], [1, 2]]).doit() == exp(-2)/(8*pi)
+    n = symbols('n', positive=True)
+    d = symbols('d', positive=True, integer=True)
+    Y = MatrixSymbol('Y', d, d)
+    SM = MatrixSymbol('SM', d, d)
+    W = Wishart('W', n, SM)
+    k = Dummy('k')
+    exprd = 2**(-d*n/2)*pi**(-d*(d - 1)/4)*exp(Trace(-(S(1)/2)*SM**(-1)*Y)
+    )*Determinant(SM)**(-n/2)*Determinant(Y)**(
+    -d/2 + n/2 - S(1)/2)/Product(gamma(-k/2 + n/2 + S(1)/2), (k, 1, d))
+    assert density(W)(Y).dummy_eq(exprd)
+    raises(ValueError, lambda: density(W)(1))
+    raises(ValueError, lambda: Wishart('W', -1, [[1, 0], [0, 1]]))
+    raises(ValueError, lambda: Wishart('W', -1, [[1, 0], [2, 1]]))
+    raises(ValueError, lambda: Wishart('W',  2, [[1, 0], [0]]))
+
+def test_MatrixNormal():
+    M = MatrixNormal('M', [[5, 6]], [4], [[2, 1], [1, 2]])
+    assert M.pspace.distribution.set == MatrixSet(1, 2, S.Reals)
+    X = MatrixSymbol('X', 1, 2)
+    term1 = exp(-Trace(Matrix([[ S(2)/3, -S(1)/3], [-S(1)/3, S(2)/3]])*(
+            Matrix([[-5], [-6]]) + X.T)*Matrix([[S(1)/4]])*(Matrix([[-5, -6]]) + X))/2)
+    assert density(M)(X).doit() == (sqrt(3)) * term1/(24*pi)
+    assert density(M)([[7, 8]]).doit() == sqrt(3)*exp(-S(1)/3)/(24*pi)
+    d, n = symbols('d n', positive=True, integer=True)
+    SM2 = MatrixSymbol('SM2', d, d)
+    SM1 = MatrixSymbol('SM1', n, n)
+    LM = MatrixSymbol('LM', n, d)
+    Y = MatrixSymbol('Y', n, d)
+    M = MatrixNormal('M', LM, SM1, SM2)
+    exprd = (2*pi)**(-d*n/2)*exp(-Trace(SM2**(-1)*(-LM.T + Y.T)*SM1**(-1)*(-LM + Y)
+        )/2)*Determinant(SM1)**(-d/2)*Determinant(SM2)**(-n/2)
+    assert density(M)(Y).doit() == exprd
+    raises(ValueError, lambda: density(M)(1))
+    raises(ValueError, lambda: MatrixNormal('M', [1, 2], [[1, 0], [0, 1]], [[1, 0], [2, 1]]))
+    raises(ValueError, lambda: MatrixNormal('M', [1, 2], [[1, 0], [2, 1]], [[1, 0], [0, 1]]))
+    raises(ValueError, lambda: MatrixNormal('M', [1, 2], [[1, 0], [0, 1]], [[1, 0], [0, 1]]))
+    raises(ValueError, lambda: MatrixNormal('M', [1, 2], [[1, 0], [2]], [[1, 0], [0, 1]]))
+    raises(ValueError, lambda: MatrixNormal('M', [1, 2], [[1, 0], [2, 1]], [[1, 0], [0]]))
+    raises(ValueError, lambda: MatrixNormal('M', [[1, 2]], [[1, 0], [0, 1]], [[1, 0]]))
+    raises(ValueError, lambda: MatrixNormal('M', [[1, 2]], [1], [[1, 0]]))
+
+def test_MatrixStudentT():
+    M = MatrixStudentT('M', 2, [[5, 6]], [[2, 1], [1, 2]], [4])
+    assert M.pspace.distribution.set == MatrixSet(1, 2, S.Reals)
+    X = MatrixSymbol('X', 1, 2)
+    D = pi ** (-1.0) * Determinant(Matrix([[4]])) ** (-1.0) * Determinant(Matrix([[2, 1], [1, 2]])) \
+        ** (-0.5) / Determinant(Matrix([[S(1) / 4]]) * (Matrix([[-5, -6]]) + X)
+                                * Matrix([[S(2) / 3, -S(1) / 3], [-S(1) / 3, S(2) / 3]]) * (
+                                        Matrix([[-5], [-6]]) + X.T) + Matrix([[1]])) ** 2
+    assert density(M)(X) == D
+
+    v = symbols('v', positive=True)
+    n, p = 1, 2
+    Omega = MatrixSymbol('Omega', p, p)
+    Sigma = MatrixSymbol('Sigma', n, n)
+    Location = MatrixSymbol('Location', n, p)
+    Y = MatrixSymbol('Y', n, p)
+    M = MatrixStudentT('M', v, Location, Omega, Sigma)
+
+    exprd = gamma(v/2 + 1)*Determinant(Matrix([[1]]) + Sigma**(-1)*(-Location + Y)*Omega**(-1)*(-Location.T + Y.T))**(-v/2 - 1) / \
+            (pi*gamma(v/2)*sqrt(Determinant(Omega))*Determinant(Sigma))
+
+    assert density(M)(Y) == exprd
+    raises(ValueError, lambda: density(M)(1))
+    raises(ValueError, lambda: MatrixStudentT('M', 1, [1, 2], [[1, 0], [0, 1]], [[1, 0], [2, 1]]))
+    raises(ValueError, lambda: MatrixStudentT('M', 1, [1, 2], [[1, 0], [2, 1]], [[1, 0], [0, 1]]))
+    raises(ValueError, lambda: MatrixStudentT('M', 1, [1, 2], [[1, 0], [0, 1]], [[1, 0], [0, 1]]))
+    raises(ValueError, lambda: MatrixStudentT('M', 1, [1, 2], [[1, 0], [2]], [[1, 0], [0, 1]]))
+    raises(ValueError, lambda: MatrixStudentT('M', 1, [1, 2], [[1, 0], [2, 1]], [[1], [2]]))
+    raises(ValueError, lambda: MatrixStudentT('M', 1, [[1, 2]], [[1, 0], [0, 1]], [[1, 0]]))
+    raises(ValueError, lambda: MatrixStudentT('M', 1, [[1, 2]], [1], [[1, 0]]))
+    raises(ValueError, lambda: MatrixStudentT('M', -1, [1, 2], [[1, 0], [0, 1]], [4]))
+
+def test_sample_scipy():
+    distribs_scipy = [
+        MatrixNormal('M', [[5, 6]], [4], [[2, 1], [1, 2]]),
+        Wishart('W', 5, [[1, 0], [0, 1]])
+    ]
+
+    size = 5
+    scipy = import_module('scipy')
+    if not scipy:
+        skip('Scipy not installed. Abort tests for _sample_scipy.')
+    else:
+        for X in distribs_scipy:
+            samps = sample(X, size=size)
+            for sam in samps:
+                assert Matrix(sam) in X.pspace.distribution.set
+        M = MatrixGamma('M', 1, 2, [[1, 0], [0, 1]])
+        raises(NotImplementedError, lambda: sample(M, size=3))
+
+def test_sample_pymc():
+    distribs_pymc = [
+        MatrixNormal('M', [[5, 6], [3, 4]], [[1, 0], [0, 1]], [[2, 1], [1, 2]]),
+        Wishart('W', 7, [[2, 1], [1, 2]])
+    ]
+    size = 3
+    pymc = import_module('pymc')
+    if not pymc:
+        skip('PyMC is not installed. Abort tests for _sample_pymc.')
+    else:
+        for X in distribs_pymc:
+            samps = sample(X, size=size, library='pymc')
+            for sam in samps:
+                assert Matrix(sam) in X.pspace.distribution.set
+        M = MatrixGamma('M', 1, 2, [[1, 0], [0, 1]])
+        raises(NotImplementedError, lambda: sample(M, size=3))
+
+def test_sample_seed():
+    X = MatrixNormal('M', [[5, 6], [3, 4]], [[1, 0], [0, 1]], [[2, 1], [1, 2]])
+
+    libraries = ['scipy', 'numpy', 'pymc']
+    for lib in libraries:
+        try:
+            imported_lib = import_module(lib)
+            if imported_lib:
+                s0, s1, s2 = [], [], []
+                s0 = sample(X, size=10, library=lib, seed=0)
+                s1 = sample(X, size=10, library=lib, seed=0)
+                s2 = sample(X, size=10, library=lib, seed=1)
+                for i in range(10):
+                    assert (s0[i] == s1[i]).all()
+                    assert (s1[i] != s2[i]).all()
+
+        except NotImplementedError:
+            continue
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/tests/test_mix.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/tests/test_mix.py
new file mode 100644
index 0000000000000000000000000000000000000000..4334d9b144a5ddaad938f195f0276e0e8993aa35
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/tests/test_mix.py
@@ -0,0 +1,82 @@
+from sympy.concrete.summations import Sum
+from sympy.core.add import Add
+from sympy.core.mul import Mul
+from sympy.core.numbers import (Integer, oo, pi)
+from sympy.core.power import Pow
+from sympy.core.relational import (Eq, Ne)
+from sympy.core.symbol import (Dummy, Symbol, symbols)
+from sympy.functions.combinatorial.factorials import factorial
+from sympy.functions.elementary.exponential import exp
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.piecewise import Piecewise
+from sympy.functions.special.delta_functions import DiracDelta
+from sympy.functions.special.gamma_functions import gamma
+from sympy.integrals.integrals import Integral
+from sympy.simplify.simplify import simplify
+from sympy.tensor.indexed import (Indexed, IndexedBase)
+from sympy.functions.elementary.piecewise import ExprCondPair
+from sympy.stats import (Poisson, Beta, Exponential, P,
+                        Multinomial, MultivariateBeta)
+from sympy.stats.crv_types import Normal
+from sympy.stats.drv_types import PoissonDistribution
+from sympy.stats.compound_rv import CompoundPSpace, CompoundDistribution
+from sympy.stats.joint_rv import MarginalDistribution
+from sympy.stats.rv import pspace, density
+from sympy.testing.pytest import ignore_warnings
+
+def test_density():
+    x = Symbol('x')
+    l = Symbol('l', positive=True)
+    rate = Beta(l, 2, 3)
+    X = Poisson(x, rate)
+    assert isinstance(pspace(X), CompoundPSpace)
+    assert density(X, Eq(rate, rate.symbol)) == PoissonDistribution(l)
+    N1 = Normal('N1', 0, 1)
+    N2 = Normal('N2', N1, 2)
+    assert density(N2)(0).doit() == sqrt(10)/(10*sqrt(pi))
+    assert simplify(density(N2, Eq(N1, 1))(x)) == \
+        sqrt(2)*exp(-(x - 1)**2/8)/(4*sqrt(pi))
+    assert simplify(density(N2)(x)) == sqrt(10)*exp(-x**2/10)/(10*sqrt(pi))
+
+def test_MarginalDistribution():
+    a1, p1, p2 = symbols('a1 p1 p2', positive=True)
+    C = Multinomial('C', 2, p1, p2)
+    B = MultivariateBeta('B', a1, C[0])
+    MGR = MarginalDistribution(B, (C[0],))
+    mgrc = Mul(Symbol('B'), Piecewise(ExprCondPair(Mul(Integer(2),
+    Pow(Symbol('p1', positive=True), Indexed(IndexedBase(Symbol('C')),
+    Integer(0))), Pow(Symbol('p2', positive=True),
+    Indexed(IndexedBase(Symbol('C')), Integer(1))),
+    Pow(factorial(Indexed(IndexedBase(Symbol('C')), Integer(0))), Integer(-1)),
+    Pow(factorial(Indexed(IndexedBase(Symbol('C')), Integer(1))), Integer(-1))),
+    Eq(Add(Indexed(IndexedBase(Symbol('C')), Integer(0)),
+    Indexed(IndexedBase(Symbol('C')), Integer(1))), Integer(2))),
+    ExprCondPair(Integer(0), True)), Pow(gamma(Symbol('a1', positive=True)),
+    Integer(-1)), gamma(Add(Symbol('a1', positive=True),
+    Indexed(IndexedBase(Symbol('C')), Integer(0)))),
+    Pow(gamma(Indexed(IndexedBase(Symbol('C')), Integer(0))), Integer(-1)),
+    Pow(Indexed(IndexedBase(Symbol('B')), Integer(0)),
+    Add(Symbol('a1', positive=True), Integer(-1))),
+    Pow(Indexed(IndexedBase(Symbol('B')), Integer(1)),
+    Add(Indexed(IndexedBase(Symbol('C')), Integer(0)), Integer(-1))))
+    assert MGR(C) == mgrc
+
+def test_compound_distribution():
+    Y = Poisson('Y', 1)
+    Z = Poisson('Z', Y)
+    assert isinstance(pspace(Z), CompoundPSpace)
+    assert isinstance(pspace(Z).distribution, CompoundDistribution)
+    assert Z.pspace.distribution.pdf(1).doit() == exp(-2)*exp(exp(-1))
+
+def test_mix_expression():
+    Y, E = Poisson('Y', 1), Exponential('E', 1)
+    k = Dummy('k')
+    expr1 = Integral(Sum(exp(-1)*Integral(exp(-k)*DiracDelta(k - 2), (k, 0, oo)
+    )/factorial(k), (k, 0, oo)), (k, -oo, 0))
+    expr2 = Integral(Sum(exp(-1)*Integral(exp(-k)*DiracDelta(k - 2), (k, 0, oo)
+    )/factorial(k), (k, 0, oo)), (k, 0, oo))
+    assert P(Eq(Y + E, 1)) == 0
+    assert P(Ne(Y + E, 2)) == 1
+    with ignore_warnings(UserWarning): ### TODO: Restore tests once warnings are removed
+        assert P(E + Y < 2, evaluate=False).rewrite(Integral).dummy_eq(expr1)
+        assert P(E + Y > 2, evaluate=False).rewrite(Integral).dummy_eq(expr2)
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/tests/test_random_matrix.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/tests/test_random_matrix.py
new file mode 100644
index 0000000000000000000000000000000000000000..ba570a16bc42620d53bce19be71e7d125965ede1
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/tests/test_random_matrix.py
@@ -0,0 +1,135 @@
+from sympy.concrete.products import Product
+from sympy.core.function import Lambda
+from sympy.core.numbers import (I, Rational, pi)
+from sympy.core.singleton import S
+from sympy.core.symbol import Dummy
+from sympy.functions.elementary.complexes import Abs
+from sympy.functions.elementary.exponential import exp
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.integrals.integrals import Integral
+from sympy.matrices.dense import Matrix
+from sympy.matrices.expressions.matexpr import MatrixSymbol
+from sympy.matrices.expressions.trace import Trace
+from sympy.tensor.indexed import IndexedBase
+from sympy.stats import (GaussianUnitaryEnsemble as GUE, density,
+                         GaussianOrthogonalEnsemble as GOE,
+                         GaussianSymplecticEnsemble as GSE,
+                         joint_eigen_distribution,
+                         CircularUnitaryEnsemble as CUE,
+                         CircularOrthogonalEnsemble as COE,
+                         CircularSymplecticEnsemble as CSE,
+                         JointEigenDistribution,
+                         level_spacing_distribution,
+                         Normal, Beta)
+from sympy.stats.joint_rv_types import JointDistributionHandmade
+from sympy.stats.rv import RandomMatrixSymbol
+from sympy.stats.random_matrix_models import GaussianEnsemble, RandomMatrixPSpace
+from sympy.testing.pytest import raises
+
+def test_GaussianEnsemble():
+    G = GaussianEnsemble('G', 3)
+    assert density(G) == G.pspace.model
+    raises(ValueError, lambda: GaussianEnsemble('G', 3.5))
+
+def test_GaussianUnitaryEnsemble():
+    H = RandomMatrixSymbol('H', 3, 3)
+    G = GUE('U', 3)
+    assert density(G)(H) == sqrt(2)*exp(-3*Trace(H**2)/2)/(4*pi**Rational(9, 2))
+    i, j = (Dummy('i', integer=True, positive=True),
+            Dummy('j', integer=True, positive=True))
+    l = IndexedBase('l')
+    assert joint_eigen_distribution(G).dummy_eq(
+            Lambda((l[1], l[2], l[3]),
+            27*sqrt(6)*exp(-3*(l[1]**2)/2 - 3*(l[2]**2)/2 - 3*(l[3]**2)/2)*
+            Product(Abs(l[i] - l[j])**2, (j, i + 1, 3), (i, 1, 2))/(16*pi**Rational(3, 2))))
+    s = Dummy('s')
+    assert level_spacing_distribution(G).dummy_eq(Lambda(s, 32*s**2*exp(-4*s**2/pi)/pi**2))
+
+
+def test_GaussianOrthogonalEnsemble():
+    H = RandomMatrixSymbol('H', 3, 3)
+    _H = MatrixSymbol('_H', 3, 3)
+    G = GOE('O', 3)
+    assert density(G)(H) == exp(-3*Trace(H**2)/4)/Integral(exp(-3*Trace(_H**2)/4), _H)
+    i, j = (Dummy('i', integer=True, positive=True),
+            Dummy('j', integer=True, positive=True))
+    l = IndexedBase('l')
+    assert joint_eigen_distribution(G).dummy_eq(
+            Lambda((l[1], l[2], l[3]),
+            9*sqrt(2)*exp(-3*l[1]**2/2 - 3*l[2]**2/2 - 3*l[3]**2/2)*
+            Product(Abs(l[i] - l[j]), (j, i + 1, 3), (i, 1, 2))/(32*pi)))
+    s = Dummy('s')
+    assert level_spacing_distribution(G).dummy_eq(Lambda(s, s*pi*exp(-s**2*pi/4)/2))
+
+def test_GaussianSymplecticEnsemble():
+    H = RandomMatrixSymbol('H', 3, 3)
+    _H = MatrixSymbol('_H', 3, 3)
+    G = GSE('O', 3)
+    assert density(G)(H) == exp(-3*Trace(H**2))/Integral(exp(-3*Trace(_H**2)), _H)
+    i, j = (Dummy('i', integer=True, positive=True),
+            Dummy('j', integer=True, positive=True))
+    l = IndexedBase('l')
+    assert joint_eigen_distribution(G).dummy_eq(
+            Lambda((l[1], l[2], l[3]),
+            162*sqrt(3)*exp(-3*l[1]**2/2 - 3*l[2]**2/2 - 3*l[3]**2/2)*
+            Product(Abs(l[i] - l[j])**4, (j, i + 1, 3), (i, 1, 2))/(5*pi**Rational(3, 2))))
+    s = Dummy('s')
+    assert level_spacing_distribution(G).dummy_eq(Lambda(s, S(262144)*s**4*exp(-64*s**2/(9*pi))/(729*pi**3)))
+
+def test_CircularUnitaryEnsemble():
+    CU = CUE('U', 3)
+    j, k = (Dummy('j', integer=True, positive=True),
+            Dummy('k', integer=True, positive=True))
+    t = IndexedBase('t')
+    assert joint_eigen_distribution(CU).dummy_eq(
+            Lambda((t[1], t[2], t[3]),
+            Product(Abs(exp(I*t[j]) - exp(I*t[k]))**2,
+            (j, k + 1, 3), (k, 1, 2))/(48*pi**3))
+    )
+
+def test_CircularOrthogonalEnsemble():
+    CO = COE('U', 3)
+    j, k = (Dummy('j', integer=True, positive=True),
+            Dummy('k', integer=True, positive=True))
+    t = IndexedBase('t')
+    assert joint_eigen_distribution(CO).dummy_eq(
+            Lambda((t[1], t[2], t[3]),
+            Product(Abs(exp(I*t[j]) - exp(I*t[k])),
+            (j, k + 1, 3), (k, 1, 2))/(48*pi**2))
+    )
+
+def test_CircularSymplecticEnsemble():
+    CS = CSE('U', 3)
+    j, k = (Dummy('j', integer=True, positive=True),
+            Dummy('k', integer=True, positive=True))
+    t = IndexedBase('t')
+    assert joint_eigen_distribution(CS).dummy_eq(
+            Lambda((t[1], t[2], t[3]),
+            Product(Abs(exp(I*t[j]) - exp(I*t[k]))**4,
+            (j, k + 1, 3), (k, 1, 2))/(720*pi**3))
+    )
+
+def test_JointEigenDistribution():
+    A = Matrix([[Normal('A00', 0, 1), Normal('A01', 1, 1)],
+                [Beta('A10', 1, 1), Beta('A11', 1, 1)]])
+    assert JointEigenDistribution(A) == \
+    JointDistributionHandmade(-sqrt(A[0, 0]**2 - 2*A[0, 0]*A[1, 1] + 4*A[0, 1]*A[1, 0] + A[1, 1]**2)/2 +
+    A[0, 0]/2 + A[1, 1]/2, sqrt(A[0, 0]**2 - 2*A[0, 0]*A[1, 1] + 4*A[0, 1]*A[1, 0] + A[1, 1]**2)/2 + A[0, 0]/2 + A[1, 1]/2)
+    raises(ValueError, lambda: JointEigenDistribution(Matrix([[1, 0], [2, 1]])))
+
+def test_issue_19841():
+    G1 = GUE('U', 2)
+    G2 = G1.xreplace({2: 2})
+    assert G1.args == G2.args
+
+    X = MatrixSymbol('X', 2, 2)
+    G = GSE('U', 2)
+    h_pspace = RandomMatrixPSpace('P', model=density(G))
+    H = RandomMatrixSymbol('H', 2, 2, pspace=h_pspace)
+    H2 = RandomMatrixSymbol('H', 2, 2, pspace=None)
+    assert H.doit() == H
+
+    assert (2*H).xreplace({H: X}) == 2*X
+    assert (2*H).xreplace({H2: X}) == 2*H
+    assert (2*H2).xreplace({H: X}) == 2*H2
+    assert (2*H2).xreplace({H2: X}) == 2*X
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/tests/test_rv.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/tests/test_rv.py
new file mode 100644
index 0000000000000000000000000000000000000000..185756300556f2fe70b76c402113ec2bb2501ef4
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/tests/test_rv.py
@@ -0,0 +1,441 @@
+from sympy.concrete.summations import Sum
+from sympy.core.basic import Basic
+from sympy.core.containers import Tuple
+from sympy.core.function import Lambda
+from sympy.core.numbers import (Rational, nan, oo, pi)
+from sympy.core.relational import Eq
+from sympy.core.singleton import S
+from sympy.core.symbol import (Symbol, symbols)
+from sympy.functions.combinatorial.factorials import (FallingFactorial, binomial)
+from sympy.functions.elementary.exponential import (exp, log)
+from sympy.functions.elementary.trigonometric import (cos, sin)
+from sympy.functions.special.delta_functions import DiracDelta
+from sympy.integrals.integrals import integrate
+from sympy.logic.boolalg import (And, Or)
+from sympy.matrices.dense import Matrix
+from sympy.sets.sets import Interval
+from sympy.tensor.indexed import Indexed
+from sympy.stats import (Die, Normal, Exponential, FiniteRV, P, E, H, variance,
+        density, given, independent, dependent, where, pspace, GaussianUnitaryEnsemble,
+        random_symbols, sample, Geometric, factorial_moment, Binomial, Hypergeometric,
+        DiscreteUniform, Poisson, characteristic_function, moment_generating_function,
+        BernoulliProcess, Variance, Expectation, Probability, Covariance, covariance, cmoment,
+        moment, median)
+from sympy.stats.rv import (IndependentProductPSpace, rs_swap, Density, NamedArgsMixin,
+        RandomSymbol, sample_iter, PSpace, is_random, RandomIndexedSymbol, RandomMatrixSymbol)
+from sympy.testing.pytest import raises, skip, XFAIL, warns_deprecated_sympy
+from sympy.external import import_module
+from sympy.core.numbers import comp
+from sympy.stats.frv_types import BernoulliDistribution
+from sympy.core.symbol import Dummy
+from sympy.functions.elementary.piecewise import Piecewise
+
+def test_where():
+    X, Y = Die('X'), Die('Y')
+    Z = Normal('Z', 0, 1)
+
+    assert where(Z**2 <= 1).set == Interval(-1, 1)
+    assert where(Z**2 <= 1).as_boolean() == Interval(-1, 1).as_relational(Z.symbol)
+    assert where(And(X > Y, Y > 4)).as_boolean() == And(
+        Eq(X.symbol, 6), Eq(Y.symbol, 5))
+
+    assert len(where(X < 3).set) == 2
+    assert 1 in where(X < 3).set
+
+    X, Y = Normal('X', 0, 1), Normal('Y', 0, 1)
+    assert where(And(X**2 <= 1, X >= 0)).set == Interval(0, 1)
+    XX = given(X, And(X**2 <= 1, X >= 0))
+    assert XX.pspace.domain.set == Interval(0, 1)
+    assert XX.pspace.domain.as_boolean() == \
+        And(0 <= X.symbol, X.symbol**2 <= 1, -oo < X.symbol, X.symbol < oo)
+
+    with raises(TypeError):
+        XX = given(X, X + 3)
+
+
+def test_random_symbols():
+    X, Y = Normal('X', 0, 1), Normal('Y', 0, 1)
+
+    assert set(random_symbols(2*X + 1)) == {X}
+    assert set(random_symbols(2*X + Y)) == {X, Y}
+    assert set(random_symbols(2*X + Y.symbol)) == {X}
+    assert set(random_symbols(2)) == set()
+
+
+def test_characteristic_function():
+    #  Imports I from sympy
+    from sympy.core.numbers import I
+    X = Normal('X',0,1)
+    Y = DiscreteUniform('Y', [1,2,7])
+    Z = Poisson('Z', 2)
+    t = symbols('_t')
+    P = Lambda(t, exp(-t**2/2))
+    Q = Lambda(t, exp(7*t*I)/3 + exp(2*t*I)/3 + exp(t*I)/3)
+    R = Lambda(t, exp(2 * exp(t*I) - 2))
+
+
+    assert characteristic_function(X).dummy_eq(P)
+    assert characteristic_function(Y).dummy_eq(Q)
+    assert characteristic_function(Z).dummy_eq(R)
+
+
+def test_moment_generating_function():
+
+    X = Normal('X',0,1)
+    Y = DiscreteUniform('Y', [1,2,7])
+    Z = Poisson('Z', 2)
+    t = symbols('_t')
+    P = Lambda(t, exp(t**2/2))
+    Q = Lambda(t, (exp(7*t)/3 + exp(2*t)/3 + exp(t)/3))
+    R = Lambda(t, exp(2 * exp(t) - 2))
+
+
+    assert moment_generating_function(X).dummy_eq(P)
+    assert moment_generating_function(Y).dummy_eq(Q)
+    assert moment_generating_function(Z).dummy_eq(R)
+
+def test_sample_iter():
+
+    X = Normal('X',0,1)
+    Y = DiscreteUniform('Y', [1, 2, 7])
+    Z = Poisson('Z', 2)
+
+    scipy = import_module('scipy')
+    if not scipy:
+        skip('Scipy is not installed. Abort tests')
+    expr = X**2 + 3
+    iterator = sample_iter(expr)
+
+    expr2 = Y**2 + 5*Y + 4
+    iterator2 = sample_iter(expr2)
+
+    expr3 = Z**3 + 4
+    iterator3 = sample_iter(expr3)
+
+    def is_iterator(obj):
+        if (
+            hasattr(obj, '__iter__') and
+            (hasattr(obj, 'next') or
+            hasattr(obj, '__next__')) and
+            callable(obj.__iter__) and
+            obj.__iter__() is obj
+           ):
+            return True
+        else:
+            return False
+    assert is_iterator(iterator)
+    assert is_iterator(iterator2)
+    assert is_iterator(iterator3)
+
+def test_pspace():
+    X, Y = Normal('X', 0, 1), Normal('Y', 0, 1)
+    x = Symbol('x')
+
+    raises(ValueError, lambda: pspace(5 + 3))
+    raises(ValueError, lambda: pspace(x < 1))
+    assert pspace(X) == X.pspace
+    assert pspace(2*X + 1) == X.pspace
+    assert pspace(2*X + Y) == IndependentProductPSpace(Y.pspace, X.pspace)
+
+def test_rs_swap():
+    X = Normal('x', 0, 1)
+    Y = Exponential('y', 1)
+
+    XX = Normal('x', 0, 2)
+    YY = Normal('y', 0, 3)
+
+    expr = 2*X + Y
+    assert expr.subs(rs_swap((X, Y), (YY, XX))) == 2*XX + YY
+
+
+def test_RandomSymbol():
+
+    X = Normal('x', 0, 1)
+    Y = Normal('x', 0, 2)
+    assert X.symbol == Y.symbol
+    assert X != Y
+
+    assert X.name == X.symbol.name
+
+    X = Normal('lambda', 0, 1) # make sure we can use protected terms
+    X = Normal('Lambda', 0, 1) # make sure we can use SymPy terms
+
+
+def test_RandomSymbol_diff():
+    X = Normal('x', 0, 1)
+    assert (2*X).diff(X)
+
+
+def test_random_symbol_no_pspace():
+    x = RandomSymbol(Symbol('x'))
+    assert x.pspace == PSpace()
+
+def test_overlap():
+    X = Normal('x', 0, 1)
+    Y = Normal('x', 0, 2)
+
+    raises(ValueError, lambda: P(X > Y))
+
+
+def test_IndependentProductPSpace():
+    X = Normal('X', 0, 1)
+    Y = Normal('Y', 0, 1)
+    px = X.pspace
+    py = Y.pspace
+    assert pspace(X + Y) == IndependentProductPSpace(px, py)
+    assert pspace(X + Y) == IndependentProductPSpace(py, px)
+
+
+def test_E():
+    assert E(5) == 5
+
+
+def test_H():
+    X = Normal('X', 0, 1)
+    D = Die('D', sides = 4)
+    G = Geometric('G', 0.5)
+    assert H(X, X > 0) == -log(2)/2 + S.Half + log(pi)/2
+    assert H(D, D > 2) == log(2)
+    assert comp(H(G).evalf().round(2), 1.39)
+
+
+def test_Sample():
+    X = Die('X', 6)
+    Y = Normal('Y', 0, 1)
+    z = Symbol('z', integer=True)
+
+    scipy = import_module('scipy')
+    if not scipy:
+        skip('Scipy is not installed. Abort tests')
+    assert sample(X) in [1, 2, 3, 4, 5, 6]
+    assert isinstance(sample(X + Y), float)
+
+    assert P(X + Y > 0, Y < 0, numsamples=10).is_number
+    assert E(X + Y, numsamples=10).is_number
+    assert E(X**2 + Y, numsamples=10).is_number
+    assert E((X + Y)**2, numsamples=10).is_number
+    assert variance(X + Y, numsamples=10).is_number
+
+    raises(TypeError, lambda: P(Y > z, numsamples=5))
+
+    assert P(sin(Y) <= 1, numsamples=10) == 1.0
+    assert P(sin(Y) <= 1, cos(Y) < 1, numsamples=10) == 1.0
+
+    assert all(i in range(1, 7) for i in density(X, numsamples=10))
+    assert all(i in range(4, 7) for i in density(X, X>3, numsamples=10))
+
+    numpy = import_module('numpy')
+    if not numpy:
+        skip('Numpy is not installed. Abort tests')
+    #Test Issue #21563: Output of sample must be a float or array
+    assert isinstance(sample(X), (numpy.int32, numpy.int64))
+    assert isinstance(sample(Y), numpy.float64)
+    assert isinstance(sample(X, size=2), numpy.ndarray)
+
+    with warns_deprecated_sympy():
+        sample(X, numsamples=2)
+
+@XFAIL
+def test_samplingE():
+    scipy = import_module('scipy')
+    if not scipy:
+        skip('Scipy is not installed. Abort tests')
+    Y = Normal('Y', 0, 1)
+    z = Symbol('z', integer=True)
+    assert E(Sum(1/z**Y, (z, 1, oo)), Y > 2, numsamples=3).is_number
+
+
+def test_given():
+    X = Normal('X', 0, 1)
+    Y = Normal('Y', 0, 1)
+    A = given(X, True)
+    B = given(X, Y > 2)
+
+    assert X == A == B
+
+
+def test_factorial_moment():
+    X = Poisson('X', 2)
+    Y = Binomial('Y', 2, S.Half)
+    Z = Hypergeometric('Z', 4, 2, 2)
+    assert factorial_moment(X, 2) == 4
+    assert factorial_moment(Y, 2) == S.Half
+    assert factorial_moment(Z, 2) == Rational(1, 3)
+
+    x, y, z, l = symbols('x y z l')
+    Y = Binomial('Y', 2, y)
+    Z = Hypergeometric('Z', 10, 2, 3)
+    assert factorial_moment(Y, l) == y**2*FallingFactorial(
+        2, l) + 2*y*(1 - y)*FallingFactorial(1, l) + (1 - y)**2*\
+            FallingFactorial(0, l)
+    assert factorial_moment(Z, l) == 7*FallingFactorial(0, l)/\
+        15 + 7*FallingFactorial(1, l)/15 + FallingFactorial(2, l)/15
+
+
+def test_dependence():
+    X, Y = Die('X'), Die('Y')
+    assert independent(X, 2*Y)
+    assert not dependent(X, 2*Y)
+
+    X, Y = Normal('X', 0, 1), Normal('Y', 0, 1)
+    assert independent(X, Y)
+    assert dependent(X, 2*X)
+
+    # Create a dependency
+    XX, YY = given(Tuple(X, Y), Eq(X + Y, 3))
+    assert dependent(XX, YY)
+
+def test_dependent_finite():
+    X, Y = Die('X'), Die('Y')
+    # Dependence testing requires symbolic conditions which currently break
+    # finite random variables
+    assert dependent(X, Y + X)
+
+    XX, YY = given(Tuple(X, Y), X + Y > 5)  # Create a dependency
+    assert dependent(XX, YY)
+
+
+def test_normality():
+    X, Y = Normal('X', 0, 1), Normal('Y', 0, 1)
+    x = Symbol('x', real=True)
+    z = Symbol('z', real=True)
+    dens = density(X - Y, Eq(X + Y, z))
+
+    assert integrate(dens(x), (x, -oo, oo)) == 1
+
+
+def test_Density():
+    X = Die('X', 6)
+    d = Density(X)
+    assert d.doit() == density(X)
+
+def test_NamedArgsMixin():
+    class Foo(Basic, NamedArgsMixin):
+        _argnames = 'foo', 'bar'
+
+    a = Foo(S(1), S(2))
+
+    assert a.foo == 1
+    assert a.bar == 2
+
+    raises(AttributeError, lambda: a.baz)
+
+    class Bar(Basic, NamedArgsMixin):
+        pass
+
+    raises(AttributeError, lambda: Bar(S(1), S(2)).foo)
+
+def test_density_constant():
+    assert density(3)(2) == 0
+    assert density(3)(3) == DiracDelta(0)
+
+def test_cmoment_constant():
+    assert variance(3) == 0
+    assert cmoment(3, 3) == 0
+    assert cmoment(3, 4) == 0
+    x = Symbol('x')
+    assert variance(x) == 0
+    assert cmoment(x, 15) == 0
+    assert cmoment(x, 0) == 1
+
+def test_moment_constant():
+    assert moment(3, 0) == 1
+    assert moment(3, 1) == 3
+    assert moment(3, 2) == 9
+    x = Symbol('x')
+    assert moment(x, 2) == x**2
+
+def test_median_constant():
+    assert median(3) == 3
+    x = Symbol('x')
+    assert median(x) == x
+
+def test_real():
+    x = Normal('x', 0, 1)
+    assert x.is_real
+
+
+def test_issue_10052():
+    X = Exponential('X', 3)
+    assert P(X < oo) == 1
+    assert P(X > oo) == 0
+    assert P(X < 2, X > oo) == 0
+    assert P(X < oo, X > oo) == 0
+    assert P(X < oo, X > 2) == 1
+    assert P(X < 3, X == 2) == 0
+    raises(ValueError, lambda: P(1))
+    raises(ValueError, lambda: P(X < 1, 2))
+
+def test_issue_11934():
+    density = {0: .5, 1: .5}
+    X = FiniteRV('X', density)
+    assert E(X) == 0.5
+    assert P( X>= 2) == 0
+
+def test_issue_8129():
+    X = Exponential('X', 4)
+    assert P(X >= X) == 1
+    assert P(X > X) == 0
+    assert P(X > X+1) == 0
+
+def test_issue_12237():
+    X = Normal('X', 0, 1)
+    Y = Normal('Y', 0, 1)
+    U = P(X > 0, X)
+    V = P(Y < 0, X)
+    W = P(X + Y > 0, X)
+    assert W == P(X + Y > 0, X)
+    assert U == BernoulliDistribution(S.Half, S.Zero, S.One)
+    assert V == S.Half
+
+def test_is_random():
+    X = Normal('X', 0, 1)
+    Y = Normal('Y', 0, 1)
+    a, b = symbols('a, b')
+    G = GaussianUnitaryEnsemble('U', 2)
+    B = BernoulliProcess('B', 0.9)
+    assert not is_random(a)
+    assert not is_random(a + b)
+    assert not is_random(a * b)
+    assert not is_random(Matrix([a**2, b**2]))
+    assert is_random(X)
+    assert is_random(X**2 + Y)
+    assert is_random(Y + b**2)
+    assert is_random(Y > 5)
+    assert is_random(B[3] < 1)
+    assert is_random(G)
+    assert is_random(X * Y * B[1])
+    assert is_random(Matrix([[X, B[2]], [G, Y]]))
+    assert is_random(Eq(X, 4))
+
+def test_issue_12283():
+    x = symbols('x')
+    X = RandomSymbol(x)
+    Y = RandomSymbol('Y')
+    Z = RandomMatrixSymbol('Z', 2, 1)
+    W = RandomMatrixSymbol('W', 2, 1)
+    RI = RandomIndexedSymbol(Indexed('RI', 3))
+    assert pspace(Z) == PSpace()
+    assert pspace(RI) == PSpace()
+    assert pspace(X) == PSpace()
+    assert E(X) == Expectation(X)
+    assert P(Y > 3) == Probability(Y > 3)
+    assert variance(X) == Variance(X)
+    assert variance(RI) == Variance(RI)
+    assert covariance(X, Y) == Covariance(X, Y)
+    assert covariance(W, Z) == Covariance(W, Z)
+
+def test_issue_6810():
+    X = Die('X', 6)
+    Y = Normal('Y', 0, 1)
+    assert P(Eq(X, 2)) == S(1)/6
+    assert P(Eq(Y, 0)) == 0
+    assert P(Or(X > 2, X < 3)) == 1
+    assert P(And(X > 3, X > 2)) == S(1)/2
+
+def test_issue_20286():
+    n, p = symbols('n p')
+    B = Binomial('B', n, p)
+    k = Dummy('k', integer = True)
+    eq = Sum(Piecewise((-p**k*(1 - p)**(-k + n)*log(p**k*(1 - p)**(-k + n)*binomial(n, k))*binomial(n, k), (k >= 0) & (k <= n)), (nan, True)), (k, 0, n))
+    assert eq.dummy_eq(H(B))
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/tests/test_stochastic_process.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/tests/test_stochastic_process.py
new file mode 100644
index 0000000000000000000000000000000000000000..3e42ffc8632240b1d85a774467a057e9857c567c
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/tests/test_stochastic_process.py
@@ -0,0 +1,763 @@
+from sympy.concrete.summations import Sum
+from sympy.core.containers import Tuple
+from sympy.core.function import Lambda
+from sympy.core.numbers import (Float, Rational, oo, pi)
+from sympy.core.relational import (Eq, Ge, Gt, Le, Lt, Ne)
+from sympy.core.singleton import S
+from sympy.core.symbol import (Symbol, symbols)
+from sympy.functions.combinatorial.factorials import factorial
+from sympy.functions.elementary.exponential import exp
+from sympy.functions.elementary.integers import ceiling
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.piecewise import Piecewise
+from sympy.functions.special.error_functions import erf
+from sympy.functions.special.gamma_functions import (gamma, lowergamma)
+from sympy.logic.boolalg import (And, Not)
+from sympy.matrices.dense import Matrix
+from sympy.matrices.expressions.matexpr import MatrixSymbol
+from sympy.matrices.immutable import ImmutableMatrix
+from sympy.sets.contains import Contains
+from sympy.sets.fancysets import Range
+from sympy.sets.sets import (FiniteSet, Interval)
+from sympy.stats import (DiscreteMarkovChain, P, TransitionMatrixOf, E,
+                         StochasticStateSpaceOf, variance, ContinuousMarkovChain,
+                         BernoulliProcess, PoissonProcess, WienerProcess,
+                         GammaProcess, sample_stochastic_process)
+from sympy.stats.joint_rv import JointDistribution
+from sympy.stats.joint_rv_types import JointDistributionHandmade
+from sympy.stats.rv import RandomIndexedSymbol
+from sympy.stats.symbolic_probability import Probability, Expectation
+from sympy.testing.pytest import (raises, skip, ignore_warnings,
+                                  warns_deprecated_sympy)
+from sympy.external import import_module
+from sympy.stats.frv_types import BernoulliDistribution
+from sympy.stats.drv_types import PoissonDistribution
+from sympy.stats.crv_types import NormalDistribution, GammaDistribution
+from sympy.core.symbol import Str
+
+
+def test_DiscreteMarkovChain():
+
+    # pass only the name
+    X = DiscreteMarkovChain("X")
+    assert isinstance(X.state_space, Range)
+    assert X.index_set == S.Naturals0
+    assert isinstance(X.transition_probabilities, MatrixSymbol)
+    t = symbols('t', positive=True, integer=True)
+    assert isinstance(X[t], RandomIndexedSymbol)
+    assert E(X[0]) == Expectation(X[0])
+    raises(TypeError, lambda: DiscreteMarkovChain(1))
+    raises(NotImplementedError, lambda: X(t))
+    raises(NotImplementedError, lambda: X.communication_classes())
+    raises(NotImplementedError, lambda: X.canonical_form())
+    raises(NotImplementedError, lambda: X.decompose())
+
+    nz = Symbol('n', integer=True)
+    TZ = MatrixSymbol('M', nz, nz)
+    SZ = Range(nz)
+    YZ = DiscreteMarkovChain('Y', SZ, TZ)
+    assert P(Eq(YZ[2], 1), Eq(YZ[1], 0)) == TZ[0, 1]
+
+    raises(ValueError, lambda: sample_stochastic_process(t))
+    raises(ValueError, lambda: next(sample_stochastic_process(X)))
+    # pass name and state_space
+    # any hashable object should be a valid state
+    # states should be valid as a tuple/set/list/Tuple/Range
+    sym, rainy, cloudy, sunny = symbols('a Rainy Cloudy Sunny', real=True)
+    state_spaces = [(1, 2, 3), [Str('Hello'), sym, DiscreteMarkovChain("Y", (1,2,3))],
+                    Tuple(S(1), exp(sym), Str('World'), sympify=False), Range(-1, 5, 2),
+                    [rainy, cloudy, sunny]]
+    chains = [DiscreteMarkovChain("Y", state_space) for state_space in state_spaces]
+
+    for i, Y in enumerate(chains):
+        assert isinstance(Y.transition_probabilities, MatrixSymbol)
+        assert Y.state_space == state_spaces[i] or Y.state_space == FiniteSet(*state_spaces[i])
+        assert Y.number_of_states == 3
+
+        with ignore_warnings(UserWarning):  # TODO: Restore tests once warnings are removed
+            assert P(Eq(Y[2], 1), Eq(Y[0], 2), evaluate=False) == Probability(Eq(Y[2], 1), Eq(Y[0], 2))
+        assert E(Y[0]) == Expectation(Y[0])
+
+        raises(ValueError, lambda: next(sample_stochastic_process(Y)))
+
+    raises(TypeError, lambda: DiscreteMarkovChain("Y", {1: 1}))
+    Y = DiscreteMarkovChain("Y", Range(1, t, 2))
+    assert Y.number_of_states == ceiling((t-1)/2)
+
+    # pass name and transition_probabilities
+    chains = [DiscreteMarkovChain("Y", trans_probs=Matrix([])),
+              DiscreteMarkovChain("Y", trans_probs=Matrix([[0, 1], [1, 0]])),
+              DiscreteMarkovChain("Y", trans_probs=Matrix([[pi, 1-pi], [sym, 1-sym]]))]
+    for Z in chains:
+        assert Z.number_of_states == Z.transition_probabilities.shape[0]
+        assert isinstance(Z.transition_probabilities, ImmutableMatrix)
+
+    # pass name, state_space and transition_probabilities
+    T = Matrix([[0.5, 0.2, 0.3],[0.2, 0.5, 0.3],[0.2, 0.3, 0.5]])
+    TS = MatrixSymbol('T', 3, 3)
+    Y = DiscreteMarkovChain("Y", [0, 1, 2], T)
+    YS = DiscreteMarkovChain("Y", ['One', 'Two', 3], TS)
+    assert Y.joint_distribution(1, Y[2], 3) == JointDistribution(Y[1], Y[2], Y[3])
+    raises(ValueError, lambda: Y.joint_distribution(Y[1].symbol, Y[2].symbol))
+    assert P(Eq(Y[3], 2), Eq(Y[1], 1)).round(2) == Float(0.36, 2)
+    assert (P(Eq(YS[3], 2), Eq(YS[1], 1)) -
+            (TS[0, 2]*TS[1, 0] + TS[1, 1]*TS[1, 2] + TS[1, 2]*TS[2, 2])).simplify() == 0
+    assert P(Eq(YS[1], 1), Eq(YS[2], 2)) == Probability(Eq(YS[1], 1))
+    assert P(Eq(YS[3], 3), Eq(YS[1], 1)) == TS[0, 2]*TS[1, 0] + TS[1, 1]*TS[1, 2] + TS[1, 2]*TS[2, 2]
+    TO = Matrix([[0.25, 0.75, 0],[0, 0.25, 0.75],[0.75, 0, 0.25]])
+    assert P(Eq(Y[3], 2), Eq(Y[1], 1) & TransitionMatrixOf(Y, TO)).round(3) == Float(0.375, 3)
+    with ignore_warnings(UserWarning): ### TODO: Restore tests once warnings are removed
+        assert E(Y[3], evaluate=False) == Expectation(Y[3])
+        assert E(Y[3], Eq(Y[2], 1)).round(2) == Float(1.1, 3)
+    TSO = MatrixSymbol('T', 4, 4)
+    raises(ValueError, lambda: str(P(Eq(YS[3], 2), Eq(YS[1], 1) & TransitionMatrixOf(YS, TSO))))
+    raises(TypeError, lambda: DiscreteMarkovChain("Z", [0, 1, 2], symbols('M')))
+    raises(ValueError, lambda: DiscreteMarkovChain("Z", [0, 1, 2], MatrixSymbol('T', 3, 4)))
+    raises(ValueError, lambda: E(Y[3], Eq(Y[2], 6)))
+    raises(ValueError, lambda: E(Y[2], Eq(Y[3], 1)))
+
+
+    # extended tests for probability queries
+    TO1 = Matrix([[Rational(1, 4), Rational(3, 4), 0],[Rational(1, 3), Rational(1, 3), Rational(1, 3)],[0, Rational(1, 4), Rational(3, 4)]])
+    assert P(And(Eq(Y[2], 1), Eq(Y[1], 1), Eq(Y[0], 0)),
+            Eq(Probability(Eq(Y[0], 0)), Rational(1, 4)) & TransitionMatrixOf(Y, TO1)) == Rational(1, 16)
+    assert P(And(Eq(Y[2], 1), Eq(Y[1], 1), Eq(Y[0], 0)), TransitionMatrixOf(Y, TO1)) == \
+            Probability(Eq(Y[0], 0))/4
+    assert P(Lt(X[1], 2) & Gt(X[1], 0), Eq(X[0], 2) &
+        StochasticStateSpaceOf(X, [0, 1, 2]) & TransitionMatrixOf(X, TO1)) == Rational(1, 4)
+    assert P(Lt(X[1], 2) & Gt(X[1], 0), Eq(X[0], 2) &
+             StochasticStateSpaceOf(X, [S(0), '0', 1]) & TransitionMatrixOf(X, TO1)) == Rational(1, 4)
+    assert P(Ne(X[1], 2) & Ne(X[1], 1), Eq(X[0], 2) &
+        StochasticStateSpaceOf(X, [0, 1, 2]) & TransitionMatrixOf(X, TO1)) is S.Zero
+    assert P(Ne(X[1], 2) & Ne(X[1], 1), Eq(X[0], 2) &
+             StochasticStateSpaceOf(X, [S(0), '0', 1]) & TransitionMatrixOf(X, TO1)) is S.Zero
+    assert P(And(Eq(Y[2], 1), Eq(Y[1], 1), Eq(Y[0], 0)), Eq(Y[1], 1)) == 0.1*Probability(Eq(Y[0], 0))
+
+    # testing properties of Markov chain
+    TO2 = Matrix([[S.One, 0, 0],[Rational(1, 3), Rational(1, 3), Rational(1, 3)],[0, Rational(1, 4), Rational(3, 4)]])
+    TO3 = Matrix([[Rational(1, 4), Rational(3, 4), 0],[Rational(1, 3), Rational(1, 3), Rational(1, 3)], [0, Rational(1, 4), Rational(3, 4)]])
+    Y2 = DiscreteMarkovChain('Y', trans_probs=TO2)
+    Y3 = DiscreteMarkovChain('Y', trans_probs=TO3)
+    assert Y3.fundamental_matrix() == ImmutableMatrix([[176, 81, -132], [36, 141, -52], [-44, -39, 208]])/125
+    assert Y2.is_absorbing_chain() == True
+    assert Y3.is_absorbing_chain() == False
+    assert Y2.canonical_form() == ([0, 1, 2], TO2)
+    assert Y3.canonical_form() == ([0, 1, 2], TO3)
+    assert Y2.decompose() == ([0, 1, 2], TO2[0:1, 0:1], TO2[1:3, 0:1], TO2[1:3, 1:3])
+    assert Y3.decompose() == ([0, 1, 2], TO3, Matrix(0, 3, []), Matrix(0, 0, []))
+    TO4 = Matrix([[Rational(1, 5), Rational(2, 5), Rational(2, 5)], [Rational(1, 10), S.Half, Rational(2, 5)], [Rational(3, 5), Rational(3, 10), Rational(1, 10)]])
+    Y4 = DiscreteMarkovChain('Y', trans_probs=TO4)
+    w = ImmutableMatrix([[Rational(11, 39), Rational(16, 39), Rational(4, 13)]])
+    assert Y4.limiting_distribution == w
+    assert Y4.is_regular() == True
+    assert Y4.is_ergodic() == True
+    TS1 = MatrixSymbol('T', 3, 3)
+    Y5 = DiscreteMarkovChain('Y', trans_probs=TS1)
+    assert Y5.limiting_distribution(w, TO4).doit() == True
+    assert Y5.stationary_distribution(condition_set=True).subs(TS1, TO4).contains(w).doit() == S.true
+    TO6 = Matrix([[S.One, 0, 0, 0, 0],[S.Half, 0, S.Half, 0, 0],[0, S.Half, 0, S.Half, 0], [0, 0, S.Half, 0, S.Half], [0, 0, 0, 0, 1]])
+    Y6 = DiscreteMarkovChain('Y', trans_probs=TO6)
+    assert Y6.fundamental_matrix() == ImmutableMatrix([[Rational(3, 2), S.One, S.Half], [S.One, S(2), S.One], [S.Half, S.One, Rational(3, 2)]])
+    assert Y6.absorbing_probabilities() == ImmutableMatrix([[Rational(3, 4), Rational(1, 4)], [S.Half, S.Half], [Rational(1, 4), Rational(3, 4)]])
+    with warns_deprecated_sympy():
+        Y6.absorbing_probabilites()
+    TO7 = Matrix([[Rational(1, 2), Rational(1, 4), Rational(1, 4)], [Rational(1, 2), 0, Rational(1, 2)], [Rational(1, 4), Rational(1, 4), Rational(1, 2)]])
+    Y7 = DiscreteMarkovChain('Y', trans_probs=TO7)
+    assert Y7.is_absorbing_chain() == False
+    assert Y7.fundamental_matrix() == ImmutableMatrix([[Rational(86, 75), Rational(1, 25), Rational(-14, 75)],
+                                                            [Rational(2, 25), Rational(21, 25), Rational(2, 25)],
+                                                            [Rational(-14, 75), Rational(1, 25), Rational(86, 75)]])
+
+    # test for zero-sized matrix functionality
+    X = DiscreteMarkovChain('X', trans_probs=Matrix([]))
+    assert X.number_of_states == 0
+    assert X.stationary_distribution() == Matrix([[]])
+    assert X.communication_classes() == []
+    assert X.canonical_form() == ([], Matrix([]))
+    assert X.decompose() == ([], Matrix([]), Matrix([]), Matrix([]))
+    assert X.is_regular() == False
+    assert X.is_ergodic() == False
+
+    # test communication_class
+    # see https://drive.google.com/drive/folders/1HbxLlwwn2b3U8Lj7eb_ASIUb5vYaNIjg?usp=sharing
+    # tutorial 2.pdf
+    TO7 = Matrix([[0, 5, 5, 0, 0],
+                  [0, 0, 0, 10, 0],
+                  [5, 0, 5, 0, 0],
+                  [0, 10, 0, 0, 0],
+                  [0, 3, 0, 3, 4]])/10
+    Y7 = DiscreteMarkovChain('Y', trans_probs=TO7)
+    tuples = Y7.communication_classes()
+    classes, recurrence, periods = list(zip(*tuples))
+    assert classes == ([1, 3], [0, 2], [4])
+    assert recurrence == (True, False, False)
+    assert periods == (2, 1, 1)
+
+    TO8 = Matrix([[0, 0, 0, 10, 0, 0],
+                  [5, 0, 5, 0, 0, 0],
+                  [0, 4, 0, 0, 0, 6],
+                  [10, 0, 0, 0, 0, 0],
+                  [0, 10, 0, 0, 0, 0],
+                  [0, 0, 0, 5, 5, 0]])/10
+    Y8 = DiscreteMarkovChain('Y', trans_probs=TO8)
+    tuples = Y8.communication_classes()
+    classes, recurrence, periods = list(zip(*tuples))
+    assert classes == ([0, 3], [1, 2, 5, 4])
+    assert recurrence == (True, False)
+    assert periods == (2, 2)
+
+    TO9 = Matrix([[2, 0, 0, 3, 0, 0, 3, 2, 0, 0],
+                  [0, 10, 0, 0, 0, 0, 0, 0, 0, 0],
+                  [0, 2, 2, 0, 0, 0, 0, 0, 3, 3],
+                  [0, 0, 0, 3, 0, 0, 6, 1, 0, 0],
+                  [0, 0, 0, 0, 5, 5, 0, 0, 0, 0],
+                  [0, 0, 0, 0, 0, 10, 0, 0, 0, 0],
+                  [4, 0, 0, 5, 0, 0, 1, 0, 0, 0],
+                  [2, 0, 0, 4, 0, 0, 2, 2, 0, 0],
+                  [3, 0, 1, 0, 0, 0, 0, 0, 4, 2],
+                  [0, 0, 4, 0, 0, 0, 0, 0, 3, 3]])/10
+    Y9 = DiscreteMarkovChain('Y', trans_probs=TO9)
+    tuples = Y9.communication_classes()
+    classes, recurrence, periods = list(zip(*tuples))
+    assert classes == ([0, 3, 6, 7], [1], [2, 8, 9], [5], [4])
+    assert recurrence == (True, True, False, True, False)
+    assert periods == (1, 1, 1, 1, 1)
+
+    # test canonical form
+    # see https://web.archive.org/web/20201230182007/https://www.dartmouth.edu/~chance/teaching_aids/books_articles/probability_book/Chapter11.pdf
+    # example 11.13
+    T = Matrix([[1, 0, 0, 0, 0],
+                [S(1) / 2, 0, S(1) / 2, 0, 0],
+                [0, S(1) / 2, 0, S(1) / 2, 0],
+                [0, 0, S(1) / 2, 0, S(1) / 2],
+                [0, 0, 0, 0, S(1)]])
+    DW = DiscreteMarkovChain('DW', [0, 1, 2, 3, 4], T)
+    states, A, B, C = DW.decompose()
+    assert states == [0, 4, 1, 2, 3]
+    assert A == Matrix([[1, 0], [0, 1]])
+    assert B == Matrix([[S(1)/2, 0], [0, 0], [0, S(1)/2]])
+    assert C == Matrix([[0, S(1)/2, 0], [S(1)/2, 0, S(1)/2], [0, S(1)/2, 0]])
+    states, new_matrix = DW.canonical_form()
+    assert states == [0, 4, 1, 2, 3]
+    assert new_matrix == Matrix([[1, 0, 0, 0, 0],
+                                 [0, 1, 0, 0, 0],
+                                 [S(1)/2, 0, 0, S(1)/2, 0],
+                                 [0, 0, S(1)/2, 0, S(1)/2],
+                                 [0, S(1)/2, 0, S(1)/2, 0]])
+
+    # test regular and ergodic
+    # https://web.archive.org/web/20201230182007/https://www.dartmouth.edu/~chance/teaching_aids/books_articles/probability_book/Chapter11.pdf
+    T = Matrix([[0, 4, 0, 0, 0],
+                [1, 0, 3, 0, 0],
+                [0, 2, 0, 2, 0],
+                [0, 0, 3, 0, 1],
+                [0, 0, 0, 4, 0]])/4
+    X = DiscreteMarkovChain('X', trans_probs=T)
+    assert not X.is_regular()
+    assert X.is_ergodic()
+    T = Matrix([[0, 1], [1, 0]])
+    X = DiscreteMarkovChain('X', trans_probs=T)
+    assert not X.is_regular()
+    assert X.is_ergodic()
+    # http://www.math.wisc.edu/~valko/courses/331/MC2.pdf
+    T = Matrix([[2, 1, 1],
+                [2, 0, 2],
+                [1, 1, 2]])/4
+    X = DiscreteMarkovChain('X', trans_probs=T)
+    assert X.is_regular()
+    assert X.is_ergodic()
+    # https://docs.ufpr.br/~lucambio/CE222/1S2014/Kemeny-Snell1976.pdf
+    T = Matrix([[1, 1], [1, 1]])/2
+    X = DiscreteMarkovChain('X', trans_probs=T)
+    assert X.is_regular()
+    assert X.is_ergodic()
+
+    # test is_absorbing_chain
+    T = Matrix([[0, 1, 0],
+                [1, 0, 0],
+                [0, 0, 1]])
+    X = DiscreteMarkovChain('X', trans_probs=T)
+    assert not X.is_absorbing_chain()
+    # https://en.wikipedia.org/wiki/Absorbing_Markov_chain
+    T = Matrix([[1, 1, 0, 0],
+                [0, 1, 1, 0],
+                [1, 0, 0, 1],
+                [0, 0, 0, 2]])/2
+    X = DiscreteMarkovChain('X', trans_probs=T)
+    assert X.is_absorbing_chain()
+    T = Matrix([[2, 0, 0, 0, 0],
+                [1, 0, 1, 0, 0],
+                [0, 1, 0, 1, 0],
+                [0, 0, 1, 0, 1],
+                [0, 0, 0, 0, 2]])/2
+    X = DiscreteMarkovChain('X', trans_probs=T)
+    assert X.is_absorbing_chain()
+
+    # test custom state space
+    Y10 = DiscreteMarkovChain('Y', [1, 2, 3], TO2)
+    tuples = Y10.communication_classes()
+    classes, recurrence, periods = list(zip(*tuples))
+    assert classes == ([1], [2, 3])
+    assert recurrence == (True, False)
+    assert periods == (1, 1)
+    assert Y10.canonical_form() == ([1, 2, 3], TO2)
+    assert Y10.decompose() == ([1, 2, 3], TO2[0:1, 0:1], TO2[1:3, 0:1], TO2[1:3, 1:3])
+
+    # testing miscellaneous queries
+    T = Matrix([[S.Half, Rational(1, 4), Rational(1, 4)],
+                [Rational(1, 3), 0, Rational(2, 3)],
+                [S.Half, S.Half, 0]])
+    X = DiscreteMarkovChain('X', [0, 1, 2], T)
+    assert P(Eq(X[1], 2) & Eq(X[2], 1) & Eq(X[3], 0),
+    Eq(P(Eq(X[1], 0)), Rational(1, 4)) & Eq(P(Eq(X[1], 1)), Rational(1, 4))) == Rational(1, 12)
+    assert P(Eq(X[2], 1) | Eq(X[2], 2), Eq(X[1], 1)) == Rational(2, 3)
+    assert P(Eq(X[2], 1) & Eq(X[2], 2), Eq(X[1], 1)) is S.Zero
+    assert P(Ne(X[2], 2), Eq(X[1], 1)) == Rational(1, 3)
+    assert E(X[1]**2, Eq(X[0], 1)) == Rational(8, 3)
+    assert variance(X[1], Eq(X[0], 1)) == Rational(8, 9)
+    raises(ValueError, lambda: E(X[1], Eq(X[2], 1)))
+    raises(ValueError, lambda: DiscreteMarkovChain('X', [0, 1], T))
+
+    # testing miscellaneous queries with different state space
+    X = DiscreteMarkovChain('X', ['A', 'B', 'C'], T)
+    assert P(Eq(X[1], 2) & Eq(X[2], 1) & Eq(X[3], 0),
+    Eq(P(Eq(X[1], 0)), Rational(1, 4)) & Eq(P(Eq(X[1], 1)), Rational(1, 4))) == Rational(1, 12)
+    assert P(Eq(X[2], 1) | Eq(X[2], 2), Eq(X[1], 1)) == Rational(2, 3)
+    assert P(Eq(X[2], 1) & Eq(X[2], 2), Eq(X[1], 1)) is S.Zero
+    assert P(Ne(X[2], 2), Eq(X[1], 1)) == Rational(1, 3)
+    a = X.state_space.args[0]
+    c = X.state_space.args[2]
+    assert (E(X[1] ** 2, Eq(X[0], 1)) - (a**2/3 + 2*c**2/3)).simplify() == 0
+    assert (variance(X[1], Eq(X[0], 1)) - (2*(-a/3 + c/3)**2/3 + (2*a/3 - 2*c/3)**2/3)).simplify() == 0
+    raises(ValueError, lambda: E(X[1], Eq(X[2], 1)))
+
+    #testing queries with multiple RandomIndexedSymbols
+    T = Matrix([[Rational(5, 10), Rational(3, 10), Rational(2, 10)], [Rational(2, 10), Rational(7, 10), Rational(1, 10)], [Rational(3, 10), Rational(3, 10), Rational(4, 10)]])
+    Y = DiscreteMarkovChain("Y", [0, 1, 2], T)
+    assert P(Eq(Y[7], Y[5]), Eq(Y[2], 0)).round(5) == Float(0.44428, 5)
+    assert P(Gt(Y[3], Y[1]), Eq(Y[0], 0)).round(2) == Float(0.36, 2)
+    assert P(Le(Y[5], Y[10]), Eq(Y[4], 2)).round(6) == Float(0.583120, 6)
+    assert Float(P(Eq(Y[10], Y[5]), Eq(Y[4], 1)), 14) == Float(1 - P(Ne(Y[10], Y[5]), Eq(Y[4], 1)), 14)
+    assert Float(P(Gt(Y[8], Y[9]), Eq(Y[3], 2)), 14) == Float(1 - P(Le(Y[8], Y[9]), Eq(Y[3], 2)), 14)
+    assert Float(P(Lt(Y[1], Y[4]), Eq(Y[0], 0)), 14) == Float(1 - P(Ge(Y[1], Y[4]), Eq(Y[0], 0)), 14)
+    assert P(Eq(Y[5], Y[10]), Eq(Y[2], 1)) == P(Eq(Y[10], Y[5]), Eq(Y[2], 1))
+    assert P(Gt(Y[1], Y[2]), Eq(Y[0], 1)) == P(Lt(Y[2], Y[1]), Eq(Y[0], 1))
+    assert P(Ge(Y[7], Y[6]), Eq(Y[4], 1)) == P(Le(Y[6], Y[7]), Eq(Y[4], 1))
+
+    #test symbolic queries
+    a, b, c, d = symbols('a b c d')
+    T = Matrix([[Rational(1, 10), Rational(4, 10), Rational(5, 10)], [Rational(3, 10), Rational(4, 10), Rational(3, 10)], [Rational(7, 10), Rational(2, 10), Rational(1, 10)]])
+    Y = DiscreteMarkovChain("Y", [0, 1, 2], T)
+    query = P(Eq(Y[a], b), Eq(Y[c], d))
+    assert query.subs({a:10, b:2, c:5, d:1}).evalf().round(4) == P(Eq(Y[10], 2), Eq(Y[5], 1)).round(4)
+    assert query.subs({a:15, b:0, c:10, d:1}).evalf().round(4) == P(Eq(Y[15], 0), Eq(Y[10], 1)).round(4)
+    query_gt = P(Gt(Y[a], b), Eq(Y[c], d))
+    query_le = P(Le(Y[a], b), Eq(Y[c], d))
+    assert query_gt.subs({a:5, b:2, c:1, d:0}).evalf() + query_le.subs({a:5, b:2, c:1, d:0}).evalf() == 1.0
+    query_ge = P(Ge(Y[a], b), Eq(Y[c], d))
+    query_lt = P(Lt(Y[a], b), Eq(Y[c], d))
+    assert query_ge.subs({a:4, b:1, c:0, d:2}).evalf() + query_lt.subs({a:4, b:1, c:0, d:2}).evalf() == 1.0
+
+    #test issue 20078
+    assert (2*Y[1] + 3*Y[1]).simplify() == 5*Y[1]
+    assert (2*Y[1] - 3*Y[1]).simplify() == -Y[1]
+    assert (2*(0.25*Y[1])).simplify() == 0.5*Y[1]
+    assert ((2*Y[1]) * (0.25*Y[1])).simplify() == 0.5*Y[1]**2
+    assert (Y[1]**2 + Y[1]**3).simplify() == (Y[1] + 1)*Y[1]**2
+
+def test_sample_stochastic_process():
+    if not import_module('scipy'):
+        skip('SciPy Not installed. Skip sampling tests')
+    import random
+    random.seed(0)
+    numpy = import_module('numpy')
+    if numpy:
+        numpy.random.seed(0) # scipy uses numpy to sample so to set its seed
+    T = Matrix([[0.5, 0.2, 0.3],[0.2, 0.5, 0.3],[0.2, 0.3, 0.5]])
+    Y = DiscreteMarkovChain("Y", [0, 1, 2], T)
+    for samps in range(10):
+        assert next(sample_stochastic_process(Y)) in Y.state_space
+    Z = DiscreteMarkovChain("Z", ['1', 1, 0], T)
+    for samps in range(10):
+        assert next(sample_stochastic_process(Z)) in Z.state_space
+
+    T = Matrix([[S.Half, Rational(1, 4), Rational(1, 4)],
+                [Rational(1, 3), 0, Rational(2, 3)],
+                [S.Half, S.Half, 0]])
+    X = DiscreteMarkovChain('X', [0, 1, 2], T)
+    for samps in range(10):
+        assert next(sample_stochastic_process(X)) in X.state_space
+    W = DiscreteMarkovChain('W', [1, pi, oo], T)
+    for samps in range(10):
+        assert next(sample_stochastic_process(W)) in W.state_space
+
+
+def test_ContinuousMarkovChain():
+    T1 = Matrix([[S(-2), S(2), S.Zero],
+                 [S.Zero, S.NegativeOne, S.One],
+                 [Rational(3, 2), Rational(3, 2), S(-3)]])
+    C1 = ContinuousMarkovChain('C', [0, 1, 2], T1)
+    assert C1.limiting_distribution() == ImmutableMatrix([[Rational(3, 19), Rational(12, 19), Rational(4, 19)]])
+
+    T2 = Matrix([[-S.One, S.One, S.Zero], [S.One, -S.One, S.Zero], [S.Zero, S.One, -S.One]])
+    C2 = ContinuousMarkovChain('C', [0, 1, 2], T2)
+    A, t = C2.generator_matrix, symbols('t', positive=True)
+    assert C2.transition_probabilities(A)(t) == Matrix([[S.Half + exp(-2*t)/2, S.Half - exp(-2*t)/2, 0],
+                                                       [S.Half - exp(-2*t)/2, S.Half + exp(-2*t)/2, 0],
+                                                       [S.Half - exp(-t) + exp(-2*t)/2, S.Half - exp(-2*t)/2, exp(-t)]])
+    with ignore_warnings(UserWarning): ### TODO: Restore tests once warnings are removed
+        assert P(Eq(C2(1), 1), Eq(C2(0), 1), evaluate=False) == Probability(Eq(C2(1), 1), Eq(C2(0), 1))
+    assert P(Eq(C2(1), 1), Eq(C2(0), 1)) == exp(-2)/2 + S.Half
+    assert P(Eq(C2(1), 0) & Eq(C2(2), 1) & Eq(C2(3), 1),
+                Eq(P(Eq(C2(1), 0)), S.Half)) == (Rational(1, 4) - exp(-2)/4)*(exp(-2)/2 + S.Half)
+    assert P(Not(Eq(C2(1), 0) & Eq(C2(2), 1) & Eq(C2(3), 2)) |
+                (Eq(C2(1), 0) & Eq(C2(2), 1) & Eq(C2(3), 2)),
+                Eq(P(Eq(C2(1), 0)), Rational(1, 4)) & Eq(P(Eq(C2(1), 1)), Rational(1, 4))) is S.One
+    assert E(C2(Rational(3, 2)), Eq(C2(0), 2)) == -exp(-3)/2 + 2*exp(Rational(-3, 2)) + S.Half
+    assert variance(C2(Rational(3, 2)), Eq(C2(0), 1)) == ((S.Half - exp(-3)/2)**2*(exp(-3)/2 + S.Half)
+                                                    + (Rational(-1, 2) - exp(-3)/2)**2*(S.Half - exp(-3)/2))
+    raises(KeyError, lambda: P(Eq(C2(1), 0), Eq(P(Eq(C2(1), 1)), S.Half)))
+    assert P(Eq(C2(1), 0), Eq(P(Eq(C2(5), 1)), S.Half)) == Probability(Eq(C2(1), 0))
+    TS1 = MatrixSymbol('G', 3, 3)
+    CS1 = ContinuousMarkovChain('C', [0, 1, 2], TS1)
+    A = CS1.generator_matrix
+    assert CS1.transition_probabilities(A)(t) == exp(t*A)
+
+    C3 = ContinuousMarkovChain('C', [Symbol('0'), Symbol('1'), Symbol('2')], T2)
+    assert P(Eq(C3(1), 1), Eq(C3(0), 1)) == exp(-2)/2 + S.Half
+    assert P(Eq(C3(1), Symbol('1')), Eq(C3(0), Symbol('1'))) == exp(-2)/2 + S.Half
+
+    #test probability queries
+    G = Matrix([[-S(1), Rational(1, 10), Rational(9, 10)], [Rational(2, 5), -S(1), Rational(3, 5)], [Rational(1, 2), Rational(1, 2), -S(1)]])
+    C = ContinuousMarkovChain('C', state_space=[0, 1, 2], gen_mat=G)
+    assert P(Eq(C(7.385), C(3.19)), Eq(C(0.862), 0)).round(5) == Float(0.35469, 5)
+    assert P(Gt(C(98.715), C(19.807)), Eq(C(11.314), 2)).round(5) == Float(0.32452, 5)
+    assert P(Le(C(5.9), C(10.112)), Eq(C(4), 1)).round(6) == Float(0.675214, 6)
+    assert Float(P(Eq(C(7.32), C(2.91)), Eq(C(2.63), 1)), 14) == Float(1 - P(Ne(C(7.32), C(2.91)), Eq(C(2.63), 1)), 14)
+    assert Float(P(Gt(C(3.36), C(1.101)), Eq(C(0.8), 2)), 14) == Float(1 - P(Le(C(3.36), C(1.101)), Eq(C(0.8), 2)), 14)
+    assert Float(P(Lt(C(4.9), C(2.79)), Eq(C(1.61), 0)), 14) == Float(1 - P(Ge(C(4.9), C(2.79)), Eq(C(1.61), 0)), 14)
+    assert P(Eq(C(5.243), C(10.912)), Eq(C(2.174), 1)) == P(Eq(C(10.912), C(5.243)), Eq(C(2.174), 1))
+    assert P(Gt(C(2.344), C(9.9)), Eq(C(1.102), 1)) == P(Lt(C(9.9), C(2.344)), Eq(C(1.102), 1))
+    assert P(Ge(C(7.87), C(1.008)), Eq(C(0.153), 1)) == P(Le(C(1.008), C(7.87)), Eq(C(0.153), 1))
+
+    #test symbolic queries
+    a, b, c, d = symbols('a b c d')
+    query = P(Eq(C(a), b), Eq(C(c), d))
+    assert query.subs({a:3.65, b:2, c:1.78, d:1}).evalf().round(10) == P(Eq(C(3.65), 2), Eq(C(1.78), 1)).round(10)
+    query_gt = P(Gt(C(a), b), Eq(C(c), d))
+    query_le = P(Le(C(a), b), Eq(C(c), d))
+    assert query_gt.subs({a:13.2, b:0, c:3.29, d:2}).evalf() + query_le.subs({a:13.2, b:0, c:3.29, d:2}).evalf() == 1.0
+    query_ge = P(Ge(C(a), b), Eq(C(c), d))
+    query_lt = P(Lt(C(a), b), Eq(C(c), d))
+    assert query_ge.subs({a:7.43, b:1, c:1.45, d:0}).evalf() + query_lt.subs({a:7.43, b:1, c:1.45, d:0}).evalf() == 1.0
+
+    #test issue 20078
+    assert (2*C(1) + 3*C(1)).simplify() == 5*C(1)
+    assert (2*C(1) - 3*C(1)).simplify() == -C(1)
+    assert (2*(0.25*C(1))).simplify() == 0.5*C(1)
+    assert (2*C(1) * 0.25*C(1)).simplify() == 0.5*C(1)**2
+    assert (C(1)**2 + C(1)**3).simplify() == (C(1) + 1)*C(1)**2
+
+def test_BernoulliProcess():
+
+    B = BernoulliProcess("B", p=0.6, success=1, failure=0)
+    assert B.state_space == FiniteSet(0, 1)
+    assert B.index_set == S.Naturals0
+    assert B.success == 1
+    assert B.failure == 0
+
+    X = BernoulliProcess("X", p=Rational(1,3), success='H', failure='T')
+    assert X.state_space == FiniteSet('H', 'T')
+    H, T = symbols("H,T")
+    assert E(X[1]+X[2]*X[3]) == H**2/9 + 4*H*T/9 + H/3 + 4*T**2/9 + 2*T/3
+
+    t, x = symbols('t, x', positive=True, integer=True)
+    assert isinstance(B[t], RandomIndexedSymbol)
+
+    raises(ValueError, lambda: BernoulliProcess("X", p=1.1, success=1, failure=0))
+    raises(NotImplementedError, lambda: B(t))
+
+    raises(IndexError, lambda: B[-3])
+    assert B.joint_distribution(B[3], B[9]) == JointDistributionHandmade(Lambda((B[3], B[9]),
+                Piecewise((0.6, Eq(B[3], 1)), (0.4, Eq(B[3], 0)), (0, True))
+                *Piecewise((0.6, Eq(B[9], 1)), (0.4, Eq(B[9], 0)), (0, True))))
+
+    assert B.joint_distribution(2, B[4]) == JointDistributionHandmade(Lambda((B[2], B[4]),
+                Piecewise((0.6, Eq(B[2], 1)), (0.4, Eq(B[2], 0)), (0, True))
+                *Piecewise((0.6, Eq(B[4], 1)), (0.4, Eq(B[4], 0)), (0, True))))
+
+    # Test for the sum distribution of Bernoulli Process RVs
+    Y = B[1] + B[2] + B[3]
+    assert P(Eq(Y, 0)).round(2) == Float(0.06, 1)
+    assert P(Eq(Y, 2)).round(2) == Float(0.43, 2)
+    assert P(Eq(Y, 4)).round(2) == 0
+    assert P(Gt(Y, 1)).round(2) == Float(0.65, 2)
+    # Test for independency of each Random Indexed variable
+    assert P(Eq(B[1], 0) & Eq(B[2], 1) & Eq(B[3], 0) & Eq(B[4], 1)).round(2) == Float(0.06, 1)
+
+    assert E(2 * B[1] + B[2]).round(2) == Float(1.80, 3)
+    assert E(2 * B[1] + B[2] + 5).round(2) == Float(6.80, 3)
+    assert E(B[2] * B[4] + B[10]).round(2) == Float(0.96, 2)
+    assert E(B[2] > 0, Eq(B[1],1) & Eq(B[2],1)).round(2) == Float(0.60,2)
+    assert E(B[1]) == 0.6
+    assert P(B[1] > 0).round(2) == Float(0.60, 2)
+    assert P(B[1] < 1).round(2) == Float(0.40, 2)
+    assert P(B[1] > 0, B[2] <= 1).round(2) == Float(0.60, 2)
+    assert P(B[12] * B[5] > 0).round(2) == Float(0.36, 2)
+    assert P(B[12] * B[5] > 0, B[4] < 1).round(2) == Float(0.36, 2)
+    assert P(Eq(B[2], 1), B[2] > 0) == 1.0
+    assert P(Eq(B[5], 3)) == 0
+    assert P(Eq(B[1], 1), B[1] < 0) == 0
+    assert P(B[2] > 0, Eq(B[2], 1)) == 1
+    assert P(B[2] < 0, Eq(B[2], 1)) == 0
+    assert P(B[2] > 0, B[2]==7) == 0
+    assert P(B[5] > 0, B[5]) == BernoulliDistribution(0.6, 0, 1)
+    raises(ValueError, lambda: P(3))
+    raises(ValueError, lambda: P(B[3] > 0, 3))
+
+    # test issue 19456
+    expr = Sum(B[t], (t, 0, 4))
+    expr2 = Sum(B[t], (t, 1, 3))
+    expr3 = Sum(B[t]**2, (t, 1, 3))
+    assert expr.doit() == B[0] + B[1] + B[2] + B[3] + B[4]
+    assert expr2.doit() == Y
+    assert expr3.doit() == B[1]**2 + B[2]**2 + B[3]**2
+    assert B[2*t].free_symbols == {B[2*t], t}
+    assert B[4].free_symbols == {B[4]}
+    assert B[x*t].free_symbols == {B[x*t], x, t}
+
+    #test issue 20078
+    assert (2*B[t] + 3*B[t]).simplify() == 5*B[t]
+    assert (2*B[t] - 3*B[t]).simplify() == -B[t]
+    assert (2*(0.25*B[t])).simplify() == 0.5*B[t]
+    assert (2*B[t] * 0.25*B[t]).simplify() == 0.5*B[t]**2
+    assert (B[t]**2 + B[t]**3).simplify() == (B[t] + 1)*B[t]**2
+
+def test_PoissonProcess():
+    X = PoissonProcess("X", 3)
+    assert X.state_space == S.Naturals0
+    assert X.index_set == Interval(0, oo)
+    assert X.lamda == 3
+
+    t, d, x, y = symbols('t d x y', positive=True)
+    assert isinstance(X(t), RandomIndexedSymbol)
+    assert X.distribution(t) == PoissonDistribution(3*t)
+    with warns_deprecated_sympy():
+        X.distribution(X(t))
+    raises(ValueError, lambda: PoissonProcess("X", -1))
+    raises(NotImplementedError, lambda: X[t])
+    raises(IndexError, lambda: X(-5))
+
+    assert X.joint_distribution(X(2), X(3)) == JointDistributionHandmade(Lambda((X(2), X(3)),
+                6**X(2)*9**X(3)*exp(-15)/(factorial(X(2))*factorial(X(3)))))
+
+    assert X.joint_distribution(4, 6) == JointDistributionHandmade(Lambda((X(4), X(6)),
+                12**X(4)*18**X(6)*exp(-30)/(factorial(X(4))*factorial(X(6)))))
+
+    assert P(X(t) < 1) == exp(-3*t)
+    assert P(Eq(X(t), 0), Contains(t, Interval.Lopen(3, 5))) == exp(-6) # exp(-2*lamda)
+    res = P(Eq(X(t), 1), Contains(t, Interval.Lopen(3, 4)))
+    assert res == 3*exp(-3)
+
+    # Equivalent to P(Eq(X(t), 1))**4 because of non-overlapping intervals
+    assert P(Eq(X(t), 1) & Eq(X(d), 1) & Eq(X(x), 1) & Eq(X(y), 1), Contains(t, Interval.Lopen(0, 1))
+    & Contains(d, Interval.Lopen(1, 2)) & Contains(x, Interval.Lopen(2, 3))
+    & Contains(y, Interval.Lopen(3, 4))) == res**4
+
+    # Return Probability because of overlapping intervals
+    assert P(Eq(X(t), 2) & Eq(X(d), 3), Contains(t, Interval.Lopen(0, 2))
+    & Contains(d, Interval.Ropen(2, 4))) == \
+                Probability(Eq(X(d), 3) & Eq(X(t), 2), Contains(t, Interval.Lopen(0, 2))
+                & Contains(d, Interval.Ropen(2, 4)))
+
+    raises(ValueError, lambda: P(Eq(X(t), 2) & Eq(X(d), 3),
+    Contains(t, Interval.Lopen(0, 4)) & Contains(d, Interval.Lopen(3, oo)))) # no bound on d
+    assert P(Eq(X(3), 2)) == 81*exp(-9)/2
+    assert P(Eq(X(t), 2), Contains(t, Interval.Lopen(0, 5))) == 225*exp(-15)/2
+
+    # Check that probability works correctly by adding it to 1
+    res1 = P(X(t) <= 3, Contains(t, Interval.Lopen(0, 5)))
+    res2 = P(X(t) > 3, Contains(t, Interval.Lopen(0, 5)))
+    assert res1 == 691*exp(-15)
+    assert (res1 + res2).simplify() == 1
+
+    # Check Not and  Or
+    assert P(Not(Eq(X(t), 2) & (X(d) > 3)), Contains(t, Interval.Ropen(2, 4)) & \
+            Contains(d, Interval.Lopen(7, 8))).simplify() == -18*exp(-6) + 234*exp(-9) + 1
+    assert P(Eq(X(t), 2) | Ne(X(t), 4), Contains(t, Interval.Ropen(2, 4))) == 1 - 36*exp(-6)
+    raises(ValueError, lambda: P(X(t) > 2, X(t) + X(d)))
+    assert E(X(t)) == 3*t  # property of the distribution at a given timestamp
+    assert E(X(t)**2 + X(d)*2 + X(y)**3, Contains(t, Interval.Lopen(0, 1))
+        & Contains(d, Interval.Lopen(1, 2)) & Contains(y, Interval.Ropen(3, 4))) == 75
+    assert E(X(t)**2, Contains(t, Interval.Lopen(0, 1))) == 12
+    assert E(x*(X(t) + X(d))*(X(t)**2+X(d)**2), Contains(t, Interval.Lopen(0, 1))
+    & Contains(d, Interval.Ropen(1, 2))) == \
+            Expectation(x*(X(d) + X(t))*(X(d)**2 + X(t)**2), Contains(t, Interval.Lopen(0, 1))
+            & Contains(d, Interval.Ropen(1, 2)))
+
+    # Value Error because of infinite time bound
+    raises(ValueError, lambda: E(X(t)**3, Contains(t, Interval.Lopen(1, oo))))
+
+    # Equivalent to E(X(t)**2) - E(X(d)**2) == E(X(1)**2) - E(X(1)**2) == 0
+    assert E((X(t) + X(d))*(X(t) - X(d)), Contains(t, Interval.Lopen(0, 1))
+        & Contains(d, Interval.Lopen(1, 2))) == 0
+    assert E(X(2) + x*E(X(5))) == 15*x + 6
+    assert E(x*X(1) + y) == 3*x + y
+    assert P(Eq(X(1), 2) & Eq(X(t), 3), Contains(t, Interval.Lopen(1, 2))) == 81*exp(-6)/4
+    Y = PoissonProcess("Y", 6)
+    Z = X + Y
+    assert Z.lamda == X.lamda + Y.lamda == 9
+    raises(ValueError, lambda: X + 5) # should be added be only PoissonProcess instance
+    N, M = Z.split(4, 5)
+    assert N.lamda == 4
+    assert M.lamda == 5
+    raises(ValueError, lambda: Z.split(3, 2)) # 2+3 != 9
+
+    raises(ValueError, lambda :P(Eq(X(t), 0), Contains(t, Interval.Lopen(1, 3)) & Eq(X(1), 0)))
+    # check if it handles queries with two random variables in one args
+    res1 = P(Eq(N(3), N(5)))
+    assert res1 == P(Eq(N(t), 0), Contains(t, Interval(3, 5)))
+    res2 = P(N(3) > N(1))
+    assert res2 == P((N(t) > 0), Contains(t, Interval(1, 3)))
+    assert P(N(3) < N(1)) == 0 # condition is not possible
+    res3 = P(N(3) <= N(1)) # holds only for Eq(N(3), N(1))
+    assert res3 == P(Eq(N(t), 0), Contains(t, Interval(1, 3)))
+
+    # tests from https://www.probabilitycourse.com/chapter11/11_1_2_basic_concepts_of_the_poisson_process.php
+    X = PoissonProcess('X', 10) # 11.1
+    assert P(Eq(X(S(1)/3), 3) & Eq(X(1), 10)) == exp(-10)*Rational(8000000000, 11160261)
+    assert P(Eq(X(1), 1), Eq(X(S(1)/3), 3)) == 0
+    assert P(Eq(X(1), 10), Eq(X(S(1)/3), 3)) == P(Eq(X(S(2)/3), 7))
+
+    X = PoissonProcess('X', 2) # 11.2
+    assert P(X(S(1)/2) < 1) == exp(-1)
+    assert P(X(3) < 1, Eq(X(1), 0)) == exp(-4)
+    assert P(Eq(X(4), 3), Eq(X(2), 3)) == exp(-4)
+
+    X = PoissonProcess('X', 3)
+    assert P(Eq(X(2), 5) & Eq(X(1), 2)) == Rational(81, 4)*exp(-6)
+
+    # check few properties
+    assert P(X(2) <= 3, X(1)>=1) == 3*P(Eq(X(1), 0)) + 2*P(Eq(X(1), 1)) + P(Eq(X(1), 2))
+    assert P(X(2) <= 3, X(1) > 1) == 2*P(Eq(X(1), 0)) + 1*P(Eq(X(1), 1))
+    assert P(Eq(X(2), 5) & Eq(X(1), 2)) == P(Eq(X(1), 3))*P(Eq(X(1), 2))
+    assert P(Eq(X(3), 4), Eq(X(1), 3)) == P(Eq(X(2), 1))
+
+    #test issue 20078
+    assert (2*X(t) + 3*X(t)).simplify() == 5*X(t)
+    assert (2*X(t) - 3*X(t)).simplify() == -X(t)
+    assert (2*(0.25*X(t))).simplify() == 0.5*X(t)
+    assert (2*X(t) * 0.25*X(t)).simplify() == 0.5*X(t)**2
+    assert (X(t)**2 + X(t)**3).simplify() == (X(t) + 1)*X(t)**2
+
+def test_WienerProcess():
+    X = WienerProcess("X")
+    assert X.state_space == S.Reals
+    assert X.index_set == Interval(0, oo)
+
+    t, d, x, y = symbols('t d x y', positive=True)
+    assert isinstance(X(t), RandomIndexedSymbol)
+    assert X.distribution(t) == NormalDistribution(0, sqrt(t))
+    with warns_deprecated_sympy():
+        X.distribution(X(t))
+    raises(ValueError, lambda: PoissonProcess("X", -1))
+    raises(NotImplementedError, lambda: X[t])
+    raises(IndexError, lambda: X(-2))
+
+    assert X.joint_distribution(X(2), X(3)) == JointDistributionHandmade(
+        Lambda((X(2), X(3)), sqrt(6)*exp(-X(2)**2/4)*exp(-X(3)**2/6)/(12*pi)))
+    assert X.joint_distribution(4, 6) == JointDistributionHandmade(
+        Lambda((X(4), X(6)), sqrt(6)*exp(-X(4)**2/8)*exp(-X(6)**2/12)/(24*pi)))
+
+    assert P(X(t) < 3).simplify() == erf(3*sqrt(2)/(2*sqrt(t)))/2 + S(1)/2
+    assert P(X(t) > 2, Contains(t, Interval.Lopen(3, 7))).simplify() == S(1)/2 -\
+                erf(sqrt(2)/2)/2
+
+    # Equivalent to P(X(1)>1)**4
+    assert P((X(t) > 4) & (X(d) > 3) & (X(x) > 2) & (X(y) > 1),
+        Contains(t, Interval.Lopen(0, 1)) & Contains(d, Interval.Lopen(1, 2))
+        & Contains(x, Interval.Lopen(2, 3)) & Contains(y, Interval.Lopen(3, 4))).simplify() ==\
+        (1 - erf(sqrt(2)/2))*(1 - erf(sqrt(2)))*(1 - erf(3*sqrt(2)/2))*(1 - erf(2*sqrt(2)))/16
+
+    # Contains an overlapping interval so, return Probability
+    assert P((X(t)< 2) & (X(d)> 3), Contains(t, Interval.Lopen(0, 2))
+        & Contains(d, Interval.Ropen(2, 4))) == Probability((X(d) > 3) & (X(t) < 2),
+        Contains(d, Interval.Ropen(2, 4)) & Contains(t, Interval.Lopen(0, 2)))
+
+    assert str(P(Not((X(t) < 5) & (X(d) > 3)), Contains(t, Interval.Ropen(2, 4)) &
+        Contains(d, Interval.Lopen(7, 8))).simplify()) == \
+                '-(1 - erf(3*sqrt(2)/2))*(2 - erfc(5/2))/4 + 1'
+    # Distribution has mean 0 at each timestamp
+    assert E(X(t)) == 0
+    assert E(x*(X(t) + X(d))*(X(t)**2+X(d)**2), Contains(t, Interval.Lopen(0, 1))
+    & Contains(d, Interval.Ropen(1, 2))) == Expectation(x*(X(d) + X(t))*(X(d)**2 + X(t)**2),
+    Contains(d, Interval.Ropen(1, 2)) & Contains(t, Interval.Lopen(0, 1)))
+    assert E(X(t) + x*E(X(3))) == 0
+
+    #test issue 20078
+    assert (2*X(t) + 3*X(t)).simplify() == 5*X(t)
+    assert (2*X(t) - 3*X(t)).simplify() == -X(t)
+    assert (2*(0.25*X(t))).simplify() == 0.5*X(t)
+    assert (2*X(t) * 0.25*X(t)).simplify() == 0.5*X(t)**2
+    assert (X(t)**2 + X(t)**3).simplify() == (X(t) + 1)*X(t)**2
+
+
+def test_GammaProcess_symbolic():
+    t, d, x, y, g, l = symbols('t d x y g l', positive=True)
+    X = GammaProcess("X", l, g)
+
+    raises(NotImplementedError, lambda: X[t])
+    raises(IndexError, lambda: X(-1))
+    assert isinstance(X(t), RandomIndexedSymbol)
+    assert X.state_space == Interval(0, oo)
+    assert X.distribution(t) == GammaDistribution(g*t, 1/l)
+    with warns_deprecated_sympy():
+        X.distribution(X(t))
+    assert X.joint_distribution(5, X(3)) == JointDistributionHandmade(Lambda(
+        (X(5), X(3)), l**(8*g)*exp(-l*X(3))*exp(-l*X(5))*X(3)**(3*g - 1)*X(5)**(5*g
+        - 1)/(gamma(3*g)*gamma(5*g))))
+    # property of the gamma process at any given timestamp
+    assert E(X(t)) == g*t/l
+    assert variance(X(t)).simplify() == g*t/l**2
+
+    # Equivalent to E(2*X(1)) + E(X(1)**2) + E(X(1)**3), where E(X(1)) == g/l
+    assert E(X(t)**2 + X(d)*2 + X(y)**3, Contains(t, Interval.Lopen(0, 1))
+        & Contains(d, Interval.Lopen(1, 2)) & Contains(y, Interval.Ropen(3, 4))) == \
+            2*g/l + (g**2 + g)/l**2 + (g**3 + 3*g**2 + 2*g)/l**3
+
+    assert P(X(t) > 3, Contains(t, Interval.Lopen(3, 4))).simplify() == \
+                                1 - lowergamma(g, 3*l)/gamma(g) # equivalent to P(X(1)>3)
+
+
+    #test issue 20078
+    assert (2*X(t) + 3*X(t)).simplify() == 5*X(t)
+    assert (2*X(t) - 3*X(t)).simplify() == -X(t)
+    assert (2*(0.25*X(t))).simplify() == 0.5*X(t)
+    assert (2*X(t) * 0.25*X(t)).simplify() == 0.5*X(t)**2
+    assert (X(t)**2 + X(t)**3).simplify() == (X(t) + 1)*X(t)**2
+def test_GammaProcess_numeric():
+    t, d, x, y = symbols('t d x y', positive=True)
+    X = GammaProcess("X", 1, 2)
+    assert X.state_space == Interval(0, oo)
+    assert X.index_set == Interval(0, oo)
+    assert X.lamda == 1
+    assert X.gamma == 2
+
+    raises(ValueError, lambda: GammaProcess("X", -1, 2))
+    raises(ValueError, lambda: GammaProcess("X", 0, -2))
+    raises(ValueError, lambda: GammaProcess("X", -1, -2))
+
+    # all are independent because of non-overlapping intervals
+    assert P((X(t) > 4) & (X(d) > 3) & (X(x) > 2) & (X(y) > 1), Contains(t,
+        Interval.Lopen(0, 1)) & Contains(d, Interval.Lopen(1, 2)) & Contains(x,
+        Interval.Lopen(2, 3)) & Contains(y, Interval.Lopen(3, 4))).simplify() == \
+                                                            120*exp(-10)
+
+    # Check working with Not and Or
+    assert P(Not((X(t) < 5) & (X(d) > 3)), Contains(t, Interval.Ropen(2, 4)) &
+        Contains(d, Interval.Lopen(7, 8))).simplify() == -4*exp(-3) + 472*exp(-8)/3 + 1
+    assert P((X(t) > 2) | (X(t) < 4), Contains(t, Interval.Ropen(1, 4))).simplify() == \
+                                            -643*exp(-4)/15 + 109*exp(-2)/15 + 1
+
+    assert E(X(t)) == 2*t # E(X(t)) == gamma*t/l
+    assert E(X(2) + x*E(X(5))) == 10*x + 4
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/tests/test_symbolic_multivariate.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/tests/test_symbolic_multivariate.py
new file mode 100644
index 0000000000000000000000000000000000000000..79979e20a6f10d2a2ddfe85ce4c8df145e98c3fd
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/tests/test_symbolic_multivariate.py
@@ -0,0 +1,172 @@
+from sympy.stats import Expectation, Normal, Variance, Covariance
+from sympy.testing.pytest import raises
+from sympy.core.symbol import symbols
+from sympy.matrices.exceptions import ShapeError
+from sympy.matrices.dense import Matrix
+from sympy.matrices.expressions.matexpr import MatrixSymbol
+from sympy.matrices.expressions.special import ZeroMatrix
+from sympy.stats.rv import RandomMatrixSymbol
+from sympy.stats.symbolic_multivariate_probability import (ExpectationMatrix,
+                            VarianceMatrix, CrossCovarianceMatrix)
+
+j, k = symbols("j,k")
+
+A = MatrixSymbol("A", k, k)
+B = MatrixSymbol("B", k, k)
+C = MatrixSymbol("C", k, k)
+D = MatrixSymbol("D", k, k)
+
+a = MatrixSymbol("a", k, 1)
+b = MatrixSymbol("b", k, 1)
+
+A2 = MatrixSymbol("A2", 2, 2)
+B2 = MatrixSymbol("B2", 2, 2)
+
+X = RandomMatrixSymbol("X", k, 1)
+Y = RandomMatrixSymbol("Y", k, 1)
+Z = RandomMatrixSymbol("Z", k, 1)
+W = RandomMatrixSymbol("W", k, 1)
+
+R = RandomMatrixSymbol("R", k, k)
+
+X2 = RandomMatrixSymbol("X2", 2, 1)
+
+normal = Normal("normal", 0, 1)
+
+m1 = Matrix([
+    [1, j*Normal("normal2", 2, 1)],
+    [normal, 0]
+])
+
+def test_multivariate_expectation():
+    expr = Expectation(a)
+    assert expr == Expectation(a) == ExpectationMatrix(a)
+    assert expr.expand() == a
+
+    expr = Expectation(X)
+    assert expr == Expectation(X) == ExpectationMatrix(X)
+    assert expr.shape == (k, 1)
+    assert expr.rows == k
+    assert expr.cols == 1
+    assert isinstance(expr, ExpectationMatrix)
+
+    expr = Expectation(A*X + b)
+    assert expr == ExpectationMatrix(A*X + b)
+    assert expr.expand() == A*ExpectationMatrix(X) + b
+    assert isinstance(expr, ExpectationMatrix)
+    assert expr.shape == (k, 1)
+
+    expr = Expectation(m1*X2)
+    assert expr.expand() == expr
+
+    expr = Expectation(A2*m1*B2*X2)
+    assert expr.args[0].args == (A2, m1, B2, X2)
+    assert expr.expand() == A2*ExpectationMatrix(m1*B2*X2)
+
+    expr = Expectation((X + Y)*(X - Y).T)
+    assert expr.expand() == ExpectationMatrix(X*X.T) - ExpectationMatrix(X*Y.T) +\
+                ExpectationMatrix(Y*X.T) - ExpectationMatrix(Y*Y.T)
+
+    expr = Expectation(A*X + B*Y)
+    assert expr.expand() == A*ExpectationMatrix(X) + B*ExpectationMatrix(Y)
+
+    assert Expectation(m1).doit() == Matrix([[1, 2*j], [0, 0]])
+
+    x1 = Matrix([
+    [Normal('N11', 11, 1), Normal('N12', 12, 1)],
+    [Normal('N21', 21, 1), Normal('N22', 22, 1)]
+    ])
+    x2 = Matrix([
+    [Normal('M11', 1, 1), Normal('M12', 2, 1)],
+    [Normal('M21', 3, 1), Normal('M22', 4, 1)]
+    ])
+
+    assert Expectation(Expectation(x1 + x2)).doit(deep=False) == ExpectationMatrix(x1 + x2)
+    assert Expectation(Expectation(x1 + x2)).doit() == Matrix([[12, 14], [24, 26]])
+
+
+def test_multivariate_variance():
+    raises(ShapeError, lambda: Variance(A))
+
+    expr = Variance(a)
+    assert expr == Variance(a) == VarianceMatrix(a)
+    assert expr.expand() == ZeroMatrix(k, k)
+    expr = Variance(a.T)
+    assert expr == Variance(a.T) == VarianceMatrix(a.T)
+    assert expr.expand() == ZeroMatrix(k, k)
+
+    expr = Variance(X)
+    assert expr == Variance(X) == VarianceMatrix(X)
+    assert expr.shape == (k, k)
+    assert expr.rows == k
+    assert expr.cols == k
+    assert isinstance(expr, VarianceMatrix)
+
+    expr = Variance(A*X)
+    assert expr == VarianceMatrix(A*X)
+    assert expr.expand() == A*VarianceMatrix(X)*A.T
+    assert isinstance(expr, VarianceMatrix)
+    assert expr.shape == (k, k)
+
+    expr = Variance(A*B*X)
+    assert expr.expand() == A*B*VarianceMatrix(X)*B.T*A.T
+
+    expr = Variance(m1*X2)
+    assert expr.expand() == expr
+
+    expr = Variance(A2*m1*B2*X2)
+    assert expr.args[0].args == (A2, m1, B2, X2)
+    assert expr.expand() == expr
+
+    expr = Variance(A*X + B*Y)
+    assert expr.expand() == 2*A*CrossCovarianceMatrix(X, Y)*B.T +\
+                    A*VarianceMatrix(X)*A.T + B*VarianceMatrix(Y)*B.T
+
+def test_multivariate_crosscovariance():
+    raises(ShapeError, lambda: Covariance(X, Y.T))
+    raises(ShapeError, lambda: Covariance(X, A))
+
+
+    expr = Covariance(a.T, b.T)
+    assert expr.shape == (1, 1)
+    assert expr.expand() == ZeroMatrix(1, 1)
+
+    expr = Covariance(a, b)
+    assert expr == Covariance(a, b) == CrossCovarianceMatrix(a, b)
+    assert expr.expand() == ZeroMatrix(k, k)
+    assert expr.shape == (k, k)
+    assert expr.rows == k
+    assert expr.cols == k
+    assert isinstance(expr, CrossCovarianceMatrix)
+
+    expr = Covariance(A*X + a, b)
+    assert expr.expand() == ZeroMatrix(k, k)
+
+    expr = Covariance(X, Y)
+    assert isinstance(expr, CrossCovarianceMatrix)
+    assert expr.expand() == expr
+
+    expr = Covariance(X, X)
+    assert isinstance(expr, CrossCovarianceMatrix)
+    assert expr.expand() == VarianceMatrix(X)
+
+    expr = Covariance(X + Y, Z)
+    assert isinstance(expr, CrossCovarianceMatrix)
+    assert expr.expand() == CrossCovarianceMatrix(X, Z) + CrossCovarianceMatrix(Y, Z)
+
+    expr = Covariance(A*X, Y)
+    assert isinstance(expr, CrossCovarianceMatrix)
+    assert expr.expand() == A*CrossCovarianceMatrix(X, Y)
+
+    expr = Covariance(X, B*Y)
+    assert isinstance(expr, CrossCovarianceMatrix)
+    assert expr.expand() == CrossCovarianceMatrix(X, Y)*B.T
+
+    expr = Covariance(A*X + a, B.T*Y + b)
+    assert isinstance(expr, CrossCovarianceMatrix)
+    assert expr.expand() == A*CrossCovarianceMatrix(X, Y)*B
+
+    expr = Covariance(A*X + B*Y + a, C.T*Z + D.T*W + b)
+    assert isinstance(expr, CrossCovarianceMatrix)
+    assert expr.expand() == A*CrossCovarianceMatrix(X, W)*D + A*CrossCovarianceMatrix(X, Z)*C \
+        + B*CrossCovarianceMatrix(Y, W)*D + B*CrossCovarianceMatrix(Y, Z)*C
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/tests/test_symbolic_probability.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/tests/test_symbolic_probability.py
new file mode 100644
index 0000000000000000000000000000000000000000..edac942ac081c0d44cafd31761b77bc577b6a3fd
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/stats/tests/test_symbolic_probability.py
@@ -0,0 +1,175 @@
+from sympy.concrete.summations import Sum
+from sympy.core.mul import Mul
+from sympy.core.numbers import (oo, pi)
+from sympy.core.relational import Eq
+from sympy.core.symbol import (Dummy, symbols)
+from sympy.functions.elementary.exponential import exp
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import sin
+from sympy.integrals.integrals import Integral
+from sympy.core.expr import unchanged
+from sympy.stats import (Normal, Poisson, variance, Covariance, Variance,
+                         Probability, Expectation, Moment, CentralMoment)
+from sympy.stats.rv import probability, expectation
+
+
+def test_literal_probability():
+    X = Normal('X', 2, 3)
+    Y = Normal('Y', 3, 4)
+    Z = Poisson('Z', 4)
+    W = Poisson('W', 3)
+    x = symbols('x', real=True)
+    y, w, z = symbols('y, w, z')
+
+    assert Probability(X > 0).evaluate_integral() == probability(X > 0)
+    assert Probability(X > x).evaluate_integral() == probability(X > x)
+    assert Probability(X > 0).rewrite(Integral).doit() == probability(X > 0)
+    assert Probability(X > x).rewrite(Integral).doit() == probability(X > x)
+
+    assert Expectation(X).evaluate_integral() == expectation(X)
+    assert Expectation(X).rewrite(Integral).doit() == expectation(X)
+    assert Expectation(X**2).evaluate_integral() == expectation(X**2)
+    assert Expectation(x*X).args == (x*X,)
+    assert Expectation(x*X).expand() == x*Expectation(X)
+    assert Expectation(2*X + 3*Y + z*X*Y).expand() == 2*Expectation(X) + 3*Expectation(Y) + z*Expectation(X*Y)
+    assert Expectation(2*X + 3*Y + z*X*Y).args == (2*X + 3*Y + z*X*Y,)
+    assert Expectation(sin(X)) == Expectation(sin(X)).expand()
+    assert Expectation(2*x*sin(X)*Y + y*X**2 + z*X*Y).expand() == 2*x*Expectation(sin(X)*Y) \
+                            + y*Expectation(X**2) + z*Expectation(X*Y)
+    assert Expectation(X + Y).expand() ==  Expectation(X) + Expectation(Y)
+    assert Expectation((X + Y)*(X - Y)).expand() == Expectation(X**2) - Expectation(Y**2)
+    assert Expectation((X + Y)*(X - Y)).expand().doit() == -12
+    assert Expectation(X + Y, evaluate=True).doit() == 5
+    assert Expectation(X + Expectation(Y)).doit() == 5
+    assert Expectation(X + Expectation(Y)).doit(deep=False) == 2 + Expectation(Expectation(Y))
+    assert Expectation(X + Expectation(Y + Expectation(2*X))).doit(deep=False) == 2 \
+                                + Expectation(Expectation(Y + Expectation(2*X)))
+    assert Expectation(X + Expectation(Y + Expectation(2*X))).doit() == 9
+    assert Expectation(Expectation(2*X)).doit() == 4
+    assert Expectation(Expectation(2*X)).doit(deep=False) == Expectation(2*X)
+    assert Expectation(4*Expectation(2*X)).doit(deep=False) == 4*Expectation(2*X)
+    assert Expectation((X + Y)**3).expand() == 3*Expectation(X*Y**2) +\
+                3*Expectation(X**2*Y) + Expectation(X**3) + Expectation(Y**3)
+    assert Expectation((X - Y)**3).expand() == 3*Expectation(X*Y**2) -\
+                3*Expectation(X**2*Y) + Expectation(X**3) - Expectation(Y**3)
+    assert Expectation((X - Y)**2).expand() == -2*Expectation(X*Y) +\
+                Expectation(X**2) + Expectation(Y**2)
+
+    assert Variance(w).args == (w,)
+    assert Variance(w).expand() == 0
+    assert Variance(X).evaluate_integral() == Variance(X).rewrite(Integral).doit() == variance(X)
+    assert Variance(X + z).args == (X + z,)
+    assert Variance(X + z).expand() == Variance(X)
+    assert Variance(X*Y).args == (Mul(X, Y),)
+    assert type(Variance(X*Y)) == Variance
+    assert Variance(z*X).expand() == z**2*Variance(X)
+    assert Variance(X + Y).expand() == Variance(X) + Variance(Y) + 2*Covariance(X, Y)
+    assert Variance(X + Y + Z + W).expand() == (Variance(X) + Variance(Y) + Variance(Z) + Variance(W) +
+                                       2 * Covariance(X, Y) + 2 * Covariance(X, Z) + 2 * Covariance(X, W) +
+                                       2 * Covariance(Y, Z) + 2 * Covariance(Y, W) + 2 * Covariance(W, Z))
+    assert Variance(X**2).evaluate_integral() == variance(X**2)
+    assert unchanged(Variance, X**2)
+    assert Variance(x*X**2).expand() == x**2*Variance(X**2)
+    assert Variance(sin(X)).args == (sin(X),)
+    assert Variance(sin(X)).expand() == Variance(sin(X))
+    assert Variance(x*sin(X)).expand() == x**2*Variance(sin(X))
+
+    assert Covariance(w, z).args == (w, z)
+    assert Covariance(w, z).expand() == 0
+    assert Covariance(X, w).expand() == 0
+    assert Covariance(w, X).expand() == 0
+    assert Covariance(X, Y).args == (X, Y)
+    assert type(Covariance(X, Y)) == Covariance
+    assert Covariance(z*X + 3, Y).expand() == z*Covariance(X, Y)
+    assert Covariance(X, X).args == (X, X)
+    assert Covariance(X, X).expand() == Variance(X)
+    assert Covariance(z*X + 3, w*Y + 4).expand() == w*z*Covariance(X,Y)
+    assert Covariance(X, Y) == Covariance(Y, X)
+    assert Covariance(X + Y, Z + W).expand() == Covariance(W, X) + Covariance(W, Y) + Covariance(X, Z) + Covariance(Y, Z)
+    assert Covariance(x*X + y*Y, z*Z + w*W).expand() == (x*w*Covariance(W, X) + w*y*Covariance(W, Y) +
+                                                x*z*Covariance(X, Z) + y*z*Covariance(Y, Z))
+    assert Covariance(x*X**2 + y*sin(Y), z*Y*Z**2 + w*W).expand() == (w*x*Covariance(W, X**2) + w*y*Covariance(sin(Y), W) +
+                                                        x*z*Covariance(Y*Z**2, X**2) + y*z*Covariance(Y*Z**2, sin(Y)))
+    assert Covariance(X, X**2).expand() == Covariance(X, X**2)
+    assert Covariance(X, sin(X)).expand() == Covariance(sin(X), X)
+    assert Covariance(X**2, sin(X)*Y).expand() == Covariance(sin(X)*Y, X**2)
+    assert Covariance(w, X).evaluate_integral() == 0
+
+
+def test_probability_rewrite():
+    X = Normal('X', 2, 3)
+    Y = Normal('Y', 3, 4)
+    Z = Poisson('Z', 4)
+    W = Poisson('W', 3)
+    x, y, w, z = symbols('x, y, w, z')
+
+    assert Variance(w).rewrite(Expectation) == 0
+    assert Variance(X).rewrite(Expectation) == Expectation(X ** 2) - Expectation(X) ** 2
+    assert Variance(X, condition=Y).rewrite(Expectation) == Expectation(X ** 2, Y) - Expectation(X, Y) ** 2
+    assert Variance(X, Y) != Expectation(X**2) - Expectation(X)**2
+    assert Variance(X + z).rewrite(Expectation) == Expectation((X + z) ** 2) - Expectation(X + z) ** 2
+    assert Variance(X * Y).rewrite(Expectation) == Expectation(X ** 2 * Y ** 2) - Expectation(X * Y) ** 2
+
+    assert Covariance(w, X).rewrite(Expectation) == -w*Expectation(X) + Expectation(w*X)
+    assert Covariance(X, Y).rewrite(Expectation) == Expectation(X*Y) - Expectation(X)*Expectation(Y)
+    assert Covariance(X, Y, condition=W).rewrite(Expectation) == Expectation(X * Y, W) - Expectation(X, W) * Expectation(Y, W)
+
+    w, x, z = symbols("W, x, z")
+    px = Probability(Eq(X, x))
+    pz = Probability(Eq(Z, z))
+
+    assert Expectation(X).rewrite(Probability) == Integral(x*px, (x, -oo, oo))
+    assert Expectation(Z).rewrite(Probability) == Sum(z*pz, (z, 0, oo))
+    assert Variance(X).rewrite(Probability) == Integral(x**2*px, (x, -oo, oo)) - Integral(x*px, (x, -oo, oo))**2
+    assert Variance(Z).rewrite(Probability) == Sum(z**2*pz, (z, 0, oo)) - Sum(z*pz, (z, 0, oo))**2
+    assert Covariance(w, X).rewrite(Probability) == \
+           -w*Integral(x*Probability(Eq(X, x)), (x, -oo, oo)) + Integral(w*x*Probability(Eq(X, x)), (x, -oo, oo))
+
+    # To test rewrite as sum function
+    assert Variance(X).rewrite(Sum) == Variance(X).rewrite(Integral)
+    assert Expectation(X).rewrite(Sum) == Expectation(X).rewrite(Integral)
+
+    assert Covariance(w, X).rewrite(Sum) == 0
+
+    assert Covariance(w, X).rewrite(Integral) == 0
+
+    assert Variance(X, condition=Y).rewrite(Probability) == Integral(x**2*Probability(Eq(X, x), Y), (x, -oo, oo)) - \
+                                                            Integral(x*Probability(Eq(X, x), Y), (x, -oo, oo))**2
+
+
+def test_symbolic_Moment():
+    mu = symbols('mu', real=True)
+    sigma = symbols('sigma', positive=True)
+    x = symbols('x')
+    X = Normal('X', mu, sigma)
+    M = Moment(X, 4, 2)
+    assert M.rewrite(Expectation) == Expectation((X - 2)**4)
+    assert M.rewrite(Probability) == Integral((x - 2)**4*Probability(Eq(X, x)),
+                                    (x, -oo, oo))
+    k = Dummy('k')
+    expri = Integral(sqrt(2)*(k - 2)**4*exp(-(k - \
+                mu)**2/(2*sigma**2))/(2*sqrt(pi)*sigma), (k, -oo, oo))
+    assert M.rewrite(Integral).dummy_eq(expri)
+    assert M.doit() == (mu**4 - 8*mu**3 + 6*mu**2*sigma**2 + \
+                24*mu**2 - 24*mu*sigma**2 - 32*mu + 3*sigma**4 + 24*sigma**2 + 16)
+    M = Moment(2, 5)
+    assert M.doit() == 2**5
+
+
+def test_symbolic_CentralMoment():
+    mu = symbols('mu', real=True)
+    sigma = symbols('sigma', positive=True)
+    x = symbols('x')
+    X = Normal('X', mu, sigma)
+    CM = CentralMoment(X, 6)
+    assert CM.rewrite(Expectation) == Expectation((X - Expectation(X))**6)
+    assert CM.rewrite(Probability) == Integral((x - Integral(x*Probability(True),
+                    (x, -oo, oo)))**6*Probability(Eq(X, x)), (x, -oo, oo))
+    k = Dummy('k')
+    expri = Integral(sqrt(2)*(k - Integral(sqrt(2)*k*exp(-(k - \
+        mu)**2/(2*sigma**2))/(2*sqrt(pi)*sigma), (k, -oo, oo)))**6*exp(-(k - \
+        mu)**2/(2*sigma**2))/(2*sqrt(pi)*sigma), (k, -oo, oo))
+    assert CM.rewrite(Integral).dummy_eq(expri)
+    assert CM.doit().simplify() == 15*sigma**6
+    CM = Moment(5, 5)
+    assert CM.doit() == 5**5
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/strategies/__pycache__/__init__.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/strategies/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..913a44ae55ba10d1336adfdc433ee2233bf29e46
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/strategies/__pycache__/__init__.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/strategies/__pycache__/core.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/strategies/__pycache__/core.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..80534d4a9e9ab1bc814580c8a8de78617a124db0
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/strategies/__pycache__/core.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/strategies/__pycache__/rl.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/strategies/__pycache__/rl.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..427fa4178110efea5222973cfa0f1f185ea410b9
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/strategies/__pycache__/rl.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/strategies/__pycache__/tools.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/strategies/__pycache__/tools.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c3f7424d9eebf906357575d3475221a35040aff6
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/strategies/__pycache__/tools.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/strategies/__pycache__/traverse.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/strategies/__pycache__/traverse.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..63074295cde17a1c0b040552636235828a03d9e2
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/strategies/__pycache__/traverse.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/strategies/__pycache__/tree.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/strategies/__pycache__/tree.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..293ed5e39f411dd384078aeccacc60b99966cd8f
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/strategies/__pycache__/tree.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/strategies/__pycache__/util.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/strategies/__pycache__/util.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..9ff7ed8c5599aad07ba775e85bf838eb07ad22e8
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/strategies/__pycache__/util.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/strategies/branch/__init__.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/strategies/branch/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..fec5afe84a58f3d887a8c762692a3673a2b6d4c8
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/strategies/branch/__init__.py
@@ -0,0 +1,14 @@
+from . import traverse
+from .core import (
+    condition, debug, multiplex, exhaust, notempty,
+    chain, onaction, sfilter, yieldify, do_one, identity)
+from .tools import canon
+
+__all__ = [
+    'traverse',
+
+    'condition', 'debug', 'multiplex', 'exhaust', 'notempty', 'chain',
+    'onaction', 'sfilter', 'yieldify', 'do_one', 'identity',
+
+    'canon',
+]
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/strategies/branch/__pycache__/__init__.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/strategies/branch/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..491326f17f2613314e7e76f30aeac6270e099f47
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/strategies/branch/__pycache__/__init__.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/strategies/branch/__pycache__/core.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/strategies/branch/__pycache__/core.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..1b0341e3a095ab14b43d61c1fe93990f329e0044
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/strategies/branch/__pycache__/core.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/strategies/branch/__pycache__/tools.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/strategies/branch/__pycache__/tools.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..475596befc8ff5e81bfd8a8e90e7cafb2720755a
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/strategies/branch/__pycache__/tools.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/strategies/branch/__pycache__/traverse.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/strategies/branch/__pycache__/traverse.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..45e4199add23e924187b19cf2f0dc0708e870801
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/strategies/branch/__pycache__/traverse.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/strategies/branch/core.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/strategies/branch/core.py
new file mode 100644
index 0000000000000000000000000000000000000000..2dabaef69b60d994799f71414699223f84e1809b
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/strategies/branch/core.py
@@ -0,0 +1,116 @@
+""" Generic SymPy-Independent Strategies """
+
+
+def identity(x):
+    yield x
+
+
+def exhaust(brule):
+    """ Apply a branching rule repeatedly until it has no effect """
+    def exhaust_brl(expr):
+        seen = {expr}
+        for nexpr in brule(expr):
+            if nexpr not in seen:
+                seen.add(nexpr)
+                yield from exhaust_brl(nexpr)
+        if seen == {expr}:
+            yield expr
+    return exhaust_brl
+
+
+def onaction(brule, fn):
+    def onaction_brl(expr):
+        for result in brule(expr):
+            if result != expr:
+                fn(brule, expr, result)
+            yield result
+    return onaction_brl
+
+
+def debug(brule, file=None):
+    """ Print the input and output expressions at each rule application """
+    if not file:
+        from sys import stdout
+        file = stdout
+
+    def write(brl, expr, result):
+        file.write("Rule: %s\n" % brl.__name__)
+        file.write("In: %s\nOut: %s\n\n" % (expr, result))
+
+    return onaction(brule, write)
+
+
+def multiplex(*brules):
+    """ Multiplex many branching rules into one """
+    def multiplex_brl(expr):
+        seen = set()
+        for brl in brules:
+            for nexpr in brl(expr):
+                if nexpr not in seen:
+                    seen.add(nexpr)
+                    yield nexpr
+    return multiplex_brl
+
+
+def condition(cond, brule):
+    """ Only apply branching rule if condition is true """
+    def conditioned_brl(expr):
+        if cond(expr):
+            yield from brule(expr)
+        else:
+            pass
+    return conditioned_brl
+
+
+def sfilter(pred, brule):
+    """ Yield only those results which satisfy the predicate """
+    def filtered_brl(expr):
+        yield from filter(pred, brule(expr))
+    return filtered_brl
+
+
+def notempty(brule):
+    def notempty_brl(expr):
+        yielded = False
+        for nexpr in brule(expr):
+            yielded = True
+            yield nexpr
+        if not yielded:
+            yield expr
+    return notempty_brl
+
+
+def do_one(*brules):
+    """ Execute one of the branching rules """
+    def do_one_brl(expr):
+        yielded = False
+        for brl in brules:
+            for nexpr in brl(expr):
+                yielded = True
+                yield nexpr
+            if yielded:
+                return
+    return do_one_brl
+
+
+def chain(*brules):
+    """
+    Compose a sequence of brules so that they apply to the expr sequentially
+    """
+    def chain_brl(expr):
+        if not brules:
+            yield expr
+            return
+
+        head, tail = brules[0], brules[1:]
+        for nexpr in head(expr):
+            yield from chain(*tail)(nexpr)
+
+    return chain_brl
+
+
+def yieldify(rl):
+    """ Turn a rule into a branching rule """
+    def brl(expr):
+        yield rl(expr)
+    return brl
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/strategies/branch/tests/__init__.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/strategies/branch/tests/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/strategies/branch/tests/__pycache__/__init__.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/strategies/branch/tests/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f8e9bc42aea124f46c72dc9f00870c6bcc58c720
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/strategies/branch/tests/__pycache__/__init__.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/strategies/branch/tests/__pycache__/test_core.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/strategies/branch/tests/__pycache__/test_core.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..2c3c75a8fd3f9b5fd56b739f1cdd039d28372d97
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/strategies/branch/tests/__pycache__/test_core.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/strategies/branch/tests/__pycache__/test_tools.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/strategies/branch/tests/__pycache__/test_tools.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..94c70ece22dfd3bbced23b2ec2aede14a1c4be1c
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/strategies/branch/tests/__pycache__/test_tools.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/strategies/branch/tests/__pycache__/test_traverse.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/strategies/branch/tests/__pycache__/test_traverse.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..75fe03d02d75e812cc136bcb5c03c317ee16411a
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/strategies/branch/tests/__pycache__/test_traverse.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/strategies/branch/tests/test_core.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/strategies/branch/tests/test_core.py
new file mode 100644
index 0000000000000000000000000000000000000000..ac620b0afb6dbadc4d97b29ddbb341cd920b6588
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/strategies/branch/tests/test_core.py
@@ -0,0 +1,117 @@
+from sympy.strategies.branch.core import (
+    exhaust, debug, multiplex, condition, notempty, chain, onaction, sfilter,
+    yieldify, do_one, identity)
+
+
+def posdec(x):
+    if x > 0:
+        yield x - 1
+    else:
+        yield x
+
+
+def branch5(x):
+    if 0 < x < 5:
+        yield x - 1
+    elif 5 < x < 10:
+        yield x + 1
+    elif x == 5:
+        yield x + 1
+        yield x - 1
+    else:
+        yield x
+
+
+def even(x):
+    return x % 2 == 0
+
+
+def inc(x):
+    yield x + 1
+
+
+def one_to_n(n):
+    yield from range(n)
+
+
+def test_exhaust():
+    brl = exhaust(branch5)
+    assert set(brl(3)) == {0}
+    assert set(brl(7)) == {10}
+    assert set(brl(5)) == {0, 10}
+
+
+def test_debug():
+    from io import StringIO
+    file = StringIO()
+    rl = debug(posdec, file)
+    list(rl(5))
+    log = file.getvalue()
+    file.close()
+
+    assert posdec.__name__ in log
+    assert '5' in log
+    assert '4' in log
+
+
+def test_multiplex():
+    brl = multiplex(posdec, branch5)
+    assert set(brl(3)) == {2}
+    assert set(brl(7)) == {6, 8}
+    assert set(brl(5)) == {4, 6}
+
+
+def test_condition():
+    brl = condition(even, branch5)
+    assert set(brl(4)) == set(branch5(4))
+    assert set(brl(5)) == set()
+
+
+def test_sfilter():
+    brl = sfilter(even, one_to_n)
+    assert set(brl(10)) == {0, 2, 4, 6, 8}
+
+
+def test_notempty():
+    def ident_if_even(x):
+        if even(x):
+            yield x
+
+    brl = notempty(ident_if_even)
+    assert set(brl(4)) == {4}
+    assert set(brl(5)) == {5}
+
+
+def test_chain():
+    assert list(chain()(2)) == [2]  # identity
+    assert list(chain(inc, inc)(2)) == [4]
+    assert list(chain(branch5, inc)(4)) == [4]
+    assert set(chain(branch5, inc)(5)) == {5, 7}
+    assert list(chain(inc, branch5)(5)) == [7]
+
+
+def test_onaction():
+    L = []
+
+    def record(fn, input, output):
+        L.append((input, output))
+
+    list(onaction(inc, record)(2))
+    assert L == [(2, 3)]
+
+    list(onaction(identity, record)(2))
+    assert L == [(2, 3)]
+
+
+def test_yieldify():
+    yinc = yieldify(lambda x: x + 1)
+    assert list(yinc(3)) == [4]
+
+
+def test_do_one():
+    def bad(expr):
+        raise ValueError
+
+    assert list(do_one(inc)(3)) == [4]
+    assert list(do_one(inc, bad)(3)) == [4]
+    assert list(do_one(inc, posdec)(3)) == [4]
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/strategies/branch/tests/test_tools.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/strategies/branch/tests/test_tools.py
new file mode 100644
index 0000000000000000000000000000000000000000..c2bd224030c337f0a000d94f6e7e65f3b8bd118f
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/strategies/branch/tests/test_tools.py
@@ -0,0 +1,42 @@
+from sympy.strategies.branch.tools import canon
+from sympy.core.basic import Basic
+from sympy.core.numbers import Integer
+from sympy.core.singleton import S
+
+
+def posdec(x):
+    if isinstance(x, Integer) and x > 0:
+        yield x - 1
+    else:
+        yield x
+
+
+def branch5(x):
+    if isinstance(x, Integer):
+        if 0 < x < 5:
+            yield x - 1
+        elif 5 < x < 10:
+            yield x + 1
+        elif x == 5:
+            yield x + 1
+            yield x - 1
+        else:
+            yield x
+
+
+def test_zero_ints():
+    expr = Basic(S(2), Basic(S(5), S(3)), S(8))
+    expected = {Basic(S(0), Basic(S(0), S(0)), S(0))}
+
+    brl = canon(posdec)
+    assert set(brl(expr)) == expected
+
+
+def test_split5():
+    expr = Basic(S(2), Basic(S(5), S(3)), S(8))
+    expected = {
+        Basic(S(0), Basic(S(0), S(0)), S(10)),
+        Basic(S(0), Basic(S(10), S(0)), S(10))}
+
+    brl = canon(branch5)
+    assert set(brl(expr)) == expected
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/strategies/branch/tests/test_traverse.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/strategies/branch/tests/test_traverse.py
new file mode 100644
index 0000000000000000000000000000000000000000..e051928210981223004de28b8c617d0438e11ac6
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/strategies/branch/tests/test_traverse.py
@@ -0,0 +1,53 @@
+from sympy.core.basic import Basic
+from sympy.core.numbers import Integer
+from sympy.core.singleton import S
+from sympy.strategies.branch.traverse import top_down, sall
+from sympy.strategies.branch.core import do_one, identity
+
+
+def inc(x):
+    if isinstance(x, Integer):
+        yield x + 1
+
+
+def test_top_down_easy():
+    expr = Basic(S(1), S(2))
+    expected = Basic(S(2), S(3))
+    brl = top_down(inc)
+
+    assert set(brl(expr)) == {expected}
+
+
+def test_top_down_big_tree():
+    expr = Basic(S(1), Basic(S(2)), Basic(S(3), Basic(S(4)), S(5)))
+    expected = Basic(S(2), Basic(S(3)), Basic(S(4), Basic(S(5)), S(6)))
+    brl = top_down(inc)
+
+    assert set(brl(expr)) == {expected}
+
+
+def test_top_down_harder_function():
+    def split5(x):
+        if x == 5:
+            yield x - 1
+            yield x + 1
+
+    expr = Basic(Basic(S(5), S(6)), S(1))
+    expected = {Basic(Basic(S(4), S(6)), S(1)), Basic(Basic(S(6), S(6)), S(1))}
+    brl = top_down(split5)
+
+    assert set(brl(expr)) == expected
+
+
+def test_sall():
+    expr = Basic(S(1), S(2))
+    expected = Basic(S(2), S(3))
+    brl = sall(inc)
+
+    assert list(brl(expr)) == [expected]
+
+    expr = Basic(S(1), S(2), Basic(S(3), S(4)))
+    expected = Basic(S(2), S(3), Basic(S(3), S(4)))
+    brl = sall(do_one(inc, identity))
+
+    assert list(brl(expr)) == [expected]
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/strategies/branch/tools.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/strategies/branch/tools.py
new file mode 100644
index 0000000000000000000000000000000000000000..a6c9097323a7962080ae4497ead976818e386518
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/strategies/branch/tools.py
@@ -0,0 +1,12 @@
+from .core import exhaust, multiplex
+from .traverse import top_down
+
+
+def canon(*rules):
+    """ Strategy for canonicalization
+
+    Apply each branching rule in a top-down fashion through the tree.
+    Multiplex through all branching rule traversals
+    Keep doing this until there is no change.
+    """
+    return exhaust(multiplex(*map(top_down, rules)))
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/strategies/branch/traverse.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/strategies/branch/traverse.py
new file mode 100644
index 0000000000000000000000000000000000000000..28b7098dbda401fc0f0b6d27988d8c37e2f231ae
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/strategies/branch/traverse.py
@@ -0,0 +1,25 @@
+""" Branching Strategies to Traverse a Tree """
+from itertools import product
+from sympy.strategies.util import basic_fns
+from .core import chain, identity, do_one
+
+
+def top_down(brule, fns=basic_fns):
+    """ Apply a rule down a tree running it on the top nodes first """
+    return chain(do_one(brule, identity),
+                 lambda expr: sall(top_down(brule, fns), fns)(expr))
+
+
+def sall(brule, fns=basic_fns):
+    """ Strategic all - apply rule to args """
+    op, new, children, leaf = map(fns.get, ('op', 'new', 'children', 'leaf'))
+
+    def all_rl(expr):
+        if leaf(expr):
+            yield expr
+        else:
+            myop = op(expr)
+            argss = product(*map(brule, children(expr)))
+            for args in argss:
+                yield new(myop, *args)
+    return all_rl
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/strategies/tests/__init__.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/strategies/tests/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/strategies/tests/__pycache__/__init__.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/strategies/tests/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..3e85a81d2e5323c5be046663d2aee0793356dcd0
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/strategies/tests/__pycache__/__init__.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/strategies/tests/__pycache__/test_core.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/strategies/tests/__pycache__/test_core.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..629833204c412c61263a9e1e83c24649b7079b17
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/strategies/tests/__pycache__/test_core.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/strategies/tests/__pycache__/test_rl.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/strategies/tests/__pycache__/test_rl.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..7e7fc0468d10cb0718470174ad04afdc1e73104e
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/strategies/tests/__pycache__/test_rl.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/strategies/tests/__pycache__/test_tools.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/strategies/tests/__pycache__/test_tools.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ba4f7d9262673f729e5c00bb641a81a3eadb471c
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/strategies/tests/__pycache__/test_tools.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/strategies/tests/__pycache__/test_traverse.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/strategies/tests/__pycache__/test_traverse.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f6f8e46a85a671aa173c6340bc42d49c9af4bb52
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/strategies/tests/__pycache__/test_traverse.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/strategies/tests/__pycache__/test_tree.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/strategies/tests/__pycache__/test_tree.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d9e6053eafba1f376073008792c1ca13f727c15a
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/strategies/tests/__pycache__/test_tree.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/strategies/tests/test_core.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/strategies/tests/test_core.py
new file mode 100644
index 0000000000000000000000000000000000000000..1e19bcab1940c476a8996b7ba92e7645a6230034
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/strategies/tests/test_core.py
@@ -0,0 +1,118 @@
+from __future__ import annotations
+from sympy.core.singleton import S
+from sympy.core.basic import Basic
+from sympy.strategies.core import (
+    null_safe, exhaust, memoize, condition,
+    chain, tryit, do_one, debug, switch, minimize)
+from io import StringIO
+
+
+def posdec(x: int) -> int:
+    if x > 0:
+        return x - 1
+    return x
+
+
+def inc(x: int) -> int:
+    return x + 1
+
+
+def dec(x: int) -> int:
+    return x - 1
+
+
+def test_null_safe():
+    def rl(expr: int) -> int | None:
+        if expr == 1:
+            return 2
+        return None
+
+    safe_rl = null_safe(rl)
+    assert rl(1) == safe_rl(1)
+    assert rl(3) is None
+    assert safe_rl(3) == 3
+
+
+def test_exhaust():
+    sink = exhaust(posdec)
+    assert sink(5) == 0
+    assert sink(10) == 0
+
+
+def test_memoize():
+    rl = memoize(posdec)
+    assert rl(5) == posdec(5)
+    assert rl(5) == posdec(5)
+    assert rl(-2) == posdec(-2)
+
+
+def test_condition():
+    rl = condition(lambda x: x % 2 == 0, posdec)
+    assert rl(5) == 5
+    assert rl(4) == 3
+
+
+def test_chain():
+    rl = chain(posdec, posdec)
+    assert rl(5) == 3
+    assert rl(1) == 0
+
+
+def test_tryit():
+    def rl(expr: Basic) -> Basic:
+        assert False
+
+    safe_rl = tryit(rl, AssertionError)
+    assert safe_rl(S(1)) == S(1)
+
+
+def test_do_one():
+    rl = do_one(posdec, posdec)
+    assert rl(5) == 4
+
+    def rl1(x: int) -> int:
+        if x == 1:
+            return 2
+        return x
+
+    def rl2(x: int) -> int:
+        if x == 2:
+            return 3
+        return x
+
+    rule = do_one(rl1, rl2)
+    assert rule(1) == 2
+    assert rule(rule(1)) == 3
+
+
+def test_debug():
+    file = StringIO()
+    rl = debug(posdec, file)
+    rl(5)
+    log = file.getvalue()
+    file.close()
+
+    assert posdec.__name__ in log
+    assert '5' in log
+    assert '4' in log
+
+
+def test_switch():
+    def key(x: int) -> int:
+        return x % 3
+
+    rl = switch(key, {0: inc, 1: dec})
+    assert rl(3) == 4
+    assert rl(4) == 3
+    assert rl(5) == 5
+
+
+def test_minimize():
+    def key(x: int) -> int:
+        return -x
+
+    rl = minimize(inc, dec)
+    assert rl(4) == 3
+
+    rl = minimize(inc, dec, objective=key)
+    assert rl(4) == 5
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/strategies/tests/test_rl.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/strategies/tests/test_rl.py
new file mode 100644
index 0000000000000000000000000000000000000000..8bfa90ad4d970b21396e0e1b6427b5a5c68fe381
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/strategies/tests/test_rl.py
@@ -0,0 +1,78 @@
+from sympy.core.singleton import S
+from sympy.strategies.rl import (
+    rm_id, glom, flatten, unpack, sort, distribute, subs, rebuild)
+from sympy.core.basic import Basic
+from sympy.core.add import Add
+from sympy.core.mul import Mul
+from sympy.core.symbol import symbols
+from sympy.abc import x
+
+
+def test_rm_id():
+    rmzeros = rm_id(lambda x: x == 0)
+    assert rmzeros(Basic(S(0), S(1))) == Basic(S(1))
+    assert rmzeros(Basic(S(0), S(0))) == Basic(S(0))
+    assert rmzeros(Basic(S(2), S(1))) == Basic(S(2), S(1))
+
+
+def test_glom():
+    def key(x):
+        return x.as_coeff_Mul()[1]
+
+    def count(x):
+        return x.as_coeff_Mul()[0]
+
+    def newargs(cnt, arg):
+        return cnt * arg
+
+    rl = glom(key, count, newargs)
+
+    result = rl(Add(x, -x, 3 * x, 2, 3, evaluate=False))
+    expected = Add(3 * x, 5)
+    assert set(result.args) == set(expected.args)
+
+
+def test_flatten():
+    assert flatten(Basic(S(1), S(2), Basic(S(3), S(4)))) == \
+        Basic(S(1), S(2), S(3), S(4))
+
+
+def test_unpack():
+    assert unpack(Basic(S(2))) == 2
+    assert unpack(Basic(S(2), S(3))) == Basic(S(2), S(3))
+
+
+def test_sort():
+    assert sort(str)(Basic(S(3), S(1), S(2))) == Basic(S(1), S(2), S(3))
+
+
+def test_distribute():
+    class T1(Basic):
+        pass
+
+    class T2(Basic):
+        pass
+
+    distribute_t12 = distribute(T1, T2)
+    assert distribute_t12(T1(S(1), S(2), T2(S(3), S(4)), S(5))) == \
+        T2(T1(S(1), S(2), S(3), S(5)), T1(S(1), S(2), S(4), S(5)))
+    assert distribute_t12(T1(S(1), S(2), S(3))) == T1(S(1), S(2), S(3))
+
+
+def test_distribute_add_mul():
+    x, y = symbols('x, y')
+    expr = Mul(2, Add(x, y), evaluate=False)
+    expected = Add(Mul(2, x), Mul(2, y))
+    distribute_mul = distribute(Mul, Add)
+    assert distribute_mul(expr) == expected
+
+
+def test_subs():
+    rl = subs(1, 2)
+    assert rl(1) == 2
+    assert rl(3) == 3
+
+
+def test_rebuild():
+    expr = Basic.__new__(Add, S(1), S(2))
+    assert rebuild(expr) == 3
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/strategies/tests/test_tools.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/strategies/tests/test_tools.py
new file mode 100644
index 0000000000000000000000000000000000000000..89774aeb92ead5781966e4f48ad32dc63e1bf7e2
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/strategies/tests/test_tools.py
@@ -0,0 +1,32 @@
+from sympy.strategies.tools import subs, typed
+from sympy.strategies.rl import rm_id
+from sympy.core.basic import Basic
+from sympy.core.singleton import S
+
+
+def test_subs():
+    from sympy.core.symbol import symbols
+    a, b, c, d, e, f = symbols('a,b,c,d,e,f')
+    mapping = {a: d, d: a, Basic(e): Basic(f)}
+    expr = Basic(a, Basic(b, c), Basic(d, Basic(e)))
+    result = Basic(d, Basic(b, c), Basic(a, Basic(f)))
+    assert subs(mapping)(expr) == result
+
+
+def test_subs_empty():
+    assert subs({})(Basic(S(1), S(2))) == Basic(S(1), S(2))
+
+
+def test_typed():
+    class A(Basic):
+        pass
+
+    class B(Basic):
+        pass
+
+    rmzeros = rm_id(lambda x: x == S(0))
+    rmones = rm_id(lambda x: x == S(1))
+    remove_something = typed({A: rmzeros, B: rmones})
+
+    assert remove_something(A(S(0), S(1))) == A(S(1))
+    assert remove_something(B(S(0), S(1))) == B(S(0))
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/strategies/tests/test_traverse.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/strategies/tests/test_traverse.py
new file mode 100644
index 0000000000000000000000000000000000000000..ee2409616a8b4f750af8baea149b2ea52c56be9d
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/strategies/tests/test_traverse.py
@@ -0,0 +1,84 @@
+from sympy.strategies.traverse import (
+    top_down, bottom_up, sall, top_down_once, bottom_up_once, basic_fns)
+from sympy.strategies.rl import rebuild
+from sympy.strategies.util import expr_fns
+from sympy.core.add import Add
+from sympy.core.basic import Basic
+from sympy.core.numbers import Integer
+from sympy.core.singleton import S
+from sympy.core.symbol import Str, Symbol
+from sympy.abc import x, y, z
+
+
+def zero_symbols(expression):
+    return S.Zero if isinstance(expression, Symbol) else expression
+
+
+def test_sall():
+    zero_onelevel = sall(zero_symbols)
+
+    assert zero_onelevel(Basic(x, y, Basic(x, z))) == \
+        Basic(S(0), S(0), Basic(x, z))
+
+
+def test_bottom_up():
+    _test_global_traversal(bottom_up)
+    _test_stop_on_non_basics(bottom_up)
+
+
+def test_top_down():
+    _test_global_traversal(top_down)
+    _test_stop_on_non_basics(top_down)
+
+
+def _test_global_traversal(trav):
+    zero_all_symbols = trav(zero_symbols)
+
+    assert zero_all_symbols(Basic(x, y, Basic(x, z))) == \
+        Basic(S(0), S(0), Basic(S(0), S(0)))
+
+
+def _test_stop_on_non_basics(trav):
+    def add_one_if_can(expr):
+        try:
+            return expr + 1
+        except TypeError:
+            return expr
+
+    expr = Basic(S(1), Str('a'), Basic(S(2), Str('b')))
+    expected = Basic(S(2), Str('a'), Basic(S(3), Str('b')))
+    rl = trav(add_one_if_can)
+
+    assert rl(expr) == expected
+
+
+class Basic2(Basic):
+    pass
+
+
+def rl(x):
+    if x.args and not isinstance(x.args[0], Integer):
+        return Basic2(*x.args)
+    return x
+
+
+def test_top_down_once():
+    top_rl = top_down_once(rl)
+
+    assert top_rl(Basic(S(1.0), S(2.0), Basic(S(3), S(4)))) == \
+        Basic2(S(1.0), S(2.0), Basic(S(3), S(4)))
+
+
+def test_bottom_up_once():
+    bottom_rl = bottom_up_once(rl)
+
+    assert bottom_rl(Basic(S(1), S(2), Basic(S(3.0), S(4.0)))) == \
+        Basic(S(1), S(2), Basic2(S(3.0), S(4.0)))
+
+
+def test_expr_fns():
+    expr = x + y**3
+    e = bottom_up(lambda v: v + 1, expr_fns)(expr)
+    b = bottom_up(lambda v: Basic.__new__(Add, v, S(1)), basic_fns)(expr)
+
+    assert rebuild(b) == e
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/strategies/tests/test_tree.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/strategies/tests/test_tree.py
new file mode 100644
index 0000000000000000000000000000000000000000..d5cdde747fe3ab90c8fd181701194403bc526067
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/strategies/tests/test_tree.py
@@ -0,0 +1,92 @@
+from sympy.strategies.tree import treeapply, greedy, allresults, brute
+from functools import partial, reduce
+
+
+def inc(x):
+    return x + 1
+
+
+def dec(x):
+    return x - 1
+
+
+def double(x):
+    return 2 * x
+
+
+def square(x):
+    return x**2
+
+
+def add(*args):
+    return sum(args)
+
+
+def mul(*args):
+    return reduce(lambda a, b: a * b, args, 1)
+
+
+def test_treeapply():
+    tree = ([3, 3], [4, 1], 2)
+    assert treeapply(tree, {list: min, tuple: max}) == 3
+    assert treeapply(tree, {list: add, tuple: mul}) == 60
+
+
+def test_treeapply_leaf():
+    assert treeapply(3, {}, leaf=lambda x: x**2) == 9
+    tree = ([3, 3], [4, 1], 2)
+    treep1 = ([4, 4], [5, 2], 3)
+    assert treeapply(tree, {list: min, tuple: max}, leaf=lambda x: x + 1) == \
+           treeapply(treep1, {list: min, tuple: max})
+
+
+def test_treeapply_strategies():
+    from sympy.strategies import chain, minimize
+    join = {list: chain, tuple: minimize}
+
+    assert treeapply(inc, join) == inc
+    assert treeapply((inc, dec), join)(5) == minimize(inc, dec)(5)
+    assert treeapply([inc, dec], join)(5) == chain(inc, dec)(5)
+    tree = (inc, [dec, double])  # either inc or dec-then-double
+    assert treeapply(tree, join)(5) == 6
+    assert treeapply(tree, join)(1) == 0
+
+    maximize = partial(minimize, objective=lambda x: -x)
+    join = {list: chain, tuple: maximize}
+    fn = treeapply(tree, join)
+    assert fn(4) == 6  # highest value comes from the dec then double
+    assert fn(1) == 2  # highest value comes from the inc
+
+
+def test_greedy():
+    tree = [inc, (dec, double)]  # either inc or dec-then-double
+
+    fn = greedy(tree, objective=lambda x: -x)
+    assert fn(4) == 6  # highest value comes from the dec then double
+    assert fn(1) == 2  # highest value comes from the inc
+
+    tree = [inc, dec, [inc, dec, [(inc, inc), (dec, dec)]]]
+    lowest = greedy(tree)
+    assert lowest(10) == 8
+
+    highest = greedy(tree, objective=lambda x: -x)
+    assert highest(10) == 12
+
+
+def test_allresults():
+    # square = lambda x: x**2
+
+    assert set(allresults(inc)(3)) == {inc(3)}
+    assert set(allresults([inc, dec])(3)) == {2, 4}
+    assert set(allresults((inc, dec))(3)) == {3}
+    assert set(allresults([inc, (dec, double)])(4)) == {5, 6}
+
+
+def test_brute():
+    tree = ([inc, dec], square)
+    fn = brute(tree, lambda x: -x)
+
+    assert fn(2) == (2 + 1)**2
+    assert fn(-2) == (-2 - 1)**2
+
+    assert brute(inc)(1) == 2
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/__pycache__/__init__.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..dc3d141d6fc461233288e63af74c1e149a13ffbb
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/__pycache__/__init__.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/__pycache__/functions.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/__pycache__/functions.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..64455982f226909d8163da1cf9f5e6aa355b08b6
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/__pycache__/functions.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/__pycache__/index_methods.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/__pycache__/index_methods.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..2f4f610dd839c29aa7a8c514ad59b7823aae6da0
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/__pycache__/index_methods.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/__pycache__/indexed.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/__pycache__/indexed.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..68f8dd31277e5b68f705225a008f9cde09997b01
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/__pycache__/indexed.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/__pycache__/tensor.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/__pycache__/tensor.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..79273f62ad0715191510f1a89633189d43e5864f
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/__pycache__/tensor.cpython-312.pyc
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e80c6e4b58a7fbc423bde0faefae616221d7c5a8a7253772cf8e3eda6a600514
+size 228642
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/__pycache__/toperators.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/__pycache__/toperators.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..1451696d458d828dd88a41a9f01b4feac89429ed
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/__pycache__/toperators.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/__init__.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..eca2eb4c6c58cb113517b6e41737e9d97abbb84e
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/__init__.py
@@ -0,0 +1,271 @@
+r"""
+N-dim array module for SymPy.
+
+Four classes are provided to handle N-dim arrays, given by the combinations
+dense/sparse (i.e. whether to store all elements or only the non-zero ones in
+memory) and mutable/immutable (immutable classes are SymPy objects, but cannot
+change after they have been created).
+
+Examples
+========
+
+The following examples show the usage of ``Array``. This is an abbreviation for
+``ImmutableDenseNDimArray``, that is an immutable and dense N-dim array, the
+other classes are analogous. For mutable classes it is also possible to change
+element values after the object has been constructed.
+
+Array construction can detect the shape of nested lists and tuples:
+
+>>> from sympy import Array
+>>> a1 = Array([[1, 2], [3, 4], [5, 6]])
+>>> a1
+[[1, 2], [3, 4], [5, 6]]
+>>> a1.shape
+(3, 2)
+>>> a1.rank()
+2
+>>> from sympy.abc import x, y, z
+>>> a2 = Array([[[x, y], [z, x*z]], [[1, x*y], [1/x, x/y]]])
+>>> a2
+[[[x, y], [z, x*z]], [[1, x*y], [1/x, x/y]]]
+>>> a2.shape
+(2, 2, 2)
+>>> a2.rank()
+3
+
+Otherwise one could pass a 1-dim array followed by a shape tuple:
+
+>>> m1 = Array(range(12), (3, 4))
+>>> m1
+[[0, 1, 2, 3], [4, 5, 6, 7], [8, 9, 10, 11]]
+>>> m2 = Array(range(12), (3, 2, 2))
+>>> m2
+[[[0, 1], [2, 3]], [[4, 5], [6, 7]], [[8, 9], [10, 11]]]
+>>> m2[1,1,1]
+7
+>>> m2.reshape(4, 3)
+[[0, 1, 2], [3, 4, 5], [6, 7, 8], [9, 10, 11]]
+
+Slice support:
+
+>>> m2[:, 1, 1]
+[3, 7, 11]
+
+Elementwise derivative:
+
+>>> from sympy.abc import x, y, z
+>>> m3 = Array([x**3, x*y, z])
+>>> m3.diff(x)
+[3*x**2, y, 0]
+>>> m3.diff(z)
+[0, 0, 1]
+
+Multiplication with other SymPy expressions is applied elementwisely:
+
+>>> (1+x)*m3
+[x**3*(x + 1), x*y*(x + 1), z*(x + 1)]
+
+To apply a function to each element of the N-dim array, use ``applyfunc``:
+
+>>> m3.applyfunc(lambda x: x/2)
+[x**3/2, x*y/2, z/2]
+
+N-dim arrays can be converted to nested lists by the ``tolist()`` method:
+
+>>> m2.tolist()
+[[[0, 1], [2, 3]], [[4, 5], [6, 7]], [[8, 9], [10, 11]]]
+>>> isinstance(m2.tolist(), list)
+True
+
+If the rank is 2, it is possible to convert them to matrices with ``tomatrix()``:
+
+>>> m1.tomatrix()
+Matrix([
+[0, 1,  2,  3],
+[4, 5,  6,  7],
+[8, 9, 10, 11]])
+
+Products and contractions
+-------------------------
+
+Tensor product between arrays `A_{i_1,\ldots,i_n}` and `B_{j_1,\ldots,j_m}`
+creates the combined array `P = A \otimes B` defined as
+
+`P_{i_1,\ldots,i_n,j_1,\ldots,j_m} := A_{i_1,\ldots,i_n}\cdot B_{j_1,\ldots,j_m}.`
+
+It is available through ``tensorproduct(...)``:
+
+>>> from sympy import Array, tensorproduct
+>>> from sympy.abc import x,y,z,t
+>>> A = Array([x, y, z, t])
+>>> B = Array([1, 2, 3, 4])
+>>> tensorproduct(A, B)
+[[x, 2*x, 3*x, 4*x], [y, 2*y, 3*y, 4*y], [z, 2*z, 3*z, 4*z], [t, 2*t, 3*t, 4*t]]
+
+In case you don't want to evaluate the tensor product immediately, you can use
+``ArrayTensorProduct``, which creates an unevaluated tensor product expression:
+
+>>> from sympy.tensor.array.expressions import ArrayTensorProduct
+>>> ArrayTensorProduct(A, B)
+ArrayTensorProduct([x, y, z, t], [1, 2, 3, 4])
+
+Calling ``.as_explicit()`` on ``ArrayTensorProduct`` is equivalent to just calling
+``tensorproduct(...)``:
+
+>>> ArrayTensorProduct(A, B).as_explicit()
+[[x, 2*x, 3*x, 4*x], [y, 2*y, 3*y, 4*y], [z, 2*z, 3*z, 4*z], [t, 2*t, 3*t, 4*t]]
+
+Tensor product between a rank-1 array and a matrix creates a rank-3 array:
+
+>>> from sympy import eye
+>>> p1 = tensorproduct(A, eye(4))
+>>> p1
+[[[x, 0, 0, 0], [0, x, 0, 0], [0, 0, x, 0], [0, 0, 0, x]], [[y, 0, 0, 0], [0, y, 0, 0], [0, 0, y, 0], [0, 0, 0, y]], [[z, 0, 0, 0], [0, z, 0, 0], [0, 0, z, 0], [0, 0, 0, z]], [[t, 0, 0, 0], [0, t, 0, 0], [0, 0, t, 0], [0, 0, 0, t]]]
+
+Now, to get back `A_0 \otimes \mathbf{1}` one can access `p_{0,m,n}` by slicing:
+
+>>> p1[0,:,:]
+[[x, 0, 0, 0], [0, x, 0, 0], [0, 0, x, 0], [0, 0, 0, x]]
+
+Tensor contraction sums over the specified axes, for example contracting
+positions `a` and `b` means
+
+`A_{i_1,\ldots,i_a,\ldots,i_b,\ldots,i_n} \implies \sum_k A_{i_1,\ldots,k,\ldots,k,\ldots,i_n}`
+
+Remember that Python indexing is zero starting, to contract the a-th and b-th
+axes it is therefore necessary to specify `a-1` and `b-1`
+
+>>> from sympy import tensorcontraction
+>>> C = Array([[x, y], [z, t]])
+
+The matrix trace is equivalent to the contraction of a rank-2 array:
+
+`A_{m,n} \implies \sum_k A_{k,k}`
+
+>>> tensorcontraction(C, (0, 1))
+t + x
+
+To create an expression representing a tensor contraction that does not get
+evaluated immediately, use ``ArrayContraction``, which is equivalent to
+``tensorcontraction(...)`` if it is followed by ``.as_explicit()``:
+
+>>> from sympy.tensor.array.expressions import ArrayContraction
+>>> ArrayContraction(C, (0, 1))
+ArrayContraction([[x, y], [z, t]], (0, 1))
+>>> ArrayContraction(C, (0, 1)).as_explicit()
+t + x
+
+Matrix product is equivalent to a tensor product of two rank-2 arrays, followed
+by a contraction of the 2nd and 3rd axes (in Python indexing axes number 1, 2).
+
+`A_{m,n}\cdot B_{i,j} \implies \sum_k A_{m, k}\cdot B_{k, j}`
+
+>>> D = Array([[2, 1], [0, -1]])
+>>> tensorcontraction(tensorproduct(C, D), (1, 2))
+[[2*x, x - y], [2*z, -t + z]]
+
+One may verify that the matrix product is equivalent:
+
+>>> from sympy import Matrix
+>>> Matrix([[x, y], [z, t]])*Matrix([[2, 1], [0, -1]])
+Matrix([
+[2*x,  x - y],
+[2*z, -t + z]])
+
+or equivalently
+
+>>> C.tomatrix()*D.tomatrix()
+Matrix([
+[2*x,  x - y],
+[2*z, -t + z]])
+
+Diagonal operator
+-----------------
+
+The ``tensordiagonal`` function acts in a similar manner as ``tensorcontraction``,
+but the joined indices are not summed over, for example diagonalizing
+positions `a` and `b` means
+
+`A_{i_1,\ldots,i_a,\ldots,i_b,\ldots,i_n} \implies A_{i_1,\ldots,k,\ldots,k,\ldots,i_n}
+\implies \tilde{A}_{i_1,\ldots,i_{a-1},i_{a+1},\ldots,i_{b-1},i_{b+1},\ldots,i_n,k}`
+
+where `\tilde{A}` is the array equivalent to the diagonal of `A` at positions
+`a` and `b` moved to the last index slot.
+
+Compare the difference between contraction and diagonal operators:
+
+>>> from sympy import tensordiagonal
+>>> from sympy.abc import a, b, c, d
+>>> m = Matrix([[a, b], [c, d]])
+>>> tensorcontraction(m, [0, 1])
+a + d
+>>> tensordiagonal(m, [0, 1])
+[a, d]
+
+In short, no summation occurs with ``tensordiagonal``.
+
+
+Derivatives by array
+--------------------
+
+The usual derivative operation may be extended to support derivation with
+respect to arrays, provided that all elements in the that array are symbols or
+expressions suitable for derivations.
+
+The definition of a derivative by an array is as follows: given the array
+`A_{i_1, \ldots, i_N}` and the array `X_{j_1, \ldots, j_M}`
+the derivative of arrays will return a new array `B` defined by
+
+`B_{j_1,\ldots,j_M,i_1,\ldots,i_N} := \frac{\partial A_{i_1,\ldots,i_N}}{\partial X_{j_1,\ldots,j_M}}`
+
+The function ``derive_by_array`` performs such an operation:
+
+>>> from sympy import derive_by_array
+>>> from sympy.abc import x, y, z, t
+>>> from sympy import sin, exp
+
+With scalars, it behaves exactly as the ordinary derivative:
+
+>>> derive_by_array(sin(x*y), x)
+y*cos(x*y)
+
+Scalar derived by an array basis:
+
+>>> derive_by_array(sin(x*y), [x, y, z])
+[y*cos(x*y), x*cos(x*y), 0]
+
+Deriving array by an array basis: `B^{nm} := \frac{\partial A^m}{\partial x^n}`
+
+>>> basis = [x, y, z]
+>>> ax = derive_by_array([exp(x), sin(y*z), t], basis)
+>>> ax
+[[exp(x), 0, 0], [0, z*cos(y*z), 0], [0, y*cos(y*z), 0]]
+
+Contraction of the resulting array: `\sum_m \frac{\partial A^m}{\partial x^m}`
+
+>>> tensorcontraction(ax, (0, 1))
+z*cos(y*z) + exp(x)
+
+"""
+
+from .dense_ndim_array import MutableDenseNDimArray, ImmutableDenseNDimArray, DenseNDimArray
+from .sparse_ndim_array import MutableSparseNDimArray, ImmutableSparseNDimArray, SparseNDimArray
+from .ndim_array import NDimArray, ArrayKind
+from .arrayop import tensorproduct, tensorcontraction, tensordiagonal, derive_by_array, permutedims
+from .array_comprehension import ArrayComprehension, ArrayComprehensionMap
+
+Array = ImmutableDenseNDimArray
+
+__all__ = [
+    'MutableDenseNDimArray', 'ImmutableDenseNDimArray', 'DenseNDimArray',
+
+    'MutableSparseNDimArray', 'ImmutableSparseNDimArray', 'SparseNDimArray',
+
+    'NDimArray', 'ArrayKind',
+
+    'tensorproduct', 'tensorcontraction', 'tensordiagonal', 'derive_by_array',
+
+    'permutedims', 'ArrayComprehension', 'ArrayComprehensionMap',
+
+    'Array',
+]
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/__pycache__/__init__.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..1b12add9c3016d71cf87b82d3e9a602c49e2ddea
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/__pycache__/__init__.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/__pycache__/array_comprehension.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/__pycache__/array_comprehension.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d824b345aa9664c21f898c8b43affcb1b4c52f80
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/__pycache__/array_comprehension.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/__pycache__/array_derivatives.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/__pycache__/array_derivatives.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..1c514427efaf317affc83062288547a45c03b6bd
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/__pycache__/array_derivatives.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/__pycache__/arrayop.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/__pycache__/arrayop.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5ffe73625a91e6c387ae00cbe8ba47d4f33a9646
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/__pycache__/arrayop.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/__pycache__/dense_ndim_array.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/__pycache__/dense_ndim_array.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..2cfc627a8580bd2b377d1986eaaddf66f432b0d0
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/__pycache__/dense_ndim_array.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/__pycache__/mutable_ndim_array.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/__pycache__/mutable_ndim_array.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..48c556d596fb25d58d310c3cb6b368b4e7a8f95b
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/__pycache__/mutable_ndim_array.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/__pycache__/ndim_array.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/__pycache__/ndim_array.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..003350ed5dfe0e2f5ba60ebb3aa6bb278cc88d98
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/__pycache__/ndim_array.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/__pycache__/sparse_ndim_array.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/__pycache__/sparse_ndim_array.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..2dfd9758720f2014146a3a8e83fcab8a4f4b9745
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/__pycache__/sparse_ndim_array.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/array_comprehension.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/array_comprehension.py
new file mode 100644
index 0000000000000000000000000000000000000000..95702f499f3e40597fd0144929138ac1329962ee
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/array_comprehension.py
@@ -0,0 +1,399 @@
+import functools, itertools
+from sympy.core.sympify import _sympify, sympify
+from sympy.core.expr import Expr
+from sympy.core import Basic, Tuple
+from sympy.tensor.array import ImmutableDenseNDimArray
+from sympy.core.symbol import Symbol
+from sympy.core.numbers import Integer
+
+
+class ArrayComprehension(Basic):
+    """
+    Generate a list comprehension.
+
+    Explanation
+    ===========
+
+    If there is a symbolic dimension, for example, say [i for i in range(1, N)] where
+    N is a Symbol, then the expression will not be expanded to an array. Otherwise,
+    calling the doit() function will launch the expansion.
+
+    Examples
+    ========
+
+    >>> from sympy.tensor.array import ArrayComprehension
+    >>> from sympy import symbols
+    >>> i, j, k = symbols('i j k')
+    >>> a = ArrayComprehension(10*i + j, (i, 1, 4), (j, 1, 3))
+    >>> a
+    ArrayComprehension(10*i + j, (i, 1, 4), (j, 1, 3))
+    >>> a.doit()
+    [[11, 12, 13], [21, 22, 23], [31, 32, 33], [41, 42, 43]]
+    >>> b = ArrayComprehension(10*i + j, (i, 1, 4), (j, 1, k))
+    >>> b.doit()
+    ArrayComprehension(10*i + j, (i, 1, 4), (j, 1, k))
+    """
+    def __new__(cls, function, *symbols, **assumptions):
+        if any(len(l) != 3 or None for l in symbols):
+            raise ValueError('ArrayComprehension requires values lower and upper bound'
+                              ' for the expression')
+        arglist = [sympify(function)]
+        arglist.extend(cls._check_limits_validity(function, symbols))
+        obj = Basic.__new__(cls, *arglist, **assumptions)
+        obj._limits = obj._args[1:]
+        obj._shape = cls._calculate_shape_from_limits(obj._limits)
+        obj._rank = len(obj._shape)
+        obj._loop_size = cls._calculate_loop_size(obj._shape)
+        return obj
+
+    @property
+    def function(self):
+        """The function applied across limits.
+
+        Examples
+        ========
+
+        >>> from sympy.tensor.array import ArrayComprehension
+        >>> from sympy import symbols
+        >>> i, j = symbols('i j')
+        >>> a = ArrayComprehension(10*i + j, (i, 1, 4), (j, 1, 3))
+        >>> a.function
+        10*i + j
+        """
+        return self._args[0]
+
+    @property
+    def limits(self):
+        """
+        The list of limits that will be applied while expanding the array.
+
+        Examples
+        ========
+
+        >>> from sympy.tensor.array import ArrayComprehension
+        >>> from sympy import symbols
+        >>> i, j = symbols('i j')
+        >>> a = ArrayComprehension(10*i + j, (i, 1, 4), (j, 1, 3))
+        >>> a.limits
+        ((i, 1, 4), (j, 1, 3))
+        """
+        return self._limits
+
+    @property
+    def free_symbols(self):
+        """
+        The set of the free_symbols in the array.
+        Variables appeared in the bounds are supposed to be excluded
+        from the free symbol set.
+
+        Examples
+        ========
+
+        >>> from sympy.tensor.array import ArrayComprehension
+        >>> from sympy import symbols
+        >>> i, j, k = symbols('i j k')
+        >>> a = ArrayComprehension(10*i + j, (i, 1, 4), (j, 1, 3))
+        >>> a.free_symbols
+        set()
+        >>> b = ArrayComprehension(10*i + j, (i, 1, 4), (j, 1, k+3))
+        >>> b.free_symbols
+        {k}
+        """
+        expr_free_sym = self.function.free_symbols
+        for var, inf, sup in self._limits:
+            expr_free_sym.discard(var)
+            curr_free_syms = inf.free_symbols.union(sup.free_symbols)
+            expr_free_sym = expr_free_sym.union(curr_free_syms)
+        return expr_free_sym
+
+    @property
+    def variables(self):
+        """The tuples of the variables in the limits.
+
+        Examples
+        ========
+
+        >>> from sympy.tensor.array import ArrayComprehension
+        >>> from sympy import symbols
+        >>> i, j, k = symbols('i j k')
+        >>> a = ArrayComprehension(10*i + j, (i, 1, 4), (j, 1, 3))
+        >>> a.variables
+        [i, j]
+        """
+        return [l[0] for l in self._limits]
+
+    @property
+    def bound_symbols(self):
+        """The list of dummy variables.
+
+        Note
+        ====
+
+        Note that all variables are dummy variables since a limit without
+        lower bound or upper bound is not accepted.
+        """
+        return [l[0] for l in self._limits if len(l) != 1]
+
+    @property
+    def shape(self):
+        """
+        The shape of the expanded array, which may have symbols.
+
+        Note
+        ====
+
+        Both the lower and the upper bounds are included while
+        calculating the shape.
+
+        Examples
+        ========
+
+        >>> from sympy.tensor.array import ArrayComprehension
+        >>> from sympy import symbols
+        >>> i, j, k = symbols('i j k')
+        >>> a = ArrayComprehension(10*i + j, (i, 1, 4), (j, 1, 3))
+        >>> a.shape
+        (4, 3)
+        >>> b = ArrayComprehension(10*i + j, (i, 1, 4), (j, 1, k+3))
+        >>> b.shape
+        (4, k + 3)
+        """
+        return self._shape
+
+    @property
+    def is_shape_numeric(self):
+        """
+        Test if the array is shape-numeric which means there is no symbolic
+        dimension.
+
+        Examples
+        ========
+
+        >>> from sympy.tensor.array import ArrayComprehension
+        >>> from sympy import symbols
+        >>> i, j, k = symbols('i j k')
+        >>> a = ArrayComprehension(10*i + j, (i, 1, 4), (j, 1, 3))
+        >>> a.is_shape_numeric
+        True
+        >>> b = ArrayComprehension(10*i + j, (i, 1, 4), (j, 1, k+3))
+        >>> b.is_shape_numeric
+        False
+        """
+        for _, inf, sup in self._limits:
+            if Basic(inf, sup).atoms(Symbol):
+                return False
+        return True
+
+    def rank(self):
+        """The rank of the expanded array.
+
+        Examples
+        ========
+
+        >>> from sympy.tensor.array import ArrayComprehension
+        >>> from sympy import symbols
+        >>> i, j, k = symbols('i j k')
+        >>> a = ArrayComprehension(10*i + j, (i, 1, 4), (j, 1, 3))
+        >>> a.rank()
+        2
+        """
+        return self._rank
+
+    def __len__(self):
+        """
+        The length of the expanded array which means the number
+        of elements in the array.
+
+        Raises
+        ======
+
+        ValueError : When the length of the array is symbolic
+
+        Examples
+        ========
+
+        >>> from sympy.tensor.array import ArrayComprehension
+        >>> from sympy import symbols
+        >>> i, j = symbols('i j')
+        >>> a = ArrayComprehension(10*i + j, (i, 1, 4), (j, 1, 3))
+        >>> len(a)
+        12
+        """
+        if self._loop_size.free_symbols:
+            raise ValueError('Symbolic length is not supported')
+        return self._loop_size
+
+    @classmethod
+    def _check_limits_validity(cls, function, limits):
+        #limits = sympify(limits)
+        new_limits = []
+        for var, inf, sup in limits:
+            var = _sympify(var)
+            inf = _sympify(inf)
+            #since this is stored as an argument, it should be
+            #a Tuple
+            if isinstance(sup, list):
+                sup = Tuple(*sup)
+            else:
+                sup = _sympify(sup)
+            new_limits.append(Tuple(var, inf, sup))
+            if any((not isinstance(i, Expr)) or i.atoms(Symbol, Integer) != i.atoms()
+                                                                for i in [inf, sup]):
+                raise TypeError('Bounds should be an Expression(combination of Integer and Symbol)')
+            if (inf > sup) == True:
+                raise ValueError('Lower bound should be inferior to upper bound')
+            if var in inf.free_symbols or var in sup.free_symbols:
+                raise ValueError('Variable should not be part of its bounds')
+        return new_limits
+
+    @classmethod
+    def _calculate_shape_from_limits(cls, limits):
+        return tuple([sup - inf + 1 for _, inf, sup in limits])
+
+    @classmethod
+    def _calculate_loop_size(cls, shape):
+        if not shape:
+            return 0
+        loop_size = 1
+        for l in shape:
+            loop_size = loop_size * l
+
+        return loop_size
+
+    def doit(self, **hints):
+        if not self.is_shape_numeric:
+            return self
+
+        return self._expand_array()
+
+    def _expand_array(self):
+        res = []
+        for values in itertools.product(*[range(inf, sup+1)
+                                        for var, inf, sup
+                                        in self._limits]):
+            res.append(self._get_element(values))
+
+        return ImmutableDenseNDimArray(res, self.shape)
+
+    def _get_element(self, values):
+        temp = self.function
+        for var, val in zip(self.variables, values):
+            temp = temp.subs(var, val)
+        return temp
+
+    def tolist(self):
+        """Transform the expanded array to a list.
+
+        Raises
+        ======
+
+        ValueError : When there is a symbolic dimension
+
+        Examples
+        ========
+
+        >>> from sympy.tensor.array import ArrayComprehension
+        >>> from sympy import symbols
+        >>> i, j = symbols('i j')
+        >>> a = ArrayComprehension(10*i + j, (i, 1, 4), (j, 1, 3))
+        >>> a.tolist()
+        [[11, 12, 13], [21, 22, 23], [31, 32, 33], [41, 42, 43]]
+        """
+        if self.is_shape_numeric:
+            return self._expand_array().tolist()
+
+        raise ValueError("A symbolic array cannot be expanded to a list")
+
+    def tomatrix(self):
+        """Transform the expanded array to a matrix.
+
+        Raises
+        ======
+
+        ValueError : When there is a symbolic dimension
+        ValueError : When the rank of the expanded array is not equal to 2
+
+        Examples
+        ========
+
+        >>> from sympy.tensor.array import ArrayComprehension
+        >>> from sympy import symbols
+        >>> i, j = symbols('i j')
+        >>> a = ArrayComprehension(10*i + j, (i, 1, 4), (j, 1, 3))
+        >>> a.tomatrix()
+        Matrix([
+        [11, 12, 13],
+        [21, 22, 23],
+        [31, 32, 33],
+        [41, 42, 43]])
+        """
+        from sympy.matrices import Matrix
+
+        if not self.is_shape_numeric:
+            raise ValueError("A symbolic array cannot be expanded to a matrix")
+        if self._rank != 2:
+            raise ValueError('Dimensions must be of size of 2')
+
+        return Matrix(self._expand_array().tomatrix())
+
+
+def isLambda(v):
+    LAMBDA = lambda: 0
+    return isinstance(v, type(LAMBDA)) and v.__name__ == LAMBDA.__name__
+
+class ArrayComprehensionMap(ArrayComprehension):
+    '''
+    A subclass of ArrayComprehension dedicated to map external function lambda.
+
+    Notes
+    =====
+
+    Only the lambda function is considered.
+    At most one argument in lambda function is accepted in order to avoid ambiguity
+    in value assignment.
+
+    Examples
+    ========
+
+    >>> from sympy.tensor.array import ArrayComprehensionMap
+    >>> from sympy import symbols
+    >>> i, j, k = symbols('i j k')
+    >>> a = ArrayComprehensionMap(lambda: 1, (i, 1, 4))
+    >>> a.doit()
+    [1, 1, 1, 1]
+    >>> b = ArrayComprehensionMap(lambda a: a+1, (j, 1, 4))
+    >>> b.doit()
+    [2, 3, 4, 5]
+
+    '''
+    def __new__(cls, function, *symbols, **assumptions):
+        if any(len(l) != 3 or None for l in symbols):
+            raise ValueError('ArrayComprehension requires values lower and upper bound'
+                              ' for the expression')
+
+        if not isLambda(function):
+            raise ValueError('Data type not supported')
+
+        arglist = cls._check_limits_validity(function, symbols)
+        obj = Basic.__new__(cls, *arglist, **assumptions)
+        obj._limits = obj._args
+        obj._shape = cls._calculate_shape_from_limits(obj._limits)
+        obj._rank = len(obj._shape)
+        obj._loop_size = cls._calculate_loop_size(obj._shape)
+        obj._lambda = function
+        return obj
+
+    @property
+    def func(self):
+        class _(ArrayComprehensionMap):
+            def __new__(cls, *args, **kwargs):
+                return ArrayComprehensionMap(self._lambda, *args, **kwargs)
+        return _
+
+    def _get_element(self, values):
+        temp = self._lambda
+        if self._lambda.__code__.co_argcount == 0:
+            temp = temp()
+        elif self._lambda.__code__.co_argcount == 1:
+            temp = temp(functools.reduce(lambda a, b: a*b, values))
+        return temp
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/array_derivatives.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/array_derivatives.py
new file mode 100644
index 0000000000000000000000000000000000000000..a38db6caefe256a8c7e1f3415b78351b3787fee9
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/array_derivatives.py
@@ -0,0 +1,129 @@
+from __future__ import annotations
+
+from sympy.core.expr import Expr
+from sympy.core.function import Derivative
+from sympy.core.numbers import Integer
+from sympy.matrices.matrixbase import MatrixBase
+from .ndim_array import NDimArray
+from .arrayop import derive_by_array
+from sympy.matrices.expressions.matexpr import MatrixExpr
+from sympy.matrices.expressions.special import ZeroMatrix
+from sympy.matrices.expressions.matexpr import _matrix_derivative
+
+
+class ArrayDerivative(Derivative):
+
+    is_scalar = False
+
+    def __new__(cls, expr, *variables, **kwargs):
+        obj = super().__new__(cls, expr, *variables, **kwargs)
+        if isinstance(obj, ArrayDerivative):
+            obj._shape = obj._get_shape()
+        return obj
+
+    def _get_shape(self):
+        shape = ()
+        for v, count in self.variable_count:
+            if hasattr(v, "shape"):
+                for i in range(count):
+                    shape += v.shape
+        if hasattr(self.expr, "shape"):
+            shape += self.expr.shape
+        return shape
+
+    @property
+    def shape(self):
+        return self._shape
+
+    @classmethod
+    def _get_zero_with_shape_like(cls, expr):
+        if isinstance(expr, (MatrixBase, NDimArray)):
+            return expr.zeros(*expr.shape)
+        elif isinstance(expr, MatrixExpr):
+            return ZeroMatrix(*expr.shape)
+        else:
+            raise RuntimeError("Unable to determine shape of array-derivative.")
+
+    @staticmethod
+    def _call_derive_scalar_by_matrix(expr: Expr, v: MatrixBase) -> Expr:
+        return v.applyfunc(lambda x: expr.diff(x))
+
+    @staticmethod
+    def _call_derive_scalar_by_matexpr(expr: Expr, v: MatrixExpr) -> Expr:
+        if expr.has(v):
+            return _matrix_derivative(expr, v)
+        else:
+            return ZeroMatrix(*v.shape)
+
+    @staticmethod
+    def _call_derive_scalar_by_array(expr: Expr, v: NDimArray) -> Expr:
+        return v.applyfunc(lambda x: expr.diff(x))
+
+    @staticmethod
+    def _call_derive_matrix_by_scalar(expr: MatrixBase, v: Expr) -> Expr:
+        return _matrix_derivative(expr, v)
+
+    @staticmethod
+    def _call_derive_matexpr_by_scalar(expr: MatrixExpr, v: Expr) -> Expr:
+        return expr._eval_derivative(v)
+
+    @staticmethod
+    def _call_derive_array_by_scalar(expr: NDimArray, v: Expr) -> Expr:
+        return expr.applyfunc(lambda x: x.diff(v))
+
+    @staticmethod
+    def _call_derive_default(expr: Expr, v: Expr) -> Expr | None:
+        if expr.has(v):
+            return _matrix_derivative(expr, v)
+        else:
+            return None
+
+    @classmethod
+    def _dispatch_eval_derivative_n_times(cls, expr, v, count):
+        # Evaluate the derivative `n` times.  If
+        # `_eval_derivative_n_times` is not overridden by the current
+        # object, the default in `Basic` will call a loop over
+        # `_eval_derivative`:
+
+        if not isinstance(count, (int, Integer)) or ((count <= 0) == True):
+            return None
+
+        # TODO: this could be done with multiple-dispatching:
+        if expr.is_scalar:
+            if isinstance(v, MatrixBase):
+                result = cls._call_derive_scalar_by_matrix(expr, v)
+            elif isinstance(v, MatrixExpr):
+                result = cls._call_derive_scalar_by_matexpr(expr, v)
+            elif isinstance(v, NDimArray):
+                result = cls._call_derive_scalar_by_array(expr, v)
+            elif v.is_scalar:
+                # scalar by scalar has a special
+                return super()._dispatch_eval_derivative_n_times(expr, v, count)
+            else:
+                return None
+        elif v.is_scalar:
+            if isinstance(expr, MatrixBase):
+                result = cls._call_derive_matrix_by_scalar(expr, v)
+            elif isinstance(expr, MatrixExpr):
+                result = cls._call_derive_matexpr_by_scalar(expr, v)
+            elif isinstance(expr, NDimArray):
+                result = cls._call_derive_array_by_scalar(expr, v)
+            else:
+                return None
+        else:
+            # Both `expr` and `v` are some array/matrix type:
+            if isinstance(expr, MatrixBase) or isinstance(v, MatrixBase):
+                result = derive_by_array(expr, v)
+            elif isinstance(expr, MatrixExpr) and isinstance(v, MatrixExpr):
+                result = cls._call_derive_default(expr, v)
+            elif isinstance(expr, MatrixExpr) or isinstance(v, MatrixExpr):
+                # if one expression is a symbolic matrix expression while the other isn't, don't evaluate:
+                return None
+            else:
+                result = derive_by_array(expr, v)
+        if result is None:
+            return None
+        if count == 1:
+            return result
+        else:
+            return cls._dispatch_eval_derivative_n_times(result, v, count - 1)
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/arrayop.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/arrayop.py
new file mode 100644
index 0000000000000000000000000000000000000000..a81e6b381a8a93f0cd585278a4be0259b06406dd
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/arrayop.py
@@ -0,0 +1,528 @@
+import itertools
+from collections.abc import Iterable
+
+from sympy.core._print_helpers import Printable
+from sympy.core.containers import Tuple
+from sympy.core.function import diff
+from sympy.core.singleton import S
+from sympy.core.sympify import _sympify
+
+from sympy.tensor.array.ndim_array import NDimArray
+from sympy.tensor.array.dense_ndim_array import DenseNDimArray, ImmutableDenseNDimArray
+from sympy.tensor.array.sparse_ndim_array import SparseNDimArray
+
+
+def _arrayfy(a):
+    from sympy.matrices import MatrixBase
+
+    if isinstance(a, NDimArray):
+        return a
+    if isinstance(a, (MatrixBase, list, tuple, Tuple)):
+        return ImmutableDenseNDimArray(a)
+    return a
+
+
+def tensorproduct(*args):
+    """
+    Tensor product among scalars or array-like objects.
+
+    The equivalent operator for array expressions is ``ArrayTensorProduct``,
+    which can be used to keep the expression unevaluated.
+
+    Examples
+    ========
+
+    >>> from sympy.tensor.array import tensorproduct, Array
+    >>> from sympy.abc import x, y, z, t
+    >>> A = Array([[1, 2], [3, 4]])
+    >>> B = Array([x, y])
+    >>> tensorproduct(A, B)
+    [[[x, y], [2*x, 2*y]], [[3*x, 3*y], [4*x, 4*y]]]
+    >>> tensorproduct(A, x)
+    [[x, 2*x], [3*x, 4*x]]
+    >>> tensorproduct(A, B, B)
+    [[[[x**2, x*y], [x*y, y**2]], [[2*x**2, 2*x*y], [2*x*y, 2*y**2]]], [[[3*x**2, 3*x*y], [3*x*y, 3*y**2]], [[4*x**2, 4*x*y], [4*x*y, 4*y**2]]]]
+
+    Applying this function on two matrices will result in a rank 4 array.
+
+    >>> from sympy import Matrix, eye
+    >>> m = Matrix([[x, y], [z, t]])
+    >>> p = tensorproduct(eye(3), m)
+    >>> p
+    [[[[x, y], [z, t]], [[0, 0], [0, 0]], [[0, 0], [0, 0]]], [[[0, 0], [0, 0]], [[x, y], [z, t]], [[0, 0], [0, 0]]], [[[0, 0], [0, 0]], [[0, 0], [0, 0]], [[x, y], [z, t]]]]
+
+    See Also
+    ========
+
+    sympy.tensor.array.expressions.array_expressions.ArrayTensorProduct
+
+    """
+    from sympy.tensor.array import SparseNDimArray, ImmutableSparseNDimArray
+
+    if len(args) == 0:
+        return S.One
+    if len(args) == 1:
+        return _arrayfy(args[0])
+    from sympy.tensor.array.expressions.array_expressions import _CodegenArrayAbstract
+    from sympy.tensor.array.expressions.array_expressions import ArrayTensorProduct
+    from sympy.tensor.array.expressions.array_expressions import _ArrayExpr
+    from sympy.matrices.expressions.matexpr import MatrixSymbol
+    if any(isinstance(arg, (_ArrayExpr, _CodegenArrayAbstract, MatrixSymbol)) for arg in args):
+        return ArrayTensorProduct(*args)
+    if len(args) > 2:
+        return tensorproduct(tensorproduct(args[0], args[1]), *args[2:])
+
+    # length of args is 2:
+    a, b = map(_arrayfy, args)
+
+    if not isinstance(a, NDimArray) or not isinstance(b, NDimArray):
+        return a*b
+
+    if isinstance(a, SparseNDimArray) and isinstance(b, SparseNDimArray):
+        lp = len(b)
+        new_array = {k1*lp + k2: v1*v2 for k1, v1 in a._sparse_array.items() for k2, v2 in b._sparse_array.items()}
+        return ImmutableSparseNDimArray(new_array, a.shape + b.shape)
+
+    product_list = [i*j for i in Flatten(a) for j in Flatten(b)]
+    return ImmutableDenseNDimArray(product_list, a.shape + b.shape)
+
+
+def _util_contraction_diagonal(array, *contraction_or_diagonal_axes):
+    array = _arrayfy(array)
+
+    # Verify contraction_axes:
+    taken_dims = set()
+    for axes_group in contraction_or_diagonal_axes:
+        if not isinstance(axes_group, Iterable):
+            raise ValueError("collections of contraction/diagonal axes expected")
+
+        dim = array.shape[axes_group[0]]
+
+        for d in axes_group:
+            if d in taken_dims:
+                raise ValueError("dimension specified more than once")
+            if dim != array.shape[d]:
+                raise ValueError("cannot contract or diagonalize between axes of different dimension")
+            taken_dims.add(d)
+
+    rank = array.rank()
+
+    remaining_shape = [dim for i, dim in enumerate(array.shape) if i not in taken_dims]
+    cum_shape = [0]*rank
+    _cumul = 1
+    for i in range(rank):
+        cum_shape[rank - i - 1] = _cumul
+        _cumul *= int(array.shape[rank - i - 1])
+
+    # DEFINITION: by absolute position it is meant the position along the one
+    # dimensional array containing all the tensor components.
+
+    # Possible future work on this module: move computation of absolute
+    # positions to a class method.
+
+    # Determine absolute positions of the uncontracted indices:
+    remaining_indices = [[cum_shape[i]*j for j in range(array.shape[i])]
+                         for i in range(rank) if i not in taken_dims]
+
+    # Determine absolute positions of the contracted indices:
+    summed_deltas = []
+    for axes_group in contraction_or_diagonal_axes:
+        lidx = []
+        for js in range(array.shape[axes_group[0]]):
+            lidx.append(sum(cum_shape[ig] * js for ig in axes_group))
+        summed_deltas.append(lidx)
+
+    return array, remaining_indices, remaining_shape, summed_deltas
+
+
+def tensorcontraction(array, *contraction_axes):
+    """
+    Contraction of an array-like object on the specified axes.
+
+    The equivalent operator for array expressions is ``ArrayContraction``,
+    which can be used to keep the expression unevaluated.
+
+    Examples
+    ========
+
+    >>> from sympy import Array, tensorcontraction
+    >>> from sympy import Matrix, eye
+    >>> tensorcontraction(eye(3), (0, 1))
+    3
+    >>> A = Array(range(18), (3, 2, 3))
+    >>> A
+    [[[0, 1, 2], [3, 4, 5]], [[6, 7, 8], [9, 10, 11]], [[12, 13, 14], [15, 16, 17]]]
+    >>> tensorcontraction(A, (0, 2))
+    [21, 30]
+
+    Matrix multiplication may be emulated with a proper combination of
+    ``tensorcontraction`` and ``tensorproduct``
+
+    >>> from sympy import tensorproduct
+    >>> from sympy.abc import a,b,c,d,e,f,g,h
+    >>> m1 = Matrix([[a, b], [c, d]])
+    >>> m2 = Matrix([[e, f], [g, h]])
+    >>> p = tensorproduct(m1, m2)
+    >>> p
+    [[[[a*e, a*f], [a*g, a*h]], [[b*e, b*f], [b*g, b*h]]], [[[c*e, c*f], [c*g, c*h]], [[d*e, d*f], [d*g, d*h]]]]
+    >>> tensorcontraction(p, (1, 2))
+    [[a*e + b*g, a*f + b*h], [c*e + d*g, c*f + d*h]]
+    >>> m1*m2
+    Matrix([
+    [a*e + b*g, a*f + b*h],
+    [c*e + d*g, c*f + d*h]])
+
+    See Also
+    ========
+
+    sympy.tensor.array.expressions.array_expressions.ArrayContraction
+
+    """
+    from sympy.tensor.array.expressions.array_expressions import _array_contraction
+    from sympy.tensor.array.expressions.array_expressions import _CodegenArrayAbstract
+    from sympy.tensor.array.expressions.array_expressions import _ArrayExpr
+    from sympy.matrices.expressions.matexpr import MatrixSymbol
+    if isinstance(array, (_ArrayExpr, _CodegenArrayAbstract, MatrixSymbol)):
+        return _array_contraction(array, *contraction_axes)
+
+    array, remaining_indices, remaining_shape, summed_deltas = _util_contraction_diagonal(array, *contraction_axes)
+
+    # Compute the contracted array:
+    #
+    # 1. external for loops on all uncontracted indices.
+    #    Uncontracted indices are determined by the combinatorial product of
+    #    the absolute positions of the remaining indices.
+    # 2. internal loop on all contracted indices.
+    #    It sums the values of the absolute contracted index and the absolute
+    #    uncontracted index for the external loop.
+    contracted_array = []
+    for icontrib in itertools.product(*remaining_indices):
+        index_base_position = sum(icontrib)
+        isum = S.Zero
+        for sum_to_index in itertools.product(*summed_deltas):
+            idx = array._get_tuple_index(index_base_position + sum(sum_to_index))
+            isum += array[idx]
+
+        contracted_array.append(isum)
+
+    if len(remaining_indices) == 0:
+        assert len(contracted_array) == 1
+        return contracted_array[0]
+
+    return type(array)(contracted_array, remaining_shape)
+
+
+def tensordiagonal(array, *diagonal_axes):
+    """
+    Diagonalization of an array-like object on the specified axes.
+
+    This is equivalent to multiplying the expression by Kronecker deltas
+    uniting the axes.
+
+    The diagonal indices are put at the end of the axes.
+
+    The equivalent operator for array expressions is ``ArrayDiagonal``, which
+    can be used to keep the expression unevaluated.
+
+    Examples
+    ========
+
+    ``tensordiagonal`` acting on a 2-dimensional array by axes 0 and 1 is
+    equivalent to the diagonal of the matrix:
+
+    >>> from sympy import Array, tensordiagonal
+    >>> from sympy import Matrix, eye
+    >>> tensordiagonal(eye(3), (0, 1))
+    [1, 1, 1]
+
+    >>> from sympy.abc import a,b,c,d
+    >>> m1 = Matrix([[a, b], [c, d]])
+    >>> tensordiagonal(m1, [0, 1])
+    [a, d]
+
+    In case of higher dimensional arrays, the diagonalized out dimensions
+    are appended removed and appended as a single dimension at the end:
+
+    >>> A = Array(range(18), (3, 2, 3))
+    >>> A
+    [[[0, 1, 2], [3, 4, 5]], [[6, 7, 8], [9, 10, 11]], [[12, 13, 14], [15, 16, 17]]]
+    >>> tensordiagonal(A, (0, 2))
+    [[0, 7, 14], [3, 10, 17]]
+    >>> from sympy import permutedims
+    >>> tensordiagonal(A, (0, 2)) == permutedims(Array([A[0, :, 0], A[1, :, 1], A[2, :, 2]]), [1, 0])
+    True
+
+    See Also
+    ========
+
+    sympy.tensor.array.expressions.array_expressions.ArrayDiagonal
+
+    """
+    if any(len(i) <= 1 for i in diagonal_axes):
+        raise ValueError("need at least two axes to diagonalize")
+
+    from sympy.tensor.array.expressions.array_expressions import _ArrayExpr
+    from sympy.tensor.array.expressions.array_expressions import _CodegenArrayAbstract
+    from sympy.tensor.array.expressions.array_expressions import ArrayDiagonal, _array_diagonal
+    from sympy.matrices.expressions.matexpr import MatrixSymbol
+    if isinstance(array, (_ArrayExpr, _CodegenArrayAbstract, MatrixSymbol)):
+        return _array_diagonal(array, *diagonal_axes)
+
+    ArrayDiagonal._validate(array, *diagonal_axes)
+
+    array, remaining_indices, remaining_shape, diagonal_deltas = _util_contraction_diagonal(array, *diagonal_axes)
+
+    # Compute the diagonalized array:
+    #
+    # 1. external for loops on all undiagonalized indices.
+    #    Undiagonalized indices are determined by the combinatorial product of
+    #    the absolute positions of the remaining indices.
+    # 2. internal loop on all diagonal indices.
+    #    It appends the values of the absolute diagonalized index and the absolute
+    #    undiagonalized index for the external loop.
+    diagonalized_array = []
+    diagonal_shape = [len(i) for i in diagonal_deltas]
+    for icontrib in itertools.product(*remaining_indices):
+        index_base_position = sum(icontrib)
+        isum = []
+        for sum_to_index in itertools.product(*diagonal_deltas):
+            idx = array._get_tuple_index(index_base_position + sum(sum_to_index))
+            isum.append(array[idx])
+
+        isum = type(array)(isum).reshape(*diagonal_shape)
+        diagonalized_array.append(isum)
+
+    return type(array)(diagonalized_array, remaining_shape + diagonal_shape)
+
+
+def derive_by_array(expr, dx):
+    r"""
+    Derivative by arrays. Supports both arrays and scalars.
+
+    The equivalent operator for array expressions is ``array_derive``.
+
+    Explanation
+    ===========
+
+    Given the array `A_{i_1, \ldots, i_N}` and the array `X_{j_1, \ldots, j_M}`
+    this function will return a new array `B` defined by
+
+    `B_{j_1,\ldots,j_M,i_1,\ldots,i_N} := \frac{\partial A_{i_1,\ldots,i_N}}{\partial X_{j_1,\ldots,j_M}}`
+
+    Examples
+    ========
+
+    >>> from sympy import derive_by_array
+    >>> from sympy.abc import x, y, z, t
+    >>> from sympy import cos
+    >>> derive_by_array(cos(x*t), x)
+    -t*sin(t*x)
+    >>> derive_by_array(cos(x*t), [x, y, z, t])
+    [-t*sin(t*x), 0, 0, -x*sin(t*x)]
+    >>> derive_by_array([x, y**2*z], [[x, y], [z, t]])
+    [[[1, 0], [0, 2*y*z]], [[0, y**2], [0, 0]]]
+
+    """
+    from sympy.matrices import MatrixBase
+    from sympy.tensor.array import SparseNDimArray
+    array_types = (Iterable, MatrixBase, NDimArray)
+
+    if isinstance(dx, array_types):
+        dx = ImmutableDenseNDimArray(dx)
+        for i in dx:
+            if not i._diff_wrt:
+                raise ValueError("cannot derive by this array")
+
+    if isinstance(expr, array_types):
+        if isinstance(expr, NDimArray):
+            expr = expr.as_immutable()
+        else:
+            expr = ImmutableDenseNDimArray(expr)
+
+        if isinstance(dx, array_types):
+            if isinstance(expr, SparseNDimArray):
+                lp = len(expr)
+                new_array = {k + i*lp: v
+                             for i, x in enumerate(Flatten(dx))
+                             for k, v in expr.diff(x)._sparse_array.items()}
+            else:
+                new_array = [[y.diff(x) for y in Flatten(expr)] for x in Flatten(dx)]
+            return type(expr)(new_array, dx.shape + expr.shape)
+        else:
+            return expr.diff(dx)
+    else:
+        expr = _sympify(expr)
+        if isinstance(dx, array_types):
+            return ImmutableDenseNDimArray([expr.diff(i) for i in Flatten(dx)], dx.shape)
+        else:
+            dx = _sympify(dx)
+            return diff(expr, dx)
+
+
+def permutedims(expr, perm=None, index_order_old=None, index_order_new=None):
+    """
+    Permutes the indices of an array.
+
+    Parameter specifies the permutation of the indices.
+
+    The equivalent operator for array expressions is ``PermuteDims``, which can
+    be used to keep the expression unevaluated.
+
+    Examples
+    ========
+
+    >>> from sympy.abc import x, y, z, t
+    >>> from sympy import sin
+    >>> from sympy import Array, permutedims
+    >>> a = Array([[x, y, z], [t, sin(x), 0]])
+    >>> a
+    [[x, y, z], [t, sin(x), 0]]
+    >>> permutedims(a, (1, 0))
+    [[x, t], [y, sin(x)], [z, 0]]
+
+    If the array is of second order, ``transpose`` can be used:
+
+    >>> from sympy import transpose
+    >>> transpose(a)
+    [[x, t], [y, sin(x)], [z, 0]]
+
+    Examples on higher dimensions:
+
+    >>> b = Array([[[1, 2], [3, 4]], [[5, 6], [7, 8]]])
+    >>> permutedims(b, (2, 1, 0))
+    [[[1, 5], [3, 7]], [[2, 6], [4, 8]]]
+    >>> permutedims(b, (1, 2, 0))
+    [[[1, 5], [2, 6]], [[3, 7], [4, 8]]]
+
+    An alternative way to specify the same permutations as in the previous
+    lines involves passing the *old* and *new* indices, either as a list or as
+    a string:
+
+    >>> permutedims(b, index_order_old="cba", index_order_new="abc")
+    [[[1, 5], [3, 7]], [[2, 6], [4, 8]]]
+    >>> permutedims(b, index_order_old="cab", index_order_new="abc")
+    [[[1, 5], [2, 6]], [[3, 7], [4, 8]]]
+
+    ``Permutation`` objects are also allowed:
+
+    >>> from sympy.combinatorics import Permutation
+    >>> permutedims(b, Permutation([1, 2, 0]))
+    [[[1, 5], [2, 6]], [[3, 7], [4, 8]]]
+
+    See Also
+    ========
+
+    sympy.tensor.array.expressions.array_expressions.PermuteDims
+
+    """
+    from sympy.tensor.array import SparseNDimArray
+
+    from sympy.tensor.array.expressions.array_expressions import _ArrayExpr
+    from sympy.tensor.array.expressions.array_expressions import _CodegenArrayAbstract
+    from sympy.tensor.array.expressions.array_expressions import _permute_dims
+    from sympy.matrices.expressions.matexpr import MatrixSymbol
+    from sympy.tensor.array.expressions import PermuteDims
+    from sympy.tensor.array.expressions.array_expressions import get_rank
+    perm = PermuteDims._get_permutation_from_arguments(perm, index_order_old, index_order_new, get_rank(expr))
+    if isinstance(expr, (_ArrayExpr, _CodegenArrayAbstract, MatrixSymbol)):
+        return _permute_dims(expr, perm)
+
+    if not isinstance(expr, NDimArray):
+        expr = ImmutableDenseNDimArray(expr)
+
+    from sympy.combinatorics import Permutation
+    if not isinstance(perm, Permutation):
+        perm = Permutation(list(perm))
+
+    if perm.size != expr.rank():
+        raise ValueError("wrong permutation size")
+
+    # Get the inverse permutation:
+    iperm = ~perm
+    new_shape = perm(expr.shape)
+
+    if isinstance(expr, SparseNDimArray):
+        return type(expr)({tuple(perm(expr._get_tuple_index(k))): v
+                           for k, v in expr._sparse_array.items()}, new_shape)
+
+    indices_span = perm([range(i) for i in expr.shape])
+
+    new_array = [None]*len(expr)
+    for i, idx in enumerate(itertools.product(*indices_span)):
+        t = iperm(idx)
+        new_array[i] = expr[t]
+
+    return type(expr)(new_array, new_shape)
+
+
+class Flatten(Printable):
+    """
+    Flatten an iterable object to a list in a lazy-evaluation way.
+
+    Notes
+    =====
+
+    This class is an iterator with which the memory cost can be economised.
+    Optimisation has been considered to ameliorate the performance for some
+    specific data types like DenseNDimArray and SparseNDimArray.
+
+    Examples
+    ========
+
+    >>> from sympy.tensor.array.arrayop import Flatten
+    >>> from sympy.tensor.array import Array
+    >>> A = Array(range(6)).reshape(2, 3)
+    >>> Flatten(A)
+    Flatten([[0, 1, 2], [3, 4, 5]])
+    >>> [i for i in Flatten(A)]
+    [0, 1, 2, 3, 4, 5]
+    """
+    def __init__(self, iterable):
+        from sympy.matrices.matrixbase import MatrixBase
+        from sympy.tensor.array import NDimArray
+
+        if not isinstance(iterable, (Iterable, MatrixBase)):
+            raise NotImplementedError("Data type not yet supported")
+
+        if isinstance(iterable, list):
+            iterable = NDimArray(iterable)
+
+        self._iter = iterable
+        self._idx = 0
+
+    def __iter__(self):
+        return self
+
+    def __next__(self):
+        from sympy.matrices.matrixbase import MatrixBase
+
+        if len(self._iter) > self._idx:
+            if isinstance(self._iter, DenseNDimArray):
+                result = self._iter._array[self._idx]
+
+            elif isinstance(self._iter, SparseNDimArray):
+                if self._idx in self._iter._sparse_array:
+                    result = self._iter._sparse_array[self._idx]
+                else:
+                    result = 0
+
+            elif isinstance(self._iter, MatrixBase):
+                result = self._iter[self._idx]
+
+            elif hasattr(self._iter, '__next__'):
+                result = next(self._iter)
+
+            else:
+                result = self._iter[self._idx]
+
+        else:
+            raise StopIteration
+
+        self._idx += 1
+        return result
+
+    def next(self):
+        return self.__next__()
+
+    def _sympystr(self, printer):
+        return type(self).__name__ + '(' + printer._print(self._iter) + ')'
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/dense_ndim_array.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/dense_ndim_array.py
new file mode 100644
index 0000000000000000000000000000000000000000..576e452c55d8d374ca1f72c553f3a64de7227d43
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/dense_ndim_array.py
@@ -0,0 +1,206 @@
+import functools
+from typing import List
+
+from sympy.core.basic import Basic
+from sympy.core.containers import Tuple
+from sympy.core.singleton import S
+from sympy.core.sympify import _sympify
+from sympy.tensor.array.mutable_ndim_array import MutableNDimArray
+from sympy.tensor.array.ndim_array import NDimArray, ImmutableNDimArray, ArrayKind
+from sympy.utilities.iterables import flatten
+
+
+class DenseNDimArray(NDimArray):
+
+    _array: List[Basic]
+
+    def __new__(self, *args, **kwargs):
+        return ImmutableDenseNDimArray(*args, **kwargs)
+
+    @property
+    def kind(self) -> ArrayKind:
+        return ArrayKind._union(self._array)
+
+    def __getitem__(self, index):
+        """
+        Allows to get items from N-dim array.
+
+        Examples
+        ========
+
+        >>> from sympy import MutableDenseNDimArray
+        >>> a = MutableDenseNDimArray([0, 1, 2, 3], (2, 2))
+        >>> a
+        [[0, 1], [2, 3]]
+        >>> a[0, 0]
+        0
+        >>> a[1, 1]
+        3
+        >>> a[0]
+        [0, 1]
+        >>> a[1]
+        [2, 3]
+
+
+        Symbolic index:
+
+        >>> from sympy.abc import i, j
+        >>> a[i, j]
+        [[0, 1], [2, 3]][i, j]
+
+        Replace `i` and `j` to get element `(1, 1)`:
+
+        >>> a[i, j].subs({i: 1, j: 1})
+        3
+
+        """
+        syindex = self._check_symbolic_index(index)
+        if syindex is not None:
+            return syindex
+
+        index = self._check_index_for_getitem(index)
+
+        if isinstance(index, tuple) and any(isinstance(i, slice) for i in index):
+            sl_factors, eindices = self._get_slice_data_for_array_access(index)
+            array = [self._array[self._parse_index(i)] for i in eindices]
+            nshape = [len(el) for i, el in enumerate(sl_factors) if isinstance(index[i], slice)]
+            return type(self)(array, nshape)
+        else:
+            index = self._parse_index(index)
+            return self._array[index]
+
+    @classmethod
+    def zeros(cls, *shape):
+        list_length = functools.reduce(lambda x, y: x*y, shape, S.One)
+        return cls._new(([0]*list_length,), shape)
+
+    def tomatrix(self):
+        """
+        Converts MutableDenseNDimArray to Matrix. Can convert only 2-dim array, else will raise error.
+
+        Examples
+        ========
+
+        >>> from sympy import MutableDenseNDimArray
+        >>> a = MutableDenseNDimArray([1 for i in range(9)], (3, 3))
+        >>> b = a.tomatrix()
+        >>> b
+        Matrix([
+        [1, 1, 1],
+        [1, 1, 1],
+        [1, 1, 1]])
+
+        """
+        from sympy.matrices import Matrix
+
+        if self.rank() != 2:
+            raise ValueError('Dimensions must be of size of 2')
+
+        return Matrix(self.shape[0], self.shape[1], self._array)
+
+    def reshape(self, *newshape):
+        """
+        Returns MutableDenseNDimArray instance with new shape. Elements number
+        must be        suitable to new shape. The only argument of method sets
+        new shape.
+
+        Examples
+        ========
+
+        >>> from sympy import MutableDenseNDimArray
+        >>> a = MutableDenseNDimArray([1, 2, 3, 4, 5, 6], (2, 3))
+        >>> a.shape
+        (2, 3)
+        >>> a
+        [[1, 2, 3], [4, 5, 6]]
+        >>> b = a.reshape(3, 2)
+        >>> b.shape
+        (3, 2)
+        >>> b
+        [[1, 2], [3, 4], [5, 6]]
+
+        """
+        new_total_size = functools.reduce(lambda x,y: x*y, newshape)
+        if new_total_size != self._loop_size:
+            raise ValueError('Expecting reshape size to %d but got prod(%s) = %d' % (
+                self._loop_size, str(newshape), new_total_size))
+
+        # there is no `.func` as this class does not subtype `Basic`:
+        return type(self)(self._array, newshape)
+
+
+class ImmutableDenseNDimArray(DenseNDimArray, ImmutableNDimArray): # type: ignore
+    def __new__(cls, iterable, shape=None, **kwargs):
+        return cls._new(iterable, shape, **kwargs)
+
+    @classmethod
+    def _new(cls, iterable, shape, **kwargs):
+        shape, flat_list = cls._handle_ndarray_creation_inputs(iterable, shape, **kwargs)
+        shape = Tuple(*map(_sympify, shape))
+        cls._check_special_bounds(flat_list, shape)
+        flat_list = flatten(flat_list)
+        flat_list = Tuple(*flat_list)
+        self = Basic.__new__(cls, flat_list, shape, **kwargs)
+        self._shape = shape
+        self._array = list(flat_list)
+        self._rank = len(shape)
+        self._loop_size = functools.reduce(lambda x,y: x*y, shape, 1)
+        return self
+
+    def __setitem__(self, index, value):
+        raise TypeError('immutable N-dim array')
+
+    def as_mutable(self):
+        return MutableDenseNDimArray(self)
+
+    def _eval_simplify(self, **kwargs):
+        from sympy.simplify.simplify import simplify
+        return self.applyfunc(simplify)
+
+class MutableDenseNDimArray(DenseNDimArray, MutableNDimArray):
+
+    def __new__(cls, iterable=None, shape=None, **kwargs):
+        return cls._new(iterable, shape, **kwargs)
+
+    @classmethod
+    def _new(cls, iterable, shape, **kwargs):
+        shape, flat_list = cls._handle_ndarray_creation_inputs(iterable, shape, **kwargs)
+        flat_list = flatten(flat_list)
+        self = object.__new__(cls)
+        self._shape = shape
+        self._array = list(flat_list)
+        self._rank = len(shape)
+        self._loop_size = functools.reduce(lambda x,y: x*y, shape) if shape else len(flat_list)
+        return self
+
+    def __setitem__(self, index, value):
+        """Allows to set items to MutableDenseNDimArray.
+
+        Examples
+        ========
+
+        >>> from sympy import MutableDenseNDimArray
+        >>> a = MutableDenseNDimArray.zeros(2,  2)
+        >>> a[0,0] = 1
+        >>> a[1,1] = 1
+        >>> a
+        [[1, 0], [0, 1]]
+
+        """
+        if isinstance(index, tuple) and any(isinstance(i, slice) for i in index):
+            value, eindices, slice_offsets = self._get_slice_data_for_array_assignment(index, value)
+            for i in eindices:
+                other_i = [ind - j for ind, j in zip(i, slice_offsets) if j is not None]
+                self._array[self._parse_index(i)] = value[other_i]
+        else:
+            index = self._parse_index(index)
+            self._setter_iterable_check(value)
+            value = _sympify(value)
+            self._array[index] = value
+
+    def as_immutable(self):
+        return ImmutableDenseNDimArray(self)
+
+    @property
+    def free_symbols(self):
+        return {i for j in self._array for i in j.free_symbols}
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/expressions/__init__.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/expressions/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..f1658241782cdf0e38a30c43a6d67f9811297f4c
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/expressions/__init__.py
@@ -0,0 +1,178 @@
+r"""
+Array expressions are expressions representing N-dimensional arrays, without
+evaluating them. These expressions represent in a certain way abstract syntax
+trees of operations on N-dimensional arrays.
+
+Every N-dimensional array operator has a corresponding array expression object.
+
+Table of correspondences:
+
+=============================== =============================
+         Array operator           Array expression operator
+=============================== =============================
+        tensorproduct                 ArrayTensorProduct
+        tensorcontraction             ArrayContraction
+        tensordiagonal                ArrayDiagonal
+        permutedims                   PermuteDims
+=============================== =============================
+
+Examples
+========
+
+``ArraySymbol`` objects are the N-dimensional equivalent of ``MatrixSymbol``
+objects in the matrix module:
+
+>>> from sympy.tensor.array.expressions import ArraySymbol
+>>> from sympy.abc import i, j, k
+>>> A = ArraySymbol("A", (3, 2, 4))
+>>> A.shape
+(3, 2, 4)
+>>> A[i, j, k]
+A[i, j, k]
+>>> A.as_explicit()
+[[[A[0, 0, 0], A[0, 0, 1], A[0, 0, 2], A[0, 0, 3]],
+  [A[0, 1, 0], A[0, 1, 1], A[0, 1, 2], A[0, 1, 3]]],
+ [[A[1, 0, 0], A[1, 0, 1], A[1, 0, 2], A[1, 0, 3]],
+  [A[1, 1, 0], A[1, 1, 1], A[1, 1, 2], A[1, 1, 3]]],
+ [[A[2, 0, 0], A[2, 0, 1], A[2, 0, 2], A[2, 0, 3]],
+  [A[2, 1, 0], A[2, 1, 1], A[2, 1, 2], A[2, 1, 3]]]]
+
+Component-explicit arrays can be added inside array expressions:
+
+>>> from sympy import Array
+>>> from sympy import tensorproduct
+>>> from sympy.tensor.array.expressions import ArrayTensorProduct
+>>> a = Array([1, 2, 3])
+>>> b = Array([i, j, k])
+>>> expr = ArrayTensorProduct(a, b, b)
+>>> expr
+ArrayTensorProduct([1, 2, 3], [i, j, k], [i, j, k])
+>>> expr.as_explicit() == tensorproduct(a, b, b)
+True
+
+Constructing array expressions from index-explicit forms
+--------------------------------------------------------
+
+Array expressions are index-implicit. This means they do not use any indices to
+represent array operations. The function ``convert_indexed_to_array( ... )``
+may be used to convert index-explicit expressions to array expressions.
+It takes as input two parameters: the index-explicit expression and the order
+of the indices:
+
+>>> from sympy.tensor.array.expressions import convert_indexed_to_array
+>>> from sympy import Sum
+>>> A = ArraySymbol("A", (3, 3))
+>>> B = ArraySymbol("B", (3, 3))
+>>> convert_indexed_to_array(A[i, j], [i, j])
+A
+>>> convert_indexed_to_array(A[i, j], [j, i])
+PermuteDims(A, (0 1))
+>>> convert_indexed_to_array(A[i, j] + B[j, i], [i, j])
+ArrayAdd(A, PermuteDims(B, (0 1)))
+>>> convert_indexed_to_array(Sum(A[i, j]*B[j, k], (j, 0, 2)), [i, k])
+ArrayContraction(ArrayTensorProduct(A, B), (1, 2))
+
+The diagonal of a matrix in the array expression form:
+
+>>> convert_indexed_to_array(A[i, i], [i])
+ArrayDiagonal(A, (0, 1))
+
+The trace of a matrix in the array expression form:
+
+>>> convert_indexed_to_array(Sum(A[i, i], (i, 0, 2)), [i])
+ArrayContraction(A, (0, 1))
+
+Compatibility with matrices
+---------------------------
+
+Array expressions can be mixed with objects from the matrix module:
+
+>>> from sympy import MatrixSymbol
+>>> from sympy.tensor.array.expressions import ArrayContraction
+>>> M = MatrixSymbol("M", 3, 3)
+>>> N = MatrixSymbol("N", 3, 3)
+
+Express the matrix product in the array expression form:
+
+>>> from sympy.tensor.array.expressions import convert_matrix_to_array
+>>> expr = convert_matrix_to_array(M*N)
+>>> expr
+ArrayContraction(ArrayTensorProduct(M, N), (1, 2))
+
+The expression can be converted back to matrix form:
+
+>>> from sympy.tensor.array.expressions import convert_array_to_matrix
+>>> convert_array_to_matrix(expr)
+M*N
+
+Add a second contraction on the remaining axes in order to get the trace of `M \cdot N`:
+
+>>> expr_tr = ArrayContraction(expr, (0, 1))
+>>> expr_tr
+ArrayContraction(ArrayContraction(ArrayTensorProduct(M, N), (1, 2)), (0, 1))
+
+Flatten the expression by calling ``.doit()`` and remove the nested array contraction operations:
+
+>>> expr_tr.doit()
+ArrayContraction(ArrayTensorProduct(M, N), (0, 3), (1, 2))
+
+Get the explicit form of the array expression:
+
+>>> expr.as_explicit()
+[[M[0, 0]*N[0, 0] + M[0, 1]*N[1, 0] + M[0, 2]*N[2, 0], M[0, 0]*N[0, 1] + M[0, 1]*N[1, 1] + M[0, 2]*N[2, 1], M[0, 0]*N[0, 2] + M[0, 1]*N[1, 2] + M[0, 2]*N[2, 2]],
+ [M[1, 0]*N[0, 0] + M[1, 1]*N[1, 0] + M[1, 2]*N[2, 0], M[1, 0]*N[0, 1] + M[1, 1]*N[1, 1] + M[1, 2]*N[2, 1], M[1, 0]*N[0, 2] + M[1, 1]*N[1, 2] + M[1, 2]*N[2, 2]],
+ [M[2, 0]*N[0, 0] + M[2, 1]*N[1, 0] + M[2, 2]*N[2, 0], M[2, 0]*N[0, 1] + M[2, 1]*N[1, 1] + M[2, 2]*N[2, 1], M[2, 0]*N[0, 2] + M[2, 1]*N[1, 2] + M[2, 2]*N[2, 2]]]
+
+Express the trace of a matrix:
+
+>>> from sympy import Trace
+>>> convert_matrix_to_array(Trace(M))
+ArrayContraction(M, (0, 1))
+>>> convert_matrix_to_array(Trace(M*N))
+ArrayContraction(ArrayTensorProduct(M, N), (0, 3), (1, 2))
+
+Express the transposition of a matrix (will be expressed as a permutation of the axes:
+
+>>> convert_matrix_to_array(M.T)
+PermuteDims(M, (0 1))
+
+Compute the derivative array expressions:
+
+>>> from sympy.tensor.array.expressions import array_derive
+>>> d = array_derive(M, M)
+>>> d
+PermuteDims(ArrayTensorProduct(I, I), (3)(1 2))
+
+Verify that the derivative corresponds to the form computed with explicit matrices:
+
+>>> d.as_explicit()
+[[[[1, 0, 0], [0, 0, 0], [0, 0, 0]], [[0, 1, 0], [0, 0, 0], [0, 0, 0]], [[0, 0, 1], [0, 0, 0], [0, 0, 0]]], [[[0, 0, 0], [1, 0, 0], [0, 0, 0]], [[0, 0, 0], [0, 1, 0], [0, 0, 0]], [[0, 0, 0], [0, 0, 1], [0, 0, 0]]], [[[0, 0, 0], [0, 0, 0], [1, 0, 0]], [[0, 0, 0], [0, 0, 0], [0, 1, 0]], [[0, 0, 0], [0, 0, 0], [0, 0, 1]]]]
+>>> Me = M.as_explicit()
+>>> Me.diff(Me)
+[[[[1, 0, 0], [0, 0, 0], [0, 0, 0]], [[0, 1, 0], [0, 0, 0], [0, 0, 0]], [[0, 0, 1], [0, 0, 0], [0, 0, 0]]], [[[0, 0, 0], [1, 0, 0], [0, 0, 0]], [[0, 0, 0], [0, 1, 0], [0, 0, 0]], [[0, 0, 0], [0, 0, 1], [0, 0, 0]]], [[[0, 0, 0], [0, 0, 0], [1, 0, 0]], [[0, 0, 0], [0, 0, 0], [0, 1, 0]], [[0, 0, 0], [0, 0, 0], [0, 0, 1]]]]
+
+"""
+
+__all__ = [
+    "ArraySymbol", "ArrayElement", "ZeroArray", "OneArray",
+    "ArrayTensorProduct",
+    "ArrayContraction",
+    "ArrayDiagonal",
+    "PermuteDims",
+    "ArrayAdd",
+    "ArrayElementwiseApplyFunc",
+    "Reshape",
+    "convert_array_to_matrix",
+    "convert_matrix_to_array",
+    "convert_array_to_indexed",
+    "convert_indexed_to_array",
+    "array_derive",
+]
+
+from sympy.tensor.array.expressions.array_expressions import ArrayTensorProduct, ArrayAdd, PermuteDims, ArrayDiagonal, \
+    ArrayContraction, Reshape, ArraySymbol, ArrayElement, ZeroArray, OneArray, ArrayElementwiseApplyFunc
+from sympy.tensor.array.expressions.arrayexpr_derivatives import array_derive
+from sympy.tensor.array.expressions.from_array_to_indexed import convert_array_to_indexed
+from sympy.tensor.array.expressions.from_array_to_matrix import convert_array_to_matrix
+from sympy.tensor.array.expressions.from_indexed_to_array import convert_indexed_to_array
+from sympy.tensor.array.expressions.from_matrix_to_array import convert_matrix_to_array
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/expressions/__pycache__/__init__.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/expressions/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..21a8ef08a10a47195cb15e9ffc134fdb506ba73e
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/expressions/__pycache__/__init__.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/expressions/__pycache__/array_expressions.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/expressions/__pycache__/array_expressions.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a9842d92f5b7a1f8072dcfcf27c8e1ae82622657
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/expressions/__pycache__/array_expressions.cpython-312.pyc
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:174b0d79f4cdcc533fdd68f4714b00c1f52b5b2f6e8b24ffce6943accd5b74ee
+size 110682
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/expressions/__pycache__/arrayexpr_derivatives.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/expressions/__pycache__/arrayexpr_derivatives.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..9648ea277a481565194c97c62df78cafdfbdbed9
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/expressions/__pycache__/arrayexpr_derivatives.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/expressions/__pycache__/conv_array_to_indexed.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/expressions/__pycache__/conv_array_to_indexed.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c0c46051bb02330ade41c3ceba8ad885b94f5401
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/expressions/__pycache__/conv_array_to_indexed.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/expressions/__pycache__/conv_array_to_matrix.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/expressions/__pycache__/conv_array_to_matrix.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..2479fb181e746c0d60893e180e40888e9b5bf0e5
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/expressions/__pycache__/conv_array_to_matrix.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/expressions/__pycache__/conv_indexed_to_array.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/expressions/__pycache__/conv_indexed_to_array.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..be3aeb77a4ba720d40b921b62d4e807fae58240f
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/expressions/__pycache__/conv_indexed_to_array.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/expressions/__pycache__/conv_matrix_to_array.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/expressions/__pycache__/conv_matrix_to_array.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..26181e2d55dfb37e6f95bded6160ec424f2ecd8b
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/expressions/__pycache__/conv_matrix_to_array.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/expressions/__pycache__/from_array_to_indexed.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/expressions/__pycache__/from_array_to_indexed.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f451f9c1e744a9eb487ebd39f9ca078609beacce
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/expressions/__pycache__/from_array_to_indexed.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/expressions/__pycache__/from_array_to_matrix.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/expressions/__pycache__/from_array_to_matrix.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d620f7d4dc488c17113f00f0c419c2bb823bd31b
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/expressions/__pycache__/from_array_to_matrix.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/expressions/__pycache__/from_indexed_to_array.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/expressions/__pycache__/from_indexed_to_array.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..2f9f40f83ebad6e61f098d534e0db33942fe625b
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/expressions/__pycache__/from_indexed_to_array.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/expressions/__pycache__/from_matrix_to_array.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/expressions/__pycache__/from_matrix_to_array.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..be198b24626673af3dffea32083fbb89f18e1ff5
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/expressions/__pycache__/from_matrix_to_array.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/expressions/__pycache__/utils.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/expressions/__pycache__/utils.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c755b60f623dbc855e04bfb64a28e1d2b1b8fe68
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/expressions/__pycache__/utils.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/expressions/array_expressions.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/expressions/array_expressions.py
new file mode 100644
index 0000000000000000000000000000000000000000..f062e3de4c24987d62ba0b3a19fe474fb4687940
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/expressions/array_expressions.py
@@ -0,0 +1,1969 @@
+from __future__ import annotations
+import collections.abc
+import operator
+from collections import defaultdict, Counter
+from functools import reduce
+import itertools
+from itertools import accumulate
+
+import typing
+
+from sympy.core.numbers import Integer
+from sympy.core.relational import Equality
+from sympy.functions.special.tensor_functions import KroneckerDelta
+from sympy.core.basic import Basic
+from sympy.core.containers import Tuple
+from sympy.core.expr import Expr
+from sympy.core.function import (Function, Lambda)
+from sympy.core.mul import Mul
+from sympy.core.singleton import S
+from sympy.core.sorting import default_sort_key
+from sympy.core.symbol import (Dummy, Symbol)
+from sympy.matrices.matrixbase import MatrixBase
+from sympy.matrices.expressions.diagonal import diagonalize_vector
+from sympy.matrices.expressions.matexpr import MatrixExpr
+from sympy.matrices.expressions.special import ZeroMatrix
+from sympy.tensor.array.arrayop import (permutedims, tensorcontraction, tensordiagonal, tensorproduct)
+from sympy.tensor.array.dense_ndim_array import ImmutableDenseNDimArray
+from sympy.tensor.array.ndim_array import NDimArray
+from sympy.tensor.indexed import (Indexed, IndexedBase)
+from sympy.matrices.expressions.matexpr import MatrixElement
+from sympy.tensor.array.expressions.utils import _apply_recursively_over_nested_lists, _sort_contraction_indices, \
+    _get_mapping_from_subranks, _build_push_indices_up_func_transformation, _get_contraction_links, \
+    _build_push_indices_down_func_transformation
+from sympy.combinatorics import Permutation
+from sympy.combinatorics.permutations import _af_invert
+from sympy.core.sympify import _sympify
+
+
+class _ArrayExpr(Expr):
+    shape: tuple[Expr, ...]
+
+    def __getitem__(self, item):
+        if not isinstance(item, collections.abc.Iterable):
+            item = (item,)
+        ArrayElement._check_shape(self, item)
+        return self._get(item)
+
+    def _get(self, item):
+        return _get_array_element_or_slice(self, item)
+
+
+class ArraySymbol(_ArrayExpr):
+    """
+    Symbol representing an array expression
+    """
+
+    _iterable = False
+
+    def __new__(cls, symbol, shape: typing.Iterable) -> "ArraySymbol":
+        if isinstance(symbol, str):
+            symbol = Symbol(symbol)
+        # symbol = _sympify(symbol)
+        shape = Tuple(*map(_sympify, shape))
+        obj = Expr.__new__(cls, symbol, shape)
+        return obj
+
+    @property
+    def name(self):
+        return self._args[0]
+
+    @property
+    def shape(self):
+        return self._args[1]
+
+    def as_explicit(self):
+        if not all(i.is_Integer for i in self.shape):
+            raise ValueError("cannot express explicit array with symbolic shape")
+        data = [self[i] for i in itertools.product(*[range(j) for j in self.shape])]
+        return ImmutableDenseNDimArray(data).reshape(*self.shape)
+
+
+class ArrayElement(Expr):
+    """
+    An element of an array.
+    """
+
+    _diff_wrt = True
+    is_symbol = True
+    is_commutative = True
+
+    def __new__(cls, name, indices):
+        if isinstance(name, str):
+            name = Symbol(name)
+        name = _sympify(name)
+        if not isinstance(indices, collections.abc.Iterable):
+            indices = (indices,)
+        indices = _sympify(tuple(indices))
+        cls._check_shape(name, indices)
+        obj = Expr.__new__(cls, name, indices)
+        return obj
+
+    @classmethod
+    def _check_shape(cls, name, indices):
+        indices = tuple(indices)
+        if hasattr(name, "shape"):
+            index_error = IndexError("number of indices does not match shape of the array")
+            if len(indices) != len(name.shape):
+                raise index_error
+            if any((i >= s) == True for i, s in zip(indices, name.shape)):
+                raise ValueError("shape is out of bounds")
+        if any((i < 0) == True for i in indices):
+            raise ValueError("shape contains negative values")
+
+    @property
+    def name(self):
+        return self._args[0]
+
+    @property
+    def indices(self):
+        return self._args[1]
+
+    def _eval_derivative(self, s):
+        if not isinstance(s, ArrayElement):
+            return S.Zero
+
+        if s == self:
+            return S.One
+
+        if s.name != self.name:
+            return S.Zero
+
+        return Mul.fromiter(KroneckerDelta(i, j) for i, j in zip(self.indices, s.indices))
+
+
+class ZeroArray(_ArrayExpr):
+    """
+    Symbolic array of zeros. Equivalent to ``ZeroMatrix`` for matrices.
+    """
+
+    def __new__(cls, *shape):
+        if len(shape) == 0:
+            return S.Zero
+        shape = map(_sympify, shape)
+        obj = Expr.__new__(cls, *shape)
+        return obj
+
+    @property
+    def shape(self):
+        return self._args
+
+    def as_explicit(self):
+        if not all(i.is_Integer for i in self.shape):
+            raise ValueError("Cannot return explicit form for symbolic shape.")
+        return ImmutableDenseNDimArray.zeros(*self.shape)
+
+    def _get(self, item):
+        return S.Zero
+
+
+class OneArray(_ArrayExpr):
+    """
+    Symbolic array of ones.
+    """
+
+    def __new__(cls, *shape):
+        if len(shape) == 0:
+            return S.One
+        shape = map(_sympify, shape)
+        obj = Expr.__new__(cls, *shape)
+        return obj
+
+    @property
+    def shape(self):
+        return self._args
+
+    def as_explicit(self):
+        if not all(i.is_Integer for i in self.shape):
+            raise ValueError("Cannot return explicit form for symbolic shape.")
+        return ImmutableDenseNDimArray([S.One for i in range(reduce(operator.mul, self.shape))]).reshape(*self.shape)
+
+    def _get(self, item):
+        return S.One
+
+
+class _CodegenArrayAbstract(Basic):
+
+    @property
+    def subranks(self):
+        """
+        Returns the ranks of the objects in the uppermost tensor product inside
+        the current object.  In case no tensor products are contained, return
+        the atomic ranks.
+
+        Examples
+        ========
+
+        >>> from sympy.tensor.array import tensorproduct, tensorcontraction
+        >>> from sympy import MatrixSymbol
+        >>> M = MatrixSymbol("M", 3, 3)
+        >>> N = MatrixSymbol("N", 3, 3)
+        >>> P = MatrixSymbol("P", 3, 3)
+
+        Important: do not confuse the rank of the matrix with the rank of an array.
+
+        >>> tp = tensorproduct(M, N, P)
+        >>> tp.subranks
+        [2, 2, 2]
+
+        >>> co = tensorcontraction(tp, (1, 2), (3, 4))
+        >>> co.subranks
+        [2, 2, 2]
+        """
+        return self._subranks[:]
+
+    def subrank(self):
+        """
+        The sum of ``subranks``.
+        """
+        return sum(self.subranks)
+
+    @property
+    def shape(self):
+        return self._shape
+
+    def doit(self, **hints):
+        deep = hints.get("deep", True)
+        if deep:
+            return self.func(*[arg.doit(**hints) for arg in self.args])._canonicalize()
+        else:
+            return self._canonicalize()
+
+class ArrayTensorProduct(_CodegenArrayAbstract):
+    r"""
+    Class to represent the tensor product of array-like objects.
+    """
+
+    def __new__(cls, *args, **kwargs):
+        args = [_sympify(arg) for arg in args]
+
+        canonicalize = kwargs.pop("canonicalize", False)
+
+        ranks = [get_rank(arg) for arg in args]
+
+        obj = Basic.__new__(cls, *args)
+        obj._subranks = ranks
+        shapes = [get_shape(i) for i in args]
+
+        if any(i is None for i in shapes):
+            obj._shape = None
+        else:
+            obj._shape = tuple(j for i in shapes for j in i)
+        if canonicalize:
+            return obj._canonicalize()
+        return obj
+
+    def _canonicalize(self):
+        args = self.args
+        args = self._flatten(args)
+
+        ranks = [get_rank(arg) for arg in args]
+
+        # Check if there are nested permutation and lift them up:
+        permutation_cycles = []
+        for i, arg in enumerate(args):
+            if not isinstance(arg, PermuteDims):
+                continue
+            permutation_cycles.extend([[k + sum(ranks[:i]) for k in j] for j in arg.permutation.cyclic_form])
+            args[i] = arg.expr
+        if permutation_cycles:
+            return _permute_dims(_array_tensor_product(*args), Permutation(sum(ranks)-1)*Permutation(permutation_cycles))
+
+        if len(args) == 1:
+            return args[0]
+
+        # If any object is a ZeroArray, return a ZeroArray:
+        if any(isinstance(arg, (ZeroArray, ZeroMatrix)) for arg in args):
+            shapes = reduce(operator.add, [get_shape(i) for i in args], ())
+            return ZeroArray(*shapes)
+
+        # If there are contraction objects inside, transform the whole
+        # expression into `ArrayContraction`:
+        contractions = {i: arg for i, arg in enumerate(args) if isinstance(arg, ArrayContraction)}
+        if contractions:
+            ranks = [_get_subrank(arg) if isinstance(arg, ArrayContraction) else get_rank(arg) for arg in args]
+            cumulative_ranks = list(accumulate([0] + ranks))[:-1]
+            tp = _array_tensor_product(*[arg.expr if isinstance(arg, ArrayContraction) else arg for arg in args])
+            contraction_indices = [tuple(cumulative_ranks[i] + k for k in j) for i, arg in contractions.items() for j in arg.contraction_indices]
+            return _array_contraction(tp, *contraction_indices)
+
+        diagonals = {i: arg for i, arg in enumerate(args) if isinstance(arg, ArrayDiagonal)}
+        if diagonals:
+            inverse_permutation = []
+            last_perm = []
+            ranks = [get_rank(arg) for arg in args]
+            cumulative_ranks = list(accumulate([0] + ranks))[:-1]
+            for i, arg in enumerate(args):
+                if isinstance(arg, ArrayDiagonal):
+                    i1 = get_rank(arg) - len(arg.diagonal_indices)
+                    i2 = len(arg.diagonal_indices)
+                    inverse_permutation.extend([cumulative_ranks[i] + j for j in range(i1)])
+                    last_perm.extend([cumulative_ranks[i] + j for j in range(i1, i1 + i2)])
+                else:
+                    inverse_permutation.extend([cumulative_ranks[i] + j for j in range(get_rank(arg))])
+            inverse_permutation.extend(last_perm)
+            tp = _array_tensor_product(*[arg.expr if isinstance(arg, ArrayDiagonal) else arg for arg in args])
+            ranks2 = [_get_subrank(arg) if isinstance(arg, ArrayDiagonal) else get_rank(arg) for arg in args]
+            cumulative_ranks2 = list(accumulate([0] + ranks2))[:-1]
+            diagonal_indices = [tuple(cumulative_ranks2[i] + k for k in j) for i, arg in diagonals.items() for j in arg.diagonal_indices]
+            return _permute_dims(_array_diagonal(tp, *diagonal_indices), _af_invert(inverse_permutation))
+
+        return self.func(*args, canonicalize=False)
+
+    @classmethod
+    def _flatten(cls, args):
+        args = [i for arg in args for i in (arg.args if isinstance(arg, cls) else [arg])]
+        return args
+
+    def as_explicit(self):
+        return tensorproduct(*[arg.as_explicit() if hasattr(arg, "as_explicit") else arg for arg in self.args])
+
+
+class ArrayAdd(_CodegenArrayAbstract):
+    r"""
+    Class for elementwise array additions.
+    """
+
+    def __new__(cls, *args, **kwargs):
+        args = [_sympify(arg) for arg in args]
+        ranks = [get_rank(arg) for arg in args]
+        ranks = list(set(ranks))
+        if len(ranks) != 1:
+            raise ValueError("summing arrays of different ranks")
+        shapes = [arg.shape for arg in args]
+        if len({i for i in shapes if i is not None}) > 1:
+            raise ValueError("mismatching shapes in addition")
+
+        canonicalize = kwargs.pop("canonicalize", False)
+
+        obj = Basic.__new__(cls, *args)
+        obj._subranks = ranks
+        if any(i is None for i in shapes):
+            obj._shape = None
+        else:
+            obj._shape = shapes[0]
+        if canonicalize:
+            return obj._canonicalize()
+        return obj
+
+    def _canonicalize(self):
+        args = self.args
+
+        # Flatten:
+        args = self._flatten_args(args)
+
+        shapes = [get_shape(arg) for arg in args]
+        args = [arg for arg in args if not isinstance(arg, (ZeroArray, ZeroMatrix))]
+        if len(args) == 0:
+            if any(i for i in shapes if i is None):
+                raise NotImplementedError("cannot handle addition of ZeroMatrix/ZeroArray and undefined shape object")
+            return ZeroArray(*shapes[0])
+        elif len(args) == 1:
+            return args[0]
+        return self.func(*args, canonicalize=False)
+
+    @classmethod
+    def _flatten_args(cls, args):
+        new_args = []
+        for arg in args:
+            if isinstance(arg, ArrayAdd):
+                new_args.extend(arg.args)
+            else:
+                new_args.append(arg)
+        return new_args
+
+    def as_explicit(self):
+        return reduce(
+            operator.add,
+            [arg.as_explicit() if hasattr(arg, "as_explicit") else arg for arg in self.args])
+
+
+class PermuteDims(_CodegenArrayAbstract):
+    r"""
+    Class to represent permutation of axes of arrays.
+
+    Examples
+    ========
+
+    >>> from sympy.tensor.array import permutedims
+    >>> from sympy import MatrixSymbol
+    >>> M = MatrixSymbol("M", 3, 3)
+    >>> cg = permutedims(M, [1, 0])
+
+    The object ``cg`` represents the transposition of ``M``, as the permutation
+    ``[1, 0]`` will act on its indices by switching them:
+
+    `M_{ij} \Rightarrow M_{ji}`
+
+    This is evident when transforming back to matrix form:
+
+    >>> from sympy.tensor.array.expressions.from_array_to_matrix import convert_array_to_matrix
+    >>> convert_array_to_matrix(cg)
+    M.T
+
+    >>> N = MatrixSymbol("N", 3, 2)
+    >>> cg = permutedims(N, [1, 0])
+    >>> cg.shape
+    (2, 3)
+
+    There are optional parameters that can be used as alternative to the permutation:
+
+    >>> from sympy.tensor.array.expressions import ArraySymbol, PermuteDims
+    >>> M = ArraySymbol("M", (1, 2, 3, 4, 5))
+    >>> expr = PermuteDims(M, index_order_old="ijklm", index_order_new="kijml")
+    >>> expr
+    PermuteDims(M, (0 2 1)(3 4))
+    >>> expr.shape
+    (3, 1, 2, 5, 4)
+
+    Permutations of tensor products are simplified in order to achieve a
+    standard form:
+
+    >>> from sympy.tensor.array import tensorproduct
+    >>> M = MatrixSymbol("M", 4, 5)
+    >>> tp = tensorproduct(M, N)
+    >>> tp.shape
+    (4, 5, 3, 2)
+    >>> perm1 = permutedims(tp, [2, 3, 1, 0])
+
+    The args ``(M, N)`` have been sorted and the permutation has been
+    simplified, the expression is equivalent:
+
+    >>> perm1.expr.args
+    (N, M)
+    >>> perm1.shape
+    (3, 2, 5, 4)
+    >>> perm1.permutation
+    (2 3)
+
+    The permutation in its array form has been simplified from
+    ``[2, 3, 1, 0]`` to ``[0, 1, 3, 2]``, as the arguments of the tensor
+    product `M` and `N` have been switched:
+
+    >>> perm1.permutation.array_form
+    [0, 1, 3, 2]
+
+    We can nest a second permutation:
+
+    >>> perm2 = permutedims(perm1, [1, 0, 2, 3])
+    >>> perm2.shape
+    (2, 3, 5, 4)
+    >>> perm2.permutation.array_form
+    [1, 0, 3, 2]
+    """
+
+    def __new__(cls, expr, permutation=None, index_order_old=None, index_order_new=None, **kwargs):
+        from sympy.combinatorics import Permutation
+        expr = _sympify(expr)
+        expr_rank = get_rank(expr)
+        permutation = cls._get_permutation_from_arguments(permutation, index_order_old, index_order_new, expr_rank)
+        permutation = Permutation(permutation)
+        permutation_size = permutation.size
+        if permutation_size != expr_rank:
+            raise ValueError("Permutation size must be the length of the shape of expr")
+
+        canonicalize = kwargs.pop("canonicalize", False)
+
+        obj = Basic.__new__(cls, expr, permutation)
+        obj._subranks = [get_rank(expr)]
+        shape = get_shape(expr)
+        if shape is None:
+            obj._shape = None
+        else:
+            obj._shape = tuple(shape[permutation(i)] for i in range(len(shape)))
+        if canonicalize:
+            return obj._canonicalize()
+        return obj
+
+    def _canonicalize(self):
+        expr = self.expr
+        permutation = self.permutation
+        if isinstance(expr, PermuteDims):
+            subexpr = expr.expr
+            subperm = expr.permutation
+            permutation = permutation * subperm
+            expr = subexpr
+        if isinstance(expr, ArrayContraction):
+            expr, permutation = self._PermuteDims_denestarg_ArrayContraction(expr, permutation)
+        if isinstance(expr, ArrayTensorProduct):
+            expr, permutation = self._PermuteDims_denestarg_ArrayTensorProduct(expr, permutation)
+        if isinstance(expr, (ZeroArray, ZeroMatrix)):
+            return ZeroArray(*[expr.shape[i] for i in permutation.array_form])
+        plist = permutation.array_form
+        if plist == sorted(plist):
+            return expr
+        return self.func(expr, permutation, canonicalize=False)
+
+    @property
+    def expr(self):
+        return self.args[0]
+
+    @property
+    def permutation(self):
+        return self.args[1]
+
+    @classmethod
+    def _PermuteDims_denestarg_ArrayTensorProduct(cls, expr, permutation):
+        # Get the permutation in its image-form:
+        perm_image_form = _af_invert(permutation.array_form)
+        args = list(expr.args)
+        # Starting index global position for every arg:
+        cumul = list(accumulate([0] + expr.subranks))
+        # Split `perm_image_form` into a list of list corresponding to the indices
+        # of every argument:
+        perm_image_form_in_components = [perm_image_form[cumul[i]:cumul[i+1]] for i in range(len(args))]
+        # Create an index, target-position-key array:
+        ps = [(i, sorted(comp)) for i, comp in enumerate(perm_image_form_in_components)]
+        # Sort the array according to the target-position-key:
+        # In this way, we define a canonical way to sort the arguments according
+        # to the permutation.
+        ps.sort(key=lambda x: x[1])
+        # Read the inverse-permutation (i.e. image-form) of the args:
+        perm_args_image_form = [i[0] for i in ps]
+        # Apply the args-permutation to the `args`:
+        args_sorted = [args[i] for i in perm_args_image_form]
+        # Apply the args-permutation to the array-form of the permutation of the axes (of `expr`):
+        perm_image_form_sorted_args = [perm_image_form_in_components[i] for i in perm_args_image_form]
+        new_permutation = Permutation(_af_invert([j for i in perm_image_form_sorted_args for j in i]))
+        return _array_tensor_product(*args_sorted), new_permutation
+
+    @classmethod
+    def _PermuteDims_denestarg_ArrayContraction(cls, expr, permutation):
+        if not isinstance(expr, ArrayContraction):
+            return expr, permutation
+        if not isinstance(expr.expr, ArrayTensorProduct):
+            return expr, permutation
+        args = expr.expr.args
+        subranks = [get_rank(arg) for arg in expr.expr.args]
+
+        contraction_indices = expr.contraction_indices
+        contraction_indices_flat = [j for i in contraction_indices for j in i]
+        cumul = list(accumulate([0] + subranks))
+
+        # Spread the permutation in its array form across the args in the corresponding
+        # tensor-product arguments with free indices:
+        permutation_array_blocks_up = []
+        image_form = _af_invert(permutation.array_form)
+        counter = 0
+        for i in range(len(subranks)):
+            current = []
+            for j in range(cumul[i], cumul[i+1]):
+                if j in contraction_indices_flat:
+                    continue
+                current.append(image_form[counter])
+                counter += 1
+            permutation_array_blocks_up.append(current)
+
+        # Get the map of axis repositioning for every argument of tensor-product:
+        index_blocks = [list(range(cumul[i], cumul[i+1])) for i, e in enumerate(expr.subranks)]
+        index_blocks_up = expr._push_indices_up(expr.contraction_indices, index_blocks)
+        inverse_permutation = permutation**(-1)
+        index_blocks_up_permuted = [[inverse_permutation(j) for j in i if j is not None] for i in index_blocks_up]
+
+        # Sorting key is a list of tuple, first element is the index of `args`, second element of
+        # the tuple is the sorting key to sort `args` of the tensor product:
+        sorting_keys = list(enumerate(index_blocks_up_permuted))
+        sorting_keys.sort(key=lambda x: x[1])
+
+        # Now we can get the permutation acting on the args in its image-form:
+        new_perm_image_form = [i[0] for i in sorting_keys]
+        # Apply the args-level permutation to various elements:
+        new_index_blocks = [index_blocks[i] for i in new_perm_image_form]
+        new_index_perm_array_form = _af_invert([j for i in new_index_blocks for j in i])
+        new_args = [args[i] for i in new_perm_image_form]
+        new_contraction_indices = [tuple(new_index_perm_array_form[j] for j in i) for i in contraction_indices]
+        new_expr = _array_contraction(_array_tensor_product(*new_args), *new_contraction_indices)
+        new_permutation = Permutation(_af_invert([j for i in [permutation_array_blocks_up[k] for k in new_perm_image_form] for j in i]))
+        return new_expr, new_permutation
+
+    @classmethod
+    def _check_permutation_mapping(cls, expr, permutation):
+        subranks = expr.subranks
+        index2arg = [i for i, arg in enumerate(expr.args) for j in range(expr.subranks[i])]
+        permuted_indices = [permutation(i) for i in range(expr.subrank())]
+        new_args = list(expr.args)
+        arg_candidate_index = index2arg[permuted_indices[0]]
+        current_indices = []
+        new_permutation = []
+        inserted_arg_cand_indices = set()
+        for i, idx in enumerate(permuted_indices):
+            if index2arg[idx] != arg_candidate_index:
+                new_permutation.extend(current_indices)
+                current_indices = []
+                arg_candidate_index = index2arg[idx]
+            current_indices.append(idx)
+            arg_candidate_rank = subranks[arg_candidate_index]
+            if len(current_indices) == arg_candidate_rank:
+                new_permutation.extend(sorted(current_indices))
+                local_current_indices = [j - min(current_indices) for j in current_indices]
+                i1 = index2arg[i]
+                new_args[i1] = _permute_dims(new_args[i1], Permutation(local_current_indices))
+                inserted_arg_cand_indices.add(arg_candidate_index)
+                current_indices = []
+        new_permutation.extend(current_indices)
+
+        # TODO: swap args positions in order to simplify the expression:
+        # TODO: this should be in a function
+        args_positions = list(range(len(new_args)))
+        # Get possible shifts:
+        maps = {}
+        cumulative_subranks = [0] + list(accumulate(subranks))
+        for i in range(len(subranks)):
+            s = {index2arg[new_permutation[j]] for j in range(cumulative_subranks[i], cumulative_subranks[i+1])}
+            if len(s) != 1:
+                continue
+            elem = next(iter(s))
+            if i != elem:
+                maps[i] = elem
+
+        # Find cycles in the map:
+        lines = []
+        current_line = []
+        while maps:
+            if len(current_line) == 0:
+                k, v = maps.popitem()
+                current_line.append(k)
+            else:
+                k = current_line[-1]
+                if k not in maps:
+                    current_line = []
+                    continue
+                v = maps.pop(k)
+            if v in current_line:
+                lines.append(current_line)
+                current_line = []
+                continue
+            current_line.append(v)
+        for line in lines:
+            for i, e in enumerate(line):
+                args_positions[line[(i + 1) % len(line)]] = e
+
+        # TODO: function in order to permute the args:
+        permutation_blocks = [[new_permutation[cumulative_subranks[i] + j] for j in range(e)] for i, e in enumerate(subranks)]
+        new_args = [new_args[i] for i in args_positions]
+        new_permutation_blocks = [permutation_blocks[i] for i in args_positions]
+        new_permutation2 = [j for i in new_permutation_blocks for j in i]
+        return _array_tensor_product(*new_args), Permutation(new_permutation2)  # **(-1)
+
+    @classmethod
+    def _check_if_there_are_closed_cycles(cls, expr, permutation):
+        args = list(expr.args)
+        subranks = expr.subranks
+        cyclic_form = permutation.cyclic_form
+        cumulative_subranks = [0] + list(accumulate(subranks))
+        cyclic_min = [min(i) for i in cyclic_form]
+        cyclic_max = [max(i) for i in cyclic_form]
+        cyclic_keep = []
+        for i, cycle in enumerate(cyclic_form):
+            flag = True
+            for j in range(len(cumulative_subranks) - 1):
+                if cyclic_min[i] >= cumulative_subranks[j] and cyclic_max[i] < cumulative_subranks[j+1]:
+                    # Found a sinkable cycle.
+                    args[j] = _permute_dims(args[j], Permutation([[k - cumulative_subranks[j] for k in cycle]]))
+                    flag = False
+                    break
+            if flag:
+                cyclic_keep.append(cycle)
+        return _array_tensor_product(*args), Permutation(cyclic_keep, size=permutation.size)
+
+    def nest_permutation(self):
+        r"""
+        DEPRECATED.
+        """
+        ret = self._nest_permutation(self.expr, self.permutation)
+        if ret is None:
+            return self
+        return ret
+
+    @classmethod
+    def _nest_permutation(cls, expr, permutation):
+        if isinstance(expr, ArrayTensorProduct):
+            return _permute_dims(*cls._check_if_there_are_closed_cycles(expr, permutation))
+        elif isinstance(expr, ArrayContraction):
+            # Invert tree hierarchy: put the contraction above.
+            cycles = permutation.cyclic_form
+            newcycles = ArrayContraction._convert_outer_indices_to_inner_indices(expr, *cycles)
+            newpermutation = Permutation(newcycles)
+            new_contr_indices = [tuple(newpermutation(j) for j in i) for i in expr.contraction_indices]
+            return _array_contraction(PermuteDims(expr.expr, newpermutation), *new_contr_indices)
+        elif isinstance(expr, ArrayAdd):
+            return _array_add(*[PermuteDims(arg, permutation) for arg in expr.args])
+        return None
+
+    def as_explicit(self):
+        expr = self.expr
+        if hasattr(expr, "as_explicit"):
+            expr = expr.as_explicit()
+        return permutedims(expr, self.permutation)
+
+    @classmethod
+    def _get_permutation_from_arguments(cls, permutation, index_order_old, index_order_new, dim):
+        if permutation is None:
+            if index_order_new is None or index_order_old is None:
+                raise ValueError("Permutation not defined")
+            return PermuteDims._get_permutation_from_index_orders(index_order_old, index_order_new, dim)
+        else:
+            if index_order_new is not None:
+                raise ValueError("index_order_new cannot be defined with permutation")
+            if index_order_old is not None:
+                raise ValueError("index_order_old cannot be defined with permutation")
+            return permutation
+
+    @classmethod
+    def _get_permutation_from_index_orders(cls, index_order_old, index_order_new, dim):
+        if len(set(index_order_new)) != dim:
+            raise ValueError("wrong number of indices in index_order_new")
+        if len(set(index_order_old)) != dim:
+            raise ValueError("wrong number of indices in index_order_old")
+        if len(set.symmetric_difference(set(index_order_new), set(index_order_old))) > 0:
+            raise ValueError("index_order_new and index_order_old must have the same indices")
+        permutation = [index_order_old.index(i) for i in index_order_new]
+        return permutation
+
+
+class ArrayDiagonal(_CodegenArrayAbstract):
+    r"""
+    Class to represent the diagonal operator.
+
+    Explanation
+    ===========
+
+    In a 2-dimensional array it returns the diagonal, this looks like the
+    operation:
+
+    `A_{ij} \rightarrow A_{ii}`
+
+    The diagonal over axes 1 and 2 (the second and third) of the tensor product
+    of two 2-dimensional arrays `A \otimes B` is
+
+    `\Big[ A_{ab} B_{cd} \Big]_{abcd} \rightarrow \Big[ A_{ai} B_{id} \Big]_{adi}`
+
+    In this last example the array expression has been reduced from
+    4-dimensional to 3-dimensional. Notice that no contraction has occurred,
+    rather there is a new index `i` for the diagonal, contraction would have
+    reduced the array to 2 dimensions.
+
+    Notice that the diagonalized out dimensions are added as new dimensions at
+    the end of the indices.
+    """
+
+    def __new__(cls, expr, *diagonal_indices, **kwargs):
+        expr = _sympify(expr)
+        diagonal_indices = [Tuple(*sorted(i)) for i in diagonal_indices]
+        canonicalize = kwargs.get("canonicalize", False)
+
+        shape = get_shape(expr)
+        if shape is not None:
+            cls._validate(expr, *diagonal_indices, **kwargs)
+            # Get new shape:
+            positions, shape = cls._get_positions_shape(shape, diagonal_indices)
+        else:
+            positions = None
+        if len(diagonal_indices) == 0:
+            return expr
+        obj = Basic.__new__(cls, expr, *diagonal_indices)
+        obj._positions = positions
+        obj._subranks = _get_subranks(expr)
+        obj._shape = shape
+        if canonicalize:
+            return obj._canonicalize()
+        return obj
+
+    def _canonicalize(self):
+        expr = self.expr
+        diagonal_indices = self.diagonal_indices
+        trivial_diags = [i for i in diagonal_indices if len(i) == 1]
+        if len(trivial_diags) > 0:
+            trivial_pos = {e[0]: i for i, e in enumerate(diagonal_indices) if len(e) == 1}
+            diag_pos = {e: i for i, e in enumerate(diagonal_indices) if len(e) > 1}
+            diagonal_indices_short = [i for i in diagonal_indices if len(i) > 1]
+            rank1 = get_rank(self)
+            rank2 = len(diagonal_indices)
+            rank3 = rank1 - rank2
+            inv_permutation = []
+            counter1 = 0
+            indices_down = ArrayDiagonal._push_indices_down(diagonal_indices_short, list(range(rank1)), get_rank(expr))
+            for i in indices_down:
+                if i in trivial_pos:
+                    inv_permutation.append(rank3 + trivial_pos[i])
+                elif isinstance(i, (Integer, int)):
+                    inv_permutation.append(counter1)
+                    counter1 += 1
+                else:
+                    inv_permutation.append(rank3 + diag_pos[i])
+            permutation = _af_invert(inv_permutation)
+            if len(diagonal_indices_short) > 0:
+                return _permute_dims(_array_diagonal(expr, *diagonal_indices_short), permutation)
+            else:
+                return _permute_dims(expr, permutation)
+        if isinstance(expr, ArrayAdd):
+            return self._ArrayDiagonal_denest_ArrayAdd(expr, *diagonal_indices)
+        if isinstance(expr, ArrayDiagonal):
+            return self._ArrayDiagonal_denest_ArrayDiagonal(expr, *diagonal_indices)
+        if isinstance(expr, PermuteDims):
+            return self._ArrayDiagonal_denest_PermuteDims(expr, *diagonal_indices)
+        if isinstance(expr, (ZeroArray, ZeroMatrix)):
+            positions, shape = self._get_positions_shape(expr.shape, diagonal_indices)
+            return ZeroArray(*shape)
+        return self.func(expr, *diagonal_indices, canonicalize=False)
+
+    @staticmethod
+    def _validate(expr, *diagonal_indices, **kwargs):
+        # Check that no diagonalization happens on indices with mismatched
+        # dimensions:
+        shape = get_shape(expr)
+        for i in diagonal_indices:
+            if any(j >= len(shape) for j in i):
+                raise ValueError("index is larger than expression shape")
+            if len({shape[j] for j in i}) != 1:
+                raise ValueError("diagonalizing indices of different dimensions")
+            if not kwargs.get("allow_trivial_diags", False) and len(i) <= 1:
+                raise ValueError("need at least two axes to diagonalize")
+            if len(set(i)) != len(i):
+                raise ValueError("axis index cannot be repeated")
+
+    @staticmethod
+    def _remove_trivial_dimensions(shape, *diagonal_indices):
+        return [tuple(j for j in i) for i in diagonal_indices if shape[i[0]] != 1]
+
+    @property
+    def expr(self):
+        return self.args[0]
+
+    @property
+    def diagonal_indices(self):
+        return self.args[1:]
+
+    @staticmethod
+    def _flatten(expr, *outer_diagonal_indices):
+        inner_diagonal_indices = expr.diagonal_indices
+        all_inner = [j for i in inner_diagonal_indices for j in i]
+        all_inner.sort()
+        # TODO: add API for total rank and cumulative rank:
+        total_rank = _get_subrank(expr)
+        inner_rank = len(all_inner)
+        outer_rank = total_rank - inner_rank
+        shifts = [0 for i in range(outer_rank)]
+        counter = 0
+        pointer = 0
+        for i in range(outer_rank):
+            while pointer < inner_rank and counter >= all_inner[pointer]:
+                counter += 1
+                pointer += 1
+            shifts[i] += pointer
+            counter += 1
+        outer_diagonal_indices = tuple(tuple(shifts[j] + j for j in i) for i in outer_diagonal_indices)
+        diagonal_indices = inner_diagonal_indices + outer_diagonal_indices
+        return _array_diagonal(expr.expr, *diagonal_indices)
+
+    @classmethod
+    def _ArrayDiagonal_denest_ArrayAdd(cls, expr, *diagonal_indices):
+        return _array_add(*[_array_diagonal(arg, *diagonal_indices) for arg in expr.args])
+
+    @classmethod
+    def _ArrayDiagonal_denest_ArrayDiagonal(cls, expr, *diagonal_indices):
+        return cls._flatten(expr, *diagonal_indices)
+
+    @classmethod
+    def _ArrayDiagonal_denest_PermuteDims(cls, expr: PermuteDims, *diagonal_indices):
+        back_diagonal_indices = [[expr.permutation(j) for j in i] for i in diagonal_indices]
+        nondiag = [i for i in range(get_rank(expr)) if not any(i in j for j in diagonal_indices)]
+        back_nondiag = [expr.permutation(i) for i in nondiag]
+        remap = {e: i for i, e in enumerate(sorted(back_nondiag))}
+        new_permutation1 = [remap[i] for i in back_nondiag]
+        shift = len(new_permutation1)
+        diag_block_perm = [i + shift for i in range(len(back_diagonal_indices))]
+        new_permutation = new_permutation1 + diag_block_perm
+        return _permute_dims(
+            _array_diagonal(
+                expr.expr,
+                *back_diagonal_indices
+            ),
+            new_permutation
+        )
+
+    def _push_indices_down_nonstatic(self, indices):
+        transform = lambda x: self._positions[x] if x < len(self._positions) else None
+        return _apply_recursively_over_nested_lists(transform, indices)
+
+    def _push_indices_up_nonstatic(self, indices):
+
+        def transform(x):
+            for i, e in enumerate(self._positions):
+                if (isinstance(e, int) and x == e) or (isinstance(e, tuple) and x in e):
+                    return i
+
+        return _apply_recursively_over_nested_lists(transform, indices)
+
+    @classmethod
+    def _push_indices_down(cls, diagonal_indices, indices, rank):
+        positions, shape = cls._get_positions_shape(range(rank), diagonal_indices)
+        transform = lambda x: positions[x] if x < len(positions) else None
+        return _apply_recursively_over_nested_lists(transform, indices)
+
+    @classmethod
+    def _push_indices_up(cls, diagonal_indices, indices, rank):
+        positions, shape = cls._get_positions_shape(range(rank), diagonal_indices)
+
+        def transform(x):
+            for i, e in enumerate(positions):
+                if (isinstance(e, int) and x == e) or (isinstance(e, (tuple, Tuple)) and (x in e)):
+                    return i
+
+        return _apply_recursively_over_nested_lists(transform, indices)
+
+    @classmethod
+    def _get_positions_shape(cls, shape, diagonal_indices):
+        data1 = tuple((i, shp) for i, shp in enumerate(shape) if not any(i in j for j in diagonal_indices))
+        pos1, shp1 = zip(*data1) if data1 else ((), ())
+        data2 = tuple((i, shape[i[0]]) for i in diagonal_indices)
+        pos2, shp2 = zip(*data2) if data2 else ((), ())
+        positions = pos1 + pos2
+        shape = shp1 + shp2
+        return positions, shape
+
+    def as_explicit(self):
+        expr = self.expr
+        if hasattr(expr, "as_explicit"):
+            expr = expr.as_explicit()
+        return tensordiagonal(expr, *self.diagonal_indices)
+
+
+class ArrayElementwiseApplyFunc(_CodegenArrayAbstract):
+
+    def __new__(cls, function, element):
+
+        if not isinstance(function, Lambda):
+            d = Dummy('d')
+            function = Lambda(d, function(d))
+
+        obj = _CodegenArrayAbstract.__new__(cls, function, element)
+        obj._subranks = _get_subranks(element)
+        return obj
+
+    @property
+    def function(self):
+        return self.args[0]
+
+    @property
+    def expr(self):
+        return self.args[1]
+
+    @property
+    def shape(self):
+        return self.expr.shape
+
+    def _get_function_fdiff(self):
+        d = Dummy("d")
+        function = self.function(d)
+        fdiff = function.diff(d)
+        if isinstance(fdiff, Function):
+            fdiff = type(fdiff)
+        else:
+            fdiff = Lambda(d, fdiff)
+        return fdiff
+
+    def as_explicit(self):
+        expr = self.expr
+        if hasattr(expr, "as_explicit"):
+            expr = expr.as_explicit()
+        return expr.applyfunc(self.function)
+
+
+class ArrayContraction(_CodegenArrayAbstract):
+    r"""
+    This class is meant to represent contractions of arrays in a form easily
+    processable by the code printers.
+    """
+
+    def __new__(cls, expr, *contraction_indices, **kwargs):
+        contraction_indices = _sort_contraction_indices(contraction_indices)
+        expr = _sympify(expr)
+
+        canonicalize = kwargs.get("canonicalize", False)
+
+        obj = Basic.__new__(cls, expr, *contraction_indices)
+        obj._subranks = _get_subranks(expr)
+        obj._mapping = _get_mapping_from_subranks(obj._subranks)
+
+        free_indices_to_position = {i: i for i in range(sum(obj._subranks)) if all(i not in cind for cind in contraction_indices)}
+        obj._free_indices_to_position = free_indices_to_position
+
+        shape = get_shape(expr)
+        cls._validate(expr, *contraction_indices)
+        if shape:
+            shape = tuple(shp for i, shp in enumerate(shape) if not any(i in j for j in contraction_indices))
+        obj._shape = shape
+        if canonicalize:
+            return obj._canonicalize()
+        return obj
+
+    def _canonicalize(self):
+        expr = self.expr
+        contraction_indices = self.contraction_indices
+
+        if len(contraction_indices) == 0:
+            return expr
+
+        if isinstance(expr, ArrayContraction):
+            return self._ArrayContraction_denest_ArrayContraction(expr, *contraction_indices)
+
+        if isinstance(expr, (ZeroArray, ZeroMatrix)):
+            return self._ArrayContraction_denest_ZeroArray(expr, *contraction_indices)
+
+        if isinstance(expr, PermuteDims):
+            return self._ArrayContraction_denest_PermuteDims(expr, *contraction_indices)
+
+        if isinstance(expr, ArrayTensorProduct):
+            expr, contraction_indices = self._sort_fully_contracted_args(expr, contraction_indices)
+            expr, contraction_indices = self._lower_contraction_to_addends(expr, contraction_indices)
+            if len(contraction_indices) == 0:
+                return expr
+
+        if isinstance(expr, ArrayDiagonal):
+            return self._ArrayContraction_denest_ArrayDiagonal(expr, *contraction_indices)
+
+        if isinstance(expr, ArrayAdd):
+            return self._ArrayContraction_denest_ArrayAdd(expr, *contraction_indices)
+
+        # Check single index contractions on 1-dimensional axes:
+        contraction_indices = [i for i in contraction_indices if len(i) > 1 or get_shape(expr)[i[0]] != 1]
+        if len(contraction_indices) == 0:
+            return expr
+
+        return self.func(expr, *contraction_indices, canonicalize=False)
+
+    def __mul__(self, other):
+        if other == 1:
+            return self
+        else:
+            raise NotImplementedError("Product of N-dim arrays is not uniquely defined. Use another method.")
+
+    def __rmul__(self, other):
+        if other == 1:
+            return self
+        else:
+            raise NotImplementedError("Product of N-dim arrays is not uniquely defined. Use another method.")
+
+    @staticmethod
+    def _validate(expr, *contraction_indices):
+        shape = get_shape(expr)
+        if shape is None:
+            return
+
+        # Check that no contraction happens when the shape is mismatched:
+        for i in contraction_indices:
+            if len({shape[j] for j in i if shape[j] != -1}) != 1:
+                raise ValueError("contracting indices of different dimensions")
+
+    @classmethod
+    def _push_indices_down(cls, contraction_indices, indices):
+        flattened_contraction_indices = [j for i in contraction_indices for j in i]
+        flattened_contraction_indices.sort()
+        transform = _build_push_indices_down_func_transformation(flattened_contraction_indices)
+        return _apply_recursively_over_nested_lists(transform, indices)
+
+    @classmethod
+    def _push_indices_up(cls, contraction_indices, indices):
+        flattened_contraction_indices = [j for i in contraction_indices for j in i]
+        flattened_contraction_indices.sort()
+        transform = _build_push_indices_up_func_transformation(flattened_contraction_indices)
+        return _apply_recursively_over_nested_lists(transform, indices)
+
+    @classmethod
+    def _lower_contraction_to_addends(cls, expr, contraction_indices):
+        if isinstance(expr, ArrayAdd):
+            raise NotImplementedError()
+        if not isinstance(expr, ArrayTensorProduct):
+            return expr, contraction_indices
+        subranks = expr.subranks
+        cumranks = list(accumulate([0] + subranks))
+        contraction_indices_remaining = []
+        contraction_indices_args = [[] for i in expr.args]
+        backshift = set()
+        for contraction_group in contraction_indices:
+            for j in range(len(expr.args)):
+                if not isinstance(expr.args[j], ArrayAdd):
+                    continue
+                if all(cumranks[j] <= k < cumranks[j+1] for k in contraction_group):
+                    contraction_indices_args[j].append([k - cumranks[j] for k in contraction_group])
+                    backshift.update(contraction_group)
+                    break
+            else:
+                contraction_indices_remaining.append(contraction_group)
+        if len(contraction_indices_remaining) == len(contraction_indices):
+            return expr, contraction_indices
+        total_rank = get_rank(expr)
+        shifts = list(accumulate([1 if i in backshift else 0 for i in range(total_rank)]))
+        contraction_indices_remaining = [Tuple.fromiter(j - shifts[j] for j in i) for i in contraction_indices_remaining]
+        ret = _array_tensor_product(*[
+            _array_contraction(arg, *contr) for arg, contr in zip(expr.args, contraction_indices_args)
+        ])
+        return ret, contraction_indices_remaining
+
+    def split_multiple_contractions(self):
+        """
+        Recognize multiple contractions and attempt at rewriting them as paired-contractions.
+
+        This allows some contractions involving more than two indices to be
+        rewritten as multiple contractions involving two indices, thus allowing
+        the expression to be rewritten as a matrix multiplication line.
+
+        Examples:
+
+        * `A_ij b_j0 C_jk` ===> `A*DiagMatrix(b)*C`
+
+        Care for:
+        - matrix being diagonalized (i.e. `A_ii`)
+        - vectors being diagonalized (i.e. `a_i0`)
+
+        Multiple contractions can be split into matrix multiplications if
+        not more than two arguments are non-diagonals or non-vectors.
+        Vectors get diagonalized while diagonal matrices remain diagonal.
+        The non-diagonal matrices can be at the beginning or at the end
+        of the final matrix multiplication line.
+        """
+
+        editor = _EditArrayContraction(self)
+
+        contraction_indices = self.contraction_indices
+
+        onearray_insert = []
+
+        for indl, links in enumerate(contraction_indices):
+            if len(links) <= 2:
+                continue
+
+            # Check multiple contractions:
+            #
+            # Examples:
+            #
+            # * `A_ij b_j0 C_jk` ===> `A*DiagMatrix(b)*C \otimes OneArray(1)` with permutation (1 2)
+            #
+            # Care for:
+            # - matrix being diagonalized (i.e. `A_ii`)
+            # - vectors being diagonalized (i.e. `a_i0`)
+
+            # Multiple contractions can be split into matrix multiplications if
+            # not more than three arguments are non-diagonals or non-vectors.
+            #
+            # Vectors get diagonalized while diagonal matrices remain diagonal.
+            # The non-diagonal matrices can be at the beginning or at the end
+            # of the final matrix multiplication line.
+
+            positions = editor.get_mapping_for_index(indl)
+
+            # Also consider the case of diagonal matrices being contracted:
+            current_dimension = self.expr.shape[links[0]]
+
+            not_vectors = []
+            vectors = []
+            for arg_ind, rel_ind in positions:
+                arg = editor.args_with_ind[arg_ind]
+                mat = arg.element
+                abs_arg_start, abs_arg_end = editor.get_absolute_range(arg)
+                other_arg_pos = 1-rel_ind
+                other_arg_abs = abs_arg_start + other_arg_pos
+                if ((1 not in mat.shape) or
+                    ((current_dimension == 1) is True and mat.shape != (1, 1)) or
+                    any(other_arg_abs in l for li, l in enumerate(contraction_indices) if li != indl)
+                ):
+                    not_vectors.append((arg, rel_ind))
+                else:
+                    vectors.append((arg, rel_ind))
+            if len(not_vectors) > 2:
+                # If more than two arguments in the multiple contraction are
+                # non-vectors and non-diagonal matrices, we cannot find a way
+                # to split this contraction into a matrix multiplication line:
+                continue
+            # Three cases to handle:
+            # - zero non-vectors
+            # - one non-vector
+            # - two non-vectors
+            for v, rel_ind in vectors:
+                v.element = diagonalize_vector(v.element)
+            vectors_to_loop = not_vectors[:1] + vectors + not_vectors[1:]
+            first_not_vector, rel_ind = vectors_to_loop[0]
+            new_index = first_not_vector.indices[rel_ind]
+
+            for v, rel_ind in vectors_to_loop[1:-1]:
+                v.indices[rel_ind] = new_index
+                new_index = editor.get_new_contraction_index()
+                assert v.indices.index(None) == 1 - rel_ind
+                v.indices[v.indices.index(None)] = new_index
+                onearray_insert.append(v)
+
+            last_vec, rel_ind = vectors_to_loop[-1]
+            last_vec.indices[rel_ind] = new_index
+
+        for v in onearray_insert:
+            editor.insert_after(v, _ArgE(OneArray(1), [None]))
+
+        return editor.to_array_contraction()
+
+    def flatten_contraction_of_diagonal(self):
+        if not isinstance(self.expr, ArrayDiagonal):
+            return self
+        contraction_down = self.expr._push_indices_down(self.expr.diagonal_indices, self.contraction_indices)
+        new_contraction_indices = []
+        diagonal_indices = self.expr.diagonal_indices[:]
+        for i in contraction_down:
+            contraction_group = list(i)
+            for j in i:
+                diagonal_with = [k for k in diagonal_indices if j in k]
+                contraction_group.extend([l for k in diagonal_with for l in k])
+                diagonal_indices = [k for k in diagonal_indices if k not in diagonal_with]
+            new_contraction_indices.append(sorted(set(contraction_group)))
+
+        new_contraction_indices = ArrayDiagonal._push_indices_up(diagonal_indices, new_contraction_indices)
+        return _array_contraction(
+            _array_diagonal(
+                self.expr.expr,
+                *diagonal_indices
+            ),
+            *new_contraction_indices
+        )
+
+    @staticmethod
+    def _get_free_indices_to_position_map(free_indices, contraction_indices):
+        free_indices_to_position = {}
+        flattened_contraction_indices = [j for i in contraction_indices for j in i]
+        counter = 0
+        for ind in free_indices:
+            while counter in flattened_contraction_indices:
+                counter += 1
+            free_indices_to_position[ind] = counter
+            counter += 1
+        return free_indices_to_position
+
+    @staticmethod
+    def _get_index_shifts(expr):
+        """
+        Get the mapping of indices at the positions before the contraction
+        occurs.
+
+        Examples
+        ========
+
+        >>> from sympy.tensor.array import tensorproduct, tensorcontraction
+        >>> from sympy import MatrixSymbol
+        >>> M = MatrixSymbol("M", 3, 3)
+        >>> N = MatrixSymbol("N", 3, 3)
+        >>> cg = tensorcontraction(tensorproduct(M, N), [1, 2])
+        >>> cg._get_index_shifts(cg)
+        [0, 2]
+
+        Indeed, ``cg`` after the contraction has two dimensions, 0 and 1. They
+        need to be shifted by 0 and 2 to get the corresponding positions before
+        the contraction (that is, 0 and 3).
+        """
+        inner_contraction_indices = expr.contraction_indices
+        all_inner = [j for i in inner_contraction_indices for j in i]
+        all_inner.sort()
+        # TODO: add API for total rank and cumulative rank:
+        total_rank = _get_subrank(expr)
+        inner_rank = len(all_inner)
+        outer_rank = total_rank - inner_rank
+        shifts = [0 for i in range(outer_rank)]
+        counter = 0
+        pointer = 0
+        for i in range(outer_rank):
+            while pointer < inner_rank and counter >= all_inner[pointer]:
+                counter += 1
+                pointer += 1
+            shifts[i] += pointer
+            counter += 1
+        return shifts
+
+    @staticmethod
+    def _convert_outer_indices_to_inner_indices(expr, *outer_contraction_indices):
+        shifts = ArrayContraction._get_index_shifts(expr)
+        outer_contraction_indices = tuple(tuple(shifts[j] + j for j in i) for i in outer_contraction_indices)
+        return outer_contraction_indices
+
+    @staticmethod
+    def _flatten(expr, *outer_contraction_indices):
+        inner_contraction_indices = expr.contraction_indices
+        outer_contraction_indices = ArrayContraction._convert_outer_indices_to_inner_indices(expr, *outer_contraction_indices)
+        contraction_indices = inner_contraction_indices + outer_contraction_indices
+        return _array_contraction(expr.expr, *contraction_indices)
+
+    @classmethod
+    def _ArrayContraction_denest_ArrayContraction(cls, expr, *contraction_indices):
+        return cls._flatten(expr, *contraction_indices)
+
+    @classmethod
+    def _ArrayContraction_denest_ZeroArray(cls, expr, *contraction_indices):
+        contraction_indices_flat = [j for i in contraction_indices for j in i]
+        shape = [e for i, e in enumerate(expr.shape) if i not in contraction_indices_flat]
+        return ZeroArray(*shape)
+
+    @classmethod
+    def _ArrayContraction_denest_ArrayAdd(cls, expr, *contraction_indices):
+        return _array_add(*[_array_contraction(i, *contraction_indices) for i in expr.args])
+
+    @classmethod
+    def _ArrayContraction_denest_PermuteDims(cls, expr, *contraction_indices):
+        permutation = expr.permutation
+        plist = permutation.array_form
+        new_contraction_indices = [tuple(permutation(j) for j in i) for i in contraction_indices]
+        new_plist = [i for i in plist if not any(i in j for j in new_contraction_indices)]
+        new_plist = cls._push_indices_up(new_contraction_indices, new_plist)
+        return _permute_dims(
+            _array_contraction(expr.expr, *new_contraction_indices),
+            Permutation(new_plist)
+        )
+
+    @classmethod
+    def _ArrayContraction_denest_ArrayDiagonal(cls, expr: 'ArrayDiagonal', *contraction_indices):
+        diagonal_indices = list(expr.diagonal_indices)
+        down_contraction_indices = expr._push_indices_down(expr.diagonal_indices, contraction_indices, get_rank(expr.expr))
+        # Flatten diagonally contracted indices:
+        down_contraction_indices = [[k for j in i for k in (j if isinstance(j, (tuple, Tuple)) else [j])] for i in down_contraction_indices]
+        new_contraction_indices = []
+        for contr_indgrp in down_contraction_indices:
+            ind = contr_indgrp[:]
+            for j, diag_indgrp in enumerate(diagonal_indices):
+                if diag_indgrp is None:
+                    continue
+                if any(i in diag_indgrp for i in contr_indgrp):
+                    ind.extend(diag_indgrp)
+                    diagonal_indices[j] = None
+            new_contraction_indices.append(sorted(set(ind)))
+
+        new_diagonal_indices_down = [i for i in diagonal_indices if i is not None]
+        new_diagonal_indices = ArrayContraction._push_indices_up(new_contraction_indices, new_diagonal_indices_down)
+        return _array_diagonal(
+            _array_contraction(expr.expr, *new_contraction_indices),
+            *new_diagonal_indices
+        )
+
+    @classmethod
+    def _sort_fully_contracted_args(cls, expr, contraction_indices):
+        if expr.shape is None:
+            return expr, contraction_indices
+        cumul = list(accumulate([0] + expr.subranks))
+        index_blocks = [list(range(cumul[i], cumul[i+1])) for i in range(len(expr.args))]
+        contraction_indices_flat = {j for i in contraction_indices for j in i}
+        fully_contracted = [all(j in contraction_indices_flat for j in range(cumul[i], cumul[i+1])) for i, arg in enumerate(expr.args)]
+        new_pos = sorted(range(len(expr.args)), key=lambda x: (0, default_sort_key(expr.args[x])) if fully_contracted[x] else (1,))
+        new_args = [expr.args[i] for i in new_pos]
+        new_index_blocks_flat = [j for i in new_pos for j in index_blocks[i]]
+        index_permutation_array_form = _af_invert(new_index_blocks_flat)
+        new_contraction_indices = [tuple(index_permutation_array_form[j] for j in i) for i in contraction_indices]
+        new_contraction_indices = _sort_contraction_indices(new_contraction_indices)
+        return _array_tensor_product(*new_args), new_contraction_indices
+
+    def _get_contraction_tuples(self):
+        r"""
+        Return tuples containing the argument index and position within the
+        argument of the index position.
+
+        Examples
+        ========
+
+        >>> from sympy import MatrixSymbol
+        >>> from sympy.abc import N
+        >>> from sympy.tensor.array import tensorproduct, tensorcontraction
+        >>> A = MatrixSymbol("A", N, N)
+        >>> B = MatrixSymbol("B", N, N)
+
+        >>> cg = tensorcontraction(tensorproduct(A, B), (1, 2))
+        >>> cg._get_contraction_tuples()
+        [[(0, 1), (1, 0)]]
+
+        Notes
+        =====
+
+        Here the contraction pair `(1, 2)` meaning that the 2nd and 3rd indices
+        of the tensor product `A\otimes B` are contracted, has been transformed
+        into `(0, 1)` and `(1, 0)`, identifying the same indices in a different
+        notation. `(0, 1)` is the second index (1) of the first argument (i.e.
+                0 or `A`). `(1, 0)` is the first index (i.e. 0) of the second
+        argument (i.e. 1 or `B`).
+        """
+        mapping = self._mapping
+        return [[mapping[j] for j in i] for i in self.contraction_indices]
+
+    @staticmethod
+    def _contraction_tuples_to_contraction_indices(expr, contraction_tuples):
+        # TODO: check that `expr` has `.subranks`:
+        ranks = expr.subranks
+        cumulative_ranks = [0] + list(accumulate(ranks))
+        return [tuple(cumulative_ranks[j]+k for j, k in i) for i in contraction_tuples]
+
+    @property
+    def free_indices(self):
+        return self._free_indices[:]
+
+    @property
+    def free_indices_to_position(self):
+        return dict(self._free_indices_to_position)
+
+    @property
+    def expr(self):
+        return self.args[0]
+
+    @property
+    def contraction_indices(self):
+        return self.args[1:]
+
+    def _contraction_indices_to_components(self):
+        expr = self.expr
+        if not isinstance(expr, ArrayTensorProduct):
+            raise NotImplementedError("only for contractions of tensor products")
+        ranks = expr.subranks
+        mapping = {}
+        counter = 0
+        for i, rank in enumerate(ranks):
+            for j in range(rank):
+                mapping[counter] = (i, j)
+                counter += 1
+        return mapping
+
+    def sort_args_by_name(self):
+        """
+        Sort arguments in the tensor product so that their order is lexicographical.
+
+        Examples
+        ========
+
+        >>> from sympy.tensor.array.expressions.from_matrix_to_array import convert_matrix_to_array
+        >>> from sympy import MatrixSymbol
+        >>> from sympy.abc import N
+        >>> A = MatrixSymbol("A", N, N)
+        >>> B = MatrixSymbol("B", N, N)
+        >>> C = MatrixSymbol("C", N, N)
+        >>> D = MatrixSymbol("D", N, N)
+
+        >>> cg = convert_matrix_to_array(C*D*A*B)
+        >>> cg
+        ArrayContraction(ArrayTensorProduct(A, D, C, B), (0, 3), (1, 6), (2, 5))
+        >>> cg.sort_args_by_name()
+        ArrayContraction(ArrayTensorProduct(A, D, B, C), (0, 3), (1, 4), (2, 7))
+        """
+        expr = self.expr
+        if not isinstance(expr, ArrayTensorProduct):
+            return self
+        args = expr.args
+        sorted_data = sorted(enumerate(args), key=lambda x: default_sort_key(x[1]))
+        pos_sorted, args_sorted = zip(*sorted_data)
+        reordering_map = {i: pos_sorted.index(i) for i, arg in enumerate(args)}
+        contraction_tuples = self._get_contraction_tuples()
+        contraction_tuples = [[(reordering_map[j], k) for j, k in i] for i in contraction_tuples]
+        c_tp = _array_tensor_product(*args_sorted)
+        new_contr_indices = self._contraction_tuples_to_contraction_indices(
+                c_tp,
+                contraction_tuples
+        )
+        return _array_contraction(c_tp, *new_contr_indices)
+
+    def _get_contraction_links(self):
+        r"""
+        Returns a dictionary of links between arguments in the tensor product
+        being contracted.
+
+        See the example for an explanation of the values.
+
+        Examples
+        ========
+
+        >>> from sympy import MatrixSymbol
+        >>> from sympy.abc import N
+        >>> from sympy.tensor.array.expressions.from_matrix_to_array import convert_matrix_to_array
+        >>> A = MatrixSymbol("A", N, N)
+        >>> B = MatrixSymbol("B", N, N)
+        >>> C = MatrixSymbol("C", N, N)
+        >>> D = MatrixSymbol("D", N, N)
+
+        Matrix multiplications are pairwise contractions between neighboring
+        matrices:
+
+        `A_{ij} B_{jk} C_{kl} D_{lm}`
+
+        >>> cg = convert_matrix_to_array(A*B*C*D)
+        >>> cg
+        ArrayContraction(ArrayTensorProduct(B, C, A, D), (0, 5), (1, 2), (3, 6))
+
+        >>> cg._get_contraction_links()
+        {0: {0: (2, 1), 1: (1, 0)}, 1: {0: (0, 1), 1: (3, 0)}, 2: {1: (0, 0)}, 3: {0: (1, 1)}}
+
+        This dictionary is interpreted as follows: argument in position 0 (i.e.
+        matrix `A`) has its second index (i.e. 1) contracted to `(1, 0)`, that
+        is argument in position 1 (matrix `B`) on the first index slot of `B`,
+        this is the contraction provided by the index `j` from `A`.
+
+        The argument in position 1 (that is, matrix `B`) has two contractions,
+        the ones provided by the indices `j` and `k`, respectively the first
+        and second indices (0 and 1 in the sub-dict).  The link `(0, 1)` and
+        `(2, 0)` respectively. `(0, 1)` is the index slot 1 (the 2nd) of
+        argument in position 0 (that is, `A_{\ldot j}`), and so on.
+        """
+        args, dlinks = _get_contraction_links([self], self.subranks, *self.contraction_indices)
+        return dlinks
+
+    def as_explicit(self):
+        expr = self.expr
+        if hasattr(expr, "as_explicit"):
+            expr = expr.as_explicit()
+        return tensorcontraction(expr, *self.contraction_indices)
+
+
+class Reshape(_CodegenArrayAbstract):
+    """
+    Reshape the dimensions of an array expression.
+
+    Examples
+    ========
+
+    >>> from sympy.tensor.array.expressions import ArraySymbol, Reshape
+    >>> A = ArraySymbol("A", (6,))
+    >>> A.shape
+    (6,)
+    >>> Reshape(A, (3, 2)).shape
+    (3, 2)
+
+    Check the component-explicit forms:
+
+    >>> A.as_explicit()
+    [A[0], A[1], A[2], A[3], A[4], A[5]]
+    >>> Reshape(A, (3, 2)).as_explicit()
+    [[A[0], A[1]], [A[2], A[3]], [A[4], A[5]]]
+
+    """
+
+    def __new__(cls, expr, shape):
+        expr = _sympify(expr)
+        if not isinstance(shape, Tuple):
+            shape = Tuple(*shape)
+        if Equality(Mul.fromiter(expr.shape), Mul.fromiter(shape)) == False:
+            raise ValueError("shape mismatch")
+        obj = Expr.__new__(cls, expr, shape)
+        obj._shape = tuple(shape)
+        obj._expr = expr
+        return obj
+
+    @property
+    def shape(self):
+        return self._shape
+
+    @property
+    def expr(self):
+        return self._expr
+
+    def doit(self, *args, **kwargs):
+        if kwargs.get("deep", True):
+            expr = self.expr.doit(*args, **kwargs)
+        else:
+            expr = self.expr
+        if isinstance(expr, (MatrixBase, NDimArray)):
+            return expr.reshape(*self.shape)
+        return Reshape(expr, self.shape)
+
+    def as_explicit(self):
+        ee = self.expr
+        if hasattr(ee, "as_explicit"):
+            ee = ee.as_explicit()
+        if isinstance(ee, MatrixBase):
+            from sympy import Array
+            ee = Array(ee)
+        elif isinstance(ee, MatrixExpr):
+            return self
+        return ee.reshape(*self.shape)
+
+
+class _ArgE:
+    """
+    The ``_ArgE`` object contains references to the array expression
+    (``.element``) and a list containing the information about index
+    contractions (``.indices``).
+
+    Index contractions are numbered and contracted indices show the number of
+    the contraction. Uncontracted indices have ``None`` value.
+
+    For example:
+    ``_ArgE(M, [None, 3])``
+    This object means that expression ``M`` is part of an array contraction
+    and has two indices, the first is not contracted (value ``None``),
+    the second index is contracted to the 4th (i.e. number ``3``) group of the
+    array contraction object.
+    """
+    indices: list[int | None]
+
+    def __init__(self, element, indices: list[int | None] | None = None):
+        self.element = element
+        if indices is None:
+            self.indices = [None for i in range(get_rank(element))]
+        else:
+            self.indices = indices
+
+    def __str__(self):
+        return "_ArgE(%s, %s)" % (self.element, self.indices)
+
+    __repr__ = __str__
+
+
+class _IndPos:
+    """
+    Index position, requiring two integers in the constructor:
+
+    - arg: the position of the argument in the tensor product,
+    - rel: the relative position of the index inside the argument.
+    """
+    def __init__(self, arg: int, rel: int):
+        self.arg = arg
+        self.rel = rel
+
+    def __str__(self):
+        return "_IndPos(%i, %i)" % (self.arg, self.rel)
+
+    __repr__ = __str__
+
+    def __iter__(self):
+        yield from [self.arg, self.rel]
+
+
+class _EditArrayContraction:
+    """
+    Utility class to help manipulate array contraction objects.
+
+    This class takes as input an ``ArrayContraction`` object and turns it into
+    an editable object.
+
+    The field ``args_with_ind`` of this class is a list of ``_ArgE`` objects
+    which can be used to easily edit the contraction structure of the
+    expression.
+
+    Once editing is finished, the ``ArrayContraction`` object may be recreated
+    by calling the ``.to_array_contraction()`` method.
+    """
+
+    def __init__(self, base_array: typing.Union[ArrayContraction, ArrayDiagonal, ArrayTensorProduct]):
+
+        expr: Basic
+        diagonalized: tuple[tuple[int, ...], ...]
+        contraction_indices: list[tuple[int]]
+        if isinstance(base_array, ArrayContraction):
+            mapping = _get_mapping_from_subranks(base_array.subranks)
+            expr = base_array.expr
+            contraction_indices = base_array.contraction_indices
+            diagonalized = ()
+        elif isinstance(base_array, ArrayDiagonal):
+
+            if isinstance(base_array.expr, ArrayContraction):
+                mapping = _get_mapping_from_subranks(base_array.expr.subranks)
+                expr = base_array.expr.expr
+                diagonalized = ArrayContraction._push_indices_down(base_array.expr.contraction_indices, base_array.diagonal_indices)
+                contraction_indices = base_array.expr.contraction_indices
+            elif isinstance(base_array.expr, ArrayTensorProduct):
+                mapping = {}
+                expr = base_array.expr
+                diagonalized = base_array.diagonal_indices
+                contraction_indices = []
+            else:
+                mapping = {}
+                expr = base_array.expr
+                diagonalized = base_array.diagonal_indices
+                contraction_indices = []
+
+        elif isinstance(base_array, ArrayTensorProduct):
+            expr = base_array
+            contraction_indices = []
+            diagonalized = ()
+        else:
+            raise NotImplementedError()
+
+        if isinstance(expr, ArrayTensorProduct):
+            args = list(expr.args)
+        else:
+            args = [expr]
+
+        args_with_ind: list[_ArgE] = [_ArgE(arg) for arg in args]
+        for i, contraction_tuple in enumerate(contraction_indices):
+            for j in contraction_tuple:
+                arg_pos, rel_pos = mapping[j]
+                args_with_ind[arg_pos].indices[rel_pos] = i
+        self.args_with_ind: list[_ArgE] = args_with_ind
+        self.number_of_contraction_indices: int = len(contraction_indices)
+        self._track_permutation: list[list[int]] | None = None
+
+        mapping = _get_mapping_from_subranks(base_array.subranks)
+
+        # Trick: add diagonalized indices as negative indices into the editor object:
+        for i, e in enumerate(diagonalized):
+            for j in e:
+                arg_pos, rel_pos = mapping[j]
+                self.args_with_ind[arg_pos].indices[rel_pos] = -1 - i
+
+    def insert_after(self, arg: _ArgE, new_arg: _ArgE):
+        pos = self.args_with_ind.index(arg)
+        self.args_with_ind.insert(pos + 1, new_arg)
+
+    def get_new_contraction_index(self):
+        self.number_of_contraction_indices += 1
+        return self.number_of_contraction_indices - 1
+
+    def refresh_indices(self):
+        updates = {}
+        for arg_with_ind in self.args_with_ind:
+            updates.update({i: -1 for i in arg_with_ind.indices if i is not None})
+        for i, e in enumerate(sorted(updates)):
+            updates[e] = i
+        self.number_of_contraction_indices = len(updates)
+        for arg_with_ind in self.args_with_ind:
+            arg_with_ind.indices = [updates.get(i, None) for i in arg_with_ind.indices]
+
+    def merge_scalars(self):
+        scalars = []
+        for arg_with_ind in self.args_with_ind:
+            if len(arg_with_ind.indices) == 0:
+                scalars.append(arg_with_ind)
+        for i in scalars:
+            self.args_with_ind.remove(i)
+        scalar = Mul.fromiter([i.element for i in scalars])
+        if len(self.args_with_ind) == 0:
+            self.args_with_ind.append(_ArgE(scalar))
+        else:
+            from sympy.tensor.array.expressions.from_array_to_matrix import _a2m_tensor_product
+            self.args_with_ind[0].element = _a2m_tensor_product(scalar, self.args_with_ind[0].element)
+
+    def to_array_contraction(self):
+
+        # Count the ranks of the arguments:
+        counter = 0
+        # Create a collector for the new diagonal indices:
+        diag_indices = defaultdict(list)
+
+        count_index_freq = Counter()
+        for arg_with_ind in self.args_with_ind:
+            count_index_freq.update(Counter(arg_with_ind.indices))
+
+        free_index_count = count_index_freq[None]
+
+        # Construct the inverse permutation:
+        inv_perm1 = []
+        inv_perm2 = []
+        # Keep track of which diagonal indices have already been processed:
+        done = set()
+
+        # Counter for the diagonal indices:
+        counter4 = 0
+
+        for arg_with_ind in self.args_with_ind:
+            # If some diagonalization axes have been removed, they should be
+            # permuted in order to keep the permutation.
+            # Add permutation here
+            counter2 = 0  # counter for the indices
+            for i in arg_with_ind.indices:
+                if i is None:
+                    inv_perm1.append(counter4)
+                    counter2 += 1
+                    counter4 += 1
+                    continue
+                if i >= 0:
+                    continue
+                # Reconstruct the diagonal indices:
+                diag_indices[-1 - i].append(counter + counter2)
+                if count_index_freq[i] == 1 and i not in done:
+                    inv_perm1.append(free_index_count - 1 - i)
+                    done.add(i)
+                elif i not in done:
+                    inv_perm2.append(free_index_count - 1 - i)
+                    done.add(i)
+                counter2 += 1
+            # Remove negative indices to restore a proper editor object:
+            arg_with_ind.indices = [i if i is not None and i >= 0 else None for i in arg_with_ind.indices]
+            counter += len([i for i in arg_with_ind.indices if i is None or i < 0])
+
+        inverse_permutation = inv_perm1 + inv_perm2
+        permutation = _af_invert(inverse_permutation)
+
+        # Get the diagonal indices after the detection of HadamardProduct in the expression:
+        diag_indices_filtered = [tuple(v) for v in diag_indices.values() if len(v) > 1]
+
+        self.merge_scalars()
+        self.refresh_indices()
+        args = [arg.element for arg in self.args_with_ind]
+        contraction_indices = self.get_contraction_indices()
+        expr = _array_contraction(_array_tensor_product(*args), *contraction_indices)
+        expr2 = _array_diagonal(expr, *diag_indices_filtered)
+        if self._track_permutation is not None:
+            permutation2 = _af_invert([j for i in self._track_permutation for j in i])
+            expr2 = _permute_dims(expr2, permutation2)
+
+        expr3 = _permute_dims(expr2, permutation)
+        return expr3
+
+    def get_contraction_indices(self) -> list[list[int]]:
+        contraction_indices: list[list[int]] = [[] for i in range(self.number_of_contraction_indices)]
+        current_position: int = 0
+        for arg_with_ind in self.args_with_ind:
+            for j in arg_with_ind.indices:
+                if j is not None:
+                    contraction_indices[j].append(current_position)
+                current_position += 1
+        return contraction_indices
+
+    def get_mapping_for_index(self, ind) -> list[_IndPos]:
+        if ind >= self.number_of_contraction_indices:
+            raise ValueError("index value exceeding the index range")
+        positions: list[_IndPos] = []
+        for i, arg_with_ind in enumerate(self.args_with_ind):
+            for j, arg_ind in enumerate(arg_with_ind.indices):
+                if ind == arg_ind:
+                    positions.append(_IndPos(i, j))
+        return positions
+
+    def get_contraction_indices_to_ind_rel_pos(self) -> list[list[_IndPos]]:
+        contraction_indices: list[list[_IndPos]] = [[] for i in range(self.number_of_contraction_indices)]
+        for i, arg_with_ind in enumerate(self.args_with_ind):
+            for j, ind in enumerate(arg_with_ind.indices):
+                if ind is not None:
+                    contraction_indices[ind].append(_IndPos(i, j))
+        return contraction_indices
+
+    def count_args_with_index(self, index: int) -> int:
+        """
+        Count the number of arguments that have the given index.
+        """
+        counter: int = 0
+        for arg_with_ind in self.args_with_ind:
+            if index in arg_with_ind.indices:
+                counter += 1
+        return counter
+
+    def get_args_with_index(self, index: int) -> list[_ArgE]:
+        """
+        Get a list of arguments having the given index.
+        """
+        ret: list[_ArgE] = [i for i in self.args_with_ind if index in i.indices]
+        return ret
+
+    @property
+    def number_of_diagonal_indices(self):
+        data = set()
+        for arg in self.args_with_ind:
+            data.update({i for i in arg.indices if i is not None and i < 0})
+        return len(data)
+
+    def track_permutation_start(self):
+        permutation = []
+        perm_diag = []
+        counter = 0
+        counter2 = -1
+        for arg_with_ind in self.args_with_ind:
+            perm = []
+            for i in arg_with_ind.indices:
+                if i is not None:
+                    if i < 0:
+                        perm_diag.append(counter2)
+                        counter2 -= 1
+                    continue
+                perm.append(counter)
+                counter += 1
+            permutation.append(perm)
+        max_ind = max(max(i) if i else -1 for i in permutation) if permutation else -1
+        perm_diag = [max_ind - i for i in perm_diag]
+        self._track_permutation = permutation + [perm_diag]
+
+    def track_permutation_merge(self, destination: _ArgE, from_element: _ArgE):
+        index_destination = self.args_with_ind.index(destination)
+        index_element = self.args_with_ind.index(from_element)
+        self._track_permutation[index_destination].extend(self._track_permutation[index_element]) # type: ignore
+        self._track_permutation.pop(index_element) # type: ignore
+
+    def get_absolute_free_range(self, arg: _ArgE) -> typing.Tuple[int, int]:
+        """
+        Return the range of the free indices of the arg as absolute positions
+        among all free indices.
+        """
+        counter = 0
+        for arg_with_ind in self.args_with_ind:
+            number_free_indices = len([i for i in arg_with_ind.indices if i is None])
+            if arg_with_ind == arg:
+                return counter, counter + number_free_indices
+            counter += number_free_indices
+        raise IndexError("argument not found")
+
+    def get_absolute_range(self, arg: _ArgE) -> typing.Tuple[int, int]:
+        """
+        Return the absolute range of indices for arg, disregarding dummy
+        indices.
+        """
+        counter = 0
+        for arg_with_ind in self.args_with_ind:
+            number_indices = len(arg_with_ind.indices)
+            if arg_with_ind == arg:
+                return counter, counter + number_indices
+            counter += number_indices
+        raise IndexError("argument not found")
+
+
+def get_rank(expr):
+    if isinstance(expr, (MatrixExpr, MatrixElement)):
+        return 2
+    if isinstance(expr, _CodegenArrayAbstract):
+        return len(expr.shape)
+    if isinstance(expr, NDimArray):
+        return expr.rank()
+    if isinstance(expr, Indexed):
+        return expr.rank
+    if isinstance(expr, IndexedBase):
+        shape = expr.shape
+        if shape is None:
+            return -1
+        else:
+            return len(shape)
+    if hasattr(expr, "shape"):
+        return len(expr.shape)
+    return 0
+
+
+def _get_subrank(expr):
+    if isinstance(expr, _CodegenArrayAbstract):
+        return expr.subrank()
+    return get_rank(expr)
+
+
+def _get_subranks(expr):
+    if isinstance(expr, _CodegenArrayAbstract):
+        return expr.subranks
+    else:
+        return [get_rank(expr)]
+
+
+def get_shape(expr):
+    if hasattr(expr, "shape"):
+        return expr.shape
+    return ()
+
+
+def nest_permutation(expr):
+    if isinstance(expr, PermuteDims):
+        return expr.nest_permutation()
+    else:
+        return expr
+
+
+def _array_tensor_product(*args, **kwargs):
+    return ArrayTensorProduct(*args, canonicalize=True, **kwargs)
+
+
+def _array_contraction(expr, *contraction_indices, **kwargs):
+    return ArrayContraction(expr, *contraction_indices, canonicalize=True, **kwargs)
+
+
+def _array_diagonal(expr, *diagonal_indices, **kwargs):
+    return ArrayDiagonal(expr, *diagonal_indices, canonicalize=True, **kwargs)
+
+
+def _permute_dims(expr, permutation, **kwargs):
+    return PermuteDims(expr, permutation, canonicalize=True, **kwargs)
+
+
+def _array_add(*args, **kwargs):
+    return ArrayAdd(*args, canonicalize=True, **kwargs)
+
+
+def _get_array_element_or_slice(expr, indices):
+    return ArrayElement(expr, indices)
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/expressions/arrayexpr_derivatives.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/expressions/arrayexpr_derivatives.py
new file mode 100644
index 0000000000000000000000000000000000000000..ab44a6fbf715ac7f2b8c287dcc84a49289f2dd76
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/expressions/arrayexpr_derivatives.py
@@ -0,0 +1,194 @@
+import operator
+from functools import reduce, singledispatch
+
+from sympy.core.expr import Expr
+from sympy.core.singleton import S
+from sympy.matrices.expressions.hadamard import HadamardProduct
+from sympy.matrices.expressions.inverse import Inverse
+from sympy.matrices.expressions.matexpr import (MatrixExpr, MatrixSymbol)
+from sympy.matrices.expressions.special import Identity, OneMatrix
+from sympy.matrices.expressions.transpose import Transpose
+from sympy.combinatorics.permutations import _af_invert
+from sympy.matrices.expressions.applyfunc import ElementwiseApplyFunction
+from sympy.tensor.array.expressions.array_expressions import (
+    _ArrayExpr, ZeroArray, ArraySymbol, ArrayTensorProduct, ArrayAdd,
+    PermuteDims, ArrayDiagonal, ArrayElementwiseApplyFunc, get_rank,
+    get_shape, ArrayContraction, _array_tensor_product, _array_contraction,
+    _array_diagonal, _array_add, _permute_dims, Reshape)
+from sympy.tensor.array.expressions.from_matrix_to_array import convert_matrix_to_array
+
+
+@singledispatch
+def array_derive(expr, x):
+    """
+    Derivatives (gradients) for array expressions.
+    """
+    raise NotImplementedError(f"not implemented for type {type(expr)}")
+
+
+@array_derive.register(Expr)
+def _(expr: Expr, x: _ArrayExpr):
+    return ZeroArray(*x.shape)
+
+
+@array_derive.register(ArrayTensorProduct)
+def _(expr: ArrayTensorProduct, x: Expr):
+    args = expr.args
+    addend_list = []
+    for i, arg in enumerate(expr.args):
+        darg = array_derive(arg, x)
+        if darg == 0:
+            continue
+        args_prev = args[:i]
+        args_succ = args[i+1:]
+        shape_prev = reduce(operator.add, map(get_shape, args_prev), ())
+        shape_succ = reduce(operator.add, map(get_shape, args_succ), ())
+        addend = _array_tensor_product(*args_prev, darg, *args_succ)
+        tot1 = len(get_shape(x))
+        tot2 = tot1 + len(shape_prev)
+        tot3 = tot2 + len(get_shape(arg))
+        tot4 = tot3 + len(shape_succ)
+        perm = list(range(tot1, tot2)) + \
+               list(range(tot1)) + list(range(tot2, tot3)) + \
+               list(range(tot3, tot4))
+        addend = _permute_dims(addend, _af_invert(perm))
+        addend_list.append(addend)
+    if len(addend_list) == 1:
+        return addend_list[0]
+    elif len(addend_list) == 0:
+        return S.Zero
+    else:
+        return _array_add(*addend_list)
+
+
+@array_derive.register(ArraySymbol)
+def _(expr: ArraySymbol, x: _ArrayExpr):
+    if expr == x:
+        return _permute_dims(
+            ArrayTensorProduct.fromiter(Identity(i) for i in expr.shape),
+            [2*i for i in range(len(expr.shape))] + [2*i+1 for i in range(len(expr.shape))]
+        )
+    return ZeroArray(*(x.shape + expr.shape))
+
+
+@array_derive.register(MatrixSymbol)
+def _(expr: MatrixSymbol, x: _ArrayExpr):
+    m, n = expr.shape
+    if expr == x:
+        return _permute_dims(
+            _array_tensor_product(Identity(m), Identity(n)),
+            [0, 2, 1, 3]
+        )
+    return ZeroArray(*(x.shape + expr.shape))
+
+
+@array_derive.register(Identity)
+def _(expr: Identity, x: _ArrayExpr):
+    return ZeroArray(*(x.shape + expr.shape))
+
+
+@array_derive.register(OneMatrix)
+def _(expr: OneMatrix, x: _ArrayExpr):
+    return ZeroArray(*(x.shape + expr.shape))
+
+
+@array_derive.register(Transpose)
+def _(expr: Transpose, x: Expr):
+    # D(A.T, A) ==> (m,n,i,j) ==> D(A_ji, A_mn) = d_mj d_ni
+    # D(B.T, A) ==> (m,n,i,j) ==> D(B_ji, A_mn)
+    fd = array_derive(expr.arg, x)
+    return _permute_dims(fd, [0, 1, 3, 2])
+
+
+@array_derive.register(Inverse)
+def _(expr: Inverse, x: Expr):
+    mat = expr.I
+    dexpr = array_derive(mat, x)
+    tp = _array_tensor_product(-expr, dexpr, expr)
+    mp = _array_contraction(tp, (1, 4), (5, 6))
+    pp = _permute_dims(mp, [1, 2, 0, 3])
+    return pp
+
+
+@array_derive.register(ElementwiseApplyFunction)
+def _(expr: ElementwiseApplyFunction, x: Expr):
+    assert get_rank(expr) == 2
+    assert get_rank(x) == 2
+    fdiff = expr._get_function_fdiff()
+    dexpr = array_derive(expr.expr, x)
+    tp = _array_tensor_product(
+        ElementwiseApplyFunction(fdiff, expr.expr),
+        dexpr
+    )
+    td = _array_diagonal(
+        tp, (0, 4), (1, 5)
+    )
+    return td
+
+
+@array_derive.register(ArrayElementwiseApplyFunc)
+def _(expr: ArrayElementwiseApplyFunc, x: Expr):
+    fdiff = expr._get_function_fdiff()
+    subexpr = expr.expr
+    dsubexpr = array_derive(subexpr, x)
+    tp = _array_tensor_product(
+        dsubexpr,
+        ArrayElementwiseApplyFunc(fdiff, subexpr)
+    )
+    b = get_rank(x)
+    c = get_rank(expr)
+    diag_indices = [(b + i, b + c + i) for i in range(c)]
+    return _array_diagonal(tp, *diag_indices)
+
+
+@array_derive.register(MatrixExpr)
+def _(expr: MatrixExpr, x: Expr):
+    cg = convert_matrix_to_array(expr)
+    return array_derive(cg, x)
+
+
+@array_derive.register(HadamardProduct)
+def _(expr: HadamardProduct, x: Expr):
+    raise NotImplementedError()
+
+
+@array_derive.register(ArrayContraction)
+def _(expr: ArrayContraction, x: Expr):
+    fd = array_derive(expr.expr, x)
+    rank_x = len(get_shape(x))
+    contraction_indices = expr.contraction_indices
+    new_contraction_indices = [tuple(j + rank_x for j in i) for i in contraction_indices]
+    return _array_contraction(fd, *new_contraction_indices)
+
+
+@array_derive.register(ArrayDiagonal)
+def _(expr: ArrayDiagonal, x: Expr):
+    dsubexpr = array_derive(expr.expr, x)
+    rank_x = len(get_shape(x))
+    diag_indices = [[j + rank_x for j in i] for i in expr.diagonal_indices]
+    return _array_diagonal(dsubexpr, *diag_indices)
+
+
+@array_derive.register(ArrayAdd)
+def _(expr: ArrayAdd, x: Expr):
+    return _array_add(*[array_derive(arg, x) for arg in expr.args])
+
+
+@array_derive.register(PermuteDims)
+def _(expr: PermuteDims, x: Expr):
+    de = array_derive(expr.expr, x)
+    perm = [0, 1] + [i + 2 for i in expr.permutation.array_form]
+    return _permute_dims(de, perm)
+
+
+@array_derive.register(Reshape)
+def _(expr: Reshape, x: Expr):
+    de = array_derive(expr.expr, x)
+    return Reshape(de, get_shape(x) + expr.shape)
+
+
+def matrix_derive(expr, x):
+    from sympy.tensor.array.expressions.from_array_to_matrix import convert_array_to_matrix
+    ce = convert_matrix_to_array(expr)
+    dce = array_derive(ce, x)
+    return convert_array_to_matrix(dce).doit()
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/expressions/conv_array_to_indexed.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/expressions/conv_array_to_indexed.py
new file mode 100644
index 0000000000000000000000000000000000000000..1929c3401e131cca0a83080131ead9198b37bcbb
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/expressions/conv_array_to_indexed.py
@@ -0,0 +1,12 @@
+from sympy.tensor.array.expressions import from_array_to_indexed
+from sympy.utilities.decorator import deprecated
+
+
+_conv_to_from_decorator = deprecated(
+    "module has been renamed by replacing 'conv_' with 'from_' in its name",
+    deprecated_since_version="1.11",
+    active_deprecations_target="deprecated-conv-array-expr-module-names",
+)
+
+
+convert_array_to_indexed = _conv_to_from_decorator(from_array_to_indexed.convert_array_to_indexed)
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/expressions/conv_array_to_matrix.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/expressions/conv_array_to_matrix.py
new file mode 100644
index 0000000000000000000000000000000000000000..2708e74aaa98d6ee38eae46d97d4483a546e0776
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/expressions/conv_array_to_matrix.py
@@ -0,0 +1,6 @@
+from sympy.tensor.array.expressions import from_array_to_matrix
+from sympy.tensor.array.expressions.conv_array_to_indexed import _conv_to_from_decorator
+
+convert_array_to_matrix = _conv_to_from_decorator(from_array_to_matrix.convert_array_to_matrix)
+_array2matrix = _conv_to_from_decorator(from_array_to_matrix._array2matrix)
+_remove_trivial_dims = _conv_to_from_decorator(from_array_to_matrix._remove_trivial_dims)
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/expressions/conv_indexed_to_array.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/expressions/conv_indexed_to_array.py
new file mode 100644
index 0000000000000000000000000000000000000000..6058b31f20778834ea23a01553d594b7965eb6bb
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/expressions/conv_indexed_to_array.py
@@ -0,0 +1,4 @@
+from sympy.tensor.array.expressions import from_indexed_to_array
+from sympy.tensor.array.expressions.conv_array_to_indexed import _conv_to_from_decorator
+
+convert_indexed_to_array = _conv_to_from_decorator(from_indexed_to_array.convert_indexed_to_array)
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/expressions/conv_matrix_to_array.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/expressions/conv_matrix_to_array.py
new file mode 100644
index 0000000000000000000000000000000000000000..46469df60703c237527c0b2834235309640afe7c
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/expressions/conv_matrix_to_array.py
@@ -0,0 +1,4 @@
+from sympy.tensor.array.expressions import from_matrix_to_array
+from sympy.tensor.array.expressions.conv_array_to_indexed import _conv_to_from_decorator
+
+convert_matrix_to_array = _conv_to_from_decorator(from_matrix_to_array.convert_matrix_to_array)
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/expressions/from_array_to_indexed.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/expressions/from_array_to_indexed.py
new file mode 100644
index 0000000000000000000000000000000000000000..9eb86e7cfbe31ebfe7c9649803d9cb5e34b98276
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/expressions/from_array_to_indexed.py
@@ -0,0 +1,84 @@
+import collections.abc
+import operator
+from itertools import accumulate
+
+from sympy import Mul, Sum, Dummy, Add
+from sympy.tensor.array.expressions import PermuteDims, ArrayAdd, ArrayElementwiseApplyFunc, Reshape
+from sympy.tensor.array.expressions.array_expressions import ArrayTensorProduct, get_rank, ArrayContraction, \
+    ArrayDiagonal, get_shape, _get_array_element_or_slice, _ArrayExpr
+from sympy.tensor.array.expressions.utils import _apply_permutation_to_list
+
+
+def convert_array_to_indexed(expr, indices):
+    return _ConvertArrayToIndexed().do_convert(expr, indices)
+
+
+class _ConvertArrayToIndexed:
+
+    def __init__(self):
+        self.count_dummies = 0
+
+    def do_convert(self, expr, indices):
+        if isinstance(expr, ArrayTensorProduct):
+            cumul = list(accumulate([0] + [get_rank(arg) for arg in expr.args]))
+            indices_grp = [indices[cumul[i]:cumul[i+1]] for i in range(len(expr.args))]
+            return Mul.fromiter(self.do_convert(arg, ind) for arg, ind in zip(expr.args, indices_grp))
+        if isinstance(expr, ArrayContraction):
+            new_indices = [None for i in range(get_rank(expr.expr))]
+            limits = []
+            bottom_shape = get_shape(expr.expr)
+            for contraction_index_grp in expr.contraction_indices:
+                d = Dummy(f"d{self.count_dummies}")
+                self.count_dummies += 1
+                dim = bottom_shape[contraction_index_grp[0]]
+                limits.append((d, 0, dim-1))
+                for i in contraction_index_grp:
+                    new_indices[i] = d
+            j = 0
+            for i in range(len(new_indices)):
+                if new_indices[i] is None:
+                    new_indices[i] = indices[j]
+                    j += 1
+            newexpr = self.do_convert(expr.expr, new_indices)
+            return Sum(newexpr, *limits)
+        if isinstance(expr, ArrayDiagonal):
+            new_indices = [None for i in range(get_rank(expr.expr))]
+            ind_pos = expr._push_indices_down(expr.diagonal_indices, list(range(len(indices))), get_rank(expr))
+            for i, index in zip(ind_pos, indices):
+                if isinstance(i, collections.abc.Iterable):
+                    for j in i:
+                        new_indices[j] = index
+                else:
+                    new_indices[i] = index
+            newexpr = self.do_convert(expr.expr, new_indices)
+            return newexpr
+        if isinstance(expr, PermuteDims):
+            permuted_indices = _apply_permutation_to_list(expr.permutation, indices)
+            return self.do_convert(expr.expr, permuted_indices)
+        if isinstance(expr, ArrayAdd):
+            return Add.fromiter(self.do_convert(arg, indices) for arg in expr.args)
+        if isinstance(expr, _ArrayExpr):
+            return expr.__getitem__(tuple(indices))
+        if isinstance(expr, ArrayElementwiseApplyFunc):
+            return expr.function(self.do_convert(expr.expr, indices))
+        if isinstance(expr, Reshape):
+            shape_up = expr.shape
+            shape_down = get_shape(expr.expr)
+            cumul = list(accumulate([1] + list(reversed(shape_up)), operator.mul))
+            one_index = Add.fromiter(i*s for i, s in zip(reversed(indices), cumul))
+            dest_indices = [None for _ in shape_down]
+            c = 1
+            for i, e in enumerate(reversed(shape_down)):
+                if c == 1:
+                    if i == len(shape_down) - 1:
+                        dest_indices[i] = one_index
+                    else:
+                        dest_indices[i] = one_index % e
+                elif i == len(shape_down) - 1:
+                    dest_indices[i] = one_index // c
+                else:
+                    dest_indices[i] = one_index // c % e
+                c *= e
+            dest_indices.reverse()
+            return self.do_convert(expr.expr, dest_indices)
+        return _get_array_element_or_slice(expr, indices)
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/expressions/from_array_to_matrix.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/expressions/from_array_to_matrix.py
new file mode 100644
index 0000000000000000000000000000000000000000..debfdd7eb5c4533996b3d72b55d679be3daf3afe
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/expressions/from_array_to_matrix.py
@@ -0,0 +1,1004 @@
+from __future__ import annotations
+import itertools
+from collections import defaultdict
+from typing import FrozenSet
+from functools import singledispatch
+from itertools import accumulate
+
+from sympy import MatMul, Basic, Wild, KroneckerProduct
+from sympy.assumptions.ask import (Q, ask)
+from sympy.core.mul import Mul
+from sympy.core.singleton import S
+from sympy.matrices.expressions.diagonal import DiagMatrix
+from sympy.matrices.expressions.hadamard import hadamard_product, HadamardPower
+from sympy.matrices.expressions.matexpr import MatrixExpr
+from sympy.matrices.expressions.special import (Identity, ZeroMatrix, OneMatrix)
+from sympy.matrices.expressions.trace import Trace
+from sympy.matrices.expressions.transpose import Transpose
+from sympy.combinatorics.permutations import _af_invert, Permutation
+from sympy.matrices.matrixbase import MatrixBase
+from sympy.matrices.expressions.applyfunc import ElementwiseApplyFunction
+from sympy.matrices.expressions.matexpr import MatrixElement
+from sympy.tensor.array.expressions.array_expressions import PermuteDims, ArrayDiagonal, \
+    ArrayTensorProduct, OneArray, get_rank, _get_subrank, ZeroArray, ArrayContraction, \
+    ArrayAdd, _CodegenArrayAbstract, get_shape, ArrayElementwiseApplyFunc, _ArrayExpr, _EditArrayContraction, _ArgE, \
+    ArrayElement, _array_tensor_product, _array_contraction, _array_diagonal, _array_add, _permute_dims
+from sympy.tensor.array.expressions.utils import _get_mapping_from_subranks
+
+
+def _get_candidate_for_matmul_from_contraction(scan_indices: list[int | None], remaining_args: list[_ArgE]) -> tuple[_ArgE | None, bool, int]:
+
+    scan_indices_int: list[int] = [i for i in scan_indices if i is not None]
+    if len(scan_indices_int) == 0:
+        return None, False, -1
+
+    transpose: bool = False
+    candidate: _ArgE | None = None
+    candidate_index: int = -1
+    for arg_with_ind2 in remaining_args:
+        if not isinstance(arg_with_ind2.element, MatrixExpr):
+            continue
+        for index in scan_indices_int:
+            if candidate_index != -1 and candidate_index != index:
+                # A candidate index has already been selected, check
+                # repetitions only for that index:
+                continue
+            if index in arg_with_ind2.indices:
+                if set(arg_with_ind2.indices) == {index}:
+                    # Index repeated twice in arg_with_ind2
+                    candidate = None
+                    break
+                if candidate is None:
+                    candidate = arg_with_ind2
+                    candidate_index = index
+                    transpose = (index == arg_with_ind2.indices[1])
+                else:
+                    # Index repeated more than twice, break
+                    candidate = None
+                    break
+    return candidate, transpose, candidate_index
+
+
+def _insert_candidate_into_editor(editor: _EditArrayContraction, arg_with_ind: _ArgE, candidate: _ArgE, transpose1: bool, transpose2: bool):
+    other = candidate.element
+    other_index: int | None
+    if transpose2:
+        other = Transpose(other)
+        other_index = candidate.indices[0]
+    else:
+        other_index = candidate.indices[1]
+    new_element = (Transpose(arg_with_ind.element) if transpose1 else arg_with_ind.element) * other
+    editor.args_with_ind.remove(candidate)
+    new_arge = _ArgE(new_element)
+    return new_arge, other_index
+
+
+def _support_function_tp1_recognize(contraction_indices, args):
+    if len(contraction_indices) == 0:
+        return _a2m_tensor_product(*args)
+
+    ac = _array_contraction(_array_tensor_product(*args), *contraction_indices)
+    editor = _EditArrayContraction(ac)
+    editor.track_permutation_start()
+
+    while True:
+        flag_stop = True
+        for i, arg_with_ind in enumerate(editor.args_with_ind):
+            if not isinstance(arg_with_ind.element, MatrixExpr):
+                continue
+
+            first_index = arg_with_ind.indices[0]
+            second_index = arg_with_ind.indices[1]
+
+            first_frequency = editor.count_args_with_index(first_index)
+            second_frequency = editor.count_args_with_index(second_index)
+
+            if first_index is not None and first_frequency == 1 and first_index == second_index:
+                flag_stop = False
+                arg_with_ind.element = Trace(arg_with_ind.element)._normalize()
+                arg_with_ind.indices = []
+                break
+
+            scan_indices = []
+            if first_frequency == 2:
+                scan_indices.append(first_index)
+            if second_frequency == 2:
+                scan_indices.append(second_index)
+
+            candidate, transpose, found_index = _get_candidate_for_matmul_from_contraction(scan_indices, editor.args_with_ind[i+1:])
+            if candidate is not None:
+                flag_stop = False
+                editor.track_permutation_merge(arg_with_ind, candidate)
+                transpose1 = found_index == first_index
+                new_arge, other_index = _insert_candidate_into_editor(editor, arg_with_ind, candidate, transpose1, transpose)
+                if found_index == first_index:
+                    new_arge.indices = [second_index, other_index]
+                else:
+                    new_arge.indices = [first_index, other_index]
+                set_indices = set(new_arge.indices)
+                if len(set_indices) == 1 and set_indices != {None}:
+                    # This is a trace:
+                    new_arge.element = Trace(new_arge.element)._normalize()
+                    new_arge.indices = []
+                editor.args_with_ind[i] = new_arge
+                # TODO: is this break necessary?
+                break
+
+        if flag_stop:
+            break
+
+    editor.refresh_indices()
+    return editor.to_array_contraction()
+
+
+def _find_trivial_matrices_rewrite(expr: ArrayTensorProduct):
+    # If there are matrices of trivial shape in the tensor product (i.e. shape
+    # (1, 1)), try to check if there is a suitable non-trivial MatMul where the
+    # expression can be inserted.
+
+    # For example, if "a" has shape (1, 1) and "b" has shape (k, 1), the
+    # expressions "_array_tensor_product(a, b*b.T)" can be rewritten as
+    # "b*a*b.T"
+
+    trivial_matrices = []
+    pos: int | None = None  # must be initialized else causes UnboundLocalError
+    first: MatrixExpr | None = None  # may cause UnboundLocalError if not initialized
+    second: MatrixExpr | None = None  # may cause UnboundLocalError if not initialized
+    removed: list[int] = []
+    counter: int = 0
+    args: list[Basic | None] = list(expr.args)
+    for i, arg in enumerate(expr.args):
+        if isinstance(arg, MatrixExpr):
+            if arg.shape == (1, 1):
+                trivial_matrices.append(arg)
+                args[i] = None
+                removed.extend([counter, counter+1])
+            elif pos is None and isinstance(arg, MatMul):
+                margs = arg.args
+                for j, e in enumerate(margs):
+                    if isinstance(e, MatrixExpr) and e.shape[1] == 1:
+                        pos = i
+                        first = MatMul.fromiter(margs[:j+1])
+                        second = MatMul.fromiter(margs[j+1:])
+                        break
+        counter += get_rank(arg)
+    if pos is None:
+        return expr, []
+    args[pos] = (first*MatMul.fromiter(i for i in trivial_matrices)*second).doit()
+    return _array_tensor_product(*[i for i in args if i is not None]), removed
+
+
+def _find_trivial_kronecker_products_broadcast(expr: ArrayTensorProduct):
+    newargs: list[Basic] = []
+    removed = []
+    count_dims = 0
+    for arg in expr.args:
+        count_dims += get_rank(arg)
+        shape = get_shape(arg)
+        current_range = [count_dims-i for i in range(len(shape), 0, -1)]
+        if (shape == (1, 1) and len(newargs) > 0 and 1 not in get_shape(newargs[-1]) and
+            isinstance(newargs[-1], MatrixExpr) and isinstance(arg, MatrixExpr)):
+            # KroneckerProduct object allows the trick of broadcasting:
+            newargs[-1] = KroneckerProduct(newargs[-1], arg)
+            removed.extend(current_range)
+        elif 1 not in shape and len(newargs) > 0 and get_shape(newargs[-1]) == (1, 1):
+            # Broadcast:
+            newargs[-1] = KroneckerProduct(newargs[-1], arg)
+            prev_range = [i for i in range(min(current_range)) if i not in removed]
+            removed.extend(prev_range[-2:])
+        else:
+            newargs.append(arg)
+    return _array_tensor_product(*newargs), removed
+
+
+@singledispatch
+def _array2matrix(expr):
+    return expr
+
+
+@_array2matrix.register(ZeroArray)
+def _(expr: ZeroArray):
+    if get_rank(expr) == 2:
+        return ZeroMatrix(*expr.shape)
+    else:
+        return expr
+
+
+@_array2matrix.register(ArrayTensorProduct)
+def _(expr: ArrayTensorProduct):
+    return _a2m_tensor_product(*[_array2matrix(arg) for arg in expr.args])
+
+
+@_array2matrix.register(ArrayContraction)
+def _(expr: ArrayContraction):
+    expr = expr.flatten_contraction_of_diagonal()
+    expr = identify_removable_identity_matrices(expr)
+    expr = expr.split_multiple_contractions()
+    expr = identify_hadamard_products(expr)
+    if not isinstance(expr, ArrayContraction):
+        return _array2matrix(expr)
+    subexpr = expr.expr
+    contraction_indices: tuple[tuple[int]] = expr.contraction_indices
+    if contraction_indices == ((0,), (1,)) or (
+        contraction_indices == ((0,),) and subexpr.shape[1] == 1
+    ) or (
+        contraction_indices == ((1,),) and subexpr.shape[0] == 1
+    ):
+        shape = subexpr.shape
+        subexpr = _array2matrix(subexpr)
+        if isinstance(subexpr, MatrixExpr):
+            return OneMatrix(1, shape[0])*subexpr*OneMatrix(shape[1], 1)
+    if isinstance(subexpr, ArrayTensorProduct):
+        newexpr = _array_contraction(_array2matrix(subexpr), *contraction_indices)
+        contraction_indices = newexpr.contraction_indices
+        if any(i > 2 for i in newexpr.subranks):
+            addends = _array_add(*[_a2m_tensor_product(*j) for j in itertools.product(*[i.args if isinstance(i,
+                                                                                                                             ArrayAdd) else [i] for i in expr.expr.args])])
+            newexpr = _array_contraction(addends, *contraction_indices)
+        if isinstance(newexpr, ArrayAdd):
+            ret = _array2matrix(newexpr)
+            return ret
+        assert isinstance(newexpr, ArrayContraction)
+        ret = _support_function_tp1_recognize(contraction_indices, list(newexpr.expr.args))
+        return ret
+    elif not isinstance(subexpr, _CodegenArrayAbstract):
+        ret = _array2matrix(subexpr)
+        if isinstance(ret, MatrixExpr):
+            assert expr.contraction_indices == ((0, 1),)
+            return _a2m_trace(ret)
+        else:
+            return _array_contraction(ret, *expr.contraction_indices)
+
+
+@_array2matrix.register(ArrayDiagonal)
+def _(expr: ArrayDiagonal):
+    pexpr = _array_diagonal(_array2matrix(expr.expr), *expr.diagonal_indices)
+    pexpr = identify_hadamard_products(pexpr)
+    if isinstance(pexpr, ArrayDiagonal):
+        pexpr = _array_diag2contr_diagmatrix(pexpr)
+    if expr == pexpr:
+        return expr
+    return _array2matrix(pexpr)
+
+
+@_array2matrix.register(PermuteDims)
+def _(expr: PermuteDims):
+    if expr.permutation.array_form == [1, 0]:
+        return _a2m_transpose(_array2matrix(expr.expr))
+    elif isinstance(expr.expr, ArrayTensorProduct):
+        ranks = expr.expr.subranks
+        inv_permutation = expr.permutation**(-1)
+        newrange = [inv_permutation(i) for i in range(sum(ranks))]
+        newpos = []
+        counter = 0
+        for rank in ranks:
+            newpos.append(newrange[counter:counter+rank])
+            counter += rank
+        newargs = []
+        newperm = []
+        scalars = []
+        for pos, arg in zip(newpos, expr.expr.args):
+            if len(pos) == 0:
+                scalars.append(_array2matrix(arg))
+            elif pos == sorted(pos):
+                newargs.append((_array2matrix(arg), pos[0]))
+                newperm.extend(pos)
+            elif len(pos) == 2:
+                newargs.append((_a2m_transpose(_array2matrix(arg)), pos[0]))
+                newperm.extend(reversed(pos))
+            else:
+                raise NotImplementedError()
+        newargs = [i[0] for i in newargs]
+        return _permute_dims(_a2m_tensor_product(*scalars, *newargs), _af_invert(newperm))
+    elif isinstance(expr.expr, ArrayContraction):
+        mat_mul_lines = _array2matrix(expr.expr)
+        if not isinstance(mat_mul_lines, ArrayTensorProduct):
+            return _permute_dims(mat_mul_lines, expr.permutation)
+        # TODO: this assumes that all arguments are matrices, it may not be the case:
+        permutation = Permutation(2*len(mat_mul_lines.args)-1)*expr.permutation
+        permuted = [permutation(i) for i in range(2*len(mat_mul_lines.args))]
+        args_array = [None for i in mat_mul_lines.args]
+        for i in range(len(mat_mul_lines.args)):
+            p1 = permuted[2*i]
+            p2 = permuted[2*i+1]
+            if p1 // 2 != p2 // 2:
+                return _permute_dims(mat_mul_lines, permutation)
+            if p1 > p2:
+                args_array[i] = _a2m_transpose(mat_mul_lines.args[p1 // 2])
+            else:
+                args_array[i] = mat_mul_lines.args[p1 // 2]
+        return _a2m_tensor_product(*args_array)
+    else:
+        return expr
+
+
+@_array2matrix.register(ArrayAdd)
+def _(expr: ArrayAdd):
+    addends = [_array2matrix(arg) for arg in expr.args]
+    return _a2m_add(*addends)
+
+
+@_array2matrix.register(ArrayElementwiseApplyFunc)
+def _(expr: ArrayElementwiseApplyFunc):
+    subexpr = _array2matrix(expr.expr)
+    if isinstance(subexpr, MatrixExpr):
+        if subexpr.shape != (1, 1):
+            d = expr.function.bound_symbols[0]
+            w = Wild("w", exclude=[d])
+            p = Wild("p", exclude=[d])
+            m = expr.function.expr.match(w*d**p)
+            if m is not None:
+                return m[w]*HadamardPower(subexpr, m[p])
+        return ElementwiseApplyFunction(expr.function, subexpr)
+    else:
+        return ArrayElementwiseApplyFunc(expr.function, subexpr)
+
+
+@_array2matrix.register(ArrayElement)
+def _(expr: ArrayElement):
+    ret = _array2matrix(expr.name)
+    if isinstance(ret, MatrixExpr):
+        return MatrixElement(ret, *expr.indices)
+    return ArrayElement(ret, expr.indices)
+
+
+@singledispatch
+def _remove_trivial_dims(expr):
+    return expr, []
+
+
+@_remove_trivial_dims.register(ArrayTensorProduct)
+def _(expr: ArrayTensorProduct):
+    # Recognize expressions like [x, y] with shape (k, 1, k, 1) as `x*y.T`.
+    # The matrix expression has to be equivalent to the tensor product of the
+    # matrices, with trivial dimensions (i.e. dim=1) dropped.
+    # That is, add contractions over trivial dimensions:
+
+    removed = []
+    newargs = []
+    cumul = list(accumulate([0] + [get_rank(arg) for arg in expr.args]))
+    pending = None
+    prev_i = None
+    for i, arg in enumerate(expr.args):
+        current_range = list(range(cumul[i], cumul[i+1]))
+        if isinstance(arg, OneArray):
+            removed.extend(current_range)
+            continue
+        if not isinstance(arg, (MatrixExpr, MatrixBase)):
+            rarg, rem = _remove_trivial_dims(arg)
+            removed.extend(rem)
+            newargs.append(rarg)
+            continue
+        elif getattr(arg, "is_Identity", False) and arg.shape == (1, 1):
+            if arg.shape == (1, 1):
+                # Ignore identity matrices of shape (1, 1) - they are equivalent to scalar 1.
+                removed.extend(current_range)
+            continue
+        elif arg.shape == (1, 1):
+            arg, _ = _remove_trivial_dims(arg)
+            # Matrix is equivalent to scalar:
+            if len(newargs) == 0:
+                newargs.append(arg)
+            elif 1 in get_shape(newargs[-1]):
+                if newargs[-1].shape[1] == 1:
+                    newargs[-1] = newargs[-1]*arg
+                else:
+                    newargs[-1] = arg*newargs[-1]
+                removed.extend(current_range)
+            else:
+                newargs.append(arg)
+        elif 1 in arg.shape:
+            k = [i for i in arg.shape if i != 1][0]
+            if pending is None:
+                pending = k
+                prev_i = i
+                newargs.append(arg)
+            elif pending == k:
+                prev = newargs[-1]
+                if prev.shape[0] == 1:
+                    d1 = cumul[prev_i]  # type: ignore
+                    prev = _a2m_transpose(prev)
+                else:
+                    d1 = cumul[prev_i] + 1  # type: ignore
+                if arg.shape[1] == 1:
+                    d2 = cumul[i] + 1
+                    arg = _a2m_transpose(arg)
+                else:
+                    d2 = cumul[i]
+                newargs[-1] = prev*arg
+                pending = None
+                removed.extend([d1, d2])
+            else:
+                newargs.append(arg)
+                pending = k
+                prev_i = i
+        else:
+            newargs.append(arg)
+            pending = None
+    newexpr, newremoved = _a2m_tensor_product(*newargs), sorted(removed)
+    if isinstance(newexpr, ArrayTensorProduct):
+        newexpr, newremoved2 = _find_trivial_matrices_rewrite(newexpr)
+        newremoved = _combine_removed(-1, newremoved, newremoved2)
+    if isinstance(newexpr, ArrayTensorProduct):
+        newexpr, newremoved2 = _find_trivial_kronecker_products_broadcast(newexpr)
+        newremoved = _combine_removed(-1, newremoved, newremoved2)
+    return newexpr, newremoved
+
+
+@_remove_trivial_dims.register(ArrayAdd)
+def _(expr: ArrayAdd):
+    rec = [_remove_trivial_dims(arg) for arg in expr.args]
+    newargs, removed = zip(*rec)
+    if len({get_shape(i) for i in newargs}) > 1:
+        return expr, []
+    if len(removed) == 0:
+        return expr, removed
+    removed1 = removed[0]
+    return _a2m_add(*newargs), removed1
+
+
+@_remove_trivial_dims.register(PermuteDims)
+def _(expr: PermuteDims):
+    subexpr, subremoved = _remove_trivial_dims(expr.expr)
+    p = expr.permutation.array_form
+    pinv = _af_invert(expr.permutation.array_form)
+    shift = list(accumulate([1 if i in subremoved else 0 for i in range(len(p))]))
+    premoved = [pinv[i] for i in subremoved]
+    p2 = [e - shift[e] for e in p if e not in subremoved]
+    # TODO: check if subremoved should be permuted as well...
+    newexpr = _permute_dims(subexpr, p2)
+    premoved = sorted(premoved)
+    if newexpr != expr:
+        newexpr, removed2 = _remove_trivial_dims(_array2matrix(newexpr))
+        premoved = _combine_removed(-1, premoved, removed2)
+    return newexpr, premoved
+
+
+@_remove_trivial_dims.register(ArrayContraction)
+def _(expr: ArrayContraction):
+    new_expr, removed0 = _array_contraction_to_diagonal_multiple_identity(expr)
+    if new_expr != expr:
+        new_expr2, removed1 = _remove_trivial_dims(_array2matrix(new_expr))
+        removed = _combine_removed(-1, removed0, removed1)
+        return new_expr2, removed
+    rank1 = get_rank(expr)
+    expr, removed1 = remove_identity_matrices(expr)
+    if not isinstance(expr, ArrayContraction):
+        expr2, removed2 = _remove_trivial_dims(expr)
+        return expr2, _combine_removed(rank1, removed1, removed2)
+    newexpr, removed2 = _remove_trivial_dims(expr.expr)
+    shifts = list(accumulate([1 if i in removed2 else 0 for i in range(get_rank(expr.expr))]))
+    new_contraction_indices = [tuple(j for j in i if j not in removed2) for i in expr.contraction_indices]
+    # Remove possible empty tuples "()":
+    new_contraction_indices = [i for i in new_contraction_indices if len(i) > 0]
+    contraction_indices_flat = [j for i in expr.contraction_indices for j in i]
+    removed2 = [i for i in removed2 if i not in contraction_indices_flat]
+    new_contraction_indices = [tuple(j - shifts[j] for j in i) for i in new_contraction_indices]
+    # Shift removed2:
+    removed2 = ArrayContraction._push_indices_up(expr.contraction_indices, removed2)
+    removed = _combine_removed(rank1, removed1, removed2)
+    return _array_contraction(newexpr, *new_contraction_indices), list(removed)
+
+
+def _remove_diagonalized_identity_matrices(expr: ArrayDiagonal):
+    assert isinstance(expr, ArrayDiagonal)
+    editor = _EditArrayContraction(expr)
+    mapping = {i: {j for j in editor.args_with_ind if i in j.indices} for i in range(-1, -1-editor.number_of_diagonal_indices, -1)}
+    removed = []
+    counter: int = 0
+    for i, arg_with_ind in enumerate(editor.args_with_ind):
+        counter += len(arg_with_ind.indices)
+        if isinstance(arg_with_ind.element, Identity):
+            if None in arg_with_ind.indices and any(i is not None and (i < 0) == True for i in arg_with_ind.indices):
+                diag_ind = [j for j in arg_with_ind.indices if j is not None][0]
+                other = [j for j in mapping[diag_ind] if j != arg_with_ind][0]
+                if not isinstance(other.element, MatrixExpr):
+                    continue
+                if 1 not in other.element.shape:
+                    continue
+                if None not in other.indices:
+                    continue
+                editor.args_with_ind[i].element = None
+                none_index = other.indices.index(None)
+                other.element = DiagMatrix(other.element)
+                other_range = editor.get_absolute_range(other)
+                removed.extend([other_range[0] + none_index])
+    editor.args_with_ind = [i for i in editor.args_with_ind if i.element is not None]
+    removed = ArrayDiagonal._push_indices_up(expr.diagonal_indices, removed, get_rank(expr.expr))
+    return editor.to_array_contraction(), removed
+
+
+@_remove_trivial_dims.register(ArrayDiagonal)
+def _(expr: ArrayDiagonal):
+    newexpr, removed = _remove_trivial_dims(expr.expr)
+    shifts = list(accumulate([0] + [1 if i in removed else 0 for i in range(get_rank(expr.expr))]))
+    new_diag_indices_map = {i: tuple(j for j in i if j not in removed) for i in expr.diagonal_indices}
+    for old_diag_tuple, new_diag_tuple in new_diag_indices_map.items():
+        if len(new_diag_tuple) == 1:
+            removed = [i for i in removed if i not in old_diag_tuple]
+    new_diag_indices = [tuple(j - shifts[j] for j in i) for i in new_diag_indices_map.values()]
+    rank = get_rank(expr.expr)
+    removed = ArrayDiagonal._push_indices_up(expr.diagonal_indices, removed, rank)
+    removed = sorted(set(removed))
+    # If there are single axes to diagonalize remaining, it means that their
+    # corresponding dimension has been removed, they no longer need diagonalization:
+    new_diag_indices = [i for i in new_diag_indices if len(i) > 0]
+    if len(new_diag_indices) > 0:
+        newexpr2 = _array_diagonal(newexpr, *new_diag_indices, allow_trivial_diags=True)
+    else:
+        newexpr2 = newexpr
+    if isinstance(newexpr2, ArrayDiagonal):
+        newexpr3, removed2 = _remove_diagonalized_identity_matrices(newexpr2)
+        removed = _combine_removed(-1, removed, removed2)
+        return newexpr3, removed
+    else:
+        return newexpr2, removed
+
+
+@_remove_trivial_dims.register(ElementwiseApplyFunction)
+def _(expr: ElementwiseApplyFunction):
+    subexpr, removed = _remove_trivial_dims(expr.expr)
+    if subexpr.shape == (1, 1):
+        # TODO: move this to ElementwiseApplyFunction
+        return expr.function(subexpr), removed + [0, 1]
+    return ElementwiseApplyFunction(expr.function, subexpr), []
+
+
+@_remove_trivial_dims.register(ArrayElementwiseApplyFunc)
+def _(expr: ArrayElementwiseApplyFunc):
+    subexpr, removed = _remove_trivial_dims(expr.expr)
+    return ArrayElementwiseApplyFunc(expr.function, subexpr), removed
+
+
+def convert_array_to_matrix(expr):
+    r"""
+    Recognize matrix expressions in codegen objects.
+
+    If more than one matrix multiplication line have been detected, return a
+    list with the matrix expressions.
+
+    Examples
+    ========
+
+    >>> from sympy.tensor.array.expressions.from_indexed_to_array import convert_indexed_to_array
+    >>> from sympy.tensor.array import tensorcontraction, tensorproduct
+    >>> from sympy import MatrixSymbol, Sum
+    >>> from sympy.abc import i, j, k, l, N
+    >>> from sympy.tensor.array.expressions.from_matrix_to_array import convert_matrix_to_array
+    >>> from sympy.tensor.array.expressions.from_array_to_matrix import convert_array_to_matrix
+    >>> A = MatrixSymbol("A", N, N)
+    >>> B = MatrixSymbol("B", N, N)
+    >>> C = MatrixSymbol("C", N, N)
+    >>> D = MatrixSymbol("D", N, N)
+
+    >>> expr = Sum(A[i, j]*B[j, k], (j, 0, N-1))
+    >>> cg = convert_indexed_to_array(expr)
+    >>> convert_array_to_matrix(cg)
+    A*B
+    >>> cg = convert_indexed_to_array(expr, first_indices=[k])
+    >>> convert_array_to_matrix(cg)
+    B.T*A.T
+
+    Transposition is detected:
+
+    >>> expr = Sum(A[j, i]*B[j, k], (j, 0, N-1))
+    >>> cg = convert_indexed_to_array(expr)
+    >>> convert_array_to_matrix(cg)
+    A.T*B
+    >>> cg = convert_indexed_to_array(expr, first_indices=[k])
+    >>> convert_array_to_matrix(cg)
+    B.T*A
+
+    Detect the trace:
+
+    >>> expr = Sum(A[i, i], (i, 0, N-1))
+    >>> cg = convert_indexed_to_array(expr)
+    >>> convert_array_to_matrix(cg)
+    Trace(A)
+
+    Recognize some more complex traces:
+
+    >>> expr = Sum(A[i, j]*B[j, i], (i, 0, N-1), (j, 0, N-1))
+    >>> cg = convert_indexed_to_array(expr)
+    >>> convert_array_to_matrix(cg)
+    Trace(A*B)
+
+    More complicated expressions:
+
+    >>> expr = Sum(A[i, j]*B[k, j]*A[l, k], (j, 0, N-1), (k, 0, N-1))
+    >>> cg = convert_indexed_to_array(expr)
+    >>> convert_array_to_matrix(cg)
+    A*B.T*A.T
+
+    Expressions constructed from matrix expressions do not contain literal
+    indices, the positions of free indices are returned instead:
+
+    >>> expr = A*B
+    >>> cg = convert_matrix_to_array(expr)
+    >>> convert_array_to_matrix(cg)
+    A*B
+
+    If more than one line of matrix multiplications is detected, return
+    separate matrix multiplication factors embedded in a tensor product object:
+
+    >>> cg = tensorcontraction(tensorproduct(A, B, C, D), (1, 2), (5, 6))
+    >>> convert_array_to_matrix(cg)
+    ArrayTensorProduct(A*B, C*D)
+
+    The two lines have free indices at axes 0, 3 and 4, 7, respectively.
+    """
+    rec = _array2matrix(expr)
+    rec, removed = _remove_trivial_dims(rec)
+    return rec
+
+
+def _array_diag2contr_diagmatrix(expr: ArrayDiagonal):
+    if isinstance(expr.expr, ArrayTensorProduct):
+        args = list(expr.expr.args)
+        diag_indices = list(expr.diagonal_indices)
+        mapping = _get_mapping_from_subranks([_get_subrank(arg) for arg in args])
+        tuple_links = [[mapping[j] for j in i] for i in diag_indices]
+        contr_indices = []
+        total_rank = get_rank(expr)
+        replaced = [False for arg in args]
+        for i, (abs_pos, rel_pos) in enumerate(zip(diag_indices, tuple_links)):
+            if len(abs_pos) != 2:
+                continue
+            (pos1_outer, pos1_inner), (pos2_outer, pos2_inner) = rel_pos
+            arg1 = args[pos1_outer]
+            arg2 = args[pos2_outer]
+            if get_rank(arg1) != 2 or get_rank(arg2) != 2:
+                if replaced[pos1_outer]:
+                    diag_indices[i] = None
+                if replaced[pos2_outer]:
+                    diag_indices[i] = None
+                continue
+            pos1_in2 = 1 - pos1_inner
+            pos2_in2 = 1 - pos2_inner
+            if arg1.shape[pos1_in2] == 1:
+                if arg1.shape[pos1_inner] != 1:
+                    darg1 = DiagMatrix(arg1)
+                else:
+                    darg1 = arg1
+                args.append(darg1)
+                contr_indices.append(((pos2_outer, pos2_inner), (len(args)-1, pos1_inner)))
+                total_rank += 1
+                diag_indices[i] = None
+                args[pos1_outer] = OneArray(arg1.shape[pos1_in2])
+                replaced[pos1_outer] = True
+            elif arg2.shape[pos2_in2] == 1:
+                if arg2.shape[pos2_inner] != 1:
+                    darg2 = DiagMatrix(arg2)
+                else:
+                    darg2 = arg2
+                args.append(darg2)
+                contr_indices.append(((pos1_outer, pos1_inner), (len(args)-1, pos2_inner)))
+                total_rank += 1
+                diag_indices[i] = None
+                args[pos2_outer] = OneArray(arg2.shape[pos2_in2])
+                replaced[pos2_outer] = True
+        diag_indices_new = [i for i in diag_indices if i is not None]
+        cumul = list(accumulate([0] + [get_rank(arg) for arg in args]))
+        contr_indices2 = [tuple(cumul[a] + b for a, b in i) for i in contr_indices]
+        tc = _array_contraction(
+            _array_tensor_product(*args), *contr_indices2
+        )
+        td = _array_diagonal(tc, *diag_indices_new)
+        return td
+    return expr
+
+
+def _a2m_mul(*args):
+    if not any(isinstance(i, _CodegenArrayAbstract) for i in args):
+        from sympy.matrices.expressions.matmul import MatMul
+        return MatMul(*args).doit()
+    else:
+        return _array_contraction(
+            _array_tensor_product(*args),
+            *[(2*i-1, 2*i) for i in range(1, len(args))]
+        )
+
+
+def _a2m_tensor_product(*args):
+    scalars = []
+    arrays = []
+    for arg in args:
+        if isinstance(arg, (MatrixExpr, _ArrayExpr, _CodegenArrayAbstract)):
+            arrays.append(arg)
+        else:
+            scalars.append(arg)
+    scalar = Mul.fromiter(scalars)
+    if len(arrays) == 0:
+        return scalar
+    if scalar != 1:
+        if isinstance(arrays[0], _CodegenArrayAbstract):
+            arrays = [scalar] + arrays
+        else:
+            arrays[0] *= scalar
+    return _array_tensor_product(*arrays)
+
+
+def _a2m_add(*args):
+    if not any(isinstance(i, _CodegenArrayAbstract) for i in args):
+        from sympy.matrices.expressions.matadd import MatAdd
+        return MatAdd(*args).doit()
+    else:
+        return _array_add(*args)
+
+
+def _a2m_trace(arg):
+    if isinstance(arg, _CodegenArrayAbstract):
+        return _array_contraction(arg, (0, 1))
+    else:
+        from sympy.matrices.expressions.trace import Trace
+        return Trace(arg)
+
+
+def _a2m_transpose(arg):
+    if isinstance(arg, _CodegenArrayAbstract):
+        return _permute_dims(arg, [1, 0])
+    else:
+        from sympy.matrices.expressions.transpose import Transpose
+        return Transpose(arg).doit()
+
+
+def identify_hadamard_products(expr: ArrayContraction | ArrayDiagonal):
+
+    editor: _EditArrayContraction = _EditArrayContraction(expr)
+
+    map_contr_to_args: dict[FrozenSet, list[_ArgE]] = defaultdict(list)
+    map_ind_to_inds: dict[int | None, int] = defaultdict(int)
+    for arg_with_ind in editor.args_with_ind:
+        for ind in arg_with_ind.indices:
+            map_ind_to_inds[ind] += 1
+        if None in arg_with_ind.indices:
+            continue
+        map_contr_to_args[frozenset(arg_with_ind.indices)].append(arg_with_ind)
+
+    k: FrozenSet[int]
+    v: list[_ArgE]
+    for k, v in map_contr_to_args.items():
+        make_trace: bool = False
+        if len(k) == 1 and next(iter(k)) >= 0 and sum(next(iter(k)) in i for i in map_contr_to_args) == 1:
+            # This is a trace: the arguments are fully contracted with only one
+            # index, and the index isn't used anywhere else:
+            make_trace = True
+            first_element = S.One
+        elif len(k) != 2:
+            # Hadamard product only defined for matrices:
+            continue
+        if len(v) == 1:
+            # Hadamard product with a single argument makes no sense:
+            continue
+        for ind in k:
+            if map_ind_to_inds[ind] <= 2:
+                # There is no other contraction, skip:
+                continue
+
+        def check_transpose(x):
+            x = [i if i >= 0 else -1-i for i in x]
+            return x == sorted(x)
+
+        # Check if expression is a trace:
+        if all(map_ind_to_inds[j] == len(v) and j >= 0 for j in k) and all(j >= 0 for j in k):
+            # This is a trace
+            make_trace = True
+            first_element = v[0].element
+            if not check_transpose(v[0].indices):
+                first_element = first_element.T # type: ignore
+            hadamard_factors = v[1:]
+        else:
+            hadamard_factors = v
+
+        # This is a Hadamard product:
+
+        hp = hadamard_product(*[i.element if check_transpose(i.indices) else Transpose(i.element) for i in hadamard_factors])
+        hp_indices = v[0].indices
+        if not check_transpose(hadamard_factors[0].indices):
+            hp_indices = list(reversed(hp_indices))
+        if make_trace:
+            hp = Trace(first_element*hp.T)._normalize()
+            hp_indices = []
+        editor.insert_after(v[0], _ArgE(hp, hp_indices))
+        for i in v:
+            editor.args_with_ind.remove(i)
+
+    return editor.to_array_contraction()
+
+
+def identify_removable_identity_matrices(expr):
+    editor = _EditArrayContraction(expr)
+
+    flag = True
+    while flag:
+        flag = False
+        for arg_with_ind in editor.args_with_ind:
+            if isinstance(arg_with_ind.element, Identity):
+                k = arg_with_ind.element.shape[0]
+                # Candidate for removal:
+                if arg_with_ind.indices == [None, None]:
+                    # Free identity matrix, will be cleared by _remove_trivial_dims:
+                    continue
+                elif None in arg_with_ind.indices:
+                    ind = [j for j in arg_with_ind.indices if j is not None][0]
+                    counted = editor.count_args_with_index(ind)
+                    if counted == 1:
+                        # Identity matrix contracted only on one index with itself,
+                        # transform to a OneArray(k) element:
+                        editor.insert_after(arg_with_ind, OneArray(k))
+                        editor.args_with_ind.remove(arg_with_ind)
+                        flag = True
+                        break
+                    elif counted > 2:
+                        # Case counted = 2 is a matrix multiplication by identity matrix, skip it.
+                        # Case counted > 2 is a multiple contraction,
+                        # this is a case where the contraction becomes a diagonalization if the
+                        # identity matrix is dropped.
+                        continue
+                elif arg_with_ind.indices[0] == arg_with_ind.indices[1]:
+                    ind = arg_with_ind.indices[0]
+                    counted = editor.count_args_with_index(ind)
+                    if counted > 1:
+                        editor.args_with_ind.remove(arg_with_ind)
+                        flag = True
+                        break
+                    else:
+                        # This is a trace, skip it as it will be recognized somewhere else:
+                        pass
+            elif ask(Q.diagonal(arg_with_ind.element)):
+                if arg_with_ind.indices == [None, None]:
+                    continue
+                elif None in arg_with_ind.indices:
+                    pass
+                elif arg_with_ind.indices[0] == arg_with_ind.indices[1]:
+                    ind = arg_with_ind.indices[0]
+                    counted = editor.count_args_with_index(ind)
+                    if counted == 3:
+                        # A_ai B_bi D_ii ==> A_ai D_ij B_bj
+                        ind_new = editor.get_new_contraction_index()
+                        other_args = [j for j in editor.args_with_ind if j != arg_with_ind]
+                        other_args[1].indices = [ind_new if j == ind else j for j in other_args[1].indices]
+                        arg_with_ind.indices = [ind, ind_new]
+                        flag = True
+                        break
+
+    return editor.to_array_contraction()
+
+
+def remove_identity_matrices(expr: ArrayContraction):
+    editor = _EditArrayContraction(expr)
+    removed: list[int] = []
+
+    permutation_map = {}
+
+    free_indices = list(accumulate([0] + [sum(i is None for i in arg.indices) for arg in editor.args_with_ind]))
+    free_map = dict(zip(editor.args_with_ind, free_indices[:-1]))
+
+    update_pairs = {}
+
+    for ind in range(editor.number_of_contraction_indices):
+        args = editor.get_args_with_index(ind)
+        identity_matrices = [i for i in args if isinstance(i.element, Identity)]
+        number_identity_matrices = len(identity_matrices)
+        # If the contraction involves a non-identity matrix and multiple identity matrices:
+        if number_identity_matrices != len(args) - 1 or number_identity_matrices == 0:
+            continue
+        # Get the non-identity element:
+        non_identity = [i for i in args if not isinstance(i.element, Identity)][0]
+        # Check that all identity matrices have at least one free index
+        # (otherwise they would be contractions to some other elements)
+        if any(None not in i.indices for i in identity_matrices):
+            continue
+        # Mark the identity matrices for removal:
+        for i in identity_matrices:
+            i.element = None
+            removed.extend(range(free_map[i], free_map[i] + len([j for j in i.indices if j is None])))
+        last_removed = removed.pop(-1)
+        update_pairs[last_removed, ind] = non_identity.indices[:]
+        # Remove the indices from the non-identity matrix, as the contraction
+        # no longer exists:
+        non_identity.indices = [None if i == ind else i for i in non_identity.indices]
+
+    removed.sort()
+
+    shifts = list(accumulate([1 if i in removed else 0 for i in range(get_rank(expr))]))
+    for (last_removed, ind), non_identity_indices in update_pairs.items():
+        pos = [free_map[non_identity] + i for i, e in enumerate(non_identity_indices) if e == ind]
+        assert len(pos) == 1
+        for j in pos:
+            permutation_map[j] = last_removed
+
+    editor.args_with_ind = [i for i in editor.args_with_ind if i.element is not None]
+    ret_expr = editor.to_array_contraction()
+    permutation = []
+    counter = 0
+    counter2 = 0
+    for j in range(get_rank(expr)):
+        if j in removed:
+            continue
+        if counter2 in permutation_map:
+            target = permutation_map[counter2]
+            permutation.append(target - shifts[target])
+            counter2 += 1
+        else:
+            while counter in permutation_map.values():
+                counter += 1
+            permutation.append(counter)
+            counter += 1
+            counter2 += 1
+    ret_expr2 = _permute_dims(ret_expr, _af_invert(permutation))
+    return ret_expr2, removed
+
+
+def _combine_removed(dim: int, removed1: list[int], removed2: list[int]) -> list[int]:
+    # Concatenate two axis removal operations as performed by
+    # _remove_trivial_dims,
+    removed1 = sorted(removed1)
+    removed2 = sorted(removed2)
+    i = 0
+    j = 0
+    removed = []
+    while True:
+        if j >= len(removed2):
+            while i < len(removed1):
+                removed.append(removed1[i])
+                i += 1
+            break
+        elif i < len(removed1) and removed1[i] <= i + removed2[j]:
+            removed.append(removed1[i])
+            i += 1
+        else:
+            removed.append(i + removed2[j])
+            j += 1
+    return removed
+
+
+def _array_contraction_to_diagonal_multiple_identity(expr: ArrayContraction):
+    editor = _EditArrayContraction(expr)
+    editor.track_permutation_start()
+    removed: list[int] = []
+    diag_index_counter: int = 0
+    for i in range(editor.number_of_contraction_indices):
+        identities = []
+        args = []
+        for j, arg in enumerate(editor.args_with_ind):
+            if i not in arg.indices:
+                continue
+            if isinstance(arg.element, Identity):
+                identities.append(arg)
+            else:
+                args.append(arg)
+        if len(identities) == 0:
+            continue
+        if len(args) + len(identities) < 3:
+            continue
+        new_diag_ind = -1 - diag_index_counter
+        diag_index_counter += 1
+        # Variable "flag" to control whether to skip this contraction set:
+        flag: bool = True
+        for i1, id1 in enumerate(identities):
+            if None not in id1.indices:
+                flag = True
+                break
+            free_pos = list(range(*editor.get_absolute_free_range(id1)))[0]
+            editor._track_permutation[-1].append(free_pos) # type: ignore
+            id1.element = None
+            flag = False
+            break
+        if flag:
+            continue
+        for arg in identities[:i1] + identities[i1+1:]:
+            arg.element = None
+            removed.extend(range(*editor.get_absolute_free_range(arg)))
+        for arg in args:
+            arg.indices = [new_diag_ind if j == i else j for j in arg.indices]
+    for j, e in enumerate(editor.args_with_ind):
+        if e.element is None:
+            editor._track_permutation[j] = None # type: ignore
+    editor._track_permutation = [i for i in editor._track_permutation if i is not None] # type: ignore
+    # Renumber permutation array form in order to deal with deleted positions:
+    remap = {e: i for i, e in enumerate(sorted({k for j in editor._track_permutation for k in j}))}
+    editor._track_permutation = [[remap[j] for j in i] for i in editor._track_permutation]
+    editor.args_with_ind = [i for i in editor.args_with_ind if i.element is not None]
+    new_expr = editor.to_array_contraction()
+    return new_expr, removed
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/expressions/from_indexed_to_array.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/expressions/from_indexed_to_array.py
new file mode 100644
index 0000000000000000000000000000000000000000..c219a205c4305bd7070e5117978146224521c58c
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/expressions/from_indexed_to_array.py
@@ -0,0 +1,257 @@
+from collections import defaultdict
+
+from sympy import Function
+from sympy.combinatorics.permutations import _af_invert
+from sympy.concrete.summations import Sum
+from sympy.core.add import Add
+from sympy.core.mul import Mul
+from sympy.core.numbers import Integer
+from sympy.core.power import Pow
+from sympy.core.sorting import default_sort_key
+from sympy.functions.special.tensor_functions import KroneckerDelta
+from sympy.tensor.array.expressions import ArrayElementwiseApplyFunc
+from sympy.tensor.indexed import (Indexed, IndexedBase)
+from sympy.combinatorics import Permutation
+from sympy.matrices.expressions.matexpr import MatrixElement
+from sympy.tensor.array.expressions.array_expressions import ArrayDiagonal, \
+    get_shape, ArrayElement, _array_tensor_product, _array_diagonal, _array_contraction, _array_add, \
+    _permute_dims, OneArray, ArrayAdd
+from sympy.tensor.array.expressions.utils import _get_argindex, _get_diagonal_indices
+
+
+def convert_indexed_to_array(expr, first_indices=None):
+    r"""
+    Parse indexed expression into a form useful for code generation.
+
+    Examples
+    ========
+
+    >>> from sympy.tensor.array.expressions.from_indexed_to_array import convert_indexed_to_array
+    >>> from sympy import MatrixSymbol, Sum, symbols
+
+    >>> i, j, k, d = symbols("i j k d")
+    >>> M = MatrixSymbol("M", d, d)
+    >>> N = MatrixSymbol("N", d, d)
+
+    Recognize the trace in summation form:
+
+    >>> expr = Sum(M[i, i], (i, 0, d-1))
+    >>> convert_indexed_to_array(expr)
+    ArrayContraction(M, (0, 1))
+
+    Recognize the extraction of the diagonal by using the same index `i` on
+    both axes of the matrix:
+
+    >>> expr = M[i, i]
+    >>> convert_indexed_to_array(expr)
+    ArrayDiagonal(M, (0, 1))
+
+    This function can help perform the transformation expressed in two
+    different mathematical notations as:
+
+    `\sum_{j=0}^{N-1} A_{i,j} B_{j,k} \Longrightarrow \mathbf{A}\cdot \mathbf{B}`
+
+    Recognize the matrix multiplication in summation form:
+
+    >>> expr = Sum(M[i, j]*N[j, k], (j, 0, d-1))
+    >>> convert_indexed_to_array(expr)
+    ArrayContraction(ArrayTensorProduct(M, N), (1, 2))
+
+    Specify that ``k`` has to be the starting index:
+
+    >>> convert_indexed_to_array(expr, first_indices=[k])
+    ArrayContraction(ArrayTensorProduct(N, M), (0, 3))
+    """
+
+    result, indices = _convert_indexed_to_array(expr)
+
+    if any(isinstance(i, (int, Integer)) for i in indices):
+        result = ArrayElement(result, indices)
+        indices = []
+
+    if not first_indices:
+        return result
+
+    def _check_is_in(elem, indices):
+        if elem in indices:
+            return True
+        if any(elem in i for i in indices if isinstance(i, frozenset)):
+            return True
+        return False
+
+    repl = {j: i for i in indices if isinstance(i, frozenset) for j in i}
+    first_indices = [repl.get(i, i) for i in first_indices]
+    for i in first_indices:
+        if not _check_is_in(i, indices):
+            first_indices.remove(i)
+    first_indices.extend([i for i in indices if not _check_is_in(i, first_indices)])
+
+    def _get_pos(elem, indices):
+        if elem in indices:
+            return indices.index(elem)
+        for i, e in enumerate(indices):
+            if not isinstance(e, frozenset):
+                continue
+            if elem in e:
+                return i
+        raise ValueError("not found")
+
+    permutation = _af_invert([_get_pos(i, first_indices) for i in indices])
+    if isinstance(result, ArrayAdd):
+        return _array_add(*[_permute_dims(arg, permutation) for arg in result.args])
+    else:
+        return _permute_dims(result, permutation)
+
+
+def _convert_indexed_to_array(expr):
+    if isinstance(expr, Sum):
+        function = expr.function
+        summation_indices = expr.variables
+        subexpr, subindices = _convert_indexed_to_array(function)
+        subindicessets = {j: i for i in subindices if isinstance(i, frozenset) for j in i}
+        summation_indices = sorted({subindicessets.get(i, i) for i in summation_indices}, key=default_sort_key)
+        # TODO: check that Kronecker delta is only contracted to one other element:
+        kronecker_indices = set()
+        if isinstance(function, Mul):
+            for arg in function.args:
+                if not isinstance(arg, KroneckerDelta):
+                    continue
+                arg_indices = sorted(set(arg.indices), key=default_sort_key)
+                if len(arg_indices) == 2:
+                    kronecker_indices.update(arg_indices)
+        kronecker_indices = sorted(kronecker_indices, key=default_sort_key)
+        # Check dimensional consistency:
+        shape = get_shape(subexpr)
+        if shape:
+            for ind, istart, iend in expr.limits:
+                i = _get_argindex(subindices, ind)
+                if istart != 0 or iend+1 != shape[i]:
+                    raise ValueError("summation index and array dimension mismatch: %s" % ind)
+        contraction_indices = []
+        subindices = list(subindices)
+        if isinstance(subexpr, ArrayDiagonal):
+            diagonal_indices = list(subexpr.diagonal_indices)
+            dindices = subindices[-len(diagonal_indices):]
+            subindices = subindices[:-len(diagonal_indices)]
+            for index in summation_indices:
+                if index in dindices:
+                    position = dindices.index(index)
+                    contraction_indices.append(diagonal_indices[position])
+                    diagonal_indices[position] = None
+            diagonal_indices = [i for i in diagonal_indices if i is not None]
+            for i, ind in enumerate(subindices):
+                if ind in summation_indices:
+                    pass
+            if diagonal_indices:
+                subexpr = _array_diagonal(subexpr.expr, *diagonal_indices)
+            else:
+                subexpr = subexpr.expr
+
+        axes_contraction = defaultdict(list)
+        for i, ind in enumerate(subindices):
+            include = all(j not in kronecker_indices for j in ind) if isinstance(ind, frozenset) else ind not in kronecker_indices
+            if ind in summation_indices and include:
+                axes_contraction[ind].append(i)
+                subindices[i] = None
+        for k, v in axes_contraction.items():
+            if any(i in kronecker_indices for i in k) if isinstance(k, frozenset) else k in kronecker_indices:
+                continue
+            contraction_indices.append(tuple(v))
+        free_indices = [i for i in subindices if i is not None]
+        indices_ret = list(free_indices)
+        indices_ret.sort(key=lambda x: free_indices.index(x))
+        return _array_contraction(
+                subexpr,
+                *contraction_indices,
+                free_indices=free_indices
+            ), tuple(indices_ret)
+    if isinstance(expr, Mul):
+        args, indices = zip(*[_convert_indexed_to_array(arg) for arg in expr.args])
+        # Check if there are KroneckerDelta objects:
+        kronecker_delta_repl = {}
+        for arg in args:
+            if not isinstance(arg, KroneckerDelta):
+                continue
+            # Diagonalize two indices:
+            i, j = arg.indices
+            kindices = set(arg.indices)
+            if i in kronecker_delta_repl:
+                kindices.update(kronecker_delta_repl[i])
+            if j in kronecker_delta_repl:
+                kindices.update(kronecker_delta_repl[j])
+            kindices = frozenset(kindices)
+            for index in kindices:
+                kronecker_delta_repl[index] = kindices
+        # Remove KroneckerDelta objects, their relations should be handled by
+        # ArrayDiagonal:
+        newargs = []
+        newindices = []
+        for arg, loc_indices in zip(args, indices):
+            if isinstance(arg, KroneckerDelta):
+                continue
+            newargs.append(arg)
+            newindices.append(loc_indices)
+        flattened_indices = [kronecker_delta_repl.get(j, j) for i in newindices for j in i]
+        diagonal_indices, ret_indices = _get_diagonal_indices(flattened_indices)
+        tp = _array_tensor_product(*newargs)
+        if diagonal_indices:
+            return _array_diagonal(tp, *diagonal_indices), ret_indices
+        else:
+            return tp, ret_indices
+    if isinstance(expr, MatrixElement):
+        indices = expr.args[1:]
+        diagonal_indices, ret_indices = _get_diagonal_indices(indices)
+        if diagonal_indices:
+            return _array_diagonal(expr.args[0], *diagonal_indices), ret_indices
+        else:
+            return expr.args[0], ret_indices
+    if isinstance(expr, ArrayElement):
+        indices = expr.indices
+        diagonal_indices, ret_indices = _get_diagonal_indices(indices)
+        if diagonal_indices:
+            return _array_diagonal(expr.name, *diagonal_indices), ret_indices
+        else:
+            return expr.name, ret_indices
+    if isinstance(expr, Indexed):
+        indices = expr.indices
+        diagonal_indices, ret_indices = _get_diagonal_indices(indices)
+        if diagonal_indices:
+            return _array_diagonal(expr.base, *diagonal_indices), ret_indices
+        else:
+            return expr.args[0], ret_indices
+    if isinstance(expr, IndexedBase):
+        raise NotImplementedError
+    if isinstance(expr, KroneckerDelta):
+        return expr, expr.indices
+    if isinstance(expr, Add):
+        args, indices = zip(*[_convert_indexed_to_array(arg) for arg in expr.args])
+        args = list(args)
+        # Check if all indices are compatible. Otherwise expand the dimensions:
+        index0 = []
+        shape0 = []
+        for arg, arg_indices in zip(args, indices):
+            arg_indices_set = set(arg_indices)
+            arg_indices_missing = arg_indices_set.difference(index0)
+            index0.extend([i for i in arg_indices if i in arg_indices_missing])
+            arg_shape = get_shape(arg)
+            shape0.extend([arg_shape[i] for i, e in enumerate(arg_indices) if e in arg_indices_missing])
+        for i, (arg, arg_indices) in enumerate(zip(args, indices)):
+            if len(arg_indices) < len(index0):
+                missing_indices_pos = [i for i, e in enumerate(index0) if e not in arg_indices]
+                missing_shape = [shape0[i] for i in missing_indices_pos]
+                arg_indices = tuple(index0[j] for j in missing_indices_pos) + arg_indices
+                args[i] = _array_tensor_product(OneArray(*missing_shape), args[i])
+            permutation = Permutation([arg_indices.index(j) for j in index0])
+            # Perform index permutations:
+            args[i] = _permute_dims(args[i], permutation)
+        return _array_add(*args), tuple(index0)
+    if isinstance(expr, Pow):
+        subexpr, subindices = _convert_indexed_to_array(expr.base)
+        if isinstance(expr.exp, (int, Integer)):
+            diags = zip(*[(2*i, 2*i + 1) for i in range(expr.exp)])
+            arr = _array_diagonal(_array_tensor_product(*[subexpr for i in range(expr.exp)]), *diags)
+            return arr, subindices
+    if isinstance(expr, Function):
+        subexpr, subindices = _convert_indexed_to_array(expr.args[0])
+        return ArrayElementwiseApplyFunc(type(expr), subexpr), subindices
+    return expr, ()
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/expressions/from_matrix_to_array.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/expressions/from_matrix_to_array.py
new file mode 100644
index 0000000000000000000000000000000000000000..8f66961727f6338318d65876a7768802773e4f2d
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/expressions/from_matrix_to_array.py
@@ -0,0 +1,87 @@
+from sympy import KroneckerProduct
+from sympy.core.basic import Basic
+from sympy.core.function import Lambda
+from sympy.core.mul import Mul
+from sympy.core.numbers import Integer
+from sympy.core.power import Pow
+from sympy.core.singleton import S
+from sympy.core.symbol import (Dummy, symbols)
+from sympy.matrices.expressions.hadamard import (HadamardPower, HadamardProduct)
+from sympy.matrices.expressions.matadd import MatAdd
+from sympy.matrices.expressions.matmul import MatMul
+from sympy.matrices.expressions.matpow import MatPow
+from sympy.matrices.expressions.trace import Trace
+from sympy.matrices.expressions.transpose import Transpose
+from sympy.matrices.expressions.matexpr import MatrixExpr
+from sympy.tensor.array.expressions.array_expressions import \
+    ArrayElementwiseApplyFunc, _array_tensor_product, _array_contraction, \
+    _array_diagonal, _array_add, _permute_dims, Reshape
+
+
+def convert_matrix_to_array(expr: Basic) -> Basic:
+    if isinstance(expr, MatMul):
+        args_nonmat = []
+        args = []
+        for arg in expr.args:
+            if isinstance(arg, MatrixExpr):
+                args.append(arg)
+            else:
+                args_nonmat.append(convert_matrix_to_array(arg))
+        contractions = [(2*i+1, 2*i+2) for i in range(len(args)-1)]
+        scalar = _array_tensor_product(*args_nonmat) if args_nonmat else S.One
+        if scalar == 1:
+            tprod = _array_tensor_product(
+                *[convert_matrix_to_array(arg) for arg in args])
+        else:
+            tprod = _array_tensor_product(
+                scalar,
+                *[convert_matrix_to_array(arg) for arg in args])
+        return _array_contraction(
+                tprod,
+                *contractions
+        )
+    elif isinstance(expr, MatAdd):
+        return _array_add(
+                *[convert_matrix_to_array(arg) for arg in expr.args]
+        )
+    elif isinstance(expr, Transpose):
+        return _permute_dims(
+                convert_matrix_to_array(expr.args[0]), [1, 0]
+        )
+    elif isinstance(expr, Trace):
+        inner_expr: MatrixExpr = convert_matrix_to_array(expr.arg) # type: ignore
+        return _array_contraction(inner_expr, (0, len(inner_expr.shape) - 1))
+    elif isinstance(expr, Mul):
+        return _array_tensor_product(*[convert_matrix_to_array(i) for i in expr.args])
+    elif isinstance(expr, Pow):
+        base = convert_matrix_to_array(expr.base)
+        if (expr.exp > 0) == True:
+            return _array_tensor_product(*[base for i in range(expr.exp)])
+        else:
+            return expr
+    elif isinstance(expr, MatPow):
+        base = convert_matrix_to_array(expr.base)
+        if expr.exp.is_Integer != True:
+            b = symbols("b", cls=Dummy)
+            return ArrayElementwiseApplyFunc(Lambda(b, b**expr.exp), convert_matrix_to_array(base))
+        elif (expr.exp > 0) == True:
+            return convert_matrix_to_array(MatMul.fromiter(base for i in range(expr.exp)))
+        else:
+            return expr
+    elif isinstance(expr, HadamardProduct):
+        tp = _array_tensor_product(*[convert_matrix_to_array(arg) for arg in expr.args])
+        diag = [[2*i for i in range(len(expr.args))], [2*i+1 for i in range(len(expr.args))]]
+        return _array_diagonal(tp, *diag)
+    elif isinstance(expr, HadamardPower):
+        base, exp = expr.args
+        if isinstance(exp, Integer) and exp > 0:
+            return convert_matrix_to_array(HadamardProduct.fromiter(base for i in range(exp)))
+        else:
+            d = Dummy("d")
+            return ArrayElementwiseApplyFunc(Lambda(d, d**exp), base)
+    elif isinstance(expr, KroneckerProduct):
+        kp_args = [convert_matrix_to_array(arg) for arg in expr.args]
+        permutation = [2*i for i in range(len(kp_args))] + [2*i + 1 for i in range(len(kp_args))]
+        return Reshape(_permute_dims(_array_tensor_product(*kp_args), permutation), expr.shape)
+    else:
+        return expr
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/expressions/tests/__init__.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/expressions/tests/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/expressions/tests/__pycache__/__init__.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/expressions/tests/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..20db15f6876759b80814f0e86ba90e919f058dde
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/expressions/tests/__pycache__/__init__.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/expressions/tests/__pycache__/test_array_expressions.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/expressions/tests/__pycache__/test_array_expressions.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..9d64dc6d51e6df5e5b40ad7a1930987911eb0298
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/expressions/tests/__pycache__/test_array_expressions.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/expressions/tests/__pycache__/test_arrayexpr_derivatives.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/expressions/tests/__pycache__/test_arrayexpr_derivatives.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..2bf17bc9ee529c7ccd61ebf6d5c60f1044eeb394
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/expressions/tests/__pycache__/test_arrayexpr_derivatives.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/expressions/tests/__pycache__/test_as_explicit.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/expressions/tests/__pycache__/test_as_explicit.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f98a06f072151c658a8c938299f1ff42b35d8c05
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/expressions/tests/__pycache__/test_as_explicit.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/expressions/tests/__pycache__/test_convert_array_to_indexed.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/expressions/tests/__pycache__/test_convert_array_to_indexed.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..7de744e69f2f0bd0ba36262bca6934a467a8dff3
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/expressions/tests/__pycache__/test_convert_array_to_indexed.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/expressions/tests/__pycache__/test_convert_array_to_matrix.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/expressions/tests/__pycache__/test_convert_array_to_matrix.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..9a1e601b3df12a2dd852c3a4c21a930bf507fd12
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/expressions/tests/__pycache__/test_convert_array_to_matrix.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/expressions/tests/__pycache__/test_convert_indexed_to_array.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/expressions/tests/__pycache__/test_convert_indexed_to_array.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..dc405ca4076a42f46753fc40596a3b7ce14d59de
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/expressions/tests/__pycache__/test_convert_indexed_to_array.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/expressions/tests/__pycache__/test_convert_matrix_to_array.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/expressions/tests/__pycache__/test_convert_matrix_to_array.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f97187ffb4e3ffa9b0d06432bd3d11690cee0795
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/expressions/tests/__pycache__/test_convert_matrix_to_array.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/expressions/tests/__pycache__/test_deprecated_conv_modules.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/expressions/tests/__pycache__/test_deprecated_conv_modules.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f0176b5a7ce371e7e3c07f01b803350f17e94df4
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/expressions/tests/__pycache__/test_deprecated_conv_modules.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/expressions/tests/test_array_expressions.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/expressions/tests/test_array_expressions.py
new file mode 100644
index 0000000000000000000000000000000000000000..63fb79ab7ced7bff5ecb55b1764f43e29f98609d
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/expressions/tests/test_array_expressions.py
@@ -0,0 +1,808 @@
+import random
+
+from sympy import tensordiagonal, eye, KroneckerDelta, Array
+from sympy.core.symbol import symbols
+from sympy.functions.elementary.trigonometric import (cos, sin)
+from sympy.matrices.expressions.diagonal import DiagMatrix
+from sympy.matrices.expressions.matexpr import MatrixSymbol
+from sympy.matrices.expressions.special import ZeroMatrix
+from sympy.tensor.array.arrayop import (permutedims, tensorcontraction, tensorproduct)
+from sympy.tensor.array.dense_ndim_array import ImmutableDenseNDimArray
+from sympy.combinatorics import Permutation
+from sympy.tensor.array.expressions.array_expressions import ZeroArray, OneArray, ArraySymbol, ArrayElement, \
+    PermuteDims, ArrayContraction, ArrayTensorProduct, ArrayDiagonal, \
+    ArrayAdd, nest_permutation, ArrayElementwiseApplyFunc, _EditArrayContraction, _ArgE, _array_tensor_product, \
+    _array_contraction, _array_diagonal, _array_add, _permute_dims, Reshape
+from sympy.testing.pytest import raises
+
+i, j, k, l, m, n = symbols("i j k l m n")
+
+
+M = ArraySymbol("M", (k, k))
+N = ArraySymbol("N", (k, k))
+P = ArraySymbol("P", (k, k))
+Q = ArraySymbol("Q", (k, k))
+
+A = ArraySymbol("A", (k, k))
+B = ArraySymbol("B", (k, k))
+C = ArraySymbol("C", (k, k))
+D = ArraySymbol("D", (k, k))
+
+X = ArraySymbol("X", (k, k))
+Y = ArraySymbol("Y", (k, k))
+
+a = ArraySymbol("a", (k, 1))
+b = ArraySymbol("b", (k, 1))
+c = ArraySymbol("c", (k, 1))
+d = ArraySymbol("d", (k, 1))
+
+
+def test_array_symbol_and_element():
+    A = ArraySymbol("A", (2,))
+    A0 = ArrayElement(A, (0,))
+    A1 = ArrayElement(A, (1,))
+    assert A[0] == A0
+    assert A[1] != A0
+    assert A.as_explicit() == ImmutableDenseNDimArray([A0, A1])
+
+    A2 = tensorproduct(A, A)
+    assert A2.shape == (2, 2)
+    # TODO: not yet supported:
+    # assert A2.as_explicit() == Array([[A[0]*A[0], A[1]*A[0]], [A[0]*A[1], A[1]*A[1]]])
+    A3 = tensorcontraction(A2, (0, 1))
+    assert A3.shape == ()
+    # TODO: not yet supported:
+    # assert A3.as_explicit() == Array([])
+
+    A = ArraySymbol("A", (2, 3, 4))
+    Ae = A.as_explicit()
+    assert Ae == ImmutableDenseNDimArray(
+        [[[ArrayElement(A, (i, j, k)) for k in range(4)] for j in range(3)] for i in range(2)])
+
+    p = _permute_dims(A, Permutation(0, 2, 1))
+    assert isinstance(p, PermuteDims)
+
+    A = ArraySymbol("A", (2,))
+    raises(IndexError, lambda: A[()])
+    raises(IndexError, lambda: A[0, 1])
+    raises(ValueError, lambda: A[-1])
+    raises(ValueError, lambda: A[2])
+
+    O = OneArray(3, 4)
+    Z = ZeroArray(m, n)
+
+    raises(IndexError, lambda: O[()])
+    raises(IndexError, lambda: O[1, 2, 3])
+    raises(ValueError, lambda: O[3, 0])
+    raises(ValueError, lambda: O[0, 4])
+
+    assert O[1, 2] == 1
+    assert Z[1, 2] == 0
+
+
+def test_zero_array():
+    assert ZeroArray() == 0
+    assert ZeroArray().is_Integer
+
+    za = ZeroArray(3, 2, 4)
+    assert za.shape == (3, 2, 4)
+    za_e = za.as_explicit()
+    assert za_e.shape == (3, 2, 4)
+
+    m, n, k = symbols("m n k")
+    za = ZeroArray(m, n, k, 2)
+    assert za.shape == (m, n, k, 2)
+    raises(ValueError, lambda: za.as_explicit())
+
+
+def test_one_array():
+    assert OneArray() == 1
+    assert OneArray().is_Integer
+
+    oa = OneArray(3, 2, 4)
+    assert oa.shape == (3, 2, 4)
+    oa_e = oa.as_explicit()
+    assert oa_e.shape == (3, 2, 4)
+
+    m, n, k = symbols("m n k")
+    oa = OneArray(m, n, k, 2)
+    assert oa.shape == (m, n, k, 2)
+    raises(ValueError, lambda: oa.as_explicit())
+
+
+def test_arrayexpr_contraction_construction():
+
+    cg = _array_contraction(A)
+    assert cg == A
+
+    cg = _array_contraction(_array_tensor_product(A, B), (1, 0))
+    assert cg == _array_contraction(_array_tensor_product(A, B), (0, 1))
+
+    cg = _array_contraction(_array_tensor_product(M, N), (0, 1))
+    indtup = cg._get_contraction_tuples()
+    assert indtup == [[(0, 0), (0, 1)]]
+    assert cg._contraction_tuples_to_contraction_indices(cg.expr, indtup) == [(0, 1)]
+
+    cg = _array_contraction(_array_tensor_product(M, N), (1, 2))
+    indtup = cg._get_contraction_tuples()
+    assert indtup == [[(0, 1), (1, 0)]]
+    assert cg._contraction_tuples_to_contraction_indices(cg.expr, indtup) == [(1, 2)]
+
+    cg = _array_contraction(_array_tensor_product(M, M, N), (1, 4), (2, 5))
+    indtup = cg._get_contraction_tuples()
+    assert indtup == [[(0, 0), (1, 1)], [(0, 1), (2, 0)]]
+    assert cg._contraction_tuples_to_contraction_indices(cg.expr, indtup) == [(0, 3), (1, 4)]
+
+    # Test removal of trivial contraction:
+    assert _array_contraction(a, (1,)) == a
+    assert _array_contraction(
+        _array_tensor_product(a, b), (0, 2), (1,), (3,)) == _array_contraction(
+        _array_tensor_product(a, b), (0, 2))
+
+
+def test_arrayexpr_array_flatten():
+
+    # Flatten nested ArrayTensorProduct objects:
+    expr1 = _array_tensor_product(M, N)
+    expr2 = _array_tensor_product(P, Q)
+    expr = _array_tensor_product(expr1, expr2)
+    assert expr == _array_tensor_product(M, N, P, Q)
+    assert expr.args == (M, N, P, Q)
+
+    # Flatten mixed ArrayTensorProduct and ArrayContraction objects:
+    cg1 = _array_contraction(expr1, (1, 2))
+    cg2 = _array_contraction(expr2, (0, 3))
+
+    expr = _array_tensor_product(cg1, cg2)
+    assert expr == _array_contraction(_array_tensor_product(M, N, P, Q), (1, 2), (4, 7))
+
+    expr = _array_tensor_product(M, cg1)
+    assert expr == _array_contraction(_array_tensor_product(M, M, N), (3, 4))
+
+    # Flatten nested ArrayContraction objects:
+    cgnested = _array_contraction(cg1, (0, 1))
+    assert cgnested == _array_contraction(_array_tensor_product(M, N), (0, 3), (1, 2))
+
+    cgnested = _array_contraction(_array_tensor_product(cg1, cg2), (0, 3))
+    assert cgnested == _array_contraction(_array_tensor_product(M, N, P, Q), (0, 6), (1, 2), (4, 7))
+
+    cg3 = _array_contraction(_array_tensor_product(M, N, P, Q), (1, 3), (2, 4))
+    cgnested = _array_contraction(cg3, (0, 1))
+    assert cgnested == _array_contraction(_array_tensor_product(M, N, P, Q), (0, 5), (1, 3), (2, 4))
+
+    cgnested = _array_contraction(cg3, (0, 3), (1, 2))
+    assert cgnested == _array_contraction(_array_tensor_product(M, N, P, Q), (0, 7), (1, 3), (2, 4), (5, 6))
+
+    cg4 = _array_contraction(_array_tensor_product(M, N, P, Q), (1, 5), (3, 7))
+    cgnested = _array_contraction(cg4, (0, 1))
+    assert cgnested == _array_contraction(_array_tensor_product(M, N, P, Q), (0, 2), (1, 5), (3, 7))
+
+    cgnested = _array_contraction(cg4, (0, 1), (2, 3))
+    assert cgnested == _array_contraction(_array_tensor_product(M, N, P, Q), (0, 2), (1, 5), (3, 7), (4, 6))
+
+    cg = _array_diagonal(cg4)
+    assert cg == cg4
+    assert isinstance(cg, type(cg4))
+
+    # Flatten nested ArrayDiagonal objects:
+    cg1 = _array_diagonal(expr1, (1, 2))
+    cg2 = _array_diagonal(expr2, (0, 3))
+    cg3 = _array_diagonal(_array_tensor_product(M, N, P, Q), (1, 3), (2, 4))
+    cg4 = _array_diagonal(_array_tensor_product(M, N, P, Q), (1, 5), (3, 7))
+
+    cgnested = _array_diagonal(cg1, (0, 1))
+    assert cgnested == _array_diagonal(_array_tensor_product(M, N), (1, 2), (0, 3))
+
+    cgnested = _array_diagonal(cg3, (1, 2))
+    assert cgnested == _array_diagonal(_array_tensor_product(M, N, P, Q), (1, 3), (2, 4), (5, 6))
+
+    cgnested = _array_diagonal(cg4, (1, 2))
+    assert cgnested == _array_diagonal(_array_tensor_product(M, N, P, Q), (1, 5), (3, 7), (2, 4))
+
+    cg = _array_add(M, N)
+    cg2 = _array_add(cg, P)
+    assert isinstance(cg2, ArrayAdd)
+    assert cg2.args == (M, N, P)
+    assert cg2.shape == (k, k)
+
+    expr = _array_tensor_product(_array_diagonal(X, (0, 1)), _array_diagonal(A, (0, 1)))
+    assert expr == _array_diagonal(_array_tensor_product(X, A), (0, 1), (2, 3))
+
+    expr1 = _array_diagonal(_array_tensor_product(X, A), (1, 2))
+    expr2 = _array_tensor_product(expr1, a)
+    assert expr2 == _permute_dims(_array_diagonal(_array_tensor_product(X, A, a), (1, 2)), [0, 1, 4, 2, 3])
+
+    expr1 = _array_contraction(_array_tensor_product(X, A), (1, 2))
+    expr2 = _array_tensor_product(expr1, a)
+    assert isinstance(expr2, ArrayContraction)
+    assert isinstance(expr2.expr, ArrayTensorProduct)
+
+    cg = _array_tensor_product(_array_diagonal(_array_tensor_product(A, X, Y), (0, 3), (1, 5)), a, b)
+    assert cg == _permute_dims(_array_diagonal(_array_tensor_product(A, X, Y, a, b), (0, 3), (1, 5)), [0, 1, 6, 7, 2, 3, 4, 5])
+
+
+def test_arrayexpr_array_diagonal():
+    cg = _array_diagonal(M, (1, 0))
+    assert cg == _array_diagonal(M, (0, 1))
+
+    cg = _array_diagonal(_array_tensor_product(M, N, P), (4, 1), (2, 0))
+    assert cg == _array_diagonal(_array_tensor_product(M, N, P), (1, 4), (0, 2))
+
+    cg = _array_diagonal(_array_tensor_product(M, N), (1, 2), (3,), allow_trivial_diags=True)
+    assert cg == _permute_dims(_array_diagonal(_array_tensor_product(M, N), (1, 2)), [0, 2, 1])
+
+    Ax = ArraySymbol("Ax", shape=(1, 2, 3, 4, 3, 5, 6, 2, 7))
+    cg = _array_diagonal(Ax, (1, 7), (3,), (2, 4), (6,), allow_trivial_diags=True)
+    assert cg == _permute_dims(_array_diagonal(Ax, (1, 7), (2, 4)), [0, 2, 4, 5, 1, 6, 3])
+
+    cg = _array_diagonal(M, (0,), allow_trivial_diags=True)
+    assert cg == _permute_dims(M, [1, 0])
+
+    raises(ValueError, lambda: _array_diagonal(M, (0, 0)))
+
+
+def test_arrayexpr_array_shape():
+    expr = _array_tensor_product(M, N, P, Q)
+    assert expr.shape == (k, k, k, k, k, k, k, k)
+    Z = MatrixSymbol("Z", m, n)
+    expr = _array_tensor_product(M, Z)
+    assert expr.shape == (k, k, m, n)
+    expr2 = _array_contraction(expr, (0, 1))
+    assert expr2.shape == (m, n)
+    expr2 = _array_diagonal(expr, (0, 1))
+    assert expr2.shape == (m, n, k)
+    exprp = _permute_dims(expr, [2, 1, 3, 0])
+    assert exprp.shape == (m, k, n, k)
+    expr3 = _array_tensor_product(N, Z)
+    expr2 = _array_add(expr, expr3)
+    assert expr2.shape == (k, k, m, n)
+
+    # Contraction along axes with discordant dimensions:
+    raises(ValueError, lambda: _array_contraction(expr, (1, 2)))
+    # Also diagonal needs the same dimensions:
+    raises(ValueError, lambda: _array_diagonal(expr, (1, 2)))
+    # Diagonal requires at least to axes to compute the diagonal:
+    raises(ValueError, lambda: _array_diagonal(expr, (1,)))
+
+
+def test_arrayexpr_permutedims_sink():
+
+    cg = _permute_dims(_array_tensor_product(M, N), [0, 1, 3, 2], nest_permutation=False)
+    sunk = nest_permutation(cg)
+    assert sunk == _array_tensor_product(M, _permute_dims(N, [1, 0]))
+
+    cg = _permute_dims(_array_tensor_product(M, N), [1, 0, 3, 2], nest_permutation=False)
+    sunk = nest_permutation(cg)
+    assert sunk == _array_tensor_product(_permute_dims(M, [1, 0]), _permute_dims(N, [1, 0]))
+
+    cg = _permute_dims(_array_tensor_product(M, N), [3, 2, 1, 0], nest_permutation=False)
+    sunk = nest_permutation(cg)
+    assert sunk == _array_tensor_product(_permute_dims(N, [1, 0]), _permute_dims(M, [1, 0]))
+
+    cg = _permute_dims(_array_contraction(_array_tensor_product(M, N), (1, 2)), [1, 0], nest_permutation=False)
+    sunk = nest_permutation(cg)
+    assert sunk == _array_contraction(_permute_dims(_array_tensor_product(M, N), [[0, 3]]), (1, 2))
+
+    cg = _permute_dims(_array_tensor_product(M, N), [1, 0, 3, 2], nest_permutation=False)
+    sunk = nest_permutation(cg)
+    assert sunk == _array_tensor_product(_permute_dims(M, [1, 0]), _permute_dims(N, [1, 0]))
+
+    cg = _permute_dims(_array_contraction(_array_tensor_product(M, N, P), (1, 2), (3, 4)), [1, 0], nest_permutation=False)
+    sunk = nest_permutation(cg)
+    assert sunk == _array_contraction(_permute_dims(_array_tensor_product(M, N, P), [[0, 5]]), (1, 2), (3, 4))
+
+
+def test_arrayexpr_push_indices_up_and_down():
+
+    indices = list(range(12))
+
+    contr_diag_indices = [(0, 6), (2, 8)]
+    assert ArrayContraction._push_indices_down(contr_diag_indices, indices) == (1, 3, 4, 5, 7, 9, 10, 11, 12, 13, 14, 15)
+    assert ArrayContraction._push_indices_up(contr_diag_indices, indices) == (None, 0, None, 1, 2, 3, None, 4, None, 5, 6, 7)
+
+    assert ArrayDiagonal._push_indices_down(contr_diag_indices, indices, 10) == (1, 3, 4, 5, 7, 9, (0, 6), (2, 8), None, None, None, None)
+    assert ArrayDiagonal._push_indices_up(contr_diag_indices, indices, 10) == (6, 0, 7, 1, 2, 3, 6, 4, 7, 5, None, None)
+
+    contr_diag_indices = [(1, 2), (7, 8)]
+    assert ArrayContraction._push_indices_down(contr_diag_indices, indices) == (0, 3, 4, 5, 6, 9, 10, 11, 12, 13, 14, 15)
+    assert ArrayContraction._push_indices_up(contr_diag_indices, indices) == (0, None, None, 1, 2, 3, 4, None, None, 5, 6, 7)
+
+    assert ArrayDiagonal._push_indices_down(contr_diag_indices, indices, 10) == (0, 3, 4, 5, 6, 9, (1, 2), (7, 8), None, None, None, None)
+    assert ArrayDiagonal._push_indices_up(contr_diag_indices, indices, 10) == (0, 6, 6, 1, 2, 3, 4, 7, 7, 5, None, None)
+
+
+def test_arrayexpr_split_multiple_contractions():
+    a = MatrixSymbol("a", k, 1)
+    b = MatrixSymbol("b", k, 1)
+    A = MatrixSymbol("A", k, k)
+    B = MatrixSymbol("B", k, k)
+    C = MatrixSymbol("C", k, k)
+    X = MatrixSymbol("X", k, k)
+
+    cg = _array_contraction(_array_tensor_product(A.T, a, b, b.T, (A*X*b).applyfunc(cos)), (1, 2, 8), (5, 6, 9))
+    expected = _array_contraction(_array_tensor_product(A.T, DiagMatrix(a), OneArray(1), b, b.T, (A*X*b).applyfunc(cos)), (1, 3), (2, 9), (6, 7, 10))
+    assert cg.split_multiple_contractions().dummy_eq(expected)
+
+    # Check no overlap of lines:
+
+    cg = _array_contraction(_array_tensor_product(A, a, C, a, B), (1, 2, 4), (5, 6, 8), (3, 7))
+    assert cg.split_multiple_contractions() == cg
+
+    cg = _array_contraction(_array_tensor_product(a, b, A), (0, 2, 4), (1, 3))
+    assert cg.split_multiple_contractions() == cg
+
+
+def test_arrayexpr_nested_permutations():
+
+    cg = _permute_dims(_permute_dims(M, (1, 0)), (1, 0))
+    assert cg == M
+
+    times = 3
+    plist1 = [list(range(6)) for i in range(times)]
+    plist2 = [list(range(6)) for i in range(times)]
+
+    for i in range(times):
+        random.shuffle(plist1[i])
+        random.shuffle(plist2[i])
+
+    plist1.append([2, 5, 4, 1, 0, 3])
+    plist2.append([3, 5, 0, 4, 1, 2])
+
+    plist1.append([2, 5, 4, 0, 3, 1])
+    plist2.append([3, 0, 5, 1, 2, 4])
+
+    plist1.append([5, 4, 2, 0, 3, 1])
+    plist2.append([4, 5, 0, 2, 3, 1])
+
+    Me = M.subs(k, 3).as_explicit()
+    Ne = N.subs(k, 3).as_explicit()
+    Pe = P.subs(k, 3).as_explicit()
+    cge = tensorproduct(Me, Ne, Pe)
+
+    for permutation_array1, permutation_array2 in zip(plist1, plist2):
+        p1 = Permutation(permutation_array1)
+        p2 = Permutation(permutation_array2)
+
+        cg = _permute_dims(
+            _permute_dims(
+                _array_tensor_product(M, N, P),
+                p1),
+            p2
+        )
+        result = _permute_dims(
+            _array_tensor_product(M, N, P),
+            p2*p1
+        )
+        assert cg == result
+
+        # Check that `permutedims` behaves the same way with explicit-component arrays:
+        result1 = _permute_dims(_permute_dims(cge, p1), p2)
+        result2 = _permute_dims(cge, p2*p1)
+        assert result1 == result2
+
+
+def test_arrayexpr_contraction_permutation_mix():
+
+    Me = M.subs(k, 3).as_explicit()
+    Ne = N.subs(k, 3).as_explicit()
+
+    cg1 = _array_contraction(PermuteDims(_array_tensor_product(M, N), Permutation([0, 2, 1, 3])), (2, 3))
+    cg2 = _array_contraction(_array_tensor_product(M, N), (1, 3))
+    assert cg1 == cg2
+    cge1 = tensorcontraction(permutedims(tensorproduct(Me, Ne), Permutation([0, 2, 1, 3])), (2, 3))
+    cge2 = tensorcontraction(tensorproduct(Me, Ne), (1, 3))
+    assert cge1 == cge2
+
+    cg1 = _permute_dims(_array_tensor_product(M, N), Permutation([0, 1, 3, 2]))
+    cg2 = _array_tensor_product(M, _permute_dims(N, Permutation([1, 0])))
+    assert cg1 == cg2
+
+    cg1 = _array_contraction(
+        _permute_dims(
+            _array_tensor_product(M, N, P, Q), Permutation([0, 2, 3, 1, 4, 5, 7, 6])),
+        (1, 2), (3, 5)
+    )
+    cg2 = _array_contraction(
+        _array_tensor_product(M, N, P, _permute_dims(Q, Permutation([1, 0]))),
+        (1, 5), (2, 3)
+    )
+    assert cg1 == cg2
+
+    cg1 = _array_contraction(
+        _permute_dims(
+            _array_tensor_product(M, N, P, Q), Permutation([1, 0, 4, 6, 2, 7, 5, 3])),
+        (0, 1), (2, 6), (3, 7)
+    )
+    cg2 = _permute_dims(
+        _array_contraction(
+            _array_tensor_product(M, P, Q, N),
+            (0, 1), (2, 3), (4, 7)),
+        [1, 0]
+    )
+    assert cg1 == cg2
+
+    cg1 = _array_contraction(
+        _permute_dims(
+            _array_tensor_product(M, N, P, Q), Permutation([1, 0, 4, 6, 7, 2, 5, 3])),
+        (0, 1), (2, 6), (3, 7)
+    )
+    cg2 = _permute_dims(
+        _array_contraction(
+            _array_tensor_product(_permute_dims(M, [1, 0]), N, P, Q),
+            (0, 1), (3, 6), (4, 5)
+        ),
+        Permutation([1, 0])
+    )
+    assert cg1 == cg2
+
+
+def test_arrayexpr_permute_tensor_product():
+    cg1 = _permute_dims(_array_tensor_product(M, N, P, Q), Permutation([2, 3, 1, 0, 5, 4, 6, 7]))
+    cg2 = _array_tensor_product(N, _permute_dims(M, [1, 0]),
+                                    _permute_dims(P, [1, 0]), Q)
+    assert cg1 == cg2
+
+    # TODO: reverse operation starting with `PermuteDims` and getting down to `bb`...
+    cg1 = _permute_dims(_array_tensor_product(M, N, P, Q), Permutation([2, 3, 4, 5, 0, 1, 6, 7]))
+    cg2 = _array_tensor_product(N, P, M, Q)
+    assert cg1 == cg2
+
+    cg1 = _permute_dims(_array_tensor_product(M, N, P, Q), Permutation([2, 3, 4, 6, 5, 7, 0, 1]))
+    assert cg1.expr == _array_tensor_product(N, P, Q, M)
+    assert cg1.permutation == Permutation([0, 1, 2, 4, 3, 5, 6, 7])
+
+    cg1 = _array_contraction(
+        _permute_dims(
+            _array_tensor_product(N, Q, Q, M),
+            [2, 1, 5, 4, 0, 3, 6, 7]),
+        [1, 2, 6])
+    cg2 = _permute_dims(_array_contraction(_array_tensor_product(Q, Q, N, M), (3, 5, 6)), [0, 2, 3, 1, 4])
+    assert cg1 == cg2
+
+    cg1 = _array_contraction(
+        _array_contraction(
+            _array_contraction(
+                _array_contraction(
+                    _permute_dims(
+                        _array_tensor_product(N, Q, Q, M),
+                        [2, 1, 5, 4, 0, 3, 6, 7]),
+                    [1, 2, 6]),
+                [1, 3, 4]),
+            [1]),
+        [0])
+    cg2 = _array_contraction(_array_tensor_product(M, N, Q, Q), (0, 3, 5), (1, 4, 7), (2,), (6,))
+    assert cg1 == cg2
+
+
+def test_arrayexpr_canonicalize_diagonal__permute_dims():
+    tp = _array_tensor_product(M, Q, N, P)
+    expr = _array_diagonal(
+        _permute_dims(tp, [0, 1, 2, 4, 7, 6, 3, 5]), (2, 4, 5), (6, 7),
+        (0, 3))
+    result = _array_diagonal(tp, (2, 6, 7), (3, 5), (0, 4))
+    assert expr == result
+
+    tp = _array_tensor_product(M, N, P, Q)
+    expr = _array_diagonal(_permute_dims(tp, [0, 5, 2, 4, 1, 6, 3, 7]), (1, 2, 6), (3, 4))
+    result = _array_diagonal(_array_tensor_product(M, P, N, Q), (3, 4, 5), (1, 2))
+    assert expr == result
+
+
+def test_arrayexpr_canonicalize_diagonal_contraction():
+    tp = _array_tensor_product(M, N, P, Q)
+    expr = _array_contraction(_array_diagonal(tp, (1, 3, 4)), (0, 3))
+    result = _array_diagonal(_array_contraction(_array_tensor_product(M, N, P, Q), (0, 6)), (0, 2, 3))
+    assert expr == result
+
+    expr = _array_contraction(_array_diagonal(tp, (0, 1, 2, 3, 7)), (1, 2, 3))
+    result = _array_contraction(_array_tensor_product(M, N, P, Q), (0, 1, 2, 3, 5, 6, 7))
+    assert expr == result
+
+    expr = _array_contraction(_array_diagonal(tp, (0, 2, 6, 7)), (1, 2, 3))
+    result = _array_diagonal(_array_contraction(tp, (3, 4, 5)), (0, 2, 3, 4))
+    assert expr == result
+
+    td = _array_diagonal(_array_tensor_product(M, N, P, Q), (0, 3))
+    expr = _array_contraction(td, (2, 1), (0, 4, 6, 5, 3))
+    result = _array_contraction(_array_tensor_product(M, N, P, Q), (0, 1, 3, 5, 6, 7), (2, 4))
+    assert expr == result
+
+
+def test_arrayexpr_array_wrong_permutation_size():
+    cg = _array_tensor_product(M, N)
+    raises(ValueError, lambda: _permute_dims(cg, [1, 0]))
+    raises(ValueError, lambda: _permute_dims(cg, [1, 0, 2, 3, 5, 4]))
+
+
+def test_arrayexpr_nested_array_elementwise_add():
+    cg = _array_contraction(_array_add(
+        _array_tensor_product(M, N),
+        _array_tensor_product(N, M)
+    ), (1, 2))
+    result = _array_add(
+        _array_contraction(_array_tensor_product(M, N), (1, 2)),
+        _array_contraction(_array_tensor_product(N, M), (1, 2))
+    )
+    assert cg == result
+
+    cg = _array_diagonal(_array_add(
+        _array_tensor_product(M, N),
+        _array_tensor_product(N, M)
+    ), (1, 2))
+    result = _array_add(
+        _array_diagonal(_array_tensor_product(M, N), (1, 2)),
+        _array_diagonal(_array_tensor_product(N, M), (1, 2))
+    )
+    assert cg == result
+
+
+def test_arrayexpr_array_expr_zero_array():
+    za1 = ZeroArray(k, l, m, n)
+    zm1 = ZeroMatrix(m, n)
+
+    za2 = ZeroArray(k, m, m, n)
+    zm2 = ZeroMatrix(m, m)
+    zm3 = ZeroMatrix(k, k)
+
+    assert _array_tensor_product(M, N, za1) == ZeroArray(k, k, k, k, k, l, m, n)
+    assert _array_tensor_product(M, N, zm1) == ZeroArray(k, k, k, k, m, n)
+
+    assert _array_contraction(za1, (3,)) == ZeroArray(k, l, m)
+    assert _array_contraction(zm1, (1,)) == ZeroArray(m)
+    assert _array_contraction(za2, (1, 2)) == ZeroArray(k, n)
+    assert _array_contraction(zm2, (0, 1)) == 0
+
+    assert _array_diagonal(za2, (1, 2)) == ZeroArray(k, n, m)
+    assert _array_diagonal(zm2, (0, 1)) == ZeroArray(m)
+
+    assert _permute_dims(za1, [2, 1, 3, 0]) == ZeroArray(m, l, n, k)
+    assert _permute_dims(zm1, [1, 0]) == ZeroArray(n, m)
+
+    assert _array_add(za1) == za1
+    assert _array_add(zm1) == ZeroArray(m, n)
+    tp1 = _array_tensor_product(MatrixSymbol("A", k, l), MatrixSymbol("B", m, n))
+    assert _array_add(tp1, za1) == tp1
+    tp2 = _array_tensor_product(MatrixSymbol("C", k, l), MatrixSymbol("D", m, n))
+    assert _array_add(tp1, za1, tp2) == _array_add(tp1, tp2)
+    assert _array_add(M, zm3) == M
+    assert _array_add(M, N, zm3) == _array_add(M, N)
+
+
+def test_arrayexpr_array_expr_applyfunc():
+
+    A = ArraySymbol("A", (3, k, 2))
+    aaf = ArrayElementwiseApplyFunc(sin, A)
+    assert aaf.shape == (3, k, 2)
+
+
+def test_edit_array_contraction():
+    cg = _array_contraction(_array_tensor_product(A, B, C, D), (1, 2, 5))
+    ecg = _EditArrayContraction(cg)
+    assert ecg.to_array_contraction() == cg
+
+    ecg.args_with_ind[1], ecg.args_with_ind[2] = ecg.args_with_ind[2], ecg.args_with_ind[1]
+    assert ecg.to_array_contraction() == _array_contraction(_array_tensor_product(A, C, B, D), (1, 3, 4))
+
+    ci = ecg.get_new_contraction_index()
+    new_arg = _ArgE(X)
+    new_arg.indices = [ci, ci]
+    ecg.args_with_ind.insert(2, new_arg)
+    assert ecg.to_array_contraction() == _array_contraction(_array_tensor_product(A, C, X, B, D), (1, 3, 6), (4, 5))
+
+    assert ecg.get_contraction_indices() == [[1, 3, 6], [4, 5]]
+    assert [[tuple(j) for j in i] for i in ecg.get_contraction_indices_to_ind_rel_pos()] == [[(0, 1), (1, 1), (3, 0)], [(2, 0), (2, 1)]]
+    assert [list(i) for i in ecg.get_mapping_for_index(0)] == [[0, 1], [1, 1], [3, 0]]
+    assert [list(i) for i in ecg.get_mapping_for_index(1)] == [[2, 0], [2, 1]]
+    raises(ValueError, lambda: ecg.get_mapping_for_index(2))
+
+    ecg.args_with_ind.pop(1)
+    assert ecg.to_array_contraction() == _array_contraction(_array_tensor_product(A, X, B, D), (1, 4), (2, 3))
+
+    ecg.args_with_ind[0].indices[1] = ecg.args_with_ind[1].indices[0]
+    ecg.args_with_ind[1].indices[1] = ecg.args_with_ind[2].indices[0]
+    assert ecg.to_array_contraction() == _array_contraction(_array_tensor_product(A, X, B, D), (1, 2), (3, 4))
+
+    ecg.insert_after(ecg.args_with_ind[1], _ArgE(C))
+    assert ecg.to_array_contraction() == _array_contraction(_array_tensor_product(A, X, C, B, D), (1, 2), (3, 6))
+
+
+def test_array_expressions_no_canonicalization():
+
+    tp = _array_tensor_product(M, N, P)
+
+    # ArrayTensorProduct:
+
+    expr = ArrayTensorProduct(tp, N)
+    assert str(expr) == "ArrayTensorProduct(ArrayTensorProduct(M, N, P), N)"
+    assert expr.doit() == ArrayTensorProduct(M, N, P, N)
+
+    expr = ArrayTensorProduct(ArrayContraction(M, (0, 1)), N)
+    assert str(expr) == "ArrayTensorProduct(ArrayContraction(M, (0, 1)), N)"
+    assert expr.doit() == ArrayContraction(ArrayTensorProduct(M, N), (0, 1))
+
+    expr = ArrayTensorProduct(ArrayDiagonal(M, (0, 1)), N)
+    assert str(expr) == "ArrayTensorProduct(ArrayDiagonal(M, (0, 1)), N)"
+    assert expr.doit() == PermuteDims(ArrayDiagonal(ArrayTensorProduct(M, N), (0, 1)), [2, 0, 1])
+
+    expr = ArrayTensorProduct(PermuteDims(M, [1, 0]), N)
+    assert str(expr) == "ArrayTensorProduct(PermuteDims(M, (0 1)), N)"
+    assert expr.doit() == PermuteDims(ArrayTensorProduct(M, N), [1, 0, 2, 3])
+
+    # ArrayContraction:
+
+    expr = ArrayContraction(_array_contraction(tp, (0, 2)), (0, 1))
+    assert isinstance(expr, ArrayContraction)
+    assert isinstance(expr.expr, ArrayContraction)
+    assert str(expr) == "ArrayContraction(ArrayContraction(ArrayTensorProduct(M, N, P), (0, 2)), (0, 1))"
+    assert expr.doit() == ArrayContraction(tp, (0, 2), (1, 3))
+
+    expr = ArrayContraction(ArrayContraction(ArrayContraction(tp, (0, 1)), (0, 1)), (0, 1))
+    assert expr.doit() == ArrayContraction(tp, (0, 1), (2, 3), (4, 5))
+    # assert expr._canonicalize() == ArrayContraction(ArrayContraction(tp, (0, 1)), (0, 1), (2, 3))
+
+    expr = ArrayContraction(ArrayDiagonal(tp, (0, 1)), (0, 1))
+    assert str(expr) == "ArrayContraction(ArrayDiagonal(ArrayTensorProduct(M, N, P), (0, 1)), (0, 1))"
+    assert expr.doit() == ArrayDiagonal(ArrayContraction(ArrayTensorProduct(N, M, P), (0, 1)), (0, 1))
+
+    expr = ArrayContraction(PermuteDims(M, [1, 0]), (0, 1))
+    assert str(expr) == "ArrayContraction(PermuteDims(M, (0 1)), (0, 1))"
+    assert expr.doit() == ArrayContraction(M, (0, 1))
+
+    # ArrayDiagonal:
+
+    expr = ArrayDiagonal(ArrayDiagonal(tp, (0, 2)), (0, 1))
+    assert str(expr) == "ArrayDiagonal(ArrayDiagonal(ArrayTensorProduct(M, N, P), (0, 2)), (0, 1))"
+    assert expr.doit() == ArrayDiagonal(tp, (0, 2), (1, 3))
+
+    expr = ArrayDiagonal(ArrayDiagonal(ArrayDiagonal(tp, (0, 1)), (0, 1)), (0, 1))
+    assert expr.doit() == ArrayDiagonal(tp, (0, 1), (2, 3), (4, 5))
+    assert expr._canonicalize() == expr.doit()
+
+    expr = ArrayDiagonal(ArrayContraction(tp, (0, 1)), (0, 1))
+    assert str(expr) == "ArrayDiagonal(ArrayContraction(ArrayTensorProduct(M, N, P), (0, 1)), (0, 1))"
+    assert expr.doit() == expr
+
+    expr = ArrayDiagonal(PermuteDims(M, [1, 0]), (0, 1))
+    assert str(expr) == "ArrayDiagonal(PermuteDims(M, (0 1)), (0, 1))"
+    assert expr.doit() == ArrayDiagonal(M, (0, 1))
+
+    # ArrayAdd:
+
+    expr = ArrayAdd(M)
+    assert isinstance(expr, ArrayAdd)
+    assert expr.doit() == M
+
+    expr = ArrayAdd(ArrayAdd(M, N), P)
+    assert str(expr) == "ArrayAdd(ArrayAdd(M, N), P)"
+    assert expr.doit() == ArrayAdd(M, N, P)
+
+    expr = ArrayAdd(M, ArrayAdd(N, ArrayAdd(P, M)))
+    assert expr.doit() == ArrayAdd(M, N, P, M)
+    assert expr._canonicalize() == ArrayAdd(M, N, ArrayAdd(P, M))
+
+    expr = ArrayAdd(M, ZeroArray(k, k), N)
+    assert str(expr) == "ArrayAdd(M, ZeroArray(k, k), N)"
+    assert expr.doit() == ArrayAdd(M, N)
+
+    # PermuteDims:
+
+    expr = PermuteDims(PermuteDims(M, [1, 0]), [1, 0])
+    assert str(expr) == "PermuteDims(PermuteDims(M, (0 1)), (0 1))"
+    assert expr.doit() == M
+
+    expr = PermuteDims(PermuteDims(PermuteDims(M, [1, 0]), [1, 0]), [1, 0])
+    assert expr.doit() == PermuteDims(M, [1, 0])
+    assert expr._canonicalize() == expr.doit()
+
+    # Reshape
+
+    expr = Reshape(A, (k**2,))
+    assert expr.shape == (k**2,)
+    assert isinstance(expr, Reshape)
+
+
+def test_array_expr_construction_with_functions():
+
+    tp = tensorproduct(M, N)
+    assert tp == ArrayTensorProduct(M, N)
+
+    expr = tensorproduct(A, eye(2))
+    assert expr == ArrayTensorProduct(A, eye(2))
+
+    # Contraction:
+
+    expr = tensorcontraction(M, (0, 1))
+    assert expr == ArrayContraction(M, (0, 1))
+
+    expr = tensorcontraction(tp, (1, 2))
+    assert expr == ArrayContraction(tp, (1, 2))
+
+    expr = tensorcontraction(tensorcontraction(tp, (1, 2)), (0, 1))
+    assert expr == ArrayContraction(tp, (0, 3), (1, 2))
+
+    # Diagonalization:
+
+    expr = tensordiagonal(M, (0, 1))
+    assert expr == ArrayDiagonal(M, (0, 1))
+
+    expr = tensordiagonal(tensordiagonal(tp, (0, 1)), (0, 1))
+    assert expr == ArrayDiagonal(tp, (0, 1), (2, 3))
+
+    # Permutation of dimensions:
+
+    expr = permutedims(M, [1, 0])
+    assert expr == PermuteDims(M, [1, 0])
+
+    expr = permutedims(PermuteDims(tp, [1, 0, 2, 3]), [0, 1, 3, 2])
+    assert expr == PermuteDims(tp, [1, 0, 3, 2])
+
+    expr = PermuteDims(tp, index_order_new=["a", "b", "c", "d"], index_order_old=["d", "c", "b", "a"])
+    assert expr == PermuteDims(tp, [3, 2, 1, 0])
+
+    arr = Array(range(32)).reshape(2, 2, 2, 2, 2)
+    expr = PermuteDims(arr, index_order_new=["a", "b", "c", "d", "e"], index_order_old=['b', 'e', 'a', 'd', 'c'])
+    assert expr == PermuteDims(arr, [2, 0, 4, 3, 1])
+    assert expr.as_explicit() == permutedims(arr, index_order_new=["a", "b", "c", "d", "e"], index_order_old=['b', 'e', 'a', 'd', 'c'])
+
+
+def test_array_element_expressions():
+    # Check commutative property:
+    assert M[0, 0]*N[0, 0] == N[0, 0]*M[0, 0]
+
+    # Check derivatives:
+    assert M[0, 0].diff(M[0, 0]) == 1
+    assert M[0, 0].diff(M[1, 0]) == 0
+    assert M[0, 0].diff(N[0, 0]) == 0
+    assert M[0, 1].diff(M[i, j]) == KroneckerDelta(i, 0)*KroneckerDelta(j, 1)
+    assert M[0, 1].diff(N[i, j]) == 0
+
+    K4 = ArraySymbol("K4", shape=(k, k, k, k))
+
+    assert K4[i, j, k, l].diff(K4[1, 2, 3, 4]) == (
+        KroneckerDelta(i, 1)*KroneckerDelta(j, 2)*KroneckerDelta(k, 3)*KroneckerDelta(l, 4)
+    )
+
+
+def test_array_expr_reshape():
+
+    A = MatrixSymbol("A", 2, 2)
+    B = ArraySymbol("B", (2, 2, 2))
+    C = Array([1, 2, 3, 4])
+
+    expr = Reshape(A, (4,))
+    assert expr.expr == A
+    assert expr.shape == (4,)
+    assert expr.as_explicit() == Array([A[0, 0], A[0, 1], A[1, 0], A[1, 1]])
+
+    expr = Reshape(B, (2, 4))
+    assert expr.expr == B
+    assert expr.shape == (2, 4)
+    ee = expr.as_explicit()
+    assert isinstance(ee, ImmutableDenseNDimArray)
+    assert ee.shape == (2, 4)
+    assert ee == Array([[B[0, 0, 0], B[0, 0, 1], B[0, 1, 0], B[0, 1, 1]], [B[1, 0, 0], B[1, 0, 1], B[1, 1, 0], B[1, 1, 1]]])
+
+    expr = Reshape(A, (k, 2))
+    assert expr.shape == (k, 2)
+
+    raises(ValueError, lambda: Reshape(A, (2, 3)))
+    raises(ValueError, lambda: Reshape(A, (3,)))
+
+    expr = Reshape(C, (2, 2))
+    assert expr.expr == C
+    assert expr.shape == (2, 2)
+    assert expr.doit() == Array([[1, 2], [3, 4]])
+
+
+def test_array_expr_as_explicit_with_explicit_component_arrays():
+    # Test if .as_explicit() works with explicit-component arrays
+    # nested in array expressions:
+    from sympy.abc import x, y, z, t
+    A = Array([[x, y], [z, t]])
+    assert ArrayTensorProduct(A, A).as_explicit() == tensorproduct(A, A)
+    assert ArrayDiagonal(A, (0, 1)).as_explicit() == tensordiagonal(A, (0, 1))
+    assert ArrayContraction(A, (0, 1)).as_explicit() == tensorcontraction(A, (0, 1))
+    assert ArrayAdd(A, A).as_explicit() == A + A
+    assert ArrayElementwiseApplyFunc(sin, A).as_explicit() == A.applyfunc(sin)
+    assert PermuteDims(A, [1, 0]).as_explicit() == permutedims(A, [1, 0])
+    assert Reshape(A, [4]).as_explicit() == A.reshape(4)
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/expressions/tests/test_arrayexpr_derivatives.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/expressions/tests/test_arrayexpr_derivatives.py
new file mode 100644
index 0000000000000000000000000000000000000000..bc0fcf63f2607b23feb38758e4f0994de4f0384b
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/expressions/tests/test_arrayexpr_derivatives.py
@@ -0,0 +1,78 @@
+from sympy.core.symbol import symbols
+from sympy.functions.elementary.trigonometric import (cos, sin)
+from sympy.matrices.expressions.matexpr import MatrixSymbol
+from sympy.matrices.expressions.special import Identity
+from sympy.matrices.expressions.applyfunc import ElementwiseApplyFunction
+from sympy.tensor.array.expressions.array_expressions import ArraySymbol, ArrayTensorProduct, \
+    PermuteDims, ArrayDiagonal, ArrayElementwiseApplyFunc, ArrayContraction, _permute_dims, Reshape
+from sympy.tensor.array.expressions.arrayexpr_derivatives import array_derive
+
+k = symbols("k")
+
+I = Identity(k)
+X = MatrixSymbol("X", k, k)
+x = MatrixSymbol("x", k, 1)
+
+A = MatrixSymbol("A", k, k)
+B = MatrixSymbol("B", k, k)
+C = MatrixSymbol("C", k, k)
+D = MatrixSymbol("D", k, k)
+
+A1 = ArraySymbol("A", (3, 2, k))
+
+
+def test_arrayexpr_derivatives1():
+
+    res = array_derive(X, X)
+    assert res == PermuteDims(ArrayTensorProduct(I, I), [0, 2, 1, 3])
+
+    cg = ArrayTensorProduct(A, X, B)
+    res = array_derive(cg, X)
+    assert res == _permute_dims(
+        ArrayTensorProduct(I, A, I, B),
+        [0, 4, 2, 3, 1, 5, 6, 7])
+
+    cg = ArrayContraction(X, (0, 1))
+    res = array_derive(cg, X)
+    assert res == ArrayContraction(ArrayTensorProduct(I, I), (1, 3))
+
+    cg = ArrayDiagonal(X, (0, 1))
+    res = array_derive(cg, X)
+    assert res == ArrayDiagonal(ArrayTensorProduct(I, I), (1, 3))
+
+    cg = ElementwiseApplyFunction(sin, X)
+    res = array_derive(cg, X)
+    assert res.dummy_eq(ArrayDiagonal(
+        ArrayTensorProduct(
+            ElementwiseApplyFunction(cos, X),
+            I,
+            I
+        ), (0, 3), (1, 5)))
+
+    cg = ArrayElementwiseApplyFunc(sin, X)
+    res = array_derive(cg, X)
+    assert res.dummy_eq(ArrayDiagonal(
+        ArrayTensorProduct(
+            I,
+            I,
+            ArrayElementwiseApplyFunc(cos, X)
+        ), (1, 4), (3, 5)))
+
+    res = array_derive(A1, A1)
+    assert res == PermuteDims(
+        ArrayTensorProduct(Identity(3), Identity(2), Identity(k)),
+        [0, 2, 4, 1, 3, 5]
+    )
+
+    cg = ArrayElementwiseApplyFunc(sin, A1)
+    res = array_derive(cg, A1)
+    assert res.dummy_eq(ArrayDiagonal(
+        ArrayTensorProduct(
+            Identity(3), Identity(2), Identity(k),
+            ArrayElementwiseApplyFunc(cos, A1)
+        ), (1, 6), (3, 7), (5, 8)
+    ))
+
+    cg = Reshape(A, (k**2,))
+    res = array_derive(cg, A)
+    assert res == Reshape(PermuteDims(ArrayTensorProduct(I, I), [0, 2, 1, 3]), (k, k, k**2))
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/expressions/tests/test_as_explicit.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/expressions/tests/test_as_explicit.py
new file mode 100644
index 0000000000000000000000000000000000000000..30cc61b1ee651ca032e165cd67926fa33c71354f
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/expressions/tests/test_as_explicit.py
@@ -0,0 +1,63 @@
+from sympy.core.symbol import Symbol
+from sympy.matrices.expressions.matexpr import MatrixSymbol
+from sympy.tensor.array.arrayop import (permutedims, tensorcontraction, tensordiagonal, tensorproduct)
+from sympy.tensor.array.dense_ndim_array import ImmutableDenseNDimArray
+from sympy.tensor.array.expressions.array_expressions import ZeroArray, OneArray, ArraySymbol, \
+    ArrayTensorProduct, PermuteDims, ArrayDiagonal, ArrayContraction, ArrayAdd
+from sympy.testing.pytest import raises
+
+
+def test_array_as_explicit_call():
+
+    assert ZeroArray(3, 2, 4).as_explicit() == ImmutableDenseNDimArray.zeros(3, 2, 4)
+    assert OneArray(3, 2, 4).as_explicit() == ImmutableDenseNDimArray([1 for i in range(3*2*4)]).reshape(3, 2, 4)
+
+    k = Symbol("k")
+    X = ArraySymbol("X", (k, 3, 2))
+    raises(ValueError, lambda: X.as_explicit())
+    raises(ValueError, lambda: ZeroArray(k, 2, 3).as_explicit())
+    raises(ValueError, lambda: OneArray(2, k, 2).as_explicit())
+
+    A = ArraySymbol("A", (3, 3))
+    B = ArraySymbol("B", (3, 3))
+
+    texpr = tensorproduct(A, B)
+    assert isinstance(texpr, ArrayTensorProduct)
+    assert texpr.as_explicit() == tensorproduct(A.as_explicit(), B.as_explicit())
+
+    texpr = tensorcontraction(A, (0, 1))
+    assert isinstance(texpr, ArrayContraction)
+    assert texpr.as_explicit() == A[0, 0] + A[1, 1] + A[2, 2]
+
+    texpr = tensordiagonal(A, (0, 1))
+    assert isinstance(texpr, ArrayDiagonal)
+    assert texpr.as_explicit() == ImmutableDenseNDimArray([A[0, 0], A[1, 1], A[2, 2]])
+
+    texpr = permutedims(A, [1, 0])
+    assert isinstance(texpr, PermuteDims)
+    assert texpr.as_explicit() == permutedims(A.as_explicit(), [1, 0])
+
+
+def test_array_as_explicit_matrix_symbol():
+
+    A = MatrixSymbol("A", 3, 3)
+    B = MatrixSymbol("B", 3, 3)
+
+    texpr = tensorproduct(A, B)
+    assert isinstance(texpr, ArrayTensorProduct)
+    assert texpr.as_explicit() == tensorproduct(A.as_explicit(), B.as_explicit())
+
+    texpr = tensorcontraction(A, (0, 1))
+    assert isinstance(texpr, ArrayContraction)
+    assert texpr.as_explicit() == A[0, 0] + A[1, 1] + A[2, 2]
+
+    texpr = tensordiagonal(A, (0, 1))
+    assert isinstance(texpr, ArrayDiagonal)
+    assert texpr.as_explicit() == ImmutableDenseNDimArray([A[0, 0], A[1, 1], A[2, 2]])
+
+    texpr = permutedims(A, [1, 0])
+    assert isinstance(texpr, PermuteDims)
+    assert texpr.as_explicit() == permutedims(A.as_explicit(), [1, 0])
+
+    expr = ArrayAdd(ArrayTensorProduct(A, B), ArrayTensorProduct(B, A))
+    assert expr.as_explicit() == expr.args[0].as_explicit() + expr.args[1].as_explicit()
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/expressions/tests/test_convert_array_to_indexed.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/expressions/tests/test_convert_array_to_indexed.py
new file mode 100644
index 0000000000000000000000000000000000000000..a6b713fbec94ab7808c5a8a778b3313402d9d0c7
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/expressions/tests/test_convert_array_to_indexed.py
@@ -0,0 +1,61 @@
+from sympy import Sum, Dummy, sin
+from sympy.tensor.array.expressions import ArraySymbol, ArrayTensorProduct, ArrayContraction, PermuteDims, \
+    ArrayDiagonal, ArrayAdd, OneArray, ZeroArray, convert_indexed_to_array, ArrayElementwiseApplyFunc, Reshape
+from sympy.tensor.array.expressions.from_array_to_indexed import convert_array_to_indexed
+
+from sympy.abc import i, j, k, l, m, n, o
+
+
+def test_convert_array_to_indexed_main():
+    A = ArraySymbol("A", (3, 3, 3))
+    B = ArraySymbol("B", (3, 3))
+    C = ArraySymbol("C", (3, 3))
+
+    d_ = Dummy("d_")
+
+    assert convert_array_to_indexed(A, [i, j, k]) == A[i, j, k]
+
+    expr = ArrayTensorProduct(A, B, C)
+    conv = convert_array_to_indexed(expr, [i,j,k,l,m,n,o])
+    assert conv == A[i,j,k]*B[l,m]*C[n,o]
+    assert convert_indexed_to_array(conv, [i,j,k,l,m,n,o]) == expr
+
+    expr = ArrayContraction(A, (0, 2))
+    assert convert_array_to_indexed(expr, [i]).dummy_eq(Sum(A[d_, i, d_], (d_, 0, 2)))
+
+    expr = ArrayDiagonal(A, (0, 2))
+    assert convert_array_to_indexed(expr, [i, j]) == A[j, i, j]
+
+    expr = PermuteDims(A, [1, 2, 0])
+    conv = convert_array_to_indexed(expr, [i, j, k])
+    assert conv == A[k, i, j]
+    assert convert_indexed_to_array(conv, [i, j, k]) == expr
+
+    expr = ArrayAdd(B, C, PermuteDims(C, [1, 0]))
+    conv = convert_array_to_indexed(expr, [i, j])
+    assert conv == B[i, j] + C[i, j] + C[j, i]
+    assert convert_indexed_to_array(conv, [i, j]) == expr
+
+    expr = ArrayElementwiseApplyFunc(sin, A)
+    conv = convert_array_to_indexed(expr, [i, j, k])
+    assert conv == sin(A[i, j, k])
+    assert convert_indexed_to_array(conv, [i, j, k]).dummy_eq(expr)
+
+    assert convert_array_to_indexed(OneArray(3, 3), [i, j]) == 1
+    assert convert_array_to_indexed(ZeroArray(3, 3), [i, j]) == 0
+
+    expr = Reshape(A, (27,))
+    assert convert_array_to_indexed(expr, [i]) == A[i // 9, i // 3 % 3, i % 3]
+
+    X = ArraySymbol("X", (2, 3, 4, 5, 6))
+    expr = Reshape(X, (2*3*4*5*6,))
+    assert convert_array_to_indexed(expr, [i]) == X[i // 360, i // 120 % 3, i // 30 % 4, i // 6 % 5, i % 6]
+
+    expr = Reshape(X, (4, 9, 2, 2, 5))
+    one_index = 180*i + 20*j + 10*k + 5*l + m
+    expected = X[one_index // (3*4*5*6), one_index // (4*5*6) % 3, one_index // (5*6) % 4, one_index // 6 % 5, one_index % 6]
+    assert convert_array_to_indexed(expr, [i, j, k, l, m]) == expected
+
+    X = ArraySymbol("X", (2*3*5,))
+    expr = Reshape(X, (2, 3, 5))
+    assert convert_array_to_indexed(expr, [i, j, k]) == X[15*i + 5*j + k]
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/expressions/tests/test_convert_array_to_matrix.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/expressions/tests/test_convert_array_to_matrix.py
new file mode 100644
index 0000000000000000000000000000000000000000..26839d5e7cec0554948c6b726482f9d8ca250b1c
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/expressions/tests/test_convert_array_to_matrix.py
@@ -0,0 +1,689 @@
+from sympy import Lambda, S, Dummy, KroneckerProduct
+from sympy.core.symbol import symbols
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import cos, sin
+from sympy.matrices.expressions.hadamard import HadamardProduct, HadamardPower
+from sympy.matrices.expressions.special import (Identity, OneMatrix, ZeroMatrix)
+from sympy.matrices.expressions.matexpr import MatrixElement
+from sympy.tensor.array.expressions.from_matrix_to_array import convert_matrix_to_array
+from sympy.tensor.array.expressions.from_array_to_matrix import _support_function_tp1_recognize, \
+    _array_diag2contr_diagmatrix, convert_array_to_matrix, _remove_trivial_dims, _array2matrix, \
+    _combine_removed, identify_removable_identity_matrices, _array_contraction_to_diagonal_multiple_identity
+from sympy.matrices.expressions.matexpr import MatrixSymbol
+from sympy.combinatorics import Permutation
+from sympy.matrices.expressions.diagonal import DiagMatrix, DiagonalMatrix
+from sympy.matrices import Trace, MatMul, Transpose
+from sympy.tensor.array.expressions.array_expressions import ZeroArray, OneArray, \
+    ArrayElement, ArraySymbol, ArrayElementwiseApplyFunc, _array_tensor_product, _array_contraction, \
+    _array_diagonal, _permute_dims, PermuteDims, ArrayAdd, ArrayDiagonal, ArrayContraction, ArrayTensorProduct
+from sympy.testing.pytest import raises
+
+
+i, j, k, l, m, n = symbols("i j k l m n")
+
+I = Identity(k)
+I1 = Identity(1)
+
+M = MatrixSymbol("M", k, k)
+N = MatrixSymbol("N", k, k)
+P = MatrixSymbol("P", k, k)
+Q = MatrixSymbol("Q", k, k)
+
+A = MatrixSymbol("A", k, k)
+B = MatrixSymbol("B", k, k)
+C = MatrixSymbol("C", k, k)
+D = MatrixSymbol("D", k, k)
+
+X = MatrixSymbol("X", k, k)
+Y = MatrixSymbol("Y", k, k)
+
+a = MatrixSymbol("a", k, 1)
+b = MatrixSymbol("b", k, 1)
+c = MatrixSymbol("c", k, 1)
+d = MatrixSymbol("d", k, 1)
+
+x = MatrixSymbol("x", k, 1)
+y = MatrixSymbol("y", k, 1)
+
+
+def test_arrayexpr_convert_array_to_matrix():
+
+    cg = _array_contraction(_array_tensor_product(M), (0, 1))
+    assert convert_array_to_matrix(cg) == Trace(M)
+
+    cg = _array_contraction(_array_tensor_product(M, N), (0, 1), (2, 3))
+    assert convert_array_to_matrix(cg) == Trace(M) * Trace(N)
+
+    cg = _array_contraction(_array_tensor_product(M, N), (0, 3), (1, 2))
+    assert convert_array_to_matrix(cg) == Trace(M * N)
+
+    cg = _array_contraction(_array_tensor_product(M, N), (0, 2), (1, 3))
+    assert convert_array_to_matrix(cg) == Trace(M * N.T)
+
+    cg = convert_matrix_to_array(M * N * P)
+    assert convert_array_to_matrix(cg) == M * N * P
+
+    cg = convert_matrix_to_array(M * N.T * P)
+    assert convert_array_to_matrix(cg) == M * N.T * P
+
+    cg = _array_contraction(_array_tensor_product(M,N,P,Q), (1, 2), (5, 6))
+    assert convert_array_to_matrix(cg) == _array_tensor_product(M * N, P * Q)
+
+    cg = _array_contraction(_array_tensor_product(-2, M, N), (1, 2))
+    assert convert_array_to_matrix(cg) == -2 * M * N
+
+    a = MatrixSymbol("a", k, 1)
+    b = MatrixSymbol("b", k, 1)
+    c = MatrixSymbol("c", k, 1)
+    cg = PermuteDims(
+        _array_contraction(
+            _array_tensor_product(
+                a,
+                ArrayAdd(
+                    _array_tensor_product(b, c),
+                    _array_tensor_product(c, b),
+                )
+            ), (2, 4)), [0, 1, 3, 2])
+    assert convert_array_to_matrix(cg) == a * (b.T * c + c.T * b)
+
+    za = ZeroArray(m, n)
+    assert convert_array_to_matrix(za) == ZeroMatrix(m, n)
+
+    cg = _array_tensor_product(3, M)
+    assert convert_array_to_matrix(cg) == 3 * M
+
+    # Partial conversion to matrix multiplication:
+    expr = _array_contraction(_array_tensor_product(M, N, P, Q), (0, 2), (1, 4, 6))
+    assert convert_array_to_matrix(expr) == _array_contraction(_array_tensor_product(M.T*N, P, Q), (0, 2, 4))
+
+    x = MatrixSymbol("x", k, 1)
+    cg = PermuteDims(
+        _array_contraction(_array_tensor_product(OneArray(1), x, OneArray(1), DiagMatrix(Identity(1))),
+                                (0, 5)), Permutation(1, 2, 3))
+    assert convert_array_to_matrix(cg) == x
+
+    expr = ArrayAdd(M, PermuteDims(M, [1, 0]))
+    assert convert_array_to_matrix(expr) == M + Transpose(M)
+
+
+def test_arrayexpr_convert_array_to_matrix2():
+    cg = _array_contraction(_array_tensor_product(M, N), (1, 3))
+    assert convert_array_to_matrix(cg) == M * N.T
+
+    cg = PermuteDims(_array_tensor_product(M, N), Permutation([0, 1, 3, 2]))
+    assert convert_array_to_matrix(cg) == _array_tensor_product(M, N.T)
+
+    cg = _array_tensor_product(M, PermuteDims(N, Permutation([1, 0])))
+    assert convert_array_to_matrix(cg) == _array_tensor_product(M, N.T)
+
+    cg = _array_contraction(
+        PermuteDims(
+            _array_tensor_product(M, N, P, Q), Permutation([0, 2, 3, 1, 4, 5, 7, 6])),
+        (1, 2), (3, 5)
+    )
+    assert convert_array_to_matrix(cg) == _array_tensor_product(M * P.T * Trace(N), Q.T)
+
+    cg = _array_contraction(
+        _array_tensor_product(M, N, P, PermuteDims(Q, Permutation([1, 0]))),
+        (1, 5), (2, 3)
+    )
+    assert convert_array_to_matrix(cg) == _array_tensor_product(M * P.T * Trace(N), Q.T)
+
+    cg = _array_tensor_product(M, PermuteDims(N, [1, 0]))
+    assert convert_array_to_matrix(cg) == _array_tensor_product(M, N.T)
+
+    cg = _array_tensor_product(PermuteDims(M, [1, 0]), PermuteDims(N, [1, 0]))
+    assert convert_array_to_matrix(cg) == _array_tensor_product(M.T, N.T)
+
+    cg = _array_tensor_product(PermuteDims(N, [1, 0]), PermuteDims(M, [1, 0]))
+    assert convert_array_to_matrix(cg) == _array_tensor_product(N.T, M.T)
+
+    cg = _array_contraction(M, (0,), (1,))
+    assert convert_array_to_matrix(cg) == OneMatrix(1, k)*M*OneMatrix(k, 1)
+
+    cg = _array_contraction(x, (0,), (1,))
+    assert convert_array_to_matrix(cg) == OneMatrix(1, k)*x
+
+    Xm = MatrixSymbol("Xm", m, n)
+    cg = _array_contraction(Xm, (0,), (1,))
+    assert convert_array_to_matrix(cg) == OneMatrix(1, m)*Xm*OneMatrix(n, 1)
+
+
+def test_arrayexpr_convert_array_to_diagonalized_vector():
+
+    # Check matrix recognition over trivial dimensions:
+
+    cg = _array_tensor_product(a, b)
+    assert convert_array_to_matrix(cg) == a * b.T
+
+    cg = _array_tensor_product(I1, a, b)
+    assert convert_array_to_matrix(cg) == a * b.T
+
+    # Recognize trace inside a tensor product:
+
+    cg = _array_contraction(_array_tensor_product(A, B, C), (0, 3), (1, 2))
+    assert convert_array_to_matrix(cg) == Trace(A * B) * C
+
+    # Transform diagonal operator to contraction:
+
+    cg = _array_diagonal(_array_tensor_product(A, a), (1, 2))
+    assert _array_diag2contr_diagmatrix(cg) == _array_contraction(_array_tensor_product(A, OneArray(1), DiagMatrix(a)), (1, 3))
+    assert convert_array_to_matrix(cg) == A * DiagMatrix(a)
+
+    cg = _array_diagonal(_array_tensor_product(a, b), (0, 2))
+    assert _array_diag2contr_diagmatrix(cg) == _permute_dims(
+        _array_contraction(_array_tensor_product(DiagMatrix(a), OneArray(1), b), (0, 3)), [1, 2, 0]
+    )
+    assert convert_array_to_matrix(cg) == b.T * DiagMatrix(a)
+
+    cg = _array_diagonal(_array_tensor_product(A, a), (0, 2))
+    assert _array_diag2contr_diagmatrix(cg) == _array_contraction(_array_tensor_product(A, OneArray(1), DiagMatrix(a)), (0, 3))
+    assert convert_array_to_matrix(cg) == A.T * DiagMatrix(a)
+
+    cg = _array_diagonal(_array_tensor_product(I, x, I1), (0, 2), (3, 5))
+    assert _array_diag2contr_diagmatrix(cg) == _array_contraction(_array_tensor_product(I, OneArray(1), I1, DiagMatrix(x)), (0, 5))
+    assert convert_array_to_matrix(cg) == DiagMatrix(x)
+
+    cg = _array_diagonal(_array_tensor_product(I, x, A, B), (1, 2), (5, 6))
+    assert _array_diag2contr_diagmatrix(cg) == _array_diagonal(_array_contraction(_array_tensor_product(I, OneArray(1), A, B, DiagMatrix(x)), (1, 7)), (5, 6))
+    # TODO: this is returning a wrong result:
+    # convert_array_to_matrix(cg)
+
+    cg = _array_diagonal(_array_tensor_product(I1, a, b), (1, 3, 5))
+    assert convert_array_to_matrix(cg) == a*b.T
+
+    cg = _array_diagonal(_array_tensor_product(I1, a, b), (1, 3))
+    assert _array_diag2contr_diagmatrix(cg) == _array_contraction(_array_tensor_product(OneArray(1), a, b, I1), (2, 6))
+    assert convert_array_to_matrix(cg) == a*b.T
+
+    cg = _array_diagonal(_array_tensor_product(x, I1), (1, 2))
+    assert isinstance(cg, ArrayDiagonal)
+    assert cg.diagonal_indices == ((1, 2),)
+    assert convert_array_to_matrix(cg) == x
+
+    cg = _array_diagonal(_array_tensor_product(x, I), (0, 2))
+    assert _array_diag2contr_diagmatrix(cg) == _array_contraction(_array_tensor_product(OneArray(1), I, DiagMatrix(x)), (1, 3))
+    assert convert_array_to_matrix(cg).doit() == DiagMatrix(x)
+
+    raises(ValueError, lambda: _array_diagonal(x, (1,)))
+
+    # Ignore identity matrices with contractions:
+
+    cg = _array_contraction(_array_tensor_product(I, A, I, I), (0, 2), (1, 3), (5, 7))
+    assert cg.split_multiple_contractions() == cg
+    assert convert_array_to_matrix(cg) == Trace(A) * I
+
+    cg = _array_contraction(_array_tensor_product(Trace(A) * I, I, I), (1, 5), (3, 4))
+    assert cg.split_multiple_contractions() == cg
+    assert convert_array_to_matrix(cg).doit() == Trace(A) * I
+
+    # Add DiagMatrix when required:
+
+    cg = _array_contraction(_array_tensor_product(A, a), (1, 2))
+    assert cg.split_multiple_contractions() == cg
+    assert convert_array_to_matrix(cg) == A * a
+
+    cg = _array_contraction(_array_tensor_product(A, a, B), (1, 2, 4))
+    assert cg.split_multiple_contractions() == _array_contraction(_array_tensor_product(A, DiagMatrix(a), OneArray(1), B), (1, 2), (3, 5))
+    assert convert_array_to_matrix(cg) == A * DiagMatrix(a) * B
+
+    cg = _array_contraction(_array_tensor_product(A, a, B), (0, 2, 4))
+    assert cg.split_multiple_contractions() == _array_contraction(_array_tensor_product(A, DiagMatrix(a), OneArray(1), B), (0, 2), (3, 5))
+    assert convert_array_to_matrix(cg) == A.T * DiagMatrix(a) * B
+
+    cg = _array_contraction(_array_tensor_product(A, a, b, a.T, B), (0, 2, 4, 7, 9))
+    assert cg.split_multiple_contractions() == _array_contraction(_array_tensor_product(A, DiagMatrix(a), OneArray(1),
+                                                DiagMatrix(b), OneArray(1), DiagMatrix(a), OneArray(1), B),
+                                               (0, 2), (3, 5), (6, 9), (8, 12))
+    assert convert_array_to_matrix(cg) == A.T * DiagMatrix(a) * DiagMatrix(b) * DiagMatrix(a) * B.T
+
+    cg = _array_contraction(_array_tensor_product(I1, I1, I1), (1, 2, 4))
+    assert cg.split_multiple_contractions() == _array_contraction(_array_tensor_product(I1, I1, OneArray(1), I1), (1, 2), (3, 5))
+    assert convert_array_to_matrix(cg) == 1
+
+    cg = _array_contraction(_array_tensor_product(I, I, I, I, A), (1, 2, 8), (5, 6, 9))
+    assert convert_array_to_matrix(cg.split_multiple_contractions()).doit() == A
+
+    cg = _array_contraction(_array_tensor_product(A, a, C, a, B), (1, 2, 4), (5, 6, 8))
+    expected = _array_contraction(_array_tensor_product(A, DiagMatrix(a), OneArray(1), C, DiagMatrix(a), OneArray(1), B), (1, 3), (2, 5), (6, 7), (8, 10))
+    assert cg.split_multiple_contractions() == expected
+    assert convert_array_to_matrix(cg) == A * DiagMatrix(a) * C * DiagMatrix(a) * B
+
+    cg = _array_contraction(_array_tensor_product(a, I1, b, I1, (a.T*b).applyfunc(cos)), (1, 2, 8), (5, 6, 9))
+    expected = _array_contraction(_array_tensor_product(a, I1, OneArray(1), b, I1, OneArray(1), (a.T*b).applyfunc(cos)),
+                                (1, 3), (2, 10), (6, 8), (7, 11))
+    assert cg.split_multiple_contractions().dummy_eq(expected)
+    assert convert_array_to_matrix(cg).doit().dummy_eq(MatMul(a, (a.T * b).applyfunc(cos), b.T))
+
+
+def test_arrayexpr_convert_array_contraction_tp_additions():
+    a = ArrayAdd(
+        _array_tensor_product(M, N),
+        _array_tensor_product(N, M)
+    )
+    tp = _array_tensor_product(P, a, Q)
+    expr = _array_contraction(tp, (3, 4))
+    expected = _array_tensor_product(
+        P,
+        ArrayAdd(
+            _array_contraction(_array_tensor_product(M, N), (1, 2)),
+            _array_contraction(_array_tensor_product(N, M), (1, 2)),
+        ),
+        Q
+    )
+    assert expr == expected
+    assert convert_array_to_matrix(expr) == _array_tensor_product(P, M * N + N * M, Q)
+
+    expr = _array_contraction(tp, (1, 2), (3, 4), (5, 6))
+    result = _array_contraction(
+        _array_tensor_product(
+            P,
+            ArrayAdd(
+                _array_contraction(_array_tensor_product(M, N), (1, 2)),
+                _array_contraction(_array_tensor_product(N, M), (1, 2)),
+            ),
+            Q
+        ), (1, 2), (3, 4))
+    assert expr == result
+    assert convert_array_to_matrix(expr) == P * (M * N + N * M) * Q
+
+
+def test_arrayexpr_convert_array_to_implicit_matmul():
+    # Trivial dimensions are suppressed, so the result can be expressed in matrix form:
+
+    cg = _array_tensor_product(a, b)
+    assert convert_array_to_matrix(cg) == a * b.T
+
+    cg = _array_tensor_product(a, b, I)
+    assert convert_array_to_matrix(cg) == _array_tensor_product(a*b.T, I)
+
+    cg = _array_tensor_product(I, a, b)
+    assert convert_array_to_matrix(cg) == _array_tensor_product(I, a*b.T)
+
+    cg = _array_tensor_product(a, I, b)
+    assert convert_array_to_matrix(cg) == _array_tensor_product(a, I, b)
+
+    cg = _array_contraction(_array_tensor_product(I, I), (1, 2))
+    assert convert_array_to_matrix(cg) == I
+
+    cg = PermuteDims(_array_tensor_product(I, Identity(1)), [0, 2, 1, 3])
+    assert convert_array_to_matrix(cg) == I
+
+
+def test_arrayexpr_convert_array_to_matrix_remove_trivial_dims():
+
+    # Tensor Product:
+    assert _remove_trivial_dims(_array_tensor_product(a, b)) == (a * b.T, [1, 3])
+    assert _remove_trivial_dims(_array_tensor_product(a.T, b)) == (a * b.T, [0, 3])
+    assert _remove_trivial_dims(_array_tensor_product(a, b.T)) == (a * b.T, [1, 2])
+    assert _remove_trivial_dims(_array_tensor_product(a.T, b.T)) == (a * b.T, [0, 2])
+
+    assert _remove_trivial_dims(_array_tensor_product(I, a.T, b.T)) == (_array_tensor_product(I, a * b.T), [2, 4])
+    assert _remove_trivial_dims(_array_tensor_product(a.T, I, b.T)) == (_array_tensor_product(a.T, I, b.T), [])
+
+    assert _remove_trivial_dims(_array_tensor_product(a, I)) == (_array_tensor_product(a, I), [])
+    assert _remove_trivial_dims(_array_tensor_product(I, a)) == (_array_tensor_product(I, a), [])
+
+    assert _remove_trivial_dims(_array_tensor_product(a.T, b.T, c, d)) == (
+        _array_tensor_product(a * b.T, c * d.T), [0, 2, 5, 7])
+    assert _remove_trivial_dims(_array_tensor_product(a.T, I, b.T, c, d, I)) == (
+        _array_tensor_product(a.T, I, b*c.T, d, I), [4, 7])
+
+    # Addition:
+
+    cg = ArrayAdd(_array_tensor_product(a, b), _array_tensor_product(c, d))
+    assert _remove_trivial_dims(cg) == (a * b.T + c * d.T, [1, 3])
+
+    # Permute Dims:
+
+    cg = PermuteDims(_array_tensor_product(a, b), Permutation(3)(1, 2))
+    assert _remove_trivial_dims(cg) == (a * b.T, [2, 3])
+
+    cg = PermuteDims(_array_tensor_product(a, I, b), Permutation(5)(1, 2, 3, 4))
+    assert _remove_trivial_dims(cg) == (cg, [])
+
+    cg = PermuteDims(_array_tensor_product(I, b, a), Permutation(5)(1, 2, 4, 5, 3))
+    assert _remove_trivial_dims(cg) == (PermuteDims(_array_tensor_product(I, b * a.T), [0, 2, 3, 1]), [4, 5])
+
+    # Diagonal:
+
+    cg = _array_diagonal(_array_tensor_product(M, a), (1, 2))
+    assert _remove_trivial_dims(cg) == (cg, [])
+
+    # Contraction:
+
+    cg = _array_contraction(_array_tensor_product(M, a), (1, 2))
+    assert _remove_trivial_dims(cg) == (cg, [])
+
+    # A few more cases to test the removal and shift of nested removed axes
+    # with array contractions and array diagonals:
+    tp = _array_tensor_product(
+        OneMatrix(1, 1),
+        M,
+        x,
+        OneMatrix(1, 1),
+        Identity(1),
+    )
+
+    expr = _array_contraction(tp, (1, 8))
+    rexpr, removed = _remove_trivial_dims(expr)
+    assert removed == [0, 5, 6, 7]
+
+    expr = _array_contraction(tp, (1, 8), (3, 4))
+    rexpr, removed = _remove_trivial_dims(expr)
+    assert removed == [0, 3, 4, 5]
+
+    expr = _array_diagonal(tp, (1, 8))
+    rexpr, removed = _remove_trivial_dims(expr)
+    assert removed == [0, 5, 6, 7, 8]
+
+    expr = _array_diagonal(tp, (1, 8), (3, 4))
+    rexpr, removed = _remove_trivial_dims(expr)
+    assert removed == [0, 3, 4, 5, 6]
+
+    expr = _array_diagonal(_array_contraction(_array_tensor_product(A, x, I, I1), (1, 2, 5)), (1, 4))
+    rexpr, removed = _remove_trivial_dims(expr)
+    assert removed == [2, 3]
+
+    cg = _array_diagonal(_array_tensor_product(PermuteDims(_array_tensor_product(x, I1), Permutation(1, 2, 3)), (x.T*x).applyfunc(sqrt)), (2, 4), (3, 5))
+    rexpr, removed = _remove_trivial_dims(cg)
+    assert removed == [1, 2]
+
+    # Contractions with identity matrices need to be followed by a permutation
+    # in order
+    cg = _array_contraction(_array_tensor_product(A, B, C, M, I), (1, 8))
+    ret, removed = _remove_trivial_dims(cg)
+    assert ret == PermuteDims(_array_tensor_product(A, B, C, M), [0, 2, 3, 4, 5, 6, 7, 1])
+    assert removed == []
+
+    cg = _array_contraction(_array_tensor_product(A, B, C, M, I), (1, 8), (3, 4))
+    ret, removed = _remove_trivial_dims(cg)
+    assert ret == PermuteDims(_array_contraction(_array_tensor_product(A, B, C, M), (3, 4)), [0, 2, 3, 4, 5, 1])
+    assert removed == []
+
+    # Trivial matrices are sometimes inserted into MatMul expressions:
+
+    cg = _array_tensor_product(b*b.T, a.T*a)
+    ret, removed = _remove_trivial_dims(cg)
+    assert ret == b*a.T*a*b.T
+    assert removed == [2, 3]
+
+    Xs = ArraySymbol("X", (3, 2, k))
+    cg = _array_tensor_product(M, Xs, b.T*c, a*a.T, b*b.T, c.T*d)
+    ret, removed = _remove_trivial_dims(cg)
+    assert ret == _array_tensor_product(M, Xs, a*b.T*c*c.T*d*a.T, b*b.T)
+    assert removed == [5, 6, 11, 12]
+
+    cg = _array_diagonal(_array_tensor_product(I, I1, x), (1, 4), (3, 5))
+    assert _remove_trivial_dims(cg) == (PermuteDims(_array_diagonal(_array_tensor_product(I, x), (1, 2)), Permutation(1, 2)), [1])
+
+    expr = _array_diagonal(_array_tensor_product(x, I, y), (0, 2))
+    assert _remove_trivial_dims(expr) == (PermuteDims(_array_tensor_product(DiagMatrix(x), y), [1, 2, 3, 0]), [0])
+
+    expr = _array_diagonal(_array_tensor_product(x, I, y), (0, 2), (3, 4))
+    assert _remove_trivial_dims(expr) == (expr, [])
+
+
+def test_arrayexpr_convert_array_to_matrix_diag2contraction_diagmatrix():
+    cg = _array_diagonal(_array_tensor_product(M, a), (1, 2))
+    res = _array_diag2contr_diagmatrix(cg)
+    assert res.shape == cg.shape
+    assert res == _array_contraction(_array_tensor_product(M, OneArray(1), DiagMatrix(a)), (1, 3))
+
+    raises(ValueError, lambda: _array_diagonal(_array_tensor_product(a, M), (1, 2)))
+
+    cg = _array_diagonal(_array_tensor_product(a.T, M), (1, 2))
+    res = _array_diag2contr_diagmatrix(cg)
+    assert res.shape == cg.shape
+    assert res == _array_contraction(_array_tensor_product(OneArray(1), M, DiagMatrix(a.T)), (1, 4))
+
+    cg = _array_diagonal(_array_tensor_product(a.T, M, N, b.T), (1, 2), (4, 7))
+    res = _array_diag2contr_diagmatrix(cg)
+    assert res.shape == cg.shape
+    assert res == _array_contraction(
+        _array_tensor_product(OneArray(1), M, N, OneArray(1), DiagMatrix(a.T), DiagMatrix(b.T)), (1, 7), (3, 9))
+
+    cg = _array_diagonal(_array_tensor_product(a, M, N, b.T), (0, 2), (4, 7))
+    res = _array_diag2contr_diagmatrix(cg)
+    assert res.shape == cg.shape
+    assert res == _array_contraction(
+        _array_tensor_product(OneArray(1), M, N, OneArray(1), DiagMatrix(a), DiagMatrix(b.T)), (1, 6), (3, 9))
+
+    cg = _array_diagonal(_array_tensor_product(a, M, N, b.T), (0, 4), (3, 7))
+    res = _array_diag2contr_diagmatrix(cg)
+    assert res.shape == cg.shape
+    assert res == _array_contraction(
+        _array_tensor_product(OneArray(1), M, N, OneArray(1), DiagMatrix(a), DiagMatrix(b.T)), (3, 6), (2, 9))
+
+    I1 = Identity(1)
+    x = MatrixSymbol("x", k, 1)
+    A = MatrixSymbol("A", k, k)
+    cg = _array_diagonal(_array_tensor_product(x, A.T, I1), (0, 2))
+    assert _array_diag2contr_diagmatrix(cg).shape == cg.shape
+    assert _array2matrix(cg).shape == cg.shape
+
+
+def test_arrayexpr_convert_array_to_matrix_support_function():
+
+    assert _support_function_tp1_recognize([], [2 * k]) == 2 * k
+
+    assert _support_function_tp1_recognize([(1, 2)], [A, 2 * k, B, 3]) == 6 * k * A * B
+
+    assert _support_function_tp1_recognize([(0, 3), (1, 2)], [A, B]) == Trace(A * B)
+
+    assert _support_function_tp1_recognize([(1, 2)], [A, B]) == A * B
+    assert _support_function_tp1_recognize([(0, 2)], [A, B]) == A.T * B
+    assert _support_function_tp1_recognize([(1, 3)], [A, B]) == A * B.T
+    assert _support_function_tp1_recognize([(0, 3)], [A, B]) == A.T * B.T
+
+    assert _support_function_tp1_recognize([(1, 2), (5, 6)], [A, B, C, D]) == _array_tensor_product(A * B, C * D)
+    assert _support_function_tp1_recognize([(1, 4), (3, 6)], [A, B, C, D]) == PermuteDims(
+        _array_tensor_product(A * C, B * D), [0, 2, 1, 3])
+
+    assert _support_function_tp1_recognize([(0, 3), (1, 4)], [A, B, C]) == B * A * C
+
+    assert _support_function_tp1_recognize([(9, 10), (1, 2), (5, 6), (3, 4), (7, 8)],
+                                           [X, Y, A, B, C, D]) == X * Y * A * B * C * D
+
+    assert _support_function_tp1_recognize([(9, 10), (1, 2), (5, 6), (3, 4)],
+                                           [X, Y, A, B, C, D]) == _array_tensor_product(X * Y * A * B, C * D)
+
+    assert _support_function_tp1_recognize([(1, 7), (3, 8), (4, 11)], [X, Y, A, B, C, D]) == PermuteDims(
+        _array_tensor_product(X * B.T, Y * C, A.T * D.T), [0, 2, 4, 1, 3, 5]
+    )
+
+    assert _support_function_tp1_recognize([(0, 1), (3, 6), (5, 8)], [X, A, B, C, D]) == PermuteDims(
+        _array_tensor_product(Trace(X) * A * C, B * D), [0, 2, 1, 3])
+
+    assert _support_function_tp1_recognize([(1, 2), (3, 4), (5, 6), (7, 8)], [A, A, B, C, D]) == A ** 2 * B * C * D
+    assert _support_function_tp1_recognize([(1, 2), (3, 4), (5, 6), (7, 8)], [X, A, B, C, D]) == X * A * B * C * D
+
+    assert _support_function_tp1_recognize([(1, 6), (3, 8), (5, 10)], [X, Y, A, B, C, D]) == PermuteDims(
+        _array_tensor_product(X * B, Y * C, A * D), [0, 2, 4, 1, 3, 5]
+    )
+
+    assert _support_function_tp1_recognize([(1, 4), (3, 6)], [A, B, C, D]) == PermuteDims(
+        _array_tensor_product(A * C, B * D), [0, 2, 1, 3])
+
+    assert _support_function_tp1_recognize([(0, 4), (1, 7), (2, 5), (3, 8)], [X, A, B, C, D]) == C*X.T*B*A*D
+
+    assert _support_function_tp1_recognize([(0, 4), (1, 7), (2, 5), (3, 8)], [X, A, B, C, D]) == C*X.T*B*A*D
+
+
+def test_convert_array_to_hadamard_products():
+
+    expr = HadamardProduct(M, N)
+    cg = convert_matrix_to_array(expr)
+    ret = convert_array_to_matrix(cg)
+    assert ret == expr
+
+    expr = HadamardProduct(M, N)*P
+    cg = convert_matrix_to_array(expr)
+    ret = convert_array_to_matrix(cg)
+    assert ret == expr
+
+    expr = Q*HadamardProduct(M, N)*P
+    cg = convert_matrix_to_array(expr)
+    ret = convert_array_to_matrix(cg)
+    assert ret == expr
+
+    expr = Q*HadamardProduct(M, N.T)*P
+    cg = convert_matrix_to_array(expr)
+    ret = convert_array_to_matrix(cg)
+    assert ret == expr
+
+    expr = HadamardProduct(M, N)*HadamardProduct(Q, P)
+    cg = convert_matrix_to_array(expr)
+    ret = convert_array_to_matrix(cg)
+    assert expr == ret
+
+    expr = P.T*HadamardProduct(M, N)*HadamardProduct(Q, P)
+    cg = convert_matrix_to_array(expr)
+    ret = convert_array_to_matrix(cg)
+    assert expr == ret
+
+    # ArrayDiagonal should be converted
+    cg = _array_diagonal(_array_tensor_product(M, N, Q), (1, 3), (0, 2, 4))
+    ret = convert_array_to_matrix(cg)
+    expected = PermuteDims(_array_diagonal(_array_tensor_product(HadamardProduct(M.T, N.T), Q), (1, 2)), [1, 0, 2])
+    assert expected == ret
+
+    # Special case that should return the same expression:
+    cg = _array_diagonal(_array_tensor_product(HadamardProduct(M, N), Q), (0, 2))
+    ret = convert_array_to_matrix(cg)
+    assert ret == cg
+
+    # Hadamard products with traces:
+
+    expr = Trace(HadamardProduct(M, N))
+    cg = convert_matrix_to_array(expr)
+    ret = convert_array_to_matrix(cg)
+    assert ret == Trace(HadamardProduct(M.T, N.T))
+
+    expr = Trace(A*HadamardProduct(M, N))
+    cg = convert_matrix_to_array(expr)
+    ret = convert_array_to_matrix(cg)
+    assert ret == Trace(HadamardProduct(M, N)*A)
+
+    expr = Trace(HadamardProduct(A, M)*N)
+    cg = convert_matrix_to_array(expr)
+    ret = convert_array_to_matrix(cg)
+    assert ret == Trace(HadamardProduct(M.T, N)*A)
+
+    # These should not be converted into Hadamard products:
+
+    cg = _array_diagonal(_array_tensor_product(M, N), (0, 1, 2, 3))
+    ret = convert_array_to_matrix(cg)
+    assert ret == cg
+
+    cg = _array_diagonal(_array_tensor_product(A), (0, 1))
+    ret = convert_array_to_matrix(cg)
+    assert ret == cg
+
+    cg = _array_diagonal(_array_tensor_product(M, N, P), (0, 2, 4), (1, 3, 5))
+    assert convert_array_to_matrix(cg) == HadamardProduct(M, N, P)
+
+    cg = _array_diagonal(_array_tensor_product(M, N, P), (0, 3, 4), (1, 2, 5))
+    assert convert_array_to_matrix(cg) == HadamardProduct(M, P, N.T)
+
+    cg = _array_diagonal(_array_tensor_product(I, I1, x), (1, 4), (3, 5))
+    assert convert_array_to_matrix(cg) == DiagMatrix(x)
+
+
+def test_identify_removable_identity_matrices():
+
+    D = DiagonalMatrix(MatrixSymbol("D", k, k))
+
+    cg = _array_contraction(_array_tensor_product(A, B, I), (1, 2, 4, 5))
+    expected = _array_contraction(_array_tensor_product(A, B), (1, 2))
+    assert identify_removable_identity_matrices(cg) == expected
+
+    cg = _array_contraction(_array_tensor_product(A, B, C, I), (1, 3, 5, 6, 7))
+    expected = _array_contraction(_array_tensor_product(A, B, C), (1, 3, 5))
+    assert identify_removable_identity_matrices(cg) == expected
+
+    # Tests with diagonal matrices:
+
+    cg = _array_contraction(_array_tensor_product(A, B, D), (1, 2, 4, 5))
+    ret = identify_removable_identity_matrices(cg)
+    expected = _array_contraction(_array_tensor_product(A, B, D), (1, 4), (2, 5))
+    assert ret == expected
+
+    cg = _array_contraction(_array_tensor_product(A, B, D, M, N), (1, 2, 4, 5, 6, 8))
+    ret = identify_removable_identity_matrices(cg)
+    assert ret == cg
+
+
+def test_combine_removed():
+
+    assert _combine_removed(6, [0, 1, 2], [0, 1, 2]) == [0, 1, 2, 3, 4, 5]
+    assert _combine_removed(8, [2, 5], [1, 3, 4]) == [1, 2, 4, 5, 6]
+    assert _combine_removed(8, [7], []) == [7]
+
+
+def test_array_contraction_to_diagonal_multiple_identities():
+
+    expr = _array_contraction(_array_tensor_product(A, B, I, C), (1, 2, 4), (5, 6))
+    assert _array_contraction_to_diagonal_multiple_identity(expr) == (expr, [])
+    assert convert_array_to_matrix(expr) == _array_contraction(_array_tensor_product(A, B, C), (1, 2, 4))
+
+    expr = _array_contraction(_array_tensor_product(A, I, I), (1, 2, 4))
+    assert _array_contraction_to_diagonal_multiple_identity(expr) == (A, [2])
+    assert convert_array_to_matrix(expr) == A
+
+    expr = _array_contraction(_array_tensor_product(A, I, I, B), (1, 2, 4), (3, 6))
+    assert _array_contraction_to_diagonal_multiple_identity(expr) == (expr, [])
+
+    expr = _array_contraction(_array_tensor_product(A, I, I, B), (1, 2, 3, 4, 6))
+    assert _array_contraction_to_diagonal_multiple_identity(expr) == (expr, [])
+
+
+def test_convert_array_element_to_matrix():
+
+    expr = ArrayElement(M, (i, j))
+    assert convert_array_to_matrix(expr) == MatrixElement(M, i, j)
+
+    expr = ArrayElement(_array_contraction(_array_tensor_product(M, N), (1, 3)), (i, j))
+    assert convert_array_to_matrix(expr) == MatrixElement(M*N.T, i, j)
+
+    expr = ArrayElement(_array_tensor_product(M, N), (i, j, m, n))
+    assert convert_array_to_matrix(expr) == expr
+
+
+def test_convert_array_elementwise_function_to_matrix():
+
+    d = Dummy("d")
+
+    expr = ArrayElementwiseApplyFunc(Lambda(d, sin(d)), x.T*y)
+    assert convert_array_to_matrix(expr) == sin(x.T*y)
+
+    expr = ArrayElementwiseApplyFunc(Lambda(d, d**2), x.T*y)
+    assert convert_array_to_matrix(expr) == (x.T*y)**2
+
+    expr = ArrayElementwiseApplyFunc(Lambda(d, sin(d)), x)
+    assert convert_array_to_matrix(expr).dummy_eq(x.applyfunc(sin))
+
+    expr = ArrayElementwiseApplyFunc(Lambda(d, 1 / (2 * sqrt(d))), x)
+    assert convert_array_to_matrix(expr) == S.Half * HadamardPower(x, -S.Half)
+
+
+def test_array2matrix():
+    # See issue https://github.com/sympy/sympy/pull/22877
+    expr = PermuteDims(ArrayContraction(ArrayTensorProduct(x, I, I1, x), (0, 3), (1, 7)), Permutation(2, 3))
+    expected = PermuteDims(ArrayTensorProduct(x*x.T, I1), Permutation(3)(1, 2))
+    assert _array2matrix(expr) == expected
+
+
+def test_recognize_broadcasting():
+    expr = ArrayTensorProduct(x.T*x, A)
+    assert _remove_trivial_dims(expr) == (KroneckerProduct(x.T*x, A), [0, 1])
+
+    expr = ArrayTensorProduct(A, x.T*x)
+    assert _remove_trivial_dims(expr) == (KroneckerProduct(A, x.T*x), [2, 3])
+
+    expr = ArrayTensorProduct(A, B, x.T*x, C)
+    assert _remove_trivial_dims(expr) == (ArrayTensorProduct(A, KroneckerProduct(B, x.T*x), C), [4, 5])
+
+    # Always prefer matrix multiplication to Kronecker product, if possible:
+    expr = ArrayTensorProduct(a, b, x.T*x)
+    assert _remove_trivial_dims(expr) == (a*x.T*x*b.T, [1, 3, 4, 5])
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/expressions/tests/test_convert_indexed_to_array.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/expressions/tests/test_convert_indexed_to_array.py
new file mode 100644
index 0000000000000000000000000000000000000000..258062eadeca041ae3c864dabeefd5165f1cef11
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/expressions/tests/test_convert_indexed_to_array.py
@@ -0,0 +1,205 @@
+from sympy import tanh
+from sympy.concrete.summations import Sum
+from sympy.core.symbol import symbols
+from sympy.functions.special.tensor_functions import KroneckerDelta
+from sympy.matrices.expressions.matexpr import MatrixSymbol
+from sympy.matrices.expressions.special import Identity
+from sympy.tensor.array.expressions import ArrayElementwiseApplyFunc
+from sympy.tensor.indexed import IndexedBase
+from sympy.combinatorics import Permutation
+from sympy.tensor.array.expressions.array_expressions import ArrayContraction, ArrayTensorProduct, \
+    ArrayDiagonal, ArrayAdd, PermuteDims, ArrayElement, _array_tensor_product, _array_contraction, _array_diagonal, \
+    _array_add, _permute_dims, ArraySymbol, OneArray
+from sympy.tensor.array.expressions.from_array_to_matrix import convert_array_to_matrix
+from sympy.tensor.array.expressions.from_indexed_to_array import convert_indexed_to_array, _convert_indexed_to_array
+from sympy.testing.pytest import raises
+
+
+A, B = symbols("A B", cls=IndexedBase)
+i, j, k, l, m, n = symbols("i j k l m n")
+d0, d1, d2, d3 = symbols("d0:4")
+
+I = Identity(k)
+
+M = MatrixSymbol("M", k, k)
+N = MatrixSymbol("N", k, k)
+P = MatrixSymbol("P", k, k)
+Q = MatrixSymbol("Q", k, k)
+
+a = MatrixSymbol("a", k, 1)
+b = MatrixSymbol("b", k, 1)
+c = MatrixSymbol("c", k, 1)
+d = MatrixSymbol("d", k, 1)
+
+
+def test_arrayexpr_convert_index_to_array_support_function():
+    expr = M[i, j]
+    assert _convert_indexed_to_array(expr) == (M, (i, j))
+    expr = M[i, j]*N[k, l]
+    assert _convert_indexed_to_array(expr) == (ArrayTensorProduct(M, N), (i, j, k, l))
+    expr = M[i, j]*N[j, k]
+    assert _convert_indexed_to_array(expr) == (ArrayDiagonal(ArrayTensorProduct(M, N), (1, 2)), (i, k, j))
+    expr = Sum(M[i, j]*N[j, k], (j, 0, k-1))
+    assert _convert_indexed_to_array(expr) == (ArrayContraction(ArrayTensorProduct(M, N), (1, 2)), (i, k))
+    expr = M[i, j] + N[i, j]
+    assert _convert_indexed_to_array(expr) == (ArrayAdd(M, N), (i, j))
+    expr = M[i, j] + N[j, i]
+    assert _convert_indexed_to_array(expr) == (ArrayAdd(M, PermuteDims(N, Permutation([1, 0]))), (i, j))
+    expr = M[i, j] + M[j, i]
+    assert _convert_indexed_to_array(expr) == (ArrayAdd(M, PermuteDims(M, Permutation([1, 0]))), (i, j))
+    expr = (M*N*P)[i, j]
+    assert _convert_indexed_to_array(expr) == (_array_contraction(ArrayTensorProduct(M, N, P), (1, 2), (3, 4)), (i, j))
+    expr = expr.function  # Disregard summation in previous expression
+    ret1, ret2 = _convert_indexed_to_array(expr)
+    assert ret1 == ArrayDiagonal(ArrayTensorProduct(M, N, P), (1, 2), (3, 4))
+    assert str(ret2) == "(i, j, _i_1, _i_2)"
+    expr = KroneckerDelta(i, j)*M[i, k]
+    assert _convert_indexed_to_array(expr) == (M, ({i, j}, k))
+    expr = KroneckerDelta(i, j)*KroneckerDelta(j, k)*M[i, l]
+    assert _convert_indexed_to_array(expr) == (M, ({i, j, k}, l))
+    expr = KroneckerDelta(j, k)*(M[i, j]*N[k, l] + N[i, j]*M[k, l])
+    assert _convert_indexed_to_array(expr) == (_array_diagonal(_array_add(
+            ArrayTensorProduct(M, N),
+            _permute_dims(ArrayTensorProduct(M, N), Permutation(0, 2)(1, 3))
+        ), (1, 2)), (i, l, frozenset({j, k})))
+    expr = KroneckerDelta(j, m)*KroneckerDelta(m, k)*(M[i, j]*N[k, l] + N[i, j]*M[k, l])
+    assert _convert_indexed_to_array(expr) == (_array_diagonal(_array_add(
+            ArrayTensorProduct(M, N),
+            _permute_dims(ArrayTensorProduct(M, N), Permutation(0, 2)(1, 3))
+        ), (1, 2)), (i, l, frozenset({j, m, k})))
+    expr = KroneckerDelta(i, j)*KroneckerDelta(j, k)*KroneckerDelta(k,m)*M[i, 0]*KroneckerDelta(m, n)
+    assert _convert_indexed_to_array(expr) == (M, ({i, j, k, m, n}, 0))
+    expr = M[i, i]
+    assert _convert_indexed_to_array(expr) == (ArrayDiagonal(M, (0, 1)), (i,))
+
+
+def test_arrayexpr_convert_indexed_to_array_expression():
+
+    s = Sum(A[i]*B[i], (i, 0, 3))
+    cg = convert_indexed_to_array(s)
+    assert cg == ArrayContraction(ArrayTensorProduct(A, B), (0, 1))
+
+    expr = M*N
+    result = ArrayContraction(ArrayTensorProduct(M, N), (1, 2))
+    elem = expr[i, j]
+    assert convert_indexed_to_array(elem) == result
+
+    expr = M*N*M
+    elem = expr[i, j]
+    result = _array_contraction(_array_tensor_product(M, M, N), (1, 4), (2, 5))
+    cg = convert_indexed_to_array(elem)
+    assert cg == result
+
+    cg = convert_indexed_to_array((M * N * P)[i, j])
+    assert cg == _array_contraction(ArrayTensorProduct(M, N, P), (1, 2), (3, 4))
+
+    cg = convert_indexed_to_array((M * N.T * P)[i, j])
+    assert cg == _array_contraction(ArrayTensorProduct(M, N, P), (1, 3), (2, 4))
+
+    expr = -2*M*N
+    elem = expr[i, j]
+    cg = convert_indexed_to_array(elem)
+    assert cg == ArrayContraction(ArrayTensorProduct(-2, M, N), (1, 2))
+
+
+def test_arrayexpr_convert_array_element_to_array_expression():
+    A = ArraySymbol("A", (k,))
+    B = ArraySymbol("B", (k,))
+
+    s = Sum(A[i]*B[i], (i, 0, k-1))
+    cg = convert_indexed_to_array(s)
+    assert cg == ArrayContraction(ArrayTensorProduct(A, B), (0, 1))
+
+    s = A[i]*B[i]
+    cg = convert_indexed_to_array(s)
+    assert cg == ArrayDiagonal(ArrayTensorProduct(A, B), (0, 1))
+
+    s = A[i]*B[j]
+    cg = convert_indexed_to_array(s, [i, j])
+    assert cg == ArrayTensorProduct(A, B)
+    cg = convert_indexed_to_array(s, [j, i])
+    assert cg == ArrayTensorProduct(B, A)
+
+    s = tanh(A[i]*B[j])
+    cg = convert_indexed_to_array(s, [i, j])
+    assert cg.dummy_eq(ArrayElementwiseApplyFunc(tanh, ArrayTensorProduct(A, B)))
+
+
+def test_arrayexpr_convert_indexed_to_array_and_back_to_matrix():
+
+    expr = a.T*b
+    elem = expr[0, 0]
+    cg = convert_indexed_to_array(elem)
+    assert cg == ArrayElement(ArrayContraction(ArrayTensorProduct(a, b), (0, 2)), [0, 0])
+
+    expr = M[i,j] + N[i,j]
+    p1, p2 = _convert_indexed_to_array(expr)
+    assert convert_array_to_matrix(p1) == M + N
+
+    expr = M[i,j] + N[j,i]
+    p1, p2 = _convert_indexed_to_array(expr)
+    assert convert_array_to_matrix(p1) == M + N.T
+
+    expr = M[i,j]*N[k,l] + N[i,j]*M[k,l]
+    p1, p2 = _convert_indexed_to_array(expr)
+    assert convert_array_to_matrix(p1) == ArrayAdd(
+        ArrayTensorProduct(M, N),
+        ArrayTensorProduct(N, M))
+
+    expr = (M*N*P)[i, j]
+    p1, p2 = _convert_indexed_to_array(expr)
+    assert convert_array_to_matrix(p1) == M * N * P
+
+    expr = Sum(M[i,j]*(N*P)[j,m], (j, 0, k-1))
+    p1, p2 = _convert_indexed_to_array(expr)
+    assert convert_array_to_matrix(p1) == M * N * P
+
+    expr = Sum((P[j, m] + P[m, j])*(M[i,j]*N[m,n] + N[i,j]*M[m,n]), (j, 0, k-1), (m, 0, k-1))
+    p1, p2 = _convert_indexed_to_array(expr)
+    assert convert_array_to_matrix(p1) == M * P * N + M * P.T * N + N * P * M + N * P.T * M
+
+
+def test_arrayexpr_convert_indexed_to_array_out_of_bounds():
+
+    expr = Sum(M[i, i], (i, 0, 4))
+    raises(ValueError, lambda: convert_indexed_to_array(expr))
+    expr = Sum(M[i, i], (i, 0, k))
+    raises(ValueError, lambda: convert_indexed_to_array(expr))
+    expr = Sum(M[i, i], (i, 1, k-1))
+    raises(ValueError, lambda: convert_indexed_to_array(expr))
+
+    expr = Sum(M[i, j]*N[j,m], (j, 0, 4))
+    raises(ValueError, lambda: convert_indexed_to_array(expr))
+    expr = Sum(M[i, j]*N[j,m], (j, 0, k))
+    raises(ValueError, lambda: convert_indexed_to_array(expr))
+    expr = Sum(M[i, j]*N[j,m], (j, 1, k-1))
+    raises(ValueError, lambda: convert_indexed_to_array(expr))
+
+
+def test_arrayexpr_convert_indexed_to_array_broadcast():
+    A = ArraySymbol("A", (3, 3))
+    B = ArraySymbol("B", (3, 3))
+
+    expr = A[i, j] + B[k, l]
+    O2 = OneArray(3, 3)
+    expected = ArrayAdd(ArrayTensorProduct(A, O2), ArrayTensorProduct(O2, B))
+    assert convert_indexed_to_array(expr) == expected
+    assert convert_indexed_to_array(expr, [i, j, k, l]) == expected
+    assert convert_indexed_to_array(expr, [l, k, i, j]) == ArrayAdd(PermuteDims(ArrayTensorProduct(O2, A), [1, 0, 2, 3]), PermuteDims(ArrayTensorProduct(B, O2), [1, 0, 2, 3]))
+
+    expr = A[i, j] + B[j, k]
+    O1 = OneArray(3)
+    assert convert_indexed_to_array(expr, [i, j, k]) == ArrayAdd(ArrayTensorProduct(A, O1), ArrayTensorProduct(O1, B))
+
+    C = ArraySymbol("C", (d0, d1))
+    D = ArraySymbol("D", (d3, d1))
+
+    expr = C[i, j] + D[k, j]
+    assert convert_indexed_to_array(expr, [i, j, k]) == ArrayAdd(ArrayTensorProduct(C, OneArray(d3)), PermuteDims(ArrayTensorProduct(OneArray(d0), D), [0, 2, 1]))
+
+    X = ArraySymbol("X", (5, 3))
+
+    expr = X[i, n] - X[j, n]
+    assert convert_indexed_to_array(expr, [i, j, n]) == ArrayAdd(ArrayTensorProduct(-1, OneArray(5), X), PermuteDims(ArrayTensorProduct(X, OneArray(5)), [0, 2, 1]))
+
+    raises(ValueError, lambda: convert_indexed_to_array(C[i, j] + D[i, j]))
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/expressions/tests/test_convert_matrix_to_array.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/expressions/tests/test_convert_matrix_to_array.py
new file mode 100644
index 0000000000000000000000000000000000000000..142585882588df6aa0e4648d9d8881ea755f42a0
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/expressions/tests/test_convert_matrix_to_array.py
@@ -0,0 +1,128 @@
+from sympy import Lambda, KroneckerProduct
+from sympy.core.symbol import symbols, Dummy
+from sympy.matrices.expressions.hadamard import (HadamardPower, HadamardProduct)
+from sympy.matrices.expressions.inverse import Inverse
+from sympy.matrices.expressions.matexpr import MatrixSymbol
+from sympy.matrices.expressions.matpow import MatPow
+from sympy.matrices.expressions.special import Identity
+from sympy.matrices.expressions.trace import Trace
+from sympy.matrices.expressions.transpose import Transpose
+from sympy.tensor.array.expressions.array_expressions import ArrayTensorProduct, ArrayContraction, \
+    PermuteDims, ArrayDiagonal, ArrayElementwiseApplyFunc, _array_contraction, _array_tensor_product, Reshape
+from sympy.tensor.array.expressions.from_array_to_matrix import convert_array_to_matrix
+from sympy.tensor.array.expressions.from_matrix_to_array import convert_matrix_to_array
+
+i, j, k, l, m, n = symbols("i j k l m n")
+
+I = Identity(k)
+
+M = MatrixSymbol("M", k, k)
+N = MatrixSymbol("N", k, k)
+P = MatrixSymbol("P", k, k)
+Q = MatrixSymbol("Q", k, k)
+
+A = MatrixSymbol("A", k, k)
+B = MatrixSymbol("B", k, k)
+C = MatrixSymbol("C", k, k)
+D = MatrixSymbol("D", k, k)
+
+X = MatrixSymbol("X", k, k)
+Y = MatrixSymbol("Y", k, k)
+
+a = MatrixSymbol("a", k, 1)
+b = MatrixSymbol("b", k, 1)
+c = MatrixSymbol("c", k, 1)
+d = MatrixSymbol("d", k, 1)
+
+
+def test_arrayexpr_convert_matrix_to_array():
+
+    expr = M*N
+    result = ArrayContraction(ArrayTensorProduct(M, N), (1, 2))
+    assert convert_matrix_to_array(expr) == result
+
+    expr = M*N*M
+    result = _array_contraction(ArrayTensorProduct(M, N, M), (1, 2), (3, 4))
+    assert convert_matrix_to_array(expr) == result
+
+    expr = Transpose(M)
+    assert convert_matrix_to_array(expr) == PermuteDims(M, [1, 0])
+
+    expr = M*Transpose(N)
+    assert convert_matrix_to_array(expr) == _array_contraction(_array_tensor_product(M, PermuteDims(N, [1, 0])), (1, 2))
+
+    expr = 3*M*N
+    res = convert_matrix_to_array(expr)
+    rexpr = convert_array_to_matrix(res)
+    assert expr == rexpr
+
+    expr = 3*M + N*M.T*M + 4*k*N
+    res = convert_matrix_to_array(expr)
+    rexpr = convert_array_to_matrix(res)
+    assert expr == rexpr
+
+    expr = Inverse(M)*N
+    rexpr = convert_array_to_matrix(convert_matrix_to_array(expr))
+    assert expr == rexpr
+
+    expr = M**2
+    rexpr = convert_array_to_matrix(convert_matrix_to_array(expr))
+    assert expr == rexpr
+
+    expr = M*(2*N + 3*M)
+    res = convert_matrix_to_array(expr)
+    rexpr = convert_array_to_matrix(res)
+    assert expr == rexpr
+
+    expr = Trace(M)
+    result = ArrayContraction(M, (0, 1))
+    assert convert_matrix_to_array(expr) == result
+
+    expr = 3*Trace(M)
+    result = ArrayContraction(ArrayTensorProduct(3, M), (0, 1))
+    assert convert_matrix_to_array(expr) == result
+
+    expr = 3*Trace(Trace(M) * M)
+    result = ArrayContraction(ArrayTensorProduct(3, M, M), (0, 1), (2, 3))
+    assert convert_matrix_to_array(expr) == result
+
+    expr = 3*Trace(M)**2
+    result = ArrayContraction(ArrayTensorProduct(3, M, M), (0, 1), (2, 3))
+    assert convert_matrix_to_array(expr) == result
+
+    expr = HadamardProduct(M, N)
+    result = ArrayDiagonal(ArrayTensorProduct(M, N), (0, 2), (1, 3))
+    assert convert_matrix_to_array(expr) == result
+
+    expr = HadamardProduct(M*N, N*M)
+    result = ArrayDiagonal(ArrayContraction(ArrayTensorProduct(M, N, N, M), (1, 2), (5, 6)), (0, 2), (1, 3))
+    assert convert_matrix_to_array(expr) == result
+
+    expr = HadamardPower(M, 2)
+    result = ArrayDiagonal(ArrayTensorProduct(M, M), (0, 2), (1, 3))
+    assert convert_matrix_to_array(expr) == result
+
+    expr = HadamardPower(M*N, 2)
+    result = ArrayDiagonal(ArrayContraction(ArrayTensorProduct(M, N, M, N), (1, 2), (5, 6)), (0, 2), (1, 3))
+    assert convert_matrix_to_array(expr) == result
+
+    expr = HadamardPower(M, n)
+    d0 = Dummy("d0")
+    result = ArrayElementwiseApplyFunc(Lambda(d0, d0**n), M)
+    assert convert_matrix_to_array(expr).dummy_eq(result)
+
+    expr = M**2
+    assert isinstance(expr, MatPow)
+    assert convert_matrix_to_array(expr) == ArrayContraction(ArrayTensorProduct(M, M), (1, 2))
+
+    expr = a.T*b
+    cg = convert_matrix_to_array(expr)
+    assert cg == ArrayContraction(ArrayTensorProduct(a, b), (0, 2))
+
+    expr = KroneckerProduct(A, B)
+    cg = convert_matrix_to_array(expr)
+    assert cg == Reshape(PermuteDims(ArrayTensorProduct(A, B), [0, 2, 1, 3]), (k**2, k**2))
+
+    expr = KroneckerProduct(A, B, C, D)
+    cg = convert_matrix_to_array(expr)
+    assert cg == Reshape(PermuteDims(ArrayTensorProduct(A, B, C, D), [0, 2, 4, 6, 1, 3, 5, 7]), (k**4, k**4))
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/expressions/tests/test_deprecated_conv_modules.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/expressions/tests/test_deprecated_conv_modules.py
new file mode 100644
index 0000000000000000000000000000000000000000..b41b6105410a308e7774fce760b235497d0303bb
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/expressions/tests/test_deprecated_conv_modules.py
@@ -0,0 +1,22 @@
+from sympy import MatrixSymbol, symbols, Sum
+from sympy.tensor.array.expressions import conv_array_to_indexed, from_array_to_indexed, ArrayTensorProduct, \
+    ArrayContraction, conv_array_to_matrix, from_array_to_matrix, conv_matrix_to_array, from_matrix_to_array, \
+    conv_indexed_to_array, from_indexed_to_array
+from sympy.testing.pytest import warns
+from sympy.utilities.exceptions import SymPyDeprecationWarning
+
+
+def test_deprecated_conv_module_results():
+
+    M = MatrixSymbol("M", 3, 3)
+    N = MatrixSymbol("N", 3, 3)
+    i, j, d = symbols("i j d")
+
+    x = ArrayContraction(ArrayTensorProduct(M, N), (1, 2))
+    y = Sum(M[i, d]*N[d, j], (d, 0, 2))
+
+    with warns(SymPyDeprecationWarning, test_stacklevel=False):
+        assert conv_array_to_indexed.convert_array_to_indexed(x, [i, j]).dummy_eq(from_array_to_indexed.convert_array_to_indexed(x, [i, j]))
+        assert conv_array_to_matrix.convert_array_to_matrix(x) == from_array_to_matrix.convert_array_to_matrix(x)
+        assert conv_matrix_to_array.convert_matrix_to_array(M*N) == from_matrix_to_array.convert_matrix_to_array(M*N)
+        assert conv_indexed_to_array.convert_indexed_to_array(y) == from_indexed_to_array.convert_indexed_to_array(y)
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/expressions/utils.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/expressions/utils.py
new file mode 100644
index 0000000000000000000000000000000000000000..e55c0e6ed47cdc9ff1c24cc92f006998aeb86822
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/expressions/utils.py
@@ -0,0 +1,123 @@
+import bisect
+from collections import defaultdict
+
+from sympy.combinatorics import Permutation
+from sympy.core.containers import Tuple
+from sympy.core.numbers import Integer
+
+
+def _get_mapping_from_subranks(subranks):
+    mapping = {}
+    counter = 0
+    for i, rank in enumerate(subranks):
+        for j in range(rank):
+            mapping[counter] = (i, j)
+            counter += 1
+    return mapping
+
+
+def _get_contraction_links(args, subranks, *contraction_indices):
+    mapping = _get_mapping_from_subranks(subranks)
+    contraction_tuples = [[mapping[j] for j in i] for i in contraction_indices]
+    dlinks = defaultdict(dict)
+    for links in contraction_tuples:
+        if len(links) == 2:
+            (arg1, pos1), (arg2, pos2) = links
+            dlinks[arg1][pos1] = (arg2, pos2)
+            dlinks[arg2][pos2] = (arg1, pos1)
+            continue
+
+    return args, dict(dlinks)
+
+
+def _sort_contraction_indices(pairing_indices):
+    pairing_indices = [Tuple(*sorted(i)) for i in pairing_indices]
+    pairing_indices.sort(key=lambda x: min(x))
+    return pairing_indices
+
+
+def _get_diagonal_indices(flattened_indices):
+    axes_contraction = defaultdict(list)
+    for i, ind in enumerate(flattened_indices):
+        if isinstance(ind, (int, Integer)):
+            # If the indices is a number, there can be no diagonal operation:
+            continue
+        axes_contraction[ind].append(i)
+    axes_contraction = {k: v for k, v in axes_contraction.items() if len(v) > 1}
+    # Put the diagonalized indices at the end:
+    ret_indices = [i for i in flattened_indices if i not in axes_contraction]
+    diag_indices = list(axes_contraction)
+    diag_indices.sort(key=lambda x: flattened_indices.index(x))
+    diagonal_indices = [tuple(axes_contraction[i]) for i in diag_indices]
+    ret_indices += diag_indices
+    ret_indices = tuple(ret_indices)
+    return diagonal_indices, ret_indices
+
+
+def _get_argindex(subindices, ind):
+    for i, sind in enumerate(subindices):
+        if ind == sind:
+            return i
+        if isinstance(sind, (set, frozenset)) and ind in sind:
+            return i
+    raise IndexError("%s not found in %s" % (ind, subindices))
+
+
+def _apply_recursively_over_nested_lists(func, arr):
+    if isinstance(arr, (tuple, list, Tuple)):
+        return tuple(_apply_recursively_over_nested_lists(func, i) for i in arr)
+    elif isinstance(arr, Tuple):
+        return Tuple.fromiter(_apply_recursively_over_nested_lists(func, i) for i in arr)
+    else:
+        return func(arr)
+
+
+def _build_push_indices_up_func_transformation(flattened_contraction_indices):
+    shifts = {0: 0}
+    i = 0
+    cumulative = 0
+    while i < len(flattened_contraction_indices):
+        j = 1
+        while i+j < len(flattened_contraction_indices):
+            if flattened_contraction_indices[i] + j != flattened_contraction_indices[i+j]:
+                break
+            j += 1
+        cumulative += j
+        shifts[flattened_contraction_indices[i]] = cumulative
+        i += j
+    shift_keys = sorted(shifts.keys())
+
+    def func(idx):
+        return shifts[shift_keys[bisect.bisect_right(shift_keys, idx)-1]]
+
+    def transform(j):
+        if j in flattened_contraction_indices:
+            return None
+        else:
+            return j - func(j)
+
+    return transform
+
+
+def _build_push_indices_down_func_transformation(flattened_contraction_indices):
+    N = flattened_contraction_indices[-1]+2
+
+    shifts = [i for i in range(N) if i not in flattened_contraction_indices]
+
+    def transform(j):
+        if j < len(shifts):
+            return shifts[j]
+        else:
+            return j + shifts[-1] - len(shifts) + 1
+
+    return transform
+
+
+def _apply_permutation_to_list(perm: Permutation, target_list: list):
+    """
+    Permute a list according to the given permutation.
+    """
+    new_list = [None for i in range(perm.size)]
+    for i, e in enumerate(target_list):
+        new_list[perm(i)] = e
+    return new_list
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/mutable_ndim_array.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/mutable_ndim_array.py
new file mode 100644
index 0000000000000000000000000000000000000000..e1eaaf7241bc3b4a48234178d18da3aa5736e189
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/mutable_ndim_array.py
@@ -0,0 +1,13 @@
+from sympy.tensor.array.ndim_array import NDimArray
+
+
+class MutableNDimArray(NDimArray):
+
+    def as_immutable(self):
+        raise NotImplementedError("abstract method")
+
+    def as_mutable(self):
+        return self
+
+    def _sympy_(self):
+        return self.as_immutable()
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/ndim_array.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/ndim_array.py
new file mode 100644
index 0000000000000000000000000000000000000000..2b9a857b8cfd9ee46646c46f274636d6b9962b6e
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/ndim_array.py
@@ -0,0 +1,601 @@
+from sympy.core.basic import Basic
+from sympy.core.containers import (Dict, Tuple)
+from sympy.core.expr import Expr
+from sympy.core.kind import Kind, NumberKind, UndefinedKind
+from sympy.core.numbers import Integer
+from sympy.core.singleton import S
+from sympy.core.sympify import sympify
+from sympy.external.gmpy import SYMPY_INTS
+from sympy.printing.defaults import Printable
+
+import itertools
+from collections.abc import Iterable
+
+
+class ArrayKind(Kind):
+    """
+    Kind for N-dimensional array in SymPy.
+
+    This kind represents the multidimensional array that algebraic
+    operations are defined. Basic class for this kind is ``NDimArray``,
+    but any expression representing the array can have this.
+
+    Parameters
+    ==========
+
+    element_kind : Kind
+        Kind of the element. Default is :obj:NumberKind `<sympy.core.kind.NumberKind>`,
+        which means that the array contains only numbers.
+
+    Examples
+    ========
+
+    Any instance of array class has ``ArrayKind``.
+
+    >>> from sympy import NDimArray
+    >>> NDimArray([1,2,3]).kind
+    ArrayKind(NumberKind)
+
+    Although expressions representing an array may be not instance of
+    array class, it will have ``ArrayKind`` as well.
+
+    >>> from sympy import Integral
+    >>> from sympy.tensor.array import NDimArray
+    >>> from sympy.abc import x
+    >>> intA = Integral(NDimArray([1,2,3]), x)
+    >>> isinstance(intA, NDimArray)
+    False
+    >>> intA.kind
+    ArrayKind(NumberKind)
+
+    Use ``isinstance()`` to check for ``ArrayKind` without specifying
+    the element kind. Use ``is`` with specifying the element kind.
+
+    >>> from sympy.tensor.array import ArrayKind
+    >>> from sympy.core import NumberKind
+    >>> boolA = NDimArray([True, False])
+    >>> isinstance(boolA.kind, ArrayKind)
+    True
+    >>> boolA.kind is ArrayKind(NumberKind)
+    False
+
+    See Also
+    ========
+
+    shape : Function to return the shape of objects with ``MatrixKind``.
+
+    """
+    def __new__(cls, element_kind=NumberKind):
+        obj = super().__new__(cls, element_kind)
+        obj.element_kind = element_kind
+        return obj
+
+    def __repr__(self):
+        return "ArrayKind(%s)" % self.element_kind
+
+    @classmethod
+    def _union(cls, kinds) -> 'ArrayKind':
+        elem_kinds = {e.kind for e in kinds}
+        if len(elem_kinds) == 1:
+            elemkind, = elem_kinds
+        else:
+            elemkind = UndefinedKind
+        return ArrayKind(elemkind)
+
+
+class NDimArray(Printable):
+    """N-dimensional array.
+
+    Examples
+    ========
+
+    Create an N-dim array of zeros:
+
+    >>> from sympy import MutableDenseNDimArray
+    >>> a = MutableDenseNDimArray.zeros(2, 3, 4)
+    >>> a
+    [[[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]], [[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]]]
+
+    Create an N-dim array from a list;
+
+    >>> a = MutableDenseNDimArray([[2, 3], [4, 5]])
+    >>> a
+    [[2, 3], [4, 5]]
+
+    >>> b = MutableDenseNDimArray([[[1, 2], [3, 4], [5, 6]], [[7, 8], [9, 10], [11, 12]]])
+    >>> b
+    [[[1, 2], [3, 4], [5, 6]], [[7, 8], [9, 10], [11, 12]]]
+
+    Create an N-dim array from a flat list with dimension shape:
+
+    >>> a = MutableDenseNDimArray([1, 2, 3, 4, 5, 6], (2, 3))
+    >>> a
+    [[1, 2, 3], [4, 5, 6]]
+
+    Create an N-dim array from a matrix:
+
+    >>> from sympy import Matrix
+    >>> a = Matrix([[1,2],[3,4]])
+    >>> a
+    Matrix([
+    [1, 2],
+    [3, 4]])
+    >>> b = MutableDenseNDimArray(a)
+    >>> b
+    [[1, 2], [3, 4]]
+
+    Arithmetic operations on N-dim arrays
+
+    >>> a = MutableDenseNDimArray([1, 1, 1, 1], (2, 2))
+    >>> b = MutableDenseNDimArray([4, 4, 4, 4], (2, 2))
+    >>> c = a + b
+    >>> c
+    [[5, 5], [5, 5]]
+    >>> a - b
+    [[-3, -3], [-3, -3]]
+
+    """
+
+    _diff_wrt = True
+    is_scalar = False
+
+    def __new__(cls, iterable, shape=None, **kwargs):
+        from sympy.tensor.array import ImmutableDenseNDimArray
+        return ImmutableDenseNDimArray(iterable, shape, **kwargs)
+
+    def __getitem__(self, index):
+        raise NotImplementedError("A subclass of NDimArray should implement __getitem__")
+
+    def _parse_index(self, index):
+        if isinstance(index, (SYMPY_INTS, Integer)):
+            if index >= self._loop_size:
+                raise ValueError("Only a tuple index is accepted")
+            return index
+
+        if self._loop_size == 0:
+            raise ValueError("Index not valid with an empty array")
+
+        if len(index) != self._rank:
+            raise ValueError('Wrong number of array axes')
+
+        real_index = 0
+        # check if input index can exist in current indexing
+        for i in range(self._rank):
+            if (index[i] >= self.shape[i]) or (index[i] < -self.shape[i]):
+                raise ValueError('Index ' + str(index) + ' out of border')
+            if index[i] < 0:
+                real_index += 1
+            real_index = real_index*self.shape[i] + index[i]
+
+        return real_index
+
+    def _get_tuple_index(self, integer_index):
+        index = []
+        for sh in reversed(self.shape):
+            index.append(integer_index % sh)
+            integer_index //= sh
+        index.reverse()
+        return tuple(index)
+
+    def _check_symbolic_index(self, index):
+        # Check if any index is symbolic:
+        tuple_index = (index if isinstance(index, tuple) else (index,))
+        if any((isinstance(i, Expr) and (not i.is_number)) for i in tuple_index):
+            for i, nth_dim in zip(tuple_index, self.shape):
+                if ((i < 0) == True) or ((i >= nth_dim) == True):
+                    raise ValueError("index out of range")
+            from sympy.tensor import Indexed
+            return Indexed(self, *tuple_index)
+        return None
+
+    def _setter_iterable_check(self, value):
+        from sympy.matrices.matrixbase import MatrixBase
+        if isinstance(value, (Iterable, MatrixBase, NDimArray)):
+            raise NotImplementedError
+
+    @classmethod
+    def _scan_iterable_shape(cls, iterable):
+        def f(pointer):
+            if not isinstance(pointer, Iterable):
+                return [pointer], ()
+
+            if len(pointer) == 0:
+                return [], (0,)
+
+            result = []
+            elems, shapes = zip(*[f(i) for i in pointer])
+            if len(set(shapes)) != 1:
+                raise ValueError("could not determine shape unambiguously")
+            for i in elems:
+                result.extend(i)
+            return result, (len(shapes),)+shapes[0]
+
+        return f(iterable)
+
+    @classmethod
+    def _handle_ndarray_creation_inputs(cls, iterable=None, shape=None, **kwargs):
+        from sympy.matrices.matrixbase import MatrixBase
+        from sympy.tensor.array import SparseNDimArray
+
+        if shape is None:
+            if iterable is None:
+                shape = ()
+                iterable = ()
+            # Construction of a sparse array from a sparse array
+            elif isinstance(iterable, SparseNDimArray):
+                return iterable._shape, iterable._sparse_array
+
+            # Construct N-dim array from another N-dim array:
+            elif isinstance(iterable, NDimArray):
+                shape = iterable.shape
+
+            # Construct N-dim array from an iterable (numpy arrays included):
+            elif isinstance(iterable, Iterable):
+                iterable, shape = cls._scan_iterable_shape(iterable)
+
+            # Construct N-dim array from a Matrix:
+            elif isinstance(iterable, MatrixBase):
+                shape = iterable.shape
+
+            else:
+                shape = ()
+                iterable = (iterable,)
+
+        if isinstance(iterable, (Dict, dict)) and shape is not None:
+            new_dict = iterable.copy()
+            for k in new_dict:
+                if isinstance(k, (tuple, Tuple)):
+                    new_key = 0
+                    for i, idx in enumerate(k):
+                        new_key = new_key * shape[i] + idx
+                    iterable[new_key] = iterable[k]
+                    del iterable[k]
+
+        if isinstance(shape, (SYMPY_INTS, Integer)):
+            shape = (shape,)
+
+        if not all(isinstance(dim, (SYMPY_INTS, Integer)) for dim in shape):
+            raise TypeError("Shape should contain integers only.")
+
+        return tuple(shape), iterable
+
+    def __len__(self):
+        """Overload common function len(). Returns number of elements in array.
+
+        Examples
+        ========
+
+        >>> from sympy import MutableDenseNDimArray
+        >>> a = MutableDenseNDimArray.zeros(3, 3)
+        >>> a
+        [[0, 0, 0], [0, 0, 0], [0, 0, 0]]
+        >>> len(a)
+        9
+
+        """
+        return self._loop_size
+
+    @property
+    def shape(self):
+        """
+        Returns array shape (dimension).
+
+        Examples
+        ========
+
+        >>> from sympy import MutableDenseNDimArray
+        >>> a = MutableDenseNDimArray.zeros(3, 3)
+        >>> a.shape
+        (3, 3)
+
+        """
+        return self._shape
+
+    def rank(self):
+        """
+        Returns rank of array.
+
+        Examples
+        ========
+
+        >>> from sympy import MutableDenseNDimArray
+        >>> a = MutableDenseNDimArray.zeros(3,4,5,6,3)
+        >>> a.rank()
+        5
+
+        """
+        return self._rank
+
+    def diff(self, *args, **kwargs):
+        """
+        Calculate the derivative of each element in the array.
+
+        Examples
+        ========
+
+        >>> from sympy import ImmutableDenseNDimArray
+        >>> from sympy.abc import x, y
+        >>> M = ImmutableDenseNDimArray([[x, y], [1, x*y]])
+        >>> M.diff(x)
+        [[1, 0], [0, y]]
+
+        """
+        from sympy.tensor.array.array_derivatives import ArrayDerivative
+        kwargs.setdefault('evaluate', True)
+        return ArrayDerivative(self.as_immutable(), *args, **kwargs)
+
+    def _eval_derivative(self, base):
+        # Types are (base: scalar, self: array)
+        return self.applyfunc(lambda x: base.diff(x))
+
+    def _eval_derivative_n_times(self, s, n):
+        return Basic._eval_derivative_n_times(self, s, n)
+
+    def applyfunc(self, f):
+        """Apply a function to each element of the N-dim array.
+
+        Examples
+        ========
+
+        >>> from sympy import ImmutableDenseNDimArray
+        >>> m = ImmutableDenseNDimArray([i*2+j for i in range(2) for j in range(2)], (2, 2))
+        >>> m
+        [[0, 1], [2, 3]]
+        >>> m.applyfunc(lambda i: 2*i)
+        [[0, 2], [4, 6]]
+        """
+        from sympy.tensor.array import SparseNDimArray
+        from sympy.tensor.array.arrayop import Flatten
+
+        if isinstance(self, SparseNDimArray) and f(S.Zero) == 0:
+            return type(self)({k: f(v) for k, v in self._sparse_array.items() if f(v) != 0}, self.shape)
+
+        return type(self)(map(f, Flatten(self)), self.shape)
+
+    def _sympystr(self, printer):
+        def f(sh, shape_left, i, j):
+            if len(shape_left) == 1:
+                return "["+", ".join([printer._print(self[self._get_tuple_index(e)]) for e in range(i, j)])+"]"
+
+            sh //= shape_left[0]
+            return "[" + ", ".join([f(sh, shape_left[1:], i+e*sh, i+(e+1)*sh) for e in range(shape_left[0])]) + "]" # + "\n"*len(shape_left)
+
+        if self.rank() == 0:
+            return printer._print(self[()])
+        if 0 in self.shape:
+            return f"{self.__class__.__name__}([], {self.shape})"
+        return f(self._loop_size, self.shape, 0, self._loop_size)
+
+    def tolist(self):
+        """
+        Converting MutableDenseNDimArray to one-dim list
+
+        Examples
+        ========
+
+        >>> from sympy import MutableDenseNDimArray
+        >>> a = MutableDenseNDimArray([1, 2, 3, 4], (2, 2))
+        >>> a
+        [[1, 2], [3, 4]]
+        >>> b = a.tolist()
+        >>> b
+        [[1, 2], [3, 4]]
+        """
+
+        def f(sh, shape_left, i, j):
+            if len(shape_left) == 1:
+                return [self[self._get_tuple_index(e)] for e in range(i, j)]
+            result = []
+            sh //= shape_left[0]
+            for e in range(shape_left[0]):
+                result.append(f(sh, shape_left[1:], i+e*sh, i+(e+1)*sh))
+            return result
+
+        return f(self._loop_size, self.shape, 0, self._loop_size)
+
+    def __add__(self, other):
+        from sympy.tensor.array.arrayop import Flatten
+
+        if not isinstance(other, NDimArray):
+            return NotImplemented
+
+        if self.shape != other.shape:
+            raise ValueError("array shape mismatch")
+        result_list = [i+j for i,j in zip(Flatten(self), Flatten(other))]
+
+        return type(self)(result_list, self.shape)
+
+    def __sub__(self, other):
+        from sympy.tensor.array.arrayop import Flatten
+
+        if not isinstance(other, NDimArray):
+            return NotImplemented
+
+        if self.shape != other.shape:
+            raise ValueError("array shape mismatch")
+        result_list = [i-j for i,j in zip(Flatten(self), Flatten(other))]
+
+        return type(self)(result_list, self.shape)
+
+    def __mul__(self, other):
+        from sympy.matrices.matrixbase import MatrixBase
+        from sympy.tensor.array import SparseNDimArray
+        from sympy.tensor.array.arrayop import Flatten
+
+        if isinstance(other, (Iterable, NDimArray, MatrixBase)):
+            raise ValueError("scalar expected, use tensorproduct(...) for tensorial product")
+
+        other = sympify(other)
+        if isinstance(self, SparseNDimArray):
+            if other.is_zero:
+                return type(self)({}, self.shape)
+            return type(self)({k: other*v for (k, v) in self._sparse_array.items()}, self.shape)
+
+        result_list = [i*other for i in Flatten(self)]
+        return type(self)(result_list, self.shape)
+
+    def __rmul__(self, other):
+        from sympy.matrices.matrixbase import MatrixBase
+        from sympy.tensor.array import SparseNDimArray
+        from sympy.tensor.array.arrayop import Flatten
+
+        if isinstance(other, (Iterable, NDimArray, MatrixBase)):
+            raise ValueError("scalar expected, use tensorproduct(...) for tensorial product")
+
+        other = sympify(other)
+        if isinstance(self, SparseNDimArray):
+            if other.is_zero:
+                return type(self)({}, self.shape)
+            return type(self)({k: other*v for (k, v) in self._sparse_array.items()}, self.shape)
+
+        result_list = [other*i for i in Flatten(self)]
+        return type(self)(result_list, self.shape)
+
+    def __truediv__(self, other):
+        from sympy.matrices.matrixbase import MatrixBase
+        from sympy.tensor.array import SparseNDimArray
+        from sympy.tensor.array.arrayop import Flatten
+
+        if isinstance(other, (Iterable, NDimArray, MatrixBase)):
+            raise ValueError("scalar expected")
+
+        other = sympify(other)
+        if isinstance(self, SparseNDimArray) and other != S.Zero:
+            return type(self)({k: v/other for (k, v) in self._sparse_array.items()}, self.shape)
+
+        result_list = [i/other for i in Flatten(self)]
+        return type(self)(result_list, self.shape)
+
+    def __rtruediv__(self, other):
+        raise NotImplementedError('unsupported operation on NDimArray')
+
+    def __neg__(self):
+        from sympy.tensor.array import SparseNDimArray
+        from sympy.tensor.array.arrayop import Flatten
+
+        if isinstance(self, SparseNDimArray):
+            return type(self)({k: -v for (k, v) in self._sparse_array.items()}, self.shape)
+
+        result_list = [-i for i in Flatten(self)]
+        return type(self)(result_list, self.shape)
+
+    def __iter__(self):
+        def iterator():
+            if self._shape:
+                for i in range(self._shape[0]):
+                    yield self[i]
+            else:
+                yield self[()]
+
+        return iterator()
+
+    def __eq__(self, other):
+        """
+        NDimArray instances can be compared to each other.
+        Instances equal if they have same shape and data.
+
+        Examples
+        ========
+
+        >>> from sympy import MutableDenseNDimArray
+        >>> a = MutableDenseNDimArray.zeros(2, 3)
+        >>> b = MutableDenseNDimArray.zeros(2, 3)
+        >>> a == b
+        True
+        >>> c = a.reshape(3, 2)
+        >>> c == b
+        False
+        >>> a[0,0] = 1
+        >>> b[0,0] = 2
+        >>> a == b
+        False
+        """
+        from sympy.tensor.array import SparseNDimArray
+        if not isinstance(other, NDimArray):
+            return False
+
+        if not self.shape == other.shape:
+            return False
+
+        if isinstance(self, SparseNDimArray) and isinstance(other, SparseNDimArray):
+            return dict(self._sparse_array) == dict(other._sparse_array)
+
+        return list(self) == list(other)
+
+    def __ne__(self, other):
+        return not self == other
+
+    def _eval_transpose(self):
+        if self.rank() != 2:
+            raise ValueError("array rank not 2")
+        from .arrayop import permutedims
+        return permutedims(self, (1, 0))
+
+    def transpose(self):
+        return self._eval_transpose()
+
+    def _eval_conjugate(self):
+        from sympy.tensor.array.arrayop import Flatten
+
+        return self.func([i.conjugate() for i in Flatten(self)], self.shape)
+
+    def conjugate(self):
+        return self._eval_conjugate()
+
+    def _eval_adjoint(self):
+        return self.transpose().conjugate()
+
+    def adjoint(self):
+        return self._eval_adjoint()
+
+    def _slice_expand(self, s, dim):
+        if not isinstance(s, slice):
+                return (s,)
+        start, stop, step = s.indices(dim)
+        return [start + i*step for i in range((stop-start)//step)]
+
+    def _get_slice_data_for_array_access(self, index):
+        sl_factors = [self._slice_expand(i, dim) for (i, dim) in zip(index, self.shape)]
+        eindices = itertools.product(*sl_factors)
+        return sl_factors, eindices
+
+    def _get_slice_data_for_array_assignment(self, index, value):
+        if not isinstance(value, NDimArray):
+            value = type(self)(value)
+        sl_factors, eindices = self._get_slice_data_for_array_access(index)
+        slice_offsets = [min(i) if isinstance(i, list) else None for i in sl_factors]
+        # TODO: add checks for dimensions for `value`?
+        return value, eindices, slice_offsets
+
+    @classmethod
+    def _check_special_bounds(cls, flat_list, shape):
+        if shape == () and len(flat_list) != 1:
+            raise ValueError("arrays without shape need one scalar value")
+        if shape == (0,) and len(flat_list) > 0:
+            raise ValueError("if array shape is (0,) there cannot be elements")
+
+    def _check_index_for_getitem(self, index):
+        if isinstance(index, (SYMPY_INTS, Integer, slice)):
+            index = (index,)
+
+        if len(index) < self.rank():
+            index = tuple(index) + \
+                          tuple(slice(None) for i in range(len(index), self.rank()))
+
+        if len(index) > self.rank():
+            raise ValueError('Dimension of index greater than rank of array')
+
+        return index
+
+
+class ImmutableNDimArray(NDimArray, Basic):
+    _op_priority = 11.0
+
+    def __hash__(self):
+        return Basic.__hash__(self)
+
+    def as_immutable(self):
+        return self
+
+    def as_mutable(self):
+        raise NotImplementedError("abstract method")
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/sparse_ndim_array.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/sparse_ndim_array.py
new file mode 100644
index 0000000000000000000000000000000000000000..f11aa95be8ec9d10a9104d48fb28f406fe43845e
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/sparse_ndim_array.py
@@ -0,0 +1,196 @@
+from sympy.core.basic import Basic
+from sympy.core.containers import (Dict, Tuple)
+from sympy.core.singleton import S
+from sympy.core.sympify import _sympify
+from sympy.tensor.array.mutable_ndim_array import MutableNDimArray
+from sympy.tensor.array.ndim_array import NDimArray, ImmutableNDimArray
+from sympy.utilities.iterables import flatten
+
+import functools
+
+class SparseNDimArray(NDimArray):
+
+    def __new__(self, *args, **kwargs):
+        return ImmutableSparseNDimArray(*args, **kwargs)
+
+    def __getitem__(self, index):
+        """
+        Get an element from a sparse N-dim array.
+
+        Examples
+        ========
+
+        >>> from sympy import MutableSparseNDimArray
+        >>> a = MutableSparseNDimArray(range(4), (2, 2))
+        >>> a
+        [[0, 1], [2, 3]]
+        >>> a[0, 0]
+        0
+        >>> a[1, 1]
+        3
+        >>> a[0]
+        [0, 1]
+        >>> a[1]
+        [2, 3]
+
+        Symbolic indexing:
+
+        >>> from sympy.abc import i, j
+        >>> a[i, j]
+        [[0, 1], [2, 3]][i, j]
+
+        Replace `i` and `j` to get element `(0, 0)`:
+
+        >>> a[i, j].subs({i: 0, j: 0})
+        0
+
+        """
+        syindex = self._check_symbolic_index(index)
+        if syindex is not None:
+            return syindex
+
+        index = self._check_index_for_getitem(index)
+
+        # `index` is a tuple with one or more slices:
+        if isinstance(index, tuple) and any(isinstance(i, slice) for i in index):
+            sl_factors, eindices = self._get_slice_data_for_array_access(index)
+            array = [self._sparse_array.get(self._parse_index(i), S.Zero) for i in eindices]
+            nshape = [len(el) for i, el in enumerate(sl_factors) if isinstance(index[i], slice)]
+            return type(self)(array, nshape)
+        else:
+            index = self._parse_index(index)
+            return self._sparse_array.get(index, S.Zero)
+
+    @classmethod
+    def zeros(cls, *shape):
+        """
+        Return a sparse N-dim array of zeros.
+        """
+        return cls({}, shape)
+
+    def tomatrix(self):
+        """
+        Converts MutableDenseNDimArray to Matrix. Can convert only 2-dim array, else will raise error.
+
+        Examples
+        ========
+
+        >>> from sympy import MutableSparseNDimArray
+        >>> a = MutableSparseNDimArray([1 for i in range(9)], (3, 3))
+        >>> b = a.tomatrix()
+        >>> b
+        Matrix([
+        [1, 1, 1],
+        [1, 1, 1],
+        [1, 1, 1]])
+        """
+        from sympy.matrices import SparseMatrix
+        if self.rank() != 2:
+            raise ValueError('Dimensions must be of size of 2')
+
+        mat_sparse = {}
+        for key, value in self._sparse_array.items():
+            mat_sparse[self._get_tuple_index(key)] = value
+
+        return SparseMatrix(self.shape[0], self.shape[1], mat_sparse)
+
+    def reshape(self, *newshape):
+        new_total_size = functools.reduce(lambda x,y: x*y, newshape)
+        if new_total_size != self._loop_size:
+            raise ValueError("Invalid reshape parameters " + newshape)
+
+        return type(self)(self._sparse_array, newshape)
+
+class ImmutableSparseNDimArray(SparseNDimArray, ImmutableNDimArray): # type: ignore
+
+    def __new__(cls, iterable=None, shape=None, **kwargs):
+        shape, flat_list = cls._handle_ndarray_creation_inputs(iterable, shape, **kwargs)
+        shape = Tuple(*map(_sympify, shape))
+        cls._check_special_bounds(flat_list, shape)
+        loop_size = functools.reduce(lambda x,y: x*y, shape) if shape else len(flat_list)
+
+        # Sparse array:
+        if isinstance(flat_list, (dict, Dict)):
+            sparse_array = Dict(flat_list)
+        else:
+            sparse_array = {}
+            for i, el in enumerate(flatten(flat_list)):
+                if el != 0:
+                    sparse_array[i] = _sympify(el)
+
+        sparse_array = Dict(sparse_array)
+
+        self = Basic.__new__(cls, sparse_array, shape, **kwargs)
+        self._shape = shape
+        self._rank = len(shape)
+        self._loop_size = loop_size
+        self._sparse_array = sparse_array
+
+        return self
+
+    def __setitem__(self, index, value):
+        raise TypeError("immutable N-dim array")
+
+    def as_mutable(self):
+        return MutableSparseNDimArray(self)
+
+
+class MutableSparseNDimArray(MutableNDimArray, SparseNDimArray):
+
+    def __new__(cls, iterable=None, shape=None, **kwargs):
+        shape, flat_list = cls._handle_ndarray_creation_inputs(iterable, shape, **kwargs)
+        self = object.__new__(cls)
+        self._shape = shape
+        self._rank = len(shape)
+        self._loop_size = functools.reduce(lambda x,y: x*y, shape) if shape else len(flat_list)
+
+        # Sparse array:
+        if isinstance(flat_list, (dict, Dict)):
+            self._sparse_array = dict(flat_list)
+            return self
+
+        self._sparse_array = {}
+
+        for i, el in enumerate(flatten(flat_list)):
+            if el != 0:
+                self._sparse_array[i] = _sympify(el)
+
+        return self
+
+    def __setitem__(self, index, value):
+        """Allows to set items to MutableDenseNDimArray.
+
+        Examples
+        ========
+
+        >>> from sympy import MutableSparseNDimArray
+        >>> a = MutableSparseNDimArray.zeros(2, 2)
+        >>> a[0, 0] = 1
+        >>> a[1, 1] = 1
+        >>> a
+        [[1, 0], [0, 1]]
+        """
+        if isinstance(index, tuple) and any(isinstance(i, slice) for i in index):
+            value, eindices, slice_offsets = self._get_slice_data_for_array_assignment(index, value)
+            for i in eindices:
+                other_i = [ind - j for ind, j in zip(i, slice_offsets) if j is not None]
+                other_value = value[other_i]
+                complete_index = self._parse_index(i)
+                if other_value != 0:
+                    self._sparse_array[complete_index] = other_value
+                elif complete_index in self._sparse_array:
+                    self._sparse_array.pop(complete_index)
+        else:
+            index = self._parse_index(index)
+            value = _sympify(value)
+            if value == 0 and index in self._sparse_array:
+                self._sparse_array.pop(index)
+            else:
+                self._sparse_array[index] = value
+
+    def as_immutable(self):
+        return ImmutableSparseNDimArray(self)
+
+    @property
+    def free_symbols(self):
+        return {i for j in self._sparse_array.values() for i in j.free_symbols}
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/tests/__init__.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/tests/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/tests/__pycache__/__init__.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/tests/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f90f2d8f0f912dffa0d6c58286258443bb27720f
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/tests/__pycache__/__init__.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/tests/__pycache__/test_array_comprehension.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/tests/__pycache__/test_array_comprehension.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..22138cd915fd263beb753cf6c1ce171e053257a0
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/tests/__pycache__/test_array_comprehension.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/tests/__pycache__/test_array_derivatives.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/tests/__pycache__/test_array_derivatives.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..0a896ce7f0ed4edc233ed8cc6a76c61042d36c70
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/tests/__pycache__/test_array_derivatives.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/tests/__pycache__/test_arrayop.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/tests/__pycache__/test_arrayop.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..57901d6dfae9f51429d3e0ea2b7a62d1a519595d
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/tests/__pycache__/test_arrayop.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/tests/__pycache__/test_immutable_ndim_array.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/tests/__pycache__/test_immutable_ndim_array.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..e1e3a1bea84a3d374c79e3a0a641da6924c09277
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/tests/__pycache__/test_immutable_ndim_array.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/tests/__pycache__/test_mutable_ndim_array.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/tests/__pycache__/test_mutable_ndim_array.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5a11238ffadc8f84f7c672f0a7d49890d34e81ab
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/tests/__pycache__/test_mutable_ndim_array.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/tests/__pycache__/test_ndim_array.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/tests/__pycache__/test_ndim_array.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..964bfb1a3604b241234b42ee78ae6338fe09b73d
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/tests/__pycache__/test_ndim_array.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/tests/__pycache__/test_ndim_array_conversions.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/tests/__pycache__/test_ndim_array_conversions.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..8f02601c0d546883b26a38e52b4b2f3b8ea7f7a3
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/tests/__pycache__/test_ndim_array_conversions.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/tests/test_array_comprehension.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/tests/test_array_comprehension.py
new file mode 100644
index 0000000000000000000000000000000000000000..510e068f287fa04419712e5e9a16a314e522a62d
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/tests/test_array_comprehension.py
@@ -0,0 +1,78 @@
+from sympy.tensor.array.array_comprehension import ArrayComprehension, ArrayComprehensionMap
+from sympy.tensor.array import ImmutableDenseNDimArray
+from sympy.abc import i, j, k, l
+from sympy.testing.pytest import raises
+from sympy.matrices import Matrix
+
+
+def test_array_comprehension():
+    a = ArrayComprehension(i*j, (i, 1, 3), (j, 2, 4))
+    b = ArrayComprehension(i, (i, 1, j+1))
+    c = ArrayComprehension(i+j+k+l, (i, 1, 2), (j, 1, 3), (k, 1, 4), (l, 1, 5))
+    d = ArrayComprehension(k, (i, 1, 5))
+    e = ArrayComprehension(i, (j, k+1, k+5))
+    assert a.doit().tolist() == [[2, 3, 4], [4, 6, 8], [6, 9, 12]]
+    assert a.shape == (3, 3)
+    assert a.is_shape_numeric == True
+    assert a.tolist() == [[2, 3, 4], [4, 6, 8], [6, 9, 12]]
+    assert a.tomatrix() == Matrix([
+                           [2, 3, 4],
+                           [4, 6, 8],
+                           [6, 9, 12]])
+    assert len(a) == 9
+    assert isinstance(b.doit(), ArrayComprehension)
+    assert isinstance(a.doit(), ImmutableDenseNDimArray)
+    assert b.subs(j, 3) == ArrayComprehension(i, (i, 1, 4))
+    assert b.free_symbols == {j}
+    assert b.shape == (j + 1,)
+    assert b.rank() == 1
+    assert b.is_shape_numeric == False
+    assert c.free_symbols == set()
+    assert c.function == i + j + k + l
+    assert c.limits == ((i, 1, 2), (j, 1, 3), (k, 1, 4), (l, 1, 5))
+    assert c.doit().tolist() == [[[[4, 5, 6, 7, 8], [5, 6, 7, 8, 9], [6, 7, 8, 9, 10], [7, 8, 9, 10, 11]],
+                                  [[5, 6, 7, 8, 9], [6, 7, 8, 9, 10], [7, 8, 9, 10, 11], [8, 9, 10, 11, 12]],
+                                  [[6, 7, 8, 9, 10], [7, 8, 9, 10, 11], [8, 9, 10, 11, 12], [9, 10, 11, 12, 13]]],
+                                 [[[5, 6, 7, 8, 9], [6, 7, 8, 9, 10], [7, 8, 9, 10, 11], [8, 9, 10, 11, 12]],
+                                  [[6, 7, 8, 9, 10], [7, 8, 9, 10, 11], [8, 9, 10, 11, 12], [9, 10, 11, 12, 13]],
+                                  [[7, 8, 9, 10, 11], [8, 9, 10, 11, 12], [9, 10, 11, 12, 13], [10, 11, 12, 13, 14]]]]
+    assert c.free_symbols == set()
+    assert c.variables == [i, j, k, l]
+    assert c.bound_symbols == [i, j, k, l]
+    assert d.doit().tolist() == [k, k, k, k, k]
+    assert len(e) == 5
+    raises(TypeError, lambda: ArrayComprehension(i*j, (i, 1, 3), (j, 2, [1, 3, 2])))
+    raises(ValueError, lambda: ArrayComprehension(i*j, (i, 1, 3), (j, 2, 1)))
+    raises(ValueError, lambda: ArrayComprehension(i*j, (i, 1, 3), (j, 2, j+1)))
+    raises(ValueError, lambda: len(ArrayComprehension(i*j, (i, 1, 3), (j, 2, j+4))))
+    raises(TypeError, lambda: ArrayComprehension(i*j, (i, 0, i + 1.5), (j, 0, 2)))
+    raises(ValueError, lambda: b.tolist())
+    raises(ValueError, lambda: b.tomatrix())
+    raises(ValueError, lambda: c.tomatrix())
+
+def test_arraycomprehensionmap():
+    a = ArrayComprehensionMap(lambda i: i+1, (i, 1, 5))
+    assert a.doit().tolist() == [2, 3, 4, 5, 6]
+    assert a.shape == (5,)
+    assert a.is_shape_numeric
+    assert a.tolist() == [2, 3, 4, 5, 6]
+    assert len(a) == 5
+    assert isinstance(a.doit(), ImmutableDenseNDimArray)
+    expr = ArrayComprehensionMap(lambda i: i+1, (i, 1, k))
+    assert expr.doit() == expr
+    assert expr.subs(k, 4) == ArrayComprehensionMap(lambda i: i+1, (i, 1, 4))
+    assert expr.subs(k, 4).doit() == ImmutableDenseNDimArray([2, 3, 4, 5])
+    b = ArrayComprehensionMap(lambda i: i+1, (i, 1, 2), (i, 1, 3), (i, 1, 4), (i, 1, 5))
+    assert b.doit().tolist() == [[[[2, 3, 4, 5, 6], [3, 5, 7, 9, 11], [4, 7, 10, 13, 16], [5, 9, 13, 17, 21]],
+                                  [[3, 5, 7, 9, 11], [5, 9, 13, 17, 21], [7, 13, 19, 25, 31], [9, 17, 25, 33, 41]],
+                                  [[4, 7, 10, 13, 16], [7, 13, 19, 25, 31], [10, 19, 28, 37, 46], [13, 25, 37, 49, 61]]],
+                                 [[[3, 5, 7, 9, 11], [5, 9, 13, 17, 21], [7, 13, 19, 25, 31], [9, 17, 25, 33, 41]],
+                                  [[5, 9, 13, 17, 21], [9, 17, 25, 33, 41], [13, 25, 37, 49, 61], [17, 33, 49, 65, 81]],
+                                  [[7, 13, 19, 25, 31], [13, 25, 37, 49, 61], [19, 37, 55, 73, 91], [25, 49, 73, 97, 121]]]]
+
+    # tests about lambda expression
+    assert ArrayComprehensionMap(lambda: 3, (i, 1, 5)).doit().tolist() == [3, 3, 3, 3, 3]
+    assert ArrayComprehensionMap(lambda i: i+1, (i, 1, 5)).doit().tolist() == [2, 3, 4, 5, 6]
+    raises(ValueError, lambda: ArrayComprehensionMap(i*j, (i, 1, 3), (j, 2, 4)))
+    a = ArrayComprehensionMap(lambda i, j: i+j, (i, 1, 5))
+    raises(ValueError, lambda: a.doit())
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/tests/test_array_derivatives.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/tests/test_array_derivatives.py
new file mode 100644
index 0000000000000000000000000000000000000000..7f6c777c55a9170704f309bf74387d140bf2ec32
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/tests/test_array_derivatives.py
@@ -0,0 +1,52 @@
+from sympy.core.symbol import symbols
+from sympy.matrices.dense import Matrix
+from sympy.matrices.expressions.matexpr import MatrixSymbol
+from sympy.tensor.array.ndim_array import NDimArray
+from sympy.matrices.matrixbase import MatrixBase
+from sympy.tensor.array.array_derivatives import ArrayDerivative
+
+x, y, z, t = symbols("x y z t")
+
+m = Matrix([[x, y], [z, t]])
+
+M = MatrixSymbol("M", 3, 2)
+N = MatrixSymbol("N", 4, 3)
+
+
+def test_array_derivative_construction():
+
+    d = ArrayDerivative(x, m, evaluate=False)
+    assert d.shape == (2, 2)
+    expr = d.doit()
+    assert isinstance(expr, MatrixBase)
+    assert expr.shape == (2, 2)
+
+    d = ArrayDerivative(m, m, evaluate=False)
+    assert d.shape == (2, 2, 2, 2)
+    expr = d.doit()
+    assert isinstance(expr, NDimArray)
+    assert expr.shape == (2, 2, 2, 2)
+
+    d = ArrayDerivative(m, x, evaluate=False)
+    assert d.shape == (2, 2)
+    expr = d.doit()
+    assert isinstance(expr, MatrixBase)
+    assert expr.shape == (2, 2)
+
+    d = ArrayDerivative(M, N, evaluate=False)
+    assert d.shape == (4, 3, 3, 2)
+    expr = d.doit()
+    assert isinstance(expr, ArrayDerivative)
+    assert expr.shape == (4, 3, 3, 2)
+
+    d = ArrayDerivative(M, (N, 2), evaluate=False)
+    assert d.shape == (4, 3, 4, 3, 3, 2)
+    expr = d.doit()
+    assert isinstance(expr, ArrayDerivative)
+    assert expr.shape == (4, 3, 4, 3, 3, 2)
+
+    d = ArrayDerivative(M.as_explicit(), (N.as_explicit(), 2), evaluate=False)
+    assert d.doit().shape == (4, 3, 4, 3, 3, 2)
+    expr = d.doit()
+    assert isinstance(expr, NDimArray)
+    assert expr.shape == (4, 3, 4, 3, 3, 2)
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/tests/test_arrayop.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/tests/test_arrayop.py
new file mode 100644
index 0000000000000000000000000000000000000000..de56e81e0064f1e303a7a58e41932d15f2d0b41e
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/tests/test_arrayop.py
@@ -0,0 +1,361 @@
+import itertools
+import random
+
+from sympy.combinatorics import Permutation
+from sympy.combinatorics.permutations import _af_invert
+from sympy.testing.pytest import raises
+
+from sympy.core.function import diff
+from sympy.core.symbol import symbols
+from sympy.functions.elementary.complexes import (adjoint, conjugate, transpose)
+from sympy.functions.elementary.exponential import (exp, log)
+from sympy.functions.elementary.trigonometric import (cos, sin)
+from sympy.tensor.array import Array, ImmutableDenseNDimArray, ImmutableSparseNDimArray, MutableSparseNDimArray
+
+from sympy.tensor.array.arrayop import tensorproduct, tensorcontraction, derive_by_array, permutedims, Flatten, \
+    tensordiagonal
+
+
+def test_import_NDimArray():
+    from sympy.tensor.array import NDimArray
+    del NDimArray
+
+
+def test_tensorproduct():
+    x,y,z,t = symbols('x y z t')
+    from sympy.abc import a,b,c,d
+    assert tensorproduct() == 1
+    assert tensorproduct([x]) == Array([x])
+    assert tensorproduct([x], [y]) == Array([[x*y]])
+    assert tensorproduct([x], [y], [z]) == Array([[[x*y*z]]])
+    assert tensorproduct([x], [y], [z], [t]) == Array([[[[x*y*z*t]]]])
+
+    assert tensorproduct(x) == x
+    assert tensorproduct(x, y) == x*y
+    assert tensorproduct(x, y, z) == x*y*z
+    assert tensorproduct(x, y, z, t) == x*y*z*t
+
+    for ArrayType in [ImmutableDenseNDimArray, ImmutableSparseNDimArray]:
+        A = ArrayType([x, y])
+        B = ArrayType([1, 2, 3])
+        C = ArrayType([a, b, c, d])
+
+        assert tensorproduct(A, B, C) == ArrayType([[[a*x, b*x, c*x, d*x], [2*a*x, 2*b*x, 2*c*x, 2*d*x], [3*a*x, 3*b*x, 3*c*x, 3*d*x]],
+                                                    [[a*y, b*y, c*y, d*y], [2*a*y, 2*b*y, 2*c*y, 2*d*y], [3*a*y, 3*b*y, 3*c*y, 3*d*y]]])
+
+        assert tensorproduct([x, y], [1, 2, 3]) == tensorproduct(A, B)
+
+        assert tensorproduct(A, 2) == ArrayType([2*x, 2*y])
+        assert tensorproduct(A, [2]) == ArrayType([[2*x], [2*y]])
+        assert tensorproduct([2], A) == ArrayType([[2*x, 2*y]])
+        assert tensorproduct(a, A) == ArrayType([a*x, a*y])
+        assert tensorproduct(a, A, B) == ArrayType([[a*x, 2*a*x, 3*a*x], [a*y, 2*a*y, 3*a*y]])
+        assert tensorproduct(A, B, a) == ArrayType([[a*x, 2*a*x, 3*a*x], [a*y, 2*a*y, 3*a*y]])
+        assert tensorproduct(B, a, A) == ArrayType([[a*x, a*y], [2*a*x, 2*a*y], [3*a*x, 3*a*y]])
+
+    # tests for large scale sparse array
+    for SparseArrayType in [ImmutableSparseNDimArray, MutableSparseNDimArray]:
+        a = SparseArrayType({1:2, 3:4},(1000, 2000))
+        b = SparseArrayType({1:2, 3:4},(1000, 2000))
+        assert tensorproduct(a, b) == ImmutableSparseNDimArray({2000001: 4, 2000003: 8, 6000001: 8, 6000003: 16}, (1000, 2000, 1000, 2000))
+
+
+def test_tensorcontraction():
+    from sympy.abc import a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x
+    B = Array(range(18), (2, 3, 3))
+    assert tensorcontraction(B, (1, 2)) == Array([12, 39])
+    C1 = Array([a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x], (2, 3, 2, 2))
+
+    assert tensorcontraction(C1, (0, 2)) == Array([[a + o, b + p], [e + s, f + t], [i + w, j + x]])
+    assert tensorcontraction(C1, (0, 2, 3)) == Array([a + p, e + t, i + x])
+    assert tensorcontraction(C1, (2, 3)) == Array([[a + d, e + h, i + l], [m + p, q + t, u + x]])
+
+
+def test_derivative_by_array():
+    from sympy.abc import i, j, t, x, y, z
+
+    bexpr = x*y**2*exp(z)*log(t)
+    sexpr = sin(bexpr)
+    cexpr = cos(bexpr)
+
+    a = Array([sexpr])
+
+    assert derive_by_array(sexpr, t) == x*y**2*exp(z)*cos(x*y**2*exp(z)*log(t))/t
+    assert derive_by_array(sexpr, [x, y, z]) == Array([bexpr/x*cexpr, 2*y*bexpr/y**2*cexpr, bexpr*cexpr])
+    assert derive_by_array(a, [x, y, z]) == Array([[bexpr/x*cexpr], [2*y*bexpr/y**2*cexpr], [bexpr*cexpr]])
+
+    assert derive_by_array(sexpr, [[x, y], [z, t]]) == Array([[bexpr/x*cexpr, 2*y*bexpr/y**2*cexpr], [bexpr*cexpr, bexpr/log(t)/t*cexpr]])
+    assert derive_by_array(a, [[x, y], [z, t]]) == Array([[[bexpr/x*cexpr], [2*y*bexpr/y**2*cexpr]], [[bexpr*cexpr], [bexpr/log(t)/t*cexpr]]])
+    assert derive_by_array([[x, y], [z, t]], [x, y]) == Array([[[1, 0], [0, 0]], [[0, 1], [0, 0]]])
+    assert derive_by_array([[x, y], [z, t]], [[x, y], [z, t]]) == Array([[[[1, 0], [0, 0]], [[0, 1], [0, 0]]],
+                                                                         [[[0, 0], [1, 0]], [[0, 0], [0, 1]]]])
+
+    assert diff(sexpr, t) == x*y**2*exp(z)*cos(x*y**2*exp(z)*log(t))/t
+    assert diff(sexpr, Array([x, y, z])) == Array([bexpr/x*cexpr, 2*y*bexpr/y**2*cexpr, bexpr*cexpr])
+    assert diff(a, Array([x, y, z])) == Array([[bexpr/x*cexpr], [2*y*bexpr/y**2*cexpr], [bexpr*cexpr]])
+
+    assert diff(sexpr, Array([[x, y], [z, t]])) == Array([[bexpr/x*cexpr, 2*y*bexpr/y**2*cexpr], [bexpr*cexpr, bexpr/log(t)/t*cexpr]])
+    assert diff(a, Array([[x, y], [z, t]])) == Array([[[bexpr/x*cexpr], [2*y*bexpr/y**2*cexpr]], [[bexpr*cexpr], [bexpr/log(t)/t*cexpr]]])
+    assert diff(Array([[x, y], [z, t]]), Array([x, y])) == Array([[[1, 0], [0, 0]], [[0, 1], [0, 0]]])
+    assert diff(Array([[x, y], [z, t]]), Array([[x, y], [z, t]])) == Array([[[[1, 0], [0, 0]], [[0, 1], [0, 0]]],
+                                                                         [[[0, 0], [1, 0]], [[0, 0], [0, 1]]]])
+
+    # test for large scale sparse array
+    for SparseArrayType in [ImmutableSparseNDimArray, MutableSparseNDimArray]:
+        b = MutableSparseNDimArray({0:i, 1:j}, (10000, 20000))
+        assert derive_by_array(b, i) == ImmutableSparseNDimArray({0: 1}, (10000, 20000))
+        assert derive_by_array(b, (i, j)) == ImmutableSparseNDimArray({0: 1, 200000001: 1}, (2, 10000, 20000))
+
+    #https://github.com/sympy/sympy/issues/20655
+    U = Array([x, y, z])
+    E = 2
+    assert derive_by_array(E, U) ==  ImmutableDenseNDimArray([0, 0, 0])
+
+
+def test_issue_emerged_while_discussing_10972():
+    ua = Array([-1,0])
+    Fa = Array([[0, 1], [-1, 0]])
+    po = tensorproduct(Fa, ua, Fa, ua)
+    assert tensorcontraction(po, (1, 2), (4, 5)) == Array([[0, 0], [0, 1]])
+
+    sa = symbols('a0:144')
+    po = Array(sa, [2, 2, 3, 3, 2, 2])
+    assert tensorcontraction(po, (0, 1), (2, 3), (4, 5)) == sa[0] + sa[108] + sa[111] + sa[124] + sa[127] + sa[140] + sa[143] + sa[16] + sa[19] + sa[3] + sa[32] + sa[35]
+    assert tensorcontraction(po, (0, 1, 4, 5), (2, 3)) == sa[0] + sa[111] + sa[127] + sa[143] + sa[16] + sa[32]
+    assert tensorcontraction(po, (0, 1), (4, 5)) == Array([[sa[0] + sa[108] + sa[111] + sa[3], sa[112] + sa[115] + sa[4] + sa[7],
+                                                             sa[11] + sa[116] + sa[119] + sa[8]], [sa[12] + sa[120] + sa[123] + sa[15],
+                                                             sa[124] + sa[127] + sa[16] + sa[19], sa[128] + sa[131] + sa[20] + sa[23]],
+                                                            [sa[132] + sa[135] + sa[24] + sa[27], sa[136] + sa[139] + sa[28] + sa[31],
+                                                             sa[140] + sa[143] + sa[32] + sa[35]]])
+    assert tensorcontraction(po, (0, 1), (2, 3)) == Array([[sa[0] + sa[108] + sa[124] + sa[140] + sa[16] + sa[32], sa[1] + sa[109] + sa[125] + sa[141] + sa[17] + sa[33]],
+                                                           [sa[110] + sa[126] + sa[142] + sa[18] + sa[2] + sa[34], sa[111] + sa[127] + sa[143] + sa[19] + sa[3] + sa[35]]])
+
+
+def test_array_permutedims():
+    sa = symbols('a0:144')
+
+    for ArrayType in [ImmutableDenseNDimArray, ImmutableSparseNDimArray]:
+        m1 = ArrayType(sa[:6], (2, 3))
+        assert permutedims(m1, (1, 0)) == transpose(m1)
+        assert m1.tomatrix().T == permutedims(m1, (1, 0)).tomatrix()
+
+        assert m1.tomatrix().T == transpose(m1).tomatrix()
+        assert m1.tomatrix().C == conjugate(m1).tomatrix()
+        assert m1.tomatrix().H == adjoint(m1).tomatrix()
+
+        assert m1.tomatrix().T == m1.transpose().tomatrix()
+        assert m1.tomatrix().C == m1.conjugate().tomatrix()
+        assert m1.tomatrix().H == m1.adjoint().tomatrix()
+
+        raises(ValueError, lambda: permutedims(m1, (0,)))
+        raises(ValueError, lambda: permutedims(m1, (0, 0)))
+        raises(ValueError, lambda: permutedims(m1, (1, 2, 0)))
+
+        # Some tests with random arrays:
+        dims = 6
+        shape = [random.randint(1,5) for i in range(dims)]
+        elems = [random.random() for i in range(tensorproduct(*shape))]
+        ra = ArrayType(elems, shape)
+        perm = list(range(dims))
+        # Randomize the permutation:
+        random.shuffle(perm)
+        # Test inverse permutation:
+        assert permutedims(permutedims(ra, perm), _af_invert(perm)) == ra
+        # Test that permuted shape corresponds to action by `Permutation`:
+        assert permutedims(ra, perm).shape == tuple(Permutation(perm)(shape))
+
+        z = ArrayType.zeros(4,5,6,7)
+
+        assert permutedims(z, (2, 3, 1, 0)).shape == (6, 7, 5, 4)
+        assert permutedims(z, [2, 3, 1, 0]).shape == (6, 7, 5, 4)
+        assert permutedims(z, Permutation([2, 3, 1, 0])).shape == (6, 7, 5, 4)
+
+        po = ArrayType(sa, [2, 2, 3, 3, 2, 2])
+
+        raises(ValueError, lambda: permutedims(po, (1, 1)))
+        raises(ValueError, lambda: po.transpose())
+        raises(ValueError, lambda: po.adjoint())
+
+        assert permutedims(po, reversed(range(po.rank()))) == ArrayType(
+            [[[[[[sa[0], sa[72]], [sa[36], sa[108]]], [[sa[12], sa[84]], [sa[48], sa[120]]], [[sa[24],
+                                                                                               sa[96]], [sa[60], sa[132]]]],
+               [[[sa[4], sa[76]], [sa[40], sa[112]]], [[sa[16],
+                                                        sa[88]], [sa[52], sa[124]]],
+                [[sa[28], sa[100]], [sa[64], sa[136]]]],
+               [[[sa[8],
+                  sa[80]], [sa[44], sa[116]]], [[sa[20], sa[92]], [sa[56], sa[128]]], [[sa[32],
+                                                                                        sa[104]], [sa[68], sa[140]]]]],
+              [[[[sa[2], sa[74]], [sa[38], sa[110]]], [[sa[14],
+                                                        sa[86]], [sa[50], sa[122]]], [[sa[26], sa[98]], [sa[62], sa[134]]]],
+               [[[sa[6],
+                  sa[78]], [sa[42], sa[114]]], [[sa[18], sa[90]], [sa[54], sa[126]]], [[sa[30],
+                                                                                        sa[102]], [sa[66], sa[138]]]],
+               [[[sa[10], sa[82]], [sa[46], sa[118]]], [[sa[22],
+                                                         sa[94]], [sa[58], sa[130]]],
+                [[sa[34], sa[106]], [sa[70], sa[142]]]]]],
+             [[[[[sa[1],
+                  sa[73]], [sa[37], sa[109]]], [[sa[13], sa[85]], [sa[49], sa[121]]], [[sa[25],
+                                                                                        sa[97]], [sa[61], sa[133]]]],
+               [[[sa[5], sa[77]], [sa[41], sa[113]]], [[sa[17],
+                                                        sa[89]], [sa[53], sa[125]]],
+                [[sa[29], sa[101]], [sa[65], sa[137]]]],
+               [[[sa[9],
+                  sa[81]], [sa[45], sa[117]]], [[sa[21], sa[93]], [sa[57], sa[129]]], [[sa[33],
+                                                                                        sa[105]], [sa[69], sa[141]]]]],
+              [[[[sa[3], sa[75]], [sa[39], sa[111]]], [[sa[15],
+                                                        sa[87]], [sa[51], sa[123]]], [[sa[27], sa[99]], [sa[63], sa[135]]]],
+               [[[sa[7],
+                  sa[79]], [sa[43], sa[115]]], [[sa[19], sa[91]], [sa[55], sa[127]]], [[sa[31],
+                                                                                        sa[103]], [sa[67], sa[139]]]],
+               [[[sa[11], sa[83]], [sa[47], sa[119]]], [[sa[23],
+                                                         sa[95]], [sa[59], sa[131]]],
+                [[sa[35], sa[107]], [sa[71], sa[143]]]]]]])
+
+        assert permutedims(po, (1, 0, 2, 3, 4, 5)) == ArrayType(
+            [[[[[[sa[0], sa[1]], [sa[2], sa[3]]], [[sa[4], sa[5]], [sa[6], sa[7]]], [[sa[8], sa[9]], [sa[10],
+                                                                                                      sa[11]]]],
+               [[[sa[12], sa[13]], [sa[14], sa[15]]], [[sa[16], sa[17]], [sa[18],
+                                                                          sa[19]]], [[sa[20], sa[21]], [sa[22], sa[23]]]],
+               [[[sa[24], sa[25]], [sa[26],
+                                    sa[27]]], [[sa[28], sa[29]], [sa[30], sa[31]]], [[sa[32], sa[33]], [sa[34],
+                                                                                                        sa[35]]]]],
+              [[[[sa[72], sa[73]], [sa[74], sa[75]]], [[sa[76], sa[77]], [sa[78],
+                                                                          sa[79]]], [[sa[80], sa[81]], [sa[82], sa[83]]]],
+               [[[sa[84], sa[85]], [sa[86],
+                                    sa[87]]], [[sa[88], sa[89]], [sa[90], sa[91]]], [[sa[92], sa[93]], [sa[94],
+                                                                                                        sa[95]]]],
+               [[[sa[96], sa[97]], [sa[98], sa[99]]], [[sa[100], sa[101]], [sa[102],
+                                                                            sa[103]]],
+                [[sa[104], sa[105]], [sa[106], sa[107]]]]]], [[[[[sa[36], sa[37]], [sa[38],
+                                                                                    sa[39]]],
+                                                                [[sa[40], sa[41]], [sa[42], sa[43]]],
+                                                                [[sa[44], sa[45]], [sa[46],
+                                                                                    sa[47]]]],
+                                                               [[[sa[48], sa[49]], [sa[50], sa[51]]],
+                                                                [[sa[52], sa[53]], [sa[54],
+                                                                                    sa[55]]],
+                                                                [[sa[56], sa[57]], [sa[58], sa[59]]]],
+                                                               [[[sa[60], sa[61]], [sa[62],
+                                                                                    sa[63]]],
+                                                                [[sa[64], sa[65]], [sa[66], sa[67]]],
+                                                                [[sa[68], sa[69]], [sa[70],
+                                                                                    sa[71]]]]], [
+                                                                  [[[sa[108], sa[109]], [sa[110], sa[111]]],
+                                                                   [[sa[112], sa[113]], [sa[114],
+                                                                                         sa[115]]],
+                                                                   [[sa[116], sa[117]], [sa[118], sa[119]]]],
+                                                                  [[[sa[120], sa[121]], [sa[122],
+                                                                                         sa[123]]],
+                                                                   [[sa[124], sa[125]], [sa[126], sa[127]]],
+                                                                   [[sa[128], sa[129]], [sa[130],
+                                                                                         sa[131]]]],
+                                                                  [[[sa[132], sa[133]], [sa[134], sa[135]]],
+                                                                   [[sa[136], sa[137]], [sa[138],
+                                                                                         sa[139]]],
+                                                                   [[sa[140], sa[141]], [sa[142], sa[143]]]]]]])
+
+        assert permutedims(po, (0, 2, 1, 4, 3, 5)) == ArrayType(
+            [[[[[[sa[0], sa[1]], [sa[4], sa[5]], [sa[8], sa[9]]], [[sa[2], sa[3]], [sa[6], sa[7]], [sa[10],
+                                                                                                    sa[11]]]],
+               [[[sa[36], sa[37]], [sa[40], sa[41]], [sa[44], sa[45]]], [[sa[38],
+                                                                          sa[39]], [sa[42], sa[43]], [sa[46], sa[47]]]]],
+              [[[[sa[12], sa[13]], [sa[16],
+                                    sa[17]], [sa[20], sa[21]]], [[sa[14], sa[15]], [sa[18], sa[19]], [sa[22],
+                                                                                                      sa[23]]]],
+               [[[sa[48], sa[49]], [sa[52], sa[53]], [sa[56], sa[57]]], [[sa[50],
+                                                                          sa[51]], [sa[54], sa[55]], [sa[58], sa[59]]]]],
+              [[[[sa[24], sa[25]], [sa[28],
+                                    sa[29]], [sa[32], sa[33]]], [[sa[26], sa[27]], [sa[30], sa[31]], [sa[34],
+                                                                                                      sa[35]]]],
+               [[[sa[60], sa[61]], [sa[64], sa[65]], [sa[68], sa[69]]], [[sa[62],
+                                                                          sa[63]], [sa[66], sa[67]], [sa[70], sa[71]]]]]],
+             [[[[[sa[72], sa[73]], [sa[76],
+                                    sa[77]], [sa[80], sa[81]]], [[sa[74], sa[75]], [sa[78], sa[79]], [sa[82],
+                                                                                                      sa[83]]]],
+               [[[sa[108], sa[109]], [sa[112], sa[113]], [sa[116], sa[117]]], [[sa[110],
+                                                                                sa[111]], [sa[114], sa[115]],
+                                                                               [sa[118], sa[119]]]]],
+              [[[[sa[84], sa[85]], [sa[88],
+                                    sa[89]], [sa[92], sa[93]]], [[sa[86], sa[87]], [sa[90], sa[91]], [sa[94],
+                                                                                                      sa[95]]]],
+               [[[sa[120], sa[121]], [sa[124], sa[125]], [sa[128], sa[129]]], [[sa[122],
+                                                                                sa[123]], [sa[126], sa[127]],
+                                                                               [sa[130], sa[131]]]]],
+              [[[[sa[96], sa[97]], [sa[100],
+                                    sa[101]], [sa[104], sa[105]]], [[sa[98], sa[99]], [sa[102], sa[103]], [sa[106],
+                                                                                                           sa[107]]]],
+               [[[sa[132], sa[133]], [sa[136], sa[137]], [sa[140], sa[141]]], [[sa[134],
+                                                                                sa[135]], [sa[138], sa[139]],
+                                                                               [sa[142], sa[143]]]]]]])
+
+        po2 = po.reshape(4, 9, 2, 2)
+        assert po2 == ArrayType([[[[sa[0], sa[1]], [sa[2], sa[3]]], [[sa[4], sa[5]], [sa[6], sa[7]]], [[sa[8], sa[9]], [sa[10], sa[11]]], [[sa[12], sa[13]], [sa[14], sa[15]]], [[sa[16], sa[17]], [sa[18], sa[19]]], [[sa[20], sa[21]], [sa[22], sa[23]]], [[sa[24], sa[25]], [sa[26], sa[27]]], [[sa[28], sa[29]], [sa[30], sa[31]]], [[sa[32], sa[33]], [sa[34], sa[35]]]], [[[sa[36], sa[37]], [sa[38], sa[39]]], [[sa[40], sa[41]], [sa[42], sa[43]]], [[sa[44], sa[45]], [sa[46], sa[47]]], [[sa[48], sa[49]], [sa[50], sa[51]]], [[sa[52], sa[53]], [sa[54], sa[55]]], [[sa[56], sa[57]], [sa[58], sa[59]]], [[sa[60], sa[61]], [sa[62], sa[63]]], [[sa[64], sa[65]], [sa[66], sa[67]]], [[sa[68], sa[69]], [sa[70], sa[71]]]], [[[sa[72], sa[73]], [sa[74], sa[75]]], [[sa[76], sa[77]], [sa[78], sa[79]]], [[sa[80], sa[81]], [sa[82], sa[83]]], [[sa[84], sa[85]], [sa[86], sa[87]]], [[sa[88], sa[89]], [sa[90], sa[91]]], [[sa[92], sa[93]], [sa[94], sa[95]]], [[sa[96], sa[97]], [sa[98], sa[99]]], [[sa[100], sa[101]], [sa[102], sa[103]]], [[sa[104], sa[105]], [sa[106], sa[107]]]], [[[sa[108], sa[109]], [sa[110], sa[111]]], [[sa[112], sa[113]], [sa[114], sa[115]]], [[sa[116], sa[117]], [sa[118], sa[119]]], [[sa[120], sa[121]], [sa[122], sa[123]]], [[sa[124], sa[125]], [sa[126], sa[127]]], [[sa[128], sa[129]], [sa[130], sa[131]]], [[sa[132], sa[133]], [sa[134], sa[135]]], [[sa[136], sa[137]], [sa[138], sa[139]]], [[sa[140], sa[141]], [sa[142], sa[143]]]]])
+
+        assert permutedims(po2, (3, 2, 0, 1)) == ArrayType([[[[sa[0], sa[4], sa[8], sa[12], sa[16], sa[20], sa[24], sa[28], sa[32]], [sa[36], sa[40], sa[44], sa[48], sa[52], sa[56], sa[60], sa[64], sa[68]], [sa[72], sa[76], sa[80], sa[84], sa[88], sa[92], sa[96], sa[100], sa[104]], [sa[108], sa[112], sa[116], sa[120], sa[124], sa[128], sa[132], sa[136], sa[140]]], [[sa[2], sa[6], sa[10], sa[14], sa[18], sa[22], sa[26], sa[30], sa[34]], [sa[38], sa[42], sa[46], sa[50], sa[54], sa[58], sa[62], sa[66], sa[70]], [sa[74], sa[78], sa[82], sa[86], sa[90], sa[94], sa[98], sa[102], sa[106]], [sa[110], sa[114], sa[118], sa[122], sa[126], sa[130], sa[134], sa[138], sa[142]]]], [[[sa[1], sa[5], sa[9], sa[13], sa[17], sa[21], sa[25], sa[29], sa[33]], [sa[37], sa[41], sa[45], sa[49], sa[53], sa[57], sa[61], sa[65], sa[69]], [sa[73], sa[77], sa[81], sa[85], sa[89], sa[93], sa[97], sa[101], sa[105]], [sa[109], sa[113], sa[117], sa[121], sa[125], sa[129], sa[133], sa[137], sa[141]]], [[sa[3], sa[7], sa[11], sa[15], sa[19], sa[23], sa[27], sa[31], sa[35]], [sa[39], sa[43], sa[47], sa[51], sa[55], sa[59], sa[63], sa[67], sa[71]], [sa[75], sa[79], sa[83], sa[87], sa[91], sa[95], sa[99], sa[103], sa[107]], [sa[111], sa[115], sa[119], sa[123], sa[127], sa[131], sa[135], sa[139], sa[143]]]]])
+
+    # test for large scale sparse array
+    for SparseArrayType in [ImmutableSparseNDimArray, MutableSparseNDimArray]:
+        A = SparseArrayType({1:1, 10000:2}, (10000, 20000, 10000))
+        assert permutedims(A, (0, 1, 2)) == A
+        assert permutedims(A, (1, 0, 2)) == SparseArrayType({1: 1, 100000000: 2}, (20000, 10000, 10000))
+        B = SparseArrayType({1:1, 20000:2}, (10000, 20000))
+        assert B.transpose() == SparseArrayType({10000: 1, 1: 2}, (20000, 10000))
+
+
+def test_permutedims_with_indices():
+    A = Array(range(32)).reshape(2, 2, 2, 2, 2)
+    indices_new = list("abcde")
+    indices_old = list("ebdac")
+    new_A = permutedims(A, index_order_new=indices_new, index_order_old=indices_old)
+    for a, b, c, d, e in itertools.product(range(2), range(2), range(2), range(2), range(2)):
+        assert new_A[a, b, c, d, e] == A[e, b, d, a, c]
+    indices_old = list("cabed")
+    new_A = permutedims(A, index_order_new=indices_new, index_order_old=indices_old)
+    for a, b, c, d, e in itertools.product(range(2), range(2), range(2), range(2), range(2)):
+        assert new_A[a, b, c, d, e] == A[c, a, b, e, d]
+    raises(ValueError, lambda: permutedims(A, index_order_old=list("aacde"), index_order_new=list("abcde")))
+    raises(ValueError, lambda: permutedims(A, index_order_old=list("abcde"), index_order_new=list("abcce")))
+    raises(ValueError, lambda: permutedims(A, index_order_old=list("abcde"), index_order_new=list("abce")))
+    raises(ValueError, lambda: permutedims(A, index_order_old=list("abce"), index_order_new=list("abce")))
+    raises(ValueError, lambda: permutedims(A, [2, 1, 0, 3, 4], index_order_old=list("abcde")))
+    raises(ValueError, lambda: permutedims(A, [2, 1, 0, 3, 4], index_order_new=list("abcde")))
+
+
+def test_flatten():
+    from sympy.matrices.dense import Matrix
+    for ArrayType in [ImmutableDenseNDimArray, ImmutableSparseNDimArray, Matrix]:
+        A = ArrayType(range(24)).reshape(4, 6)
+        assert list(Flatten(A)) == [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23]
+
+        for i, v in enumerate(Flatten(A)):
+            assert i == v
+
+
+def test_tensordiagonal():
+    from sympy.matrices.dense import eye
+    expr = Array(range(9)).reshape(3, 3)
+    raises(ValueError, lambda: tensordiagonal(expr, [0], [1]))
+    raises(ValueError, lambda: tensordiagonal(expr, [0, 0]))
+    assert tensordiagonal(eye(3), [0, 1]) == Array([1, 1, 1])
+    assert tensordiagonal(expr, [0, 1]) == Array([0, 4, 8])
+    x, y, z = symbols("x y z")
+    expr2 = tensorproduct([x, y, z], expr)
+    assert tensordiagonal(expr2, [1, 2]) == Array([[0, 4*x, 8*x], [0, 4*y, 8*y], [0, 4*z, 8*z]])
+    assert tensordiagonal(expr2, [0, 1]) == Array([[0, 3*y, 6*z], [x, 4*y, 7*z], [2*x, 5*y, 8*z]])
+    assert tensordiagonal(expr2, [0, 1, 2]) == Array([0, 4*y, 8*z])
+    # assert tensordiagonal(expr2, [0]) == permutedims(expr2, [1, 2, 0])
+    # assert tensordiagonal(expr2, [1]) == permutedims(expr2, [0, 2, 1])
+    # assert tensordiagonal(expr2, [2]) == expr2
+    # assert tensordiagonal(expr2, [1], [2]) == expr2
+    # assert tensordiagonal(expr2, [0], [1]) == permutedims(expr2, [2, 0, 1])
+
+    a, b, c, X, Y, Z = symbols("a b c X Y Z")
+    expr3 = tensorproduct([x, y, z], [1, 2, 3], [a, b, c], [X, Y, Z])
+    assert tensordiagonal(expr3, [0, 1, 2, 3]) == Array([x*a*X, 2*y*b*Y, 3*z*c*Z])
+    assert tensordiagonal(expr3, [0, 1], [2, 3]) == tensorproduct([x, 2*y, 3*z], [a*X, b*Y, c*Z])
+
+    # assert tensordiagonal(expr3, [0], [1, 2], [3]) == tensorproduct([x, y, z], [a, 2*b, 3*c], [X, Y, Z])
+    assert tensordiagonal(tensordiagonal(expr3, [2, 3]), [0, 1]) == tensorproduct([a*X, b*Y, c*Z], [x, 2*y, 3*z])
+
+    raises(ValueError, lambda: tensordiagonal([[1, 2, 3], [4, 5, 6]], [0, 1]))
+    raises(ValueError, lambda: tensordiagonal(expr3.reshape(3, 3, 9), [1, 2]))
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/tests/test_immutable_ndim_array.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/tests/test_immutable_ndim_array.py
new file mode 100644
index 0000000000000000000000000000000000000000..c6bed4b605c424284b4752592b03b13a9178aac8
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/tests/test_immutable_ndim_array.py
@@ -0,0 +1,452 @@
+from copy import copy
+
+from sympy.tensor.array.dense_ndim_array import ImmutableDenseNDimArray
+from sympy.core.containers import Dict
+from sympy.core.function import diff
+from sympy.core.numbers import Rational
+from sympy.core.singleton import S
+from sympy.core.symbol import (Symbol, symbols)
+from sympy.matrices import SparseMatrix
+from sympy.tensor.indexed import (Indexed, IndexedBase)
+from sympy.matrices import Matrix
+from sympy.tensor.array.sparse_ndim_array import ImmutableSparseNDimArray
+from sympy.testing.pytest import raises
+
+
+def test_ndim_array_initiation():
+    arr_with_no_elements = ImmutableDenseNDimArray([], shape=(0,))
+    assert len(arr_with_no_elements) == 0
+    assert arr_with_no_elements.rank() == 1
+
+    raises(ValueError, lambda: ImmutableDenseNDimArray([0], shape=(0,)))
+    raises(ValueError, lambda: ImmutableDenseNDimArray([1, 2, 3], shape=(0,)))
+    raises(ValueError, lambda: ImmutableDenseNDimArray([], shape=()))
+
+    raises(ValueError, lambda: ImmutableSparseNDimArray([0], shape=(0,)))
+    raises(ValueError, lambda: ImmutableSparseNDimArray([1, 2, 3], shape=(0,)))
+    raises(ValueError, lambda: ImmutableSparseNDimArray([], shape=()))
+
+    arr_with_one_element = ImmutableDenseNDimArray([23])
+    assert len(arr_with_one_element) == 1
+    assert arr_with_one_element[0] == 23
+    assert arr_with_one_element[:] == ImmutableDenseNDimArray([23])
+    assert arr_with_one_element.rank() == 1
+
+    arr_with_symbol_element = ImmutableDenseNDimArray([Symbol('x')])
+    assert len(arr_with_symbol_element) == 1
+    assert arr_with_symbol_element[0] == Symbol('x')
+    assert arr_with_symbol_element[:] == ImmutableDenseNDimArray([Symbol('x')])
+    assert arr_with_symbol_element.rank() == 1
+
+    number5 = 5
+    vector = ImmutableDenseNDimArray.zeros(number5)
+    assert len(vector) == number5
+    assert vector.shape == (number5,)
+    assert vector.rank() == 1
+
+    vector = ImmutableSparseNDimArray.zeros(number5)
+    assert len(vector) == number5
+    assert vector.shape == (number5,)
+    assert vector._sparse_array == Dict()
+    assert vector.rank() == 1
+
+    n_dim_array = ImmutableDenseNDimArray(range(3**4), (3, 3, 3, 3,))
+    assert len(n_dim_array) == 3 * 3 * 3 * 3
+    assert n_dim_array.shape == (3, 3, 3, 3)
+    assert n_dim_array.rank() == 4
+
+    array_shape = (3, 3, 3, 3)
+    sparse_array = ImmutableSparseNDimArray.zeros(*array_shape)
+    assert len(sparse_array._sparse_array) == 0
+    assert len(sparse_array) == 3 * 3 * 3 * 3
+    assert n_dim_array.shape == array_shape
+    assert n_dim_array.rank() == 4
+
+    one_dim_array = ImmutableDenseNDimArray([2, 3, 1])
+    assert len(one_dim_array) == 3
+    assert one_dim_array.shape == (3,)
+    assert one_dim_array.rank() == 1
+    assert one_dim_array.tolist() == [2, 3, 1]
+
+    shape = (3, 3)
+    array_with_many_args = ImmutableSparseNDimArray.zeros(*shape)
+    assert len(array_with_many_args) == 3 * 3
+    assert array_with_many_args.shape == shape
+    assert array_with_many_args[0, 0] == 0
+    assert array_with_many_args.rank() == 2
+
+    shape = (int(3), int(3))
+    array_with_long_shape = ImmutableSparseNDimArray.zeros(*shape)
+    assert len(array_with_long_shape) == 3 * 3
+    assert array_with_long_shape.shape == shape
+    assert array_with_long_shape[int(0), int(0)] == 0
+    assert array_with_long_shape.rank() == 2
+
+    vector_with_long_shape = ImmutableDenseNDimArray(range(5), int(5))
+    assert len(vector_with_long_shape) == 5
+    assert vector_with_long_shape.shape == (int(5),)
+    assert vector_with_long_shape.rank() == 1
+    raises(ValueError, lambda: vector_with_long_shape[int(5)])
+
+    from sympy.abc import x
+    for ArrayType in [ImmutableDenseNDimArray, ImmutableSparseNDimArray]:
+        rank_zero_array = ArrayType(x)
+        assert len(rank_zero_array) == 1
+        assert rank_zero_array.shape == ()
+        assert rank_zero_array.rank() == 0
+        assert rank_zero_array[()] == x
+        raises(ValueError, lambda: rank_zero_array[0])
+
+
+def test_reshape():
+    array = ImmutableDenseNDimArray(range(50), 50)
+    assert array.shape == (50,)
+    assert array.rank() == 1
+
+    array = array.reshape(5, 5, 2)
+    assert array.shape == (5, 5, 2)
+    assert array.rank() == 3
+    assert len(array) == 50
+
+
+def test_getitem():
+    for ArrayType in [ImmutableDenseNDimArray, ImmutableSparseNDimArray]:
+        array = ArrayType(range(24)).reshape(2, 3, 4)
+        assert array.tolist() == [[[0, 1, 2, 3], [4, 5, 6, 7], [8, 9, 10, 11]], [[12, 13, 14, 15], [16, 17, 18, 19], [20, 21, 22, 23]]]
+        assert array[0] == ArrayType([[0, 1, 2, 3], [4, 5, 6, 7], [8, 9, 10, 11]])
+        assert array[0, 0] == ArrayType([0, 1, 2, 3])
+        value = 0
+        for i in range(2):
+            for j in range(3):
+                for k in range(4):
+                    assert array[i, j, k] == value
+                    value += 1
+
+    raises(ValueError, lambda: array[3, 4, 5])
+    raises(ValueError, lambda: array[3, 4, 5, 6])
+    raises(ValueError, lambda: array[3, 4, 5, 3:4])
+
+
+def test_iterator():
+    array = ImmutableDenseNDimArray(range(4), (2, 2))
+    assert array[0] == ImmutableDenseNDimArray([0, 1])
+    assert array[1] == ImmutableDenseNDimArray([2, 3])
+
+    array = array.reshape(4)
+    j = 0
+    for i in array:
+        assert i == j
+        j += 1
+
+
+def test_sparse():
+    sparse_array = ImmutableSparseNDimArray([0, 0, 0, 1], (2, 2))
+    assert len(sparse_array) == 2 * 2
+    # dictionary where all data is, only non-zero entries are actually stored:
+    assert len(sparse_array._sparse_array) == 1
+
+    assert sparse_array.tolist() == [[0, 0], [0, 1]]
+
+    for i, j in zip(sparse_array, [[0, 0], [0, 1]]):
+        assert i == ImmutableSparseNDimArray(j)
+
+    def sparse_assignment():
+        sparse_array[0, 0] = 123
+
+    assert len(sparse_array._sparse_array) == 1
+    raises(TypeError, sparse_assignment)
+    assert len(sparse_array._sparse_array) == 1
+    assert sparse_array[0, 0] == 0
+    assert sparse_array/0 == ImmutableSparseNDimArray([[S.NaN, S.NaN], [S.NaN, S.ComplexInfinity]], (2, 2))
+
+    # test for large scale sparse array
+    # equality test
+    assert ImmutableSparseNDimArray.zeros(100000, 200000) == ImmutableSparseNDimArray.zeros(100000, 200000)
+
+    # __mul__ and __rmul__
+    a = ImmutableSparseNDimArray({200001: 1}, (100000, 200000))
+    assert a * 3 == ImmutableSparseNDimArray({200001: 3}, (100000, 200000))
+    assert 3 * a == ImmutableSparseNDimArray({200001: 3}, (100000, 200000))
+    assert a * 0 == ImmutableSparseNDimArray({}, (100000, 200000))
+    assert 0 * a == ImmutableSparseNDimArray({}, (100000, 200000))
+
+    # __truediv__
+    assert a/3 == ImmutableSparseNDimArray({200001: Rational(1, 3)}, (100000, 200000))
+
+    # __neg__
+    assert -a == ImmutableSparseNDimArray({200001: -1}, (100000, 200000))
+
+
+def test_calculation():
+
+    a = ImmutableDenseNDimArray([1]*9, (3, 3))
+    b = ImmutableDenseNDimArray([9]*9, (3, 3))
+
+    c = a + b
+    for i in c:
+        assert i == ImmutableDenseNDimArray([10, 10, 10])
+
+    assert c == ImmutableDenseNDimArray([10]*9, (3, 3))
+    assert c == ImmutableSparseNDimArray([10]*9, (3, 3))
+
+    c = b - a
+    for i in c:
+        assert i == ImmutableDenseNDimArray([8, 8, 8])
+
+    assert c == ImmutableDenseNDimArray([8]*9, (3, 3))
+    assert c == ImmutableSparseNDimArray([8]*9, (3, 3))
+
+
+def test_ndim_array_converting():
+    dense_array = ImmutableDenseNDimArray([1, 2, 3, 4], (2, 2))
+    alist = dense_array.tolist()
+
+    assert alist == [[1, 2], [3, 4]]
+
+    matrix = dense_array.tomatrix()
+    assert (isinstance(matrix, Matrix))
+
+    for i in range(len(dense_array)):
+        assert dense_array[dense_array._get_tuple_index(i)] == matrix[i]
+    assert matrix.shape == dense_array.shape
+
+    assert ImmutableDenseNDimArray(matrix) == dense_array
+    assert ImmutableDenseNDimArray(matrix.as_immutable()) == dense_array
+    assert ImmutableDenseNDimArray(matrix.as_mutable()) == dense_array
+
+    sparse_array = ImmutableSparseNDimArray([1, 2, 3, 4], (2, 2))
+    alist = sparse_array.tolist()
+
+    assert alist == [[1, 2], [3, 4]]
+
+    matrix = sparse_array.tomatrix()
+    assert(isinstance(matrix, SparseMatrix))
+
+    for i in range(len(sparse_array)):
+        assert sparse_array[sparse_array._get_tuple_index(i)] == matrix[i]
+    assert matrix.shape == sparse_array.shape
+
+    assert ImmutableSparseNDimArray(matrix) == sparse_array
+    assert ImmutableSparseNDimArray(matrix.as_immutable()) == sparse_array
+    assert ImmutableSparseNDimArray(matrix.as_mutable()) == sparse_array
+
+
+def test_converting_functions():
+    arr_list = [1, 2, 3, 4]
+    arr_matrix = Matrix(((1, 2), (3, 4)))
+
+    # list
+    arr_ndim_array = ImmutableDenseNDimArray(arr_list, (2, 2))
+    assert (isinstance(arr_ndim_array, ImmutableDenseNDimArray))
+    assert arr_matrix.tolist() == arr_ndim_array.tolist()
+
+    # Matrix
+    arr_ndim_array = ImmutableDenseNDimArray(arr_matrix)
+    assert (isinstance(arr_ndim_array, ImmutableDenseNDimArray))
+    assert arr_matrix.tolist() == arr_ndim_array.tolist()
+    assert arr_matrix.shape == arr_ndim_array.shape
+
+
+def test_equality():
+    first_list = [1, 2, 3, 4]
+    second_list = [1, 2, 3, 4]
+    third_list = [4, 3, 2, 1]
+    assert first_list == second_list
+    assert first_list != third_list
+
+    first_ndim_array = ImmutableDenseNDimArray(first_list, (2, 2))
+    second_ndim_array = ImmutableDenseNDimArray(second_list, (2, 2))
+    fourth_ndim_array = ImmutableDenseNDimArray(first_list, (2, 2))
+
+    assert first_ndim_array == second_ndim_array
+
+    def assignment_attempt(a):
+        a[0, 0] = 0
+
+    raises(TypeError, lambda: assignment_attempt(second_ndim_array))
+    assert first_ndim_array == second_ndim_array
+    assert first_ndim_array == fourth_ndim_array
+
+
+def test_arithmetic():
+    a = ImmutableDenseNDimArray([3 for i in range(9)], (3, 3))
+    b = ImmutableDenseNDimArray([7 for i in range(9)], (3, 3))
+
+    c1 = a + b
+    c2 = b + a
+    assert c1 == c2
+
+    d1 = a - b
+    d2 = b - a
+    assert d1 == d2 * (-1)
+
+    e1 = a * 5
+    e2 = 5 * a
+    e3 = copy(a)
+    e3 *= 5
+    assert e1 == e2 == e3
+
+    f1 = a / 5
+    f2 = copy(a)
+    f2 /= 5
+    assert f1 == f2
+    assert f1[0, 0] == f1[0, 1] == f1[0, 2] == f1[1, 0] == f1[1, 1] == \
+    f1[1, 2] == f1[2, 0] == f1[2, 1] == f1[2, 2] == Rational(3, 5)
+
+    assert type(a) == type(b) == type(c1) == type(c2) == type(d1) == type(d2) \
+        == type(e1) == type(e2) == type(e3) == type(f1)
+
+    z0 = -a
+    assert z0 == ImmutableDenseNDimArray([-3 for i in range(9)], (3, 3))
+
+
+def test_higher_dimenions():
+    m3 = ImmutableDenseNDimArray(range(10, 34), (2, 3, 4))
+
+    assert m3.tolist() == [[[10, 11, 12, 13],
+            [14, 15, 16, 17],
+            [18, 19, 20, 21]],
+
+           [[22, 23, 24, 25],
+            [26, 27, 28, 29],
+            [30, 31, 32, 33]]]
+
+    assert m3._get_tuple_index(0) == (0, 0, 0)
+    assert m3._get_tuple_index(1) == (0, 0, 1)
+    assert m3._get_tuple_index(4) == (0, 1, 0)
+    assert m3._get_tuple_index(12) == (1, 0, 0)
+
+    assert str(m3) == '[[[10, 11, 12, 13], [14, 15, 16, 17], [18, 19, 20, 21]], [[22, 23, 24, 25], [26, 27, 28, 29], [30, 31, 32, 33]]]'
+
+    m3_rebuilt = ImmutableDenseNDimArray([[[10, 11, 12, 13], [14, 15, 16, 17], [18, 19, 20, 21]], [[22, 23, 24, 25], [26, 27, 28, 29], [30, 31, 32, 33]]])
+    assert m3 == m3_rebuilt
+
+    m3_other = ImmutableDenseNDimArray([[[10, 11, 12, 13], [14, 15, 16, 17], [18, 19, 20, 21]], [[22, 23, 24, 25], [26, 27, 28, 29], [30, 31, 32, 33]]], (2, 3, 4))
+
+    assert m3 == m3_other
+
+
+def test_rebuild_immutable_arrays():
+    sparr = ImmutableSparseNDimArray(range(10, 34), (2, 3, 4))
+    densarr = ImmutableDenseNDimArray(range(10, 34), (2, 3, 4))
+
+    assert sparr == sparr.func(*sparr.args)
+    assert densarr == densarr.func(*densarr.args)
+
+
+def test_slices():
+    md = ImmutableDenseNDimArray(range(10, 34), (2, 3, 4))
+
+    assert md[:] == ImmutableDenseNDimArray(range(10, 34), (2, 3, 4))
+    assert md[:, :, 0].tomatrix() == Matrix([[10, 14, 18], [22, 26, 30]])
+    assert md[0, 1:2, :].tomatrix() == Matrix([[14, 15, 16, 17]])
+    assert md[0, 1:3, :].tomatrix() == Matrix([[14, 15, 16, 17], [18, 19, 20, 21]])
+    assert md[:, :, :] == md
+
+    sd = ImmutableSparseNDimArray(range(10, 34), (2, 3, 4))
+    assert sd == ImmutableSparseNDimArray(md)
+
+    assert sd[:] == ImmutableSparseNDimArray(range(10, 34), (2, 3, 4))
+    assert sd[:, :, 0].tomatrix() == Matrix([[10, 14, 18], [22, 26, 30]])
+    assert sd[0, 1:2, :].tomatrix() == Matrix([[14, 15, 16, 17]])
+    assert sd[0, 1:3, :].tomatrix() == Matrix([[14, 15, 16, 17], [18, 19, 20, 21]])
+    assert sd[:, :, :] == sd
+
+
+def test_diff_and_applyfunc():
+    from sympy.abc import x, y, z
+    md = ImmutableDenseNDimArray([[x, y], [x*z, x*y*z]])
+    assert md.diff(x) == ImmutableDenseNDimArray([[1, 0], [z, y*z]])
+    assert diff(md, x) == ImmutableDenseNDimArray([[1, 0], [z, y*z]])
+
+    sd = ImmutableSparseNDimArray(md)
+    assert sd == ImmutableSparseNDimArray([x, y, x*z, x*y*z], (2, 2))
+    assert sd.diff(x) == ImmutableSparseNDimArray([[1, 0], [z, y*z]])
+    assert diff(sd, x) == ImmutableSparseNDimArray([[1, 0], [z, y*z]])
+
+    mdn = md.applyfunc(lambda x: x*3)
+    assert mdn == ImmutableDenseNDimArray([[3*x, 3*y], [3*x*z, 3*x*y*z]])
+    assert md != mdn
+
+    sdn = sd.applyfunc(lambda x: x/2)
+    assert sdn == ImmutableSparseNDimArray([[x/2, y/2], [x*z/2, x*y*z/2]])
+    assert sd != sdn
+
+    sdp = sd.applyfunc(lambda x: x+1)
+    assert sdp == ImmutableSparseNDimArray([[x + 1, y + 1], [x*z + 1, x*y*z + 1]])
+    assert sd != sdp
+
+
+def test_op_priority():
+    from sympy.abc import x
+    md = ImmutableDenseNDimArray([1, 2, 3])
+    e1 = (1+x)*md
+    e2 = md*(1+x)
+    assert e1 == ImmutableDenseNDimArray([1+x, 2+2*x, 3+3*x])
+    assert e1 == e2
+
+    sd = ImmutableSparseNDimArray([1, 2, 3])
+    e3 = (1+x)*sd
+    e4 = sd*(1+x)
+    assert e3 == ImmutableDenseNDimArray([1+x, 2+2*x, 3+3*x])
+    assert e3 == e4
+
+
+def test_symbolic_indexing():
+    x, y, z, w = symbols("x y z w")
+    M = ImmutableDenseNDimArray([[x, y], [z, w]])
+    i, j = symbols("i, j")
+    Mij = M[i, j]
+    assert isinstance(Mij, Indexed)
+    Ms = ImmutableSparseNDimArray([[2, 3*x], [4, 5]])
+    msij = Ms[i, j]
+    assert isinstance(msij, Indexed)
+    for oi, oj in [(0, 0), (0, 1), (1, 0), (1, 1)]:
+        assert Mij.subs({i: oi, j: oj}) == M[oi, oj]
+        assert msij.subs({i: oi, j: oj}) == Ms[oi, oj]
+    A = IndexedBase("A", (0, 2))
+    assert A[0, 0].subs(A, M) == x
+    assert A[i, j].subs(A, M) == M[i, j]
+    assert M[i, j].subs(M, A) == A[i, j]
+
+    assert isinstance(M[3 * i - 2, j], Indexed)
+    assert M[3 * i - 2, j].subs({i: 1, j: 0}) == M[1, 0]
+    assert isinstance(M[i, 0], Indexed)
+    assert M[i, 0].subs(i, 0) == M[0, 0]
+    assert M[0, i].subs(i, 1) == M[0, 1]
+
+    assert M[i, j].diff(x) == ImmutableDenseNDimArray([[1, 0], [0, 0]])[i, j]
+    assert Ms[i, j].diff(x) == ImmutableSparseNDimArray([[0, 3], [0, 0]])[i, j]
+
+    Mo = ImmutableDenseNDimArray([1, 2, 3])
+    assert Mo[i].subs(i, 1) == 2
+    Mos = ImmutableSparseNDimArray([1, 2, 3])
+    assert Mos[i].subs(i, 1) == 2
+
+    raises(ValueError, lambda: M[i, 2])
+    raises(ValueError, lambda: M[i, -1])
+    raises(ValueError, lambda: M[2, i])
+    raises(ValueError, lambda: M[-1, i])
+
+    raises(ValueError, lambda: Ms[i, 2])
+    raises(ValueError, lambda: Ms[i, -1])
+    raises(ValueError, lambda: Ms[2, i])
+    raises(ValueError, lambda: Ms[-1, i])
+
+
+def test_issue_12665():
+    # Testing Python 3 hash of immutable arrays:
+    arr = ImmutableDenseNDimArray([1, 2, 3])
+    # This should NOT raise an exception:
+    hash(arr)
+
+
+def test_zeros_without_shape():
+    arr = ImmutableDenseNDimArray.zeros()
+    assert arr == ImmutableDenseNDimArray(0)
+
+def test_issue_21870():
+    a0 = ImmutableDenseNDimArray(0)
+    assert a0.rank() == 0
+    a1 = ImmutableDenseNDimArray(a0)
+    assert a1.rank() == 0
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/tests/test_mutable_ndim_array.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/tests/test_mutable_ndim_array.py
new file mode 100644
index 0000000000000000000000000000000000000000..9a232f399bbc0639d326217975fb0a12e645a984
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/tests/test_mutable_ndim_array.py
@@ -0,0 +1,374 @@
+from copy import copy
+
+from sympy.tensor.array.dense_ndim_array import MutableDenseNDimArray
+from sympy.core.function import diff
+from sympy.core.numbers import Rational
+from sympy.core.singleton import S
+from sympy.core.symbol import Symbol
+from sympy.core.sympify import sympify
+from sympy.matrices import SparseMatrix
+from sympy.matrices import Matrix
+from sympy.tensor.array.sparse_ndim_array import MutableSparseNDimArray
+from sympy.testing.pytest import raises
+
+
+def test_ndim_array_initiation():
+    arr_with_one_element = MutableDenseNDimArray([23])
+    assert len(arr_with_one_element) == 1
+    assert arr_with_one_element[0] == 23
+    assert arr_with_one_element.rank() == 1
+    raises(ValueError, lambda: arr_with_one_element[1])
+
+    arr_with_symbol_element = MutableDenseNDimArray([Symbol('x')])
+    assert len(arr_with_symbol_element) == 1
+    assert arr_with_symbol_element[0] == Symbol('x')
+    assert arr_with_symbol_element.rank() == 1
+
+    number5 = 5
+    vector = MutableDenseNDimArray.zeros(number5)
+    assert len(vector) == number5
+    assert vector.shape == (number5,)
+    assert vector.rank() == 1
+    raises(ValueError, lambda: arr_with_one_element[5])
+
+    vector = MutableSparseNDimArray.zeros(number5)
+    assert len(vector) == number5
+    assert vector.shape == (number5,)
+    assert vector._sparse_array == {}
+    assert vector.rank() == 1
+
+    n_dim_array = MutableDenseNDimArray(range(3**4), (3, 3, 3, 3,))
+    assert len(n_dim_array) == 3 * 3 * 3 * 3
+    assert n_dim_array.shape == (3, 3, 3, 3)
+    assert n_dim_array.rank() == 4
+    raises(ValueError, lambda: n_dim_array[0, 0, 0, 3])
+    raises(ValueError, lambda: n_dim_array[3, 0, 0, 0])
+    raises(ValueError, lambda: n_dim_array[3**4])
+
+    array_shape = (3, 3, 3, 3)
+    sparse_array = MutableSparseNDimArray.zeros(*array_shape)
+    assert len(sparse_array._sparse_array) == 0
+    assert len(sparse_array) == 3 * 3 * 3 * 3
+    assert n_dim_array.shape == array_shape
+    assert n_dim_array.rank() == 4
+
+    one_dim_array = MutableDenseNDimArray([2, 3, 1])
+    assert len(one_dim_array) == 3
+    assert one_dim_array.shape == (3,)
+    assert one_dim_array.rank() == 1
+    assert one_dim_array.tolist() == [2, 3, 1]
+
+    shape = (3, 3)
+    array_with_many_args = MutableSparseNDimArray.zeros(*shape)
+    assert len(array_with_many_args) == 3 * 3
+    assert array_with_many_args.shape == shape
+    assert array_with_many_args[0, 0] == 0
+    assert array_with_many_args.rank() == 2
+
+    shape = (int(3), int(3))
+    array_with_long_shape = MutableSparseNDimArray.zeros(*shape)
+    assert len(array_with_long_shape) == 3 * 3
+    assert array_with_long_shape.shape == shape
+    assert array_with_long_shape[int(0), int(0)] == 0
+    assert array_with_long_shape.rank() == 2
+
+    vector_with_long_shape = MutableDenseNDimArray(range(5), int(5))
+    assert len(vector_with_long_shape) == 5
+    assert vector_with_long_shape.shape == (int(5),)
+    assert vector_with_long_shape.rank() == 1
+    raises(ValueError, lambda: vector_with_long_shape[int(5)])
+
+    from sympy.abc import x
+    for ArrayType in [MutableDenseNDimArray, MutableSparseNDimArray]:
+        rank_zero_array = ArrayType(x)
+        assert len(rank_zero_array) == 1
+        assert rank_zero_array.shape == ()
+        assert rank_zero_array.rank() == 0
+        assert rank_zero_array[()] == x
+        raises(ValueError, lambda: rank_zero_array[0])
+
+def test_sympify():
+    from sympy.abc import x, y, z, t
+    arr = MutableDenseNDimArray([[x, y], [1, z*t]])
+    arr_other = sympify(arr)
+    assert arr_other.shape == (2, 2)
+    assert arr_other == arr
+
+
+def test_reshape():
+    array = MutableDenseNDimArray(range(50), 50)
+    assert array.shape == (50,)
+    assert array.rank() == 1
+
+    array = array.reshape(5, 5, 2)
+    assert array.shape == (5, 5, 2)
+    assert array.rank() == 3
+    assert len(array) == 50
+
+
+def test_iterator():
+    array = MutableDenseNDimArray(range(4), (2, 2))
+    assert array[0] == MutableDenseNDimArray([0, 1])
+    assert array[1] == MutableDenseNDimArray([2, 3])
+
+    array = array.reshape(4)
+    j = 0
+    for i in array:
+        assert i == j
+        j += 1
+
+
+def test_getitem():
+    for ArrayType in [MutableDenseNDimArray, MutableSparseNDimArray]:
+        array = ArrayType(range(24)).reshape(2, 3, 4)
+        assert array.tolist() == [[[0, 1, 2, 3], [4, 5, 6, 7], [8, 9, 10, 11]], [[12, 13, 14, 15], [16, 17, 18, 19], [20, 21, 22, 23]]]
+        assert array[0] == ArrayType([[0, 1, 2, 3], [4, 5, 6, 7], [8, 9, 10, 11]])
+        assert array[0, 0] == ArrayType([0, 1, 2, 3])
+        value = 0
+        for i in range(2):
+            for j in range(3):
+                for k in range(4):
+                    assert array[i, j, k] == value
+                    value += 1
+
+    raises(ValueError, lambda: array[3, 4, 5])
+    raises(ValueError, lambda: array[3, 4, 5, 6])
+    raises(ValueError, lambda: array[3, 4, 5, 3:4])
+
+
+def test_sparse():
+    sparse_array = MutableSparseNDimArray([0, 0, 0, 1], (2, 2))
+    assert len(sparse_array) == 2 * 2
+    # dictionary where all data is, only non-zero entries are actually stored:
+    assert len(sparse_array._sparse_array) == 1
+
+    assert sparse_array.tolist() == [[0, 0], [0, 1]]
+
+    for i, j in zip(sparse_array, [[0, 0], [0, 1]]):
+        assert i == MutableSparseNDimArray(j)
+
+    sparse_array[0, 0] = 123
+    assert len(sparse_array._sparse_array) == 2
+    assert sparse_array[0, 0] == 123
+    assert sparse_array/0 == MutableSparseNDimArray([[S.ComplexInfinity, S.NaN], [S.NaN, S.ComplexInfinity]], (2, 2))
+
+    # when element in sparse array become zero it will disappear from
+    # dictionary
+    sparse_array[0, 0] = 0
+    assert len(sparse_array._sparse_array) == 1
+    sparse_array[1, 1] = 0
+    assert len(sparse_array._sparse_array) == 0
+    assert sparse_array[0, 0] == 0
+
+    # test for large scale sparse array
+    # equality test
+    a = MutableSparseNDimArray.zeros(100000, 200000)
+    b = MutableSparseNDimArray.zeros(100000, 200000)
+    assert a == b
+    a[1, 1] = 1
+    b[1, 1] = 2
+    assert a != b
+
+    # __mul__ and __rmul__
+    assert a * 3 == MutableSparseNDimArray({200001: 3}, (100000, 200000))
+    assert 3 * a == MutableSparseNDimArray({200001: 3}, (100000, 200000))
+    assert a * 0 == MutableSparseNDimArray({}, (100000, 200000))
+    assert 0 * a == MutableSparseNDimArray({}, (100000, 200000))
+
+    # __truediv__
+    assert a/3 == MutableSparseNDimArray({200001: Rational(1, 3)}, (100000, 200000))
+
+    # __neg__
+    assert -a == MutableSparseNDimArray({200001: -1}, (100000, 200000))
+
+
+def test_calculation():
+
+    a = MutableDenseNDimArray([1]*9, (3, 3))
+    b = MutableDenseNDimArray([9]*9, (3, 3))
+
+    c = a + b
+    for i in c:
+        assert i == MutableDenseNDimArray([10, 10, 10])
+
+    assert c == MutableDenseNDimArray([10]*9, (3, 3))
+    assert c == MutableSparseNDimArray([10]*9, (3, 3))
+
+    c = b - a
+    for i in c:
+        assert i == MutableSparseNDimArray([8, 8, 8])
+
+    assert c == MutableDenseNDimArray([8]*9, (3, 3))
+    assert c == MutableSparseNDimArray([8]*9, (3, 3))
+
+
+def test_ndim_array_converting():
+    dense_array = MutableDenseNDimArray([1, 2, 3, 4], (2, 2))
+    alist = dense_array.tolist()
+
+    assert alist == [[1, 2], [3, 4]]
+
+    matrix = dense_array.tomatrix()
+    assert (isinstance(matrix, Matrix))
+
+    for i in range(len(dense_array)):
+        assert dense_array[dense_array._get_tuple_index(i)] == matrix[i]
+    assert matrix.shape == dense_array.shape
+
+    assert MutableDenseNDimArray(matrix) == dense_array
+    assert MutableDenseNDimArray(matrix.as_immutable()) == dense_array
+    assert MutableDenseNDimArray(matrix.as_mutable()) == dense_array
+
+    sparse_array = MutableSparseNDimArray([1, 2, 3, 4], (2, 2))
+    alist = sparse_array.tolist()
+
+    assert alist == [[1, 2], [3, 4]]
+
+    matrix = sparse_array.tomatrix()
+    assert(isinstance(matrix, SparseMatrix))
+
+    for i in range(len(sparse_array)):
+        assert sparse_array[sparse_array._get_tuple_index(i)] == matrix[i]
+    assert matrix.shape == sparse_array.shape
+
+    assert MutableSparseNDimArray(matrix) == sparse_array
+    assert MutableSparseNDimArray(matrix.as_immutable()) == sparse_array
+    assert MutableSparseNDimArray(matrix.as_mutable()) == sparse_array
+
+
+def test_converting_functions():
+    arr_list = [1, 2, 3, 4]
+    arr_matrix = Matrix(((1, 2), (3, 4)))
+
+    # list
+    arr_ndim_array = MutableDenseNDimArray(arr_list, (2, 2))
+    assert (isinstance(arr_ndim_array, MutableDenseNDimArray))
+    assert arr_matrix.tolist() == arr_ndim_array.tolist()
+
+    # Matrix
+    arr_ndim_array = MutableDenseNDimArray(arr_matrix)
+    assert (isinstance(arr_ndim_array, MutableDenseNDimArray))
+    assert arr_matrix.tolist() == arr_ndim_array.tolist()
+    assert arr_matrix.shape == arr_ndim_array.shape
+
+
+def test_equality():
+    first_list = [1, 2, 3, 4]
+    second_list = [1, 2, 3, 4]
+    third_list = [4, 3, 2, 1]
+    assert first_list == second_list
+    assert first_list != third_list
+
+    first_ndim_array = MutableDenseNDimArray(first_list, (2, 2))
+    second_ndim_array = MutableDenseNDimArray(second_list, (2, 2))
+    third_ndim_array = MutableDenseNDimArray(third_list, (2, 2))
+    fourth_ndim_array = MutableDenseNDimArray(first_list, (2, 2))
+
+    assert first_ndim_array == second_ndim_array
+    second_ndim_array[0, 0] = 0
+    assert first_ndim_array != second_ndim_array
+    assert first_ndim_array != third_ndim_array
+    assert first_ndim_array == fourth_ndim_array
+
+
+def test_arithmetic():
+    a = MutableDenseNDimArray([3 for i in range(9)], (3, 3))
+    b = MutableDenseNDimArray([7 for i in range(9)], (3, 3))
+
+    c1 = a + b
+    c2 = b + a
+    assert c1 == c2
+
+    d1 = a - b
+    d2 = b - a
+    assert d1 == d2 * (-1)
+
+    e1 = a * 5
+    e2 = 5 * a
+    e3 = copy(a)
+    e3 *= 5
+    assert e1 == e2 == e3
+
+    f1 = a / 5
+    f2 = copy(a)
+    f2 /= 5
+    assert f1 == f2
+    assert f1[0, 0] == f1[0, 1] == f1[0, 2] == f1[1, 0] == f1[1, 1] == \
+    f1[1, 2] == f1[2, 0] == f1[2, 1] == f1[2, 2] == Rational(3, 5)
+
+    assert type(a) == type(b) == type(c1) == type(c2) == type(d1) == type(d2) \
+        == type(e1) == type(e2) == type(e3) == type(f1)
+
+    z0 = -a
+    assert z0 == MutableDenseNDimArray([-3 for i in range(9)], (3, 3))
+
+
+def test_higher_dimenions():
+    m3 = MutableDenseNDimArray(range(10, 34), (2, 3, 4))
+
+    assert m3.tolist() == [[[10, 11, 12, 13],
+            [14, 15, 16, 17],
+            [18, 19, 20, 21]],
+
+           [[22, 23, 24, 25],
+            [26, 27, 28, 29],
+            [30, 31, 32, 33]]]
+
+    assert m3._get_tuple_index(0) == (0, 0, 0)
+    assert m3._get_tuple_index(1) == (0, 0, 1)
+    assert m3._get_tuple_index(4) == (0, 1, 0)
+    assert m3._get_tuple_index(12) == (1, 0, 0)
+
+    assert str(m3) == '[[[10, 11, 12, 13], [14, 15, 16, 17], [18, 19, 20, 21]], [[22, 23, 24, 25], [26, 27, 28, 29], [30, 31, 32, 33]]]'
+
+    m3_rebuilt = MutableDenseNDimArray([[[10, 11, 12, 13], [14, 15, 16, 17], [18, 19, 20, 21]], [[22, 23, 24, 25], [26, 27, 28, 29], [30, 31, 32, 33]]])
+    assert m3 == m3_rebuilt
+
+    m3_other = MutableDenseNDimArray([[[10, 11, 12, 13], [14, 15, 16, 17], [18, 19, 20, 21]], [[22, 23, 24, 25], [26, 27, 28, 29], [30, 31, 32, 33]]], (2, 3, 4))
+
+    assert m3 == m3_other
+
+
+def test_slices():
+    md = MutableDenseNDimArray(range(10, 34), (2, 3, 4))
+
+    assert md[:] == MutableDenseNDimArray(range(10, 34), (2, 3, 4))
+    assert md[:, :, 0].tomatrix() == Matrix([[10, 14, 18], [22, 26, 30]])
+    assert md[0, 1:2, :].tomatrix() == Matrix([[14, 15, 16, 17]])
+    assert md[0, 1:3, :].tomatrix() == Matrix([[14, 15, 16, 17], [18, 19, 20, 21]])
+    assert md[:, :, :] == md
+
+    sd = MutableSparseNDimArray(range(10, 34), (2, 3, 4))
+    assert sd == MutableSparseNDimArray(md)
+
+    assert sd[:] == MutableSparseNDimArray(range(10, 34), (2, 3, 4))
+    assert sd[:, :, 0].tomatrix() == Matrix([[10, 14, 18], [22, 26, 30]])
+    assert sd[0, 1:2, :].tomatrix() == Matrix([[14, 15, 16, 17]])
+    assert sd[0, 1:3, :].tomatrix() == Matrix([[14, 15, 16, 17], [18, 19, 20, 21]])
+    assert sd[:, :, :] == sd
+
+
+def test_slices_assign():
+    a = MutableDenseNDimArray(range(12), shape=(4, 3))
+    b = MutableSparseNDimArray(range(12), shape=(4, 3))
+
+    for i in [a, b]:
+        assert i.tolist() == [[0, 1, 2], [3, 4, 5], [6, 7, 8], [9, 10, 11]]
+        i[0, :] = [2, 2, 2]
+        assert i.tolist() == [[2, 2, 2], [3, 4, 5], [6, 7, 8], [9, 10, 11]]
+        i[0, 1:] = [8, 8]
+        assert i.tolist() == [[2, 8, 8], [3, 4, 5], [6, 7, 8], [9, 10, 11]]
+        i[1:3, 1] = [20, 44]
+        assert i.tolist() == [[2, 8, 8], [3, 20, 5], [6, 44, 8], [9, 10, 11]]
+
+
+def test_diff():
+    from sympy.abc import x, y, z
+    md = MutableDenseNDimArray([[x, y], [x*z, x*y*z]])
+    assert md.diff(x) == MutableDenseNDimArray([[1, 0], [z, y*z]])
+    assert diff(md, x) == MutableDenseNDimArray([[1, 0], [z, y*z]])
+
+    sd = MutableSparseNDimArray(md)
+    assert sd == MutableSparseNDimArray([x, y, x*z, x*y*z], (2, 2))
+    assert sd.diff(x) == MutableSparseNDimArray([[1, 0], [z, y*z]])
+    assert diff(sd, x) == MutableSparseNDimArray([[1, 0], [z, y*z]])
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/tests/test_ndim_array.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/tests/test_ndim_array.py
new file mode 100644
index 0000000000000000000000000000000000000000..7ff9b032631c01272c00478e4cdf0dcbc6997990
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/tests/test_ndim_array.py
@@ -0,0 +1,73 @@
+from sympy.testing.pytest import raises
+from sympy.functions.elementary.trigonometric import sin, cos
+from sympy.matrices.dense import Matrix
+from sympy.simplify import simplify
+from sympy.tensor.array import Array
+from sympy.tensor.array.dense_ndim_array import (
+    ImmutableDenseNDimArray, MutableDenseNDimArray)
+from sympy.tensor.array.sparse_ndim_array import (
+    ImmutableSparseNDimArray, MutableSparseNDimArray)
+
+from sympy.abc import x, y
+
+mutable_array_types = [
+    MutableDenseNDimArray,
+    MutableSparseNDimArray
+]
+
+array_types = [
+    ImmutableDenseNDimArray,
+    ImmutableSparseNDimArray,
+    MutableDenseNDimArray,
+    MutableSparseNDimArray
+]
+
+
+def test_array_negative_indices():
+    for ArrayType in array_types:
+        test_array = ArrayType([[1, 2, 3, 4, 5], [6, 7, 8, 9, 10]])
+        assert test_array[:, -1] == Array([5, 10])
+        assert test_array[:, -2] == Array([4, 9])
+        assert test_array[:, -3] == Array([3, 8])
+        assert test_array[:, -4] == Array([2, 7])
+        assert test_array[:, -5] == Array([1, 6])
+        assert test_array[:, 0] == Array([1, 6])
+        assert test_array[:, 1] == Array([2, 7])
+        assert test_array[:, 2] == Array([3, 8])
+        assert test_array[:, 3] == Array([4, 9])
+        assert test_array[:, 4] == Array([5, 10])
+
+        raises(ValueError, lambda: test_array[:, -6])
+        raises(ValueError, lambda: test_array[-3, :])
+
+        assert test_array[-1, -1] == 10
+
+
+def test_issue_18361():
+    A = Array([sin(2 * x) - 2 * sin(x) * cos(x)])
+    B = Array([sin(x)**2 + cos(x)**2, 0])
+    C = Array([(x + x**2)/(x*sin(y)**2 + x*cos(y)**2), 2*sin(x)*cos(x)])
+    assert simplify(A) == Array([0])
+    assert simplify(B) == Array([1, 0])
+    assert simplify(C) == Array([x + 1, sin(2*x)])
+
+
+def test_issue_20222():
+    A = Array([[1, 2], [3, 4]])
+    B = Matrix([[1,2],[3,4]])
+    raises(TypeError, lambda: A - B)
+
+
+def test_issue_17851():
+    for array_type in array_types:
+        A = array_type([])
+        assert isinstance(A, array_type)
+        assert A.shape == (0,)
+        assert list(A) == []
+
+
+def test_issue_and_18715():
+    for array_type in mutable_array_types:
+        A = array_type([0, 1, 2])
+        A[0] += 5
+        assert A[0] == 5
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/tests/test_ndim_array_conversions.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/tests/test_ndim_array_conversions.py
new file mode 100644
index 0000000000000000000000000000000000000000..f43260ccc636ac461ba0c06dbfcf3fe3a8d5338d
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/array/tests/test_ndim_array_conversions.py
@@ -0,0 +1,22 @@
+from sympy.tensor.array import (ImmutableDenseNDimArray,
+        ImmutableSparseNDimArray, MutableDenseNDimArray, MutableSparseNDimArray)
+from sympy.abc import x, y, z
+
+
+def test_NDim_array_conv():
+    MD = MutableDenseNDimArray([x, y, z])
+    MS = MutableSparseNDimArray([x, y, z])
+    ID = ImmutableDenseNDimArray([x, y, z])
+    IS = ImmutableSparseNDimArray([x, y, z])
+
+    assert MD.as_immutable() == ID
+    assert MD.as_mutable() == MD
+
+    assert MS.as_immutable() == IS
+    assert MS.as_mutable() == MS
+
+    assert ID.as_immutable() == ID
+    assert ID.as_mutable() == MD
+
+    assert IS.as_immutable() == IS
+    assert IS.as_mutable() == MS
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/tests/__init__.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/tests/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/tests/__pycache__/__init__.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/tests/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a5774ac3d1f9028daaa0f6cf108ad84561d9228c
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/tests/__pycache__/__init__.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/tests/__pycache__/test_functions.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/tests/__pycache__/test_functions.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5807cb99c9d5ab6847e39a155bdda77648c8a852
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/tests/__pycache__/test_functions.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/tests/__pycache__/test_index_methods.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/tests/__pycache__/test_index_methods.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c4e25833c9fd7e4b38d598f007270c4dc90a52d3
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/tests/__pycache__/test_index_methods.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/tests/__pycache__/test_indexed.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/tests/__pycache__/test_indexed.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..6c82ce31efdf783286b4acd5a5ae69c0d163392c
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/tests/__pycache__/test_indexed.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/tests/__pycache__/test_printing.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/tests/__pycache__/test_printing.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..37d10b170b3282389dcabadcf7f9a226562e14fb
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/tests/__pycache__/test_printing.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/tests/__pycache__/test_tensor.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/tests/__pycache__/test_tensor.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f026f99f42c5db9884960a5922e938469b15a7b1
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/tests/__pycache__/test_tensor.cpython-312.pyc
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:317c536f7357d555831f3cc5573210638a9fa9d09d17da1a573abe17f38f7bac
+size 145208
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/tests/__pycache__/test_tensor_element.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/tests/__pycache__/test_tensor_element.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..26e0feb47a827e61964156de87f020fa1648a267
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/tests/__pycache__/test_tensor_element.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/tests/__pycache__/test_tensor_operators.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/tests/__pycache__/test_tensor_operators.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b2864a9e3591ed1a1c56b414589c6a50337e5667
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/tests/__pycache__/test_tensor_operators.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/tests/test_functions.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/tests/test_functions.py
new file mode 100644
index 0000000000000000000000000000000000000000..ae40865d1bddffaa976dc3d94ae1ef1b6c97ca35
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/tests/test_functions.py
@@ -0,0 +1,57 @@
+from sympy.tensor.functions import TensorProduct
+from sympy.matrices.dense import Matrix
+from sympy.matrices.expressions.matexpr import MatrixSymbol
+from sympy.tensor.array import Array
+from sympy.abc import x, y, z
+from sympy.abc import i, j, k, l
+
+
+A = MatrixSymbol("A", 3, 3)
+B = MatrixSymbol("B", 3, 3)
+C = MatrixSymbol("C", 3, 3)
+
+
+def test_TensorProduct_construction():
+    assert TensorProduct(3, 4) == 12
+    assert isinstance(TensorProduct(A, A), TensorProduct)
+
+    expr = TensorProduct(TensorProduct(x, y), z)
+    assert expr == x*y*z
+
+    expr = TensorProduct(TensorProduct(A, B), C)
+    assert expr == TensorProduct(A, B, C)
+
+    expr = TensorProduct(Matrix.eye(2), Array([[0, -1], [1, 0]]))
+    assert expr == Array([
+        [
+            [[0, -1], [1, 0]],
+            [[0, 0], [0, 0]]
+        ],
+        [
+            [[0, 0], [0, 0]],
+            [[0, -1], [1, 0]]
+        ]
+    ])
+
+
+def test_TensorProduct_shape():
+
+    expr = TensorProduct(3, 4, evaluate=False)
+    assert expr.shape == ()
+    assert expr.rank() == 0
+
+    expr = TensorProduct(Array([1, 2]), Array([x, y]), evaluate=False)
+    assert expr.shape == (2, 2)
+    assert expr.rank() == 2
+    expr = TensorProduct(expr, expr, evaluate=False)
+    assert expr.shape == (2, 2, 2, 2)
+    assert expr.rank() == 4
+
+    expr = TensorProduct(Matrix.eye(2), Array([[0, -1], [1, 0]]), evaluate=False)
+    assert expr.shape == (2, 2, 2, 2)
+    assert expr.rank() == 4
+
+
+def test_TensorProduct_getitem():
+    expr = TensorProduct(A, B)
+    assert expr[i, j, k, l] == A[i, j]*B[k, l]
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/tests/test_index_methods.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/tests/test_index_methods.py
new file mode 100644
index 0000000000000000000000000000000000000000..df20f7e7c1ab392321e8350b95dd07c5639c1865
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/tests/test_index_methods.py
@@ -0,0 +1,227 @@
+from sympy.core import symbols, S, Pow, Function
+from sympy.functions import exp
+from sympy.testing.pytest import raises
+from sympy.tensor.indexed import Idx, IndexedBase
+from sympy.tensor.index_methods import IndexConformanceException
+
+from sympy.tensor.index_methods import (get_contraction_structure, get_indices)
+
+
+def test_trivial_indices():
+    x, y = symbols('x y')
+    assert get_indices(x) == (set(), {})
+    assert get_indices(x*y) == (set(), {})
+    assert get_indices(x + y) == (set(), {})
+    assert get_indices(x**y) == (set(), {})
+
+
+def test_get_indices_Indexed():
+    x = IndexedBase('x')
+    i, j = Idx('i'), Idx('j')
+    assert get_indices(x[i, j]) == ({i, j}, {})
+    assert get_indices(x[j, i]) == ({j, i}, {})
+
+
+def test_get_indices_Idx():
+    f = Function('f')
+    i, j = Idx('i'), Idx('j')
+    assert get_indices(f(i)*j) == ({i, j}, {})
+    assert get_indices(f(j, i)) == ({j, i}, {})
+    assert get_indices(f(i)*i) == (set(), {})
+
+
+def test_get_indices_mul():
+    x = IndexedBase('x')
+    y = IndexedBase('y')
+    i, j = Idx('i'), Idx('j')
+    assert get_indices(x[j]*y[i]) == ({i, j}, {})
+    assert get_indices(x[i]*y[j]) == ({i, j}, {})
+
+
+def test_get_indices_exceptions():
+    x = IndexedBase('x')
+    y = IndexedBase('y')
+    i, j = Idx('i'), Idx('j')
+    raises(IndexConformanceException, lambda: get_indices(x[i] + y[j]))
+
+
+def test_scalar_broadcast():
+    x = IndexedBase('x')
+    y = IndexedBase('y')
+    i, j = Idx('i'), Idx('j')
+    assert get_indices(x[i] + y[i, i]) == ({i}, {})
+    assert get_indices(x[i] + y[j, j]) == ({i}, {})
+
+
+def test_get_indices_add():
+    x = IndexedBase('x')
+    y = IndexedBase('y')
+    A = IndexedBase('A')
+    i, j, k = Idx('i'), Idx('j'), Idx('k')
+    assert get_indices(x[i] + 2*y[i]) == ({i}, {})
+    assert get_indices(y[i] + 2*A[i, j]*x[j]) == ({i}, {})
+    assert get_indices(y[i] + 2*(x[i] + A[i, j]*x[j])) == ({i}, {})
+    assert get_indices(y[i] + x[i]*(A[j, j] + 1)) == ({i}, {})
+    assert get_indices(
+        y[i] + x[i]*x[j]*(y[j] + A[j, k]*x[k])) == ({i}, {})
+
+
+def test_get_indices_Pow():
+    x = IndexedBase('x')
+    y = IndexedBase('y')
+    A = IndexedBase('A')
+    i, j, k = Idx('i'), Idx('j'), Idx('k')
+    assert get_indices(Pow(x[i], y[j])) == ({i, j}, {})
+    assert get_indices(Pow(x[i, k], y[j, k])) == ({i, j, k}, {})
+    assert get_indices(Pow(A[i, k], y[k] + A[k, j]*x[j])) == ({i, k}, {})
+    assert get_indices(Pow(2, x[i])) == get_indices(exp(x[i]))
+
+    # test of a design decision, this may change:
+    assert get_indices(Pow(x[i], 2)) == ({i}, {})
+
+
+def test_get_contraction_structure_basic():
+    x = IndexedBase('x')
+    y = IndexedBase('y')
+    i, j = Idx('i'), Idx('j')
+    assert get_contraction_structure(x[i]*y[j]) == {None: {x[i]*y[j]}}
+    assert get_contraction_structure(x[i] + y[j]) == {None: {x[i], y[j]}}
+    assert get_contraction_structure(x[i]*y[i]) == {(i,): {x[i]*y[i]}}
+    assert get_contraction_structure(
+        1 + x[i]*y[i]) == {None: {S.One}, (i,): {x[i]*y[i]}}
+    assert get_contraction_structure(x[i]**y[i]) == {None: {x[i]**y[i]}}
+
+
+def test_get_contraction_structure_complex():
+    x = IndexedBase('x')
+    y = IndexedBase('y')
+    A = IndexedBase('A')
+    i, j, k = Idx('i'), Idx('j'), Idx('k')
+    expr1 = y[i] + A[i, j]*x[j]
+    d1 = {None: {y[i]}, (j,): {A[i, j]*x[j]}}
+    assert get_contraction_structure(expr1) == d1
+    expr2 = expr1*A[k, i] + x[k]
+    d2 = {None: {x[k]}, (i,): {expr1*A[k, i]}, expr1*A[k, i]: [d1]}
+    assert get_contraction_structure(expr2) == d2
+
+
+def test_contraction_structure_simple_Pow():
+    x = IndexedBase('x')
+    y = IndexedBase('y')
+    i, j, k = Idx('i'), Idx('j'), Idx('k')
+    ii_jj = x[i, i]**y[j, j]
+    assert get_contraction_structure(ii_jj) == {
+        None: {ii_jj},
+        ii_jj: [
+            {(i,): {x[i, i]}},
+            {(j,): {y[j, j]}}
+        ]
+    }
+
+    ii_jk = x[i, i]**y[j, k]
+    assert get_contraction_structure(ii_jk) == {
+        None: {x[i, i]**y[j, k]},
+        x[i, i]**y[j, k]: [
+            {(i,): {x[i, i]}}
+        ]
+    }
+
+
+def test_contraction_structure_Mul_and_Pow():
+    x = IndexedBase('x')
+    y = IndexedBase('y')
+    i, j, k = Idx('i'), Idx('j'), Idx('k')
+
+    i_ji = x[i]**(y[j]*x[i])
+    assert get_contraction_structure(i_ji) == {None: {i_ji}}
+    ij_i = (x[i]*y[j])**(y[i])
+    assert get_contraction_structure(ij_i) == {None: {ij_i}}
+    j_ij_i = x[j]*(x[i]*y[j])**(y[i])
+    assert get_contraction_structure(j_ij_i) == {(j,): {j_ij_i}}
+    j_i_ji = x[j]*x[i]**(y[j]*x[i])
+    assert get_contraction_structure(j_i_ji) == {(j,): {j_i_ji}}
+    ij_exp_kki = x[i]*y[j]*exp(y[i]*y[k, k])
+    result = get_contraction_structure(ij_exp_kki)
+    expected = {
+        (i,): {ij_exp_kki},
+        ij_exp_kki: [{
+                     None: {exp(y[i]*y[k, k])},
+                exp(y[i]*y[k, k]): [{
+                    None: {y[i]*y[k, k]},
+                    y[i]*y[k, k]: [{(k,): {y[k, k]}}]
+                }]}
+        ]
+    }
+    assert result == expected
+
+
+def test_contraction_structure_Add_in_Pow():
+    x = IndexedBase('x')
+    y = IndexedBase('y')
+    i, j, k = Idx('i'), Idx('j'), Idx('k')
+    s_ii_jj_s = (1 + x[i, i])**(1 + y[j, j])
+    expected = {
+        None: {s_ii_jj_s},
+        s_ii_jj_s: [
+            {None: {S.One}, (i,): {x[i, i]}},
+            {None: {S.One}, (j,): {y[j, j]}}
+        ]
+    }
+    result = get_contraction_structure(s_ii_jj_s)
+    assert result == expected
+
+    s_ii_jk_s = (1 + x[i, i]) ** (1 + y[j, k])
+    expected_2 = {
+        None: {(x[i, i] + 1)**(y[j, k] + 1)},
+        s_ii_jk_s: [
+            {None: {S.One}, (i,): {x[i, i]}}
+        ]
+    }
+    result_2 = get_contraction_structure(s_ii_jk_s)
+    assert result_2 == expected_2
+
+
+def test_contraction_structure_Pow_in_Pow():
+    x = IndexedBase('x')
+    y = IndexedBase('y')
+    z = IndexedBase('z')
+    i, j, k = Idx('i'), Idx('j'), Idx('k')
+    ii_jj_kk = x[i, i]**y[j, j]**z[k, k]
+    expected = {
+        None: {ii_jj_kk},
+        ii_jj_kk: [
+            {(i,): {x[i, i]}},
+            {
+                None: {y[j, j]**z[k, k]},
+                y[j, j]**z[k, k]: [
+                    {(j,): {y[j, j]}},
+                    {(k,): {z[k, k]}}
+                ]
+            }
+        ]
+    }
+    assert get_contraction_structure(ii_jj_kk) == expected
+
+
+def test_ufunc_support():
+    f = Function('f')
+    g = Function('g')
+    x = IndexedBase('x')
+    y = IndexedBase('y')
+    i, j = Idx('i'), Idx('j')
+    a = symbols('a')
+
+    assert get_indices(f(x[i])) == ({i}, {})
+    assert get_indices(f(x[i], y[j])) == ({i, j}, {})
+    assert get_indices(f(y[i])*g(x[i])) == (set(), {})
+    assert get_indices(f(a, x[i])) == ({i}, {})
+    assert get_indices(f(a, y[i], x[j])*g(x[i])) == ({j}, {})
+    assert get_indices(g(f(x[i]))) == ({i}, {})
+
+    assert get_contraction_structure(f(x[i])) == {None: {f(x[i])}}
+    assert get_contraction_structure(
+        f(y[i])*g(x[i])) == {(i,): {f(y[i])*g(x[i])}}
+    assert get_contraction_structure(
+        f(y[i])*g(f(x[i]))) == {(i,): {f(y[i])*g(f(x[i]))}}
+    assert get_contraction_structure(
+        f(x[j], y[i])*g(x[i])) == {(i,): {f(x[j], y[i])*g(x[i])}}
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/tests/test_indexed.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/tests/test_indexed.py
new file mode 100644
index 0000000000000000000000000000000000000000..689ec932c8fcefe0a24de289dd2ffd6820c63f19
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/tests/test_indexed.py
@@ -0,0 +1,511 @@
+from sympy.core import symbols, Symbol, Tuple, oo, Dummy
+from sympy.tensor.indexed import IndexException
+from sympy.testing.pytest import raises
+from sympy.utilities.iterables import iterable
+
+# import test:
+from sympy.concrete.summations import Sum
+from sympy.core.function import Function, Subs, Derivative
+from sympy.core.relational import (StrictLessThan, GreaterThan,
+    StrictGreaterThan, LessThan)
+from sympy.core.singleton import S
+from sympy.functions.elementary.exponential import exp, log
+from sympy.functions.elementary.trigonometric import cos, sin
+from sympy.functions.special.tensor_functions import KroneckerDelta
+from sympy.series.order import Order
+from sympy.sets.fancysets import Range
+from sympy.tensor.indexed import IndexedBase, Idx, Indexed
+
+
+def test_Idx_construction():
+    i, a, b = symbols('i a b', integer=True)
+    assert Idx(i) != Idx(i, 1)
+    assert Idx(i, a) == Idx(i, (0, a - 1))
+    assert Idx(i, oo) == Idx(i, (0, oo))
+
+    x = symbols('x', integer=False)
+    raises(TypeError, lambda: Idx(x))
+    raises(TypeError, lambda: Idx(0.5))
+    raises(TypeError, lambda: Idx(i, x))
+    raises(TypeError, lambda: Idx(i, 0.5))
+    raises(TypeError, lambda: Idx(i, (x, 5)))
+    raises(TypeError, lambda: Idx(i, (2, x)))
+    raises(TypeError, lambda: Idx(i, (2, 3.5)))
+
+
+def test_Idx_properties():
+    i, a, b = symbols('i a b', integer=True)
+    assert Idx(i).is_integer
+    assert Idx(i).name == 'i'
+    assert Idx(i + 2).name == 'i + 2'
+    assert Idx('foo').name == 'foo'
+
+
+def test_Idx_bounds():
+    i, a, b = symbols('i a b', integer=True)
+    assert Idx(i).lower is None
+    assert Idx(i).upper is None
+    assert Idx(i, a).lower == 0
+    assert Idx(i, a).upper == a - 1
+    assert Idx(i, 5).lower == 0
+    assert Idx(i, 5).upper == 4
+    assert Idx(i, oo).lower == 0
+    assert Idx(i, oo).upper is oo
+    assert Idx(i, (a, b)).lower == a
+    assert Idx(i, (a, b)).upper == b
+    assert Idx(i, (1, 5)).lower == 1
+    assert Idx(i, (1, 5)).upper == 5
+    assert Idx(i, (-oo, oo)).lower is -oo
+    assert Idx(i, (-oo, oo)).upper is oo
+
+
+def test_Idx_fixed_bounds():
+    i, a, b, x = symbols('i a b x', integer=True)
+    assert Idx(x).lower is None
+    assert Idx(x).upper is None
+    assert Idx(x, a).lower == 0
+    assert Idx(x, a).upper == a - 1
+    assert Idx(x, 5).lower == 0
+    assert Idx(x, 5).upper == 4
+    assert Idx(x, oo).lower == 0
+    assert Idx(x, oo).upper is oo
+    assert Idx(x, (a, b)).lower == a
+    assert Idx(x, (a, b)).upper == b
+    assert Idx(x, (1, 5)).lower == 1
+    assert Idx(x, (1, 5)).upper == 5
+    assert Idx(x, (-oo, oo)).lower is -oo
+    assert Idx(x, (-oo, oo)).upper is oo
+
+
+def test_Idx_inequalities():
+    i14 = Idx("i14", (1, 4))
+    i79 = Idx("i79", (7, 9))
+    i46 = Idx("i46", (4, 6))
+    i35 = Idx("i35", (3, 5))
+
+    assert i14 <= 5
+    assert i14 < 5
+    assert not (i14 >= 5)
+    assert not (i14 > 5)
+
+    assert 5 >= i14
+    assert 5 > i14
+    assert not (5 <= i14)
+    assert not (5 < i14)
+
+    assert LessThan(i14, 5)
+    assert StrictLessThan(i14, 5)
+    assert not GreaterThan(i14, 5)
+    assert not StrictGreaterThan(i14, 5)
+
+    assert i14 <= 4
+    assert isinstance(i14 < 4, StrictLessThan)
+    assert isinstance(i14 >= 4, GreaterThan)
+    assert not (i14 > 4)
+
+    assert isinstance(i14 <= 1, LessThan)
+    assert not (i14 < 1)
+    assert i14 >= 1
+    assert isinstance(i14 > 1, StrictGreaterThan)
+
+    assert not (i14 <= 0)
+    assert not (i14 < 0)
+    assert i14 >= 0
+    assert i14 > 0
+
+    from sympy.abc import x
+
+    assert isinstance(i14 < x, StrictLessThan)
+    assert isinstance(i14 > x, StrictGreaterThan)
+    assert isinstance(i14 <= x, LessThan)
+    assert isinstance(i14 >= x, GreaterThan)
+
+    assert i14 < i79
+    assert i14 <= i79
+    assert not (i14 > i79)
+    assert not (i14 >= i79)
+
+    assert i14 <= i46
+    assert isinstance(i14 < i46, StrictLessThan)
+    assert isinstance(i14 >= i46, GreaterThan)
+    assert not (i14 > i46)
+
+    assert isinstance(i14 < i35, StrictLessThan)
+    assert isinstance(i14 > i35, StrictGreaterThan)
+    assert isinstance(i14 <= i35, LessThan)
+    assert isinstance(i14 >= i35, GreaterThan)
+
+    iNone1 = Idx("iNone1")
+    iNone2 = Idx("iNone2")
+
+    assert isinstance(iNone1 < iNone2, StrictLessThan)
+    assert isinstance(iNone1 > iNone2, StrictGreaterThan)
+    assert isinstance(iNone1 <= iNone2, LessThan)
+    assert isinstance(iNone1 >= iNone2, GreaterThan)
+
+
+def test_Idx_inequalities_current_fails():
+    i14 = Idx("i14", (1, 4))
+
+    assert S(5) >= i14
+    assert S(5) > i14
+    assert not (S(5) <= i14)
+    assert not (S(5) < i14)
+
+
+def test_Idx_func_args():
+    i, a, b = symbols('i a b', integer=True)
+    ii = Idx(i)
+    assert ii.func(*ii.args) == ii
+    ii = Idx(i, a)
+    assert ii.func(*ii.args) == ii
+    ii = Idx(i, (a, b))
+    assert ii.func(*ii.args) == ii
+
+
+def test_Idx_subs():
+    i, a, b = symbols('i a b', integer=True)
+    assert Idx(i, a).subs(a, b) == Idx(i, b)
+    assert Idx(i, a).subs(i, b) == Idx(b, a)
+
+    assert Idx(i).subs(i, 2) == Idx(2)
+    assert Idx(i, a).subs(a, 2) == Idx(i, 2)
+    assert Idx(i, (a, b)).subs(i, 2) == Idx(2, (a, b))
+
+
+def test_IndexedBase_sugar():
+    i, j = symbols('i j', integer=True)
+    a = symbols('a')
+    A1 = Indexed(a, i, j)
+    A2 = IndexedBase(a)
+    assert A1 == A2[i, j]
+    assert A1 == A2[(i, j)]
+    assert A1 == A2[[i, j]]
+    assert A1 == A2[Tuple(i, j)]
+    assert all(a.is_Integer for a in A2[1, 0].args[1:])
+
+
+def test_IndexedBase_subs():
+    i = symbols('i', integer=True)
+    a, b = symbols('a b')
+    A = IndexedBase(a)
+    B = IndexedBase(b)
+    assert A[i] == B[i].subs(b, a)
+    C = {1: 2}
+    assert C[1] == A[1].subs(A, C)
+
+
+def test_IndexedBase_shape():
+    i, j, m, n = symbols('i j m n', integer=True)
+    a = IndexedBase('a', shape=(m, m))
+    b = IndexedBase('a', shape=(m, n))
+    assert b.shape == Tuple(m, n)
+    assert a[i, j] != b[i, j]
+    assert a[i, j] == b[i, j].subs(n, m)
+    assert b.func(*b.args) == b
+    assert b[i, j].func(*b[i, j].args) == b[i, j]
+    raises(IndexException, lambda: b[i])
+    raises(IndexException, lambda: b[i, i, j])
+    F = IndexedBase("F", shape=m)
+    assert F.shape == Tuple(m)
+    assert F[i].subs(i, j) == F[j]
+    raises(IndexException, lambda: F[i, j])
+
+
+def test_IndexedBase_assumptions():
+    i = Symbol('i', integer=True)
+    a = Symbol('a')
+    A = IndexedBase(a, positive=True)
+    for c in (A, A[i]):
+        assert c.is_real
+        assert c.is_complex
+        assert not c.is_imaginary
+        assert c.is_nonnegative
+        assert c.is_nonzero
+        assert c.is_commutative
+        assert log(exp(c)) == c
+
+    assert A != IndexedBase(a)
+    assert A == IndexedBase(a, positive=True, real=True)
+    assert A[i] != Indexed(a, i)
+
+
+def test_IndexedBase_assumptions_inheritance():
+    I = Symbol('I', integer=True)
+    I_inherit = IndexedBase(I)
+    I_explicit = IndexedBase('I', integer=True)
+
+    assert I_inherit.is_integer
+    assert I_explicit.is_integer
+    assert I_inherit.label.is_integer
+    assert I_explicit.label.is_integer
+    assert I_inherit == I_explicit
+
+
+def test_issue_17652():
+    """Regression test issue #17652.
+
+    IndexedBase.label should not upcast subclasses of Symbol
+    """
+    class SubClass(Symbol):
+        pass
+
+    x = SubClass('X')
+    assert type(x) == SubClass
+    base = IndexedBase(x)
+    assert type(x) == SubClass
+    assert type(base.label) == SubClass
+
+
+def test_Indexed_constructor():
+    i, j = symbols('i j', integer=True)
+    A = Indexed('A', i, j)
+    assert A == Indexed(Symbol('A'), i, j)
+    assert A == Indexed(IndexedBase('A'), i, j)
+    raises(TypeError, lambda: Indexed(A, i, j))
+    raises(IndexException, lambda: Indexed("A"))
+    assert A.free_symbols == {A, A.base.label, i, j}
+
+
+def test_Indexed_func_args():
+    i, j = symbols('i j', integer=True)
+    a = symbols('a')
+    A = Indexed(a, i, j)
+    assert A == A.func(*A.args)
+
+
+def test_Indexed_subs():
+    i, j, k = symbols('i j k', integer=True)
+    a, b = symbols('a b')
+    A = IndexedBase(a)
+    B = IndexedBase(b)
+    assert A[i, j] == B[i, j].subs(b, a)
+    assert A[i, j] == A[i, k].subs(k, j)
+
+
+def test_Indexed_properties():
+    i, j = symbols('i j', integer=True)
+    A = Indexed('A', i, j)
+    assert A.name == 'A[i, j]'
+    assert A.rank == 2
+    assert A.indices == (i, j)
+    assert A.base == IndexedBase('A')
+    assert A.ranges == [None, None]
+    raises(IndexException, lambda: A.shape)
+
+    n, m = symbols('n m', integer=True)
+    assert Indexed('A', Idx(
+        i, m), Idx(j, n)).ranges == [Tuple(0, m - 1), Tuple(0, n - 1)]
+    assert Indexed('A', Idx(i, m), Idx(j, n)).shape == Tuple(m, n)
+    raises(IndexException, lambda: Indexed("A", Idx(i, m), Idx(j)).shape)
+
+
+def test_Indexed_shape_precedence():
+    i, j = symbols('i j', integer=True)
+    o, p = symbols('o p', integer=True)
+    n, m = symbols('n m', integer=True)
+    a = IndexedBase('a', shape=(o, p))
+    assert a.shape == Tuple(o, p)
+    assert Indexed(
+        a, Idx(i, m), Idx(j, n)).ranges == [Tuple(0, m - 1), Tuple(0, n - 1)]
+    assert Indexed(a, Idx(i, m), Idx(j, n)).shape == Tuple(o, p)
+    assert Indexed(
+        a, Idx(i, m), Idx(j)).ranges == [Tuple(0, m - 1), (None, None)]
+    assert Indexed(a, Idx(i, m), Idx(j)).shape == Tuple(o, p)
+
+
+def test_complex_indices():
+    i, j = symbols('i j', integer=True)
+    A = Indexed('A', i, i + j)
+    assert A.rank == 2
+    assert A.indices == (i, i + j)
+
+
+def test_not_interable():
+    i, j = symbols('i j', integer=True)
+    A = Indexed('A', i, i + j)
+    assert not iterable(A)
+
+
+def test_Indexed_coeff():
+    N = Symbol('N', integer=True)
+    len_y = N
+    i = Idx('i', len_y-1)
+    y = IndexedBase('y', shape=(len_y,))
+    a = (1/y[i+1]*y[i]).coeff(y[i])
+    b = (y[i]/y[i+1]).coeff(y[i])
+    assert a == b
+
+
+def test_differentiation():
+    from sympy.functions.special.tensor_functions import KroneckerDelta
+    i, j, k, l = symbols('i j k l', cls=Idx)
+    a = symbols('a')
+    m, n = symbols("m, n", integer=True, finite=True)
+    assert m.is_real
+    h, L = symbols('h L', cls=IndexedBase)
+    hi, hj = h[i], h[j]
+
+    expr = hi
+    assert expr.diff(hj) == KroneckerDelta(i, j)
+    assert expr.diff(hi) == KroneckerDelta(i, i)
+
+    expr = S(2) * hi
+    assert expr.diff(hj) == S(2) * KroneckerDelta(i, j)
+    assert expr.diff(hi) == S(2) * KroneckerDelta(i, i)
+    assert expr.diff(a) is S.Zero
+
+    assert Sum(expr, (i, -oo, oo)).diff(hj) == Sum(2*KroneckerDelta(i, j), (i, -oo, oo))
+    assert Sum(expr.diff(hj), (i, -oo, oo)) == Sum(2*KroneckerDelta(i, j), (i, -oo, oo))
+    assert Sum(expr, (i, -oo, oo)).diff(hj).doit() == 2
+
+    assert Sum(expr.diff(hi), (i, -oo, oo)).doit() == Sum(2, (i, -oo, oo)).doit()
+    assert Sum(expr, (i, -oo, oo)).diff(hi).doit() is oo
+
+    expr = a * hj * hj / S(2)
+    assert expr.diff(hi) == a * h[j] * KroneckerDelta(i, j)
+    assert expr.diff(a) == hj * hj / S(2)
+    assert expr.diff(a, 2) is S.Zero
+
+    assert Sum(expr, (i, -oo, oo)).diff(hi) == Sum(a*KroneckerDelta(i, j)*h[j], (i, -oo, oo))
+    assert Sum(expr.diff(hi), (i, -oo, oo)) == Sum(a*KroneckerDelta(i, j)*h[j], (i, -oo, oo))
+    assert Sum(expr, (i, -oo, oo)).diff(hi).doit() == a*h[j]
+
+    assert Sum(expr, (j, -oo, oo)).diff(hi) == Sum(a*KroneckerDelta(i, j)*h[j], (j, -oo, oo))
+    assert Sum(expr.diff(hi), (j, -oo, oo)) == Sum(a*KroneckerDelta(i, j)*h[j], (j, -oo, oo))
+    assert Sum(expr, (j, -oo, oo)).diff(hi).doit() == a*h[i]
+
+    expr = a * sin(hj * hj)
+    assert expr.diff(hi) == 2*a*cos(hj * hj) * hj * KroneckerDelta(i, j)
+    assert expr.diff(hj) == 2*a*cos(hj * hj) * hj
+
+    expr = a * L[i, j] * h[j]
+    assert expr.diff(hi) == a*L[i, j]*KroneckerDelta(i, j)
+    assert expr.diff(hj) == a*L[i, j]
+    assert expr.diff(L[i, j]) == a*h[j]
+    assert expr.diff(L[k, l]) == a*KroneckerDelta(i, k)*KroneckerDelta(j, l)*h[j]
+    assert expr.diff(L[i, l]) == a*KroneckerDelta(j, l)*h[j]
+
+    assert Sum(expr, (j, -oo, oo)).diff(L[k, l]) == Sum(a * KroneckerDelta(i, k) * KroneckerDelta(j, l) * h[j], (j, -oo, oo))
+    assert Sum(expr, (j, -oo, oo)).diff(L[k, l]).doit() == a * KroneckerDelta(i, k) * h[l]
+
+    assert h[m].diff(h[m]) == 1
+    assert h[m].diff(h[n]) == KroneckerDelta(m, n)
+    assert Sum(a*h[m], (m, -oo, oo)).diff(h[n]) == Sum(a*KroneckerDelta(m, n), (m, -oo, oo))
+    assert Sum(a*h[m], (m, -oo, oo)).diff(h[n]).doit() == a
+    assert Sum(a*h[m], (n, -oo, oo)).diff(h[n]) == Sum(a*KroneckerDelta(m, n), (n, -oo, oo))
+    assert Sum(a*h[m], (m, -oo, oo)).diff(h[m]).doit() == oo*a
+
+
+def test_indexed_series():
+    A = IndexedBase("A")
+    i = symbols("i", integer=True)
+    assert sin(A[i]).series(A[i]) == A[i] - A[i]**3/6 + A[i]**5/120 + Order(A[i]**6, A[i])
+
+
+def test_indexed_is_constant():
+    A = IndexedBase("A")
+    i, j, k = symbols("i,j,k")
+    assert not A[i].is_constant()
+    assert A[i].is_constant(j)
+    assert not A[1+2*i, k].is_constant()
+    assert not A[1+2*i, k].is_constant(i)
+    assert A[1+2*i, k].is_constant(j)
+    assert not A[1+2*i, k].is_constant(k)
+
+
+def test_issue_12533():
+    d = IndexedBase('d')
+    assert IndexedBase(range(5)) == Range(0, 5, 1)
+    assert d[0].subs(Symbol("d"), range(5)) == 0
+    assert d[0].subs(d, range(5)) == 0
+    assert d[1].subs(d, range(5)) == 1
+    assert Indexed(Range(5), 2) == 2
+
+
+def test_issue_12780():
+    n = symbols("n")
+    i = Idx("i", (0, n))
+    raises(TypeError, lambda: i.subs(n, 1.5))
+
+
+def test_issue_18604():
+    m = symbols("m")
+    assert Idx("i", m).name == 'i'
+    assert Idx("i", m).lower == 0
+    assert Idx("i", m).upper == m - 1
+    m = symbols("m", real=False)
+    raises(TypeError, lambda: Idx("i", m))
+
+def test_Subs_with_Indexed():
+    A = IndexedBase("A")
+    i, j, k = symbols("i,j,k")
+    x, y, z = symbols("x,y,z")
+    f = Function("f")
+
+    assert Subs(A[i], A[i], A[j]).diff(A[j]) == 1
+    assert Subs(A[i], A[i], x).diff(A[i]) == 0
+    assert Subs(A[i], A[i], x).diff(A[j]) == 0
+    assert Subs(A[i], A[i], x).diff(x) == 1
+    assert Subs(A[i], A[i], x).diff(y) == 0
+    assert Subs(A[i], A[i], A[j]).diff(A[k]) == KroneckerDelta(j, k)
+    assert Subs(x, x, A[i]).diff(A[j]) == KroneckerDelta(i, j)
+    assert Subs(f(A[i]), A[i], x).diff(A[j]) == 0
+    assert Subs(f(A[i]), A[i], A[k]).diff(A[j]) == Derivative(f(A[k]), A[k])*KroneckerDelta(j, k)
+    assert Subs(x, x, A[i]**2).diff(A[j]) == 2*KroneckerDelta(i, j)*A[i]
+    assert Subs(A[i], A[i], A[j]**2).diff(A[k]) == 2*KroneckerDelta(j, k)*A[j]
+
+    assert Subs(A[i]*x, x, A[i]).diff(A[i]) == 2*A[i]
+    assert Subs(A[i]*x, x, A[i]).diff(A[j]) == 2*A[i]*KroneckerDelta(i, j)
+    assert Subs(A[i]*x, x, A[j]).diff(A[i]) == A[j] + A[i]*KroneckerDelta(i, j)
+    assert Subs(A[i]*x, x, A[j]).diff(A[j]) == A[i] + A[j]*KroneckerDelta(i, j)
+    assert Subs(A[i]*x, x, A[i]).diff(A[k]) == 2*A[i]*KroneckerDelta(i, k)
+    assert Subs(A[i]*x, x, A[j]).diff(A[k]) == KroneckerDelta(i, k)*A[j] + KroneckerDelta(j, k)*A[i]
+
+    assert Subs(A[i]*x, A[i], x).diff(A[i]) == 0
+    assert Subs(A[i]*x, A[i], x).diff(A[j]) == 0
+    assert Subs(A[i]*x, A[j], x).diff(A[i]) == x
+    assert Subs(A[i]*x, A[j], x).diff(A[j]) == x*KroneckerDelta(i, j)
+    assert Subs(A[i]*x, A[i], x).diff(A[k]) == 0
+    assert Subs(A[i]*x, A[j], x).diff(A[k]) == x*KroneckerDelta(i, k)
+
+
+def test_complicated_derivative_with_Indexed():
+    x, y = symbols("x,y", cls=IndexedBase)
+    sigma = symbols("sigma")
+    i, j, k = symbols("i,j,k")
+    m0,m1,m2,m3,m4,m5 = symbols("m0:6")
+    f = Function("f")
+
+    expr = f((x[i] - y[i])**2/sigma)
+    _xi_1 = symbols("xi_1", cls=Dummy)
+    assert expr.diff(x[m0]).dummy_eq(
+        (x[i] - y[i])*KroneckerDelta(i, m0)*\
+        2*Subs(
+            Derivative(f(_xi_1), _xi_1),
+            (_xi_1,),
+            ((x[i] - y[i])**2/sigma,)
+        )/sigma
+    )
+    assert expr.diff(x[m0]).diff(x[m1]).dummy_eq(
+        2*KroneckerDelta(i, m0)*\
+        KroneckerDelta(i, m1)*Subs(
+            Derivative(f(_xi_1), _xi_1),
+            (_xi_1,),
+            ((x[i] - y[i])**2/sigma,)
+         )/sigma + \
+        4*(x[i] - y[i])**2*KroneckerDelta(i, m0)*KroneckerDelta(i, m1)*\
+        Subs(
+            Derivative(f(_xi_1), _xi_1, _xi_1),
+            (_xi_1,),
+            ((x[i] - y[i])**2/sigma,)
+        )/sigma**2
+    )
+
+
+def test_IndexedBase_commutative():
+    t = IndexedBase('t', commutative=False)
+    u = IndexedBase('u', commutative=False)
+    v = IndexedBase('v')
+    assert t[0]*v[0] == v[0]*t[0]
+    assert t[0]*u[0] != u[0]*t[0]
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/tests/test_printing.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/tests/test_printing.py
new file mode 100644
index 0000000000000000000000000000000000000000..9f3cf7f0591a7012c93354ab7b8d7e010def38bb
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/tests/test_printing.py
@@ -0,0 +1,13 @@
+from sympy.tensor.tensor import TensorIndexType, tensor_indices, TensorHead
+from sympy import I
+
+def test_printing_TensMul():
+    R3 = TensorIndexType('R3', dim=3)
+    p, q = tensor_indices("p q", R3)
+    K = TensorHead("K", [R3])
+
+    assert repr(2*K(p)) == "2*K(p)"
+    assert repr(-K(p)) == "-K(p)"
+    assert repr(-2*K(p)*K(q)) == "-2*K(p)*K(q)"
+    assert repr(-I*K(p)) == "-I*K(p)"
+    assert repr(I*K(p)) == "I*K(p)"
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/tests/test_tensor.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/tests/test_tensor.py
new file mode 100644
index 0000000000000000000000000000000000000000..3113f5be9bcd32224f3525b5d831b6d7476c39e3
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/tests/test_tensor.py
@@ -0,0 +1,2218 @@
+from sympy.concrete.summations import Sum
+from sympy.core.function import expand
+from sympy.core.numbers import Integer
+from sympy.matrices.dense import (Matrix, eye)
+from sympy.tensor.indexed import Indexed
+from sympy.combinatorics import Permutation
+from sympy.core import S, Rational, Symbol, Basic, Add, Wild, Function
+from sympy.core.containers import Tuple
+from sympy.core.symbol import symbols
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.integrals import integrate
+from sympy.tensor.array import Array
+from sympy.tensor.tensor import TensorIndexType, tensor_indices, TensorSymmetry, \
+    get_symmetric_group_sgs, TensorIndex, tensor_mul, TensAdd, \
+    riemann_cyclic_replace, riemann_cyclic, TensMul, tensor_heads, \
+    TensorManager, TensExpr, TensorHead, canon_bp, \
+    tensorhead, tensorsymmetry, TensorType, substitute_indices, \
+    WildTensorIndex, WildTensorHead, _WildTensExpr
+from sympy.testing.pytest import raises, XFAIL, warns_deprecated_sympy
+from sympy.matrices import diag
+
+def _is_equal(arg1, arg2):
+    if isinstance(arg1, TensExpr):
+        return arg1.equals(arg2)
+    elif isinstance(arg2, TensExpr):
+        return arg2.equals(arg1)
+    return arg1 == arg2
+
+
+#################### Tests from tensor_can.py #######################
+def test_canonicalize_no_slot_sym():
+    # A_d0 * B^d0; T_c = A^d0*B_d0
+    Lorentz = TensorIndexType('Lorentz', dummy_name='L')
+    a, b, d0, d1 = tensor_indices('a,b,d0,d1', Lorentz)
+    A, B = tensor_heads('A,B', [Lorentz], TensorSymmetry.no_symmetry(1))
+    t = A(-d0)*B(d0)
+    tc = t.canon_bp()
+    assert str(tc) == 'A(L_0)*B(-L_0)'
+
+    # A^a * B^b;  T_c = T
+    t = A(a)*B(b)
+    tc = t.canon_bp()
+    assert tc == t
+    # B^b * A^a
+    t1 = B(b)*A(a)
+    tc = t1.canon_bp()
+    assert str(tc) == 'A(a)*B(b)'
+
+    # A symmetric
+    # A^{b}_{d0}*A^{d0, a}; T_c = A^{a d0}*A{b}_{d0}
+    A = TensorHead('A', [Lorentz]*2, TensorSymmetry.fully_symmetric(2))
+    t = A(b, -d0)*A(d0, a)
+    tc = t.canon_bp()
+    assert str(tc) == 'A(a, L_0)*A(b, -L_0)'
+
+    # A^{d1}_{d0}*B^d0*C_d1
+    # T_c = A^{d0 d1}*B_d0*C_d1
+    B, C = tensor_heads('B,C', [Lorentz], TensorSymmetry.no_symmetry(1))
+    t = A(d1, -d0)*B(d0)*C(-d1)
+    tc = t.canon_bp()
+    assert str(tc) == 'A(L_0, L_1)*B(-L_0)*C(-L_1)'
+
+    # A without symmetry
+    # A^{d1}_{d0}*B^d0*C_d1 ord=[d0,-d0,d1,-d1]; g = [2,1,0,3,4,5]
+    # T_c = A^{d0 d1}*B_d1*C_d0; can = [0,2,3,1,4,5]
+    A = TensorHead('A', [Lorentz]*2, TensorSymmetry.no_symmetry(2))
+    t = A(d1, -d0)*B(d0)*C(-d1)
+    tc = t.canon_bp()
+    assert str(tc) == 'A(L_0, L_1)*B(-L_1)*C(-L_0)'
+
+    # A, B without symmetry
+    # A^{d1}_{d0}*B_{d1}^{d0}
+    # T_c = A^{d0 d1}*B_{d0 d1}
+    B = TensorHead('B', [Lorentz]*2, TensorSymmetry.no_symmetry(2))
+    t = A(d1, -d0)*B(-d1, d0)
+    tc = t.canon_bp()
+    assert str(tc) == 'A(L_0, L_1)*B(-L_0, -L_1)'
+    # A_{d0}^{d1}*B_{d1}^{d0}
+    # T_c = A^{d0 d1}*B_{d1 d0}
+    t = A(-d0, d1)*B(-d1, d0)
+    tc = t.canon_bp()
+    assert str(tc) == 'A(L_0, L_1)*B(-L_1, -L_0)'
+
+    # A, B, C without symmetry
+    # A^{d1 d0}*B_{a d0}*C_{d1 b}
+    # T_c=A^{d0 d1}*B_{a d1}*C_{d0 b}
+    C = TensorHead('C', [Lorentz]*2, TensorSymmetry.no_symmetry(2))
+    t = A(d1, d0)*B(-a, -d0)*C(-d1, -b)
+    tc = t.canon_bp()
+    assert str(tc) == 'A(L_0, L_1)*B(-a, -L_1)*C(-L_0, -b)'
+
+    # A symmetric, B and C without symmetry
+    # A^{d1 d0}*B_{a d0}*C_{d1 b}
+    # T_c = A^{d0 d1}*B_{a d0}*C_{d1 b}
+    A = TensorHead('A', [Lorentz]*2, TensorSymmetry.fully_symmetric(2))
+    t = A(d1, d0)*B(-a, -d0)*C(-d1, -b)
+    tc = t.canon_bp()
+    assert str(tc) == 'A(L_0, L_1)*B(-a, -L_0)*C(-L_1, -b)'
+
+    # A and C symmetric, B without symmetry
+    # A^{d1 d0}*B_{a d0}*C_{d1 b} ord=[a,b,d0,-d0,d1,-d1]
+    # T_c = A^{d0 d1}*B_{a d0}*C_{b d1}
+    C = TensorHead('C', [Lorentz]*2, TensorSymmetry.fully_symmetric(2))
+    t = A(d1, d0)*B(-a, -d0)*C(-d1, -b)
+    tc = t.canon_bp()
+    assert str(tc) == 'A(L_0, L_1)*B(-a, -L_0)*C(-b, -L_1)'
+
+def test_canonicalize_no_dummies():
+    Lorentz = TensorIndexType('Lorentz', dummy_name='L')
+    a, b, c, d = tensor_indices('a, b, c, d', Lorentz)
+
+    # A commuting
+    # A^c A^b A^a
+    # T_c = A^a A^b A^c
+    A = TensorHead('A', [Lorentz], TensorSymmetry.no_symmetry(1))
+    t = A(c)*A(b)*A(a)
+    tc = t.canon_bp()
+    assert str(tc) == 'A(a)*A(b)*A(c)'
+
+    # A anticommuting
+    # A^c A^b A^a
+    # T_c = -A^a A^b A^c
+    A = TensorHead('A', [Lorentz], TensorSymmetry.no_symmetry(1), 1)
+    t = A(c)*A(b)*A(a)
+    tc = t.canon_bp()
+    assert str(tc) == '-A(a)*A(b)*A(c)'
+
+    # A commuting and symmetric
+    # A^{b,d}*A^{c,a}
+    # T_c = A^{a c}*A^{b d}
+    A = TensorHead('A', [Lorentz]*2, TensorSymmetry.fully_symmetric(2))
+    t = A(b, d)*A(c, a)
+    tc = t.canon_bp()
+    assert str(tc) == 'A(a, c)*A(b, d)'
+
+    # A anticommuting and symmetric
+    # A^{b,d}*A^{c,a}
+    # T_c = -A^{a c}*A^{b d}
+    A = TensorHead('A', [Lorentz]*2, TensorSymmetry.fully_symmetric(2), 1)
+    t = A(b, d)*A(c, a)
+    tc = t.canon_bp()
+    assert str(tc) == '-A(a, c)*A(b, d)'
+
+    # A^{c,a}*A^{b,d}
+    # T_c = A^{a c}*A^{b d}
+    t = A(c, a)*A(b, d)
+    tc = t.canon_bp()
+    assert str(tc) == 'A(a, c)*A(b, d)'
+
+def test_tensorhead_construction_without_symmetry():
+    L = TensorIndexType('Lorentz')
+    A1 = TensorHead('A', [L, L])
+    A2 = TensorHead('A', [L, L], TensorSymmetry.no_symmetry(2))
+    assert A1 == A2
+    A3 = TensorHead('A', [L, L], TensorSymmetry.fully_symmetric(2))  # Symmetric
+    assert A1 != A3
+
+def test_no_metric_symmetry():
+    # no metric symmetry; A no symmetry
+    # A^d1_d0 * A^d0_d1
+    # T_c = A^d0_d1 * A^d1_d0
+    Lorentz = TensorIndexType('Lorentz', dummy_name='L', metric_symmetry=0)
+    d0, d1, d2, d3 = tensor_indices('d:4', Lorentz)
+    A = TensorHead('A', [Lorentz]*2, TensorSymmetry.no_symmetry(2))
+    t = A(d1, -d0)*A(d0, -d1)
+    tc = t.canon_bp()
+    assert str(tc) == 'A(L_0, -L_1)*A(L_1, -L_0)'
+
+    # A^d1_d2 * A^d0_d3 * A^d2_d1 * A^d3_d0
+    # T_c = A^d0_d1 * A^d1_d0 * A^d2_d3 * A^d3_d2
+    t = A(d1, -d2)*A(d0, -d3)*A(d2, -d1)*A(d3, -d0)
+    tc = t.canon_bp()
+    assert str(tc) == 'A(L_0, -L_1)*A(L_1, -L_0)*A(L_2, -L_3)*A(L_3, -L_2)'
+
+    # A^d0_d2 * A^d1_d3 * A^d3_d0 * A^d2_d1
+    # T_c = A^d0_d1 * A^d1_d2 * A^d2_d3 * A^d3_d0
+    t = A(d0, -d1)*A(d1, -d2)*A(d2, -d3)*A(d3, -d0)
+    tc = t.canon_bp()
+    assert str(tc) == 'A(L_0, -L_1)*A(L_1, -L_2)*A(L_2, -L_3)*A(L_3, -L_0)'
+
+def test_canonicalize1():
+    Lorentz = TensorIndexType('Lorentz', dummy_name='L')
+    a, a0, a1, a2, a3, b, d0, d1, d2, d3 = \
+        tensor_indices('a,a0,a1,a2,a3,b,d0,d1,d2,d3', Lorentz)
+
+    # A_d0*A^d0; ord = [d0,-d0]
+    # T_c = A^d0*A_d0
+    A = TensorHead('A', [Lorentz], TensorSymmetry.no_symmetry(1))
+    t = A(-d0)*A(d0)
+    tc = t.canon_bp()
+    assert str(tc) == 'A(L_0)*A(-L_0)'
+
+    # A commuting
+    # A_d0*A_d1*A_d2*A^d2*A^d1*A^d0
+    # T_c = A^d0*A_d0*A^d1*A_d1*A^d2*A_d2
+    t = A(-d0)*A(-d1)*A(-d2)*A(d2)*A(d1)*A(d0)
+    tc = t.canon_bp()
+    assert str(tc) == 'A(L_0)*A(-L_0)*A(L_1)*A(-L_1)*A(L_2)*A(-L_2)'
+
+    # A anticommuting
+    # A_d0*A_d1*A_d2*A^d2*A^d1*A^d0
+    # T_c 0
+    A = TensorHead('A', [Lorentz], TensorSymmetry.no_symmetry(1), 1)
+    t = A(-d0)*A(-d1)*A(-d2)*A(d2)*A(d1)*A(d0)
+    tc = t.canon_bp()
+    assert tc == 0
+
+    # A commuting symmetric
+    # A^{d0 b}*A^a_d1*A^d1_d0
+    # T_c = A^{a d0}*A^{b d1}*A_{d0 d1}
+    A = TensorHead('A', [Lorentz]*2, TensorSymmetry.fully_symmetric(2))
+    t = A(d0, b)*A(a, -d1)*A(d1, -d0)
+    tc = t.canon_bp()
+    assert str(tc) == 'A(a, L_0)*A(b, L_1)*A(-L_0, -L_1)'
+
+    # A, B commuting symmetric
+    # A^{d0 b}*A^d1_d0*B^a_d1
+    # T_c = A^{b d0}*A_d0^d1*B^a_d1
+    B = TensorHead('B', [Lorentz]*2, TensorSymmetry.fully_symmetric(2))
+    t = A(d0, b)*A(d1, -d0)*B(a, -d1)
+    tc = t.canon_bp()
+    assert str(tc) == 'A(b, L_0)*A(-L_0, L_1)*B(a, -L_1)'
+
+    # A commuting symmetric
+    # A^{d1 d0 b}*A^{a}_{d1 d0}; ord=[a,b, d0,-d0,d1,-d1]
+    # T_c = A^{a d0 d1}*A^{b}_{d0 d1}
+    A = TensorHead('A', [Lorentz]*3, TensorSymmetry.fully_symmetric(3))
+    t = A(d1, d0, b)*A(a, -d1, -d0)
+    tc = t.canon_bp()
+    assert str(tc) == 'A(a, L_0, L_1)*A(b, -L_0, -L_1)'
+
+    # A^{d3 d0 d2}*A^a0_{d1 d2}*A^d1_d3^a1*A^{a2 a3}_d0
+    # T_c = A^{a0 d0 d1}*A^a1_d0^d2*A^{a2 a3 d3}*A_{d1 d2 d3}
+    t = A(d3, d0, d2)*A(a0, -d1, -d2)*A(d1, -d3, a1)*A(a2, a3, -d0)
+    tc = t.canon_bp()
+    assert str(tc) == 'A(a0, L_0, L_1)*A(a1, -L_0, L_2)*A(a2, a3, L_3)*A(-L_1, -L_2, -L_3)'
+
+    # A commuting symmetric, B antisymmetric
+    # A^{d0 d1 d2} * A_{d2 d3 d1} * B_d0^d3
+    # in this esxample and in the next three,
+    # renaming dummy indices and using symmetry of A,
+    # T = A^{d0 d1 d2} * A_{d0 d1 d3} * B_d2^d3
+    # can = 0
+    A = TensorHead('A', [Lorentz]*3, TensorSymmetry.fully_symmetric(3))
+    B = TensorHead('B', [Lorentz]*2, TensorSymmetry.fully_symmetric(-2))
+    t = A(d0, d1, d2)*A(-d2, -d3, -d1)*B(-d0, d3)
+    tc = t.canon_bp()
+    assert tc == 0
+
+    # A anticommuting symmetric, B antisymmetric
+    # A^{d0 d1 d2} * A_{d2 d3 d1} * B_d0^d3
+    # T_c = A^{d0 d1 d2} * A_{d0 d1}^d3 * B_{d2 d3}
+    A = TensorHead('A', [Lorentz]*3, TensorSymmetry.fully_symmetric(3), 1)
+    B = TensorHead('B', [Lorentz]*2, TensorSymmetry.fully_symmetric(-2))
+    t = A(d0, d1, d2)*A(-d2, -d3, -d1)*B(-d0, d3)
+    tc = t.canon_bp()
+    assert str(tc) == 'A(L_0, L_1, L_2)*A(-L_0, -L_1, L_3)*B(-L_2, -L_3)'
+
+    # A anticommuting symmetric, B antisymmetric commuting, antisymmetric metric
+    # A^{d0 d1 d2} * A_{d2 d3 d1} * B_d0^d3
+    # T_c = -A^{d0 d1 d2} * A_{d0 d1}^d3 * B_{d2 d3}
+    Spinor = TensorIndexType('Spinor', dummy_name='S', metric_symmetry=-1)
+    a, a0, a1, a2, a3, b, d0, d1, d2, d3 = \
+        tensor_indices('a,a0,a1,a2,a3,b,d0,d1,d2,d3', Spinor)
+    A = TensorHead('A', [Spinor]*3, TensorSymmetry.fully_symmetric(3), 1)
+    B = TensorHead('B', [Spinor]*2, TensorSymmetry.fully_symmetric(-2))
+    t = A(d0, d1, d2)*A(-d2, -d3, -d1)*B(-d0, d3)
+    tc = t.canon_bp()
+    assert str(tc) == '-A(S_0, S_1, S_2)*A(-S_0, -S_1, S_3)*B(-S_2, -S_3)'
+
+    # A anticommuting symmetric, B antisymmetric anticommuting,
+    # no metric symmetry
+    # A^{d0 d1 d2} * A_{d2 d3 d1} * B_d0^d3
+    # T_c = A^{d0 d1 d2} * A_{d0 d1 d3} * B_d2^d3
+    Mat = TensorIndexType('Mat', metric_symmetry=0, dummy_name='M')
+    a, a0, a1, a2, a3, b, d0, d1, d2, d3 = \
+        tensor_indices('a,a0,a1,a2,a3,b,d0,d1,d2,d3', Mat)
+    A = TensorHead('A', [Mat]*3, TensorSymmetry.fully_symmetric(3), 1)
+    B = TensorHead('B', [Mat]*2, TensorSymmetry.fully_symmetric(-2))
+    t = A(d0, d1, d2)*A(-d2, -d3, -d1)*B(-d0, d3)
+    tc = t.canon_bp()
+    assert str(tc) == 'A(M_0, M_1, M_2)*A(-M_0, -M_1, -M_3)*B(-M_2, M_3)'
+
+    # Gamma anticommuting
+    # Gamma_{mu nu} * gamma^rho * Gamma^{nu mu alpha}
+    # T_c = -Gamma^{mu nu} * gamma^rho * Gamma_{alpha mu nu}
+    alpha, beta, gamma, mu, nu, rho = \
+        tensor_indices('alpha,beta,gamma,mu,nu,rho', Lorentz)
+    Gamma = TensorHead('Gamma', [Lorentz],
+                       TensorSymmetry.fully_symmetric(1), 2)
+    Gamma2 = TensorHead('Gamma', [Lorentz]*2,
+                        TensorSymmetry.fully_symmetric(-2), 2)
+    Gamma3 = TensorHead('Gamma', [Lorentz]*3,
+                        TensorSymmetry.fully_symmetric(-3), 2)
+    t = Gamma2(-mu, -nu)*Gamma(rho)*Gamma3(nu, mu, alpha)
+    tc = t.canon_bp()
+    assert str(tc) == '-Gamma(L_0, L_1)*Gamma(rho)*Gamma(alpha, -L_0, -L_1)'
+
+    # Gamma_{mu nu} * Gamma^{gamma beta} * gamma_rho * Gamma^{nu mu alpha}
+    # T_c = Gamma^{mu nu} * Gamma^{beta gamma} * gamma_rho * Gamma^alpha_{mu nu}
+    t = Gamma2(mu, nu)*Gamma2(beta, gamma)*Gamma(-rho)*Gamma3(alpha, -mu, -nu)
+    tc = t.canon_bp()
+    assert str(tc) == 'Gamma(L_0, L_1)*Gamma(beta, gamma)*Gamma(-rho)*Gamma(alpha, -L_0, -L_1)'
+
+    # f^a_{b,c} antisymmetric in b,c; A_mu^a no symmetry
+    # f^c_{d a} * f_{c e b} * A_mu^d * A_nu^a * A^{nu e} * A^{mu b}
+    # g = [8,11,5, 9,13,7, 1,10, 3,4, 2,12, 0,6, 14,15]
+    # T_c = -f^{a b c} * f_a^{d e} * A^mu_b * A_{mu d} * A^nu_c * A_{nu e}
+    Flavor = TensorIndexType('Flavor', dummy_name='F')
+    a, b, c, d, e, ff = tensor_indices('a,b,c,d,e,f', Flavor)
+    mu, nu = tensor_indices('mu,nu', Lorentz)
+    f = TensorHead('f', [Flavor]*3, TensorSymmetry.direct_product(1, -2))
+    A = TensorHead('A', [Lorentz, Flavor], TensorSymmetry.no_symmetry(2))
+    t = f(c, -d, -a)*f(-c, -e, -b)*A(-mu, d)*A(-nu, a)*A(nu, e)*A(mu, b)
+    tc = t.canon_bp()
+    assert str(tc) == '-f(F_0, F_1, F_2)*f(-F_0, F_3, F_4)*A(L_0, -F_1)*A(-L_0, -F_3)*A(L_1, -F_2)*A(-L_1, -F_4)'
+
+
+def test_bug_correction_tensor_indices():
+    # to make sure that tensor_indices does not return a list if creating
+    # only one index:
+    A = TensorIndexType("A")
+    i = tensor_indices('i', A)
+    assert not isinstance(i, (tuple, list))
+    assert isinstance(i, TensorIndex)
+
+
+def test_riemann_invariants():
+    Lorentz = TensorIndexType('Lorentz', dummy_name='L')
+    d0, d1, d2, d3, d4, d5, d6, d7, d8, d9, d10, d11 = \
+        tensor_indices('d0:12', Lorentz)
+    # R^{d0 d1}_{d1 d0}; ord = [d0,-d0,d1,-d1]
+    # T_c = -R^{d0 d1}_{d0 d1}
+    R = TensorHead('R', [Lorentz]*4, TensorSymmetry.riemann())
+    t = R(d0, d1, -d1, -d0)
+    tc = t.canon_bp()
+    assert str(tc) == '-R(L_0, L_1, -L_0, -L_1)'
+
+    # R_d11^d1_d0^d5 * R^{d6 d4 d0}_d5 * R_{d7 d2 d8 d9} *
+    # R_{d10 d3 d6 d4} * R^{d2 d7 d11}_d1 * R^{d8 d9 d3 d10}
+    # can = [0,2,4,6, 1,3,8,10, 5,7,12,14, 9,11,16,18, 13,15,20,22,
+    #        17,19,21<F10,23, 24,25]
+    # T_c = R^{d0 d1 d2 d3} * R_{d0 d1}^{d4 d5} * R_{d2 d3}^{d6 d7} *
+    # R_{d4 d5}^{d8 d9} * R_{d6 d7}^{d10 d11} * R_{d8 d9 d10 d11}
+
+    t = R(-d11,d1,-d0,d5)*R(d6,d4,d0,-d5)*R(-d7,-d2,-d8,-d9)* \
+        R(-d10,-d3,-d6,-d4)*R(d2,d7,d11,-d1)*R(d8,d9,d3,d10)
+    tc = t.canon_bp()
+    assert str(tc) == 'R(L_0, L_1, L_2, L_3)*R(-L_0, -L_1, L_4, L_5)*R(-L_2, -L_3, L_6, L_7)*R(-L_4, -L_5, L_8, L_9)*R(-L_6, -L_7, L_10, L_11)*R(-L_8, -L_9, -L_10, -L_11)'
+
+def test_riemann_products():
+    Lorentz = TensorIndexType('Lorentz', dummy_name='L')
+    d0, d1, d2, d3, d4, d5, d6 = tensor_indices('d0:7', Lorentz)
+    a0, a1, a2, a3, a4, a5 = tensor_indices('a0:6', Lorentz)
+    a, b = tensor_indices('a,b', Lorentz)
+    R = TensorHead('R', [Lorentz]*4, TensorSymmetry.riemann())
+    # R^{a b d0}_d0 = 0
+    t = R(a, b, d0, -d0)
+    tc = t.canon_bp()
+    assert tc == 0
+
+    # R^{d0 b a}_d0
+    # T_c = -R^{a d0 b}_d0
+    t = R(d0, b, a, -d0)
+    tc = t.canon_bp()
+    assert str(tc) == '-R(a, L_0, b, -L_0)'
+
+    # R^d1_d2^b_d0 * R^{d0 a}_d1^d2; ord=[a,b,d0,-d0,d1,-d1,d2,-d2]
+    # T_c = -R^{a d0 d1 d2}* R^b_{d0 d1 d2}
+    t = R(d1, -d2, b, -d0)*R(d0, a, -d1, d2)
+    tc = t.canon_bp()
+    assert str(tc) == '-R(a, L_0, L_1, L_2)*R(b, -L_0, -L_1, -L_2)'
+
+    # A symmetric commuting
+    # R^{d6 d5}_d2^d1 * R^{d4 d0 d2 d3} * A_{d6 d0} A_{d3 d1} * A_{d4 d5}
+    # g = [12,10,5,2, 8,0,4,6, 13,1, 7,3, 9,11,14,15]
+    # T_c = -R^{d0 d1 d2 d3} * R_d0^{d4 d5 d6} * A_{d1 d4}*A_{d2 d5}*A_{d3 d6}
+    V = TensorHead('V', [Lorentz]*2, TensorSymmetry.fully_symmetric(2))
+    t = R(d6, d5, -d2, d1)*R(d4, d0, d2, d3)*V(-d6, -d0)*V(-d3, -d1)*V(-d4, -d5)
+    tc = t.canon_bp()
+    assert str(tc) == '-R(L_0, L_1, L_2, L_3)*R(-L_0, L_4, L_5, L_6)*V(-L_1, -L_4)*V(-L_2, -L_5)*V(-L_3, -L_6)'
+
+    # R^{d2 a0 a2 d0} * R^d1_d2^{a1 a3} * R^{a4 a5}_{d0 d1}
+    # T_c = R^{a0 d0 a2 d1}*R^{a1 a3}_d0^d2*R^{a4 a5}_{d1 d2}
+    t = R(d2, a0, a2, d0)*R(d1, -d2, a1, a3)*R(a4, a5, -d0, -d1)
+    tc = t.canon_bp()
+    assert str(tc) == 'R(a0, L_0, a2, L_1)*R(a1, a3, -L_0, L_2)*R(a4, a5, -L_1, -L_2)'
+######################################################################
+
+
+def test_canonicalize2():
+    D = Symbol('D')
+    Eucl = TensorIndexType('Eucl', metric_symmetry=1, dim=D, dummy_name='E')
+    i0,i1,i2,i3,i4,i5,i6,i7,i8,i9,i10,i11,i12,i13,i14 = \
+        tensor_indices('i0:15', Eucl)
+    A = TensorHead('A', [Eucl]*3, TensorSymmetry.fully_symmetric(-3))
+
+    # two examples from Cvitanovic, Group Theory page 59
+    # of identities for antisymmetric tensors of rank 3
+    # contracted according to the Kuratowski graph  eq.(6.59)
+    t = A(i0,i1,i2)*A(-i1,i3,i4)*A(-i3,i7,i5)*A(-i2,-i5,i6)*A(-i4,-i6,i8)
+    t1 = t.canon_bp()
+    assert t1 == 0
+
+    # eq.(6.60)
+    #t = A(i0,i1,i2)*A(-i1,i3,i4)*A(-i2,i5,i6)*A(-i3,i7,i8)*A(-i6,-i7,i9)*
+    #    A(-i8,i10,i13)*A(-i5,-i10,i11)*A(-i4,-i11,i12)*A(-i3,-i12,i14)
+    t = A(i0,i1,i2)*A(-i1,i3,i4)*A(-i2,i5,i6)*A(-i3,i7,i8)*A(-i6,-i7,i9)*\
+        A(-i8,i10,i13)*A(-i5,-i10,i11)*A(-i4,-i11,i12)*A(-i9,-i12,i14)
+    t1 = t.canon_bp()
+    assert t1 == 0
+
+def test_canonicalize3():
+    D = Symbol('D')
+    Spinor = TensorIndexType('Spinor', dim=D, metric_symmetry=-1, dummy_name='S')
+    a0,a1,a2,a3,a4 = tensor_indices('a0:5', Spinor)
+    chi, psi = tensor_heads('chi,psi', [Spinor], TensorSymmetry.no_symmetry(1), 1)
+
+    t = chi(a1)*psi(a0)
+    t1 = t.canon_bp()
+    assert t1 == t
+
+    t = psi(a1)*chi(a0)
+    t1 = t.canon_bp()
+    assert t1 == -chi(a0)*psi(a1)
+
+def test_canonicalize4():
+    #Check whether TensAdd.canon_bp chokes on a case where the type of the expression changes on calling expand
+    Cartesian = TensorIndexType('Cartesian', dim=3)
+    p = tensor_indices("p", Cartesian)
+    K = TensorHead("K", [Cartesian])
+    expr = TensAdd( K(p) , - 2*K(p) )
+    assert expr.canon_bp() == -K(p)
+
+def test_canonicalize5():
+    R3 = TensorIndexType('R3', dim=3)
+    p = tensor_indices("p", R3)
+    K = TensorHead("K", [R3])
+    f = symbols("f", cls=Function)
+    x = symbols("x")
+
+    expr = integrate(f(x), (x,0,1)) * K(p)
+    assert expr.as_dummy().canon_bp() == integrate(f(x), (x,0,1)).as_dummy() * K(p)
+
+def test_TensorIndexType():
+    D = Symbol('D')
+    Lorentz = TensorIndexType('Lorentz', metric_name='g', metric_symmetry=1,
+                              dim=D, dummy_name='L')
+    m0, m1, m2, m3, m4 = tensor_indices('m0:5', Lorentz)
+    sym2 = TensorSymmetry.fully_symmetric(2)
+    sym2n = TensorSymmetry(*get_symmetric_group_sgs(2))
+    assert sym2 == sym2n
+    g = Lorentz.metric
+    assert str(g) == 'g(Lorentz,Lorentz)'
+    assert Lorentz.eps_dim == Lorentz.dim
+
+    TSpace = TensorIndexType('TSpace', dummy_name = 'TSpace')
+    i0, i1 = tensor_indices('i0 i1', TSpace)
+    g = TSpace.metric
+    A = TensorHead('A', [TSpace]*2, sym2)
+    assert str(A(i0,-i0).canon_bp()) == 'A(TSpace_0, -TSpace_0)'
+
+def test_indices():
+    Lorentz = TensorIndexType('Lorentz', dummy_name='L')
+    a, b, c, d = tensor_indices('a,b,c,d', Lorentz)
+    assert a.tensor_index_type == Lorentz
+    assert a != -a
+    A, B = tensor_heads('A B', [Lorentz]*2, TensorSymmetry.fully_symmetric(2))
+    t = A(a,b)*B(-b,c)
+    indices = t.get_indices()
+    L_0 = TensorIndex('L_0', Lorentz)
+    assert indices == [a, L_0, -L_0, c]
+    raises(ValueError, lambda: tensor_indices(3, Lorentz))
+    raises(ValueError, lambda: A(a,b,c))
+
+    A = TensorHead('A', [Lorentz, Lorentz])
+    assert A('a', 'b') == A(TensorIndex('a', Lorentz),
+                            TensorIndex('b', Lorentz))
+    assert A('a', '-b') == A(TensorIndex('a', Lorentz),
+                             TensorIndex('b', Lorentz, is_up=False))
+    assert A('a', TensorIndex('b', Lorentz)) == A(TensorIndex('a', Lorentz),
+                                                  TensorIndex('b', Lorentz))
+
+def test_TensorSymmetry():
+    assert TensorSymmetry.fully_symmetric(2) == \
+        TensorSymmetry(get_symmetric_group_sgs(2))
+    assert TensorSymmetry.fully_symmetric(-3) == \
+        TensorSymmetry(get_symmetric_group_sgs(3, True))
+    assert TensorSymmetry.direct_product(-4) == \
+        TensorSymmetry.fully_symmetric(-4)
+    assert TensorSymmetry.fully_symmetric(-1) == \
+        TensorSymmetry.fully_symmetric(1)
+    assert TensorSymmetry.direct_product(1, -1, 1) == \
+        TensorSymmetry.no_symmetry(3)
+    assert TensorSymmetry(get_symmetric_group_sgs(2)) == \
+        TensorSymmetry(*get_symmetric_group_sgs(2))
+    # TODO: add check for *get_symmetric_group_sgs(0)
+    sym = TensorSymmetry.fully_symmetric(-3)
+    assert sym.rank == 3
+    assert sym.base == Tuple(0, 1)
+    assert sym.generators == Tuple(Permutation(0, 1)(3, 4), Permutation(1, 2)(3, 4))
+
+def test_TensExpr():
+    Lorentz = TensorIndexType('Lorentz', dummy_name='L')
+    a, b, c, d = tensor_indices('a,b,c,d', Lorentz)
+    g = Lorentz.metric
+    A, B = tensor_heads('A B', [Lorentz]*2, TensorSymmetry.fully_symmetric(2))
+    raises(ValueError, lambda: g(c, d)/g(a, b))
+    raises(ValueError, lambda: S.One/g(a, b))
+    raises(ValueError, lambda: (A(c, d) + g(c, d))/g(a, b))
+    raises(ValueError, lambda: S.One/(A(c, d) + g(c, d)))
+    raises(ValueError, lambda: A(a, b) + A(a, c))
+
+    #t = A(a, b) + B(a, b) # assigned to t for below
+    #raises(NotImplementedError, lambda: TensExpr.__mul__(t, 'a'))
+    #raises(NotImplementedError, lambda: TensExpr.__add__(t, 'a'))
+    #raises(NotImplementedError, lambda: TensExpr.__radd__(t, 'a'))
+    #raises(NotImplementedError, lambda: TensExpr.__sub__(t, 'a'))
+    #raises(NotImplementedError, lambda: TensExpr.__rsub__(t, 'a'))
+    #raises(NotImplementedError, lambda: TensExpr.__truediv__(t, 'a'))
+    #raises(NotImplementedError, lambda: TensExpr.__rtruediv__(t, 'a'))
+    with warns_deprecated_sympy():
+        # DO NOT REMOVE THIS AFTER DEPRECATION REMOVED:
+        raises(ValueError, lambda: A(a, b)**2)
+    raises(NotImplementedError, lambda: 2**A(a, b))
+    raises(NotImplementedError, lambda: abs(A(a, b)))
+
+def test_TensorHead():
+    # simple example of algebraic expression
+    Lorentz = TensorIndexType('Lorentz', dummy_name='L')
+    A = TensorHead('A', [Lorentz]*2)
+    assert A.name == 'A'
+    assert A.index_types == [Lorentz, Lorentz]
+    assert A.rank == 2
+    assert A.symmetry == TensorSymmetry.no_symmetry(2)
+    assert A.comm == 0
+
+
+def test_add1():
+    assert TensAdd().args == ()
+    assert TensAdd().doit() == 0
+    # simple example of algebraic expression
+    Lorentz = TensorIndexType('Lorentz', dummy_name='L')
+    a,b,d0,d1,i,j,k = tensor_indices('a,b,d0,d1,i,j,k', Lorentz)
+    # A, B symmetric
+    A, B = tensor_heads('A,B', [Lorentz]*2, TensorSymmetry.fully_symmetric(2))
+    t1 = A(b, -d0)*B(d0, a)
+    assert TensAdd(t1).equals(t1)
+    t2a = B(d0, a) + A(d0, a)
+    t2 = A(b, -d0)*t2a
+    assert str(t2) == 'A(b, -L_0)*(A(L_0, a) + B(L_0, a))'
+    t2 = t2.expand()
+    assert str(t2) == 'A(b, -L_0)*A(L_0, a) + A(b, -L_0)*B(L_0, a)'
+    t2 = t2.canon_bp()
+    assert str(t2) == 'A(a, L_0)*A(b, -L_0) + A(b, L_0)*B(a, -L_0)'
+    t2b = t2 + t1
+    assert str(t2b) == 'A(a, L_0)*A(b, -L_0) + A(b, -L_0)*B(L_0, a) + A(b, L_0)*B(a, -L_0)'
+    t2b = t2b.canon_bp()
+    assert str(t2b) == 'A(a, L_0)*A(b, -L_0) + 2*A(b, L_0)*B(a, -L_0)'
+    p, q, r = tensor_heads('p,q,r', [Lorentz])
+    t = q(d0)*2
+    assert str(t) == '2*q(d0)'
+    t = 2*q(d0)
+    assert str(t) == '2*q(d0)'
+    t1 = p(d0) + 2*q(d0)
+    assert str(t1) == '2*q(d0) + p(d0)'
+    t2 = p(-d0) + 2*q(-d0)
+    assert str(t2) == '2*q(-d0) + p(-d0)'
+    t1 = p(d0)
+    t3 = t1*t2
+    assert str(t3) == 'p(L_0)*(2*q(-L_0) + p(-L_0))'
+    t3 = t3.expand()
+    assert str(t3) == 'p(L_0)*p(-L_0) + 2*p(L_0)*q(-L_0)'
+    t3 = t2*t1
+    t3 = t3.expand()
+    assert str(t3) == 'p(-L_0)*p(L_0) + 2*q(-L_0)*p(L_0)'
+    t3 = t3.canon_bp()
+    assert str(t3) == 'p(L_0)*p(-L_0) + 2*p(L_0)*q(-L_0)'
+    t1 = p(d0) + 2*q(d0)
+    t3 = t1*t2
+    t3 = t3.canon_bp()
+    assert str(t3) == 'p(L_0)*p(-L_0) + 4*p(L_0)*q(-L_0) + 4*q(L_0)*q(-L_0)'
+    t1 = p(d0) - 2*q(d0)
+    assert str(t1) == '-2*q(d0) + p(d0)'
+    t2 = p(-d0) + 2*q(-d0)
+    t3 = t1*t2
+    t3 = t3.canon_bp()
+    assert t3 == p(d0)*p(-d0) - 4*q(d0)*q(-d0)
+    t = p(i)*p(j)*(p(k) + q(k)) + p(i)*(p(j) + q(j))*(p(k) - 3*q(k))
+    t = t.canon_bp()
+    assert t == 2*p(i)*p(j)*p(k) - 2*p(i)*p(j)*q(k) + p(i)*p(k)*q(j) - 3*p(i)*q(j)*q(k)
+    t1 = (p(i) + q(i) + 2*r(i))*(p(j) - q(j))
+    t2 = (p(j) + q(j) + 2*r(j))*(p(i) - q(i))
+    t = t1 + t2
+    t = t.canon_bp()
+    assert t == 2*p(i)*p(j) + 2*p(i)*r(j) + 2*p(j)*r(i) - 2*q(i)*q(j) - 2*q(i)*r(j) - 2*q(j)*r(i)
+    t = p(i)*q(j)/2
+    assert 2*t == p(i)*q(j)
+    t = (p(i) + q(i))/2
+    assert 2*t == p(i) + q(i)
+
+    t = S.One - p(i)*p(-i)
+    t = t.canon_bp()
+    tz1 = t + p(-j)*p(j)
+    assert tz1 != 1
+    tz1 = tz1.canon_bp()
+    assert tz1.equals(1)
+    t = S.One + p(i)*p(-i)
+    assert (t - p(-j)*p(j)).canon_bp().equals(1)
+
+    t = A(a, b) + B(a, b)
+    assert t.rank == 2
+    t1 = t - A(a, b) - B(a, b)
+    assert t1 == 0
+    t = 1 - (A(a, -a) + B(a, -a))
+    t1 = 1 + (A(a, -a) + B(a, -a))
+    assert (t + t1).expand().equals(2)
+    t2 = 1 + A(a, -a)
+    assert t1 != t2
+    assert t2 != TensMul.from_data(0, [], [], [])
+
+    #Test whether TensAdd.doit chokes on subterms that are zero.
+    assert TensAdd(p(a), TensMul(0, p(a)) ).doit() == p(a)
+
+def test_special_eq_ne():
+    # test special equality cases:
+    Lorentz = TensorIndexType('Lorentz', dummy_name='L')
+    a, b, d0, d1, i, j, k = tensor_indices('a,b,d0,d1,i,j,k', Lorentz)
+    # A, B symmetric
+    A, B = tensor_heads('A,B', [Lorentz]*2, TensorSymmetry.fully_symmetric(2))
+    p, q, r = tensor_heads('p,q,r', [Lorentz])
+
+    t = 0*A(a, b)
+    assert _is_equal(t, 0)
+    assert _is_equal(t, S.Zero)
+
+    assert p(i) != A(a, b)
+    assert A(a, -a) != A(a, b)
+    assert 0*(A(a, b) + B(a, b)) == 0
+    assert 0*(A(a, b) + B(a, b)) is S.Zero
+
+    assert 3*(A(a, b) - A(a, b)) is S.Zero
+
+    assert p(i) + q(i) != A(a, b)
+    assert p(i) + q(i) != A(a, b) + B(a, b)
+
+    assert p(i) - p(i) == 0
+    assert p(i) - p(i) is S.Zero
+
+    assert _is_equal(A(a, b), A(b, a))
+
+def test_add2():
+    Lorentz = TensorIndexType('Lorentz', dummy_name='L')
+    m, n, p, q = tensor_indices('m,n,p,q', Lorentz)
+    R = TensorHead('R', [Lorentz]*4, TensorSymmetry.riemann())
+    A = TensorHead('A', [Lorentz]*3, TensorSymmetry.fully_symmetric(-3))
+    t1 = 2*R(m, n, p, q) - R(m, q, n, p) + R(m, p, n, q)
+    t2 = t1*A(-n, -p, -q)
+    t2 = t2.canon_bp()
+    assert t2 == 0
+    t1 = Rational(2, 3)*R(m,n,p,q) - Rational(1, 3)*R(m,q,n,p) + Rational(1, 3)*R(m,p,n,q)
+    t2 = t1*A(-n, -p, -q)
+    t2 = t2.canon_bp()
+    assert t2 == 0
+    t = A(m, -m, n) + A(n, p, -p)
+    t = t.canon_bp()
+    assert t == 0
+
+def test_add3():
+    Lorentz = TensorIndexType('Lorentz', dummy_name='L')
+    i0, i1 = tensor_indices('i0:2', Lorentz)
+    E, px, py, pz = symbols('E px py pz')
+    A = TensorHead('A', [Lorentz])
+    B = TensorHead('B', [Lorentz])
+
+    expr1 = A(i0)*A(-i0) - (E**2 - px**2 - py**2 - pz**2)
+    assert expr1.args == (-E**2, px**2, py**2, pz**2, A(i0)*A(-i0))
+
+    expr2 = E**2 - px**2 - py**2 - pz**2 - A(i0)*A(-i0)
+    assert expr2.args == (E**2, -px**2, -py**2, -pz**2, -A(i0)*A(-i0))
+
+    expr3 = A(i0)*A(-i0) - E**2 + px**2 + py**2 + pz**2
+    assert expr3.args == (-E**2, px**2, py**2, pz**2, A(i0)*A(-i0))
+
+    expr4 = B(i1)*B(-i1) + 2*E**2 - 2*px**2 - 2*py**2 - 2*pz**2 - A(i0)*A(-i0)
+    assert expr4.args == (2*E**2, -2*px**2, -2*py**2, -2*pz**2, B(i1)*B(-i1), -A(i0)*A(-i0))
+
+
+def test_mul():
+    from sympy.abc import x
+    Lorentz = TensorIndexType('Lorentz', dummy_name='L')
+    a, b, c, d = tensor_indices('a,b,c,d', Lorentz)
+    t = TensMul.from_data(S.One, [], [], [])
+    assert str(t) == '1'
+    A, B = tensor_heads('A B', [Lorentz]*2, TensorSymmetry.fully_symmetric(2))
+    t = (1 + x)*A(a, b)
+    assert str(t) == '(x + 1)*A(a, b)'
+    assert t.index_types == [Lorentz, Lorentz]
+    assert t.rank == 2
+    assert t.dum == []
+    assert t.coeff == 1 + x
+    assert sorted(t.free) == [(a, 0), (b, 1)]
+    assert t.components == [A]
+
+    ts = A(a, b)
+    assert str(ts) == 'A(a, b)'
+    assert ts.index_types == [Lorentz, Lorentz]
+    assert ts.rank == 2
+    assert ts.dum == []
+    assert ts.coeff == 1
+    assert sorted(ts.free) == [(a, 0), (b, 1)]
+    assert ts.components == [A]
+
+    t = A(-b, a)*B(-a, c)*A(-c, d)
+    t1 = tensor_mul(*t.split())
+    assert t == t1
+    assert tensor_mul(*[]) == TensMul.from_data(S.One, [], [], [])
+
+    t = TensMul.from_data(1, [], [], [])
+    C = TensorHead('C', [])
+    assert str(C()) == 'C'
+    assert str(t) == '1'
+    assert t == 1
+    raises(ValueError, lambda: A(a, b)*A(a, c))
+
+def test_substitute_indices():
+    Lorentz = TensorIndexType('Lorentz', dummy_name='L')
+    i, j, k, l, m, n, p, q = tensor_indices('i,j,k,l,m,n,p,q', Lorentz)
+    A, B = tensor_heads('A,B', [Lorentz]*2, TensorSymmetry.fully_symmetric(2))
+
+    p = TensorHead('p', [Lorentz])
+    t = p(i)
+    t1 = t.substitute_indices((j, k))
+    assert t1 == t
+    t1 = t.substitute_indices((i, j))
+    assert t1 == p(j)
+    t1 = t.substitute_indices((i, -j))
+    assert t1 == p(-j)
+    t1 = t.substitute_indices((-i, j))
+    assert t1 == p(-j)
+    t1 = t.substitute_indices((-i, -j))
+    assert t1 == p(j)
+    t = A(m, n)
+    t1 = t.substitute_indices((m, i), (n, -i))
+    assert t1 == A(n, -n)
+    t1 = substitute_indices(t, (m, i), (n, -i))
+    assert t1 == A(n, -n)
+
+    t = A(i, k)*B(-k, -j)
+    t1 = t.substitute_indices((i, j), (j, k))
+    t1a = A(j, l)*B(-l, -k)
+    assert t1 == t1a
+    t1 = substitute_indices(t, (i, j), (j, k))
+    assert t1 == t1a
+
+    t = A(i, j) + B(i, j)
+    t1 = t.substitute_indices((j, -i))
+    t1a = A(i, -i) + B(i, -i)
+    assert t1 == t1a
+    t1 = substitute_indices(t, (j, -i))
+    assert t1 == t1a
+
+def test_riemann_cyclic_replace():
+    Lorentz = TensorIndexType('Lorentz', dummy_name='L')
+    m0, m1, m2, m3 = tensor_indices('m:4', Lorentz)
+    R = TensorHead('R', [Lorentz]*4, TensorSymmetry.riemann())
+    t = R(m0, m2, m1, m3)
+    t1 = riemann_cyclic_replace(t)
+    t1a = Rational(-1, 3)*R(m0, m3, m2, m1) + Rational(1, 3)*R(m0, m1, m2, m3) + Rational(2, 3)*R(m0, m2, m1, m3)
+    assert t1 == t1a
+
+def test_riemann_cyclic():
+    Lorentz = TensorIndexType('Lorentz', dummy_name='L')
+    i, j, k, l, m, n, p, q = tensor_indices('i,j,k,l,m,n,p,q', Lorentz)
+    R = TensorHead('R', [Lorentz]*4, TensorSymmetry.riemann())
+    t = R(i,j,k,l) + R(i,l,j,k) + R(i,k,l,j) - \
+        R(i,j,l,k) - R(i,l,k,j) - R(i,k,j,l)
+    t2 = t*R(-i,-j,-k,-l)
+    t3 = riemann_cyclic(t2)
+    assert t3 == 0
+    t = R(i,j,k,l)*(R(-i,-j,-k,-l) - 2*R(-i,-k,-j,-l))
+    t1 = riemann_cyclic(t)
+    assert t1 == 0
+    t = R(i,j,k,l)
+    t1 = riemann_cyclic(t)
+    assert t1 == Rational(-1, 3)*R(i, l, j, k) + Rational(1, 3)*R(i, k, j, l) + Rational(2, 3)*R(i, j, k, l)
+
+    t = R(i,j,k,l)*R(-k,-l,m,n)*(R(-m,-n,-i,-j) + 2*R(-m,-j,-n,-i))
+    t1 = riemann_cyclic(t)
+    assert t1 == 0
+
+@XFAIL
+def test_div():
+    Lorentz = TensorIndexType('Lorentz', dummy_name='L')
+    m0, m1, m2, m3 = tensor_indices('m0:4', Lorentz)
+    R = TensorHead('R', [Lorentz]*4, TensorSymmetry.riemann())
+    t = R(m0,m1,-m1,m3)
+    t1 = t/S(4)
+    assert str(t1) == '(1/4)*R(m0, L_0, -L_0, m3)'
+    t = t.canon_bp()
+    assert not t1._is_canon_bp
+    t1 = t*4
+    assert t1._is_canon_bp
+    t1 = t1/4
+    assert t1._is_canon_bp
+
+def test_contract_metric1():
+    D = Symbol('D')
+    Lorentz = TensorIndexType('Lorentz', dim=D, dummy_name='L')
+    a, b, c, d, e = tensor_indices('a,b,c,d,e', Lorentz)
+    g = Lorentz.metric
+    p = TensorHead('p', [Lorentz])
+    t = g(a, b)*p(-b)
+    t1 = t.contract_metric(g)
+    assert t1 == p(a)
+    A, B = tensor_heads('A,B', [Lorentz]*2, TensorSymmetry.fully_symmetric(2))
+
+    # case with g with all free indices
+    t1 = A(a,b)*B(-b,c)*g(d, e)
+    t2 = t1.contract_metric(g)
+    assert t1 == t2
+
+    # case of g(d, -d)
+    t1 = A(a,b)*B(-b,c)*g(-d, d)
+    t2 = t1.contract_metric(g)
+    assert t2 == D*A(a, d)*B(-d, c)
+
+    # g with one free index
+    t1 = A(a,b)*B(-b,-c)*g(c, d)
+    t2 = t1.contract_metric(g)
+    assert t2 == A(a, c)*B(-c, d)
+
+    # g with both indices contracted with another tensor
+    t1 = A(a,b)*B(-b,-c)*g(c, -a)
+    t2 = t1.contract_metric(g)
+    assert _is_equal(t2, A(a, b)*B(-b, -a))
+
+    t1 = A(a,b)*B(-b,-c)*g(c, d)*g(-a, -d)
+    t2 = t1.contract_metric(g)
+    assert _is_equal(t2, A(a,b)*B(-b,-a))
+
+    t1 = A(a,b)*g(-a,-b)
+    t2 = t1.contract_metric(g)
+    assert _is_equal(t2, A(a, -a))
+    assert not t2.free
+    Lorentz = TensorIndexType('Lorentz', dummy_name='L')
+    a, b = tensor_indices('a,b', Lorentz)
+    g = Lorentz.metric
+    assert _is_equal(g(a, -a).contract_metric(g), Lorentz.dim) # no dim
+
+def test_contract_metric2():
+    D = Symbol('D')
+    Lorentz = TensorIndexType('Lorentz', dim=D, dummy_name='L')
+    a, b, c, d, e, L_0 = tensor_indices('a,b,c,d,e,L_0', Lorentz)
+    g = Lorentz.metric
+    p, q = tensor_heads('p,q', [Lorentz])
+
+    t1 = g(a,b)*p(c)*p(-c)
+    t2 = 3*g(-a,-b)*q(c)*q(-c)
+    t = t1*t2
+    t = t.contract_metric(g)
+    assert t == 3*D*p(a)*p(-a)*q(b)*q(-b)
+    t1 = g(a,b)*p(c)*p(-c)
+    t2 = 3*q(-a)*q(-b)
+    t = t1*t2
+    t = t.contract_metric(g)
+    t = t.canon_bp()
+    assert t == 3*p(a)*p(-a)*q(b)*q(-b)
+
+    t1 = 2*g(a,b)*p(c)*p(-c)
+    t2 = - 3*g(-a,-b)*q(c)*q(-c)
+    t = t1*t2
+    t = t.contract_metric(g)
+    t = 6*g(a,b)*g(-a,-b)*p(c)*p(-c)*q(d)*q(-d)
+    t = t.contract_metric(g)
+
+    t1 = 2*g(a,b)*p(c)*p(-c)
+    t2 = q(-a)*q(-b) + 3*g(-a,-b)*q(c)*q(-c)
+    t = t1*t2
+    t = t.contract_metric(g)
+    assert t == (2 + 6*D)*p(a)*p(-a)*q(b)*q(-b)
+
+    t1 = p(a)*p(b) + p(a)*q(b) + 2*g(a,b)*p(c)*p(-c)
+    t2 = q(-a)*q(-b) - g(-a,-b)*q(c)*q(-c)
+    t = t1*t2
+    t = t.contract_metric(g)
+    t1 = (1 - 2*D)*p(a)*p(-a)*q(b)*q(-b) + p(a)*q(-a)*p(b)*q(-b)
+    assert canon_bp(t - t1) == 0
+
+    t = g(a,b)*g(c,d)*g(-b,-c)
+    t1 = t.contract_metric(g)
+    assert t1 == g(a, d)
+
+    t1 = g(a,b)*g(c,d) + g(a,c)*g(b,d) + g(a,d)*g(b,c)
+    t2 = t1.substitute_indices((a,-a),(b,-b),(c,-c),(d,-d))
+    t = t1*t2
+    t = t.contract_metric(g)
+    assert t.equals(3*D**2 + 6*D)
+
+    t = 2*p(a)*g(b,-b)
+    t1 = t.contract_metric(g)
+    assert t1.equals(2*D*p(a))
+
+    t = 2*p(a)*g(b,-a)
+    t1 = t.contract_metric(g)
+    assert t1 == 2*p(b)
+
+    M = Symbol('M')
+    t = (p(a)*p(b) + g(a, b)*M**2)*g(-a, -b) - D*M**2
+    t1 = t.contract_metric(g)
+    assert t1 == p(a)*p(-a)
+
+    A = TensorHead('A', [Lorentz]*2, TensorSymmetry.fully_symmetric(2))
+    t = A(a, b)*p(L_0)*g(-a, -b)
+    t1 = t.contract_metric(g)
+    assert str(t1) == 'A(L_1, -L_1)*p(L_0)' or str(t1) == 'A(-L_1, L_1)*p(L_0)'
+
+def test_metric_contract3():
+    D = Symbol('D')
+    Spinor = TensorIndexType('Spinor', dim=D, metric_symmetry=-1, dummy_name='S')
+    a0, a1, a2, a3, a4 = tensor_indices('a0:5', Spinor)
+    C = Spinor.metric
+    chi, psi = tensor_heads('chi,psi', [Spinor], TensorSymmetry.no_symmetry(1), 1)
+    B = TensorHead('B', [Spinor]*2, TensorSymmetry.no_symmetry(2))
+
+    t = C(a0,-a0)
+    t1 = t.contract_metric(C)
+    assert t1.equals(-D)
+
+    t = C(-a0,a0)
+    t1 = t.contract_metric(C)
+    assert t1.equals(D)
+
+    t = C(a0,a1)*C(-a0,-a1)
+    t1 = t.contract_metric(C)
+    assert t1.equals(D)
+
+    t = C(a1,a0)*C(-a0,-a1)
+    t1 = t.contract_metric(C)
+    assert t1.equals(-D)
+
+    t = C(-a0,a1)*C(a0,-a1)
+    t1 = t.contract_metric(C)
+    assert t1.equals(-D)
+
+    t = C(a1,-a0)*C(a0,-a1)
+    t1 = t.contract_metric(C)
+    assert t1.equals(D)
+
+    t = C(a0,a1)*B(-a1,-a0)
+    t1 = t.contract_metric(C)
+    t1 = t1.canon_bp()
+    assert _is_equal(t1, B(a0,-a0))
+
+    t = C(a1,a0)*B(-a1,-a0)
+    t1 = t.contract_metric(C)
+    assert _is_equal(t1, -B(a0,-a0))
+
+    t = C(a0,-a1)*B(a1,-a0)
+    t1 = t.contract_metric(C)
+    assert _is_equal(t1, -B(a0,-a0))
+
+    t = C(-a0,a1)*B(-a1,a0)
+    t1 = t.contract_metric(C)
+    assert _is_equal(t1, -B(a0,-a0))
+
+    t = C(-a0,-a1)*B(a1,a0)
+    t1 = t.contract_metric(C)
+    assert _is_equal(t1, B(a0,-a0))
+
+    t = C(-a1, a0)*B(a1,-a0)
+    t1 = t.contract_metric(C)
+    assert _is_equal(t1, B(a0,-a0))
+
+    t = C(a0,a1)*psi(-a1)
+    t1 = t.contract_metric(C)
+    assert _is_equal(t1, psi(a0))
+
+    t = C(a1,a0)*psi(-a1)
+    t1 = t.contract_metric(C)
+    assert _is_equal(t1, -psi(a0))
+
+    t = C(a0,a1)*chi(-a0)*psi(-a1)
+    t1 = t.contract_metric(C)
+    assert _is_equal(t1, -chi(a1)*psi(-a1))
+
+    t = C(a1,a0)*chi(-a0)*psi(-a1)
+    t1 = t.contract_metric(C)
+    assert _is_equal(t1, chi(a1)*psi(-a1))
+
+    t = C(-a1,a0)*chi(-a0)*psi(a1)
+    t1 = t.contract_metric(C)
+    assert _is_equal(t1, chi(-a1)*psi(a1))
+
+    t = C(a0,-a1)*chi(-a0)*psi(a1)
+    t1 = t.contract_metric(C)
+    assert _is_equal(t1, -chi(-a1)*psi(a1))
+
+    t = C(-a0,-a1)*chi(a0)*psi(a1)
+    t1 = t.contract_metric(C)
+    assert _is_equal(t1, chi(-a1)*psi(a1))
+
+    t = C(-a1,-a0)*chi(a0)*psi(a1)
+    t1 = t.contract_metric(C)
+    assert _is_equal(t1, -chi(-a1)*psi(a1))
+
+    t = C(-a1,-a0)*B(a0,a2)*psi(a1)
+    t1 = t.contract_metric(C)
+    assert _is_equal(t1, -B(-a1,a2)*psi(a1))
+
+    t = C(a1,a0)*B(-a2,-a0)*psi(-a1)
+    t1 = t.contract_metric(C)
+    assert _is_equal(t1, B(-a2,a1)*psi(-a1))
+
+
+def test_contract_metric4():
+    R3 = TensorIndexType('R3', dim=3)
+    p, q, r = tensor_indices("p q r", R3)
+    delta = R3.delta
+    eps = R3.epsilon
+    K = TensorHead("K", [R3])
+
+    #Check whether contract_metric chokes on an expandable expression which becomes zero on canonicalization (issue #24354)
+    expr = eps(p,q,r)*( K(-p)*K(-q) + delta(-p,-q) )
+    assert expr.contract_metric(delta) == 0
+
+
+def test_contract_metric5():
+    R3 = TensorIndexType('R3', dim=3)
+    p, q, r = tensor_indices("p q r", R3)
+    delta = R3.delta
+    K = TensorHead("K", [R3])
+
+    F = Function("F")
+    x = Symbol("x")
+
+    #Check if contract_metric gets into an infinite loop when given a TensMul whose coeff is an Add
+    expr = (2+F(x))*K(-p)*K(-q)
+    assert expr.contract_metric(delta) == expr
+
+
+def test_epsilon():
+    Lorentz = TensorIndexType('Lorentz', dim=4, dummy_name='L')
+    a, b, c, d, e = tensor_indices('a,b,c,d,e', Lorentz)
+    epsilon = Lorentz.epsilon
+    p, q, r, s = tensor_heads('p,q,r,s', [Lorentz])
+
+    t = epsilon(b,a,c,d)
+    t1 = t.canon_bp()
+    assert t1 == -epsilon(a,b,c,d)
+
+    t = epsilon(c,b,d,a)
+    t1 = t.canon_bp()
+    assert t1 == epsilon(a,b,c,d)
+
+    t = epsilon(c,a,d,b)
+    t1 = t.canon_bp()
+    assert t1 == -epsilon(a,b,c,d)
+
+    t = epsilon(a,b,c,d)*p(-a)*q(-b)
+    t1 = t.canon_bp()
+    assert t1 == epsilon(c,d,a,b)*p(-a)*q(-b)
+
+    t = epsilon(c,b,d,a)*p(-a)*q(-b)
+    t1 = t.canon_bp()
+    assert t1 == epsilon(c,d,a,b)*p(-a)*q(-b)
+
+    t = epsilon(c,a,d,b)*p(-a)*q(-b)
+    t1 = t.canon_bp()
+    assert t1 == -epsilon(c,d,a,b)*p(-a)*q(-b)
+
+    t = epsilon(c,a,d,b)*p(-a)*p(-b)
+    t1 = t.canon_bp()
+    assert t1 == 0
+
+    t = epsilon(c,a,d,b)*p(-a)*q(-b) + epsilon(a,b,c,d)*p(-b)*q(-a)
+    t1 = t.canon_bp()
+    assert t1 == -2*epsilon(c,d,a,b)*p(-a)*q(-b)
+
+    # Test that epsilon can be create with a SymPy integer:
+    Lorentz = TensorIndexType('Lorentz', dim=Integer(4), dummy_name='L')
+    epsilon = Lorentz.epsilon
+    assert isinstance(epsilon, TensorHead)
+
+def test_contract_delta1():
+    # see Group Theory by Cvitanovic page 9
+    n = Symbol('n')
+    Color = TensorIndexType('Color', dim=n, dummy_name='C')
+    a, b, c, d, e, f = tensor_indices('a,b,c,d,e,f', Color)
+    delta = Color.delta
+
+    def idn(a, b, d, c):
+        assert a.is_up and d.is_up
+        assert not (b.is_up or c.is_up)
+        return delta(a,c)*delta(d,b)
+
+    def T(a, b, d, c):
+        assert a.is_up and d.is_up
+        assert not (b.is_up or c.is_up)
+        return delta(a,b)*delta(d,c)
+
+    def P1(a, b, c, d):
+        return idn(a,b,c,d) - 1/n*T(a,b,c,d)
+
+    def P2(a, b, c, d):
+        return 1/n*T(a,b,c,d)
+
+    t = P1(a, -b, e, -f)*P1(f, -e, d, -c)
+    t1 = t.contract_delta(delta)
+    assert canon_bp(t1 - P1(a, -b, d, -c)) == 0
+
+    t = P2(a, -b, e, -f)*P2(f, -e, d, -c)
+    t1 = t.contract_delta(delta)
+    assert t1 == P2(a, -b, d, -c)
+
+    t = P1(a, -b, e, -f)*P2(f, -e, d, -c)
+    t1 = t.contract_delta(delta)
+    assert t1 == 0
+
+    t = P1(a, -b, b, -a)
+    t1 = t.contract_delta(delta)
+    assert t1.equals(n**2 - 1)
+
+def test_contract_delta2():
+    R3 = TensorIndexType('R3', dim=3)
+    p, q = tensor_indices("p q", R3)
+    delta = R3.delta
+    K = TensorHead("K", [R3])
+
+    #Check if TensAdd.contract_delta can handle the case when the TensAdd has non-TensExpr args.
+    expr = 1 + K(p)*K(q)*delta(-p,-q)
+    assert expr.contract_delta(delta) == 1 + K(p)*K(-p)
+
+def test_fun():
+    with warns_deprecated_sympy():
+        D = Symbol('D')
+        Lorentz = TensorIndexType('Lorentz', dim=D, dummy_name='L')
+        a, b, c, d, e = tensor_indices('a,b,c,d,e', Lorentz)
+        g = Lorentz.metric
+
+        p, q = tensor_heads('p q', [Lorentz])
+        t = q(c)*p(a)*q(b) + g(a,b)*g(c,d)*q(-d)
+        assert t(a,b,c) == t
+        assert canon_bp(t - t(b,a,c) - q(c)*p(a)*q(b) + q(c)*p(b)*q(a)) == 0
+        assert t(b,c,d) == q(d)*p(b)*q(c) + g(b,c)*g(d,e)*q(-e)
+        t1 = t.substitute_indices((a,b),(b,a))
+        assert canon_bp(t1 - q(c)*p(b)*q(a) - g(a,b)*g(c,d)*q(-d)) == 0
+
+        # check that g_{a b; c} = 0
+        # example taken from  L. Brewin
+        # "A brief introduction to Cadabra" arxiv:0903.2085
+        # dg_{a b c} = \partial_{a} g_{b c} is symmetric in b, c
+        dg = TensorHead('dg', [Lorentz]*3, TensorSymmetry.direct_product(1, 2))
+        # gamma^a_{b c} is the Christoffel symbol
+        gamma = S.Half*g(a,d)*(dg(-b,-d,-c) + dg(-c,-b,-d) - dg(-d,-b,-c))
+        # t = g_{a b; c}
+        t = dg(-c,-a,-b) - g(-a,-d)*gamma(d,-b,-c) - g(-b,-d)*gamma(d,-a,-c)
+        t = t.contract_metric(g)
+        assert t == 0
+        t = q(c)*p(a)*q(b)
+        assert t(b,c,d) == q(d)*p(b)*q(c)
+
+def test_TensorManager():
+    Lorentz = TensorIndexType('Lorentz', dummy_name='L')
+    LorentzH = TensorIndexType('LorentzH', dummy_name='LH')
+    i, j = tensor_indices('i,j', Lorentz)
+    ih, jh = tensor_indices('ih,jh', LorentzH)
+    p, q = tensor_heads('p q', [Lorentz])
+    ph, qh = tensor_heads('ph qh', [LorentzH])
+
+    Gsymbol = Symbol('Gsymbol')
+    GHsymbol = Symbol('GHsymbol')
+    TensorManager.set_comm(Gsymbol, GHsymbol, 0)
+    G = TensorHead('G', [Lorentz], TensorSymmetry.no_symmetry(1), Gsymbol)
+    assert TensorManager._comm_i2symbol[G.comm] == Gsymbol
+    GH = TensorHead('GH', [LorentzH], TensorSymmetry.no_symmetry(1), GHsymbol)
+    ps = G(i)*p(-i)
+    psh = GH(ih)*ph(-ih)
+    t = ps + psh
+    t1 = t*t
+    assert canon_bp(t1 - ps*ps - 2*ps*psh - psh*psh) == 0
+    qs = G(i)*q(-i)
+    qsh = GH(ih)*qh(-ih)
+    assert _is_equal(ps*qsh, qsh*ps)
+    assert not _is_equal(ps*qs, qs*ps)
+    n = TensorManager.comm_symbols2i(Gsymbol)
+    assert TensorManager.comm_i2symbol(n) == Gsymbol
+
+    assert GHsymbol in TensorManager._comm_symbols2i
+    raises(ValueError, lambda: TensorManager.set_comm(GHsymbol, 1, 2))
+    TensorManager.set_comms((Gsymbol,GHsymbol,0),(Gsymbol,1,1))
+    assert TensorManager.get_comm(n, 1) == TensorManager.get_comm(1, n) == 1
+    TensorManager.clear()
+    assert TensorManager.comm == [{0:0, 1:0, 2:0}, {0:0, 1:1, 2:None}, {0:0, 1:None}]
+    assert GHsymbol not in TensorManager._comm_symbols2i
+    nh = TensorManager.comm_symbols2i(GHsymbol)
+    assert TensorManager.comm_i2symbol(nh) == GHsymbol
+    assert GHsymbol in TensorManager._comm_symbols2i
+
+
+def test_hash():
+    D = Symbol('D')
+    Lorentz = TensorIndexType('Lorentz', dim=D, dummy_name='L')
+    a, b, c, d, e = tensor_indices('a,b,c,d,e', Lorentz)
+    g = Lorentz.metric
+
+    p, q = tensor_heads('p q', [Lorentz])
+    p_type = p.args[1]
+    t1 = p(a)*q(b)
+    t2 = p(a)*p(b)
+    assert hash(t1) != hash(t2)
+    t3 = p(a)*p(b) + g(a,b)
+    t4 = p(a)*p(b) - g(a,b)
+    assert hash(t3) != hash(t4)
+
+    assert a.func(*a.args) == a
+    assert Lorentz.func(*Lorentz.args) == Lorentz
+    assert g.func(*g.args) == g
+    assert p.func(*p.args) == p
+    assert p_type.func(*p_type.args) == p_type
+    assert p(a).func(*(p(a)).args) == p(a)
+    assert t1.func(*t1.args) == t1
+    assert t2.func(*t2.args) == t2
+    assert t3.func(*t3.args) == t3
+    assert t4.func(*t4.args) == t4
+
+    assert hash(a.func(*a.args)) == hash(a)
+    assert hash(Lorentz.func(*Lorentz.args)) == hash(Lorentz)
+    assert hash(g.func(*g.args)) == hash(g)
+    assert hash(p.func(*p.args)) == hash(p)
+    assert hash(p_type.func(*p_type.args)) == hash(p_type)
+    assert hash(p(a).func(*(p(a)).args)) == hash(p(a))
+    assert hash(t1.func(*t1.args)) == hash(t1)
+    assert hash(t2.func(*t2.args)) == hash(t2)
+    assert hash(t3.func(*t3.args)) == hash(t3)
+    assert hash(t4.func(*t4.args)) == hash(t4)
+
+    def check_all(obj):
+        return all(isinstance(_, Basic) for _ in obj.args)
+
+    assert check_all(a)
+    assert check_all(Lorentz)
+    assert check_all(g)
+    assert check_all(p)
+    assert check_all(p_type)
+    assert check_all(p(a))
+    assert check_all(t1)
+    assert check_all(t2)
+    assert check_all(t3)
+    assert check_all(t4)
+
+    tsymmetry = TensorSymmetry.direct_product(-2, 1, 3)
+
+    assert tsymmetry.func(*tsymmetry.args) == tsymmetry
+    assert hash(tsymmetry.func(*tsymmetry.args)) == hash(tsymmetry)
+    assert check_all(tsymmetry)
+
+
+### TEST VALUED TENSORS ###
+
+
+def _get_valued_base_test_variables():
+    minkowski = Matrix((
+        (1, 0, 0, 0),
+        (0, -1, 0, 0),
+        (0, 0, -1, 0),
+        (0, 0, 0, -1),
+    ))
+    Lorentz = TensorIndexType('Lorentz', dim=4)
+    Lorentz.data = minkowski
+
+    i0, i1, i2, i3, i4 = tensor_indices('i0:5', Lorentz)
+
+    E, px, py, pz = symbols('E px py pz')
+    A = TensorHead('A', [Lorentz])
+    A.data = [E, px, py, pz]
+    B = TensorHead('B', [Lorentz], TensorSymmetry.no_symmetry(1), 'Gcomm')
+    B.data = range(4)
+    AB = TensorHead("AB", [Lorentz]*2)
+    AB.data = minkowski
+
+    ba_matrix = Matrix((
+        (1, 2, 3, 4),
+        (5, 6, 7, 8),
+        (9, 0, -1, -2),
+        (-3, -4, -5, -6),
+    ))
+
+    BA = TensorHead("BA", [Lorentz]*2)
+    BA.data = ba_matrix
+
+    # Let's test the diagonal metric, with inverted Minkowski metric:
+    LorentzD = TensorIndexType('LorentzD')
+    LorentzD.data = [-1, 1, 1, 1]
+    mu0, mu1, mu2 = tensor_indices('mu0:3', LorentzD)
+    C = TensorHead('C', [LorentzD])
+    C.data = [E, px, py, pz]
+
+    ### non-diagonal metric ###
+    ndm_matrix = (
+        (1, 1, 0,),
+        (1, 0, 1),
+        (0, 1, 0,),
+    )
+    ndm = TensorIndexType("ndm")
+    ndm.data = ndm_matrix
+    n0, n1, n2 = tensor_indices('n0:3', ndm)
+    NA = TensorHead('NA', [ndm])
+    NA.data = range(10, 13)
+    NB = TensorHead('NB', [ndm]*2)
+    NB.data = [[i+j for j in range(10, 13)] for i in range(10, 13)]
+    NC = TensorHead('NC', [ndm]*3)
+    NC.data = [[[i+j+k for k in range(4, 7)] for j in range(1, 4)] for i in range(2, 5)]
+
+    return (A, B, AB, BA, C, Lorentz, E, px, py, pz, LorentzD, mu0, mu1, mu2, ndm, n0, n1,
+            n2, NA, NB, NC, minkowski, ba_matrix, ndm_matrix, i0, i1, i2, i3, i4)
+
+
+def test_valued_tensor_iter():
+    with warns_deprecated_sympy():
+        (A, B, AB, BA, C, Lorentz, E, px, py, pz, LorentzD, mu0, mu1, mu2, ndm, n0, n1,
+         n2, NA, NB, NC, minkowski, ba_matrix, ndm_matrix, i0, i1, i2, i3, i4) = _get_valued_base_test_variables()
+
+        list_BA = [Array([1, 2, 3, 4]), Array([5, 6, 7, 8]), Array([9, 0, -1, -2]), Array([-3, -4, -5, -6])]
+        # iteration on VTensorHead
+        assert list(A) == [E, px, py, pz]
+        assert list(ba_matrix) == [1, 2, 3, 4, 5, 6, 7, 8, 9, 0, -1, -2, -3, -4, -5, -6]
+        assert list(BA) == list_BA
+
+        # iteration on VTensMul
+        assert list(A(i1)) == [E, px, py, pz]
+        assert list(BA(i1, i2)) == list_BA
+        assert list(3 * BA(i1, i2)) == [3 * i for i in list_BA]
+        assert list(-5 * BA(i1, i2)) == [-5 * i for i in list_BA]
+
+        # iteration on VTensAdd
+        # A(i1) + A(i1)
+        assert list(A(i1) + A(i1)) == [2*E, 2*px, 2*py, 2*pz]
+        assert BA(i1, i2) - BA(i1, i2) == 0
+        assert list(BA(i1, i2) - 2 * BA(i1, i2)) == [-i for i in list_BA]
+
+
+def test_valued_tensor_covariant_contravariant_elements():
+    with warns_deprecated_sympy():
+        (A, B, AB, BA, C, Lorentz, E, px, py, pz, LorentzD, mu0, mu1, mu2, ndm, n0, n1,
+         n2, NA, NB, NC, minkowski, ba_matrix, ndm_matrix, i0, i1, i2, i3, i4) = _get_valued_base_test_variables()
+
+        assert A(-i0)[0] == A(i0)[0]
+        assert A(-i0)[1] == -A(i0)[1]
+
+        assert AB(i0, i1)[1, 1] == -1
+        assert AB(i0, -i1)[1, 1] == 1
+        assert AB(-i0, -i1)[1, 1] == -1
+        assert AB(-i0, i1)[1, 1] == 1
+
+
+def test_valued_tensor_get_matrix():
+    with warns_deprecated_sympy():
+        (A, B, AB, BA, C, Lorentz, E, px, py, pz, LorentzD, mu0, mu1, mu2, ndm, n0, n1,
+         n2, NA, NB, NC, minkowski, ba_matrix, ndm_matrix, i0, i1, i2, i3, i4) = _get_valued_base_test_variables()
+
+        matab = AB(i0, i1).get_matrix()
+        assert matab == Matrix([
+                                [1,  0,  0,  0],
+                                [0, -1,  0,  0],
+                                [0,  0, -1,  0],
+                                [0,  0,  0, -1],
+                                ])
+        # when alternating contravariant/covariant with [1, -1, -1, -1] metric
+        # it becomes the identity matrix:
+        assert AB(i0, -i1).get_matrix() == eye(4)
+
+        # covariant and contravariant forms:
+        assert A(i0).get_matrix() == Matrix([E, px, py, pz])
+        assert A(-i0).get_matrix() == Matrix([E, -px, -py, -pz])
+
+def test_valued_tensor_contraction():
+    with warns_deprecated_sympy():
+        (A, B, AB, BA, C, Lorentz, E, px, py, pz, LorentzD, mu0, mu1, mu2, ndm, n0, n1,
+         n2, NA, NB, NC, minkowski, ba_matrix, ndm_matrix, i0, i1, i2, i3, i4) = _get_valued_base_test_variables()
+
+        assert (A(i0) * A(-i0)).data == E ** 2 - px ** 2 - py ** 2 - pz ** 2
+        assert (A(i0) * A(-i0)).data == A ** 2
+        assert (A(i0) * A(-i0)).data == A(i0) ** 2
+        assert (A(i0) * B(-i0)).data == -px - 2 * py - 3 * pz
+
+        for i in range(4):
+            for j in range(4):
+                assert (A(i0) * B(-i1))[i, j] == [E, px, py, pz][i] * [0, -1, -2, -3][j]
+
+        # test contraction on the alternative Minkowski metric: [-1, 1, 1, 1]
+        assert (C(mu0) * C(-mu0)).data == -E ** 2 + px ** 2 + py ** 2 + pz ** 2
+
+        contrexp = A(i0) * AB(i1, -i0)
+        assert A(i0).rank == 1
+        assert AB(i1, -i0).rank == 2
+        assert contrexp.rank == 1
+        for i in range(4):
+            assert contrexp[i] == [E, px, py, pz][i]
+
+def test_valued_tensor_self_contraction():
+    with warns_deprecated_sympy():
+        (A, B, AB, BA, C, Lorentz, E, px, py, pz, LorentzD, mu0, mu1, mu2, ndm, n0, n1,
+         n2, NA, NB, NC, minkowski, ba_matrix, ndm_matrix, i0, i1, i2, i3, i4) = _get_valued_base_test_variables()
+
+        assert AB(i0, -i0).data == 4
+        assert BA(i0, -i0).data == 2
+
+
+def test_valued_tensor_pow():
+    with warns_deprecated_sympy():
+        (A, B, AB, BA, C, Lorentz, E, px, py, pz, LorentzD, mu0, mu1, mu2, ndm, n0, n1,
+         n2, NA, NB, NC, minkowski, ba_matrix, ndm_matrix, i0, i1, i2, i3, i4) = _get_valued_base_test_variables()
+
+        assert C**2 == -E**2 + px**2 + py**2 + pz**2
+        assert C**1 == sqrt(-E**2 + px**2 + py**2 + pz**2)
+        assert C(mu0)**2 == C**2
+        assert C(mu0)**1 == C**1
+
+
+def test_valued_tensor_expressions():
+    with warns_deprecated_sympy():
+        (A, B, AB, BA, C, Lorentz, E, px, py, pz, LorentzD, mu0, mu1, mu2, ndm, n0, n1,
+         n2, NA, NB, NC, minkowski, ba_matrix, ndm_matrix, i0, i1, i2, i3, i4) = _get_valued_base_test_variables()
+
+        x1, x2, x3 = symbols('x1:4')
+
+        # test coefficient in contraction:
+        rank2coeff = x1 * A(i3) * B(i2)
+        assert rank2coeff[1, 1] == x1 * px
+        assert rank2coeff[3, 3] == 3 * pz * x1
+        coeff_expr = ((x1 * A(i4)) * (B(-i4) / x2)).data
+
+        assert coeff_expr.expand() == -px*x1/x2 - 2*py*x1/x2 - 3*pz*x1/x2
+
+        add_expr = A(i0) + B(i0)
+
+        assert add_expr[0] == E
+        assert add_expr[1] == px + 1
+        assert add_expr[2] == py + 2
+        assert add_expr[3] == pz + 3
+
+        sub_expr = A(i0) - B(i0)
+
+        assert sub_expr[0] == E
+        assert sub_expr[1] == px - 1
+        assert sub_expr[2] == py - 2
+        assert sub_expr[3] == pz - 3
+
+        assert (add_expr * B(-i0)).data == -px - 2*py - 3*pz - 14
+
+        expr1 = x1*A(i0) + x2*B(i0)
+        expr2 = expr1 * B(i1) * (-4)
+        expr3 = expr2 + 3*x3*AB(i0, i1)
+        expr4 = expr3 / 2
+        assert expr4 * 2 == expr3
+        expr5 = (expr4 * BA(-i1, -i0))
+
+        assert expr5.data.expand() == 28*E*x1 + 12*px*x1 + 20*py*x1 + 28*pz*x1 + 136*x2 + 3*x3
+
+
+def test_valued_tensor_add_scalar():
+    with warns_deprecated_sympy():
+        (A, B, AB, BA, C, Lorentz, E, px, py, pz, LorentzD, mu0, mu1, mu2, ndm, n0, n1,
+         n2, NA, NB, NC, minkowski, ba_matrix, ndm_matrix, i0, i1, i2, i3, i4) = _get_valued_base_test_variables()
+
+        # one scalar summand after the contracted tensor
+        expr1 = A(i0)*A(-i0) - (E**2 - px**2 - py**2 - pz**2)
+        assert expr1.data == 0
+
+        # multiple scalar summands in front of the contracted tensor
+        expr2 = E**2 - px**2 - py**2 - pz**2 - A(i0)*A(-i0)
+        assert expr2.data == 0
+
+        # multiple scalar summands after the contracted tensor
+        expr3 =  A(i0)*A(-i0) - E**2 + px**2 + py**2 + pz**2
+        assert expr3.data == 0
+
+        # multiple scalar summands and multiple tensors
+        expr4 = C(mu0)*C(-mu0) + 2*E**2 - 2*px**2 - 2*py**2 - 2*pz**2 - A(i0)*A(-i0)
+        assert expr4.data == 0
+
+def test_noncommuting_components():
+    with warns_deprecated_sympy():
+        (A, B, AB, BA, C, Lorentz, E, px, py, pz, LorentzD, mu0, mu1, mu2, ndm, n0, n1,
+         n2, NA, NB, NC, minkowski, ba_matrix, ndm_matrix, i0, i1, i2, i3, i4) = _get_valued_base_test_variables()
+
+        euclid = TensorIndexType('Euclidean')
+        euclid.data = [1, 1]
+        i1, i2, i3 = tensor_indices('i1:4', euclid)
+
+        a, b, c, d = symbols('a b c d', commutative=False)
+        V1 = TensorHead('V1', [euclid]*2)
+        V1.data = [[a, b], (c, d)]
+        V2 = TensorHead('V2', [euclid]*2)
+        V2.data = [[a, c], [b, d]]
+
+        vtp = V1(i1, i2) * V2(-i2, -i1)
+
+        assert vtp.data == a**2 + b**2 + c**2 + d**2
+        assert vtp.data != a**2 + 2*b*c + d**2
+
+        vtp2 = V1(i1, i2)*V1(-i2, -i1)
+
+        assert vtp2.data == a**2 + b*c + c*b + d**2
+        assert vtp2.data != a**2 + 2*b*c + d**2
+
+        Vc = (b * V1(i1, -i1)).data
+        assert Vc.expand() == b * a + b * d
+
+
+def test_valued_non_diagonal_metric():
+    with warns_deprecated_sympy():
+        (A, B, AB, BA, C, Lorentz, E, px, py, pz, LorentzD, mu0, mu1, mu2, ndm, n0, n1,
+         n2, NA, NB, NC, minkowski, ba_matrix, ndm_matrix, i0, i1, i2, i3, i4) = _get_valued_base_test_variables()
+
+        mmatrix = Matrix(ndm_matrix)
+        assert (NA(n0)*NA(-n0)).data == (NA(n0).get_matrix().T * mmatrix * NA(n0).get_matrix())[0, 0]
+
+
+def test_valued_assign_numpy_ndarray():
+    with warns_deprecated_sympy():
+        (A, B, AB, BA, C, Lorentz, E, px, py, pz, LorentzD, mu0, mu1, mu2, ndm, n0, n1,
+         n2, NA, NB, NC, minkowski, ba_matrix, ndm_matrix, i0, i1, i2, i3, i4) = _get_valued_base_test_variables()
+
+        # this is needed to make sure that a numpy.ndarray can be assigned to a
+        # tensor.
+        arr = [E+1, px-1, py, pz]
+        A.data = Array(arr)
+        for i in range(4):
+                assert A(i0).data[i] == arr[i]
+
+        qx, qy, qz = symbols('qx qy qz')
+        A(-i0).data = Array([E, qx, qy, qz])
+        for i in range(4):
+            assert A(i0).data[i] == [E, -qx, -qy, -qz][i]
+            assert A.data[i] == [E, -qx, -qy, -qz][i]
+
+        # test on multi-indexed tensors.
+        random_4x4_data = [[(i**3-3*i**2)%(j+7) for i in range(4)] for j in range(4)]
+        AB(-i0, -i1).data = random_4x4_data
+
+        for i in range(4):
+            for j in range(4):
+                assert AB(i0, i1).data[i, j] == random_4x4_data[i][j]*(-1 if i else 1)*(-1 if j else 1)
+                assert AB(-i0, i1).data[i, j] == random_4x4_data[i][j]*(-1 if j else 1)
+                assert AB(i0, -i1).data[i, j] == random_4x4_data[i][j]*(-1 if i else 1)
+                assert AB(-i0, -i1).data[i, j] == random_4x4_data[i][j]
+
+        AB(-i0, i1).data = random_4x4_data
+        for i in range(4):
+            for j in range(4):
+                assert AB(i0, i1).data[i, j] == random_4x4_data[i][j]*(-1 if i else 1)
+                assert AB(-i0, i1).data[i, j] == random_4x4_data[i][j]
+                assert AB(i0, -i1).data[i, j] == random_4x4_data[i][j]*(-1 if i else 1)*(-1 if j else 1)
+                assert AB(-i0, -i1).data[i, j] == random_4x4_data[i][j]*(-1 if j else 1)
+
+
+def test_valued_metric_inverse():
+    with warns_deprecated_sympy():
+        (A, B, AB, BA, C, Lorentz, E, px, py, pz, LorentzD, mu0, mu1, mu2, ndm, n0, n1,
+         n2, NA, NB, NC, minkowski, ba_matrix, ndm_matrix, i0, i1, i2, i3, i4) = _get_valued_base_test_variables()
+
+        # let's assign some fancy matrix, just to verify it:
+        # (this has no physical sense, it's just testing sympy);
+        # it is symmetrical:
+        md = [[2, 2, 2, 1], [2, 3, 1, 0], [2, 1, 2, 3], [1, 0, 3, 2]]
+        Lorentz.data = md
+        m = Matrix(md)
+        metric = Lorentz.metric
+        minv = m.inv()
+
+        meye = eye(4)
+
+        # the Kronecker Delta:
+        KD = Lorentz.get_kronecker_delta()
+
+        for i in range(4):
+            for j in range(4):
+                assert metric(i0, i1).data[i, j] == m[i, j]
+                assert metric(-i0, -i1).data[i, j] == minv[i, j]
+                assert metric(i0, -i1).data[i, j] == meye[i, j]
+                assert metric(-i0, i1).data[i, j] == meye[i, j]
+                assert metric(i0, i1)[i, j] == m[i, j]
+                assert metric(-i0, -i1)[i, j] == minv[i, j]
+                assert metric(i0, -i1)[i, j] == meye[i, j]
+                assert metric(-i0, i1)[i, j] == meye[i, j]
+
+                assert KD(i0, -i1)[i, j] == meye[i, j]
+
+
+def test_valued_canon_bp_swapaxes():
+    with warns_deprecated_sympy():
+        (A, B, AB, BA, C, Lorentz, E, px, py, pz, LorentzD, mu0, mu1, mu2, ndm, n0, n1,
+         n2, NA, NB, NC, minkowski, ba_matrix, ndm_matrix, i0, i1, i2, i3, i4) = _get_valued_base_test_variables()
+
+        e1 = A(i1)*A(i0)
+        e2 = e1.canon_bp()
+        assert e2 == A(i0)*A(i1)
+        for i in range(4):
+            for j in range(4):
+                assert e1[i, j] == e2[j, i]
+        o1 = B(i2)*A(i1)*B(i0)
+        o2 = o1.canon_bp()
+        for i in range(4):
+            for j in range(4):
+                for k in range(4):
+                    assert o1[i, j, k] == o2[j, i, k]
+
+
+def test_valued_components_with_wrong_symmetry():
+    with warns_deprecated_sympy():
+        IT = TensorIndexType('IT', dim=3)
+        i0, i1, i2, i3 = tensor_indices('i0:4', IT)
+        IT.data = [1, 1, 1]
+        A_nosym = TensorHead('A', [IT]*2)
+        A_sym = TensorHead('A', [IT]*2, TensorSymmetry.fully_symmetric(2))
+        A_antisym = TensorHead('A', [IT]*2, TensorSymmetry.fully_symmetric(-2))
+
+        mat_nosym = Matrix([[1,2,3],[4,5,6],[7,8,9]])
+        mat_sym = mat_nosym + mat_nosym.T
+        mat_antisym = mat_nosym - mat_nosym.T
+
+        A_nosym.data = mat_nosym
+        A_nosym.data = mat_sym
+        A_nosym.data = mat_antisym
+
+        def assign(A, dat):
+            A.data = dat
+
+        A_sym.data = mat_sym
+        raises(ValueError, lambda: assign(A_sym, mat_nosym))
+        raises(ValueError, lambda: assign(A_sym, mat_antisym))
+
+        A_antisym.data = mat_antisym
+        raises(ValueError, lambda: assign(A_antisym, mat_sym))
+        raises(ValueError, lambda: assign(A_antisym, mat_nosym))
+
+        A_sym.data = [[0, 0, 0], [0, 0, 0], [0, 0, 0]]
+        A_antisym.data = [[0, 0, 0], [0, 0, 0], [0, 0, 0]]
+
+def test_issue_10972_TensMul_data():
+    with warns_deprecated_sympy():
+        Lorentz = TensorIndexType('Lorentz', metric_symmetry=1, dummy_name='i', dim=2)
+        Lorentz.data = [-1, 1]
+
+        mu, nu, alpha, beta = tensor_indices('\\mu, \\nu, \\alpha, \\beta',
+                                             Lorentz)
+
+        u = TensorHead('u', [Lorentz])
+        u.data = [1, 0]
+
+        F = TensorHead('F', [Lorentz]*2, TensorSymmetry.fully_symmetric(-2))
+        F.data = [[0, 1],
+                  [-1, 0]]
+
+        mul_1 = F(mu, alpha) * u(-alpha) * F(nu, beta) * u(-beta)
+        assert (mul_1.data == Array([[0, 0], [0, 1]]))
+
+        mul_2 = F(mu, alpha) * F(nu, beta) * u(-alpha) * u(-beta)
+        assert (mul_2.data == mul_1.data)
+
+        assert ((mul_1 + mul_1).data == 2 * mul_1.data)
+
+
+def test_TensMul_data():
+    with warns_deprecated_sympy():
+        Lorentz = TensorIndexType('Lorentz', metric_symmetry=1, dummy_name='L', dim=4)
+        Lorentz.data = [-1, 1, 1, 1]
+
+        mu, nu, alpha, beta = tensor_indices('\\mu, \\nu, \\alpha, \\beta',
+                                             Lorentz)
+
+        u = TensorHead('u', [Lorentz])
+        u.data = [1, 0, 0, 0]
+
+        F = TensorHead('F', [Lorentz]*2, TensorSymmetry.fully_symmetric(-2))
+        Ex, Ey, Ez, Bx, By, Bz = symbols('E_x E_y E_z B_x B_y B_z')
+        F.data = [
+            [0, Ex, Ey, Ez],
+            [-Ex, 0, Bz, -By],
+            [-Ey, -Bz, 0, Bx],
+            [-Ez, By, -Bx, 0]]
+
+        E = F(mu, nu) * u(-nu)
+
+        assert ((E(mu) * E(nu)).data ==
+                Array([[0, 0, 0, 0],
+                             [0, Ex ** 2, Ex * Ey, Ex * Ez],
+                             [0, Ex * Ey, Ey ** 2, Ey * Ez],
+                             [0, Ex * Ez, Ey * Ez, Ez ** 2]])
+                )
+
+        assert ((E(mu) * E(nu)).canon_bp().data == (E(mu) * E(nu)).data)
+
+        assert ((F(mu, alpha) * F(beta, nu) * u(-alpha) * u(-beta)).data ==
+                - (E(mu) * E(nu)).data
+                )
+        assert ((F(alpha, mu) * F(beta, nu) * u(-alpha) * u(-beta)).data ==
+                (E(mu) * E(nu)).data
+                )
+
+        g = TensorHead('g', [Lorentz]*2, TensorSymmetry.fully_symmetric(2))
+        g.data = Lorentz.data
+
+        # tensor 'perp' is orthogonal to vector 'u'
+        perp = u(mu) * u(nu) + g(mu, nu)
+
+        mul_1 = u(-mu) * perp(mu, nu)
+        assert (mul_1.data == Array([0, 0, 0, 0]))
+
+        mul_2 = u(-mu) * perp(mu, alpha) * perp(nu, beta)
+        assert (mul_2.data == Array.zeros(4, 4, 4))
+
+        Fperp = perp(mu, alpha) * perp(nu, beta) * F(-alpha, -beta)
+        assert (Fperp.data[0, :] == Array([0, 0, 0, 0]))
+        assert (Fperp.data[:, 0] == Array([0, 0, 0, 0]))
+
+        mul_3 = u(-mu) * Fperp(mu, nu)
+        assert (mul_3.data == Array([0, 0, 0, 0]))
+
+        # Test the deleter
+        del g.data
+
+def test_issue_11020_TensAdd_data():
+    with warns_deprecated_sympy():
+        Lorentz = TensorIndexType('Lorentz', metric_symmetry=1, dummy_name='i', dim=2)
+        Lorentz.data = [-1, 1]
+
+        a, b, c, d = tensor_indices('a, b, c, d', Lorentz)
+        i0, i1 = tensor_indices('i_0:2', Lorentz)
+
+        # metric tensor
+        g = TensorHead('g', [Lorentz]*2, TensorSymmetry.fully_symmetric(2))
+        g.data = Lorentz.data
+
+        u = TensorHead('u', [Lorentz])
+        u.data = [1, 0]
+
+        add_1 = g(b, c) * g(d, i0) * u(-i0) - g(b, c) * u(d)
+        assert (add_1.data == Array.zeros(2, 2, 2))
+        # Now let us replace index `d` with `a`:
+        add_2 = g(b, c) * g(a, i0) * u(-i0) - g(b, c) * u(a)
+        assert (add_2.data == Array.zeros(2, 2, 2))
+
+        # some more tests
+        # perp is tensor orthogonal to u^\mu
+        perp = u(a) * u(b) + g(a, b)
+        mul_1 = u(-a) * perp(a, b)
+        assert (mul_1.data == Array([0, 0]))
+
+        mul_2 = u(-c) * perp(c, a) * perp(d, b)
+        assert (mul_2.data == Array.zeros(2, 2, 2))
+
+
+def test_index_iteration():
+    L = TensorIndexType("Lorentz", dummy_name="L")
+    i0, i1, i2, i3, i4 = tensor_indices('i0:5', L)
+    L0 = tensor_indices('L_0', L)
+    L1 = tensor_indices('L_1', L)
+    A = TensorHead("A", [L, L])
+    B = TensorHead("B", [L, L], TensorSymmetry.fully_symmetric(2))
+
+    e1 = A(i0,i2)
+    e2 = A(i0,-i0)
+    e3 = A(i0,i1)*B(i2,i3)
+    e4 = A(i0,i1)*B(i2,-i1)
+    e5 = A(i0,i1)*B(-i0,-i1)
+    e6 = e1 + e4
+
+    assert list(e1._iterate_free_indices) == [(i0, (1, 0)), (i2, (1, 1))]
+    assert list(e1._iterate_dummy_indices) == []
+    assert list(e1._iterate_indices) == [(i0, (1, 0)), (i2, (1, 1))]
+
+    assert list(e2._iterate_free_indices) == []
+    assert list(e2._iterate_dummy_indices) == [(L0, (1, 0)), (-L0, (1, 1))]
+    assert list(e2._iterate_indices) == [(L0, (1, 0)), (-L0, (1, 1))]
+
+    assert list(e3._iterate_free_indices) == [(i0, (0, 1, 0)), (i1, (0, 1, 1)), (i2, (1, 1, 0)), (i3, (1, 1, 1))]
+    assert list(e3._iterate_dummy_indices) == []
+    assert list(e3._iterate_indices) == [(i0, (0, 1, 0)), (i1, (0, 1, 1)), (i2, (1, 1, 0)), (i3, (1, 1, 1))]
+
+    assert list(e4._iterate_free_indices) == [(i0, (0, 1, 0)), (i2, (1, 1, 0))]
+    assert list(e4._iterate_dummy_indices) == [(L0, (0, 1, 1)), (-L0, (1, 1, 1))]
+    assert list(e4._iterate_indices) == [(i0, (0, 1, 0)), (L0, (0, 1, 1)), (i2, (1, 1, 0)), (-L0, (1, 1, 1))]
+
+    assert list(e5._iterate_free_indices) == []
+    assert list(e5._iterate_dummy_indices) == [(L0, (0, 1, 0)), (L1, (0, 1, 1)), (-L0, (1, 1, 0)), (-L1, (1, 1, 1))]
+    assert list(e5._iterate_indices) == [(L0, (0, 1, 0)), (L1, (0, 1, 1)), (-L0, (1, 1, 0)), (-L1, (1, 1, 1))]
+
+    assert list(e6._iterate_free_indices) == [(i0, (0, 0, 1, 0)), (i2, (0, 1, 1, 0)), (i0, (1, 1, 0)), (i2, (1, 1, 1))]
+    assert list(e6._iterate_dummy_indices) == [(L0, (0, 0, 1, 1)), (-L0, (0, 1, 1, 1))]
+    assert list(e6._iterate_indices) == [(i0, (0, 0, 1, 0)), (L0, (0, 0, 1, 1)), (i2, (0, 1, 1, 0)), (-L0, (0, 1, 1, 1)), (i0, (1, 1, 0)), (i2, (1, 1, 1))]
+
+    assert e1.get_indices() == [i0, i2]
+    assert e1.get_free_indices() == [i0, i2]
+    assert e2.get_indices() == [L0, -L0]
+    assert e2.get_free_indices() == []
+    assert e3.get_indices() == [i0, i1, i2, i3]
+    assert e3.get_free_indices() == [i0, i1, i2, i3]
+    assert e4.get_indices() == [i0, L0, i2, -L0]
+    assert e4.get_free_indices() == [i0, i2]
+    assert e5.get_indices() == [L0, L1, -L0, -L1]
+    assert e5.get_free_indices() == []
+
+
+def test_tensor_expand():
+    L = TensorIndexType("L")
+
+    i, j, k = tensor_indices("i j k", L)
+    L_0 = TensorIndex("L_0", L)
+
+    A, B, C, D = tensor_heads("A B C D", [L])
+
+    F = Function("F")
+    x = Symbol("x")
+
+    assert isinstance(Add(A(i), B(i)), TensAdd)
+    assert isinstance(expand(A(i)+B(i)), TensAdd)
+
+    expr = A(i)*(A(-i)+B(-i))
+    assert expr.args == (A(L_0), A(-L_0) + B(-L_0))
+    assert expr != A(i)*A(-i) + A(i)*B(-i)
+    assert expr.expand() == A(i)*A(-i) + A(i)*B(-i)
+    assert str(expr) == "A(L_0)*(A(-L_0) + B(-L_0))"
+
+    expr = A(i)*A(j) + A(i)*B(j)
+    assert str(expr) == "A(i)*A(j) + A(i)*B(j)"
+
+    expr = A(-i)*(A(i)*A(j) + A(i)*B(j)*C(k)*C(-k))
+    assert expr != A(-i)*A(i)*A(j) + A(-i)*A(i)*B(j)*C(k)*C(-k)
+    assert expr.expand() == A(-i)*A(i)*A(j) + A(-i)*A(i)*B(j)*C(k)*C(-k)
+    assert str(expr) == "A(-L_0)*(A(L_0)*A(j) + A(L_0)*B(j)*C(L_1)*C(-L_1))"
+    assert str(expr.canon_bp()) == 'A(j)*A(L_0)*A(-L_0) + A(L_0)*A(-L_0)*B(j)*C(L_1)*C(-L_1)'
+
+    expr = A(-i)*(2*A(i)*A(j) + A(i)*B(j))
+    assert expr.expand() == 2*A(-i)*A(i)*A(j) + A(-i)*A(i)*B(j)
+
+    expr = 2*A(i)*A(-i)
+    assert expr.coeff == 2
+
+    expr = A(i)*(B(j)*C(k) + C(j)*(A(k) + D(k)))
+    assert str(expr) == "A(i)*(B(j)*C(k) + C(j)*(A(k) + D(k)))"
+    assert str(expr.expand()) == "A(i)*B(j)*C(k) + A(i)*C(j)*A(k) + A(i)*C(j)*D(k)"
+
+    assert isinstance(TensMul(3), TensMul)
+    tm = TensMul(3).doit()
+    assert tm == 3
+    assert isinstance(tm, Integer)
+
+    p1 = B(j)*B(-j) + B(j)*C(-j)
+    p2 = C(-i)*p1
+    p3 = A(i)*p2
+    assert p3.expand() == A(i)*C(-i)*B(j)*B(-j) + A(i)*C(-i)*B(j)*C(-j)
+
+    expr = A(i)*(B(-i) + C(-i)*(B(j)*B(-j) + B(j)*C(-j)))
+    assert expr.expand() == A(i)*B(-i) + A(i)*C(-i)*B(j)*B(-j) + A(i)*C(-i)*B(j)*C(-j)
+
+    expr = C(-i)*(B(j)*B(-j) + B(j)*C(-j))
+    assert expr.expand() == C(-i)*B(j)*B(-j) + C(-i)*B(j)*C(-j)
+
+    """
+    Test whether expand correctly handles the case where the coeff of a TensMul
+    is an add. We do not directly check expr_expand == 2*A(i) + F(x)*A(i) since
+    __add__ currently consolidates the coefficients automatically
+    """
+    expr = (2 + F(x))*A(i)
+    expr_expand = expr.expand()
+    assert isinstance(expr_expand, TensAdd)
+    assert expr_expand.args == (2*A(i), F(x)*A(i))
+
+    expr = (2 + F(x))*A(i) + B(i)
+    expr_expand = expr.expand()
+    assert isinstance(expr_expand, TensAdd)
+    assert expr_expand.args == (2*A(i), F(x)*A(i), B(i))
+
+
+def test_tensor_alternative_construction():
+    L = TensorIndexType("L")
+    i0, i1, i2, i3 = tensor_indices('i0:4', L)
+    A = TensorHead("A", [L])
+    x, y = symbols("x y")
+
+    assert A(i0) == A(Symbol("i0"))
+    assert A(-i0) == A(-Symbol("i0"))
+    raises(TypeError, lambda: A(x+y))
+    raises(ValueError, lambda: A(2*x))
+
+
+def test_tensor_replacement():
+    L = TensorIndexType("L")
+    L2 = TensorIndexType("L2", dim=2)
+    i, j, k, l = tensor_indices("i j k l", L)
+    A, B, C, D = tensor_heads("A B C D", [L])
+    H = TensorHead("H", [L, L])
+    K = TensorHead("K", [L]*4)
+
+    expr = H(i, j)
+    repl = {H(i,-j): [[1,2],[3,4]], L: diag(1, -1)}
+    assert expr._extract_data(repl) == ([i, j], Array([[1, -2], [3, -4]]))
+
+    assert expr.replace_with_arrays(repl) == Array([[1, -2], [3, -4]])
+    assert expr.replace_with_arrays(repl, [i, j]) == Array([[1, -2], [3, -4]])
+    assert expr.replace_with_arrays(repl, [i, -j]) == Array([[1, 2], [3, 4]])
+    assert expr.replace_with_arrays(repl, [Symbol("i"), -Symbol("j")]) == Array([[1, 2], [3, 4]])
+    assert expr.replace_with_arrays(repl, [-i, j]) == Array([[1, -2], [-3, 4]])
+    assert expr.replace_with_arrays(repl, [-i, -j]) == Array([[1, 2], [-3, -4]])
+    assert expr.replace_with_arrays(repl, [j, i]) == Array([[1, 3], [-2, -4]])
+    assert expr.replace_with_arrays(repl, [j, -i]) == Array([[1, -3], [-2, 4]])
+    assert expr.replace_with_arrays(repl, [-j, i]) == Array([[1, 3], [2, 4]])
+    assert expr.replace_with_arrays(repl, [-j, -i]) == Array([[1, -3], [2, -4]])
+    # Test stability of optional parameter 'indices'
+    assert expr.replace_with_arrays(repl) == Array([[1, -2], [3, -4]])
+
+    expr = H(i,j)
+    repl = {H(i,j): [[1,2],[3,4]], L: diag(1, -1)}
+    assert expr._extract_data(repl) == ([i, j], Array([[1, 2], [3, 4]]))
+
+    assert expr.replace_with_arrays(repl) == Array([[1, 2], [3, 4]])
+    assert expr.replace_with_arrays(repl, [i, j]) == Array([[1, 2], [3, 4]])
+    assert expr.replace_with_arrays(repl, [i, -j]) == Array([[1, -2], [3, -4]])
+    assert expr.replace_with_arrays(repl, [-i, j]) == Array([[1, 2], [-3, -4]])
+    assert expr.replace_with_arrays(repl, [-i, -j]) == Array([[1, -2], [-3, 4]])
+    assert expr.replace_with_arrays(repl, [j, i]) == Array([[1, 3], [2, 4]])
+    assert expr.replace_with_arrays(repl, [j, -i]) == Array([[1, -3], [2, -4]])
+    assert expr.replace_with_arrays(repl, [-j, i]) == Array([[1, 3], [-2, -4]])
+    assert expr.replace_with_arrays(repl, [-j, -i]) == Array([[1, -3], [-2, 4]])
+
+    # Not the same indices:
+    expr = H(i,k)
+    repl = {H(i,j): [[1,2],[3,4]], L: diag(1, -1)}
+    assert expr._extract_data(repl) == ([i, k], Array([[1, 2], [3, 4]]))
+
+    expr = A(i)*A(-i)
+    repl = {A(i): [1,2], L: diag(1, -1)}
+    assert expr._extract_data(repl) == ([], -3)
+    assert expr.replace_with_arrays(repl, []) == -3
+
+    expr = K(i, j, -j, k)*A(-i)*A(-k)
+    repl = {A(i): [1, 2], K(i,j,k,l): Array([1]*2**4).reshape(2,2,2,2), L: diag(1, -1)}
+    assert expr._extract_data(repl)
+
+    expr = H(j, k)
+    repl = {H(i,j): [[1,2],[3,4]], L: diag(1, -1)}
+    raises(ValueError, lambda: expr._extract_data(repl))
+
+    expr = A(i)
+    repl = {B(i): [1, 2]}
+    raises(ValueError, lambda: expr._extract_data(repl))
+
+    expr = A(i)
+    repl = {A(i): [[1, 2], [3, 4]]}
+    raises(ValueError, lambda: expr._extract_data(repl))
+
+    # TensAdd:
+    expr = A(k)*H(i, j) + B(k)*H(i, j)
+    repl = {A(k): [1], B(k): [1], H(i, j): [[1, 2],[3,4]], L:diag(1,1)}
+    assert expr._extract_data(repl) == ([k, i, j], Array([[[2, 4], [6, 8]]]))
+    assert expr.replace_with_arrays(repl, [k, i, j]) == Array([[[2, 4], [6, 8]]])
+    assert expr.replace_with_arrays(repl, [k, j, i]) == Array([[[2, 6], [4, 8]]])
+
+    expr = A(k)*A(-k) + 100
+    repl = {A(k): [2, 3], L: diag(1, 1)}
+    assert expr.replace_with_arrays(repl, []) == 113
+
+    ## Symmetrization:
+    expr = H(i, j) + H(j, i)
+    repl = {H(i, j): [[1, 2], [3, 4]]}
+    assert expr._extract_data(repl) == ([i, j], Array([[2, 5], [5, 8]]))
+    assert expr.replace_with_arrays(repl, [i, j]) == Array([[2, 5], [5, 8]])
+    assert expr.replace_with_arrays(repl, [j, i]) == Array([[2, 5], [5, 8]])
+
+    ## Anti-symmetrization:
+    expr = H(i, j) - H(j, i)
+    repl = {H(i, j): [[1, 2], [3, 4]]}
+    assert expr.replace_with_arrays(repl, [i, j]) == Array([[0, -1], [1, 0]])
+    assert expr.replace_with_arrays(repl, [j, i]) == Array([[0, 1], [-1, 0]])
+
+    # Tensors with contractions in replacements:
+    expr = K(i, j, k, -k)
+    repl = {K(i, j, k, -k): [[1, 2], [3, 4]]}
+    assert expr._extract_data(repl) == ([i, j], Array([[1, 2], [3, 4]]))
+
+    expr = H(i, -i)
+    repl = {H(i, -i): 42}
+    assert expr._extract_data(repl) == ([], 42)
+
+    expr = H(i, -i)
+    repl = {
+        H(-i, -j): Array([[1, 0, 0, 0], [0, -1, 0, 0], [0, 0, -1, 0], [0, 0, 0, -1]]),
+        L: Array([[1, 0, 0, 0], [0, -1, 0, 0], [0, 0, -1, 0], [0, 0, 0, -1]]),
+    }
+    assert expr._extract_data(repl) == ([], 4)
+
+    # Replace with array, raise exception if indices are not compatible:
+    expr = A(i)*A(j)
+    repl = {A(i): [1, 2]}
+    raises(ValueError, lambda: expr.replace_with_arrays(repl, [j]))
+
+    # Raise exception if array dimension is not compatible:
+    expr = A(i)
+    repl = {A(i): [[1, 2]]}
+    raises(ValueError, lambda: expr.replace_with_arrays(repl, [i]))
+
+    # TensorIndexType with dimension, wrong dimension in replacement array:
+    u1, u2, u3 = tensor_indices("u1:4", L2)
+    U = TensorHead("U", [L2])
+    expr = U(u1)*U(-u2)
+    repl = {U(u1): [[1]]}
+    raises(ValueError, lambda: expr.replace_with_arrays(repl, [u1, -u2]))
+
+
+def test_rewrite_tensor_to_Indexed():
+    L = TensorIndexType("L", dim=4)
+    A = TensorHead("A", [L]*4)
+    B = TensorHead("B", [L])
+
+    i0, i1, i2, i3 = symbols("i0:4")
+    L_0, L_1 = symbols("L_0:2")
+
+    a1 = A(i0, i1, i2, i3)
+    assert a1.rewrite(Indexed) == Indexed(Symbol("A"), i0, i1, i2, i3)
+
+    a2 = A(i0, -i0, i2, i3)
+    assert a2.rewrite(Indexed) == Sum(Indexed(Symbol("A"), L_0, L_0, i2, i3), (L_0, 0, 3))
+
+    a3 = a2 + A(i2, i3, i0, -i0)
+    assert a3.rewrite(Indexed) == \
+        Sum(Indexed(Symbol("A"), L_0, L_0, i2, i3), (L_0, 0, 3)) +\
+        Sum(Indexed(Symbol("A"), i2, i3, L_0, L_0), (L_0, 0, 3))
+
+    b1 = B(-i0)*a1
+    assert b1.rewrite(Indexed) == Sum(Indexed(Symbol("B"), L_0)*Indexed(Symbol("A"), L_0, i1, i2, i3), (L_0, 0, 3))
+
+    b2 = B(-i3)*a2
+    assert b2.rewrite(Indexed) == Sum(Indexed(Symbol("B"), L_1)*Indexed(Symbol("A"), L_0, L_0, i2, L_1), (L_0, 0, 3), (L_1, 0, 3))
+
+def test_tensor_matching():
+    """
+    Test match and replace with the pattern being a WildTensor or a WildTensorIndex
+    """
+    R3 = TensorIndexType('R3', dim=3)
+    p, q, r = tensor_indices("p q r", R3)
+    a,b,c = symbols("a b c", cls = WildTensorIndex, tensor_index_type=R3, ignore_updown=True)
+    g = WildTensorIndex("g", R3)
+    delta = R3.delta
+    eps = R3.epsilon
+    K = TensorHead("K", [R3])
+    V = TensorHead("V", [R3])
+    A = TensorHead("A", [R3, R3])
+    W = WildTensorHead('W', unordered_indices=True)
+    U = WildTensorHead('U')
+
+    assert a.matches(q) == {a:q}
+    assert a.matches(-q) == {a:-q}
+    assert g.matches(-q) == None
+    assert g.matches(q) == {g:q}
+    assert eps(p,-a,a).matches( eps(p,q,r) ) == None
+    assert eps(p,-b,a).matches( eps(p,q,r) ) == {a: r, -b: q}
+    assert eps(p,-q,r).replace(eps(a,b,c), 1) == 1
+    assert W().matches( K(p)*V(q) ) == {W(): K(p)*V(q)}
+    assert W(a).matches( K(p) ) == {a:p, W(a).head: _WildTensExpr(K(p))}
+    assert W(a,p).matches( K(p)*V(q) ) == {a:q, W(a,p).head: _WildTensExpr(K(p)*V(q))}
+    assert W(p,q).matches( K(p)*V(q) ) == {W(p,q).head: _WildTensExpr(K(p)*V(q))}
+    assert W(p,q).matches( A(q,p) ) == {W(p,q).head: _WildTensExpr(A(q, p))}
+    assert U(p,q).matches( A(q,p) ) == None
+    assert ( K(q)*K(p) ).replace( W(q,p), 1) == 1
+
+    #Some tests for matching without Wild
+    assert delta(p,q).matches(delta(q,p)) == {}
+    assert eps(p,q,r).matches(eps(q,p,r)) is None
+    assert eps(p,q,r).matches(eps(q,r,p)) == {}
+
+def test_TensAdd_matching():
+    """
+    Test match and replace with the pattern being a TensAdd
+    """
+    R3 = TensorIndexType('R3', dim=3)
+    p, q = tensor_indices("p q", R3)
+    K = TensorHead("K", [R3])
+    V = TensorHead("V", [R3])
+    W = WildTensorHead('W', unordered_indices=True)
+
+    assert ( K(p)*K(q) + V(p)*V(q) ).matches( K(p)*K(q) + V(p)*V(q) ) == {}
+    assert ( K(p)*K(q) + V(p)*V(q) ).matches( K(p)*K(q) + V(p)*V(q) + K(p)*V(q) + V(p)*K(q) ) is None
+    assert ( K(p)*K(q) + V(p)*V(q) + K(p)*V(q) + K(q)*V(p) ).replace(
+        W(p,q) + K(p)*K(q) + V(p)*V(q),
+        W(p,q) + 3*K(p)*V(q)
+        ).doit() == K(q)*V(p) + 4*K(p)*V(q)
+
+def test_TensMul_matching():
+    """
+    Test match and replace with the pattern being a TensMul
+    """
+    R3 = TensorIndexType('R3', dim=3)
+    p, q, r, s, t = tensor_indices("p q r s t", R3)
+    wi = Wild("wi")
+    a,b,c,d,e,f = symbols("a b c d e f", cls = WildTensorIndex, tensor_index_type=R3, ignore_updown=True)
+    delta = R3.delta
+    eps = R3.epsilon
+    K = TensorHead("K", [R3])
+    V = TensorHead("V", [R3])
+    W = WildTensorHead('W', unordered_indices=True)
+    U = WildTensorHead('U')
+    k = Symbol("K")
+
+    assert ( wi*K(p) ).matches( K(p) ) == {wi: 1}
+    assert ( wi * eps(p,q,r) ).matches(eps(p,r,q)) == {wi:-1}
+    assert ( K(p)*V(-p) ).replace( W(a)*V(-a), 1) == 1
+    assert ( K(q)*K(p)*V(-p) ).replace( W(q,a)*V(-a), 1) == 1
+    assert ( K(p)*V(-p) ).replace( K(-a)*V(a), 1 ) == 1
+    assert ( K(q)*K(p)*V(-p) ).replace( W(q)*U(p)*V(-p), 1) == 1
+    assert (
+        (K(p)*V(q)).replace(W()*K(p)*V(q), W()*V(p)*V(q)).doit()
+        == V(p)*V(q)
+        )
+    assert (
+        ( eps(r,p,q)*eps(-r,-s,-t) ).replace(
+            eps(e,a,b)*eps(-e,c,d),
+            delta(a,c)*delta(b,d) - delta(a,d)*delta(b,c),
+            ).doit().canon_bp()
+        == delta(p,-s)*delta(q,-t) - delta(p,-t)*delta(q,-s)
+        )
+    assert (
+        ( eps(r,p,q)*eps(-r,-p,-q) ).replace(
+            eps(c,a,b)*eps(-c,d,f),
+            delta(a,d)*delta(b,f) - delta(a,f)*delta(b,d),
+            ).contract_delta(delta).doit()
+        == 6
+        )
+    assert ( V(-p)*V(q)*V(-q) ).replace( wi*W()*V(a)*V(-a), wi*W() ).doit() == V(-p)
+    assert ( k**4*K(r)*K(-r) ).replace( wi*W()*K(a)*K(-a), wi*W()*k**2 ).doit() == k**6
+
+    #Multiple occurrence of WildTensor in value
+    assert (
+        ( K(p)*V(q) ).replace(W(q)*K(p), W(p)*W(q))
+        == V(p)*V(q)
+        )
+    assert (
+        ( K(p)*V(q)*V(r) ).replace(W(q,r)*K(p), W(p,r)*W(q,s)*V(-s) )
+        == V(p)*V(r)*V(q)*V(s)*V(-s)
+        )
+
+    #Edge case involving automatic index relabelling
+    D0, D1, D2, D3 = tensor_indices("R_0 R_1 R_2 R_3", R3)
+    expr = delta(-D0, -D1)*K(D2)*K(D3)*K(-D3)
+    m = ( W()*K(a)*K(-a) ).matches(expr)
+    assert D2 not in m.values()
+
+def test_TensMul_subs():
+    """
+    Test subs and xreplace in TensMul. See bug #24337
+    """
+    R3 = TensorIndexType('R3', dim=3)
+    p, q, r = tensor_indices("p q r", R3)
+    K = TensorHead("K", [R3])
+    V = TensorHead("V", [R3])
+    A = TensorHead("A", [R3, R3])
+    C0 = TensorIndex(R3.dummy_name + "_0", R3, True)
+    a = WildTensorIndex("a", R3, ignore_updown=True)
+
+    assert ( K(p)*V(r)*K(-p) ).subs({V(r): K(q)*K(-q)}) == K(p)*K(q)*K(-q)*K(-p)
+    assert ( K(p)*V(r)*K(-p) ).xreplace({V(r): K(q)*K(-q)}) == K(p)*K(q)*K(-q)*K(-p)
+    assert ( K(p)*V(r) ).xreplace({p: C0, V(r): K(q)*K(-q)}) == K(C0)*K(q)*K(-q)
+    assert ( K(p)*A(q,-q)*K(-p) ).doit() == K(p)*A(q,-q)*K(-p)
+    assert ( K(p)*V(-p) ).replace( K(a), V(a)*V(q)*V(-q) ) == V(p)*V(q)*V(-q)*V(-p)
+
+
+def test_tensorsymmetry():
+    with warns_deprecated_sympy():
+        tensorsymmetry([1]*2)
+
+def test_tensorhead():
+    with warns_deprecated_sympy():
+        tensorhead('A', [])
+
+def test_TensorType():
+    with warns_deprecated_sympy():
+        sym2 = TensorSymmetry.fully_symmetric(2)
+        Lorentz = TensorIndexType('Lorentz')
+        S2 = TensorType([Lorentz]*2, sym2)
+        assert isinstance(S2, TensorType)
+
+def test_dummy_fmt():
+    with warns_deprecated_sympy():
+        TensorIndexType('Lorentz', dummy_fmt='L')
+
+def test_postprocessor():
+    """
+    Test if substituting a Tensor into a Mul or Add automatically converts it
+    to TensMul or TensAdd respectively. See github issue #25051
+    """
+    R3 = TensorIndexType('R3', dim=3)
+    i = tensor_indices("i", R3)
+    K = TensorHead("K", [R3])
+    x,y,z = symbols("x y z")
+
+    assert isinstance((x*2).xreplace({x: K(i)}), TensMul)
+    assert isinstance((x+2).xreplace({x: K(i)*K(-i)}), TensAdd)
+
+    assert isinstance((x*2).subs({x: K(i)}), TensMul)
+    assert isinstance((x+2).subs({x: K(i)*K(-i)}), TensAdd)
+
+    assert isinstance((x*2).replace(x, K(i)), TensMul)
+    assert isinstance((x+2).replace(x, K(i)*K(-i)), TensAdd)
+
+def test_TensMul_nocoeff():
+    """
+    Ensure that for any TensMul instance, self.coeff * self.nocoeff == self
+    """
+
+    R3 = TensorIndexType('R3', dim=3)
+    i, j = tensor_indices("i j", R3)
+    K = TensorHead("K", [R3])
+    P = TensorHead("P", [R3])
+
+    expr = TensMul(2, K(i), P(j))
+    assert expr.coeff * expr.nocoeff == expr
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/tests/test_tensor_element.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/tests/test_tensor_element.py
new file mode 100644
index 0000000000000000000000000000000000000000..21a35da334a733a472649fce756bbabc84f4827d
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/tests/test_tensor_element.py
@@ -0,0 +1,31 @@
+from sympy.tensor.tensor import (Tensor, TensorIndexType, TensorSymmetry,
+        tensor_indices, TensorHead, TensorElement)
+from sympy.tensor import Array
+from sympy.core.symbol import Symbol
+
+
+def test_tensor_element():
+    L = TensorIndexType("L")
+    i, j, k, l, m, n = tensor_indices("i j k l m n", L)
+
+    A = TensorHead("A", [L, L], TensorSymmetry.no_symmetry(2))
+
+    a = A(i, j)
+
+    assert isinstance(TensorElement(a, {}), Tensor)
+    assert isinstance(TensorElement(a, {k: 1}), Tensor)
+
+    te1 = TensorElement(a, {Symbol("i"): 1})
+    assert te1.free == [(j, 0)]
+    assert te1.get_free_indices() == [j]
+    assert te1.dum == []
+
+    te2 = TensorElement(a, {i: 1})
+    assert te2.free == [(j, 0)]
+    assert te2.get_free_indices() == [j]
+    assert te2.dum == []
+
+    assert te1 == te2
+
+    array = Array([[1, 2], [3, 4]])
+    assert te1.replace_with_arrays({A(i, j): array}, [j]) == array[1, :]
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/tests/test_tensor_operators.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/tests/test_tensor_operators.py
new file mode 100644
index 0000000000000000000000000000000000000000..e0c801d958341aff7d27c6146f4cfa70051b3a54
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/tensor/tests/test_tensor_operators.py
@@ -0,0 +1,464 @@
+from sympy import sin, cos
+from sympy.testing.pytest import raises
+
+from sympy.tensor.toperators import PartialDerivative
+from sympy.tensor.tensor import (TensorIndexType,
+                                 tensor_indices,
+                                 TensorHead, tensor_heads)
+from sympy.core.numbers import Rational
+from sympy.core.symbol import symbols
+from sympy.matrices.dense import diag
+from sympy.tensor.array import Array
+
+from sympy.core.random import randint
+
+
+L = TensorIndexType("L")
+i, j, k, m, m1, m2, m3, m4 = tensor_indices("i j k m m1 m2 m3 m4", L)
+i0 = tensor_indices("i0", L)
+L_0, L_1 = tensor_indices("L_0 L_1", L)
+
+A, B, C, D = tensor_heads("A B C D", [L])
+
+H = TensorHead("H", [L, L])
+
+
+def test_invalid_partial_derivative_valence():
+    raises(ValueError, lambda: PartialDerivative(C(j), D(-j)))
+    raises(ValueError, lambda: PartialDerivative(C(-j), D(j)))
+
+
+def test_tensor_partial_deriv():
+    # Test flatten:
+    expr = PartialDerivative(PartialDerivative(A(i), A(j)), A(k))
+    assert expr == PartialDerivative(A(i), A(j), A(k))
+    assert expr.expr == A(i)
+    assert expr.variables == (A(j), A(k))
+    assert expr.get_indices() == [i, -j, -k]
+    assert expr.get_free_indices() == [i, -j, -k]
+
+    expr = PartialDerivative(PartialDerivative(A(i), A(j)), A(i))
+    assert expr.expr == A(L_0)
+    assert expr.variables == (A(j), A(L_0))
+
+    expr1 = PartialDerivative(A(i), A(j))
+    assert expr1.expr == A(i)
+    assert expr1.variables == (A(j),)
+
+    expr2 = A(i)*PartialDerivative(H(k, -i), A(j))
+    assert expr2.get_indices() == [L_0, k, -L_0, -j]
+
+    expr2b = A(i)*PartialDerivative(H(k, -i), A(-j))
+    assert expr2b.get_indices() == [L_0, k, -L_0, j]
+
+    expr3 = A(i)*PartialDerivative(B(k)*C(-i) + 3*H(k, -i), A(j))
+    assert expr3.get_indices() == [L_0, k, -L_0, -j]
+
+    expr4 = (A(i) + B(i))*PartialDerivative(C(j), D(j))
+    assert expr4.get_indices() == [i, L_0, -L_0]
+
+    expr4b = (A(i) + B(i))*PartialDerivative(C(-j), D(-j))
+    assert expr4b.get_indices() == [i, -L_0, L_0]
+
+    expr5 = (A(i) + B(i))*PartialDerivative(C(-i), D(j))
+    assert expr5.get_indices() == [L_0, -L_0, -j]
+
+
+def test_replace_arrays_partial_derivative():
+
+    x, y, z, t = symbols("x y z t")
+
+    expr = PartialDerivative(A(i), B(j))
+    repl = expr.replace_with_arrays({A(i): [sin(x)*cos(y), x**3*y**2], B(i): [x, y]})
+    assert repl == Array([[cos(x)*cos(y), -sin(x)*sin(y)], [3*x**2*y**2, 2*x**3*y]])
+    repl = expr.replace_with_arrays({A(i): [sin(x)*cos(y), x**3*y**2], B(i): [x, y]}, [-j, i])
+    assert repl == Array([[cos(x)*cos(y), 3*x**2*y**2], [-sin(x)*sin(y), 2*x**3*y]])
+
+    # d(A^i)/d(A_j) = d(g^ik A_k)/d(A_j) = g^ik delta_jk
+    expr = PartialDerivative(A(i), A(-j))
+    assert expr.get_free_indices() == [i, j]
+    assert expr.get_indices() == [i, j]
+    assert expr.replace_with_arrays({A(i): [x, y], L: diag(1, 1)}, [i, j]) == Array([[1, 0], [0, 1]])
+    assert expr.replace_with_arrays({A(i): [x, y], L: diag(1, -1)}, [i, j]) == Array([[1, 0], [0, -1]])
+    assert expr.replace_with_arrays({A(-i): [x, y], L: diag(1, 1)}, [i, j]) == Array([[1, 0], [0, 1]])
+    assert expr.replace_with_arrays({A(-i): [x, y], L: diag(1, -1)}, [i, j]) == Array([[1, 0], [0, -1]])
+
+    expr = PartialDerivative(A(i), A(j))
+    assert expr.get_free_indices() == [i, -j]
+    assert expr.get_indices() == [i, -j]
+    assert expr.replace_with_arrays({A(i): [x, y]}, [i, -j]) == Array([[1, 0], [0, 1]])
+    assert expr.replace_with_arrays({A(i): [x, y], L: diag(1, 1)}, [i, -j]) == Array([[1, 0], [0, 1]])
+    assert expr.replace_with_arrays({A(i): [x, y], L: diag(1, -1)}, [i, -j]) == Array([[1, 0], [0, 1]])
+    assert expr.replace_with_arrays({A(-i): [x, y], L: diag(1, 1)}, [i, -j]) == Array([[1, 0], [0, 1]])
+    assert expr.replace_with_arrays({A(-i): [x, y], L: diag(1, -1)}, [i, -j]) == Array([[1, 0], [0, 1]])
+
+    expr = PartialDerivative(A(-i), A(-j))
+    assert expr.get_free_indices() == [-i, j]
+    assert expr.get_indices() == [-i, j]
+    assert expr.replace_with_arrays({A(-i): [x, y]}, [-i, j]) == Array([[1, 0], [0, 1]])
+    assert expr.replace_with_arrays({A(-i): [x, y], L: diag(1, 1)}, [-i, j]) == Array([[1, 0], [0, 1]])
+    assert expr.replace_with_arrays({A(-i): [x, y], L: diag(1, -1)}, [-i, j]) == Array([[1, 0], [0, 1]])
+    assert expr.replace_with_arrays({A(i): [x, y], L: diag(1, 1)}, [-i, j]) == Array([[1, 0], [0, 1]])
+    assert expr.replace_with_arrays({A(i): [x, y], L: diag(1, -1)}, [-i, j]) == Array([[1, 0], [0, 1]])
+
+    expr = PartialDerivative(A(i), A(i))
+    assert expr.get_free_indices() == []
+    assert expr.get_indices() == [L_0, -L_0]
+    assert expr.replace_with_arrays({A(i): [x, y], L: diag(1, 1)}, []) == 2
+    assert expr.replace_with_arrays({A(i): [x, y], L: diag(1, -1)}, []) == 2
+
+    expr = PartialDerivative(A(-i), A(-i))
+    assert expr.get_free_indices() == []
+    assert expr.get_indices() == [-L_0, L_0]
+    assert expr.replace_with_arrays({A(i): [x, y], L: diag(1, 1)}, []) == 2
+    assert expr.replace_with_arrays({A(i): [x, y], L: diag(1, -1)}, []) == 2
+
+    expr = PartialDerivative(H(i, j) + H(j, i), A(i))
+    assert expr.get_indices() == [L_0, j, -L_0]
+    assert expr.get_free_indices() == [j]
+
+    expr = PartialDerivative(H(i, j) + H(j, i), A(k))*B(-i)
+    assert expr.get_indices() == [L_0, j, -k, -L_0]
+    assert expr.get_free_indices() == [j, -k]
+
+    expr = PartialDerivative(A(i)*(H(-i, j) + H(j, -i)), A(j))
+    assert expr.get_indices() == [L_0, -L_0, L_1, -L_1]
+    assert expr.get_free_indices() == []
+
+    expr = A(j)*A(-j) + expr
+    assert expr.get_indices() == [L_0, -L_0, L_1, -L_1]
+    assert expr.get_free_indices() == []
+
+    expr = A(i)*(B(j)*PartialDerivative(C(-j), D(i)) + C(j)*PartialDerivative(D(-j), B(i)))
+    assert expr.get_indices() == [L_0, L_1, -L_1, -L_0]
+    assert expr.get_free_indices() == []
+
+    expr = A(i)*PartialDerivative(C(-j), D(i))
+    assert expr.get_indices() == [L_0, -j, -L_0]
+    assert expr.get_free_indices() == [-j]
+
+
+def test_expand_partial_derivative_sum_rule():
+    tau = symbols("tau")
+
+    # check sum rule for D(tensor, symbol)
+    expr1aa = PartialDerivative(A(i), tau)
+
+    assert expr1aa._expand_partial_derivative() == PartialDerivative(A(i), tau)
+
+    expr1ab = PartialDerivative(A(i) + B(i), tau)
+
+    assert (expr1ab._expand_partial_derivative() ==
+            PartialDerivative(A(i), tau) +
+            PartialDerivative(B(i), tau))
+
+    expr1ac = PartialDerivative(A(i) + B(i) + C(i), tau)
+
+    assert (expr1ac._expand_partial_derivative() ==
+            PartialDerivative(A(i), tau) +
+            PartialDerivative(B(i), tau) +
+            PartialDerivative(C(i), tau))
+
+    # check sum rule for D(tensor, D(j))
+    expr1ba = PartialDerivative(A(i), D(j))
+
+    assert expr1ba._expand_partial_derivative() ==\
+        PartialDerivative(A(i), D(j))
+    expr1bb = PartialDerivative(A(i) + B(i), D(j))
+
+    assert (expr1bb._expand_partial_derivative() ==
+            PartialDerivative(A(i), D(j)) +
+            PartialDerivative(B(i), D(j)))
+
+    expr1bc = PartialDerivative(A(i) + B(i) + C(i), D(j))
+    assert expr1bc._expand_partial_derivative() ==\
+        PartialDerivative(A(i), D(j))\
+        + PartialDerivative(B(i), D(j))\
+        + PartialDerivative(C(i), D(j))
+
+    # check sum rule for D(tensor, H(j, k))
+    expr1ca = PartialDerivative(A(i), H(j, k))
+    assert expr1ca._expand_partial_derivative() ==\
+        PartialDerivative(A(i), H(j, k))
+    expr1cb = PartialDerivative(A(i) + B(i), H(j, k))
+    assert (expr1cb._expand_partial_derivative() ==
+            PartialDerivative(A(i), H(j, k))
+            + PartialDerivative(B(i), H(j, k)))
+    expr1cc = PartialDerivative(A(i) + B(i) + C(i), H(j, k))
+    assert (expr1cc._expand_partial_derivative() ==
+            PartialDerivative(A(i), H(j, k))
+            + PartialDerivative(B(i), H(j, k))
+            + PartialDerivative(C(i), H(j, k)))
+
+    # check sum rule for D(D(tensor, D(j)), H(k, m))
+    expr1da = PartialDerivative(A(i), (D(j), H(k, m)))
+    assert expr1da._expand_partial_derivative() ==\
+        PartialDerivative(A(i), (D(j), H(k, m)))
+    expr1db = PartialDerivative(A(i) + B(i), (D(j), H(k, m)))
+    assert expr1db._expand_partial_derivative() ==\
+        PartialDerivative(A(i), (D(j), H(k, m)))\
+        + PartialDerivative(B(i), (D(j), H(k, m)))
+    expr1dc = PartialDerivative(A(i) + B(i) + C(i), (D(j), H(k, m)))
+    assert expr1dc._expand_partial_derivative() ==\
+        PartialDerivative(A(i), (D(j), H(k, m)))\
+        + PartialDerivative(B(i), (D(j), H(k, m)))\
+        + PartialDerivative(C(i), (D(j), H(k, m)))
+
+
+def test_expand_partial_derivative_constant_factor_rule():
+    nneg = randint(0, 1000)
+    pos = randint(1, 1000)
+    neg = -randint(1, 1000)
+
+    c1 = Rational(nneg, pos)
+    c2 = Rational(neg, pos)
+    c3 = Rational(nneg, neg)
+
+    expr2a = PartialDerivative(nneg*A(i), D(j))
+    assert expr2a._expand_partial_derivative() ==\
+        nneg*PartialDerivative(A(i), D(j))
+
+    expr2b = PartialDerivative(neg*A(i), D(j))
+    assert expr2b._expand_partial_derivative() ==\
+        neg*PartialDerivative(A(i), D(j))
+
+    expr2ca = PartialDerivative(c1*A(i), D(j))
+    assert expr2ca._expand_partial_derivative() ==\
+        c1*PartialDerivative(A(i), D(j))
+
+    expr2cb = PartialDerivative(c2*A(i), D(j))
+    assert expr2cb._expand_partial_derivative() ==\
+        c2*PartialDerivative(A(i), D(j))
+
+    expr2cc = PartialDerivative(c3*A(i), D(j))
+    assert expr2cc._expand_partial_derivative() ==\
+        c3*PartialDerivative(A(i), D(j))
+
+
+def test_expand_partial_derivative_full_linearity():
+    nneg = randint(0, 1000)
+    pos = randint(1, 1000)
+    neg = -randint(1, 1000)
+
+    c1 = Rational(nneg, pos)
+    c2 = Rational(neg, pos)
+    c3 = Rational(nneg, neg)
+
+    # check full linearity
+    p = PartialDerivative(42, D(j))
+    assert p and not p._expand_partial_derivative()
+
+    expr3a = PartialDerivative(nneg*A(i) + pos*B(i), D(j))
+    assert expr3a._expand_partial_derivative() ==\
+        nneg*PartialDerivative(A(i), D(j))\
+        + pos*PartialDerivative(B(i), D(j))
+
+    expr3b = PartialDerivative(nneg*A(i) + neg*B(i), D(j))
+    assert expr3b._expand_partial_derivative() ==\
+        nneg*PartialDerivative(A(i), D(j))\
+        + neg*PartialDerivative(B(i), D(j))
+
+    expr3c = PartialDerivative(neg*A(i) + pos*B(i), D(j))
+    assert expr3c._expand_partial_derivative() ==\
+        neg*PartialDerivative(A(i), D(j))\
+        + pos*PartialDerivative(B(i), D(j))
+
+    expr3d = PartialDerivative(c1*A(i) + c2*B(i), D(j))
+    assert expr3d._expand_partial_derivative() ==\
+        c1*PartialDerivative(A(i), D(j))\
+        + c2*PartialDerivative(B(i), D(j))
+
+    expr3e = PartialDerivative(c2*A(i) + c1*B(i), D(j))
+    assert expr3e._expand_partial_derivative() ==\
+        c2*PartialDerivative(A(i), D(j))\
+        + c1*PartialDerivative(B(i), D(j))
+
+    expr3f = PartialDerivative(c2*A(i) + c3*B(i), D(j))
+    assert expr3f._expand_partial_derivative() ==\
+        c2*PartialDerivative(A(i), D(j))\
+        + c3*PartialDerivative(B(i), D(j))
+
+    expr3g = PartialDerivative(c3*A(i) + c2*B(i), D(j))
+    assert expr3g._expand_partial_derivative() ==\
+        c3*PartialDerivative(A(i), D(j))\
+        + c2*PartialDerivative(B(i), D(j))
+
+    expr3h = PartialDerivative(c3*A(i) + c1*B(i), D(j))
+    assert expr3h._expand_partial_derivative() ==\
+        c3*PartialDerivative(A(i), D(j))\
+        + c1*PartialDerivative(B(i), D(j))
+
+    expr3i = PartialDerivative(c1*A(i) + c3*B(i), D(j))
+    assert expr3i._expand_partial_derivative() ==\
+        c1*PartialDerivative(A(i), D(j))\
+        + c3*PartialDerivative(B(i), D(j))
+
+
+def test_expand_partial_derivative_product_rule():
+    # check product rule
+    expr4a = PartialDerivative(A(i)*B(j), D(k))
+
+    assert expr4a._expand_partial_derivative() == \
+        PartialDerivative(A(i), D(k))*B(j)\
+        + A(i)*PartialDerivative(B(j), D(k))
+
+    expr4b = PartialDerivative(A(i)*B(j)*C(k), D(m))
+    assert expr4b._expand_partial_derivative() ==\
+        PartialDerivative(A(i), D(m))*B(j)*C(k)\
+        + A(i)*PartialDerivative(B(j), D(m))*C(k)\
+        + A(i)*B(j)*PartialDerivative(C(k), D(m))
+
+    expr4c = PartialDerivative(A(i)*B(j), C(k), D(m))
+    assert expr4c._expand_partial_derivative() ==\
+        PartialDerivative(A(i), C(k), D(m))*B(j) \
+        + PartialDerivative(A(i), C(k))*PartialDerivative(B(j), D(m))\
+        + PartialDerivative(A(i), D(m))*PartialDerivative(B(j), C(k))\
+        + A(i)*PartialDerivative(B(j), C(k), D(m))
+
+
+def test_eval_partial_derivative_expr_by_symbol():
+
+    tau, alpha = symbols("tau alpha")
+
+    expr1 = PartialDerivative(tau**alpha, tau)
+    assert expr1._perform_derivative() == alpha * 1 / tau * tau ** alpha
+
+    expr2 = PartialDerivative(2*tau + 3*tau**4, tau)
+    assert expr2._perform_derivative() == 2 + 12 * tau ** 3
+
+    expr3 = PartialDerivative(2*tau + 3*tau**4, alpha)
+    assert expr3._perform_derivative() == 0
+
+
+def test_eval_partial_derivative_single_tensors_by_scalar():
+
+    tau, mu = symbols("tau mu")
+
+    expr = PartialDerivative(tau**mu, tau)
+    assert expr._perform_derivative() == mu*tau**mu/tau
+
+    expr1a = PartialDerivative(A(i), tau)
+    assert expr1a._perform_derivative() == 0
+
+    expr1b = PartialDerivative(A(-i), tau)
+    assert expr1b._perform_derivative() == 0
+
+    expr2a = PartialDerivative(H(i, j), tau)
+    assert expr2a._perform_derivative() == 0
+
+    expr2b = PartialDerivative(H(i, -j), tau)
+    assert expr2b._perform_derivative() == 0
+
+    expr2c = PartialDerivative(H(-i, j), tau)
+    assert expr2c._perform_derivative() == 0
+
+    expr2d = PartialDerivative(H(-i, -j), tau)
+    assert expr2d._perform_derivative() == 0
+
+
+def test_eval_partial_derivative_single_1st_rank_tensors_by_tensor():
+
+    expr1 = PartialDerivative(A(i), A(j))
+    assert expr1._perform_derivative() - L.delta(i, -j) == 0
+
+    expr2 = PartialDerivative(A(i), A(-j))
+    assert expr2._perform_derivative() - L.metric(i, L_0) * L.delta(-L_0, j) == 0
+
+    expr3 = PartialDerivative(A(-i), A(-j))
+    assert expr3._perform_derivative() - L.delta(-i, j) == 0
+
+    expr4 = PartialDerivative(A(-i), A(j))
+    assert expr4._perform_derivative() - L.metric(-i, -L_0) * L.delta(L_0, -j) == 0
+
+    expr5 = PartialDerivative(A(i), B(j))
+    expr6 = PartialDerivative(A(i), C(j))
+    expr7 = PartialDerivative(A(i), D(j))
+    expr8 = PartialDerivative(A(i), H(j, k))
+    assert expr5._perform_derivative() == 0
+    assert expr6._perform_derivative() == 0
+    assert expr7._perform_derivative() == 0
+    assert expr8._perform_derivative() == 0
+
+    expr9 = PartialDerivative(A(i), A(i))
+    assert expr9._perform_derivative() - L.delta(L_0, -L_0) == 0
+
+    expr10 = PartialDerivative(A(-i), A(-i))
+    assert expr10._perform_derivative() - L.delta(-L_0, L_0) == 0
+
+
+def test_eval_partial_derivative_single_2nd_rank_tensors_by_tensor():
+
+    expr1 = PartialDerivative(H(i, j), H(m, m1))
+    assert expr1._perform_derivative() - L.delta(i, -m) * L.delta(j, -m1) == 0
+
+    expr2 = PartialDerivative(H(i, j), H(-m, m1))
+    assert expr2._perform_derivative() - L.metric(i, L_0) * L.delta(-L_0, m) * L.delta(j, -m1) == 0
+
+    expr3 = PartialDerivative(H(i, j), H(m, -m1))
+    assert expr3._perform_derivative() - L.delta(i, -m) * L.metric(j, L_0) * L.delta(-L_0, m1) == 0
+
+    expr4 = PartialDerivative(H(i, j), H(-m, -m1))
+    assert expr4._perform_derivative() - L.metric(i, L_0) * L.delta(-L_0, m) * L.metric(j, L_1) * L.delta(-L_1, m1) == 0
+
+def test_eval_partial_derivative_divergence_type():
+    expr1a = PartialDerivative(A(i), A(i))
+    expr1b = PartialDerivative(A(i), A(k))
+    expr1c = PartialDerivative(L.delta(-i, k) * A(i), A(k))
+
+    assert (expr1a._perform_derivative()
+            - (L.delta(-i, k) * expr1b._perform_derivative())).contract_delta(L.delta) == 0
+
+    assert (expr1a._perform_derivative()
+            - expr1c._perform_derivative()).contract_delta(L.delta) == 0
+
+    expr2a = PartialDerivative(H(i, j), H(i, j))
+    expr2b = PartialDerivative(H(i, j), H(k, m))
+    expr2c = PartialDerivative(L.delta(-i, k) * L.delta(-j, m) * H(i, j), H(k, m))
+
+    assert (expr2a._perform_derivative()
+            - (L.delta(-i, k) * L.delta(-j, m) * expr2b._perform_derivative())).contract_delta(L.delta) == 0
+
+    assert (expr2a._perform_derivative()
+            - expr2c._perform_derivative()).contract_delta(L.delta) == 0
+
+
+def test_eval_partial_derivative_expr1():
+
+    tau, alpha = symbols("tau alpha")
+
+    # this is only some special expression
+    # tested: vector derivative
+    # tested: scalar derivative
+    # tested: tensor derivative
+    base_expr1 = A(i)*H(-i, j) + A(i)*A(-i)*A(j) + tau**alpha*A(j)
+
+    tensor_derivative = PartialDerivative(base_expr1, H(k, m))._perform_derivative()
+    vector_derivative = PartialDerivative(base_expr1, A(k))._perform_derivative()
+    scalar_derivative = PartialDerivative(base_expr1, tau)._perform_derivative()
+
+    assert (tensor_derivative - A(L_0)*L.metric(-L_0, -L_1)*L.delta(L_1, -k)*L.delta(j, -m)) == 0
+
+    assert (vector_derivative - (tau**alpha*L.delta(j, -k) +
+        L.delta(L_0, -k)*A(-L_0)*A(j) +
+        A(L_0)*L.metric(-L_0, -L_1)*L.delta(L_1, -k)*A(j) +
+        A(L_0)*A(-L_0)*L.delta(j, -k) +
+        L.delta(L_0, -k)*H(-L_0, j))).expand().doit() == 0
+
+    assert (vector_derivative.contract_metric(L.metric).contract_delta(L.delta) -
+        (tau**alpha*L.delta(j, -k) + A(L_0)*A(-L_0)*L.delta(j, -k) + H(-k, j) + 2*A(j)*A(-k))).expand().doit() == 0
+
+    assert scalar_derivative - alpha*1/tau*tau**alpha*A(j) == 0
+
+
+def test_eval_partial_derivative_mixed_scalar_tensor_expr2():
+
+    tau, alpha = symbols("tau alpha")
+
+    base_expr2 = A(i)*A(-i) + tau**2
+
+    vector_expression = PartialDerivative(base_expr2, A(k))._perform_derivative()
+    assert  (vector_expression -
+        (L.delta(L_0, -k)*A(-L_0) + A(L_0)*L.metric(-L_0, -L_1)*L.delta(L_1, -k))).expand().doit() == 0
+
+    scalar_expression = PartialDerivative(base_expr2, tau)._perform_derivative()
+    assert scalar_expression == 2*tau
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/testing/__pycache__/__init__.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/testing/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..2a71f07c92aed8a8f4cc47b31a1c2ceff3d60c4e
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/testing/__pycache__/__init__.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/testing/__pycache__/matrices.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/testing/__pycache__/matrices.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..0967bed6af5017220e0d3ea61ffebdd8b5273564
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/testing/__pycache__/matrices.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/testing/__pycache__/pytest.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/testing/__pycache__/pytest.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..808a1b670cb5a496ff3e405e41b7d43abbac5088
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/testing/__pycache__/pytest.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/testing/__pycache__/quality_unicode.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/testing/__pycache__/quality_unicode.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..16e8b2a53335dad089cf8a4816002929798349f9
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/testing/__pycache__/quality_unicode.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/testing/__pycache__/randtest.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/testing/__pycache__/randtest.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f9597f6147eaca11c9adce99a3f559f3d15509e7
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/testing/__pycache__/randtest.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/testing/__pycache__/runtests.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/testing/__pycache__/runtests.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b9baac1881d65fcfa5e62c69b950b12077451acf
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/testing/__pycache__/runtests.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/testing/__pycache__/runtests_pytest.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/testing/__pycache__/runtests_pytest.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..7547988dc7ec4251453aa227a4fef719c5ca74d4
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/testing/__pycache__/runtests_pytest.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/testing/__pycache__/tmpfiles.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/testing/__pycache__/tmpfiles.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..df280a99223fef396adffd39d49d6eb87b95ac7b
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/testing/__pycache__/tmpfiles.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/testing/tests/__init__.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/testing/tests/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/testing/tests/__pycache__/__init__.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/testing/tests/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..92e1f3d9031a6f642dda1b1350a1b2b5e78e40a0
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/testing/tests/__pycache__/__init__.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/testing/tests/__pycache__/diagnose_imports.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/testing/tests/__pycache__/diagnose_imports.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5dca1d93ab37fc087a0f4f8c608c718d9b0e4877
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/testing/tests/__pycache__/diagnose_imports.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/testing/tests/__pycache__/test_code_quality.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/testing/tests/__pycache__/test_code_quality.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ccf9a39dbe7eb20e5abd33c7aa5bacda77d6b540
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/testing/tests/__pycache__/test_code_quality.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/testing/tests/__pycache__/test_deprecated.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/testing/tests/__pycache__/test_deprecated.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c4a4913b6c24472432cd0f3787bae5bbed3e2567
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/testing/tests/__pycache__/test_deprecated.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/testing/tests/__pycache__/test_module_imports.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/testing/tests/__pycache__/test_module_imports.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..44178b0d34eda711019085bad0f175f14900e235
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/testing/tests/__pycache__/test_module_imports.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/testing/tests/__pycache__/test_pytest.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/testing/tests/__pycache__/test_pytest.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..0522e6e4ef547b9a53b63f4fb271d054cbcff94d
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/testing/tests/__pycache__/test_pytest.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/testing/tests/__pycache__/test_runtests_pytest.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/testing/tests/__pycache__/test_runtests_pytest.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..0fd7700a1796c8de2041a69120dadf2ab28c9f00
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/testing/tests/__pycache__/test_runtests_pytest.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/testing/tests/diagnose_imports.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/testing/tests/diagnose_imports.py
new file mode 100644
index 0000000000000000000000000000000000000000..a31b66c66690c082800ae36eee37dad6927e0b37
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/testing/tests/diagnose_imports.py
@@ -0,0 +1,216 @@
+#!/usr/bin/env python
+
+"""
+Import diagnostics. Run bin/diagnose_imports.py --help for details.
+"""
+
+from __future__ import annotations
+
+if __name__ == "__main__":
+
+    import sys
+    import inspect
+    import builtins
+
+    import optparse
+
+    from os.path import abspath, dirname, join, normpath
+    this_file = abspath(__file__)
+    sympy_dir = join(dirname(this_file), '..', '..', '..')
+    sympy_dir = normpath(sympy_dir)
+    sys.path.insert(0, sympy_dir)
+
+    option_parser = optparse.OptionParser(
+        usage=
+            "Usage: %prog option [options]\n"
+            "\n"
+            "Import analysis for imports between SymPy modules.")
+    option_group = optparse.OptionGroup(
+        option_parser,
+        'Analysis options',
+        'Options that define what to do. Exactly one of these must be given.')
+    option_group.add_option(
+        '--problems',
+        help=
+            'Print all import problems, that is: '
+            'If an import pulls in a package instead of a module '
+            '(e.g. sympy.core instead of sympy.core.add); ' # see ##PACKAGE##
+            'if it imports a symbol that is already present; ' # see ##DUPLICATE##
+            'if it imports a symbol '
+            'from somewhere other than the defining module.', # see ##ORIGIN##
+        action='count')
+    option_group.add_option(
+        '--origins',
+        help=
+            'For each imported symbol in each module, '
+            'print the module that defined it. '
+            '(This is useful for import refactoring.)',
+        action='count')
+    option_parser.add_option_group(option_group)
+    option_group = optparse.OptionGroup(
+        option_parser,
+        'Sort options',
+        'These options define the sort order for output lines. '
+        'At most one of these options is allowed. '
+        'Unsorted output will reflect the order in which imports happened.')
+    option_group.add_option(
+        '--by-importer',
+        help='Sort output lines by name of importing module.',
+        action='count')
+    option_group.add_option(
+        '--by-origin',
+        help='Sort output lines by name of imported module.',
+        action='count')
+    option_parser.add_option_group(option_group)
+    (options, args) = option_parser.parse_args()
+    if args:
+        option_parser.error(
+            'Unexpected arguments %s (try %s --help)' % (args, sys.argv[0]))
+    if options.problems > 1:
+        option_parser.error('--problems must not be given more than once.')
+    if options.origins > 1:
+        option_parser.error('--origins must not be given more than once.')
+    if options.by_importer > 1:
+        option_parser.error('--by-importer must not be given more than once.')
+    if options.by_origin > 1:
+        option_parser.error('--by-origin must not be given more than once.')
+    options.problems = options.problems == 1
+    options.origins = options.origins == 1
+    options.by_importer = options.by_importer == 1
+    options.by_origin = options.by_origin == 1
+    if not options.problems and not options.origins:
+        option_parser.error(
+            'At least one of --problems and --origins is required')
+    if options.problems and options.origins:
+        option_parser.error(
+            'At most one of --problems and --origins is allowed')
+    if options.by_importer and options.by_origin:
+        option_parser.error(
+            'At most one of --by-importer and --by-origin is allowed')
+    options.by_process = not options.by_importer and not options.by_origin
+
+    builtin_import = builtins.__import__
+
+    class Definition:
+        """Information about a symbol's definition."""
+        def __init__(self, name, value, definer):
+            self.name = name
+            self.value = value
+            self.definer = definer
+        def __hash__(self):
+            return hash(self.name)
+        def __eq__(self, other):
+            return self.name == other.name and self.value == other.value
+        def __ne__(self, other):
+            return not (self == other)
+        def __repr__(self):
+            return 'Definition(%s, ..., %s)' % (
+                repr(self.name), repr(self.definer))
+
+    # Maps each function/variable to name of module to define it
+    symbol_definers: dict[Definition, str] = {}
+
+    def in_module(a, b):
+        """Is a the same module as or a submodule of b?"""
+        return a == b or a != None and b != None and a.startswith(b + '.')
+
+    def relevant(module):
+        """Is module relevant for import checking?
+
+        Only imports between relevant modules will be checked."""
+        return in_module(module, 'sympy')
+
+    sorted_messages = []
+
+    def msg(msg, *args):
+        if options.by_process:
+            print(msg % args)
+        else:
+            sorted_messages.append(msg % args)
+
+    def tracking_import(module, globals=globals(), locals=[], fromlist=None, level=-1):
+        """__import__ wrapper - does not change imports at all, but tracks them.
+
+        Default order is implemented by doing output directly.
+        All other orders are implemented by collecting output information into
+        a sorted list that will be emitted after all imports are processed.
+
+        Indirect imports can only occur after the requested symbol has been
+        imported directly (because the indirect import would not have a module
+        to pick the symbol up from).
+        So this code detects indirect imports by checking whether the symbol in
+        question was already imported.
+
+        Keeps the semantics of __import__ unchanged."""
+        caller_frame = inspect.getframeinfo(sys._getframe(1))
+        importer_filename = caller_frame.filename
+        importer_module = globals['__name__']
+        if importer_filename == caller_frame.filename:
+            importer_reference = '%s line %s' % (
+                importer_filename, str(caller_frame.lineno))
+        else:
+            importer_reference = importer_filename
+        result = builtin_import(module, globals, locals, fromlist, level)
+        importee_module = result.__name__
+        # We're only interested if importer and importee are in SymPy
+        if relevant(importer_module) and relevant(importee_module):
+            for symbol in result.__dict__.iterkeys():
+                definition = Definition(
+                    symbol, result.__dict__[symbol], importer_module)
+                if definition not in symbol_definers:
+                    symbol_definers[definition] = importee_module
+            if hasattr(result, '__path__'):
+                ##PACKAGE##
+                # The existence of __path__ is documented in the tutorial on modules.
+                # Python 3.3 documents this in http://docs.python.org/3.3/reference/import.html
+                if options.by_origin:
+                    msg('Error: %s (a package) is imported by %s',
+                        module, importer_reference)
+                else:
+                    msg('Error: %s contains package import %s',
+                        importer_reference, module)
+            if fromlist != None:
+                symbol_list = fromlist
+                if '*' in symbol_list:
+                    if (importer_filename.endswith(("__init__.py", "__init__.pyc", "__init__.pyo"))):
+                        # We do not check starred imports inside __init__
+                        # That's the normal "please copy over its imports to my namespace"
+                        symbol_list = []
+                    else:
+                        symbol_list = result.__dict__.iterkeys()
+                for symbol in symbol_list:
+                    if symbol not in result.__dict__:
+                        if options.by_origin:
+                            msg('Error: %s.%s is not defined (yet), but %s tries to import it',
+                                importee_module, symbol, importer_reference)
+                        else:
+                            msg('Error: %s tries to import %s.%s, which did not define it (yet)',
+                                importer_reference, importee_module, symbol)
+                    else:
+                        definition = Definition(
+                            symbol, result.__dict__[symbol], importer_module)
+                        symbol_definer = symbol_definers[definition]
+                        if symbol_definer == importee_module:
+                            ##DUPLICATE##
+                            if options.by_origin:
+                                msg('Error: %s.%s is imported again into %s',
+                                    importee_module, symbol, importer_reference)
+                            else:
+                                msg('Error: %s imports %s.%s again',
+                                      importer_reference, importee_module, symbol)
+                        else:
+                            ##ORIGIN##
+                            if options.by_origin:
+                                msg('Error: %s.%s is imported by %s, which should import %s.%s instead',
+                                      importee_module, symbol, importer_reference, symbol_definer, symbol)
+                            else:
+                                msg('Error: %s imports %s.%s but should import %s.%s instead',
+                                      importer_reference, importee_module, symbol, symbol_definer, symbol)
+        return result
+
+    builtins.__import__ = tracking_import
+    __import__('sympy')
+
+    sorted_messages.sort()
+    for message in sorted_messages:
+        print(message)
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/testing/tests/test_code_quality.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/testing/tests/test_code_quality.py
new file mode 100644
index 0000000000000000000000000000000000000000..9a9f363f0b9a802553f8643186b7d858d1ad0694
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/testing/tests/test_code_quality.py
@@ -0,0 +1,510 @@
+# coding=utf-8
+from os import walk, sep, pardir
+from os.path import split, join, abspath, exists, isfile
+from glob import glob
+import re
+import random
+import ast
+
+from sympy.testing.pytest import raises
+from sympy.testing.quality_unicode import _test_this_file_encoding
+
+# System path separator (usually slash or backslash) to be
+# used with excluded files, e.g.
+#     exclude = set([
+#                    "%(sep)smpmath%(sep)s" % sepd,
+#                   ])
+sepd = {"sep": sep}
+
+# path and sympy_path
+SYMPY_PATH = abspath(join(split(__file__)[0], pardir, pardir))  # go to sympy/
+assert exists(SYMPY_PATH)
+
+TOP_PATH = abspath(join(SYMPY_PATH, pardir))
+BIN_PATH = join(TOP_PATH, "bin")
+EXAMPLES_PATH = join(TOP_PATH, "examples")
+
+# Error messages
+message_space = "File contains trailing whitespace: %s, line %s."
+message_implicit = "File contains an implicit import: %s, line %s."
+message_tabs = "File contains tabs instead of spaces: %s, line %s."
+message_carriage = "File contains carriage returns at end of line: %s, line %s"
+message_str_raise = "File contains string exception: %s, line %s"
+message_gen_raise = "File contains generic exception: %s, line %s"
+message_old_raise = "File contains old-style raise statement: %s, line %s, \"%s\""
+message_eof = "File does not end with a newline: %s, line %s"
+message_multi_eof = "File ends with more than 1 newline: %s, line %s"
+message_test_suite_def = "Function should start with 'test_' or '_': %s, line %s"
+message_duplicate_test = "This is a duplicate test function: %s, line %s"
+message_self_assignments = "File contains assignments to self/cls: %s, line %s."
+message_func_is = "File contains '.func is': %s, line %s."
+message_bare_expr = "File contains bare expression: %s, line %s."
+
+implicit_test_re = re.compile(r'^\s*(>>> )?(\.\.\. )?from .* import .*\*')
+str_raise_re = re.compile(
+    r'^\s*(>>> )?(\.\.\. )?raise(\s+(\'|\")|\s*(\(\s*)+(\'|\"))')
+gen_raise_re = re.compile(
+    r'^\s*(>>> )?(\.\.\. )?raise(\s+Exception|\s*(\(\s*)+Exception)')
+old_raise_re = re.compile(r'^\s*(>>> )?(\.\.\. )?raise((\s*\(\s*)|\s+)\w+\s*,')
+test_suite_def_re = re.compile(r'^def\s+(?!(_|test))[^(]*\(\s*\)\s*:$')
+test_ok_def_re = re.compile(r'^def\s+test_.*:$')
+test_file_re = re.compile(r'.*[/\\]test_.*\.py$')
+func_is_re = re.compile(r'\.\s*func\s+is')
+
+
+def tab_in_leading(s):
+    """Returns True if there are tabs in the leading whitespace of a line,
+    including the whitespace of docstring code samples."""
+    n = len(s) - len(s.lstrip())
+    if not s[n:n + 3] in ['...', '>>>']:
+        check = s[:n]
+    else:
+        smore = s[n + 3:]
+        check = s[:n] + smore[:len(smore) - len(smore.lstrip())]
+    return not (check.expandtabs() == check)
+
+
+def find_self_assignments(s):
+    """Returns a list of "bad" assignments: if there are instances
+    of assigning to the first argument of the class method (except
+    for staticmethod's).
+    """
+    t = [n for n in ast.parse(s).body if isinstance(n, ast.ClassDef)]
+
+    bad = []
+    for c in t:
+        for n in c.body:
+            if not isinstance(n, ast.FunctionDef):
+                continue
+            if any(d.id == 'staticmethod'
+                   for d in n.decorator_list if isinstance(d, ast.Name)):
+                continue
+            if n.name == '__new__':
+                continue
+            if not n.args.args:
+                continue
+            first_arg = n.args.args[0].arg
+
+            for m in ast.walk(n):
+                if isinstance(m, ast.Assign):
+                    for a in m.targets:
+                        if isinstance(a, ast.Name) and a.id == first_arg:
+                            bad.append(m)
+                        elif (isinstance(a, ast.Tuple) and
+                              any(q.id == first_arg for q in a.elts
+                                  if isinstance(q, ast.Name))):
+                            bad.append(m)
+
+    return bad
+
+
+def check_directory_tree(base_path, file_check, exclusions=set(), pattern="*.py"):
+    """
+    Checks all files in the directory tree (with base_path as starting point)
+    with the file_check function provided, skipping files that contain
+    any of the strings in the set provided by exclusions.
+    """
+    if not base_path:
+        return
+    for root, dirs, files in walk(base_path):
+        check_files(glob(join(root, pattern)), file_check, exclusions)
+
+
+def check_files(files, file_check, exclusions=set(), pattern=None):
+    """
+    Checks all files with the file_check function provided, skipping files
+    that contain any of the strings in the set provided by exclusions.
+    """
+    if not files:
+        return
+    for fname in files:
+        if not exists(fname) or not isfile(fname):
+            continue
+        if any(ex in fname for ex in exclusions):
+            continue
+        if pattern is None or re.match(pattern, fname):
+            file_check(fname)
+
+
+class _Visit(ast.NodeVisitor):
+    """return the line number corresponding to the
+    line on which a bare expression appears if it is a binary op
+    or a comparison that is not in a with block.
+
+    EXAMPLES
+    ========
+
+    >>> import ast
+    >>> class _Visit(ast.NodeVisitor):
+    ...     def visit_Expr(self, node):
+    ...         if isinstance(node.value, (ast.BinOp, ast.Compare)):
+    ...             print(node.lineno)
+    ...     def visit_With(self, node):
+    ...         pass  # no checking there
+    ...
+    >>> code='''x = 1    # line 1
+    ... for i in range(3):
+    ...     x == 2       # <-- 3
+    ... if x == 2:
+    ...     x == 3       # <-- 5
+    ...     x + 1        # <-- 6
+    ...     x = 1
+    ...     if x == 1:
+    ...         print(1)
+    ... while x != 1:
+    ...     x == 1       # <-- 11
+    ... with raises(TypeError):
+    ...     c == 1
+    ...     raise TypeError
+    ... assert x == 1
+    ... '''
+    >>> _Visit().visit(ast.parse(code))
+    3
+    5
+    6
+    11
+    """
+    def visit_Expr(self, node):
+        if isinstance(node.value, (ast.BinOp, ast.Compare)):
+            assert None, message_bare_expr % ('', node.lineno)
+    def visit_With(self, node):
+        pass
+
+
+BareExpr = _Visit()
+
+
+def line_with_bare_expr(code):
+    """return None or else 0-based line number of code on which
+    a bare expression appeared.
+    """
+    tree = ast.parse(code)
+    try:
+        BareExpr.visit(tree)
+    except AssertionError as msg:
+        assert msg.args
+        msg = msg.args[0]
+        assert msg.startswith(message_bare_expr.split(':', 1)[0])
+        return int(msg.rsplit(' ', 1)[1].rstrip('.'))  # the line number
+
+
+def test_files():
+    """
+    This test tests all files in SymPy and checks that:
+      o no lines contains a trailing whitespace
+      o no lines end with \r\n
+      o no line uses tabs instead of spaces
+      o that the file ends with a single newline
+      o there are no general or string exceptions
+      o there are no old style raise statements
+      o name of arg-less test suite functions start with _ or test_
+      o no duplicate function names that start with test_
+      o no assignments to self variable in class methods
+      o no lines contain ".func is" except in the test suite
+      o there is no do-nothing expression like `a == b` or `x + 1`
+    """
+
+    def test(fname):
+        with open(fname, encoding="utf8") as test_file:
+            test_this_file(fname, test_file)
+        with open(fname, encoding='utf8') as test_file:
+            _test_this_file_encoding(fname, test_file)
+
+    def test_this_file(fname, test_file):
+        idx = None
+        code = test_file.read()
+        test_file.seek(0)  # restore reader to head
+        py = fname if sep not in fname else fname.rsplit(sep, 1)[-1]
+        if py.startswith('test_'):
+            idx = line_with_bare_expr(code)
+        if idx is not None:
+            assert False, message_bare_expr % (fname, idx + 1)
+
+        line = None  # to flag the case where there were no lines in file
+        tests = 0
+        test_set = set()
+        for idx, line in enumerate(test_file):
+            if test_file_re.match(fname):
+                if test_suite_def_re.match(line):
+                    assert False, message_test_suite_def % (fname, idx + 1)
+                if test_ok_def_re.match(line):
+                    tests += 1
+                    test_set.add(line[3:].split('(')[0].strip())
+                    if len(test_set) != tests:
+                        assert False, message_duplicate_test % (fname, idx + 1)
+            if line.endswith((" \n", "\t\n")):
+                assert False, message_space % (fname, idx + 1)
+            if line.endswith("\r\n"):
+                assert False, message_carriage % (fname, idx + 1)
+            if tab_in_leading(line):
+                assert False, message_tabs % (fname, idx + 1)
+            if str_raise_re.search(line):
+                assert False, message_str_raise % (fname, idx + 1)
+            if gen_raise_re.search(line):
+                assert False, message_gen_raise % (fname, idx + 1)
+            if (implicit_test_re.search(line) and
+                    not list(filter(lambda ex: ex in fname, import_exclude))):
+                assert False, message_implicit % (fname, idx + 1)
+            if func_is_re.search(line) and not test_file_re.search(fname):
+                assert False, message_func_is % (fname, idx + 1)
+
+            result = old_raise_re.search(line)
+
+            if result is not None:
+                assert False, message_old_raise % (
+                    fname, idx + 1, result.group(2))
+
+        if line is not None:
+            if line == '\n' and idx > 0:
+                assert False, message_multi_eof % (fname, idx + 1)
+            elif not line.endswith('\n'):
+                # eof newline check
+                assert False, message_eof % (fname, idx + 1)
+
+
+    # Files to test at top level
+    top_level_files = [join(TOP_PATH, file) for file in [
+        "isympy.py",
+        "build.py",
+        "setup.py",
+    ]]
+    # Files to exclude from all tests
+    exclude = {
+        "%(sep)ssympy%(sep)sparsing%(sep)sautolev%(sep)s_antlr%(sep)sautolevparser.py" % sepd,
+        "%(sep)ssympy%(sep)sparsing%(sep)sautolev%(sep)s_antlr%(sep)sautolevlexer.py" % sepd,
+        "%(sep)ssympy%(sep)sparsing%(sep)sautolev%(sep)s_antlr%(sep)sautolevlistener.py" % sepd,
+        "%(sep)ssympy%(sep)sparsing%(sep)slatex%(sep)s_antlr%(sep)slatexparser.py" % sepd,
+        "%(sep)ssympy%(sep)sparsing%(sep)slatex%(sep)s_antlr%(sep)slatexlexer.py" % sepd,
+    }
+    # Files to exclude from the implicit import test
+    import_exclude = {
+        # glob imports are allowed in top-level __init__.py:
+        "%(sep)ssympy%(sep)s__init__.py" % sepd,
+        # these __init__.py should be fixed:
+        # XXX: not really, they use useful import pattern (DRY)
+        "%(sep)svector%(sep)s__init__.py" % sepd,
+        "%(sep)smechanics%(sep)s__init__.py" % sepd,
+        "%(sep)squantum%(sep)s__init__.py" % sepd,
+        "%(sep)spolys%(sep)s__init__.py" % sepd,
+        "%(sep)spolys%(sep)sdomains%(sep)s__init__.py" % sepd,
+        # interactive SymPy executes ``from sympy import *``:
+        "%(sep)sinteractive%(sep)ssession.py" % sepd,
+        # isympy.py executes ``from sympy import *``:
+        "%(sep)sisympy.py" % sepd,
+        # these two are import timing tests:
+        "%(sep)sbin%(sep)ssympy_time.py" % sepd,
+        "%(sep)sbin%(sep)ssympy_time_cache.py" % sepd,
+        # Taken from Python stdlib:
+        "%(sep)sparsing%(sep)ssympy_tokenize.py" % sepd,
+        # this one should be fixed:
+        "%(sep)splotting%(sep)spygletplot%(sep)s" % sepd,
+        # False positive in the docstring
+        "%(sep)sbin%(sep)stest_external_imports.py" % sepd,
+        "%(sep)sbin%(sep)stest_submodule_imports.py" % sepd,
+        # These are deprecated stubs that can be removed at some point:
+        "%(sep)sutilities%(sep)sruntests.py" % sepd,
+        "%(sep)sutilities%(sep)spytest.py" % sepd,
+        "%(sep)sutilities%(sep)srandtest.py" % sepd,
+        "%(sep)sutilities%(sep)stmpfiles.py" % sepd,
+        "%(sep)sutilities%(sep)squality_unicode.py" % sepd,
+    }
+    check_files(top_level_files, test)
+    check_directory_tree(BIN_PATH, test, {"~", ".pyc", ".sh"}, "*")
+    check_directory_tree(SYMPY_PATH, test, exclude)
+    check_directory_tree(EXAMPLES_PATH, test, exclude)
+
+
+def _with_space(c):
+    # return c with a random amount of leading space
+    return random.randint(0, 10)*' ' + c
+
+
+def test_raise_statement_regular_expression():
+    candidates_ok = [
+        "some text # raise Exception, 'text'",
+        "raise ValueError('text') # raise Exception, 'text'",
+        "raise ValueError('text')",
+        "raise ValueError",
+        "raise ValueError('text')",
+        "raise ValueError('text') #,",
+        # Talking about an exception in a docstring
+        ''''"""This function will raise ValueError, except when it doesn't"""''',
+        "raise (ValueError('text')",
+    ]
+    str_candidates_fail = [
+        "raise 'exception'",
+        "raise 'Exception'",
+        'raise "exception"',
+        'raise "Exception"',
+        "raise 'ValueError'",
+    ]
+    gen_candidates_fail = [
+        "raise Exception('text') # raise Exception, 'text'",
+        "raise Exception('text')",
+        "raise Exception",
+        "raise Exception('text')",
+        "raise Exception('text') #,",
+        "raise Exception, 'text'",
+        "raise Exception, 'text' # raise Exception('text')",
+        "raise Exception, 'text' # raise Exception, 'text'",
+        ">>> raise Exception, 'text'",
+        ">>> raise Exception, 'text' # raise Exception('text')",
+        ">>> raise Exception, 'text' # raise Exception, 'text'",
+    ]
+    old_candidates_fail = [
+        "raise Exception, 'text'",
+        "raise Exception, 'text' # raise Exception('text')",
+        "raise Exception, 'text' # raise Exception, 'text'",
+        ">>> raise Exception, 'text'",
+        ">>> raise Exception, 'text' # raise Exception('text')",
+        ">>> raise Exception, 'text' # raise Exception, 'text'",
+        "raise ValueError, 'text'",
+        "raise ValueError, 'text' # raise Exception('text')",
+        "raise ValueError, 'text' # raise Exception, 'text'",
+        ">>> raise ValueError, 'text'",
+        ">>> raise ValueError, 'text' # raise Exception('text')",
+        ">>> raise ValueError, 'text' # raise Exception, 'text'",
+        "raise(ValueError,",
+        "raise (ValueError,",
+        "raise( ValueError,",
+        "raise ( ValueError,",
+        "raise(ValueError ,",
+        "raise (ValueError ,",
+        "raise( ValueError ,",
+        "raise ( ValueError ,",
+    ]
+
+    for c in candidates_ok:
+        assert str_raise_re.search(_with_space(c)) is None, c
+        assert gen_raise_re.search(_with_space(c)) is None, c
+        assert old_raise_re.search(_with_space(c)) is None, c
+    for c in str_candidates_fail:
+        assert str_raise_re.search(_with_space(c)) is not None, c
+    for c in gen_candidates_fail:
+        assert gen_raise_re.search(_with_space(c)) is not None, c
+    for c in old_candidates_fail:
+        assert old_raise_re.search(_with_space(c)) is not None, c
+
+
+def test_implicit_imports_regular_expression():
+    candidates_ok = [
+        "from sympy import something",
+        ">>> from sympy import something",
+        "from sympy.somewhere import something",
+        ">>> from sympy.somewhere import something",
+        "import sympy",
+        ">>> import sympy",
+        "import sympy.something.something",
+        "... import sympy",
+        "... import sympy.something.something",
+        "... from sympy import something",
+        "... from sympy.somewhere import something",
+        ">> from sympy import *",  # To allow 'fake' docstrings
+        "# from sympy import *",
+        "some text # from sympy import *",
+    ]
+    candidates_fail = [
+        "from sympy import *",
+        ">>> from sympy import *",
+        "from sympy.somewhere import *",
+        ">>> from sympy.somewhere import *",
+        "... from sympy import *",
+        "... from sympy.somewhere import *",
+    ]
+    for c in candidates_ok:
+        assert implicit_test_re.search(_with_space(c)) is None, c
+    for c in candidates_fail:
+        assert implicit_test_re.search(_with_space(c)) is not None, c
+
+
+def test_test_suite_defs():
+    candidates_ok = [
+        "    def foo():\n",
+        "def foo(arg):\n",
+        "def _foo():\n",
+        "def test_foo():\n",
+    ]
+    candidates_fail = [
+        "def foo():\n",
+        "def foo() :\n",
+        "def foo( ):\n",
+        "def  foo():\n",
+    ]
+    for c in candidates_ok:
+        assert test_suite_def_re.search(c) is None, c
+    for c in candidates_fail:
+        assert test_suite_def_re.search(c) is not None, c
+
+
+def test_test_duplicate_defs():
+    candidates_ok = [
+        "def foo():\ndef foo():\n",
+        "def test():\ndef test_():\n",
+        "def test_():\ndef test__():\n",
+    ]
+    candidates_fail = [
+        "def test_():\ndef test_ ():\n",
+        "def test_1():\ndef  test_1():\n",
+    ]
+    ok = (None, 'check')
+    def check(file):
+        tests = 0
+        test_set = set()
+        for idx, line in enumerate(file.splitlines()):
+            if test_ok_def_re.match(line):
+                tests += 1
+                test_set.add(line[3:].split('(')[0].strip())
+                if len(test_set) != tests:
+                    return False, message_duplicate_test % ('check', idx + 1)
+        return None, 'check'
+    for c in candidates_ok:
+        assert check(c) == ok
+    for c in candidates_fail:
+        assert check(c) != ok
+
+
+def test_find_self_assignments():
+    candidates_ok = [
+        "class A(object):\n    def foo(self, arg): arg = self\n",
+        "class A(object):\n    def foo(self, arg): self.prop = arg\n",
+        "class A(object):\n    def foo(self, arg): obj, obj2 = arg, self\n",
+        "class A(object):\n    @classmethod\n    def bar(cls, arg): arg = cls\n",
+        "class A(object):\n    def foo(var, arg): arg = var\n",
+    ]
+    candidates_fail = [
+        "class A(object):\n    def foo(self, arg): self = arg\n",
+        "class A(object):\n    def foo(self, arg): obj, self = arg, arg\n",
+        "class A(object):\n    def foo(self, arg):\n        if arg: self = arg",
+        "class A(object):\n    @classmethod\n    def foo(cls, arg): cls = arg\n",
+        "class A(object):\n    def foo(var, arg): var = arg\n",
+    ]
+
+    for c in candidates_ok:
+        assert find_self_assignments(c) == []
+    for c in candidates_fail:
+        assert find_self_assignments(c) != []
+
+
+def test_test_unicode_encoding():
+    unicode_whitelist = ['foo']
+    unicode_strict_whitelist = ['bar']
+
+    fname = 'abc'
+    test_file = ['α']
+    raises(AssertionError, lambda: _test_this_file_encoding(
+        fname, test_file, unicode_whitelist, unicode_strict_whitelist))
+
+    fname = 'abc'
+    test_file = ['abc']
+    _test_this_file_encoding(
+        fname, test_file, unicode_whitelist, unicode_strict_whitelist)
+
+    fname = 'foo'
+    test_file = ['abc']
+    raises(AssertionError, lambda: _test_this_file_encoding(
+        fname, test_file, unicode_whitelist, unicode_strict_whitelist))
+
+    fname = 'bar'
+    test_file = ['abc']
+    _test_this_file_encoding(
+        fname, test_file, unicode_whitelist, unicode_strict_whitelist)
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/testing/tests/test_deprecated.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/testing/tests/test_deprecated.py
new file mode 100644
index 0000000000000000000000000000000000000000..696933d96d6232ea869da1002ec9ebee5309724d
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/testing/tests/test_deprecated.py
@@ -0,0 +1,5 @@
+from sympy.testing.pytest import warns_deprecated_sympy
+
+def test_deprecated_testing_randtest():
+    with warns_deprecated_sympy():
+        import sympy.testing.randtest  # noqa:F401
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/testing/tests/test_module_imports.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/testing/tests/test_module_imports.py
new file mode 100644
index 0000000000000000000000000000000000000000..d16dbaa98156c287c18b46ff07c0ede5d26e069a
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/testing/tests/test_module_imports.py
@@ -0,0 +1,42 @@
+"""
+Checks that SymPy does not contain indirect imports.
+
+An indirect import is importing a symbol from a module that itself imported the
+symbol from elsewhere. Such a constellation makes it harder to diagnose
+inter-module dependencies and import order problems, and is therefore strongly
+discouraged.
+
+(Indirect imports from end-user code is fine and in fact a best practice.)
+
+Implementation note: Forcing Python into actually unloading already-imported
+submodules is a tricky and partly undocumented process. To avoid these issues,
+the actual diagnostic code is in bin/diagnose_imports, which is run as a
+separate, pristine Python process.
+"""
+
+import subprocess
+import sys
+from os.path import abspath, dirname, join, normpath
+import inspect
+
+from sympy.testing.pytest import XFAIL
+
+@XFAIL
+def test_module_imports_are_direct():
+    my_filename = abspath(inspect.getfile(inspect.currentframe()))
+    my_dirname = dirname(my_filename)
+    diagnose_imports_filename = join(my_dirname, 'diagnose_imports.py')
+    diagnose_imports_filename = normpath(diagnose_imports_filename)
+
+    process = subprocess.Popen(
+        [
+            sys.executable,
+            normpath(diagnose_imports_filename),
+            '--problems',
+            '--by-importer'
+        ],
+        stdout=subprocess.PIPE,
+        stderr=subprocess.STDOUT,
+        bufsize=-1)
+    output, _ = process.communicate()
+    assert output == '', "There are import problems:\n" + output.decode()
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/testing/tests/test_pytest.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/testing/tests/test_pytest.py
new file mode 100644
index 0000000000000000000000000000000000000000..7080a4ed4602707a3efb4d9025e8e9cbe23a5ef8
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/testing/tests/test_pytest.py
@@ -0,0 +1,211 @@
+import warnings
+
+from sympy.testing.pytest import (raises, warns, ignore_warnings,
+                                    warns_deprecated_sympy, Failed)
+from sympy.utilities.exceptions import sympy_deprecation_warning
+
+
+
+# Test callables
+
+
+def test_expected_exception_is_silent_callable():
+    def f():
+        raise ValueError()
+    raises(ValueError, f)
+
+
+# Under pytest raises will raise Failed rather than AssertionError
+def test_lack_of_exception_triggers_AssertionError_callable():
+    try:
+        raises(Exception, lambda: 1 + 1)
+        assert False
+    except Failed as e:
+        assert "DID NOT RAISE" in str(e)
+
+
+def test_unexpected_exception_is_passed_through_callable():
+    def f():
+        raise ValueError("some error message")
+    try:
+        raises(TypeError, f)
+        assert False
+    except ValueError as e:
+        assert str(e) == "some error message"
+
+# Test with statement
+
+def test_expected_exception_is_silent_with():
+    with raises(ValueError):
+        raise ValueError()
+
+
+def test_lack_of_exception_triggers_AssertionError_with():
+    try:
+        with raises(Exception):
+            1 + 1
+        assert False
+    except Failed as e:
+        assert "DID NOT RAISE" in str(e)
+
+
+def test_unexpected_exception_is_passed_through_with():
+    try:
+        with raises(TypeError):
+            raise ValueError("some error message")
+        assert False
+    except ValueError as e:
+        assert str(e) == "some error message"
+
+# Now we can use raises() instead of try/catch
+# to test that a specific exception class is raised
+
+
+def test_second_argument_should_be_callable_or_string():
+    raises(TypeError, lambda: raises("irrelevant", 42))
+
+
+def test_warns_catches_warning():
+    with warnings.catch_warnings(record=True) as w:
+        with warns(UserWarning):
+            warnings.warn('this is the warning message')
+        assert len(w) == 0
+
+
+def test_warns_raises_without_warning():
+    with raises(Failed):
+        with warns(UserWarning):
+            pass
+
+
+def test_warns_hides_other_warnings():
+    with raises(RuntimeWarning):
+        with warns(UserWarning):
+            warnings.warn('this is the warning message', UserWarning)
+            warnings.warn('this is the other message', RuntimeWarning)
+
+
+def test_warns_continues_after_warning():
+    with warnings.catch_warnings(record=True) as w:
+        finished = False
+        with warns(UserWarning):
+            warnings.warn('this is the warning message')
+            finished = True
+        assert finished
+        assert len(w) == 0
+
+
+def test_warns_many_warnings():
+    with warns(UserWarning):
+        warnings.warn('this is the warning message', UserWarning)
+        warnings.warn('this is the other warning message', UserWarning)
+
+
+def test_warns_match_matching():
+    with warnings.catch_warnings(record=True) as w:
+        with warns(UserWarning, match='this is the warning message'):
+            warnings.warn('this is the warning message', UserWarning)
+        assert len(w) == 0
+
+
+def test_warns_match_non_matching():
+    with warnings.catch_warnings(record=True) as w:
+        with raises(Failed):
+            with warns(UserWarning, match='this is the warning message'):
+                warnings.warn('this is not the expected warning message', UserWarning)
+        assert len(w) == 0
+
+def _warn_sympy_deprecation(stacklevel=3):
+    sympy_deprecation_warning(
+        "feature",
+        active_deprecations_target="active-deprecations",
+        deprecated_since_version="0.0.0",
+        stacklevel=stacklevel,
+    )
+
+def test_warns_deprecated_sympy_catches_warning():
+    with warnings.catch_warnings(record=True) as w:
+        with warns_deprecated_sympy():
+            _warn_sympy_deprecation()
+        assert len(w) == 0
+
+
+def test_warns_deprecated_sympy_raises_without_warning():
+    with raises(Failed):
+        with warns_deprecated_sympy():
+            pass
+
+def test_warns_deprecated_sympy_wrong_stacklevel():
+    with raises(Failed):
+        with warns_deprecated_sympy():
+            _warn_sympy_deprecation(stacklevel=1)
+
+def test_warns_deprecated_sympy_doesnt_hide_other_warnings():
+    # Unlike pytest's deprecated_call, we should not hide other warnings.
+    with raises(RuntimeWarning):
+        with warns_deprecated_sympy():
+            _warn_sympy_deprecation()
+            warnings.warn('this is the other message', RuntimeWarning)
+
+
+def test_warns_deprecated_sympy_continues_after_warning():
+    with warnings.catch_warnings(record=True) as w:
+        finished = False
+        with warns_deprecated_sympy():
+            _warn_sympy_deprecation()
+            finished = True
+        assert finished
+        assert len(w) == 0
+
+def test_ignore_ignores_warning():
+    with warnings.catch_warnings(record=True) as w:
+        with ignore_warnings(UserWarning):
+            warnings.warn('this is the warning message')
+        assert len(w) == 0
+
+
+def test_ignore_does_not_raise_without_warning():
+    with warnings.catch_warnings(record=True) as w:
+        with ignore_warnings(UserWarning):
+            pass
+        assert len(w) == 0
+
+
+def test_ignore_allows_other_warnings():
+    with warnings.catch_warnings(record=True) as w:
+        # This is needed when pytest is run as -Werror
+        # the setting is reverted at the end of the catch_Warnings block.
+        warnings.simplefilter("always")
+        with ignore_warnings(UserWarning):
+            warnings.warn('this is the warning message', UserWarning)
+            warnings.warn('this is the other message', RuntimeWarning)
+        assert len(w) == 1
+        assert isinstance(w[0].message, RuntimeWarning)
+        assert str(w[0].message) == 'this is the other message'
+
+
+def test_ignore_continues_after_warning():
+    with warnings.catch_warnings(record=True) as w:
+        finished = False
+        with ignore_warnings(UserWarning):
+            warnings.warn('this is the warning message')
+            finished = True
+        assert finished
+        assert len(w) == 0
+
+
+def test_ignore_many_warnings():
+    with warnings.catch_warnings(record=True) as w:
+        # This is needed when pytest is run as -Werror
+        # the setting is reverted at the end of the catch_Warnings block.
+        warnings.simplefilter("always")
+        with ignore_warnings(UserWarning):
+            warnings.warn('this is the warning message', UserWarning)
+            warnings.warn('this is the other message', RuntimeWarning)
+            warnings.warn('this is the warning message', UserWarning)
+            warnings.warn('this is the other message', RuntimeWarning)
+            warnings.warn('this is the other message', RuntimeWarning)
+        assert len(w) == 3
+        for wi in w:
+            assert isinstance(wi.message, RuntimeWarning)
+            assert str(wi.message) == 'this is the other message'
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/testing/tests/test_runtests_pytest.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/testing/tests/test_runtests_pytest.py
new file mode 100644
index 0000000000000000000000000000000000000000..cd56d831f3618c9dbb8a1dffe63d95a0befc6adf
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/testing/tests/test_runtests_pytest.py
@@ -0,0 +1,171 @@
+import pathlib
+from typing import List
+
+import pytest
+
+from sympy.testing.runtests_pytest import (
+    make_absolute_path,
+    sympy_dir,
+    update_args_with_paths,
+)
+
+
+class TestMakeAbsolutePath:
+
+    @staticmethod
+    @pytest.mark.parametrize(
+        'partial_path', ['sympy', 'sympy/core', 'sympy/nonexistant_directory'],
+    )
+    def test_valid_partial_path(partial_path: str):
+        """Paths that start with `sympy` are valid."""
+        _ = make_absolute_path(partial_path)
+
+    @staticmethod
+    @pytest.mark.parametrize(
+        'partial_path', ['not_sympy', 'also/not/sympy'],
+    )
+    def test_invalid_partial_path_raises_value_error(partial_path: str):
+        """A `ValueError` is raises on paths that don't start with `sympy`."""
+        with pytest.raises(ValueError):
+            _ = make_absolute_path(partial_path)
+
+
+class TestUpdateArgsWithPaths:
+
+    @staticmethod
+    def test_no_paths():
+        """If no paths are passed, only `sympy` and `doc/src` are appended.
+
+        `sympy` and `doc/src` are the `testpaths` stated in `pytest.ini`. They
+        need to be manually added as if any path-related arguments are passed
+        to `pytest.main` then the settings in `pytest.ini` may be ignored.
+
+        """
+        paths = []
+        args = update_args_with_paths(paths=paths, keywords=None, args=[])
+        expected = [
+            str(pathlib.Path(sympy_dir(), 'sympy')),
+            str(pathlib.Path(sympy_dir(), 'doc/src')),
+        ]
+        assert args == expected
+
+    @staticmethod
+    @pytest.mark.parametrize(
+        'path',
+        ['sympy/core/tests/test_basic.py', '_basic']
+    )
+    def test_one_file(path: str):
+        """Single files/paths, full or partial, are matched correctly."""
+        args = update_args_with_paths(paths=[path], keywords=None, args=[])
+        expected = [
+            str(pathlib.Path(sympy_dir(), 'sympy/core/tests/test_basic.py')),
+        ]
+        assert args == expected
+
+    @staticmethod
+    def test_partial_path_from_root():
+        """Partial paths from the root directly are matched correctly."""
+        args = update_args_with_paths(paths=['sympy/functions'], keywords=None, args=[])
+        expected = [str(pathlib.Path(sympy_dir(), 'sympy/functions'))]
+        assert args == expected
+
+    @staticmethod
+    def test_multiple_paths_from_root():
+        """Multiple paths, partial or full, are matched correctly."""
+        paths = ['sympy/core/tests/test_basic.py', 'sympy/functions']
+        args = update_args_with_paths(paths=paths, keywords=None, args=[])
+        expected = [
+            str(pathlib.Path(sympy_dir(), 'sympy/core/tests/test_basic.py')),
+            str(pathlib.Path(sympy_dir(), 'sympy/functions')),
+        ]
+        assert args == expected
+
+    @staticmethod
+    @pytest.mark.parametrize(
+        'paths, expected_paths',
+        [
+            (
+                ['/core', '/util'],
+                [
+                    'doc/src/modules/utilities',
+                    'doc/src/reference/public/utilities',
+                    'sympy/core',
+                    'sympy/logic/utilities',
+                    'sympy/utilities',
+                ]
+            ),
+        ]
+    )
+    def test_multiple_paths_from_non_root(paths: List[str], expected_paths: List[str]):
+        """Multiple partial paths are matched correctly."""
+        args = update_args_with_paths(paths=paths, keywords=None, args=[])
+        assert len(args) == len(expected_paths)
+        for arg, expected in zip(sorted(args), expected_paths):
+            assert expected in arg
+
+    @staticmethod
+    @pytest.mark.parametrize(
+        'paths',
+        [
+
+            [],
+            ['sympy/physics'],
+            ['sympy/physics/mechanics'],
+            ['sympy/physics/mechanics/tests'],
+            ['sympy/physics/mechanics/tests/test_kane3.py'],
+        ]
+    )
+    def test_string_as_keyword(paths: List[str]):
+        """String keywords are matched correctly."""
+        keywords = ('bicycle', )
+        args = update_args_with_paths(paths=paths, keywords=keywords, args=[])
+        expected_args = ['sympy/physics/mechanics/tests/test_kane3.py::test_bicycle']
+        assert len(args) == len(expected_args)
+        for arg, expected in zip(sorted(args), expected_args):
+            assert expected in arg
+
+    @staticmethod
+    @pytest.mark.parametrize(
+        'paths',
+        [
+
+            [],
+            ['sympy/core'],
+            ['sympy/core/tests'],
+            ['sympy/core/tests/test_sympify.py'],
+        ]
+    )
+    def test_integer_as_keyword(paths: List[str]):
+        """Integer keywords are matched correctly."""
+        keywords = ('3538', )
+        args = update_args_with_paths(paths=paths, keywords=keywords, args=[])
+        expected_args = ['sympy/core/tests/test_sympify.py::test_issue_3538']
+        assert len(args) == len(expected_args)
+        for arg, expected in zip(sorted(args), expected_args):
+            assert expected in arg
+
+    @staticmethod
+    def test_multiple_keywords():
+        """Multiple keywords are matched correctly."""
+        keywords = ('bicycle', '3538')
+        args = update_args_with_paths(paths=[], keywords=keywords, args=[])
+        expected_args = [
+            'sympy/core/tests/test_sympify.py::test_issue_3538',
+            'sympy/physics/mechanics/tests/test_kane3.py::test_bicycle',
+        ]
+        assert len(args) == len(expected_args)
+        for arg, expected in zip(sorted(args), expected_args):
+            assert expected in arg
+
+    @staticmethod
+    def test_keyword_match_in_multiple_files():
+        """Keywords are matched across multiple files."""
+        keywords = ('1130', )
+        args = update_args_with_paths(paths=[], keywords=keywords, args=[])
+        expected_args = [
+            'sympy/integrals/tests/test_heurisch.py::test_heurisch_symbolic_coeffs_1130',
+            'sympy/utilities/tests/test_lambdify.py::test_python_div_zero_issue_11306',
+        ]
+        assert len(args) == len(expected_args)
+        for arg, expected in zip(sorted(args), expected_args):
+            assert expected in arg
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/unify/__pycache__/__init__.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/unify/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..066e2d06d1d0142fbfd2d597c08e67a312767bf6
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/unify/__pycache__/__init__.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/unify/__pycache__/core.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/unify/__pycache__/core.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..eb813aa7ac6e35b35be2c094e7d7ce0bff7488cd
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/unify/__pycache__/core.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/unify/__pycache__/rewrite.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/unify/__pycache__/rewrite.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a33eda72c8b701435553d0f404f78a3e6879dbbd
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/unify/__pycache__/rewrite.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/unify/__pycache__/usympy.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/unify/__pycache__/usympy.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..236019573c5c0eb79ad95b9f0bddc5ee58030bcb
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/unify/__pycache__/usympy.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/unify/tests/__init__.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/unify/tests/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/unify/tests/__pycache__/__init__.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/unify/tests/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..2b6990496137da2588a12b891e453be4216132fe
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/unify/tests/__pycache__/__init__.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/unify/tests/__pycache__/test_rewrite.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/unify/tests/__pycache__/test_rewrite.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c3aaa9905d5fafccc9a037db2a203f2f5eaac1bc
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/unify/tests/__pycache__/test_rewrite.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/unify/tests/__pycache__/test_sympy.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/unify/tests/__pycache__/test_sympy.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a17f1ae87cd4492ef0b03745c06418954ff00f4d
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/unify/tests/__pycache__/test_sympy.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/unify/tests/__pycache__/test_unify.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/unify/tests/__pycache__/test_unify.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..01da3da411d2a88d1b4584588f2d45b8bc07b93c
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/unify/tests/__pycache__/test_unify.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/unify/tests/test_rewrite.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/unify/tests/test_rewrite.py
new file mode 100644
index 0000000000000000000000000000000000000000..7b73e2856d5f6380c576220fa2780324df98091a
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/unify/tests/test_rewrite.py
@@ -0,0 +1,74 @@
+from sympy.unify.rewrite import rewriterule
+from sympy.core.basic import Basic
+from sympy.core.singleton import S
+from sympy.core.symbol import Symbol
+from sympy.functions.elementary.trigonometric import sin
+from sympy.abc import x, y
+from sympy.strategies.rl import rebuild
+from sympy.assumptions import Q
+
+p, q = Symbol('p'), Symbol('q')
+
+def test_simple():
+    rl = rewriterule(Basic(p, S(1)), Basic(p, S(2)), variables=(p,))
+    assert list(rl(Basic(S(3), S(1)))) == [Basic(S(3), S(2))]
+
+    p1 = p**2
+    p2 = p**3
+    rl = rewriterule(p1, p2, variables=(p,))
+
+    expr = x**2
+    assert list(rl(expr)) == [x**3]
+
+def test_simple_variables():
+    rl = rewriterule(Basic(x, S(1)), Basic(x, S(2)), variables=(x,))
+    assert list(rl(Basic(S(3), S(1)))) == [Basic(S(3), S(2))]
+
+    rl = rewriterule(x**2, x**3, variables=(x,))
+    assert list(rl(y**2)) == [y**3]
+
+def test_moderate():
+    p1 = p**2 + q**3
+    p2 = (p*q)**4
+    rl = rewriterule(p1, p2, (p, q))
+
+    expr = x**2 + y**3
+    assert list(rl(expr)) == [(x*y)**4]
+
+def test_sincos():
+    p1 = sin(p)**2 + sin(p)**2
+    p2 = 1
+    rl = rewriterule(p1, p2, (p, q))
+
+    assert list(rl(sin(x)**2 + sin(x)**2)) == [1]
+    assert list(rl(sin(y)**2 + sin(y)**2)) == [1]
+
+def test_Exprs_ok():
+    rl = rewriterule(p+q, q+p, (p, q))
+    next(rl(x+y)).is_commutative
+    str(next(rl(x+y)))
+
+def test_condition_simple():
+    rl = rewriterule(x, x+1, [x], lambda x: x < 10)
+    assert not list(rl(S(15)))
+    assert rebuild(next(rl(S(5)))) == 6
+
+
+def test_condition_multiple():
+    rl = rewriterule(x + y, x**y, [x,y], lambda x, y: x.is_integer)
+
+    a = Symbol('a')
+    b = Symbol('b', integer=True)
+    expr = a + b
+    assert list(rl(expr)) == [b**a]
+
+    c = Symbol('c', integer=True)
+    d = Symbol('d', integer=True)
+    assert set(rl(c + d)) == {c**d, d**c}
+
+def test_assumptions():
+    rl = rewriterule(x + y, x**y, [x, y], assume=Q.integer(x))
+
+    a, b = map(Symbol, 'ab')
+    expr = a + b
+    assert list(rl(expr, Q.integer(b))) == [b**a]
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/unify/tests/test_sympy.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/unify/tests/test_sympy.py
new file mode 100644
index 0000000000000000000000000000000000000000..eca3933a91abfabdbad96f626e4da761a41b3fd2
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/unify/tests/test_sympy.py
@@ -0,0 +1,162 @@
+from sympy.core.add import Add
+from sympy.core.basic import Basic
+from sympy.core.containers import Tuple
+from sympy.core.singleton import S
+from sympy.core.symbol import (Symbol, symbols)
+from sympy.logic.boolalg import And
+from sympy.core.symbol import Str
+from sympy.unify.core import Compound, Variable
+from sympy.unify.usympy import (deconstruct, construct, unify, is_associative,
+        is_commutative)
+from sympy.abc import x, y, z, n
+
+def test_deconstruct():
+    expr     = Basic(S(1), S(2), S(3))
+    expected = Compound(Basic, (1, 2, 3))
+    assert deconstruct(expr) == expected
+
+    assert deconstruct(1) == 1
+    assert deconstruct(x) == x
+    assert deconstruct(x, variables=(x,)) == Variable(x)
+    assert deconstruct(Add(1, x, evaluate=False)) == Compound(Add, (1, x))
+    assert deconstruct(Add(1, x, evaluate=False), variables=(x,)) == \
+              Compound(Add, (1, Variable(x)))
+
+def test_construct():
+    expr     = Compound(Basic, (S(1), S(2), S(3)))
+    expected = Basic(S(1), S(2), S(3))
+    assert construct(expr) == expected
+
+def test_nested():
+    expr = Basic(S(1), Basic(S(2)), S(3))
+    cmpd = Compound(Basic, (S(1), Compound(Basic, Tuple(2)), S(3)))
+    assert deconstruct(expr) == cmpd
+    assert construct(cmpd) == expr
+
+def test_unify():
+    expr = Basic(S(1), S(2), S(3))
+    a, b, c = map(Symbol, 'abc')
+    pattern = Basic(a, b, c)
+    assert list(unify(expr, pattern, {}, (a, b, c))) == [{a: 1, b: 2, c: 3}]
+    assert list(unify(expr, pattern, variables=(a, b, c))) == \
+            [{a: 1, b: 2, c: 3}]
+
+def test_unify_variables():
+    assert list(unify(Basic(S(1), S(2)), Basic(S(1), x), {}, variables=(x,))) == [{x: 2}]
+
+def test_s_input():
+    expr = Basic(S(1), S(2))
+    a, b = map(Symbol, 'ab')
+    pattern = Basic(a, b)
+    assert list(unify(expr, pattern, {}, (a, b))) == [{a: 1, b: 2}]
+    assert list(unify(expr, pattern, {a: 5}, (a, b))) == []
+
+def iterdicteq(a, b):
+    a = tuple(a)
+    b = tuple(b)
+    return len(a) == len(b) and all(x in b for x in a)
+
+def test_unify_commutative():
+    expr = Add(1, 2, 3, evaluate=False)
+    a, b, c = map(Symbol, 'abc')
+    pattern = Add(a, b, c, evaluate=False)
+
+    result  = tuple(unify(expr, pattern, {}, (a, b, c)))
+    expected = ({a: 1, b: 2, c: 3},
+                {a: 1, b: 3, c: 2},
+                {a: 2, b: 1, c: 3},
+                {a: 2, b: 3, c: 1},
+                {a: 3, b: 1, c: 2},
+                {a: 3, b: 2, c: 1})
+
+    assert iterdicteq(result, expected)
+
+def test_unify_iter():
+    expr = Add(1, 2, 3, evaluate=False)
+    a, b, c = map(Symbol, 'abc')
+    pattern = Add(a, c, evaluate=False)
+    assert is_associative(deconstruct(pattern))
+    assert is_commutative(deconstruct(pattern))
+
+    result   = list(unify(expr, pattern, {}, (a, c)))
+    expected = [{a: 1, c: Add(2, 3, evaluate=False)},
+                {a: 1, c: Add(3, 2, evaluate=False)},
+                {a: 2, c: Add(1, 3, evaluate=False)},
+                {a: 2, c: Add(3, 1, evaluate=False)},
+                {a: 3, c: Add(1, 2, evaluate=False)},
+                {a: 3, c: Add(2, 1, evaluate=False)},
+                {a: Add(1, 2, evaluate=False), c: 3},
+                {a: Add(2, 1, evaluate=False), c: 3},
+                {a: Add(1, 3, evaluate=False), c: 2},
+                {a: Add(3, 1, evaluate=False), c: 2},
+                {a: Add(2, 3, evaluate=False), c: 1},
+                {a: Add(3, 2, evaluate=False), c: 1}]
+
+    assert iterdicteq(result, expected)
+
+def test_hard_match():
+    from sympy.functions.elementary.trigonometric import (cos, sin)
+    expr = sin(x) + cos(x)**2
+    p, q = map(Symbol, 'pq')
+    pattern = sin(p) + cos(p)**2
+    assert list(unify(expr, pattern, {}, (p, q))) == [{p: x}]
+
+def test_matrix():
+    from sympy.matrices.expressions.matexpr import MatrixSymbol
+    X = MatrixSymbol('X', n, n)
+    Y = MatrixSymbol('Y', 2, 2)
+    Z = MatrixSymbol('Z', 2, 3)
+    assert list(unify(X, Y, {}, variables=[n, Str('X')])) == [{Str('X'): Str('Y'), n: 2}]
+    assert list(unify(X, Z, {}, variables=[n, Str('X')])) == []
+
+def test_non_frankenAdds():
+    # the is_commutative property used to fail because of Basic.__new__
+    # This caused is_commutative and str calls to fail
+    expr = x+y*2
+    rebuilt = construct(deconstruct(expr))
+    # Ensure that we can run these commands without causing an error
+    str(rebuilt)
+    rebuilt.is_commutative
+
+def test_FiniteSet_commutivity():
+    from sympy.sets.sets import FiniteSet
+    a, b, c, x, y = symbols('a,b,c,x,y')
+    s = FiniteSet(a, b, c)
+    t = FiniteSet(x, y)
+    variables = (x, y)
+    assert {x: FiniteSet(a, c), y: b} in tuple(unify(s, t, variables=variables))
+
+def test_FiniteSet_complex():
+    from sympy.sets.sets import FiniteSet
+    a, b, c, x, y, z = symbols('a,b,c,x,y,z')
+    expr = FiniteSet(Basic(S(1), x), y, Basic(x, z))
+    pattern = FiniteSet(a, Basic(x, b))
+    variables = a, b
+    expected = ({b: 1, a: FiniteSet(y, Basic(x, z))},
+                      {b: z, a: FiniteSet(y, Basic(S(1), x))})
+    assert iterdicteq(unify(expr, pattern, variables=variables), expected)
+
+
+def test_and():
+    variables = x, y
+    expected = ({x: z > 0, y: n < 3},)
+    assert iterdicteq(unify((z>0) & (n<3), And(x, y), variables=variables),
+                      expected)
+
+def test_Union():
+    from sympy.sets.sets import Interval
+    assert list(unify(Interval(0, 1) + Interval(10, 11),
+                      Interval(0, 1) + Interval(12, 13),
+                      variables=(Interval(12, 13),)))
+
+def test_is_commutative():
+    assert is_commutative(deconstruct(x+y))
+    assert is_commutative(deconstruct(x*y))
+    assert not is_commutative(deconstruct(x**y))
+
+def test_commutative_in_commutative():
+    from sympy.abc import a,b,c,d
+    from sympy.functions.elementary.trigonometric import (cos, sin)
+    eq = sin(3)*sin(4)*sin(5) + 4*cos(3)*cos(4)
+    pat = a*cos(b)*cos(c) + d*sin(b)*sin(c)
+    assert next(unify(eq, pat, variables=(a,b,c,d)))
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/unify/tests/test_unify.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/unify/tests/test_unify.py
new file mode 100644
index 0000000000000000000000000000000000000000..31153242576e1ff55dd3097efbc985aced5d574a
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/unify/tests/test_unify.py
@@ -0,0 +1,88 @@
+from sympy.unify.core import Compound, Variable, CondVariable, allcombinations
+from sympy.unify import core
+
+a,b,c = 'a', 'b', 'c'
+w,x,y,z = map(Variable, 'wxyz')
+
+C = Compound
+
+def is_associative(x):
+    return isinstance(x, Compound) and (x.op in ('Add', 'Mul', 'CAdd', 'CMul'))
+def is_commutative(x):
+    return isinstance(x, Compound) and (x.op in ('CAdd', 'CMul'))
+
+
+def unify(a, b, s={}):
+    return core.unify(a, b, s=s, is_associative=is_associative,
+                          is_commutative=is_commutative)
+
+def test_basic():
+    assert list(unify(a, x, {})) == [{x: a}]
+    assert list(unify(a, x, {x: 10})) == []
+    assert list(unify(1, x, {})) == [{x: 1}]
+    assert list(unify(a, a, {})) == [{}]
+    assert list(unify((w, x), (y, z), {})) == [{w: y, x: z}]
+    assert list(unify(x, (a, b), {})) == [{x: (a, b)}]
+
+    assert list(unify((a, b), (x, x), {})) == []
+    assert list(unify((y, z), (x, x), {}))!= []
+    assert list(unify((a, (b, c)), (a, (x, y)), {})) == [{x: b, y: c}]
+
+def test_ops():
+    assert list(unify(C('Add', (a,b,c)), C('Add', (a,x,y)), {})) == \
+            [{x:b, y:c}]
+    assert list(unify(C('Add', (C('Mul', (1,2)), b,c)), C('Add', (x,y,c)), {})) == \
+            [{x: C('Mul', (1,2)), y:b}]
+
+def test_associative():
+    c1 = C('Add', (1,2,3))
+    c2 = C('Add', (x,y))
+    assert tuple(unify(c1, c2, {})) == ({x: 1, y: C('Add', (2, 3))},
+                                         {x: C('Add', (1, 2)), y: 3})
+
+def test_commutative():
+    c1 = C('CAdd', (1,2,3))
+    c2 = C('CAdd', (x,y))
+    result = list(unify(c1, c2, {}))
+    assert  {x: 1, y: C('CAdd', (2, 3))} in result
+    assert ({x: 2, y: C('CAdd', (1, 3))} in result or
+            {x: 2, y: C('CAdd', (3, 1))} in result)
+
+def _test_combinations_assoc():
+    assert set(allcombinations((1,2,3), (a,b), True)) == \
+        {(((1, 2), (3,)), (a, b)), (((1,), (2, 3)), (a, b))}
+
+def _test_combinations_comm():
+    assert set(allcombinations((1,2,3), (a,b), None)) == \
+        {(((1,), (2, 3)), ('a', 'b')), (((2,), (3, 1)), ('a', 'b')),
+             (((3,), (1, 2)), ('a', 'b')), (((1, 2), (3,)), ('a', 'b')),
+             (((2, 3), (1,)), ('a', 'b')), (((3, 1), (2,)), ('a', 'b'))}
+
+def test_allcombinations():
+    assert set(allcombinations((1,2), (1,2), 'commutative')) ==\
+        {(((1,),(2,)), ((1,),(2,))), (((1,),(2,)), ((2,),(1,)))}
+
+
+def test_commutativity():
+    c1 = Compound('CAdd', (a, b))
+    c2 = Compound('CAdd', (x, y))
+    assert is_commutative(c1) and is_commutative(c2)
+    assert len(list(unify(c1, c2, {}))) == 2
+
+
+def test_CondVariable():
+    expr = C('CAdd', (1, 2))
+    x = Variable('x')
+    y = CondVariable('y', lambda a: a % 2 == 0)
+    z = CondVariable('z', lambda a: a > 3)
+    pattern = C('CAdd', (x, y))
+    assert list(unify(expr, pattern, {})) == \
+            [{x: 1, y: 2}]
+
+    z = CondVariable('z', lambda a: a > 3)
+    pattern = C('CAdd', (z, y))
+
+    assert list(unify(expr, pattern, {})) == []
+
+def test_defaultdict():
+    assert next(unify(Variable('x'), 'foo')) == {Variable('x'): 'foo'}
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/__pycache__/__init__.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..079dbe20dfa3604b7243cd1e09831c64e11c9ef2
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/__pycache__/__init__.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/__pycache__/autowrap.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/__pycache__/autowrap.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a8409a00df0fa2ba9642477ef50e810b7dd8174b
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/__pycache__/autowrap.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/__pycache__/codegen.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/__pycache__/codegen.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f507986db07034c3537b4842b61824b23bf91630
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/__pycache__/codegen.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/__pycache__/decorator.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/__pycache__/decorator.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..569b6ec7a879e59d9263c75f899684ded386ed46
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/__pycache__/decorator.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/__pycache__/enumerative.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/__pycache__/enumerative.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..67b793cf8e6f743827e97671f14230dd63850eee
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/__pycache__/enumerative.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/__pycache__/exceptions.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/__pycache__/exceptions.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c49428db412bb60578c3f10ad361ba59a88ed1f3
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/__pycache__/exceptions.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/__pycache__/iterables.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/__pycache__/iterables.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5e4b82cb4ddff8fdd92cf9c4577a7867e3f580f7
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/__pycache__/iterables.cpython-312.pyc
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e3675effc1795d9d244656dd6ec2c51cbd51747f16c622d9621f8ea3912424e4
+size 105777
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/__pycache__/lambdify.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/__pycache__/lambdify.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..2d42dee65861edfad2ec7da1203970e13e985575
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/__pycache__/lambdify.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/__pycache__/magic.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/__pycache__/magic.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b352f48ebeef61051a1c0630ee47d86c4dd372b2
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/__pycache__/magic.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/__pycache__/matchpy_connector.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/__pycache__/matchpy_connector.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c91db3f638d17027f44e23399733fbd90a3eb9d8
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/__pycache__/matchpy_connector.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/__pycache__/memoization.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/__pycache__/memoization.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a28b2b6b5ed776239d555f7ed0baeb1e5fc4ff2c
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/__pycache__/memoization.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/__pycache__/misc.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/__pycache__/misc.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5d7f48ea2c475fbddfb8c2a1ec0f588814618930
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/__pycache__/misc.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/__pycache__/pkgdata.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/__pycache__/pkgdata.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f5f8f66f0fbafc19067ee8b2396ba2e240365c44
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/__pycache__/pkgdata.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/__pycache__/pytest.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/__pycache__/pytest.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..78d28dcfa5173794437abb619ca85117e0ba17b7
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/__pycache__/pytest.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/__pycache__/randtest.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/__pycache__/randtest.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c2eb06fadc0192e386e23cd3cf61a34dbd964f1a
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/__pycache__/randtest.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/__pycache__/runtests.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/__pycache__/runtests.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..81c3716fa9fa8e4c9fedd7bd462e92c78b4b543a
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/__pycache__/runtests.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/__pycache__/source.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/__pycache__/source.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c4f997c6cd3a63b49a14de31cf4914c2439177c2
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/__pycache__/source.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/__pycache__/timeutils.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/__pycache__/timeutils.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..71bd8f742291ad4b22fb7d7c19401ad4d6500e33
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/__pycache__/timeutils.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/__pycache__/tmpfiles.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/__pycache__/tmpfiles.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..3f76774bb632be9c7826a2389fc79b0a3910079f
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/__pycache__/tmpfiles.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/_compilation/__init__.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/_compilation/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..d2c05ad48a93493bb5434256c88dfd614ac47b2d
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/_compilation/__init__.py
@@ -0,0 +1,22 @@
+""" This sub-module is private, i.e. external code should not depend on it.
+
+These functions are used by tests run as part of continuous integration.
+Once the implementation is mature (it should support the major
+platforms: Windows, OS X & Linux) it may become official API which
+ may be relied upon by downstream libraries. Until then API may break
+without prior notice.
+
+TODO:
+- (optionally) clean up after tempfile.mkdtemp()
+- cross-platform testing
+- caching of compiler choice and intermediate files
+
+"""
+
+from .compilation import compile_link_import_strings, compile_run_strings
+from .availability import has_fortran, has_c, has_cxx
+
+__all__ = [
+    'compile_link_import_strings', 'compile_run_strings',
+    'has_fortran', 'has_c', 'has_cxx',
+]
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/_compilation/__pycache__/__init__.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/_compilation/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..7261aa021c7776343ec5e90333bd2ea8d0e9d9ec
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/_compilation/__pycache__/__init__.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/_compilation/__pycache__/availability.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/_compilation/__pycache__/availability.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f0760ca24157ac09e3f2b91fb06c7ba23c78cd8f
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/_compilation/__pycache__/availability.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/_compilation/__pycache__/compilation.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/_compilation/__pycache__/compilation.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..4d24699d1bd5760858cfee4422aaa2c81d314268
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/_compilation/__pycache__/compilation.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/_compilation/__pycache__/runners.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/_compilation/__pycache__/runners.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..be8fd636640072bd499b2c60af4539694f663df3
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/_compilation/__pycache__/runners.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/_compilation/__pycache__/util.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/_compilation/__pycache__/util.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..9dad75ac261996a380407984637ad843d0811c36
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/_compilation/__pycache__/util.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/_compilation/availability.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/_compilation/availability.py
new file mode 100644
index 0000000000000000000000000000000000000000..dc97b3e7b8c7e7307c6c21352ed4035d977aabb3
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/_compilation/availability.py
@@ -0,0 +1,77 @@
+import os
+from .compilation import compile_run_strings
+from .util import CompilerNotFoundError
+
+def has_fortran():
+    if not hasattr(has_fortran, 'result'):
+        try:
+            (stdout, stderr), info = compile_run_strings(
+                [('main.f90', (
+                    'program foo\n'
+                    'print *, "hello world"\n'
+                    'end program'
+                ))], clean=True
+            )
+        except CompilerNotFoundError:
+            has_fortran.result = False
+            if os.environ.get('SYMPY_STRICT_COMPILER_CHECKS', '0') == '1':
+                raise
+        else:
+            if info['exit_status'] != os.EX_OK or 'hello world' not in stdout:
+                if os.environ.get('SYMPY_STRICT_COMPILER_CHECKS', '0') == '1':
+                    raise ValueError("Failed to compile test program:\n%s\n%s\n" % (stdout, stderr))
+                has_fortran.result = False
+            else:
+                has_fortran.result = True
+    return has_fortran.result
+
+
+def has_c():
+    if not hasattr(has_c, 'result'):
+        try:
+            (stdout, stderr), info = compile_run_strings(
+                [('main.c', (
+                    '#include <stdio.h>\n'
+                    'int main(){\n'
+                    'printf("hello world\\n");\n'
+                    'return 0;\n'
+                    '}'
+                ))], clean=True
+            )
+        except CompilerNotFoundError:
+            has_c.result = False
+            if os.environ.get('SYMPY_STRICT_COMPILER_CHECKS', '0') == '1':
+                raise
+        else:
+            if info['exit_status'] != os.EX_OK or 'hello world' not in stdout:
+                if os.environ.get('SYMPY_STRICT_COMPILER_CHECKS', '0') == '1':
+                    raise ValueError("Failed to compile test program:\n%s\n%s\n" % (stdout, stderr))
+                has_c.result = False
+            else:
+                has_c.result = True
+    return has_c.result
+
+
+def has_cxx():
+    if not hasattr(has_cxx, 'result'):
+        try:
+            (stdout, stderr), info = compile_run_strings(
+                [('main.cxx', (
+                    '#include <iostream>\n'
+                    'int main(){\n'
+                    'std::cout << "hello world" << std::endl;\n'
+                    '}'
+                ))], clean=True
+            )
+        except CompilerNotFoundError:
+            has_cxx.result = False
+            if os.environ.get('SYMPY_STRICT_COMPILER_CHECKS', '0') == '1':
+                raise
+        else:
+            if info['exit_status'] != os.EX_OK or 'hello world' not in stdout:
+                if os.environ.get('SYMPY_STRICT_COMPILER_CHECKS', '0') == '1':
+                    raise ValueError("Failed to compile test program:\n%s\n%s\n" % (stdout, stderr))
+                has_cxx.result = False
+            else:
+                has_cxx.result = True
+    return has_cxx.result
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/_compilation/compilation.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/_compilation/compilation.py
new file mode 100644
index 0000000000000000000000000000000000000000..2d50a20467c08086d6cb5fb5b0d478e7a953d720
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/_compilation/compilation.py
@@ -0,0 +1,657 @@
+import glob
+import os
+import shutil
+import subprocess
+import sys
+import tempfile
+import warnings
+from pathlib import Path
+from sysconfig import get_config_var, get_config_vars, get_path
+
+from .runners import (
+    CCompilerRunner,
+    CppCompilerRunner,
+    FortranCompilerRunner
+)
+from .util import (
+    get_abspath, make_dirs, copy, Glob, ArbitraryDepthGlob,
+    glob_at_depth, import_module_from_file, pyx_is_cplus,
+    sha256_of_string, sha256_of_file, CompileError
+)
+
+if os.name == 'posix':
+    objext = '.o'
+elif os.name == 'nt':
+    objext = '.obj'
+else:
+    warnings.warn("Unknown os.name: {}".format(os.name))
+    objext = '.o'
+
+
+def compile_sources(files, Runner=None, destdir=None, cwd=None, keep_dir_struct=False,
+                    per_file_kwargs=None, **kwargs):
+    """ Compile source code files to object files.
+
+    Parameters
+    ==========
+
+    files : iterable of str
+        Paths to source files, if ``cwd`` is given, the paths are taken as relative.
+    Runner: CompilerRunner subclass (optional)
+        Could be e.g. ``FortranCompilerRunner``. Will be inferred from filename
+        extensions if missing.
+    destdir: str
+        Output directory, if cwd is given, the path is taken as relative.
+    cwd: str
+        Working directory. Specify to have compiler run in other directory.
+        also used as root of relative paths.
+    keep_dir_struct: bool
+        Reproduce directory structure in `destdir`. default: ``False``
+    per_file_kwargs: dict
+        Dict mapping instances in ``files`` to keyword arguments.
+    \\*\\*kwargs: dict
+        Default keyword arguments to pass to ``Runner``.
+
+    Returns
+    =======
+    List of strings (paths of object files).
+    """
+    _per_file_kwargs = {}
+
+    if per_file_kwargs is not None:
+        for k, v in per_file_kwargs.items():
+            if isinstance(k, Glob):
+                for path in glob.glob(k.pathname):
+                    _per_file_kwargs[path] = v
+            elif isinstance(k, ArbitraryDepthGlob):
+                for path in glob_at_depth(k.filename, cwd):
+                    _per_file_kwargs[path] = v
+            else:
+                _per_file_kwargs[k] = v
+
+    # Set up destination directory
+    destdir = destdir or '.'
+    if not os.path.isdir(destdir):
+        if os.path.exists(destdir):
+            raise OSError("{} is not a directory".format(destdir))
+        else:
+            make_dirs(destdir)
+    if cwd is None:
+        cwd = '.'
+        for f in files:
+            copy(f, destdir, only_update=True, dest_is_dir=True)
+
+    # Compile files and return list of paths to the objects
+    dstpaths = []
+    for f in files:
+        if keep_dir_struct:
+            name, ext = os.path.splitext(f)
+        else:
+            name, ext = os.path.splitext(os.path.basename(f))
+        file_kwargs = kwargs.copy()
+        file_kwargs.update(_per_file_kwargs.get(f, {}))
+        dstpaths.append(src2obj(f, Runner, cwd=cwd, **file_kwargs))
+    return dstpaths
+
+
+def get_mixed_fort_c_linker(vendor=None, cplus=False, cwd=None):
+    vendor = vendor or os.environ.get('SYMPY_COMPILER_VENDOR', 'gnu')
+
+    if vendor.lower() == 'intel':
+        if cplus:
+            return (FortranCompilerRunner,
+                    {'flags': ['-nofor_main', '-cxxlib']}, vendor)
+        else:
+            return (FortranCompilerRunner,
+                    {'flags': ['-nofor_main']}, vendor)
+    elif vendor.lower() == 'gnu' or 'llvm':
+        if cplus:
+            return (CppCompilerRunner,
+                    {'lib_options': ['fortran']}, vendor)
+        else:
+            return (FortranCompilerRunner,
+                    {}, vendor)
+    else:
+        raise ValueError("No vendor found.")
+
+
+def link(obj_files, out_file=None, shared=False, Runner=None,
+         cwd=None, cplus=False, fort=False, extra_objs=None, **kwargs):
+    """ Link object files.
+
+    Parameters
+    ==========
+
+    obj_files: iterable of str
+        Paths to object files.
+    out_file: str (optional)
+        Path to executable/shared library, if ``None`` it will be
+        deduced from the last item in obj_files.
+    shared: bool
+        Generate a shared library?
+    Runner: CompilerRunner subclass (optional)
+        If not given the ``cplus`` and ``fort`` flags will be inspected
+        (fallback is the C compiler).
+    cwd: str
+        Path to the root of relative paths and working directory for compiler.
+    cplus: bool
+        C++ objects? default: ``False``.
+    fort: bool
+        Fortran objects? default: ``False``.
+    extra_objs: list
+        List of paths to extra object files / static libraries.
+    \\*\\*kwargs: dict
+        Keyword arguments passed to ``Runner``.
+
+    Returns
+    =======
+
+    The absolute path to the generated shared object / executable.
+
+    """
+    if out_file is None:
+        out_file, ext = os.path.splitext(os.path.basename(obj_files[-1]))
+        if shared:
+            out_file += get_config_var('EXT_SUFFIX')
+
+    if not Runner:
+        if fort:
+            Runner, extra_kwargs, vendor = \
+                get_mixed_fort_c_linker(
+                    vendor=kwargs.get('vendor', None),
+                    cplus=cplus,
+                    cwd=cwd,
+                )
+            for k, v in extra_kwargs.items():
+                if k in kwargs:
+                    kwargs[k].expand(v)
+                else:
+                    kwargs[k] = v
+        else:
+            if cplus:
+                Runner = CppCompilerRunner
+            else:
+                Runner = CCompilerRunner
+
+    flags = kwargs.pop('flags', [])
+    if shared:
+        if '-shared' not in flags:
+            flags.append('-shared')
+    run_linker = kwargs.pop('run_linker', True)
+    if not run_linker:
+        raise ValueError("run_linker was set to False (nonsensical).")
+
+    out_file = get_abspath(out_file, cwd=cwd)
+    runner = Runner(obj_files+(extra_objs or []), out_file, flags, cwd=cwd, **kwargs)
+    runner.run()
+    return out_file
+
+
+def link_py_so(obj_files, so_file=None, cwd=None, libraries=None,
+               cplus=False, fort=False, extra_objs=None, **kwargs):
+    """ Link Python extension module (shared object) for importing
+
+    Parameters
+    ==========
+
+    obj_files: iterable of str
+        Paths to object files to be linked.
+    so_file: str
+        Name (path) of shared object file to create. If not specified it will
+        have the basname of the last object file in `obj_files` but with the
+        extension '.so' (Unix).
+    cwd: path string
+        Root of relative paths and working directory of linker.
+    libraries: iterable of strings
+        Libraries to link against, e.g. ['m'].
+    cplus: bool
+        Any C++ objects? default: ``False``.
+    fort: bool
+        Any Fortran objects? default: ``False``.
+    extra_objs: list
+        List of paths of extra object files / static libraries to link against.
+    kwargs**: dict
+        Keyword arguments passed to ``link(...)``.
+
+    Returns
+    =======
+
+    Absolute path to the generate shared object.
+    """
+    libraries = libraries or []
+
+    include_dirs = kwargs.pop('include_dirs', [])
+    library_dirs = kwargs.pop('library_dirs', [])
+
+    # Add Python include and library directories
+    # PY_LDFLAGS does not available on all python implementations
+    # e.g. when with pypy, so it's LDFLAGS we need to use
+    if sys.platform == "win32":
+        warnings.warn("Windows not yet supported.")
+    elif sys.platform == 'darwin':
+        cfgDict = get_config_vars()
+        kwargs['linkline'] = kwargs.get('linkline', []) + [cfgDict['LDFLAGS']]
+        library_dirs += [cfgDict['LIBDIR']]
+
+        # In macOS, linker needs to compile frameworks
+        # e.g. "-framework CoreFoundation"
+        is_framework = False
+        for opt in cfgDict['LIBS'].split():
+            if is_framework:
+                kwargs['linkline'] = kwargs.get('linkline', []) + ['-framework', opt]
+                is_framework = False
+            elif opt.startswith('-l'):
+                libraries.append(opt[2:])
+            elif opt.startswith('-framework'):
+                is_framework = True
+        # The python library is not included in LIBS
+        libfile = cfgDict['LIBRARY']
+        libname = ".".join(libfile.split('.')[:-1])[3:]
+        libraries.append(libname)
+
+    elif sys.platform[:3] == 'aix':
+        # Don't use the default code below
+        pass
+    else:
+        if get_config_var('Py_ENABLE_SHARED'):
+            cfgDict = get_config_vars()
+            kwargs['linkline'] = kwargs.get('linkline', []) + [cfgDict['LDFLAGS']]
+            library_dirs += [cfgDict['LIBDIR']]
+            for opt in cfgDict['BLDLIBRARY'].split():
+                if opt.startswith('-l'):
+                    libraries += [opt[2:]]
+        else:
+            pass
+
+    flags = kwargs.pop('flags', [])
+    needed_flags = ('-pthread',)
+    for flag in needed_flags:
+        if flag not in flags:
+            flags.append(flag)
+
+    return link(obj_files, shared=True, flags=flags, cwd=cwd, cplus=cplus, fort=fort,
+                include_dirs=include_dirs, libraries=libraries,
+                library_dirs=library_dirs, extra_objs=extra_objs, **kwargs)
+
+
+def simple_cythonize(src, destdir=None, cwd=None, **cy_kwargs):
+    """ Generates a C file from a Cython source file.
+
+    Parameters
+    ==========
+
+    src: str
+        Path to Cython source.
+    destdir: str (optional)
+        Path to output directory (default: '.').
+    cwd: path string (optional)
+        Root of relative paths (default: '.').
+    **cy_kwargs:
+        Second argument passed to cy_compile. Generates a .cpp file if ``cplus=True`` in ``cy_kwargs``,
+        else a .c file.
+    """
+    from Cython.Compiler.Main import (
+        default_options, CompilationOptions
+    )
+    from Cython.Compiler.Main import compile as cy_compile
+
+    assert src.lower().endswith('.pyx') or src.lower().endswith('.py')
+    cwd = cwd or '.'
+    destdir = destdir or '.'
+
+    ext = '.cpp' if cy_kwargs.get('cplus', False) else '.c'
+    c_name = os.path.splitext(os.path.basename(src))[0] + ext
+
+    dstfile = os.path.join(destdir, c_name)
+
+    if cwd:
+        ori_dir = os.getcwd()
+    else:
+        ori_dir = '.'
+    os.chdir(cwd)
+    try:
+        cy_options = CompilationOptions(default_options)
+        cy_options.__dict__.update(cy_kwargs)
+        # Set language_level if not set by cy_kwargs
+        # as not setting it is deprecated
+        if 'language_level' not in cy_kwargs:
+            cy_options.__dict__['language_level'] = 3
+        cy_result = cy_compile([src], cy_options)
+        if cy_result.num_errors > 0:
+            raise ValueError("Cython compilation failed.")
+
+        # Move generated C file to destination
+        # In macOS, the generated C file is in the same directory as the source
+        # but the /var is a symlink to /private/var, so we need to use realpath
+        if os.path.realpath(os.path.dirname(src)) != os.path.realpath(destdir):
+            if os.path.exists(dstfile):
+                os.unlink(dstfile)
+            shutil.move(os.path.join(os.path.dirname(src), c_name), destdir)
+    finally:
+        os.chdir(ori_dir)
+    return dstfile
+
+
+extension_mapping = {
+    '.c': (CCompilerRunner, None),
+    '.cpp': (CppCompilerRunner, None),
+    '.cxx': (CppCompilerRunner, None),
+    '.f': (FortranCompilerRunner, None),
+    '.for': (FortranCompilerRunner, None),
+    '.ftn': (FortranCompilerRunner, None),
+    '.f90': (FortranCompilerRunner, None),  # ifort only knows about .f90
+    '.f95': (FortranCompilerRunner, 'f95'),
+    '.f03': (FortranCompilerRunner, 'f2003'),
+    '.f08': (FortranCompilerRunner, 'f2008'),
+}
+
+
+def src2obj(srcpath, Runner=None, objpath=None, cwd=None, inc_py=False, **kwargs):
+    """ Compiles a source code file to an object file.
+
+    Files ending with '.pyx' assumed to be cython files and
+    are dispatched to pyx2obj.
+
+    Parameters
+    ==========
+
+    srcpath: str
+        Path to source file.
+    Runner: CompilerRunner subclass (optional)
+        If ``None``: deduced from extension of srcpath.
+    objpath : str (optional)
+        Path to generated object. If ``None``: deduced from ``srcpath``.
+    cwd: str (optional)
+        Working directory and root of relative paths. If ``None``: current dir.
+    inc_py: bool
+        Add Python include path to kwarg "include_dirs". Default: False
+    \\*\\*kwargs: dict
+        keyword arguments passed to Runner or pyx2obj
+
+    """
+    name, ext = os.path.splitext(os.path.basename(srcpath))
+    if objpath is None:
+        if os.path.isabs(srcpath):
+            objpath = '.'
+        else:
+            objpath = os.path.dirname(srcpath)
+            objpath = objpath or '.'  # avoid objpath == ''
+
+    if os.path.isdir(objpath):
+        objpath = os.path.join(objpath, name + objext)
+
+    include_dirs = kwargs.pop('include_dirs', [])
+    if inc_py:
+        py_inc_dir = get_path('include')
+        if py_inc_dir not in include_dirs:
+            include_dirs.append(py_inc_dir)
+
+    if ext.lower() == '.pyx':
+        return pyx2obj(srcpath, objpath=objpath, include_dirs=include_dirs, cwd=cwd,
+                       **kwargs)
+
+    if Runner is None:
+        Runner, std = extension_mapping[ext.lower()]
+        if 'std' not in kwargs:
+            kwargs['std'] = std
+
+    flags = kwargs.pop('flags', [])
+    needed_flags = ('-fPIC',)
+    for flag in needed_flags:
+        if flag not in flags:
+            flags.append(flag)
+
+    # src2obj implies not running the linker...
+    run_linker = kwargs.pop('run_linker', False)
+    if run_linker:
+        raise CompileError("src2obj called with run_linker=True")
+
+    runner = Runner([srcpath], objpath, include_dirs=include_dirs,
+                    run_linker=run_linker, cwd=cwd, flags=flags, **kwargs)
+    runner.run()
+    return objpath
+
+
+def pyx2obj(pyxpath, objpath=None, destdir=None, cwd=None,
+            include_dirs=None, cy_kwargs=None, cplus=None, **kwargs):
+    """
+    Convenience function
+
+    If cwd is specified, pyxpath and dst are taken to be relative
+    If only_update is set to `True` the modification time is checked
+    and compilation is only run if the source is newer than the
+    destination
+
+    Parameters
+    ==========
+
+    pyxpath: str
+        Path to Cython source file.
+    objpath: str (optional)
+        Path to object file to generate.
+    destdir: str (optional)
+        Directory to put generated C file. When ``None``: directory of ``objpath``.
+    cwd: str (optional)
+        Working directory and root of relative paths.
+    include_dirs: iterable of path strings (optional)
+        Passed onto src2obj and via cy_kwargs['include_path']
+        to simple_cythonize.
+    cy_kwargs: dict (optional)
+        Keyword arguments passed onto `simple_cythonize`
+    cplus: bool (optional)
+        Indicate whether C++ is used. default: auto-detect using ``.util.pyx_is_cplus``.
+    compile_kwargs: dict
+        keyword arguments passed onto src2obj
+
+    Returns
+    =======
+
+    Absolute path of generated object file.
+
+    """
+    assert pyxpath.endswith('.pyx')
+    cwd = cwd or '.'
+    objpath = objpath or '.'
+    destdir = destdir or os.path.dirname(objpath)
+
+    abs_objpath = get_abspath(objpath, cwd=cwd)
+
+    if os.path.isdir(abs_objpath):
+        pyx_fname = os.path.basename(pyxpath)
+        name, ext = os.path.splitext(pyx_fname)
+        objpath = os.path.join(objpath, name + objext)
+
+    cy_kwargs = cy_kwargs or {}
+    cy_kwargs['output_dir'] = cwd
+    if cplus is None:
+        cplus = pyx_is_cplus(pyxpath)
+    cy_kwargs['cplus'] = cplus
+
+    interm_c_file = simple_cythonize(pyxpath, destdir=destdir, cwd=cwd, **cy_kwargs)
+
+    include_dirs = include_dirs or []
+    flags = kwargs.pop('flags', [])
+    needed_flags = ('-fwrapv', '-pthread', '-fPIC')
+    for flag in needed_flags:
+        if flag not in flags:
+            flags.append(flag)
+
+    options = kwargs.pop('options', [])
+
+    if kwargs.pop('strict_aliasing', False):
+        raise CompileError("Cython requires strict aliasing to be disabled.")
+
+    # Let's be explicit about standard
+    if cplus:
+        std = kwargs.pop('std', 'c++98')
+    else:
+        std = kwargs.pop('std', 'c99')
+
+    return src2obj(interm_c_file, objpath=objpath, cwd=cwd,
+                   include_dirs=include_dirs, flags=flags, std=std,
+                   options=options, inc_py=True, strict_aliasing=False,
+                   **kwargs)
+
+
+def _any_X(srcs, cls):
+    for src in srcs:
+        name, ext = os.path.splitext(src)
+        key = ext.lower()
+        if key in extension_mapping:
+            if extension_mapping[key][0] == cls:
+                return True
+    return False
+
+
+def any_fortran_src(srcs):
+    return _any_X(srcs, FortranCompilerRunner)
+
+
+def any_cplus_src(srcs):
+    return _any_X(srcs, CppCompilerRunner)
+
+
+def compile_link_import_py_ext(sources, extname=None, build_dir='.', compile_kwargs=None,
+                               link_kwargs=None, extra_objs=None):
+    """ Compiles sources to a shared object (Python extension) and imports it
+
+    Sources in ``sources`` which is imported. If shared object is newer than the sources, they
+    are not recompiled but instead it is imported.
+
+    Parameters
+    ==========
+
+    sources : list of strings
+        List of paths to sources.
+    extname : string
+        Name of extension (default: ``None``).
+        If ``None``: taken from the last file in ``sources`` without extension.
+    build_dir: str
+        Path to directory in which objects files etc. are generated.
+    compile_kwargs: dict
+        keyword arguments passed to ``compile_sources``
+    link_kwargs: dict
+        keyword arguments passed to ``link_py_so``
+    extra_objs: list
+        List of paths to (prebuilt) object files / static libraries to link against.
+
+    Returns
+    =======
+
+    The imported module from of the Python extension.
+    """
+    if extname is None:
+        extname = os.path.splitext(os.path.basename(sources[-1]))[0]
+
+    compile_kwargs = compile_kwargs or {}
+    link_kwargs = link_kwargs or {}
+
+    try:
+        mod = import_module_from_file(os.path.join(build_dir, extname), sources)
+    except ImportError:
+        objs = compile_sources(list(map(get_abspath, sources)), destdir=build_dir,
+                               cwd=build_dir, **compile_kwargs)
+        so = link_py_so(objs, cwd=build_dir, fort=any_fortran_src(sources),
+                        cplus=any_cplus_src(sources), extra_objs=extra_objs, **link_kwargs)
+        mod = import_module_from_file(so)
+    return mod
+
+
+def _write_sources_to_build_dir(sources, build_dir):
+    build_dir = build_dir or tempfile.mkdtemp()
+    if not os.path.isdir(build_dir):
+        raise OSError("Non-existent directory: ", build_dir)
+
+    source_files = []
+    for name, src in sources:
+        dest = os.path.join(build_dir, name)
+        differs = True
+        sha256_in_mem = sha256_of_string(src.encode('utf-8')).hexdigest()
+        if os.path.exists(dest):
+            if os.path.exists(dest + '.sha256'):
+                sha256_on_disk = Path(dest + '.sha256').read_text()
+            else:
+                sha256_on_disk = sha256_of_file(dest).hexdigest()
+
+            differs = sha256_on_disk != sha256_in_mem
+        if differs:
+            with open(dest, 'wt') as fh:
+                fh.write(src)
+            with open(dest + '.sha256', 'wt') as fh:
+                fh.write(sha256_in_mem)
+        source_files.append(dest)
+    return source_files, build_dir
+
+
+def compile_link_import_strings(sources, build_dir=None, **kwargs):
+    """ Compiles, links and imports extension module from source.
+
+    Parameters
+    ==========
+
+    sources : iterable of name/source pair tuples
+    build_dir : string (default: None)
+        Path. ``None`` implies use a temporary directory.
+    **kwargs:
+        Keyword arguments passed onto `compile_link_import_py_ext`.
+
+    Returns
+    =======
+
+    mod : module
+        The compiled and imported extension module.
+    info : dict
+        Containing ``build_dir`` as 'build_dir'.
+
+    """
+    source_files, build_dir = _write_sources_to_build_dir(sources, build_dir)
+    mod = compile_link_import_py_ext(source_files, build_dir=build_dir, **kwargs)
+    info = {"build_dir": build_dir}
+    return mod, info
+
+
+def compile_run_strings(sources, build_dir=None, clean=False, compile_kwargs=None, link_kwargs=None):
+    """ Compiles, links and runs a program built from sources.
+
+    Parameters
+    ==========
+
+    sources : iterable of name/source pair tuples
+    build_dir : string (default: None)
+        Path. ``None`` implies use a temporary directory.
+    clean : bool
+        Whether to remove build_dir after use. This will only have an
+        effect if ``build_dir`` is ``None`` (which creates a temporary directory).
+        Passing ``clean == True`` and ``build_dir != None`` raises a ``ValueError``.
+        This will also set ``build_dir`` in returned info dictionary to ``None``.
+    compile_kwargs: dict
+        Keyword arguments passed onto ``compile_sources``
+    link_kwargs: dict
+        Keyword arguments passed onto ``link``
+
+    Returns
+    =======
+
+    (stdout, stderr): pair of strings
+    info: dict
+        Containing exit status as 'exit_status' and ``build_dir`` as 'build_dir'
+
+    """
+    if clean and build_dir is not None:
+        raise ValueError("Automatic removal of build_dir is only available for temporary directory.")
+    try:
+        source_files, build_dir = _write_sources_to_build_dir(sources, build_dir)
+        objs = compile_sources(list(map(get_abspath, source_files)), destdir=build_dir,
+                               cwd=build_dir, **(compile_kwargs or {}))
+        prog = link(objs, cwd=build_dir,
+                    fort=any_fortran_src(source_files),
+                    cplus=any_cplus_src(source_files), **(link_kwargs or {}))
+        p = subprocess.Popen([prog], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+        exit_status = p.wait()
+        stdout, stderr = [txt.decode('utf-8') for txt in p.communicate()]
+    finally:
+        if clean and os.path.isdir(build_dir):
+            shutil.rmtree(build_dir)
+            build_dir = None
+    info = {"exit_status": exit_status, "build_dir": build_dir}
+    return (stdout, stderr), info
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/_compilation/runners.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/_compilation/runners.py
new file mode 100644
index 0000000000000000000000000000000000000000..1f37d6cf8ac47807da7f3f00dfc5cd847c03fa8d
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/_compilation/runners.py
@@ -0,0 +1,301 @@
+from __future__ import annotations
+from typing import Callable, Optional
+
+from collections import OrderedDict
+import os
+import re
+import subprocess
+import warnings
+
+from .util import (
+    find_binary_of_command, unique_list, CompileError
+)
+
+
+class CompilerRunner:
+    """ CompilerRunner base class.
+
+    Parameters
+    ==========
+
+    sources : list of str
+        Paths to sources.
+    out : str
+    flags : iterable of str
+        Compiler flags.
+    run_linker : bool
+    compiler_name_exe : (str, str) tuple
+        Tuple of compiler name &  command to call.
+    cwd : str
+        Path of root of relative paths.
+    include_dirs : list of str
+        Include directories.
+    libraries : list of str
+        Libraries to link against.
+    library_dirs : list of str
+        Paths to search for shared libraries.
+    std : str
+        Standard string, e.g. ``'c++11'``, ``'c99'``, ``'f2003'``.
+    define: iterable of strings
+        macros to define
+    undef : iterable of strings
+        macros to undefine
+    preferred_vendor : string
+        name of preferred vendor e.g. 'gnu' or 'intel'
+
+    Methods
+    =======
+
+    run():
+        Invoke compilation as a subprocess.
+
+    """
+
+    environ_key_compiler: str  # e.g. 'CC', 'CXX', ...
+    environ_key_flags: str  # e.g. 'CFLAGS', 'CXXFLAGS', ...
+    environ_key_ldflags: str = "LDFLAGS"  # typically 'LDFLAGS'
+
+    # Subclass to vendor/binary dict
+    compiler_dict: dict[str, str]
+
+    # Standards should be a tuple of supported standards
+    # (first one will be the default)
+    standards: tuple[None | str, ...]
+
+    # Subclass to dict of binary/formater-callback
+    std_formater: dict[str, Callable[[Optional[str]], str]]
+
+    # subclass to be e.g. {'gcc': 'gnu', ...}
+    compiler_name_vendor_mapping: dict[str, str]
+
+    def __init__(self, sources, out, flags=None, run_linker=True, compiler=None, cwd='.',
+                 include_dirs=None, libraries=None, library_dirs=None, std=None, define=None,
+                 undef=None, strict_aliasing=None, preferred_vendor=None, linkline=None, **kwargs):
+        if isinstance(sources, str):
+            raise ValueError("Expected argument sources to be a list of strings.")
+        self.sources = list(sources)
+        self.out = out
+        self.flags = flags or []
+        if os.environ.get(self.environ_key_flags):
+            self.flags += os.environ[self.environ_key_flags].split()
+        self.cwd = cwd
+        if compiler:
+            self.compiler_name, self.compiler_binary = compiler
+        elif os.environ.get(self.environ_key_compiler):
+            self.compiler_binary = os.environ[self.environ_key_compiler]
+            for k, v in self.compiler_dict.items():
+                if k in self.compiler_binary:
+                    self.compiler_vendor = k
+                    self.compiler_name = v
+                    break
+            else:
+                self.compiler_vendor, self.compiler_name = list(self.compiler_dict.items())[0]
+                warnings.warn("failed to determine what kind of compiler %s is, assuming %s" %
+                              (self.compiler_binary, self.compiler_name))
+        else:
+            # Find a compiler
+            if preferred_vendor is None:
+                preferred_vendor = os.environ.get('SYMPY_COMPILER_VENDOR', None)
+            self.compiler_name, self.compiler_binary, self.compiler_vendor = self.find_compiler(preferred_vendor)
+            if self.compiler_binary is None:
+                raise ValueError("No compiler found (searched: {})".format(', '.join(self.compiler_dict.values())))
+        self.define = define or []
+        self.undef = undef or []
+        self.include_dirs = include_dirs or []
+        self.libraries = libraries or []
+        self.library_dirs = library_dirs or []
+        self.std = std or self.standards[0]
+        self.run_linker = run_linker
+        if self.run_linker:
+            # both gnu and intel compilers use '-c' for disabling linker
+            self.flags = list(filter(lambda x: x != '-c', self.flags))
+        else:
+            if '-c' not in self.flags:
+                self.flags.append('-c')
+
+        if self.std:
+            self.flags.append(self.std_formater[
+                self.compiler_name](self.std))
+
+        self.linkline = (linkline or []) + [lf for lf in map(
+            str.strip, os.environ.get(self.environ_key_ldflags, "").split()
+        ) if lf != ""]
+
+        if strict_aliasing is not None:
+            nsa_re = re.compile("no-strict-aliasing$")
+            sa_re = re.compile("strict-aliasing$")
+            if strict_aliasing is True:
+                if any(map(nsa_re.match, flags)):
+                    raise CompileError("Strict aliasing cannot be both enforced and disabled")
+                elif any(map(sa_re.match, flags)):
+                    pass  # already enforced
+                else:
+                    flags.append('-fstrict-aliasing')
+            elif strict_aliasing is False:
+                if any(map(nsa_re.match, flags)):
+                    pass  # already disabled
+                else:
+                    if any(map(sa_re.match, flags)):
+                        raise CompileError("Strict aliasing cannot be both enforced and disabled")
+                    else:
+                        flags.append('-fno-strict-aliasing')
+            else:
+                msg = "Expected argument strict_aliasing to be True/False, got {}"
+                raise ValueError(msg.format(strict_aliasing))
+
+    @classmethod
+    def find_compiler(cls, preferred_vendor=None):
+        """ Identify a suitable C/fortran/other compiler. """
+        candidates = list(cls.compiler_dict.keys())
+        if preferred_vendor:
+            if preferred_vendor in candidates:
+                candidates = [preferred_vendor]+candidates
+            else:
+                raise ValueError("Unknown vendor {}".format(preferred_vendor))
+        name, path = find_binary_of_command([cls.compiler_dict[x] for x in candidates])
+        return name, path, cls.compiler_name_vendor_mapping[name]
+
+    def cmd(self):
+        """ List of arguments (str) to be passed to e.g. ``subprocess.Popen``. """
+        cmd = (
+            [self.compiler_binary] +
+            self.flags +
+            ['-U'+x for x in self.undef] +
+            ['-D'+x for x in self.define] +
+            ['-I'+x for x in self.include_dirs] +
+            self.sources
+        )
+        if self.run_linker:
+            cmd += (['-L'+x for x in self.library_dirs] +
+                    ['-l'+x for x in self.libraries] +
+                    self.linkline)
+        counted = []
+        for envvar in re.findall(r'\$\{(\w+)\}', ' '.join(cmd)):
+            if os.getenv(envvar) is None:
+                if envvar not in counted:
+                    counted.append(envvar)
+                    msg = "Environment variable '{}' undefined.".format(envvar)
+                    raise CompileError(msg)
+        return cmd
+
+    def run(self):
+        self.flags = unique_list(self.flags)
+
+        # Append output flag and name to tail of flags
+        self.flags.extend(['-o', self.out])
+        env = os.environ.copy()
+        env['PWD'] = self.cwd
+
+        # NOTE: intel compilers seems to need shell=True
+        p = subprocess.Popen(' '.join(self.cmd()),
+                             shell=True,
+                             cwd=self.cwd,
+                             stdin=subprocess.PIPE,
+                             stdout=subprocess.PIPE,
+                             stderr=subprocess.STDOUT,
+                             env=env)
+        comm = p.communicate()
+        try:
+            self.cmd_outerr = comm[0].decode('utf-8')
+        except UnicodeDecodeError:
+            self.cmd_outerr = comm[0].decode('iso-8859-1')  # win32
+        self.cmd_returncode = p.returncode
+
+        # Error handling
+        if self.cmd_returncode != 0:
+            msg = "Error executing '{}' in {} (exited status {}):\n {}\n".format(
+                ' '.join(self.cmd()), self.cwd, str(self.cmd_returncode), self.cmd_outerr
+            )
+            raise CompileError(msg)
+
+        return self.cmd_outerr, self.cmd_returncode
+
+
+class CCompilerRunner(CompilerRunner):
+
+    environ_key_compiler = 'CC'
+    environ_key_flags = 'CFLAGS'
+
+    compiler_dict = OrderedDict([
+        ('gnu', 'gcc'),
+        ('intel', 'icc'),
+        ('llvm', 'clang'),
+    ])
+
+    standards = ('c89', 'c90', 'c99', 'c11')  # First is default
+
+    std_formater = {
+        'gcc': '-std={}'.format,
+        'icc': '-std={}'.format,
+        'clang': '-std={}'.format,
+    }
+
+    compiler_name_vendor_mapping = {
+        'gcc': 'gnu',
+        'icc': 'intel',
+        'clang': 'llvm'
+    }
+
+
+def _mk_flag_filter(cmplr_name):  # helper for class initialization
+    not_welcome = {'g++': ("Wimplicit-interface",)}  # "Wstrict-prototypes",)}
+    if cmplr_name in not_welcome:
+        def fltr(x):
+            for nw in not_welcome[cmplr_name]:
+                if nw in x:
+                    return False
+            return True
+    else:
+        def fltr(x):
+            return True
+    return fltr
+
+
+class CppCompilerRunner(CompilerRunner):
+
+    environ_key_compiler = 'CXX'
+    environ_key_flags = 'CXXFLAGS'
+
+    compiler_dict = OrderedDict([
+        ('gnu', 'g++'),
+        ('intel', 'icpc'),
+        ('llvm', 'clang++'),
+    ])
+
+    # First is the default, c++0x == c++11
+    standards = ('c++98', 'c++0x')
+
+    std_formater = {
+        'g++': '-std={}'.format,
+        'icpc': '-std={}'.format,
+        'clang++': '-std={}'.format,
+    }
+
+    compiler_name_vendor_mapping = {
+        'g++': 'gnu',
+        'icpc': 'intel',
+        'clang++': 'llvm'
+    }
+
+
+class FortranCompilerRunner(CompilerRunner):
+
+    environ_key_compiler = 'FC'
+    environ_key_flags = 'FFLAGS'
+
+    standards = (None, 'f77', 'f95', 'f2003', 'f2008')
+
+    std_formater = {
+        'gfortran': lambda x: '-std=gnu' if x is None else '-std=legacy' if x == 'f77' else '-std={}'.format(x),
+        'ifort': lambda x: '-stand f08' if x is None else '-stand f{}'.format(x[-2:]),  # f2008 => f08
+    }
+
+    compiler_dict = OrderedDict([
+        ('gnu', 'gfortran'),
+        ('intel', 'ifort'),
+    ])
+
+    compiler_name_vendor_mapping = {
+        'gfortran': 'gnu',
+        'ifort': 'intel',
+    }
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/_compilation/tests/__init__.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/_compilation/tests/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/_compilation/tests/__pycache__/__init__.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/_compilation/tests/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..2b4056b42e3a9b2d46f72e351e53562d98e5dbec
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/_compilation/tests/__pycache__/__init__.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/_compilation/tests/__pycache__/test_compilation.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/_compilation/tests/__pycache__/test_compilation.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d8c2d1ab733956ab6b5a809608bdae45ef5e02f9
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/_compilation/tests/__pycache__/test_compilation.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/_compilation/tests/test_compilation.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/_compilation/tests/test_compilation.py
new file mode 100644
index 0000000000000000000000000000000000000000..ff7cf86644a9645665e62b49cfc4e7ea73b2c1ab
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/_compilation/tests/test_compilation.py
@@ -0,0 +1,104 @@
+import shutil
+import os
+import subprocess
+import tempfile
+from sympy.external import import_module
+from sympy.testing.pytest import skip, skip_under_pyodide
+
+from sympy.utilities._compilation.compilation import compile_link_import_py_ext, compile_link_import_strings, compile_sources, get_abspath
+
+numpy = import_module('numpy')
+cython = import_module('cython')
+
+_sources1 = [
+    ('sigmoid.c', r"""
+#include <math.h>
+
+void sigmoid(int n, const double * const restrict in,
+             double * const restrict out, double lim){
+    for (int i=0; i<n; ++i){
+        const double x = in[i];
+        out[i] = x*pow(pow(x/lim, 8)+1, -1./8.);
+    }
+}
+"""),
+    ('_sigmoid.pyx', r"""
+import numpy as np
+cimport numpy as cnp
+
+cdef extern void c_sigmoid "sigmoid" (int, const double * const,
+                                      double * const, double)
+
+def sigmoid(double [:] inp, double lim=350.0):
+    cdef cnp.ndarray[cnp.float64_t, ndim=1] out = np.empty(
+        inp.size, dtype=np.float64)
+    c_sigmoid(inp.size, &inp[0], &out[0], lim)
+    return out
+""")
+]
+
+
+def npy(data, lim=350.0):
+    return data/((data/lim)**8+1)**(1/8.)
+
+
+def test_compile_link_import_strings():
+    if not numpy:
+        skip("numpy not installed.")
+    if not cython:
+        skip("cython not installed.")
+
+    from sympy.utilities._compilation import has_c
+    if not has_c():
+        skip("No C compiler found.")
+
+    compile_kw = {"std": 'c99', "include_dirs": [numpy.get_include()]}
+    info = None
+    try:
+        mod, info = compile_link_import_strings(_sources1, compile_kwargs=compile_kw)
+        data = numpy.random.random(1024*1024*8)  # 64 MB of RAM needed..
+        res_mod = mod.sigmoid(data)
+        res_npy = npy(data)
+        assert numpy.allclose(res_mod, res_npy)
+    finally:
+        if info and info['build_dir']:
+            shutil.rmtree(info['build_dir'])
+
+
+@skip_under_pyodide("Emscripten does not support subprocesses")
+def test_compile_sources():
+    tmpdir = tempfile.mkdtemp()
+
+    from sympy.utilities._compilation import has_c
+    if not has_c():
+        skip("No C compiler found.")
+
+    build_dir = str(tmpdir)
+    _handle, file_path = tempfile.mkstemp('.c', dir=build_dir)
+    with open(file_path, 'wt') as ofh:
+        ofh.write("""
+        int foo(int bar) {
+            return 2*bar;
+        }
+        """)
+    obj, = compile_sources([file_path], cwd=build_dir)
+    obj_path = get_abspath(obj, cwd=build_dir)
+    assert os.path.exists(obj_path)
+    try:
+        _ = subprocess.check_output(["nm", "--help"])
+    except subprocess.CalledProcessError:
+        pass  # we cannot test contents of object file
+    else:
+        nm_out = subprocess.check_output(["nm", obj_path])
+        assert 'foo' in nm_out.decode('utf-8')
+
+    if not cython:
+        return  # the final (optional) part of the test below requires Cython.
+
+    _handle, pyx_path = tempfile.mkstemp('.pyx', dir=build_dir)
+    with open(pyx_path, 'wt') as ofh:
+        ofh.write(("cdef extern int foo(int)\n"
+                   "def _foo(arg):\n"
+                   "    return foo(arg)"))
+    mod = compile_link_import_py_ext([pyx_path], extra_objs=[obj_path], build_dir=build_dir)
+    assert mod._foo(21) == 42
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/_compilation/util.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/_compilation/util.py
new file mode 100644
index 0000000000000000000000000000000000000000..56da78ff89d1228b503f9d273784faf2cea85c5e
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/_compilation/util.py
@@ -0,0 +1,312 @@
+from collections import namedtuple
+from hashlib import sha256
+import os
+import shutil
+import sys
+import fnmatch
+
+from sympy.testing.pytest import XFAIL
+
+
+def may_xfail(func):
+    if sys.platform.lower() == 'darwin' or os.name == 'nt':
+        # sympy.utilities._compilation needs more testing on Windows and macOS
+        # once those two platforms are reliably supported this xfail decorator
+        # may be removed.
+        return XFAIL(func)
+    else:
+        return func
+
+
+class CompilerNotFoundError(FileNotFoundError):
+    pass
+
+
+class CompileError (Exception):
+    """Failure to compile one or more C/C++ source files."""
+
+
+def get_abspath(path, cwd='.'):
+    """ Returns the absolute path.
+
+    Parameters
+    ==========
+
+    path : str
+        (relative) path.
+    cwd : str
+        Path to root of relative path.
+    """
+    if os.path.isabs(path):
+        return path
+    else:
+        if not os.path.isabs(cwd):
+            cwd = os.path.abspath(cwd)
+        return os.path.abspath(
+            os.path.join(cwd, path)
+        )
+
+
+def make_dirs(path):
+    """ Create directories (equivalent of ``mkdir -p``). """
+    if path[-1] == '/':
+        parent = os.path.dirname(path[:-1])
+    else:
+        parent = os.path.dirname(path)
+
+    if len(parent) > 0:
+        if not os.path.exists(parent):
+            make_dirs(parent)
+
+    if not os.path.exists(path):
+        os.mkdir(path, 0o777)
+    else:
+        assert os.path.isdir(path)
+
+def missing_or_other_newer(path, other_path, cwd=None):
+    """
+    Investigate if path is non-existent or older than provided reference
+    path.
+
+    Parameters
+    ==========
+    path: string
+        path to path which might be missing or too old
+    other_path: string
+        reference path
+    cwd: string
+        working directory (root of relative paths)
+
+    Returns
+    =======
+    True if path is older or missing.
+    """
+    cwd = cwd or '.'
+    path = get_abspath(path, cwd=cwd)
+    other_path = get_abspath(other_path, cwd=cwd)
+    if not os.path.exists(path):
+        return True
+    if os.path.getmtime(other_path) - 1e-6 >= os.path.getmtime(path):
+        # 1e-6 is needed because http://stackoverflow.com/questions/17086426/
+        return True
+    return False
+
+def copy(src, dst, only_update=False, copystat=True, cwd=None,
+         dest_is_dir=False, create_dest_dirs=False):
+    """ Variation of ``shutil.copy`` with extra options.
+
+    Parameters
+    ==========
+
+    src : str
+        Path to source file.
+    dst : str
+        Path to destination.
+    only_update : bool
+        Only copy if source is newer than destination
+        (returns None if it was newer), default: ``False``.
+    copystat : bool
+        See ``shutil.copystat``. default: ``True``.
+    cwd : str
+        Path to working directory (root of relative paths).
+    dest_is_dir : bool
+        Ensures that dst is treated as a directory. default: ``False``
+    create_dest_dirs : bool
+        Creates directories if needed.
+
+    Returns
+    =======
+
+    Path to the copied file.
+
+    """
+    if cwd:  # Handle working directory
+        if not os.path.isabs(src):
+            src = os.path.join(cwd, src)
+        if not os.path.isabs(dst):
+            dst = os.path.join(cwd, dst)
+
+    if not os.path.exists(src):  # Make sure source file exists
+        raise FileNotFoundError("Source: `{}` does not exist".format(src))
+
+    # We accept both (re)naming destination file _or_
+    # passing a (possible non-existent) destination directory
+    if dest_is_dir:
+        if not dst[-1] == '/':
+            dst = dst+'/'
+    else:
+        if os.path.exists(dst) and os.path.isdir(dst):
+            dest_is_dir = True
+
+    if dest_is_dir:
+        dest_dir = dst
+        dest_fname = os.path.basename(src)
+        dst = os.path.join(dest_dir, dest_fname)
+    else:
+        dest_dir = os.path.dirname(dst)
+
+    if not os.path.exists(dest_dir):
+        if create_dest_dirs:
+            make_dirs(dest_dir)
+        else:
+            raise FileNotFoundError("You must create directory first.")
+
+    if only_update:
+        if not missing_or_other_newer(dst, src):
+            return
+
+    if os.path.islink(dst):
+        dst = os.path.abspath(os.path.realpath(dst), cwd=cwd)
+
+    shutil.copy(src, dst)
+    if copystat:
+        shutil.copystat(src, dst)
+
+    return dst
+
+Glob = namedtuple('Glob', 'pathname')
+ArbitraryDepthGlob = namedtuple('ArbitraryDepthGlob', 'filename')
+
+def glob_at_depth(filename_glob, cwd=None):
+    if cwd is not None:
+        cwd = '.'
+    globbed = []
+    for root, dirs, filenames in os.walk(cwd):
+        for fn in filenames:
+            # This is not tested:
+            if fnmatch.fnmatch(fn, filename_glob):
+                globbed.append(os.path.join(root, fn))
+    return globbed
+
+def sha256_of_file(path, nblocks=128):
+    """ Computes the SHA256 hash of a file.
+
+    Parameters
+    ==========
+
+    path : string
+        Path to file to compute hash of.
+    nblocks : int
+        Number of blocks to read per iteration.
+
+    Returns
+    =======
+
+    hashlib sha256 hash object. Use ``.digest()`` or ``.hexdigest()``
+    on returned object to get binary or hex encoded string.
+    """
+    sh = sha256()
+    with open(path, 'rb') as f:
+        for chunk in iter(lambda: f.read(nblocks*sh.block_size), b''):
+            sh.update(chunk)
+    return sh
+
+
+def sha256_of_string(string):
+    """ Computes the SHA256 hash of a string. """
+    sh = sha256()
+    sh.update(string)
+    return sh
+
+
+def pyx_is_cplus(path):
+    """
+    Inspect a Cython source file (.pyx) and look for comment line like:
+
+    # distutils: language = c++
+
+    Returns True if such a file is present in the file, else False.
+    """
+    with open(path) as fh:
+        for line in fh:
+            if line.startswith('#') and '=' in line:
+                splitted = line.split('=')
+                if len(splitted) != 2:
+                    continue
+                lhs, rhs = splitted
+                if lhs.strip().split()[-1].lower() == 'language' and \
+                       rhs.strip().split()[0].lower() == 'c++':
+                            return True
+    return False
+
+def import_module_from_file(filename, only_if_newer_than=None):
+    """ Imports Python extension (from shared object file)
+
+    Provide a list of paths in `only_if_newer_than` to check
+    timestamps of dependencies. import_ raises an ImportError
+    if any is newer.
+
+    Word of warning: The OS may cache shared objects which makes
+    reimporting same path of an shared object file very problematic.
+
+    It will not detect the new time stamp, nor new checksum, but will
+    instead silently use old module. Use unique names for this reason.
+
+    Parameters
+    ==========
+
+    filename : str
+        Path to shared object.
+    only_if_newer_than : iterable of strings
+        Paths to dependencies of the shared object.
+
+    Raises
+    ======
+
+    ``ImportError`` if any of the files specified in ``only_if_newer_than`` are newer
+    than the file given by filename.
+    """
+    path, name = os.path.split(filename)
+    name, ext = os.path.splitext(name)
+    name = name.split('.')[0]
+    if sys.version_info[0] == 2:
+        from imp import find_module, load_module
+        fobj, filename, data = find_module(name, [path])
+        if only_if_newer_than:
+            for dep in only_if_newer_than:
+                if os.path.getmtime(filename) < os.path.getmtime(dep):
+                    raise ImportError("{} is newer than {}".format(dep, filename))
+        mod = load_module(name, fobj, filename, data)
+    else:
+        import importlib.util
+        spec = importlib.util.spec_from_file_location(name, filename)
+        if spec is None:
+            raise ImportError("Failed to import: '%s'" % filename)
+        mod = importlib.util.module_from_spec(spec)
+        spec.loader.exec_module(mod)
+    return mod
+
+
+def find_binary_of_command(candidates):
+    """ Finds binary first matching name among candidates.
+
+    Calls ``which`` from shutils for provided candidates and returns
+    first hit.
+
+    Parameters
+    ==========
+
+    candidates : iterable of str
+        Names of candidate commands
+
+    Raises
+    ======
+
+    CompilerNotFoundError if no candidates match.
+    """
+    from shutil import which
+    for c in candidates:
+        binary_path = which(c)
+        if c and binary_path:
+            return c, binary_path
+
+    raise CompilerNotFoundError('No binary located for candidates: {}'.format(candidates))
+
+
+def unique_list(l):
+    """ Uniquify a list (skip duplicate items). """
+    result = []
+    for x in l:
+        if x not in result:
+            result.append(x)
+    return result
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/mathml/__init__.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/mathml/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..eded44ee3c0f34ad1324765ba06ee9d6eb5e9899
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/mathml/__init__.py
@@ -0,0 +1,122 @@
+"""Module with some functions for MathML, like transforming MathML
+content in MathML presentation.
+
+To use this module, you will need lxml.
+"""
+
+from pathlib import Path
+
+from sympy.utilities.decorator import doctest_depends_on
+
+
+__doctest_requires__ = {('apply_xsl', 'c2p'): ['lxml']}
+
+
+def add_mathml_headers(s):
+    return """<math xmlns:mml="http://www.w3.org/1998/Math/MathML"
+      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+      xsi:schemaLocation="http://www.w3.org/1998/Math/MathML
+        http://www.w3.org/Math/XMLSchema/mathml2/mathml2.xsd">""" + s + "</math>"
+
+
+def _read_binary(pkgname, filename):
+    import sys
+
+    if sys.version_info >= (3, 10):
+        # files was added in Python 3.9 but only seems to work here in 3.10+
+        from importlib.resources import files
+        return files(pkgname).joinpath(filename).read_bytes()
+    else:
+        # read_binary was deprecated in Python 3.11
+        from importlib.resources import read_binary
+        return read_binary(pkgname, filename)
+
+
+def _read_xsl(xsl):
+    # Previously these values were allowed:
+    if xsl == 'mathml/data/simple_mmlctop.xsl':
+        xsl = 'simple_mmlctop.xsl'
+    elif xsl == 'mathml/data/mmlctop.xsl':
+        xsl = 'mmlctop.xsl'
+    elif xsl == 'mathml/data/mmltex.xsl':
+        xsl = 'mmltex.xsl'
+
+    if xsl in ['simple_mmlctop.xsl', 'mmlctop.xsl', 'mmltex.xsl']:
+        xslbytes = _read_binary('sympy.utilities.mathml.data', xsl)
+    else:
+        xslbytes = Path(xsl).read_bytes()
+
+    return xslbytes
+
+
+@doctest_depends_on(modules=('lxml',))
+def apply_xsl(mml, xsl):
+    """Apply a xsl to a MathML string.
+
+    Parameters
+    ==========
+
+    mml
+        A string with MathML code.
+    xsl
+        A string giving the name of an xsl (xml stylesheet) file which can be
+        found in sympy/utilities/mathml/data. The following files are supplied
+        with SymPy:
+
+        - mmlctop.xsl
+        - mmltex.xsl
+        - simple_mmlctop.xsl
+
+        Alternatively, a full path to an xsl file can be given.
+
+    Examples
+    ========
+
+    >>> from sympy.utilities.mathml import apply_xsl
+    >>> xsl = 'simple_mmlctop.xsl'
+    >>> mml = '<apply> <plus/> <ci>a</ci> <ci>b</ci> </apply>'
+    >>> res = apply_xsl(mml,xsl)
+    >>> print(res)
+    <?xml version="1.0"?>
+    <mrow xmlns="http://www.w3.org/1998/Math/MathML">
+      <mi>a</mi>
+      <mo> + </mo>
+      <mi>b</mi>
+    </mrow>
+    """
+    from lxml import etree
+
+    parser = etree.XMLParser(resolve_entities=False)
+    ac = etree.XSLTAccessControl.DENY_ALL
+
+    s = etree.XML(_read_xsl(xsl), parser=parser)
+    transform = etree.XSLT(s, access_control=ac)
+    doc = etree.XML(mml, parser=parser)
+    result = transform(doc)
+    s = str(result)
+    return s
+
+
+@doctest_depends_on(modules=('lxml',))
+def c2p(mml, simple=False):
+    """Transforms a document in MathML content (like the one that sympy produces)
+    in one document in MathML presentation, more suitable for printing, and more
+    widely accepted
+
+    Examples
+    ========
+
+    >>> from sympy.utilities.mathml import c2p
+    >>> mml = '<apply> <exp/> <cn>2</cn> </apply>'
+    >>> c2p(mml,simple=True) != c2p(mml,simple=False)
+    True
+
+    """
+
+    if not mml.startswith('<math'):
+        mml = add_mathml_headers(mml)
+
+    if simple:
+        return apply_xsl(mml, 'mathml/data/simple_mmlctop.xsl')
+
+    return apply_xsl(mml, 'mathml/data/mmlctop.xsl')
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/mathml/__pycache__/__init__.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/mathml/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..6e8eb30b148ff8a83fb795dd096cf71d8260523f
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/mathml/__pycache__/__init__.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/mathml/data/__init__.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/mathml/data/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/mathml/data/__pycache__/__init__.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/mathml/data/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..687e0e24b0a7b92082dcd4d677ff08575450849d
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/mathml/data/__pycache__/__init__.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/mathml/data/mmlctop.xsl b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/mathml/data/mmlctop.xsl
new file mode 100644
index 0000000000000000000000000000000000000000..8d1c33a67b1f98a648db99d32f6d3ff3a65611f7
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/mathml/data/mmlctop.xsl
@@ -0,0 +1,3165 @@
+<?xml version="1.0"?>
+
+<!-- ******************************************************** -->
+<!--  XSL Transform of MathML content to MathML presentation  -->
+<!--             Version 1.0 RC2 from 13-Jun-2003             -->
+<!--                                                          -->
+<!--    Complies with the W3C MathML 2.0 Recommenation of     -->
+<!--                    21 February 2001.                     -->
+<!--                                                          -->
+<!--   Authors Igor Rodionov <igor@csd.uwo.ca>,               -->
+<!--           Stephen Watt  <watt@csd.uwo.ca>.               -->
+<!--                                                          -->
+<!-- (C) Copyright 2000-2003 Symbolic Computation Laboratory, -->
+<!--                         University of Western Ontario,   -->
+<!--                         London, Canada N6A 5B7.          -->
+<!--                                                          -->
+<!-- Modified: Fabian Seoane <fabian@fseoane> 2007 for sympy  -->
+<!-- ******************************************************** -->
+
+<xsl:stylesheet id="mmlctop2.xsl"
+                version="1.0"
+                xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
+                xmlns:mml="http://www.w3.org/1998/Math/MathML"
+                xmlns="http://www.w3.org/1998/Math/MathML">
+
+<xsl:output method="xml" indent="yes"/>
+
+<xsl:strip-space elements="apply semantics annotation-xml
+        csymbol fn cn ci interval matrix matrixrow vector
+        lambda bvar condition logbase degree set list
+        lowlimit uplimit math"/>
+
+
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -->
+<!--         Parameters, variables and constants           -->
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -->
+
+<!-- ~~~~~~~~ Semantics related *constants*: ~~~~~~~~ -->
+
+<!-- Strip off semantics -->
+<xsl:variable name="SEM_STRIP" select="-1"/>
+
+<!-- Pass semantics "as is" -->
+<xsl:variable name="SEM_PASS" select="0"/>
+
+<!-- Add semantics at top level only -->
+<xsl:variable name="SEM_TOP" select="1"/>
+
+<!-- Add semantics at all levels -->
+<xsl:variable name="SEM_ALL" select="2"/>
+
+<!-- Semantics at top level only, with id refs -->
+<!-- NOTE: ids have to be already present in the
+           input for this feature to work. -->
+<xsl:variable name="SEM_XREF" select="3"/>
+
+<!-- No semantics at top level, with id refs -->
+<!-- NOTE: ids have to be already present in the
+           input for this feature to work. -->
+<xsl:variable name="SEM_XREF_EXT" select="4"/>
+
+
+<!-- ~~~~~~~~~~ Stylesheet *parameter*: SEM_SW ~~~~~~~~~~~~~~ -->
+<!-- Assumes one of the above values; SEM_PASS is the default -->
+<!-- The default can be overridden by specifying different    -->
+<!-- value on the command line when the stylesheet is invoked -->
+
+<xsl:param name="SEM_SW" select="SEM_PASS"/>
+
+
+<!-- ~~~~~~ Operator precedence definitions ~~~~~~ -->
+
+<xsl:variable name="NO_PREC" select="0"/>
+<xsl:variable name="UNION_PREC" select="1"/>
+<xsl:variable name="SETDIFF_PREC" select="1"/>
+<xsl:variable name="INTERSECT_PREC" select="3"/>
+<xsl:variable name="CARTPROD_PREC" select="3"/>
+<xsl:variable name="OR_PREC" select="5"/>
+<xsl:variable name="XOR_PREC" select="7"/>
+<xsl:variable name="AND_PREC" select="9"/>
+<xsl:variable name="NOT_PREC" select="11"/>
+<xsl:variable name="PLUS_PREC" select="13"/>
+<xsl:variable name="MINUS_PREC" select="13"/>
+<xsl:variable name="NEG_PREC" select="15"/>
+<xsl:variable name="MUL_PREC" select="17"/>
+<xsl:variable name="DIV_PREC" select="17"/>
+<xsl:variable name="REM_PREC" select="17"/>
+<xsl:variable name="FUNCTN_PREC" select="97"/>
+<xsl:variable name="GEN_FUN_PREC" select="99"/>
+
+<!-- ~~~~~ Miscellaneous constant definitions ~~~~~ -->
+
+<xsl:variable name="YES" select="1"/>
+<xsl:variable name="NO" select="0"/>
+<xsl:variable name="NO_PARAM" select="-1"/>
+<xsl:variable name="PAR_SAME" select="-3"/>
+<xsl:variable name="PAR_YES" select="-5"/>
+<xsl:variable name="PAR_NO" select="-7"/>
+
+
+
+<!-- +++++++++++++++++ INDEX OF TEMPLATES +++++++++++++++++++ -->
+
+<!-- All templates are subdivided into the following categories
+     (listed in the order of appearance in the stylesheet):
+
+THE TOPMOST ELEMENT: MATH
+ math
+
+SEMANTICS HANDLING
+ semantics
+
+BASIC CONTAINER ELEMENTS
+ cn, ci; csymbol
+
+BASIC CONTENT ELEMENTS
+ fn, interval, inverse, sep, condition, declare, lambda, compose,
+ ident; domain, codomain, image, domainofapplication, piecewise
+
+ARITHMETIC, ALGEBRA & LOGIC
+ quotient, exp, factorial, max, min, minus, plus, power, rem, divide,
+ times, root, gcd, and, or, xor, not, forall, exists, abs, conjugate;
+ arg, real, imaginary, lcm, floor, ceiling
+
+RELATIONS
+ neq, approx, tendsto, implies, in, notin, notsubset, notprsubset,
+ subset, prsubset, eq, gt, lt, geq, leq; equivalent, factorof
+
+CALCULUS
+ ln, log, diff, partialdiff, lowlimit, uplimit, bvar, degree,
+ logbase; divergence, grad, curl, laplacian
+
+SET THEORY
+ set, list, union, intersect, setdiff; card, cartesianproduct
+
+SEQUENCES AND SERIES
+ sum, product, limit
+
+TRIGONOMETRY
+ sin, cos, tan, sec, csc, cot, sinh, cosh, tanh, sech, csch, coth,
+ arcsin, arccos, arctan, arcsec, arccsc, arccot, arcsinh, arccosh,
+ arctanh, arcsech, arccsch, arccoth
+
+STATISTICS
+ mean, sdev, variance, median, mode, moment, momentabout
+
+LINEAR ALGEBRA
+ vector, matrix, matrixrow, determinant, transpose, selector;
+ vectorproduct, scalarproduct, outerproduct
+
+CONSTANT and SYMBOL ELEMENTS
+ integers, reals, rationals, naturalnumbers, complexes, primes,
+ exponentiale, imaginaryi, notanumber, true, false, emptyset,
+ pi, eulergamma, infinity
+-->
+
+
+
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -->
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~ TEMPLATES ~~~~~~~~~~~~~~~~~~~~~~~~~ -->
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -->
+
+
+
+<!-- *********************** COPY THROUGH ************************ -->
+
+<xsl:template match = "*">
+  <xsl:copy>
+    <xsl:copy-of select="@*"/>
+    <xsl:apply-templates/>
+  </xsl:copy>
+</xsl:template>
+
+
+
+<!-- ***************** THE TOPMOST ELEMENT: MATH ***************** -->
+
+<xsl:template match = "math">
+  <math>
+    <xsl:copy-of select="@*"/>
+    <xsl:choose>
+      <xsl:when test="$SEM_SW=$SEM_TOP or $SEM_SW=$SEM_ALL and *[2] or
+	                  $SEM_SW=$SEM_XREF">
+        <semantics>
+          <mrow>
+            <xsl:apply-templates mode = "semantics"/>
+          </mrow>
+          <annotation-xml encoding="MathML">
+            <xsl:copy-of select="*"/>
+          </annotation-xml>
+        </semantics>
+      </xsl:when>
+      <xsl:otherwise>
+        <xsl:apply-templates mode = "semantics"/>
+      </xsl:otherwise>
+    </xsl:choose>
+  </math>
+</xsl:template>
+
+
+
+<!-- ***************** SEMANTICS HANDLING ***************** -->
+
+<!-- This template is called recursively.  At each level   -->
+<!-- in the source tree it decides whether to strip off,   -->
+<!-- pass or add semantics at that level (depending on the -->
+<!-- value of SEM_SW parameter).  Then the actual template -->
+<!-- is applied to the node.                               -->
+
+<xsl:template match = "*" mode = "semantics">
+  <xsl:param name="IN_PREC" select="$NO_PREC"/>
+  <xsl:param name="PARAM" select="$NO_PARAM"/>
+  <xsl:param name="PAREN" select="$PAR_NO"/>
+  <xsl:param name="PAR_NO_IGNORE" select="$YES"/>
+  <xsl:choose>
+    <xsl:when test="$SEM_SW=$SEM_STRIP and self::semantics">
+      <xsl:apply-templates select="annotation-xml[@encoding='MathML']">
+        <xsl:with-param name="IN_PREC" select="$IN_PREC"/>
+        <xsl:with-param name="PARAM" select="$PARAM"/>
+        <xsl:with-param name="PAREN" select="$PAREN"/>
+        <xsl:with-param name="PAR_NO_IGNORE" select="$PAR_NO_IGNORE"/>
+      </xsl:apply-templates>
+    </xsl:when>
+    <xsl:when test="($SEM_SW=$SEM_PASS or $SEM_SW=$SEM_TOP) and self::semantics">
+      <semantics>
+        <xsl:apply-templates select="*[1]">
+        <xsl:with-param name="IN_PREC" select="$IN_PREC"/>
+        <xsl:with-param name="PARAM" select="$PARAM"/>
+        <xsl:with-param name="PAREN" select="$PAREN"/>
+        <xsl:with-param name="PAR_NO_IGNORE" select="$PAR_NO_IGNORE"/>
+      </xsl:apply-templates>
+        <xsl:copy-of select="annotation-xml"/>
+      </semantics>
+    </xsl:when>
+    <xsl:when test="$SEM_SW=$SEM_ALL">
+      <semantics>
+        <xsl:choose>
+          <xsl:when test="self::semantics">
+            <xsl:apply-templates select="*[1]">
+              <xsl:with-param name="IN_PREC" select="$IN_PREC"/>
+              <xsl:with-param name="PARAM" select="$PARAM"/>
+              <xsl:with-param name="PAREN" select="$PAREN"/>
+              <xsl:with-param name="PAR_NO_IGNORE" select="$PAR_NO_IGNORE"/>
+            </xsl:apply-templates>
+            <xsl:copy-of select="annotation-xml"/>
+          </xsl:when>
+          <xsl:otherwise>
+            <xsl:apply-templates select=".">
+              <xsl:with-param name="IN_PREC" select="$IN_PREC"/>
+              <xsl:with-param name="PARAM" select="$PARAM"/>
+              <xsl:with-param name="PAREN" select="$PAREN"/>
+              <xsl:with-param name="PAR_NO_IGNORE" select="$PAR_NO_IGNORE"/>
+            </xsl:apply-templates>
+            <annotation-xml encoding="MathML">
+              <xsl:copy-of select="."/>
+            </annotation-xml>
+          </xsl:otherwise>
+        </xsl:choose>
+      </semantics>
+    </xsl:when>
+    <xsl:when test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+      <xsl:choose>
+        <xsl:when test="self::semantics">
+          <xsl:copy>
+            <xsl:copy-of select="@*"/>
+            <xsl:attribute name="xref">
+              <xsl:value-of select="@id"/>
+            </xsl:attribute>
+            <xsl:copy-of select="*[1]"/>
+            <xsl:copy-of select="annotation-xml"/>
+          </xsl:copy>
+        </xsl:when>
+        <xsl:otherwise>
+          <xsl:apply-templates select=".">
+            <xsl:with-param name="IN_PREC" select="$IN_PREC"/>
+            <xsl:with-param name="PARAM" select="$PARAM"/>
+            <xsl:with-param name="PAREN" select="$PAREN"/>
+            <xsl:with-param name="PAR_NO_IGNORE" select="$PAR_NO_IGNORE"/>
+          </xsl:apply-templates>
+        </xsl:otherwise>
+      </xsl:choose>
+    </xsl:when>
+    <xsl:otherwise>
+      <xsl:apply-templates select=".">
+        <xsl:with-param name="IN_PREC" select="$IN_PREC"/>
+        <xsl:with-param name="PARAM" select="$PARAM"/>
+        <xsl:with-param name="PAREN" select="$PAREN"/>
+        <xsl:with-param name="PAR_NO_IGNORE" select="$PAR_NO_IGNORE"/>
+      </xsl:apply-templates>
+    </xsl:otherwise>
+  </xsl:choose>
+</xsl:template>
+
+
+<xsl:template match = "semantics">
+  <xsl:apply-templates select="*[1]" mode = "semantics"/>
+</xsl:template>
+
+
+
+<!-- ***************** BASIC CONTAINER ELEMENTS ***************** -->
+
+<xsl:template match = "cn">
+  <xsl:param name="IN_PREC" select="$NO_PREC"/>
+  <xsl:param name="PAREN" select="$PAR_NO"/>
+  <xsl:param name="PAR_NO_IGNORE" select="$YES"/>
+  <xsl:choose>
+    <xsl:when test=". &lt; 0 and $IN_PREC &gt; $NO_PREC and $PAREN=$PAR_NO
+                                                   and $PAR_NO_IGNORE=$NO">
+      <mfenced separators="">
+        <xsl:apply-templates select="." mode="cn"/>
+      </mfenced>
+    </xsl:when>
+    <xsl:otherwise>
+      <xsl:apply-templates select="." mode="cn"/>
+    </xsl:otherwise>
+  </xsl:choose>
+</xsl:template>
+
+<xsl:template match = "cn" mode="cn">
+  <xsl:choose>
+    <xsl:when test="(not(@type) or @type='integer' or @type='real') and @base">
+      <msub>
+        <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+          <xsl:attribute name="xref">
+            <xsl:value-of select="@id"/>
+          </xsl:attribute>
+        </xsl:if>
+        <mn> <xsl:apply-templates mode = "semantics"/> </mn>
+        <mn> <xsl:value-of select="@base"/> </mn>
+      </msub>
+    </xsl:when>
+    <xsl:when test="not(@type) or @type='integer' or @type='real'">
+      <mn>
+        <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+          <xsl:attribute name="xref">
+            <xsl:value-of select="@id"/>
+          </xsl:attribute>
+        </xsl:if>
+        <xsl:apply-templates mode = "semantics"/>
+      </mn>
+    </xsl:when>
+    <xsl:when test="@type='constant'">
+      <mn>
+        <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+          <xsl:attribute name="xref">
+            <xsl:value-of select="@id"/>
+          </xsl:attribute>
+        </xsl:if>
+        <xsl:apply-templates mode = "semantics"/>
+      </mn>
+    </xsl:when>
+    <xsl:when test="@type='e-notation' and not(@base) and child::sep[1]">
+      <mrow>
+        <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+          <xsl:attribute name="xref">
+            <xsl:value-of select="@id"/>
+          </xsl:attribute>
+        </xsl:if>
+        <mn> <xsl:apply-templates select="text()[1]" mode = "semantics"/> </mn>
+        <mo> e </mo>
+        <mn> <xsl:apply-templates select="text()[2]" mode = "semantics"/> </mn>
+      </mrow>
+    </xsl:when>
+    <xsl:when test="@type='complex-cartesian' and not(@base) and child::sep[1]">
+      <mfenced separators="">
+        <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+          <xsl:attribute name="xref">
+            <xsl:value-of select="@id"/>
+          </xsl:attribute>
+        </xsl:if>
+        <mn> <xsl:apply-templates select="text()[1]" mode = "semantics"/> </mn>
+        <xsl:if test="text()[2] &lt; 0">
+          <mo> - </mo>
+          <mn> <xsl:value-of select="-text()[2]"/> </mn>
+        </xsl:if>
+        <xsl:if test="not(text()[2] &lt; 0)">
+          <mo> + </mo>
+          <mn> <xsl:value-of select="text()[2]"/> </mn>
+        </xsl:if>
+        <mo> <xsl:text disable-output-escaping='yes'>&amp;#x2062;</xsl:text> </mo>
+        <mo> <xsl:text disable-output-escaping='yes'>&amp;#x2148;</xsl:text> </mo>
+      </mfenced>
+    </xsl:when>
+    <xsl:when test="@type='complex-cartesian' and @base and child::sep[1]">
+      <msub>
+        <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+          <xsl:attribute name="xref">
+            <xsl:value-of select="@id"/>
+          </xsl:attribute>
+        </xsl:if>
+        <mfenced separators="">
+          <mn> <xsl:apply-templates select="text()[1]"/> </mn>
+          <xsl:if test="text()[2] &lt; 0">
+            <mo> - </mo>
+            <mn> <xsl:value-of select="-text()[2]"/> </mn>
+          </xsl:if>
+          <xsl:if test="not(text()[2] &lt; 0)">
+            <mo> + </mo>
+            <mn> <xsl:apply-templates select="text()[2]"/> </mn>
+          </xsl:if>
+          <mo> <xsl:text disable-output-escaping='yes'>&amp;#x2062;</xsl:text> </mo>
+          <mo> <xsl:text disable-output-escaping='yes'>&amp;#x2148;</xsl:text> </mo>
+        </mfenced>
+        <mn> <xsl:value-of select="@base"/> </mn>
+      </msub>
+    </xsl:when>
+    <xsl:when test="@type='rational' and not(@base) and child::sep[1]">
+      <mfrac>
+        <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+          <xsl:attribute name="xref">
+            <xsl:value-of select="@id"/>
+          </xsl:attribute>
+        </xsl:if>
+        <mn> <xsl:apply-templates select="text()[1]"/> </mn>
+        <mn> <xsl:apply-templates select="text()[2]"/> </mn>
+      </mfrac>
+    </xsl:when>
+    <xsl:when test="@type='rational' and @base and child::sep[1]">
+      <msub>
+        <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+          <xsl:attribute name="xref">
+            <xsl:value-of select="@id"/>
+          </xsl:attribute>
+        </xsl:if>
+        <mfenced>
+          <mfrac>
+            <mn> <xsl:apply-templates select="text()[1]"/> </mn>
+            <mn> <xsl:apply-templates select="text()[2]"/> </mn>
+          </mfrac>
+        </mfenced>
+        <mn> <xsl:value-of select="@base"/> </mn>
+      </msub>
+    </xsl:when>
+    <xsl:when test="@type='complex-polar' and not(@base) and child::sep[1]">
+      <mrow>
+        <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+          <xsl:attribute name="xref">
+            <xsl:value-of select="@id"/>
+          </xsl:attribute>
+        </xsl:if>
+        <mo> Polar </mo>
+        <mo> <xsl:text disable-output-escaping='yes'>&amp;#x2062;</xsl:text> </mo>
+        <mfenced separators=",">
+          <mn> <xsl:apply-templates select="text()[1]"/> </mn>
+          <mn> <xsl:apply-templates select="text()[2]"/> </mn>
+        </mfenced>
+      </mrow>
+    </xsl:when>
+    <xsl:when test="@type='complex-polar' and @base and child::sep[1]">
+      <msub>
+        <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+          <xsl:attribute name="xref">
+            <xsl:value-of select="@id"/>
+          </xsl:attribute>
+        </xsl:if>
+        <mrow>
+          <mo> Polar </mo>
+          <mo> <xsl:text disable-output-escaping='yes'>&amp;#x2062;</xsl:text> </mo>
+          <mfenced separators=",">
+            <mn> <xsl:apply-templates select="text()[1]"/> </mn>
+            <mn> <xsl:apply-templates select="text()[2]"/> </mn>
+          </mfenced>
+        </mrow>
+        <mn> <xsl:value-of select="@base"/> </mn>
+      </msub>
+   </xsl:when>
+    <xsl:otherwise>
+      <mn> <xsl:apply-templates mode = "semantics"/> </mn>
+    </xsl:otherwise>
+  </xsl:choose>
+</xsl:template>
+
+
+<xsl:template match = "ci">
+  <xsl:choose>
+    <xsl:when test="@type='vector' or @type='matrix' or @type='set'">
+      <mi mathvariant="bold">
+        <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+          <xsl:attribute name="xref">
+            <xsl:value-of select="@id"/>
+          </xsl:attribute>
+        </xsl:if>
+        <xsl:apply-templates mode = "semantics"/>
+      </mi>
+    </xsl:when>
+    <xsl:when test="child::text() and not(child::*[1])">
+      <mi>
+        <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+          <xsl:attribute name="xref">
+            <xsl:value-of select="@id"/>
+          </xsl:attribute>
+        </xsl:if>
+        <xsl:apply-templates/>
+      </mi>
+    </xsl:when>
+    <xsl:when test="child::text() and *[1] and not(*[1]=sep)">
+      <mrow>
+        <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+          <xsl:attribute name="xref">
+            <xsl:value-of select="@id"/>
+          </xsl:attribute>
+        </xsl:if>
+        <xsl:apply-templates/>
+      </mrow>
+    </xsl:when>
+    <xsl:otherwise>
+      <xsl:if test="*[2]">
+        <mrow>
+          <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+            <xsl:attribute name="xref">
+              <xsl:value-of select="@id"/>
+            </xsl:attribute>
+          </xsl:if>
+          <xsl:apply-templates select="*"/>
+        </mrow>
+      </xsl:if>
+      <xsl:if test="not(*[2])">
+        <xsl:apply-templates select="*[1]"/>
+      </xsl:if>
+    </xsl:otherwise>
+  </xsl:choose>
+</xsl:template>
+
+<xsl:template match = "ci/*[not(self::sep)]">
+  <xsl:copy-of select = "."/>
+</xsl:template>
+
+
+<xsl:template match = "csymbol">
+  <mrow>
+    <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+      <xsl:attribute name="xref">
+        <xsl:value-of select="@id"/>
+      </xsl:attribute>
+    </xsl:if>
+    <xsl:copy-of select = "* | text()"/>
+  </mrow>
+</xsl:template>
+
+
+
+<!-- ***************** BASIC CONTENT ELEMENTS ***************** -->
+
+<!-- General <apply> <AnyFunction/> ... </apply> -->
+<!-- Dependants: csymbol apply[fn inverse compose] -->
+<xsl:template match = "apply">
+  <xsl:param name="IN_PREC" select="$NO_PREC"/>
+  <xsl:param name="PARAM" select="$NO_PARAM"/>
+  <xsl:param name="PAREN" select="$PAR_NO"/>
+  <xsl:param name="PAR_NO_IGNORE" select="$YES"/>
+  <mrow>
+    <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+      <xsl:attribute name="xref">
+        <xsl:value-of select="@id"/>
+      </xsl:attribute>
+    </xsl:if>
+    <xsl:apply-templates select = "*[1]" mode = "semantics">
+      <xsl:with-param name="IN_PREC" select="$FUNCTN_PREC"/>
+      <xsl:with-param name="PARAM" select="$PAR_SAME"/>
+      <xsl:with-param name="PAR_NO_IGNORE" select="$NO"/>
+    </xsl:apply-templates>
+    <mo> <xsl:text disable-output-escaping='yes'>&amp;#x2061;</xsl:text> </mo>
+    <mfenced separators=",">
+      <xsl:apply-templates select = "*[position()>1]" mode = "semantics">
+        <xsl:with-param name="IN_PREC" select="$FUNCTN_PREC"/>
+        <xsl:with-param name="PARAM" select="$PAR_SAME"/>
+        <xsl:with-param name="PAR_NO_IGNORE" select="$NO"/>
+      </xsl:apply-templates>
+    </mfenced>
+ </mrow>
+</xsl:template>
+
+
+<!-- fn is ***DEPRECATED*** -->
+<xsl:template match = "fn">
+  <xsl:param name="IN_PREC" select="$NO_PREC"/>
+  <xsl:param name="PARAM" select="$NO_PARAM"/>
+  <xsl:param name="PAREN" select="$PAR_NO"/>
+  <xsl:param name="PAR_NO_IGNORE" select="$YES"/>
+  <xsl:apply-templates mode = "semantics">
+    <xsl:with-param name="IN_PREC" select="$FUNCTN_PREC"/>
+    <xsl:with-param name="PARAM" select="$PAR_SAME"/>
+    <xsl:with-param name="PAR_NO_IGNORE" select="$NO"/>
+  </xsl:apply-templates>
+</xsl:template>
+
+
+<xsl:template match = "interval">
+  <mfenced>
+    <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+      <xsl:attribute name="xref">
+        <xsl:value-of select="@id"/>
+      </xsl:attribute>
+    </xsl:if>
+    <xsl:if test="not(@closure) or @closure='closed' or @closure='closed-open' or not(@closure='open') and not(@closure='open-closed')">
+      <xsl:attribute name="open"> [ </xsl:attribute>
+    </xsl:if>
+    <xsl:if test="not(@closure) or @closure='closed' or @closure='open-closed' or not(@closure='open') and not(@closure='closed-open')">
+      <xsl:attribute name="close"> ] </xsl:attribute>
+    </xsl:if>
+    <xsl:apply-templates select="*" mode = "semantics"/>
+  </mfenced>
+</xsl:template>
+
+
+<xsl:template match = "apply[*[1][self::inverse]]">
+  <xsl:param name="IN_PREC" select="$NO_PREC"/>
+  <xsl:param name="PAREN" select="$PAR_NO"/>
+  <xsl:param name="PARAM" select="$NO_PARAM"/>
+  <xsl:param name="PAR_NO_IGNORE" select="$YES"/>
+  <xsl:choose>
+    <xsl:when test="*[2]=exp | *[2]=ln | *[2]=sin | *[2]=cos |
+                    *[2]=tan | *[2]=sec | *[2]=csc | *[2]=cot |
+                    *[2]=sinh | *[2]=cosh | *[2]=tanh | *[2]=sech |
+                    *[2]=csch | *[2]=coth | *[2]=arcsin |
+                    *[2]=arccos | *[2]=arctan">
+      <mo>
+        <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+          <xsl:attribute name="xref">
+            <xsl:value-of select="@id"/>
+          </xsl:attribute>
+        </xsl:if>
+        <xsl:apply-templates select="*[2]" mode="inverse"/>
+      </mo>
+    </xsl:when>
+    <xsl:otherwise>
+      <msup>
+        <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+          <xsl:attribute name="xref">
+            <xsl:value-of select="@id"/>
+          </xsl:attribute>
+        </xsl:if>
+		<mrow>
+          <xsl:apply-templates select = "*[2]">
+            <xsl:with-param name="IN_PREC" select="$FUNCTN_PREC"/>
+            <xsl:with-param name="PARAM" select="$PAR_SAME"/>
+            <xsl:with-param name="PAR_NO_IGNORE" select="$NO"/>
+          </xsl:apply-templates>
+		</mrow>
+		<mfenced>
+          <mn> -1 </mn>
+        </mfenced>
+      </msup>
+    </xsl:otherwise>
+  </xsl:choose>
+</xsl:template>
+
+<xsl:template match = "*" mode="inverse">
+  <xsl:choose>
+    <xsl:when test="self::exp">
+      <xsl:value-of select="'ln'"/>
+    </xsl:when>
+    <xsl:when test="self::ln">
+      <xsl:value-of select="'exp'"/>
+    </xsl:when>
+    <xsl:when test="self::sin">
+      <xsl:value-of select="'arcsin'"/>
+    </xsl:when>
+    <xsl:when test="self::cos">
+      <xsl:value-of select="'arccos'"/>
+    </xsl:when>
+    <xsl:when test="self::tan">
+      <xsl:value-of select="'arctan'"/>
+    </xsl:when>
+    <xsl:when test="self::sec">
+      <xsl:value-of select="'arcsec'"/>
+    </xsl:when>
+    <xsl:when test="self::csc">
+      <xsl:value-of select="'arccsc'"/>
+    </xsl:when>
+    <xsl:when test="self::cot">
+      <xsl:value-of select="'arccot'"/>
+    </xsl:when>
+    <xsl:when test="self::sinh">
+      <xsl:value-of select="'arcsinh'"/>
+    </xsl:when>
+    <xsl:when test="self::cosh">
+      <xsl:value-of select="'arccosh'"/>
+    </xsl:when>
+    <xsl:when test="self::tanh">
+      <xsl:value-of select="'arctanh'"/>
+    </xsl:when>
+    <xsl:when test="self::sech">
+      <xsl:value-of select="'arcsech'"/>
+    </xsl:when>
+    <xsl:when test="self::csch">
+      <xsl:value-of select="'arccsch'"/>
+    </xsl:when>
+    <xsl:when test="self::coth">
+      <xsl:value-of select="'arccoth'"/>
+    </xsl:when>
+    <xsl:when test="self::arcsin">
+      <xsl:value-of select="'sin'"/>
+    </xsl:when>
+    <xsl:when test="self::arccos">
+      <xsl:value-of select="'cos'"/>
+    </xsl:when>
+    <xsl:when test="self::arctan">
+      <xsl:value-of select="'tan'"/>
+    </xsl:when>
+  </xsl:choose>
+</xsl:template>
+
+
+<xsl:template match = "condition">
+  <mrow>
+    <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+      <xsl:attribute name="xref">
+        <xsl:value-of select="@id"/>
+      </xsl:attribute>
+    </xsl:if>
+    <xsl:apply-templates select="*" mode = "semantics"/>
+  </mrow>
+</xsl:template>
+
+
+<xsl:template match = "declare"/>
+
+
+<xsl:template match = "lambda">
+  <mrow>
+    <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+      <xsl:attribute name="xref">
+        <xsl:value-of select="@id"/>
+      </xsl:attribute>
+    </xsl:if>
+    <mo> <xsl:text disable-output-escaping='yes'>&amp;#x03BB;</xsl:text> </mo>
+    <mo> <xsl:text disable-output-escaping='yes'>&amp;#x2061;</xsl:text> </mo>
+    <mfenced>
+      <xsl:for-each select = "*">
+        <xsl:choose>
+          <xsl:when test="self::ci or self::cn">
+            <xsl:apply-templates select = "." mode="semantics"/>
+          </xsl:when>
+          <xsl:otherwise>
+            <mrow>
+              <xsl:apply-templates select = "." mode="semantics"/>
+            </mrow>
+          </xsl:otherwise>
+        </xsl:choose>
+      </xsl:for-each>
+    </mfenced>
+  </mrow>
+</xsl:template>
+
+
+<xsl:template match = "apply[*[1][self::compose]]">
+  <xsl:param name="IN_PREC" select="$NO_PREC"/>
+  <xsl:param name="PAREN" select="$PAR_NO"/>
+  <xsl:param name="PARAM" select="$NO_PARAM"/>
+  <xsl:param name="PAR_NO_IGNORE" select="$YES"/>
+  <xsl:choose>
+    <xsl:when test="$IN_PREC &lt; $GEN_FUN_PREC and
+                   ($IN_PREC &gt; $FUNCTN_PREC or $IN_PREC=$FUNCTN_PREC and $PARAM=$PAR_SAME)">
+      <mfenced separators="">
+        <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+          <xsl:attribute name="xref">
+            <xsl:value-of select="@id"/>
+          </xsl:attribute>
+        </xsl:if>
+        <xsl:apply-templates select = "*[2]" mode="semantics"/>
+        <xsl:for-each select = "*[position()>2]">
+          <mo> <xsl:text disable-output-escaping='yes'>&amp;#x2218;</xsl:text> </mo>
+          <xsl:apply-templates select = "." mode="semantics">
+            <xsl:with-param name="IN_PREC" select="$FUNCTN_PREC"/>
+            <xsl:with-param name="PARAM" select="$PAR_SAME"/>
+            <xsl:with-param name="PAR_NO_IGNORE" select="$NO"/>
+          </xsl:apply-templates>
+        </xsl:for-each>
+      </mfenced>
+    </xsl:when>
+    <xsl:otherwise>
+      <mrow>
+        <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+          <xsl:attribute name="xref">
+            <xsl:value-of select="@id"/>
+          </xsl:attribute>
+        </xsl:if>
+        <xsl:apply-templates select = "*[2]" mode="semantics"/>
+        <xsl:for-each select = "*[position()>2]">
+          <mo> <xsl:text disable-output-escaping='yes'>&amp;#x2218;</xsl:text> </mo>
+          <xsl:apply-templates select = "." mode="semantics">
+            <xsl:with-param name="IN_PREC" select="$FUNCTN_PREC"/>
+            <xsl:with-param name="PARAM" select="$PAR_SAME"/>
+            <xsl:with-param name="PAR_NO_IGNORE" select="$NO"/>
+          </xsl:apply-templates>
+        </xsl:for-each>
+      </mrow>
+	</xsl:otherwise>
+  </xsl:choose>
+</xsl:template>
+
+
+<xsl:template match = "ident">
+  <xsl:choose>
+    <xsl:when test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+      <mtext xref="{@id}">id</mtext>
+    </xsl:when>
+    <xsl:otherwise>
+      <mtext>id</mtext>
+    </xsl:otherwise>
+  </xsl:choose>
+</xsl:template>
+
+
+<xsl:template match="apply[*[1]=domain or *[1]=codomain or *[1]=image]">
+  <mrow>
+    <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+      <xsl:attribute name="xref">
+        <xsl:value-of select="@id"/>
+      </xsl:attribute>
+    </xsl:if>
+	<xsl:if test="*[1]=domain">
+      <mtext>domain</mtext>
+	</xsl:if>
+	<xsl:if test="*[1]=codomain">
+      <mtext>codomain</mtext>
+	</xsl:if>
+	<xsl:if test="*[1]=image">
+      <mtext>image</mtext>
+	</xsl:if>
+    <mo> <xsl:text disable-output-escaping='yes'>&amp;#x2061;</xsl:text> </mo>
+    <mfenced separators="">
+      <xsl:apply-templates select="*[position()>1]" mode = "semantics"/>
+    </mfenced>
+  </mrow>
+</xsl:template>
+
+
+<xsl:template match = "domainofapplication">
+  <mrow>
+    <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+      <xsl:attribute name="xref">
+        <xsl:value-of select="@id"/>
+      </xsl:attribute>
+    </xsl:if>
+    <xsl:apply-templates select = "*" mode = "semantics"/>
+  </mrow>
+</xsl:template>
+
+
+<xsl:template match="piecewise">
+  <mrow>
+    <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+      <xsl:attribute name="xref">
+        <xsl:value-of select="@id"/>
+      </xsl:attribute>
+    </xsl:if>
+    <mo stretchy="true"> { </mo>
+    <mtable columnalign="left left">
+      <xsl:for-each select="piece">
+        <mtr>
+          <mtd>
+            <xsl:apply-templates select="*[position()=1]" mode = "semantics"/>
+          </mtd>
+          <mtd>
+            <mtext>if </mtext>
+            <xsl:apply-templates select="*[position()=2]" mode = "semantics"/>
+          </mtd>
+        </mtr>
+      </xsl:for-each>
+      <xsl:if test="otherwise">
+        <mtr>
+          <mtd>
+            <xsl:apply-templates select="otherwise/*" mode = "semantics"/>
+          </mtd>
+          <mtd>
+            <mtext>otherwise</mtext>
+          </mtd>
+        </mtr>
+      </xsl:if>
+    </mtable>
+  </mrow>
+</xsl:template>
+
+
+
+<!-- ***************** ARITHMETIC, ALGEBRA & LOGIC ***************** -->
+
+<xsl:template match = "apply[quotient[1]]">
+  <xsl:param name="IN_PREC" select="$NO_PREC"/>
+  <xsl:param name="PARAM" select="$NO_PARAM"/>
+  <xsl:param name="PAREN" select="$PAR_NO"/>
+  <xsl:param name="PAR_NO_IGNORE" select="$YES"/>
+  <mrow>
+    <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+      <xsl:attribute name="xref">
+        <xsl:value-of select="@id"/>
+      </xsl:attribute>
+    </xsl:if>
+    <mo> <xsl:text disable-output-escaping='yes'>&amp;#x230A;</xsl:text> </mo>
+    <mfrac>
+      <mrow>
+        <xsl:apply-templates select="*[2]" mode = "semantics">
+          <xsl:with-param name="IN_PREC" select="$DIV_PREC"/>
+          <xsl:with-param name="PARAM" select="$PARAM"/>
+          <xsl:with-param name="PAREN" select="$PAREN"/>
+          <xsl:with-param name="PAR_NO_IGNORE" select="$PAR_NO_IGNORE"/>
+        </xsl:apply-templates>
+      </mrow>
+      <mrow>
+        <xsl:apply-templates select="*[3]" mode = "semantics">
+          <xsl:with-param name="IN_PREC" select="$DIV_PREC"/>
+          <xsl:with-param name="PARAM" select="$PARAM"/>
+          <xsl:with-param name="PAREN" select="$PAREN"/>
+          <xsl:with-param name="PAR_NO_IGNORE" select="$PAR_NO_IGNORE"/>
+        </xsl:apply-templates>
+      </mrow>
+    </mfrac>
+    <mo> <xsl:text disable-output-escaping='yes'>&amp;#x230B;</xsl:text> </mo>
+  </mrow>
+</xsl:template>
+
+
+<xsl:template match = "apply[*[1][self::exp]]">
+  <msup>
+    <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+      <xsl:attribute name="xref">
+        <xsl:value-of select="@id"/>
+      </xsl:attribute>
+    </xsl:if>
+    <mn> <xsl:text disable-output-escaping='yes'>&amp;#x2147;</xsl:text> </mn>
+    <xsl:apply-templates select = "*[2]" mode = "semantics"/>
+  </msup>
+</xsl:template>
+
+
+<xsl:template match = "apply[factorial[1]]">
+  <mrow>
+    <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+      <xsl:attribute name="xref">
+        <xsl:value-of select="@id"/>
+      </xsl:attribute>
+    </xsl:if>
+    <xsl:apply-templates select = "*[2]" mode = "semantics">
+      <xsl:with-param name="IN_PREC" select="$FUNCTN_PREC"/>
+      <xsl:with-param name="PAR_NO_IGNORE" select="$NO"/>
+    </xsl:apply-templates>
+    <mo> ! </mo>
+  </mrow>
+</xsl:template>
+
+
+<xsl:template match = "apply[max[1] | min[1]]">
+  <mrow>
+    <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+      <xsl:attribute name="xref">
+        <xsl:value-of select="@id"/>
+      </xsl:attribute>
+    </xsl:if>
+    <xsl:choose>
+      <xsl:when test="*[2]=bvar">
+        <munder>
+          <xsl:if test="*[1]=max">
+            <mo> max </mo>
+          </xsl:if>
+          <xsl:if test="*[1]=min">
+            <mo> min </mo>
+          </xsl:if>
+          <xsl:apply-templates select="*[2]" mode = "semantics"/>
+        </munder>
+      </xsl:when>
+      <xsl:otherwise>
+        <xsl:if test="*[1]=max">
+          <mo> max </mo>
+        </xsl:if>
+        <xsl:if test="*[1]=min">
+          <mo> min </mo>
+        </xsl:if>
+      </xsl:otherwise>
+	</xsl:choose>
+    <mfenced open="{{" close="}}">
+      <xsl:if test="child::condition">
+        <xsl:attribute name="separators"/>
+        <xsl:if test="*[position()>1 and not(self::bvar) and not(self::condition)]">
+          <mfenced open="" close="" separators=",">
+            <xsl:for-each select = "*[position()>1 and not(self::bvar) and not(self::condition)]">
+              <xsl:apply-templates select = "." mode="semantics"/>
+            </xsl:for-each>
+          </mfenced>
+          <mo lspace="0.1666em" rspace="0.1666em"> | </mo>
+        </xsl:if>
+        <xsl:apply-templates select="condition" mode = "semantics"/>
+      </xsl:if>
+      <xsl:if test="not(child::condition)">
+        <xsl:for-each select = "*[position()>1 and not(self::bvar)]">
+          <xsl:apply-templates select = "." mode="semantics"/>
+        </xsl:for-each>
+      </xsl:if>
+    </mfenced>
+  </mrow>
+</xsl:template>
+
+
+<xsl:template match = "apply[minus[1]]">
+  <xsl:param name="IN_PREC" select="$NO_PREC"/>
+  <xsl:param name="PARAM" select="$NO_PARAM"/>
+  <xsl:param name="PAREN" select="$PAR_NO"/>
+  <xsl:param name="PAR_NO_IGNORE" select="$YES"/>
+  <xsl:choose>
+    <xsl:when test="$IN_PREC &lt; $GEN_FUN_PREC and
+                   ($IN_PREC &gt; $MINUS_PREC or $IN_PREC=$MINUS_PREC and $PARAM=$PAR_SAME)">
+      <mfenced separators="">
+        <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+          <xsl:attribute name="xref">
+            <xsl:value-of select="@id"/>
+          </xsl:attribute>
+        </xsl:if>
+        <xsl:apply-templates select="." mode="minus">
+          <xsl:with-param name="PARAM" select="$PARAM"/>
+          <xsl:with-param name="PAREN" select="$PAR_YES"/>
+          <xsl:with-param name="PAR_NO_IGNORE" select="$PAR_NO_IGNORE"/>
+        </xsl:apply-templates>
+      </mfenced>
+    </xsl:when>
+    <xsl:when test="$IN_PREC &gt; $NO_PREC and $IN_PREC &lt; $GEN_FUN_PREC
+                    and not($SEM_SW=$SEM_ALL) and not($SEM_SW=$SEM_XREF)
+                    and not($SEM_SW=$SEM_XREF_EXT)">
+      <xsl:apply-templates select="." mode="minus">
+        <xsl:with-param name="PARAM" select="$PARAM"/>
+        <xsl:with-param name="PAREN" select="$PAREN"/>
+        <xsl:with-param name="PAR_NO_IGNORE" select="$PAR_NO_IGNORE"/>
+      </xsl:apply-templates>
+    </xsl:when>
+    <xsl:otherwise>
+      <mrow>
+        <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+          <xsl:attribute name="xref">
+            <xsl:value-of select="@id"/>
+          </xsl:attribute>
+        </xsl:if>
+        <xsl:apply-templates select="." mode="minus">
+          <xsl:with-param name="PARAM" select="$PARAM"/>
+          <xsl:with-param name="PAREN" select="$PAREN"/>
+          <xsl:with-param name="PAR_NO_IGNORE" select="$PAR_NO_IGNORE"/>
+        </xsl:apply-templates>
+      </mrow>
+    </xsl:otherwise>
+  </xsl:choose>
+</xsl:template>
+
+<xsl:template match = "apply[minus[1]]" mode="minus">
+  <xsl:param name="PARAM" select="$NO_PARAM"/>
+  <xsl:param name="PAREN" select="$PAR_NO"/>
+  <xsl:param name="PAR_NO_IGNORE" select="$YES"/>
+  <xsl:if test="not(*[3])">
+    <mo> - </mo>
+    <xsl:apply-templates select="*[2]" mode = "semantics">
+      <xsl:with-param name="IN_PREC" select="$NEG_PREC"/>
+      <xsl:with-param name="PAREN" select="$PAREN"/>
+      <xsl:with-param name="PAR_NO_IGNORE" select="$NO"/>
+    </xsl:apply-templates>
+  </xsl:if>
+  <xsl:if test="*[3]">
+    <xsl:apply-templates select="*[2]" mode = "semantics">
+      <xsl:with-param name="IN_PREC" select="$MINUS_PREC"/>
+      <xsl:with-param name="PARAM" select="$PARAM"/>
+      <xsl:with-param name="PAREN" select="$PAREN"/>
+      <xsl:with-param name="PAR_NO_IGNORE" select="$PAR_NO_IGNORE"/>
+    </xsl:apply-templates>
+    <mo> - </mo>
+    <xsl:apply-templates select="*[3]" mode = "semantics">
+      <xsl:with-param name="IN_PREC" select="$MINUS_PREC"/>
+      <xsl:with-param name="PARAM" select="$PAR_SAME"/>
+      <xsl:with-param name="PAREN" select="$PAREN"/>
+      <xsl:with-param name="PAR_NO_IGNORE" select="$NO"/>
+    </xsl:apply-templates>
+  </xsl:if>
+</xsl:template>
+
+
+<xsl:template match = "apply[plus[1]]">
+  <xsl:param name="IN_PREC" select="$NO_PREC"/>
+  <xsl:param name="PARAM" select="$NO_PARAM"/>
+  <xsl:param name="PAREN" select="$PAR_NO"/>
+  <xsl:param name="PAR_NO_IGNORE" select="$YES"/>
+  <xsl:choose>
+    <xsl:when test="$IN_PREC &lt; $GEN_FUN_PREC and
+                   ($IN_PREC &gt; $PLUS_PREC or $IN_PREC=$PLUS_PREC and $PARAM=$PAR_SAME)">
+      <mfenced separators="">
+        <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+          <xsl:attribute name="xref">
+            <xsl:value-of select="@id"/>
+          </xsl:attribute>
+        </xsl:if>
+        <xsl:apply-templates select="." mode="plus">
+          <xsl:with-param name="PARAM" select="$IN_PREC"/>
+          <xsl:with-param name="PAREN" select="$PAR_YES"/>
+          <xsl:with-param name="PAR_NO_IGNORE" select="$PAR_NO_IGNORE"/>
+        </xsl:apply-templates>
+      </mfenced>
+    </xsl:when>
+    <xsl:when test="$IN_PREC &gt; $NO_PREC and $IN_PREC &lt; $GEN_FUN_PREC
+                    and not($SEM_SW=$SEM_ALL) and not($SEM_SW=$SEM_XREF)
+                    and not($SEM_SW=$SEM_XREF_EXT)">
+      <xsl:apply-templates select="." mode="plus">
+        <xsl:with-param name="PARAM" select="$PARAM"/>
+        <xsl:with-param name="PAREN" select="$PAREN"/>
+        <xsl:with-param name="PAR_NO_IGNORE" select="$PAR_NO_IGNORE"/>
+      </xsl:apply-templates>
+    </xsl:when>
+    <xsl:otherwise>
+      <mrow>
+        <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+          <xsl:attribute name="xref">
+            <xsl:value-of select="@id"/>
+          </xsl:attribute>
+        </xsl:if>
+        <xsl:apply-templates select="." mode="plus">
+          <xsl:with-param name="PARAM" select="$IN_PREC"/>
+          <xsl:with-param name="PAREN" select="$PAREN"/>
+          <xsl:with-param name="PAR_NO_IGNORE" select="$PAR_NO_IGNORE"/>
+        </xsl:apply-templates>
+      </mrow>
+    </xsl:otherwise>
+  </xsl:choose>
+</xsl:template>
+
+<xsl:template match = "apply[plus[1]]" mode="plus">
+  <xsl:param name="PARAM" select="$NO_PARAM"/>
+  <xsl:param name="PAREN" select="$PAR_NO"/>
+  <xsl:param name="PAR_NO_IGNORE" select="$YES"/>
+  <xsl:if test="*[2]">
+    <xsl:apply-templates select="*[2]" mode = "semantics">
+      <xsl:with-param name="IN_PREC" select="$PLUS_PREC"/>
+      <xsl:with-param name="PARAM" select="$PARAM"/>
+      <xsl:with-param name="PAREN" select="$PAREN"/>
+      <xsl:with-param name="PAR_NO_IGNORE" select="$PAR_NO_IGNORE"/>
+    </xsl:apply-templates>
+    <xsl:for-each select = "*[position()>2]">
+      <xsl:choose>
+        <xsl:when test=". &lt; 0">
+          <mo> - </mo>
+          <mn> <xsl:value-of select="-."/> </mn>
+        </xsl:when>
+        <xsl:when test="self::apply[minus[1]] and not(*[3])">
+          <xsl:apply-templates select="." mode = "semantics">
+            <xsl:with-param name="IN_PREC" select="$PLUS_PREC"/>
+            <xsl:with-param name="PAREN" select="$PAREN"/>
+            <xsl:with-param name="PAR_NO_IGNORE" select="$NO"/>
+          </xsl:apply-templates>
+        </xsl:when>
+        <xsl:otherwise>
+          <mo> + </mo>
+          <xsl:apply-templates select="." mode = "semantics">
+            <xsl:with-param name="IN_PREC" select="$PLUS_PREC"/>
+            <xsl:with-param name="PAREN" select="$PAREN"/>
+            <xsl:with-param name="PAR_NO_IGNORE" select="$NO"/>
+          </xsl:apply-templates>
+        </xsl:otherwise>
+      </xsl:choose>
+    </xsl:for-each>
+  </xsl:if>
+</xsl:template>
+
+
+<xsl:template match = "apply[*[1][self::power]]">
+  <xsl:choose>
+    <xsl:when test="*[2]=apply[ln[1] | log[1] | abs[1] |
+                         gcd[1] | lcm[1] | sin[1] | cos[1] | tan[1] |
+                         sec[1] | csc[1] | cot[1] | sinh[1] |
+                         cosh[1] | tanh[1] | sech[1] | csch[1] |
+                         coth[1] | arcsin[1] | arccos[1] |
+                         arctan[1] | arcsec[1] | arccsc[1] |
+                         arccot[1] | arcsinh[1] | arccosh[1] |
+                         arctanh[1] | arcsech[1] | arccsch[1] |
+                         arccoth[1]]">
+      <xsl:apply-templates select="*[2]" mode = "semantics"/>
+    </xsl:when>
+    <xsl:otherwise>
+      <msup>
+        <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+          <xsl:attribute name="xref">
+            <xsl:value-of select="@id"/>
+          </xsl:attribute>
+        </xsl:if>
+        <xsl:apply-templates select = "*[2]" mode = "semantics">
+          <xsl:with-param name="IN_PREC" select="$FUNCTN_PREC"/>
+          <xsl:with-param name="PAR_NO_IGNORE" select="$NO"/>
+        </xsl:apply-templates>
+        <xsl:apply-templates select = "*[3]" mode = "semantics"/>
+      </msup>
+    </xsl:otherwise>
+  </xsl:choose>
+</xsl:template>
+
+
+<xsl:template match = "apply[divide[1]]">
+  <xsl:param name="IN_PREC" select="$NO_PREC"/>
+  <xsl:param name="PARAM" select="$NO_PARAM"/>
+  <xsl:param name="PAREN" select="$PAR_NO"/>
+  <xsl:param name="PAR_NO_IGNORE" select="$YES"/>
+  <xsl:choose>
+    <xsl:when test="$IN_PREC &lt; $GEN_FUN_PREC and
+                   ($IN_PREC &gt; $DIV_PREC or $IN_PREC=$DIV_PREC and $PARAM=$PAR_SAME)">
+      <mfenced separators="">
+        <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+          <xsl:attribute name="xref">
+            <xsl:value-of select="@id"/>
+          </xsl:attribute>
+        </xsl:if>
+        <xsl:apply-templates select="." mode="div">
+          <xsl:with-param name="PARAM" select="$IN_PREC"/>
+          <xsl:with-param name="PAREN" select="$PAR_YES"/>
+          <xsl:with-param name="PAR_NO_IGNORE" select="$PAR_NO_IGNORE"/>
+        </xsl:apply-templates>
+      </mfenced>
+    </xsl:when>
+    <xsl:when test="$IN_PREC &gt; $NO_PREC and $IN_PREC &lt; $GEN_FUN_PREC
+                    and not($SEM_SW=$SEM_ALL) and not($SEM_SW=$SEM_XREF)
+                    and not($SEM_SW=$SEM_XREF_EXT)">
+      <xsl:apply-templates select="." mode="div">
+        <xsl:with-param name="PARAM" select="$PARAM"/>
+        <xsl:with-param name="PAREN" select="$PAREN"/>
+        <xsl:with-param name="PAR_NO_IGNORE" select="$PAR_NO_IGNORE"/>
+      </xsl:apply-templates>
+    </xsl:when>
+    <xsl:otherwise>
+      <mrow>
+        <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+          <xsl:attribute name="xref">
+            <xsl:value-of select="@id"/>
+          </xsl:attribute>
+        </xsl:if>
+        <xsl:apply-templates select="." mode="div">
+          <xsl:with-param name="PARAM" select="$IN_PREC"/>
+          <xsl:with-param name="PAREN" select="$PAREN"/>
+          <xsl:with-param name="PAR_NO_IGNORE" select="$PAR_NO_IGNORE"/>
+        </xsl:apply-templates>
+      </mrow>
+    </xsl:otherwise>
+  </xsl:choose>
+</xsl:template>
+
+<xsl:template match = "apply[divide[1]]" mode="div">
+  <xsl:param name="PARAM" select="$NO_PARAM"/>
+  <xsl:param name="PAREN" select="$PAR_NO"/>
+  <xsl:param name="PAR_NO_IGNORE" select="$YES"/>
+  <mfrac>
+    <mrow>
+      <xsl:apply-templates select = "*[2]" mode = "semantics">
+        <xsl:with-param name="IN_PREC" select="$GEN_FUN_PREC"/>
+        <xsl:with-param name="PARAM" select="$PARAM"/>
+        <xsl:with-param name="PAREN" select="$PAREN"/>
+        <xsl:with-param name="PAR_NO_IGNORE" select="$PAR_NO_IGNORE"/>
+      </xsl:apply-templates>
+    </mrow>
+    <mrow>
+      <xsl:apply-templates select = "*[3]" mode = "semantics">
+        <xsl:with-param name="IN_PREC" select="$GEN_FUN_PREC"/>
+        <xsl:with-param name="PARAM" select="$PARAM"/>
+        <xsl:with-param name="PAREN" select="$PAREN"/>
+        <xsl:with-param name="PAR_NO_IGNORE" select="$PAR_NO_IGNORE"/>
+      </xsl:apply-templates>
+    </mrow>
+  </mfrac>
+</xsl:template>
+
+
+<xsl:template match = "apply[rem[1]]">
+  <xsl:param name="IN_PREC" select="$NO_PREC"/>
+  <xsl:param name="PARAM" select="$NO_PARAM"/>
+  <xsl:param name="PAREN" select="$PAR_NO"/>
+  <xsl:param name="PAR_NO_IGNORE" select="$YES"/>
+  <xsl:choose>
+    <xsl:when test="$IN_PREC &lt; $GEN_FUN_PREC and
+                   ($IN_PREC &gt; $REM_PREC or $IN_PREC=$REM_PREC and $PARAM=$PAR_SAME)">
+      <mfenced separators="">
+        <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+          <xsl:attribute name="xref">
+            <xsl:value-of select="@id"/>
+          </xsl:attribute>
+        </xsl:if>
+        <xsl:apply-templates select="." mode="rem">
+          <xsl:with-param name="PARAM" select="$IN_PREC"/>
+          <xsl:with-param name="PAREN" select="$PAR_YES"/>
+          <xsl:with-param name="PAR_NO_IGNORE" select="$PAR_NO_IGNORE"/>
+        </xsl:apply-templates>
+      </mfenced>
+    </xsl:when>
+    <xsl:when test="$IN_PREC &gt; $NO_PREC and $IN_PREC &lt; $GEN_FUN_PREC
+                    and not($SEM_SW=$SEM_ALL) and not($SEM_SW=$SEM_XREF)
+                    and not($SEM_SW=$SEM_XREF_EXT)">
+      <xsl:apply-templates select="." mode="rem">
+        <xsl:with-param name="PARAM" select="$PARAM"/>
+        <xsl:with-param name="PAREN" select="$PAREN"/>
+        <xsl:with-param name="PAR_NO_IGNORE" select="$PAR_NO_IGNORE"/>
+      </xsl:apply-templates>
+    </xsl:when>
+    <xsl:otherwise>
+      <mrow>
+        <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+          <xsl:attribute name="xref">
+            <xsl:value-of select="@id"/>
+          </xsl:attribute>
+        </xsl:if>
+        <xsl:apply-templates select="." mode="rem">
+          <xsl:with-param name="PARAM" select="$IN_PREC"/>
+          <xsl:with-param name="PAREN" select="$PAREN"/>
+          <xsl:with-param name="PAR_NO_IGNORE" select="$PAR_NO_IGNORE"/>
+        </xsl:apply-templates>
+      </mrow>
+    </xsl:otherwise>
+  </xsl:choose>
+</xsl:template>
+
+<xsl:template match = "apply[rem[1]]" mode="rem">
+  <xsl:param name="PARAM" select="$NO_PARAM"/>
+  <xsl:param name="PAREN" select="$PAR_NO"/>
+  <xsl:param name="PAR_NO_IGNORE" select="$YES"/>
+  <xsl:apply-templates select = "*[2]" mode = "semantics">
+    <xsl:with-param name="IN_PREC" select="$REM_PREC"/>
+    <xsl:with-param name="PARAM" select="$PARAM"/>
+    <xsl:with-param name="PAREN" select="$PAREN"/>
+    <xsl:with-param name="PAR_NO_IGNORE" select="$PAR_NO_IGNORE"/>
+  </xsl:apply-templates>
+  <mo lspace="thickmathspace" rspace="thickmathspace"> <xsl:value-of select="'mod'"/> </mo>
+  <xsl:apply-templates select = "*[3]" mode = "semantics">
+    <xsl:with-param name="IN_PREC" select="$REM_PREC"/>
+    <xsl:with-param name="PARAM" select="$PAR_SAME"/>
+    <xsl:with-param name="PAREN" select="$PAREN"/>
+    <xsl:with-param name="PAR_NO_IGNORE" select="$NO"/>
+  </xsl:apply-templates>
+</xsl:template>
+
+
+<xsl:template match = "apply[times[1]]">
+  <xsl:param name="IN_PREC" select="$NO_PREC"/>
+  <xsl:param name="PARAM" select="$NO_PARAM"/>
+  <xsl:param name="PAREN" select="$PAR_NO"/>
+  <xsl:param name="PAR_NO_IGNORE" select="$YES"/>
+  <xsl:choose>
+    <xsl:when test="$IN_PREC &lt; $GEN_FUN_PREC and
+                   ($IN_PREC &gt; $MUL_PREC or $IN_PREC=$MUL_PREC and $PARAM=$PAR_SAME)">
+      <mfenced separators="">
+        <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+          <xsl:attribute name="xref">
+            <xsl:value-of select="@id"/>
+          </xsl:attribute>
+        </xsl:if>
+        <xsl:apply-templates select="." mode="times">
+          <xsl:with-param name="PARAM" select="$IN_PREC"/>
+          <xsl:with-param name="PAREN" select="$PAR_YES"/>
+          <xsl:with-param name="PAR_NO_IGNORE" select="$PAR_NO_IGNORE"/>
+        </xsl:apply-templates>
+      </mfenced>
+    </xsl:when>
+    <xsl:when test="$IN_PREC &gt; $NO_PREC and $IN_PREC &lt; $GEN_FUN_PREC
+                    and not($SEM_SW=$SEM_ALL) and not($SEM_SW=$SEM_XREF)
+                    and not($SEM_SW=$SEM_XREF_EXT)">
+      <xsl:apply-templates select="." mode="times">
+        <xsl:with-param name="PARAM" select="$PARAM"/>
+        <xsl:with-param name="PAREN" select="$PAREN"/>
+        <xsl:with-param name="PAR_NO_IGNORE" select="$PAR_NO_IGNORE"/>
+      </xsl:apply-templates>
+    </xsl:when>
+    <xsl:otherwise>
+      <mrow>
+        <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+          <xsl:attribute name="xref">
+            <xsl:value-of select="@id"/>
+          </xsl:attribute>
+        </xsl:if>
+        <xsl:apply-templates select="." mode="times">
+          <xsl:with-param name="PARAM" select="$IN_PREC"/>
+          <xsl:with-param name="PAREN" select="$PAREN"/>
+          <xsl:with-param name="PAR_NO_IGNORE" select="$PAR_NO_IGNORE"/>
+        </xsl:apply-templates>
+      </mrow>
+    </xsl:otherwise>
+  </xsl:choose>
+</xsl:template>
+
+<xsl:template match = "apply[times[1]]" mode="times">
+  <xsl:param name="PARAM" select="$NO_PARAM"/>
+  <xsl:param name="PAREN" select="$PAR_NO"/>
+  <xsl:param name="PAR_NO_IGNORE" select="$YES"/>
+  <xsl:apply-templates select="*[2]" mode = "semantics">
+    <xsl:with-param name="IN_PREC" select="$MUL_PREC"/>
+    <xsl:with-param name="PARAM" select="$PARAM"/>
+    <xsl:with-param name="PAREN" select="$PAREN"/>
+    <xsl:with-param name="PAR_NO_IGNORE" select="$PAR_NO_IGNORE"/>
+  </xsl:apply-templates>
+  <xsl:if test="*[3]">
+    <xsl:for-each select = "*[position()>2]">
+      <mo> <xsl:text disable-output-escaping='yes'>&amp;#x2062;</xsl:text> </mo>
+      <xsl:apply-templates select="." mode = "semantics">
+        <xsl:with-param name="IN_PREC" select="$MUL_PREC"/>
+        <xsl:with-param name="PAREN" select="$PAREN"/>
+        <xsl:with-param name="PAR_NO_IGNORE" select="$NO"/>
+      </xsl:apply-templates>
+    </xsl:for-each>
+  </xsl:if>
+</xsl:template>
+
+
+<xsl:template match = "apply[*[1]=root and *[2]=degree]">
+  <mroot>
+    <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+      <xsl:attribute name="xref">
+        <xsl:value-of select="@id"/>
+      </xsl:attribute>
+    </xsl:if>
+    <xsl:apply-templates select="*[3]" mode = "semantics">
+      <xsl:with-param name="IN_PREC" select="$GEN_FUN_PREC"/>
+      <xsl:with-param name="PAR_NO_IGNORE" select="$NO"/>
+    </xsl:apply-templates>
+    <xsl:apply-templates select="*[2]" mode = "semantics"/>
+  </mroot>
+</xsl:template>
+
+<xsl:template match = "apply[*[1]=root and not(*[2]=degree)]">
+  <msqrt>
+    <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+      <xsl:attribute name="xref">
+        <xsl:value-of select="@id"/>
+      </xsl:attribute>
+    </xsl:if>
+    <xsl:apply-templates select="*[2]" mode = "semantics">
+      <xsl:with-param name="IN_PREC" select="$GEN_FUN_PREC"/>
+      <xsl:with-param name="PAR_NO_IGNORE" select="$NO"/>
+    </xsl:apply-templates>
+  </msqrt>
+</xsl:template>
+
+
+<xsl:template match = "apply[gcd[1] | lcm[1]]">
+  <mrow>
+    <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+      <xsl:attribute name="xref">
+        <xsl:value-of select="@id"/>
+      </xsl:attribute>
+    </xsl:if>
+    <xsl:if test="not(parent::apply[power[1]])">
+      <xsl:if test="gcd[1]">
+        <mo> gcd </mo>
+      </xsl:if>
+      <xsl:if test="lcm[1]">
+        <mo> lcm </mo>
+      </xsl:if>
+    </xsl:if>
+    <xsl:if test="parent::apply[power[1]]">
+      <msup>
+      <xsl:if test="gcd[1]">
+        <mo> gcd </mo>
+      </xsl:if>
+      <xsl:if test="lcm[1]">
+        <mo> lcm </mo>
+      </xsl:if>
+        <xsl:apply-templates select = "../*[3]" mode = "semantics"/>
+      </msup>
+    </xsl:if>
+    <mo> <xsl:text disable-output-escaping='yes'>&amp;#x2061;</xsl:text> </mo>
+    <mfenced separators=",">
+      <xsl:for-each select = "*[position()>1]">
+        <xsl:apply-templates select = "." mode="semantics"/>
+      </xsl:for-each>
+    </mfenced>
+  </mrow>
+</xsl:template>
+
+
+<xsl:template match = "apply[and[1]]">
+  <xsl:param name="IN_PREC" select="$NO_PREC"/>
+  <xsl:param name="PARAM" select="$NO_PARAM"/>
+  <xsl:param name="PAREN" select="$PAR_NO"/>
+  <xsl:param name="PAR_NO_IGNORE" select="$YES"/>
+  <xsl:choose>
+    <xsl:when test="$IN_PREC &lt; $GEN_FUN_PREC and
+                   ($IN_PREC &gt; $AND_PREC or $IN_PREC=$AND_PREC and $PARAM=$PAR_SAME)">
+      <mfenced separators="">
+        <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+          <xsl:attribute name="xref">
+            <xsl:value-of select="@id"/>
+          </xsl:attribute>
+        </xsl:if>
+        <xsl:apply-templates select="." mode="and">
+          <xsl:with-param name="PARAM" select="$IN_PREC"/>
+          <xsl:with-param name="PAREN" select="$PAR_YES"/>
+        </xsl:apply-templates>
+      </mfenced>
+    </xsl:when>
+    <xsl:when test="$IN_PREC &gt; $NO_PREC and $IN_PREC &lt; $GEN_FUN_PREC
+                    and not($SEM_SW=$SEM_ALL) and not($SEM_SW=$SEM_XREF)
+                    and not($SEM_SW=$SEM_XREF_EXT)">
+      <xsl:apply-templates select="." mode="and">
+        <xsl:with-param name="PARAM" select="$IN_PREC"/>
+        <xsl:with-param name="PAREN" select="$PAREN"/>
+        <xsl:with-param name="PAR_NO_IGNORE" select="$PAR_NO_IGNORE"/>
+      </xsl:apply-templates>
+    </xsl:when>
+    <xsl:otherwise>
+      <mrow>
+        <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+          <xsl:attribute name="xref">
+            <xsl:value-of select="@id"/>
+          </xsl:attribute>
+        </xsl:if>
+        <xsl:apply-templates select="." mode="and">
+          <xsl:with-param name="PARAM" select="$IN_PREC"/>
+          <xsl:with-param name="PAREN" select="$PAREN"/>
+          <xsl:with-param name="PAR_NO_IGNORE" select="$PAR_NO_IGNORE"/>
+        </xsl:apply-templates>
+      </mrow>
+    </xsl:otherwise>
+  </xsl:choose>
+</xsl:template>
+
+<xsl:template match = "apply[and[1]]" mode="and">
+  <xsl:param name="PARAM" select="$NO_PARAM"/>
+  <xsl:param name="PAREN" select="$PAR_NO"/>
+  <xsl:param name="PAR_NO_IGNORE" select="$YES"/>
+  <xsl:apply-templates select="*[2]" mode = "semantics">
+    <xsl:with-param name="IN_PREC" select="$AND_PREC"/>
+    <xsl:with-param name="PARAM" select="$PARAM"/>
+    <xsl:with-param name="PAREN" select="$PAREN"/>
+    <xsl:with-param name="PAR_NO_IGNORE" select="$PAR_NO_IGNORE"/>
+  </xsl:apply-templates>
+  <xsl:for-each select = "*[position()>2]">
+    <mo> <xsl:text disable-output-escaping='yes'>&amp;#x2227;</xsl:text> </mo>
+    <mo> <xsl:text disable-output-escaping='yes'>&amp;#x2061;</xsl:text> </mo>
+    <xsl:apply-templates select="." mode = "semantics">
+      <xsl:with-param name="IN_PREC" select="$AND_PREC"/>
+      <xsl:with-param name="PAREN" select="$PAREN"/>
+      <xsl:with-param name="PAR_NO_IGNORE" select="$NO"/>
+    </xsl:apply-templates>
+  </xsl:for-each>
+</xsl:template>
+
+
+<xsl:template match = "apply[or[1]]">
+  <xsl:param name="IN_PREC" select="$NO_PREC"/>
+  <xsl:param name="PARAM" select="$NO_PARAM"/>
+  <xsl:param name="PAREN" select="$PAR_NO"/>
+  <xsl:param name="PAR_NO_IGNORE" select="$YES"/>
+  <xsl:choose>
+    <xsl:when test="$IN_PREC &lt; $GEN_FUN_PREC and
+                   ($IN_PREC &gt; $OR_PREC or $IN_PREC=$OR_PREC and $PARAM=$PAR_SAME)">
+      <mfenced separators="">
+        <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+          <xsl:attribute name="xref">
+            <xsl:value-of select="@id"/>
+          </xsl:attribute>
+        </xsl:if>
+        <xsl:apply-templates select="." mode="or">
+          <xsl:with-param name="PARAM" select="$IN_PREC"/>
+          <xsl:with-param name="PAREN" select="$PAR_YES"/>
+        </xsl:apply-templates>
+      </mfenced>
+    </xsl:when>
+    <xsl:when test="$IN_PREC &gt; $NO_PREC and $IN_PREC &lt; $GEN_FUN_PREC
+                    and not($SEM_SW=$SEM_ALL) and not($SEM_SW=$SEM_XREF)
+                    and not($SEM_SW=$SEM_XREF_EXT)">
+      <xsl:apply-templates select="." mode="or">
+        <xsl:with-param name="PARAM" select="$IN_PREC"/>
+        <xsl:with-param name="PAREN" select="$PAREN"/>
+        <xsl:with-param name="PAR_NO_IGNORE" select="$PAR_NO_IGNORE"/>
+      </xsl:apply-templates>
+    </xsl:when>
+    <xsl:otherwise>
+      <mrow>
+        <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+          <xsl:attribute name="xref">
+            <xsl:value-of select="@id"/>
+          </xsl:attribute>
+        </xsl:if>
+        <xsl:apply-templates select="." mode="or">
+          <xsl:with-param name="PARAM" select="$IN_PREC"/>
+          <xsl:with-param name="PAREN" select="$PAREN"/>
+          <xsl:with-param name="PAR_NO_IGNORE" select="$PAR_NO_IGNORE"/>
+        </xsl:apply-templates>
+      </mrow>
+    </xsl:otherwise>
+  </xsl:choose>
+</xsl:template>
+
+<xsl:template match = "apply[or[1]]" mode="or">
+  <xsl:param name="PARAM" select="$NO_PARAM"/>
+  <xsl:param name="PAREN" select="$PAR_NO"/>
+  <xsl:param name="PAR_NO_IGNORE" select="$YES"/>
+  <xsl:apply-templates select="*[2]" mode = "semantics">
+    <xsl:with-param name="IN_PREC" select="$OR_PREC"/>
+    <xsl:with-param name="PARAM" select="$PARAM"/>
+    <xsl:with-param name="PAREN" select="$PAREN"/>
+    <xsl:with-param name="PAR_NO_IGNORE" select="$PAR_NO_IGNORE"/>
+  </xsl:apply-templates>
+  <xsl:for-each select = "*[position()>2]">
+    <mo> <xsl:text disable-output-escaping='yes'>&amp;#x2228;</xsl:text> </mo>
+    <mo> <xsl:text disable-output-escaping='yes'>&amp;#x2061;</xsl:text> </mo>
+    <xsl:apply-templates select="." mode = "semantics">
+      <xsl:with-param name="IN_PREC" select="$OR_PREC"/>
+      <xsl:with-param name="PAREN" select="$PAREN"/>
+      <xsl:with-param name="PAR_NO_IGNORE" select="$NO"/>
+    </xsl:apply-templates>
+  </xsl:for-each>
+</xsl:template>
+
+
+<xsl:template match = "apply[xor[1]]">
+  <xsl:param name="IN_PREC" select="$NO_PREC"/>
+  <xsl:param name="PARAM" select="$NO_PARAM"/>
+  <xsl:param name="PAREN" select="$PAR_NO"/>
+  <xsl:param name="PAR_NO_IGNORE" select="$YES"/>
+  <xsl:choose>
+    <xsl:when test="$IN_PREC &lt; $GEN_FUN_PREC and
+                   ($IN_PREC &gt; $XOR_PREC or $IN_PREC=$XOR_PREC and $PARAM=$PAR_SAME)">
+      <mfenced separators="">
+        <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+          <xsl:attribute name="xref">
+            <xsl:value-of select="@id"/>
+          </xsl:attribute>
+        </xsl:if>
+        <xsl:apply-templates select="." mode="xor">
+          <xsl:with-param name="PARAM" select="$IN_PREC"/>
+          <xsl:with-param name="PAREN" select="$PAR_YES"/>
+          <xsl:with-param name="PAR_NO_IGNORE" select="$PAR_NO_IGNORE"/>
+        </xsl:apply-templates>
+      </mfenced>
+    </xsl:when>
+    <xsl:when test="$IN_PREC &gt; $NO_PREC and $IN_PREC &lt; $GEN_FUN_PREC
+                                                and not($SEM_SW=$SEM_ALL)">
+      <xsl:apply-templates select="." mode="xor">
+        <xsl:with-param name="PARAM" select="$IN_PREC"/>
+        <xsl:with-param name="PAREN" select="$PAREN"/>
+      </xsl:apply-templates>
+    </xsl:when>
+    <xsl:otherwise>
+      <mrow>
+        <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+          <xsl:attribute name="xref">
+            <xsl:value-of select="@id"/>
+          </xsl:attribute>
+        </xsl:if>
+        <xsl:apply-templates select="." mode="xor">
+          <xsl:with-param name="PARAM" select="$IN_PREC"/>
+          <xsl:with-param name="PAREN" select="$PAREN"/>
+          <xsl:with-param name="PAR_NO_IGNORE" select="$PAR_NO_IGNORE"/>
+        </xsl:apply-templates>
+      </mrow>
+    </xsl:otherwise>
+  </xsl:choose>
+</xsl:template>
+
+<xsl:template match = "apply[xor[1]]" mode="xor">
+  <xsl:param name="PARAM" select="$NO_PARAM"/>
+  <xsl:param name="PAREN" select="$PAR_NO"/>
+  <xsl:param name="PAR_NO_IGNORE" select="$YES"/>
+  <xsl:apply-templates select="*[2]" mode = "semantics">
+    <xsl:with-param name="IN_PREC" select="$XOR_PREC"/>
+    <xsl:with-param name="PARAM" select="$PARAM"/>
+    <xsl:with-param name="PAREN" select="$PAREN"/>
+    <xsl:with-param name="PAR_NO_IGNORE" select="$PAR_NO_IGNORE"/>
+  </xsl:apply-templates>
+  <xsl:for-each select = "*[position()>2]">
+    <mo> <xsl:text disable-output-escaping='yes'>&amp;#x22BB;</xsl:text> </mo>
+    <mo> <xsl:text disable-output-escaping='yes'>&amp;#x2061;</xsl:text> </mo>
+    <xsl:apply-templates select="." mode = "semantics">
+      <xsl:with-param name="IN_PREC" select="$XOR_PREC"/>
+      <xsl:with-param name="PAREN" select="$PAREN"/>
+      <xsl:with-param name="PAR_NO_IGNORE" select="$NO"/>
+    </xsl:apply-templates>
+  </xsl:for-each>
+</xsl:template>
+
+
+<xsl:template match = "apply[not[1]]">
+  <xsl:param name="IN_PREC" select="$NO_PREC"/>
+  <xsl:param name="PARAM" select="$NO_PARAM"/>
+  <xsl:param name="PAREN" select="$PAR_NO"/>
+  <xsl:param name="PAR_NO_IGNORE" select="$YES"/>
+  <xsl:choose>
+    <xsl:when test="$IN_PREC &lt; $GEN_FUN_PREC and $IN_PREC &gt;= $NOT_PREC">
+      <mfenced separators="">
+        <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+          <xsl:attribute name="xref">
+            <xsl:value-of select="@id"/>
+          </xsl:attribute>
+        </xsl:if>
+        <mo> <xsl:text disable-output-escaping='yes'>&amp;#x00AC;</xsl:text> </mo>
+        <mo> <xsl:text disable-output-escaping='yes'>&amp;#x2061;</xsl:text> </mo>
+        <xsl:apply-templates select = "*[2]" mode = "semantics">
+          <xsl:with-param name="IN_PREC" select="$NOT_PREC"/>
+          <xsl:with-param name="PAREN" select="$PAREN"/>
+          <xsl:with-param name="PAR_NO_IGNORE" select="$NO"/>
+        </xsl:apply-templates>
+	  </mfenced>
+    </xsl:when>
+    <xsl:otherwise>
+      <mrow>
+        <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+          <xsl:attribute name="xref">
+            <xsl:value-of select="@id"/>
+          </xsl:attribute>
+        </xsl:if>
+        <mo> <xsl:text disable-output-escaping='yes'>&amp;#x00AC;</xsl:text> </mo>
+        <mo> <xsl:text disable-output-escaping='yes'>&amp;#x2061;</xsl:text> </mo>
+        <xsl:apply-templates select = "*[2]" mode = "semantics">
+          <xsl:with-param name="IN_PREC" select="$NOT_PREC"/>
+          <xsl:with-param name="PAREN" select="$PAREN"/>
+          <xsl:with-param name="PAR_NO_IGNORE" select="$NO"/>
+        </xsl:apply-templates>
+      </mrow>
+    </xsl:otherwise>
+  </xsl:choose>
+</xsl:template>
+
+
+<xsl:template match = "apply[forall[1]]">
+  <mrow>
+    <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+      <xsl:attribute name="xref">
+        <xsl:value-of select="@id"/>
+      </xsl:attribute>
+    </xsl:if>
+    <mo> <xsl:text disable-output-escaping='yes'>&amp;#x2200;</xsl:text> </mo>
+    <xsl:if test="count(bvar)=1">
+      <xsl:apply-templates select = "bvar" mode="semantics"/>
+    </xsl:if>
+    <xsl:if test="count(bvar) &gt; 1">
+      <mfenced open="" close="">
+        <xsl:for-each select = "bvar">
+          <xsl:apply-templates select = "." mode="semantics"/>
+        </xsl:for-each>
+      </mfenced>
+    </xsl:if>
+	<xsl:if test="condition">
+      <mo> : </mo>
+      <xsl:apply-templates select = "condition/*" mode = "semantics"/>
+    </xsl:if>
+	<xsl:if test="*[position()>1 and not(self::bvar) and not(self::condition)]">
+      <mo> , </mo>
+      <xsl:apply-templates select = "*[position()>1 and not(self::bvar) and
+                                not(self::condition)]" mode = "semantics"/>
+    </xsl:if>
+  </mrow>
+</xsl:template>
+
+
+<xsl:template match = "apply[exists[1]]">
+  <mrow>
+    <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+      <xsl:attribute name="xref">
+        <xsl:value-of select="@id"/>
+      </xsl:attribute>
+    </xsl:if>
+    <mo> <xsl:text disable-output-escaping='yes'>&amp;#x2203;</xsl:text> </mo>
+    <xsl:if test="count(bvar) &gt; 1">
+      <mfenced open="" close="">
+        <xsl:for-each select = "bvar">
+          <xsl:apply-templates select = "." mode="semantics"/>
+        </xsl:for-each>
+      </mfenced>
+    </xsl:if>
+    <xsl:if test="count(bvar)=1">
+      <xsl:apply-templates select = "bvar" mode="semantics"/>
+    </xsl:if>
+    <xsl:if test="condition">
+      <mo> : </mo>
+      <xsl:apply-templates select = "condition/*" mode = "semantics"/>
+    </xsl:if>
+    <xsl:if test="*[position()>1 and not(self::bvar) and not(self::condition)]">
+      <mo> , </mo>
+      <xsl:apply-templates select = "*[position()>1 and not(self::bvar) and
+                                not(self::condition)]" mode = "semantics"/>
+    </xsl:if>
+  </mrow>
+</xsl:template>
+
+
+<xsl:template match = "apply[abs[1]]">
+  <xsl:if test="not(parent::apply[power[1]])">
+    <mfenced open="&#x2223;" close="&#x2223;" separators="">
+      <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+        <xsl:attribute name="xref">
+          <xsl:value-of select="@id"/>
+        </xsl:attribute>
+      </xsl:if>
+      <xsl:apply-templates select = "*[position()>1]" mode = "semantics"/>
+    </mfenced>
+  </xsl:if>
+  <xsl:if test="parent::apply[power[1]]">
+    <msup>
+      <mfenced open="&#x2223;" close="&#x2223;" separators="">
+        <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+          <xsl:attribute name="xref">
+            <xsl:value-of select="@id"/>
+          </xsl:attribute>
+        </xsl:if>
+        <xsl:apply-templates select = "*[position()>1]" mode = "semantics"/>
+      </mfenced>
+      <xsl:apply-templates select = "../*[3]" mode = "semantics"/>
+    </msup>
+  </xsl:if>
+</xsl:template>
+
+
+<xsl:template match = "apply[conjugate[1]]">
+  <mover>
+    <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+      <xsl:attribute name="xref">
+        <xsl:value-of select="@id"/>
+      </xsl:attribute>
+    </xsl:if>
+    <mrow>
+      <xsl:apply-templates select = "*[position()>1]" mode = "semantics"/>
+    </mrow>
+    <mo> <xsl:text disable-output-escaping='yes'>&amp;#x00AF;</xsl:text> </mo>
+  </mover>
+</xsl:template>
+
+
+<xsl:template match = "apply[arg[1] | real[1] | imaginary[1]]">
+  <mrow>
+    <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+      <xsl:attribute name="xref">
+        <xsl:value-of select="@id"/>
+      </xsl:attribute>
+    </xsl:if>
+    <mo>
+      <xsl:if test="arg">
+        <xsl:value-of select="'arg'"/>
+      </xsl:if>
+      <xsl:if test="real">
+        <xsl:text disable-output-escaping='yes'>&amp;#x211C;</xsl:text>
+      </xsl:if>
+      <xsl:if test="imaginary">
+        <xsl:text disable-output-escaping='yes'>&amp;#x2111;</xsl:text>
+      </xsl:if>
+    </mo>
+    <mo> <xsl:text disable-output-escaping='yes'>&amp;#x2061;</xsl:text> </mo>
+    <mfenced separators="">
+      <xsl:apply-templates select = "*[2]" mode = "semantics"/>
+    </mfenced>
+  </mrow>
+</xsl:template>
+
+
+<xsl:template match = "apply[floor[1] or ceiling[1]]">
+  <mrow>
+    <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+      <xsl:attribute name="xref">
+        <xsl:value-of select="@id"/>
+      </xsl:attribute>
+    </xsl:if>
+    <mo>
+      <xsl:if test="floor[1]">
+        <xsl:text disable-output-escaping='yes'>&amp;#x230A;</xsl:text>
+      </xsl:if>
+      <xsl:if test="ceiling[1]">
+        <xsl:text disable-output-escaping='yes'>&amp;#x2308;</xsl:text>
+      </xsl:if>
+    </mo>
+    <xsl:apply-templates select="*[position()>1]"  mode="semantics"/>
+    <mo>
+      <xsl:if test="floor[1]">
+        <xsl:text disable-output-escaping='yes'>&amp;#x230B;</xsl:text>
+      </xsl:if>
+      <xsl:if test="ceiling[1]">
+        <xsl:text disable-output-escaping='yes'>&amp;#x2309;</xsl:text>
+      </xsl:if>
+    </mo>
+  </mrow>
+</xsl:template>
+
+
+
+<!-- ***************** RELATIONS ***************** -->
+
+<xsl:template match = "apply[neq | approx | tendsto | implies
+                     | in | notin | notsubset | notprsubset
+                     | subset | prsubset | eq | gt | lt
+                     | geq | leq | equivalent | factorof]">
+  <mrow>
+    <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+      <xsl:attribute name="xref">
+        <xsl:value-of select="@id"/>
+      </xsl:attribute>
+    </xsl:if>
+    <xsl:apply-templates select="."  mode="relations"/>
+  </mrow>
+</xsl:template>
+
+<!-- reln is ***DEPRECATED*** -->
+<xsl:template match = "reln[neq | approx | tendsto | implies
+                     | in | notin | notsubset | notprsubset
+                     | subset | prsubset | eq | gt | lt
+                     | geq | leq | equivalent | factorof]">
+  <mrow>
+    <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+      <xsl:attribute name="xref">
+        <xsl:value-of select="@id"/>
+      </xsl:attribute>
+    </xsl:if>
+    <xsl:apply-templates select="."  mode="relations"/>
+  </mrow>
+</xsl:template>
+
+<xsl:template match = "*" mode="relations">
+  <xsl:if test="*[1]=neq or *[1]=approx or *[1]=factorof or *[1]=tendsto or
+                *[1]=implies or *[1]=in or *[1]=notin or
+                *[1]=notsubset or *[1]=notprsubset">
+    <xsl:apply-templates select = "*[2]" mode = "semantics"/>
+    <mo>
+      <xsl:if test="*[1]=neq">
+        <xsl:text disable-output-escaping='yes'>&amp;#x2260;</xsl:text>
+      </xsl:if>
+      <xsl:if test="*[1]=approx">
+        <xsl:text disable-output-escaping='yes'>&amp;#x2248;</xsl:text>
+      </xsl:if>
+      <xsl:if test="*[1]=factorof">
+        <xsl:text disable-output-escaping='yes'>&amp;#x2223;</xsl:text>
+      </xsl:if>
+      <xsl:if test="*[1]=tendsto">
+        <xsl:choose>
+          <xsl:when test="tendsto[@type='above']">
+            <xsl:text disable-output-escaping='yes'>&amp;#x2198;</xsl:text>
+          </xsl:when>
+          <xsl:when test="tendsto[@type='below']">
+            <xsl:text disable-output-escaping='yes'>&amp;#x2197;</xsl:text>
+          </xsl:when>
+		  <xsl:otherwise>
+            <xsl:text disable-output-escaping='yes'>&amp;#x2192;</xsl:text>
+          </xsl:otherwise>
+        </xsl:choose>
+      </xsl:if>
+      <xsl:if test="*[1]=implies">
+        <xsl:text disable-output-escaping='yes'>&amp;#x21D2;</xsl:text>
+      </xsl:if>
+      <xsl:if test="*[1]=in">
+        <xsl:text disable-output-escaping='yes'>&amp;#x2208;</xsl:text>
+      </xsl:if>
+      <xsl:if test="*[1]=notin">
+        <xsl:text disable-output-escaping='yes'>&amp;#x2209;</xsl:text>
+      </xsl:if>
+      <xsl:if test="*[1]=notsubset">
+        <xsl:text disable-output-escaping='yes'>&amp;#x2284;</xsl:text>
+      </xsl:if>
+      <xsl:if test="*[1]=notprsubset">
+        <xsl:text disable-output-escaping='yes'>&amp;#x2288;</xsl:text>
+      </xsl:if>
+    </mo>
+    <xsl:apply-templates select = "*[3]" mode = "semantics"/>
+  </xsl:if>
+  <xsl:if test="*[1]=subset or *[1]=prsubset or *[1]=eq or *[1]=gt
+             or *[1]=lt or *[1]=geq or *[1]=leq or *[1]=equivalent">
+    <xsl:apply-templates select = "*[2]" mode="semantics"/>
+    <xsl:for-each select = "*[position()>2]">
+      <mo>
+        <xsl:if test="../*[self::subset][1]">
+          <xsl:text disable-output-escaping='yes'>&amp;#x2286;</xsl:text>
+        </xsl:if>
+        <xsl:if test="../*[self::prsubset][1]">
+         <xsl:text disable-output-escaping='yes'>&amp;#x2282;</xsl:text>
+        </xsl:if>
+        <xsl:if test="../*[self::eq][1]">
+          <xsl:value-of select="'='"/>
+        </xsl:if>
+        <xsl:if test="../*[self::gt][1]">
+          <xsl:value-of select="'&gt;'"/>
+        </xsl:if>
+        <xsl:if test="../*[self::lt][1]">
+          <xsl:value-of select="'&lt;'"/>
+        </xsl:if>
+        <xsl:if test="../*[self::geq][1]">
+         <xsl:text disable-output-escaping='yes'>&amp;#x2265;</xsl:text>
+        </xsl:if>
+        <xsl:if test="../*[self::leq][1]">
+         <xsl:text disable-output-escaping='yes'>&amp;#x2264;</xsl:text>
+        </xsl:if>
+        <xsl:if test="../*[self::equivalent][1]">
+         <xsl:text disable-output-escaping='yes'>&amp;#x2261;</xsl:text>
+        </xsl:if>
+      </mo>
+      <xsl:apply-templates select = "." mode="semantics"/>
+    </xsl:for-each>
+  </xsl:if>
+</xsl:template>
+
+
+
+<!-- ***************** CALCULUS ***************** -->
+
+<xsl:template match = "apply[*[1][self::ln]]">
+  <mrow>
+    <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+      <xsl:attribute name="xref">
+        <xsl:value-of select="@id"/>
+      </xsl:attribute>
+    </xsl:if>
+    <xsl:choose>
+      <xsl:when test="parent::apply[power[1]]">
+        <msup>
+          <mo> ln </mo>
+          <xsl:apply-templates select = "../*[3]" mode = "semantics"/>
+        </msup>
+      </xsl:when>
+      <xsl:otherwise>
+        <mo rspace="thinmathspace"> ln </mo>
+      </xsl:otherwise>
+    </xsl:choose>
+    <xsl:apply-templates select = "*[2]" mode = "semantics">
+      <xsl:with-param name="IN_PREC" select="$FUNCTN_PREC"/>
+      <xsl:with-param name="PAR_NO_IGNORE" select="$NO"/>
+    </xsl:apply-templates>
+  </mrow>
+</xsl:template>
+
+
+<xsl:template match = "apply[log[1]]">
+  <mrow>
+    <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+      <xsl:attribute name="xref">
+        <xsl:value-of select="@id"/>
+      </xsl:attribute>
+    </xsl:if>
+    <xsl:choose>
+      <xsl:when test="parent::apply[power[1]]">
+        <xsl:if test="not(*[2]=logbase)">
+          <msup>
+            <mo> log </mo>
+            <xsl:apply-templates select = "../*[3]" mode = "semantics"/>
+          </msup>
+        </xsl:if>
+        <xsl:if test="*[2]=logbase">
+          <msubsup>
+            <mo> log </mo>
+            <xsl:apply-templates select = "../*[3]" mode = "semantics"/>
+            <xsl:apply-templates select = "logbase" mode = "semantics"/>
+          </msubsup>
+        </xsl:if>
+      </xsl:when>
+      <xsl:otherwise>
+        <xsl:if test="not(*[2]=logbase)">
+          <mo rspace="thinmathspace"> log </mo>
+        </xsl:if>
+        <xsl:if test="*[2]=logbase">
+          <msub>
+            <mo> log </mo>
+            <xsl:apply-templates select = "logbase" mode = "semantics"/>
+          </msub>
+        </xsl:if>
+      </xsl:otherwise>
+    </xsl:choose>
+    <xsl:if test="*[2]=logbase">
+      <xsl:apply-templates select = "*[3]" mode = "semantics">
+        <xsl:with-param name="IN_PREC" select="$FUNCTN_PREC"/>
+        <xsl:with-param name="PAR_NO_IGNORE" select="$NO"/>
+      </xsl:apply-templates>
+    </xsl:if>
+    <xsl:if test="not(*[2]=logbase)">
+      <xsl:apply-templates select = "*[2]" mode = "semantics">
+        <xsl:with-param name="IN_PREC" select="$FUNCTN_PREC"/>
+        <xsl:with-param name="PAR_NO_IGNORE" select="$NO"/>
+      </xsl:apply-templates>
+    </xsl:if>
+  </mrow>
+</xsl:template>
+
+
+<xsl:template match = "apply[diff[1]]">
+  <mrow>
+    <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+      <xsl:attribute name="xref">
+        <xsl:value-of select="@id"/>
+      </xsl:attribute>
+    </xsl:if>
+	<xsl:choose>
+      <xsl:when test="bvar">
+        <xsl:if test="not(bvar[*[2]=degree])">
+          <mfrac>
+            <mo> <xsl:text disable-output-escaping='yes'>&amp;#x2146;</xsl:text> </mo>
+            <mrow>
+              <mo> <xsl:text disable-output-escaping='yes'>&amp;#x2146;</xsl:text> </mo>
+              <xsl:apply-templates select = "bvar/*[1]" mode = "semantics"/>
+            </mrow>
+          </mfrac>
+        </xsl:if>
+        <xsl:if test="bvar[*[2]=degree]">
+          <mfrac>
+            <msup>
+              <mo> <xsl:text disable-output-escaping='yes'>&amp;#x2146;</xsl:text> </mo>
+              <xsl:apply-templates select = "bvar/degree" mode = "semantics"/>
+            </msup>
+            <mrow>
+              <mo> <xsl:text disable-output-escaping='yes'>&amp;#x2146;</xsl:text> </mo>
+              <msup>
+                <xsl:apply-templates select = "bvar/*[1]" mode = "semantics"/>
+                <xsl:apply-templates select = "bvar/degree" mode = "semantics"/>
+              </msup>
+            </mrow>
+          </mfrac>
+        </xsl:if>
+        <xsl:apply-templates select = "*[position()=last() and not(self::bvar)]" mode = "semantics">
+          <xsl:with-param name="IN_PREC" select="$FUNCTN_PREC"/>
+          <xsl:with-param name="PAR_NO_IGNORE" select="$NO"/>
+        </xsl:apply-templates>
+      </xsl:when>
+      <xsl:otherwise>
+        <xsl:apply-templates select = "*[position()=last() and not(self::bvar)]" mode = "semantics">
+          <xsl:with-param name="IN_PREC" select="$FUNCTN_PREC"/>
+          <xsl:with-param name="PAR_NO_IGNORE" select="$NO"/>
+        </xsl:apply-templates>
+        <mo> <xsl:text disable-output-escaping='yes'>&amp;#x2032;</xsl:text> </mo>
+	  </xsl:otherwise>
+    </xsl:choose>
+  </mrow>
+</xsl:template>
+
+
+<xsl:template match = "apply[partialdiff[1]]">
+  <mrow>
+    <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+      <xsl:attribute name="xref">
+        <xsl:value-of select="@id"/>
+      </xsl:attribute>
+    </xsl:if>
+    <xsl:choose>
+      <xsl:when test="list">
+        <msub>
+          <mo> <xsl:text disable-output-escaping='yes'>&amp;#x2145;</xsl:text> </mo>
+          <xsl:apply-templates select = "list" mode = "semantics"/>
+        </msub>
+      </xsl:when>
+      <xsl:otherwise>
+        <xsl:if test="degree">
+		  <mfrac>
+            <msup>
+              <mo> <xsl:text disable-output-escaping='yes'>&amp;#x2202;</xsl:text> </mo>
+              <xsl:apply-templates select = "degree" mode = "semantics"/>
+            </msup>
+            <mrow>
+              <xsl:for-each select = "bvar">
+                <mo> <xsl:text disable-output-escaping='yes'>&amp;#x2202;</xsl:text> </mo>
+                <xsl:if test="*[last()]=degree">
+                  <msup>
+                    <xsl:apply-templates select = "*[1]" mode = "semantics"/>
+                    <xsl:apply-templates select = "degree" mode = "semantics"/>
+                  </msup>
+                </xsl:if>
+                <xsl:if test="not(*[last()]=degree)">
+                  <xsl:apply-templates select = "*[1]" mode = "semantics"/>
+                </xsl:if>
+              </xsl:for-each>
+            </mrow>
+		  </mfrac>
+		</xsl:if>
+        <xsl:if test="not(degree)">
+          <xsl:for-each select = "bvar">
+            <xsl:if test="*[last()]=degree">
+              <mfrac>
+                <msup>
+                  <mo> <xsl:text disable-output-escaping='yes'>&amp;#x2202;</xsl:text> </mo>
+                  <xsl:apply-templates select = "degree" mode = "semantics"/>
+                </msup>
+                <mrow>
+                  <mo> <xsl:text disable-output-escaping='yes'>&amp;#x2202;</xsl:text> </mo>
+                  <msup>
+                    <xsl:apply-templates select = "*[1]" mode = "semantics"/>
+                    <xsl:apply-templates select = "degree" mode = "semantics"/>
+                  </msup>
+                </mrow>
+              </mfrac>
+            </xsl:if>
+            <xsl:if test="not(*[last()]=degree)">
+              <mfrac>
+                <mo> <xsl:text disable-output-escaping='yes'>&amp;#x2202;</xsl:text> </mo>
+                <mrow>
+                  <mo> <xsl:text disable-output-escaping='yes'>&amp;#x2202;</xsl:text> </mo>
+                  <xsl:apply-templates select = "*[1]" mode = "semantics"/>
+                </mrow>
+              </mfrac>
+            </xsl:if>
+          </xsl:for-each>
+		</xsl:if>
+	  </xsl:otherwise>
+	</xsl:choose>
+	<xsl:apply-templates select = "*[last()]" mode = "semantics">
+      <xsl:with-param name="IN_PREC" select="$GEN_FUN_PREC"/>
+      <xsl:with-param name="PAR_NO_IGNORE" select="$NO"/>
+    </xsl:apply-templates>
+  </mrow>
+</xsl:template>
+
+
+<xsl:template match = "lowlimit | uplimit | bvar | degree | logbase">
+  <mrow>
+    <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+      <xsl:attribute name="xref">
+        <xsl:value-of select="@id"/>
+      </xsl:attribute>
+    </xsl:if>
+    <xsl:apply-templates select="*" mode = "semantics"/>
+  </mrow>
+</xsl:template>
+
+
+<xsl:template match = "apply[divergence[1] | grad[1] | curl[1]]">
+  <mrow>
+    <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+      <xsl:attribute name="xref">
+        <xsl:value-of select="@id"/>
+      </xsl:attribute>
+    </xsl:if>
+    <mo>
+      <xsl:if test="*[1]=divergence">
+        <xsl:value-of select="'div'"/>
+      </xsl:if>
+      <xsl:if test="*[1]=grad">
+        <xsl:value-of select="'grad'"/>
+      </xsl:if>
+      <xsl:if test="*[1]=curl">
+        <xsl:value-of select="'curl'"/>
+      </xsl:if>
+    </mo>
+    <mspace width="0.01em" linebreak="nobreak"/>
+    <xsl:choose>
+      <xsl:when test="*[2]=ci">
+        <xsl:apply-templates select = "*[2]" mode = "semantics"/>
+      </xsl:when>
+      <xsl:otherwise>
+        <mfenced separators="">
+          <xsl:apply-templates select = "*[2]" mode = "semantics"/>
+        </mfenced>
+      </xsl:otherwise>
+    </xsl:choose>
+  </mrow>
+</xsl:template>
+
+
+<xsl:template match = "apply[laplacian[1]]">
+  <mrow>
+    <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+      <xsl:attribute name="xref">
+        <xsl:value-of select="@id"/>
+      </xsl:attribute>
+    </xsl:if>
+    <msup>
+      <mo> <xsl:text disable-output-escaping='yes'>&amp;#x2207;</xsl:text> </mo>
+      <mn> 2 </mn>
+    </msup>
+    <mo> <xsl:text disable-output-escaping='yes'>&amp;#x2061;</xsl:text> </mo>
+    <xsl:apply-templates select = "*[2]" mode = "semantics">
+      <xsl:with-param name="IN_PREC" select="$GEN_FUN_PREC"/>
+      <xsl:with-param name="PAR_NO_IGNORE" select="$NO"/>
+    </xsl:apply-templates>
+  </mrow>
+</xsl:template>
+
+
+
+<!-- ***************** SET THEORY ***************** -->
+
+<xsl:template match = "set | list">
+  <mfenced>
+    <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+      <xsl:attribute name="xref">
+        <xsl:value-of select="@id"/>
+      </xsl:attribute>
+    </xsl:if>
+	<xsl:if test="self::set">
+      <xsl:attribute name="open">
+        <xsl:value-of select="'{'"/>
+      </xsl:attribute>
+      <xsl:attribute name="close">
+        <xsl:value-of select="'}'"/>
+      </xsl:attribute>
+    </xsl:if>
+	<xsl:if test="self::list">
+      <xsl:attribute name="open">
+        <xsl:value-of select="'['"/>
+      </xsl:attribute>
+      <xsl:attribute name="close">
+        <xsl:value-of select="']'"/>
+      </xsl:attribute>
+    </xsl:if>
+    <xsl:choose>
+      <xsl:when test="not(child::bvar) and not(child::condition)">
+        <xsl:apply-templates select = "*" mode="semantics"/>
+      </xsl:when>
+      <xsl:otherwise>
+        <xsl:attribute name="separators"/>
+        <xsl:apply-templates select = "*[not(self::condition) and not(self::bvar)]" mode="semantics"/>
+        <mo lspace="0.1666em" rspace="0.1666em"> | </mo>
+        <xsl:apply-templates select="condition" mode = "semantics"/>
+      </xsl:otherwise>
+    </xsl:choose>
+  </mfenced>
+</xsl:template>
+
+
+<xsl:template match = "apply[union[1]]">
+  <xsl:param name="IN_PREC" select="$NO_PREC"/>
+  <xsl:param name="PARAM" select="$NO_PARAM"/>
+  <xsl:param name="PAREN" select="$PAR_NO"/>
+  <xsl:param name="PAR_NO_IGNORE" select="$YES"/>
+  <xsl:choose>
+    <xsl:when test="$IN_PREC &gt; $UNION_PREC or $IN_PREC=$UNION_PREC
+                    and $PARAM=$PAR_SAME">
+      <mfenced separators="">
+        <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+          <xsl:attribute name="xref">
+            <xsl:value-of select="@id"/>
+          </xsl:attribute>
+        </xsl:if>
+        <xsl:apply-templates select="." mode="union">
+          <xsl:with-param name="PARAM" select="$PARAM"/>
+          <xsl:with-param name="PAREN" select="$PAREN"/>
+          <xsl:with-param name="PAR_NO_IGNORE" select="$PAR_NO_IGNORE"/>
+        </xsl:apply-templates>
+      </mfenced>
+    </xsl:when>
+    <xsl:when test="$IN_PREC &gt; $NO_PREC and $IN_PREC &lt; $GEN_FUN_PREC
+                    and not($SEM_SW=$SEM_ALL) and not($SEM_SW=$SEM_XREF)
+                    and not($SEM_SW=$SEM_XREF_EXT)">
+      <xsl:apply-templates select="." mode="union">
+        <xsl:with-param name="PARAM" select="$PARAM"/>
+        <xsl:with-param name="PAREN" select="$PAREN"/>
+        <xsl:with-param name="PAR_NO_IGNORE" select="$PAR_NO_IGNORE"/>
+      </xsl:apply-templates>
+    </xsl:when>
+    <xsl:otherwise>
+      <mrow>
+        <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+          <xsl:attribute name="xref">
+            <xsl:value-of select="@id"/>
+          </xsl:attribute>
+        </xsl:if>
+        <xsl:apply-templates select="." mode="union">
+          <xsl:with-param name="PARAM" select="$PARAM"/>
+          <xsl:with-param name="PAREN" select="$PAREN"/>
+          <xsl:with-param name="PAR_NO_IGNORE" select="$PAR_NO_IGNORE"/>
+        </xsl:apply-templates>
+      </mrow>
+    </xsl:otherwise>
+  </xsl:choose>
+</xsl:template>
+
+
+<xsl:template match = "apply[union[1]]" mode="union">
+  <xsl:param name="PARAM" select="$NO_PARAM"/>
+  <xsl:param name="PAREN" select="$PAR_NO"/>
+  <xsl:param name="PAR_NO_IGNORE" select="$YES"/>
+  <xsl:apply-templates select = "*[2]" mode="semantics">
+    <xsl:with-param name="IN_PREC" select="$UNION_PREC"/>
+    <xsl:with-param name="PARAM" select="$PARAM"/>
+    <xsl:with-param name="PAREN" select="$PAREN"/>
+    <xsl:with-param name="PAR_NO_IGNORE" select="$PAR_NO_IGNORE"/>
+  </xsl:apply-templates>
+  <xsl:for-each select = "*[position()>2]">
+    <mo> <xsl:text disable-output-escaping='yes'>&amp;#x222A;</xsl:text> </mo>
+    <xsl:apply-templates select = "." mode="semantics">
+      <xsl:with-param name="IN_PREC" select="$UNION_PREC"/>
+      <xsl:with-param name="PAREN" select="$PAREN"/>
+      <xsl:with-param name="PAR_NO_IGNORE" select="$NO"/>
+    </xsl:apply-templates>
+  </xsl:for-each>
+</xsl:template>
+
+
+<xsl:template match = "apply[intersect[1]]">
+  <xsl:param name="IN_PREC" select="$NO_PREC"/>
+  <xsl:param name="PARAM" select="$NO_PARAM"/>
+  <xsl:param name="PAREN" select="$PAR_NO"/>
+  <xsl:param name="PAR_NO_IGNORE" select="$YES"/>
+  <xsl:choose>
+    <xsl:when test="$IN_PREC &gt; $INTERSECT_PREC or $IN_PREC=$INTERSECT_PREC
+                    and $PARAM=$PAR_SAME">
+      <mfenced separators="">
+        <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+          <xsl:attribute name="xref">
+            <xsl:value-of select="@id"/>
+          </xsl:attribute>
+        </xsl:if>
+        <xsl:apply-templates select="." mode="intersect">
+          <xsl:with-param name="PARAM" select="$PARAM"/>
+          <xsl:with-param name="PAREN" select="$PAREN"/>
+          <xsl:with-param name="PAR_NO_IGNORE" select="$PAR_NO_IGNORE"/>
+        </xsl:apply-templates>
+      </mfenced>
+    </xsl:when>
+    <xsl:when test="$IN_PREC &gt; $NO_PREC and $IN_PREC &lt; $GEN_FUN_PREC
+                    and not($SEM_SW=$SEM_ALL) and not($SEM_SW=$SEM_XREF)
+                    and not($SEM_SW=$SEM_XREF_EXT)">
+      <xsl:apply-templates select="." mode="intersect">
+        <xsl:with-param name="PARAM" select="$PARAM"/>
+        <xsl:with-param name="PAREN" select="$PAREN"/>
+        <xsl:with-param name="PAR_NO_IGNORE" select="$PAR_NO_IGNORE"/>
+      </xsl:apply-templates>
+    </xsl:when>
+    <xsl:otherwise>
+      <mrow>
+        <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+          <xsl:attribute name="xref">
+            <xsl:value-of select="@id"/>
+          </xsl:attribute>
+        </xsl:if>
+        <xsl:apply-templates select="." mode="intersect">
+          <xsl:with-param name="PARAM" select="$PARAM"/>
+          <xsl:with-param name="PAREN" select="$PAREN"/>
+          <xsl:with-param name="PAR_NO_IGNORE" select="$PAR_NO_IGNORE"/>
+        </xsl:apply-templates>
+      </mrow>
+    </xsl:otherwise>
+  </xsl:choose>
+</xsl:template>
+
+<xsl:template match = "apply[intersect[1]]" mode="intersect">
+  <xsl:param name="PARAM" select="$NO_PARAM"/>
+  <xsl:param name="PAREN" select="$PAR_NO"/>
+  <xsl:param name="PAR_NO_IGNORE" select="$YES"/>
+  <xsl:apply-templates select = "*[2]" mode="semantics">
+    <xsl:with-param name="IN_PREC" select="$INTERSECT_PREC"/>
+    <xsl:with-param name="PARAM" select="$PARAM"/>
+    <xsl:with-param name="PAREN" select="$PAREN"/>
+    <xsl:with-param name="PAR_NO_IGNORE" select="$PAR_NO_IGNORE"/>
+  </xsl:apply-templates>
+  <xsl:for-each select = "*[position()>2]">
+    <mo> <xsl:text disable-output-escaping='yes'>&amp;#x2229;</xsl:text> </mo>
+    <xsl:apply-templates select = "." mode="semantics">
+      <xsl:with-param name="IN_PREC" select="$INTERSECT_PREC"/>
+      <xsl:with-param name="PAREN" select="$PAREN"/>
+      <xsl:with-param name="PAR_NO_IGNORE" select="$NO"/>
+    </xsl:apply-templates>
+  </xsl:for-each>
+</xsl:template>
+
+
+<xsl:template match = "apply[setdiff[1]]">
+  <xsl:param name="IN_PREC" select="$NO_PREC"/>
+  <xsl:param name="PARAM" select="$NO_PARAM"/>
+  <xsl:param name="PAREN" select="$PAR_NO"/>
+  <xsl:param name="PAR_NO_IGNORE" select="$YES"/>
+  <xsl:choose>
+    <xsl:when test="$IN_PREC &gt; $SETDIFF_PREC or $IN_PREC=$SETDIFF_PREC
+                    and $PARAM=$PAR_SAME">
+      <mfenced separators="">
+        <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+          <xsl:attribute name="xref">
+            <xsl:value-of select="@id"/>
+          </xsl:attribute>
+        </xsl:if>
+        <xsl:apply-templates select="." mode="setdiff">
+          <xsl:with-param name="PARAM" select="$PARAM"/>
+          <xsl:with-param name="PAREN" select="$PAREN"/>
+          <xsl:with-param name="PAR_NO_IGNORE" select="$PAR_NO_IGNORE"/>
+        </xsl:apply-templates>
+      </mfenced>
+    </xsl:when>
+    <xsl:when test="$IN_PREC &gt; $NO_PREC and $IN_PREC &lt; $GEN_FUN_PREC
+                    and not($SEM_SW=$SEM_ALL) and not($SEM_SW=$SEM_XREF)
+                    and not($SEM_SW=$SEM_XREF_EXT)">
+      <xsl:apply-templates select="." mode="setdiff">
+        <xsl:with-param name="PARAM" select="$PARAM"/>
+        <xsl:with-param name="PAREN" select="$PAREN"/>
+        <xsl:with-param name="PAR_NO_IGNORE" select="$PAR_NO_IGNORE"/>
+      </xsl:apply-templates>
+    </xsl:when>
+    <xsl:otherwise>
+      <mrow>
+        <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+          <xsl:attribute name="xref">
+            <xsl:value-of select="@id"/>
+          </xsl:attribute>
+        </xsl:if>
+        <xsl:apply-templates select="." mode="setdiff">
+          <xsl:with-param name="PARAM" select="$PARAM"/>
+          <xsl:with-param name="PAREN" select="$PAREN"/>
+          <xsl:with-param name="PAR_NO_IGNORE" select="$PAR_NO_IGNORE"/>
+        </xsl:apply-templates>
+      </mrow>
+    </xsl:otherwise>
+  </xsl:choose>
+</xsl:template>
+
+<xsl:template match = "apply[setdiff[1]]" mode="setdiff">
+  <xsl:param name="PARAM" select="$NO_PARAM"/>
+  <xsl:param name="PAREN" select="$PAR_NO"/>
+  <xsl:param name="PAR_NO_IGNORE" select="$YES"/>
+  <xsl:apply-templates select = "*[2]" mode = "semantics">
+    <xsl:with-param name="IN_PREC" select="$SETDIFF_PREC"/>
+    <xsl:with-param name="PARAM" select="$PARAM"/>
+    <xsl:with-param name="PAREN" select="$PAREN"/>
+    <xsl:with-param name="PAR_NO_IGNORE" select="$PAR_NO_IGNORE"/>
+  </xsl:apply-templates>
+  <mo>\</mo>
+  <xsl:apply-templates select = "*[3]" mode = "semantics">
+    <xsl:with-param name="IN_PREC" select="$SETDIFF_PREC"/>
+    <xsl:with-param name="PARAM" select="$PAR_SAME"/>
+    <xsl:with-param name="PAREN" select="$PAREN"/>
+    <xsl:with-param name="PAR_NO_IGNORE" select="$NO"/>
+  </xsl:apply-templates>
+</xsl:template>
+
+
+<xsl:template match = "apply[cartesianproduct[1]]">
+  <xsl:param name="IN_PREC" select="$NO_PREC"/>
+  <xsl:param name="PARAM" select="$NO_PARAM"/>
+  <xsl:param name="PAREN" select="$PAR_NO"/>
+  <xsl:param name="PAR_NO_IGNORE" select="$YES"/>
+  <xsl:choose>
+    <xsl:when test="$IN_PREC &gt; $CARTPROD_PREC or $IN_PREC=$CARTPROD_PREC
+                    and $PARAM=$PAR_SAME">
+      <mfenced separators="">
+        <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+          <xsl:attribute name="xref">
+            <xsl:value-of select="@id"/>
+          </xsl:attribute>
+        </xsl:if>
+        <xsl:apply-templates select="." mode="cartprod">
+          <xsl:with-param name="PARAM" select="$PARAM"/>
+          <xsl:with-param name="PAREN" select="$PAREN"/>
+          <xsl:with-param name="PAR_NO_IGNORE" select="$PAR_NO_IGNORE"/>
+        </xsl:apply-templates>
+      </mfenced>
+    </xsl:when>
+    <xsl:when test="$IN_PREC &gt; $NO_PREC and $IN_PREC &lt; $GEN_FUN_PREC
+                    and not($SEM_SW=$SEM_ALL) and not($SEM_SW=$SEM_XREF)
+                    and not($SEM_SW=$SEM_XREF_EXT)">
+      <xsl:apply-templates select="." mode="cartprod">
+        <xsl:with-param name="PARAM" select="$PARAM"/>
+        <xsl:with-param name="PAREN" select="$PAREN"/>
+        <xsl:with-param name="PAR_NO_IGNORE" select="$PAR_NO_IGNORE"/>
+      </xsl:apply-templates>
+    </xsl:when>
+    <xsl:otherwise>
+      <mrow>
+        <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+          <xsl:attribute name="xref">
+            <xsl:value-of select="@id"/>
+          </xsl:attribute>
+        </xsl:if>
+        <xsl:apply-templates select="." mode="cartprod">
+          <xsl:with-param name="PARAM" select="$PARAM"/>
+          <xsl:with-param name="PAREN" select="$PAREN"/>
+          <xsl:with-param name="PAR_NO_IGNORE" select="$PAR_NO_IGNORE"/>
+        </xsl:apply-templates>
+      </mrow>
+    </xsl:otherwise>
+  </xsl:choose>
+</xsl:template>
+
+<xsl:template match = "*" mode="cartprod">
+  <xsl:param name="PARAM" select="$NO_PARAM"/>
+  <xsl:param name="PAREN" select="$PAR_NO"/>
+  <xsl:param name="PAR_NO_IGNORE" select="$YES"/>
+  <xsl:apply-templates select = "*[2]" mode = "semantics">
+    <xsl:with-param name="IN_PREC" select="$CARTPROD_PREC"/>
+    <xsl:with-param name="PARAM" select="$PARAM"/>
+    <xsl:with-param name="PAREN" select="$PAREN"/>
+    <xsl:with-param name="PAR_NO_IGNORE" select="$PAR_NO_IGNORE"/>
+  </xsl:apply-templates>
+  <xsl:for-each select = "*[position()>2]">
+    <mo><xsl:text disable-output-escaping='yes'>&amp;#x00D7;</xsl:text></mo>
+    <xsl:apply-templates select = "." mode="semantics">
+      <xsl:with-param name="IN_PREC" select="$CARTPROD_PREC"/>
+      <xsl:with-param name="PARAM" select="$PAR_SAME"/>
+      <xsl:with-param name="PAREN" select="$PAREN"/>
+      <xsl:with-param name="PAR_NO_IGNORE" select="$NO"/>
+    </xsl:apply-templates>
+  </xsl:for-each>
+</xsl:template>
+
+
+<xsl:template match = "apply[card[1]]">
+  <mfenced open="&#x2223;" close="&#x2223;" separators=",">
+    <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+      <xsl:attribute name="xref">
+        <xsl:value-of select="@id"/>
+      </xsl:attribute>
+    </xsl:if>
+    <xsl:for-each select = "*[position()>1]">
+      <xsl:apply-templates select = "." mode="semantics"/>
+    </xsl:for-each>
+  </mfenced>
+</xsl:template>
+
+
+
+<!-- ***************** SEQUENCES AND SERIES ***************** -->
+
+<xsl:template match = "apply[sum[1] | product[1]]">
+  <mrow>
+    <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+      <xsl:attribute name="xref">
+        <xsl:value-of select="@id"/>
+      </xsl:attribute>
+    </xsl:if>
+    <xsl:choose>
+      <xsl:when test="*[2]=bvar and lowlimit and uplimit">
+        <munderover>
+          <mo>
+            <xsl:if test="*[1]=sum">
+             <xsl:text disable-output-escaping='yes'>&amp;#x2211;</xsl:text>
+            </xsl:if>
+            <xsl:if test="*[1]=product">
+             <xsl:text disable-output-escaping='yes'>&amp;#x220F;</xsl:text>
+            </xsl:if>
+          </mo>
+          <mrow>
+            <xsl:apply-templates select = "*[2]" mode = "semantics"/>
+            <mo> = </mo>
+            <xsl:apply-templates select = "lowlimit" mode = "semantics"/>
+          </mrow>
+          <xsl:apply-templates select = "uplimit" mode = "semantics"/>
+        </munderover>
+        <xsl:apply-templates select = "*[5]" mode = "semantics"/>
+      </xsl:when>
+      <xsl:when test="*[2]=bvar and *[3]=condition">
+        <munder>
+          <mo>
+            <xsl:if test="*[1]=sum">
+             <xsl:text disable-output-escaping='yes'>&amp;#x2211;</xsl:text>
+            </xsl:if>
+            <xsl:if test="*[1]=product">
+             <xsl:text disable-output-escaping='yes'>&amp;#x220F;</xsl:text>
+            </xsl:if>
+          </mo>
+          <xsl:apply-templates select = "*[3]" mode = "semantics"/>
+        </munder>
+        <xsl:apply-templates select = "*[4]" mode = "semantics"/>
+      </xsl:when>
+      <xsl:when test="*[2]=domainofapplication">
+        <munder>
+          <mo>
+            <xsl:if test="*[1]=sum">
+              <xsl:text disable-output-escaping='yes'>&amp;#x2211;</xsl:text>
+            </xsl:if>
+            <xsl:if test="*[1]=product">
+              <xsl:text disable-output-escaping='yes'>&amp;#x220F;</xsl:text>
+            </xsl:if>
+          </mo>
+          <xsl:apply-templates select="domainofapplication" mode = "semantics"/>
+        </munder>
+        <mrow>
+          <xsl:apply-templates select="*[position()=last()]" mode = "semantics"/>
+        </mrow>
+      </xsl:when>
+    </xsl:choose>
+  </mrow>
+</xsl:template>
+
+
+<xsl:template match="apply[*[1][self::int]]">
+  <mrow>
+    <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+      <xsl:attribute name="xref">
+        <xsl:value-of select="@id"/>
+      </xsl:attribute>
+    </xsl:if>
+	<xsl:choose>
+	  <xsl:when test="domainofapplication">
+        <munder>
+          <mo> <xsl:text disable-output-escaping='yes'>&amp;#x222B;</xsl:text> </mo>
+          <xsl:apply-templates select="domainofapplication" mode="semantics"/>
+        </munder>
+      </xsl:when>
+	  <xsl:when test="condition">
+        <munder>
+          <mo> <xsl:text disable-output-escaping='yes'>&amp;#x222B;</xsl:text> </mo>
+          <xsl:apply-templates select="condition" mode="semantics"/>
+        </munder>
+      </xsl:when>
+      <xsl:when test="interval">
+        <munderover>
+          <mo> <xsl:text disable-output-escaping='yes'>&amp;#x222B;</xsl:text> </mo>
+          <mrow>
+            <xsl:apply-templates select="interval/*[position()=1]" mode="semantics"/>
+          </mrow>
+          <mrow>
+            <mspace width="1em"/>
+            <xsl:apply-templates select="interval/*[position()=2]" mode="semantics"/>
+          </mrow>
+		</munderover>
+      </xsl:when>
+      <xsl:when test="lowlimit | uplimit">
+        <munderover>
+          <mo> <xsl:text disable-output-escaping='yes'>&amp;#x222B;</xsl:text> </mo>
+          <xsl:apply-templates select="lowlimit" mode="semantics"/>
+          <mrow>
+            <mspace width="1em"/>
+            <xsl:apply-templates select="uplimit" mode="semantics"/>
+          </mrow>
+        </munderover>
+      </xsl:when>
+	  <xsl:otherwise>
+        <mo> <xsl:text disable-output-escaping='yes'>&amp;#x222B;</xsl:text> </mo>
+      </xsl:otherwise>
+    </xsl:choose>
+    <xsl:apply-templates select="*[position()=last() and last()>1 and not(self::domainofapplication) and not(self::condition) and not(self::interval) and not(self::lowlimit) and not(self::uplimit) and not(self::bvar)]" mode="semantics">
+      <xsl:with-param name="IN_PREC" select="$FUNCTN_PREC"/>
+      <xsl:with-param name="PAR_NO_IGNORE" select="$NO"/>
+    </xsl:apply-templates>
+	<xsl:if test="bvar">
+      <mrow>
+        <mo> <xsl:text disable-output-escaping='yes'>&amp;#x2146;</xsl:text> </mo>
+        <xsl:apply-templates select="bvar" mode="semantics"/>
+      </mrow>
+    </xsl:if>
+  </mrow>
+</xsl:template>
+
+
+<xsl:template match = "apply[limit[1]]">
+  <mrow>
+    <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+      <xsl:attribute name="xref">
+        <xsl:value-of select="@id"/>
+      </xsl:attribute>
+    </xsl:if>
+    <munder>
+      <mo> lim </mo>
+      <mrow>
+        <xsl:if test="*[2]=bvar and *[3]=lowlimit">
+            <xsl:apply-templates select = "*[2]" mode = "semantics"/>
+            <mo> <xsl:text disable-output-escaping='yes'>&amp;#x2192;</xsl:text> </mo>
+            <xsl:apply-templates select = "*[3]" mode = "semantics"/>
+        </xsl:if>
+        <xsl:if test="*[2]=bvar and *[3]=condition">
+          <xsl:apply-templates select = "*[3]" mode = "semantics"/>
+        </xsl:if>
+      </mrow>
+    </munder>
+    <xsl:apply-templates select = "*[4]" mode = "semantics"/>
+  </mrow>
+</xsl:template>
+
+
+
+<!-- ***************** TRIGONOMETRY ***************** -->
+
+<xsl:template match = "apply[*[1][self::sin | self::cos |
+                       self::tan | self::sec | self::csc |
+                       self::cot | self::sinh | self::cosh |
+                       self::tanh | self::sech | self::csch |
+                       self::coth | self::arcsin | self::arccos |
+                       self::arctan | self::arcsec | self::arccsc |
+                       self::arccot | self::arcsinh | self::arccosh |
+                       self::arctanh | self::arcsech | self::arccsch |
+                       self::arccoth]]">
+  <mrow>
+    <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+      <xsl:attribute name="xref">
+        <xsl:value-of select="@id"/>
+      </xsl:attribute>
+    </xsl:if>
+    <xsl:if test="not(parent::apply[power[1]])">
+      <xsl:apply-templates select = "*[1]" mode = "trigonometry"/>
+    </xsl:if>
+    <xsl:if test="parent::apply[power[1]]">
+      <msup>
+        <xsl:apply-templates select = "*[1]" mode = "trigonometry"/>
+        <xsl:apply-templates select = "../*[3]" mode = "semantics"/>
+      </msup>
+    </xsl:if>
+    <mspace width="0.01em" linebreak="nobreak"/>
+    <xsl:apply-templates select = "*[2]" mode = "semantics">
+      <xsl:with-param name="IN_PREC" select="$FUNCTN_PREC"/>
+      <xsl:with-param name="PAR_NO_IGNORE" select="$NO"/>
+    </xsl:apply-templates>
+  </mrow>
+</xsl:template>
+
+<xsl:template match = "sin | cos |
+                       tan | sec | csc |
+                       cot | sinh | cosh |
+                       tanh | sech | csch |
+                       coth | arcsin | arccos |
+                       arctan | arcsec | arccsc |
+                       arccot | arcsinh | arccosh |
+                       arctanh | arcsech | arccsch |
+                       arccoth">
+  <xsl:apply-templates select = "." mode = "trigonometry"/>
+</xsl:template>
+
+<xsl:template match = "*" mode="trigonometry">
+  <mo>
+    <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+      <xsl:attribute name="xref">
+        <xsl:value-of select="@id"/>
+      </xsl:attribute>
+    </xsl:if>
+    <xsl:choose>
+      <xsl:when test="self::sin">
+        <xsl:value-of select="'sin'"/>
+      </xsl:when>
+      <xsl:when test="self::cos">
+        <xsl:value-of select="'cos'"/>
+      </xsl:when>
+      <xsl:when test="self::tan">
+        <xsl:value-of select="'tan'"/>
+      </xsl:when>
+      <xsl:when test="self::sec">
+        <xsl:value-of select="'sec'"/>
+      </xsl:when>
+      <xsl:when test="self::csc">
+        <xsl:value-of select="'csc'"/>
+      </xsl:when>
+      <xsl:when test="self::cot">
+        <xsl:value-of select="'cot'"/>
+      </xsl:when>
+      <xsl:when test="self::sinh">
+        <xsl:value-of select="'sinh'"/>
+      </xsl:when>
+      <xsl:when test="self::cosh">
+        <xsl:value-of select="'cosh'"/>
+      </xsl:when>
+      <xsl:when test="self::tanh">
+        <xsl:value-of select="'tanh'"/>
+      </xsl:when>
+      <xsl:when test="self::sech">
+        <xsl:value-of select="'sech'"/>
+      </xsl:when>
+      <xsl:when test="self::csch">
+        <xsl:value-of select="'csch'"/>
+      </xsl:when>
+      <xsl:when test="self::coth">
+        <xsl:value-of select="'coth'"/>
+      </xsl:when>
+      <xsl:when test="self::arcsin">
+        <xsl:value-of select="'arcsin'"/>
+      </xsl:when>
+      <xsl:when test="self::arccos">
+        <xsl:value-of select="'arccos'"/>
+      </xsl:when>
+      <xsl:when test="self::arctan">
+        <xsl:value-of select="'arctan'"/>
+      </xsl:when>
+      <xsl:when test="self::arcsec">
+        <xsl:value-of select="'arcsec'"/>
+      </xsl:when>
+      <xsl:when test="self::arccsc">
+        <xsl:value-of select="'arccsc'"/>
+      </xsl:when>
+      <xsl:when test="self::arccot">
+        <xsl:value-of select="'arccot'"/>
+      </xsl:when>
+      <xsl:when test="self::arcsinh">
+        <xsl:value-of select="'arcsinh'"/>
+      </xsl:when>
+      <xsl:when test="self::arccosh">
+        <xsl:value-of select="'arccosh'"/>
+      </xsl:when>
+      <xsl:when test="self::arctanh">
+        <xsl:value-of select="'arctanh'"/>
+      </xsl:when>
+      <xsl:when test="self::arcsech">
+        <xsl:value-of select="'arcsech'"/>
+      </xsl:when>
+      <xsl:when test="self::arccsch">
+        <xsl:value-of select="'arccsch'"/>
+      </xsl:when>
+      <xsl:when test="self::arccoth">
+        <xsl:value-of select="'arccot'"/>
+      </xsl:when>
+    </xsl:choose>
+  </mo>
+</xsl:template>
+
+
+
+<!-- ***************** STATISTICS ***************** -->
+
+<xsl:template match = "apply[mean[1]]">
+  <mfenced open="&#x2329;" close="&#x232A;" separators=",">
+    <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+      <xsl:attribute name="xref">
+        <xsl:value-of select="@id"/>
+      </xsl:attribute>
+    </xsl:if>
+    <xsl:for-each select = "*[position()>1]">
+      <xsl:apply-templates select = "." mode="semantics"/>
+    </xsl:for-each>
+  </mfenced>
+</xsl:template>
+
+
+<xsl:template match = "apply[sdev[1]]">
+  <mrow>
+    <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+      <xsl:attribute name="xref">
+        <xsl:value-of select="@id"/>
+      </xsl:attribute>
+    </xsl:if>
+    <mo> <xsl:text disable-output-escaping='yes'>&amp;#x03C3;</xsl:text> </mo>
+    <mfenced separators=",">
+      <xsl:for-each select = "*[position()>1]">
+        <xsl:apply-templates select = "." mode="semantics"/>
+      </xsl:for-each>
+    </mfenced>
+  </mrow>
+</xsl:template>
+
+
+<xsl:template match = "apply[variance[1]]">
+  <mrow>
+    <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+      <xsl:attribute name="xref">
+        <xsl:value-of select="@id"/>
+      </xsl:attribute>
+    </xsl:if>
+    <mo> <xsl:text disable-output-escaping='yes'>&amp;#x03C3;</xsl:text> </mo>
+    <msup>
+      <mfenced separators=",">
+        <xsl:for-each select = "*[position()>1]">
+          <xsl:apply-templates select = "." mode="semantics"/>
+        </xsl:for-each>
+      </mfenced>
+      <mn> 2 </mn>
+    </msup>
+  </mrow>
+</xsl:template>
+
+
+<xsl:template match = "apply[median[1]]">
+  <mrow>
+    <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+      <xsl:attribute name="xref">
+        <xsl:value-of select="@id"/>
+      </xsl:attribute>
+    </xsl:if>
+    <mo> median </mo>
+    <mfenced separators=",">
+      <xsl:for-each select = "*[position()>1]">
+        <xsl:apply-templates select = "." mode="semantics"/>
+      </xsl:for-each>
+    </mfenced>
+  </mrow>
+</xsl:template>
+
+
+<xsl:template match = "apply[mode[1]]">
+  <mrow>
+    <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+      <xsl:attribute name="xref">
+        <xsl:value-of select="@id"/>
+      </xsl:attribute>
+    </xsl:if>
+    <mo> mode </mo>
+    <mfenced separators=",">
+      <xsl:for-each select = "*[position()>1]">
+        <xsl:apply-templates select = "." mode="semantics"/>
+      </xsl:for-each>
+    </mfenced>
+  </mrow>
+</xsl:template>
+
+
+<xsl:template match = "apply[moment[1]]">
+  <mfenced open="&#x2329;" close="&#x232A;" separators="">
+    <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+      <xsl:attribute name="xref">
+        <xsl:value-of select="@id"/>
+      </xsl:attribute>
+    </xsl:if>
+    <xsl:if test="*[2]=degree and not(*[3]=momentabout)">
+      <msup>
+        <xsl:apply-templates select="*[3]" mode = "semantics"/>
+        <xsl:apply-templates select="*[2]" mode = "semantics"/>
+      </msup>
+    </xsl:if>
+    <xsl:if test="*[2]=degree and *[3]=momentabout">
+      <msup>
+        <xsl:apply-templates select="*[4]" mode = "semantics"/>
+        <xsl:apply-templates select="*[2]" mode = "semantics"/>
+      </msup>
+    </xsl:if>
+    <xsl:if test="not(*[2]=degree) and *[2]=momentabout">
+      <xsl:for-each select = "*[position()>2]">
+        <xsl:apply-templates select = "." mode="semantics"/>
+      </xsl:for-each>
+    </xsl:if>
+    <xsl:if test="not(*[2]=degree) and not(*[2]=momentabout)">
+      <xsl:for-each select = "*[position()>1]">
+        <xsl:apply-templates select = "." mode="semantics"/>
+      </xsl:for-each>
+    </xsl:if>
+  </mfenced>
+</xsl:template>
+
+
+
+<!-- ***************** LINEAR ALGEBRA ***************** -->
+
+<xsl:template match="vector">
+  <mfenced separators="">
+    <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+      <xsl:attribute name="xref">
+        <xsl:value-of select="@id"/>
+      </xsl:attribute>
+    </xsl:if>
+    <mtable columnalign="center">
+      <xsl:for-each select="*">
+        <mtr>
+          <mtd> <xsl:apply-templates select="." mode = "semantics"/> </mtd>
+        </mtr>
+      </xsl:for-each>
+    </mtable>
+  </mfenced>
+</xsl:template>
+
+
+<xsl:template match = "matrix">
+  <mfenced separators="">
+    <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+      <xsl:attribute name="xref">
+        <xsl:value-of select="@id"/>
+      </xsl:attribute>
+    </xsl:if>
+    <mtable>
+      <xsl:apply-templates mode = "semantics"/>
+    </mtable>
+  </mfenced>
+</xsl:template>
+
+
+<xsl:template match = "matrixrow">
+  <mtr>
+    <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+      <xsl:attribute name="xref">
+        <xsl:value-of select="@id"/>
+      </xsl:attribute>
+    </xsl:if>
+    <xsl:for-each select="*">
+      <mtd>
+        <xsl:apply-templates select="." mode = "semantics"/>
+      </mtd>
+    </xsl:for-each>
+  </mtr>
+</xsl:template>
+
+
+<xsl:template match = "apply[determinant[1]]">
+  <mrow>
+    <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+      <xsl:attribute name="xref">
+        <xsl:value-of select="@id"/>
+      </xsl:attribute>
+    </xsl:if>
+    <mo> det </mo>
+    <mspace width="0.2em" linebreak="nobreak"/>
+    <xsl:apply-templates select = "*[2]" mode = "semantics"/>
+  </mrow>
+</xsl:template>
+
+
+<xsl:template match = "apply[transpose[1]]">
+  <msup>
+    <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+      <xsl:attribute name="xref">
+        <xsl:value-of select="@id"/>
+      </xsl:attribute>
+    </xsl:if>
+    <xsl:apply-templates select = "*[2]" mode = "semantics"/>
+    <mo> T </mo>
+  </msup>
+</xsl:template>
+
+
+<xsl:template match = "apply[selector[1]]">
+  <msub>
+    <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+      <xsl:attribute name="xref">
+        <xsl:value-of select="@id"/>
+      </xsl:attribute>
+    </xsl:if>
+    <xsl:apply-templates select="*[2]" mode = "semantics"/>
+    <mfenced open="" close="">
+      <xsl:for-each select="*[position()>2]">
+        <xsl:apply-templates select="." mode = "semantics"/>
+      </xsl:for-each>
+    </mfenced>
+  </msub>
+</xsl:template>
+
+
+<xsl:template match = "apply[vectorproduct[1] |
+                                 scalarproduct[1] | outerproduct[1]]">
+  <mrow>
+    <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+      <xsl:attribute name="xref">
+        <xsl:value-of select="@id"/>
+      </xsl:attribute>
+    </xsl:if>
+    <xsl:apply-templates select="*[2]" mode = "semantics"/>
+    <mo>
+      <xsl:if test="vectorproduct[1]">
+        <xsl:text disable-output-escaping='yes'>&amp;#x00D7;</xsl:text>
+      </xsl:if>
+      <xsl:if test="scalarproduct[1]">
+        <xsl:text disable-output-escaping='yes'>&amp;#x22C5;</xsl:text>
+      </xsl:if>
+      <xsl:if test="outerproduct[1]">
+        <xsl:text disable-output-escaping='yes'>&amp;#x2297;</xsl:text>
+      </xsl:if>
+    </mo>
+    <xsl:apply-templates select="*[3]" mode = "semantics"/>
+  </mrow>
+</xsl:template>
+
+
+
+<!-- ***************** CONSTANT and SYMBOL ELEMENTS ***************** -->
+
+<xsl:template match="integers">
+  <mo> <xsl:text disable-output-escaping='yes'>&amp;#x2124;</xsl:text> </mo>
+</xsl:template>
+
+<xsl:template match="reals">
+  <mo> <xsl:text disable-output-escaping='yes'>&amp;#x211D;</xsl:text> </mo>
+</xsl:template>
+
+<xsl:template match="rationals">
+  <mo> <xsl:text disable-output-escaping='yes'>&amp;#x211A;</xsl:text> </mo>
+</xsl:template>
+
+<xsl:template match="naturalnumbers">
+  <mo> <xsl:text disable-output-escaping='yes'>&amp;#x2115;</xsl:text> </mo>
+</xsl:template>
+
+<xsl:template match="complexes">
+  <mo> <xsl:text disable-output-escaping='yes'>&amp;#x2102;</xsl:text> </mo>
+</xsl:template>
+
+<xsl:template match="primes">
+  <mo> <xsl:text disable-output-escaping='yes'>&amp;#x2119;</xsl:text> </mo>
+</xsl:template>
+
+<xsl:template match="exponentiale">
+  <mn> <xsl:text disable-output-escaping='yes'>&amp;#x2147;</xsl:text> </mn>
+</xsl:template>
+
+<xsl:template match="imaginaryi">
+  <mn> <xsl:text disable-output-escaping='yes'>&amp;#x2148;</xsl:text> </mn>
+</xsl:template>
+
+<xsl:template match="notanumber">
+  <mo> NaN </mo>
+</xsl:template>
+
+<xsl:template match="true">
+  <mo> true </mo>
+</xsl:template>
+
+<xsl:template match="false">
+  <mo> false </mo>
+</xsl:template>
+
+<xsl:template match="emptyset">
+  <mo> <xsl:text disable-output-escaping='yes'>&amp;#x2205;</xsl:text> </mo>
+</xsl:template>
+
+<xsl:template match="pi">
+  <mn> <xsl:text disable-output-escaping='yes'>&amp;#x03C0;</xsl:text> </mn>
+</xsl:template>
+
+<xsl:template match="eulergamma">
+  <mo> <xsl:text disable-output-escaping='yes'>&amp;#x213D;</xsl:text> </mo>
+</xsl:template>
+
+<xsl:template match="infinity">
+  <mo> <xsl:text disable-output-escaping='yes'>&amp;#x221E;</xsl:text> </mo>
+</xsl:template>
+
+</xsl:stylesheet>
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/mathml/data/mmltex.xsl b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/mathml/data/mmltex.xsl
new file mode 100644
index 0000000000000000000000000000000000000000..5e6b85e02efd5196fe76b6ce4e10def27b9a8497
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/mathml/data/mmltex.xsl
@@ -0,0 +1,2360 @@
+<?xml version='1.0' encoding="UTF-8"?>
+<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
+		xmlns:m="http://www.w3.org/1998/Math/MathML"
+                version='1.0'>
+
+<!--
+Copyright (C) 2001, 2002 Vasil Yaroshevich
+
+Modified Fabian Seoane 2007 for sympy
+-->
+
+<xsl:output method="text" indent="no" encoding="UTF-8"/>
+
+<!-- ====================================================================== -->
+<!-- $id: mmltex.xsl, 2002/22/11 Exp $
+     This file is part of the XSLT MathML Library distribution.
+     See ./README or http://www.raleigh.ru/MathML/mmltex for
+     copyright and other information                                        -->
+<!-- ====================================================================== -->
+
+<!-- Note: variables colora (template color) and symbola (template startspace) only for Sablotron -->
+
+<xsl:template name="startspace">
+	<xsl:param name="symbol"/>
+	<xsl:if test="contains($symbol,' ')">
+		<xsl:variable name="symbola" select="concat(substring-before($symbol,' '),substring-after($symbol,' '))"/>
+		<xsl:call-template name="startspace">
+			<xsl:with-param name="symbol" select="$symbola"/>
+		</xsl:call-template>
+	</xsl:if>
+	<xsl:if test="not(contains($symbol,' '))">
+		<xsl:value-of select="$symbol"/>
+	</xsl:if>
+</xsl:template>
+
+<xsl:strip-space elements="m:*"/>
+
+<xsl:template match="m:math">
+	<xsl:text>&#x00024;</xsl:text>
+	<xsl:apply-templates/>
+	<xsl:text>&#x00024;</xsl:text>
+</xsl:template>
+
+
+<!-- ====================================================================== -->
+<!-- $id: tokens.xsl, 2002/22/11 Exp $
+     This file is part of the XSLT MathML Library distribution.
+     See ./README or http://www.raleigh.ru/MathML/mmltex for
+     copyright and other information                                        -->
+<!-- ====================================================================== -->
+
+<!-- 4.4.1.1 cn -->
+<xsl:template match="m:cn"><xsl:apply-templates/></xsl:template>
+
+<xsl:template match="m:cn[@type='complex-cartesian']">
+	<xsl:apply-templates select="text()[1]"/>
+  	<xsl:text>+</xsl:text>
+	<xsl:apply-templates select="text()[2]"/>
+	<xsl:text>i</xsl:text>
+</xsl:template>
+
+<xsl:template match="m:cn[@type='rational']">
+	<xsl:apply-templates select="text()[1]"/>
+	<xsl:text>/</xsl:text>
+	<xsl:apply-templates select="text()[2]"/>
+</xsl:template>
+
+<xsl:template match="m:cn[@type='integer' and @base!=10]">
+		<xsl:apply-templates/>
+		<xsl:text>_{</xsl:text><xsl:value-of select="@base"/><xsl:text>}</xsl:text>
+</xsl:template>
+
+<xsl:template match="m:cn[@type='complex-polar']">
+	<xsl:apply-templates select="text()[1]"/>
+	<xsl:text>e^{i </xsl:text>
+	<xsl:apply-templates select="text()[2]"/>
+	<xsl:text>}</xsl:text>
+</xsl:template>
+
+<xsl:template match="m:cn[@type='e-notation']">
+    <xsl:apply-templates select="text()[1]"/>
+    <xsl:text>E</xsl:text>
+    <xsl:apply-templates select="text()[2]"/>
+</xsl:template>
+
+<!-- 4.4.1.1 ci 4.4.1.2 csymbol -->
+<xsl:template match="m:ci | m:csymbol">
+	<xsl:choose>
+		<xsl:when test="string-length(normalize-space(text()))>1">
+			<xsl:text>\mathrm{</xsl:text><xsl:apply-templates/><xsl:text>}</xsl:text>
+		</xsl:when>
+		<xsl:otherwise><xsl:apply-templates/></xsl:otherwise>
+	</xsl:choose>
+</xsl:template>
+
+<!-- 4.4.2.1 apply 4.4.2.2 reln -->
+<xsl:template match="m:apply | m:reln">
+	<xsl:apply-templates select="*[1]">
+	<!-- <? -->
+		<xsl:with-param name="p" select="10"/>
+	</xsl:apply-templates>
+	<!-- ?> -->
+ 	<xsl:text>(</xsl:text>
+	<xsl:for-each select="*[position()>1]">
+		<xsl:apply-templates select="."/>
+		<xsl:if test="not(position()=last())"><xsl:text>, </xsl:text></xsl:if>
+	</xsl:for-each>
+ 	<xsl:text>)</xsl:text>
+</xsl:template>
+
+<!-- 4.4.2.3 fn -->
+<xsl:template match="m:fn[m:apply[1]]"> <!-- for m:fn using default rule -->
+	<xsl:text>(</xsl:text><xsl:apply-templates/><xsl:text>)</xsl:text>
+</xsl:template>
+
+<!-- 4.4.2.4 interval -->
+<xsl:template match="m:interval[*[2]]">
+	<xsl:choose>
+		<xsl:when test="@closure='open' or @closure='open-closed'">
+			<xsl:text>\left(</xsl:text>
+		</xsl:when>
+		<xsl:otherwise><xsl:text>\left[</xsl:text></xsl:otherwise>
+	</xsl:choose>
+	<xsl:apply-templates select="*[1]"/>
+	<xsl:text> , </xsl:text>
+	<xsl:apply-templates select="*[2]"/>
+	<xsl:choose>
+		<xsl:when test="@closure='open' or @closure='closed-open'">
+			<xsl:text>\right)</xsl:text>
+		</xsl:when>
+		<xsl:otherwise><xsl:text>\right]</xsl:text></xsl:otherwise>
+	</xsl:choose>
+</xsl:template>
+
+<xsl:template match="m:interval">
+	<xsl:text>\left\{</xsl:text><xsl:apply-templates/><xsl:text>\right\}</xsl:text>
+</xsl:template>
+
+<!-- 4.4.2.5 inverse -->
+<xsl:template match="m:apply[*[1][self::m:inverse]]">
+	<xsl:apply-templates select="*[2]"/><xsl:text>^{(-1)}</xsl:text>
+</xsl:template>
+
+<!-- 4.4.2.6 sep 4.4.2.7 condition -->
+<xsl:template match="m:sep | m:condition"><xsl:apply-templates/></xsl:template>
+
+<!-- 4.4.2.9 lambda -->
+<xsl:template match="m:lambda">
+	<xsl:text>\mathrm{lambda}\: </xsl:text>
+  	<xsl:apply-templates select="m:bvar/*"/>
+  	<xsl:text>.\: </xsl:text>
+  <xsl:apply-templates select="*[last()]"/>
+</xsl:template>
+
+<!-- 4.4.2.10 compose -->
+<xsl:template match="m:apply[*[1][self::m:compose]]">
+	<xsl:param name="p" select="0"/>
+	<xsl:call-template name="infix">
+		<xsl:with-param name="this-p" select="1"/>
+		<xsl:with-param name="p" select="$p"/>
+		<xsl:with-param name="mo">\circ </xsl:with-param>
+	</xsl:call-template>
+</xsl:template>
+
+<!-- 4.4.2.11 ident -->
+<xsl:template match="m:ident"><xsl:text>\mathrm{id}</xsl:text></xsl:template>
+
+<!-- 4.4.2.12 domain 4.4.2.13 codomain 4.4.2.14 image 4.4.3.21 arg 4.4.3.24 lcm
+		4.4.5.9 grad 4.4.5.10 curl 4.4.9.4 median 4.4.9.5 mode-->
+<xsl:template match="m:domain | m:codomain | m:image | m:arg | m:lcm | m:grad |
+								 m:curl | m:median | m:mode">
+	<xsl:text>\mathop{\mathrm{</xsl:text>
+	<xsl:value-of select="local-name()"/>
+	<xsl:text>}}</xsl:text>
+</xsl:template>
+
+<!-- 4.4.2.15 domainofapplication -->
+<xsl:template match="m:domainofapplication"/>
+
+<!-- 4.4.2.16 piecewise -->
+<xsl:template match="m:piecewise">
+	<xsl:text>\begin{cases}</xsl:text>
+	<xsl:apply-templates select="m:piece"/>
+	<xsl:apply-templates select="m:otherwise"/>
+	<xsl:text>\end{cases}</xsl:text>
+</xsl:template>
+
+<xsl:template match="m:piece">
+		<xsl:apply-templates select="*[1]"/>
+		<xsl:text> &amp; \text{if $</xsl:text>
+		<xsl:apply-templates select="*[2]"/>
+		<xsl:text>$}</xsl:text>
+		<xsl:if test="not(position()=last()) or ../m:otherwise"><xsl:text>\\ </xsl:text></xsl:if>
+</xsl:template>
+
+<xsl:template match="m:otherwise">
+	<xsl:apply-templates select="*[1]"/>
+	<xsl:text> &amp; \text{otherwise}</xsl:text>
+</xsl:template>
+
+<!-- 4.4.3.1 quotient -->
+<xsl:template match="m:apply[*[1][self::m:quotient]]">
+	<xsl:text>\left\lfloor\frac{</xsl:text>
+	<xsl:apply-templates select="*[2]"/>
+	<xsl:text>}{</xsl:text>
+	<xsl:apply-templates select="*[3]"/>
+	<xsl:text>}\right\rfloor </xsl:text>
+</xsl:template>
+
+<!-- 4.4.3.2 factorial -->
+<xsl:template match="m:apply[*[1][self::m:factorial]]">
+	<xsl:apply-templates select="*[2]">
+		<xsl:with-param name="p" select="7"/>
+	</xsl:apply-templates>
+	<xsl:text>!</xsl:text>
+</xsl:template>
+
+<!-- 4.4.3.3 divide -->
+<xsl:template match="m:apply[*[1][self::m:divide]]">
+	<xsl:param name="p" select="0"/>
+  <xsl:param name="this-p" select="3"/>
+  <xsl:if test="$this-p &lt; $p"><xsl:text>\left(</xsl:text></xsl:if>
+  <xsl:text>\frac{</xsl:text>
+	<xsl:apply-templates select="*[2]"/>
+<!--		<xsl:with-param name="p" select="$this-p"/>
+	</xsl:apply-templates>-->
+	<xsl:text>}{</xsl:text>
+	<xsl:apply-templates select="*[3]"/>
+<!--    	<xsl:with-param name="p" select="$this-p"/>
+	</xsl:apply-templates>-->
+	<xsl:text>}</xsl:text>
+	<xsl:if test="$this-p &lt; $p"><xsl:text>\right)</xsl:text></xsl:if>
+</xsl:template>
+
+<!-- 4.4.3.4 max min -->
+<xsl:template match="m:apply[*[1][self::m:max or self::m:min]]">
+	<xsl:text>\</xsl:text>
+	<xsl:value-of select="local-name(*[1])"/>
+	<xsl:text>\{</xsl:text>
+   <xsl:choose>
+		<xsl:when test="m:condition">
+   		<xsl:apply-templates select="*[last()]"/>
+   		<xsl:text>, </xsl:text>
+			<xsl:apply-templates select="m:condition/node()"/>
+		</xsl:when>
+		<xsl:otherwise>
+			<xsl:for-each select="*[position() &gt; 1]">
+				<xsl:apply-templates select="."/>
+				<xsl:if test="position() !=last()"><xsl:text> , </xsl:text></xsl:if>
+			</xsl:for-each>
+		</xsl:otherwise>
+   </xsl:choose>
+	<xsl:text>\}</xsl:text>
+</xsl:template>
+
+<!-- 4.4.3.5  minus-->
+<xsl:template match="m:apply[*[1][self::m:minus] and count(*)=2]">
+	<xsl:text>-</xsl:text>
+	<xsl:apply-templates select="*[2]">
+		<xsl:with-param name="p" select="5"/>
+	</xsl:apply-templates>
+</xsl:template>
+
+<xsl:template match="m:apply[*[1][self::m:minus] and count(*)&gt;2]">
+	<xsl:param name="p" select="0"/>
+	<xsl:call-template name="binary">
+		<xsl:with-param name="mo">-</xsl:with-param>
+		<xsl:with-param name="p" select="$p"/>
+		<xsl:with-param name="this-p" select="2"/>
+	</xsl:call-template>
+</xsl:template>
+
+<!-- 4.4.3.6  plus-->
+<xsl:template match="m:apply[*[1][self::m:plus]]">
+  <xsl:param name="p" select="0"/>
+  <xsl:if test="$p &gt; 2">
+		<xsl:text>(</xsl:text>
+	</xsl:if>
+  <xsl:for-each select="*[position()&gt;1]">
+   <xsl:if test="position() &gt; 1">
+    <xsl:choose>
+      <xsl:when test="self::m:apply[*[1][self::m:times] and
+      *[2][self::m:apply/*[1][self::m:minus] or self::m:cn[not(m:sep) and
+      (number(.) &lt; 0)]]]">-</xsl:when>
+      <xsl:otherwise>+</xsl:otherwise>
+    </xsl:choose>
+   </xsl:if>
+    <xsl:choose>
+      <xsl:when test="self::m:apply[*[1][self::m:times] and
+      *[2][self::m:cn[not(m:sep) and (number(.) &lt;0)]]]">
+			<xsl:value-of select="-(*[2])"/>
+			<xsl:apply-templates select=".">
+		     <xsl:with-param name="first" select="2"/>
+		     <xsl:with-param name="p" select="2"/>
+		   </xsl:apply-templates>
+       </xsl:when>
+      <xsl:when test="self::m:apply[*[1][self::m:times] and
+      *[2][self::m:apply/*[1][self::m:minus]]]">
+				<xsl:apply-templates select="./*[2]/*[2]"/>
+				<xsl:apply-templates select=".">
+					<xsl:with-param name="first" select="2"/>
+					<xsl:with-param name="p" select="2"/>
+				</xsl:apply-templates>
+			</xsl:when>
+			<xsl:otherwise>
+				<xsl:apply-templates select=".">
+					<xsl:with-param name="p" select="2"/>
+				</xsl:apply-templates>
+			</xsl:otherwise>
+		</xsl:choose>
+	</xsl:for-each>
+	<xsl:if test="$p &gt; 2">
+		<xsl:text>)</xsl:text>
+	</xsl:if>
+</xsl:template>
+
+<!-- 4.4.3.7 power -->
+<xsl:template match="m:apply[*[1][self::m:power]]">
+	<xsl:apply-templates select="*[2]">
+		<xsl:with-param name="p" select="5"/>
+	</xsl:apply-templates>
+	<xsl:text>^{</xsl:text>
+	<xsl:apply-templates select="*[3]">
+		<xsl:with-param name="p" select="5"/>
+	</xsl:apply-templates>
+	<xsl:text>}</xsl:text>
+</xsl:template>
+
+<!-- 4.4.3.8 remainder -->
+<xsl:template match="m:apply[*[1][self::m:rem]]">
+	<xsl:param name="p" select="0"/>
+	<xsl:call-template name="binary">
+		<xsl:with-param name="mo">\mod </xsl:with-param>
+		<xsl:with-param name="p" select="$p"/>
+		<xsl:with-param name="this-p" select="3"/>
+	</xsl:call-template>
+</xsl:template>
+
+<!-- 4.4.3.9  times-->
+<xsl:template match="m:apply[*[1][self::m:times]]" name="times">
+  <xsl:param name="p" select="0"/>
+  <xsl:param name="first" select="1"/>
+  <xsl:if test="$p &gt; 3"><xsl:text>(</xsl:text></xsl:if>
+  <xsl:for-each select="*[position()&gt;1]">
+		<xsl:if test="position() &gt; 1">
+			<xsl:choose>
+				<xsl:when test="self::m:cn">\times <!-- times --></xsl:when>
+				<xsl:otherwise><!--invisible times--></xsl:otherwise>
+			</xsl:choose>
+		</xsl:if>
+		<xsl:if test="position()&gt;= $first">
+			<xsl:apply-templates select=".">
+				<xsl:with-param name="p" select="3"/>
+			</xsl:apply-templates>
+		</xsl:if>
+	</xsl:for-each>
+  <xsl:if test="$p &gt; 3"><xsl:text>)</xsl:text></xsl:if>
+</xsl:template>
+
+<!-- 4.4.3.10 root -->
+<xsl:template match="m:apply[*[1][self::m:root]]">
+	<xsl:text>\sqrt</xsl:text>
+	<xsl:if test="m:degree!=2">
+		<xsl:text>[</xsl:text>
+		<xsl:apply-templates select="m:degree/*"/>
+		<xsl:text>]</xsl:text>
+	</xsl:if>
+	<xsl:text>{</xsl:text>
+	<xsl:apply-templates select="*[position()&gt;1 and not(self::m:degree)]"/>
+	<xsl:text>}</xsl:text>
+</xsl:template>
+
+<!-- 4.4.3.11 gcd -->
+<xsl:template match="m:gcd"><xsl:text>\gcd </xsl:text></xsl:template>
+
+<!-- 4.4.3.12 and -->
+<xsl:template match="m:apply[*[1][self::m:and]]">
+	<xsl:param name="p" select="0"/>
+	<xsl:call-template name="infix">
+		<xsl:with-param name="this-p" select="2"/>
+		<xsl:with-param name="p" select="$p"/>
+		<xsl:with-param name="mo">\land <!-- and --></xsl:with-param>
+	</xsl:call-template>
+</xsl:template>
+
+<!-- 4.4.3.13 or -->
+<xsl:template match="m:apply[*[1][self::m:or]]">
+	<xsl:param name="p" select="0"/>
+	<xsl:call-template name="infix">
+		<xsl:with-param name="this-p" select="3"/>
+		<xsl:with-param name="p" select="$p"/>
+		<xsl:with-param name="mo">\lor </xsl:with-param>
+	</xsl:call-template>
+</xsl:template>
+
+<!-- 4.4.3.14 xor -->
+<xsl:template match="m:apply[*[1][self::m:xor]]">
+	<xsl:param name="p" select="0"/>
+	<xsl:call-template name="infix">
+		<xsl:with-param name="this-p" select="3"/>
+		<xsl:with-param name="p" select="$p"/>
+		<xsl:with-param name="mo">\mathop{\mathrm{xor}}</xsl:with-param>
+	</xsl:call-template>
+</xsl:template>
+
+<!-- 4.4.3.15 not -->
+<xsl:template match="m:apply[*[1][self::m:not]]">
+	<xsl:text>\neg </xsl:text>
+	<xsl:apply-templates select="*[2]">
+		<xsl:with-param name="p" select="7"/>
+	</xsl:apply-templates>
+</xsl:template>
+
+<!-- 4.4.3.16 implies -->
+<xsl:template match="m:apply[*[1][self::m:implies]]">
+	<xsl:param name="p" select="0"/>
+	<xsl:call-template name="binary">
+		<xsl:with-param name="mo">\implies </xsl:with-param>
+		<xsl:with-param name="p" select="$p"/>
+		<xsl:with-param name="this-p" select="3"/>
+	</xsl:call-template>
+</xsl:template>
+
+<!-- 4.4.3.17 forall 4.4.3.18 exists -->
+<xsl:template match="m:apply[*[1][self::m:forall or self::m:exists]]">
+	<xsl:text>\</xsl:text>
+	<xsl:value-of select="local-name(*[1])"/>
+	<xsl:text> </xsl:text>
+	<xsl:apply-templates select="m:bvar"/>
+	<xsl:if test="m:condition">
+		<xsl:text>, </xsl:text><xsl:apply-templates select="m:condition"/>
+	</xsl:if>
+	<xsl:if test="*[last()][local-name()!='condition'][local-name()!='bvar']">
+		<xsl:text>\colon </xsl:text>
+	  <xsl:apply-templates select="*[last()]"/>
+  </xsl:if>
+</xsl:template>
+
+<!-- 4.4.3.19 abs -->
+<xsl:template match="m:apply[*[1][self::m:abs]]">
+	<xsl:text>\left|</xsl:text>
+	<xsl:apply-templates select="*[2]"/>
+	<xsl:text>\right|</xsl:text>
+</xsl:template>
+
+<!-- 4.4.3.20 conjugate -->
+<xsl:template match="m:apply[*[1][self::m:conjugate]]">
+	<xsl:text>\overline{</xsl:text><xsl:apply-templates select="*[2]"/><xsl:text>}</xsl:text>
+</xsl:template>
+
+<!-- 4.4.3.22 real -->
+<xsl:template match="m:real"><xsl:text>\Re </xsl:text></xsl:template>
+
+<!-- 4.4.3.23 imaginary -->
+<xsl:template match="m:imaginary"><xsl:text>\Im </xsl:text></xsl:template>
+
+<!-- 4.4.3.25 floor -->
+<xsl:template match="m:apply[*[1][self::m:floor]]">
+	<xsl:text>\left\lfloor </xsl:text>
+	<xsl:apply-templates select="*[2]"/>
+	<xsl:text>\right\rfloor </xsl:text>
+</xsl:template>
+
+<!-- 4.4.3.25 ceiling -->
+<xsl:template match="m:apply[*[1][self::m:ceiling]]">
+	<xsl:text>\left\lceil </xsl:text>
+	<xsl:apply-templates select="*[2]"/>
+	<xsl:text>\right\rceil </xsl:text>
+</xsl:template>
+
+<!-- 4.4.4.1 eq -->
+<xsl:template match="m:apply[*[1][self::m:eq]]">
+	<xsl:param name="p" select="0"/>
+	<xsl:call-template name="infix">
+		<xsl:with-param name="this-p" select="1"/>
+		<xsl:with-param name="p" select="$p"/>
+		<xsl:with-param name="mo">=</xsl:with-param>
+	</xsl:call-template>
+</xsl:template>
+
+<!-- 4.4.4.2 neq -->
+<xsl:template match="m:apply[*[1][self::m:neq]]">
+	<xsl:param name="p" select="0"/>
+	<xsl:call-template name="infix">
+		<xsl:with-param name="this-p" select="1"/>
+		<xsl:with-param name="p" select="$p"/>
+		<xsl:with-param name="mo">\neq </xsl:with-param>
+	</xsl:call-template>
+</xsl:template>
+
+<!-- 4.4.4.3 gt -->
+<xsl:template match="m:apply[*[1][self::m:gt]]">
+<xsl:param name="p" select="0"/>
+<xsl:call-template name="infix">
+	<xsl:with-param name="this-p" select="1"/>
+	<xsl:with-param name="p" select="$p"/>
+	<xsl:with-param name="mo">&gt; </xsl:with-param>
+</xsl:call-template>
+</xsl:template>
+
+<!-- 4.4.4.4 lt -->
+<xsl:template match="m:apply[*[1][self::m:lt]]">
+<xsl:param name="p" select="0"/>
+<xsl:call-template name="infix">
+	<xsl:with-param name="this-p" select="1"/>
+	<xsl:with-param name="p" select="$p"/>
+	<xsl:with-param name="mo">&lt; </xsl:with-param>
+</xsl:call-template>
+</xsl:template>
+
+<!-- 4.4.4.5 geq -->
+<xsl:template match="m:apply[*[1][self::m:geq]]">
+	<xsl:param name="p" select="0"/>
+	<xsl:call-template name="infix">
+		<xsl:with-param name="this-p" select="1"/>
+		<xsl:with-param name="p" select="$p"/>
+		<xsl:with-param name="mo">\ge </xsl:with-param>
+	</xsl:call-template>
+</xsl:template>
+
+<!-- 4.4.4.6 leq -->
+<xsl:template match="m:apply[*[1][self::m:leq]]">
+	<xsl:param name="p" select="0"/>
+	<xsl:call-template name="infix">
+		<xsl:with-param name="this-p" select="1"/>
+		<xsl:with-param name="p" select="$p"/>
+		<xsl:with-param name="mo">\le </xsl:with-param>
+	</xsl:call-template>
+</xsl:template>
+
+<!-- 4.4.4.7 equivalent -->
+<xsl:template match="m:apply[*[1][self::m:equivalent]]">
+	<xsl:param name="p" select="0"/>
+	<xsl:call-template name="infix">
+		<xsl:with-param name="this-p" select="1"/>
+		<xsl:with-param name="p" select="$p"/>
+		<xsl:with-param name="mo">\equiv </xsl:with-param>
+	</xsl:call-template>
+</xsl:template>
+
+<!-- 4.4.4.8 approx -->
+<xsl:template match="m:apply[*[1][self::m:approx]]">
+	<xsl:param name="p" select="0"/>
+	<xsl:call-template name="infix">
+		<xsl:with-param name="this-p" select="1"/>
+		<xsl:with-param name="p" select="$p"/>
+		<xsl:with-param name="mo">\approx </xsl:with-param>
+	</xsl:call-template>
+</xsl:template>
+
+<!-- 4.4.4.9 factorof -->
+<xsl:template match="m:apply[*[1][self::m:factorof]]">
+	<xsl:param name="p" select="0"/>
+	<xsl:call-template name="binary">
+		<xsl:with-param name="mo"> | </xsl:with-param>
+		<xsl:with-param name="p" select="$p"/>
+		<xsl:with-param name="this-p" select="3"/>
+	</xsl:call-template>
+</xsl:template>
+
+<!-- 4.4.5.1 int -->
+<xsl:template match="m:apply[*[1][self::m:int]]">
+	<xsl:text>\int</xsl:text>
+	<xsl:if test="m:lowlimit/*|m:interval/*[1]|m:condition/*">
+		<xsl:text>_{</xsl:text>
+		<xsl:apply-templates select="m:lowlimit/*|m:interval/*[1]|m:condition/*"/>
+		<xsl:text>}</xsl:text>
+	</xsl:if>
+	<xsl:if test="m:uplimit/*|m:interval/*[2]">
+		<xsl:text>^{</xsl:text>
+		<xsl:apply-templates select="m:uplimit/*|m:interval/*[2]"/>
+		<xsl:text>}</xsl:text>
+	</xsl:if>
+	<xsl:text> </xsl:text>
+	<xsl:apply-templates select="*[last()]"/>
+	<xsl:text>\,d </xsl:text>
+	<xsl:apply-templates select="m:bvar"/>
+</xsl:template>
+
+<!-- 4.4.5.2 diff -->
+<xsl:template match="m:apply[*[1][self::m:diff] and m:ci and count(*)=2]" priority="2">
+	<xsl:apply-templates select="*[2]"/>
+	<xsl:text>^\prime </xsl:text>
+</xsl:template>
+
+<xsl:template match="m:apply[*[1][self::m:diff]]" priority="1">
+	<xsl:text>\frac{</xsl:text>
+	<xsl:choose>
+		<xsl:when test="m:bvar/m:degree">
+			<xsl:text>d^{</xsl:text>
+			<xsl:apply-templates select="m:bvar/m:degree/node()"/>
+			<xsl:text>}</xsl:text>
+			<xsl:apply-templates select="*[last()]"/>
+			<xsl:text>}{d</xsl:text>
+			<xsl:apply-templates select="m:bvar/node()"/>
+			<xsl:text>^{</xsl:text>
+			<xsl:apply-templates select="m:bvar/m:degree/node()"/>
+			<xsl:text>}</xsl:text>
+		</xsl:when>
+		<xsl:otherwise>
+			<xsl:text>d </xsl:text>
+			<xsl:apply-templates select="*[last()]"/>
+			<xsl:text>}{d </xsl:text>
+			<xsl:apply-templates select="m:bvar"/>
+			<xsl:text>}</xsl:text>
+		</xsl:otherwise>
+	</xsl:choose>
+	<xsl:text>}</xsl:text>
+</xsl:template>
+
+<!-- 4.4.5.3 partialdiff -->
+<xsl:template match="m:apply[*[1][self::m:partialdiff] and m:list and m:ci and count(*)=3]" priority="2">
+	<xsl:text>D_{</xsl:text>
+	<xsl:for-each select="m:list[1]/*">
+		<xsl:apply-templates select="."/>
+		<xsl:if test="position()&lt;last()"><xsl:text>, </xsl:text></xsl:if>
+	</xsl:for-each>
+	<xsl:text>}</xsl:text>
+	<xsl:apply-templates select="*[3]"/>
+</xsl:template>
+
+<xsl:template match="m:apply[*[1][self::m:partialdiff]]" priority="1">
+	<xsl:text>\frac{\partial^{</xsl:text>
+	<xsl:choose>
+		<xsl:when test="m:degree">
+			<xsl:apply-templates select="m:degree/node()"/>
+		</xsl:when>
+		<xsl:when test="m:bvar/m:degree[string(number(.))='NaN']">
+			<xsl:for-each select="m:bvar/m:degree">
+				<xsl:apply-templates select="node()"/>
+				<xsl:if test="position()&lt;last()"><xsl:text>+</xsl:text></xsl:if>
+			</xsl:for-each>
+			<xsl:if test="count(m:bvar[not(m:degree)])&gt;0">
+				<xsl:text>+</xsl:text>
+				<xsl:value-of select="count(m:bvar[not(m:degree)])"/>
+			</xsl:if>
+		</xsl:when>
+		<xsl:otherwise>
+			<xsl:value-of select="sum(m:bvar/m:degree)+count(m:bvar[not(m:degree)])"/>
+		</xsl:otherwise>
+	</xsl:choose>
+	<xsl:text>}</xsl:text>
+	<xsl:apply-templates select="*[last()]"/>
+	<xsl:text>}{</xsl:text>
+	<xsl:for-each select="m:bvar">
+		<xsl:text>\partial </xsl:text>
+		<xsl:apply-templates select="node()"/>
+		<xsl:if test="m:degree">
+			<xsl:text>^{</xsl:text>
+			<xsl:apply-templates select="m:degree/node()"/>
+			<xsl:text>}</xsl:text>
+		</xsl:if>
+	</xsl:for-each>
+	<xsl:text>}</xsl:text>
+</xsl:template>
+
+<!-- 4.4.2.8 declare 4.4.5.4 lowlimit 4.4.5.5 uplimit 4.4.5.7 degree 4.4.9.5 momentabout -->
+<xsl:template match="m:declare | m:lowlimit | m:uplimit | m:degree | m:momentabout"/>
+
+<!-- 4.4.5.6  bvar-->
+<xsl:template match="m:bvar">
+	<xsl:apply-templates/>
+	<xsl:if test="following-sibling::m:bvar"><xsl:text>, </xsl:text></xsl:if>
+</xsl:template>
+
+<!-- 4.4.5.8 divergence-->
+<xsl:template match="m:divergence"><xsl:text>\mathop{\mathrm{div}}</xsl:text></xsl:template>
+
+<!-- 4.4.5.11 laplacian-->
+<xsl:template match="m:laplacian"><xsl:text>\nabla^2 </xsl:text></xsl:template>
+
+<!-- 4.4.6.1 set -->
+<xsl:template match="m:set">
+	<xsl:text>\{</xsl:text><xsl:call-template name="set"/><xsl:text>\}</xsl:text>
+</xsl:template>
+
+<!-- 4.4.6.2 list -->
+<xsl:template match="m:list">
+	<xsl:text>\left[</xsl:text><xsl:call-template name="set"/><xsl:text>\right]</xsl:text>
+</xsl:template>
+
+<xsl:template name="set">
+   <xsl:choose>
+		<xsl:when test="m:condition">
+   		<xsl:apply-templates select="m:bvar/*[not(self::bvar or self::condition)]"/>
+   		<xsl:text>\colon </xsl:text>
+			<xsl:apply-templates select="m:condition/node()"/>
+		</xsl:when>
+		<xsl:otherwise>
+			<xsl:for-each select="*">
+				<xsl:apply-templates select="."/>
+				<xsl:if test="position()!=last()"><xsl:text>, </xsl:text></xsl:if>
+			</xsl:for-each>
+		</xsl:otherwise>
+   </xsl:choose>
+</xsl:template>
+
+<!-- 4.4.6.3 union -->
+<xsl:template match="m:apply[*[1][self::m:union]]">
+	<xsl:param name="p" select="0"/>
+	<xsl:call-template name="infix">
+		<xsl:with-param name="this-p" select="2"/>
+		<xsl:with-param name="p" select="$p"/>
+		<xsl:with-param name="mo">\cup </xsl:with-param>
+	</xsl:call-template>
+</xsl:template>
+
+<!-- 4.4.6.4 intersect -->
+<xsl:template match="m:apply[*[1][self::m:intersect]]">
+	<xsl:param name="p" select="0"/>
+	<xsl:call-template name="infix">
+		<xsl:with-param name="this-p" select="3"/>
+		<xsl:with-param name="p" select="$p"/>
+		<xsl:with-param name="mo">\cap </xsl:with-param>
+	</xsl:call-template>
+</xsl:template>
+
+<!-- 4.4.6.5 in -->
+<xsl:template match="m:apply[*[1][self::m:in]]">
+	<xsl:param name="p" select="0"/>
+	<xsl:call-template name="binary">
+		<xsl:with-param name="mo">\in </xsl:with-param>
+		<xsl:with-param name="p" select="$p"/>
+		<xsl:with-param name="this-p" select="3"/>
+	</xsl:call-template>
+</xsl:template>
+
+<!-- 4.4.6.5 notin -->
+<xsl:template match="m:apply[*[1][self::m:notin]]">
+	<xsl:param name="p" select="0"/>
+	<xsl:call-template name="binary">
+		<xsl:with-param name="mo">\notin </xsl:with-param>
+		<xsl:with-param name="p" select="$p"/>
+		<xsl:with-param name="this-p" select="3"/>
+	</xsl:call-template>
+</xsl:template>
+
+<!-- 4.4.6.7 subset -->
+<xsl:template match="m:apply[*[1][self::m:subset]]">
+	<xsl:param name="p" select="0"/>
+	<xsl:call-template name="infix">
+		<xsl:with-param name="this-p" select="2"/>
+		<xsl:with-param name="p" select="$p"/>
+		<xsl:with-param name="mo">\subseteq </xsl:with-param>
+	</xsl:call-template>
+</xsl:template>
+
+<!-- 4.4.6.8 prsubset -->
+<xsl:template match="m:apply[*[1][self::m:prsubset]]">
+	<xsl:param name="p" select="0"/>
+	<xsl:call-template name="infix">
+		<xsl:with-param name="this-p" select="2"/>
+		<xsl:with-param name="p" select="$p"/>
+		<xsl:with-param name="mo">\subset </xsl:with-param>
+	</xsl:call-template>
+</xsl:template>
+
+<!-- 4.4.6.9 notsubset -->
+<xsl:template match="m:apply[*[1][self::m:notsubset]]">
+	<xsl:param name="p" select="0"/>
+	<xsl:call-template name="binary">
+		<xsl:with-param name="this-p" select="2"/>
+		<xsl:with-param name="p" select="$p"/>
+		<xsl:with-param name="mo">\nsubseteq </xsl:with-param>
+	</xsl:call-template>
+</xsl:template>
+
+<!-- 4.4.6.10 notprsubset -->
+<xsl:template match="m:apply[*[1][self::m:notprsubset]]">
+	<xsl:param name="p" select="0"/>
+	<xsl:call-template name="binary">
+		<xsl:with-param name="this-p" select="2"/>
+		<xsl:with-param name="p" select="$p"/>
+		<xsl:with-param name="mo">\not\subset </xsl:with-param>
+	</xsl:call-template>
+</xsl:template>
+
+<!-- 4.4.6.11 setdiff -->
+<xsl:template match="m:apply[*[1][self::m:setdiff]]">
+	<xsl:param name="p" select="0"/>
+	<xsl:call-template name="binary">
+		<xsl:with-param name="this-p" select="2"/>
+		<xsl:with-param name="p" select="$p"/>
+		<xsl:with-param name="mo">\setminus </xsl:with-param>
+	</xsl:call-template>
+</xsl:template>
+
+<!-- 4.4.6.12 card -->
+<xsl:template match="m:apply[*[1][self::m:card]]">
+	<xsl:text>|</xsl:text>
+	<xsl:apply-templates select="*[2]"/>
+	<xsl:text>|</xsl:text>
+</xsl:template>
+
+<!-- 4.4.6.13 cartesianproduct 4.4.10.6 vectorproduct -->
+<xsl:template match="m:apply[*[1][self::m:cartesianproduct or self::m:vectorproduct]]">
+	<xsl:param name="p" select="0"/>
+	<xsl:call-template name="infix">
+		<xsl:with-param name="this-p" select="2"/>
+		<xsl:with-param name="p" select="$p"/>
+		<xsl:with-param name="mo">\times </xsl:with-param>
+	</xsl:call-template>
+</xsl:template>
+
+<xsl:template
+match="m:apply[*[1][self::m:cartesianproduct][count(following-sibling::m:reals)=count(following-sibling::*)]]"
+priority="2">
+	<xsl:apply-templates select="*[2]">
+		<xsl:with-param name="p" select="5"/>
+	</xsl:apply-templates>
+	<xsl:text>^{</xsl:text>
+	<xsl:value-of select="count(*)-1"/>
+	<xsl:text>}</xsl:text>
+</xsl:template>
+
+<!-- 4.4.7.1 sum -->
+<xsl:template match="m:apply[*[1][self::m:sum]]">
+	<xsl:text>\sum</xsl:text><xsl:call-template name="series"/>
+</xsl:template>
+
+<!-- 4.4.7.2 product -->
+<xsl:template match="m:apply[*[1][self::m:product]]">
+	<xsl:text>\prod</xsl:text><xsl:call-template name="series"/>
+</xsl:template>
+
+<xsl:template name="series">
+	<xsl:if test="m:lowlimit/*|m:interval/*[1]|m:condition/*">
+		<xsl:text>_{</xsl:text>
+		<xsl:if test="not(m:condition)">
+			<xsl:apply-templates select="m:bvar"/>
+			<xsl:text>=</xsl:text>
+		</xsl:if>
+		<xsl:apply-templates select="m:lowlimit/*|m:interval/*[1]|m:condition/*"/>
+		<xsl:text>}</xsl:text>
+	</xsl:if>
+	<xsl:if test="m:uplimit/*|m:interval/*[2]">
+		<xsl:text>^{</xsl:text>
+		<xsl:apply-templates select="m:uplimit/*|m:interval/*[2]"/>
+		<xsl:text>}</xsl:text>
+	</xsl:if>
+	<xsl:text> </xsl:text>
+	<xsl:apply-templates select="*[last()]"/>
+</xsl:template>
+
+<!-- 4.4.7.3 limit -->
+<xsl:template match="m:apply[*[1][self::m:limit]]">
+	<xsl:text>\lim_{</xsl:text>
+	<xsl:apply-templates select="m:lowlimit|m:condition/*"/>
+	<xsl:text>}</xsl:text>
+	<xsl:apply-templates select="*[last()]"/>
+</xsl:template>
+
+<xsl:template match="m:apply[m:limit]/m:lowlimit" priority="3">
+	<xsl:apply-templates select="../m:bvar/node()"/>
+	<xsl:text>\to </xsl:text>
+	<xsl:apply-templates/>
+</xsl:template>
+
+<!-- 4.4.7.4 tendsto -->
+<xsl:template match="m:apply[*[1][self::m:tendsto]]">
+	<xsl:param name="p"/>
+	<xsl:call-template name="binary">
+		<xsl:with-param name="this-p" select="2"/>
+		<xsl:with-param name="p" select="$p"/>
+		<xsl:with-param name="mo">
+			<xsl:choose>
+				<xsl:when test="@type='above'">\searrow </xsl:when>
+				<xsl:when test="@type='below'">\nearrow </xsl:when>
+				<xsl:when test="@type='two-sided'">\rightarrow </xsl:when>
+				<xsl:otherwise>\to </xsl:otherwise>
+			</xsl:choose>
+		</xsl:with-param>
+	</xsl:call-template>
+</xsl:template>
+
+<!-- 4.4.8.1 common tringonometric functions 4.4.8.3 natural logarithm -->
+<xsl:template match="m:apply[*[1][
+ self::m:sin or 		self::m:cos or 	self::m:tan or		self::m:sec or
+ self::m:csc or 		self::m:cot or 	self::m:sinh or	 	self::m:cosh or
+ self::m:tanh or 		self::m:coth or	self::m:arcsin or 	self::m:arccos or
+ self::m:arctan or 	self::m:ln]]">
+	<xsl:text>\</xsl:text>
+	<xsl:value-of select="local-name(*[1])"/>
+	<xsl:text> </xsl:text>
+	<xsl:apply-templates select="*[2]">
+		<xsl:with-param name="p" select="7"/>
+	</xsl:apply-templates>
+</xsl:template>
+
+<xsl:template match="m:sin | m:cos | m:tan | m:sec | m:csc |
+								 m:cot | m:sinh | m:cosh | m:tanh | m:coth |
+								 m:arcsin | m:arccos | m:arctan | m:ln">
+	<xsl:text>\</xsl:text>
+	<xsl:value-of select="local-name(.)"/>
+	<xsl:text> </xsl:text>
+</xsl:template>
+
+<xsl:template match="m:apply[*[1][
+ self::m:sech or 		self::m:csch or		self::m:arccosh or
+ self::m:arccot or 	self::m:arccoth or 	self::m:arccsc or
+ self::m:arccsch or self::m:arcsec or 	self::m:arcsech or
+ self::m:arcsinh or self::m:arctanh]]">
+	<xsl:text>\mathrm{</xsl:text>
+	<xsl:value-of select="local-name(*[1])"/>
+	<xsl:text>\,}</xsl:text>
+	<xsl:apply-templates select="*[2]">
+		<xsl:with-param name="p" select="7"/>
+	</xsl:apply-templates>
+</xsl:template>
+
+<xsl:template match="m:sech | m:csch | m:arccosh | m:arccot |
+								 m:arccoth | m:arccsc |m:arccsch |m:arcsec |
+								 m:arcsech | m:arcsinh | m:arctanh">
+	<xsl:text>\mathrm{</xsl:text>
+	<xsl:value-of select="local-name(.)"/>
+	<xsl:text>}</xsl:text>
+</xsl:template>
+
+<!-- 4.4.8.2 exp -->
+<xsl:template match="m:apply[*[1][self::m:exp]]">
+	<xsl:text>e^{</xsl:text><xsl:apply-templates select="*[2]"/><xsl:text>}</xsl:text>
+</xsl:template>
+
+<!-- 4.4.8.4 log -->
+<xsl:template match="m:apply[*[1][self::m:log]]">
+	<xsl:text>\lg </xsl:text>
+	<xsl:apply-templates select="*[last()]">
+		<xsl:with-param name="p" select="7"/>
+	</xsl:apply-templates>
+</xsl:template>
+
+<xsl:template match="m:apply[*[1][self::m:log] and m:logbase != 10]">
+	<xsl:text>\log_{</xsl:text>
+	<xsl:apply-templates select="m:logbase/node()"/>
+	<xsl:text>}</xsl:text>
+	<xsl:apply-templates select="*[last()]">
+		<xsl:with-param name="p" select="7"/>
+	</xsl:apply-templates>
+</xsl:template>
+
+<!-- 4.4.9.1 mean -->
+<xsl:template match="m:apply[*[1][self::m:mean]]">
+	<xsl:text>\left\langle </xsl:text>
+	<xsl:for-each select="*[position()&gt;1]">
+		<xsl:apply-templates select="."/>
+		<xsl:if test="position() !=last()"><xsl:text>, </xsl:text></xsl:if>
+	</xsl:for-each>
+	<xsl:text>\right\rangle </xsl:text>
+</xsl:template>
+
+<!-- 4.4.9.2 sdef -->
+<xsl:template match="m:sdev"><xsl:text>\sigma </xsl:text></xsl:template>
+
+<!-- 4.4.9.3 variance -->
+<xsl:template match="m:apply[*[1][self::m:variance]]">
+	<xsl:text>\sigma(</xsl:text>
+	<xsl:apply-templates select="*[2]"/>
+	<xsl:text>)^2</xsl:text>
+</xsl:template>
+
+<!-- 4.4.9.5 moment -->
+<xsl:template match="m:apply[*[1][self::m:moment]]">
+	<xsl:text>\left\langle </xsl:text>
+	<xsl:apply-templates select="*[last()]"/>
+	<xsl:text>^{</xsl:text>
+	<xsl:apply-templates select="m:degree/node()"/>
+	<xsl:text>}\right\rangle</xsl:text>
+	<xsl:if test="m:momentabout">
+		<xsl:text>_{</xsl:text>
+		<xsl:apply-templates select="m:momentabout/node()"/>
+		<xsl:text>}</xsl:text>
+	</xsl:if>
+	<xsl:text> </xsl:text>
+</xsl:template>
+
+<!-- 4.4.10.1 vector  -->
+<xsl:template match="m:vector">
+	<xsl:text>\left(\begin{array}{c}</xsl:text>
+	<xsl:for-each select="*">
+		<xsl:apply-templates select="."/>
+		<xsl:if test="position()!=last()"><xsl:text>\\ </xsl:text></xsl:if>
+	</xsl:for-each>
+	<xsl:text>\end{array}\right)</xsl:text>
+</xsl:template>
+
+<!-- 4.4.10.2 matrix  -->
+<xsl:template match="m:matrix">
+	<xsl:text>\begin{pmatrix}</xsl:text>
+	<xsl:apply-templates/>
+	<xsl:text>\end{pmatrix}</xsl:text>
+</xsl:template>
+
+<!-- 4.4.10.3 matrixrow  -->
+<xsl:template match="m:matrixrow">
+	<xsl:for-each select="*">
+		<xsl:apply-templates select="."/>
+		<xsl:if test="position()!=last()"><xsl:text> &amp; </xsl:text></xsl:if>
+	</xsl:for-each>
+	<xsl:if test="position()!=last()"><xsl:text>\\ </xsl:text></xsl:if>
+</xsl:template>
+
+<!-- 4.4.10.4 determinant  -->
+<xsl:template match="m:apply[*[1][self::m:determinant]]">
+	<xsl:text>\det </xsl:text>
+	<xsl:apply-templates select="*[2]">
+		<xsl:with-param name="p" select="7"/>
+	</xsl:apply-templates>
+</xsl:template>
+
+<xsl:template match="m:apply[*[1][self::m:determinant]][*[2][self::m:matrix]]" priority="2">
+	<xsl:text>\begin{vmatrix}</xsl:text>
+	<xsl:apply-templates select="m:matrix/*"/>
+	<xsl:text>\end{vmatrix}</xsl:text>
+</xsl:template>
+
+<!-- 4.4.10.5 transpose -->
+<xsl:template match="m:apply[*[1][self::m:transpose]]">
+	<xsl:apply-templates select="*[2]">
+		<xsl:with-param name="p" select="7"/>
+	</xsl:apply-templates>
+	<xsl:text>^T</xsl:text>
+</xsl:template>
+
+<!-- 4.4.10.5 selector -->
+<xsl:template match="m:apply[*[1][self::m:selector]]">
+	<xsl:apply-templates select="*[2]">
+		<xsl:with-param name="p" select="7"/>
+	</xsl:apply-templates>
+	<xsl:text>_{</xsl:text>
+	<xsl:for-each select="*[position()&gt;2]">
+		<xsl:apply-templates select="."/>
+		<xsl:if test="position() !=last()"><xsl:text>, </xsl:text></xsl:if>
+	</xsl:for-each>
+	<xsl:text>}</xsl:text>
+</xsl:template>
+
+<!-- 4.4.10.7 scalarproduct 4.4.10.8 outerproduct -->
+<xsl:template match="m:apply[*[1][self::m:scalarproduct or self::m:outerproduct]]">
+	<xsl:param name="p" select="0"/>
+	<xsl:call-template name="infix">
+		<xsl:with-param name="this-p" select="2"/>
+		<xsl:with-param name="p" select="$p"/>
+		<xsl:with-param name="mo">\dot </xsl:with-param>
+	</xsl:call-template>
+</xsl:template>
+
+<!-- 4.4.11.2 semantics -->
+<xsl:template match="m:semantics"><xsl:apply-templates select="*[1]"/></xsl:template>
+
+<xsl:template match="m:semantics[m:annotation/@encoding='TeX']">
+	<xsl:apply-templates select="m:annotation[@encoding='TeX']/node()"/>
+</xsl:template>
+
+<!-- 4.4.12.1 integers -->
+<xsl:template match="m:integers"><xsl:text>\mathbb{Z}</xsl:text></xsl:template>
+
+<!-- 4.4.12.2 reals -->
+<xsl:template match="m:reals"><xsl:text>\mathbb{R}</xsl:text></xsl:template>
+
+<!-- 4.4.12.3 rationals -->
+<xsl:template match="m:rationals"><xsl:text>\mathbb{Q}</xsl:text></xsl:template>
+
+<!-- 4.4.12.4 naturalnumbers -->
+<xsl:template match="m:naturalnumbers"><xsl:text>\mathbb{N}</xsl:text></xsl:template>
+
+<!-- 4.4.12.5 complexes -->
+<xsl:template match="m:complexes"><xsl:text>\mathbb{C}</xsl:text></xsl:template>
+
+<!-- 4.4.12.6 primes -->
+<xsl:template match="m:primes"><xsl:text>\mathbb{P}</xsl:text></xsl:template>
+
+<!-- 4.4.12.7 exponentiale -->
+<xsl:template match="m:exponentiale"><xsl:text>e</xsl:text></xsl:template>
+
+<!-- 4.4.12.8 imaginaryi -->
+<xsl:template match="m:imaginaryi"><xsl:text>i</xsl:text></xsl:template>
+
+<!-- 4.4.12.9 notanumber -->
+<xsl:template match="m:notanumber"><xsl:text>NaN</xsl:text></xsl:template>
+
+<!-- 4.4.12.10 true -->
+<xsl:template match="m:true"><xsl:text>\mbox{true}</xsl:text></xsl:template>
+
+<!-- 4.4.12.11 false -->
+<xsl:template match="m:false"><xsl:text>\mbox{false}</xsl:text></xsl:template>
+
+<!-- 4.4.12.12 emptyset -->
+<xsl:template match="m:emptyset"><xsl:text>\emptyset </xsl:text></xsl:template>
+
+<!-- 4.4.12.13 pi -->
+<xsl:template match="m:pi"><xsl:text>\pi </xsl:text></xsl:template>
+
+<!-- 4.4.12.14 eulergamma -->
+<xsl:template match="m:eulergamma"><xsl:text>\gamma </xsl:text></xsl:template>
+
+<!-- 4.4.12.15 infinity -->
+<xsl:template match="m:infinity"><xsl:text>\infty </xsl:text></xsl:template>
+
+<!-- ****************************** -->
+<xsl:template name="infix" >
+  <xsl:param name="mo"/>
+  <xsl:param name="p" select="0"/>
+  <xsl:param name="this-p" select="0"/>
+  <xsl:if test="$this-p &lt; $p"><xsl:text>(</xsl:text></xsl:if>
+  <xsl:for-each select="*[position()&gt;1]">
+		<xsl:if test="position() &gt; 1">
+			<xsl:copy-of select="$mo"/>
+		</xsl:if>
+		<xsl:apply-templates select=".">
+			<xsl:with-param name="p" select="$this-p"/>
+		</xsl:apply-templates>
+	</xsl:for-each>
+  <xsl:if test="$this-p &lt; $p"><xsl:text>)</xsl:text></xsl:if>
+</xsl:template>
+
+<xsl:template name="binary" >
+  <xsl:param name="mo"/>
+  <xsl:param name="p" select="0"/>
+  <xsl:param name="this-p" select="0"/>
+  <xsl:if test="$this-p &lt; $p"><xsl:text>(</xsl:text></xsl:if>
+	<xsl:apply-templates select="*[2]">
+		<xsl:with-param name="p" select="$this-p"/>
+	</xsl:apply-templates>
+	<xsl:value-of select="$mo"/>
+	<xsl:apply-templates select="*[3]">
+    	<xsl:with-param name="p" select="$this-p"/>
+	</xsl:apply-templates>
+	<xsl:if test="$this-p &lt; $p"><xsl:text>)</xsl:text></xsl:if>
+</xsl:template>
+
+
+<!-- ====================================================================== -->
+<!-- $id: entities.xsl, 2002/22/11 Exp $
+     This file is part of the XSLT MathML Library distribution.
+     See ./README or http://www.raleigh.ru/MathML/mmltex for
+     copyright and other information                                        -->
+<!-- ====================================================================== -->
+
+<xsl:template name="replaceEntities">
+	<xsl:param name="content"/>
+	<xsl:if test="string-length($content)>0">
+	<xsl:choose>
+		<xsl:when test="starts-with($content,'&#x0025B;')"><xsl:value-of select="'\varepsilon '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x0025B;')"/></xsl:call-template></xsl:when>	<!--/varepsilon -->
+
+<!-- ====================================================================== -->
+<!-- 	Unicode 3.2
+	Greek
+	Range: 0370-03FF
+	http://www.unicode.org/charts/PDF/U0370.pdf	                    -->
+<!-- ====================================================================== -->
+		<xsl:when test="starts-with($content,'&#x00393;')"><xsl:value-of select="'\Gamma '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x00393;')"/></xsl:call-template></xsl:when>	<!--/Gamma capital Gamma, Greek -->
+		<xsl:when test="starts-with($content,'&#x00394;')"><xsl:value-of select="'\Delta '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x00394;')"/></xsl:call-template></xsl:when>	<!--/Delta capital Delta, Greek -->
+		<xsl:when test="starts-with($content,'&#x00398;')"><xsl:value-of select="'\Theta '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x00398;')"/></xsl:call-template></xsl:when>	<!--/Theta capital Theta, Greek -->
+		<xsl:when test="starts-with($content,'&#x0039B;')"><xsl:value-of select="'\Lambda '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x0039B;')"/></xsl:call-template></xsl:when>	<!--/Lambda capital Lambda, Greek -->
+		<xsl:when test="starts-with($content,'&#x0039E;')"><xsl:value-of select="'\Xi '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x0039E;')"/></xsl:call-template></xsl:when>	<!--/Xi capital Xi, Greek -->
+		<xsl:when test="starts-with($content,'&#x003A0;')"><xsl:value-of select="'\Pi '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x003A0;')"/></xsl:call-template></xsl:when>	<!--/Pi capital Pi, Greek -->
+		<xsl:when test="starts-with($content,'&#x003A3;')"><xsl:value-of select="'\Sigma '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x003A3;')"/></xsl:call-template></xsl:when>	<!--/Sigma capital Sigma, Greek -->
+		<xsl:when test="starts-with($content,'&#x003A6;')"><xsl:value-of select="'\Phi '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x003A6;')"/></xsl:call-template></xsl:when>	<!--/Phi capital Phi, Greek -->
+		<xsl:when test="starts-with($content,'&#x003A8;')"><xsl:value-of select="'\Psi '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x003A8;')"/></xsl:call-template></xsl:when>	<!--/Psi capital Psi, Greek -->
+		<xsl:when test="starts-with($content,'&#x003A9;')"><xsl:value-of select="'\Omega '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x003A9;')"/></xsl:call-template></xsl:when>	<!--/Omega capital Omega, Greek -->
+		<xsl:when test="starts-with($content,'&#x003B1;')"><xsl:value-of select="'\alpha '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x003B1;')"/></xsl:call-template></xsl:when>	<!--/alpha small alpha, Greek -->
+		<xsl:when test="starts-with($content,'&#x003B2;')"><xsl:value-of select="'\beta '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x003B2;')"/></xsl:call-template></xsl:when>	<!--/beta small beta, Greek -->
+		<xsl:when test="starts-with($content,'&#x003B3;')"><xsl:value-of select="'\gamma '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x003B3;')"/></xsl:call-template></xsl:when>	<!--/gamma small gamma, Greek -->
+		<xsl:when test="starts-with($content,'&#x003B4;')"><xsl:value-of select="'\delta '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x003B4;')"/></xsl:call-template></xsl:when>	<!--/delta small delta, Greek -->
+		<xsl:when test="starts-with($content,'&#x003B5;')"><xsl:value-of select="'\epsilon '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x003B5;')"/></xsl:call-template></xsl:when>	<!--/straightepsilon, small epsilon, Greek -->
+		<xsl:when test="starts-with($content,'&#x003B6;')"><xsl:value-of select="'\zeta '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x003B6;')"/></xsl:call-template></xsl:when>	<!--/zeta small zeta, Greek -->
+		<xsl:when test="starts-with($content,'&#x003B7;')"><xsl:value-of select="'\eta '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x003B7;')"/></xsl:call-template></xsl:when>	<!--/eta small eta, Greek -->
+		<xsl:when test="starts-with($content,'&#x003B8;')"><xsl:value-of select="'\theta '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x003B8;')"/></xsl:call-template></xsl:when>	<!--/theta straight theta, small theta, Greek -->
+		<xsl:when test="starts-with($content,'&#x003B9;')"><xsl:value-of select="'\iota '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x003B9;')"/></xsl:call-template></xsl:when>	<!--/iota small iota, Greek -->
+		<xsl:when test="starts-with($content,'&#x003BA;')"><xsl:value-of select="'\kappa '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x003BA;')"/></xsl:call-template></xsl:when>	<!--/kappa small kappa, Greek -->
+		<xsl:when test="starts-with($content,'&#x003BB;')"><xsl:value-of select="'\lambda '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x003BB;')"/></xsl:call-template></xsl:when>	<!--/lambda small lambda, Greek -->
+		<xsl:when test="starts-with($content,'&#x003BC;')"><xsl:value-of select="'\mu '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x003BC;')"/></xsl:call-template></xsl:when>	<!--/mu small mu, Greek -->
+		<xsl:when test="starts-with($content,'&#x003BD;')"><xsl:value-of select="'\nu '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x003BD;')"/></xsl:call-template></xsl:when>	<!--/nu small nu, Greek -->
+		<xsl:when test="starts-with($content,'&#x003BE;')"><xsl:value-of select="'\xi '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x003BE;')"/></xsl:call-template></xsl:when>	<!--/xi small xi, Greek -->
+		<xsl:when test="starts-with($content,'&#x003C0;')"><xsl:value-of select="'\pi '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x003C0;')"/></xsl:call-template></xsl:when>	<!--/pi small pi, Greek -->
+		<xsl:when test="starts-with($content,'&#x003C1;')"><xsl:value-of select="'\rho '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x003C1;')"/></xsl:call-template></xsl:when>	<!--/rho small rho, Greek -->
+		<xsl:when test="starts-with($content,'&#x003C2;')"><xsl:value-of select="'\varsigma '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x003C2;')"/></xsl:call-template></xsl:when>	<!--/varsigma -->
+		<xsl:when test="starts-with($content,'&#x003C3;')"><xsl:value-of select="'\sigma '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x003C3;')"/></xsl:call-template></xsl:when>	<!--/sigma small sigma, Greek -->
+		<xsl:when test="starts-with($content,'&#x003C4;')"><xsl:value-of select="'\tau '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x003C4;')"/></xsl:call-template></xsl:when>	<!--/tau small tau, Greek -->
+		<xsl:when test="starts-with($content,'&#x003C5;')"><xsl:value-of select="'\upsilon '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x003C5;')"/></xsl:call-template></xsl:when>	<!--/upsilon small upsilon, Greek -->
+		<xsl:when test="starts-with($content,'&#x003C6;')"><xsl:value-of select="'\phi '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x003C6;')"/></xsl:call-template></xsl:when>	<!--/straightphi - small phi, Greek -->
+		<xsl:when test="starts-with($content,'&#x003C7;')"><xsl:value-of select="'\chi '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x003C7;')"/></xsl:call-template></xsl:when>	<!--/chi small chi, Greek -->
+		<xsl:when test="starts-with($content,'&#x003C8;')"><xsl:value-of select="'\psi '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x003C8;')"/></xsl:call-template></xsl:when>	<!--/psi small psi, Greek -->
+		<xsl:when test="starts-with($content,'&#x003C9;')"><xsl:value-of select="'\omega '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x003C9;')"/></xsl:call-template></xsl:when>	<!--/omega small omega, Greek -->
+		<xsl:when test="starts-with($content,'&#x003D1;')"><xsl:value-of select="'\vartheta '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x003D1;')"/></xsl:call-template></xsl:when>	<!--/vartheta - curly or open theta -->
+		<xsl:when test="starts-with($content,'&#x003D2;')"><xsl:value-of select="'\Upsilon '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x003D2;')"/></xsl:call-template></xsl:when>	<!--/Upsilon capital Upsilon, Greek -->
+		<xsl:when test="starts-with($content,'&#x003D5;')"><xsl:value-of select="'\varphi '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x003D5;')"/></xsl:call-template></xsl:when>	<!--/varphi - curly or open phi -->
+		<xsl:when test="starts-with($content,'&#x003D6;')"><xsl:value-of select="'\varpi '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x003D6;')"/></xsl:call-template></xsl:when>		<!--/varpi -->
+		<xsl:when test="starts-with($content,'&#x003F0;')"><xsl:value-of select="'\varkappa '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x003F0;')"/></xsl:call-template></xsl:when>	<!--/varkappa -->
+		<xsl:when test="starts-with($content,'&#x003F1;')"><xsl:value-of select="'\varrho '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x003F1;')"/></xsl:call-template></xsl:when>	<!--/varrho -->
+
+<!-- ====================================================================== -->
+		<xsl:when test="starts-with($content,'&#x0200B;')"><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x0200B;')"/></xsl:call-template></xsl:when>						<!--short form of  &InvisibleComma; -->
+		<xsl:when test="starts-with($content,'&#x02026;')"><xsl:value-of select="'\dots '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02026;')"/></xsl:call-template></xsl:when>
+		<xsl:when test="starts-with($content,'&#x02032;')"><xsl:value-of select="'\prime '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02032;')"/></xsl:call-template></xsl:when>		<!--/prime prime or minute -->
+		<xsl:when test="starts-with($content,'&#x02061;')"><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02061;')"/></xsl:call-template></xsl:when>						<!-- ApplyFunction -->
+		<xsl:when test="starts-with($content,'&#x02062;')"><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02062;')"/></xsl:call-template></xsl:when>						<!-- InvisibleTimes -->
+<!-- ====================================================================== -->
+<!-- 	Unicode 3.2
+	Letterlike Symbols
+	Range: 2100-214F
+	http://www.unicode.org/charts/PDF/U2100.pdf	                    -->
+<!-- ====================================================================== -->
+		<xsl:when test="starts-with($content,'&#x0210F;&#x0FE00;')"><xsl:value-of select="'\hbar '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x0210F;&#x0FE00;')"/></xsl:call-template></xsl:when>	<!--/hbar - Planck's over 2pi -->
+		<xsl:when test="starts-with($content,'&#x0210F;')"><xsl:value-of select="'\hslash '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x0210F;')"/></xsl:call-template></xsl:when>	<!--/hslash - variant Planck's over 2pi --> <!-- Required amssymb -->
+		<xsl:when test="starts-with($content,'&#x02111;')"><xsl:value-of select="'\Im '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02111;')"/></xsl:call-template></xsl:when>		<!--/Im - imaginary   -->
+		<xsl:when test="starts-with($content,'&#x02113;')"><xsl:value-of select="'\ell '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02113;')"/></xsl:call-template></xsl:when>		<!--/ell - cursive small l -->
+		<xsl:when test="starts-with($content,'&#x02118;')"><xsl:value-of select="'\wp '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02118;')"/></xsl:call-template></xsl:when>		<!--/wp - Weierstrass p -->
+		<xsl:when test="starts-with($content,'&#x0211C;')"><xsl:value-of select="'\Re '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x0211C;')"/></xsl:call-template></xsl:when>		<!--/Re - real -->
+		<xsl:when test="starts-with($content,'&#x02127;')"><xsl:value-of select="'\mho '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02127;')"/></xsl:call-template></xsl:when>		<!--/mho - conductance -->
+		<xsl:when test="starts-with($content,'&#x02135;')"><xsl:value-of select="'\aleph '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02135;')"/></xsl:call-template></xsl:when>		<!--/aleph aleph, Hebrew -->
+		<xsl:when test="starts-with($content,'&#x02136;')"><xsl:value-of select="'\beth '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02136;')"/></xsl:call-template></xsl:when>		<!--/beth - beth, Hebrew --> <!-- Required amssymb -->
+		<xsl:when test="starts-with($content,'&#x02137;')"><xsl:value-of select="'\gimel '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02137;')"/></xsl:call-template></xsl:when>		<!--/gimel - gimel, Hebrew --> <!-- Required amssymb -->
+		<xsl:when test="starts-with($content,'&#x02138;')"><xsl:value-of select="'\daleth '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02138;')"/></xsl:call-template></xsl:when>	<!--/daleth - daleth, Hebrew --> <!-- Required amssymb -->
+		<xsl:when test="starts-with($content,'&#x02145;')"><xsl:value-of select="'D'" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02145;')"/></xsl:call-template></xsl:when>		<!--D for use in differentials, e.g., within integrals -->
+		<xsl:when test="starts-with($content,'&#x02146;')"><xsl:value-of select="'d'" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02146;')"/></xsl:call-template></xsl:when>		<!--d for use in differentials, e.g., within integrals -->
+		<xsl:when test="starts-with($content,'&#x02147;')"><xsl:value-of select="'e'" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02147;')"/></xsl:call-template></xsl:when>		<!--e use for the exponential base of the natural logarithms -->
+		<xsl:when test="starts-with($content,'&#x02148;')"><xsl:value-of select="'i'" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02148;')"/></xsl:call-template></xsl:when>		<!--i for use as a square root of -1 -->
+
+<!-- ====================================================================== -->
+		<xsl:when test="starts-with($content,'&#x02192;')"><xsl:value-of select="'\to '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02192;')"/></xsl:call-template></xsl:when>		<!--/rightarrow /to A: =rightward arrow -->
+
+<!-- ====================================================================== -->
+<!-- 	Unicode 3.2
+	Mathematical Operators
+	Range: 2200-22FF
+	http://www.unicode.org/charts/PDF/U2200.pdf                         -->
+<!-- ====================================================================== -->
+		<xsl:when test="starts-with($content,'&#x02200;')"><xsl:value-of select="'\forall '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02200;')"/></xsl:call-template></xsl:when>	<!--/forall for all -->
+		<xsl:when test="starts-with($content,'&#x02201;')"><xsl:value-of select="'\complement '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02201;')"/></xsl:call-template></xsl:when>	<!--/complement - complement sign --> <!-- Required amssymb -->
+		<xsl:when test="starts-with($content,'&#x02202;')"><xsl:value-of select="'\partial '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02202;')"/></xsl:call-template></xsl:when>	<!--/partial partial differential -->
+		<xsl:when test="starts-with($content,'&#x02203;')"><xsl:value-of select="'\exists '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02203;')"/></xsl:call-template></xsl:when>	<!--/exists at least one exists -->
+		<xsl:when test="starts-with($content,'&#x02204;')"><xsl:value-of select="'\nexists '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02204;')"/></xsl:call-template></xsl:when>	<!--/nexists - negated exists --> <!-- Required amssymb -->
+		<xsl:when test="starts-with($content,'&#x02205;&#x0FE00;')"><xsl:value-of select="'\emptyset '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02205;&#x0FE00;')"/></xsl:call-template></xsl:when>	<!--/emptyset - zero, slash -->
+		<xsl:when test="starts-with($content,'&#x02205;')"><xsl:value-of select="'\varnothing '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02205;')"/></xsl:call-template></xsl:when>	<!--/varnothing - circle, slash --> <!-- Required amssymb -->
+<!--		<xsl:when test="starts-with($content,'&#x02206;')"><xsl:value-of select="' '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02206;')"/></xsl:call-template></xsl:when>-->
+		<xsl:when test="starts-with($content,'&#x02207;')"><xsl:value-of select="'\nabla '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02207;')"/></xsl:call-template></xsl:when>		<!--/nabla del, Hamilton operator -->
+		<xsl:when test="starts-with($content,'&#x02208;')"><xsl:value-of select="'\in '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02208;')"/></xsl:call-template></xsl:when>		<!--/in R: set membership  -->
+		<xsl:when test="starts-with($content,'&#x02209;')"><xsl:value-of select="'\notin '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02209;')"/></xsl:call-template></xsl:when>		<!--/notin N: negated set membership -->
+		<xsl:when test="starts-with($content,'&#x0220B;')"><xsl:value-of select="'\ni '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x0220B;')"/></xsl:call-template></xsl:when>		<!--/ni /owns R: contains -->
+		<xsl:when test="starts-with($content,'&#x0220C;')"><xsl:value-of select="'\not\ni '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x0220C;')"/></xsl:call-template></xsl:when>	<!--negated contains -->
+		<xsl:when test="starts-with($content,'&#x0220F;')"><xsl:value-of select="'\prod '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x0220F;')"/></xsl:call-template></xsl:when>		<!--/prod L: product operator -->
+		<xsl:when test="starts-with($content,'&#x02210;')"><xsl:value-of select="'\coprod '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02210;')"/></xsl:call-template></xsl:when>	<!--/coprod L: coproduct operator -->
+		<xsl:when test="starts-with($content,'&#x02211;')"><xsl:value-of select="'\sum '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02211;')"/></xsl:call-template></xsl:when>		<!--/sum L: summation operator -->
+		<xsl:when test="starts-with($content,'&#x02212;')"><xsl:value-of select="'-'" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02212;')"/></xsl:call-template></xsl:when>		<!--B: minus sign -->
+		<xsl:when test="starts-with($content,'&#x02213;')"><xsl:value-of select="'\mp '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02213;')"/></xsl:call-template></xsl:when>		<!--/mp B: minus-or-plus sign -->
+		<xsl:when test="starts-with($content,'&#x02214;')"><xsl:value-of select="'\dotplus '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02214;')"/></xsl:call-template></xsl:when>	<!--/dotplus B: plus sign, dot above --> <!-- Required amssymb -->
+<!--		<xsl:when test="starts-with($content,'&#x02215;')"><xsl:value-of select="' '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02215;')"/></xsl:call-template></xsl:when>-->
+		<xsl:when test="starts-with($content,'&#x02216;')"><xsl:value-of select="'\setminus '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02216;')"/></xsl:call-template></xsl:when>	<!--/setminus B: reverse solidus -->
+		<xsl:when test="starts-with($content,'&#x02217;')"><xsl:value-of select="'\ast '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02217;')"/></xsl:call-template></xsl:when>		<!--low asterisk -->
+		<xsl:when test="starts-with($content,'&#x02218;')"><xsl:value-of select="'\circ '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02218;')"/></xsl:call-template></xsl:when>		<!--/circ B: composite function (small circle) -->
+		<xsl:when test="starts-with($content,'&#x02219;')"><xsl:value-of select="'\bullet '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02219;')"/></xsl:call-template></xsl:when>
+		<xsl:when test="starts-with($content,'&#x0221A;')"><xsl:value-of select="'\surd '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x0221A;')"/></xsl:call-template></xsl:when>		<!--/surd radical -->
+		<xsl:when test="starts-with($content,'&#x0221D;')"><xsl:value-of select="'\propto '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x0221D;')"/></xsl:call-template></xsl:when>	<!--/propto R: is proportional to -->
+		<xsl:when test="starts-with($content,'&#x0221E;')"><xsl:value-of select="'\infty '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x0221E;')"/></xsl:call-template></xsl:when>		<!--/infty infinity -->
+<!--		<xsl:when test="starts-with($content,'&#x0221F;')"><xsl:value-of select="' '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x0221F;')"/></xsl:call-template></xsl:when>		right (90 degree) angle -->
+		<xsl:when test="starts-with($content,'&#x02220;')"><xsl:value-of select="'\angle '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02220;')"/></xsl:call-template></xsl:when>		<!--/angle - angle -->
+		<xsl:when test="starts-with($content,'&#x02221;')"><xsl:value-of select="'\measuredangle '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02221;')"/></xsl:call-template></xsl:when>	<!--/measuredangle - angle-measured -->	<!-- Required amssymb -->
+		<xsl:when test="starts-with($content,'&#x02222;')"><xsl:value-of select="'\sphericalangle '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02222;')"/></xsl:call-template></xsl:when><!--/sphericalangle angle-spherical -->	<!-- Required amssymb -->
+		<xsl:when test="starts-with($content,'&#x02223;')"><xsl:value-of select="'\mid '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02223;')"/></xsl:call-template></xsl:when>		<!--/mid R: -->
+		<xsl:when test="starts-with($content,'&#x02224;&#x0FE00;')"><xsl:value-of select="'\nshortmid '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02224;&#x0FE00;')"/></xsl:call-template></xsl:when>	<!--/nshortmid --> <!-- Required amssymb -->
+		<xsl:when test="starts-with($content,'&#x02224;')"><xsl:value-of select="'\nmid '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02224;')"/></xsl:call-template></xsl:when>		<!--/nmid --> <!-- Required amssymb -->
+		<xsl:when test="starts-with($content,'&#x02225;')"><xsl:value-of select="'\parallel '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02225;')"/></xsl:call-template></xsl:when>	<!--/parallel R: parallel -->
+		<xsl:when test="starts-with($content,'&#x02226;&#x0FE00;')"><xsl:value-of select="'\nshortparallel '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02226;&#x0FE00;')"/></xsl:call-template></xsl:when>	<!--/nshortparallel N: not short par --> <!-- Required amssymb -->
+		<xsl:when test="starts-with($content,'&#x02226;')"><xsl:value-of select="'\nparallel '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02226;')"/></xsl:call-template></xsl:when>	<!--/nparallel N: not parallel --> <!-- Required amssymb -->
+		<xsl:when test="starts-with($content,'&#x02227;')"><xsl:value-of select="'\wedge '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02227;')"/></xsl:call-template></xsl:when>		<!--/wedge /land B: logical and -->
+		<xsl:when test="starts-with($content,'&#x02228;')"><xsl:value-of select="'\vee '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02228;')"/></xsl:call-template></xsl:when>		<!--/vee /lor B: logical or -->
+		<xsl:when test="starts-with($content,'&#x02229;')"><xsl:value-of select="'\cap '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02229;')"/></xsl:call-template></xsl:when>		<!--/cap B: intersection -->
+		<xsl:when test="starts-with($content,'&#x0222A;')"><xsl:value-of select="'\cup '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x0222A;')"/></xsl:call-template></xsl:when>		<!--/cup B: union or logical sum -->
+		<xsl:when test="starts-with($content,'&#x0222B;')"><xsl:value-of select="'\int '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x0222B;')"/></xsl:call-template></xsl:when>		<!--/int L: integral operator -->
+		<xsl:when test="starts-with($content,'&#x0222C;')"><xsl:value-of select="'\iint '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x0222C;')"/></xsl:call-template></xsl:when>		<!--double integral operator --> <!-- Required amsmath -->
+		<xsl:when test="starts-with($content,'&#x0222D;')"><xsl:value-of select="'\iiint '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x0222D;')"/></xsl:call-template></xsl:when>		<!--/iiint triple integral operator -->	<!-- Required amsmath -->
+		<xsl:when test="starts-with($content,'&#x0222E;')"><xsl:value-of select="'\oint '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x0222E;')"/></xsl:call-template></xsl:when>		<!--/oint L: contour integral operator -->
+<!--		<xsl:when test="starts-with($content,'&#x0222F;')"><xsl:value-of select="' '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x0222F;')"/></xsl:call-template></xsl:when>-->
+<!--		<xsl:when test="starts-with($content,'&#x02230;')"><xsl:value-of select="' '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02230;')"/></xsl:call-template></xsl:when>-->
+<!--		<xsl:when test="starts-with($content,'&#x02231;')"><xsl:value-of select="' '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02231;')"/></xsl:call-template></xsl:when>-->
+<!--		<xsl:when test="starts-with($content,'&#x02232;')"><xsl:value-of select="' '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02232;')"/></xsl:call-template></xsl:when>-->
+<!--		<xsl:when test="starts-with($content,'&#x02233;')"><xsl:value-of select="' '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02233;')"/></xsl:call-template></xsl:when>-->
+		<xsl:when test="starts-with($content,'&#x02234;')"><xsl:value-of select="'\therefore '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02234;')"/></xsl:call-template></xsl:when>	<!--/therefore R: therefore --> <!-- Required amssymb -->
+		<xsl:when test="starts-with($content,'&#x02235;')"><xsl:value-of select="'\because '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02235;')"/></xsl:call-template></xsl:when>	<!--/because R: because --> <!-- Required amssymb -->
+<!-- ? -->	<xsl:when test="starts-with($content,'&#x02236;')"><xsl:value-of select="':'" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02236;')"/></xsl:call-template></xsl:when>		<!--/ratio -->
+<!-- ? -->	<xsl:when test="starts-with($content,'&#x02237;')"><xsl:value-of select="'\colon\colon '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02237;')"/></xsl:call-template></xsl:when>	<!--/Colon, two colons -->
+<!-- ? -->	<xsl:when test="starts-with($content,'&#x02238;')"><xsl:value-of select="'\dot{-}'" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02238;')"/></xsl:call-template></xsl:when>		<!--/dotminus B: minus sign, dot above -->
+<!--		<xsl:when test="starts-with($content,'&#x02239;')"><xsl:value-of select="' '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02239;')"/></xsl:call-template></xsl:when>		-->
+<!--		<xsl:when test="starts-with($content,'&#x0223A;')"><xsl:value-of select="' '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x0223A;')"/></xsl:call-template></xsl:when>		minus with four dots, geometric properties -->
+<!--		<xsl:when test="starts-with($content,'&#x0223B;')"><xsl:value-of select="' '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x0223B;')"/></xsl:call-template></xsl:when>		homothetic -->
+		<xsl:when test="starts-with($content,'&#x0223C;')"><xsl:value-of select="'\sim '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x0223C;')"/></xsl:call-template></xsl:when>		<!--/sim R: similar -->
+		<xsl:when test="starts-with($content,'&#x0223D;')"><xsl:value-of select="'\backsim '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x0223D;')"/></xsl:call-template></xsl:when>	<!--/backsim R: reverse similar --> <!-- Required amssymb -->
+<!--		<xsl:when test="starts-with($content,'&#x0223E;')"><xsl:value-of select="' '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x0223E;')"/></xsl:call-template></xsl:when>		most positive -->
+<!--		<xsl:when test="starts-with($content,'&#x0223F;')"><xsl:value-of select="' '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x0223F;')"/></xsl:call-template></xsl:when>		ac current -->
+		<xsl:when test="starts-with($content,'&#x02240;')"><xsl:value-of select="'\wr '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02240;')"/></xsl:call-template></xsl:when>		<!--/wr B: wreath product -->
+		<xsl:when test="starts-with($content,'&#x02241;')"><xsl:value-of select="'\nsim '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02241;')"/></xsl:call-template></xsl:when>		<!--/nsim N: not similar --> <!-- Required amssymb -->
+		<xsl:when test="starts-with($content,'&#x02242;')"><xsl:value-of select="'\eqsim '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02242;')"/></xsl:call-template></xsl:when>		<!--/esim R: equals, similar --> <!-- Required amssymb -->
+		<xsl:when test="starts-with($content,'&#x02243;')"><xsl:value-of select="'\simeq '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02243;')"/></xsl:call-template></xsl:when>		<!--/simeq R: similar, equals -->
+		<xsl:when test="starts-with($content,'&#x02244;')"><xsl:value-of select="'\not\simeq '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02244;')"/></xsl:call-template></xsl:when>	<!--/nsimeq N: not similar, equals -->
+		<xsl:when test="starts-with($content,'&#x02245;')"><xsl:value-of select="'\cong '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02245;')"/></xsl:call-template></xsl:when>		<!--/cong R: congruent with -->
+<!--		<xsl:when test="starts-with($content,'&#x02246;')"><xsl:value-of select="' '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02246;')"/></xsl:call-template></xsl:when>		similar, not equals -->
+		<xsl:when test="starts-with($content,'&#x02247;')"><xsl:value-of select="'\ncong '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02247;')"/></xsl:call-template></xsl:when>		<!--/ncong N: not congruent with --> <!-- Required amssymb -->
+		<xsl:when test="starts-with($content,'&#x02248;')"><xsl:value-of select="'\approx '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02248;')"/></xsl:call-template></xsl:when>	<!--/approx R: approximate -->
+<!--		<xsl:when test="starts-with($content,'&#x02249;&#x00338;')"><xsl:value-of select="' '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02249;&#x00338;')"/></xsl:call-template></xsl:when>	not, vert, approximate -->
+		<xsl:when test="starts-with($content,'&#x02249;')"><xsl:value-of select="'\not\approx '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02249;')"/></xsl:call-template></xsl:when>	<!--/napprox N: not approximate -->
+		<xsl:when test="starts-with($content,'&#x0224A;')"><xsl:value-of select="'\approxeq '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x0224A;')"/></xsl:call-template></xsl:when>	<!--/approxeq R: approximate, equals --> <!-- Required amssymb -->
+<!--		<xsl:when test="starts-with($content,'&#x0224B;')"><xsl:value-of select="' '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x0224B;')"/></xsl:call-template></xsl:when>		approximately identical to -->
+<!--		<xsl:when test="starts-with($content,'&#x0224C;')"><xsl:value-of select="' '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x0224C;')"/></xsl:call-template></xsl:when>		/backcong R: reverse congruent -->
+		<xsl:when test="starts-with($content,'&#x0224D;')"><xsl:value-of select="'\asymp '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x0224D;')"/></xsl:call-template></xsl:when>		<!--/asymp R: asymptotically equal to -->
+		<xsl:when test="starts-with($content,'&#x0224E;')"><xsl:value-of select="'\Bumpeq '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x0224E;')"/></xsl:call-template></xsl:when>	<!--/Bumpeq R: bumpy equals --> <!-- Required amssymb -->
+		<xsl:when test="starts-with($content,'&#x0224F;')"><xsl:value-of select="'\bumpeq '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x0224F;')"/></xsl:call-template></xsl:when>	<!--/bumpeq R: bumpy equals, equals --> <!-- Required amssymb -->
+		<xsl:when test="starts-with($content,'&#x02250;')"><xsl:value-of select="'\doteq '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02250;')"/></xsl:call-template></xsl:when>		<!--/doteq R: equals, single dot above -->
+		<xsl:when test="starts-with($content,'&#x02251;')"><xsl:value-of select="'\doteqdot '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02251;')"/></xsl:call-template></xsl:when>	<!--/doteqdot /Doteq R: eq, even dots --> <!-- Required amssymb -->
+		<xsl:when test="starts-with($content,'&#x02252;')"><xsl:value-of select="'\fallingdotseq '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02252;')"/></xsl:call-template></xsl:when>	<!--/fallingdotseq R: eq, falling dots --> <!-- Required amssymb -->
+		<xsl:when test="starts-with($content,'&#x02253;')"><xsl:value-of select="'\risingdotseq '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02253;')"/></xsl:call-template></xsl:when>	<!--/risingdotseq R: eq, rising dots --> <!-- Required amssymb -->
+<!--		<xsl:when test="starts-with($content,'&#x02254;')"><xsl:value-of select="' '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02254;')"/></xsl:call-template></xsl:when>		/coloneq R: colon, equals -->
+<!--		<xsl:when test="starts-with($content,'&#x02255;')"><xsl:value-of select="' '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02255;')"/></xsl:call-template></xsl:when>		/eqcolon R: equals, colon -->
+		<xsl:when test="starts-with($content,'&#x02256;')"><xsl:value-of select="'\eqcirc '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02256;')"/></xsl:call-template></xsl:when>	<!--/eqcirc R: circle on equals sign --> <!-- Required amssymb -->
+		<xsl:when test="starts-with($content,'&#x02257;')"><xsl:value-of select="'\circeq '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02257;')"/></xsl:call-template></xsl:when>	<!--/circeq R: circle, equals --> <!-- Required amssymb -->
+<!-- ? -->	<xsl:when test="starts-with($content,'&#x02258;')"><xsl:value-of select="'\stackrel{\frown}{=}'" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02258;')"/></xsl:call-template></xsl:when>
+<!-- ? -->	<xsl:when test="starts-with($content,'&#x02259;')"><xsl:value-of select="'\stackrel{\wedge}{=}'" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02259;')"/></xsl:call-template></xsl:when>	<!--/wedgeq R: corresponds to (wedge, equals) -->
+<!-- ? -->	<xsl:when test="starts-with($content,'&#x0225A;')"><xsl:value-of select="'\stackrel{\vee}{=}'" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x0225A;')"/></xsl:call-template></xsl:when>	<!--logical or, equals -->
+<!-- ? -->	<xsl:when test="starts-with($content,'&#x0225B;')"><xsl:value-of select="'\stackrel{\star}{=}'" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x0225B;')"/></xsl:call-template></xsl:when>	<!--equal, asterisk above -->
+		<xsl:when test="starts-with($content,'&#x0225C;')"><xsl:value-of select="'\triangleq '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x0225C;')"/></xsl:call-template></xsl:when>	<!--/triangleq R: triangle, equals --> <!-- Required amssymb -->
+<!-- ? -->	<xsl:when test="starts-with($content,'&#x0225D;')"><xsl:value-of select="'\stackrel{\scriptscriptstyle\mathrm{def}}{=}'" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x0225D;')"/></xsl:call-template></xsl:when>
+<!-- ? -->	<xsl:when test="starts-with($content,'&#x0225E;')"><xsl:value-of select="'\stackrel{\scriptscriptstyle\mathrm{m}}{=}'" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x0225E;')"/></xsl:call-template></xsl:when>
+<!-- ? -->	<xsl:when test="starts-with($content,'&#x0225F;')"><xsl:value-of select="'\stackrel{?}{=}'" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x0225F;')"/></xsl:call-template></xsl:when>	<!--/questeq R: equal with questionmark -->
+<!--		<xsl:when test="starts-with($content,'&#x02260;&#x0FE00;')"><xsl:value-of select="' '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02260;&#x0FE00;')"/></xsl:call-template></xsl:when>	not equal, dot -->
+		<xsl:when test="starts-with($content,'&#x02260;')"><xsl:value-of select="'\ne '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02260;')"/></xsl:call-template></xsl:when>		<!--/ne /neq R: not equal -->
+<!--		<xsl:when test="starts-with($content,'&#x02261;&#x020E5;')"><xsl:value-of select="' '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02261;&#x020E5;')"/></xsl:call-template></xsl:when>	reverse not equivalent -->
+		<xsl:when test="starts-with($content,'&#x02261;')"><xsl:value-of select="'\equiv '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02261;')"/></xsl:call-template></xsl:when>		<!--/equiv R: identical with -->
+		<xsl:when test="starts-with($content,'&#x02262;')"><xsl:value-of select="'\not\equiv '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02262;')"/></xsl:call-template></xsl:when>	<!--/nequiv N: not identical with -->
+<!--		<xsl:when test="starts-with($content,'&#x02263;')"><xsl:value-of select="' '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02263;')"/></xsl:call-template></xsl:when>		-->
+		<xsl:when test="starts-with($content,'&#x02264;')"><xsl:value-of select="'\le '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02264;')"/></xsl:call-template></xsl:when>		<!--/leq /le R: less-than-or-equal -->
+		<xsl:when test="starts-with($content,'&#x02265;')"><xsl:value-of select="'\ge '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02265;')"/></xsl:call-template></xsl:when>		<!--/geq /ge R: greater-than-or-equal -->
+		<xsl:when test="starts-with($content,'&#x02266;')"><xsl:value-of select="'\leqq '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02266;')"/></xsl:call-template></xsl:when>		<!--/leqq R: less, double equals --> <!-- Required amssymb -->
+		<xsl:when test="starts-with($content,'&#x02267;')"><xsl:value-of select="'\geqq '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02267;')"/></xsl:call-template></xsl:when>		<!--/geqq R: greater, double equals --> <!-- Required amssymb -->
+		<xsl:when test="starts-with($content,'&#x02268;')"><xsl:value-of select="'\lneqq '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02268;')"/></xsl:call-template></xsl:when>		<!--/lneqq N: less, not double equals --> <!-- Required amssymb -->
+		<xsl:when test="starts-with($content,'&#x02269;')"><xsl:value-of select="'\gneqq '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02269;')"/></xsl:call-template></xsl:when>		<!--/gneqq N: greater, not dbl equals --> <!-- Required amssymb -->
+<!--		<xsl:when test="starts-with($content,'&#x0226A;&#x00338;&#x0FE00;')"><xsl:value-of select="' '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x0226A;&#x00338;&#x0FE00;')"/></xsl:call-template></xsl:when>	not much less than, variant -->
+<!--		<xsl:when test="starts-with($content,'&#x0226A;&#x00338;')"><xsl:value-of select="' '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x0226A;&#x00338;')"/></xsl:call-template></xsl:when>	not, vert, much less than -->
+		<xsl:when test="starts-with($content,'&#x0226A;')"><xsl:value-of select="'\ll '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x0226A;')"/></xsl:call-template></xsl:when>		<!--/ll R: double less-than sign -->
+<!--		<xsl:when test="starts-with($content,'&#x0226B;&#x00338;&#x0FE00;')"><xsl:value-of select="' '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x0226B;&#x00338;&#x0FE00;')"/></xsl:call-template></xsl:when>	not much greater than, variant -->
+<!--		<xsl:when test="starts-with($content,'&#x0226B;&#x00338;')"><xsl:value-of select="' '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x0226B;&#x00338;')"/></xsl:call-template></xsl:when>	not, vert, much greater than -->
+		<xsl:when test="starts-with($content,'&#x0226B;')"><xsl:value-of select="'\gg '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x0226B;')"/></xsl:call-template></xsl:when>		<!--/gg R: dbl greater-than sign -->
+		<xsl:when test="starts-with($content,'&#x0226C;')"><xsl:value-of select="'\between '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x0226C;')"/></xsl:call-template></xsl:when>	<!--/between R: between --> <!-- Required amssymb -->
+		<xsl:when test="starts-with($content,'&#x0226D;')"><xsl:value-of select="'\not\asymp '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x0226D;')"/></xsl:call-template></xsl:when>
+		<xsl:when test="starts-with($content,'&#x0226E;')"><xsl:value-of select="'\nless '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x0226E;')"/></xsl:call-template></xsl:when>		<!--/nless N: not less-than --> <!-- Required amssymb -->
+		<xsl:when test="starts-with($content,'&#x0226F;')"><xsl:value-of select="'\ngtr '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x0226F;')"/></xsl:call-template></xsl:when>		<!--/ngtr N: not greater-than --> <!-- Required amssymb -->
+		<xsl:when test="starts-with($content,'&#x02270;&#x020E5;')"><xsl:value-of select="'\nleq '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02270;&#x020E5;')"/></xsl:call-template></xsl:when>	<!--/nleq N: not less-than-or-equal --> <!-- Required amssymb -->
+		<xsl:when test="starts-with($content,'&#x02270;')"><xsl:value-of select="'\nleqq '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02270;')"/></xsl:call-template></xsl:when>		<!--/nleqq N: not less, dbl equals --> <!-- Required amssymb -->
+		<xsl:when test="starts-with($content,'&#x02271;&#x020E5;')"><xsl:value-of select="'\ngeq '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02271;&#x020E5;')"/></xsl:call-template></xsl:when>	<!--/ngeq N: not greater-than-or-equal --> <!-- Required amssymb -->
+		<xsl:when test="starts-with($content,'&#x02271;')"><xsl:value-of select="'\ngeqq '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02271;')"/></xsl:call-template></xsl:when>		<!--/ngeqq N: not greater, dbl equals --> <!-- Required amssymb -->
+		<xsl:when test="starts-with($content,'&#x02272;')"><xsl:value-of select="'\lesssim '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02272;')"/></xsl:call-template></xsl:when>	<!--/lesssim R: less, similar --> <!-- Required amssymb -->
+		<xsl:when test="starts-with($content,'&#x02273;')"><xsl:value-of select="'\gtrsim '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02273;')"/></xsl:call-template></xsl:when>	<!--/gtrsim R: greater, similar --> <!-- Required amssymb -->
+		<xsl:when test="starts-with($content,'&#x02274;')"><xsl:value-of select="'\not\lesssim '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02274;')"/></xsl:call-template></xsl:when>	<!--not less, similar --> <!-- Required amssymb -->
+		<xsl:when test="starts-with($content,'&#x02275;')"><xsl:value-of select="'\not\gtrsim '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02275;')"/></xsl:call-template></xsl:when>	<!--not greater, similar --> <!-- Required amssymb -->
+		<xsl:when test="starts-with($content,'&#x02276;')"><xsl:value-of select="'\lessgtr '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02276;')"/></xsl:call-template></xsl:when>	<!--/lessgtr R: less, greater --> <!-- Required amssymb -->
+		<xsl:when test="starts-with($content,'&#x02277;')"><xsl:value-of select="'\gtrless '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02277;')"/></xsl:call-template></xsl:when>	<!--/gtrless R: greater, less --> <!-- Required amssymb -->
+		<xsl:when test="starts-with($content,'&#x02278;')"><xsl:value-of select="'\not\lessgtr '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02278;')"/></xsl:call-template></xsl:when>	<!--not less, greater --> <!-- Required amssymb -->
+		<xsl:when test="starts-with($content,'&#x02279;')"><xsl:value-of select="'\not\gtrless '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02279;')"/></xsl:call-template></xsl:when>	<!--not greater, less --> <!-- Required amssymb -->
+		<xsl:when test="starts-with($content,'&#x0227A;')"><xsl:value-of select="'\prec '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x0227A;')"/></xsl:call-template></xsl:when>		<!--/prec R: precedes -->
+		<xsl:when test="starts-with($content,'&#x0227B;')"><xsl:value-of select="'\succ '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x0227B;')"/></xsl:call-template></xsl:when>		<!--/succ R: succeeds -->
+		<xsl:when test="starts-with($content,'&#x0227C;')"><xsl:value-of select="'\preccurlyeq '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x0227C;')"/></xsl:call-template></xsl:when>	<!--/preccurlyeq R: precedes, curly eq --> <!-- Required amssymb -->
+		<xsl:when test="starts-with($content,'&#x0227D;')"><xsl:value-of select="'\succcurlyeq '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x0227D;')"/></xsl:call-template></xsl:when>	<!--/succcurlyeq R: succeeds, curly eq --> <!-- Required amssymb -->
+		<xsl:when test="starts-with($content,'&#x0227E;')"><xsl:value-of select="'\precsim '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x0227E;')"/></xsl:call-template></xsl:when>	<!--/precsim R: precedes, similar --> <!-- Required amssymb -->
+		<xsl:when test="starts-with($content,'&#x0227F;')"><xsl:value-of select="'\succsim '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x0227F;')"/></xsl:call-template></xsl:when>	<!--/succsim R: succeeds, similar --> <!-- Required amssymb -->
+		<xsl:when test="starts-with($content,'&#x02280;')"><xsl:value-of select="'\nprec '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02280;')"/></xsl:call-template></xsl:when>		<!--/nprec N: not precedes --> <!-- Required amssymb -->
+		<xsl:when test="starts-with($content,'&#x02281;')"><xsl:value-of select="'\nsucc '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02281;')"/></xsl:call-template></xsl:when>		<!--/nsucc N: not succeeds --> <!-- Required amssymb -->
+		<xsl:when test="starts-with($content,'&#x02282;')"><xsl:value-of select="'\subset '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02282;')"/></xsl:call-template></xsl:when>	<!--/subset R: subset or is implied by -->
+		<xsl:when test="starts-with($content,'&#x02283;')"><xsl:value-of select="'\supset '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02283;')"/></xsl:call-template></xsl:when>	<!--/supset R: superset or implies -->
+		<xsl:when test="starts-with($content,'&#x02284;')"><xsl:value-of select="'\not\subset '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02284;')"/></xsl:call-template></xsl:when>	<!--not subset -->
+		<xsl:when test="starts-with($content,'&#x02285;')"><xsl:value-of select="'\not\supset '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02285;')"/></xsl:call-template></xsl:when>	<!--not superset -->
+		<xsl:when test="starts-with($content,'&#x02286;')"><xsl:value-of select="'\subseteq '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02286;')"/></xsl:call-template></xsl:when>	<!--/subseteq R: subset, equals -->
+		<xsl:when test="starts-with($content,'&#x02287;')"><xsl:value-of select="'\supseteq '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02287;')"/></xsl:call-template></xsl:when>	<!--/supseteq R: superset, equals -->
+		<xsl:when test="starts-with($content,'&#x0228E;')"><xsl:value-of select="'\uplus '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x0228E;')"/></xsl:call-template></xsl:when>		<!--/uplus B: plus sign in union -->
+		<xsl:when test="starts-with($content,'&#x02293;')"><xsl:value-of select="'\sqcap '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02293;')"/></xsl:call-template></xsl:when>		<!--/sqcap B: square intersection -->
+		<xsl:when test="starts-with($content,'&#x02294;')"><xsl:value-of select="'\bigsqcup '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02294;')"/></xsl:call-template></xsl:when>		<!--/sqcup B: square union -->
+		<xsl:when test="starts-with($content,'&#x02295;')"><xsl:value-of select="'\oplus '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02295;')"/></xsl:call-template></xsl:when>		<!--/oplus B: plus sign in circle -->
+		<xsl:when test="starts-with($content,'&#x02296;')"><xsl:value-of select="'\ominus '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02296;')"/></xsl:call-template></xsl:when>	<!--/ominus B: minus sign in circle -->
+		<xsl:when test="starts-with($content,'&#x02297;')"><xsl:value-of select="'\otimes '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02297;')"/></xsl:call-template></xsl:when>	<!--/otimes B: multiply sign in circle -->
+		<xsl:when test="starts-with($content,'&#x02298;')"><xsl:value-of select="'\oslash '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02298;')"/></xsl:call-template></xsl:when>	<!--/oslash B: solidus in circle -->
+<!-- ? -->	<xsl:when test="starts-with($content,'&#x02299;')"><xsl:value-of select="'\odot '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02299;')"/></xsl:call-template></xsl:when>		<!--/odot B: middle dot in circle --> <!--/bigodot L: circle dot operator -->
+		<xsl:when test="starts-with($content,'&#x0229F;')"><xsl:value-of select="'\boxminus '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x0229F;')"/></xsl:call-template></xsl:when>	<!--/boxminus B: minus sign in box --> <!-- Required amssymb -->
+		<xsl:when test="starts-with($content,'&#x022A4;')"><xsl:value-of select="'\top '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x022A4;')"/></xsl:call-template></xsl:when>		<!--/top top -->
+		<xsl:when test="starts-with($content,'&#x022A5;')"><xsl:value-of select="'\perp '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x022A5;')"/></xsl:call-template></xsl:when>		<!--/perp R: perpendicular --><!--/bot bottom -->
+		<xsl:when test="starts-with($content,'&#x022A6;')"><xsl:value-of select="'\vdash '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x022A6;')"/></xsl:call-template></xsl:when>		<!--/vdash R: vertical, dash -->
+		<xsl:when test="starts-with($content,'&#x022A7;')"><xsl:value-of select="'\vDash '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x022A7;')"/></xsl:call-template></xsl:when>		<!--/vDash R: vertical, dbl dash --> <!-- Required amssymb -->
+		<xsl:when test="starts-with($content,'&#x022A8;')"><xsl:value-of select="'\models '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x022A8;')"/></xsl:call-template></xsl:when>	<!--/models R: -->
+		<xsl:when test="starts-with($content,'&#x022AA;')"><xsl:value-of select="'\Vvdash '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x022AA;')"/></xsl:call-template></xsl:when>	<!--/Vvdash R: triple vertical, dash --> <!-- Required amssymb -->
+		<xsl:when test="starts-with($content,'&#x022C0;')"><xsl:value-of select="'\bigwedge '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x022C0;')"/></xsl:call-template></xsl:when>	<!--/bigwedge L: logical or operator -->
+		<xsl:when test="starts-with($content,'&#x022C1;')"><xsl:value-of select="'\bigvee '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x022C1;')"/></xsl:call-template></xsl:when>	<!--/bigcap L: intersection operator -->
+		<xsl:when test="starts-with($content,'&#x022C2;')"><xsl:value-of select="'\bigcap '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x022C2;')"/></xsl:call-template></xsl:when>	<!--/bigvee L: logical and operator -->
+		<xsl:when test="starts-with($content,'&#x022C3;')"><xsl:value-of select="'\bigcup '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x022C3;')"/></xsl:call-template></xsl:when>	<!--/bigcup L: union operator -->
+		<xsl:when test="starts-with($content,'&#x022C4;')"><xsl:value-of select="'\diamond '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x022C4;')"/></xsl:call-template></xsl:when>	<!--/diamond B: open diamond -->
+		<xsl:when test="starts-with($content,'&#x022C5;')"><xsl:value-of select="'\cdot '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x022C5;')"/></xsl:call-template></xsl:when>		<!--/cdot B: small middle dot -->
+		<xsl:when test="starts-with($content,'&#x022C6;')"><xsl:value-of select="'\star '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x022C6;')"/></xsl:call-template></xsl:when>		<!--/star B: small star, filled -->
+		<xsl:when test="starts-with($content,'&#x022C7;')"><xsl:value-of select="'\divideontimes '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x022C7;')"/></xsl:call-template></xsl:when>	<!--/divideontimes B: division on times --> <!-- Required amssymb -->
+		<xsl:when test="starts-with($content,'&#x022C8;')"><xsl:value-of select="'\bowtie '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x022C8;')"/></xsl:call-template></xsl:when>	<!--/bowtie R: -->
+		<xsl:when test="starts-with($content,'&#x022CD;')"><xsl:value-of select="'\backsimeq '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x022CD;')"/></xsl:call-template></xsl:when>	<!--/backsimeq R: reverse similar, eq --> <!-- Required amssymb -->
+		<xsl:when test="starts-with($content,'&#x022EF;')"><xsl:value-of select="'\cdots '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x022EF;')"/></xsl:call-template></xsl:when>		<!--/cdots, three dots, centered -->
+<!--		<xsl:when test="starts-with($content,'&#x022F0;')"><xsl:value-of select="' '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x022F0;')"/></xsl:call-template></xsl:when>		three dots, ascending -->
+		<xsl:when test="starts-with($content,'&#x022F1;')"><xsl:value-of select="'\ddots '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x022F1;')"/></xsl:call-template></xsl:when>		<!--/ddots, three dots, descending -->
+
+<!-- ====================================================================== -->
+		<xsl:when test="starts-with($content,'&#x025A1;')"><xsl:value-of select="'\square '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x025A1;')"/></xsl:call-template></xsl:when>	<!--/square, square --> <!-- Required amssymb -->
+		<xsl:when test="starts-with($content,'&#x025AA;')"><xsl:value-of select="'\blacksquare '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x025AA;')"/></xsl:call-template></xsl:when>	<!--/blacksquare, square, filled  --> <!-- Required amssymb -->
+
+		<xsl:when test='starts-with($content,"&apos;")'><xsl:value-of select='"\text{&apos;}"' /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select='substring-after($content, "&apos;")'/></xsl:call-template></xsl:when><!-- \text required amslatex -->
+		<xsl:when test='starts-with($content,"(")'><xsl:value-of select='"\left("' /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '(')"/></xsl:call-template></xsl:when>
+		<xsl:when test='starts-with($content,")")'><xsl:value-of select='"\right)"' /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, ')')"/></xsl:call-template></xsl:when>
+		<xsl:when test='starts-with($content,"[")'><xsl:value-of select='"\left["' /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '[')"/></xsl:call-template></xsl:when>
+		<xsl:when test='starts-with($content,"]")'><xsl:value-of select='"\right]"' /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, ']')"/></xsl:call-template></xsl:when>
+		<xsl:when test='starts-with($content,"{")'><xsl:value-of select='"\left\{"' /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '{')"/></xsl:call-template></xsl:when>
+		<xsl:when test='starts-with($content,"}")'><xsl:value-of select='"\right\}"' /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '}')"/></xsl:call-template></xsl:when>
+
+
+		<xsl:otherwise>
+			<xsl:value-of select="substring($content,1,1)"/>
+			<xsl:call-template name="replaceEntities">
+				<xsl:with-param name="content" select="substring($content, 2)"/>
+			</xsl:call-template>
+		</xsl:otherwise>
+	</xsl:choose></xsl:if>
+</xsl:template>
+
+<xsl:template name="replaceMtextEntities">
+	<xsl:param name="content"/>
+	<xsl:choose>
+	<xsl:when test="contains($content,'&#x02009;&#x0200A;&#x0200A;')">	<!-- ThickSpace - space of width 5/18 em -->
+		<xsl:call-template name="replaceMtextEntities">
+			<xsl:with-param name="content" select="concat(substring-before($content,'&#x02009;&#x0200A;&#x0200A;'),'\hspace{0.28em}',substring-after($content,'&#x02009;&#x0200A;&#x0200A;'))"/>
+		</xsl:call-template>
+	</xsl:when>
+	<xsl:when test="contains($content,'&#x02009;')">	<!-- ThinSpace - space of width 3/18 em -->
+		<xsl:call-template name="replaceMtextEntities">
+			<xsl:with-param name="content" select="concat(substring-before($content,'&#x02009;'),'\hspace{0.17em}',substring-after($content,'&#x02009;'))"/>
+		</xsl:call-template>
+	</xsl:when>
+	<xsl:otherwise>
+		<xsl:value-of select="normalize-space($content)"/>
+	</xsl:otherwise>
+	</xsl:choose>
+</xsl:template>
+
+
+<!-- ====================================================================== -->
+<!-- $id: tables.xsl, 2002/17/05 Exp $
+     This file is part of the XSLT MathML Library distribution.
+     See ./README or http://www.raleigh.ru/MathML/mmltex for
+     copyright and other information                                        -->
+<!-- ====================================================================== -->
+
+<xsl:template match="m:mtd[@columnspan]">
+	<xsl:text>\multicolumn{</xsl:text>
+	<xsl:value-of select="@columnspan"/>
+	<xsl:text>}{c}{</xsl:text>
+	<xsl:apply-templates/>
+	<xsl:text>}</xsl:text>
+	<xsl:if test="count(following-sibling::*)>0">
+		<xsl:text>&amp; </xsl:text>
+	</xsl:if>
+</xsl:template>
+
+
+<xsl:template match="m:mtd">
+	<xsl:if test="@columnalign='right' or @columnalign='center'">
+		<xsl:text>\hfill </xsl:text>
+	</xsl:if>
+	<xsl:apply-templates/>
+	<xsl:if test="@columnalign='left' or @columnalign='center'">
+		<xsl:text>\hfill </xsl:text>
+	</xsl:if>
+	<xsl:if test="count(following-sibling::*)>0">
+<!--    this test valid for Sablotron, another form - test="not(position()=last())".
+	Also for m:mtd[@columnspan] and m:mtr  -->
+		<xsl:text>&amp; </xsl:text>
+	</xsl:if>
+</xsl:template>
+
+<xsl:template match="m:mtr">
+	<xsl:apply-templates/>
+	<xsl:if test="count(following-sibling::*)>0">
+		<xsl:text>\\ </xsl:text>
+	</xsl:if>
+</xsl:template>
+
+<xsl:template match="m:mtable">
+	<xsl:text>\begin{array}{</xsl:text>
+	<xsl:if test="@frame='solid'">
+		<xsl:text>|</xsl:text>
+	</xsl:if>
+	<xsl:variable name="numbercols" select="count(./m:mtr[1]/m:mtd[not(@columnspan)])+sum(./m:mtr[1]/m:mtd/@columnspan)"/>
+	<xsl:choose>
+		<xsl:when test="@columnalign">
+			<xsl:variable name="colalign">
+				<xsl:call-template name="colalign">
+					<xsl:with-param name="colalign" select="@columnalign"/>
+				</xsl:call-template>
+			</xsl:variable>
+			<xsl:choose>
+				<xsl:when test="string-length($colalign) > $numbercols">
+					<xsl:value-of select="substring($colalign,1,$numbercols)"/>
+				</xsl:when>
+				<xsl:when test="string-length($colalign) &lt; $numbercols">
+					<xsl:value-of select="$colalign"/>
+					<xsl:call-template name="generate-string">
+						<xsl:with-param name="text" select="substring($colalign,string-length($colalign))"/>
+						<xsl:with-param name="count" select="$numbercols - string-length($colalign)"/>
+					</xsl:call-template>
+				</xsl:when>
+				<xsl:otherwise>
+					<xsl:value-of select="$colalign"/>
+				</xsl:otherwise>
+			</xsl:choose>
+		</xsl:when>
+		<xsl:otherwise>
+			<xsl:call-template name="generate-string">
+				<xsl:with-param name="text" select="'c'"/>
+				<xsl:with-param name="count" select="$numbercols"/>
+			</xsl:call-template>
+		</xsl:otherwise>
+	</xsl:choose>
+	<xsl:if test="@frame='solid'">
+		<xsl:text>|</xsl:text>
+	</xsl:if>
+	<xsl:text>}</xsl:text>
+	<xsl:if test="@frame='solid'">
+		<xsl:text>\hline </xsl:text>
+	</xsl:if>
+	<xsl:apply-templates/>
+	<xsl:if test="@frame='solid'">
+		<xsl:text>\\ \hline</xsl:text>
+	</xsl:if>
+	<xsl:text>\end{array}</xsl:text>
+</xsl:template>
+
+<xsl:template name="colalign">
+	<xsl:param name="colalign"/>
+	<xsl:choose>
+		<xsl:when test="contains($colalign,' ')">
+			<xsl:value-of select="substring($colalign,1,1)"/>
+			<xsl:call-template name="colalign">
+				<xsl:with-param name="colalign" select="substring-after($colalign,' ')"/>
+			</xsl:call-template>
+		</xsl:when>
+		<xsl:otherwise>
+			<xsl:value-of select="substring($colalign,1,1)"/>
+		</xsl:otherwise>
+	</xsl:choose>
+</xsl:template>
+
+<xsl:template name="generate-string">
+<!-- template from XSLT Standard Library v1.1 -->
+    <xsl:param name="text"/>
+    <xsl:param name="count"/>
+
+    <xsl:choose>
+      <xsl:when test="string-length($text) = 0 or $count &lt;= 0"/>
+
+      <xsl:otherwise>
+	<xsl:value-of select="$text"/>
+	<xsl:call-template name="generate-string">
+	  <xsl:with-param name="text" select="$text"/>
+	  <xsl:with-param name="count" select="$count - 1"/>
+	</xsl:call-template>
+      </xsl:otherwise>
+    </xsl:choose>
+</xsl:template>
+
+
+<!-- ====================================================================== -->
+<!-- $Id: scripts.xsl,v 1.1.1.1 2002/10/26 14:20:06 shade33 Exp $
+     This file is part of the XSLT MathML Library distribution.
+     See ./README or http://www.raleigh.ru/MathML/mmltex for
+     copyright and other information                                        -->
+<!-- ====================================================================== -->
+
+<xsl:template match="m:munderover">
+	<xsl:variable name="base">
+		<xsl:call-template name="startspace">
+			<xsl:with-param name="symbol" select="./*[1]"/>
+		</xsl:call-template>
+	</xsl:variable>
+	<xsl:variable name="under">
+		<xsl:call-template name="startspace">
+			<xsl:with-param name="symbol" select="./*[2]"/>
+		</xsl:call-template>
+	</xsl:variable>
+	<xsl:variable name="over">
+		<xsl:call-template name="startspace">
+			<xsl:with-param name="symbol" select="./*[3]"/>
+		</xsl:call-template>
+	</xsl:variable>
+
+	<xsl:choose>
+		<xsl:when test="$over='&#x000AF;'">	<!-- OverBar - over bar -->
+			<xsl:text>\overline{</xsl:text>
+			<xsl:call-template name="munder">
+				<xsl:with-param name="base" select="$base"/>
+				<xsl:with-param name="under" select="$under"/>
+			</xsl:call-template>
+			<xsl:text>}</xsl:text>
+		</xsl:when>
+		<xsl:when test="$over='&#x0FE37;'">	<!-- OverBrace - over brace -->
+			<xsl:text>\overbrace{</xsl:text>
+			<xsl:call-template name="munder">
+				<xsl:with-param name="base" select="$base"/>
+				<xsl:with-param name="under" select="$under"/>
+			</xsl:call-template>
+			<xsl:text>}</xsl:text>
+		</xsl:when>
+		<xsl:when test="$under='&#x00332;'">	<!-- UnderBar - combining low line -->
+			<xsl:text>\underline{</xsl:text>
+			<xsl:call-template name="mover">
+				<xsl:with-param name="base" select="$base"/>
+				<xsl:with-param name="over" select="$over"/>
+				<xsl:with-param name="pos_over" select="3"/>
+			</xsl:call-template>
+			<xsl:text>}</xsl:text>
+		</xsl:when>
+		<xsl:when test="$under='&#x0FE38;'">	<!-- UnderBrace - under brace -->
+			<xsl:text>\underbrace{</xsl:text>
+			<xsl:call-template name="mover">
+				<xsl:with-param name="base" select="$base"/>
+				<xsl:with-param name="over" select="$over"/>
+				<xsl:with-param name="pos_over" select="3"/>
+			</xsl:call-template>
+			<xsl:text>}</xsl:text>
+		</xsl:when>
+		<xsl:when test="translate($base,'&#x0220F;&#x02210;&#x022c2;&#x022c3;&#x02294;',
+						'&#x02211;&#x02211;&#x02211;&#x02211;&#x02211;')='&#x02211;'">
+<!-- if $base is operator, such as
+			&#x02211;	/sum L: summation operator
+			&#x0220F;	/prod L: product operator
+			&#x02210;	/coprod L: coproduct operator
+			&#x022c2;	/bigcap
+			&#x022c3;	/bigcup
+			&#x02294;	/bigsqcup
+-->
+			<xsl:apply-templates select="./*[1]"/>
+			<xsl:text>_{</xsl:text>
+			<xsl:apply-templates select="./*[2]"/>
+			<xsl:text>}^{</xsl:text>
+			<xsl:apply-templates select="./*[3]"/>
+			<xsl:text>}</xsl:text>
+		</xsl:when>
+		<xsl:otherwise>
+			<xsl:text>\underset{</xsl:text>
+			<xsl:apply-templates select="./*[2]"/>
+			<xsl:text>}{\overset{</xsl:text>
+			<xsl:apply-templates select="./*[3]"/>
+			<xsl:text>}{</xsl:text>
+			<xsl:apply-templates select="./*[1]"/>
+			<xsl:text>}}</xsl:text>
+		</xsl:otherwise>
+	</xsl:choose>
+</xsl:template>
+
+<xsl:template match="m:mover">
+	<xsl:call-template name="mover">
+		<xsl:with-param name="base">
+			<xsl:call-template name="startspace">
+				<xsl:with-param name="symbol" select="./*[1]"/>
+			</xsl:call-template>
+		</xsl:with-param>
+		<xsl:with-param name="over">
+			<xsl:call-template name="startspace">
+				<xsl:with-param name="symbol" select="./*[2]"/>
+			</xsl:call-template>
+		</xsl:with-param>
+	</xsl:call-template>
+</xsl:template>
+
+<xsl:template match="m:munder">
+	<xsl:call-template name="munder">
+		<xsl:with-param name="base">
+			<xsl:call-template name="startspace">
+				<xsl:with-param name="symbol" select="./*[1]"/>
+			</xsl:call-template>
+		</xsl:with-param>
+		<xsl:with-param name="under">
+			<xsl:call-template name="startspace">
+				<xsl:with-param name="symbol" select="./*[2]"/>
+			</xsl:call-template>
+		</xsl:with-param>
+	</xsl:call-template>
+</xsl:template>
+
+<xsl:template name="mover">
+	<xsl:param name="base"/>
+	<xsl:param name="over"/>
+	<xsl:param name="pos_over" select="2"/>
+	<xsl:choose>
+		<xsl:when test="$over='&#x000AF;'">	<!-- OverBar - over bar -->
+			<xsl:text>\overline{</xsl:text>
+			<xsl:apply-templates select="./*[1]"/>
+			<xsl:text>}</xsl:text>
+		</xsl:when>
+		<xsl:when test="$over='&#x0FE37;'">	<!-- OverBrace - over brace -->
+			<xsl:text>\overbrace{</xsl:text>
+			<xsl:apply-templates select="./*[1]"/>
+			<xsl:text>}</xsl:text>
+		</xsl:when>
+		<xsl:when test="translate($base,'&#x0220F;&#x02210;&#x022c2;&#x022c3;&#x02294;',
+						'&#x02211;&#x02211;&#x02211;&#x02211;&#x02211;')='&#x02211;'">
+<!-- if $base is operator, such as
+			&#x02211;	/sum L: summation operator
+			&#x0220F;	/prod L: product operator
+			&#x02210;	/coprod L: coproduct operator
+			&#x022c2;	/bigcap
+			&#x022c3;	/bigcup
+			&#x02294;	/bigsqcup
+-->
+			<xsl:apply-templates select="./*[1]"/>
+			<xsl:text>^{</xsl:text>
+			<xsl:apply-templates select="./*[$pos_over]"/>
+			<xsl:text>}</xsl:text>
+		</xsl:when>
+		<xsl:otherwise>
+			<xsl:text>\stackrel{</xsl:text>
+			<xsl:apply-templates select="./*[$pos_over]"/>
+			<xsl:text>}{</xsl:text>
+			<xsl:apply-templates select="./*[1]"/>
+			<xsl:text>}</xsl:text>
+			<!--
+			<xsl:text>\overset{</xsl:text>
+			<xsl:apply-templates select="./*[$pos_over]"/>
+			<xsl:text>}{</xsl:text>
+			<xsl:apply-templates select="./*[1]"/>
+			<xsl:text>}</xsl:text>-->
+		</xsl:otherwise>
+	</xsl:choose>
+</xsl:template>
+
+<xsl:template name="munder">
+	<xsl:param name="base"/>
+	<xsl:param name="under"/>
+	<xsl:choose>
+		<xsl:when test="$under='&#x00332;'">	<!-- UnderBar - combining low line -->
+			<xsl:text>\underline{</xsl:text>
+			<xsl:apply-templates select="./*[1]"/>
+			<xsl:text>}</xsl:text>
+		</xsl:when>
+		<xsl:when test="$under='&#x0FE38;'">	<!-- UnderBrace - under brace -->
+			<xsl:text>\underbrace{</xsl:text>
+			<xsl:apply-templates select="./*[1]"/>
+			<xsl:text>}</xsl:text>
+		</xsl:when>
+		<xsl:when test="translate($base,'&#x0220F;&#x02210;&#x022c2;&#x022c3;&#x02294;',
+						'&#x02211;&#x02211;&#x02211;&#x02211;&#x02211;')='&#x02211;'">
+<!-- if $base is operator, such as
+			&#x02211;	/sum L: summation operator
+			&#x0220F;	/prod L: product operator
+			&#x02210;	/coprod L: coproduct operator
+			&#x022c2;	/bigcap
+			&#x022c3;	/bigcup
+			&#x02294;	/bigsqcup
+-->
+			<xsl:apply-templates select="./*[1]"/>
+			<xsl:text>_{</xsl:text>
+			<xsl:apply-templates select="./*[2]"/>
+			<xsl:text>}</xsl:text>
+		</xsl:when>
+		<xsl:otherwise>
+			<xsl:text>\underset{</xsl:text>		<!-- Required AmsMath package -->
+			<xsl:apply-templates select="./*[2]"/>
+			<xsl:text>}{</xsl:text>
+			<xsl:apply-templates select="./*[1]"/>
+			<xsl:text>}</xsl:text>
+		</xsl:otherwise>
+	</xsl:choose>
+</xsl:template>
+
+<xsl:template match="m:msubsup">
+	<xsl:text>{</xsl:text>
+	<xsl:apply-templates select="./*[1]"/>
+	<xsl:text>}_{</xsl:text>
+	<xsl:apply-templates select="./*[2]"/>
+	<xsl:text>}^{</xsl:text>
+	<xsl:apply-templates select="./*[3]"/>
+	<xsl:text>}</xsl:text>
+</xsl:template>
+
+<xsl:template match="m:msup">
+	<xsl:text>{</xsl:text>
+	<xsl:apply-templates select="./*[1]"/>
+	<xsl:text>}^{</xsl:text>
+	<xsl:apply-templates select="./*[2]"/>
+	<xsl:text>}</xsl:text>
+</xsl:template>
+
+<xsl:template match="m:msub">
+	<xsl:text>{</xsl:text>
+	<xsl:apply-templates select="./*[1]"/>
+	<xsl:text>}_{</xsl:text>
+	<xsl:apply-templates select="./*[2]"/>
+	<xsl:text>}</xsl:text>
+</xsl:template>
+
+<xsl:template match="m:mmultiscripts" mode="mprescripts">
+	<xsl:for-each select="m:mprescripts/following-sibling::*">
+		<xsl:if test="position() mod 2 and local-name(.)!='none'">
+			<xsl:text>{}_{</xsl:text>
+			<xsl:apply-templates select="."/>
+			<xsl:text>}</xsl:text>
+		</xsl:if>
+		<xsl:if test="not(position() mod 2) and local-name(.)!='none'">
+			<xsl:text>{}^{</xsl:text>
+			<xsl:apply-templates select="."/>
+			<xsl:text>}</xsl:text>
+		</xsl:if>
+	</xsl:for-each>
+	<xsl:apply-templates select="./*[1]"/>
+	<xsl:for-each select="m:mprescripts/preceding-sibling::*[position()!=last()]">
+		<xsl:if test="position()>2 and local-name(.)!='none'">
+			<xsl:text>{}</xsl:text>
+		</xsl:if>
+		<xsl:if test="position() mod 2 and local-name(.)!='none'">
+			<xsl:text>_{</xsl:text>
+			<xsl:apply-templates select="."/>
+			<xsl:text>}</xsl:text>
+		</xsl:if>
+		<xsl:if test="not(position() mod 2) and local-name(.)!='none'">
+			<xsl:text>^{</xsl:text>
+			<xsl:apply-templates select="."/>
+			<xsl:text>}</xsl:text>
+		</xsl:if>
+	</xsl:for-each>
+</xsl:template>
+
+<xsl:template match="m:mmultiscripts">
+	<xsl:choose>
+		<xsl:when test="m:mprescripts">
+			<xsl:apply-templates select="." mode="mprescripts"/>
+		</xsl:when>
+		<xsl:otherwise>
+			<xsl:apply-templates select="./*[1]"/>
+			<xsl:for-each select="*[position()>1]">
+				<xsl:if test="position()>2 and local-name(.)!='none'">
+					<xsl:text>{}</xsl:text>
+				</xsl:if>
+				<xsl:if test="position() mod 2 and local-name(.)!='none'">
+					<xsl:text>_{</xsl:text>
+					<xsl:apply-templates select="."/>
+					<xsl:text>}</xsl:text>
+				</xsl:if>
+				<xsl:if test="not(position() mod 2) and local-name(.)!='none'">
+					<xsl:text>^{</xsl:text>
+					<xsl:apply-templates select="."/>
+					<xsl:text>}</xsl:text>
+				</xsl:if>
+			</xsl:for-each>
+		</xsl:otherwise>
+	</xsl:choose>
+</xsl:template>
+
+
+<!-- ====================================================================== -->
+<!-- $id: glayout.xsl, 2002/17/05 Exp $
+     This file is part of the XSLT MathML Library distribution.
+     See ./README or http://www.raleigh.ru/MathML/mmltex for
+     copyright and other information                                        -->
+<!-- ====================================================================== -->
+
+<xsl:template match="m:mfrac">
+	<xsl:choose>
+		<xsl:when test="@bevelled='true'">
+<!--			<xsl:text>\raisebox{1ex}{</xsl:text>
+			<xsl:apply-templates select="./*[1]"/>
+			<xsl:text>}\!\left/ \!\raisebox{-1ex}{</xsl:text>
+			<xsl:apply-templates select="./*[2]"/>
+			<xsl:text>}\right.</xsl:text>-->
+		</xsl:when>
+		<xsl:when test="@linethickness">
+			<xsl:text>\genfrac{}{}{</xsl:text>
+			<xsl:choose>
+				<xsl:when test="number(@linethickness)">
+					<xsl:value-of select="@linethickness div 10"/>
+					<xsl:text>ex</xsl:text>
+				</xsl:when>
+				<xsl:when test="@linethickness='thin'">
+					<xsl:text>.05ex</xsl:text>
+				</xsl:when>
+				<xsl:when test="@linethickness='medium'"/>
+				<xsl:when test="@linethickness='thick'">
+					<xsl:text>.2ex</xsl:text>
+				</xsl:when>
+				<xsl:otherwise>
+					<xsl:value-of select="@linethickness"/>
+				</xsl:otherwise>
+			</xsl:choose>
+			<xsl:text>}{}{</xsl:text>
+		</xsl:when>
+		<xsl:otherwise>
+			<xsl:text>\frac{</xsl:text>
+		</xsl:otherwise>
+	</xsl:choose>
+	<xsl:if test="@numalign='right'">
+		<xsl:text>\hfill </xsl:text>
+	</xsl:if>
+	<xsl:apply-templates select="./*[1]"/>
+	<xsl:if test="@numalign='left'">
+		<xsl:text>\hfill </xsl:text>
+	</xsl:if>
+	<xsl:text>}{</xsl:text>
+	<xsl:if test="@denomalign='right'">
+		<xsl:text>\hfill </xsl:text>
+	</xsl:if>
+	<xsl:apply-templates select="./*[2]"/>
+		<xsl:if test="@denomalign='left'">
+		<xsl:text>\hfill </xsl:text>
+	</xsl:if>
+	<xsl:text>}</xsl:text>
+</xsl:template>
+
+<xsl:template match="m:mroot">
+	<xsl:choose>
+		<xsl:when test="count(./*)=2">
+			<xsl:text>\sqrt[</xsl:text>
+			<xsl:apply-templates select="./*[2]"/>
+			<xsl:text>]{</xsl:text>
+			<xsl:apply-templates select="./*[1]"/>
+			<xsl:text>}</xsl:text>
+		</xsl:when>
+		<xsl:otherwise>
+		<!-- number of arguments is not 2 - code 25 -->
+			<xsl:message>exception 25:</xsl:message>
+			<xsl:text>\text{exception 25:}</xsl:text>
+		</xsl:otherwise>
+	</xsl:choose>
+</xsl:template>
+
+<xsl:template match="m:msqrt">
+	<xsl:text>\sqrt{</xsl:text>
+	<xsl:apply-templates/>
+	<xsl:text>}</xsl:text>
+</xsl:template>
+
+<xsl:template match="m:mfenced">
+	<xsl:choose>
+		<xsl:when test="@open">
+			<xsl:if test="translate(@open,'{}[]()|','{{{{{{{')='{'">
+				<xsl:text>\left</xsl:text>
+			</xsl:if>
+			<xsl:if test="@open='{' or @open='}'">
+				<xsl:text>\</xsl:text>
+			</xsl:if>
+			<xsl:value-of select="@open"/>
+		</xsl:when>
+		<xsl:otherwise><xsl:text>\left(</xsl:text></xsl:otherwise>
+	</xsl:choose>
+	<xsl:choose>
+		<xsl:when test="count(./*)>1">
+			<xsl:variable name="symbol">
+				<xsl:choose>
+					<xsl:when test="@separators">
+						<xsl:call-template name="startspace">
+							<xsl:with-param name="symbol" select="@separators"/>
+						</xsl:call-template>
+					</xsl:when>
+					<xsl:otherwise>,</xsl:otherwise>
+				</xsl:choose>
+			</xsl:variable>
+			<xsl:for-each select="./*">
+				<xsl:apply-templates select="."/>
+				<xsl:if test="not(position()=last())">
+					<xsl:choose>
+						<xsl:when test="position()>string-length($symbol)">
+							<xsl:value-of select="substring($symbol,string-length($symbol))"/>
+						</xsl:when>
+						<xsl:otherwise>
+							<xsl:value-of select="substring($symbol,position(),1)"/>
+						</xsl:otherwise>
+					</xsl:choose>
+				</xsl:if>
+			</xsl:for-each>
+		</xsl:when>
+		<xsl:otherwise>
+			<xsl:apply-templates/>
+		</xsl:otherwise>
+	</xsl:choose>
+	<xsl:choose>
+		<xsl:when test="@close">
+			<xsl:if test="translate(@open,'{}[]()|','{{{{{{{')='{'">
+				<xsl:text>\right</xsl:text>
+			</xsl:if>
+			<xsl:if test="@open='{' or @open='}'">
+				<xsl:text>\</xsl:text>
+			</xsl:if>
+			<xsl:value-of select="@close"/>
+		</xsl:when>
+		<xsl:otherwise><xsl:text>\right)</xsl:text></xsl:otherwise>
+	</xsl:choose>
+</xsl:template>
+
+<xsl:template match="m:mphantom">
+	<xsl:text>\phantom{</xsl:text>
+	<xsl:apply-templates/>
+	<xsl:text>}</xsl:text>
+</xsl:template>
+
+<xsl:template match="m:menclose">
+	<xsl:choose>
+		<xsl:when test="@notation = 'actuarial'">
+			<xsl:text>\overline{</xsl:text>
+			<xsl:apply-templates/>
+			<xsl:text>\hspace{.2em}|}</xsl:text>
+		</xsl:when>
+		<xsl:when test="@notation = 'radical'">
+			<xsl:text>\sqrt{</xsl:text>
+			<xsl:apply-templates/>
+			<xsl:text>}</xsl:text>
+		</xsl:when>
+		<xsl:otherwise>
+			<xsl:text>\overline{)</xsl:text>
+			<xsl:apply-templates/>
+			<xsl:text>}</xsl:text>
+		</xsl:otherwise>
+	</xsl:choose>
+</xsl:template>
+
+<xsl:template match="m:mrow">
+	<xsl:apply-templates/>
+</xsl:template>
+
+<xsl:template match="m:mstyle">
+	<xsl:if test="@background">
+		<xsl:text>\colorbox[rgb]{</xsl:text>
+		<xsl:call-template name="color">
+			<xsl:with-param name="color" select="@background"/>
+		</xsl:call-template>
+		<xsl:text>}{$</xsl:text>
+	</xsl:if>
+	<xsl:if test="@color">
+		<xsl:text>\textcolor[rgb]{</xsl:text>
+		<xsl:call-template name="color">
+			<xsl:with-param name="color" select="@color"/>
+		</xsl:call-template>
+		<xsl:text>}{</xsl:text>
+	</xsl:if>
+	<xsl:apply-templates/>
+	<xsl:if test="@color">
+		<xsl:text>}</xsl:text>
+	</xsl:if>
+	<xsl:if test="@background">
+		<xsl:text>$}</xsl:text>
+	</xsl:if>
+</xsl:template>
+<!--
+
+<xsl:template match="m:mstyle">
+	<xsl:if test="@displaystyle='true'">
+		<xsl:text>{\displaystyle</xsl:text>
+	</xsl:if>
+	<xsl:if test="@scriptlevel=2">
+		<xsl:text>{\scriptscriptstyle</xsl:text>
+	</xsl:if>
+	<xsl:apply-templates/>
+	<xsl:if test="@scriptlevel=2">
+		<xsl:text>}</xsl:text>
+	</xsl:if>
+	<xsl:if test="@displaystyle='true'">
+		<xsl:text>}</xsl:text>
+	</xsl:if>
+</xsl:template>
+-->
+
+<xsl:template match="m:merror">
+	<xsl:apply-templates/>
+</xsl:template>
+
+
+<!-- ====================================================================== -->
+<!-- $id: tokens.xsl, 2002/22/11 Exp $
+     This file is part of the XSLT MathML Library distribution.
+     See ./README or http://www.raleigh.ru/MathML/mmltex for
+     copyright and other information                                        -->
+<!-- ====================================================================== -->
+
+<xsl:template match="m:mi|m:mn|m:mo|m:mtext|m:ms">
+	<xsl:call-template name="CommonTokenAtr"/>
+</xsl:template>
+
+<xsl:template name="mi">
+	<xsl:choose>
+		<xsl:when test="string-length(normalize-space(.))>1 and not(@mathvariant)">
+			<xsl:text>\mathrm{</xsl:text>
+				<xsl:apply-templates/>
+			<xsl:text>}</xsl:text>
+		</xsl:when>
+		<xsl:otherwise>
+			<xsl:apply-templates/>
+		</xsl:otherwise>
+	</xsl:choose>
+</xsl:template>
+
+<xsl:template name="mn">
+	<xsl:apply-templates/>
+</xsl:template>
+
+<xsl:template name="mo">
+	<xsl:apply-templates/>
+</xsl:template>
+
+<xsl:template name="mtext">
+	<xsl:variable name="content">
+		<xsl:call-template name="replaceMtextEntities">
+			<xsl:with-param name="content" select="."/>
+		</xsl:call-template>
+	</xsl:variable>
+	<xsl:text>\text{</xsl:text>
+	<xsl:value-of select="$content"/>
+	<xsl:text>}</xsl:text>
+</xsl:template>
+
+<xsl:template match="m:mspace">
+	<xsl:text>\phantom{\rule</xsl:text>
+	<xsl:if test="@depth">
+		<xsl:text>[-</xsl:text>
+		<xsl:value-of select="@depth"/>
+		<xsl:text>]</xsl:text>
+	</xsl:if>
+	<xsl:text>{</xsl:text>
+	<xsl:if test="not(@width)">
+		<xsl:text>0ex</xsl:text>
+	</xsl:if>
+	<xsl:value-of select="@width"/>
+	<xsl:text>}{</xsl:text>
+	<xsl:if test="not(@height)">
+		<xsl:text>0ex</xsl:text>
+	</xsl:if>
+	<xsl:value-of select="@height"/>
+	<xsl:text>}}</xsl:text>
+</xsl:template>
+
+<xsl:template name="ms">
+	<xsl:choose>
+		<xsl:when test="@lquote"><xsl:value-of select="@lquote"/></xsl:when>
+		<xsl:otherwise><xsl:text>"</xsl:text></xsl:otherwise>
+	</xsl:choose><xsl:apply-templates/><xsl:choose>
+		<xsl:when test="@rquote"><xsl:value-of select="@rquote"/></xsl:when>
+		<xsl:otherwise><xsl:text>"</xsl:text></xsl:otherwise>
+	</xsl:choose>
+</xsl:template>
+
+<xsl:template name="CommonTokenAtr">
+	<xsl:if test="@mathbackground">
+		<xsl:text>\colorbox[rgb]{</xsl:text>
+		<xsl:call-template name="color">
+			<xsl:with-param name="color" select="@mathbackground"/>
+		</xsl:call-template>
+		<xsl:text>}{$</xsl:text>
+	</xsl:if>
+	<xsl:if test="@color or @mathcolor"> <!-- Note: @color is deprecated in MathML 2.0 -->
+		<xsl:text>\textcolor[rgb]{</xsl:text>
+		<xsl:call-template name="color">
+			<xsl:with-param name="color" select="@color|@mathcolor"/>
+		</xsl:call-template>
+		<xsl:text>}{</xsl:text>
+	</xsl:if>
+	<xsl:if test="@mathvariant">
+		<xsl:choose>
+			<xsl:when test="@mathvariant='normal'">
+				<xsl:text>\mathrm{</xsl:text>
+			</xsl:when>
+			<xsl:when test="@mathvariant='bold'">
+				<xsl:text>\mathbf{</xsl:text>
+			</xsl:when>
+			<xsl:when test="@mathvariant='italic'">
+				<xsl:text>\mathit{</xsl:text>
+			</xsl:when>
+			<xsl:when test="@mathvariant='bold-italic'">	<!-- Required definition -->
+				<xsl:text>\mathbit{</xsl:text>
+			</xsl:when>
+			<xsl:when test="@mathvariant='double-struck'">	<!-- Required amsfonts -->
+				<xsl:text>\mathbb{</xsl:text>
+			</xsl:when>
+			<xsl:when test="@mathvariant='bold-fraktur'">	<!-- Error -->
+				<xsl:text>{</xsl:text>
+			</xsl:when>
+			<xsl:when test="@mathvariant='script'">
+				<xsl:text>\mathcal{</xsl:text>
+			</xsl:when>
+			<xsl:when test="@mathvariant='bold-script'">	<!-- Error -->
+				<xsl:text>\mathsc{</xsl:text>
+			</xsl:when>
+			<xsl:when test="@mathvariant='fraktur'">	<!-- Required amsfonts -->
+				<xsl:text>\mathfrak{</xsl:text>
+			</xsl:when>
+			<xsl:when test="@mathvariant='sans-serif'">
+				<xsl:text>\mathsf{</xsl:text>
+			</xsl:when>
+			<xsl:when test="@mathvariant='bold-sans-serif'"> <!-- Required definition -->
+				<xsl:text>\mathbsf{</xsl:text>
+			</xsl:when>
+			<xsl:when test="@mathvariant='sans-serif-italic'"> <!-- Required definition -->
+				<xsl:text>\mathsfit{</xsl:text>
+			</xsl:when>
+			<xsl:when test="@mathvariant='sans-serif-bold-italic'">	<!-- Error -->
+				<xsl:text>\mathbsfit{</xsl:text>
+			</xsl:when>
+			<xsl:when test="@mathvariant='monospace'">
+				<xsl:text>\mathtt{</xsl:text>
+			</xsl:when>
+			<xsl:otherwise>
+				<xsl:text>{</xsl:text>
+			</xsl:otherwise>
+		</xsl:choose>
+	</xsl:if>
+	<xsl:call-template name="selectTemplate"/>
+	<xsl:if test="@mathvariant">
+		<xsl:text>}</xsl:text>
+	</xsl:if>
+	<xsl:if test="@color or @mathcolor">
+		<xsl:text>}</xsl:text>
+	</xsl:if>
+	<xsl:if test="@mathbackground">
+		<xsl:text>$}</xsl:text>
+	</xsl:if>
+</xsl:template>
+
+<xsl:template name="selectTemplate">
+<!--	<xsl:variable name="name" select="local-name()"/>
+	<xsl:call-template name="{$name}"/>-->
+	<xsl:choose>
+		<xsl:when test="local-name(.)='mi'">
+			<xsl:call-template name="mi"/>
+		</xsl:when>
+		<xsl:when test="local-name(.)='mn'">
+			<xsl:call-template name="mn"/>
+		</xsl:when>
+		<xsl:when test="local-name(.)='mo'">
+			<xsl:call-template name="mo"/>
+		</xsl:when>
+		<xsl:when test="local-name(.)='mtext'">
+			<xsl:call-template name="mtext"/>
+		</xsl:when>
+		<xsl:when test="local-name(.)='ms'">
+			<xsl:call-template name="ms"/>
+		</xsl:when>
+	</xsl:choose>
+</xsl:template>
+
+<xsl:template name="color">
+<!-- NB: Variables colora and valueColor{n} only for Sablotron -->
+	<xsl:param name="color"/>
+	<xsl:variable name="colora" select="translate($color,'ABCDEFGHIJKLMNOPQRSTUVWXYZ','abcdefghijklmnopqrstuvwxyz')"/>
+	<xsl:choose>
+	<xsl:when test="starts-with($colora,'#') and string-length($colora)=4">
+		<xsl:variable name="valueColor">
+			<xsl:call-template name="Hex2Decimal">
+				<xsl:with-param name="arg" select="substring($colora,2,1)"/>
+			</xsl:call-template>
+		</xsl:variable>
+		<xsl:value-of select="$valueColor div 15"/><xsl:text>,</xsl:text>
+		<xsl:variable name="valueColor1">
+			<xsl:call-template name="Hex2Decimal">
+				<xsl:with-param name="arg" select="substring($colora,3,1)"/>
+			</xsl:call-template>
+		</xsl:variable>
+		<xsl:value-of select="$valueColor1 div 15"/><xsl:text>,</xsl:text>
+		<xsl:variable name="valueColor2">
+			<xsl:call-template name="Hex2Decimal">
+				<xsl:with-param name="arg" select="substring($colora,4,1)"/>
+			</xsl:call-template>
+		</xsl:variable>
+		<xsl:value-of select="$valueColor2 div 15"/>
+	</xsl:when>
+	<xsl:when test="starts-with($colora,'#') and string-length($colora)=7">
+		<xsl:variable name="valueColor1">
+			<xsl:call-template name="Hex2Decimal">
+				<xsl:with-param name="arg" select="substring($colora,2,1)"/>
+			</xsl:call-template>
+		</xsl:variable>
+		<xsl:variable name="valueColor2">
+			<xsl:call-template name="Hex2Decimal">
+				<xsl:with-param name="arg" select="substring($colora,3,1)"/>
+			</xsl:call-template>
+		</xsl:variable>
+		<xsl:value-of select="($valueColor1*16 + $valueColor2) div 255"/><xsl:text>,</xsl:text>
+		<xsl:variable name="valueColor1a">
+			<xsl:call-template name="Hex2Decimal">
+				<xsl:with-param name="arg" select="substring($colora,4,1)"/>
+			</xsl:call-template>
+		</xsl:variable>
+		<xsl:variable name="valueColor2a">
+			<xsl:call-template name="Hex2Decimal">
+				<xsl:with-param name="arg" select="substring($colora,5,1)"/>
+			</xsl:call-template>
+		</xsl:variable>
+		<xsl:value-of select="($valueColor1a*16 + $valueColor2a) div 255"/><xsl:text>,</xsl:text>
+		<xsl:variable name="valueColor1b">
+			<xsl:call-template name="Hex2Decimal">
+				<xsl:with-param name="arg" select="substring($colora,6,1)"/>
+			</xsl:call-template>
+		</xsl:variable>
+		<xsl:variable name="valueColor2b">
+			<xsl:call-template name="Hex2Decimal">
+				<xsl:with-param name="arg" select="substring($colora,7,1)"/>
+			</xsl:call-template>
+		</xsl:variable>
+		<xsl:value-of select="($valueColor1b*16 + $valueColor2b) div 255"/>
+	</xsl:when>
+<!-- ======================= if color specified as an html-color-name ========================================== -->
+	<xsl:when test="$colora='aqua'"><xsl:text>0,1,1</xsl:text></xsl:when>
+	<xsl:when test="$colora='black'"><xsl:text>0,0,0</xsl:text></xsl:when>
+	<xsl:when test="$colora='blue'"><xsl:text>0,0,1</xsl:text></xsl:when>
+	<xsl:when test="$colora='fuchsia'"><xsl:text>1,0,1</xsl:text></xsl:when>
+	<xsl:when test="$colora='gray'"><xsl:text>.5,.5,.5</xsl:text></xsl:when>
+	<xsl:when test="$colora='green'"><xsl:text>0,.5,0</xsl:text></xsl:when>
+	<xsl:when test="$colora='lime'"><xsl:text>0,1,0</xsl:text></xsl:when>
+	<xsl:when test="$colora='maroon'"><xsl:text>.5,0,0</xsl:text></xsl:when>
+	<xsl:when test="$colora='navy'"><xsl:text>0,0,.5</xsl:text></xsl:when>
+	<xsl:when test="$colora='olive'"><xsl:text>.5,.5,0</xsl:text></xsl:when>
+	<xsl:when test="$colora='purple'"><xsl:text>.5,0,.5</xsl:text></xsl:when>
+	<xsl:when test="$colora='red'"><xsl:text>1,0,0</xsl:text></xsl:when>
+	<xsl:when test="$colora='silver'"><xsl:text>.75,.75,.75</xsl:text></xsl:when>
+	<xsl:when test="$colora='teal'"><xsl:text>0,.5,.5</xsl:text></xsl:when>
+	<xsl:when test="$colora='white'"><xsl:text>1,1,1</xsl:text></xsl:when>
+	<xsl:when test="$colora='yellow'"><xsl:text>1,1,0</xsl:text></xsl:when>
+	<xsl:otherwise>
+		<xsl:message>Exception at color template</xsl:message>
+	</xsl:otherwise>
+	</xsl:choose>
+</xsl:template>
+
+<xsl:template name="Hex2Decimal">
+	<xsl:param name="arg"/>
+	<xsl:choose>
+		<xsl:when test="$arg='f'">
+			<xsl:value-of select="15"/>
+		</xsl:when>
+		<xsl:when test="$arg='e'">
+			<xsl:value-of select="14"/>
+		</xsl:when>
+		<xsl:when test="$arg='d'">
+			<xsl:value-of select="13"/>
+		</xsl:when>
+		<xsl:when test="$arg='c'">
+			<xsl:value-of select="12"/>
+		</xsl:when>
+		<xsl:when test="$arg='b'">
+			<xsl:value-of select="11"/>
+		</xsl:when>
+		<xsl:when test="$arg='a'">
+			<xsl:value-of select="10"/>
+		</xsl:when>
+		<xsl:when test="translate($arg, '0123456789', '9999999999')='9'"> <!-- if $arg is number -->
+			<xsl:value-of select="$arg"/>
+		</xsl:when>
+		<xsl:otherwise>
+			<xsl:message>Exception at Hex2Decimal template</xsl:message>
+		</xsl:otherwise>
+	</xsl:choose>
+</xsl:template>
+
+<xsl:template match="m:*/text()">
+	<xsl:call-template name="replaceEntities">
+		<xsl:with-param name="content" select="normalize-space()"/>
+	</xsl:call-template>
+</xsl:template>
+
+</xsl:stylesheet>
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/mathml/data/simple_mmlctop.xsl b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/mathml/data/simple_mmlctop.xsl
new file mode 100644
index 0000000000000000000000000000000000000000..0cd73bccc24c963ed9c6c4121cc410997b94261c
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/mathml/data/simple_mmlctop.xsl
@@ -0,0 +1,3166 @@
+<?xml version="1.0"?>
+
+<!-- ******************************************************** -->
+<!--  XSL Transform of MathML content to MathML presentation  -->
+<!--             Version 1.0 RC2 from 13-Jun-2003             -->
+<!--                                                          -->
+<!--    Complies with the W3C MathML 2.0 Recommenation of     -->
+<!--                    21 February 2001.                     -->
+<!--                                                          -->
+<!--   Authors Igor Rodionov <igor@csd.uwo.ca>,               -->
+<!--           Stephen Watt  <watt@csd.uwo.ca>.               -->
+<!--                                                          -->
+<!-- (C) Copyright 2000-2003 Symbolic Computation Laboratory, -->
+<!--                         University of Western Ontario,   -->
+<!--                         London, Canada N6A 5B7.          -->
+<!--                                                          -->
+<!-- Modified: Fabian Seoane <fabian@fseoane> 2007 for sympy  -->
+<!--                                                          -->
+<!-- ******************************************************** -->
+
+<xsl:stylesheet id="mmlctop2.xsl"
+                version="1.0"
+                xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
+                xmlns:mml="http://www.w3.org/1998/Math/MathML"
+                xmlns="http://www.w3.org/1998/Math/MathML">
+
+<xsl:output method="xml" indent="yes"/>
+
+<xsl:strip-space elements="apply semantics annotation-xml
+        csymbol fn cn ci interval matrix matrixrow vector
+        lambda bvar condition logbase degree set list
+        lowlimit uplimit math"/>
+
+
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -->
+<!--         Parameters, variables and constants           -->
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -->
+
+<!-- ~~~~~~~~ Semantics related *constants*: ~~~~~~~~ -->
+
+<!-- Strip off semantics -->
+<xsl:variable name="SEM_STRIP" select="-1"/>
+
+<!-- Pass semantics "as is" -->
+<xsl:variable name="SEM_PASS" select="0"/>
+
+<!-- Add semantics at top level only -->
+<xsl:variable name="SEM_TOP" select="1"/>
+
+<!-- Add semantics at all levels -->
+<xsl:variable name="SEM_ALL" select="2"/>
+
+<!-- Semantics at top level only, with id refs -->
+<!-- NOTE: ids have to be already present in the
+           input for this feature to work. -->
+<xsl:variable name="SEM_XREF" select="3"/>
+
+<!-- No semantics at top level, with id refs -->
+<!-- NOTE: ids have to be already present in the
+           input for this feature to work. -->
+<xsl:variable name="SEM_XREF_EXT" select="4"/>
+
+
+<!-- ~~~~~~~~~~ Stylesheet *parameter*: SEM_SW ~~~~~~~~~~~~~~ -->
+<!-- Assumes one of the above values; SEM_PASS is the default -->
+<!-- The default can be overridden by specifying different    -->
+<!-- value on the command line when the stylesheet is invoked -->
+
+<xsl:param name="SEM_SW" select="SEM_PASS"/>
+
+
+<!-- ~~~~~~ Operator precedence definitions ~~~~~~ -->
+
+<xsl:variable name="NO_PREC" select="0"/>
+<xsl:variable name="UNION_PREC" select="1"/>
+<xsl:variable name="SETDIFF_PREC" select="1"/>
+<xsl:variable name="INTERSECT_PREC" select="3"/>
+<xsl:variable name="CARTPROD_PREC" select="3"/>
+<xsl:variable name="OR_PREC" select="5"/>
+<xsl:variable name="XOR_PREC" select="7"/>
+<xsl:variable name="AND_PREC" select="9"/>
+<xsl:variable name="NOT_PREC" select="11"/>
+<xsl:variable name="PLUS_PREC" select="13"/>
+<xsl:variable name="MINUS_PREC" select="13"/>
+<xsl:variable name="NEG_PREC" select="15"/>
+<xsl:variable name="MUL_PREC" select="17"/>
+<xsl:variable name="DIV_PREC" select="17"/>
+<xsl:variable name="REM_PREC" select="17"/>
+<xsl:variable name="FUNCTN_PREC" select="97"/>
+<xsl:variable name="GEN_FUN_PREC" select="99"/>
+
+<!-- ~~~~~ Miscellaneous constant definitions ~~~~~ -->
+
+<xsl:variable name="YES" select="1"/>
+<xsl:variable name="NO" select="0"/>
+<xsl:variable name="NO_PARAM" select="-1"/>
+<xsl:variable name="PAR_SAME" select="-3"/>
+<xsl:variable name="PAR_YES" select="-5"/>
+<xsl:variable name="PAR_NO" select="-7"/>
+
+
+
+<!-- +++++++++++++++++ INDEX OF TEMPLATES +++++++++++++++++++ -->
+
+<!-- All templates are subdivided into the following categories
+     (listed in the order of appearance in the stylesheet):
+
+THE TOPMOST ELEMENT: MATH
+ math
+
+SEMANTICS HANDLING
+ semantics
+
+BASIC CONTAINER ELEMENTS
+ cn, ci; csymbol
+
+BASIC CONTENT ELEMENTS
+ fn, interval, inverse, sep, condition, declare, lambda, compose,
+ ident; domain, codomain, image, domainofapplication, piecewise
+
+ARITHMETIC, ALGEBRA & LOGIC
+ quotient, exp, factorial, max, min, minus, plus, power, rem, divide,
+ times, root, gcd, and, or, xor, not, forall, exists, abs, conjugate;
+ arg, real, imaginary, lcm, floor, ceiling
+
+RELATIONS
+ neq, approx, tendsto, implies, in, notin, notsubset, notprsubset,
+ subset, prsubset, eq, gt, lt, geq, leq; equivalent, factorof
+
+CALCULUS
+ ln, log, diff, partialdiff, lowlimit, uplimit, bvar, degree,
+ logbase; divergence, grad, curl, laplacian
+
+SET THEORY
+ set, list, union, intersect, setdiff; card, cartesianproduct
+
+SEQUENCES AND SERIES
+ sum, product, limit
+
+TRIGONOMETRY
+ sin, cos, tan, sec, csc, cot, sinh, cosh, tanh, sech, csch, coth,
+ arcsin, arccos, arctan, arcsec, arccsc, arccot, arcsinh, arccosh,
+ arctanh, arcsech, arccsch, arccoth
+
+STATISTICS
+ mean, sdev, variance, median, mode, moment, momentabout
+
+LINEAR ALGEBRA
+ vector, matrix, matrixrow, determinant, transpose, selector;
+ vectorproduct, scalarproduct, outerproduct
+
+CONSTANT and SYMBOL ELEMENTS
+ integers, reals, rationals, naturalnumbers, complexes, primes,
+ exponentiale, imaginaryi, notanumber, true, false, emptyset,
+ pi, eulergamma, infinity
+-->
+
+
+
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -->
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~ TEMPLATES ~~~~~~~~~~~~~~~~~~~~~~~~~ -->
+<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -->
+
+
+
+<!-- *********************** COPY THROUGH ************************ -->
+
+<xsl:template match = "*">
+  <xsl:copy>
+    <xsl:copy-of select="@*"/>
+    <xsl:apply-templates/>
+  </xsl:copy>
+</xsl:template>
+
+
+
+<!-- ***************** THE TOPMOST ELEMENT: MATH ***************** -->
+
+<xsl:template match = "math">
+  <math>
+    <xsl:copy-of select="@*"/>
+    <xsl:choose>
+      <xsl:when test="$SEM_SW=$SEM_TOP or $SEM_SW=$SEM_ALL and *[2] or
+	                  $SEM_SW=$SEM_XREF">
+        <semantics>
+          <mrow>
+            <xsl:apply-templates mode = "semantics"/>
+          </mrow>
+          <annotation-xml encoding="MathML">
+            <xsl:copy-of select="*"/>
+          </annotation-xml>
+        </semantics>
+      </xsl:when>
+      <xsl:otherwise>
+        <xsl:apply-templates mode = "semantics"/>
+      </xsl:otherwise>
+    </xsl:choose>
+  </math>
+</xsl:template>
+
+
+
+<!-- ***************** SEMANTICS HANDLING ***************** -->
+
+<!-- This template is called recursively.  At each level   -->
+<!-- in the source tree it decides whether to strip off,   -->
+<!-- pass or add semantics at that level (depending on the -->
+<!-- value of SEM_SW parameter).  Then the actual template -->
+<!-- is applied to the node.                               -->
+
+<xsl:template match = "*" mode = "semantics">
+  <xsl:param name="IN_PREC" select="$NO_PREC"/>
+  <xsl:param name="PARAM" select="$NO_PARAM"/>
+  <xsl:param name="PAREN" select="$PAR_NO"/>
+  <xsl:param name="PAR_NO_IGNORE" select="$YES"/>
+  <xsl:choose>
+    <xsl:when test="$SEM_SW=$SEM_STRIP and self::semantics">
+      <xsl:apply-templates select="annotation-xml[@encoding='MathML']">
+        <xsl:with-param name="IN_PREC" select="$IN_PREC"/>
+        <xsl:with-param name="PARAM" select="$PARAM"/>
+        <xsl:with-param name="PAREN" select="$PAREN"/>
+        <xsl:with-param name="PAR_NO_IGNORE" select="$PAR_NO_IGNORE"/>
+      </xsl:apply-templates>
+    </xsl:when>
+    <xsl:when test="($SEM_SW=$SEM_PASS or $SEM_SW=$SEM_TOP) and self::semantics">
+      <semantics>
+        <xsl:apply-templates select="*[1]">
+        <xsl:with-param name="IN_PREC" select="$IN_PREC"/>
+        <xsl:with-param name="PARAM" select="$PARAM"/>
+        <xsl:with-param name="PAREN" select="$PAREN"/>
+        <xsl:with-param name="PAR_NO_IGNORE" select="$PAR_NO_IGNORE"/>
+      </xsl:apply-templates>
+        <xsl:copy-of select="annotation-xml"/>
+      </semantics>
+    </xsl:when>
+    <xsl:when test="$SEM_SW=$SEM_ALL">
+      <semantics>
+        <xsl:choose>
+          <xsl:when test="self::semantics">
+            <xsl:apply-templates select="*[1]">
+              <xsl:with-param name="IN_PREC" select="$IN_PREC"/>
+              <xsl:with-param name="PARAM" select="$PARAM"/>
+              <xsl:with-param name="PAREN" select="$PAREN"/>
+              <xsl:with-param name="PAR_NO_IGNORE" select="$PAR_NO_IGNORE"/>
+            </xsl:apply-templates>
+            <xsl:copy-of select="annotation-xml"/>
+          </xsl:when>
+          <xsl:otherwise>
+            <xsl:apply-templates select=".">
+              <xsl:with-param name="IN_PREC" select="$IN_PREC"/>
+              <xsl:with-param name="PARAM" select="$PARAM"/>
+              <xsl:with-param name="PAREN" select="$PAREN"/>
+              <xsl:with-param name="PAR_NO_IGNORE" select="$PAR_NO_IGNORE"/>
+            </xsl:apply-templates>
+            <annotation-xml encoding="MathML">
+              <xsl:copy-of select="."/>
+            </annotation-xml>
+          </xsl:otherwise>
+        </xsl:choose>
+      </semantics>
+    </xsl:when>
+    <xsl:when test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+      <xsl:choose>
+        <xsl:when test="self::semantics">
+          <xsl:copy>
+            <xsl:copy-of select="@*"/>
+            <xsl:attribute name="xref">
+              <xsl:value-of select="@id"/>
+            </xsl:attribute>
+            <xsl:copy-of select="*[1]"/>
+            <xsl:copy-of select="annotation-xml"/>
+          </xsl:copy>
+        </xsl:when>
+        <xsl:otherwise>
+          <xsl:apply-templates select=".">
+            <xsl:with-param name="IN_PREC" select="$IN_PREC"/>
+            <xsl:with-param name="PARAM" select="$PARAM"/>
+            <xsl:with-param name="PAREN" select="$PAREN"/>
+            <xsl:with-param name="PAR_NO_IGNORE" select="$PAR_NO_IGNORE"/>
+          </xsl:apply-templates>
+        </xsl:otherwise>
+      </xsl:choose>
+    </xsl:when>
+    <xsl:otherwise>
+      <xsl:apply-templates select=".">
+        <xsl:with-param name="IN_PREC" select="$IN_PREC"/>
+        <xsl:with-param name="PARAM" select="$PARAM"/>
+        <xsl:with-param name="PAREN" select="$PAREN"/>
+        <xsl:with-param name="PAR_NO_IGNORE" select="$PAR_NO_IGNORE"/>
+      </xsl:apply-templates>
+    </xsl:otherwise>
+  </xsl:choose>
+</xsl:template>
+
+
+<xsl:template match = "semantics">
+  <xsl:apply-templates select="*[1]" mode = "semantics"/>
+</xsl:template>
+
+
+
+<!-- ***************** BASIC CONTAINER ELEMENTS ***************** -->
+
+<xsl:template match = "cn">
+  <xsl:param name="IN_PREC" select="$NO_PREC"/>
+  <xsl:param name="PAREN" select="$PAR_NO"/>
+  <xsl:param name="PAR_NO_IGNORE" select="$YES"/>
+  <xsl:choose>
+    <xsl:when test=". &lt; 0 and $IN_PREC &gt; $NO_PREC and $PAREN=$PAR_NO
+                                                   and $PAR_NO_IGNORE=$NO">
+      <mfenced separators="">
+        <xsl:apply-templates select="." mode="cn"/>
+      </mfenced>
+    </xsl:when>
+    <xsl:otherwise>
+      <xsl:apply-templates select="." mode="cn"/>
+    </xsl:otherwise>
+  </xsl:choose>
+</xsl:template>
+
+<xsl:template match = "cn" mode="cn">
+  <xsl:choose>
+    <xsl:when test="(not(@type) or @type='integer' or @type='real') and @base">
+      <msub>
+        <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+          <xsl:attribute name="xref">
+            <xsl:value-of select="@id"/>
+          </xsl:attribute>
+        </xsl:if>
+        <mn> <xsl:apply-templates mode = "semantics"/> </mn>
+        <mn> <xsl:value-of select="@base"/> </mn>
+      </msub>
+    </xsl:when>
+    <xsl:when test="not(@type) or @type='integer' or @type='real'">
+      <mn>
+        <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+          <xsl:attribute name="xref">
+            <xsl:value-of select="@id"/>
+          </xsl:attribute>
+        </xsl:if>
+        <xsl:apply-templates mode = "semantics"/>
+      </mn>
+    </xsl:when>
+    <xsl:when test="@type='constant'">
+      <mn>
+        <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+          <xsl:attribute name="xref">
+            <xsl:value-of select="@id"/>
+          </xsl:attribute>
+        </xsl:if>
+        <xsl:apply-templates mode = "semantics"/>
+      </mn>
+    </xsl:when>
+    <xsl:when test="@type='e-notation' and not(@base) and child::sep[1]">
+      <mrow>
+        <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+          <xsl:attribute name="xref">
+            <xsl:value-of select="@id"/>
+          </xsl:attribute>
+        </xsl:if>
+        <mn> <xsl:apply-templates select="text()[1]" mode = "semantics"/> </mn>
+        <mo> e </mo>
+        <mn> <xsl:apply-templates select="text()[2]" mode = "semantics"/> </mn>
+      </mrow>
+    </xsl:when>
+    <xsl:when test="@type='complex-cartesian' and not(@base) and child::sep[1]">
+      <mfenced separators="">
+        <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+          <xsl:attribute name="xref">
+            <xsl:value-of select="@id"/>
+          </xsl:attribute>
+        </xsl:if>
+        <mn> <xsl:apply-templates select="text()[1]" mode = "semantics"/> </mn>
+        <xsl:if test="text()[2] &lt; 0">
+          <mo> - </mo>
+          <mn> <xsl:value-of select="-text()[2]"/> </mn>
+        </xsl:if>
+        <xsl:if test="not(text()[2] &lt; 0)">
+          <mo> + </mo>
+          <mn> <xsl:value-of select="text()[2]"/> </mn>
+        </xsl:if>
+        <mo> <xsl:text disable-output-escaping='yes'>&amp;#x2062;</xsl:text> </mo>
+        <mo> <xsl:text disable-output-escaping='yes'>&amp;#x2148;</xsl:text> </mo>
+      </mfenced>
+    </xsl:when>
+    <xsl:when test="@type='complex-cartesian' and @base and child::sep[1]">
+      <msub>
+        <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+          <xsl:attribute name="xref">
+            <xsl:value-of select="@id"/>
+          </xsl:attribute>
+        </xsl:if>
+        <mfenced separators="">
+          <mn> <xsl:apply-templates select="text()[1]"/> </mn>
+          <xsl:if test="text()[2] &lt; 0">
+            <mo> - </mo>
+            <mn> <xsl:value-of select="-text()[2]"/> </mn>
+          </xsl:if>
+          <xsl:if test="not(text()[2] &lt; 0)">
+            <mo> + </mo>
+            <mn> <xsl:apply-templates select="text()[2]"/> </mn>
+          </xsl:if>
+          <mo> <xsl:text disable-output-escaping='yes'>&amp;#x2062;</xsl:text> </mo>
+          <mo> <xsl:text disable-output-escaping='yes'>&amp;#x2148;</xsl:text> </mo>
+        </mfenced>
+        <mn> <xsl:value-of select="@base"/> </mn>
+      </msub>
+    </xsl:when>
+    <xsl:when test="@type='rational' and not(@base) and child::sep[1]">
+      <mfrac>
+        <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+          <xsl:attribute name="xref">
+            <xsl:value-of select="@id"/>
+          </xsl:attribute>
+        </xsl:if>
+        <mn> <xsl:apply-templates select="text()[1]"/> </mn>
+        <mn> <xsl:apply-templates select="text()[2]"/> </mn>
+      </mfrac>
+    </xsl:when>
+    <xsl:when test="@type='rational' and @base and child::sep[1]">
+      <msub>
+        <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+          <xsl:attribute name="xref">
+            <xsl:value-of select="@id"/>
+          </xsl:attribute>
+        </xsl:if>
+        <mfenced>
+          <mfrac>
+            <mn> <xsl:apply-templates select="text()[1]"/> </mn>
+            <mn> <xsl:apply-templates select="text()[2]"/> </mn>
+          </mfrac>
+        </mfenced>
+        <mn> <xsl:value-of select="@base"/> </mn>
+      </msub>
+    </xsl:when>
+    <xsl:when test="@type='complex-polar' and not(@base) and child::sep[1]">
+      <mrow>
+        <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+          <xsl:attribute name="xref">
+            <xsl:value-of select="@id"/>
+          </xsl:attribute>
+        </xsl:if>
+        <mo> Polar </mo>
+        <mo> <xsl:text disable-output-escaping='yes'>&amp;#x2062;</xsl:text> </mo>
+        <mfenced separators=",">
+          <mn> <xsl:apply-templates select="text()[1]"/> </mn>
+          <mn> <xsl:apply-templates select="text()[2]"/> </mn>
+        </mfenced>
+      </mrow>
+    </xsl:when>
+    <xsl:when test="@type='complex-polar' and @base and child::sep[1]">
+      <msub>
+        <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+          <xsl:attribute name="xref">
+            <xsl:value-of select="@id"/>
+          </xsl:attribute>
+        </xsl:if>
+        <mrow>
+          <mo> Polar </mo>
+          <mo> <xsl:text disable-output-escaping='yes'>&amp;#x2062;</xsl:text> </mo>
+          <mfenced separators=",">
+            <mn> <xsl:apply-templates select="text()[1]"/> </mn>
+            <mn> <xsl:apply-templates select="text()[2]"/> </mn>
+          </mfenced>
+        </mrow>
+        <mn> <xsl:value-of select="@base"/> </mn>
+      </msub>
+   </xsl:when>
+    <xsl:otherwise>
+      <mn> <xsl:apply-templates mode = "semantics"/> </mn>
+    </xsl:otherwise>
+  </xsl:choose>
+</xsl:template>
+
+
+<xsl:template match = "ci">
+  <xsl:choose>
+    <xsl:when test="@type='vector' or @type='matrix' or @type='set'">
+      <mi mathvariant="bold">
+        <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+          <xsl:attribute name="xref">
+            <xsl:value-of select="@id"/>
+          </xsl:attribute>
+        </xsl:if>
+        <xsl:apply-templates mode = "semantics"/>
+      </mi>
+    </xsl:when>
+    <xsl:when test="child::text() and not(child::*[1])">
+      <mi>
+        <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+          <xsl:attribute name="xref">
+            <xsl:value-of select="@id"/>
+          </xsl:attribute>
+        </xsl:if>
+        <xsl:apply-templates/>
+      </mi>
+    </xsl:when>
+    <xsl:when test="child::text() and *[1] and not(*[1]=sep)">
+      <mrow>
+        <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+          <xsl:attribute name="xref">
+            <xsl:value-of select="@id"/>
+          </xsl:attribute>
+        </xsl:if>
+        <xsl:apply-templates/>
+      </mrow>
+    </xsl:when>
+    <xsl:otherwise>
+      <xsl:if test="*[2]">
+        <mrow>
+          <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+            <xsl:attribute name="xref">
+              <xsl:value-of select="@id"/>
+            </xsl:attribute>
+          </xsl:if>
+          <xsl:apply-templates select="*"/>
+        </mrow>
+      </xsl:if>
+      <xsl:if test="not(*[2])">
+        <xsl:apply-templates select="*[1]"/>
+      </xsl:if>
+    </xsl:otherwise>
+  </xsl:choose>
+</xsl:template>
+
+<xsl:template match = "ci/*[not(self::sep)]">
+  <xsl:copy-of select = "."/>
+</xsl:template>
+
+
+<xsl:template match = "csymbol">
+  <mrow>
+    <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+      <xsl:attribute name="xref">
+        <xsl:value-of select="@id"/>
+      </xsl:attribute>
+    </xsl:if>
+    <xsl:copy-of select = "* | text()"/>
+  </mrow>
+</xsl:template>
+
+
+
+<!-- ***************** BASIC CONTENT ELEMENTS ***************** -->
+
+<!-- General <apply> <AnyFunction/> ... </apply> -->
+<!-- Dependants: csymbol apply[fn inverse compose] -->
+<xsl:template match = "apply">
+  <xsl:param name="IN_PREC" select="$NO_PREC"/>
+  <xsl:param name="PARAM" select="$NO_PARAM"/>
+  <xsl:param name="PAREN" select="$PAR_NO"/>
+  <xsl:param name="PAR_NO_IGNORE" select="$YES"/>
+  <mrow>
+    <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+      <xsl:attribute name="xref">
+        <xsl:value-of select="@id"/>
+      </xsl:attribute>
+    </xsl:if>
+    <xsl:apply-templates select = "*[1]" mode = "semantics">
+      <xsl:with-param name="IN_PREC" select="$FUNCTN_PREC"/>
+      <xsl:with-param name="PARAM" select="$PAR_SAME"/>
+      <xsl:with-param name="PAR_NO_IGNORE" select="$NO"/>
+    </xsl:apply-templates>
+    <mo> <xsl:text disable-output-escaping='yes'>&amp;#x2061;</xsl:text> </mo>
+    <mfenced separators=",">
+      <xsl:apply-templates select = "*[position()>1]" mode = "semantics">
+        <xsl:with-param name="IN_PREC" select="$FUNCTN_PREC"/>
+        <xsl:with-param name="PARAM" select="$PAR_SAME"/>
+        <xsl:with-param name="PAR_NO_IGNORE" select="$NO"/>
+      </xsl:apply-templates>
+    </mfenced>
+ </mrow>
+</xsl:template>
+
+
+<!-- fn is ***DEPRECATED*** -->
+<xsl:template match = "fn">
+  <xsl:param name="IN_PREC" select="$NO_PREC"/>
+  <xsl:param name="PARAM" select="$NO_PARAM"/>
+  <xsl:param name="PAREN" select="$PAR_NO"/>
+  <xsl:param name="PAR_NO_IGNORE" select="$YES"/>
+  <xsl:apply-templates mode = "semantics">
+    <xsl:with-param name="IN_PREC" select="$FUNCTN_PREC"/>
+    <xsl:with-param name="PARAM" select="$PAR_SAME"/>
+    <xsl:with-param name="PAR_NO_IGNORE" select="$NO"/>
+  </xsl:apply-templates>
+</xsl:template>
+
+
+<xsl:template match = "interval">
+  <mfenced>
+    <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+      <xsl:attribute name="xref">
+        <xsl:value-of select="@id"/>
+      </xsl:attribute>
+    </xsl:if>
+    <xsl:if test="not(@closure) or @closure='closed' or @closure='closed-open' or not(@closure='open') and not(@closure='open-closed')">
+      <xsl:attribute name="open"> [ </xsl:attribute>
+    </xsl:if>
+    <xsl:if test="not(@closure) or @closure='closed' or @closure='open-closed' or not(@closure='open') and not(@closure='closed-open')">
+      <xsl:attribute name="close"> ] </xsl:attribute>
+    </xsl:if>
+    <xsl:apply-templates select="*" mode = "semantics"/>
+  </mfenced>
+</xsl:template>
+
+
+<xsl:template match = "apply[*[1][self::inverse]]">
+  <xsl:param name="IN_PREC" select="$NO_PREC"/>
+  <xsl:param name="PAREN" select="$PAR_NO"/>
+  <xsl:param name="PARAM" select="$NO_PARAM"/>
+  <xsl:param name="PAR_NO_IGNORE" select="$YES"/>
+  <xsl:choose>
+    <xsl:when test="*[2]=exp | *[2]=ln | *[2]=sin | *[2]=cos |
+                    *[2]=tan | *[2]=sec | *[2]=csc | *[2]=cot |
+                    *[2]=sinh | *[2]=cosh | *[2]=tanh | *[2]=sech |
+                    *[2]=csch | *[2]=coth | *[2]=arcsin |
+                    *[2]=arccos | *[2]=arctan">
+      <mo>
+        <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+          <xsl:attribute name="xref">
+            <xsl:value-of select="@id"/>
+          </xsl:attribute>
+        </xsl:if>
+        <xsl:apply-templates select="*[2]" mode="inverse"/>
+      </mo>
+    </xsl:when>
+    <xsl:otherwise>
+      <msup>
+        <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+          <xsl:attribute name="xref">
+            <xsl:value-of select="@id"/>
+          </xsl:attribute>
+        </xsl:if>
+		<mrow>
+          <xsl:apply-templates select = "*[2]">
+            <xsl:with-param name="IN_PREC" select="$FUNCTN_PREC"/>
+            <xsl:with-param name="PARAM" select="$PAR_SAME"/>
+            <xsl:with-param name="PAR_NO_IGNORE" select="$NO"/>
+          </xsl:apply-templates>
+		</mrow>
+		<mfenced>
+          <mn> -1 </mn>
+        </mfenced>
+      </msup>
+    </xsl:otherwise>
+  </xsl:choose>
+</xsl:template>
+
+<xsl:template match = "*" mode="inverse">
+  <xsl:choose>
+    <xsl:when test="self::exp">
+      <xsl:value-of select="'ln'"/>
+    </xsl:when>
+    <xsl:when test="self::ln">
+      <xsl:value-of select="'exp'"/>
+    </xsl:when>
+    <xsl:when test="self::sin">
+      <xsl:value-of select="'arcsin'"/>
+    </xsl:when>
+    <xsl:when test="self::cos">
+      <xsl:value-of select="'arccos'"/>
+    </xsl:when>
+    <xsl:when test="self::tan">
+      <xsl:value-of select="'arctan'"/>
+    </xsl:when>
+    <xsl:when test="self::sec">
+      <xsl:value-of select="'arcsec'"/>
+    </xsl:when>
+    <xsl:when test="self::csc">
+      <xsl:value-of select="'arccsc'"/>
+    </xsl:when>
+    <xsl:when test="self::cot">
+      <xsl:value-of select="'arccot'"/>
+    </xsl:when>
+    <xsl:when test="self::sinh">
+      <xsl:value-of select="'arcsinh'"/>
+    </xsl:when>
+    <xsl:when test="self::cosh">
+      <xsl:value-of select="'arccosh'"/>
+    </xsl:when>
+    <xsl:when test="self::tanh">
+      <xsl:value-of select="'arctanh'"/>
+    </xsl:when>
+    <xsl:when test="self::sech">
+      <xsl:value-of select="'arcsech'"/>
+    </xsl:when>
+    <xsl:when test="self::csch">
+      <xsl:value-of select="'arccsch'"/>
+    </xsl:when>
+    <xsl:when test="self::coth">
+      <xsl:value-of select="'arccoth'"/>
+    </xsl:when>
+    <xsl:when test="self::arcsin">
+      <xsl:value-of select="'sin'"/>
+    </xsl:when>
+    <xsl:when test="self::arccos">
+      <xsl:value-of select="'cos'"/>
+    </xsl:when>
+    <xsl:when test="self::arctan">
+      <xsl:value-of select="'tan'"/>
+    </xsl:when>
+  </xsl:choose>
+</xsl:template>
+
+
+<xsl:template match = "condition">
+  <mrow>
+    <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+      <xsl:attribute name="xref">
+        <xsl:value-of select="@id"/>
+      </xsl:attribute>
+    </xsl:if>
+    <xsl:apply-templates select="*" mode = "semantics"/>
+  </mrow>
+</xsl:template>
+
+
+<xsl:template match = "declare"/>
+
+
+<xsl:template match = "lambda">
+  <mrow>
+    <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+      <xsl:attribute name="xref">
+        <xsl:value-of select="@id"/>
+      </xsl:attribute>
+    </xsl:if>
+    <mo> <xsl:text disable-output-escaping='yes'>&amp;#x03BB;</xsl:text> </mo>
+    <mo> <xsl:text disable-output-escaping='yes'>&amp;#x2061;</xsl:text> </mo>
+    <mfenced>
+      <xsl:for-each select = "*">
+        <xsl:choose>
+          <xsl:when test="self::ci or self::cn">
+            <xsl:apply-templates select = "." mode="semantics"/>
+          </xsl:when>
+          <xsl:otherwise>
+            <mrow>
+              <xsl:apply-templates select = "." mode="semantics"/>
+            </mrow>
+          </xsl:otherwise>
+        </xsl:choose>
+      </xsl:for-each>
+    </mfenced>
+  </mrow>
+</xsl:template>
+
+
+<xsl:template match = "apply[*[1][self::compose]]">
+  <xsl:param name="IN_PREC" select="$NO_PREC"/>
+  <xsl:param name="PAREN" select="$PAR_NO"/>
+  <xsl:param name="PARAM" select="$NO_PARAM"/>
+  <xsl:param name="PAR_NO_IGNORE" select="$YES"/>
+  <xsl:choose>
+    <xsl:when test="$IN_PREC &lt; $GEN_FUN_PREC and
+                   ($IN_PREC &gt; $FUNCTN_PREC or $IN_PREC=$FUNCTN_PREC and $PARAM=$PAR_SAME)">
+      <mfenced separators="">
+        <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+          <xsl:attribute name="xref">
+            <xsl:value-of select="@id"/>
+          </xsl:attribute>
+        </xsl:if>
+        <xsl:apply-templates select = "*[2]" mode="semantics"/>
+        <xsl:for-each select = "*[position()>2]">
+          <mo> <xsl:text disable-output-escaping='yes'>&amp;#x2218;</xsl:text> </mo>
+          <xsl:apply-templates select = "." mode="semantics">
+            <xsl:with-param name="IN_PREC" select="$FUNCTN_PREC"/>
+            <xsl:with-param name="PARAM" select="$PAR_SAME"/>
+            <xsl:with-param name="PAR_NO_IGNORE" select="$NO"/>
+          </xsl:apply-templates>
+        </xsl:for-each>
+      </mfenced>
+    </xsl:when>
+    <xsl:otherwise>
+      <mrow>
+        <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+          <xsl:attribute name="xref">
+            <xsl:value-of select="@id"/>
+          </xsl:attribute>
+        </xsl:if>
+        <xsl:apply-templates select = "*[2]" mode="semantics"/>
+        <xsl:for-each select = "*[position()>2]">
+          <mo> <xsl:text disable-output-escaping='yes'>&amp;#x2218;</xsl:text> </mo>
+          <xsl:apply-templates select = "." mode="semantics">
+            <xsl:with-param name="IN_PREC" select="$FUNCTN_PREC"/>
+            <xsl:with-param name="PARAM" select="$PAR_SAME"/>
+            <xsl:with-param name="PAR_NO_IGNORE" select="$NO"/>
+          </xsl:apply-templates>
+        </xsl:for-each>
+      </mrow>
+	</xsl:otherwise>
+  </xsl:choose>
+</xsl:template>
+
+
+<xsl:template match = "ident">
+  <xsl:choose>
+    <xsl:when test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+      <mtext xref="{@id}">id</mtext>
+    </xsl:when>
+    <xsl:otherwise>
+      <mtext>id</mtext>
+    </xsl:otherwise>
+  </xsl:choose>
+</xsl:template>
+
+
+<xsl:template match="apply[*[1]=domain or *[1]=codomain or *[1]=image]">
+  <mrow>
+    <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+      <xsl:attribute name="xref">
+        <xsl:value-of select="@id"/>
+      </xsl:attribute>
+    </xsl:if>
+	<xsl:if test="*[1]=domain">
+      <mtext>domain</mtext>
+	</xsl:if>
+	<xsl:if test="*[1]=codomain">
+      <mtext>codomain</mtext>
+	</xsl:if>
+	<xsl:if test="*[1]=image">
+      <mtext>image</mtext>
+	</xsl:if>
+    <mo> <xsl:text disable-output-escaping='yes'>&amp;#x2061;</xsl:text> </mo>
+    <mfenced separators="">
+      <xsl:apply-templates select="*[position()>1]" mode = "semantics"/>
+    </mfenced>
+  </mrow>
+</xsl:template>
+
+
+<xsl:template match = "domainofapplication">
+  <mrow>
+    <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+      <xsl:attribute name="xref">
+        <xsl:value-of select="@id"/>
+      </xsl:attribute>
+    </xsl:if>
+    <xsl:apply-templates select = "*" mode = "semantics"/>
+  </mrow>
+</xsl:template>
+
+
+<xsl:template match="piecewise">
+  <mrow>
+    <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+      <xsl:attribute name="xref">
+        <xsl:value-of select="@id"/>
+      </xsl:attribute>
+    </xsl:if>
+    <mo stretchy="true"> { </mo>
+    <mtable columnalign="left left">
+      <xsl:for-each select="piece">
+        <mtr>
+          <mtd>
+            <xsl:apply-templates select="*[position()=1]" mode = "semantics"/>
+          </mtd>
+          <mtd>
+            <mtext>if </mtext>
+            <xsl:apply-templates select="*[position()=2]" mode = "semantics"/>
+          </mtd>
+        </mtr>
+      </xsl:for-each>
+      <xsl:if test="otherwise">
+        <mtr>
+          <mtd>
+            <xsl:apply-templates select="otherwise/*" mode = "semantics"/>
+          </mtd>
+          <mtd>
+            <mtext>otherwise</mtext>
+          </mtd>
+        </mtr>
+      </xsl:if>
+    </mtable>
+  </mrow>
+</xsl:template>
+
+
+
+<!-- ***************** ARITHMETIC, ALGEBRA & LOGIC ***************** -->
+
+<xsl:template match = "apply[quotient[1]]">
+  <xsl:param name="IN_PREC" select="$NO_PREC"/>
+  <xsl:param name="PARAM" select="$NO_PARAM"/>
+  <xsl:param name="PAREN" select="$PAR_NO"/>
+  <xsl:param name="PAR_NO_IGNORE" select="$YES"/>
+  <mrow>
+    <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+      <xsl:attribute name="xref">
+        <xsl:value-of select="@id"/>
+      </xsl:attribute>
+    </xsl:if>
+    <mo> <xsl:text disable-output-escaping='yes'>&amp;#x230A;</xsl:text> </mo>
+    <mfrac>
+      <mrow>
+        <xsl:apply-templates select="*[2]" mode = "semantics">
+          <xsl:with-param name="IN_PREC" select="$DIV_PREC"/>
+          <xsl:with-param name="PARAM" select="$PARAM"/>
+          <xsl:with-param name="PAREN" select="$PAREN"/>
+          <xsl:with-param name="PAR_NO_IGNORE" select="$PAR_NO_IGNORE"/>
+        </xsl:apply-templates>
+      </mrow>
+      <mrow>
+        <xsl:apply-templates select="*[3]" mode = "semantics">
+          <xsl:with-param name="IN_PREC" select="$DIV_PREC"/>
+          <xsl:with-param name="PARAM" select="$PARAM"/>
+          <xsl:with-param name="PAREN" select="$PAREN"/>
+          <xsl:with-param name="PAR_NO_IGNORE" select="$PAR_NO_IGNORE"/>
+        </xsl:apply-templates>
+      </mrow>
+    </mfrac>
+    <mo> <xsl:text disable-output-escaping='yes'>&amp;#x230B;</xsl:text> </mo>
+  </mrow>
+</xsl:template>
+
+
+<xsl:template match = "apply[*[1][self::exp]]">
+  <msup>
+    <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+      <xsl:attribute name="xref">
+        <xsl:value-of select="@id"/>
+      </xsl:attribute>
+    </xsl:if>
+    <mn> <xsl:text disable-output-escaping='yes'>e</xsl:text> </mn>
+    <xsl:apply-templates select = "*[2]" mode = "semantics"/>
+  </msup>
+</xsl:template>
+
+
+<xsl:template match = "apply[factorial[1]]">
+  <mrow>
+    <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+      <xsl:attribute name="xref">
+        <xsl:value-of select="@id"/>
+      </xsl:attribute>
+    </xsl:if>
+    <xsl:apply-templates select = "*[2]" mode = "semantics">
+      <xsl:with-param name="IN_PREC" select="$FUNCTN_PREC"/>
+      <xsl:with-param name="PAR_NO_IGNORE" select="$NO"/>
+    </xsl:apply-templates>
+    <mo> ! </mo>
+  </mrow>
+</xsl:template>
+
+
+<xsl:template match = "apply[max[1] | min[1]]">
+  <mrow>
+    <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+      <xsl:attribute name="xref">
+        <xsl:value-of select="@id"/>
+      </xsl:attribute>
+    </xsl:if>
+    <xsl:choose>
+      <xsl:when test="*[2]=bvar">
+        <munder>
+          <xsl:if test="*[1]=max">
+            <mo> max </mo>
+          </xsl:if>
+          <xsl:if test="*[1]=min">
+            <mo> min </mo>
+          </xsl:if>
+          <xsl:apply-templates select="*[2]" mode = "semantics"/>
+        </munder>
+      </xsl:when>
+      <xsl:otherwise>
+        <xsl:if test="*[1]=max">
+          <mo> max </mo>
+        </xsl:if>
+        <xsl:if test="*[1]=min">
+          <mo> min </mo>
+        </xsl:if>
+      </xsl:otherwise>
+	</xsl:choose>
+    <mfenced open="{{" close="}}">
+      <xsl:if test="child::condition">
+        <xsl:attribute name="separators"/>
+        <xsl:if test="*[position()>1 and not(self::bvar) and not(self::condition)]">
+          <mfenced open="" close="" separators=",">
+            <xsl:for-each select = "*[position()>1 and not(self::bvar) and not(self::condition)]">
+              <xsl:apply-templates select = "." mode="semantics"/>
+            </xsl:for-each>
+          </mfenced>
+          <mo lspace="0.1666em" rspace="0.1666em"> | </mo>
+        </xsl:if>
+        <xsl:apply-templates select="condition" mode = "semantics"/>
+      </xsl:if>
+      <xsl:if test="not(child::condition)">
+        <xsl:for-each select = "*[position()>1 and not(self::bvar)]">
+          <xsl:apply-templates select = "." mode="semantics"/>
+        </xsl:for-each>
+      </xsl:if>
+    </mfenced>
+  </mrow>
+</xsl:template>
+
+
+<xsl:template match = "apply[minus[1]]">
+  <xsl:param name="IN_PREC" select="$NO_PREC"/>
+  <xsl:param name="PARAM" select="$NO_PARAM"/>
+  <xsl:param name="PAREN" select="$PAR_NO"/>
+  <xsl:param name="PAR_NO_IGNORE" select="$YES"/>
+  <xsl:choose>
+    <xsl:when test="$IN_PREC &lt; $GEN_FUN_PREC and
+                   ($IN_PREC &gt; $MINUS_PREC or $IN_PREC=$MINUS_PREC and $PARAM=$PAR_SAME)">
+      <mfenced separators="">
+        <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+          <xsl:attribute name="xref">
+            <xsl:value-of select="@id"/>
+          </xsl:attribute>
+        </xsl:if>
+        <xsl:apply-templates select="." mode="minus">
+          <xsl:with-param name="PARAM" select="$PARAM"/>
+          <xsl:with-param name="PAREN" select="$PAR_YES"/>
+          <xsl:with-param name="PAR_NO_IGNORE" select="$PAR_NO_IGNORE"/>
+        </xsl:apply-templates>
+      </mfenced>
+    </xsl:when>
+    <xsl:when test="$IN_PREC &gt; $NO_PREC and $IN_PREC &lt; $GEN_FUN_PREC
+                    and not($SEM_SW=$SEM_ALL) and not($SEM_SW=$SEM_XREF)
+                    and not($SEM_SW=$SEM_XREF_EXT)">
+      <xsl:apply-templates select="." mode="minus">
+        <xsl:with-param name="PARAM" select="$PARAM"/>
+        <xsl:with-param name="PAREN" select="$PAREN"/>
+        <xsl:with-param name="PAR_NO_IGNORE" select="$PAR_NO_IGNORE"/>
+      </xsl:apply-templates>
+    </xsl:when>
+    <xsl:otherwise>
+      <mrow>
+        <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+          <xsl:attribute name="xref">
+            <xsl:value-of select="@id"/>
+          </xsl:attribute>
+        </xsl:if>
+        <xsl:apply-templates select="." mode="minus">
+          <xsl:with-param name="PARAM" select="$PARAM"/>
+          <xsl:with-param name="PAREN" select="$PAREN"/>
+          <xsl:with-param name="PAR_NO_IGNORE" select="$PAR_NO_IGNORE"/>
+        </xsl:apply-templates>
+      </mrow>
+    </xsl:otherwise>
+  </xsl:choose>
+</xsl:template>
+
+<xsl:template match = "apply[minus[1]]" mode="minus">
+  <xsl:param name="PARAM" select="$NO_PARAM"/>
+  <xsl:param name="PAREN" select="$PAR_NO"/>
+  <xsl:param name="PAR_NO_IGNORE" select="$YES"/>
+  <xsl:if test="not(*[3])">
+    <mo> - </mo>
+    <xsl:apply-templates select="*[2]" mode = "semantics">
+      <xsl:with-param name="IN_PREC" select="$NEG_PREC"/>
+      <xsl:with-param name="PAREN" select="$PAREN"/>
+      <xsl:with-param name="PAR_NO_IGNORE" select="$NO"/>
+    </xsl:apply-templates>
+  </xsl:if>
+  <xsl:if test="*[3]">
+    <xsl:apply-templates select="*[2]" mode = "semantics">
+      <xsl:with-param name="IN_PREC" select="$MINUS_PREC"/>
+      <xsl:with-param name="PARAM" select="$PARAM"/>
+      <xsl:with-param name="PAREN" select="$PAREN"/>
+      <xsl:with-param name="PAR_NO_IGNORE" select="$PAR_NO_IGNORE"/>
+    </xsl:apply-templates>
+    <mo> - </mo>
+    <xsl:apply-templates select="*[3]" mode = "semantics">
+      <xsl:with-param name="IN_PREC" select="$MINUS_PREC"/>
+      <xsl:with-param name="PARAM" select="$PAR_SAME"/>
+      <xsl:with-param name="PAREN" select="$PAREN"/>
+      <xsl:with-param name="PAR_NO_IGNORE" select="$NO"/>
+    </xsl:apply-templates>
+  </xsl:if>
+</xsl:template>
+
+
+<xsl:template match = "apply[plus[1]]">
+  <xsl:param name="IN_PREC" select="$NO_PREC"/>
+  <xsl:param name="PARAM" select="$NO_PARAM"/>
+  <xsl:param name="PAREN" select="$PAR_NO"/>
+  <xsl:param name="PAR_NO_IGNORE" select="$YES"/>
+  <xsl:choose>
+    <xsl:when test="$IN_PREC &lt; $GEN_FUN_PREC and
+                   ($IN_PREC &gt; $PLUS_PREC or $IN_PREC=$PLUS_PREC and $PARAM=$PAR_SAME)">
+      <mfenced separators="">
+        <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+          <xsl:attribute name="xref">
+            <xsl:value-of select="@id"/>
+          </xsl:attribute>
+        </xsl:if>
+        <xsl:apply-templates select="." mode="plus">
+          <xsl:with-param name="PARAM" select="$IN_PREC"/>
+          <xsl:with-param name="PAREN" select="$PAR_YES"/>
+          <xsl:with-param name="PAR_NO_IGNORE" select="$PAR_NO_IGNORE"/>
+        </xsl:apply-templates>
+      </mfenced>
+    </xsl:when>
+    <xsl:when test="$IN_PREC &gt; $NO_PREC and $IN_PREC &lt; $GEN_FUN_PREC
+                    and not($SEM_SW=$SEM_ALL) and not($SEM_SW=$SEM_XREF)
+                    and not($SEM_SW=$SEM_XREF_EXT)">
+      <xsl:apply-templates select="." mode="plus">
+        <xsl:with-param name="PARAM" select="$PARAM"/>
+        <xsl:with-param name="PAREN" select="$PAREN"/>
+        <xsl:with-param name="PAR_NO_IGNORE" select="$PAR_NO_IGNORE"/>
+      </xsl:apply-templates>
+    </xsl:when>
+    <xsl:otherwise>
+      <mrow>
+        <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+          <xsl:attribute name="xref">
+            <xsl:value-of select="@id"/>
+          </xsl:attribute>
+        </xsl:if>
+        <xsl:apply-templates select="." mode="plus">
+          <xsl:with-param name="PARAM" select="$IN_PREC"/>
+          <xsl:with-param name="PAREN" select="$PAREN"/>
+          <xsl:with-param name="PAR_NO_IGNORE" select="$PAR_NO_IGNORE"/>
+        </xsl:apply-templates>
+      </mrow>
+    </xsl:otherwise>
+  </xsl:choose>
+</xsl:template>
+
+<xsl:template match = "apply[plus[1]]" mode="plus">
+  <xsl:param name="PARAM" select="$NO_PARAM"/>
+  <xsl:param name="PAREN" select="$PAR_NO"/>
+  <xsl:param name="PAR_NO_IGNORE" select="$YES"/>
+  <xsl:if test="*[2]">
+    <xsl:apply-templates select="*[2]" mode = "semantics">
+      <xsl:with-param name="IN_PREC" select="$PLUS_PREC"/>
+      <xsl:with-param name="PARAM" select="$PARAM"/>
+      <xsl:with-param name="PAREN" select="$PAREN"/>
+      <xsl:with-param name="PAR_NO_IGNORE" select="$PAR_NO_IGNORE"/>
+    </xsl:apply-templates>
+    <xsl:for-each select = "*[position()>2]">
+      <xsl:choose>
+        <xsl:when test=". &lt; 0">
+          <mo> - </mo>
+          <mn> <xsl:value-of select="-."/> </mn>
+        </xsl:when>
+        <xsl:when test="self::apply[minus[1]] and not(*[3])">
+          <xsl:apply-templates select="." mode = "semantics">
+            <xsl:with-param name="IN_PREC" select="$PLUS_PREC"/>
+            <xsl:with-param name="PAREN" select="$PAREN"/>
+            <xsl:with-param name="PAR_NO_IGNORE" select="$NO"/>
+          </xsl:apply-templates>
+        </xsl:when>
+        <xsl:otherwise>
+          <mo> + </mo>
+          <xsl:apply-templates select="." mode = "semantics">
+            <xsl:with-param name="IN_PREC" select="$PLUS_PREC"/>
+            <xsl:with-param name="PAREN" select="$PAREN"/>
+            <xsl:with-param name="PAR_NO_IGNORE" select="$NO"/>
+          </xsl:apply-templates>
+        </xsl:otherwise>
+      </xsl:choose>
+    </xsl:for-each>
+  </xsl:if>
+</xsl:template>
+
+
+<xsl:template match = "apply[*[1][self::power]]">
+  <xsl:choose>
+    <xsl:when test="*[2]=apply[ln[1] | log[1] | abs[1] |
+                         gcd[1] | lcm[1] | sin[1] | cos[1] | tan[1] |
+                         sec[1] | csc[1] | cot[1] | sinh[1] |
+                         cosh[1] | tanh[1] | sech[1] | csch[1] |
+                         coth[1] | arcsin[1] | arccos[1] |
+                         arctan[1] | arcsec[1] | arccsc[1] |
+                         arccot[1] | arcsinh[1] | arccosh[1] |
+                         arctanh[1] | arcsech[1] | arccsch[1] |
+                         arccoth[1]]">
+      <xsl:apply-templates select="*[2]" mode = "semantics"/>
+    </xsl:when>
+    <xsl:otherwise>
+      <msup>
+        <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+          <xsl:attribute name="xref">
+            <xsl:value-of select="@id"/>
+          </xsl:attribute>
+        </xsl:if>
+        <xsl:apply-templates select = "*[2]" mode = "semantics">
+          <xsl:with-param name="IN_PREC" select="$FUNCTN_PREC"/>
+          <xsl:with-param name="PAR_NO_IGNORE" select="$NO"/>
+        </xsl:apply-templates>
+        <xsl:apply-templates select = "*[3]" mode = "semantics"/>
+      </msup>
+    </xsl:otherwise>
+  </xsl:choose>
+</xsl:template>
+
+
+<xsl:template match = "apply[divide[1]]">
+  <xsl:param name="IN_PREC" select="$NO_PREC"/>
+  <xsl:param name="PARAM" select="$NO_PARAM"/>
+  <xsl:param name="PAREN" select="$PAR_NO"/>
+  <xsl:param name="PAR_NO_IGNORE" select="$YES"/>
+  <xsl:choose>
+    <xsl:when test="$IN_PREC &lt; $GEN_FUN_PREC and
+                   ($IN_PREC &gt; $DIV_PREC or $IN_PREC=$DIV_PREC and $PARAM=$PAR_SAME)">
+      <mfenced separators="">
+        <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+          <xsl:attribute name="xref">
+            <xsl:value-of select="@id"/>
+          </xsl:attribute>
+        </xsl:if>
+        <xsl:apply-templates select="." mode="div">
+          <xsl:with-param name="PARAM" select="$IN_PREC"/>
+          <xsl:with-param name="PAREN" select="$PAR_YES"/>
+          <xsl:with-param name="PAR_NO_IGNORE" select="$PAR_NO_IGNORE"/>
+        </xsl:apply-templates>
+      </mfenced>
+    </xsl:when>
+    <xsl:when test="$IN_PREC &gt; $NO_PREC and $IN_PREC &lt; $GEN_FUN_PREC
+                    and not($SEM_SW=$SEM_ALL) and not($SEM_SW=$SEM_XREF)
+                    and not($SEM_SW=$SEM_XREF_EXT)">
+      <xsl:apply-templates select="." mode="div">
+        <xsl:with-param name="PARAM" select="$PARAM"/>
+        <xsl:with-param name="PAREN" select="$PAREN"/>
+        <xsl:with-param name="PAR_NO_IGNORE" select="$PAR_NO_IGNORE"/>
+      </xsl:apply-templates>
+    </xsl:when>
+    <xsl:otherwise>
+      <mrow>
+        <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+          <xsl:attribute name="xref">
+            <xsl:value-of select="@id"/>
+          </xsl:attribute>
+        </xsl:if>
+        <xsl:apply-templates select="." mode="div">
+          <xsl:with-param name="PARAM" select="$IN_PREC"/>
+          <xsl:with-param name="PAREN" select="$PAREN"/>
+          <xsl:with-param name="PAR_NO_IGNORE" select="$PAR_NO_IGNORE"/>
+        </xsl:apply-templates>
+      </mrow>
+    </xsl:otherwise>
+  </xsl:choose>
+</xsl:template>
+
+<xsl:template match = "apply[divide[1]]" mode="div">
+  <xsl:param name="PARAM" select="$NO_PARAM"/>
+  <xsl:param name="PAREN" select="$PAR_NO"/>
+  <xsl:param name="PAR_NO_IGNORE" select="$YES"/>
+  <mfrac>
+    <mrow>
+      <xsl:apply-templates select = "*[2]" mode = "semantics">
+        <xsl:with-param name="IN_PREC" select="$GEN_FUN_PREC"/>
+        <xsl:with-param name="PARAM" select="$PARAM"/>
+        <xsl:with-param name="PAREN" select="$PAREN"/>
+        <xsl:with-param name="PAR_NO_IGNORE" select="$PAR_NO_IGNORE"/>
+      </xsl:apply-templates>
+    </mrow>
+    <mrow>
+      <xsl:apply-templates select = "*[3]" mode = "semantics">
+        <xsl:with-param name="IN_PREC" select="$GEN_FUN_PREC"/>
+        <xsl:with-param name="PARAM" select="$PARAM"/>
+        <xsl:with-param name="PAREN" select="$PAREN"/>
+        <xsl:with-param name="PAR_NO_IGNORE" select="$PAR_NO_IGNORE"/>
+      </xsl:apply-templates>
+    </mrow>
+  </mfrac>
+</xsl:template>
+
+
+<xsl:template match = "apply[rem[1]]">
+  <xsl:param name="IN_PREC" select="$NO_PREC"/>
+  <xsl:param name="PARAM" select="$NO_PARAM"/>
+  <xsl:param name="PAREN" select="$PAR_NO"/>
+  <xsl:param name="PAR_NO_IGNORE" select="$YES"/>
+  <xsl:choose>
+    <xsl:when test="$IN_PREC &lt; $GEN_FUN_PREC and
+                   ($IN_PREC &gt; $REM_PREC or $IN_PREC=$REM_PREC and $PARAM=$PAR_SAME)">
+      <mfenced separators="">
+        <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+          <xsl:attribute name="xref">
+            <xsl:value-of select="@id"/>
+          </xsl:attribute>
+        </xsl:if>
+        <xsl:apply-templates select="." mode="rem">
+          <xsl:with-param name="PARAM" select="$IN_PREC"/>
+          <xsl:with-param name="PAREN" select="$PAR_YES"/>
+          <xsl:with-param name="PAR_NO_IGNORE" select="$PAR_NO_IGNORE"/>
+        </xsl:apply-templates>
+      </mfenced>
+    </xsl:when>
+    <xsl:when test="$IN_PREC &gt; $NO_PREC and $IN_PREC &lt; $GEN_FUN_PREC
+                    and not($SEM_SW=$SEM_ALL) and not($SEM_SW=$SEM_XREF)
+                    and not($SEM_SW=$SEM_XREF_EXT)">
+      <xsl:apply-templates select="." mode="rem">
+        <xsl:with-param name="PARAM" select="$PARAM"/>
+        <xsl:with-param name="PAREN" select="$PAREN"/>
+        <xsl:with-param name="PAR_NO_IGNORE" select="$PAR_NO_IGNORE"/>
+      </xsl:apply-templates>
+    </xsl:when>
+    <xsl:otherwise>
+      <mrow>
+        <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+          <xsl:attribute name="xref">
+            <xsl:value-of select="@id"/>
+          </xsl:attribute>
+        </xsl:if>
+        <xsl:apply-templates select="." mode="rem">
+          <xsl:with-param name="PARAM" select="$IN_PREC"/>
+          <xsl:with-param name="PAREN" select="$PAREN"/>
+          <xsl:with-param name="PAR_NO_IGNORE" select="$PAR_NO_IGNORE"/>
+        </xsl:apply-templates>
+      </mrow>
+    </xsl:otherwise>
+  </xsl:choose>
+</xsl:template>
+
+<xsl:template match = "apply[rem[1]]" mode="rem">
+  <xsl:param name="PARAM" select="$NO_PARAM"/>
+  <xsl:param name="PAREN" select="$PAR_NO"/>
+  <xsl:param name="PAR_NO_IGNORE" select="$YES"/>
+  <xsl:apply-templates select = "*[2]" mode = "semantics">
+    <xsl:with-param name="IN_PREC" select="$REM_PREC"/>
+    <xsl:with-param name="PARAM" select="$PARAM"/>
+    <xsl:with-param name="PAREN" select="$PAREN"/>
+    <xsl:with-param name="PAR_NO_IGNORE" select="$PAR_NO_IGNORE"/>
+  </xsl:apply-templates>
+  <mo lspace="thickmathspace" rspace="thickmathspace"> <xsl:value-of select="'mod'"/> </mo>
+  <xsl:apply-templates select = "*[3]" mode = "semantics">
+    <xsl:with-param name="IN_PREC" select="$REM_PREC"/>
+    <xsl:with-param name="PARAM" select="$PAR_SAME"/>
+    <xsl:with-param name="PAREN" select="$PAREN"/>
+    <xsl:with-param name="PAR_NO_IGNORE" select="$NO"/>
+  </xsl:apply-templates>
+</xsl:template>
+
+
+<xsl:template match = "apply[times[1]]">
+  <xsl:param name="IN_PREC" select="$NO_PREC"/>
+  <xsl:param name="PARAM" select="$NO_PARAM"/>
+  <xsl:param name="PAREN" select="$PAR_NO"/>
+  <xsl:param name="PAR_NO_IGNORE" select="$YES"/>
+  <xsl:choose>
+    <xsl:when test="$IN_PREC &lt; $GEN_FUN_PREC and
+                   ($IN_PREC &gt; $MUL_PREC or $IN_PREC=$MUL_PREC and $PARAM=$PAR_SAME)">
+      <mfenced separators="">
+        <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+          <xsl:attribute name="xref">
+            <xsl:value-of select="@id"/>
+          </xsl:attribute>
+        </xsl:if>
+        <xsl:apply-templates select="." mode="times">
+          <xsl:with-param name="PARAM" select="$IN_PREC"/>
+          <xsl:with-param name="PAREN" select="$PAR_YES"/>
+          <xsl:with-param name="PAR_NO_IGNORE" select="$PAR_NO_IGNORE"/>
+        </xsl:apply-templates>
+      </mfenced>
+    </xsl:when>
+    <xsl:when test="$IN_PREC &gt; $NO_PREC and $IN_PREC &lt; $GEN_FUN_PREC
+                    and not($SEM_SW=$SEM_ALL) and not($SEM_SW=$SEM_XREF)
+                    and not($SEM_SW=$SEM_XREF_EXT)">
+      <xsl:apply-templates select="." mode="times">
+        <xsl:with-param name="PARAM" select="$PARAM"/>
+        <xsl:with-param name="PAREN" select="$PAREN"/>
+        <xsl:with-param name="PAR_NO_IGNORE" select="$PAR_NO_IGNORE"/>
+      </xsl:apply-templates>
+    </xsl:when>
+    <xsl:otherwise>
+      <mrow>
+        <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+          <xsl:attribute name="xref">
+            <xsl:value-of select="@id"/>
+          </xsl:attribute>
+        </xsl:if>
+        <xsl:apply-templates select="." mode="times">
+          <xsl:with-param name="PARAM" select="$IN_PREC"/>
+          <xsl:with-param name="PAREN" select="$PAREN"/>
+          <xsl:with-param name="PAR_NO_IGNORE" select="$PAR_NO_IGNORE"/>
+        </xsl:apply-templates>
+      </mrow>
+    </xsl:otherwise>
+  </xsl:choose>
+</xsl:template>
+
+<xsl:template match = "apply[times[1]]" mode="times">
+  <xsl:param name="PARAM" select="$NO_PARAM"/>
+  <xsl:param name="PAREN" select="$PAR_NO"/>
+  <xsl:param name="PAR_NO_IGNORE" select="$YES"/>
+  <xsl:apply-templates select="*[2]" mode = "semantics">
+    <xsl:with-param name="IN_PREC" select="$MUL_PREC"/>
+    <xsl:with-param name="PARAM" select="$PARAM"/>
+    <xsl:with-param name="PAREN" select="$PAREN"/>
+    <xsl:with-param name="PAR_NO_IGNORE" select="$PAR_NO_IGNORE"/>
+  </xsl:apply-templates>
+  <xsl:if test="*[3]">
+    <xsl:for-each select = "*[position()>2]">
+      <mo> <xsl:text disable-output-escaping='yes'>&amp;#x2062;</xsl:text> </mo>
+      <xsl:apply-templates select="." mode = "semantics">
+        <xsl:with-param name="IN_PREC" select="$MUL_PREC"/>
+        <xsl:with-param name="PAREN" select="$PAREN"/>
+        <xsl:with-param name="PAR_NO_IGNORE" select="$NO"/>
+      </xsl:apply-templates>
+    </xsl:for-each>
+  </xsl:if>
+</xsl:template>
+
+
+<xsl:template match = "apply[*[1]=root and *[2]=degree]">
+  <mroot>
+    <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+      <xsl:attribute name="xref">
+        <xsl:value-of select="@id"/>
+      </xsl:attribute>
+    </xsl:if>
+    <xsl:apply-templates select="*[3]" mode = "semantics">
+      <xsl:with-param name="IN_PREC" select="$GEN_FUN_PREC"/>
+      <xsl:with-param name="PAR_NO_IGNORE" select="$NO"/>
+    </xsl:apply-templates>
+    <xsl:apply-templates select="*[2]" mode = "semantics"/>
+  </mroot>
+</xsl:template>
+
+<xsl:template match = "apply[*[1]=root and not(*[2]=degree)]">
+  <msqrt>
+    <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+      <xsl:attribute name="xref">
+        <xsl:value-of select="@id"/>
+      </xsl:attribute>
+    </xsl:if>
+    <xsl:apply-templates select="*[2]" mode = "semantics">
+      <xsl:with-param name="IN_PREC" select="$GEN_FUN_PREC"/>
+      <xsl:with-param name="PAR_NO_IGNORE" select="$NO"/>
+    </xsl:apply-templates>
+  </msqrt>
+</xsl:template>
+
+
+<xsl:template match = "apply[gcd[1] | lcm[1]]">
+  <mrow>
+    <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+      <xsl:attribute name="xref">
+        <xsl:value-of select="@id"/>
+      </xsl:attribute>
+    </xsl:if>
+    <xsl:if test="not(parent::apply[power[1]])">
+      <xsl:if test="gcd[1]">
+        <mo> gcd </mo>
+      </xsl:if>
+      <xsl:if test="lcm[1]">
+        <mo> lcm </mo>
+      </xsl:if>
+    </xsl:if>
+    <xsl:if test="parent::apply[power[1]]">
+      <msup>
+      <xsl:if test="gcd[1]">
+        <mo> gcd </mo>
+      </xsl:if>
+      <xsl:if test="lcm[1]">
+        <mo> lcm </mo>
+      </xsl:if>
+        <xsl:apply-templates select = "../*[3]" mode = "semantics"/>
+      </msup>
+    </xsl:if>
+    <mo> <xsl:text disable-output-escaping='yes'>&amp;#x2061;</xsl:text> </mo>
+    <mfenced separators=",">
+      <xsl:for-each select = "*[position()>1]">
+        <xsl:apply-templates select = "." mode="semantics"/>
+      </xsl:for-each>
+    </mfenced>
+  </mrow>
+</xsl:template>
+
+
+<xsl:template match = "apply[and[1]]">
+  <xsl:param name="IN_PREC" select="$NO_PREC"/>
+  <xsl:param name="PARAM" select="$NO_PARAM"/>
+  <xsl:param name="PAREN" select="$PAR_NO"/>
+  <xsl:param name="PAR_NO_IGNORE" select="$YES"/>
+  <xsl:choose>
+    <xsl:when test="$IN_PREC &lt; $GEN_FUN_PREC and
+                   ($IN_PREC &gt; $AND_PREC or $IN_PREC=$AND_PREC and $PARAM=$PAR_SAME)">
+      <mfenced separators="">
+        <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+          <xsl:attribute name="xref">
+            <xsl:value-of select="@id"/>
+          </xsl:attribute>
+        </xsl:if>
+        <xsl:apply-templates select="." mode="and">
+          <xsl:with-param name="PARAM" select="$IN_PREC"/>
+          <xsl:with-param name="PAREN" select="$PAR_YES"/>
+        </xsl:apply-templates>
+      </mfenced>
+    </xsl:when>
+    <xsl:when test="$IN_PREC &gt; $NO_PREC and $IN_PREC &lt; $GEN_FUN_PREC
+                    and not($SEM_SW=$SEM_ALL) and not($SEM_SW=$SEM_XREF)
+                    and not($SEM_SW=$SEM_XREF_EXT)">
+      <xsl:apply-templates select="." mode="and">
+        <xsl:with-param name="PARAM" select="$IN_PREC"/>
+        <xsl:with-param name="PAREN" select="$PAREN"/>
+        <xsl:with-param name="PAR_NO_IGNORE" select="$PAR_NO_IGNORE"/>
+      </xsl:apply-templates>
+    </xsl:when>
+    <xsl:otherwise>
+      <mrow>
+        <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+          <xsl:attribute name="xref">
+            <xsl:value-of select="@id"/>
+          </xsl:attribute>
+        </xsl:if>
+        <xsl:apply-templates select="." mode="and">
+          <xsl:with-param name="PARAM" select="$IN_PREC"/>
+          <xsl:with-param name="PAREN" select="$PAREN"/>
+          <xsl:with-param name="PAR_NO_IGNORE" select="$PAR_NO_IGNORE"/>
+        </xsl:apply-templates>
+      </mrow>
+    </xsl:otherwise>
+  </xsl:choose>
+</xsl:template>
+
+<xsl:template match = "apply[and[1]]" mode="and">
+  <xsl:param name="PARAM" select="$NO_PARAM"/>
+  <xsl:param name="PAREN" select="$PAR_NO"/>
+  <xsl:param name="PAR_NO_IGNORE" select="$YES"/>
+  <xsl:apply-templates select="*[2]" mode = "semantics">
+    <xsl:with-param name="IN_PREC" select="$AND_PREC"/>
+    <xsl:with-param name="PARAM" select="$PARAM"/>
+    <xsl:with-param name="PAREN" select="$PAREN"/>
+    <xsl:with-param name="PAR_NO_IGNORE" select="$PAR_NO_IGNORE"/>
+  </xsl:apply-templates>
+  <xsl:for-each select = "*[position()>2]">
+    <mo> <xsl:text disable-output-escaping='yes'>&amp;#x2227;</xsl:text> </mo>
+    <mo> <xsl:text disable-output-escaping='yes'>&amp;#x2061;</xsl:text> </mo>
+    <xsl:apply-templates select="." mode = "semantics">
+      <xsl:with-param name="IN_PREC" select="$AND_PREC"/>
+      <xsl:with-param name="PAREN" select="$PAREN"/>
+      <xsl:with-param name="PAR_NO_IGNORE" select="$NO"/>
+    </xsl:apply-templates>
+  </xsl:for-each>
+</xsl:template>
+
+
+<xsl:template match = "apply[or[1]]">
+  <xsl:param name="IN_PREC" select="$NO_PREC"/>
+  <xsl:param name="PARAM" select="$NO_PARAM"/>
+  <xsl:param name="PAREN" select="$PAR_NO"/>
+  <xsl:param name="PAR_NO_IGNORE" select="$YES"/>
+  <xsl:choose>
+    <xsl:when test="$IN_PREC &lt; $GEN_FUN_PREC and
+                   ($IN_PREC &gt; $OR_PREC or $IN_PREC=$OR_PREC and $PARAM=$PAR_SAME)">
+      <mfenced separators="">
+        <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+          <xsl:attribute name="xref">
+            <xsl:value-of select="@id"/>
+          </xsl:attribute>
+        </xsl:if>
+        <xsl:apply-templates select="." mode="or">
+          <xsl:with-param name="PARAM" select="$IN_PREC"/>
+          <xsl:with-param name="PAREN" select="$PAR_YES"/>
+        </xsl:apply-templates>
+      </mfenced>
+    </xsl:when>
+    <xsl:when test="$IN_PREC &gt; $NO_PREC and $IN_PREC &lt; $GEN_FUN_PREC
+                    and not($SEM_SW=$SEM_ALL) and not($SEM_SW=$SEM_XREF)
+                    and not($SEM_SW=$SEM_XREF_EXT)">
+      <xsl:apply-templates select="." mode="or">
+        <xsl:with-param name="PARAM" select="$IN_PREC"/>
+        <xsl:with-param name="PAREN" select="$PAREN"/>
+        <xsl:with-param name="PAR_NO_IGNORE" select="$PAR_NO_IGNORE"/>
+      </xsl:apply-templates>
+    </xsl:when>
+    <xsl:otherwise>
+      <mrow>
+        <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+          <xsl:attribute name="xref">
+            <xsl:value-of select="@id"/>
+          </xsl:attribute>
+        </xsl:if>
+        <xsl:apply-templates select="." mode="or">
+          <xsl:with-param name="PARAM" select="$IN_PREC"/>
+          <xsl:with-param name="PAREN" select="$PAREN"/>
+          <xsl:with-param name="PAR_NO_IGNORE" select="$PAR_NO_IGNORE"/>
+        </xsl:apply-templates>
+      </mrow>
+    </xsl:otherwise>
+  </xsl:choose>
+</xsl:template>
+
+<xsl:template match = "apply[or[1]]" mode="or">
+  <xsl:param name="PARAM" select="$NO_PARAM"/>
+  <xsl:param name="PAREN" select="$PAR_NO"/>
+  <xsl:param name="PAR_NO_IGNORE" select="$YES"/>
+  <xsl:apply-templates select="*[2]" mode = "semantics">
+    <xsl:with-param name="IN_PREC" select="$OR_PREC"/>
+    <xsl:with-param name="PARAM" select="$PARAM"/>
+    <xsl:with-param name="PAREN" select="$PAREN"/>
+    <xsl:with-param name="PAR_NO_IGNORE" select="$PAR_NO_IGNORE"/>
+  </xsl:apply-templates>
+  <xsl:for-each select = "*[position()>2]">
+    <mo> <xsl:text disable-output-escaping='yes'>&amp;#x2228;</xsl:text> </mo>
+    <mo> <xsl:text disable-output-escaping='yes'>&amp;#x2061;</xsl:text> </mo>
+    <xsl:apply-templates select="." mode = "semantics">
+      <xsl:with-param name="IN_PREC" select="$OR_PREC"/>
+      <xsl:with-param name="PAREN" select="$PAREN"/>
+      <xsl:with-param name="PAR_NO_IGNORE" select="$NO"/>
+    </xsl:apply-templates>
+  </xsl:for-each>
+</xsl:template>
+
+
+<xsl:template match = "apply[xor[1]]">
+  <xsl:param name="IN_PREC" select="$NO_PREC"/>
+  <xsl:param name="PARAM" select="$NO_PARAM"/>
+  <xsl:param name="PAREN" select="$PAR_NO"/>
+  <xsl:param name="PAR_NO_IGNORE" select="$YES"/>
+  <xsl:choose>
+    <xsl:when test="$IN_PREC &lt; $GEN_FUN_PREC and
+                   ($IN_PREC &gt; $XOR_PREC or $IN_PREC=$XOR_PREC and $PARAM=$PAR_SAME)">
+      <mfenced separators="">
+        <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+          <xsl:attribute name="xref">
+            <xsl:value-of select="@id"/>
+          </xsl:attribute>
+        </xsl:if>
+        <xsl:apply-templates select="." mode="xor">
+          <xsl:with-param name="PARAM" select="$IN_PREC"/>
+          <xsl:with-param name="PAREN" select="$PAR_YES"/>
+          <xsl:with-param name="PAR_NO_IGNORE" select="$PAR_NO_IGNORE"/>
+        </xsl:apply-templates>
+      </mfenced>
+    </xsl:when>
+    <xsl:when test="$IN_PREC &gt; $NO_PREC and $IN_PREC &lt; $GEN_FUN_PREC
+                                                and not($SEM_SW=$SEM_ALL)">
+      <xsl:apply-templates select="." mode="xor">
+        <xsl:with-param name="PARAM" select="$IN_PREC"/>
+        <xsl:with-param name="PAREN" select="$PAREN"/>
+      </xsl:apply-templates>
+    </xsl:when>
+    <xsl:otherwise>
+      <mrow>
+        <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+          <xsl:attribute name="xref">
+            <xsl:value-of select="@id"/>
+          </xsl:attribute>
+        </xsl:if>
+        <xsl:apply-templates select="." mode="xor">
+          <xsl:with-param name="PARAM" select="$IN_PREC"/>
+          <xsl:with-param name="PAREN" select="$PAREN"/>
+          <xsl:with-param name="PAR_NO_IGNORE" select="$PAR_NO_IGNORE"/>
+        </xsl:apply-templates>
+      </mrow>
+    </xsl:otherwise>
+  </xsl:choose>
+</xsl:template>
+
+<xsl:template match = "apply[xor[1]]" mode="xor">
+  <xsl:param name="PARAM" select="$NO_PARAM"/>
+  <xsl:param name="PAREN" select="$PAR_NO"/>
+  <xsl:param name="PAR_NO_IGNORE" select="$YES"/>
+  <xsl:apply-templates select="*[2]" mode = "semantics">
+    <xsl:with-param name="IN_PREC" select="$XOR_PREC"/>
+    <xsl:with-param name="PARAM" select="$PARAM"/>
+    <xsl:with-param name="PAREN" select="$PAREN"/>
+    <xsl:with-param name="PAR_NO_IGNORE" select="$PAR_NO_IGNORE"/>
+  </xsl:apply-templates>
+  <xsl:for-each select = "*[position()>2]">
+    <mo> <xsl:text disable-output-escaping='yes'>&amp;#x22BB;</xsl:text> </mo>
+    <mo> <xsl:text disable-output-escaping='yes'>&amp;#x2061;</xsl:text> </mo>
+    <xsl:apply-templates select="." mode = "semantics">
+      <xsl:with-param name="IN_PREC" select="$XOR_PREC"/>
+      <xsl:with-param name="PAREN" select="$PAREN"/>
+      <xsl:with-param name="PAR_NO_IGNORE" select="$NO"/>
+    </xsl:apply-templates>
+  </xsl:for-each>
+</xsl:template>
+
+
+<xsl:template match = "apply[not[1]]">
+  <xsl:param name="IN_PREC" select="$NO_PREC"/>
+  <xsl:param name="PARAM" select="$NO_PARAM"/>
+  <xsl:param name="PAREN" select="$PAR_NO"/>
+  <xsl:param name="PAR_NO_IGNORE" select="$YES"/>
+  <xsl:choose>
+    <xsl:when test="$IN_PREC &lt; $GEN_FUN_PREC and $IN_PREC &gt;= $NOT_PREC">
+      <mfenced separators="">
+        <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+          <xsl:attribute name="xref">
+            <xsl:value-of select="@id"/>
+          </xsl:attribute>
+        </xsl:if>
+        <mo> <xsl:text disable-output-escaping='yes'>&amp;#x00AC;</xsl:text> </mo>
+        <mo> <xsl:text disable-output-escaping='yes'>&amp;#x2061;</xsl:text> </mo>
+        <xsl:apply-templates select = "*[2]" mode = "semantics">
+          <xsl:with-param name="IN_PREC" select="$NOT_PREC"/>
+          <xsl:with-param name="PAREN" select="$PAREN"/>
+          <xsl:with-param name="PAR_NO_IGNORE" select="$NO"/>
+        </xsl:apply-templates>
+	  </mfenced>
+    </xsl:when>
+    <xsl:otherwise>
+      <mrow>
+        <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+          <xsl:attribute name="xref">
+            <xsl:value-of select="@id"/>
+          </xsl:attribute>
+        </xsl:if>
+        <mo> <xsl:text disable-output-escaping='yes'>&amp;#x00AC;</xsl:text> </mo>
+        <mo> <xsl:text disable-output-escaping='yes'>&amp;#x2061;</xsl:text> </mo>
+        <xsl:apply-templates select = "*[2]" mode = "semantics">
+          <xsl:with-param name="IN_PREC" select="$NOT_PREC"/>
+          <xsl:with-param name="PAREN" select="$PAREN"/>
+          <xsl:with-param name="PAR_NO_IGNORE" select="$NO"/>
+        </xsl:apply-templates>
+      </mrow>
+    </xsl:otherwise>
+  </xsl:choose>
+</xsl:template>
+
+
+<xsl:template match = "apply[forall[1]]">
+  <mrow>
+    <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+      <xsl:attribute name="xref">
+        <xsl:value-of select="@id"/>
+      </xsl:attribute>
+    </xsl:if>
+    <mo> <xsl:text disable-output-escaping='yes'>&amp;#x2200;</xsl:text> </mo>
+    <xsl:if test="count(bvar)=1">
+      <xsl:apply-templates select = "bvar" mode="semantics"/>
+    </xsl:if>
+    <xsl:if test="count(bvar) &gt; 1">
+      <mfenced open="" close="">
+        <xsl:for-each select = "bvar">
+          <xsl:apply-templates select = "." mode="semantics"/>
+        </xsl:for-each>
+      </mfenced>
+    </xsl:if>
+	<xsl:if test="condition">
+      <mo> : </mo>
+      <xsl:apply-templates select = "condition/*" mode = "semantics"/>
+    </xsl:if>
+	<xsl:if test="*[position()>1 and not(self::bvar) and not(self::condition)]">
+      <mo> , </mo>
+      <xsl:apply-templates select = "*[position()>1 and not(self::bvar) and
+                                not(self::condition)]" mode = "semantics"/>
+    </xsl:if>
+  </mrow>
+</xsl:template>
+
+
+<xsl:template match = "apply[exists[1]]">
+  <mrow>
+    <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+      <xsl:attribute name="xref">
+        <xsl:value-of select="@id"/>
+      </xsl:attribute>
+    </xsl:if>
+    <mo> <xsl:text disable-output-escaping='yes'>&amp;#x2203;</xsl:text> </mo>
+    <xsl:if test="count(bvar) &gt; 1">
+      <mfenced open="" close="">
+        <xsl:for-each select = "bvar">
+          <xsl:apply-templates select = "." mode="semantics"/>
+        </xsl:for-each>
+      </mfenced>
+    </xsl:if>
+    <xsl:if test="count(bvar)=1">
+      <xsl:apply-templates select = "bvar" mode="semantics"/>
+    </xsl:if>
+    <xsl:if test="condition">
+      <mo> : </mo>
+      <xsl:apply-templates select = "condition/*" mode = "semantics"/>
+    </xsl:if>
+    <xsl:if test="*[position()>1 and not(self::bvar) and not(self::condition)]">
+      <mo> , </mo>
+      <xsl:apply-templates select = "*[position()>1 and not(self::bvar) and
+                                not(self::condition)]" mode = "semantics"/>
+    </xsl:if>
+  </mrow>
+</xsl:template>
+
+
+<xsl:template match = "apply[abs[1]]">
+  <xsl:if test="not(parent::apply[power[1]])">
+    <mfenced open="&#x2223;" close="&#x2223;" separators="">
+      <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+        <xsl:attribute name="xref">
+          <xsl:value-of select="@id"/>
+        </xsl:attribute>
+      </xsl:if>
+      <xsl:apply-templates select = "*[position()>1]" mode = "semantics"/>
+    </mfenced>
+  </xsl:if>
+  <xsl:if test="parent::apply[power[1]]">
+    <msup>
+      <mfenced open="&#x2223;" close="&#x2223;" separators="">
+        <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+          <xsl:attribute name="xref">
+            <xsl:value-of select="@id"/>
+          </xsl:attribute>
+        </xsl:if>
+        <xsl:apply-templates select = "*[position()>1]" mode = "semantics"/>
+      </mfenced>
+      <xsl:apply-templates select = "../*[3]" mode = "semantics"/>
+    </msup>
+  </xsl:if>
+</xsl:template>
+
+
+<xsl:template match = "apply[conjugate[1]]">
+  <mover>
+    <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+      <xsl:attribute name="xref">
+        <xsl:value-of select="@id"/>
+      </xsl:attribute>
+    </xsl:if>
+    <mrow>
+      <xsl:apply-templates select = "*[position()>1]" mode = "semantics"/>
+    </mrow>
+    <mo> <xsl:text disable-output-escaping='yes'>&amp;#x00AF;</xsl:text> </mo>
+  </mover>
+</xsl:template>
+
+
+<xsl:template match = "apply[arg[1] | real[1] | imaginary[1]]">
+  <mrow>
+    <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+      <xsl:attribute name="xref">
+        <xsl:value-of select="@id"/>
+      </xsl:attribute>
+    </xsl:if>
+    <mo>
+      <xsl:if test="arg">
+        <xsl:value-of select="'arg'"/>
+      </xsl:if>
+      <xsl:if test="real">
+        <xsl:text disable-output-escaping='yes'>&amp;#x211C;</xsl:text>
+      </xsl:if>
+      <xsl:if test="imaginary">
+        <xsl:text disable-output-escaping='yes'>&amp;#x2111;</xsl:text>
+      </xsl:if>
+    </mo>
+    <mo> <xsl:text disable-output-escaping='yes'>&amp;#x2061;</xsl:text> </mo>
+    <mfenced separators="">
+      <xsl:apply-templates select = "*[2]" mode = "semantics"/>
+    </mfenced>
+  </mrow>
+</xsl:template>
+
+
+<xsl:template match = "apply[floor[1] or ceiling[1]]">
+  <mrow>
+    <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+      <xsl:attribute name="xref">
+        <xsl:value-of select="@id"/>
+      </xsl:attribute>
+    </xsl:if>
+    <mo>
+      <xsl:if test="floor[1]">
+        <xsl:text disable-output-escaping='yes'>&amp;#x230A;</xsl:text>
+      </xsl:if>
+      <xsl:if test="ceiling[1]">
+        <xsl:text disable-output-escaping='yes'>&amp;#x2308;</xsl:text>
+      </xsl:if>
+    </mo>
+    <xsl:apply-templates select="*[position()>1]"  mode="semantics"/>
+    <mo>
+      <xsl:if test="floor[1]">
+        <xsl:text disable-output-escaping='yes'>&amp;#x230B;</xsl:text>
+      </xsl:if>
+      <xsl:if test="ceiling[1]">
+        <xsl:text disable-output-escaping='yes'>&amp;#x2309;</xsl:text>
+      </xsl:if>
+    </mo>
+  </mrow>
+</xsl:template>
+
+
+
+<!-- ***************** RELATIONS ***************** -->
+
+<xsl:template match = "apply[neq | approx | tendsto | implies
+                     | in | notin | notsubset | notprsubset
+                     | subset | prsubset | eq | gt | lt
+                     | geq | leq | equivalent | factorof]">
+  <mrow>
+    <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+      <xsl:attribute name="xref">
+        <xsl:value-of select="@id"/>
+      </xsl:attribute>
+    </xsl:if>
+    <xsl:apply-templates select="."  mode="relations"/>
+  </mrow>
+</xsl:template>
+
+<!-- reln is ***DEPRECATED*** -->
+<xsl:template match = "reln[neq | approx | tendsto | implies
+                     | in | notin | notsubset | notprsubset
+                     | subset | prsubset | eq | gt | lt
+                     | geq | leq | equivalent | factorof]">
+  <mrow>
+    <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+      <xsl:attribute name="xref">
+        <xsl:value-of select="@id"/>
+      </xsl:attribute>
+    </xsl:if>
+    <xsl:apply-templates select="."  mode="relations"/>
+  </mrow>
+</xsl:template>
+
+<xsl:template match = "*" mode="relations">
+  <xsl:if test="*[1]=neq or *[1]=approx or *[1]=factorof or *[1]=tendsto or
+                *[1]=implies or *[1]=in or *[1]=notin or
+                *[1]=notsubset or *[1]=notprsubset">
+    <xsl:apply-templates select = "*[2]" mode = "semantics"/>
+    <mo>
+      <xsl:if test="*[1]=neq">
+        <xsl:text disable-output-escaping='yes'>&amp;#x2260;</xsl:text>
+      </xsl:if>
+      <xsl:if test="*[1]=approx">
+        <xsl:text disable-output-escaping='yes'>&amp;#x2248;</xsl:text>
+      </xsl:if>
+      <xsl:if test="*[1]=factorof">
+        <xsl:text disable-output-escaping='yes'>&amp;#x2223;</xsl:text>
+      </xsl:if>
+      <xsl:if test="*[1]=tendsto">
+        <xsl:choose>
+          <xsl:when test="tendsto[@type='above']">
+            <xsl:text disable-output-escaping='yes'>&amp;#x2198;</xsl:text>
+          </xsl:when>
+          <xsl:when test="tendsto[@type='below']">
+            <xsl:text disable-output-escaping='yes'>&amp;#x2197;</xsl:text>
+          </xsl:when>
+		  <xsl:otherwise>
+            <xsl:text disable-output-escaping='yes'>&amp;#x2192;</xsl:text>
+          </xsl:otherwise>
+        </xsl:choose>
+      </xsl:if>
+      <xsl:if test="*[1]=implies">
+        <xsl:text disable-output-escaping='yes'>&amp;#x21D2;</xsl:text>
+      </xsl:if>
+      <xsl:if test="*[1]=in">
+        <xsl:text disable-output-escaping='yes'>&amp;#x2208;</xsl:text>
+      </xsl:if>
+      <xsl:if test="*[1]=notin">
+        <xsl:text disable-output-escaping='yes'>&amp;#x2209;</xsl:text>
+      </xsl:if>
+      <xsl:if test="*[1]=notsubset">
+        <xsl:text disable-output-escaping='yes'>&amp;#x2284;</xsl:text>
+      </xsl:if>
+      <xsl:if test="*[1]=notprsubset">
+        <xsl:text disable-output-escaping='yes'>&amp;#x2288;</xsl:text>
+      </xsl:if>
+    </mo>
+    <xsl:apply-templates select = "*[3]" mode = "semantics"/>
+  </xsl:if>
+  <xsl:if test="*[1]=subset or *[1]=prsubset or *[1]=eq or *[1]=gt
+             or *[1]=lt or *[1]=geq or *[1]=leq or *[1]=equivalent">
+    <xsl:apply-templates select = "*[2]" mode="semantics"/>
+    <xsl:for-each select = "*[position()>2]">
+      <mo>
+        <xsl:if test="../*[self::subset][1]">
+          <xsl:text disable-output-escaping='yes'>&amp;#x2286;</xsl:text>
+        </xsl:if>
+        <xsl:if test="../*[self::prsubset][1]">
+         <xsl:text disable-output-escaping='yes'>&amp;#x2282;</xsl:text>
+        </xsl:if>
+        <xsl:if test="../*[self::eq][1]">
+          <xsl:value-of select="'='"/>
+        </xsl:if>
+        <xsl:if test="../*[self::gt][1]">
+          <xsl:value-of select="'&gt;'"/>
+        </xsl:if>
+        <xsl:if test="../*[self::lt][1]">
+          <xsl:value-of select="'&lt;'"/>
+        </xsl:if>
+        <xsl:if test="../*[self::geq][1]">
+         <xsl:text disable-output-escaping='yes'>&amp;#x2265;</xsl:text>
+        </xsl:if>
+        <xsl:if test="../*[self::leq][1]">
+         <xsl:text disable-output-escaping='yes'>&amp;#x2264;</xsl:text>
+        </xsl:if>
+        <xsl:if test="../*[self::equivalent][1]">
+         <xsl:text disable-output-escaping='yes'>&amp;#x2261;</xsl:text>
+        </xsl:if>
+      </mo>
+      <xsl:apply-templates select = "." mode="semantics"/>
+    </xsl:for-each>
+  </xsl:if>
+</xsl:template>
+
+
+
+<!-- ***************** CALCULUS ***************** -->
+
+<xsl:template match = "apply[*[1][self::ln]]">
+  <mrow>
+    <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+      <xsl:attribute name="xref">
+        <xsl:value-of select="@id"/>
+      </xsl:attribute>
+    </xsl:if>
+    <xsl:choose>
+      <xsl:when test="parent::apply[power[1]]">
+        <msup>
+          <mo> ln </mo>
+          <xsl:apply-templates select = "../*[3]" mode = "semantics"/>
+        </msup>
+      </xsl:when>
+      <xsl:otherwise>
+        <mo rspace="thinmathspace"> ln </mo>
+      </xsl:otherwise>
+    </xsl:choose>
+    <xsl:apply-templates select = "*[2]" mode = "semantics">
+      <xsl:with-param name="IN_PREC" select="$FUNCTN_PREC"/>
+      <xsl:with-param name="PAR_NO_IGNORE" select="$NO"/>
+    </xsl:apply-templates>
+  </mrow>
+</xsl:template>
+
+
+<xsl:template match = "apply[log[1]]">
+  <mrow>
+    <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+      <xsl:attribute name="xref">
+        <xsl:value-of select="@id"/>
+      </xsl:attribute>
+    </xsl:if>
+    <xsl:choose>
+      <xsl:when test="parent::apply[power[1]]">
+        <xsl:if test="not(*[2]=logbase)">
+          <msup>
+            <mo> log </mo>
+            <xsl:apply-templates select = "../*[3]" mode = "semantics"/>
+          </msup>
+        </xsl:if>
+        <xsl:if test="*[2]=logbase">
+          <msubsup>
+            <mo> log </mo>
+            <xsl:apply-templates select = "../*[3]" mode = "semantics"/>
+            <xsl:apply-templates select = "logbase" mode = "semantics"/>
+          </msubsup>
+        </xsl:if>
+      </xsl:when>
+      <xsl:otherwise>
+        <xsl:if test="not(*[2]=logbase)">
+          <mo rspace="thinmathspace"> log </mo>
+        </xsl:if>
+        <xsl:if test="*[2]=logbase">
+          <msub>
+            <mo> log </mo>
+            <xsl:apply-templates select = "logbase" mode = "semantics"/>
+          </msub>
+        </xsl:if>
+      </xsl:otherwise>
+    </xsl:choose>
+    <xsl:if test="*[2]=logbase">
+      <xsl:apply-templates select = "*[3]" mode = "semantics">
+        <xsl:with-param name="IN_PREC" select="$FUNCTN_PREC"/>
+        <xsl:with-param name="PAR_NO_IGNORE" select="$NO"/>
+      </xsl:apply-templates>
+    </xsl:if>
+    <xsl:if test="not(*[2]=logbase)">
+      <xsl:apply-templates select = "*[2]" mode = "semantics">
+        <xsl:with-param name="IN_PREC" select="$FUNCTN_PREC"/>
+        <xsl:with-param name="PAR_NO_IGNORE" select="$NO"/>
+      </xsl:apply-templates>
+    </xsl:if>
+  </mrow>
+</xsl:template>
+
+
+<xsl:template match = "apply[diff[1]]">
+  <mrow>
+    <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+      <xsl:attribute name="xref">
+        <xsl:value-of select="@id"/>
+      </xsl:attribute>
+    </xsl:if>
+	<xsl:choose>
+      <xsl:when test="bvar">
+        <xsl:if test="not(bvar[*[2]=degree])">
+          <mfrac>
+            <mo> <xsl:text disable-output-escaping='yes'>d</xsl:text> </mo>
+            <mrow>
+              <mo> <xsl:text disable-output-escaping='yes'>d</xsl:text> </mo>
+              <xsl:apply-templates select = "bvar/*[1]" mode = "semantics"/>
+            </mrow>
+          </mfrac>
+        </xsl:if>
+        <xsl:if test="bvar[*[2]=degree]">
+          <mfrac>
+            <msup>
+              <mo> <xsl:text disable-output-escaping='yes'>d</xsl:text> </mo>
+              <xsl:apply-templates select = "bvar/degree" mode = "semantics"/>
+            </msup>
+            <mrow>
+              <mo> <xsl:text disable-output-escaping='yes'>d</xsl:text> </mo>
+              <msup>
+                <xsl:apply-templates select = "bvar/*[1]" mode = "semantics"/>
+                <xsl:apply-templates select = "bvar/degree" mode = "semantics"/>
+              </msup>
+            </mrow>
+          </mfrac>
+        </xsl:if>
+        <xsl:apply-templates select = "*[position()=last() and not(self::bvar)]" mode = "semantics">
+          <xsl:with-param name="IN_PREC" select="$FUNCTN_PREC"/>
+          <xsl:with-param name="PAR_NO_IGNORE" select="$NO"/>
+        </xsl:apply-templates>
+      </xsl:when>
+      <xsl:otherwise>
+        <xsl:apply-templates select = "*[position()=last() and not(self::bvar)]" mode = "semantics">
+          <xsl:with-param name="IN_PREC" select="$FUNCTN_PREC"/>
+          <xsl:with-param name="PAR_NO_IGNORE" select="$NO"/>
+        </xsl:apply-templates>
+        <mo> <xsl:text disable-output-escaping='yes'>&amp;#x2032;</xsl:text> </mo>
+	  </xsl:otherwise>
+    </xsl:choose>
+  </mrow>
+</xsl:template>
+
+
+<xsl:template match = "apply[partialdiff[1]]">
+  <mrow>
+    <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+      <xsl:attribute name="xref">
+        <xsl:value-of select="@id"/>
+      </xsl:attribute>
+    </xsl:if>
+    <xsl:choose>
+      <xsl:when test="list">
+        <msub>
+          <mo> <xsl:text disable-output-escaping='yes'>&amp;#x2145;</xsl:text> </mo>
+          <xsl:apply-templates select = "list" mode = "semantics"/>
+        </msub>
+      </xsl:when>
+      <xsl:otherwise>
+        <xsl:if test="degree">
+		  <mfrac>
+            <msup>
+              <mo> <xsl:text disable-output-escaping='yes'>&amp;#x2202;</xsl:text> </mo>
+              <xsl:apply-templates select = "degree" mode = "semantics"/>
+            </msup>
+            <mrow>
+              <xsl:for-each select = "bvar">
+                <mo> <xsl:text disable-output-escaping='yes'>&amp;#x2202;</xsl:text> </mo>
+                <xsl:if test="*[last()]=degree">
+                  <msup>
+                    <xsl:apply-templates select = "*[1]" mode = "semantics"/>
+                    <xsl:apply-templates select = "degree" mode = "semantics"/>
+                  </msup>
+                </xsl:if>
+                <xsl:if test="not(*[last()]=degree)">
+                  <xsl:apply-templates select = "*[1]" mode = "semantics"/>
+                </xsl:if>
+              </xsl:for-each>
+            </mrow>
+		  </mfrac>
+		</xsl:if>
+        <xsl:if test="not(degree)">
+          <xsl:for-each select = "bvar">
+            <xsl:if test="*[last()]=degree">
+              <mfrac>
+                <msup>
+                  <mo> <xsl:text disable-output-escaping='yes'>&amp;#x2202;</xsl:text> </mo>
+                  <xsl:apply-templates select = "degree" mode = "semantics"/>
+                </msup>
+                <mrow>
+                  <mo> <xsl:text disable-output-escaping='yes'>&amp;#x2202;</xsl:text> </mo>
+                  <msup>
+                    <xsl:apply-templates select = "*[1]" mode = "semantics"/>
+                    <xsl:apply-templates select = "degree" mode = "semantics"/>
+                  </msup>
+                </mrow>
+              </mfrac>
+            </xsl:if>
+            <xsl:if test="not(*[last()]=degree)">
+              <mfrac>
+                <mo> <xsl:text disable-output-escaping='yes'>&amp;#x2202;</xsl:text> </mo>
+                <mrow>
+                  <mo> <xsl:text disable-output-escaping='yes'>&amp;#x2202;</xsl:text> </mo>
+                  <xsl:apply-templates select = "*[1]" mode = "semantics"/>
+                </mrow>
+              </mfrac>
+            </xsl:if>
+          </xsl:for-each>
+		</xsl:if>
+	  </xsl:otherwise>
+	</xsl:choose>
+	<xsl:apply-templates select = "*[last()]" mode = "semantics">
+      <xsl:with-param name="IN_PREC" select="$GEN_FUN_PREC"/>
+      <xsl:with-param name="PAR_NO_IGNORE" select="$NO"/>
+    </xsl:apply-templates>
+  </mrow>
+</xsl:template>
+
+
+<xsl:template match = "lowlimit | uplimit | bvar | degree | logbase">
+  <mrow>
+    <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+      <xsl:attribute name="xref">
+        <xsl:value-of select="@id"/>
+      </xsl:attribute>
+    </xsl:if>
+    <xsl:apply-templates select="*" mode = "semantics"/>
+  </mrow>
+</xsl:template>
+
+
+<xsl:template match = "apply[divergence[1] | grad[1] | curl[1]]">
+  <mrow>
+    <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+      <xsl:attribute name="xref">
+        <xsl:value-of select="@id"/>
+      </xsl:attribute>
+    </xsl:if>
+    <mo>
+      <xsl:if test="*[1]=divergence">
+        <xsl:value-of select="'div'"/>
+      </xsl:if>
+      <xsl:if test="*[1]=grad">
+        <xsl:value-of select="'grad'"/>
+      </xsl:if>
+      <xsl:if test="*[1]=curl">
+        <xsl:value-of select="'curl'"/>
+      </xsl:if>
+    </mo>
+    <mspace width="0.01em" linebreak="nobreak"/>
+    <xsl:choose>
+      <xsl:when test="*[2]=ci">
+        <xsl:apply-templates select = "*[2]" mode = "semantics"/>
+      </xsl:when>
+      <xsl:otherwise>
+        <mfenced separators="">
+          <xsl:apply-templates select = "*[2]" mode = "semantics"/>
+        </mfenced>
+      </xsl:otherwise>
+    </xsl:choose>
+  </mrow>
+</xsl:template>
+
+
+<xsl:template match = "apply[laplacian[1]]">
+  <mrow>
+    <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+      <xsl:attribute name="xref">
+        <xsl:value-of select="@id"/>
+      </xsl:attribute>
+    </xsl:if>
+    <msup>
+      <mo> <xsl:text disable-output-escaping='yes'>&amp;#x2207;</xsl:text> </mo>
+      <mn> 2 </mn>
+    </msup>
+    <mo> <xsl:text disable-output-escaping='yes'>&amp;#x2061;</xsl:text> </mo>
+    <xsl:apply-templates select = "*[2]" mode = "semantics">
+      <xsl:with-param name="IN_PREC" select="$GEN_FUN_PREC"/>
+      <xsl:with-param name="PAR_NO_IGNORE" select="$NO"/>
+    </xsl:apply-templates>
+  </mrow>
+</xsl:template>
+
+
+
+<!-- ***************** SET THEORY ***************** -->
+
+<xsl:template match = "set | list">
+  <mfenced>
+    <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+      <xsl:attribute name="xref">
+        <xsl:value-of select="@id"/>
+      </xsl:attribute>
+    </xsl:if>
+	<xsl:if test="self::set">
+      <xsl:attribute name="open">
+        <xsl:value-of select="'{'"/>
+      </xsl:attribute>
+      <xsl:attribute name="close">
+        <xsl:value-of select="'}'"/>
+      </xsl:attribute>
+    </xsl:if>
+	<xsl:if test="self::list">
+      <xsl:attribute name="open">
+        <xsl:value-of select="'['"/>
+      </xsl:attribute>
+      <xsl:attribute name="close">
+        <xsl:value-of select="']'"/>
+      </xsl:attribute>
+    </xsl:if>
+    <xsl:choose>
+      <xsl:when test="not(child::bvar) and not(child::condition)">
+        <xsl:apply-templates select = "*" mode="semantics"/>
+      </xsl:when>
+      <xsl:otherwise>
+        <xsl:attribute name="separators"/>
+        <xsl:apply-templates select = "*[not(self::condition) and not(self::bvar)]" mode="semantics"/>
+        <mo lspace="0.1666em" rspace="0.1666em"> | </mo>
+        <xsl:apply-templates select="condition" mode = "semantics"/>
+      </xsl:otherwise>
+    </xsl:choose>
+  </mfenced>
+</xsl:template>
+
+
+<xsl:template match = "apply[union[1]]">
+  <xsl:param name="IN_PREC" select="$NO_PREC"/>
+  <xsl:param name="PARAM" select="$NO_PARAM"/>
+  <xsl:param name="PAREN" select="$PAR_NO"/>
+  <xsl:param name="PAR_NO_IGNORE" select="$YES"/>
+  <xsl:choose>
+    <xsl:when test="$IN_PREC &gt; $UNION_PREC or $IN_PREC=$UNION_PREC
+                    and $PARAM=$PAR_SAME">
+      <mfenced separators="">
+        <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+          <xsl:attribute name="xref">
+            <xsl:value-of select="@id"/>
+          </xsl:attribute>
+        </xsl:if>
+        <xsl:apply-templates select="." mode="union">
+          <xsl:with-param name="PARAM" select="$PARAM"/>
+          <xsl:with-param name="PAREN" select="$PAREN"/>
+          <xsl:with-param name="PAR_NO_IGNORE" select="$PAR_NO_IGNORE"/>
+        </xsl:apply-templates>
+      </mfenced>
+    </xsl:when>
+    <xsl:when test="$IN_PREC &gt; $NO_PREC and $IN_PREC &lt; $GEN_FUN_PREC
+                    and not($SEM_SW=$SEM_ALL) and not($SEM_SW=$SEM_XREF)
+                    and not($SEM_SW=$SEM_XREF_EXT)">
+      <xsl:apply-templates select="." mode="union">
+        <xsl:with-param name="PARAM" select="$PARAM"/>
+        <xsl:with-param name="PAREN" select="$PAREN"/>
+        <xsl:with-param name="PAR_NO_IGNORE" select="$PAR_NO_IGNORE"/>
+      </xsl:apply-templates>
+    </xsl:when>
+    <xsl:otherwise>
+      <mrow>
+        <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+          <xsl:attribute name="xref">
+            <xsl:value-of select="@id"/>
+          </xsl:attribute>
+        </xsl:if>
+        <xsl:apply-templates select="." mode="union">
+          <xsl:with-param name="PARAM" select="$PARAM"/>
+          <xsl:with-param name="PAREN" select="$PAREN"/>
+          <xsl:with-param name="PAR_NO_IGNORE" select="$PAR_NO_IGNORE"/>
+        </xsl:apply-templates>
+      </mrow>
+    </xsl:otherwise>
+  </xsl:choose>
+</xsl:template>
+
+
+<xsl:template match = "apply[union[1]]" mode="union">
+  <xsl:param name="PARAM" select="$NO_PARAM"/>
+  <xsl:param name="PAREN" select="$PAR_NO"/>
+  <xsl:param name="PAR_NO_IGNORE" select="$YES"/>
+  <xsl:apply-templates select = "*[2]" mode="semantics">
+    <xsl:with-param name="IN_PREC" select="$UNION_PREC"/>
+    <xsl:with-param name="PARAM" select="$PARAM"/>
+    <xsl:with-param name="PAREN" select="$PAREN"/>
+    <xsl:with-param name="PAR_NO_IGNORE" select="$PAR_NO_IGNORE"/>
+  </xsl:apply-templates>
+  <xsl:for-each select = "*[position()>2]">
+    <mo> <xsl:text disable-output-escaping='yes'>&amp;#x222A;</xsl:text> </mo>
+    <xsl:apply-templates select = "." mode="semantics">
+      <xsl:with-param name="IN_PREC" select="$UNION_PREC"/>
+      <xsl:with-param name="PAREN" select="$PAREN"/>
+      <xsl:with-param name="PAR_NO_IGNORE" select="$NO"/>
+    </xsl:apply-templates>
+  </xsl:for-each>
+</xsl:template>
+
+
+<xsl:template match = "apply[intersect[1]]">
+  <xsl:param name="IN_PREC" select="$NO_PREC"/>
+  <xsl:param name="PARAM" select="$NO_PARAM"/>
+  <xsl:param name="PAREN" select="$PAR_NO"/>
+  <xsl:param name="PAR_NO_IGNORE" select="$YES"/>
+  <xsl:choose>
+    <xsl:when test="$IN_PREC &gt; $INTERSECT_PREC or $IN_PREC=$INTERSECT_PREC
+                    and $PARAM=$PAR_SAME">
+      <mfenced separators="">
+        <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+          <xsl:attribute name="xref">
+            <xsl:value-of select="@id"/>
+          </xsl:attribute>
+        </xsl:if>
+        <xsl:apply-templates select="." mode="intersect">
+          <xsl:with-param name="PARAM" select="$PARAM"/>
+          <xsl:with-param name="PAREN" select="$PAREN"/>
+          <xsl:with-param name="PAR_NO_IGNORE" select="$PAR_NO_IGNORE"/>
+        </xsl:apply-templates>
+      </mfenced>
+    </xsl:when>
+    <xsl:when test="$IN_PREC &gt; $NO_PREC and $IN_PREC &lt; $GEN_FUN_PREC
+                    and not($SEM_SW=$SEM_ALL) and not($SEM_SW=$SEM_XREF)
+                    and not($SEM_SW=$SEM_XREF_EXT)">
+      <xsl:apply-templates select="." mode="intersect">
+        <xsl:with-param name="PARAM" select="$PARAM"/>
+        <xsl:with-param name="PAREN" select="$PAREN"/>
+        <xsl:with-param name="PAR_NO_IGNORE" select="$PAR_NO_IGNORE"/>
+      </xsl:apply-templates>
+    </xsl:when>
+    <xsl:otherwise>
+      <mrow>
+        <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+          <xsl:attribute name="xref">
+            <xsl:value-of select="@id"/>
+          </xsl:attribute>
+        </xsl:if>
+        <xsl:apply-templates select="." mode="intersect">
+          <xsl:with-param name="PARAM" select="$PARAM"/>
+          <xsl:with-param name="PAREN" select="$PAREN"/>
+          <xsl:with-param name="PAR_NO_IGNORE" select="$PAR_NO_IGNORE"/>
+        </xsl:apply-templates>
+      </mrow>
+    </xsl:otherwise>
+  </xsl:choose>
+</xsl:template>
+
+<xsl:template match = "apply[intersect[1]]" mode="intersect">
+  <xsl:param name="PARAM" select="$NO_PARAM"/>
+  <xsl:param name="PAREN" select="$PAR_NO"/>
+  <xsl:param name="PAR_NO_IGNORE" select="$YES"/>
+  <xsl:apply-templates select = "*[2]" mode="semantics">
+    <xsl:with-param name="IN_PREC" select="$INTERSECT_PREC"/>
+    <xsl:with-param name="PARAM" select="$PARAM"/>
+    <xsl:with-param name="PAREN" select="$PAREN"/>
+    <xsl:with-param name="PAR_NO_IGNORE" select="$PAR_NO_IGNORE"/>
+  </xsl:apply-templates>
+  <xsl:for-each select = "*[position()>2]">
+    <mo> <xsl:text disable-output-escaping='yes'>&amp;#x2229;</xsl:text> </mo>
+    <xsl:apply-templates select = "." mode="semantics">
+      <xsl:with-param name="IN_PREC" select="$INTERSECT_PREC"/>
+      <xsl:with-param name="PAREN" select="$PAREN"/>
+      <xsl:with-param name="PAR_NO_IGNORE" select="$NO"/>
+    </xsl:apply-templates>
+  </xsl:for-each>
+</xsl:template>
+
+
+<xsl:template match = "apply[setdiff[1]]">
+  <xsl:param name="IN_PREC" select="$NO_PREC"/>
+  <xsl:param name="PARAM" select="$NO_PARAM"/>
+  <xsl:param name="PAREN" select="$PAR_NO"/>
+  <xsl:param name="PAR_NO_IGNORE" select="$YES"/>
+  <xsl:choose>
+    <xsl:when test="$IN_PREC &gt; $SETDIFF_PREC or $IN_PREC=$SETDIFF_PREC
+                    and $PARAM=$PAR_SAME">
+      <mfenced separators="">
+        <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+          <xsl:attribute name="xref">
+            <xsl:value-of select="@id"/>
+          </xsl:attribute>
+        </xsl:if>
+        <xsl:apply-templates select="." mode="setdiff">
+          <xsl:with-param name="PARAM" select="$PARAM"/>
+          <xsl:with-param name="PAREN" select="$PAREN"/>
+          <xsl:with-param name="PAR_NO_IGNORE" select="$PAR_NO_IGNORE"/>
+        </xsl:apply-templates>
+      </mfenced>
+    </xsl:when>
+    <xsl:when test="$IN_PREC &gt; $NO_PREC and $IN_PREC &lt; $GEN_FUN_PREC
+                    and not($SEM_SW=$SEM_ALL) and not($SEM_SW=$SEM_XREF)
+                    and not($SEM_SW=$SEM_XREF_EXT)">
+      <xsl:apply-templates select="." mode="setdiff">
+        <xsl:with-param name="PARAM" select="$PARAM"/>
+        <xsl:with-param name="PAREN" select="$PAREN"/>
+        <xsl:with-param name="PAR_NO_IGNORE" select="$PAR_NO_IGNORE"/>
+      </xsl:apply-templates>
+    </xsl:when>
+    <xsl:otherwise>
+      <mrow>
+        <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+          <xsl:attribute name="xref">
+            <xsl:value-of select="@id"/>
+          </xsl:attribute>
+        </xsl:if>
+        <xsl:apply-templates select="." mode="setdiff">
+          <xsl:with-param name="PARAM" select="$PARAM"/>
+          <xsl:with-param name="PAREN" select="$PAREN"/>
+          <xsl:with-param name="PAR_NO_IGNORE" select="$PAR_NO_IGNORE"/>
+        </xsl:apply-templates>
+      </mrow>
+    </xsl:otherwise>
+  </xsl:choose>
+</xsl:template>
+
+<xsl:template match = "apply[setdiff[1]]" mode="setdiff">
+  <xsl:param name="PARAM" select="$NO_PARAM"/>
+  <xsl:param name="PAREN" select="$PAR_NO"/>
+  <xsl:param name="PAR_NO_IGNORE" select="$YES"/>
+  <xsl:apply-templates select = "*[2]" mode = "semantics">
+    <xsl:with-param name="IN_PREC" select="$SETDIFF_PREC"/>
+    <xsl:with-param name="PARAM" select="$PARAM"/>
+    <xsl:with-param name="PAREN" select="$PAREN"/>
+    <xsl:with-param name="PAR_NO_IGNORE" select="$PAR_NO_IGNORE"/>
+  </xsl:apply-templates>
+  <mo>\</mo>
+  <xsl:apply-templates select = "*[3]" mode = "semantics">
+    <xsl:with-param name="IN_PREC" select="$SETDIFF_PREC"/>
+    <xsl:with-param name="PARAM" select="$PAR_SAME"/>
+    <xsl:with-param name="PAREN" select="$PAREN"/>
+    <xsl:with-param name="PAR_NO_IGNORE" select="$NO"/>
+  </xsl:apply-templates>
+</xsl:template>
+
+
+<xsl:template match = "apply[cartesianproduct[1]]">
+  <xsl:param name="IN_PREC" select="$NO_PREC"/>
+  <xsl:param name="PARAM" select="$NO_PARAM"/>
+  <xsl:param name="PAREN" select="$PAR_NO"/>
+  <xsl:param name="PAR_NO_IGNORE" select="$YES"/>
+  <xsl:choose>
+    <xsl:when test="$IN_PREC &gt; $CARTPROD_PREC or $IN_PREC=$CARTPROD_PREC
+                    and $PARAM=$PAR_SAME">
+      <mfenced separators="">
+        <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+          <xsl:attribute name="xref">
+            <xsl:value-of select="@id"/>
+          </xsl:attribute>
+        </xsl:if>
+        <xsl:apply-templates select="." mode="cartprod">
+          <xsl:with-param name="PARAM" select="$PARAM"/>
+          <xsl:with-param name="PAREN" select="$PAREN"/>
+          <xsl:with-param name="PAR_NO_IGNORE" select="$PAR_NO_IGNORE"/>
+        </xsl:apply-templates>
+      </mfenced>
+    </xsl:when>
+    <xsl:when test="$IN_PREC &gt; $NO_PREC and $IN_PREC &lt; $GEN_FUN_PREC
+                    and not($SEM_SW=$SEM_ALL) and not($SEM_SW=$SEM_XREF)
+                    and not($SEM_SW=$SEM_XREF_EXT)">
+      <xsl:apply-templates select="." mode="cartprod">
+        <xsl:with-param name="PARAM" select="$PARAM"/>
+        <xsl:with-param name="PAREN" select="$PAREN"/>
+        <xsl:with-param name="PAR_NO_IGNORE" select="$PAR_NO_IGNORE"/>
+      </xsl:apply-templates>
+    </xsl:when>
+    <xsl:otherwise>
+      <mrow>
+        <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+          <xsl:attribute name="xref">
+            <xsl:value-of select="@id"/>
+          </xsl:attribute>
+        </xsl:if>
+        <xsl:apply-templates select="." mode="cartprod">
+          <xsl:with-param name="PARAM" select="$PARAM"/>
+          <xsl:with-param name="PAREN" select="$PAREN"/>
+          <xsl:with-param name="PAR_NO_IGNORE" select="$PAR_NO_IGNORE"/>
+        </xsl:apply-templates>
+      </mrow>
+    </xsl:otherwise>
+  </xsl:choose>
+</xsl:template>
+
+<xsl:template match = "*" mode="cartprod">
+  <xsl:param name="PARAM" select="$NO_PARAM"/>
+  <xsl:param name="PAREN" select="$PAR_NO"/>
+  <xsl:param name="PAR_NO_IGNORE" select="$YES"/>
+  <xsl:apply-templates select = "*[2]" mode = "semantics">
+    <xsl:with-param name="IN_PREC" select="$CARTPROD_PREC"/>
+    <xsl:with-param name="PARAM" select="$PARAM"/>
+    <xsl:with-param name="PAREN" select="$PAREN"/>
+    <xsl:with-param name="PAR_NO_IGNORE" select="$PAR_NO_IGNORE"/>
+  </xsl:apply-templates>
+  <xsl:for-each select = "*[position()>2]">
+    <mo><xsl:text disable-output-escaping='yes'>&amp;#x00D7;</xsl:text></mo>
+    <xsl:apply-templates select = "." mode="semantics">
+      <xsl:with-param name="IN_PREC" select="$CARTPROD_PREC"/>
+      <xsl:with-param name="PARAM" select="$PAR_SAME"/>
+      <xsl:with-param name="PAREN" select="$PAREN"/>
+      <xsl:with-param name="PAR_NO_IGNORE" select="$NO"/>
+    </xsl:apply-templates>
+  </xsl:for-each>
+</xsl:template>
+
+
+<xsl:template match = "apply[card[1]]">
+  <mfenced open="&#x2223;" close="&#x2223;" separators=",">
+    <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+      <xsl:attribute name="xref">
+        <xsl:value-of select="@id"/>
+      </xsl:attribute>
+    </xsl:if>
+    <xsl:for-each select = "*[position()>1]">
+      <xsl:apply-templates select = "." mode="semantics"/>
+    </xsl:for-each>
+  </mfenced>
+</xsl:template>
+
+
+
+<!-- ***************** SEQUENCES AND SERIES ***************** -->
+
+<xsl:template match = "apply[sum[1] | product[1]]">
+  <mrow>
+    <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+      <xsl:attribute name="xref">
+        <xsl:value-of select="@id"/>
+      </xsl:attribute>
+    </xsl:if>
+    <xsl:choose>
+      <xsl:when test="*[2]=bvar and lowlimit and uplimit">
+        <munderover>
+          <mo>
+            <xsl:if test="*[1]=sum">
+             <xsl:text disable-output-escaping='yes'>&amp;#x2211;</xsl:text>
+            </xsl:if>
+            <xsl:if test="*[1]=product">
+             <xsl:text disable-output-escaping='yes'>&amp;#x220F;</xsl:text>
+            </xsl:if>
+          </mo>
+          <mrow>
+            <xsl:apply-templates select = "*[2]" mode = "semantics"/>
+            <mo> = </mo>
+            <xsl:apply-templates select = "lowlimit" mode = "semantics"/>
+          </mrow>
+          <xsl:apply-templates select = "uplimit" mode = "semantics"/>
+        </munderover>
+        <xsl:apply-templates select = "*[5]" mode = "semantics"/>
+      </xsl:when>
+      <xsl:when test="*[2]=bvar and *[3]=condition">
+        <munder>
+          <mo>
+            <xsl:if test="*[1]=sum">
+             <xsl:text disable-output-escaping='yes'>&amp;#x2211;</xsl:text>
+            </xsl:if>
+            <xsl:if test="*[1]=product">
+             <xsl:text disable-output-escaping='yes'>&amp;#x220F;</xsl:text>
+            </xsl:if>
+          </mo>
+          <xsl:apply-templates select = "*[3]" mode = "semantics"/>
+        </munder>
+        <xsl:apply-templates select = "*[4]" mode = "semantics"/>
+      </xsl:when>
+      <xsl:when test="*[2]=domainofapplication">
+        <munder>
+          <mo>
+            <xsl:if test="*[1]=sum">
+              <xsl:text disable-output-escaping='yes'>&amp;#x2211;</xsl:text>
+            </xsl:if>
+            <xsl:if test="*[1]=product">
+              <xsl:text disable-output-escaping='yes'>&amp;#x220F;</xsl:text>
+            </xsl:if>
+          </mo>
+          <xsl:apply-templates select="domainofapplication" mode = "semantics"/>
+        </munder>
+        <mrow>
+          <xsl:apply-templates select="*[position()=last()]" mode = "semantics"/>
+        </mrow>
+      </xsl:when>
+    </xsl:choose>
+  </mrow>
+</xsl:template>
+
+
+<xsl:template match="apply[*[1][self::int]]">
+  <mrow>
+    <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+      <xsl:attribute name="xref">
+        <xsl:value-of select="@id"/>
+      </xsl:attribute>
+    </xsl:if>
+	<xsl:choose>
+	  <xsl:when test="domainofapplication">
+        <munder>
+          <mo> <xsl:text disable-output-escaping='yes'>&amp;#x222B;</xsl:text> </mo>
+          <xsl:apply-templates select="domainofapplication" mode="semantics"/>
+        </munder>
+      </xsl:when>
+	  <xsl:when test="condition">
+        <munder>
+          <mo> <xsl:text disable-output-escaping='yes'>&amp;#x222B;</xsl:text> </mo>
+          <xsl:apply-templates select="condition" mode="semantics"/>
+        </munder>
+      </xsl:when>
+      <xsl:when test="interval">
+        <munderover>
+          <mo> <xsl:text disable-output-escaping='yes'>&amp;#x222B;</xsl:text> </mo>
+          <mrow>
+            <xsl:apply-templates select="interval/*[position()=1]" mode="semantics"/>
+          </mrow>
+          <mrow>
+            <mspace width="1em"/>
+            <xsl:apply-templates select="interval/*[position()=2]" mode="semantics"/>
+          </mrow>
+		</munderover>
+      </xsl:when>
+      <xsl:when test="lowlimit | uplimit">
+        <munderover>
+          <mo> <xsl:text disable-output-escaping='yes'>&amp;#x222B;</xsl:text> </mo>
+          <xsl:apply-templates select="lowlimit" mode="semantics"/>
+          <mrow>
+            <mspace width="1em"/>
+            <xsl:apply-templates select="uplimit" mode="semantics"/>
+          </mrow>
+        </munderover>
+      </xsl:when>
+	  <xsl:otherwise>
+        <mo> <xsl:text disable-output-escaping='yes'>&amp;#x222B;</xsl:text> </mo>
+      </xsl:otherwise>
+    </xsl:choose>
+    <xsl:apply-templates select="*[position()=last() and last()>1 and not(self::domainofapplication) and not(self::condition) and not(self::interval) and not(self::lowlimit) and not(self::uplimit) and not(self::bvar)]" mode="semantics">
+      <xsl:with-param name="IN_PREC" select="$FUNCTN_PREC"/>
+      <xsl:with-param name="PAR_NO_IGNORE" select="$NO"/>
+    </xsl:apply-templates>
+	<xsl:if test="bvar">
+      <mrow>
+        <mo> <xsl:text disable-output-escaping='yes'>d</xsl:text> </mo>
+        <xsl:apply-templates select="bvar" mode="semantics"/>
+      </mrow>
+    </xsl:if>
+  </mrow>
+</xsl:template>
+
+
+<xsl:template match = "apply[limit[1]]">
+  <mrow>
+    <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+      <xsl:attribute name="xref">
+        <xsl:value-of select="@id"/>
+      </xsl:attribute>
+    </xsl:if>
+    <munder>
+      <mo> lim </mo>
+      <mrow>
+        <xsl:if test="*[2]=bvar and *[3]=lowlimit">
+            <xsl:apply-templates select = "*[2]" mode = "semantics"/>
+            <mo> <xsl:text disable-output-escaping='yes'>&amp;#x2192;</xsl:text> </mo>
+            <xsl:apply-templates select = "*[3]" mode = "semantics"/>
+        </xsl:if>
+        <xsl:if test="*[2]=bvar and *[3]=condition">
+          <xsl:apply-templates select = "*[3]" mode = "semantics"/>
+        </xsl:if>
+      </mrow>
+    </munder>
+    <xsl:apply-templates select = "*[4]" mode = "semantics"/>
+  </mrow>
+</xsl:template>
+
+
+
+<!-- ***************** TRIGONOMETRY ***************** -->
+
+<xsl:template match = "apply[*[1][self::sin | self::cos |
+                       self::tan | self::sec | self::csc |
+                       self::cot | self::sinh | self::cosh |
+                       self::tanh | self::sech | self::csch |
+                       self::coth | self::arcsin | self::arccos |
+                       self::arctan | self::arcsec | self::arccsc |
+                       self::arccot | self::arcsinh | self::arccosh |
+                       self::arctanh | self::arcsech | self::arccsch |
+                       self::arccoth]]">
+  <mrow>
+    <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+      <xsl:attribute name="xref">
+        <xsl:value-of select="@id"/>
+      </xsl:attribute>
+    </xsl:if>
+    <xsl:if test="not(parent::apply[power[1]])">
+      <xsl:apply-templates select = "*[1]" mode = "trigonometry"/>
+    </xsl:if>
+    <xsl:if test="parent::apply[power[1]]">
+      <msup>
+        <xsl:apply-templates select = "*[1]" mode = "trigonometry"/>
+        <xsl:apply-templates select = "../*[3]" mode = "semantics"/>
+      </msup>
+    </xsl:if>
+    <mspace width="0.01em" linebreak="nobreak"/>
+    <xsl:apply-templates select = "*[2]" mode = "semantics">
+      <xsl:with-param name="IN_PREC" select="$FUNCTN_PREC"/>
+      <xsl:with-param name="PAR_NO_IGNORE" select="$NO"/>
+    </xsl:apply-templates>
+  </mrow>
+</xsl:template>
+
+<xsl:template match = "sin | cos |
+                       tan | sec | csc |
+                       cot | sinh | cosh |
+                       tanh | sech | csch |
+                       coth | arcsin | arccos |
+                       arctan | arcsec | arccsc |
+                       arccot | arcsinh | arccosh |
+                       arctanh | arcsech | arccsch |
+                       arccoth">
+  <xsl:apply-templates select = "." mode = "trigonometry"/>
+</xsl:template>
+
+<xsl:template match = "*" mode="trigonometry">
+  <mo>
+    <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+      <xsl:attribute name="xref">
+        <xsl:value-of select="@id"/>
+      </xsl:attribute>
+    </xsl:if>
+    <xsl:choose>
+      <xsl:when test="self::sin">
+        <xsl:value-of select="'sin'"/>
+      </xsl:when>
+      <xsl:when test="self::cos">
+        <xsl:value-of select="'cos'"/>
+      </xsl:when>
+      <xsl:when test="self::tan">
+        <xsl:value-of select="'tan'"/>
+      </xsl:when>
+      <xsl:when test="self::sec">
+        <xsl:value-of select="'sec'"/>
+      </xsl:when>
+      <xsl:when test="self::csc">
+        <xsl:value-of select="'csc'"/>
+      </xsl:when>
+      <xsl:when test="self::cot">
+        <xsl:value-of select="'cot'"/>
+      </xsl:when>
+      <xsl:when test="self::sinh">
+        <xsl:value-of select="'sinh'"/>
+      </xsl:when>
+      <xsl:when test="self::cosh">
+        <xsl:value-of select="'cosh'"/>
+      </xsl:when>
+      <xsl:when test="self::tanh">
+        <xsl:value-of select="'tanh'"/>
+      </xsl:when>
+      <xsl:when test="self::sech">
+        <xsl:value-of select="'sech'"/>
+      </xsl:when>
+      <xsl:when test="self::csch">
+        <xsl:value-of select="'csch'"/>
+      </xsl:when>
+      <xsl:when test="self::coth">
+        <xsl:value-of select="'coth'"/>
+      </xsl:when>
+      <xsl:when test="self::arcsin">
+        <xsl:value-of select="'arcsin'"/>
+      </xsl:when>
+      <xsl:when test="self::arccos">
+        <xsl:value-of select="'arccos'"/>
+      </xsl:when>
+      <xsl:when test="self::arctan">
+        <xsl:value-of select="'arctan'"/>
+      </xsl:when>
+      <xsl:when test="self::arcsec">
+        <xsl:value-of select="'arcsec'"/>
+      </xsl:when>
+      <xsl:when test="self::arccsc">
+        <xsl:value-of select="'arccsc'"/>
+      </xsl:when>
+      <xsl:when test="self::arccot">
+        <xsl:value-of select="'arccot'"/>
+      </xsl:when>
+      <xsl:when test="self::arcsinh">
+        <xsl:value-of select="'arcsinh'"/>
+      </xsl:when>
+      <xsl:when test="self::arccosh">
+        <xsl:value-of select="'arccosh'"/>
+      </xsl:when>
+      <xsl:when test="self::arctanh">
+        <xsl:value-of select="'arctanh'"/>
+      </xsl:when>
+      <xsl:when test="self::arcsech">
+        <xsl:value-of select="'arcsech'"/>
+      </xsl:when>
+      <xsl:when test="self::arccsch">
+        <xsl:value-of select="'arccsch'"/>
+      </xsl:when>
+      <xsl:when test="self::arccoth">
+        <xsl:value-of select="'arccot'"/>
+      </xsl:when>
+    </xsl:choose>
+  </mo>
+</xsl:template>
+
+
+
+<!-- ***************** STATISTICS ***************** -->
+
+<xsl:template match = "apply[mean[1]]">
+  <mfenced open="&#x2329;" close="&#x232A;" separators=",">
+    <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+      <xsl:attribute name="xref">
+        <xsl:value-of select="@id"/>
+      </xsl:attribute>
+    </xsl:if>
+    <xsl:for-each select = "*[position()>1]">
+      <xsl:apply-templates select = "." mode="semantics"/>
+    </xsl:for-each>
+  </mfenced>
+</xsl:template>
+
+
+<xsl:template match = "apply[sdev[1]]">
+  <mrow>
+    <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+      <xsl:attribute name="xref">
+        <xsl:value-of select="@id"/>
+      </xsl:attribute>
+    </xsl:if>
+    <mo> <xsl:text disable-output-escaping='yes'>&amp;#x03C3;</xsl:text> </mo>
+    <mfenced separators=",">
+      <xsl:for-each select = "*[position()>1]">
+        <xsl:apply-templates select = "." mode="semantics"/>
+      </xsl:for-each>
+    </mfenced>
+  </mrow>
+</xsl:template>
+
+
+<xsl:template match = "apply[variance[1]]">
+  <mrow>
+    <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+      <xsl:attribute name="xref">
+        <xsl:value-of select="@id"/>
+      </xsl:attribute>
+    </xsl:if>
+    <mo> <xsl:text disable-output-escaping='yes'>&amp;#x03C3;</xsl:text> </mo>
+    <msup>
+      <mfenced separators=",">
+        <xsl:for-each select = "*[position()>1]">
+          <xsl:apply-templates select = "." mode="semantics"/>
+        </xsl:for-each>
+      </mfenced>
+      <mn> 2 </mn>
+    </msup>
+  </mrow>
+</xsl:template>
+
+
+<xsl:template match = "apply[median[1]]">
+  <mrow>
+    <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+      <xsl:attribute name="xref">
+        <xsl:value-of select="@id"/>
+      </xsl:attribute>
+    </xsl:if>
+    <mo> median </mo>
+    <mfenced separators=",">
+      <xsl:for-each select = "*[position()>1]">
+        <xsl:apply-templates select = "." mode="semantics"/>
+      </xsl:for-each>
+    </mfenced>
+  </mrow>
+</xsl:template>
+
+
+<xsl:template match = "apply[mode[1]]">
+  <mrow>
+    <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+      <xsl:attribute name="xref">
+        <xsl:value-of select="@id"/>
+      </xsl:attribute>
+    </xsl:if>
+    <mo> mode </mo>
+    <mfenced separators=",">
+      <xsl:for-each select = "*[position()>1]">
+        <xsl:apply-templates select = "." mode="semantics"/>
+      </xsl:for-each>
+    </mfenced>
+  </mrow>
+</xsl:template>
+
+
+<xsl:template match = "apply[moment[1]]">
+  <mfenced open="&#x2329;" close="&#x232A;" separators="">
+    <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+      <xsl:attribute name="xref">
+        <xsl:value-of select="@id"/>
+      </xsl:attribute>
+    </xsl:if>
+    <xsl:if test="*[2]=degree and not(*[3]=momentabout)">
+      <msup>
+        <xsl:apply-templates select="*[3]" mode = "semantics"/>
+        <xsl:apply-templates select="*[2]" mode = "semantics"/>
+      </msup>
+    </xsl:if>
+    <xsl:if test="*[2]=degree and *[3]=momentabout">
+      <msup>
+        <xsl:apply-templates select="*[4]" mode = "semantics"/>
+        <xsl:apply-templates select="*[2]" mode = "semantics"/>
+      </msup>
+    </xsl:if>
+    <xsl:if test="not(*[2]=degree) and *[2]=momentabout">
+      <xsl:for-each select = "*[position()>2]">
+        <xsl:apply-templates select = "." mode="semantics"/>
+      </xsl:for-each>
+    </xsl:if>
+    <xsl:if test="not(*[2]=degree) and not(*[2]=momentabout)">
+      <xsl:for-each select = "*[position()>1]">
+        <xsl:apply-templates select = "." mode="semantics"/>
+      </xsl:for-each>
+    </xsl:if>
+  </mfenced>
+</xsl:template>
+
+
+
+<!-- ***************** LINEAR ALGEBRA ***************** -->
+
+<xsl:template match="vector">
+  <mfenced separators="">
+    <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+      <xsl:attribute name="xref">
+        <xsl:value-of select="@id"/>
+      </xsl:attribute>
+    </xsl:if>
+    <mtable columnalign="center">
+      <xsl:for-each select="*">
+        <mtr>
+          <mtd> <xsl:apply-templates select="." mode = "semantics"/> </mtd>
+        </mtr>
+      </xsl:for-each>
+    </mtable>
+  </mfenced>
+</xsl:template>
+
+
+<xsl:template match = "matrix">
+  <mfenced separators="">
+    <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+      <xsl:attribute name="xref">
+        <xsl:value-of select="@id"/>
+      </xsl:attribute>
+    </xsl:if>
+    <mtable>
+      <xsl:apply-templates mode = "semantics"/>
+    </mtable>
+  </mfenced>
+</xsl:template>
+
+
+<xsl:template match = "matrixrow">
+  <mtr>
+    <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+      <xsl:attribute name="xref">
+        <xsl:value-of select="@id"/>
+      </xsl:attribute>
+    </xsl:if>
+    <xsl:for-each select="*">
+      <mtd>
+        <xsl:apply-templates select="." mode = "semantics"/>
+      </mtd>
+    </xsl:for-each>
+  </mtr>
+</xsl:template>
+
+
+<xsl:template match = "apply[determinant[1]]">
+  <mrow>
+    <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+      <xsl:attribute name="xref">
+        <xsl:value-of select="@id"/>
+      </xsl:attribute>
+    </xsl:if>
+    <mo> det </mo>
+    <mspace width="0.2em" linebreak="nobreak"/>
+    <xsl:apply-templates select = "*[2]" mode = "semantics"/>
+  </mrow>
+</xsl:template>
+
+
+<xsl:template match = "apply[transpose[1]]">
+  <msup>
+    <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+      <xsl:attribute name="xref">
+        <xsl:value-of select="@id"/>
+      </xsl:attribute>
+    </xsl:if>
+    <xsl:apply-templates select = "*[2]" mode = "semantics"/>
+    <mo> T </mo>
+  </msup>
+</xsl:template>
+
+
+<xsl:template match = "apply[selector[1]]">
+  <msub>
+    <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+      <xsl:attribute name="xref">
+        <xsl:value-of select="@id"/>
+      </xsl:attribute>
+    </xsl:if>
+    <xsl:apply-templates select="*[2]" mode = "semantics"/>
+    <mfenced open="" close="">
+      <xsl:for-each select="*[position()>2]">
+        <xsl:apply-templates select="." mode = "semantics"/>
+      </xsl:for-each>
+    </mfenced>
+  </msub>
+</xsl:template>
+
+
+<xsl:template match = "apply[vectorproduct[1] |
+                                 scalarproduct[1] | outerproduct[1]]">
+  <mrow>
+    <xsl:if test="($SEM_SW=$SEM_XREF or $SEM_SW=$SEM_XREF_EXT) and @id">
+      <xsl:attribute name="xref">
+        <xsl:value-of select="@id"/>
+      </xsl:attribute>
+    </xsl:if>
+    <xsl:apply-templates select="*[2]" mode = "semantics"/>
+    <mo>
+      <xsl:if test="vectorproduct[1]">
+        <xsl:text disable-output-escaping='yes'>&amp;#x00D7;</xsl:text>
+      </xsl:if>
+      <xsl:if test="scalarproduct[1]">
+        <xsl:text disable-output-escaping='yes'>&amp;#x22C5;</xsl:text>
+      </xsl:if>
+      <xsl:if test="outerproduct[1]">
+        <xsl:text disable-output-escaping='yes'>&amp;#x2297;</xsl:text>
+      </xsl:if>
+    </mo>
+    <xsl:apply-templates select="*[3]" mode = "semantics"/>
+  </mrow>
+</xsl:template>
+
+
+
+<!-- ***************** CONSTANT and SYMBOL ELEMENTS ***************** -->
+
+<xsl:template match="integers">
+  <mo> <xsl:text disable-output-escaping='yes'>&amp;#x2124;</xsl:text> </mo>
+</xsl:template>
+
+<xsl:template match="reals">
+  <mo> <xsl:text disable-output-escaping='yes'>&amp;#x211D;</xsl:text> </mo>
+</xsl:template>
+
+<xsl:template match="rationals">
+  <mo> <xsl:text disable-output-escaping='yes'>&amp;#x211A;</xsl:text> </mo>
+</xsl:template>
+
+<xsl:template match="naturalnumbers">
+  <mo> <xsl:text disable-output-escaping='yes'>&amp;#x2115;</xsl:text> </mo>
+</xsl:template>
+
+<xsl:template match="complexes">
+  <mo> <xsl:text disable-output-escaping='yes'>&amp;#x2102;</xsl:text> </mo>
+</xsl:template>
+
+<xsl:template match="primes">
+  <mo> <xsl:text disable-output-escaping='yes'>&amp;#x2119;</xsl:text> </mo>
+</xsl:template>
+
+<xsl:template match="exponentiale">
+  <mn> <xsl:text disable-output-escaping='yes'>e</xsl:text> </mn>
+</xsl:template>
+
+<xsl:template match="imaginaryi">
+  <mn> <xsl:text disable-output-escaping='yes'>&amp;#x2148;</xsl:text> </mn>
+</xsl:template>
+
+<xsl:template match="notanumber">
+  <mo> NaN </mo>
+</xsl:template>
+
+<xsl:template match="true">
+  <mo> true </mo>
+</xsl:template>
+
+<xsl:template match="false">
+  <mo> false </mo>
+</xsl:template>
+
+<xsl:template match="emptyset">
+  <mo> <xsl:text disable-output-escaping='yes'>&amp;#x2205;</xsl:text> </mo>
+</xsl:template>
+
+<xsl:template match="pi">
+  <mn> <xsl:text disable-output-escaping='yes'>&amp;#x03C0;</xsl:text> </mn>
+</xsl:template>
+
+<xsl:template match="eulergamma">
+  <mo> <xsl:text disable-output-escaping='yes'>&amp;#x213D;</xsl:text> </mo>
+</xsl:template>
+
+<xsl:template match="infinity">
+  <mo> <xsl:text disable-output-escaping='yes'>&amp;#x221E;</xsl:text> </mo>
+</xsl:template>
+
+</xsl:stylesheet>
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/tests/__init__.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/tests/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/tests/__pycache__/__init__.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/tests/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..9b05e8a6e040c13c7fc993ae9a1e773c22f328da
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/tests/__pycache__/__init__.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/tests/__pycache__/test_autowrap.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/tests/__pycache__/test_autowrap.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..95afbce87f1b52a95551d2689876d2771dcc57ab
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/tests/__pycache__/test_autowrap.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/tests/__pycache__/test_codegen.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/tests/__pycache__/test_codegen.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..e8c709524b239e608ef93e945ddb340ee65ec043
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/tests/__pycache__/test_codegen.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/tests/__pycache__/test_codegen_julia.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/tests/__pycache__/test_codegen_julia.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..6ca0b948a15618d4163fb6890d03adbede0e800c
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/tests/__pycache__/test_codegen_julia.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/tests/__pycache__/test_codegen_octave.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/tests/__pycache__/test_codegen_octave.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..58f64c5397b2d89951c8f2b43bf1e1e6e3a89aee
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/tests/__pycache__/test_codegen_octave.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/tests/__pycache__/test_codegen_rust.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/tests/__pycache__/test_codegen_rust.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..88caa106d861e17e2cd1a68ce2648a9f3c44c2a1
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/tests/__pycache__/test_codegen_rust.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/tests/__pycache__/test_decorator.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/tests/__pycache__/test_decorator.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..8842320f967d4a70185cc0e60a7a04f623053acd
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/tests/__pycache__/test_decorator.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/tests/__pycache__/test_deprecated.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/tests/__pycache__/test_deprecated.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..9317885d463cdcf057fa74fd5ef813fbc50d5665
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/tests/__pycache__/test_deprecated.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/tests/__pycache__/test_enumerative.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/tests/__pycache__/test_enumerative.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..6794c54ee19af4e3342fc0ccefe4844a0de61243
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/tests/__pycache__/test_enumerative.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/tests/__pycache__/test_exceptions.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/tests/__pycache__/test_exceptions.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..239149e0133f01761d196e47aa96eff2dcefe00f
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/tests/__pycache__/test_exceptions.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/tests/__pycache__/test_iterables.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/tests/__pycache__/test_iterables.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..1767ac56c5d1cba65af948adbfb8f21e4adf9ff7
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/tests/__pycache__/test_iterables.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/tests/__pycache__/test_lambdify.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/tests/__pycache__/test_lambdify.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..597b23be24f277f3681cf89fd06aae6e4b185c39
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/tests/__pycache__/test_lambdify.cpython-312.pyc
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2a535dbefc3476da5dc7074209649d2577d6887c71e09ec6f25bcb03fad78313
+size 141609
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/tests/__pycache__/test_matchpy_connector.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/tests/__pycache__/test_matchpy_connector.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..76e41c43b09552a405b567228f73c66a97774233
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/tests/__pycache__/test_matchpy_connector.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/tests/__pycache__/test_mathml.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/tests/__pycache__/test_mathml.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..1c3766f0f026f941c311e66b6616fc2dc479461a
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/tests/__pycache__/test_mathml.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/tests/__pycache__/test_misc.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/tests/__pycache__/test_misc.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b8c809628d7df116dfe9f6fa8b748d883323dfd1
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/tests/__pycache__/test_misc.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/tests/__pycache__/test_pickling.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/tests/__pycache__/test_pickling.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c917ee51ce1d8851b5f4bbdcce568010dcaeaba3
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/tests/__pycache__/test_pickling.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/tests/__pycache__/test_source.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/tests/__pycache__/test_source.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..55ca62a752d066892aab74c9cde84951702f1b22
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/tests/__pycache__/test_source.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/tests/__pycache__/test_timeutils.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/tests/__pycache__/test_timeutils.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..aef0d1beb33bdddc36208644997f68e8fc4f090d
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/tests/__pycache__/test_timeutils.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/tests/__pycache__/test_wester.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/tests/__pycache__/test_wester.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ac5e19f843d350b8f81d43a2c0e4e6c7bccb3d71
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/tests/__pycache__/test_wester.cpython-312.pyc
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b22545b56683b9eec4b45694108d2e48bdbd921a90f67d5e0996febcb7ade96e
+size 205470
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/tests/__pycache__/test_xxe.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/tests/__pycache__/test_xxe.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5493aa7b569afbfd849d029025628780c29b66a6
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/tests/__pycache__/test_xxe.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/tests/test_autowrap.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/tests/test_autowrap.py
new file mode 100644
index 0000000000000000000000000000000000000000..b5a33d77adb46710cfa3cfeb1ea39402e35c76cf
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/tests/test_autowrap.py
@@ -0,0 +1,467 @@
+# Tests that require installed backends go into
+# sympy/test_external/test_autowrap
+
+import os
+import tempfile
+import shutil
+from io import StringIO
+from pathlib import Path
+
+from sympy.core import symbols, Eq
+from sympy.utilities.autowrap import (autowrap, binary_function,
+            CythonCodeWrapper, UfuncifyCodeWrapper, CodeWrapper)
+from sympy.utilities.codegen import (
+    CCodeGen, C99CodeGen, CodeGenArgumentListError, make_routine
+)
+from sympy.testing.pytest import raises
+from sympy.testing.tmpfiles import TmpFileManager
+
+
+def get_string(dump_fn, routines, prefix="file", **kwargs):
+    """Wrapper for dump_fn. dump_fn writes its results to a stream object and
+       this wrapper returns the contents of that stream as a string. This
+       auxiliary function is used by many tests below.
+
+       The header and the empty lines are not generator to facilitate the
+       testing of the output.
+    """
+    output = StringIO()
+    dump_fn(routines, output, prefix, **kwargs)
+    source = output.getvalue()
+    output.close()
+    return source
+
+
+def test_cython_wrapper_scalar_function():
+    x, y, z = symbols('x,y,z')
+    expr = (x + y)*z
+    routine = make_routine("test", expr)
+    code_gen = CythonCodeWrapper(CCodeGen())
+    source = get_string(code_gen.dump_pyx, [routine])
+
+    expected = (
+        "cdef extern from 'file.h':\n"
+        "    double test(double x, double y, double z)\n"
+        "\n"
+        "def test_c(double x, double y, double z):\n"
+        "\n"
+        "    return test(x, y, z)")
+    assert source == expected
+
+
+def test_cython_wrapper_outarg():
+    from sympy.core.relational import Equality
+    x, y, z = symbols('x,y,z')
+    code_gen = CythonCodeWrapper(C99CodeGen())
+
+    routine = make_routine("test", Equality(z, x + y))
+    source = get_string(code_gen.dump_pyx, [routine])
+    expected = (
+        "cdef extern from 'file.h':\n"
+        "    void test(double x, double y, double *z)\n"
+        "\n"
+        "def test_c(double x, double y):\n"
+        "\n"
+        "    cdef double z = 0\n"
+        "    test(x, y, &z)\n"
+        "    return z")
+    assert source == expected
+
+
+def test_cython_wrapper_inoutarg():
+    from sympy.core.relational import Equality
+    x, y, z = symbols('x,y,z')
+    code_gen = CythonCodeWrapper(C99CodeGen())
+    routine = make_routine("test", Equality(z, x + y + z))
+    source = get_string(code_gen.dump_pyx, [routine])
+    expected = (
+        "cdef extern from 'file.h':\n"
+        "    void test(double x, double y, double *z)\n"
+        "\n"
+        "def test_c(double x, double y, double z):\n"
+        "\n"
+        "    test(x, y, &z)\n"
+        "    return z")
+    assert source == expected
+
+
+def test_cython_wrapper_compile_flags():
+    from sympy.core.relational import Equality
+    x, y, z = symbols('x,y,z')
+    routine = make_routine("test", Equality(z, x + y))
+
+    code_gen = CythonCodeWrapper(CCodeGen())
+
+    expected = """\
+from setuptools import setup
+from setuptools import Extension
+from Cython.Build import cythonize
+cy_opts = {'compiler_directives': {'language_level': '3'}}
+
+ext_mods = [Extension(
+    'wrapper_module_%(num)s', ['wrapper_module_%(num)s.pyx', 'wrapped_code_%(num)s.c'],
+    include_dirs=[],
+    library_dirs=[],
+    libraries=[],
+    extra_compile_args=['-std=c99'],
+    extra_link_args=[]
+)]
+setup(ext_modules=cythonize(ext_mods, **cy_opts))
+""" % {'num': CodeWrapper._module_counter}
+
+    temp_dir = tempfile.mkdtemp()
+    TmpFileManager.tmp_folder(temp_dir)
+    setup_file_path = os.path.join(temp_dir, 'setup.py')
+
+    code_gen._prepare_files(routine, build_dir=temp_dir)
+    setup_text = Path(setup_file_path).read_text()
+    assert setup_text == expected
+
+    code_gen = CythonCodeWrapper(CCodeGen(),
+                                 include_dirs=['/usr/local/include', '/opt/booger/include'],
+                                 library_dirs=['/user/local/lib'],
+                                 libraries=['thelib', 'nilib'],
+                                 extra_compile_args=['-slow-math'],
+                                 extra_link_args=['-lswamp', '-ltrident'],
+                                 cythonize_options={'compiler_directives': {'boundscheck': False}}
+                                 )
+    expected = """\
+from setuptools import setup
+from setuptools import Extension
+from Cython.Build import cythonize
+cy_opts = {'compiler_directives': {'boundscheck': False}}
+
+ext_mods = [Extension(
+    'wrapper_module_%(num)s', ['wrapper_module_%(num)s.pyx', 'wrapped_code_%(num)s.c'],
+    include_dirs=['/usr/local/include', '/opt/booger/include'],
+    library_dirs=['/user/local/lib'],
+    libraries=['thelib', 'nilib'],
+    extra_compile_args=['-slow-math', '-std=c99'],
+    extra_link_args=['-lswamp', '-ltrident']
+)]
+setup(ext_modules=cythonize(ext_mods, **cy_opts))
+""" % {'num': CodeWrapper._module_counter}
+
+    code_gen._prepare_files(routine, build_dir=temp_dir)
+    setup_text = Path(setup_file_path).read_text()
+    assert setup_text == expected
+
+    expected = """\
+from setuptools import setup
+from setuptools import Extension
+from Cython.Build import cythonize
+cy_opts = {'compiler_directives': {'boundscheck': False}}
+import numpy as np
+
+ext_mods = [Extension(
+    'wrapper_module_%(num)s', ['wrapper_module_%(num)s.pyx', 'wrapped_code_%(num)s.c'],
+    include_dirs=['/usr/local/include', '/opt/booger/include', np.get_include()],
+    library_dirs=['/user/local/lib'],
+    libraries=['thelib', 'nilib'],
+    extra_compile_args=['-slow-math', '-std=c99'],
+    extra_link_args=['-lswamp', '-ltrident']
+)]
+setup(ext_modules=cythonize(ext_mods, **cy_opts))
+""" % {'num': CodeWrapper._module_counter}
+
+    code_gen._need_numpy = True
+    code_gen._prepare_files(routine, build_dir=temp_dir)
+    setup_text = Path(setup_file_path).read_text()
+    assert setup_text == expected
+
+    TmpFileManager.cleanup()
+
+def test_cython_wrapper_unique_dummyvars():
+    from sympy.core.relational import Equality
+    from sympy.core.symbol import Dummy
+    x, y, z = Dummy('x'), Dummy('y'), Dummy('z')
+    x_id, y_id, z_id = [str(d.dummy_index) for d in [x, y, z]]
+    expr = Equality(z, x + y)
+    routine = make_routine("test", expr)
+    code_gen = CythonCodeWrapper(CCodeGen())
+    source = get_string(code_gen.dump_pyx, [routine])
+    expected_template = (
+        "cdef extern from 'file.h':\n"
+        "    void test(double x_{x_id}, double y_{y_id}, double *z_{z_id})\n"
+        "\n"
+        "def test_c(double x_{x_id}, double y_{y_id}):\n"
+        "\n"
+        "    cdef double z_{z_id} = 0\n"
+        "    test(x_{x_id}, y_{y_id}, &z_{z_id})\n"
+        "    return z_{z_id}")
+    expected = expected_template.format(x_id=x_id, y_id=y_id, z_id=z_id)
+    assert source == expected
+
+def test_autowrap_dummy():
+    x, y, z = symbols('x y z')
+
+    # Uses DummyWrapper to test that codegen works as expected
+
+    f = autowrap(x + y, backend='dummy')
+    assert f() == str(x + y)
+    assert f.args == "x, y"
+    assert f.returns == "nameless"
+    f = autowrap(Eq(z, x + y), backend='dummy')
+    assert f() == str(x + y)
+    assert f.args == "x, y"
+    assert f.returns == "z"
+    f = autowrap(Eq(z, x + y + z), backend='dummy')
+    assert f() == str(x + y + z)
+    assert f.args == "x, y, z"
+    assert f.returns == "z"
+
+
+def test_autowrap_args():
+    x, y, z = symbols('x y z')
+
+    raises(CodeGenArgumentListError, lambda: autowrap(Eq(z, x + y),
+           backend='dummy', args=[x]))
+    f = autowrap(Eq(z, x + y), backend='dummy', args=[y, x])
+    assert f() == str(x + y)
+    assert f.args == "y, x"
+    assert f.returns == "z"
+
+    raises(CodeGenArgumentListError, lambda: autowrap(Eq(z, x + y + z),
+           backend='dummy', args=[x, y]))
+    f = autowrap(Eq(z, x + y + z), backend='dummy', args=[y, x, z])
+    assert f() == str(x + y + z)
+    assert f.args == "y, x, z"
+    assert f.returns == "z"
+
+    f = autowrap(Eq(z, x + y + z), backend='dummy', args=(y, x, z))
+    assert f() == str(x + y + z)
+    assert f.args == "y, x, z"
+    assert f.returns == "z"
+
+def test_autowrap_store_files():
+    x, y = symbols('x y')
+    tmp = tempfile.mkdtemp()
+    TmpFileManager.tmp_folder(tmp)
+
+    f = autowrap(x + y, backend='dummy', tempdir=tmp)
+    assert f() == str(x + y)
+    assert os.access(tmp, os.F_OK)
+
+    TmpFileManager.cleanup()
+
+def test_autowrap_store_files_issue_gh12939():
+    x, y = symbols('x y')
+    tmp = './tmp'
+    saved_cwd = os.getcwd()
+    temp_cwd = tempfile.mkdtemp()
+    try:
+        os.chdir(temp_cwd)
+        f = autowrap(x + y, backend='dummy', tempdir=tmp)
+        assert f() == str(x + y)
+        assert os.access(tmp, os.F_OK)
+    finally:
+        os.chdir(saved_cwd)
+        shutil.rmtree(temp_cwd)
+
+
+def test_binary_function():
+    x, y = symbols('x y')
+    f = binary_function('f', x + y, backend='dummy')
+    assert f._imp_() == str(x + y)
+
+
+def test_ufuncify_source():
+    x, y, z = symbols('x,y,z')
+    code_wrapper = UfuncifyCodeWrapper(C99CodeGen("ufuncify"))
+    routine = make_routine("test", x + y + z)
+    source = get_string(code_wrapper.dump_c, [routine])
+    expected = """\
+#include "Python.h"
+#include "math.h"
+#include "numpy/ndarraytypes.h"
+#include "numpy/ufuncobject.h"
+#include "numpy/halffloat.h"
+#include "file.h"
+
+static PyMethodDef wrapper_module_%(num)sMethods[] = {
+        {NULL, NULL, 0, NULL}
+};
+
+#ifdef NPY_1_19_API_VERSION
+static void test_ufunc(char **args, const npy_intp *dimensions, const npy_intp* steps, void* data)
+#else
+static void test_ufunc(char **args, npy_intp *dimensions, npy_intp* steps, void* data)
+#endif
+{
+    npy_intp i;
+    npy_intp n = dimensions[0];
+    char *in0 = args[0];
+    char *in1 = args[1];
+    char *in2 = args[2];
+    char *out0 = args[3];
+    npy_intp in0_step = steps[0];
+    npy_intp in1_step = steps[1];
+    npy_intp in2_step = steps[2];
+    npy_intp out0_step = steps[3];
+    for (i = 0; i < n; i++) {
+        *((double *)out0) = test(*(double *)in0, *(double *)in1, *(double *)in2);
+        in0 += in0_step;
+        in1 += in1_step;
+        in2 += in2_step;
+        out0 += out0_step;
+    }
+}
+PyUFuncGenericFunction test_funcs[1] = {&test_ufunc};
+static char test_types[4] = {NPY_DOUBLE, NPY_DOUBLE, NPY_DOUBLE, NPY_DOUBLE};
+static void *test_data[1] = {NULL};
+
+#if PY_VERSION_HEX >= 0x03000000
+static struct PyModuleDef moduledef = {
+    PyModuleDef_HEAD_INIT,
+    "wrapper_module_%(num)s",
+    NULL,
+    -1,
+    wrapper_module_%(num)sMethods,
+    NULL,
+    NULL,
+    NULL,
+    NULL
+};
+
+PyMODINIT_FUNC PyInit_wrapper_module_%(num)s(void)
+{
+    PyObject *m, *d;
+    PyObject *ufunc0;
+    m = PyModule_Create(&moduledef);
+    if (!m) {
+        return NULL;
+    }
+    import_array();
+    import_umath();
+    d = PyModule_GetDict(m);
+    ufunc0 = PyUFunc_FromFuncAndData(test_funcs, test_data, test_types, 1, 3, 1,
+            PyUFunc_None, "wrapper_module_%(num)s", "Created in SymPy with Ufuncify", 0);
+    PyDict_SetItemString(d, "test", ufunc0);
+    Py_DECREF(ufunc0);
+    return m;
+}
+#else
+PyMODINIT_FUNC initwrapper_module_%(num)s(void)
+{
+    PyObject *m, *d;
+    PyObject *ufunc0;
+    m = Py_InitModule("wrapper_module_%(num)s", wrapper_module_%(num)sMethods);
+    if (m == NULL) {
+        return;
+    }
+    import_array();
+    import_umath();
+    d = PyModule_GetDict(m);
+    ufunc0 = PyUFunc_FromFuncAndData(test_funcs, test_data, test_types, 1, 3, 1,
+            PyUFunc_None, "wrapper_module_%(num)s", "Created in SymPy with Ufuncify", 0);
+    PyDict_SetItemString(d, "test", ufunc0);
+    Py_DECREF(ufunc0);
+}
+#endif""" % {'num': CodeWrapper._module_counter}
+    assert source == expected
+
+
+def test_ufuncify_source_multioutput():
+    x, y, z = symbols('x,y,z')
+    var_symbols = (x, y, z)
+    expr = x + y**3 + 10*z**2
+    code_wrapper = UfuncifyCodeWrapper(C99CodeGen("ufuncify"))
+    routines = [make_routine("func{}".format(i), expr.diff(var_symbols[i]), var_symbols) for i in range(len(var_symbols))]
+    source = get_string(code_wrapper.dump_c, routines, funcname='multitest')
+    expected = """\
+#include "Python.h"
+#include "math.h"
+#include "numpy/ndarraytypes.h"
+#include "numpy/ufuncobject.h"
+#include "numpy/halffloat.h"
+#include "file.h"
+
+static PyMethodDef wrapper_module_%(num)sMethods[] = {
+        {NULL, NULL, 0, NULL}
+};
+
+#ifdef NPY_1_19_API_VERSION
+static void multitest_ufunc(char **args, const npy_intp *dimensions, const npy_intp* steps, void* data)
+#else
+static void multitest_ufunc(char **args, npy_intp *dimensions, npy_intp* steps, void* data)
+#endif
+{
+    npy_intp i;
+    npy_intp n = dimensions[0];
+    char *in0 = args[0];
+    char *in1 = args[1];
+    char *in2 = args[2];
+    char *out0 = args[3];
+    char *out1 = args[4];
+    char *out2 = args[5];
+    npy_intp in0_step = steps[0];
+    npy_intp in1_step = steps[1];
+    npy_intp in2_step = steps[2];
+    npy_intp out0_step = steps[3];
+    npy_intp out1_step = steps[4];
+    npy_intp out2_step = steps[5];
+    for (i = 0; i < n; i++) {
+        *((double *)out0) = func0(*(double *)in0, *(double *)in1, *(double *)in2);
+        *((double *)out1) = func1(*(double *)in0, *(double *)in1, *(double *)in2);
+        *((double *)out2) = func2(*(double *)in0, *(double *)in1, *(double *)in2);
+        in0 += in0_step;
+        in1 += in1_step;
+        in2 += in2_step;
+        out0 += out0_step;
+        out1 += out1_step;
+        out2 += out2_step;
+    }
+}
+PyUFuncGenericFunction multitest_funcs[1] = {&multitest_ufunc};
+static char multitest_types[6] = {NPY_DOUBLE, NPY_DOUBLE, NPY_DOUBLE, NPY_DOUBLE, NPY_DOUBLE, NPY_DOUBLE};
+static void *multitest_data[1] = {NULL};
+
+#if PY_VERSION_HEX >= 0x03000000
+static struct PyModuleDef moduledef = {
+    PyModuleDef_HEAD_INIT,
+    "wrapper_module_%(num)s",
+    NULL,
+    -1,
+    wrapper_module_%(num)sMethods,
+    NULL,
+    NULL,
+    NULL,
+    NULL
+};
+
+PyMODINIT_FUNC PyInit_wrapper_module_%(num)s(void)
+{
+    PyObject *m, *d;
+    PyObject *ufunc0;
+    m = PyModule_Create(&moduledef);
+    if (!m) {
+        return NULL;
+    }
+    import_array();
+    import_umath();
+    d = PyModule_GetDict(m);
+    ufunc0 = PyUFunc_FromFuncAndData(multitest_funcs, multitest_data, multitest_types, 1, 3, 3,
+            PyUFunc_None, "wrapper_module_%(num)s", "Created in SymPy with Ufuncify", 0);
+    PyDict_SetItemString(d, "multitest", ufunc0);
+    Py_DECREF(ufunc0);
+    return m;
+}
+#else
+PyMODINIT_FUNC initwrapper_module_%(num)s(void)
+{
+    PyObject *m, *d;
+    PyObject *ufunc0;
+    m = Py_InitModule("wrapper_module_%(num)s", wrapper_module_%(num)sMethods);
+    if (m == NULL) {
+        return;
+    }
+    import_array();
+    import_umath();
+    d = PyModule_GetDict(m);
+    ufunc0 = PyUFunc_FromFuncAndData(multitest_funcs, multitest_data, multitest_types, 1, 3, 3,
+            PyUFunc_None, "wrapper_module_%(num)s", "Created in SymPy with Ufuncify", 0);
+    PyDict_SetItemString(d, "multitest", ufunc0);
+    Py_DECREF(ufunc0);
+}
+#endif""" % {'num': CodeWrapper._module_counter}
+    assert source == expected
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/tests/test_codegen.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/tests/test_codegen.py
new file mode 100644
index 0000000000000000000000000000000000000000..4ccc6f9a90fb0a0bec39cea22420da8091ede740
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/tests/test_codegen.py
@@ -0,0 +1,1632 @@
+from io import StringIO
+
+from sympy.core import symbols, Eq, pi, Catalan, Lambda, Dummy
+from sympy.core.relational import Equality
+from sympy.core.symbol import Symbol
+from sympy.functions.special.error_functions import erf
+from sympy.integrals.integrals import Integral
+from sympy.matrices import Matrix, MatrixSymbol
+from sympy.utilities.codegen import (
+    codegen, make_routine, CCodeGen, C89CodeGen, C99CodeGen, InputArgument,
+    CodeGenError, FCodeGen, CodeGenArgumentListError, OutputArgument,
+    InOutArgument)
+from sympy.testing.pytest import raises
+from sympy.utilities.lambdify import implemented_function
+
+#FIXME: Fails due to circular import in with core
+# from sympy import codegen
+
+
+def get_string(dump_fn, routines, prefix="file", header=False, empty=False):
+    """Wrapper for dump_fn. dump_fn writes its results to a stream object and
+       this wrapper returns the contents of that stream as a string. This
+       auxiliary function is used by many tests below.
+
+       The header and the empty lines are not generated to facilitate the
+       testing of the output.
+    """
+    output = StringIO()
+    dump_fn(routines, output, prefix, header, empty)
+    source = output.getvalue()
+    output.close()
+    return source
+
+
+def test_Routine_argument_order():
+    a, x, y, z = symbols('a x y z')
+    expr = (x + y)*z
+    raises(CodeGenArgumentListError, lambda: make_routine("test", expr,
+           argument_sequence=[z, x]))
+    raises(CodeGenArgumentListError, lambda: make_routine("test", Eq(a,
+           expr), argument_sequence=[z, x, y]))
+    r = make_routine('test', Eq(a, expr), argument_sequence=[z, x, a, y])
+    assert [ arg.name for arg in r.arguments ] == [z, x, a, y]
+    assert [ type(arg) for arg in r.arguments ] == [
+        InputArgument, InputArgument, OutputArgument, InputArgument  ]
+    r = make_routine('test', Eq(z, expr), argument_sequence=[z, x, y])
+    assert [ type(arg) for arg in r.arguments ] == [
+        InOutArgument, InputArgument, InputArgument ]
+
+    from sympy.tensor import IndexedBase, Idx
+    A, B = map(IndexedBase, ['A', 'B'])
+    m = symbols('m', integer=True)
+    i = Idx('i', m)
+    r = make_routine('test', Eq(A[i], B[i]), argument_sequence=[B, A, m])
+    assert [ arg.name for arg in r.arguments ] == [B.label, A.label, m]
+
+    expr = Integral(x*y*z, (x, 1, 2), (y, 1, 3))
+    r = make_routine('test', Eq(a, expr), argument_sequence=[z, x, a, y])
+    assert [ arg.name for arg in r.arguments ] == [z, x, a, y]
+
+
+def test_empty_c_code():
+    code_gen = C89CodeGen()
+    source = get_string(code_gen.dump_c, [])
+    assert source == "#include \"file.h\"\n#include <math.h>\n"
+
+
+def test_empty_c_code_with_comment():
+    code_gen = C89CodeGen()
+    source = get_string(code_gen.dump_c, [], header=True)
+    assert source[:82] == (
+        "/******************************************************************************\n *"
+    )
+          #   "                    Code generated with SymPy 0.7.2-git                    "
+    assert source[158:] == (                                                              "*\n"
+            " *                                                                            *\n"
+            " *              See http://www.sympy.org/ for more information.               *\n"
+            " *                                                                            *\n"
+            " *                       This file is part of 'project'                       *\n"
+            " ******************************************************************************/\n"
+            "#include \"file.h\"\n"
+            "#include <math.h>\n"
+            )
+
+
+def test_empty_c_header():
+    code_gen = C99CodeGen()
+    source = get_string(code_gen.dump_h, [])
+    assert source == "#ifndef PROJECT__FILE__H\n#define PROJECT__FILE__H\n#endif\n"
+
+
+def test_simple_c_code():
+    x, y, z = symbols('x,y,z')
+    expr = (x + y)*z
+    routine = make_routine("test", expr)
+    code_gen = C89CodeGen()
+    source = get_string(code_gen.dump_c, [routine])
+    expected = (
+        "#include \"file.h\"\n"
+        "#include <math.h>\n"
+        "double test(double x, double y, double z) {\n"
+        "   double test_result;\n"
+        "   test_result = z*(x + y);\n"
+        "   return test_result;\n"
+        "}\n"
+    )
+    assert source == expected
+
+
+def test_c_code_reserved_words():
+    x, y, z = symbols('if, typedef, while')
+    expr = (x + y) * z
+    routine = make_routine("test", expr)
+    code_gen = C99CodeGen()
+    source = get_string(code_gen.dump_c, [routine])
+    expected = (
+        "#include \"file.h\"\n"
+        "#include <math.h>\n"
+        "double test(double if_, double typedef_, double while_) {\n"
+        "   double test_result;\n"
+        "   test_result = while_*(if_ + typedef_);\n"
+        "   return test_result;\n"
+        "}\n"
+    )
+    assert source == expected
+
+
+def test_numbersymbol_c_code():
+    routine = make_routine("test", pi**Catalan)
+    code_gen = C89CodeGen()
+    source = get_string(code_gen.dump_c, [routine])
+    expected = (
+        "#include \"file.h\"\n"
+        "#include <math.h>\n"
+        "double test() {\n"
+        "   double test_result;\n"
+        "   double const Catalan = %s;\n"
+        "   test_result = pow(M_PI, Catalan);\n"
+        "   return test_result;\n"
+        "}\n"
+    ) % Catalan.evalf(17)
+    assert source == expected
+
+
+def test_c_code_argument_order():
+    x, y, z = symbols('x,y,z')
+    expr = x + y
+    routine = make_routine("test", expr, argument_sequence=[z, x, y])
+    code_gen = C89CodeGen()
+    source = get_string(code_gen.dump_c, [routine])
+    expected = (
+        "#include \"file.h\"\n"
+        "#include <math.h>\n"
+        "double test(double z, double x, double y) {\n"
+        "   double test_result;\n"
+        "   test_result = x + y;\n"
+        "   return test_result;\n"
+        "}\n"
+    )
+    assert source == expected
+
+
+def test_simple_c_header():
+    x, y, z = symbols('x,y,z')
+    expr = (x + y)*z
+    routine = make_routine("test", expr)
+    code_gen = C89CodeGen()
+    source = get_string(code_gen.dump_h, [routine])
+    expected = (
+        "#ifndef PROJECT__FILE__H\n"
+        "#define PROJECT__FILE__H\n"
+        "double test(double x, double y, double z);\n"
+        "#endif\n"
+    )
+    assert source == expected
+
+
+def test_simple_c_codegen():
+    x, y, z = symbols('x,y,z')
+    expr = (x + y)*z
+    expected = [
+        ("file.c",
+        "#include \"file.h\"\n"
+        "#include <math.h>\n"
+        "double test(double x, double y, double z) {\n"
+        "   double test_result;\n"
+        "   test_result = z*(x + y);\n"
+        "   return test_result;\n"
+        "}\n"),
+        ("file.h",
+        "#ifndef PROJECT__FILE__H\n"
+        "#define PROJECT__FILE__H\n"
+        "double test(double x, double y, double z);\n"
+        "#endif\n")
+    ]
+    result = codegen(("test", expr), "C", "file", header=False, empty=False)
+    assert result == expected
+
+
+def test_multiple_results_c():
+    x, y, z = symbols('x,y,z')
+    expr1 = (x + y)*z
+    expr2 = (x - y)*z
+    routine = make_routine(
+        "test",
+        [expr1, expr2]
+    )
+    code_gen = C99CodeGen()
+    raises(CodeGenError, lambda: get_string(code_gen.dump_h, [routine]))
+
+
+def test_no_results_c():
+    raises(ValueError, lambda: make_routine("test", []))
+
+
+def test_ansi_math1_codegen():
+    # not included: log10
+    from sympy.functions.elementary.complexes import Abs
+    from sympy.functions.elementary.exponential import log
+    from sympy.functions.elementary.hyperbolic import (cosh, sinh, tanh)
+    from sympy.functions.elementary.integers import (ceiling, floor)
+    from sympy.functions.elementary.miscellaneous import sqrt
+    from sympy.functions.elementary.trigonometric import (acos, asin, atan, cos, sin, tan)
+    x = symbols('x')
+    name_expr = [
+        ("test_fabs", Abs(x)),
+        ("test_acos", acos(x)),
+        ("test_asin", asin(x)),
+        ("test_atan", atan(x)),
+        ("test_ceil", ceiling(x)),
+        ("test_cos", cos(x)),
+        ("test_cosh", cosh(x)),
+        ("test_floor", floor(x)),
+        ("test_log", log(x)),
+        ("test_ln", log(x)),
+        ("test_sin", sin(x)),
+        ("test_sinh", sinh(x)),
+        ("test_sqrt", sqrt(x)),
+        ("test_tan", tan(x)),
+        ("test_tanh", tanh(x)),
+    ]
+    result = codegen(name_expr, "C89", "file", header=False, empty=False)
+    assert result[0][0] == "file.c"
+    assert result[0][1] == (
+        '#include "file.h"\n#include <math.h>\n'
+        'double test_fabs(double x) {\n   double test_fabs_result;\n   test_fabs_result = fabs(x);\n   return test_fabs_result;\n}\n'
+        'double test_acos(double x) {\n   double test_acos_result;\n   test_acos_result = acos(x);\n   return test_acos_result;\n}\n'
+        'double test_asin(double x) {\n   double test_asin_result;\n   test_asin_result = asin(x);\n   return test_asin_result;\n}\n'
+        'double test_atan(double x) {\n   double test_atan_result;\n   test_atan_result = atan(x);\n   return test_atan_result;\n}\n'
+        'double test_ceil(double x) {\n   double test_ceil_result;\n   test_ceil_result = ceil(x);\n   return test_ceil_result;\n}\n'
+        'double test_cos(double x) {\n   double test_cos_result;\n   test_cos_result = cos(x);\n   return test_cos_result;\n}\n'
+        'double test_cosh(double x) {\n   double test_cosh_result;\n   test_cosh_result = cosh(x);\n   return test_cosh_result;\n}\n'
+        'double test_floor(double x) {\n   double test_floor_result;\n   test_floor_result = floor(x);\n   return test_floor_result;\n}\n'
+        'double test_log(double x) {\n   double test_log_result;\n   test_log_result = log(x);\n   return test_log_result;\n}\n'
+        'double test_ln(double x) {\n   double test_ln_result;\n   test_ln_result = log(x);\n   return test_ln_result;\n}\n'
+        'double test_sin(double x) {\n   double test_sin_result;\n   test_sin_result = sin(x);\n   return test_sin_result;\n}\n'
+        'double test_sinh(double x) {\n   double test_sinh_result;\n   test_sinh_result = sinh(x);\n   return test_sinh_result;\n}\n'
+        'double test_sqrt(double x) {\n   double test_sqrt_result;\n   test_sqrt_result = sqrt(x);\n   return test_sqrt_result;\n}\n'
+        'double test_tan(double x) {\n   double test_tan_result;\n   test_tan_result = tan(x);\n   return test_tan_result;\n}\n'
+        'double test_tanh(double x) {\n   double test_tanh_result;\n   test_tanh_result = tanh(x);\n   return test_tanh_result;\n}\n'
+    )
+    assert result[1][0] == "file.h"
+    assert result[1][1] == (
+        '#ifndef PROJECT__FILE__H\n#define PROJECT__FILE__H\n'
+        'double test_fabs(double x);\ndouble test_acos(double x);\n'
+        'double test_asin(double x);\ndouble test_atan(double x);\n'
+        'double test_ceil(double x);\ndouble test_cos(double x);\n'
+        'double test_cosh(double x);\ndouble test_floor(double x);\n'
+        'double test_log(double x);\ndouble test_ln(double x);\n'
+        'double test_sin(double x);\ndouble test_sinh(double x);\n'
+        'double test_sqrt(double x);\ndouble test_tan(double x);\n'
+        'double test_tanh(double x);\n#endif\n'
+    )
+
+
+def test_ansi_math2_codegen():
+    # not included: frexp, ldexp, modf, fmod
+    from sympy.functions.elementary.trigonometric import atan2
+    x, y = symbols('x,y')
+    name_expr = [
+        ("test_atan2", atan2(x, y)),
+        ("test_pow", x**y),
+    ]
+    result = codegen(name_expr, "C89", "file", header=False, empty=False)
+    assert result[0][0] == "file.c"
+    assert result[0][1] == (
+        '#include "file.h"\n#include <math.h>\n'
+        'double test_atan2(double x, double y) {\n   double test_atan2_result;\n   test_atan2_result = atan2(x, y);\n   return test_atan2_result;\n}\n'
+        'double test_pow(double x, double y) {\n   double test_pow_result;\n   test_pow_result = pow(x, y);\n   return test_pow_result;\n}\n'
+    )
+    assert result[1][0] == "file.h"
+    assert result[1][1] == (
+        '#ifndef PROJECT__FILE__H\n#define PROJECT__FILE__H\n'
+        'double test_atan2(double x, double y);\n'
+        'double test_pow(double x, double y);\n'
+        '#endif\n'
+    )
+
+
+def test_complicated_codegen():
+    from sympy.functions.elementary.trigonometric import (cos, sin, tan)
+    x, y, z = symbols('x,y,z')
+    name_expr = [
+        ("test1", ((sin(x) + cos(y) + tan(z))**7).expand()),
+        ("test2", cos(cos(cos(cos(cos(cos(cos(cos(x + y + z))))))))),
+    ]
+    result = codegen(name_expr, "C89", "file", header=False, empty=False)
+    assert result[0][0] == "file.c"
+    assert result[0][1] == (
+        '#include "file.h"\n#include <math.h>\n'
+        'double test1(double x, double y, double z) {\n'
+        '   double test1_result;\n'
+        '   test1_result = '
+        'pow(sin(x), 7) + '
+        '7*pow(sin(x), 6)*cos(y) + '
+        '7*pow(sin(x), 6)*tan(z) + '
+        '21*pow(sin(x), 5)*pow(cos(y), 2) + '
+        '42*pow(sin(x), 5)*cos(y)*tan(z) + '
+        '21*pow(sin(x), 5)*pow(tan(z), 2) + '
+        '35*pow(sin(x), 4)*pow(cos(y), 3) + '
+        '105*pow(sin(x), 4)*pow(cos(y), 2)*tan(z) + '
+        '105*pow(sin(x), 4)*cos(y)*pow(tan(z), 2) + '
+        '35*pow(sin(x), 4)*pow(tan(z), 3) + '
+        '35*pow(sin(x), 3)*pow(cos(y), 4) + '
+        '140*pow(sin(x), 3)*pow(cos(y), 3)*tan(z) + '
+        '210*pow(sin(x), 3)*pow(cos(y), 2)*pow(tan(z), 2) + '
+        '140*pow(sin(x), 3)*cos(y)*pow(tan(z), 3) + '
+        '35*pow(sin(x), 3)*pow(tan(z), 4) + '
+        '21*pow(sin(x), 2)*pow(cos(y), 5) + '
+        '105*pow(sin(x), 2)*pow(cos(y), 4)*tan(z) + '
+        '210*pow(sin(x), 2)*pow(cos(y), 3)*pow(tan(z), 2) + '
+        '210*pow(sin(x), 2)*pow(cos(y), 2)*pow(tan(z), 3) + '
+        '105*pow(sin(x), 2)*cos(y)*pow(tan(z), 4) + '
+        '21*pow(sin(x), 2)*pow(tan(z), 5) + '
+        '7*sin(x)*pow(cos(y), 6) + '
+        '42*sin(x)*pow(cos(y), 5)*tan(z) + '
+        '105*sin(x)*pow(cos(y), 4)*pow(tan(z), 2) + '
+        '140*sin(x)*pow(cos(y), 3)*pow(tan(z), 3) + '
+        '105*sin(x)*pow(cos(y), 2)*pow(tan(z), 4) + '
+        '42*sin(x)*cos(y)*pow(tan(z), 5) + '
+        '7*sin(x)*pow(tan(z), 6) + '
+        'pow(cos(y), 7) + '
+        '7*pow(cos(y), 6)*tan(z) + '
+        '21*pow(cos(y), 5)*pow(tan(z), 2) + '
+        '35*pow(cos(y), 4)*pow(tan(z), 3) + '
+        '35*pow(cos(y), 3)*pow(tan(z), 4) + '
+        '21*pow(cos(y), 2)*pow(tan(z), 5) + '
+        '7*cos(y)*pow(tan(z), 6) + '
+        'pow(tan(z), 7);\n'
+        '   return test1_result;\n'
+        '}\n'
+        'double test2(double x, double y, double z) {\n'
+        '   double test2_result;\n'
+        '   test2_result = cos(cos(cos(cos(cos(cos(cos(cos(x + y + z))))))));\n'
+        '   return test2_result;\n'
+        '}\n'
+    )
+    assert result[1][0] == "file.h"
+    assert result[1][1] == (
+        '#ifndef PROJECT__FILE__H\n'
+        '#define PROJECT__FILE__H\n'
+        'double test1(double x, double y, double z);\n'
+        'double test2(double x, double y, double z);\n'
+        '#endif\n'
+    )
+
+
+def test_loops_c():
+    from sympy.tensor import IndexedBase, Idx
+    from sympy.core.symbol import symbols
+    n, m = symbols('n m', integer=True)
+    A = IndexedBase('A')
+    x = IndexedBase('x')
+    y = IndexedBase('y')
+    i = Idx('i', m)
+    j = Idx('j', n)
+
+    (f1, code), (f2, interface) = codegen(
+        ('matrix_vector', Eq(y[i], A[i, j]*x[j])), "C99", "file", header=False, empty=False)
+
+    assert f1 == 'file.c'
+    expected = (
+        '#include "file.h"\n'
+        '#include <math.h>\n'
+        'void matrix_vector(double *A, int m, int n, double *x, double *y) {\n'
+        '   for (int i=0; i<m; i++){\n'
+        '      y[i] = 0;\n'
+        '   }\n'
+        '   for (int i=0; i<m; i++){\n'
+        '      for (int j=0; j<n; j++){\n'
+        '         y[i] = %(rhs)s + y[i];\n'
+        '      }\n'
+        '   }\n'
+        '}\n'
+    )
+
+    assert (code == expected % {'rhs': 'A[%s]*x[j]' % (i*n + j)} or
+            code == expected % {'rhs': 'A[%s]*x[j]' % (j + i*n)} or
+            code == expected % {'rhs': 'x[j]*A[%s]' % (i*n + j)} or
+            code == expected % {'rhs': 'x[j]*A[%s]' % (j + i*n)})
+    assert f2 == 'file.h'
+    assert interface == (
+        '#ifndef PROJECT__FILE__H\n'
+        '#define PROJECT__FILE__H\n'
+        'void matrix_vector(double *A, int m, int n, double *x, double *y);\n'
+        '#endif\n'
+    )
+
+
+def test_dummy_loops_c():
+    from sympy.tensor import IndexedBase, Idx
+    i, m = symbols('i m', integer=True, cls=Dummy)
+    x = IndexedBase('x')
+    y = IndexedBase('y')
+    i = Idx(i, m)
+    expected = (
+        '#include "file.h"\n'
+        '#include <math.h>\n'
+        'void test_dummies(int m_%(mno)i, double *x, double *y) {\n'
+        '   for (int i_%(ino)i=0; i_%(ino)i<m_%(mno)i; i_%(ino)i++){\n'
+        '      y[i_%(ino)i] = x[i_%(ino)i];\n'
+        '   }\n'
+        '}\n'
+    ) % {'ino': i.label.dummy_index, 'mno': m.dummy_index}
+    r = make_routine('test_dummies', Eq(y[i], x[i]))
+    c89 = C89CodeGen()
+    c99 = C99CodeGen()
+    code = get_string(c99.dump_c, [r])
+    assert code == expected
+    with raises(NotImplementedError):
+        get_string(c89.dump_c, [r])
+
+def test_partial_loops_c():
+    # check that loop boundaries are determined by Idx, and array strides
+    # determined by shape of IndexedBase object.
+    from sympy.tensor import IndexedBase, Idx
+    from sympy.core.symbol import symbols
+    n, m, o, p = symbols('n m o p', integer=True)
+    A = IndexedBase('A', shape=(m, p))
+    x = IndexedBase('x')
+    y = IndexedBase('y')
+    i = Idx('i', (o, m - 5))  # Note: bounds are inclusive
+    j = Idx('j', n)          # dimension n corresponds to bounds (0, n - 1)
+
+    (f1, code), (f2, interface) = codegen(
+        ('matrix_vector', Eq(y[i], A[i, j]*x[j])), "C99", "file", header=False, empty=False)
+
+    assert f1 == 'file.c'
+    expected = (
+        '#include "file.h"\n'
+        '#include <math.h>\n'
+        'void matrix_vector(double *A, int m, int n, int o, int p, double *x, double *y) {\n'
+        '   for (int i=o; i<%(upperi)s; i++){\n'
+        '      y[i] = 0;\n'
+        '   }\n'
+        '   for (int i=o; i<%(upperi)s; i++){\n'
+        '      for (int j=0; j<n; j++){\n'
+        '         y[i] = %(rhs)s + y[i];\n'
+        '      }\n'
+        '   }\n'
+        '}\n'
+    ) % {'upperi': m - 4, 'rhs': '%(rhs)s'}
+
+    assert (code == expected % {'rhs': 'A[%s]*x[j]' % (i*p + j)} or
+            code == expected % {'rhs': 'A[%s]*x[j]' % (j + i*p)} or
+            code == expected % {'rhs': 'x[j]*A[%s]' % (i*p + j)} or
+            code == expected % {'rhs': 'x[j]*A[%s]' % (j + i*p)})
+    assert f2 == 'file.h'
+    assert interface == (
+        '#ifndef PROJECT__FILE__H\n'
+        '#define PROJECT__FILE__H\n'
+        'void matrix_vector(double *A, int m, int n, int o, int p, double *x, double *y);\n'
+        '#endif\n'
+    )
+
+
+def test_output_arg_c():
+    from sympy.core.relational import Equality
+    from sympy.functions.elementary.trigonometric import (cos, sin)
+    x, y, z = symbols("x,y,z")
+    r = make_routine("foo", [Equality(y, sin(x)), cos(x)])
+    c = C89CodeGen()
+    result = c.write([r], "test", header=False, empty=False)
+    assert result[0][0] == "test.c"
+    expected = (
+        '#include "test.h"\n'
+        '#include <math.h>\n'
+        'double foo(double x, double *y) {\n'
+        '   (*y) = sin(x);\n'
+        '   double foo_result;\n'
+        '   foo_result = cos(x);\n'
+        '   return foo_result;\n'
+        '}\n'
+    )
+    assert result[0][1] == expected
+
+
+def test_output_arg_c_reserved_words():
+    from sympy.core.relational import Equality
+    from sympy.functions.elementary.trigonometric import (cos, sin)
+    x, y, z = symbols("if, while, z")
+    r = make_routine("foo", [Equality(y, sin(x)), cos(x)])
+    c = C89CodeGen()
+    result = c.write([r], "test", header=False, empty=False)
+    assert result[0][0] == "test.c"
+    expected = (
+        '#include "test.h"\n'
+        '#include <math.h>\n'
+        'double foo(double if_, double *while_) {\n'
+        '   (*while_) = sin(if_);\n'
+        '   double foo_result;\n'
+        '   foo_result = cos(if_);\n'
+        '   return foo_result;\n'
+        '}\n'
+    )
+    assert result[0][1] == expected
+
+
+def test_multidim_c_argument_cse():
+    A_sym = MatrixSymbol('A', 3, 3)
+    b_sym = MatrixSymbol('b', 3, 1)
+    A = Matrix(A_sym)
+    b = Matrix(b_sym)
+    c = A*b
+    cgen = CCodeGen(project="test", cse=True)
+    r = cgen.routine("c", c)
+    r.arguments[-1].result_var = "out"
+    r.arguments[-1]._name = "out"
+    code = get_string(cgen.dump_c, [r], prefix="test")
+    expected = (
+        '#include "test.h"\n'
+        "#include <math.h>\n"
+        "void c(double *A, double *b, double *out) {\n"
+        "   out[0] = A[0]*b[0] + A[1]*b[1] + A[2]*b[2];\n"
+        "   out[1] = A[3]*b[0] + A[4]*b[1] + A[5]*b[2];\n"
+        "   out[2] = A[6]*b[0] + A[7]*b[1] + A[8]*b[2];\n"
+        "}\n"
+    )
+    assert code == expected
+
+
+def test_ccode_results_named_ordered():
+    x, y, z = symbols('x,y,z')
+    B, C = symbols('B,C')
+    A = MatrixSymbol('A', 1, 3)
+    expr1 = Equality(A, Matrix([[1, 2, x]]))
+    expr2 = Equality(C, (x + y)*z)
+    expr3 = Equality(B, 2*x)
+    name_expr = ("test", [expr1, expr2, expr3])
+    expected = (
+        '#include "test.h"\n'
+        '#include <math.h>\n'
+        'void test(double x, double *C, double z, double y, double *A, double *B) {\n'
+        '   (*C) = z*(x + y);\n'
+        '   A[0] = 1;\n'
+        '   A[1] = 2;\n'
+        '   A[2] = x;\n'
+        '   (*B) = 2*x;\n'
+        '}\n'
+    )
+
+    result = codegen(name_expr, "c", "test", header=False, empty=False,
+                     argument_sequence=(x, C, z, y, A, B))
+    source = result[0][1]
+    assert source == expected
+
+
+def test_ccode_matrixsymbol_slice():
+    A = MatrixSymbol('A', 5, 3)
+    B = MatrixSymbol('B', 1, 3)
+    C = MatrixSymbol('C', 1, 3)
+    D = MatrixSymbol('D', 5, 1)
+    name_expr = ("test", [Equality(B, A[0, :]),
+                          Equality(C, A[1, :]),
+                          Equality(D, A[:, 2])])
+    result = codegen(name_expr, "c99", "test", header=False, empty=False)
+    source = result[0][1]
+    expected = (
+        '#include "test.h"\n'
+        '#include <math.h>\n'
+        'void test(double *A, double *B, double *C, double *D) {\n'
+        '   B[0] = A[0];\n'
+        '   B[1] = A[1];\n'
+        '   B[2] = A[2];\n'
+        '   C[0] = A[3];\n'
+        '   C[1] = A[4];\n'
+        '   C[2] = A[5];\n'
+        '   D[0] = A[2];\n'
+        '   D[1] = A[5];\n'
+        '   D[2] = A[8];\n'
+        '   D[3] = A[11];\n'
+        '   D[4] = A[14];\n'
+        '}\n'
+    )
+    assert source == expected
+
+def test_ccode_cse():
+    a, b, c, d = symbols('a b c d')
+    e = MatrixSymbol('e', 3, 1)
+    name_expr = ("test", [Equality(e, Matrix([[a*b], [a*b + c*d], [a*b*c*d]]))])
+    generator = CCodeGen(cse=True)
+    result = codegen(name_expr, code_gen=generator, header=False, empty=False)
+    source = result[0][1]
+    expected = (
+        '#include "test.h"\n'
+        '#include <math.h>\n'
+        'void test(double a, double b, double c, double d, double *e) {\n'
+        '   const double x0 = a*b;\n'
+        '   const double x1 = c*d;\n'
+        '   e[0] = x0;\n'
+        '   e[1] = x0 + x1;\n'
+        '   e[2] = x0*x1;\n'
+        '}\n'
+    )
+    assert source == expected
+
+def test_ccode_unused_array_arg():
+    x = MatrixSymbol('x', 2, 1)
+    # x does not appear in output
+    name_expr = ("test", 1.0)
+    generator = CCodeGen()
+    result = codegen(name_expr, code_gen=generator, header=False, empty=False, argument_sequence=(x,))
+    source = result[0][1]
+    # note: x should appear as (double *)
+    expected = (
+        '#include "test.h"\n'
+        '#include <math.h>\n'
+        'double test(double *x) {\n'
+        '   double test_result;\n'
+        '   test_result = 1.0;\n'
+        '   return test_result;\n'
+        '}\n'
+    )
+    assert source == expected
+
+def test_ccode_unused_array_arg_func():
+    # issue 16689
+    X = MatrixSymbol('X',3,1)
+    Y = MatrixSymbol('Y',3,1)
+    z = symbols('z',integer = True)
+    name_expr = ('testBug', X[0] + X[1])
+    result = codegen(name_expr, language='C', header=False, empty=False, argument_sequence=(X, Y, z))
+    source = result[0][1]
+    expected = (
+        '#include "testBug.h"\n'
+        '#include <math.h>\n'
+        'double testBug(double *X, double *Y, int z) {\n'
+        '   double testBug_result;\n'
+        '   testBug_result = X[0] + X[1];\n'
+        '   return testBug_result;\n'
+        '}\n'
+    )
+    assert source == expected
+
+def test_empty_f_code():
+    code_gen = FCodeGen()
+    source = get_string(code_gen.dump_f95, [])
+    assert source == ""
+
+
+def test_empty_f_code_with_header():
+    code_gen = FCodeGen()
+    source = get_string(code_gen.dump_f95, [], header=True)
+    assert source[:82] == (
+        "!******************************************************************************\n!*"
+    )
+          #   "                    Code generated with SymPy 0.7.2-git                    "
+    assert source[158:] == (                                                              "*\n"
+            "!*                                                                            *\n"
+            "!*              See http://www.sympy.org/ for more information.               *\n"
+            "!*                                                                            *\n"
+            "!*                       This file is part of 'project'                       *\n"
+            "!******************************************************************************\n"
+            )
+
+
+def test_empty_f_header():
+    code_gen = FCodeGen()
+    source = get_string(code_gen.dump_h, [])
+    assert source == ""
+
+
+def test_simple_f_code():
+    x, y, z = symbols('x,y,z')
+    expr = (x + y)*z
+    routine = make_routine("test", expr)
+    code_gen = FCodeGen()
+    source = get_string(code_gen.dump_f95, [routine])
+    expected = (
+        "REAL*8 function test(x, y, z)\n"
+        "implicit none\n"
+        "REAL*8, intent(in) :: x\n"
+        "REAL*8, intent(in) :: y\n"
+        "REAL*8, intent(in) :: z\n"
+        "test = z*(x + y)\n"
+        "end function\n"
+    )
+    assert source == expected
+
+
+def test_numbersymbol_f_code():
+    routine = make_routine("test", pi**Catalan)
+    code_gen = FCodeGen()
+    source = get_string(code_gen.dump_f95, [routine])
+    expected = (
+        "REAL*8 function test()\n"
+        "implicit none\n"
+        "REAL*8, parameter :: Catalan = %sd0\n"
+        "REAL*8, parameter :: pi = %sd0\n"
+        "test = pi**Catalan\n"
+        "end function\n"
+    ) % (Catalan.evalf(17), pi.evalf(17))
+    assert source == expected
+
+def test_erf_f_code():
+    x = symbols('x')
+    routine = make_routine("test", erf(x) - erf(-2 * x))
+    code_gen = FCodeGen()
+    source = get_string(code_gen.dump_f95, [routine])
+    expected = (
+        "REAL*8 function test(x)\n"
+        "implicit none\n"
+        "REAL*8, intent(in) :: x\n"
+        "test = erf(x) + erf(2.0d0*x)\n"
+        "end function\n"
+    )
+    assert source == expected, source
+
+def test_f_code_argument_order():
+    x, y, z = symbols('x,y,z')
+    expr = x + y
+    routine = make_routine("test", expr, argument_sequence=[z, x, y])
+    code_gen = FCodeGen()
+    source = get_string(code_gen.dump_f95, [routine])
+    expected = (
+        "REAL*8 function test(z, x, y)\n"
+        "implicit none\n"
+        "REAL*8, intent(in) :: z\n"
+        "REAL*8, intent(in) :: x\n"
+        "REAL*8, intent(in) :: y\n"
+        "test = x + y\n"
+        "end function\n"
+    )
+    assert source == expected
+
+
+def test_simple_f_header():
+    x, y, z = symbols('x,y,z')
+    expr = (x + y)*z
+    routine = make_routine("test", expr)
+    code_gen = FCodeGen()
+    source = get_string(code_gen.dump_h, [routine])
+    expected = (
+        "interface\n"
+        "REAL*8 function test(x, y, z)\n"
+        "implicit none\n"
+        "REAL*8, intent(in) :: x\n"
+        "REAL*8, intent(in) :: y\n"
+        "REAL*8, intent(in) :: z\n"
+        "end function\n"
+        "end interface\n"
+    )
+    assert source == expected
+
+
+def test_simple_f_codegen():
+    x, y, z = symbols('x,y,z')
+    expr = (x + y)*z
+    result = codegen(
+        ("test", expr), "F95", "file", header=False, empty=False)
+    expected = [
+        ("file.f90",
+        "REAL*8 function test(x, y, z)\n"
+        "implicit none\n"
+        "REAL*8, intent(in) :: x\n"
+        "REAL*8, intent(in) :: y\n"
+        "REAL*8, intent(in) :: z\n"
+        "test = z*(x + y)\n"
+        "end function\n"),
+        ("file.h",
+        "interface\n"
+        "REAL*8 function test(x, y, z)\n"
+        "implicit none\n"
+        "REAL*8, intent(in) :: x\n"
+        "REAL*8, intent(in) :: y\n"
+        "REAL*8, intent(in) :: z\n"
+        "end function\n"
+        "end interface\n")
+    ]
+    assert result == expected
+
+
+def test_multiple_results_f():
+    x, y, z = symbols('x,y,z')
+    expr1 = (x + y)*z
+    expr2 = (x - y)*z
+    routine = make_routine(
+        "test",
+        [expr1, expr2]
+    )
+    code_gen = FCodeGen()
+    raises(CodeGenError, lambda: get_string(code_gen.dump_h, [routine]))
+
+
+def test_no_results_f():
+    raises(ValueError, lambda: make_routine("test", []))
+
+
+def test_intrinsic_math_codegen():
+    # not included: log10
+    from sympy.functions.elementary.complexes import Abs
+    from sympy.functions.elementary.exponential import log
+    from sympy.functions.elementary.hyperbolic import (cosh, sinh, tanh)
+    from sympy.functions.elementary.miscellaneous import sqrt
+    from sympy.functions.elementary.trigonometric import (acos, asin, atan, cos, sin, tan)
+    x = symbols('x')
+    name_expr = [
+        ("test_abs", Abs(x)),
+        ("test_acos", acos(x)),
+        ("test_asin", asin(x)),
+        ("test_atan", atan(x)),
+        ("test_cos", cos(x)),
+        ("test_cosh", cosh(x)),
+        ("test_log", log(x)),
+        ("test_ln", log(x)),
+        ("test_sin", sin(x)),
+        ("test_sinh", sinh(x)),
+        ("test_sqrt", sqrt(x)),
+        ("test_tan", tan(x)),
+        ("test_tanh", tanh(x)),
+    ]
+    result = codegen(name_expr, "F95", "file", header=False, empty=False)
+    assert result[0][0] == "file.f90"
+    expected = (
+        'REAL*8 function test_abs(x)\n'
+        'implicit none\n'
+        'REAL*8, intent(in) :: x\n'
+        'test_abs = abs(x)\n'
+        'end function\n'
+        'REAL*8 function test_acos(x)\n'
+        'implicit none\n'
+        'REAL*8, intent(in) :: x\n'
+        'test_acos = acos(x)\n'
+        'end function\n'
+        'REAL*8 function test_asin(x)\n'
+        'implicit none\n'
+        'REAL*8, intent(in) :: x\n'
+        'test_asin = asin(x)\n'
+        'end function\n'
+        'REAL*8 function test_atan(x)\n'
+        'implicit none\n'
+        'REAL*8, intent(in) :: x\n'
+        'test_atan = atan(x)\n'
+        'end function\n'
+        'REAL*8 function test_cos(x)\n'
+        'implicit none\n'
+        'REAL*8, intent(in) :: x\n'
+        'test_cos = cos(x)\n'
+        'end function\n'
+        'REAL*8 function test_cosh(x)\n'
+        'implicit none\n'
+        'REAL*8, intent(in) :: x\n'
+        'test_cosh = cosh(x)\n'
+        'end function\n'
+        'REAL*8 function test_log(x)\n'
+        'implicit none\n'
+        'REAL*8, intent(in) :: x\n'
+        'test_log = log(x)\n'
+        'end function\n'
+        'REAL*8 function test_ln(x)\n'
+        'implicit none\n'
+        'REAL*8, intent(in) :: x\n'
+        'test_ln = log(x)\n'
+        'end function\n'
+        'REAL*8 function test_sin(x)\n'
+        'implicit none\n'
+        'REAL*8, intent(in) :: x\n'
+        'test_sin = sin(x)\n'
+        'end function\n'
+        'REAL*8 function test_sinh(x)\n'
+        'implicit none\n'
+        'REAL*8, intent(in) :: x\n'
+        'test_sinh = sinh(x)\n'
+        'end function\n'
+        'REAL*8 function test_sqrt(x)\n'
+        'implicit none\n'
+        'REAL*8, intent(in) :: x\n'
+        'test_sqrt = sqrt(x)\n'
+        'end function\n'
+        'REAL*8 function test_tan(x)\n'
+        'implicit none\n'
+        'REAL*8, intent(in) :: x\n'
+        'test_tan = tan(x)\n'
+        'end function\n'
+        'REAL*8 function test_tanh(x)\n'
+        'implicit none\n'
+        'REAL*8, intent(in) :: x\n'
+        'test_tanh = tanh(x)\n'
+        'end function\n'
+    )
+    assert result[0][1] == expected
+
+    assert result[1][0] == "file.h"
+    expected = (
+        'interface\n'
+        'REAL*8 function test_abs(x)\n'
+        'implicit none\n'
+        'REAL*8, intent(in) :: x\n'
+        'end function\n'
+        'end interface\n'
+        'interface\n'
+        'REAL*8 function test_acos(x)\n'
+        'implicit none\n'
+        'REAL*8, intent(in) :: x\n'
+        'end function\n'
+        'end interface\n'
+        'interface\n'
+        'REAL*8 function test_asin(x)\n'
+        'implicit none\n'
+        'REAL*8, intent(in) :: x\n'
+        'end function\n'
+        'end interface\n'
+        'interface\n'
+        'REAL*8 function test_atan(x)\n'
+        'implicit none\n'
+        'REAL*8, intent(in) :: x\n'
+        'end function\n'
+        'end interface\n'
+        'interface\n'
+        'REAL*8 function test_cos(x)\n'
+        'implicit none\n'
+        'REAL*8, intent(in) :: x\n'
+        'end function\n'
+        'end interface\n'
+        'interface\n'
+        'REAL*8 function test_cosh(x)\n'
+        'implicit none\n'
+        'REAL*8, intent(in) :: x\n'
+        'end function\n'
+        'end interface\n'
+        'interface\n'
+        'REAL*8 function test_log(x)\n'
+        'implicit none\n'
+        'REAL*8, intent(in) :: x\n'
+        'end function\n'
+        'end interface\n'
+        'interface\n'
+        'REAL*8 function test_ln(x)\n'
+        'implicit none\n'
+        'REAL*8, intent(in) :: x\n'
+        'end function\n'
+        'end interface\n'
+        'interface\n'
+        'REAL*8 function test_sin(x)\n'
+        'implicit none\n'
+        'REAL*8, intent(in) :: x\n'
+        'end function\n'
+        'end interface\n'
+        'interface\n'
+        'REAL*8 function test_sinh(x)\n'
+        'implicit none\n'
+        'REAL*8, intent(in) :: x\n'
+        'end function\n'
+        'end interface\n'
+        'interface\n'
+        'REAL*8 function test_sqrt(x)\n'
+        'implicit none\n'
+        'REAL*8, intent(in) :: x\n'
+        'end function\n'
+        'end interface\n'
+        'interface\n'
+        'REAL*8 function test_tan(x)\n'
+        'implicit none\n'
+        'REAL*8, intent(in) :: x\n'
+        'end function\n'
+        'end interface\n'
+        'interface\n'
+        'REAL*8 function test_tanh(x)\n'
+        'implicit none\n'
+        'REAL*8, intent(in) :: x\n'
+        'end function\n'
+        'end interface\n'
+    )
+    assert result[1][1] == expected
+
+
+def test_intrinsic_math2_codegen():
+    # not included: frexp, ldexp, modf, fmod
+    from sympy.functions.elementary.trigonometric import atan2
+    x, y = symbols('x,y')
+    name_expr = [
+        ("test_atan2", atan2(x, y)),
+        ("test_pow", x**y),
+    ]
+    result = codegen(name_expr, "F95", "file", header=False, empty=False)
+    assert result[0][0] == "file.f90"
+    expected = (
+        'REAL*8 function test_atan2(x, y)\n'
+        'implicit none\n'
+        'REAL*8, intent(in) :: x\n'
+        'REAL*8, intent(in) :: y\n'
+        'test_atan2 = atan2(x, y)\n'
+        'end function\n'
+        'REAL*8 function test_pow(x, y)\n'
+        'implicit none\n'
+        'REAL*8, intent(in) :: x\n'
+        'REAL*8, intent(in) :: y\n'
+        'test_pow = x**y\n'
+        'end function\n'
+    )
+    assert result[0][1] == expected
+
+    assert result[1][0] == "file.h"
+    expected = (
+        'interface\n'
+        'REAL*8 function test_atan2(x, y)\n'
+        'implicit none\n'
+        'REAL*8, intent(in) :: x\n'
+        'REAL*8, intent(in) :: y\n'
+        'end function\n'
+        'end interface\n'
+        'interface\n'
+        'REAL*8 function test_pow(x, y)\n'
+        'implicit none\n'
+        'REAL*8, intent(in) :: x\n'
+        'REAL*8, intent(in) :: y\n'
+        'end function\n'
+        'end interface\n'
+    )
+    assert result[1][1] == expected
+
+
+def test_complicated_codegen_f95():
+    from sympy.functions.elementary.trigonometric import (cos, sin, tan)
+    x, y, z = symbols('x,y,z')
+    name_expr = [
+        ("test1", ((sin(x) + cos(y) + tan(z))**7).expand()),
+        ("test2", cos(cos(cos(cos(cos(cos(cos(cos(x + y + z))))))))),
+    ]
+    result = codegen(name_expr, "F95", "file", header=False, empty=False)
+    assert result[0][0] == "file.f90"
+    expected = (
+        'REAL*8 function test1(x, y, z)\n'
+        'implicit none\n'
+        'REAL*8, intent(in) :: x\n'
+        'REAL*8, intent(in) :: y\n'
+        'REAL*8, intent(in) :: z\n'
+        'test1 = sin(x)**7 + 7*sin(x)**6*cos(y) + 7*sin(x)**6*tan(z) + 21*sin(x) &\n'
+        '      **5*cos(y)**2 + 42*sin(x)**5*cos(y)*tan(z) + 21*sin(x)**5*tan(z) &\n'
+        '      **2 + 35*sin(x)**4*cos(y)**3 + 105*sin(x)**4*cos(y)**2*tan(z) + &\n'
+        '      105*sin(x)**4*cos(y)*tan(z)**2 + 35*sin(x)**4*tan(z)**3 + 35*sin( &\n'
+        '      x)**3*cos(y)**4 + 140*sin(x)**3*cos(y)**3*tan(z) + 210*sin(x)**3* &\n'
+        '      cos(y)**2*tan(z)**2 + 140*sin(x)**3*cos(y)*tan(z)**3 + 35*sin(x) &\n'
+        '      **3*tan(z)**4 + 21*sin(x)**2*cos(y)**5 + 105*sin(x)**2*cos(y)**4* &\n'
+        '      tan(z) + 210*sin(x)**2*cos(y)**3*tan(z)**2 + 210*sin(x)**2*cos(y) &\n'
+        '      **2*tan(z)**3 + 105*sin(x)**2*cos(y)*tan(z)**4 + 21*sin(x)**2*tan &\n'
+        '      (z)**5 + 7*sin(x)*cos(y)**6 + 42*sin(x)*cos(y)**5*tan(z) + 105* &\n'
+        '      sin(x)*cos(y)**4*tan(z)**2 + 140*sin(x)*cos(y)**3*tan(z)**3 + 105 &\n'
+        '      *sin(x)*cos(y)**2*tan(z)**4 + 42*sin(x)*cos(y)*tan(z)**5 + 7*sin( &\n'
+        '      x)*tan(z)**6 + cos(y)**7 + 7*cos(y)**6*tan(z) + 21*cos(y)**5*tan( &\n'
+        '      z)**2 + 35*cos(y)**4*tan(z)**3 + 35*cos(y)**3*tan(z)**4 + 21*cos( &\n'
+        '      y)**2*tan(z)**5 + 7*cos(y)*tan(z)**6 + tan(z)**7\n'
+        'end function\n'
+        'REAL*8 function test2(x, y, z)\n'
+        'implicit none\n'
+        'REAL*8, intent(in) :: x\n'
+        'REAL*8, intent(in) :: y\n'
+        'REAL*8, intent(in) :: z\n'
+        'test2 = cos(cos(cos(cos(cos(cos(cos(cos(x + y + z))))))))\n'
+        'end function\n'
+    )
+    assert result[0][1] == expected
+    assert result[1][0] == "file.h"
+    expected = (
+        'interface\n'
+        'REAL*8 function test1(x, y, z)\n'
+        'implicit none\n'
+        'REAL*8, intent(in) :: x\n'
+        'REAL*8, intent(in) :: y\n'
+        'REAL*8, intent(in) :: z\n'
+        'end function\n'
+        'end interface\n'
+        'interface\n'
+        'REAL*8 function test2(x, y, z)\n'
+        'implicit none\n'
+        'REAL*8, intent(in) :: x\n'
+        'REAL*8, intent(in) :: y\n'
+        'REAL*8, intent(in) :: z\n'
+        'end function\n'
+        'end interface\n'
+    )
+    assert result[1][1] == expected
+
+
+def test_loops():
+    from sympy.tensor import IndexedBase, Idx
+    from sympy.core.symbol import symbols
+
+    n, m = symbols('n,m', integer=True)
+    A, x, y = map(IndexedBase, 'Axy')
+    i = Idx('i', m)
+    j = Idx('j', n)
+
+    (f1, code), (f2, interface) = codegen(
+        ('matrix_vector', Eq(y[i], A[i, j]*x[j])), "F95", "file", header=False, empty=False)
+
+    assert f1 == 'file.f90'
+    expected = (
+        'subroutine matrix_vector(A, m, n, x, y)\n'
+        'implicit none\n'
+        'INTEGER*4, intent(in) :: m\n'
+        'INTEGER*4, intent(in) :: n\n'
+        'REAL*8, intent(in), dimension(1:m, 1:n) :: A\n'
+        'REAL*8, intent(in), dimension(1:n) :: x\n'
+        'REAL*8, intent(out), dimension(1:m) :: y\n'
+        'INTEGER*4 :: i\n'
+        'INTEGER*4 :: j\n'
+        'do i = 1, m\n'
+        '   y(i) = 0\n'
+        'end do\n'
+        'do i = 1, m\n'
+        '   do j = 1, n\n'
+        '      y(i) = %(rhs)s + y(i)\n'
+        '   end do\n'
+        'end do\n'
+        'end subroutine\n'
+    )
+
+    assert code == expected % {'rhs': 'A(i, j)*x(j)'} or\
+        code == expected % {'rhs': 'x(j)*A(i, j)'}
+    assert f2 == 'file.h'
+    assert interface == (
+        'interface\n'
+        'subroutine matrix_vector(A, m, n, x, y)\n'
+        'implicit none\n'
+        'INTEGER*4, intent(in) :: m\n'
+        'INTEGER*4, intent(in) :: n\n'
+        'REAL*8, intent(in), dimension(1:m, 1:n) :: A\n'
+        'REAL*8, intent(in), dimension(1:n) :: x\n'
+        'REAL*8, intent(out), dimension(1:m) :: y\n'
+        'end subroutine\n'
+        'end interface\n'
+    )
+
+
+def test_dummy_loops_f95():
+    from sympy.tensor import IndexedBase, Idx
+    i, m = symbols('i m', integer=True, cls=Dummy)
+    x = IndexedBase('x')
+    y = IndexedBase('y')
+    i = Idx(i, m)
+    expected = (
+        'subroutine test_dummies(m_%(mcount)i, x, y)\n'
+        'implicit none\n'
+        'INTEGER*4, intent(in) :: m_%(mcount)i\n'
+        'REAL*8, intent(in), dimension(1:m_%(mcount)i) :: x\n'
+        'REAL*8, intent(out), dimension(1:m_%(mcount)i) :: y\n'
+        'INTEGER*4 :: i_%(icount)i\n'
+        'do i_%(icount)i = 1, m_%(mcount)i\n'
+        '   y(i_%(icount)i) = x(i_%(icount)i)\n'
+        'end do\n'
+        'end subroutine\n'
+    ) % {'icount': i.label.dummy_index, 'mcount': m.dummy_index}
+    r = make_routine('test_dummies', Eq(y[i], x[i]))
+    c = FCodeGen()
+    code = get_string(c.dump_f95, [r])
+    assert code == expected
+
+
+def test_loops_InOut():
+    from sympy.tensor import IndexedBase, Idx
+    from sympy.core.symbol import symbols
+
+    i, j, n, m = symbols('i,j,n,m', integer=True)
+    A, x, y = symbols('A,x,y')
+    A = IndexedBase(A)[Idx(i, m), Idx(j, n)]
+    x = IndexedBase(x)[Idx(j, n)]
+    y = IndexedBase(y)[Idx(i, m)]
+
+    (f1, code), (f2, interface) = codegen(
+        ('matrix_vector', Eq(y, y + A*x)), "F95", "file", header=False, empty=False)
+
+    assert f1 == 'file.f90'
+    expected = (
+        'subroutine matrix_vector(A, m, n, x, y)\n'
+        'implicit none\n'
+        'INTEGER*4, intent(in) :: m\n'
+        'INTEGER*4, intent(in) :: n\n'
+        'REAL*8, intent(in), dimension(1:m, 1:n) :: A\n'
+        'REAL*8, intent(in), dimension(1:n) :: x\n'
+        'REAL*8, intent(inout), dimension(1:m) :: y\n'
+        'INTEGER*4 :: i\n'
+        'INTEGER*4 :: j\n'
+        'do i = 1, m\n'
+        '   do j = 1, n\n'
+        '      y(i) = %(rhs)s + y(i)\n'
+        '   end do\n'
+        'end do\n'
+        'end subroutine\n'
+    )
+
+    assert (code == expected % {'rhs': 'A(i, j)*x(j)'} or
+            code == expected % {'rhs': 'x(j)*A(i, j)'})
+    assert f2 == 'file.h'
+    assert interface == (
+        'interface\n'
+        'subroutine matrix_vector(A, m, n, x, y)\n'
+        'implicit none\n'
+        'INTEGER*4, intent(in) :: m\n'
+        'INTEGER*4, intent(in) :: n\n'
+        'REAL*8, intent(in), dimension(1:m, 1:n) :: A\n'
+        'REAL*8, intent(in), dimension(1:n) :: x\n'
+        'REAL*8, intent(inout), dimension(1:m) :: y\n'
+        'end subroutine\n'
+        'end interface\n'
+    )
+
+
+def test_partial_loops_f():
+    # check that loop boundaries are determined by Idx, and array strides
+    # determined by shape of IndexedBase object.
+    from sympy.tensor import IndexedBase, Idx
+    from sympy.core.symbol import symbols
+    n, m, o, p = symbols('n m o p', integer=True)
+    A = IndexedBase('A', shape=(m, p))
+    x = IndexedBase('x')
+    y = IndexedBase('y')
+    i = Idx('i', (o, m - 5))  # Note: bounds are inclusive
+    j = Idx('j', n)          # dimension n corresponds to bounds (0, n - 1)
+
+    (f1, code), (f2, interface) = codegen(
+        ('matrix_vector', Eq(y[i], A[i, j]*x[j])), "F95", "file", header=False, empty=False)
+
+    expected = (
+        'subroutine matrix_vector(A, m, n, o, p, x, y)\n'
+        'implicit none\n'
+        'INTEGER*4, intent(in) :: m\n'
+        'INTEGER*4, intent(in) :: n\n'
+        'INTEGER*4, intent(in) :: o\n'
+        'INTEGER*4, intent(in) :: p\n'
+        'REAL*8, intent(in), dimension(1:m, 1:p) :: A\n'
+        'REAL*8, intent(in), dimension(1:n) :: x\n'
+        'REAL*8, intent(out), dimension(1:%(iup-ilow)s) :: y\n'
+        'INTEGER*4 :: i\n'
+        'INTEGER*4 :: j\n'
+        'do i = %(ilow)s, %(iup)s\n'
+        '   y(i) = 0\n'
+        'end do\n'
+        'do i = %(ilow)s, %(iup)s\n'
+        '   do j = 1, n\n'
+        '      y(i) = %(rhs)s + y(i)\n'
+        '   end do\n'
+        'end do\n'
+        'end subroutine\n'
+    ) % {
+        'rhs': '%(rhs)s',
+        'iup': str(m - 4),
+        'ilow': str(1 + o),
+        'iup-ilow': str(m - 4 - o)
+    }
+
+    assert code == expected % {'rhs': 'A(i, j)*x(j)'} or\
+        code == expected % {'rhs': 'x(j)*A(i, j)'}
+
+
+def test_output_arg_f():
+    from sympy.core.relational import Equality
+    from sympy.functions.elementary.trigonometric import (cos, sin)
+    x, y, z = symbols("x,y,z")
+    r = make_routine("foo", [Equality(y, sin(x)), cos(x)])
+    c = FCodeGen()
+    result = c.write([r], "test", header=False, empty=False)
+    assert result[0][0] == "test.f90"
+    assert result[0][1] == (
+        'REAL*8 function foo(x, y)\n'
+        'implicit none\n'
+        'REAL*8, intent(in) :: x\n'
+        'REAL*8, intent(out) :: y\n'
+        'y = sin(x)\n'
+        'foo = cos(x)\n'
+        'end function\n'
+    )
+
+
+def test_inline_function():
+    from sympy.tensor import IndexedBase, Idx
+    from sympy.core.symbol import symbols
+    n, m = symbols('n m', integer=True)
+    A, x, y = map(IndexedBase, 'Axy')
+    i = Idx('i', m)
+    p = FCodeGen()
+    func = implemented_function('func', Lambda(n, n*(n + 1)))
+    routine = make_routine('test_inline', Eq(y[i], func(x[i])))
+    code = get_string(p.dump_f95, [routine])
+    expected = (
+        'subroutine test_inline(m, x, y)\n'
+        'implicit none\n'
+        'INTEGER*4, intent(in) :: m\n'
+        'REAL*8, intent(in), dimension(1:m) :: x\n'
+        'REAL*8, intent(out), dimension(1:m) :: y\n'
+        'INTEGER*4 :: i\n'
+        'do i = 1, m\n'
+        '   y(i) = %s*%s\n'
+        'end do\n'
+        'end subroutine\n'
+    )
+    args = ('x(i)', '(x(i) + 1)')
+    assert code == expected % args or\
+        code == expected % args[::-1]
+
+
+def test_f_code_call_signature_wrap():
+    # Issue #7934
+    x = symbols('x:20')
+    expr = 0
+    for sym in x:
+        expr += sym
+    routine = make_routine("test", expr)
+    code_gen = FCodeGen()
+    source = get_string(code_gen.dump_f95, [routine])
+    expected = """\
+REAL*8 function test(x0, x1, x10, x11, x12, x13, x14, x15, x16, x17, x18, &
+      x19, x2, x3, x4, x5, x6, x7, x8, x9)
+implicit none
+REAL*8, intent(in) :: x0
+REAL*8, intent(in) :: x1
+REAL*8, intent(in) :: x10
+REAL*8, intent(in) :: x11
+REAL*8, intent(in) :: x12
+REAL*8, intent(in) :: x13
+REAL*8, intent(in) :: x14
+REAL*8, intent(in) :: x15
+REAL*8, intent(in) :: x16
+REAL*8, intent(in) :: x17
+REAL*8, intent(in) :: x18
+REAL*8, intent(in) :: x19
+REAL*8, intent(in) :: x2
+REAL*8, intent(in) :: x3
+REAL*8, intent(in) :: x4
+REAL*8, intent(in) :: x5
+REAL*8, intent(in) :: x6
+REAL*8, intent(in) :: x7
+REAL*8, intent(in) :: x8
+REAL*8, intent(in) :: x9
+test = x0 + x1 + x10 + x11 + x12 + x13 + x14 + x15 + x16 + x17 + x18 + &
+      x19 + x2 + x3 + x4 + x5 + x6 + x7 + x8 + x9
+end function
+"""
+    assert source == expected
+
+
+def test_check_case():
+    x, X = symbols('x,X')
+    raises(CodeGenError, lambda: codegen(('test', x*X), 'f95', 'prefix'))
+
+
+def test_check_case_false_positive():
+    # The upper case/lower case exception should not be triggered by SymPy
+    # objects that differ only because of assumptions.  (It may be useful to
+    # have a check for that as well, but here we only want to test against
+    # false positives with respect to case checking.)
+    x1 = symbols('x')
+    x2 = symbols('x', my_assumption=True)
+    try:
+        codegen(('test', x1*x2), 'f95', 'prefix')
+    except CodeGenError as e:
+        if e.args[0].startswith("Fortran ignores case."):
+            raise AssertionError("This exception should not be raised!")
+
+
+def test_c_fortran_omit_routine_name():
+    x, y = symbols("x,y")
+    name_expr = [("foo", 2*x)]
+    result = codegen(name_expr, "F95", header=False, empty=False)
+    expresult = codegen(name_expr, "F95", "foo", header=False, empty=False)
+    assert result[0][1] == expresult[0][1]
+
+    name_expr = ("foo", x*y)
+    result = codegen(name_expr, "F95", header=False, empty=False)
+    expresult = codegen(name_expr, "F95", "foo", header=False, empty=False)
+    assert result[0][1] == expresult[0][1]
+
+    name_expr = ("foo", Matrix([[x, y], [x+y, x-y]]))
+    result = codegen(name_expr, "C89", header=False, empty=False)
+    expresult = codegen(name_expr, "C89", "foo", header=False, empty=False)
+    assert result[0][1] == expresult[0][1]
+
+
+def test_fcode_matrix_output():
+    x, y, z = symbols('x,y,z')
+    e1 = x + y
+    e2 = Matrix([[x, y], [z, 16]])
+    name_expr = ("test", (e1, e2))
+    result = codegen(name_expr, "f95", "test", header=False, empty=False)
+    source = result[0][1]
+    expected = (
+        "REAL*8 function test(x, y, z, out_%(hash)s)\n"
+        "implicit none\n"
+        "REAL*8, intent(in) :: x\n"
+        "REAL*8, intent(in) :: y\n"
+        "REAL*8, intent(in) :: z\n"
+        "REAL*8, intent(out), dimension(1:2, 1:2) :: out_%(hash)s\n"
+        "out_%(hash)s(1, 1) = x\n"
+        "out_%(hash)s(2, 1) = z\n"
+        "out_%(hash)s(1, 2) = y\n"
+        "out_%(hash)s(2, 2) = 16\n"
+        "test = x + y\n"
+        "end function\n"
+    )
+    # look for the magic number
+    a = source.splitlines()[5]
+    b = a.split('_')
+    out = b[1]
+    expected = expected % {'hash': out}
+    assert source == expected
+
+
+def test_fcode_results_named_ordered():
+    x, y, z = symbols('x,y,z')
+    B, C = symbols('B,C')
+    A = MatrixSymbol('A', 1, 3)
+    expr1 = Equality(A, Matrix([[1, 2, x]]))
+    expr2 = Equality(C, (x + y)*z)
+    expr3 = Equality(B, 2*x)
+    name_expr = ("test", [expr1, expr2, expr3])
+    result = codegen(name_expr, "f95", "test", header=False, empty=False,
+                     argument_sequence=(x, z, y, C, A, B))
+    source = result[0][1]
+    expected = (
+        "subroutine test(x, z, y, C, A, B)\n"
+        "implicit none\n"
+        "REAL*8, intent(in) :: x\n"
+        "REAL*8, intent(in) :: z\n"
+        "REAL*8, intent(in) :: y\n"
+        "REAL*8, intent(out) :: C\n"
+        "REAL*8, intent(out) :: B\n"
+        "REAL*8, intent(out), dimension(1:1, 1:3) :: A\n"
+        "C = z*(x + y)\n"
+        "A(1, 1) = 1\n"
+        "A(1, 2) = 2\n"
+        "A(1, 3) = x\n"
+        "B = 2*x\n"
+        "end subroutine\n"
+    )
+    assert source == expected
+
+
+def test_fcode_matrixsymbol_slice():
+    A = MatrixSymbol('A', 2, 3)
+    B = MatrixSymbol('B', 1, 3)
+    C = MatrixSymbol('C', 1, 3)
+    D = MatrixSymbol('D', 2, 1)
+    name_expr = ("test", [Equality(B, A[0, :]),
+                          Equality(C, A[1, :]),
+                          Equality(D, A[:, 2])])
+    result = codegen(name_expr, "f95", "test", header=False, empty=False)
+    source = result[0][1]
+    expected = (
+        "subroutine test(A, B, C, D)\n"
+        "implicit none\n"
+        "REAL*8, intent(in), dimension(1:2, 1:3) :: A\n"
+        "REAL*8, intent(out), dimension(1:1, 1:3) :: B\n"
+        "REAL*8, intent(out), dimension(1:1, 1:3) :: C\n"
+        "REAL*8, intent(out), dimension(1:2, 1:1) :: D\n"
+        "B(1, 1) = A(1, 1)\n"
+        "B(1, 2) = A(1, 2)\n"
+        "B(1, 3) = A(1, 3)\n"
+        "C(1, 1) = A(2, 1)\n"
+        "C(1, 2) = A(2, 2)\n"
+        "C(1, 3) = A(2, 3)\n"
+        "D(1, 1) = A(1, 3)\n"
+        "D(2, 1) = A(2, 3)\n"
+        "end subroutine\n"
+    )
+    assert source == expected
+
+
+def test_fcode_matrixsymbol_slice_autoname():
+    # see issue #8093
+    A = MatrixSymbol('A', 2, 3)
+    name_expr = ("test", A[:, 1])
+    result = codegen(name_expr, "f95", "test", header=False, empty=False)
+    source = result[0][1]
+    expected = (
+        "subroutine test(A, out_%(hash)s)\n"
+        "implicit none\n"
+        "REAL*8, intent(in), dimension(1:2, 1:3) :: A\n"
+        "REAL*8, intent(out), dimension(1:2, 1:1) :: out_%(hash)s\n"
+        "out_%(hash)s(1, 1) = A(1, 2)\n"
+        "out_%(hash)s(2, 1) = A(2, 2)\n"
+        "end subroutine\n"
+    )
+    # look for the magic number
+    a = source.splitlines()[3]
+    b = a.split('_')
+    out = b[1]
+    expected = expected % {'hash': out}
+    assert source == expected
+
+
+def test_global_vars():
+    x, y, z, t = symbols("x y z t")
+    result = codegen(('f', x*y), "F95", header=False, empty=False,
+                     global_vars=(y,))
+    source = result[0][1]
+    expected = (
+        "REAL*8 function f(x)\n"
+        "implicit none\n"
+        "REAL*8, intent(in) :: x\n"
+        "f = x*y\n"
+        "end function\n"
+        )
+    assert source == expected
+
+    expected = (
+        '#include "f.h"\n'
+        '#include <math.h>\n'
+        'double f(double x, double y) {\n'
+        '   double f_result;\n'
+        '   f_result = x*y + z;\n'
+        '   return f_result;\n'
+        '}\n'
+    )
+    result = codegen(('f', x*y+z), "C", header=False, empty=False,
+                     global_vars=(z, t))
+    source = result[0][1]
+    assert source == expected
+
+def test_custom_codegen():
+    from sympy.printing.c import C99CodePrinter
+    from sympy.functions.elementary.exponential import exp
+
+    printer = C99CodePrinter(settings={'user_functions': {'exp': 'fastexp'}})
+
+    x, y = symbols('x y')
+    expr = exp(x + y)
+
+    # replace math.h with a different header
+    gen = C99CodeGen(printer=printer,
+                     preprocessor_statements=['#include "fastexp.h"'])
+
+    expected = (
+        '#include "expr.h"\n'
+        '#include "fastexp.h"\n'
+        'double expr(double x, double y) {\n'
+        '   double expr_result;\n'
+        '   expr_result = fastexp(x + y);\n'
+        '   return expr_result;\n'
+        '}\n'
+    )
+
+    result = codegen(('expr', expr), header=False, empty=False, code_gen=gen)
+    source = result[0][1]
+    assert source == expected
+
+    # use both math.h and an external header
+    gen = C99CodeGen(printer=printer)
+    gen.preprocessor_statements.append('#include "fastexp.h"')
+
+    expected = (
+        '#include "expr.h"\n'
+        '#include <math.h>\n'
+        '#include "fastexp.h"\n'
+        'double expr(double x, double y) {\n'
+        '   double expr_result;\n'
+        '   expr_result = fastexp(x + y);\n'
+        '   return expr_result;\n'
+        '}\n'
+    )
+
+    result = codegen(('expr', expr), header=False, empty=False, code_gen=gen)
+    source = result[0][1]
+    assert source == expected
+
+def test_c_with_printer():
+    # issue 13586
+    from sympy.printing.c import C99CodePrinter
+    class CustomPrinter(C99CodePrinter):
+        def _print_Pow(self, expr):
+            return "fastpow({}, {})".format(self._print(expr.base),
+                                            self._print(expr.exp))
+
+    x = symbols('x')
+    expr = x**3
+    expected =[
+        ("file.c",
+        "#include \"file.h\"\n"
+        "#include <math.h>\n"
+        "double test(double x) {\n"
+        "   double test_result;\n"
+        "   test_result = fastpow(x, 3);\n"
+        "   return test_result;\n"
+        "}\n"),
+        ("file.h",
+        "#ifndef PROJECT__FILE__H\n"
+        "#define PROJECT__FILE__H\n"
+        "double test(double x);\n"
+        "#endif\n")
+    ]
+    result = codegen(("test", expr), "C","file", header=False, empty=False, printer = CustomPrinter())
+    assert result == expected
+
+
+def test_fcode_complex():
+    import sympy.utilities.codegen
+    sympy.utilities.codegen.COMPLEX_ALLOWED = True
+    x = Symbol('x', real=True)
+    y = Symbol('y',real=True)
+    result = codegen(('test',x+y), 'f95', 'test', header=False, empty=False)
+    source = (result[0][1])
+    expected = (
+        "REAL*8 function test(x, y)\n"
+        "implicit none\n"
+        "REAL*8, intent(in) :: x\n"
+        "REAL*8, intent(in) :: y\n"
+        "test = x + y\n"
+        "end function\n")
+    assert source == expected
+    x = Symbol('x')
+    y = Symbol('y',real=True)
+    result = codegen(('test',x+y), 'f95', 'test', header=False, empty=False)
+    source = (result[0][1])
+    expected = (
+        "COMPLEX*16 function test(x, y)\n"
+        "implicit none\n"
+        "COMPLEX*16, intent(in) :: x\n"
+        "REAL*8, intent(in) :: y\n"
+        "test = x + y\n"
+        "end function\n"
+        )
+    assert source==expected
+    sympy.utilities.codegen.COMPLEX_ALLOWED = False
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/tests/test_codegen_julia.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/tests/test_codegen_julia.py
new file mode 100644
index 0000000000000000000000000000000000000000..12841cb7d476107e3866d91b998bed1f997f3901
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/tests/test_codegen_julia.py
@@ -0,0 +1,620 @@
+from io import StringIO
+
+from sympy.core import S, symbols, Eq, pi, Catalan, EulerGamma, Function
+from sympy.core.relational import Equality
+from sympy.functions.elementary.piecewise import Piecewise
+from sympy.matrices import Matrix, MatrixSymbol
+from sympy.utilities.codegen import JuliaCodeGen, codegen, make_routine
+from sympy.testing.pytest import XFAIL
+import sympy
+
+
+x, y, z = symbols('x,y,z')
+
+
+def test_empty_jl_code():
+    code_gen = JuliaCodeGen()
+    output = StringIO()
+    code_gen.dump_jl([], output, "file", header=False, empty=False)
+    source = output.getvalue()
+    assert source == ""
+
+
+def test_jl_simple_code():
+    name_expr = ("test", (x + y)*z)
+    result, = codegen(name_expr, "Julia", header=False, empty=False)
+    assert result[0] == "test.jl"
+    source = result[1]
+    expected = (
+        "function test(x, y, z)\n"
+        "    out1 = z .* (x + y)\n"
+        "    return out1\n"
+        "end\n"
+    )
+    assert source == expected
+
+
+def test_jl_simple_code_with_header():
+    name_expr = ("test", (x + y)*z)
+    result, = codegen(name_expr, "Julia", header=True, empty=False)
+    assert result[0] == "test.jl"
+    source = result[1]
+    expected = (
+        "#   Code generated with SymPy " + sympy.__version__ + "\n"
+        "#\n"
+        "#   See http://www.sympy.org/ for more information.\n"
+        "#\n"
+        "#   This file is part of 'project'\n"
+        "function test(x, y, z)\n"
+        "    out1 = z .* (x + y)\n"
+        "    return out1\n"
+        "end\n"
+    )
+    assert source == expected
+
+
+def test_jl_simple_code_nameout():
+    expr = Equality(z, (x + y))
+    name_expr = ("test", expr)
+    result, = codegen(name_expr, "Julia", header=False, empty=False)
+    source = result[1]
+    expected = (
+        "function test(x, y)\n"
+        "    z = x + y\n"
+        "    return z\n"
+        "end\n"
+    )
+    assert source == expected
+
+
+def test_jl_numbersymbol():
+    name_expr = ("test", pi**Catalan)
+    result, = codegen(name_expr, "Julia", header=False, empty=False)
+    source = result[1]
+    expected = (
+        "function test()\n"
+        "    out1 = pi ^ catalan\n"
+        "    return out1\n"
+        "end\n"
+    )
+    assert source == expected
+
+
+@XFAIL
+def test_jl_numbersymbol_no_inline():
+    # FIXME: how to pass inline=False to the JuliaCodePrinter?
+    name_expr = ("test", [pi**Catalan, EulerGamma])
+    result, = codegen(name_expr, "Julia", header=False,
+                      empty=False, inline=False)
+    source = result[1]
+    expected = (
+        "function test()\n"
+        "    Catalan = 0.915965594177219\n"
+        "    EulerGamma = 0.5772156649015329\n"
+        "    out1 = pi ^ Catalan\n"
+        "    out2 = EulerGamma\n"
+        "    return out1, out2\n"
+        "end\n"
+    )
+    assert source == expected
+
+
+def test_jl_code_argument_order():
+    expr = x + y
+    routine = make_routine("test", expr, argument_sequence=[z, x, y], language="julia")
+    code_gen = JuliaCodeGen()
+    output = StringIO()
+    code_gen.dump_jl([routine], output, "test", header=False, empty=False)
+    source = output.getvalue()
+    expected = (
+        "function test(z, x, y)\n"
+        "    out1 = x + y\n"
+        "    return out1\n"
+        "end\n"
+    )
+    assert source == expected
+
+
+def test_multiple_results_m():
+    # Here the output order is the input order
+    expr1 = (x + y)*z
+    expr2 = (x - y)*z
+    name_expr = ("test", [expr1, expr2])
+    result, = codegen(name_expr, "Julia", header=False, empty=False)
+    source = result[1]
+    expected = (
+        "function test(x, y, z)\n"
+        "    out1 = z .* (x + y)\n"
+        "    out2 = z .* (x - y)\n"
+        "    return out1, out2\n"
+        "end\n"
+    )
+    assert source == expected
+
+
+def test_results_named_unordered():
+    # Here output order is based on name_expr
+    A, B, C = symbols('A,B,C')
+    expr1 = Equality(C, (x + y)*z)
+    expr2 = Equality(A, (x - y)*z)
+    expr3 = Equality(B, 2*x)
+    name_expr = ("test", [expr1, expr2, expr3])
+    result, = codegen(name_expr, "Julia", header=False, empty=False)
+    source = result[1]
+    expected = (
+        "function test(x, y, z)\n"
+        "    C = z .* (x + y)\n"
+        "    A = z .* (x - y)\n"
+        "    B = 2 * x\n"
+        "    return C, A, B\n"
+        "end\n"
+    )
+    assert source == expected
+
+
+def test_results_named_ordered():
+    A, B, C = symbols('A,B,C')
+    expr1 = Equality(C, (x + y)*z)
+    expr2 = Equality(A, (x - y)*z)
+    expr3 = Equality(B, 2*x)
+    name_expr = ("test", [expr1, expr2, expr3])
+    result = codegen(name_expr, "Julia", header=False, empty=False,
+                     argument_sequence=(x, z, y))
+    assert result[0][0] == "test.jl"
+    source = result[0][1]
+    expected = (
+        "function test(x, z, y)\n"
+        "    C = z .* (x + y)\n"
+        "    A = z .* (x - y)\n"
+        "    B = 2 * x\n"
+        "    return C, A, B\n"
+        "end\n"
+    )
+    assert source == expected
+
+
+def test_complicated_jl_codegen():
+    from sympy.functions.elementary.trigonometric import (cos, sin, tan)
+    name_expr = ("testlong",
+            [ ((sin(x) + cos(y) + tan(z))**3).expand(),
+            cos(cos(cos(cos(cos(cos(cos(cos(x + y + z))))))))
+    ])
+    result = codegen(name_expr, "Julia", header=False, empty=False)
+    assert result[0][0] == "testlong.jl"
+    source = result[0][1]
+    expected = (
+        "function testlong(x, y, z)\n"
+        "    out1 = sin(x) .^ 3 + 3 * sin(x) .^ 2 .* cos(y) + 3 * sin(x) .^ 2 .* tan(z)"
+        " + 3 * sin(x) .* cos(y) .^ 2 + 6 * sin(x) .* cos(y) .* tan(z) + 3 * sin(x) .* tan(z) .^ 2"
+        " + cos(y) .^ 3 + 3 * cos(y) .^ 2 .* tan(z) + 3 * cos(y) .* tan(z) .^ 2 + tan(z) .^ 3\n"
+        "    out2 = cos(cos(cos(cos(cos(cos(cos(cos(x + y + z))))))))\n"
+        "    return out1, out2\n"
+        "end\n"
+    )
+    assert source == expected
+
+
+def test_jl_output_arg_mixed_unordered():
+    # named outputs are alphabetical, unnamed output appear in the given order
+    from sympy.functions.elementary.trigonometric import (cos, sin)
+    a = symbols("a")
+    name_expr = ("foo", [cos(2*x), Equality(y, sin(x)), cos(x), Equality(a, sin(2*x))])
+    result, = codegen(name_expr, "Julia", header=False, empty=False)
+    assert result[0] == "foo.jl"
+    source = result[1]
+    expected = (
+        'function foo(x)\n'
+        '    out1 = cos(2 * x)\n'
+        '    y = sin(x)\n'
+        '    out3 = cos(x)\n'
+        '    a = sin(2 * x)\n'
+        '    return out1, y, out3, a\n'
+        'end\n'
+    )
+    assert source == expected
+
+
+def test_jl_piecewise_():
+    pw = Piecewise((0, x < -1), (x**2, x <= 1), (-x+2, x > 1), (1, True), evaluate=False)
+    name_expr = ("pwtest", pw)
+    result, = codegen(name_expr, "Julia", header=False, empty=False)
+    source = result[1]
+    expected = (
+        "function pwtest(x)\n"
+        "    out1 = ((x < -1) ? (0) :\n"
+        "    (x <= 1) ? (x .^ 2) :\n"
+        "    (x > 1) ? (2 - x) : (1))\n"
+        "    return out1\n"
+        "end\n"
+    )
+    assert source == expected
+
+
+@XFAIL
+def test_jl_piecewise_no_inline():
+    # FIXME: how to pass inline=False to the JuliaCodePrinter?
+    pw = Piecewise((0, x < -1), (x**2, x <= 1), (-x+2, x > 1), (1, True))
+    name_expr = ("pwtest", pw)
+    result, = codegen(name_expr, "Julia", header=False, empty=False,
+                      inline=False)
+    source = result[1]
+    expected = (
+        "function pwtest(x)\n"
+        "    if (x < -1)\n"
+        "        out1 = 0\n"
+        "    elseif (x <= 1)\n"
+        "        out1 = x .^ 2\n"
+        "    elseif (x > 1)\n"
+        "        out1 = -x + 2\n"
+        "    else\n"
+        "        out1 = 1\n"
+        "    end\n"
+        "    return out1\n"
+        "end\n"
+    )
+    assert source == expected
+
+
+def test_jl_multifcns_per_file():
+    name_expr = [ ("foo", [2*x, 3*y]), ("bar", [y**2, 4*y]) ]
+    result = codegen(name_expr, "Julia", header=False, empty=False)
+    assert result[0][0] == "foo.jl"
+    source = result[0][1]
+    expected = (
+        "function foo(x, y)\n"
+        "    out1 = 2 * x\n"
+        "    out2 = 3 * y\n"
+        "    return out1, out2\n"
+        "end\n"
+        "function bar(y)\n"
+        "    out1 = y .^ 2\n"
+        "    out2 = 4 * y\n"
+        "    return out1, out2\n"
+        "end\n"
+    )
+    assert source == expected
+
+
+def test_jl_multifcns_per_file_w_header():
+    name_expr = [ ("foo", [2*x, 3*y]), ("bar", [y**2, 4*y]) ]
+    result = codegen(name_expr, "Julia", header=True, empty=False)
+    assert result[0][0] == "foo.jl"
+    source = result[0][1]
+    expected = (
+        "#   Code generated with SymPy " + sympy.__version__ + "\n"
+        "#\n"
+        "#   See http://www.sympy.org/ for more information.\n"
+        "#\n"
+        "#   This file is part of 'project'\n"
+        "function foo(x, y)\n"
+        "    out1 = 2 * x\n"
+        "    out2 = 3 * y\n"
+        "    return out1, out2\n"
+        "end\n"
+        "function bar(y)\n"
+        "    out1 = y .^ 2\n"
+        "    out2 = 4 * y\n"
+        "    return out1, out2\n"
+        "end\n"
+    )
+    assert source == expected
+
+
+def test_jl_filename_match_prefix():
+    name_expr = [ ("foo", [2*x, 3*y]), ("bar", [y**2, 4*y]) ]
+    result, = codegen(name_expr, "Julia", prefix="baz", header=False,
+                     empty=False)
+    assert result[0] == "baz.jl"
+
+
+def test_jl_matrix_named():
+    e2 = Matrix([[x, 2*y, pi*z]])
+    name_expr = ("test", Equality(MatrixSymbol('myout1', 1, 3), e2))
+    result = codegen(name_expr, "Julia", header=False, empty=False)
+    assert result[0][0] == "test.jl"
+    source = result[0][1]
+    expected = (
+        "function test(x, y, z)\n"
+        "    myout1 = [x 2 * y pi * z]\n"
+        "    return myout1\n"
+        "end\n"
+    )
+    assert source == expected
+
+
+def test_jl_matrix_named_matsym():
+    myout1 = MatrixSymbol('myout1', 1, 3)
+    e2 = Matrix([[x, 2*y, pi*z]])
+    name_expr = ("test", Equality(myout1, e2, evaluate=False))
+    result, = codegen(name_expr, "Julia", header=False, empty=False)
+    source = result[1]
+    expected = (
+        "function test(x, y, z)\n"
+        "    myout1 = [x 2 * y pi * z]\n"
+        "    return myout1\n"
+        "end\n"
+    )
+    assert source == expected
+
+
+def test_jl_matrix_output_autoname():
+    expr = Matrix([[x, x+y, 3]])
+    name_expr = ("test", expr)
+    result, = codegen(name_expr, "Julia", header=False, empty=False)
+    source = result[1]
+    expected = (
+        "function test(x, y)\n"
+        "    out1 = [x x + y 3]\n"
+        "    return out1\n"
+        "end\n"
+    )
+    assert source == expected
+
+
+def test_jl_matrix_output_autoname_2():
+    e1 = (x + y)
+    e2 = Matrix([[2*x, 2*y, 2*z]])
+    e3 = Matrix([[x], [y], [z]])
+    e4 = Matrix([[x, y], [z, 16]])
+    name_expr = ("test", (e1, e2, e3, e4))
+    result, = codegen(name_expr, "Julia", header=False, empty=False)
+    source = result[1]
+    expected = (
+        "function test(x, y, z)\n"
+        "    out1 = x + y\n"
+        "    out2 = [2 * x 2 * y 2 * z]\n"
+        "    out3 = [x, y, z]\n"
+        "    out4 = [x  y;\n"
+        "    z 16]\n"
+        "    return out1, out2, out3, out4\n"
+        "end\n"
+    )
+    assert source == expected
+
+
+def test_jl_results_matrix_named_ordered():
+    B, C = symbols('B,C')
+    A = MatrixSymbol('A', 1, 3)
+    expr1 = Equality(C, (x + y)*z)
+    expr2 = Equality(A, Matrix([[1, 2, x]]))
+    expr3 = Equality(B, 2*x)
+    name_expr = ("test", [expr1, expr2, expr3])
+    result, = codegen(name_expr, "Julia", header=False, empty=False,
+                     argument_sequence=(x, z, y))
+    source = result[1]
+    expected = (
+        "function test(x, z, y)\n"
+        "    C = z .* (x + y)\n"
+        "    A = [1 2 x]\n"
+        "    B = 2 * x\n"
+        "    return C, A, B\n"
+        "end\n"
+    )
+    assert source == expected
+
+
+def test_jl_matrixsymbol_slice():
+    A = MatrixSymbol('A', 2, 3)
+    B = MatrixSymbol('B', 1, 3)
+    C = MatrixSymbol('C', 1, 3)
+    D = MatrixSymbol('D', 2, 1)
+    name_expr = ("test", [Equality(B, A[0, :]),
+                          Equality(C, A[1, :]),
+                          Equality(D, A[:, 2])])
+    result, = codegen(name_expr, "Julia", header=False, empty=False)
+    source = result[1]
+    expected = (
+        "function test(A)\n"
+        "    B = A[1,:]\n"
+        "    C = A[2,:]\n"
+        "    D = A[:,3]\n"
+        "    return B, C, D\n"
+        "end\n"
+    )
+    assert source == expected
+
+
+def test_jl_matrixsymbol_slice2():
+    A = MatrixSymbol('A', 3, 4)
+    B = MatrixSymbol('B', 2, 2)
+    C = MatrixSymbol('C', 2, 2)
+    name_expr = ("test", [Equality(B, A[0:2, 0:2]),
+                          Equality(C, A[0:2, 1:3])])
+    result, = codegen(name_expr, "Julia", header=False, empty=False)
+    source = result[1]
+    expected = (
+        "function test(A)\n"
+        "    B = A[1:2,1:2]\n"
+        "    C = A[1:2,2:3]\n"
+        "    return B, C\n"
+        "end\n"
+    )
+    assert source == expected
+
+
+def test_jl_matrixsymbol_slice3():
+    A = MatrixSymbol('A', 8, 7)
+    B = MatrixSymbol('B', 2, 2)
+    C = MatrixSymbol('C', 4, 2)
+    name_expr = ("test", [Equality(B, A[6:, 1::3]),
+                          Equality(C, A[::2, ::3])])
+    result, = codegen(name_expr, "Julia", header=False, empty=False)
+    source = result[1]
+    expected = (
+        "function test(A)\n"
+        "    B = A[7:end,2:3:end]\n"
+        "    C = A[1:2:end,1:3:end]\n"
+        "    return B, C\n"
+        "end\n"
+    )
+    assert source == expected
+
+
+def test_jl_matrixsymbol_slice_autoname():
+    A = MatrixSymbol('A', 2, 3)
+    B = MatrixSymbol('B', 1, 3)
+    name_expr = ("test", [Equality(B, A[0,:]), A[1,:], A[:,0], A[:,1]])
+    result, = codegen(name_expr, "Julia", header=False, empty=False)
+    source = result[1]
+    expected = (
+        "function test(A)\n"
+        "    B = A[1,:]\n"
+        "    out2 = A[2,:]\n"
+        "    out3 = A[:,1]\n"
+        "    out4 = A[:,2]\n"
+        "    return B, out2, out3, out4\n"
+        "end\n"
+    )
+    assert source == expected
+
+
+def test_jl_loops():
+    # Note: an Julia programmer would probably vectorize this across one or
+    # more dimensions.  Also, size(A) would be used rather than passing in m
+    # and n.  Perhaps users would expect us to vectorize automatically here?
+    # Or is it possible to represent such things using IndexedBase?
+    from sympy.tensor import IndexedBase, Idx
+    from sympy.core.symbol import symbols
+    n, m = symbols('n m', integer=True)
+    A = IndexedBase('A')
+    x = IndexedBase('x')
+    y = IndexedBase('y')
+    i = Idx('i', m)
+    j = Idx('j', n)
+    result, = codegen(('mat_vec_mult', Eq(y[i], A[i, j]*x[j])), "Julia",
+                      header=False, empty=False)
+    source = result[1]
+    expected = (
+        'function mat_vec_mult(y, A, m, n, x)\n'
+        '    for i = 1:m\n'
+        '        y[i] = 0\n'
+        '    end\n'
+        '    for i = 1:m\n'
+        '        for j = 1:n\n'
+        '            y[i] = %(rhs)s + y[i]\n'
+        '        end\n'
+        '    end\n'
+        '    return y\n'
+        'end\n'
+    )
+    assert (source == expected % {'rhs': 'A[%s,%s] .* x[j]' % (i, j)} or
+            source == expected % {'rhs': 'x[j] .* A[%s,%s]' % (i, j)})
+
+
+def test_jl_tensor_loops_multiple_contractions():
+    # see comments in previous test about vectorizing
+    from sympy.tensor import IndexedBase, Idx
+    from sympy.core.symbol import symbols
+    n, m, o, p = symbols('n m o p', integer=True)
+    A = IndexedBase('A')
+    B = IndexedBase('B')
+    y = IndexedBase('y')
+    i = Idx('i', m)
+    j = Idx('j', n)
+    k = Idx('k', o)
+    l = Idx('l', p)
+    result, = codegen(('tensorthing', Eq(y[i], B[j, k, l]*A[i, j, k, l])),
+                      "Julia", header=False, empty=False)
+    source = result[1]
+    expected = (
+        'function tensorthing(y, A, B, m, n, o, p)\n'
+        '    for i = 1:m\n'
+        '        y[i] = 0\n'
+        '    end\n'
+        '    for i = 1:m\n'
+        '        for j = 1:n\n'
+        '            for k = 1:o\n'
+        '                for l = 1:p\n'
+        '                    y[i] = A[i,j,k,l] .* B[j,k,l] + y[i]\n'
+        '                end\n'
+        '            end\n'
+        '        end\n'
+        '    end\n'
+        '    return y\n'
+        'end\n'
+    )
+    assert source == expected
+
+
+def test_jl_InOutArgument():
+    expr = Equality(x, x**2)
+    name_expr = ("mysqr", expr)
+    result, = codegen(name_expr, "Julia", header=False, empty=False)
+    source = result[1]
+    expected = (
+        "function mysqr(x)\n"
+        "    x = x .^ 2\n"
+        "    return x\n"
+        "end\n"
+    )
+    assert source == expected
+
+
+def test_jl_InOutArgument_order():
+    # can specify the order as (x, y)
+    expr = Equality(x, x**2 + y)
+    name_expr = ("test", expr)
+    result, = codegen(name_expr, "Julia", header=False,
+                      empty=False, argument_sequence=(x,y))
+    source = result[1]
+    expected = (
+        "function test(x, y)\n"
+        "    x = x .^ 2 + y\n"
+        "    return x\n"
+        "end\n"
+    )
+    assert source == expected
+    # make sure it gives (x, y) not (y, x)
+    expr = Equality(x, x**2 + y)
+    name_expr = ("test", expr)
+    result, = codegen(name_expr, "Julia", header=False, empty=False)
+    source = result[1]
+    expected = (
+        "function test(x, y)\n"
+        "    x = x .^ 2 + y\n"
+        "    return x\n"
+        "end\n"
+    )
+    assert source == expected
+
+
+def test_jl_not_supported():
+    f = Function('f')
+    name_expr = ("test", [f(x).diff(x), S.ComplexInfinity])
+    result, = codegen(name_expr, "Julia", header=False, empty=False)
+    source = result[1]
+    expected = (
+        "function test(x)\n"
+        "    # unsupported: Derivative(f(x), x)\n"
+        "    # unsupported: zoo\n"
+        "    out1 = Derivative(f(x), x)\n"
+        "    out2 = zoo\n"
+        "    return out1, out2\n"
+        "end\n"
+    )
+    assert source == expected
+
+
+def test_global_vars_octave():
+    x, y, z, t = symbols("x y z t")
+    result = codegen(('f', x*y), "Julia", header=False, empty=False,
+                     global_vars=(y,))
+    source = result[0][1]
+    expected = (
+        "function f(x)\n"
+        "    out1 = x .* y\n"
+        "    return out1\n"
+        "end\n"
+        )
+    assert source == expected
+
+    result = codegen(('f', x*y+z), "Julia", header=False, empty=False,
+                     argument_sequence=(x, y), global_vars=(z, t))
+    source = result[0][1]
+    expected = (
+        "function f(x, y)\n"
+        "    out1 = x .* y + z\n"
+        "    return out1\n"
+        "end\n"
+    )
+    assert source == expected
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/tests/test_codegen_octave.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/tests/test_codegen_octave.py
new file mode 100644
index 0000000000000000000000000000000000000000..77aaef7dd0d81d6855024e49fbb3d6d4c09f3384
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/tests/test_codegen_octave.py
@@ -0,0 +1,589 @@
+from io import StringIO
+
+from sympy.core import S, symbols, Eq, pi, Catalan, EulerGamma, Function
+from sympy.core.relational import Equality
+from sympy.functions.elementary.piecewise import Piecewise
+from sympy.matrices import Matrix, MatrixSymbol
+from sympy.utilities.codegen import OctaveCodeGen, codegen, make_routine
+from sympy.testing.pytest import raises
+from sympy.testing.pytest import XFAIL
+import sympy
+
+
+x, y, z = symbols('x,y,z')
+
+
+def test_empty_m_code():
+    code_gen = OctaveCodeGen()
+    output = StringIO()
+    code_gen.dump_m([], output, "file", header=False, empty=False)
+    source = output.getvalue()
+    assert source == ""
+
+
+def test_m_simple_code():
+    name_expr = ("test", (x + y)*z)
+    result, = codegen(name_expr, "Octave", header=False, empty=False)
+    assert result[0] == "test.m"
+    source = result[1]
+    expected = (
+        "function out1 = test(x, y, z)\n"
+        "  out1 = z.*(x + y);\n"
+        "end\n"
+    )
+    assert source == expected
+
+
+def test_m_simple_code_with_header():
+    name_expr = ("test", (x + y)*z)
+    result, = codegen(name_expr, "Octave", header=True, empty=False)
+    assert result[0] == "test.m"
+    source = result[1]
+    expected = (
+        "function out1 = test(x, y, z)\n"
+        "  %TEST  Autogenerated by SymPy\n"
+        "  %   Code generated with SymPy " + sympy.__version__ + "\n"
+        "  %\n"
+        "  %   See http://www.sympy.org/ for more information.\n"
+        "  %\n"
+        "  %   This file is part of 'project'\n"
+        "  out1 = z.*(x + y);\n"
+        "end\n"
+    )
+    assert source == expected
+
+
+def test_m_simple_code_nameout():
+    expr = Equality(z, (x + y))
+    name_expr = ("test", expr)
+    result, = codegen(name_expr, "Octave", header=False, empty=False)
+    source = result[1]
+    expected = (
+        "function z = test(x, y)\n"
+        "  z = x + y;\n"
+        "end\n"
+    )
+    assert source == expected
+
+
+def test_m_numbersymbol():
+    name_expr = ("test", pi**Catalan)
+    result, = codegen(name_expr, "Octave", header=False, empty=False)
+    source = result[1]
+    expected = (
+        "function out1 = test()\n"
+        "  out1 = pi^%s;\n"
+        "end\n"
+    ) % Catalan.evalf(17)
+    assert source == expected
+
+
+@XFAIL
+def test_m_numbersymbol_no_inline():
+    # FIXME: how to pass inline=False to the OctaveCodePrinter?
+    name_expr = ("test", [pi**Catalan, EulerGamma])
+    result, = codegen(name_expr, "Octave", header=False,
+                      empty=False, inline=False)
+    source = result[1]
+    expected = (
+        "function [out1, out2] = test()\n"
+        "  Catalan = 0.915965594177219;  % constant\n"
+        "  EulerGamma = 0.5772156649015329;  % constant\n"
+        "  out1 = pi^Catalan;\n"
+        "  out2 = EulerGamma;\n"
+        "end\n"
+    )
+    assert source == expected
+
+
+def test_m_code_argument_order():
+    expr = x + y
+    routine = make_routine("test", expr, argument_sequence=[z, x, y], language="octave")
+    code_gen = OctaveCodeGen()
+    output = StringIO()
+    code_gen.dump_m([routine], output, "test", header=False, empty=False)
+    source = output.getvalue()
+    expected = (
+        "function out1 = test(z, x, y)\n"
+        "  out1 = x + y;\n"
+        "end\n"
+    )
+    assert source == expected
+
+
+def test_multiple_results_m():
+    # Here the output order is the input order
+    expr1 = (x + y)*z
+    expr2 = (x - y)*z
+    name_expr = ("test", [expr1, expr2])
+    result, = codegen(name_expr, "Octave", header=False, empty=False)
+    source = result[1]
+    expected = (
+        "function [out1, out2] = test(x, y, z)\n"
+        "  out1 = z.*(x + y);\n"
+        "  out2 = z.*(x - y);\n"
+        "end\n"
+    )
+    assert source == expected
+
+
+def test_results_named_unordered():
+    # Here output order is based on name_expr
+    A, B, C = symbols('A,B,C')
+    expr1 = Equality(C, (x + y)*z)
+    expr2 = Equality(A, (x - y)*z)
+    expr3 = Equality(B, 2*x)
+    name_expr = ("test", [expr1, expr2, expr3])
+    result, = codegen(name_expr, "Octave", header=False, empty=False)
+    source = result[1]
+    expected = (
+        "function [C, A, B] = test(x, y, z)\n"
+        "  C = z.*(x + y);\n"
+        "  A = z.*(x - y);\n"
+        "  B = 2*x;\n"
+        "end\n"
+    )
+    assert source == expected
+
+
+def test_results_named_ordered():
+    A, B, C = symbols('A,B,C')
+    expr1 = Equality(C, (x + y)*z)
+    expr2 = Equality(A, (x - y)*z)
+    expr3 = Equality(B, 2*x)
+    name_expr = ("test", [expr1, expr2, expr3])
+    result = codegen(name_expr, "Octave", header=False, empty=False,
+                     argument_sequence=(x, z, y))
+    assert result[0][0] == "test.m"
+    source = result[0][1]
+    expected = (
+        "function [C, A, B] = test(x, z, y)\n"
+        "  C = z.*(x + y);\n"
+        "  A = z.*(x - y);\n"
+        "  B = 2*x;\n"
+        "end\n"
+    )
+    assert source == expected
+
+
+def test_complicated_m_codegen():
+    from sympy.functions.elementary.trigonometric import (cos, sin, tan)
+    name_expr = ("testlong",
+            [ ((sin(x) + cos(y) + tan(z))**3).expand(),
+            cos(cos(cos(cos(cos(cos(cos(cos(x + y + z))))))))
+    ])
+    result = codegen(name_expr, "Octave", header=False, empty=False)
+    assert result[0][0] == "testlong.m"
+    source = result[0][1]
+    expected = (
+        "function [out1, out2] = testlong(x, y, z)\n"
+        "  out1 = sin(x).^3 + 3*sin(x).^2.*cos(y) + 3*sin(x).^2.*tan(z)"
+        " + 3*sin(x).*cos(y).^2 + 6*sin(x).*cos(y).*tan(z) + 3*sin(x).*tan(z).^2"
+        " + cos(y).^3 + 3*cos(y).^2.*tan(z) + 3*cos(y).*tan(z).^2 + tan(z).^3;\n"
+        "  out2 = cos(cos(cos(cos(cos(cos(cos(cos(x + y + z))))))));\n"
+        "end\n"
+    )
+    assert source == expected
+
+
+def test_m_output_arg_mixed_unordered():
+    # named outputs are alphabetical, unnamed output appear in the given order
+    from sympy.functions.elementary.trigonometric import (cos, sin)
+    a = symbols("a")
+    name_expr = ("foo", [cos(2*x), Equality(y, sin(x)), cos(x), Equality(a, sin(2*x))])
+    result, = codegen(name_expr, "Octave", header=False, empty=False)
+    assert result[0] == "foo.m"
+    source = result[1]
+    expected = (
+        'function [out1, y, out3, a] = foo(x)\n'
+        '  out1 = cos(2*x);\n'
+        '  y = sin(x);\n'
+        '  out3 = cos(x);\n'
+        '  a = sin(2*x);\n'
+        'end\n'
+    )
+    assert source == expected
+
+
+def test_m_piecewise_():
+    pw = Piecewise((0, x < -1), (x**2, x <= 1), (-x+2, x > 1), (1, True), evaluate=False)
+    name_expr = ("pwtest", pw)
+    result, = codegen(name_expr, "Octave", header=False, empty=False)
+    source = result[1]
+    expected = (
+        "function out1 = pwtest(x)\n"
+        "  out1 = ((x < -1).*(0) + (~(x < -1)).*( ...\n"
+        "  (x <= 1).*(x.^2) + (~(x <= 1)).*( ...\n"
+        "  (x > 1).*(2 - x) + (~(x > 1)).*(1))));\n"
+        "end\n"
+    )
+    assert source == expected
+
+
+@XFAIL
+def test_m_piecewise_no_inline():
+    # FIXME: how to pass inline=False to the OctaveCodePrinter?
+    pw = Piecewise((0, x < -1), (x**2, x <= 1), (-x+2, x > 1), (1, True))
+    name_expr = ("pwtest", pw)
+    result, = codegen(name_expr, "Octave", header=False, empty=False,
+                      inline=False)
+    source = result[1]
+    expected = (
+        "function out1 = pwtest(x)\n"
+        "  if (x < -1)\n"
+        "    out1 = 0;\n"
+        "  elseif (x <= 1)\n"
+        "    out1 = x.^2;\n"
+        "  elseif (x > 1)\n"
+        "    out1 = -x + 2;\n"
+        "  else\n"
+        "    out1 = 1;\n"
+        "  end\n"
+        "end\n"
+    )
+    assert source == expected
+
+
+def test_m_multifcns_per_file():
+    name_expr = [ ("foo", [2*x, 3*y]), ("bar", [y**2, 4*y]) ]
+    result = codegen(name_expr, "Octave", header=False, empty=False)
+    assert result[0][0] == "foo.m"
+    source = result[0][1]
+    expected = (
+        "function [out1, out2] = foo(x, y)\n"
+        "  out1 = 2*x;\n"
+        "  out2 = 3*y;\n"
+        "end\n"
+        "function [out1, out2] = bar(y)\n"
+        "  out1 = y.^2;\n"
+        "  out2 = 4*y;\n"
+        "end\n"
+    )
+    assert source == expected
+
+
+def test_m_multifcns_per_file_w_header():
+    name_expr = [ ("foo", [2*x, 3*y]), ("bar", [y**2, 4*y]) ]
+    result = codegen(name_expr, "Octave", header=True, empty=False)
+    assert result[0][0] == "foo.m"
+    source = result[0][1]
+    expected = (
+        "function [out1, out2] = foo(x, y)\n"
+        "  %FOO  Autogenerated by SymPy\n"
+        "  %   Code generated with SymPy " + sympy.__version__ + "\n"
+        "  %\n"
+        "  %   See http://www.sympy.org/ for more information.\n"
+        "  %\n"
+        "  %   This file is part of 'project'\n"
+        "  out1 = 2*x;\n"
+        "  out2 = 3*y;\n"
+        "end\n"
+        "function [out1, out2] = bar(y)\n"
+        "  out1 = y.^2;\n"
+        "  out2 = 4*y;\n"
+        "end\n"
+    )
+    assert source == expected
+
+
+def test_m_filename_match_first_fcn():
+    name_expr = [ ("foo", [2*x, 3*y]), ("bar", [y**2, 4*y]) ]
+    raises(ValueError, lambda: codegen(name_expr,
+                        "Octave", prefix="bar", header=False, empty=False))
+
+
+def test_m_matrix_named():
+    e2 = Matrix([[x, 2*y, pi*z]])
+    name_expr = ("test", Equality(MatrixSymbol('myout1', 1, 3), e2))
+    result = codegen(name_expr, "Octave", header=False, empty=False)
+    assert result[0][0] == "test.m"
+    source = result[0][1]
+    expected = (
+        "function myout1 = test(x, y, z)\n"
+        "  myout1 = [x 2*y pi*z];\n"
+        "end\n"
+    )
+    assert source == expected
+
+
+def test_m_matrix_named_matsym():
+    myout1 = MatrixSymbol('myout1', 1, 3)
+    e2 = Matrix([[x, 2*y, pi*z]])
+    name_expr = ("test", Equality(myout1, e2, evaluate=False))
+    result, = codegen(name_expr, "Octave", header=False, empty=False)
+    source = result[1]
+    expected = (
+        "function myout1 = test(x, y, z)\n"
+        "  myout1 = [x 2*y pi*z];\n"
+        "end\n"
+    )
+    assert source == expected
+
+
+def test_m_matrix_output_autoname():
+    expr = Matrix([[x, x+y, 3]])
+    name_expr = ("test", expr)
+    result, = codegen(name_expr, "Octave", header=False, empty=False)
+    source = result[1]
+    expected = (
+        "function out1 = test(x, y)\n"
+        "  out1 = [x x + y 3];\n"
+        "end\n"
+    )
+    assert source == expected
+
+
+def test_m_matrix_output_autoname_2():
+    e1 = (x + y)
+    e2 = Matrix([[2*x, 2*y, 2*z]])
+    e3 = Matrix([[x], [y], [z]])
+    e4 = Matrix([[x, y], [z, 16]])
+    name_expr = ("test", (e1, e2, e3, e4))
+    result, = codegen(name_expr, "Octave", header=False, empty=False)
+    source = result[1]
+    expected = (
+        "function [out1, out2, out3, out4] = test(x, y, z)\n"
+        "  out1 = x + y;\n"
+        "  out2 = [2*x 2*y 2*z];\n"
+        "  out3 = [x; y; z];\n"
+        "  out4 = [x y; z 16];\n"
+        "end\n"
+    )
+    assert source == expected
+
+
+def test_m_results_matrix_named_ordered():
+    B, C = symbols('B,C')
+    A = MatrixSymbol('A', 1, 3)
+    expr1 = Equality(C, (x + y)*z)
+    expr2 = Equality(A, Matrix([[1, 2, x]]))
+    expr3 = Equality(B, 2*x)
+    name_expr = ("test", [expr1, expr2, expr3])
+    result, = codegen(name_expr, "Octave", header=False, empty=False,
+                     argument_sequence=(x, z, y))
+    source = result[1]
+    expected = (
+        "function [C, A, B] = test(x, z, y)\n"
+        "  C = z.*(x + y);\n"
+        "  A = [1 2 x];\n"
+        "  B = 2*x;\n"
+        "end\n"
+    )
+    assert source == expected
+
+
+def test_m_matrixsymbol_slice():
+    A = MatrixSymbol('A', 2, 3)
+    B = MatrixSymbol('B', 1, 3)
+    C = MatrixSymbol('C', 1, 3)
+    D = MatrixSymbol('D', 2, 1)
+    name_expr = ("test", [Equality(B, A[0, :]),
+                          Equality(C, A[1, :]),
+                          Equality(D, A[:, 2])])
+    result, = codegen(name_expr, "Octave", header=False, empty=False)
+    source = result[1]
+    expected = (
+        "function [B, C, D] = test(A)\n"
+        "  B = A(1, :);\n"
+        "  C = A(2, :);\n"
+        "  D = A(:, 3);\n"
+        "end\n"
+    )
+    assert source == expected
+
+
+def test_m_matrixsymbol_slice2():
+    A = MatrixSymbol('A', 3, 4)
+    B = MatrixSymbol('B', 2, 2)
+    C = MatrixSymbol('C', 2, 2)
+    name_expr = ("test", [Equality(B, A[0:2, 0:2]),
+                          Equality(C, A[0:2, 1:3])])
+    result, = codegen(name_expr, "Octave", header=False, empty=False)
+    source = result[1]
+    expected = (
+        "function [B, C] = test(A)\n"
+        "  B = A(1:2, 1:2);\n"
+        "  C = A(1:2, 2:3);\n"
+        "end\n"
+    )
+    assert source == expected
+
+
+def test_m_matrixsymbol_slice3():
+    A = MatrixSymbol('A', 8, 7)
+    B = MatrixSymbol('B', 2, 2)
+    C = MatrixSymbol('C', 4, 2)
+    name_expr = ("test", [Equality(B, A[6:, 1::3]),
+                          Equality(C, A[::2, ::3])])
+    result, = codegen(name_expr, "Octave", header=False, empty=False)
+    source = result[1]
+    expected = (
+        "function [B, C] = test(A)\n"
+        "  B = A(7:end, 2:3:end);\n"
+        "  C = A(1:2:end, 1:3:end);\n"
+        "end\n"
+    )
+    assert source == expected
+
+
+def test_m_matrixsymbol_slice_autoname():
+    A = MatrixSymbol('A', 2, 3)
+    B = MatrixSymbol('B', 1, 3)
+    name_expr = ("test", [Equality(B, A[0,:]), A[1,:], A[:,0], A[:,1]])
+    result, = codegen(name_expr, "Octave", header=False, empty=False)
+    source = result[1]
+    expected = (
+        "function [B, out2, out3, out4] = test(A)\n"
+        "  B = A(1, :);\n"
+        "  out2 = A(2, :);\n"
+        "  out3 = A(:, 1);\n"
+        "  out4 = A(:, 2);\n"
+        "end\n"
+    )
+    assert source == expected
+
+
+def test_m_loops():
+    # Note: an Octave programmer would probably vectorize this across one or
+    # more dimensions.  Also, size(A) would be used rather than passing in m
+    # and n.  Perhaps users would expect us to vectorize automatically here?
+    # Or is it possible to represent such things using IndexedBase?
+    from sympy.tensor import IndexedBase, Idx
+    from sympy.core.symbol import symbols
+    n, m = symbols('n m', integer=True)
+    A = IndexedBase('A')
+    x = IndexedBase('x')
+    y = IndexedBase('y')
+    i = Idx('i', m)
+    j = Idx('j', n)
+    result, = codegen(('mat_vec_mult', Eq(y[i], A[i, j]*x[j])), "Octave",
+                      header=False, empty=False)
+    source = result[1]
+    expected = (
+        'function y = mat_vec_mult(A, m, n, x)\n'
+        '  for i = 1:m\n'
+        '    y(i) = 0;\n'
+        '  end\n'
+        '  for i = 1:m\n'
+        '    for j = 1:n\n'
+        '      y(i) = %(rhs)s + y(i);\n'
+        '    end\n'
+        '  end\n'
+        'end\n'
+    )
+    assert (source == expected % {'rhs': 'A(%s, %s).*x(j)' % (i, j)} or
+            source == expected % {'rhs': 'x(j).*A(%s, %s)' % (i, j)})
+
+
+def test_m_tensor_loops_multiple_contractions():
+    # see comments in previous test about vectorizing
+    from sympy.tensor import IndexedBase, Idx
+    from sympy.core.symbol import symbols
+    n, m, o, p = symbols('n m o p', integer=True)
+    A = IndexedBase('A')
+    B = IndexedBase('B')
+    y = IndexedBase('y')
+    i = Idx('i', m)
+    j = Idx('j', n)
+    k = Idx('k', o)
+    l = Idx('l', p)
+    result, = codegen(('tensorthing', Eq(y[i], B[j, k, l]*A[i, j, k, l])),
+                      "Octave", header=False, empty=False)
+    source = result[1]
+    expected = (
+        'function y = tensorthing(A, B, m, n, o, p)\n'
+        '  for i = 1:m\n'
+        '    y(i) = 0;\n'
+        '  end\n'
+        '  for i = 1:m\n'
+        '    for j = 1:n\n'
+        '      for k = 1:o\n'
+        '        for l = 1:p\n'
+        '          y(i) = A(i, j, k, l).*B(j, k, l) + y(i);\n'
+        '        end\n'
+        '      end\n'
+        '    end\n'
+        '  end\n'
+        'end\n'
+    )
+    assert source == expected
+
+
+def test_m_InOutArgument():
+    expr = Equality(x, x**2)
+    name_expr = ("mysqr", expr)
+    result, = codegen(name_expr, "Octave", header=False, empty=False)
+    source = result[1]
+    expected = (
+        "function x = mysqr(x)\n"
+        "  x = x.^2;\n"
+        "end\n"
+    )
+    assert source == expected
+
+
+def test_m_InOutArgument_order():
+    # can specify the order as (x, y)
+    expr = Equality(x, x**2 + y)
+    name_expr = ("test", expr)
+    result, = codegen(name_expr, "Octave", header=False,
+                      empty=False, argument_sequence=(x,y))
+    source = result[1]
+    expected = (
+        "function x = test(x, y)\n"
+        "  x = x.^2 + y;\n"
+        "end\n"
+    )
+    assert source == expected
+    # make sure it gives (x, y) not (y, x)
+    expr = Equality(x, x**2 + y)
+    name_expr = ("test", expr)
+    result, = codegen(name_expr, "Octave", header=False, empty=False)
+    source = result[1]
+    expected = (
+        "function x = test(x, y)\n"
+        "  x = x.^2 + y;\n"
+        "end\n"
+    )
+    assert source == expected
+
+
+def test_m_not_supported():
+    f = Function('f')
+    name_expr = ("test", [f(x).diff(x), S.ComplexInfinity])
+    result, = codegen(name_expr, "Octave", header=False, empty=False)
+    source = result[1]
+    expected = (
+        "function [out1, out2] = test(x)\n"
+        "  % unsupported: Derivative(f(x), x)\n"
+        "  % unsupported: zoo\n"
+        "  out1 = Derivative(f(x), x);\n"
+        "  out2 = zoo;\n"
+        "end\n"
+    )
+    assert source == expected
+
+
+def test_global_vars_octave():
+    x, y, z, t = symbols("x y z t")
+    result = codegen(('f', x*y), "Octave", header=False, empty=False,
+                     global_vars=(y,))
+    source = result[0][1]
+    expected = (
+        "function out1 = f(x)\n"
+        "  global y\n"
+        "  out1 = x.*y;\n"
+        "end\n"
+        )
+    assert source == expected
+
+    result = codegen(('f', x*y+z), "Octave", header=False, empty=False,
+                     argument_sequence=(x, y), global_vars=(z, t))
+    source = result[0][1]
+    expected = (
+        "function out1 = f(x, y)\n"
+        "  global t z\n"
+        "  out1 = x.*y + z;\n"
+        "end\n"
+    )
+    assert source == expected
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/tests/test_codegen_rust.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/tests/test_codegen_rust.py
new file mode 100644
index 0000000000000000000000000000000000000000..bc7f82158ae8fa7dfe34bf909aa695b119fb9526
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/tests/test_codegen_rust.py
@@ -0,0 +1,401 @@
+from io import StringIO
+
+from sympy.core import S, symbols, pi, Catalan, EulerGamma, Function
+from sympy.core.relational import Equality
+from sympy.functions.elementary.piecewise import Piecewise
+from sympy.utilities.codegen import RustCodeGen, codegen, make_routine
+from sympy.testing.pytest import XFAIL
+import sympy
+
+
+x, y, z = symbols('x,y,z')
+
+
+def test_empty_rust_code():
+    code_gen = RustCodeGen()
+    output = StringIO()
+    code_gen.dump_rs([], output, "file", header=False, empty=False)
+    source = output.getvalue()
+    assert source == ""
+
+
+def test_simple_rust_code():
+    name_expr = ("test", (x + y)*z)
+    result, = codegen(name_expr, "Rust", header=False, empty=False)
+    assert result[0] == "test.rs"
+    source = result[1]
+    expected = (
+        "fn test(x: f64, y: f64, z: f64) -> f64 {\n"
+        "    let out1 = z*(x + y);\n"
+        "    out1\n"
+        "}\n"
+    )
+    assert source == expected
+
+
+def test_simple_code_with_header():
+    name_expr = ("test", (x + y)*z)
+    result, = codegen(name_expr, "Rust", header=True, empty=False)
+    assert result[0] == "test.rs"
+    source = result[1]
+    version_str = "Code generated with SymPy %s" % sympy.__version__
+    version_line = version_str.center(76).rstrip()
+    expected = (
+        "/*\n"
+        " *%(version_line)s\n"
+        " *\n"
+        " *              See http://www.sympy.org/ for more information.\n"
+        " *\n"
+        " *                       This file is part of 'project'\n"
+        " */\n"
+        "fn test(x: f64, y: f64, z: f64) -> f64 {\n"
+        "    let out1 = z*(x + y);\n"
+        "    out1\n"
+        "}\n"
+    ) % {'version_line': version_line}
+    assert source == expected
+
+
+def test_simple_code_nameout():
+    expr = Equality(z, (x + y))
+    name_expr = ("test", expr)
+    result, = codegen(name_expr, "Rust", header=False, empty=False)
+    source = result[1]
+    expected = (
+        "fn test(x: f64, y: f64) -> f64 {\n"
+        "    let z = x + y;\n"
+        "    z\n"
+        "}\n"
+    )
+    assert source == expected
+
+
+def test_numbersymbol():
+    name_expr = ("test", pi**Catalan)
+    result, = codegen(name_expr, "Rust", header=False, empty=False)
+    source = result[1]
+    expected = (
+        "fn test() -> f64 {\n"
+        "    const Catalan: f64 = %s;\n"
+        "    let out1 = PI.powf(Catalan);\n"
+        "    out1\n"
+        "}\n"
+    ) % Catalan.evalf(17)
+    assert source == expected
+
+
+@XFAIL
+def test_numbersymbol_inline():
+    # FIXME: how to pass inline to the RustCodePrinter?
+    name_expr = ("test", [pi**Catalan, EulerGamma])
+    result, = codegen(name_expr, "Rust", header=False,
+                      empty=False, inline=True)
+    source = result[1]
+    expected = (
+        "fn test() -> (f64, f64) {\n"
+        "    const Catalan: f64 = %s;\n"
+        "    const EulerGamma: f64 = %s;\n"
+        "    let out1 = PI.powf(Catalan);\n"
+        "    let out2 = EulerGamma);\n"
+        "    (out1, out2)\n"
+        "}\n"
+    ) % (Catalan.evalf(17), EulerGamma.evalf(17))
+    assert source == expected
+
+
+def test_argument_order():
+    expr = x + y
+    routine = make_routine("test", expr, argument_sequence=[z, x, y], language="rust")
+    code_gen = RustCodeGen()
+    output = StringIO()
+    code_gen.dump_rs([routine], output, "test", header=False, empty=False)
+    source = output.getvalue()
+    expected = (
+        "fn test(z: f64, x: f64, y: f64) -> f64 {\n"
+        "    let out1 = x + y;\n"
+        "    out1\n"
+        "}\n"
+    )
+    assert source == expected
+
+
+def test_multiple_results_rust():
+    # Here the output order is the input order
+    expr1 = (x + y)*z
+    expr2 = (x - y)*z
+    name_expr = ("test", [expr1, expr2])
+    result, = codegen(name_expr, "Rust", header=False, empty=False)
+    source = result[1]
+    expected = (
+        "fn test(x: f64, y: f64, z: f64) -> (f64, f64) {\n"
+        "    let out1 = z*(x + y);\n"
+        "    let out2 = z*(x - y);\n"
+        "    (out1, out2)\n"
+        "}\n"
+    )
+    assert source == expected
+
+
+def test_results_named_unordered():
+    # Here output order is based on name_expr
+    A, B, C = symbols('A,B,C')
+    expr1 = Equality(C, (x + y)*z)
+    expr2 = Equality(A, (x - y)*z)
+    expr3 = Equality(B, 2*x)
+    name_expr = ("test", [expr1, expr2, expr3])
+    result, = codegen(name_expr, "Rust", header=False, empty=False)
+    source = result[1]
+    expected = (
+        "fn test(x: f64, y: f64, z: f64) -> (f64, f64, f64) {\n"
+        "    let C = z*(x + y);\n"
+        "    let A = z*(x - y);\n"
+        "    let B = 2*x;\n"
+        "    (C, A, B)\n"
+        "}\n"
+    )
+    assert source == expected
+
+
+def test_results_named_ordered():
+    A, B, C = symbols('A,B,C')
+    expr1 = Equality(C, (x + y)*z)
+    expr2 = Equality(A, (x - y)*z)
+    expr3 = Equality(B, 2*x)
+    name_expr = ("test", [expr1, expr2, expr3])
+    result = codegen(name_expr, "Rust", header=False, empty=False,
+                     argument_sequence=(x, z, y))
+    assert result[0][0] == "test.rs"
+    source = result[0][1]
+    expected = (
+        "fn test(x: f64, z: f64, y: f64) -> (f64, f64, f64) {\n"
+        "    let C = z*(x + y);\n"
+        "    let A = z*(x - y);\n"
+        "    let B = 2*x;\n"
+        "    (C, A, B)\n"
+        "}\n"
+    )
+    assert source == expected
+
+
+def test_complicated_rs_codegen():
+    from sympy.functions.elementary.trigonometric import (cos, sin, tan)
+    name_expr = ("testlong",
+            [ ((sin(x) + cos(y) + tan(z))**3).expand(),
+            cos(cos(cos(cos(cos(cos(cos(cos(x + y + z))))))))
+    ])
+    result = codegen(name_expr, "Rust", header=False, empty=False)
+    assert result[0][0] == "testlong.rs"
+    source = result[0][1]
+    expected = (
+        "fn testlong(x: f64, y: f64, z: f64) -> (f64, f64) {\n"
+        "    let out1 = x.sin().powi(3) + 3*x.sin().powi(2)*y.cos()"
+        " + 3*x.sin().powi(2)*z.tan() + 3*x.sin()*y.cos().powi(2)"
+        " + 6*x.sin()*y.cos()*z.tan() + 3*x.sin()*z.tan().powi(2)"
+        " + y.cos().powi(3) + 3*y.cos().powi(2)*z.tan()"
+        " + 3*y.cos()*z.tan().powi(2) + z.tan().powi(3);\n"
+        "    let out2 = (x + y + z).cos().cos().cos().cos()"
+        ".cos().cos().cos().cos();\n"
+        "    (out1, out2)\n"
+        "}\n"
+    )
+    assert source == expected
+
+
+def test_output_arg_mixed_unordered():
+    # named outputs are alphabetical, unnamed output appear in the given order
+    from sympy.functions.elementary.trigonometric import (cos, sin)
+    a = symbols("a")
+    name_expr = ("foo", [cos(2*x), Equality(y, sin(x)), cos(x), Equality(a, sin(2*x))])
+    result, = codegen(name_expr, "Rust", header=False, empty=False)
+    assert result[0] == "foo.rs"
+    source = result[1]
+    expected = (
+        "fn foo(x: f64) -> (f64, f64, f64, f64) {\n"
+        "    let out1 = (2*x).cos();\n"
+        "    let y = x.sin();\n"
+        "    let out3 = x.cos();\n"
+        "    let a = (2*x).sin();\n"
+        "    (out1, y, out3, a)\n"
+        "}\n"
+    )
+    assert source == expected
+
+
+def test_piecewise_():
+    pw = Piecewise((0, x < -1), (x**2, x <= 1), (-x+2, x > 1), (1, True), evaluate=False)
+    name_expr = ("pwtest", pw)
+    result, = codegen(name_expr, "Rust", header=False, empty=False)
+    source = result[1]
+    expected = (
+        "fn pwtest(x: f64) -> f64 {\n"
+        "    let out1 = if (x < -1.0) {\n"
+        "        0\n"
+        "    } else if (x <= 1.0) {\n"
+        "        x.powi(2)\n"
+        "    } else if (x > 1.0) {\n"
+        "        2 - x\n"
+        "    } else {\n"
+        "        1\n"
+        "    };\n"
+        "    out1\n"
+        "}\n"
+    )
+    assert source == expected
+
+
+@XFAIL
+def test_piecewise_inline():
+    # FIXME: how to pass inline to the RustCodePrinter?
+    pw = Piecewise((0, x < -1), (x**2, x <= 1), (-x+2, x > 1), (1, True))
+    name_expr = ("pwtest", pw)
+    result, = codegen(name_expr, "Rust", header=False, empty=False,
+                      inline=True)
+    source = result[1]
+    expected = (
+        "fn pwtest(x: f64) -> f64 {\n"
+        "    let out1 = if (x < -1) { 0 } else if (x <= 1) { x.powi(2) }"
+        " else if (x > 1) { -x + 2 } else { 1 };\n"
+        "    out1\n"
+        "}\n"
+    )
+    assert source == expected
+
+
+def test_multifcns_per_file():
+    name_expr = [ ("foo", [2*x, 3*y]), ("bar", [y**2, 4*y]) ]
+    result = codegen(name_expr, "Rust", header=False, empty=False)
+    assert result[0][0] == "foo.rs"
+    source = result[0][1]
+    expected = (
+        "fn foo(x: f64, y: f64) -> (f64, f64) {\n"
+        "    let out1 = 2*x;\n"
+        "    let out2 = 3*y;\n"
+        "    (out1, out2)\n"
+        "}\n"
+        "fn bar(y: f64) -> (f64, f64) {\n"
+        "    let out1 = y.powi(2);\n"
+        "    let out2 = 4*y;\n"
+        "    (out1, out2)\n"
+        "}\n"
+    )
+    assert source == expected
+
+
+def test_multifcns_per_file_w_header():
+    name_expr = [ ("foo", [2*x, 3*y]), ("bar", [y**2, 4*y]) ]
+    result = codegen(name_expr, "Rust", header=True, empty=False)
+    assert result[0][0] == "foo.rs"
+    source = result[0][1]
+    version_str = "Code generated with SymPy %s" % sympy.__version__
+    version_line = version_str.center(76).rstrip()
+    expected = (
+        "/*\n"
+        " *%(version_line)s\n"
+        " *\n"
+        " *              See http://www.sympy.org/ for more information.\n"
+        " *\n"
+        " *                       This file is part of 'project'\n"
+        " */\n"
+        "fn foo(x: f64, y: f64) -> (f64, f64) {\n"
+        "    let out1 = 2*x;\n"
+        "    let out2 = 3*y;\n"
+        "    (out1, out2)\n"
+        "}\n"
+        "fn bar(y: f64) -> (f64, f64) {\n"
+        "    let out1 = y.powi(2);\n"
+        "    let out2 = 4*y;\n"
+        "    (out1, out2)\n"
+        "}\n"
+    ) % {'version_line': version_line}
+    assert source == expected
+
+
+def test_filename_match_prefix():
+    name_expr = [ ("foo", [2*x, 3*y]), ("bar", [y**2, 4*y]) ]
+    result, = codegen(name_expr, "Rust", prefix="baz", header=False,
+                     empty=False)
+    assert result[0] == "baz.rs"
+
+
+def test_InOutArgument():
+    expr = Equality(x, x**2)
+    name_expr = ("mysqr", expr)
+    result, = codegen(name_expr, "Rust", header=False, empty=False)
+    source = result[1]
+    expected = (
+        "fn mysqr(x: f64) -> f64 {\n"
+        "    let x = x.powi(2);\n"
+        "    x\n"
+        "}\n"
+    )
+    assert source == expected
+
+
+def test_InOutArgument_order():
+    # can specify the order as (x, y)
+    expr = Equality(x, x**2 + y)
+    name_expr = ("test", expr)
+    result, = codegen(name_expr, "Rust", header=False,
+                      empty=False, argument_sequence=(x,y))
+    source = result[1]
+    expected = (
+        "fn test(x: f64, y: f64) -> f64 {\n"
+        "    let x = x.powi(2) + y;\n"
+        "    x\n"
+        "}\n"
+    )
+    assert source == expected
+    # make sure it gives (x, y) not (y, x)
+    expr = Equality(x, x**2 + y)
+    name_expr = ("test", expr)
+    result, = codegen(name_expr, "Rust", header=False, empty=False)
+    source = result[1]
+    expected = (
+        "fn test(x: f64, y: f64) -> f64 {\n"
+        "    let x = x.powi(2) + y;\n"
+        "    x\n"
+        "}\n"
+    )
+    assert source == expected
+
+
+def test_not_supported():
+    f = Function('f')
+    name_expr = ("test", [f(x).diff(x), S.ComplexInfinity])
+    result, = codegen(name_expr, "Rust", header=False, empty=False)
+    source = result[1]
+    expected = (
+        "fn test(x: f64) -> (f64, f64) {\n"
+        "    // unsupported: Derivative(f(x), x)\n"
+        "    // unsupported: zoo\n"
+        "    let out1 = Derivative(f(x), x);\n"
+        "    let out2 = zoo;\n"
+        "    (out1, out2)\n"
+        "}\n"
+    )
+    assert source == expected
+
+
+def test_global_vars_rust():
+    x, y, z, t = symbols("x y z t")
+    result = codegen(('f', x*y), "Rust", header=False, empty=False,
+                     global_vars=(y,))
+    source = result[0][1]
+    expected = (
+        "fn f(x: f64) -> f64 {\n"
+        "    let out1 = x*y;\n"
+        "    out1\n"
+        "}\n"
+        )
+    assert source == expected
+
+    result = codegen(('f', x*y+z), "Rust", header=False, empty=False,
+                     argument_sequence=(x, y), global_vars=(z, t))
+    source = result[0][1]
+    expected = (
+        "fn f(x: f64, y: f64) -> f64 {\n"
+        "    let out1 = x*y + z;\n"
+        "    out1\n"
+        "}\n"
+    )
+    assert source == expected
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/tests/test_decorator.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/tests/test_decorator.py
new file mode 100644
index 0000000000000000000000000000000000000000..b1870d4db8f719fdabfeab14120bfb3ce10131a9
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/tests/test_decorator.py
@@ -0,0 +1,129 @@
+from functools import wraps
+
+from sympy.utilities.decorator import threaded, xthreaded, memoize_property, deprecated
+from sympy.testing.pytest import warns_deprecated_sympy
+
+from sympy.core.basic import Basic
+from sympy.core.relational import Eq
+from sympy.matrices.dense import Matrix
+
+from sympy.abc import x, y
+
+
+def test_threaded():
+    @threaded
+    def function(expr, *args):
+        return 2*expr + sum(args)
+
+    assert function(Matrix([[x, y], [1, x]]), 1, 2) == \
+        Matrix([[2*x + 3, 2*y + 3], [5, 2*x + 3]])
+
+    assert function(Eq(x, y), 1, 2) == Eq(2*x + 3, 2*y + 3)
+
+    assert function([x, y], 1, 2) == [2*x + 3, 2*y + 3]
+    assert function((x, y), 1, 2) == (2*x + 3, 2*y + 3)
+
+    assert function({x, y}, 1, 2) == {2*x + 3, 2*y + 3}
+
+    @threaded
+    def function(expr, n):
+        return expr**n
+
+    assert function(x + y, 2) == x**2 + y**2
+    assert function(x, 2) == x**2
+
+
+def test_xthreaded():
+    @xthreaded
+    def function(expr, n):
+        return expr**n
+
+    assert function(x + y, 2) == (x + y)**2
+
+
+def test_wraps():
+    def my_func(x):
+        """My function. """
+
+    my_func.is_my_func = True
+
+    new_my_func = threaded(my_func)
+    new_my_func = wraps(my_func)(new_my_func)
+
+    assert new_my_func.__name__ == 'my_func'
+    assert new_my_func.__doc__ == 'My function. '
+    assert hasattr(new_my_func, 'is_my_func')
+    assert new_my_func.is_my_func is True
+
+
+def test_memoize_property():
+    class TestMemoize(Basic):
+        @memoize_property
+        def prop(self):
+            return Basic()
+
+    member = TestMemoize()
+    obj1 = member.prop
+    obj2 = member.prop
+    assert obj1 is obj2
+
+def test_deprecated():
+    @deprecated('deprecated_function is deprecated',
+                deprecated_since_version='1.10',
+                # This is the target at the top of the file, which will never
+                # go away.
+                active_deprecations_target='active-deprecations')
+    def deprecated_function(x):
+        return x
+
+    with warns_deprecated_sympy():
+        assert deprecated_function(1) == 1
+
+    @deprecated('deprecated_class is deprecated',
+                deprecated_since_version='1.10',
+                active_deprecations_target='active-deprecations')
+    class deprecated_class:
+        pass
+
+    with warns_deprecated_sympy():
+        assert isinstance(deprecated_class(), deprecated_class)
+
+    # Ensure the class decorator works even when the class never returns
+    # itself
+    @deprecated('deprecated_class_new is deprecated',
+                deprecated_since_version='1.10',
+                active_deprecations_target='active-deprecations')
+    class deprecated_class_new:
+        def __new__(cls, arg):
+            return arg
+
+    with warns_deprecated_sympy():
+        assert deprecated_class_new(1) == 1
+
+    @deprecated('deprecated_class_init is deprecated',
+                deprecated_since_version='1.10',
+                active_deprecations_target='active-deprecations')
+    class deprecated_class_init:
+        def __init__(self, arg):
+            self.arg = 1
+
+    with warns_deprecated_sympy():
+        assert deprecated_class_init(1).arg == 1
+
+    @deprecated('deprecated_class_new_init is deprecated',
+                deprecated_since_version='1.10',
+                active_deprecations_target='active-deprecations')
+    class deprecated_class_new_init:
+        def __new__(cls, arg):
+            if arg == 0:
+                return arg
+            return object.__new__(cls)
+
+        def __init__(self, arg):
+            self.arg = 1
+
+    with warns_deprecated_sympy():
+        assert deprecated_class_new_init(0) == 0
+
+    with warns_deprecated_sympy():
+        assert deprecated_class_new_init(1).arg == 1
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/tests/test_deprecated.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/tests/test_deprecated.py
new file mode 100644
index 0000000000000000000000000000000000000000..dd4534ef1abc38ff368011b3ef9d11c497f3675b
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/tests/test_deprecated.py
@@ -0,0 +1,13 @@
+from sympy.testing.pytest import warns_deprecated_sympy
+
+# See https://github.com/sympy/sympy/pull/18095
+
+def test_deprecated_utilities():
+    with warns_deprecated_sympy():
+        import sympy.utilities.pytest  # noqa:F401
+    with warns_deprecated_sympy():
+        import sympy.utilities.runtests  # noqa:F401
+    with warns_deprecated_sympy():
+        import sympy.utilities.randtest  # noqa:F401
+    with warns_deprecated_sympy():
+        import sympy.utilities.tmpfiles  # noqa:F401
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/tests/test_enumerative.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/tests/test_enumerative.py
new file mode 100644
index 0000000000000000000000000000000000000000..357499d5fd400b14e2bcad067f3015b74b0e9003
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/tests/test_enumerative.py
@@ -0,0 +1,179 @@
+import string
+from itertools import zip_longest
+
+from sympy.utilities.enumerative import (
+    list_visitor,
+    MultisetPartitionTraverser,
+    multiset_partitions_taocp
+    )
+from sympy.utilities.iterables import _set_partitions
+
+# first some functions only useful as test scaffolding - these provide
+# straightforward, but slow reference implementations against which to
+# compare the real versions, and also a comparison to verify that
+# different versions are giving identical results.
+
+def part_range_filter(partition_iterator, lb, ub):
+    """
+    Filters (on the number of parts) a multiset partition enumeration
+
+    Arguments
+    =========
+
+    lb, and ub are a range (in the Python slice sense) on the lpart
+    variable returned from a multiset partition enumeration.  Recall
+    that lpart is 0-based (it points to the topmost part on the part
+    stack), so if you want to return parts of sizes 2,3,4,5 you would
+    use lb=1 and ub=5.
+    """
+    for state in partition_iterator:
+        f, lpart, pstack = state
+        if lpart >= lb and lpart < ub:
+            yield state
+
+def multiset_partitions_baseline(multiplicities, components):
+    """Enumerates partitions of a multiset
+
+    Parameters
+    ==========
+
+    multiplicities
+         list of integer multiplicities of the components of the multiset.
+
+    components
+         the components (elements) themselves
+
+    Returns
+    =======
+
+    Set of partitions.  Each partition is tuple of parts, and each
+    part is a tuple of components (with repeats to indicate
+    multiplicity)
+
+    Notes
+    =====
+
+    Multiset partitions can be created as equivalence classes of set
+    partitions, and this function does just that.  This approach is
+    slow and memory intensive compared to the more advanced algorithms
+    available, but the code is simple and easy to understand.  Hence
+    this routine is strictly for testing -- to provide a
+    straightforward baseline against which to regress the production
+    versions.  (This code is a simplified version of an earlier
+    production implementation.)
+    """
+
+    canon = []                  # list of components with repeats
+    for ct, elem in zip(multiplicities, components):
+        canon.extend([elem]*ct)
+
+    # accumulate the multiset partitions in a set to eliminate dups
+    cache = set()
+    n = len(canon)
+    for nc, q in _set_partitions(n):
+        rv = [[] for i in range(nc)]
+        for i in range(n):
+            rv[q[i]].append(canon[i])
+        canonical = tuple(
+            sorted([tuple(p) for p in rv]))
+        cache.add(canonical)
+    return cache
+
+
+def compare_multiset_w_baseline(multiplicities):
+    """
+    Enumerates the partitions of multiset with AOCP algorithm and
+    baseline implementation, and compare the results.
+
+    """
+    letters = string.ascii_lowercase
+    bl_partitions = multiset_partitions_baseline(multiplicities, letters)
+
+    # The partitions returned by the different algorithms may have
+    # their parts in different orders.  Also, they generate partitions
+    # in different orders.  Hence the sorting, and set comparison.
+
+    aocp_partitions = set()
+    for state in multiset_partitions_taocp(multiplicities):
+        p1 = tuple(sorted(
+                [tuple(p) for p in list_visitor(state, letters)]))
+        aocp_partitions.add(p1)
+
+    assert bl_partitions == aocp_partitions
+
+def compare_multiset_states(s1, s2):
+    """compare for equality two instances of multiset partition states
+
+    This is useful for comparing different versions of the algorithm
+    to verify correctness."""
+    # Comparison is physical, the only use of semantics is to ignore
+    # trash off the top of the stack.
+    f1, lpart1, pstack1 = s1
+    f2, lpart2, pstack2 = s2
+
+    if (lpart1 == lpart2) and (f1[0:lpart1+1] == f2[0:lpart2+1]):
+        if pstack1[0:f1[lpart1+1]] == pstack2[0:f2[lpart2+1]]:
+            return True
+    return False
+
+def test_multiset_partitions_taocp():
+    """Compares the output of multiset_partitions_taocp with a baseline
+    (set partition based) implementation."""
+
+    # Test cases should not be too large, since the baseline
+    # implementation is fairly slow.
+    multiplicities = [2,2]
+    compare_multiset_w_baseline(multiplicities)
+
+    multiplicities = [4,3,1]
+    compare_multiset_w_baseline(multiplicities)
+
+def test_multiset_partitions_versions():
+    """Compares Knuth-based versions of multiset_partitions"""
+    multiplicities = [5,2,2,1]
+    m = MultisetPartitionTraverser()
+    for s1, s2 in zip_longest(m.enum_all(multiplicities),
+                              multiset_partitions_taocp(multiplicities)):
+        assert compare_multiset_states(s1, s2)
+
+def subrange_exercise(mult, lb, ub):
+    """Compare filter-based and more optimized subrange implementations
+
+    Helper for tests, called with both small and larger multisets.
+    """
+    m = MultisetPartitionTraverser()
+    assert m.count_partitions(mult) == \
+        m.count_partitions_slow(mult)
+
+    # Note - multiple traversals from the same
+    # MultisetPartitionTraverser object cannot execute at the same
+    # time, hence make several instances here.
+    ma = MultisetPartitionTraverser()
+    mc = MultisetPartitionTraverser()
+    md = MultisetPartitionTraverser()
+
+    #  Several paths to compute just the size two partitions
+    a_it = ma.enum_range(mult, lb, ub)
+    b_it = part_range_filter(multiset_partitions_taocp(mult), lb, ub)
+    c_it = part_range_filter(mc.enum_small(mult, ub), lb, sum(mult))
+    d_it = part_range_filter(md.enum_large(mult, lb), 0, ub)
+
+    for sa, sb, sc, sd in zip_longest(a_it, b_it, c_it, d_it):
+        assert compare_multiset_states(sa, sb)
+        assert compare_multiset_states(sa, sc)
+        assert compare_multiset_states(sa, sd)
+
+def test_subrange():
+    # Quick, but doesn't hit some of the corner cases
+    mult = [4,4,2,1] # mississippi
+    lb = 1
+    ub = 2
+    subrange_exercise(mult, lb, ub)
+
+
+def test_subrange_large():
+    # takes a second or so, depending on cpu, Python version, etc.
+    mult = [6,3,2,1]
+    lb = 4
+    ub = 7
+    subrange_exercise(mult, lb, ub)
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/tests/test_exceptions.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/tests/test_exceptions.py
new file mode 100644
index 0000000000000000000000000000000000000000..d91e55e95d0ae4ac57cdd1989e0b3d39a55cd07d
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/tests/test_exceptions.py
@@ -0,0 +1,12 @@
+from sympy.testing.pytest import raises
+from sympy.utilities.exceptions import sympy_deprecation_warning
+
+# Only test exceptions here because the other cases are tested in the
+# warns_deprecated_sympy tests
+def test_sympy_deprecation_warning():
+    raises(TypeError, lambda: sympy_deprecation_warning('test',
+                                                        deprecated_since_version=1.10,
+                                                        active_deprecations_target='active-deprecations'))
+
+    raises(ValueError, lambda: sympy_deprecation_warning('test',
+                                                            deprecated_since_version="1.10", active_deprecations_target='(active-deprecations)='))
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/tests/test_iterables.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/tests/test_iterables.py
new file mode 100644
index 0000000000000000000000000000000000000000..1003522bcd556c6f63e04de7da57b43498575fee
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/tests/test_iterables.py
@@ -0,0 +1,945 @@
+from textwrap import dedent
+from itertools import islice, product
+
+from sympy.core.basic import Basic
+from sympy.core.numbers import Integer
+from sympy.core.sorting import ordered
+from sympy.core.symbol import (Dummy, symbols)
+from sympy.functions.combinatorial.factorials import factorial
+from sympy.matrices.dense import Matrix
+from sympy.combinatorics import RGS_enum, RGS_unrank, Permutation
+from sympy.utilities.iterables import (
+    _partition, _set_partitions, binary_partitions, bracelets, capture,
+    cartes, common_prefix, common_suffix, connected_components, dict_merge,
+    filter_symbols, flatten, generate_bell, generate_derangements,
+    generate_involutions, generate_oriented_forest, group, has_dups, ibin,
+    iproduct, kbins, minlex, multiset, multiset_combinations,
+    multiset_partitions, multiset_permutations, necklaces, numbered_symbols,
+    partitions, permutations, postfixes,
+    prefixes, reshape, rotate_left, rotate_right, runs, sift,
+    strongly_connected_components, subsets, take, topological_sort, unflatten,
+    uniq, variations, ordered_partitions, rotations, is_palindromic, iterable,
+    NotIterable, multiset_derangements, signed_permutations,
+    sequence_partitions, sequence_partitions_empty)
+from sympy.utilities.enumerative import (
+    factoring_visitor, multiset_partitions_taocp )
+
+from sympy.core.singleton import S
+from sympy.testing.pytest import raises, warns_deprecated_sympy
+
+w, x, y, z = symbols('w,x,y,z')
+
+
+def test_deprecated_iterables():
+    from sympy.utilities.iterables import default_sort_key, ordered
+    with warns_deprecated_sympy():
+        assert list(ordered([y, x])) == [x, y]
+    with warns_deprecated_sympy():
+        assert sorted([y, x], key=default_sort_key) == [x, y]
+
+
+def test_is_palindromic():
+    assert is_palindromic('')
+    assert is_palindromic('x')
+    assert is_palindromic('xx')
+    assert is_palindromic('xyx')
+    assert not is_palindromic('xy')
+    assert not is_palindromic('xyzx')
+    assert is_palindromic('xxyzzyx', 1)
+    assert not is_palindromic('xxyzzyx', 2)
+    assert is_palindromic('xxyzzyx', 2, -1)
+    assert is_palindromic('xxyzzyx', 2, 6)
+    assert is_palindromic('xxyzyx', 1)
+    assert not is_palindromic('xxyzyx', 2)
+    assert is_palindromic('xxyzyx', 2, 2 + 3)
+
+
+def test_flatten():
+    assert flatten((1, (1,))) == [1, 1]
+    assert flatten((x, (x,))) == [x, x]
+
+    ls = [[(-2, -1), (1, 2)], [(0, 0)]]
+
+    assert flatten(ls, levels=0) == ls
+    assert flatten(ls, levels=1) == [(-2, -1), (1, 2), (0, 0)]
+    assert flatten(ls, levels=2) == [-2, -1, 1, 2, 0, 0]
+    assert flatten(ls, levels=3) == [-2, -1, 1, 2, 0, 0]
+
+    raises(ValueError, lambda: flatten(ls, levels=-1))
+
+    class MyOp(Basic):
+        pass
+
+    assert flatten([MyOp(x, y), z]) == [MyOp(x, y), z]
+    assert flatten([MyOp(x, y), z], cls=MyOp) == [x, y, z]
+
+    assert flatten({1, 11, 2}) == list({1, 11, 2})
+
+
+def test_iproduct():
+    assert list(iproduct()) == [()]
+    assert list(iproduct([])) == []
+    assert list(iproduct([1,2,3])) == [(1,),(2,),(3,)]
+    assert sorted(iproduct([1, 2], [3, 4, 5])) == [
+        (1,3),(1,4),(1,5),(2,3),(2,4),(2,5)]
+    assert sorted(iproduct([0,1],[0,1],[0,1])) == [
+        (0,0,0),(0,0,1),(0,1,0),(0,1,1),(1,0,0),(1,0,1),(1,1,0),(1,1,1)]
+    assert iterable(iproduct(S.Integers)) is True
+    assert iterable(iproduct(S.Integers, S.Integers)) is True
+    assert (3,) in iproduct(S.Integers)
+    assert (4, 5) in iproduct(S.Integers, S.Integers)
+    assert (1, 2, 3) in iproduct(S.Integers, S.Integers, S.Integers)
+    triples  = set(islice(iproduct(S.Integers, S.Integers, S.Integers), 1000))
+    for n1, n2, n3 in triples:
+        assert isinstance(n1, Integer)
+        assert isinstance(n2, Integer)
+        assert isinstance(n3, Integer)
+    for t in set(product(*([range(-2, 3)]*3))):
+        assert t in iproduct(S.Integers, S.Integers, S.Integers)
+
+
+def test_group():
+    assert group([]) == []
+    assert group([], multiple=False) == []
+
+    assert group([1]) == [[1]]
+    assert group([1], multiple=False) == [(1, 1)]
+
+    assert group([1, 1]) == [[1, 1]]
+    assert group([1, 1], multiple=False) == [(1, 2)]
+
+    assert group([1, 1, 1]) == [[1, 1, 1]]
+    assert group([1, 1, 1], multiple=False) == [(1, 3)]
+
+    assert group([1, 2, 1]) == [[1], [2], [1]]
+    assert group([1, 2, 1], multiple=False) == [(1, 1), (2, 1), (1, 1)]
+
+    assert group([1, 1, 2, 2, 2, 1, 3, 3]) == [[1, 1], [2, 2, 2], [1], [3, 3]]
+    assert group([1, 1, 2, 2, 2, 1, 3, 3], multiple=False) == [(1, 2),
+                 (2, 3), (1, 1), (3, 2)]
+
+
+def test_subsets():
+    # combinations
+    assert list(subsets([1, 2, 3], 0)) == [()]
+    assert list(subsets([1, 2, 3], 1)) == [(1,), (2,), (3,)]
+    assert list(subsets([1, 2, 3], 2)) == [(1, 2), (1, 3), (2, 3)]
+    assert list(subsets([1, 2, 3], 3)) == [(1, 2, 3)]
+    l = list(range(4))
+    assert list(subsets(l, 0, repetition=True)) == [()]
+    assert list(subsets(l, 1, repetition=True)) == [(0,), (1,), (2,), (3,)]
+    assert list(subsets(l, 2, repetition=True)) == [(0, 0), (0, 1), (0, 2),
+                                                    (0, 3), (1, 1), (1, 2),
+                                                    (1, 3), (2, 2), (2, 3),
+                                                    (3, 3)]
+    assert list(subsets(l, 3, repetition=True)) == [(0, 0, 0), (0, 0, 1),
+                                                    (0, 0, 2), (0, 0, 3),
+                                                    (0, 1, 1), (0, 1, 2),
+                                                    (0, 1, 3), (0, 2, 2),
+                                                    (0, 2, 3), (0, 3, 3),
+                                                    (1, 1, 1), (1, 1, 2),
+                                                    (1, 1, 3), (1, 2, 2),
+                                                    (1, 2, 3), (1, 3, 3),
+                                                    (2, 2, 2), (2, 2, 3),
+                                                    (2, 3, 3), (3, 3, 3)]
+    assert len(list(subsets(l, 4, repetition=True))) == 35
+
+    assert list(subsets(l[:2], 3, repetition=False)) == []
+    assert list(subsets(l[:2], 3, repetition=True)) == [(0, 0, 0),
+                                                        (0, 0, 1),
+                                                        (0, 1, 1),
+                                                        (1, 1, 1)]
+    assert list(subsets([1, 2], repetition=True)) == \
+        [(), (1,), (2,), (1, 1), (1, 2), (2, 2)]
+    assert list(subsets([1, 2], repetition=False)) == \
+        [(), (1,), (2,), (1, 2)]
+    assert list(subsets([1, 2, 3], 2)) == \
+        [(1, 2), (1, 3), (2, 3)]
+    assert list(subsets([1, 2, 3], 2, repetition=True)) == \
+        [(1, 1), (1, 2), (1, 3), (2, 2), (2, 3), (3, 3)]
+
+
+def test_variations():
+    # permutations
+    l = list(range(4))
+    assert list(variations(l, 0, repetition=False)) == [()]
+    assert list(variations(l, 1, repetition=False)) == [(0,), (1,), (2,), (3,)]
+    assert list(variations(l, 2, repetition=False)) == [(0, 1), (0, 2), (0, 3), (1, 0), (1, 2), (1, 3), (2, 0), (2, 1), (2, 3), (3, 0), (3, 1), (3, 2)]
+    assert list(variations(l, 3, repetition=False)) == [(0, 1, 2), (0, 1, 3), (0, 2, 1), (0, 2, 3), (0, 3, 1), (0, 3, 2), (1, 0, 2), (1, 0, 3), (1, 2, 0), (1, 2, 3), (1, 3, 0), (1, 3, 2), (2, 0, 1), (2, 0, 3), (2, 1, 0), (2, 1, 3), (2, 3, 0), (2, 3, 1), (3, 0, 1), (3, 0, 2), (3, 1, 0), (3, 1, 2), (3, 2, 0), (3, 2, 1)]
+    assert list(variations(l, 0, repetition=True)) == [()]
+    assert list(variations(l, 1, repetition=True)) == [(0,), (1,), (2,), (3,)]
+    assert list(variations(l, 2, repetition=True)) == [(0, 0), (0, 1), (0, 2),
+                                                       (0, 3), (1, 0), (1, 1),
+                                                       (1, 2), (1, 3), (2, 0),
+                                                       (2, 1), (2, 2), (2, 3),
+                                                       (3, 0), (3, 1), (3, 2),
+                                                       (3, 3)]
+    assert len(list(variations(l, 3, repetition=True))) == 64
+    assert len(list(variations(l, 4, repetition=True))) == 256
+    assert list(variations(l[:2], 3, repetition=False)) == []
+    assert list(variations(l[:2], 3, repetition=True)) == [
+        (0, 0, 0), (0, 0, 1), (0, 1, 0), (0, 1, 1),
+        (1, 0, 0), (1, 0, 1), (1, 1, 0), (1, 1, 1)
+    ]
+
+
+def test_cartes():
+    assert list(cartes([1, 2], [3, 4, 5])) == \
+        [(1, 3), (1, 4), (1, 5), (2, 3), (2, 4), (2, 5)]
+    assert list(cartes()) == [()]
+    assert list(cartes('a')) == [('a',)]
+    assert list(cartes('a', repeat=2)) == [('a', 'a')]
+    assert list(cartes(list(range(2)))) == [(0,), (1,)]
+
+
+def test_filter_symbols():
+    s = numbered_symbols()
+    filtered = filter_symbols(s, symbols("x0 x2 x3"))
+    assert take(filtered, 3) == list(symbols("x1 x4 x5"))
+
+
+def test_numbered_symbols():
+    s = numbered_symbols(cls=Dummy)
+    assert isinstance(next(s), Dummy)
+    assert next(numbered_symbols('C', start=1, exclude=[symbols('C1')])) == \
+        symbols('C2')
+
+
+def test_sift():
+    assert sift(list(range(5)), lambda _: _ % 2) == {1: [1, 3], 0: [0, 2, 4]}
+    assert sift([x, y], lambda _: _.has(x)) == {False: [y], True: [x]}
+    assert sift([S.One], lambda _: _.has(x)) == {False: [1]}
+    assert sift([0, 1, 2, 3], lambda x: x % 2, binary=True) == (
+        [1, 3], [0, 2])
+    assert sift([0, 1, 2, 3], lambda x: x % 3 == 1, binary=True) == (
+        [1], [0, 2, 3])
+    raises(ValueError, lambda:
+        sift([0, 1, 2, 3], lambda x: x % 3, binary=True))
+
+
+def test_take():
+    X = numbered_symbols()
+
+    assert take(X, 5) == list(symbols('x0:5'))
+    assert take(X, 5) == list(symbols('x5:10'))
+
+    assert take([1, 2, 3, 4, 5], 5) == [1, 2, 3, 4, 5]
+
+
+def test_dict_merge():
+    assert dict_merge({}, {1: x, y: z}) == {1: x, y: z}
+    assert dict_merge({1: x, y: z}, {}) == {1: x, y: z}
+
+    assert dict_merge({2: z}, {1: x, y: z}) == {1: x, 2: z, y: z}
+    assert dict_merge({1: x, y: z}, {2: z}) == {1: x, 2: z, y: z}
+
+    assert dict_merge({1: y, 2: z}, {1: x, y: z}) == {1: x, 2: z, y: z}
+    assert dict_merge({1: x, y: z}, {1: y, 2: z}) == {1: y, 2: z, y: z}
+
+
+def test_prefixes():
+    assert list(prefixes([])) == []
+    assert list(prefixes([1])) == [[1]]
+    assert list(prefixes([1, 2])) == [[1], [1, 2]]
+
+    assert list(prefixes([1, 2, 3, 4, 5])) == \
+        [[1], [1, 2], [1, 2, 3], [1, 2, 3, 4], [1, 2, 3, 4, 5]]
+
+
+def test_postfixes():
+    assert list(postfixes([])) == []
+    assert list(postfixes([1])) == [[1]]
+    assert list(postfixes([1, 2])) == [[2], [1, 2]]
+
+    assert list(postfixes([1, 2, 3, 4, 5])) == \
+        [[5], [4, 5], [3, 4, 5], [2, 3, 4, 5], [1, 2, 3, 4, 5]]
+
+
+def test_topological_sort():
+    V = [2, 3, 5, 7, 8, 9, 10, 11]
+    E = [(7, 11), (7, 8), (5, 11),
+         (3, 8), (3, 10), (11, 2),
+         (11, 9), (11, 10), (8, 9)]
+
+    assert topological_sort((V, E)) == [3, 5, 7, 8, 11, 2, 9, 10]
+    assert topological_sort((V, E), key=lambda v: -v) == \
+        [7, 5, 11, 3, 10, 8, 9, 2]
+
+    raises(ValueError, lambda: topological_sort((V, E + [(10, 7)])))
+
+
+def test_strongly_connected_components():
+    assert strongly_connected_components(([], [])) == []
+    assert strongly_connected_components(([1, 2, 3], [])) == [[1], [2], [3]]
+
+    V = [1, 2, 3]
+    E = [(1, 2), (1, 3), (2, 1), (2, 3), (3, 1)]
+    assert strongly_connected_components((V, E)) == [[1, 2, 3]]
+
+    V = [1, 2, 3, 4]
+    E = [(1, 2), (2, 3), (3, 2), (3, 4)]
+    assert strongly_connected_components((V, E)) == [[4], [2, 3], [1]]
+
+    V = [1, 2, 3, 4]
+    E = [(1, 2), (2, 1), (3, 4), (4, 3)]
+    assert strongly_connected_components((V, E)) == [[1, 2], [3, 4]]
+
+
+def test_connected_components():
+    assert connected_components(([], [])) == []
+    assert connected_components(([1, 2, 3], [])) == [[1], [2], [3]]
+
+    V = [1, 2, 3]
+    E = [(1, 2), (1, 3), (2, 1), (2, 3), (3, 1)]
+    assert connected_components((V, E)) == [[1, 2, 3]]
+
+    V = [1, 2, 3, 4]
+    E = [(1, 2), (2, 3), (3, 2), (3, 4)]
+    assert connected_components((V, E)) == [[1, 2, 3, 4]]
+
+    V = [1, 2, 3, 4]
+    E = [(1, 2), (3, 4)]
+    assert connected_components((V, E)) == [[1, 2], [3, 4]]
+
+
+def test_rotate():
+    A = [0, 1, 2, 3, 4]
+
+    assert rotate_left(A, 2) == [2, 3, 4, 0, 1]
+    assert rotate_right(A, 1) == [4, 0, 1, 2, 3]
+    A = []
+    B = rotate_right(A, 1)
+    assert B == []
+    B.append(1)
+    assert A == []
+    B = rotate_left(A, 1)
+    assert B == []
+    B.append(1)
+    assert A == []
+
+
+def test_multiset_partitions():
+    A = [0, 1, 2, 3, 4]
+
+    assert list(multiset_partitions(A, 5)) == [[[0], [1], [2], [3], [4]]]
+    assert len(list(multiset_partitions(A, 4))) == 10
+    assert len(list(multiset_partitions(A, 3))) == 25
+
+    assert list(multiset_partitions([1, 1, 1, 2, 2], 2)) == [
+        [[1, 1, 1, 2], [2]], [[1, 1, 1], [2, 2]], [[1, 1, 2, 2], [1]],
+        [[1, 1, 2], [1, 2]], [[1, 1], [1, 2, 2]]]
+
+    assert list(multiset_partitions([1, 1, 2, 2], 2)) == [
+        [[1, 1, 2], [2]], [[1, 1], [2, 2]], [[1, 2, 2], [1]],
+        [[1, 2], [1, 2]]]
+
+    assert list(multiset_partitions([1, 2, 3, 4], 2)) == [
+        [[1, 2, 3], [4]], [[1, 2, 4], [3]], [[1, 2], [3, 4]],
+        [[1, 3, 4], [2]], [[1, 3], [2, 4]], [[1, 4], [2, 3]],
+        [[1], [2, 3, 4]]]
+
+    assert list(multiset_partitions([1, 2, 2], 2)) == [
+        [[1, 2], [2]], [[1], [2, 2]]]
+
+    assert list(multiset_partitions(3)) == [
+        [[0, 1, 2]], [[0, 1], [2]], [[0, 2], [1]], [[0], [1, 2]],
+        [[0], [1], [2]]]
+    assert list(multiset_partitions(3, 2)) == [
+        [[0, 1], [2]], [[0, 2], [1]], [[0], [1, 2]]]
+    assert list(multiset_partitions([1] * 3, 2)) == [[[1], [1, 1]]]
+    assert list(multiset_partitions([1] * 3)) == [
+        [[1, 1, 1]], [[1], [1, 1]], [[1], [1], [1]]]
+    a = [3, 2, 1]
+    assert list(multiset_partitions(a)) == \
+        list(multiset_partitions(sorted(a)))
+    assert list(multiset_partitions(a, 5)) == []
+    assert list(multiset_partitions(a, 1)) == [[[1, 2, 3]]]
+    assert list(multiset_partitions(a + [4], 5)) == []
+    assert list(multiset_partitions(a + [4], 1)) == [[[1, 2, 3, 4]]]
+    assert list(multiset_partitions(2, 5)) == []
+    assert list(multiset_partitions(2, 1)) == [[[0, 1]]]
+    assert list(multiset_partitions('a')) == [[['a']]]
+    assert list(multiset_partitions('a', 2)) == []
+    assert list(multiset_partitions('ab')) == [[['a', 'b']], [['a'], ['b']]]
+    assert list(multiset_partitions('ab', 1)) == [[['a', 'b']]]
+    assert list(multiset_partitions('aaa', 1)) == [['aaa']]
+    assert list(multiset_partitions([1, 1], 1)) == [[[1, 1]]]
+    ans = [('mpsyy',), ('mpsy', 'y'), ('mps', 'yy'), ('mps', 'y', 'y'),
+           ('mpyy', 's'), ('mpy', 'sy'), ('mpy', 's', 'y'), ('mp', 'syy'),
+           ('mp', 'sy', 'y'), ('mp', 's', 'yy'), ('mp', 's', 'y', 'y'),
+           ('msyy', 'p'), ('msy', 'py'), ('msy', 'p', 'y'), ('ms', 'pyy'),
+           ('ms', 'py', 'y'), ('ms', 'p', 'yy'), ('ms', 'p', 'y', 'y'),
+           ('myy', 'ps'), ('myy', 'p', 's'), ('my', 'psy'), ('my', 'ps', 'y'),
+           ('my', 'py', 's'), ('my', 'p', 'sy'), ('my', 'p', 's', 'y'),
+           ('m', 'psyy'), ('m', 'psy', 'y'), ('m', 'ps', 'yy'),
+           ('m', 'ps', 'y', 'y'), ('m', 'pyy', 's'), ('m', 'py', 'sy'),
+           ('m', 'py', 's', 'y'), ('m', 'p', 'syy'),
+           ('m', 'p', 'sy', 'y'), ('m', 'p', 's', 'yy'),
+           ('m', 'p', 's', 'y', 'y')]
+    assert [tuple("".join(part) for part in p)
+                for p in multiset_partitions('sympy')] == ans
+    factorings = [[24], [8, 3], [12, 2], [4, 6], [4, 2, 3],
+                  [6, 2, 2], [2, 2, 2, 3]]
+    assert [factoring_visitor(p, [2,3]) for
+                p in multiset_partitions_taocp([3, 1])] == factorings
+
+
+def test_multiset_combinations():
+    ans = ['iii', 'iim', 'iip', 'iis', 'imp', 'ims', 'ipp', 'ips',
+           'iss', 'mpp', 'mps', 'mss', 'pps', 'pss', 'sss']
+    assert [''.join(i) for i in
+            list(multiset_combinations('mississippi', 3))] == ans
+    M = multiset('mississippi')
+    assert [''.join(i) for i in
+            list(multiset_combinations(M, 3))] == ans
+    assert [''.join(i) for i in multiset_combinations(M, 30)] == []
+    assert list(multiset_combinations([[1], [2, 3]], 2)) == [[[1], [2, 3]]]
+    assert len(list(multiset_combinations('a', 3))) == 0
+    assert len(list(multiset_combinations('a', 0))) == 1
+    assert list(multiset_combinations('abc', 1)) == [['a'], ['b'], ['c']]
+    raises(ValueError, lambda: list(multiset_combinations({0: 3, 1: -1}, 2)))
+
+
+def test_multiset_permutations():
+    ans = ['abby', 'abyb', 'aybb', 'baby', 'bayb', 'bbay', 'bbya', 'byab',
+           'byba', 'yabb', 'ybab', 'ybba']
+    assert [''.join(i) for i in multiset_permutations('baby')] == ans
+    assert [''.join(i) for i in multiset_permutations(multiset('baby'))] == ans
+    assert list(multiset_permutations([0, 0, 0], 2)) == [[0, 0]]
+    assert list(multiset_permutations([0, 2, 1], 2)) == [
+        [0, 1], [0, 2], [1, 0], [1, 2], [2, 0], [2, 1]]
+    assert len(list(multiset_permutations('a', 0))) == 1
+    assert len(list(multiset_permutations('a', 3))) == 0
+    for nul in ([], {}, ''):
+        assert list(multiset_permutations(nul)) == [[]]
+    assert list(multiset_permutations(nul, 0)) == [[]]
+    # impossible requests give no result
+    assert list(multiset_permutations(nul, 1)) == []
+    assert list(multiset_permutations(nul, -1)) == []
+
+    def test():
+        for i in range(1, 7):
+            print(i)
+            for p in multiset_permutations([0, 0, 1, 0, 1], i):
+                print(p)
+    assert capture(lambda: test()) == dedent('''\
+        1
+        [0]
+        [1]
+        2
+        [0, 0]
+        [0, 1]
+        [1, 0]
+        [1, 1]
+        3
+        [0, 0, 0]
+        [0, 0, 1]
+        [0, 1, 0]
+        [0, 1, 1]
+        [1, 0, 0]
+        [1, 0, 1]
+        [1, 1, 0]
+        4
+        [0, 0, 0, 1]
+        [0, 0, 1, 0]
+        [0, 0, 1, 1]
+        [0, 1, 0, 0]
+        [0, 1, 0, 1]
+        [0, 1, 1, 0]
+        [1, 0, 0, 0]
+        [1, 0, 0, 1]
+        [1, 0, 1, 0]
+        [1, 1, 0, 0]
+        5
+        [0, 0, 0, 1, 1]
+        [0, 0, 1, 0, 1]
+        [0, 0, 1, 1, 0]
+        [0, 1, 0, 0, 1]
+        [0, 1, 0, 1, 0]
+        [0, 1, 1, 0, 0]
+        [1, 0, 0, 0, 1]
+        [1, 0, 0, 1, 0]
+        [1, 0, 1, 0, 0]
+        [1, 1, 0, 0, 0]
+        6\n''')
+    raises(ValueError, lambda: list(multiset_permutations({0: 3, 1: -1})))
+
+
+def test_partitions():
+    ans = [[{}], [(0, {})]]
+    for i in range(2):
+        assert list(partitions(0, size=i)) == ans[i]
+        assert list(partitions(1, 0, size=i)) == ans[i]
+        assert list(partitions(6, 2, 2, size=i)) == ans[i]
+        assert list(partitions(6, 2, None, size=i)) != ans[i]
+        assert list(partitions(6, None, 2, size=i)) != ans[i]
+        assert list(partitions(6, 2, 0, size=i)) == ans[i]
+
+    assert list(partitions(6, k=2)) == [
+        {2: 3}, {1: 2, 2: 2}, {1: 4, 2: 1}, {1: 6}]
+
+    assert list(partitions(6, k=3)) == [
+        {3: 2}, {1: 1, 2: 1, 3: 1}, {1: 3, 3: 1}, {2: 3}, {1: 2, 2: 2},
+        {1: 4, 2: 1}, {1: 6}]
+
+    assert list(partitions(8, k=4, m=3)) == [
+        {4: 2}, {1: 1, 3: 1, 4: 1}, {2: 2, 4: 1}, {2: 1, 3: 2}] == [
+        i for i in partitions(8, k=4, m=3) if all(k <= 4 for k in i)
+        and sum(i.values()) <=3]
+
+    assert list(partitions(S(3), m=2)) == [
+        {3: 1}, {1: 1, 2: 1}]
+
+    assert list(partitions(4, k=3)) == [
+        {1: 1, 3: 1}, {2: 2}, {1: 2, 2: 1}, {1: 4}] == [
+        i for i in partitions(4) if all(k <= 3 for k in i)]
+
+
+    # Consistency check on output of _partitions and RGS_unrank.
+    # This provides a sanity test on both routines.  Also verifies that
+    # the total number of partitions is the same in each case.
+    #    (from pkrathmann2)
+
+    for n in range(2, 6):
+        i  = 0
+        for m, q  in _set_partitions(n):
+            assert  q == RGS_unrank(i, n)
+            i += 1
+        assert i == RGS_enum(n)
+
+
+def test_binary_partitions():
+    assert [i[:] for i in binary_partitions(10)] == [[8, 2], [8, 1, 1],
+        [4, 4, 2], [4, 4, 1, 1], [4, 2, 2, 2], [4, 2, 2, 1, 1],
+        [4, 2, 1, 1, 1, 1], [4, 1, 1, 1, 1, 1, 1], [2, 2, 2, 2, 2],
+        [2, 2, 2, 2, 1, 1], [2, 2, 2, 1, 1, 1, 1], [2, 2, 1, 1, 1, 1, 1, 1],
+        [2, 1, 1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]
+
+    assert len([j[:] for j in binary_partitions(16)]) == 36
+
+
+def test_bell_perm():
+    assert [len(set(generate_bell(i))) for i in range(1, 7)] == [
+        factorial(i) for i in range(1, 7)]
+    assert list(generate_bell(3)) == [
+        (0, 1, 2), (0, 2, 1), (2, 0, 1), (2, 1, 0), (1, 2, 0), (1, 0, 2)]
+    # generate_bell and trotterjohnson are advertised to return the same
+    # permutations; this is not technically necessary so this test could
+    # be removed
+    for n in range(1, 5):
+        p = Permutation(range(n))
+        b = generate_bell(n)
+        for bi in b:
+            assert bi == tuple(p.array_form)
+            p = p.next_trotterjohnson()
+    raises(ValueError, lambda: list(generate_bell(0)))  # XXX is this consistent with other permutation algorithms?
+
+
+def test_involutions():
+    lengths = [1, 2, 4, 10, 26, 76]
+    for n, N in enumerate(lengths):
+        i = list(generate_involutions(n + 1))
+        assert len(i) == N
+        assert len({Permutation(j)**2 for j in i}) == 1
+
+
+def test_derangements():
+    assert len(list(generate_derangements(list(range(6))))) == 265
+    assert ''.join(''.join(i) for i in generate_derangements('abcde')) == (
+    'badecbaecdbcaedbcdeabceadbdaecbdeacbdecabeacdbedacbedcacabedcadebcaebd'
+    'cdaebcdbeacdeabcdebaceabdcebadcedabcedbadabecdaebcdaecbdcaebdcbeadceab'
+    'dcebadeabcdeacbdebacdebcaeabcdeadbceadcbecabdecbadecdabecdbaedabcedacb'
+    'edbacedbca')
+    assert list(generate_derangements([0, 1, 2, 3])) == [
+        [1, 0, 3, 2], [1, 2, 3, 0], [1, 3, 0, 2], [2, 0, 3, 1],
+        [2, 3, 0, 1], [2, 3, 1, 0], [3, 0, 1, 2], [3, 2, 0, 1], [3, 2, 1, 0]]
+    assert list(generate_derangements([0, 1, 2, 2])) == [
+        [2, 2, 0, 1], [2, 2, 1, 0]]
+    assert list(generate_derangements('ba')) == [list('ab')]
+    # multiset_derangements
+    D = multiset_derangements
+    assert list(D('abb')) == []
+    assert [''.join(i) for i in D('ab')] == ['ba']
+    assert [''.join(i) for i in D('abc')] == ['bca', 'cab']
+    assert [''.join(i) for i in D('aabb')] == ['bbaa']
+    assert [''.join(i) for i in D('aabbcccc')] == [
+        'ccccaabb', 'ccccabab', 'ccccabba', 'ccccbaab', 'ccccbaba',
+        'ccccbbaa']
+    assert [''.join(i) for i in D('aabbccc')] == [
+        'cccabba', 'cccabab', 'cccaabb', 'ccacbba', 'ccacbab',
+        'ccacabb', 'cbccbaa', 'cbccaba', 'cbccaab', 'bcccbaa',
+        'bcccaba', 'bcccaab']
+    assert [''.join(i) for i in D('books')] == ['kbsoo', 'ksboo',
+        'sbkoo', 'skboo', 'oksbo', 'oskbo', 'okbso', 'obkso', 'oskob',
+        'oksob', 'osbok', 'obsok']
+    assert list(generate_derangements([[3], [2], [2], [1]])) == [
+        [[2], [1], [3], [2]], [[2], [3], [1], [2]]]
+
+
+def test_necklaces():
+    def count(n, k, f):
+        return len(list(necklaces(n, k, f)))
+    m = []
+    for i in range(1, 8):
+        m.append((
+        i, count(i, 2, 0), count(i, 2, 1), count(i, 3, 1)))
+    assert Matrix(m) == Matrix([
+        [1,   2,   2,   3],
+        [2,   3,   3,   6],
+        [3,   4,   4,  10],
+        [4,   6,   6,  21],
+        [5,   8,   8,  39],
+        [6,  14,  13,  92],
+        [7,  20,  18, 198]])
+
+
+def test_bracelets():
+    bc = list(bracelets(2, 4))
+    assert Matrix(bc) == Matrix([
+        [0, 0],
+        [0, 1],
+        [0, 2],
+        [0, 3],
+        [1, 1],
+        [1, 2],
+        [1, 3],
+        [2, 2],
+        [2, 3],
+        [3, 3]
+        ])
+    bc = list(bracelets(4, 2))
+    assert Matrix(bc) == Matrix([
+        [0, 0, 0, 0],
+        [0, 0, 0, 1],
+        [0, 0, 1, 1],
+        [0, 1, 0, 1],
+        [0, 1, 1, 1],
+        [1, 1, 1, 1]
+    ])
+
+
+def test_generate_oriented_forest():
+    assert list(generate_oriented_forest(5)) == [[0, 1, 2, 3, 4],
+        [0, 1, 2, 3, 3], [0, 1, 2, 3, 2], [0, 1, 2, 3, 1], [0, 1, 2, 3, 0],
+        [0, 1, 2, 2, 2], [0, 1, 2, 2, 1], [0, 1, 2, 2, 0], [0, 1, 2, 1, 2],
+        [0, 1, 2, 1, 1], [0, 1, 2, 1, 0], [0, 1, 2, 0, 1], [0, 1, 2, 0, 0],
+        [0, 1, 1, 1, 1], [0, 1, 1, 1, 0], [0, 1, 1, 0, 1], [0, 1, 1, 0, 0],
+        [0, 1, 0, 1, 0], [0, 1, 0, 0, 0], [0, 0, 0, 0, 0]]
+    assert len(list(generate_oriented_forest(10))) == 1842
+
+
+def test_unflatten():
+    r = list(range(10))
+    assert unflatten(r) == list(zip(r[::2], r[1::2]))
+    assert unflatten(r, 5) == [tuple(r[:5]), tuple(r[5:])]
+    raises(ValueError, lambda: unflatten(list(range(10)), 3))
+    raises(ValueError, lambda: unflatten(list(range(10)), -2))
+
+
+def test_common_prefix_suffix():
+    assert common_prefix([], [1]) == []
+    assert common_prefix(list(range(3))) == [0, 1, 2]
+    assert common_prefix(list(range(3)), list(range(4))) == [0, 1, 2]
+    assert common_prefix([1, 2, 3], [1, 2, 5]) == [1, 2]
+    assert common_prefix([1, 2, 3], [1, 3, 5]) == [1]
+
+    assert common_suffix([], [1]) == []
+    assert common_suffix(list(range(3))) == [0, 1, 2]
+    assert common_suffix(list(range(3)), list(range(3))) == [0, 1, 2]
+    assert common_suffix(list(range(3)), list(range(4))) == []
+    assert common_suffix([1, 2, 3], [9, 2, 3]) == [2, 3]
+    assert common_suffix([1, 2, 3], [9, 7, 3]) == [3]
+
+
+def test_minlex():
+    assert minlex([1, 2, 0]) == (0, 1, 2)
+    assert minlex((1, 2, 0)) == (0, 1, 2)
+    assert minlex((1, 0, 2)) == (0, 2, 1)
+    assert minlex((1, 0, 2), directed=False) == (0, 1, 2)
+    assert minlex('aba') == 'aab'
+    assert minlex(('bb', 'aaa', 'c', 'a'), key=len) == ('c', 'a', 'bb', 'aaa')
+
+
+def test_ordered():
+    assert list(ordered((x, y), hash, default=False)) in [[x, y], [y, x]]
+    assert list(ordered((x, y), hash, default=False)) == \
+        list(ordered((y, x), hash, default=False))
+    assert list(ordered((x, y))) == [x, y]
+
+    seq, keys = [[[1, 2, 1], [0, 3, 1], [1, 1, 3], [2], [1]],
+                 (lambda x: len(x), lambda x: sum(x))]
+    assert list(ordered(seq, keys, default=False, warn=False)) == \
+        [[1], [2], [1, 2, 1], [0, 3, 1], [1, 1, 3]]
+    raises(ValueError, lambda:
+           list(ordered(seq, keys, default=False, warn=True)))
+
+
+def test_runs():
+    assert runs([]) == []
+    assert runs([1]) == [[1]]
+    assert runs([1, 1]) == [[1], [1]]
+    assert runs([1, 1, 2]) == [[1], [1, 2]]
+    assert runs([1, 2, 1]) == [[1, 2], [1]]
+    assert runs([2, 1, 1]) == [[2], [1], [1]]
+    from operator import lt
+    assert runs([2, 1, 1], lt) == [[2, 1], [1]]
+
+
+def test_reshape():
+    seq = list(range(1, 9))
+    assert reshape(seq, [4]) == \
+        [[1, 2, 3, 4], [5, 6, 7, 8]]
+    assert reshape(seq, (4,)) == \
+        [(1, 2, 3, 4), (5, 6, 7, 8)]
+    assert reshape(seq, (2, 2)) == \
+        [(1, 2, 3, 4), (5, 6, 7, 8)]
+    assert reshape(seq, (2, [2])) == \
+        [(1, 2, [3, 4]), (5, 6, [7, 8])]
+    assert reshape(seq, ((2,), [2])) == \
+        [((1, 2), [3, 4]), ((5, 6), [7, 8])]
+    assert reshape(seq, (1, [2], 1)) == \
+        [(1, [2, 3], 4), (5, [6, 7], 8)]
+    assert reshape(tuple(seq), ([[1], 1, (2,)],)) == \
+        (([[1], 2, (3, 4)],), ([[5], 6, (7, 8)],))
+    assert reshape(tuple(seq), ([1], 1, (2,))) == \
+        (([1], 2, (3, 4)), ([5], 6, (7, 8)))
+    assert reshape(list(range(12)), [2, [3], {2}, (1, (3,), 1)]) == \
+        [[0, 1, [2, 3, 4], {5, 6}, (7, (8, 9, 10), 11)]]
+    raises(ValueError, lambda: reshape([0, 1], [-1]))
+    raises(ValueError, lambda: reshape([0, 1], [3]))
+
+
+def test_uniq():
+    assert list(uniq(p for p in partitions(4))) == \
+        [{4: 1}, {1: 1, 3: 1}, {2: 2}, {1: 2, 2: 1}, {1: 4}]
+    assert list(uniq(x % 2 for x in range(5))) == [0, 1]
+    assert list(uniq('a')) == ['a']
+    assert list(uniq('ababc')) == list('abc')
+    assert list(uniq([[1], [2, 1], [1]])) == [[1], [2, 1]]
+    assert list(uniq(permutations(i for i in [[1], 2, 2]))) == \
+        [([1], 2, 2), (2, [1], 2), (2, 2, [1])]
+    assert list(uniq([2, 3, 2, 4, [2], [1], [2], [3], [1]])) == \
+        [2, 3, 4, [2], [1], [3]]
+    f = [1]
+    raises(RuntimeError, lambda: [f.remove(i) for i in uniq(f)])
+    f = [[1]]
+    raises(RuntimeError, lambda: [f.remove(i) for i in uniq(f)])
+
+
+def test_kbins():
+    assert len(list(kbins('1123', 2, ordered=1))) == 24
+    assert len(list(kbins('1123', 2, ordered=11))) == 36
+    assert len(list(kbins('1123', 2, ordered=10))) == 10
+    assert len(list(kbins('1123', 2, ordered=0))) == 5
+    assert len(list(kbins('1123', 2, ordered=None))) == 3
+
+    def test1():
+        for orderedval in [None, 0, 1, 10, 11]:
+            print('ordered =', orderedval)
+            for p in kbins([0, 0, 1], 2, ordered=orderedval):
+                print('   ', p)
+    assert capture(lambda : test1()) == dedent('''\
+        ordered = None
+            [[0], [0, 1]]
+            [[0, 0], [1]]
+        ordered = 0
+            [[0, 0], [1]]
+            [[0, 1], [0]]
+        ordered = 1
+            [[0], [0, 1]]
+            [[0], [1, 0]]
+            [[1], [0, 0]]
+        ordered = 10
+            [[0, 0], [1]]
+            [[1], [0, 0]]
+            [[0, 1], [0]]
+            [[0], [0, 1]]
+        ordered = 11
+            [[0], [0, 1]]
+            [[0, 0], [1]]
+            [[0], [1, 0]]
+            [[0, 1], [0]]
+            [[1], [0, 0]]
+            [[1, 0], [0]]\n''')
+
+    def test2():
+        for orderedval in [None, 0, 1, 10, 11]:
+            print('ordered =', orderedval)
+            for p in kbins(list(range(3)), 2, ordered=orderedval):
+                print('   ', p)
+    assert capture(lambda : test2()) == dedent('''\
+        ordered = None
+            [[0], [1, 2]]
+            [[0, 1], [2]]
+        ordered = 0
+            [[0, 1], [2]]
+            [[0, 2], [1]]
+            [[0], [1, 2]]
+        ordered = 1
+            [[0], [1, 2]]
+            [[0], [2, 1]]
+            [[1], [0, 2]]
+            [[1], [2, 0]]
+            [[2], [0, 1]]
+            [[2], [1, 0]]
+        ordered = 10
+            [[0, 1], [2]]
+            [[2], [0, 1]]
+            [[0, 2], [1]]
+            [[1], [0, 2]]
+            [[0], [1, 2]]
+            [[1, 2], [0]]
+        ordered = 11
+            [[0], [1, 2]]
+            [[0, 1], [2]]
+            [[0], [2, 1]]
+            [[0, 2], [1]]
+            [[1], [0, 2]]
+            [[1, 0], [2]]
+            [[1], [2, 0]]
+            [[1, 2], [0]]
+            [[2], [0, 1]]
+            [[2, 0], [1]]
+            [[2], [1, 0]]
+            [[2, 1], [0]]\n''')
+
+
+def test_has_dups():
+    assert has_dups(set()) is False
+    assert has_dups(list(range(3))) is False
+    assert has_dups([1, 2, 1]) is True
+    assert has_dups([[1], [1]]) is True
+    assert has_dups([[1], [2]]) is False
+
+
+def test__partition():
+    assert _partition('abcde', [1, 0, 1, 2, 0]) == [
+        ['b', 'e'], ['a', 'c'], ['d']]
+    assert _partition('abcde', [1, 0, 1, 2, 0], 3) == [
+        ['b', 'e'], ['a', 'c'], ['d']]
+    output = (3, [1, 0, 1, 2, 0])
+    assert _partition('abcde', *output) == [['b', 'e'], ['a', 'c'], ['d']]
+
+
+def test_ordered_partitions():
+    from sympy.functions.combinatorial.numbers import nT
+    f = ordered_partitions
+    assert list(f(0, 1)) == [[]]
+    assert list(f(1, 0)) == [[]]
+    for i in range(1, 7):
+        for j in [None] + list(range(1, i)):
+            assert (
+                sum(1 for p in f(i, j, 1)) ==
+                sum(1 for p in f(i, j, 0)) ==
+                nT(i, j))
+
+
+def test_rotations():
+    assert list(rotations('ab')) == [['a', 'b'], ['b', 'a']]
+    assert list(rotations(range(3))) == [[0, 1, 2], [1, 2, 0], [2, 0, 1]]
+    assert list(rotations(range(3), dir=-1)) == [[0, 1, 2], [2, 0, 1], [1, 2, 0]]
+
+
+def test_ibin():
+    assert ibin(3) == [1, 1]
+    assert ibin(3, 3) == [0, 1, 1]
+    assert ibin(3, str=True) == '11'
+    assert ibin(3, 3, str=True) == '011'
+    assert list(ibin(2, 'all')) == [(0, 0), (0, 1), (1, 0), (1, 1)]
+    assert list(ibin(2, '', str=True)) == ['00', '01', '10', '11']
+    raises(ValueError, lambda: ibin(-.5))
+    raises(ValueError, lambda: ibin(2, 1))
+
+
+def test_iterable():
+    assert iterable(0) is False
+    assert iterable(1) is False
+    assert iterable(None) is False
+
+    class Test1(NotIterable):
+        pass
+
+    assert iterable(Test1()) is False
+
+    class Test2(NotIterable):
+        _iterable = True
+
+    assert iterable(Test2()) is True
+
+    class Test3:
+        pass
+
+    assert iterable(Test3()) is False
+
+    class Test4:
+        _iterable = True
+
+    assert iterable(Test4()) is True
+
+    class Test5:
+        def __iter__(self):
+            yield 1
+
+    assert iterable(Test5()) is True
+
+    class Test6(Test5):
+        _iterable = False
+
+    assert iterable(Test6()) is False
+
+
+def test_sequence_partitions():
+    assert list(sequence_partitions([1], 1)) == [[[1]]]
+    assert list(sequence_partitions([1, 2], 1)) == [[[1, 2]]]
+    assert list(sequence_partitions([1, 2], 2)) == [[[1], [2]]]
+    assert list(sequence_partitions([1, 2, 3], 1)) == [[[1, 2, 3]]]
+    assert list(sequence_partitions([1, 2, 3], 2)) == \
+        [[[1], [2, 3]], [[1, 2], [3]]]
+    assert list(sequence_partitions([1, 2, 3], 3)) == [[[1], [2], [3]]]
+
+    # Exceptional cases
+    assert list(sequence_partitions([], 0)) == []
+    assert list(sequence_partitions([], 1)) == []
+    assert list(sequence_partitions([1, 2], 0)) == []
+    assert list(sequence_partitions([1, 2], 3)) == []
+
+
+def test_sequence_partitions_empty():
+    assert list(sequence_partitions_empty([], 1)) == [[[]]]
+    assert list(sequence_partitions_empty([], 2)) == [[[], []]]
+    assert list(sequence_partitions_empty([], 3)) == [[[], [], []]]
+    assert list(sequence_partitions_empty([1], 1)) == [[[1]]]
+    assert list(sequence_partitions_empty([1], 2)) == [[[], [1]], [[1], []]]
+    assert list(sequence_partitions_empty([1], 3)) == \
+        [[[], [], [1]], [[], [1], []], [[1], [], []]]
+    assert list(sequence_partitions_empty([1, 2], 1)) == [[[1, 2]]]
+    assert list(sequence_partitions_empty([1, 2], 2)) == \
+        [[[], [1, 2]], [[1], [2]], [[1, 2], []]]
+    assert list(sequence_partitions_empty([1, 2], 3)) == [
+        [[], [], [1, 2]], [[], [1], [2]], [[], [1, 2], []],
+        [[1], [], [2]], [[1], [2], []], [[1, 2], [], []]
+    ]
+    assert list(sequence_partitions_empty([1, 2, 3], 1)) == [[[1, 2, 3]]]
+    assert list(sequence_partitions_empty([1, 2, 3], 2)) == \
+        [[[], [1, 2, 3]], [[1], [2, 3]], [[1, 2], [3]], [[1, 2, 3], []]]
+    assert list(sequence_partitions_empty([1, 2, 3], 3)) == [
+        [[], [], [1, 2, 3]], [[], [1], [2, 3]],
+        [[], [1, 2], [3]], [[], [1, 2, 3], []],
+        [[1], [], [2, 3]], [[1], [2], [3]],
+        [[1], [2, 3], []], [[1, 2], [], [3]],
+        [[1, 2], [3], []], [[1, 2, 3], [], []]
+    ]
+
+    # Exceptional cases
+    assert list(sequence_partitions([], 0)) == []
+    assert list(sequence_partitions([1], 0)) == []
+    assert list(sequence_partitions([1, 2], 0)) == []
+
+
+def test_signed_permutations():
+    ans = [(0, 1, 1), (0, -1, 1), (0, 1, -1), (0, -1, -1),
+    (1, 0, 1), (-1, 0, 1), (1, 0, -1), (-1, 0, -1),
+    (1, 1, 0), (-1, 1, 0), (1, -1, 0), (-1, -1, 0)]
+    assert list(signed_permutations((0, 1, 1))) == ans
+    assert list(signed_permutations((1, 0, 1))) == ans
+    assert list(signed_permutations((1, 1, 0))) == ans
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/tests/test_lambdify.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/tests/test_lambdify.py
new file mode 100644
index 0000000000000000000000000000000000000000..b094c67d39f09c24bcb9abc1e755cb5328e143e7
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/tests/test_lambdify.py
@@ -0,0 +1,2263 @@
+from itertools import product
+import math
+import inspect
+import linecache
+import gc
+
+import mpmath
+import cmath
+
+from sympy.testing.pytest import raises, warns_deprecated_sympy
+from sympy.concrete.summations import Sum
+from sympy.core.function import (Function, Lambda, diff)
+from sympy.core.numbers import (E, Float, I, Rational, all_close, oo, pi)
+from sympy.core.relational import Eq
+from sympy.core.singleton import S
+from sympy.core.symbol import (Dummy, symbols)
+from sympy.functions.combinatorial.factorials import (RisingFactorial, factorial)
+from sympy.functions.combinatorial.numbers import bernoulli, harmonic
+from sympy.functions.elementary.complexes import Abs, sign
+from sympy.functions.elementary.exponential import exp, log
+from sympy.functions.elementary.hyperbolic import asinh,acosh,atanh
+from sympy.functions.elementary.integers import floor
+from sympy.functions.elementary.miscellaneous import (Max, Min, sqrt)
+from sympy.functions.elementary.piecewise import Piecewise
+from sympy.functions.elementary.trigonometric import (asin, acos, atan, cos, cot, sin,
+                                                      sinc, tan)
+from sympy.functions import sinh,cosh,tanh
+from sympy.functions.special.bessel import (besseli, besselj, besselk, bessely, jn, yn)
+from sympy.functions.special.beta_functions import (beta, betainc, betainc_regularized)
+from sympy.functions.special.delta_functions import (Heaviside)
+from sympy.functions.special.error_functions import (Ei, erf, erfc, fresnelc, fresnels, Si, Ci)
+from sympy.functions.special.gamma_functions import (digamma, gamma, loggamma, polygamma)
+from sympy.functions.special.zeta_functions import zeta
+from sympy.integrals.integrals import Integral
+from sympy.logic.boolalg import (And, false, ITE, Not, Or, true)
+from sympy.matrices.expressions.dotproduct import DotProduct
+from sympy.simplify.cse_main import cse
+from sympy.tensor.array import derive_by_array, Array
+from sympy.tensor.array.expressions import ArraySymbol
+from sympy.tensor.indexed import IndexedBase, Idx
+from sympy.utilities.lambdify import lambdify
+from sympy.utilities.iterables import numbered_symbols
+from sympy.vector import CoordSys3D
+from sympy.core.expr import UnevaluatedExpr
+from sympy.codegen.cfunctions import expm1, log1p, exp2, log2, log10, hypot, isnan, isinf
+from sympy.codegen.numpy_nodes import logaddexp, logaddexp2, amin, amax, minimum, maximum
+from sympy.codegen.scipy_nodes import cosm1, powm1
+from sympy.functions.elementary.complexes import re, im, arg
+from sympy.functions.special.polynomials import \
+    chebyshevt, chebyshevu, legendre, hermite, laguerre, gegenbauer, \
+    assoc_legendre, assoc_laguerre, jacobi
+from sympy.matrices import Matrix, MatrixSymbol, SparseMatrix
+from sympy.printing.codeprinter import PrintMethodNotImplementedError
+from sympy.printing.lambdarepr import LambdaPrinter
+from sympy.printing.numpy import NumPyPrinter
+from sympy.utilities.lambdify import implemented_function, lambdastr
+from sympy.testing.pytest import skip
+from sympy.utilities.decorator import conserve_mpmath_dps
+from sympy.utilities.exceptions import ignore_warnings
+from sympy.external import import_module
+from sympy.functions.special.gamma_functions import uppergamma, lowergamma
+
+
+import sympy
+
+
+MutableDenseMatrix = Matrix
+
+numpy = import_module('numpy')
+scipy = import_module('scipy', import_kwargs={'fromlist': ['sparse']})
+numexpr = import_module('numexpr')
+tensorflow = import_module('tensorflow')
+cupy = import_module('cupy')
+jax = import_module('jax')
+numba = import_module('numba')
+
+if tensorflow:
+    # Hide Tensorflow warnings
+    import os
+    os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
+
+w, x, y, z = symbols('w,x,y,z')
+
+#================== Test different arguments =======================
+
+
+def test_no_args():
+    f = lambdify([], 1)
+    raises(TypeError, lambda: f(-1))
+    assert f() == 1
+
+
+def test_single_arg():
+    f = lambdify(x, 2*x)
+    assert f(1) == 2
+
+
+def test_list_args():
+    f = lambdify([x, y], x + y)
+    assert f(1, 2) == 3
+
+
+def test_nested_args():
+    f1 = lambdify([[w, x]], [w, x])
+    assert f1([91, 2]) == [91, 2]
+    raises(TypeError, lambda: f1(1, 2))
+
+    f2 = lambdify([(w, x), (y, z)], [w, x, y, z])
+    assert f2((18, 12), (73, 4)) == [18, 12, 73, 4]
+    raises(TypeError, lambda: f2(3, 4))
+
+    f3 = lambdify([w, [[[x]], y], z], [w, x, y, z])
+    assert f3(10, [[[52]], 31], 44) == [10, 52, 31, 44]
+
+
+def test_str_args():
+    f = lambdify('x,y,z', 'z,y,x')
+    assert f(3, 2, 1) == (1, 2, 3)
+    assert f(1.0, 2.0, 3.0) == (3.0, 2.0, 1.0)
+    # make sure correct number of args required
+    raises(TypeError, lambda: f(0))
+
+
+def test_own_namespace_1():
+    myfunc = lambda x: 1
+    f = lambdify(x, sin(x), {"sin": myfunc})
+    assert f(0.1) == 1
+    assert f(100) == 1
+
+
+def test_own_namespace_2():
+    def myfunc(x):
+        return 1
+    f = lambdify(x, sin(x), {'sin': myfunc})
+    assert f(0.1) == 1
+    assert f(100) == 1
+
+
+def test_own_module():
+    f = lambdify(x, sin(x), math)
+    assert f(0) == 0.0
+
+    p, q, r = symbols("p q r", real=True)
+    ae = abs(exp(p+UnevaluatedExpr(q+r)))
+    f = lambdify([p, q, r], [ae, ae], modules=math)
+    results = f(1.0, 1e18, -1e18)
+    refvals = [math.exp(1.0)]*2
+    for res, ref in zip(results, refvals):
+        assert abs((res-ref)/ref) < 1e-15
+
+
+def test_bad_args():
+    # no vargs given
+    raises(TypeError, lambda: lambdify(1))
+    # same with vector exprs
+    raises(TypeError, lambda: lambdify([1, 2]))
+
+
+def test_atoms():
+    # Non-Symbol atoms should not be pulled out from the expression namespace
+    f = lambdify(x, pi + x, {"pi": 3.14})
+    assert f(0) == 3.14
+    f = lambdify(x, I + x, {"I": 1j})
+    assert f(1) == 1 + 1j
+
+#================== Test different modules =========================
+
+# high precision output of sin(0.2*pi) is used to detect if precision is lost unwanted
+
+
+@conserve_mpmath_dps
+def test_sympy_lambda():
+    mpmath.mp.dps = 50
+    sin02 = mpmath.mpf("0.19866933079506121545941262711838975037020672954020")
+    f = lambdify(x, sin(x), "sympy")
+    assert f(x) == sin(x)
+    prec = 1e-15
+    assert -prec < f(Rational(1, 5)).evalf() - Float(str(sin02)) < prec
+    # arctan is in numpy module and should not be available
+    # The arctan below gives NameError. What is this supposed to test?
+    # raises(NameError, lambda: lambdify(x, arctan(x), "sympy"))
+
+
+@conserve_mpmath_dps
+def test_math_lambda():
+    mpmath.mp.dps = 50
+    sin02 = mpmath.mpf("0.19866933079506121545941262711838975037020672954020")
+    f = lambdify(x, sin(x), "math")
+    prec = 1e-15
+    assert -prec < f(0.2) - sin02 < prec
+    raises(TypeError, lambda: f(x))
+           # if this succeeds, it can't be a Python math function
+
+
+@conserve_mpmath_dps
+def test_mpmath_lambda():
+    mpmath.mp.dps = 50
+    sin02 = mpmath.mpf("0.19866933079506121545941262711838975037020672954020")
+    f = lambdify(x, sin(x), "mpmath")
+    prec = 1e-49  # mpmath precision is around 50 decimal places
+    assert -prec < f(mpmath.mpf("0.2")) - sin02 < prec
+    raises(TypeError, lambda: f(x))
+           # if this succeeds, it can't be a mpmath function
+
+    ref2 = (mpmath.mpf("1e-30")
+            - mpmath.mpf("1e-45")/2
+            + 5*mpmath.mpf("1e-60")/6
+            - 3*mpmath.mpf("1e-75")/4
+            + 33*mpmath.mpf("1e-90")/40
+            )
+    f2a = lambdify((x, y), x**y - 1, "mpmath")
+    f2b = lambdify((x, y), powm1(x, y), "mpmath")
+    f2c = lambdify((x,), expm1(x*log1p(x)), "mpmath")
+    ans2a = f2a(mpmath.mpf("1")+mpmath.mpf("1e-15"), mpmath.mpf("1e-15"))
+    ans2b = f2b(mpmath.mpf("1")+mpmath.mpf("1e-15"), mpmath.mpf("1e-15"))
+    ans2c = f2c(mpmath.mpf("1e-15"))
+    assert abs(ans2a - ref2) < 1e-51
+    assert abs(ans2b - ref2) < 1e-67
+    assert abs(ans2c - ref2) < 1e-80
+
+
+@conserve_mpmath_dps
+def test_number_precision():
+    mpmath.mp.dps = 50
+    sin02 = mpmath.mpf("0.19866933079506121545941262711838975037020672954020")
+    f = lambdify(x, sin02, "mpmath")
+    prec = 1e-49  # mpmath precision is around 50 decimal places
+    assert -prec < f(0) - sin02 < prec
+
+@conserve_mpmath_dps
+def test_mpmath_precision():
+    mpmath.mp.dps = 100
+    assert str(lambdify((), pi.evalf(100), 'mpmath')()) == str(pi.evalf(100))
+
+#================== Test Translations ==============================
+# We can only check if all translated functions are valid. It has to be checked
+# by hand if they are complete.
+
+
+def test_math_transl():
+    from sympy.utilities.lambdify import MATH_TRANSLATIONS
+    for sym, mat in MATH_TRANSLATIONS.items():
+        assert sym in sympy.__dict__
+        assert mat in math.__dict__
+
+
+def test_mpmath_transl():
+    from sympy.utilities.lambdify import MPMATH_TRANSLATIONS
+    for sym, mat in MPMATH_TRANSLATIONS.items():
+        assert sym in sympy.__dict__ or sym == 'Matrix'
+        assert mat in mpmath.__dict__
+
+
+def test_numpy_transl():
+    if not numpy:
+        skip("numpy not installed.")
+
+    from sympy.utilities.lambdify import NUMPY_TRANSLATIONS
+    for sym, nump in NUMPY_TRANSLATIONS.items():
+        assert sym in sympy.__dict__
+        assert nump in numpy.__dict__
+
+
+def test_scipy_transl():
+    if not scipy:
+        skip("scipy not installed.")
+
+    from sympy.utilities.lambdify import SCIPY_TRANSLATIONS
+    for sym, scip in SCIPY_TRANSLATIONS.items():
+        assert sym in sympy.__dict__
+        assert scip in scipy.__dict__ or scip in scipy.special.__dict__
+
+
+def test_numpy_translation_abs():
+    if not numpy:
+        skip("numpy not installed.")
+
+    f = lambdify(x, Abs(x), "numpy")
+    assert f(-1) == 1
+    assert f(1) == 1
+
+
+def test_numexpr_printer():
+    if not numexpr:
+        skip("numexpr not installed.")
+
+    # if translation/printing is done incorrectly then evaluating
+    # a lambdified numexpr expression will throw an exception
+    from sympy.printing.lambdarepr import NumExprPrinter
+
+    blacklist = ('where', 'complex', 'contains')
+    arg_tuple = (x, y, z) # some functions take more than one argument
+    for sym in NumExprPrinter._numexpr_functions.keys():
+        if sym in blacklist:
+            continue
+        ssym = S(sym)
+        if hasattr(ssym, '_nargs'):
+            nargs = ssym._nargs[0]
+        else:
+            nargs = 1
+        args = arg_tuple[:nargs]
+        f = lambdify(args, ssym(*args), modules='numexpr')
+        assert f(*(1, )*nargs) is not None
+
+
+def test_cmath_sqrt():
+    f = lambdify(x, sqrt(x), "cmath")
+    assert f(0) == 0
+    assert f(1) == 1
+    assert f(4) == 2
+    assert abs(f(2) - 1.414) < 0.001
+    assert f(-1) == 1j
+    assert f(-4) == 2j
+
+
+def test_cmath_log():
+    f = lambdify(x, log(x), "cmath")
+    assert abs(f(1) - 0) < 1e-15
+    assert abs(f(cmath.e) - 1) < 1e-15
+    assert abs(f(-1) - cmath.log(-1)) < 1e-15
+
+
+def test_cmath_sinh():
+    f = lambdify(x, sinh(x), "cmath")
+    assert abs(f(0) - cmath.sinh(0)) < 1e-15
+    assert abs(f(pi) - cmath.sinh(pi)) < 1e-15
+    assert abs(f(-pi) - cmath.sinh(-pi)) < 1e-15
+    assert abs(f(1j) - cmath.sinh(1j)) < 1e-15
+
+
+def test_cmath_cosh():
+    f = lambdify(x, cosh(x), "cmath")
+    assert abs(f(0) - cmath.cosh(0)) < 1e-15
+    assert abs(f(pi) - cmath.cosh(pi)) < 1e-15
+    assert abs(f(-pi) - cmath.cosh(-pi)) < 1e-15
+    assert abs(f(1j) - cmath.cosh(1j)) < 1e-15
+
+
+def test_cmath_tanh():
+    f = lambdify(x, tanh(x), "cmath")
+    assert abs(f(0) - cmath.tanh(0)) < 1e-15
+    assert abs(f(pi) - cmath.tanh(pi)) < 1e-15
+    assert abs(f(-pi) - cmath.tanh(-pi)) < 1e-15
+    assert abs(f(1j) - cmath.tanh(1j)) < 1e-15
+
+
+def test_cmath_sin():
+    f = lambdify(x, sin(x), "cmath")
+    assert abs(f(0) - cmath.sin(0)) < 1e-15
+    assert abs(f(pi) - cmath.sin(pi)) < 1e-15
+    assert abs(f(-pi) - cmath.sin(-pi)) < 1e-15
+    assert abs(f(1j) - cmath.sin(1j)) < 1e-15
+
+
+def test_cmath_cos():
+    f = lambdify(x, cos(x), "cmath")
+    assert abs(f(0) - cmath.cos(0)) < 1e-15
+    assert abs(f(pi) - cmath.cos(pi)) < 1e-15
+    assert abs(f(-pi) - cmath.cos(-pi)) < 1e-15
+    assert abs(f(1j) - cmath.cos(1j)) < 1e-15
+
+
+def test_cmath_tan():
+    f = lambdify(x, tan(x), "cmath")
+    assert abs(f(0) - cmath.tan(0)) < 1e-15
+    assert abs(f(1j) - cmath.tan(1j)) < 1e-15
+
+
+def test_cmath_asin():
+    f = lambdify(x, asin(x), "cmath")
+    assert abs(f(0) - cmath.asin(0)) < 1e-15
+    assert abs(f(1) - cmath.asin(1)) < 1e-15
+    assert abs(f(-1) - cmath.asin(-1)) < 1e-15
+    assert abs(f(2) - cmath.asin(2)) < 1e-15
+    assert abs(f(1j) - cmath.asin(1j)) < 1e-15
+
+
+def test_cmath_acos():
+    f = lambdify(x, acos(x), "cmath")
+    assert abs(f(1) - cmath.acos(1)) < 1e-15
+    assert abs(f(-1) - cmath.acos(-1)) < 1e-15
+    assert abs(f(2) - cmath.acos(2)) < 1e-15
+    assert abs(f(1j) - cmath.acos(1j)) < 1e-15
+
+
+def test_cmath_atan():
+    f = lambdify(x, atan(x), "cmath")
+    assert abs(f(0) - cmath.atan(0)) < 1e-15
+    assert abs(f(1) - cmath.atan(1)) < 1e-15
+    assert abs(f(-1) - cmath.atan(-1)) < 1e-15
+    assert abs(f(2) - cmath.atan(2)) < 1e-15
+    assert abs(f(2j) - cmath.atan(2j)) < 1e-15
+
+
+def test_cmath_asinh():
+    f = lambdify(x, asinh(x), "cmath")
+    assert abs(f(0) - cmath.asinh(0)) < 1e-15
+    assert abs(f(1) - cmath.asinh(1)) < 1e-15
+    assert abs(f(-1) - cmath.asinh(-1)) < 1e-15
+    assert abs(f(2) - cmath.asinh(2)) < 1e-15
+    assert abs(f(2j) - cmath.asinh(2j)) < 1e-15
+
+
+def test_cmath_acosh():
+    f = lambdify(x, acosh(x), "cmath")
+    assert abs(f(1) - cmath.acosh(1)) < 1e-15
+    assert abs(f(2) - cmath.acosh(2)) < 1e-15
+    assert abs(f(-1) - cmath.acosh(-1)) < 1e-15
+    assert abs(f(2j) - cmath.acosh(2j)) < 1e-15
+
+
+def test_cmath_atanh():
+    f = lambdify(x, atanh(x), "cmath")
+    assert abs(f(0) - cmath.atanh(0)) < 1e-15
+    assert abs(f(0.5) - cmath.atanh(0.5)) < 1e-15
+    assert abs(f(-0.5) - cmath.atanh(-0.5)) < 1e-15
+    assert abs(f(2) - cmath.atanh(2)) < 1e-15
+    assert abs(f(-2) - cmath.atanh(-2)) < 1e-15
+    assert abs(f(2j) - cmath.atanh(2j)) < 1e-15
+
+
+def test_cmath_complex_identities():
+    # Define symbol
+    z = symbols('z')
+
+    # Trigonometric identity using re(z) and im(z)
+    expr = cos(z) - cos(re(z)) * cosh(im(z)) + I * sin(re(z)) * sinh(im(z))
+    func = lambdify([z], expr, modules=["cmath", "math"])
+    hpi = math.pi / 2
+    assert abs(func(hpi + 1j * hpi)) < 4e-16
+
+    # Euler's Formula: e^(i*z) = cos(z) + i*sin(z)
+    func = lambdify([z], exp(I * z) - (cos(z) + I * sin(z)), modules=["cmath", "math"])
+    assert abs(func(hpi)) < 4e-16
+
+    # Exponential Identity: e^z = e^(Re(z)) * (cos(Im(z)) + i*sin(Im(z)))
+    func_exp = lambdify([z], exp(z) - exp(re(z)) * (cos(im(z)) + I * sin(im(z))),
+                        modules=["cmath", "math"])
+    assert abs(func_exp(hpi + 1j * hpi)) < 4e-16
+
+    # Complex Cosine Identity: cos(z) = cos(Re(z)) * cosh(Im(z)) - i*sin(Re(z)) * sinh(Im(z))
+    func_cos = lambdify([z], cos(z) - (cos(re(z)) * cosh(im(z)) - I * sin(re(z)) * sinh(im(z))),
+                        modules=["cmath", "math"])
+    assert abs(func_cos(hpi + 1j * hpi)) < 4e-16
+
+    # Complex Sine Identity: sin(z) = sin(Re(z)) * cosh(Im(z)) + i*cos(Re(z)) * sinh(Im(z))
+    func_sin = lambdify([z], sin(z) - (sin(re(z)) * cosh(im(z)) + I * cos(re(z)) * sinh(im(z))),
+                        modules=["cmath", "math"])
+    assert abs(func_sin(hpi + 1j * hpi)) < 4e-16
+
+    # Complex Hyperbolic Cosine Identity: cosh(z) = cosh(Re(z)) * cos(Im(z)) + i*sinh(Re(z)) * sin(Im(z))
+    func_cosh_1 = lambdify([z], cosh(z) - (cosh(re(z)) * cos(im(z)) + I * sinh(re(z)) * sin(im(z))),
+                         modules=["cmath", "math"])
+    assert abs(func_cosh_1(hpi + 1j * hpi)) < 4e-16
+
+    # Complex Hyperbolic Sine Identity: sinh(z) = sinh(Re(z)) * cos(Im(z)) + i*cosh(Re(z)) * sin(Im(z))
+    func_sinh = lambdify([z], sinh(z) - (sinh(re(z)) * cos(im(z)) + I * cosh(re(z)) * sin(im(z))),
+                         modules=["cmath", "math"])
+    assert abs(func_sinh(hpi + 1j * hpi)) < 4e-16
+
+    # cosh(z) = (e^z + e^(-z)) / 2
+    func_cosh_2 = lambdify([z], cosh(z) - (exp(z) + exp(-z)) / 2, modules=["cmath", "math"])
+    assert abs(func_cosh_2(hpi)) < 4e-16
+
+    # Additional expressions testing log and exp with real and imaginary parts
+    expr1 = log(re(z)) + log(im(z)) - log(re(z) * im(z))
+    expr2 = exp(re(z)) * exp(im(z) * I) - exp(z)
+    expr3 = log(exp(re(z))) - re(z)
+    expr4 = exp(log(re(z))) - re(z)
+    expr5 = log(exp(re(z) + im(z))) - (re(z) + im(z))
+    expr6 = exp(log(re(z) + im(z))) - (re(z) + im(z))
+    func1 = lambdify([z], expr1, modules=["cmath", "math"])
+    func2 = lambdify([z], expr2, modules=["cmath", "math"])
+    func3 = lambdify([z], expr3, modules=["cmath", "math"])
+    func4 = lambdify([z], expr4, modules=["cmath", "math"])
+    func5 = lambdify([z], expr5, modules=["cmath", "math"])
+    func6 = lambdify([z], expr6, modules=["cmath", "math"])
+    test_value = 3 + 4j
+    assert abs(func1(test_value)) < 4e-16
+    assert abs(func2(test_value)) < 4e-16
+    assert abs(func3(test_value)) < 4e-16
+    assert abs(func4(test_value)) < 4e-16
+    assert abs(func5(test_value)) < 4e-16
+    assert abs(func6(test_value)) < 4e-16
+
+
+def test_issue_9334():
+    if not numexpr:
+        skip("numexpr not installed.")
+    if not numpy:
+        skip("numpy not installed.")
+    expr = S('b*a - sqrt(a**2)')
+    a, b = sorted(expr.free_symbols, key=lambda s: s.name)
+    func_numexpr = lambdify((a,b), expr, modules=[numexpr], dummify=False)
+    foo, bar = numpy.random.random((2, 4))
+    func_numexpr(foo, bar)
+
+
+def test_issue_12984():
+    if not numexpr:
+        skip("numexpr not installed.")
+    func_numexpr = lambdify((x,y,z), Piecewise((y, x >= 0), (z, x > -1)), numexpr)
+    with ignore_warnings(RuntimeWarning):
+        assert func_numexpr(1, 24, 42) == 24
+        assert str(func_numexpr(-1, 24, 42)) == 'nan'
+
+
+def test_empty_modules():
+    x, y = symbols('x y')
+    expr = -(x % y)
+
+    no_modules = lambdify([x, y], expr)
+    empty_modules = lambdify([x, y], expr, modules=[])
+    assert no_modules(3, 7) == empty_modules(3, 7)
+    assert no_modules(3, 7) == -3
+
+
+def test_exponentiation():
+    f = lambdify(x, x**2)
+    assert f(-1) == 1
+    assert f(0) == 0
+    assert f(1) == 1
+    assert f(-2) == 4
+    assert f(2) == 4
+    assert f(2.5) == 6.25
+
+
+def test_sqrt():
+    f = lambdify(x, sqrt(x))
+    assert f(0) == 0.0
+    assert f(1) == 1.0
+    assert f(4) == 2.0
+    assert abs(f(2) - 1.414) < 0.001
+    assert f(6.25) == 2.5
+
+
+def test_trig():
+    f = lambdify([x], [cos(x), sin(x)], 'math')
+    d = f(pi)
+    prec = 1e-11
+    assert -prec < d[0] + 1 < prec
+    assert -prec < d[1] < prec
+    d = f(3.14159)
+    prec = 1e-5
+    assert -prec < d[0] + 1 < prec
+    assert -prec < d[1] < prec
+
+
+def test_integral():
+    if numpy and not scipy:
+        skip("scipy not installed.")
+    f = Lambda(x, exp(-x**2))
+    l = lambdify(y, Integral(f(x), (x, y, oo)))
+    d = l(-oo)
+    assert 1.77245385 < d < 1.772453851
+
+
+def test_double_integral():
+    if numpy and not scipy:
+        skip("scipy not installed.")
+    # example from http://mpmath.org/doc/current/calculus/integration.html
+    i = Integral(1/(1 - x**2*y**2), (x, 0, 1), (y, 0, z))
+    l = lambdify([z], i)
+    d = l(1)
+    assert 1.23370055 < d < 1.233700551
+
+def test_spherical_bessel():
+    if numpy and not scipy:
+        skip("scipy not installed.")
+    test_point = 4.2 #randomly selected
+    x = symbols("x")
+    jtest = jn(2, x)
+    assert abs(lambdify(x,jtest)(test_point) -
+            jtest.subs(x,test_point).evalf()) < 1e-8
+    ytest = yn(2, x)
+    assert abs(lambdify(x,ytest)(test_point) -
+            ytest.subs(x,test_point).evalf()) < 1e-8
+
+
+#================== Test vectors ===================================
+
+
+def test_vector_simple():
+    f = lambdify((x, y, z), (z, y, x))
+    assert f(3, 2, 1) == (1, 2, 3)
+    assert f(1.0, 2.0, 3.0) == (3.0, 2.0, 1.0)
+    # make sure correct number of args required
+    raises(TypeError, lambda: f(0))
+
+
+def test_vector_discontinuous():
+    f = lambdify(x, (-1/x, 1/x))
+    raises(ZeroDivisionError, lambda: f(0))
+    assert f(1) == (-1.0, 1.0)
+    assert f(2) == (-0.5, 0.5)
+    assert f(-2) == (0.5, -0.5)
+
+
+def test_trig_symbolic():
+    f = lambdify([x], [cos(x), sin(x)], 'math')
+    d = f(pi)
+    assert abs(d[0] + 1) < 0.0001
+    assert abs(d[1] - 0) < 0.0001
+
+
+def test_trig_float():
+    f = lambdify([x], [cos(x), sin(x)])
+    d = f(3.14159)
+    assert abs(d[0] + 1) < 0.0001
+    assert abs(d[1] - 0) < 0.0001
+
+
+def test_docs():
+    f = lambdify(x, x**2)
+    assert f(2) == 4
+    f = lambdify([x, y, z], [z, y, x])
+    assert f(1, 2, 3) == [3, 2, 1]
+    f = lambdify(x, sqrt(x))
+    assert f(4) == 2.0
+    f = lambdify((x, y), sin(x*y)**2)
+    assert f(0, 5) == 0
+
+
+def test_math():
+    f = lambdify((x, y), sin(x), modules="math")
+    assert f(0, 5) == 0
+
+
+def test_sin():
+    f = lambdify(x, sin(x)**2)
+    assert isinstance(f(2), float)
+    f = lambdify(x, sin(x)**2, modules="math")
+    assert isinstance(f(2), float)
+
+
+def test_matrix():
+    A = Matrix([[x, x*y], [sin(z) + 4, x**z]])
+    sol = Matrix([[1, 2], [sin(3) + 4, 1]])
+    f = lambdify((x, y, z), A, modules="sympy")
+    assert f(1, 2, 3) == sol
+    f = lambdify((x, y, z), (A, [A]), modules="sympy")
+    assert f(1, 2, 3) == (sol, [sol])
+    J = Matrix((x, x + y)).jacobian((x, y))
+    v = Matrix((x, y))
+    sol = Matrix([[1, 0], [1, 1]])
+    assert lambdify(v, J, modules='sympy')(1, 2) == sol
+    assert lambdify(v.T, J, modules='sympy')(1, 2) == sol
+
+
+def test_numpy_matrix():
+    if not numpy:
+        skip("numpy not installed.")
+    A = Matrix([[x, x*y], [sin(z) + 4, x**z]])
+    sol_arr = numpy.array([[1, 2], [numpy.sin(3) + 4, 1]])
+    #Lambdify array first, to ensure return to array as default
+    f = lambdify((x, y, z), A, ['numpy'])
+    numpy.testing.assert_allclose(f(1, 2, 3), sol_arr)
+    #Check that the types are arrays and matrices
+    assert isinstance(f(1, 2, 3), numpy.ndarray)
+
+    # gh-15071
+    class dot(Function):
+        pass
+    x_dot_mtx = dot(x, Matrix([[2], [1], [0]]))
+    f_dot1 = lambdify(x, x_dot_mtx)
+    inp = numpy.zeros((17, 3))
+    assert numpy.all(f_dot1(inp) == 0)
+
+    strict_kw = {"allow_unknown_functions": False, "inline": True, "fully_qualified_modules": False}
+    p2 = NumPyPrinter(dict(user_functions={'dot': 'dot'}, **strict_kw))
+    f_dot2 = lambdify(x, x_dot_mtx, printer=p2)
+    assert numpy.all(f_dot2(inp) == 0)
+
+    p3 = NumPyPrinter(strict_kw)
+    # The line below should probably fail upon construction (before calling with "(inp)"):
+    raises(Exception, lambda: lambdify(x, x_dot_mtx, printer=p3)(inp))
+
+
+def test_numpy_transpose():
+    if not numpy:
+        skip("numpy not installed.")
+    A = Matrix([[1, x], [0, 1]])
+    f = lambdify((x), A.T, modules="numpy")
+    numpy.testing.assert_array_equal(f(2), numpy.array([[1, 0], [2, 1]]))
+
+
+def test_numpy_dotproduct():
+    if not numpy:
+        skip("numpy not installed")
+    A = Matrix([x, y, z])
+    f1 = lambdify([x, y, z], DotProduct(A, A), modules='numpy')
+    f2 = lambdify([x, y, z], DotProduct(A, A.T), modules='numpy')
+    f3 = lambdify([x, y, z], DotProduct(A.T, A), modules='numpy')
+    f4 = lambdify([x, y, z], DotProduct(A, A.T), modules='numpy')
+
+    assert f1(1, 2, 3) == \
+           f2(1, 2, 3) == \
+           f3(1, 2, 3) == \
+           f4(1, 2, 3) == \
+           numpy.array([14])
+
+
+def test_numpy_inverse():
+    if not numpy:
+        skip("numpy not installed.")
+    A = Matrix([[1, x], [0, 1]])
+    f = lambdify((x), A**-1, modules="numpy")
+    numpy.testing.assert_array_equal(f(2), numpy.array([[1, -2], [0,  1]]))
+
+
+def test_numpy_old_matrix():
+    if not numpy:
+        skip("numpy not installed.")
+    A = Matrix([[x, x*y], [sin(z) + 4, x**z]])
+    sol_arr = numpy.array([[1, 2], [numpy.sin(3) + 4, 1]])
+    f = lambdify((x, y, z), A, [{'ImmutableDenseMatrix': numpy.matrix}, 'numpy'])
+    with ignore_warnings(PendingDeprecationWarning):
+        numpy.testing.assert_allclose(f(1, 2, 3), sol_arr)
+        assert isinstance(f(1, 2, 3), numpy.matrix)
+
+
+def test_scipy_sparse_matrix():
+    if not scipy:
+        skip("scipy not installed.")
+    A = SparseMatrix([[x, 0], [0, y]])
+    f = lambdify((x, y), A, modules="scipy")
+    B = f(1, 2)
+    assert isinstance(B, scipy.sparse.coo_matrix)
+
+
+def test_python_div_zero_issue_11306():
+    if not numpy:
+        skip("numpy not installed.")
+    p = Piecewise((1 / x, y < -1), (x, y < 1), (1 / x, True))
+    f = lambdify([x, y], p, modules='numpy')
+    with numpy.errstate(divide='ignore'):
+        assert float(f(numpy.array(0), numpy.array(0.5))) == 0
+        assert float(f(numpy.array(0), numpy.array(1))) == float('inf')
+
+
+def test_issue9474():
+    mods = [None, 'math']
+    if numpy:
+        mods.append('numpy')
+    if mpmath:
+        mods.append('mpmath')
+    for mod in mods:
+        f = lambdify(x, S.One/x, modules=mod)
+        assert f(2) == 0.5
+        f = lambdify(x, floor(S.One/x), modules=mod)
+        assert f(2) == 0
+
+    for absfunc, modules in product([Abs, abs], mods):
+        f = lambdify(x, absfunc(x), modules=modules)
+        assert f(-1) == 1
+        assert f(1) == 1
+        assert f(3+4j) == 5
+
+
+def test_issue_9871():
+    if not numexpr:
+        skip("numexpr not installed.")
+    if not numpy:
+        skip("numpy not installed.")
+
+    r = sqrt(x**2 + y**2)
+    expr = diff(1/r, x)
+
+    xn = yn = numpy.linspace(1, 10, 16)
+    # expr(xn, xn) = -xn/(sqrt(2)*xn)^3
+    fv_exact = -numpy.sqrt(2.)**-3 * xn**-2
+
+    fv_numpy = lambdify((x, y), expr, modules='numpy')(xn, yn)
+    fv_numexpr = lambdify((x, y), expr, modules='numexpr')(xn, yn)
+    numpy.testing.assert_allclose(fv_numpy, fv_exact, rtol=1e-10)
+    numpy.testing.assert_allclose(fv_numexpr, fv_exact, rtol=1e-10)
+
+
+def test_numpy_piecewise():
+    if not numpy:
+        skip("numpy not installed.")
+    pieces = Piecewise((x, x < 3), (x**2, x > 5), (0, True))
+    f = lambdify(x, pieces, modules="numpy")
+    numpy.testing.assert_array_equal(f(numpy.arange(10)),
+                                     numpy.array([0, 1, 2, 0, 0, 0, 36, 49, 64, 81]))
+    # If we evaluate somewhere all conditions are False, we should get back NaN
+    nodef_func = lambdify(x, Piecewise((x, x > 0), (-x, x < 0)))
+    numpy.testing.assert_array_equal(nodef_func(numpy.array([-1, 0, 1])),
+                                     numpy.array([1, numpy.nan, 1]))
+
+
+def test_numpy_logical_ops():
+    if not numpy:
+        skip("numpy not installed.")
+    and_func = lambdify((x, y), And(x, y), modules="numpy")
+    and_func_3 = lambdify((x, y, z), And(x, y, z), modules="numpy")
+    or_func = lambdify((x, y), Or(x, y), modules="numpy")
+    or_func_3 = lambdify((x, y, z), Or(x, y, z), modules="numpy")
+    not_func = lambdify((x), Not(x), modules="numpy")
+    arr1 = numpy.array([True, True])
+    arr2 = numpy.array([False, True])
+    arr3 = numpy.array([True, False])
+    numpy.testing.assert_array_equal(and_func(arr1, arr2), numpy.array([False, True]))
+    numpy.testing.assert_array_equal(and_func_3(arr1, arr2, arr3), numpy.array([False, False]))
+    numpy.testing.assert_array_equal(or_func(arr1, arr2), numpy.array([True, True]))
+    numpy.testing.assert_array_equal(or_func_3(arr1, arr2, arr3), numpy.array([True, True]))
+    numpy.testing.assert_array_equal(not_func(arr2), numpy.array([True, False]))
+
+
+def test_numpy_matmul():
+    if not numpy:
+        skip("numpy not installed.")
+    xmat = Matrix([[x, y], [z, 1+z]])
+    ymat = Matrix([[x**2], [Abs(x)]])
+    mat_func = lambdify((x, y, z), xmat*ymat, modules="numpy")
+    numpy.testing.assert_array_equal(mat_func(0.5, 3, 4), numpy.array([[1.625], [3.5]]))
+    numpy.testing.assert_array_equal(mat_func(-0.5, 3, 4), numpy.array([[1.375], [3.5]]))
+    # Multiple matrices chained together in multiplication
+    f = lambdify((x, y, z), xmat*xmat*xmat, modules="numpy")
+    numpy.testing.assert_array_equal(f(0.5, 3, 4), numpy.array([[72.125, 119.25],
+                                                                [159, 251]]))
+
+
+def test_numpy_numexpr():
+    if not numpy:
+        skip("numpy not installed.")
+    if not numexpr:
+        skip("numexpr not installed.")
+    a, b, c = numpy.random.randn(3, 128, 128)
+    # ensure that numpy and numexpr return same value for complicated expression
+    expr = sin(x) + cos(y) + tan(z)**2 + Abs(z-y)*acos(sin(y*z)) + \
+           Abs(y-z)*acosh(2+exp(y-x))- sqrt(x**2+I*y**2)
+    npfunc = lambdify((x, y, z), expr, modules='numpy')
+    nefunc = lambdify((x, y, z), expr, modules='numexpr')
+    assert numpy.allclose(npfunc(a, b, c), nefunc(a, b, c))
+
+
+def test_numexpr_userfunctions():
+    if not numpy:
+        skip("numpy not installed.")
+    if not numexpr:
+        skip("numexpr not installed.")
+    a, b = numpy.random.randn(2, 10)
+    uf = type('uf', (Function, ),
+              {'eval' : classmethod(lambda x, y : y**2+1)})
+    func = lambdify(x, 1-uf(x), modules='numexpr')
+    assert numpy.allclose(func(a), -(a**2))
+
+    uf = implemented_function(Function('uf'), lambda x, y : 2*x*y+1)
+    func = lambdify((x, y), uf(x, y), modules='numexpr')
+    assert numpy.allclose(func(a, b), 2*a*b+1)
+
+
+def test_tensorflow_basic_math():
+    if not tensorflow:
+        skip("tensorflow not installed.")
+    expr = Max(sin(x), Abs(1/(x+2)))
+    func = lambdify(x, expr, modules="tensorflow")
+
+    with tensorflow.compat.v1.Session() as s:
+        a = tensorflow.constant(0, dtype=tensorflow.float32)
+        assert func(a).eval(session=s) == 0.5
+
+
+def test_tensorflow_placeholders():
+    if not tensorflow:
+        skip("tensorflow not installed.")
+    expr = Max(sin(x), Abs(1/(x+2)))
+    func = lambdify(x, expr, modules="tensorflow")
+
+    with tensorflow.compat.v1.Session() as s:
+        a = tensorflow.compat.v1.placeholder(dtype=tensorflow.float32)
+        assert func(a).eval(session=s, feed_dict={a: 0}) == 0.5
+
+
+def test_tensorflow_variables():
+    if not tensorflow:
+        skip("tensorflow not installed.")
+    expr = Max(sin(x), Abs(1/(x+2)))
+    func = lambdify(x, expr, modules="tensorflow")
+
+    with tensorflow.compat.v1.Session() as s:
+        a = tensorflow.Variable(0, dtype=tensorflow.float32)
+        s.run(a.initializer)
+        assert func(a).eval(session=s, feed_dict={a: 0}) == 0.5
+
+
+def test_tensorflow_logical_operations():
+    if not tensorflow:
+        skip("tensorflow not installed.")
+    expr = Not(And(Or(x, y), y))
+    func = lambdify([x, y], expr, modules="tensorflow")
+
+    with tensorflow.compat.v1.Session() as s:
+        assert func(False, True).eval(session=s) == False
+
+
+def test_tensorflow_piecewise():
+    if not tensorflow:
+        skip("tensorflow not installed.")
+    expr = Piecewise((0, Eq(x,0)), (-1, x < 0), (1, x > 0))
+    func = lambdify(x, expr, modules="tensorflow")
+
+    with tensorflow.compat.v1.Session() as s:
+        assert func(-1).eval(session=s) == -1
+        assert func(0).eval(session=s) == 0
+        assert func(1).eval(session=s) == 1
+
+
+def test_tensorflow_multi_max():
+    if not tensorflow:
+        skip("tensorflow not installed.")
+    expr = Max(x, -x, x**2)
+    func = lambdify(x, expr, modules="tensorflow")
+
+    with tensorflow.compat.v1.Session() as s:
+        assert func(-2).eval(session=s) == 4
+
+
+def test_tensorflow_multi_min():
+    if not tensorflow:
+        skip("tensorflow not installed.")
+    expr = Min(x, -x, x**2)
+    func = lambdify(x, expr, modules="tensorflow")
+
+    with tensorflow.compat.v1.Session() as s:
+        assert func(-2).eval(session=s) == -2
+
+
+def test_tensorflow_relational():
+    if not tensorflow:
+        skip("tensorflow not installed.")
+    expr = x >= 0
+    func = lambdify(x, expr, modules="tensorflow")
+
+    with tensorflow.compat.v1.Session() as s:
+        assert func(1).eval(session=s) == True
+
+
+def test_tensorflow_complexes():
+    if not tensorflow:
+        skip("tensorflow not installed")
+
+    func1 = lambdify(x, re(x), modules="tensorflow")
+    func2 = lambdify(x, im(x), modules="tensorflow")
+    func3 = lambdify(x, Abs(x), modules="tensorflow")
+    func4 = lambdify(x, arg(x), modules="tensorflow")
+
+    with tensorflow.compat.v1.Session() as s:
+        # For versions before
+        # https://github.com/tensorflow/tensorflow/issues/30029
+        # resolved, using Python numeric types may not work
+        a = tensorflow.constant(1+2j)
+        assert func1(a).eval(session=s) == 1
+        assert func2(a).eval(session=s) == 2
+
+        tensorflow_result = func3(a).eval(session=s)
+        sympy_result = Abs(1 + 2j).evalf()
+        assert abs(tensorflow_result-sympy_result) < 10**-6
+
+        tensorflow_result = func4(a).eval(session=s)
+        sympy_result = arg(1 + 2j).evalf()
+        assert abs(tensorflow_result-sympy_result) < 10**-6
+
+
+def test_tensorflow_array_arg():
+    # Test for issue 14655 (tensorflow part)
+    if not tensorflow:
+        skip("tensorflow not installed.")
+
+    f = lambdify([[x, y]], x*x + y, 'tensorflow')
+
+    with tensorflow.compat.v1.Session() as s:
+        fcall = f(tensorflow.constant([2.0, 1.0]))
+        assert fcall.eval(session=s) == 5.0
+
+
+#================== Test symbolic ==================================
+
+
+def test_sym_single_arg():
+    f = lambdify(x, x * y)
+    assert f(z) == z * y
+
+
+def test_sym_list_args():
+    f = lambdify([x, y], x + y + z)
+    assert f(1, 2) == 3 + z
+
+
+def test_sym_integral():
+    f = Lambda(x, exp(-x**2))
+    l = lambdify(x, Integral(f(x), (x, -oo, oo)), modules="sympy")
+    assert l(y) == Integral(exp(-y**2), (y, -oo, oo))
+    assert l(y).doit() == sqrt(pi)
+
+
+def test_namespace_order():
+    # lambdify had a bug, such that module dictionaries or cached module
+    # dictionaries would pull earlier namespaces into themselves.
+    # Because the module dictionaries form the namespace of the
+    # generated lambda, this meant that the behavior of a previously
+    # generated lambda function could change as a result of later calls
+    # to lambdify.
+    n1 = {'f': lambda x: 'first f'}
+    n2 = {'f': lambda x: 'second f',
+          'g': lambda x: 'function g'}
+    f = sympy.Function('f')
+    g = sympy.Function('g')
+    if1 = lambdify(x, f(x), modules=(n1, "sympy"))
+    assert if1(1) == 'first f'
+    if2 = lambdify(x, g(x), modules=(n2, "sympy"))
+    # previously gave 'second f'
+    assert if1(1) == 'first f'
+
+    assert if2(1) == 'function g'
+
+
+def test_imps():
+    # Here we check if the default returned functions are anonymous - in
+    # the sense that we can have more than one function with the same name
+    f = implemented_function('f', lambda x: 2*x)
+    g = implemented_function('f', lambda x: math.sqrt(x))
+    l1 = lambdify(x, f(x))
+    l2 = lambdify(x, g(x))
+    assert str(f(x)) == str(g(x))
+    assert l1(3) == 6
+    assert l2(3) == math.sqrt(3)
+    # check that we can pass in a Function as input
+    func = sympy.Function('myfunc')
+    assert not hasattr(func, '_imp_')
+    my_f = implemented_function(func, lambda x: 2*x)
+    assert hasattr(my_f, '_imp_')
+    # Error for functions with same name and different implementation
+    f2 = implemented_function("f", lambda x: x + 101)
+    raises(ValueError, lambda: lambdify(x, f(f2(x))))
+
+
+def test_imps_errors():
+    # Test errors that implemented functions can return, and still be able to
+    # form expressions.
+    # See: https://github.com/sympy/sympy/issues/10810
+    #
+    # XXX: Removed AttributeError here. This test was added due to issue 10810
+    # but that issue was about ValueError. It doesn't seem reasonable to
+    # "support" catching AttributeError in the same context...
+    for val, error_class in product((0, 0., 2, 2.0), (TypeError, ValueError)):
+
+        def myfunc(a):
+            if a == 0:
+                raise error_class
+            return 1
+
+        f = implemented_function('f', myfunc)
+        expr = f(val)
+        assert expr == f(val)
+
+
+def test_imps_wrong_args():
+    raises(ValueError, lambda: implemented_function(sin, lambda x: x))
+
+
+def test_lambdify_imps():
+    # Test lambdify with implemented functions
+    # first test basic (sympy) lambdify
+    f = sympy.cos
+    assert lambdify(x, f(x))(0) == 1
+    assert lambdify(x, 1 + f(x))(0) == 2
+    assert lambdify((x, y), y + f(x))(0, 1) == 2
+    # make an implemented function and test
+    f = implemented_function("f", lambda x: x + 100)
+    assert lambdify(x, f(x))(0) == 100
+    assert lambdify(x, 1 + f(x))(0) == 101
+    assert lambdify((x, y), y + f(x))(0, 1) == 101
+    # Can also handle tuples, lists, dicts as expressions
+    lam = lambdify(x, (f(x), x))
+    assert lam(3) == (103, 3)
+    lam = lambdify(x, [f(x), x])
+    assert lam(3) == [103, 3]
+    lam = lambdify(x, [f(x), (f(x), x)])
+    assert lam(3) == [103, (103, 3)]
+    lam = lambdify(x, {f(x): x})
+    assert lam(3) == {103: 3}
+    lam = lambdify(x, {f(x): x})
+    assert lam(3) == {103: 3}
+    lam = lambdify(x, {x: f(x)})
+    assert lam(3) == {3: 103}
+    # Check that imp preferred to other namespaces by default
+    d = {'f': lambda x: x + 99}
+    lam = lambdify(x, f(x), d)
+    assert lam(3) == 103
+    # Unless flag passed
+    lam = lambdify(x, f(x), d, use_imps=False)
+    assert lam(3) == 102
+
+
+def test_dummification():
+    t = symbols('t')
+    F = Function('F')
+    G = Function('G')
+    #"\alpha" is not a valid Python variable name
+    #lambdify should sub in a dummy for it, and return
+    #without a syntax error
+    alpha = symbols(r'\alpha')
+    some_expr = 2 * F(t)**2 / G(t)
+    lam = lambdify((F(t), G(t)), some_expr)
+    assert lam(3, 9) == 2
+    lam = lambdify(sin(t), 2 * sin(t)**2)
+    assert lam(F(t)) == 2 * F(t)**2
+    #Test that \alpha was properly dummified
+    lam = lambdify((alpha, t), 2*alpha + t)
+    assert lam(2, 1) == 5
+    raises(SyntaxError, lambda: lambdify(F(t) * G(t), F(t) * G(t) + 5))
+    raises(SyntaxError, lambda: lambdify(2 * F(t), 2 * F(t) + 5))
+    raises(SyntaxError, lambda: lambdify(2 * F(t), 4 * F(t) + 5))
+
+
+def test_lambdify__arguments_with_invalid_python_identifiers():
+    # see sympy/sympy#26690
+    N = CoordSys3D('N')
+    xn, yn, zn = N.base_scalars()
+    expr = xn + yn
+    f = lambdify([xn, yn], expr)
+    res = f(0.2, 0.3)
+    ref = 0.2 + 0.3
+    assert abs(res-ref) < 1e-15
+
+
+def test_curly_matrix_symbol():
+    # Issue #15009
+    curlyv = sympy.MatrixSymbol("{v}", 2, 1)
+    lam = lambdify(curlyv, curlyv)
+    assert lam(1)==1
+    lam = lambdify(curlyv, curlyv, dummify=True)
+    assert lam(1)==1
+
+
+def test_python_keywords():
+    # Test for issue 7452. The automatic dummification should ensure use of
+    # Python reserved keywords as symbol names will create valid lambda
+    # functions. This is an additional regression test.
+    python_if = symbols('if')
+    expr = python_if / 2
+    f = lambdify(python_if, expr)
+    assert f(4.0) == 2.0
+
+
+def test_lambdify_docstring():
+    func = lambdify((w, x, y, z), w + x + y + z)
+    ref = (
+        "Created with lambdify. Signature:\n\n"
+        "func(w, x, y, z)\n\n"
+        "Expression:\n\n"
+        "w + x + y + z"
+    ).splitlines()
+    assert func.__doc__.splitlines()[:len(ref)] == ref
+    syms = symbols('a1:26')
+    func = lambdify(syms, sum(syms))
+    ref = (
+        "Created with lambdify. Signature:\n\n"
+        "func(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15,\n"
+        "        a16, a17, a18, a19, a20, a21, a22, a23, a24, a25)\n\n"
+        "Expression:\n\n"
+        "a1 + a10 + a11 + a12 + a13 + a14 + a15 + a16 + a17 + a18 + a19 + a2 + a20 +..."
+    ).splitlines()
+    assert func.__doc__.splitlines()[:len(ref)] == ref
+
+
+def test_lambdify_linecache():
+    func = lambdify(x, x + 1)
+    source = 'def _lambdifygenerated(x):\n    return x + 1\n'
+    assert inspect.getsource(func) == source
+    filename = inspect.getsourcefile(func)
+    assert filename.startswith('<lambdifygenerated-')
+    assert filename in linecache.cache
+    assert linecache.cache[filename] == (len(source), None, source.splitlines(True), filename)
+    del func
+    gc.collect()
+    assert filename not in linecache.cache
+
+#================== Test special printers ==========================
+
+
+def test_special_printers():
+    from sympy.printing.lambdarepr import IntervalPrinter
+
+    def intervalrepr(expr):
+        return IntervalPrinter().doprint(expr)
+
+    expr = sqrt(sqrt(2) + sqrt(3)) + S.Half
+
+    func0 = lambdify((), expr, modules="mpmath", printer=intervalrepr)
+    func1 = lambdify((), expr, modules="mpmath", printer=IntervalPrinter)
+    func2 = lambdify((), expr, modules="mpmath", printer=IntervalPrinter())
+
+    mpi = type(mpmath.mpi(1, 2))
+
+    assert isinstance(func0(), mpi)
+    assert isinstance(func1(), mpi)
+    assert isinstance(func2(), mpi)
+
+    # To check Is lambdify loggamma works for mpmath or not
+    exp1 = lambdify(x, loggamma(x), 'mpmath')(5)
+    exp2 = lambdify(x, loggamma(x), 'mpmath')(1.8)
+    exp3 = lambdify(x, loggamma(x), 'mpmath')(15)
+    exp_ls = [exp1, exp2, exp3]
+
+    sol1 = mpmath.loggamma(5)
+    sol2 = mpmath.loggamma(1.8)
+    sol3 = mpmath.loggamma(15)
+    sol_ls = [sol1, sol2, sol3]
+
+    assert exp_ls == sol_ls
+
+
+def test_true_false():
+    # We want exact is comparison here, not just ==
+    assert lambdify([], true)() is True
+    assert lambdify([], false)() is False
+
+
+def test_issue_2790():
+    assert lambdify((x, (y, z)), x + y)(1, (2, 4)) == 3
+    assert lambdify((x, (y, (w, z))), w + x + y + z)(1, (2, (3, 4))) == 10
+    assert lambdify(x, x + 1, dummify=False)(1) == 2
+
+
+def test_issue_12092():
+    f = implemented_function('f', lambda x: x**2)
+    assert f(f(2)).evalf() == Float(16)
+
+
+def test_issue_14911():
+    class Variable(sympy.Symbol):
+        def _sympystr(self, printer):
+            return printer.doprint(self.name)
+
+        _lambdacode = _sympystr
+        _numpycode = _sympystr
+
+    x = Variable('x')
+    y = 2 * x
+    code = LambdaPrinter().doprint(y)
+    assert code.replace(' ', '') == '2*x'
+
+
+def test_ITE():
+    assert lambdify((x, y, z), ITE(x, y, z))(True, 5, 3) == 5
+    assert lambdify((x, y, z), ITE(x, y, z))(False, 5, 3) == 3
+
+
+def test_Min_Max():
+    # see gh-10375
+    assert lambdify((x, y, z), Min(x, y, z))(1, 2, 3) == 1
+    assert lambdify((x, y, z), Max(x, y, z))(1, 2, 3) == 3
+
+
+def test_amin_amax_minimum_maximum():
+    if not numpy:
+        skip("numpy not installed")
+
+    a234 = numpy.array([2, 3, 4])
+    a152 = numpy.array([1, 5, 2])
+
+    a254 = numpy.array([2, 5, 4])
+    a132 = numpy.array([1, 3, 2])
+    # 2 args
+    assert numpy.all(lambdify((x, y), maximum(x, y))(a234, a152) == a254)
+    assert numpy.all(lambdify((x, y), minimum(x, y))(a234, a152) == a132)
+
+    # 3 args
+    assert numpy.all(lambdify((x, y, z), maximum(x, y, z))(a234, a152, a234) == a254)
+    assert numpy.all(lambdify((x, y, z), minimum(x, y, z))(a234, a152, a234) == a132)
+
+    # 1 arg
+    assert numpy.all(lambdify((x,), maximum(x))(a234) == a234)
+    assert numpy.all(lambdify((x,), minimum(x))(a234) == a234)
+
+    # 4 args, mixed length
+    assert numpy.all(lambdify((x, y, z, w), maximum(x, y, z, w))(a234, a152, a234, 3) == [3, 5, 4])
+    assert numpy.all(lambdify((x, y, z, w), minimum(x, y, z, w))(a234, a152, a234, 2) == [1, 2, 2])
+
+    # amin & amax
+    assert lambdify((x, y), [amin(x), amax(y)])(a234, a152) == [2, 5]
+    A = numpy.array([
+        [0, 4, 8],
+        [1, 5, 9],
+        [2, 6, 10],
+    ])
+    min_, max_ = lambdify((x,), [amin(x, axis=0), amax(x, axis=1)])(A)
+    assert numpy.all(min_ == numpy.amin(A, axis=0))
+    assert numpy.all(max_ == numpy.amax(A, axis=1))
+
+    # see gh-25659
+    assert numpy.all(lambdify((x, y), Max(x, y))([1, 2, 3], [3, 2, 1]) == [3, 2, 3])
+    assert numpy.all(lambdify((x), Min(2, x))([1, 2, 3]) == [1, 2, 2])
+
+
+
+def test_Indexed():
+    # Issue #10934
+    if not numpy:
+        skip("numpy not installed")
+
+    a = IndexedBase('a')
+    i, j = symbols('i j')
+    b = numpy.array([[1, 2], [3, 4]])
+    assert lambdify(a, Sum(a[x, y], (x, 0, 1), (y, 0, 1)))(b) == 10
+
+def test_Sum():
+    e = Sum(z, (y, 0, x), (x, 0, 10))
+    ref = 66*z
+    assert e.doit() == ref
+    assert lambdify([z], e)(7) == ref.subs(z, 7)
+
+def test_Idx():
+    # Issue 26888
+    a = IndexedBase('a')
+    i = Idx('i')
+    b = [1,2,3]
+    assert lambdify([a, i], a[i])(b, 2) == 3
+
+
+def test_issue_12173():
+    #test for issue 12173
+    expr1 = lambdify((x, y), uppergamma(x, y),"mpmath")(1, 2)
+    expr2 = lambdify((x, y), lowergamma(x, y),"mpmath")(1, 2)
+    assert expr1 == uppergamma(1, 2).evalf()
+    assert expr2 == lowergamma(1, 2).evalf()
+
+
+def test_issue_13642():
+    if not numpy:
+        skip("numpy not installed")
+    f = lambdify(x, sinc(x))
+    assert Abs(f(1) - sinc(1)).n() < 1e-15
+
+
+def test_sinc_mpmath():
+    f = lambdify(x, sinc(x), "mpmath")
+    assert Abs(f(1) - sinc(1)).n() < 1e-15
+
+
+def test_lambdify_dummy_arg():
+    d1 = Dummy()
+    f1 = lambdify(d1, d1 + 1, dummify=False)
+    assert f1(2) == 3
+    f1b = lambdify(d1, d1 + 1)
+    assert f1b(2) == 3
+    d2 = Dummy('x')
+    f2 = lambdify(d2, d2 + 1)
+    assert f2(2) == 3
+    f3 = lambdify([[d2]], d2 + 1)
+    assert f3([2]) == 3
+
+
+def test_lambdify_mixed_symbol_dummy_args():
+    d = Dummy()
+    # Contrived example of name clash
+    dsym = symbols(str(d))
+    f = lambdify([d, dsym], d - dsym)
+    assert f(4, 1) == 3
+
+
+def test_numpy_array_arg():
+    # Test for issue 14655 (numpy part)
+    if not numpy:
+        skip("numpy not installed")
+
+    f = lambdify([[x, y]], x*x + y, 'numpy')
+
+    assert f(numpy.array([2.0, 1.0])) == 5
+
+
+def test_scipy_fns():
+    if not scipy:
+        skip("scipy not installed")
+
+    single_arg_sympy_fns = [Ei, erf, erfc, factorial, gamma, loggamma, digamma, Si, Ci]
+    single_arg_scipy_fns = [scipy.special.expi, scipy.special.erf, scipy.special.erfc,
+        scipy.special.factorial, scipy.special.gamma, scipy.special.gammaln,
+                            scipy.special.psi, scipy.special.sici, scipy.special.sici]
+    numpy.random.seed(0)
+    for (sympy_fn, scipy_fn) in zip(single_arg_sympy_fns, single_arg_scipy_fns):
+        f = lambdify(x, sympy_fn(x), modules="scipy")
+        for i in range(20):
+            tv = numpy.random.uniform(-10, 10) + 1j*numpy.random.uniform(-5, 5)
+            # SciPy thinks that factorial(z) is 0 when re(z) < 0 and
+            # does not support complex numbers.
+            # SymPy does not think so.
+            if sympy_fn == factorial:
+                tv = numpy.abs(tv)
+            # SciPy supports gammaln for real arguments only,
+            # and there is also a branch cut along the negative real axis
+            if sympy_fn == loggamma:
+                tv = numpy.abs(tv)
+            # SymPy's digamma evaluates as polygamma(0, z)
+            # which SciPy supports for real arguments only
+            if sympy_fn == digamma:
+                tv = numpy.real(tv)
+            sympy_result = sympy_fn(tv).evalf()
+            scipy_result = scipy_fn(tv)
+            # SciPy's sici returns a tuple with both Si and Ci present in it
+            # which needs to be unpacked
+            if sympy_fn == Si:
+                scipy_result = scipy_fn(tv)[0]
+            if sympy_fn == Ci:
+                scipy_result = scipy_fn(tv)[1]
+            assert abs(f(tv) - sympy_result) < 1e-13*(1 + abs(sympy_result))
+            assert abs(f(tv) - scipy_result) < 1e-13*(1 + abs(sympy_result))
+
+    double_arg_sympy_fns = [RisingFactorial, besselj, bessely, besseli,
+                            besselk, polygamma]
+    double_arg_scipy_fns = [scipy.special.poch, scipy.special.jv,
+                            scipy.special.yv, scipy.special.iv, scipy.special.kv, scipy.special.polygamma]
+    for (sympy_fn, scipy_fn) in zip(double_arg_sympy_fns, double_arg_scipy_fns):
+        f = lambdify((x, y), sympy_fn(x, y), modules="scipy")
+        for i in range(20):
+            # SciPy supports only real orders of Bessel functions
+            tv1 = numpy.random.uniform(-10, 10)
+            tv2 = numpy.random.uniform(-10, 10) + 1j*numpy.random.uniform(-5, 5)
+            # SciPy requires a real valued 2nd argument for: poch, polygamma
+            if sympy_fn in (RisingFactorial, polygamma):
+                tv2 = numpy.real(tv2)
+            if sympy_fn == polygamma:
+                tv1 = abs(int(tv1))  # first argument to polygamma must be a non-negative integer.
+            sympy_result = sympy_fn(tv1, tv2).evalf()
+            assert abs(f(tv1, tv2) - sympy_result) < 1e-13*(1 + abs(sympy_result))
+            assert abs(f(tv1, tv2) - scipy_fn(tv1, tv2)) < 1e-13*(1 + abs(sympy_result))
+
+
+def test_scipy_polys():
+    if not scipy:
+        skip("scipy not installed")
+    numpy.random.seed(0)
+
+    params = symbols('n k a b')
+    # list polynomials with the number of parameters
+    polys = [
+        (chebyshevt, 1),
+        (chebyshevu, 1),
+        (legendre, 1),
+        (hermite, 1),
+        (laguerre, 1),
+        (gegenbauer, 2),
+        (assoc_legendre, 2),
+        (assoc_laguerre, 2),
+        (jacobi, 3)
+    ]
+
+    msg = \
+        "The random test of the function {func} with the arguments " \
+        "{args} had failed because the SymPy result {sympy_result} " \
+        "and SciPy result {scipy_result} had failed to converge " \
+        "within the tolerance {tol} " \
+        "(Actual absolute difference : {diff})"
+
+    for sympy_fn, num_params in polys:
+        args = params[:num_params] + (x,)
+        f = lambdify(args, sympy_fn(*args))
+        for _ in range(10):
+            tn = numpy.random.randint(3, 10)
+            tparams = tuple(numpy.random.uniform(0, 5, size=num_params-1))
+            tv = numpy.random.uniform(-10, 10) + 1j*numpy.random.uniform(-5, 5)
+            # SciPy supports hermite for real arguments only
+            if sympy_fn == hermite:
+                tv = numpy.real(tv)
+            # assoc_legendre needs x in (-1, 1) and integer param at most n
+            if sympy_fn == assoc_legendre:
+                tv = numpy.random.uniform(-1, 1)
+                tparams = tuple(numpy.random.randint(1, tn, size=1))
+
+            vals = (tn,) + tparams + (tv,)
+            scipy_result = f(*vals)
+            sympy_result = sympy_fn(*vals).evalf()
+            atol = 1e-9*(1 + abs(sympy_result))
+            diff = abs(scipy_result - sympy_result)
+            try:
+                assert diff < atol
+            except TypeError:
+                raise AssertionError(
+                    msg.format(
+                        func=repr(sympy_fn),
+                        args=repr(vals),
+                        sympy_result=repr(sympy_result),
+                        scipy_result=repr(scipy_result),
+                        diff=diff,
+                        tol=atol)
+                    )
+
+
+def test_lambdify_inspect():
+    f = lambdify(x, x**2)
+    # Test that inspect.getsource works but don't hard-code implementation
+    # details
+    assert 'x**2' in inspect.getsource(f)
+
+
+def test_issue_14941():
+    x, y = Dummy(), Dummy()
+
+    # test dict
+    f1 = lambdify([x, y], {x: 3, y: 3}, 'sympy')
+    assert f1(2, 3) == {2: 3, 3: 3}
+
+    # test tuple
+    f2 = lambdify([x, y], (y, x), 'sympy')
+    assert f2(2, 3) == (3, 2)
+    f2b = lambdify([], (1,))  # gh-23224
+    assert f2b() == (1,)
+
+    # test list
+    f3 = lambdify([x, y], [y, x], 'sympy')
+    assert f3(2, 3) == [3, 2]
+
+
+def test_lambdify_Derivative_arg_issue_16468():
+    f = Function('f')(x)
+    fx = f.diff()
+    assert lambdify((f, fx), f + fx)(10, 5) == 15
+    assert eval(lambdastr((f, fx), f/fx))(10, 5) == 2
+    raises(Exception, lambda:
+        eval(lambdastr((f, fx), f/fx, dummify=False)))
+    assert eval(lambdastr((f, fx), f/fx, dummify=True))(10, 5) == 2
+    assert eval(lambdastr((fx, f), f/fx, dummify=True))(S(10), 5) == S.Half
+    assert lambdify(fx, 1 + fx)(41) == 42
+    assert eval(lambdastr(fx, 1 + fx, dummify=True))(41) == 42
+
+
+def test_lambdify_Derivative_zeta():
+    # This is related to gh-11802 (and to lesser extent gh-26663)
+    expr1 = zeta(x).diff(x, evaluate=False)
+    f1 = lambdify(x, expr1, modules=['mpmath'])
+    ans1 = f1(2)
+    ref1 = (zeta(2+1e-8).evalf()-zeta(2).evalf())/1e-8
+    assert abs(ans1 - ref1)/abs(ref1) < 1e-7
+
+    expr2 = zeta(x**2).diff(x)
+    f2 = lambdify(x, expr2, modules=['mpmath'])
+    ans2 = f2(2**0.5)
+    ref2 = 2*2**0.5*ref1
+    assert abs(ans2-ref2)/abs(ref2) < 1e-7
+
+
+def test_lambdify_Derivative_custom_printer():
+    func1 = Function('func1')
+    func2 = Function('func2')
+
+    class MyPrinter(NumPyPrinter):
+
+        def _print_Derivative_func1(self, args, seq_orders):
+            arg, = args
+            order, = seq_orders
+            return '42'
+
+    expr1 = func1(x).diff(x)
+    raises(PrintMethodNotImplementedError, lambda: lambdify([x], expr1))
+    f1 = lambdify([x], expr1, printer=MyPrinter)
+    assert f1(7) == 42
+
+    expr2 = func2(x).diff(x)
+    raises(PrintMethodNotImplementedError, lambda: lambdify([x], expr2, printer=MyPrinter))
+
+
+def test_lambdify_derivative_and_functions_as_arguments():
+    # see: https://github.com/sympy/sympy/issues/26663#issuecomment-2157179517
+    t, a, b = symbols('t, a, b')
+    f = Function('f')(t)
+    args = f.diff(t, 2), f.diff(t), f, a, b
+    expr1 = a*f.diff(t, 2) + b*f.diff(t) + a*b*f + a**2
+    num_args = 2.0, 3.0, 4.0, 5.0, 6.0
+    ref1 = 5*2 + 6*3 + 5*6*4 + 5**2
+
+    expr2 = a*f.diff(t, 2) + b*f.diff(t) - a*b*f + b**2 - a**2
+    ref2 = 5*2 + 6*3 - 5*6*4 + 6**2 - 5**2
+
+    for dummify, _cse in product([False, None, True], [False, True]):
+        func1 = lambdify(args, expr1, cse=_cse, dummify=dummify)
+        res1 = func1(*num_args)
+        assert abs(res1 - ref1) < 1e-12
+
+        func12 = lambdify(args, [expr1, expr2], cse=_cse, dummify=dummify)
+        res12 = func12(*num_args)
+        assert len(res12) == 2
+        assert abs(res12[0] - ref1) < 1e-12
+        assert abs(res12[1] - ref2) < 1e-12
+
+
+def test_imag_real():
+    f_re = lambdify([z], sympy.re(z))
+    val = 3+2j
+    assert f_re(val) == val.real
+
+    f_im = lambdify([z], sympy.im(z))  # see #15400
+    assert f_im(val) == val.imag
+
+
+def test_MatrixSymbol_issue_15578():
+    if not numpy:
+        skip("numpy not installed")
+    A = MatrixSymbol('A', 2, 2)
+    A0 = numpy.array([[1, 2], [3, 4]])
+    f = lambdify(A, A**(-1))
+    assert numpy.allclose(f(A0), numpy.array([[-2., 1.], [1.5, -0.5]]))
+    g = lambdify(A, A**3)
+    assert numpy.allclose(g(A0), numpy.array([[37, 54], [81, 118]]))
+
+
+def test_issue_15654():
+    if not scipy:
+        skip("scipy not installed")
+    from sympy.abc import n, l, r, Z
+    from sympy.physics import hydrogen
+    nv, lv, rv, Zv = 1, 0, 3, 1
+    sympy_value = hydrogen.R_nl(nv, lv, rv, Zv).evalf()
+    f = lambdify((n, l, r, Z), hydrogen.R_nl(n, l, r, Z))
+    scipy_value = f(nv, lv, rv, Zv)
+    assert abs(sympy_value - scipy_value) < 1e-15
+
+
+def test_issue_15827():
+    if not numpy:
+        skip("numpy not installed")
+    A = MatrixSymbol("A", 3, 3)
+    B = MatrixSymbol("B", 2, 3)
+    C = MatrixSymbol("C", 3, 4)
+    D = MatrixSymbol("D", 4, 5)
+    k=symbols("k")
+    f = lambdify(A, (2*k)*A)
+    g = lambdify(A, (2+k)*A)
+    h = lambdify(A, 2*A)
+    i = lambdify((B, C, D), 2*B*C*D)
+    assert numpy.array_equal(f(numpy.array([[1, 2, 3], [1, 2, 3], [1, 2, 3]])), \
+    numpy.array([[2*k, 4*k, 6*k], [2*k, 4*k, 6*k], [2*k, 4*k, 6*k]], dtype=object))
+
+    assert numpy.array_equal(g(numpy.array([[1, 2, 3], [1, 2, 3], [1, 2, 3]])), \
+    numpy.array([[k + 2, 2*k + 4, 3*k + 6], [k + 2, 2*k + 4, 3*k + 6], \
+    [k + 2, 2*k + 4, 3*k + 6]], dtype=object))
+
+    assert numpy.array_equal(h(numpy.array([[1, 2, 3], [1, 2, 3], [1, 2, 3]])), \
+    numpy.array([[2, 4, 6], [2, 4, 6], [2, 4, 6]]))
+
+    assert numpy.array_equal(i(numpy.array([[1, 2, 3], [1, 2, 3]]), numpy.array([[1, 2, 3, 4], [1, 2, 3, 4], [1, 2, 3, 4]]), \
+    numpy.array([[1, 2, 3, 4, 5], [1, 2, 3, 4, 5], [1, 2, 3, 4, 5], [1, 2, 3, 4, 5]])), numpy.array([[ 120, 240, 360, 480, 600], \
+    [ 120, 240, 360, 480, 600]]))
+
+
+def test_issue_16930():
+    if not scipy:
+        skip("scipy not installed")
+
+    x = symbols("x")
+    f = lambda x:  S.GoldenRatio * x**2
+    f_ = lambdify(x, f(x), modules='scipy')
+    assert f_(1) == scipy.constants.golden_ratio
+
+def test_issue_17898():
+    if not scipy:
+        skip("scipy not installed")
+    x = symbols("x")
+    f_ = lambdify([x], sympy.LambertW(x,-1), modules='scipy')
+    assert f_(0.1) == mpmath.lambertw(0.1, -1)
+
+def test_issue_13167_21411():
+    if not numpy:
+        skip("numpy not installed")
+    f1 = lambdify(x, sympy.Heaviside(x))
+    f2 = lambdify(x, sympy.Heaviside(x, 1))
+    res1 = f1([-1, 0, 1])
+    res2 = f2([-1, 0, 1])
+    assert Abs(res1[0]).n() < 1e-15        # First functionality: only one argument passed
+    assert Abs(res1[1] - 1/2).n() < 1e-15
+    assert Abs(res1[2] - 1).n() < 1e-15
+    assert Abs(res2[0]).n() < 1e-15        # Second functionality: two arguments passed
+    assert Abs(res2[1] - 1).n() < 1e-15
+    assert Abs(res2[2] - 1).n() < 1e-15
+
+def test_single_e():
+    f = lambdify(x, E)
+    assert f(23) == exp(1.0)
+
+def test_issue_16536():
+    if not scipy:
+        skip("scipy not installed")
+
+    a = symbols('a')
+    f1 = lowergamma(a, x)
+    F = lambdify((a, x), f1, modules='scipy')
+    assert abs(lowergamma(1, 3) - F(1, 3)) <= 1e-10
+
+    f2 = uppergamma(a, x)
+    F = lambdify((a, x), f2, modules='scipy')
+    assert abs(uppergamma(1, 3) - F(1, 3)) <= 1e-10
+
+
+def test_issue_22726():
+    if not numpy:
+        skip("numpy not installed")
+
+    x1, x2 = symbols('x1 x2')
+    f = Max(S.Zero, Min(x1, x2))
+    g = derive_by_array(f, (x1, x2))
+    G = lambdify((x1, x2), g, modules='numpy')
+    point = {x1: 1, x2: 2}
+    assert (abs(g.subs(point) - G(*point.values())) <= 1e-10).all()
+
+
+def test_issue_22739():
+    if not numpy:
+        skip("numpy not installed")
+
+    x1, x2 = symbols('x1 x2')
+    f = Heaviside(Min(x1, x2))
+    F = lambdify((x1, x2), f, modules='numpy')
+    point = {x1: 1, x2: 2}
+    assert abs(f.subs(point) - F(*point.values())) <= 1e-10
+
+
+def test_issue_22992():
+    if not numpy:
+        skip("numpy not installed")
+
+    a, t = symbols('a t')
+    expr = a*(log(cot(t/2)) - cos(t))
+    F = lambdify([a, t], expr, 'numpy')
+
+    point = {a: 10, t: 2}
+
+    assert abs(expr.subs(point) - F(*point.values())) <= 1e-10
+
+    # Standard math
+    F = lambdify([a, t], expr)
+
+    assert abs(expr.subs(point) - F(*point.values())) <= 1e-10
+
+
+def test_issue_19764():
+    if not numpy:
+        skip("numpy not installed")
+
+    expr = Array([x, x**2])
+    f = lambdify(x, expr, 'numpy')
+
+    assert f(1).__class__ == numpy.ndarray
+
+def test_issue_20070():
+    if not numba:
+        skip("numba not installed")
+
+    f = lambdify(x, sin(x), 'numpy')
+    assert numba.jit(f, nopython=True)(1)==0.8414709848078965
+
+
+def test_fresnel_integrals_scipy():
+    if not scipy:
+        skip("scipy not installed")
+
+    f1 = fresnelc(x)
+    f2 = fresnels(x)
+    F1 = lambdify(x, f1, modules='scipy')
+    F2 = lambdify(x, f2, modules='scipy')
+
+    assert abs(fresnelc(1.3) - F1(1.3)) <= 1e-10
+    assert abs(fresnels(1.3) - F2(1.3)) <= 1e-10
+
+
+def test_beta_scipy():
+    if not scipy:
+        skip("scipy not installed")
+
+    f = beta(x, y)
+    F = lambdify((x, y), f, modules='scipy')
+
+    assert abs(beta(1.3, 2.3) - F(1.3, 2.3)) <= 1e-10
+
+
+def test_beta_math():
+    f = beta(x, y)
+    F = lambdify((x, y), f, modules='math')
+
+    assert abs(beta(1.3, 2.3) - F(1.3, 2.3)) <= 1e-10
+
+
+def test_betainc_scipy():
+    if not scipy:
+        skip("scipy not installed")
+
+    f = betainc(w, x, y, z)
+    F = lambdify((w, x, y, z), f, modules='scipy')
+
+    assert abs(betainc(1.4, 3.1, 0.1, 0.5) - F(1.4, 3.1, 0.1, 0.5)) <= 1e-10
+
+
+def test_betainc_regularized_scipy():
+    if not scipy:
+        skip("scipy not installed")
+
+    f = betainc_regularized(w, x, y, z)
+    F = lambdify((w, x, y, z), f, modules='scipy')
+
+    assert abs(betainc_regularized(0.2, 3.5, 0.1, 1) - F(0.2, 3.5, 0.1, 1)) <= 1e-10
+
+
+def test_numpy_special_math():
+    if not numpy:
+        skip("numpy not installed")
+
+    funcs = [expm1, log1p, exp2, log2, log10, hypot, logaddexp, logaddexp2]
+    for func in funcs:
+        if 2 in func.nargs:
+            expr = func(x, y)
+            args = (x, y)
+            num_args = (0.3, 0.4)
+        elif 1 in func.nargs:
+            expr = func(x)
+            args = (x,)
+            num_args = (0.3,)
+        else:
+            raise NotImplementedError("Need to handle other than unary & binary functions in test")
+        f = lambdify(args, expr)
+        result = f(*num_args)
+        reference = expr.subs(dict(zip(args, num_args))).evalf()
+        assert numpy.allclose(result, float(reference))
+
+    lae2 = lambdify((x, y), logaddexp2(log2(x), log2(y)))
+    assert abs(2.0**lae2(1e-50, 2.5e-50) - 3.5e-50) < 1e-62  # from NumPy's docstring
+
+
+def test_scipy_special_math():
+    if not scipy:
+        skip("scipy not installed")
+
+    cm1 = lambdify((x,), cosm1(x), modules='scipy')
+    assert abs(cm1(1e-20) + 5e-41) < 1e-200
+
+    have_scipy_1_10plus = tuple(map(int, scipy.version.version.split('.')[:2])) >= (1, 10)
+
+    if have_scipy_1_10plus:
+        cm2 = lambdify((x, y), powm1(x, y), modules='scipy')
+        assert abs(cm2(1.2, 1e-9) - 1.82321557e-10)  < 1e-17
+
+
+def test_scipy_bernoulli():
+    if not scipy:
+        skip("scipy not installed")
+
+    bern = lambdify((x,), bernoulli(x), modules='scipy')
+    assert bern(1) == 0.5
+
+
+def test_scipy_harmonic():
+    if not scipy:
+        skip("scipy not installed")
+
+    hn = lambdify((x,), harmonic(x), modules='scipy')
+    assert hn(2) == 1.5
+    hnm = lambdify((x, y), harmonic(x, y), modules='scipy')
+    assert hnm(2, 2) == 1.25
+
+
+def test_cupy_array_arg():
+    if not cupy:
+        skip("CuPy not installed")
+
+    f = lambdify([[x, y]], x*x + y, 'cupy')
+    result = f(cupy.array([2.0, 1.0]))
+    assert result == 5
+    assert "cupy" in str(type(result))
+
+
+def test_cupy_array_arg_using_numpy():
+    # numpy functions can be run on cupy arrays
+    # unclear if we can "officially" support this,
+    # depends on numpy __array_function__ support
+    if not cupy:
+        skip("CuPy not installed")
+
+    f = lambdify([[x, y]], x*x + y, 'numpy')
+    result = f(cupy.array([2.0, 1.0]))
+    assert result == 5
+    assert "cupy" in str(type(result))
+
+def test_cupy_dotproduct():
+    if not cupy:
+        skip("CuPy not installed")
+
+    A = Matrix([x, y, z])
+    f1 = lambdify([x, y, z], DotProduct(A, A), modules='cupy')
+    f2 = lambdify([x, y, z], DotProduct(A, A.T), modules='cupy')
+    f3 = lambdify([x, y, z], DotProduct(A.T, A), modules='cupy')
+    f4 = lambdify([x, y, z], DotProduct(A, A.T), modules='cupy')
+
+    assert f1(1, 2, 3) == \
+        f2(1, 2, 3) == \
+        f3(1, 2, 3) == \
+        f4(1, 2, 3) == \
+        cupy.array([14])
+
+
+def test_jax_array_arg():
+    if not jax:
+        skip("JAX not installed")
+
+    f = lambdify([[x, y]], x*x + y, 'jax')
+    result = f(jax.numpy.array([2.0, 1.0]))
+    assert result == 5
+    assert "jax" in str(type(result))
+
+
+def test_jax_array_arg_using_numpy():
+    if not jax:
+        skip("JAX not installed")
+
+    f = lambdify([[x, y]], x*x + y, 'numpy')
+    result = f(jax.numpy.array([2.0, 1.0]))
+    assert result == 5
+    assert "jax" in str(type(result))
+
+
+def test_jax_dotproduct():
+    if not jax:
+        skip("JAX not installed")
+
+    A = Matrix([x, y, z])
+    f1 = lambdify([x, y, z], DotProduct(A, A), modules='jax')
+    f2 = lambdify([x, y, z], DotProduct(A, A.T), modules='jax')
+    f3 = lambdify([x, y, z], DotProduct(A.T, A), modules='jax')
+    f4 = lambdify([x, y, z], DotProduct(A, A.T), modules='jax')
+
+    assert f1(1, 2, 3) == \
+        f2(1, 2, 3) == \
+        f3(1, 2, 3) == \
+        f4(1, 2, 3) == \
+        jax.numpy.array([14])
+
+
+def test_lambdify_cse():
+    def no_op_cse(exprs):
+        return (), exprs
+
+    def dummy_cse(exprs):
+        from sympy.simplify.cse_main import cse
+        return cse(exprs, symbols=numbered_symbols(cls=Dummy))
+
+    def minmem(exprs):
+        from sympy.simplify.cse_main import cse_release_variables, cse
+        return cse(exprs, postprocess=cse_release_variables)
+
+    class Case:
+        def __init__(self, *, args, exprs, num_args, requires_numpy=False):
+            self.args = args
+            self.exprs = exprs
+            self.num_args = num_args
+            subs_dict = dict(zip(self.args, self.num_args))
+            self.ref = [e.subs(subs_dict).evalf() for e in exprs]
+            self.requires_numpy = requires_numpy
+
+        def lambdify(self, *, cse):
+            return lambdify(self.args, self.exprs, cse=cse)
+
+        def assertAllClose(self, result, *, abstol=1e-15, reltol=1e-15):
+            if self.requires_numpy:
+                assert all(numpy.allclose(result[i], numpy.asarray(r, dtype=float),
+                                          rtol=reltol, atol=abstol)
+                           for i, r in enumerate(self.ref))
+                return
+
+            for i, r in enumerate(self.ref):
+                abs_err = abs(result[i] - r)
+                if r == 0:
+                    assert abs_err < abstol
+                else:
+                    assert abs_err/abs(r) < reltol
+
+    cases = [
+        Case(
+            args=(x, y, z),
+            exprs=[
+             x + y + z,
+             x + y - z,
+             2*x + 2*y - z,
+             (x+y)**2 + (y+z)**2,
+            ],
+            num_args=(2., 3., 4.)
+        ),
+        Case(
+            args=(x, y, z),
+            exprs=[
+            x + sympy.Heaviside(x),
+            y + sympy.Heaviside(x),
+            z + sympy.Heaviside(x, 1),
+            z/sympy.Heaviside(x, 1)
+            ],
+            num_args=(0., 3., 4.)
+        ),
+        Case(
+            args=(x, y, z),
+            exprs=[
+            x + sinc(y),
+            y + sinc(y),
+            z - sinc(y)
+            ],
+            num_args=(0.1, 0.2, 0.3)
+        ),
+        Case(
+            args=(x, y, z),
+            exprs=[
+                Matrix([[x, x*y], [sin(z) + 4, x**z]]),
+                x*y+sin(z)-x**z,
+                Matrix([x*x, sin(z), x**z])
+            ],
+            num_args=(1.,2.,3.),
+            requires_numpy=True
+        ),
+        Case(
+            args=(x, y),
+            exprs=[(x + y - 1)**2, x, x + y,
+            (x + y)/(2*x + 1) + (x + y - 1)**2, (2*x + 1)**(x + y)],
+            num_args=(1,2)
+        )
+    ]
+    for case in cases:
+        if not numpy and case.requires_numpy:
+            continue
+        for _cse in [False, True, minmem, no_op_cse, dummy_cse]:
+            f = case.lambdify(cse=_cse)
+            result = f(*case.num_args)
+            case.assertAllClose(result)
+
+def test_issue_25288():
+    syms = numbered_symbols(cls=Dummy)
+    ok = lambdify(x, [x**2, sin(x**2)], cse=lambda e: cse(e, symbols=syms))(2)
+    assert ok
+
+
+def test_deprecated_set():
+    with warns_deprecated_sympy():
+        lambdify({x, y}, x + y)
+
+def test_issue_13881():
+    if not numpy:
+        skip("numpy not installed.")
+
+    X = MatrixSymbol('X', 3, 1)
+
+    f = lambdify(X, X.T*X, 'numpy')
+    assert f(numpy.array([1, 2, 3])) == 14
+    assert f(numpy.array([3, 2, 1])) == 14
+
+    f = lambdify(X, X*X.T, 'numpy')
+    assert f(numpy.array([1, 2, 3])) == 14
+    assert f(numpy.array([3, 2, 1])) == 14
+
+    f = lambdify(X, (X*X.T)*X, 'numpy')
+    arr1 = numpy.array([[1], [2], [3]])
+    arr2 = numpy.array([[14],[28],[42]])
+
+    assert numpy.array_equal(f(arr1), arr2)
+
+
+def test_23536_lambdify_cse_dummy():
+
+    f = Function('x')(y)
+    g = Function('w')(y)
+    expr = z + (f**4 + g**5)*(f**3 + (g*f)**3)
+    expr = expr.expand()
+    eval_expr = lambdify(((f, g), z), expr, cse=True)
+    ans = eval_expr((1.0, 2.0), 3.0)  # shouldn't raise NameError
+    assert ans == 300.0  # not a list and value is 300
+
+
+class LambdifyDocstringTestCase:
+    SIGNATURE = None
+    EXPR = None
+    SRC = None
+
+    def __init__(self, docstring_limit, expected_redacted):
+        self.docstring_limit = docstring_limit
+        self.expected_redacted = expected_redacted
+
+    @property
+    def expected_expr(self):
+        expr_redacted_msg = "EXPRESSION REDACTED DUE TO LENGTH, (see lambdify's `docstring_limit`)"
+        return self.EXPR if not self.expected_redacted else expr_redacted_msg
+
+    @property
+    def expected_src(self):
+        src_redacted_msg = "SOURCE CODE REDACTED DUE TO LENGTH, (see lambdify's `docstring_limit`)"
+        return self.SRC if not self.expected_redacted else src_redacted_msg
+
+    @property
+    def expected_docstring(self):
+        expected_docstring = (
+            f'Created with lambdify. Signature:\n\n'
+            f'func({self.SIGNATURE})\n\n'
+            f'Expression:\n\n'
+            f'{self.expected_expr}\n\n'
+            f'Source code:\n\n'
+            f'{self.expected_src}\n\n'
+            f'Imported modules:\n\n'
+        )
+        return expected_docstring
+
+    def __len__(self):
+        return len(self.expected_docstring)
+
+    def __repr__(self):
+        return (
+            f'{self.__class__.__name__}('
+            f'docstring_limit={self.docstring_limit}, '
+            f'expected_redacted={self.expected_redacted})'
+        )
+
+
+def test_lambdify_docstring_size_limit_simple_symbol():
+
+    class SimpleSymbolTestCase(LambdifyDocstringTestCase):
+        SIGNATURE = 'x'
+        EXPR = 'x'
+        SRC = (
+            'def _lambdifygenerated(x):\n'
+            '    return x\n'
+        )
+
+    x = symbols('x')
+
+    test_cases = (
+        SimpleSymbolTestCase(docstring_limit=None, expected_redacted=False),
+        SimpleSymbolTestCase(docstring_limit=100, expected_redacted=False),
+        SimpleSymbolTestCase(docstring_limit=1, expected_redacted=False),
+        SimpleSymbolTestCase(docstring_limit=0, expected_redacted=True),
+        SimpleSymbolTestCase(docstring_limit=-1, expected_redacted=True),
+    )
+    for test_case in test_cases:
+        lambdified_expr = lambdify(
+            [x],
+            x,
+            'sympy',
+            docstring_limit=test_case.docstring_limit,
+        )
+        assert lambdified_expr.__doc__ == test_case.expected_docstring
+
+
+def test_lambdify_docstring_size_limit_nested_expr():
+
+    class ExprListTestCase(LambdifyDocstringTestCase):
+        SIGNATURE = 'x, y, z'
+        EXPR = (
+            '[x, [y], z, x**3 + 3*x**2*y + 3*x**2*z + 3*x*y**2 + 6*x*y*z '
+            '+ 3*x*z**2 +...'
+        )
+        SRC = (
+            'def _lambdifygenerated(x, y, z):\n'
+            '    return [x, [y], z, x**3 + 3*x**2*y + 3*x**2*z + 3*x*y**2 '
+            '+ 6*x*y*z + 3*x*z**2 + y**3 + 3*y**2*z + 3*y*z**2 + z**3]\n'
+        )
+
+    x, y, z = symbols('x, y, z')
+    expr = [x, [y], z, ((x + y + z)**3).expand()]
+
+    test_cases = (
+        ExprListTestCase(docstring_limit=None, expected_redacted=False),
+        ExprListTestCase(docstring_limit=200, expected_redacted=False),
+        ExprListTestCase(docstring_limit=50, expected_redacted=True),
+        ExprListTestCase(docstring_limit=0, expected_redacted=True),
+        ExprListTestCase(docstring_limit=-1, expected_redacted=True),
+    )
+    for test_case in test_cases:
+        lambdified_expr = lambdify(
+            [x, y, z],
+            expr,
+            'sympy',
+            docstring_limit=test_case.docstring_limit,
+        )
+        assert lambdified_expr.__doc__ == test_case.expected_docstring
+
+
+def test_lambdify_docstring_size_limit_matrix():
+
+    class MatrixTestCase(LambdifyDocstringTestCase):
+        SIGNATURE = 'x, y, z'
+        EXPR = (
+            'Matrix([[0, x], [x + y + z, x**3 + 3*x**2*y + 3*x**2*z + 3*x*y**2 '
+            '+ 6*x*y*z...'
+        )
+        SRC = (
+            'def _lambdifygenerated(x, y, z):\n'
+            '    return ImmutableDenseMatrix([[0, x], [x + y + z, x**3 '
+            '+ 3*x**2*y + 3*x**2*z + 3*x*y**2 + 6*x*y*z + 3*x*z**2 + y**3 '
+            '+ 3*y**2*z + 3*y*z**2 + z**3]])\n'
+        )
+
+    x, y, z = symbols('x, y, z')
+    expr = Matrix([[S.Zero, x], [x + y + z, ((x + y + z)**3).expand()]])
+
+    test_cases = (
+        MatrixTestCase(docstring_limit=None, expected_redacted=False),
+        MatrixTestCase(docstring_limit=200, expected_redacted=False),
+        MatrixTestCase(docstring_limit=50, expected_redacted=True),
+        MatrixTestCase(docstring_limit=0, expected_redacted=True),
+        MatrixTestCase(docstring_limit=-1, expected_redacted=True),
+    )
+    for test_case in test_cases:
+        lambdified_expr = lambdify(
+            [x, y, z],
+            expr,
+            'sympy',
+            docstring_limit=test_case.docstring_limit,
+        )
+        assert lambdified_expr.__doc__ == test_case.expected_docstring
+
+
+def test_lambdify_empty_tuple():
+    a = symbols("a")
+    expr = ((), (a,))
+    f = lambdify(a, expr)
+    result = f(1)
+    assert result == ((), (1,)), "Lambdify did not handle the empty tuple correctly."
+
+
+def test_assoc_legendre_numerical_evaluation():
+
+    tol = 1e-10
+
+    sympy_result_integer = assoc_legendre(1, 1/2, 0.1).evalf()
+    sympy_result_complex = assoc_legendre(2, 1, 3).evalf()
+    mpmath_result_integer = -0.474572528387641
+    mpmath_result_complex = -25.45584412271571*I
+
+    assert all_close(sympy_result_integer, mpmath_result_integer, tol)
+    assert all_close(sympy_result_complex, mpmath_result_complex, tol)
+
+
+def test_Piecewise():
+
+    modules = [math]
+    if numpy:
+        modules.append('numpy')
+
+    for mod in modules:
+        # test isinf
+        f = lambdify(x, Piecewise((7.0, isinf(x)), (3.0, True)), mod)
+        assert f(+float('inf')) == +7.0
+        assert f(-float('inf')) == +7.0
+        assert f(42.) == 3.0
+
+        f2 = lambdify(x, Piecewise((7.0*sign(x), isinf(x)), (3.0, True)), mod)
+        assert f2(+float('inf')) == +7.0
+        assert f2(-float('inf')) == -7.0
+        assert f2(42.) == 3.0
+
+        # test isnan (gh-26784)
+        g = lambdify(x, Piecewise((7.0, isnan(x)), (3.0, True)), mod)
+        assert g(float('nan')) == 7.0
+        assert g(42.) == 3.0
+
+
+def test_array_symbol():
+    if not numpy:
+        skip("numpy not installed.")
+    a = ArraySymbol('a', (3,))
+    f = lambdify((a), a)
+    assert numpy.all(f(numpy.array([1,2,3])) == numpy.array([1,2,3]))
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/tests/test_matchpy_connector.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/tests/test_matchpy_connector.py
new file mode 100644
index 0000000000000000000000000000000000000000..3648bd49f9e56ca20fbf428ed46c01429dbe8b15
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/tests/test_matchpy_connector.py
@@ -0,0 +1,164 @@
+import pickle
+
+from sympy.core.relational import (Eq, Ne)
+from sympy.core.singleton import S
+from sympy.core.symbol import symbols
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import (cos, sin)
+from sympy.external import import_module
+from sympy.testing.pytest import skip
+from sympy.utilities.matchpy_connector import WildDot, WildPlus, WildStar, Replacer
+
+matchpy = import_module("matchpy")
+
+x, y, z = symbols("x y z")
+
+
+def _get_first_match(expr, pattern):
+    from matchpy import ManyToOneMatcher, Pattern
+
+    matcher = ManyToOneMatcher()
+    matcher.add(Pattern(pattern))
+    return next(iter(matcher.match(expr)))
+
+
+def test_matchpy_connector():
+    if matchpy is None:
+        skip("matchpy not installed")
+
+    from multiset import Multiset
+    from matchpy import Pattern, Substitution
+
+    w_ = WildDot("w_")
+    w__ = WildPlus("w__")
+    w___ = WildStar("w___")
+
+    expr = x + y
+    pattern = x + w_
+    p, subst = _get_first_match(expr, pattern)
+    assert p == Pattern(pattern)
+    assert subst == Substitution({'w_': y})
+
+    expr = x + y + z
+    pattern = x + w__
+    p, subst = _get_first_match(expr, pattern)
+    assert p == Pattern(pattern)
+    assert subst == Substitution({'w__': Multiset([y, z])})
+
+    expr = x + y + z
+    pattern = x + y + z + w___
+    p, subst = _get_first_match(expr, pattern)
+    assert p == Pattern(pattern)
+    assert subst == Substitution({'w___': Multiset()})
+
+
+def test_matchpy_optional():
+    if matchpy is None:
+        skip("matchpy not installed")
+
+    from matchpy import Pattern, Substitution
+    from matchpy import ManyToOneReplacer, ReplacementRule
+
+    p = WildDot("p", optional=1)
+    q = WildDot("q", optional=0)
+
+    pattern = p*x + q
+
+    expr1 = 2*x
+    pa, subst = _get_first_match(expr1, pattern)
+    assert pa == Pattern(pattern)
+    assert subst == Substitution({'p': 2, 'q': 0})
+
+    expr2 = x + 3
+    pa, subst = _get_first_match(expr2, pattern)
+    assert pa == Pattern(pattern)
+    assert subst == Substitution({'p': 1, 'q': 3})
+
+    expr3 = x
+    pa, subst = _get_first_match(expr3, pattern)
+    assert pa == Pattern(pattern)
+    assert subst == Substitution({'p': 1, 'q': 0})
+
+    expr4 = x*y + z
+    pa, subst = _get_first_match(expr4, pattern)
+    assert pa == Pattern(pattern)
+    assert subst == Substitution({'p': y, 'q': z})
+
+    replacer = ManyToOneReplacer()
+    replacer.add(ReplacementRule(Pattern(pattern), lambda p, q: sin(p)*cos(q)))
+    assert replacer.replace(expr1) == sin(2)*cos(0)
+    assert replacer.replace(expr2) == sin(1)*cos(3)
+    assert replacer.replace(expr3) == sin(1)*cos(0)
+    assert replacer.replace(expr4) == sin(y)*cos(z)
+
+
+def test_replacer():
+    if matchpy is None:
+        skip("matchpy not installed")
+
+    for info in [True, False]:
+        for lambdify in [True, False]:
+            _perform_test_replacer(info, lambdify)
+
+
+def _perform_test_replacer(info, lambdify):
+
+    x1_ = WildDot("x1_")
+    x2_ = WildDot("x2_")
+
+    a_ = WildDot("a_", optional=S.One)
+    b_ = WildDot("b_", optional=S.One)
+    c_ = WildDot("c_", optional=S.Zero)
+
+    replacer = Replacer(common_constraints=[
+        matchpy.CustomConstraint(lambda a_: not a_.has(x)),
+        matchpy.CustomConstraint(lambda b_: not b_.has(x)),
+        matchpy.CustomConstraint(lambda c_: not c_.has(x)),
+    ], lambdify=lambdify, info=info)
+
+    # Rewrite the equation into implicit form, unless it's already solved:
+    replacer.add(Eq(x1_, x2_), Eq(x1_ - x2_, 0), conditions_nonfalse=[Ne(x2_, 0), Ne(x1_, 0), Ne(x1_, x), Ne(x2_, x)], info=1)
+
+    # Simple equation solver for real numbers:
+    replacer.add(Eq(a_*x + b_, 0), Eq(x, -b_/a_), info=2)
+    disc = b_**2 - 4*a_*c_
+    replacer.add(
+        Eq(a_*x**2 + b_*x + c_, 0),
+        Eq(x, (-b_ - sqrt(disc))/(2*a_)) | Eq(x, (-b_ + sqrt(disc))/(2*a_)),
+        conditions_nonfalse=[disc >= 0],
+        info=3
+    )
+    replacer.add(
+        Eq(a_*x**2 + c_, 0),
+        Eq(x, sqrt(-c_/a_)) | Eq(x, -sqrt(-c_/a_)),
+        conditions_nonfalse=[-c_*a_ > 0],
+        info=4
+    )
+
+    g = lambda expr, infos: (expr, infos) if info else expr
+
+    assert replacer.replace(Eq(3*x, y)) == g(Eq(x, y/3), [1, 2])
+    assert replacer.replace(Eq(x**2 + 1, 0)) == g(Eq(x**2 + 1, 0), [])
+    assert replacer.replace(Eq(x**2, 4)) == g((Eq(x, 2) | Eq(x, -2)), [1, 4])
+    assert replacer.replace(Eq(x**2 + 4*y*x + 4*y**2, 0)) == g(Eq(x, -2*y), [3])
+
+
+def test_matchpy_object_pickle():
+    if matchpy is None:
+        return
+
+    a1 = WildDot("a")
+    a2 = pickle.loads(pickle.dumps(a1))
+    assert a1 == a2
+
+    a1 = WildDot("a", S(1))
+    a2 = pickle.loads(pickle.dumps(a1))
+    assert a1 == a2
+
+    a1 = WildPlus("a", S(1))
+    a2 = pickle.loads(pickle.dumps(a1))
+    assert a1 == a2
+
+    a1 = WildStar("a", S(1))
+    a2 = pickle.loads(pickle.dumps(a1))
+    assert a1 == a2
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/tests/test_mathml.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/tests/test_mathml.py
new file mode 100644
index 0000000000000000000000000000000000000000..e4a7598f175be34f8bb34c0bd9c003d1c0238c7b
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/tests/test_mathml.py
@@ -0,0 +1,33 @@
+import os
+from textwrap import dedent
+from sympy.external import import_module
+from sympy.testing.pytest import skip
+from sympy.utilities.mathml import apply_xsl
+
+
+
+lxml = import_module('lxml')
+
+path = os.path.abspath(os.path.join(os.path.dirname(__file__), "test_xxe.py"))
+
+
+def test_xxe():
+    assert os.path.isfile(path)
+    if not lxml:
+        skip("lxml not installed.")
+
+    mml = dedent(
+        rf"""
+        <!--?xml version="1.0" ?-->
+        <!DOCTYPE replace [<!ENTITY ent SYSTEM "file://{path}"> ]>
+        <userInfo>
+        <firstName>John</firstName>
+        <lastName>&ent;</lastName>
+        </userInfo>
+        """
+    )
+    xsl = 'mathml/data/simple_mmlctop.xsl'
+
+    res = apply_xsl(mml, xsl)
+    assert res == \
+        '<?xml version="1.0"?>\n<userInfo>\n<firstName>John</firstName>\n<lastName/>\n</userInfo>\n'
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/tests/test_misc.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/tests/test_misc.py
new file mode 100644
index 0000000000000000000000000000000000000000..0a3e059419303c33cbd7b770679b5efc1b03486d
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/tests/test_misc.py
@@ -0,0 +1,148 @@
+from textwrap import dedent
+import sys
+from subprocess import Popen, PIPE
+import os
+
+from sympy.core.singleton import S
+from sympy.testing.pytest import (raises, warns_deprecated_sympy,
+                                  skip_under_pyodide)
+from sympy.utilities.misc import (translate, replace, ordinal, rawlines,
+                                  strlines, as_int, find_executable)
+
+
+def test_translate():
+    abc = 'abc'
+    assert translate(abc, None, 'a') == 'bc'
+    assert translate(abc, None, '') == 'abc'
+    assert translate(abc, {'a': 'x'}, 'c') == 'xb'
+    assert translate(abc, {'a': 'bc'}, 'c') == 'bcb'
+    assert translate(abc, {'ab': 'x'}, 'c') == 'x'
+    assert translate(abc, {'ab': ''}, 'c') == ''
+    assert translate(abc, {'bc': 'x'}, 'c') == 'ab'
+    assert translate(abc, {'abc': 'x', 'a': 'y'}) == 'x'
+    u = chr(4096)
+    assert translate(abc, 'a', 'x', u) == 'xbc'
+    assert (u in translate(abc, 'a', u, u)) is True
+
+
+def test_replace():
+    assert replace('abc', ('a', 'b')) == 'bbc'
+    assert replace('abc', {'a': 'Aa'}) == 'Aabc'
+    assert replace('abc', ('a', 'b'), ('c', 'C')) == 'bbC'
+
+
+def test_ordinal():
+    assert ordinal(-1) == '-1st'
+    assert ordinal(0) == '0th'
+    assert ordinal(1) == '1st'
+    assert ordinal(2) == '2nd'
+    assert ordinal(3) == '3rd'
+    assert all(ordinal(i).endswith('th') for i in range(4, 21))
+    assert ordinal(100) == '100th'
+    assert ordinal(101) == '101st'
+    assert ordinal(102) == '102nd'
+    assert ordinal(103) == '103rd'
+    assert ordinal(104) == '104th'
+    assert ordinal(200) == '200th'
+    assert all(ordinal(i) == str(i) + 'th' for i in range(-220, -203))
+
+
+def test_rawlines():
+    assert rawlines('a a\na') == "dedent('''\\\n    a a\n    a''')"
+    assert rawlines('a a') == "'a a'"
+    assert rawlines(strlines('\\le"ft')) == (
+        '(\n'
+        "    '(\\n'\n"
+        '    \'r\\\'\\\\le"ft\\\'\\n\'\n'
+        "    ')'\n"
+        ')')
+
+
+def test_strlines():
+    q = 'this quote (") is in the middle'
+    # the following assert rhs was prepared with
+    # print(rawlines(strlines(q, 10)))
+    assert strlines(q, 10) == dedent('''\
+        (
+        'this quo'
+        'te (") i'
+        's in the'
+        ' middle'
+        )''')
+    assert q == (
+        'this quo'
+        'te (") i'
+        's in the'
+        ' middle'
+        )
+    q = "this quote (') is in the middle"
+    assert strlines(q, 20) == dedent('''\
+        (
+        "this quote (') is "
+        "in the middle"
+        )''')
+    assert strlines('\\left') == (
+        '(\n'
+        "r'\\left'\n"
+        ')')
+    assert strlines('\\left', short=True) == r"r'\left'"
+    assert strlines('\\le"ft') == (
+        '(\n'
+        'r\'\\le"ft\'\n'
+        ')')
+    q = 'this\nother line'
+    assert strlines(q) == rawlines(q)
+
+
+def test_translate_args():
+    try:
+        translate(None, None, None, 'not_none')
+    except ValueError:
+        pass # Exception raised successfully
+    else:
+        assert False
+
+    assert translate('s', None, None, None) == 's'
+
+    try:
+        translate('s', 'a', 'bc')
+    except ValueError:
+        pass # Exception raised successfully
+    else:
+        assert False
+
+
+@skip_under_pyodide("Cannot create subprocess under pyodide.")
+def test_debug_output():
+    env = os.environ.copy()
+    env['SYMPY_DEBUG'] = 'True'
+    cmd = 'from sympy import *; x = Symbol("x"); print(integrate((1-cos(x))/x, x))'
+    cmdline = [sys.executable, '-c', cmd]
+    proc = Popen(cmdline, env=env, stdout=PIPE, stderr=PIPE)
+    out, err = proc.communicate()
+    out = out.decode('ascii') # utf-8?
+    err = err.decode('ascii')
+    expected = 'substituted: -x*(1 - cos(x)), u: 1/x, u_var: _u'
+    assert expected in err, err
+
+
+def test_as_int():
+    raises(ValueError, lambda : as_int(True))
+    raises(ValueError, lambda : as_int(1.1))
+    raises(ValueError, lambda : as_int([]))
+    raises(ValueError, lambda : as_int(S.NaN))
+    raises(ValueError, lambda : as_int(S.Infinity))
+    raises(ValueError, lambda : as_int(S.NegativeInfinity))
+    raises(ValueError, lambda : as_int(S.ComplexInfinity))
+    # for the following, limited precision makes int(arg) == arg
+    # but the int value is not necessarily what a user might have
+    # expected; Q.prime is more nuanced in its response for
+    # expressions which might be complex representations of an
+    # integer. This is not -- by design -- as_ints role.
+    raises(ValueError, lambda : as_int(1e23))
+    raises(ValueError, lambda : as_int(S('1.'+'0'*20+'1')))
+    assert as_int(True, strict=False) == 1
+
+def test_deprecated_find_executable():
+    with warns_deprecated_sympy():
+        find_executable('python')
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/tests/test_pickling.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/tests/test_pickling.py
new file mode 100644
index 0000000000000000000000000000000000000000..7ea2d062286cbcf802eb0f42f2d7d130123599af
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/tests/test_pickling.py
@@ -0,0 +1,723 @@
+import inspect
+import copy
+import pickle
+
+from sympy.physics.units import meter
+
+from sympy.testing.pytest import XFAIL, raises, ignore_warnings
+
+from sympy.core.basic import Atom, Basic
+from sympy.core.singleton import SingletonRegistry
+from sympy.core.symbol import Str, Dummy, Symbol, Wild
+from sympy.core.numbers import (E, I, pi, oo, zoo, nan, Integer,
+        Rational, Float, AlgebraicNumber)
+from sympy.core.relational import (Equality, GreaterThan, LessThan, Relational,
+        StrictGreaterThan, StrictLessThan, Unequality)
+from sympy.core.add import Add
+from sympy.core.mul import Mul
+from sympy.core.power import Pow
+from sympy.core.function import Derivative, Function, FunctionClass, Lambda, \
+    WildFunction
+from sympy.sets.sets import Interval
+from sympy.core.multidimensional import vectorize
+
+from sympy.external.gmpy import gmpy as _gmpy
+from sympy.utilities.exceptions import SymPyDeprecationWarning
+
+from sympy.core.singleton import S
+from sympy.core.symbol import symbols
+
+from sympy.external import import_module
+cloudpickle = import_module('cloudpickle')
+
+
+not_equal_attrs = {
+    '_assumptions',  # This is a local cache that isn't automatically filled on creation
+    '_mhash',   # Cached after __hash__ is called but set to None after creation
+}
+
+
+deprecated_attrs = {
+    'is_EmptySet',  # Deprecated from SymPy 1.5. This can be removed when is_EmptySet is removed.
+    'expr_free_symbols',  # Deprecated from SymPy 1.9. This can be removed when exr_free_symbols is removed.
+}
+
+dont_check_attrs = {
+    '_sage_',  # Fails because Sage is not installed
+}
+
+
+def check(a, exclude=[], check_attr=True, deprecated=()):
+    """ Check that pickling and copying round-trips.
+    """
+    # Pickling with protocols 0 and 1 is disabled for Basic instances:
+    if isinstance(a, Basic):
+        for protocol in [0, 1]:
+            raises(NotImplementedError, lambda: pickle.dumps(a, protocol))
+
+    protocols = [2, copy.copy, copy.deepcopy, 3, 4]
+    if cloudpickle:
+        protocols.extend([cloudpickle])
+
+    for protocol in protocols:
+        if protocol in exclude:
+            continue
+
+        if callable(protocol):
+            if isinstance(a, type):
+                # Classes can't be copied, but that's okay.
+                continue
+            b = protocol(a)
+        elif inspect.ismodule(protocol):
+            b = protocol.loads(protocol.dumps(a))
+        else:
+            b = pickle.loads(pickle.dumps(a, protocol))
+
+        d1 = dir(a)
+        d2 = dir(b)
+        assert set(d1) == set(d2)
+
+        if not check_attr:
+            continue
+
+        def c(a, b, d):
+            for i in d:
+                if i in dont_check_attrs:
+                    continue
+                elif i in not_equal_attrs:
+                    if hasattr(a, i):
+                        assert hasattr(b, i), i
+                elif i in deprecated_attrs or i in deprecated:
+                    with ignore_warnings(SymPyDeprecationWarning):
+                        assert getattr(a, i) == getattr(b, i), i
+                elif not hasattr(a, i):
+                    continue
+                else:
+                    attr = getattr(a, i)
+                    if not hasattr(attr, "__call__"):
+                        assert hasattr(b, i), i
+                        assert getattr(b, i) == attr, "%s != %s, protocol: %s" % (getattr(b, i), attr, protocol)
+
+        c(a, b, d1)
+        c(b, a, d2)
+
+
+
+#================== core =========================
+
+
+def test_core_basic():
+    for c in (Atom, Atom(), Basic, Basic(), SingletonRegistry, S):
+        check(c)
+
+def test_core_Str():
+    check(Str('x'))
+
+def test_core_symbol():
+    # make the Symbol a unique name that doesn't class with any other
+    # testing variable in this file since after this test the symbol
+    # having the same name will be cached as noncommutative
+    for c in (Dummy, Dummy("x", commutative=False), Symbol,
+            Symbol("_issue_3130", commutative=False), Wild, Wild("x")):
+        check(c)
+
+
+def test_core_numbers():
+    for c in (Integer(2), Rational(2, 3), Float("1.2")):
+        check(c)
+    for c in (AlgebraicNumber, AlgebraicNumber(sqrt(3))):
+        check(c, check_attr=False)
+
+
+def test_core_float_copy():
+    # See gh-7457
+    y = Symbol("x") + 1.0
+    check(y)  # does not raise TypeError ("argument is not an mpz")
+
+
+def test_core_relational():
+    x = Symbol("x")
+    y = Symbol("y")
+    for c in (Equality, Equality(x, y), GreaterThan, GreaterThan(x, y),
+              LessThan, LessThan(x, y), Relational, Relational(x, y),
+              StrictGreaterThan, StrictGreaterThan(x, y), StrictLessThan,
+              StrictLessThan(x, y), Unequality, Unequality(x, y)):
+        check(c)
+
+
+def test_core_add():
+    x = Symbol("x")
+    for c in (Add, Add(x, 4)):
+        check(c)
+
+
+def test_core_mul():
+    x = Symbol("x")
+    for c in (Mul, Mul(x, 4)):
+        check(c)
+
+
+def test_core_power():
+    x = Symbol("x")
+    for c in (Pow, Pow(x, 4)):
+        check(c)
+
+
+def test_core_function():
+    x = Symbol("x")
+    for f in (Derivative, Derivative(x), Function, FunctionClass, Lambda,
+              WildFunction):
+        check(f)
+
+
+def test_core_undefinedfunctions():
+    f = Function("f")
+    check(f)
+
+
+def test_core_appliedundef():
+    x = Symbol("_long_unique_name_1")
+    f = Function("_long_unique_name_2")
+    check(f(x))
+
+
+def test_core_interval():
+    for c in (Interval, Interval(0, 2)):
+        check(c)
+
+
+def test_core_multidimensional():
+    for c in (vectorize, vectorize(0)):
+        check(c)
+
+
+def test_Singletons():
+    protocols = [0, 1, 2, 3, 4]
+    copiers = [copy.copy, copy.deepcopy]
+    copiers += [lambda x: pickle.loads(pickle.dumps(x, proto))
+            for proto in protocols]
+    if cloudpickle:
+        copiers += [lambda x: cloudpickle.loads(cloudpickle.dumps(x))]
+
+    for obj in (Integer(-1), Integer(0), Integer(1), Rational(1, 2), pi, E, I,
+            oo, -oo, zoo, nan, S.GoldenRatio, S.TribonacciConstant,
+            S.EulerGamma, S.Catalan, S.EmptySet, S.IdentityFunction):
+        for func in copiers:
+            assert func(obj) is obj
+
+#================== combinatorics ===================
+from sympy.combinatorics.free_groups import FreeGroup
+
+def test_free_group():
+    check(FreeGroup("x, y, z"), check_attr=False)
+
+#================== functions ===================
+from sympy.functions import (Piecewise, lowergamma, acosh, chebyshevu,
+        chebyshevt, ln, chebyshevt_root, legendre, Heaviside, bernoulli, coth,
+        tanh, assoc_legendre, sign, arg, asin, DiracDelta, re, rf, Abs,
+        uppergamma, binomial, sinh, cos, cot, acos, acot, gamma, bell,
+        hermite, harmonic, LambertW, zeta, log, factorial, asinh, acoth, cosh,
+        dirichlet_eta, Eijk, loggamma, erf, ceiling, im, fibonacci,
+        tribonacci, conjugate, tan, chebyshevu_root, floor, atanh, sqrt, sin,
+        atan, ff, lucas, atan2, polygamma, exp)
+
+
+def test_functions():
+    one_var = (acosh, ln, Heaviside, factorial, bernoulli, coth, tanh,
+            sign, arg, asin, DiracDelta, re, Abs, sinh, cos, cot, acos, acot,
+            gamma, bell, harmonic, LambertW, zeta, log, factorial, asinh,
+            acoth, cosh, dirichlet_eta, loggamma, erf, ceiling, im, fibonacci,
+            tribonacci, conjugate, tan, floor, atanh, sin, atan, lucas, exp)
+    two_var = (rf, ff, lowergamma, chebyshevu, chebyshevt, binomial,
+            atan2, polygamma, hermite, legendre, uppergamma)
+    x, y, z = symbols("x,y,z")
+    others = (chebyshevt_root, chebyshevu_root, Eijk(x, y, z),
+            Piecewise( (0, x < -1), (x**2, x <= 1), (x**3, True)),
+            assoc_legendre)
+    for cls in one_var:
+        check(cls)
+        c = cls(x)
+        check(c)
+    for cls in two_var:
+        check(cls)
+        c = cls(x, y)
+        check(c)
+    for cls in others:
+        check(cls)
+
+#================== geometry ====================
+from sympy.geometry.entity import GeometryEntity
+from sympy.geometry.point import Point
+from sympy.geometry.ellipse import Circle, Ellipse
+from sympy.geometry.line import Line, LinearEntity, Ray, Segment
+from sympy.geometry.polygon import Polygon, RegularPolygon, Triangle
+
+
+def test_geometry():
+    p1 = Point(1, 2)
+    p2 = Point(2, 3)
+    p3 = Point(0, 0)
+    p4 = Point(0, 1)
+    for c in (
+        GeometryEntity, GeometryEntity(), Point, p1, Circle, Circle(p1, 2),
+        Ellipse, Ellipse(p1, 3, 4), Line, Line(p1, p2), LinearEntity,
+        LinearEntity(p1, p2), Ray, Ray(p1, p2), Segment, Segment(p1, p2),
+        Polygon, Polygon(p1, p2, p3, p4), RegularPolygon,
+            RegularPolygon(p1, 4, 5), Triangle, Triangle(p1, p2, p3)):
+        check(c, check_attr=False)
+
+#================== integrals ====================
+from sympy.integrals.integrals import Integral
+
+
+def test_integrals():
+    x = Symbol("x")
+    for c in (Integral, Integral(x)):
+        check(c)
+
+#==================== logic =====================
+from sympy.core.logic import Logic
+
+
+def test_logic():
+    for c in (Logic, Logic(1)):
+        check(c)
+
+#================== matrices ====================
+from sympy.matrices import Matrix, SparseMatrix
+
+
+def test_matrices():
+    for c in (Matrix, Matrix([1, 2, 3]), SparseMatrix, SparseMatrix([[1, 2], [3, 4]])):
+        check(c, deprecated=['_smat', '_mat'])
+
+#================== ntheory =====================
+from sympy.ntheory.generate import Sieve
+
+
+def test_ntheory():
+    for c in (Sieve, Sieve()):
+        check(c)
+
+#================== physics =====================
+from sympy.physics.paulialgebra import Pauli
+from sympy.physics.units import Unit
+
+
+def test_physics():
+    for c in (Unit, meter, Pauli, Pauli(1)):
+        check(c)
+
+#================== plotting ====================
+# XXX: These tests are not complete, so XFAIL them
+
+
+@XFAIL
+def test_plotting():
+    from sympy.plotting.pygletplot.color_scheme import ColorGradient, ColorScheme
+    from sympy.plotting.pygletplot.managed_window import ManagedWindow
+    from sympy.plotting.plot import Plot, ScreenShot
+    from sympy.plotting.pygletplot.plot_axes import PlotAxes, PlotAxesBase, PlotAxesFrame, PlotAxesOrdinate
+    from sympy.plotting.pygletplot.plot_camera import PlotCamera
+    from sympy.plotting.pygletplot.plot_controller import PlotController
+    from sympy.plotting.pygletplot.plot_curve import PlotCurve
+    from sympy.plotting.pygletplot.plot_interval import PlotInterval
+    from sympy.plotting.pygletplot.plot_mode import PlotMode
+    from sympy.plotting.pygletplot.plot_modes import Cartesian2D, Cartesian3D, Cylindrical, \
+        ParametricCurve2D, ParametricCurve3D, ParametricSurface, Polar, Spherical
+    from sympy.plotting.pygletplot.plot_object import PlotObject
+    from sympy.plotting.pygletplot.plot_surface import PlotSurface
+    from sympy.plotting.pygletplot.plot_window import PlotWindow
+    for c in (
+        ColorGradient, ColorGradient(0.2, 0.4), ColorScheme, ManagedWindow,
+        ManagedWindow, Plot, ScreenShot, PlotAxes, PlotAxesBase,
+        PlotAxesFrame, PlotAxesOrdinate, PlotCamera, PlotController,
+        PlotCurve, PlotInterval, PlotMode, Cartesian2D, Cartesian3D,
+        Cylindrical, ParametricCurve2D, ParametricCurve3D,
+        ParametricSurface, Polar, Spherical, PlotObject, PlotSurface,
+            PlotWindow):
+        check(c)
+
+
+@XFAIL
+def test_plotting2():
+    #from sympy.plotting.color_scheme import ColorGradient
+    from sympy.plotting.pygletplot.color_scheme import ColorScheme
+    #from sympy.plotting.managed_window import ManagedWindow
+    from sympy.plotting.plot import Plot
+    #from sympy.plotting.plot import ScreenShot
+    from sympy.plotting.pygletplot.plot_axes import PlotAxes
+    #from sympy.plotting.plot_axes import PlotAxesBase, PlotAxesFrame, PlotAxesOrdinate
+    #from sympy.plotting.plot_camera import PlotCamera
+    #from sympy.plotting.plot_controller import PlotController
+    #from sympy.plotting.plot_curve import PlotCurve
+    #from sympy.plotting.plot_interval import PlotInterval
+    #from sympy.plotting.plot_mode import PlotMode
+    #from sympy.plotting.plot_modes import Cartesian2D, Cartesian3D, Cylindrical, \
+    #    ParametricCurve2D, ParametricCurve3D, ParametricSurface, Polar, Spherical
+    #from sympy.plotting.plot_object import PlotObject
+    #from sympy.plotting.plot_surface import PlotSurface
+    # from sympy.plotting.plot_window import PlotWindow
+    check(ColorScheme("rainbow"))
+    check(Plot(1, visible=False))
+    check(PlotAxes())
+
+#================== polys =======================
+from sympy.polys.domains.integerring import ZZ
+from sympy.polys.domains.rationalfield import QQ
+from sympy.polys.orderings import lex
+from sympy.polys.polytools import Poly
+
+def test_pickling_polys_polytools():
+    from sympy.polys.polytools import PurePoly
+    # from sympy.polys.polytools import GroebnerBasis
+    x = Symbol('x')
+
+    for c in (Poly, Poly(x, x)):
+        check(c)
+
+    for c in (PurePoly, PurePoly(x)):
+        check(c)
+
+    # TODO: fix pickling of Options class (see GroebnerBasis._options)
+    # for c in (GroebnerBasis, GroebnerBasis([x**2 - 1], x, order=lex)):
+    #     check(c)
+
+def test_pickling_polys_polyclasses():
+    from sympy.polys.polyclasses import DMP, DMF, ANP
+
+    for c in (DMP, DMP([[ZZ(1)], [ZZ(2)], [ZZ(3)]], ZZ)):
+        check(c, deprecated=['rep'])
+    for c in (DMF, DMF(([ZZ(1), ZZ(2)], [ZZ(1), ZZ(3)]), ZZ)):
+        check(c)
+    for c in (ANP, ANP([QQ(1), QQ(2)], [QQ(1), QQ(2), QQ(3)], QQ)):
+        check(c)
+
+@XFAIL
+def test_pickling_polys_rings():
+    # NOTE: can't use protocols < 2 because we have to execute __new__ to
+    # make sure caching of rings works properly.
+
+    from sympy.polys.rings import PolyRing
+
+    ring = PolyRing("x,y,z", ZZ, lex)
+
+    for c in (PolyRing, ring):
+        check(c, exclude=[0, 1])
+
+    for c in (ring.dtype, ring.one):
+        check(c, exclude=[0, 1], check_attr=False) # TODO: Py3k
+
+def test_pickling_polys_fields():
+    pass
+    # NOTE: can't use protocols < 2 because we have to execute __new__ to
+    # make sure caching of fields works properly.
+
+    # from sympy.polys.fields import FracField
+
+    # field = FracField("x,y,z", ZZ, lex)
+
+    # TODO: AssertionError: assert id(obj) not in self.memo
+    # for c in (FracField, field):
+    #     check(c, exclude=[0, 1])
+
+    # TODO: AssertionError: assert id(obj) not in self.memo
+    # for c in (field.dtype, field.one):
+    #     check(c, exclude=[0, 1])
+
+def test_pickling_polys_elements():
+    from sympy.polys.domains.pythonrational import PythonRational
+    #from sympy.polys.domains.pythonfinitefield import PythonFiniteField
+    #from sympy.polys.domains.mpelements import MPContext
+
+    for c in (PythonRational, PythonRational(1, 7)):
+        check(c)
+
+    #gf = PythonFiniteField(17)
+
+    # TODO: fix pickling of ModularInteger
+    # for c in (gf.dtype, gf(5)):
+    #     check(c)
+
+    #mp = MPContext()
+
+    # TODO: fix pickling of RealElement
+    # for c in (mp.mpf, mp.mpf(1.0)):
+    #     check(c)
+
+    # TODO: fix pickling of ComplexElement
+    # for c in (mp.mpc, mp.mpc(1.0, -1.5)):
+    #     check(c)
+
+def test_pickling_polys_domains():
+    # from sympy.polys.domains.pythonfinitefield import PythonFiniteField
+    from sympy.polys.domains.pythonintegerring import PythonIntegerRing
+    from sympy.polys.domains.pythonrationalfield import PythonRationalField
+
+    # TODO: fix pickling of ModularInteger
+    # for c in (PythonFiniteField, PythonFiniteField(17)):
+    #     check(c)
+
+    for c in (PythonIntegerRing, PythonIntegerRing()):
+        check(c, check_attr=False)
+
+    for c in (PythonRationalField, PythonRationalField()):
+        check(c, check_attr=False)
+
+    if _gmpy is not None:
+        # from sympy.polys.domains.gmpyfinitefield import GMPYFiniteField
+        from sympy.polys.domains.gmpyintegerring import GMPYIntegerRing
+        from sympy.polys.domains.gmpyrationalfield import GMPYRationalField
+
+        # TODO: fix pickling of ModularInteger
+        # for c in (GMPYFiniteField, GMPYFiniteField(17)):
+        #     check(c)
+
+        for c in (GMPYIntegerRing, GMPYIntegerRing()):
+            check(c, check_attr=False)
+
+        for c in (GMPYRationalField, GMPYRationalField()):
+            check(c, check_attr=False)
+
+    #from sympy.polys.domains.realfield import RealField
+    #from sympy.polys.domains.complexfield import ComplexField
+    from sympy.polys.domains.algebraicfield import AlgebraicField
+    #from sympy.polys.domains.polynomialring import PolynomialRing
+    #from sympy.polys.domains.fractionfield import FractionField
+    from sympy.polys.domains.expressiondomain import ExpressionDomain
+
+    # TODO: fix pickling of RealElement
+    # for c in (RealField, RealField(100)):
+    #     check(c)
+
+    # TODO: fix pickling of ComplexElement
+    # for c in (ComplexField, ComplexField(100)):
+    #     check(c)
+
+    for c in (AlgebraicField, AlgebraicField(QQ, sqrt(3))):
+        check(c, check_attr=False)
+
+    # TODO: AssertionError
+    # for c in (PolynomialRing, PolynomialRing(ZZ, "x,y,z")):
+    #     check(c)
+
+    # TODO: AttributeError: 'PolyElement' object has no attribute 'ring'
+    # for c in (FractionField, FractionField(ZZ, "x,y,z")):
+    #     check(c)
+
+    for c in (ExpressionDomain, ExpressionDomain()):
+        check(c, check_attr=False)
+
+
+def test_pickling_polys_orderings():
+    from sympy.polys.orderings import (LexOrder, GradedLexOrder,
+        ReversedGradedLexOrder, InverseOrder)
+    # from sympy.polys.orderings import ProductOrder
+
+    for c in (LexOrder, LexOrder()):
+        check(c)
+
+    for c in (GradedLexOrder, GradedLexOrder()):
+        check(c)
+
+    for c in (ReversedGradedLexOrder, ReversedGradedLexOrder()):
+        check(c)
+
+    # TODO: Argh, Python is so naive. No lambdas nor inner function support in
+    # pickling module. Maybe someone could figure out what to do with this.
+    #
+    # for c in (ProductOrder, ProductOrder((LexOrder(),       lambda m: m[:2]),
+    #                                      (GradedLexOrder(), lambda m: m[2:]))):
+    #     check(c)
+
+    for c in (InverseOrder, InverseOrder(LexOrder())):
+        check(c)
+
+def test_pickling_polys_monomials():
+    from sympy.polys.monomials import MonomialOps, Monomial
+    x, y, z = symbols("x,y,z")
+
+    for c in (MonomialOps, MonomialOps(3)):
+        check(c)
+
+    for c in (Monomial, Monomial((1, 2, 3), (x, y, z))):
+        check(c)
+
+def test_pickling_polys_errors():
+    from sympy.polys.polyerrors import (HeuristicGCDFailed,
+        HomomorphismFailed, IsomorphismFailed, ExtraneousFactors,
+        EvaluationFailed, RefinementFailed, CoercionFailed, NotInvertible,
+        NotReversible, NotAlgebraic, DomainError, PolynomialError,
+        UnificationFailed, GeneratorsError, GeneratorsNeeded,
+        UnivariatePolynomialError, MultivariatePolynomialError, OptionError,
+        FlagError)
+    # from sympy.polys.polyerrors import (ExactQuotientFailed,
+    #         OperationNotSupported, ComputationFailed, PolificationFailed)
+
+    # x = Symbol('x')
+
+    # TODO: TypeError: __init__() takes at least 3 arguments (1 given)
+    # for c in (ExactQuotientFailed, ExactQuotientFailed(x, 3*x, ZZ)):
+    #    check(c)
+
+    # TODO: TypeError: can't pickle instancemethod objects
+    # for c in (OperationNotSupported, OperationNotSupported(Poly(x), Poly.gcd)):
+    #    check(c)
+
+    for c in (HeuristicGCDFailed, HeuristicGCDFailed()):
+        check(c)
+
+    for c in (HomomorphismFailed, HomomorphismFailed()):
+        check(c)
+
+    for c in (IsomorphismFailed, IsomorphismFailed()):
+        check(c)
+
+    for c in (ExtraneousFactors, ExtraneousFactors()):
+        check(c)
+
+    for c in (EvaluationFailed, EvaluationFailed()):
+        check(c)
+
+    for c in (RefinementFailed, RefinementFailed()):
+        check(c)
+
+    for c in (CoercionFailed, CoercionFailed()):
+        check(c)
+
+    for c in (NotInvertible, NotInvertible()):
+        check(c)
+
+    for c in (NotReversible, NotReversible()):
+        check(c)
+
+    for c in (NotAlgebraic, NotAlgebraic()):
+        check(c)
+
+    for c in (DomainError, DomainError()):
+        check(c)
+
+    for c in (PolynomialError, PolynomialError()):
+        check(c)
+
+    for c in (UnificationFailed, UnificationFailed()):
+        check(c)
+
+    for c in (GeneratorsError, GeneratorsError()):
+        check(c)
+
+    for c in (GeneratorsNeeded, GeneratorsNeeded()):
+        check(c)
+
+    # TODO: PicklingError: Can't pickle <function <lambda> at 0x38578c0>: it's not found as __main__.<lambda>
+    # for c in (ComputationFailed, ComputationFailed(lambda t: t, 3, None)):
+    #    check(c)
+
+    for c in (UnivariatePolynomialError, UnivariatePolynomialError()):
+        check(c)
+
+    for c in (MultivariatePolynomialError, MultivariatePolynomialError()):
+        check(c)
+
+    # TODO: TypeError: __init__() takes at least 3 arguments (1 given)
+    # for c in (PolificationFailed, PolificationFailed({}, x, x, False)):
+    #    check(c)
+
+    for c in (OptionError, OptionError()):
+        check(c)
+
+    for c in (FlagError, FlagError()):
+        check(c)
+
+#def test_pickling_polys_options():
+    #from sympy.polys.polyoptions import Options
+
+    # TODO: fix pickling of `symbols' flag
+    # for c in (Options, Options((), dict(domain='ZZ', polys=False))):
+    #    check(c)
+
+# TODO: def test_pickling_polys_rootisolation():
+#    RealInterval
+#    ComplexInterval
+
+def test_pickling_polys_rootoftools():
+    from sympy.polys.rootoftools import CRootOf, RootSum
+
+    x = Symbol('x')
+    f = x**3 + x + 3
+
+    for c in (CRootOf, CRootOf(f, 0)):
+        check(c)
+
+    for c in (RootSum, RootSum(f, exp)):
+        check(c)
+
+#================== printing ====================
+from sympy.printing.latex import LatexPrinter
+from sympy.printing.mathml import MathMLContentPrinter, MathMLPresentationPrinter
+from sympy.printing.pretty.pretty import PrettyPrinter
+from sympy.printing.pretty.stringpict import prettyForm, stringPict
+from sympy.printing.printer import Printer
+from sympy.printing.python import PythonPrinter
+
+
+def test_printing():
+    for c in (LatexPrinter, LatexPrinter(), MathMLContentPrinter,
+              MathMLPresentationPrinter, PrettyPrinter, prettyForm, stringPict,
+              stringPict("a"), Printer, Printer(), PythonPrinter,
+              PythonPrinter()):
+        check(c)
+
+
+@XFAIL
+def test_printing1():
+    check(MathMLContentPrinter())
+
+
+@XFAIL
+def test_printing2():
+    check(MathMLPresentationPrinter())
+
+
+@XFAIL
+def test_printing3():
+    check(PrettyPrinter())
+
+#================== series ======================
+from sympy.series.limits import Limit
+from sympy.series.order import Order
+
+
+def test_series():
+    e = Symbol("e")
+    x = Symbol("x")
+    for c in (Limit, Limit(e, x, 1), Order, Order(e)):
+        check(c)
+
+#================== concrete ==================
+from sympy.concrete.products import Product
+from sympy.concrete.summations import Sum
+
+
+def test_concrete():
+    x = Symbol("x")
+    for c in (Product, Product(x, (x, 2, 4)), Sum, Sum(x, (x, 2, 4))):
+        check(c)
+
+def test_deprecation_warning():
+    w = SymPyDeprecationWarning("message", deprecated_since_version='1.0', active_deprecations_target="active-deprecations")
+    check(w)
+
+def test_issue_18438():
+    assert pickle.loads(pickle.dumps(S.Half)) == S.Half
+
+
+#================= old pickles =================
+def test_unpickle_from_older_versions():
+    data = (
+        b'\x80\x04\x95^\x00\x00\x00\x00\x00\x00\x00\x8c\x10sympy.core.power'
+        b'\x94\x8c\x03Pow\x94\x93\x94\x8c\x12sympy.core.numbers\x94\x8c'
+        b'\x07Integer\x94\x93\x94K\x02\x85\x94R\x94}\x94bh\x03\x8c\x04Half'
+        b'\x94\x93\x94)R\x94}\x94b\x86\x94R\x94}\x94b.'
+    )
+    assert pickle.loads(data) == sqrt(2)
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/tests/test_source.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/tests/test_source.py
new file mode 100644
index 0000000000000000000000000000000000000000..468185bc579fc325aee21024dfa15ebf14287b5f
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/tests/test_source.py
@@ -0,0 +1,11 @@
+from sympy.utilities.source import get_mod_func, get_class
+
+
+def test_get_mod_func():
+    assert get_mod_func(
+        'sympy.core.basic.Basic') == ('sympy.core.basic', 'Basic')
+
+
+def test_get_class():
+    _basic = get_class('sympy.core.basic.Basic')
+    assert _basic.__name__ == 'Basic'
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/tests/test_timeutils.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/tests/test_timeutils.py
new file mode 100644
index 0000000000000000000000000000000000000000..14edfd089c7315ee9f39a4298af0289f8919da6b
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/tests/test_timeutils.py
@@ -0,0 +1,10 @@
+"""Tests for simple tools for timing functions' execution. """
+
+from sympy.utilities.timeutils import timed
+
+def test_timed():
+    result = timed(lambda: 1 + 1, limit=100000)
+    assert result[0] == 100000 and result[3] == "ns", str(result)
+
+    result = timed("1 + 1", limit=100000)
+    assert result[0] == 100000 and result[3] == "ns"
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/tests/test_wester.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/tests/test_wester.py
new file mode 100644
index 0000000000000000000000000000000000000000..c5699a4eb0824e507967ecd4ff8f7a5f32cc9a54
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/tests/test_wester.py
@@ -0,0 +1,3104 @@
+""" Tests from Michael Wester's 1999 paper "Review of CAS mathematical
+capabilities".
+
+http://www.math.unm.edu/~wester/cas/book/Wester.pdf
+See also http://math.unm.edu/~wester/cas_review.html for detailed output of
+each tested system.
+"""
+
+from sympy.assumptions.ask import Q, ask
+from sympy.assumptions.refine import refine
+from sympy.concrete.products import product
+from sympy.core import EulerGamma
+from sympy.core.evalf import N
+from sympy.core.function import (Derivative, Function, Lambda, Subs,
+    diff, expand, expand_func)
+from sympy.core.mul import Mul
+from sympy.core.intfunc import igcd
+from sympy.core.numbers import (AlgebraicNumber, E, I, Rational,
+    nan, oo, pi, zoo)
+from sympy.core.relational import Eq, Lt
+from sympy.core.singleton import S
+from sympy.core.symbol import Dummy, Symbol, symbols
+from sympy.functions.combinatorial.factorials import (rf, binomial,
+    factorial, factorial2)
+from sympy.functions.combinatorial.numbers import bernoulli, fibonacci, totient, partition
+from sympy.functions.elementary.complexes import (conjugate, im, re,
+    sign)
+from sympy.functions.elementary.exponential import LambertW, exp, log
+from sympy.functions.elementary.hyperbolic import (asinh, cosh, sinh,
+    tanh)
+from sympy.functions.elementary.integers import ceiling, floor
+from sympy.functions.elementary.miscellaneous import Max, Min, sqrt
+from sympy.functions.elementary.piecewise import Piecewise
+from sympy.functions.elementary.trigonometric import (acos, acot, asin,
+    atan, cos, cot, csc, sec, sin, tan)
+from sympy.functions.special.bessel import besselj
+from sympy.functions.special.delta_functions import DiracDelta
+from sympy.functions.special.elliptic_integrals import (elliptic_e,
+    elliptic_f)
+from sympy.functions.special.gamma_functions import gamma, polygamma
+from sympy.functions.special.hyper import hyper
+from sympy.functions.special.polynomials import (assoc_legendre,
+    chebyshevt)
+from sympy.functions.special.zeta_functions import polylog
+from sympy.geometry.util import idiff
+from sympy.logic.boolalg import And
+from sympy.matrices.dense import hessian, wronskian
+from sympy.matrices.expressions.matmul import MatMul
+from sympy.ntheory.continued_fraction import (
+    continued_fraction_convergents as cf_c,
+    continued_fraction_iterator as cf_i, continued_fraction_periodic as
+    cf_p, continued_fraction_reduce as cf_r)
+from sympy.ntheory.factor_ import factorint
+from sympy.ntheory.generate import primerange
+from sympy.polys.domains.integerring import ZZ
+from sympy.polys.orthopolys import legendre_poly
+from sympy.polys.partfrac import apart
+from sympy.polys.polytools import Poly, factor, gcd, resultant
+from sympy.series.limits import limit
+from sympy.series.order import O
+from sympy.series.residues import residue
+from sympy.series.series import series
+from sympy.sets.fancysets import ImageSet
+from sympy.sets.sets import FiniteSet, Intersection, Interval, Union
+from sympy.simplify.combsimp import combsimp
+from sympy.simplify.hyperexpand import hyperexpand
+from sympy.simplify.powsimp import powdenest, powsimp
+from sympy.simplify.radsimp import radsimp
+from sympy.simplify.simplify import logcombine, simplify
+from sympy.simplify.sqrtdenest import sqrtdenest
+from sympy.simplify.trigsimp import trigsimp
+from sympy.solvers.solvers import solve
+
+import mpmath
+from sympy.functions.combinatorial.numbers import stirling
+from sympy.functions.special.delta_functions import Heaviside
+from sympy.functions.special.error_functions import Ci, Si, erf
+from sympy.functions.special.zeta_functions import zeta
+from sympy.testing.pytest import (XFAIL, slow, SKIP, tooslow, raises)
+from sympy.utilities.iterables import partitions
+from mpmath import mpi, mpc
+from sympy.matrices import Matrix, GramSchmidt, eye
+from sympy.matrices.expressions.blockmatrix import BlockMatrix, block_collapse
+from sympy.matrices.expressions import MatrixSymbol, ZeroMatrix
+from sympy.physics.quantum import Commutator
+from sympy.polys.rings import PolyRing
+from sympy.polys.fields import FracField
+from sympy.polys.solvers import solve_lin_sys
+from sympy.concrete import Sum
+from sympy.concrete.products import Product
+from sympy.integrals import integrate
+from sympy.integrals.transforms import laplace_transform,\
+    inverse_laplace_transform, LaplaceTransform, fourier_transform,\
+    mellin_transform, laplace_correspondence, laplace_initial_conds
+from sympy.solvers.recurr import rsolve
+from sympy.solvers.solveset import solveset, solveset_real, linsolve
+from sympy.solvers.ode import dsolve
+from sympy.core.relational import Equality
+from itertools import islice, takewhile
+from sympy.series.formal import fps
+from sympy.series.fourier import fourier_series
+from sympy.calculus.util import minimum
+
+
+EmptySet = S.EmptySet
+R = Rational
+x, y, z = symbols('x y z')
+i, j, k, l, m, n = symbols('i j k l m n', integer=True)
+f = Function('f')
+g = Function('g')
+
+# A. Boolean Logic and Quantifier Elimination
+#   Not implemented.
+
+# B. Set Theory
+
+
+def test_B1():
+    assert (FiniteSet(i, j, j, k, k, k) | FiniteSet(l, k, j) |
+            FiniteSet(j, m, j)) == FiniteSet(i, j, k, l, m)
+
+
+def test_B2():
+    assert (FiniteSet(i, j, j, k, k, k) & FiniteSet(l, k, j) &
+            FiniteSet(j, m, j)) == Intersection({j, m}, {i, j, k}, {j, k, l})
+    # Previous output below. Not sure why that should be the expected output.
+    # There should probably be a way to rewrite Intersections that way but I
+    # don't see why an Intersection should evaluate like that:
+    #
+    # == Union({j}, Intersection({m}, Union({j, k}, Intersection({i}, {l}))))
+
+
+def test_B3():
+    assert (FiniteSet(i, j, k, l, m) - FiniteSet(j) ==
+            FiniteSet(i, k, l, m))
+
+
+def test_B4():
+    assert (FiniteSet(*(FiniteSet(i, j)*FiniteSet(k, l))) ==
+            FiniteSet((i, k), (i, l), (j, k), (j, l)))
+
+
+# C. Numbers
+
+
+def test_C1():
+    assert (factorial(50) ==
+        30414093201713378043612608166064768844377641568960512000000000000)
+
+
+def test_C2():
+    assert (factorint(factorial(50)) == {2: 47, 3: 22, 5: 12, 7: 8,
+        11: 4, 13: 3, 17: 2, 19: 2, 23: 2, 29: 1, 31: 1, 37: 1,
+        41: 1, 43: 1, 47: 1})
+
+
+def test_C3():
+    assert (factorial2(10), factorial2(9)) == (3840, 945)
+
+
+# Base conversions; not really implemented by SymPy
+# Whatever. Take credit!
+def test_C4():
+    assert 0xABC == 2748
+
+
+def test_C5():
+    assert 123 == int('234', 7)
+
+
+def test_C6():
+    assert int('677', 8) == int('1BF', 16) == 447
+
+
+def test_C7():
+    assert log(32768, 8) == 5
+
+
+def test_C8():
+    # Modular multiplicative inverse. Would be nice if divmod could do this.
+    assert ZZ.invert(5, 7) == 3
+    assert ZZ.invert(5, 6) == 5
+
+
+def test_C9():
+    assert igcd(igcd(1776, 1554), 5698) == 74
+
+
+def test_C10():
+    x = 0
+    for n in range(2, 11):
+        x += R(1, n)
+    assert x == R(4861, 2520)
+
+
+def test_C11():
+    assert R(1, 7) == S('0.[142857]')
+
+
+def test_C12():
+    assert R(7, 11) * R(22, 7) == 2
+
+
+def test_C13():
+    test = R(10, 7) * (1 + R(29, 1000)) ** R(1, 3)
+    good = 3 ** R(1, 3)
+    assert test == good
+
+
+def test_C14():
+    assert sqrtdenest(sqrt(2*sqrt(3) + 4)) == 1 + sqrt(3)
+
+
+def test_C15():
+    test = sqrtdenest(sqrt(14 + 3*sqrt(3 + 2*sqrt(5 - 12*sqrt(3 - 2*sqrt(2))))))
+    good = sqrt(2) + 3
+    assert test == good
+
+
+def test_C16():
+    test = sqrtdenest(sqrt(10 + 2*sqrt(6) + 2*sqrt(10) + 2*sqrt(15)))
+    good = sqrt(2) + sqrt(3) + sqrt(5)
+    assert test == good
+
+
+def test_C17():
+    test = radsimp((sqrt(3) + sqrt(2)) / (sqrt(3) - sqrt(2)))
+    good = 5 + 2*sqrt(6)
+    assert test == good
+
+
+def test_C18():
+    assert simplify((sqrt(-2 + sqrt(-5)) * sqrt(-2 - sqrt(-5))).expand(complex=True)) == 3
+
+
+@XFAIL
+def test_C19():
+    assert radsimp(simplify((90 + 34*sqrt(7)) ** R(1, 3))) == 3 + sqrt(7)
+
+
+def test_C20():
+    inside = (135 + 78*sqrt(3))
+    test = AlgebraicNumber((inside**R(2, 3) + 3) * sqrt(3) / inside**R(1, 3))
+    assert simplify(test) == AlgebraicNumber(12)
+
+
+def test_C21():
+    assert simplify(AlgebraicNumber((41 + 29*sqrt(2)) ** R(1, 5))) == \
+        AlgebraicNumber(1 + sqrt(2))
+
+
+@XFAIL
+def test_C22():
+    test = simplify(((6 - 4*sqrt(2))*log(3 - 2*sqrt(2)) + (3 - 2*sqrt(2))*log(17
+        - 12*sqrt(2)) + 32 - 24*sqrt(2)) / (48*sqrt(2) - 72))
+    good = sqrt(2)/3 - log(sqrt(2) - 1)/3
+    assert test == good
+
+
+def test_C23():
+    assert 2 * oo - 3 is oo
+
+
+@XFAIL
+def test_C24():
+    raise NotImplementedError("2**aleph_null == aleph_1")
+
+# D. Numerical Analysis
+
+
+def test_D1():
+    assert 0.0 / sqrt(2) == 0
+
+
+def test_D2():
+    assert str(exp(-1000000).evalf()) == '3.29683147808856e-434295'
+
+
+def test_D3():
+    assert exp(pi*sqrt(163)).evalf(50).num.ae(262537412640768744)
+
+
+def test_D4():
+    assert floor(R(-5, 3)) == -2
+    assert ceiling(R(-5, 3)) == -1
+
+
+@XFAIL
+def test_D5():
+    raise NotImplementedError("cubic_spline([1, 2, 4, 5], [1, 4, 2, 3], x)(3) == 27/8")
+
+
+@XFAIL
+def test_D6():
+    raise NotImplementedError("translate sum(a[i]*x**i, (i,1,n)) to FORTRAN")
+
+
+@XFAIL
+def test_D7():
+    raise NotImplementedError("translate sum(a[i]*x**i, (i,1,n)) to C")
+
+
+@XFAIL
+def test_D8():
+    # One way is to cheat by converting the sum to a string,
+    # and replacing the '[' and ']' with ''.
+    # E.g., horner(S(str(_).replace('[','').replace(']','')))
+    raise NotImplementedError("apply Horner's rule to sum(a[i]*x**i, (i,1,5))")
+
+
+@XFAIL
+def test_D9():
+    raise NotImplementedError("translate D8 to FORTRAN")
+
+
+@XFAIL
+def test_D10():
+    raise NotImplementedError("translate D8 to C")
+
+
+@XFAIL
+def test_D11():
+    #Is there a way to use count_ops?
+    raise NotImplementedError("flops(sum(product(f[i][k], (i,1,k)), (k,1,n)))")
+
+
+@XFAIL
+def test_D12():
+    assert (mpi(-4, 2) * x + mpi(1, 3)) ** 2 == mpi(-8, 16)*x**2 + mpi(-24, 12)*x + mpi(1, 9)
+
+
+@XFAIL
+def test_D13():
+    raise NotImplementedError("discretize a PDE: diff(f(x,t),t) == diff(diff(f(x,t),x),x)")
+
+# E. Statistics
+#   See scipy; all of this is numerical.
+
+# F. Combinatorial Theory.
+
+
+def test_F1():
+    assert rf(x, 3) == x*(1 + x)*(2 + x)
+
+
+def test_F2():
+    assert expand_func(binomial(n, 3)) == n*(n - 1)*(n - 2)/6
+
+
+@XFAIL
+def test_F3():
+    assert combsimp(2**n * factorial(n) * factorial2(2*n - 1)) == factorial(2*n)
+
+
+@XFAIL
+def test_F4():
+    assert combsimp(2**n * factorial(n) * product(2*k - 1, (k, 1, n))) == factorial(2*n)
+
+
+@XFAIL
+def test_F5():
+    assert gamma(n + R(1, 2)) / sqrt(pi) / factorial(n) == factorial(2*n)/2**(2*n)/factorial(n)**2
+
+
+def test_F6():
+    partTest = [p.copy() for p in partitions(4)]
+    partDesired = [{4: 1}, {1: 1, 3: 1}, {2: 2}, {1: 2, 2:1}, {1: 4}]
+    assert partTest == partDesired
+
+
+def test_F7():
+    assert partition(4) == 5
+
+
+def test_F8():
+    assert stirling(5, 2, signed=True) == -50  # if signed, then kind=1
+
+
+def test_F9():
+    assert totient(1776) == 576
+
+# G. Number Theory
+
+
+def test_G1():
+    assert list(primerange(999983, 1000004)) == [999983, 1000003]
+
+
+@XFAIL
+def test_G2():
+    raise NotImplementedError("find the primitive root of 191 == 19")
+
+
+@XFAIL
+def test_G3():
+    raise NotImplementedError("(a+b)**p mod p == a**p + b**p mod p; p prime")
+
+# ... G14 Modular equations are not implemented.
+
+def test_G15():
+    assert Rational(sqrt(3).evalf()).limit_denominator(15) == R(26, 15)
+    assert list(takewhile(lambda x: x.q <= 15, cf_c(cf_i(sqrt(3)))))[-1] == \
+        R(26, 15)
+
+
+def test_G16():
+    assert list(islice(cf_i(pi),10)) == [3, 7, 15, 1, 292, 1, 1, 1, 2, 1]
+
+
+def test_G17():
+    assert cf_p(0, 1, 23) == [4, [1, 3, 1, 8]]
+
+
+def test_G18():
+    assert cf_p(1, 2, 5) == [[1]]
+    assert cf_r([[1]]).expand() == S.Half + sqrt(5)/2
+
+
+@XFAIL
+def test_G19():
+    s = symbols('s', integer=True, positive=True)
+    it = cf_i((exp(1/s) - 1)/(exp(1/s) + 1))
+    assert list(islice(it, 5)) == [0, 2*s, 6*s, 10*s, 14*s]
+
+
+def test_G20():
+    s = symbols('s', integer=True, positive=True)
+    # Wester erroneously has this as -s + sqrt(s**2 + 1)
+    assert cf_r([[2*s]]) == s + sqrt(s**2 + 1)
+
+
+@XFAIL
+def test_G20b():
+    s = symbols('s', integer=True, positive=True)
+    assert cf_p(s, 1, s**2 + 1) == [[2*s]]
+
+
+# H. Algebra
+
+
+def test_H1():
+    assert simplify(2*2**n) == simplify(2**(n + 1))
+    assert powdenest(2*2**n) == simplify(2**(n + 1))
+
+
+def test_H2():
+    assert powsimp(4 * 2**n) == 2**(n + 2)
+
+
+def test_H3():
+    assert (-1)**(n*(n + 1)) == 1
+
+
+def test_H4():
+    expr = factor(6*x - 10)
+    assert type(expr) is Mul
+    assert expr.args[0] == 2
+    assert expr.args[1] == 3*x - 5
+
+p1 = 64*x**34 - 21*x**47 - 126*x**8 - 46*x**5 - 16*x**60 - 81
+p2 = 72*x**60 - 25*x**25 - 19*x**23 - 22*x**39 - 83*x**52 + 54*x**10 + 81
+q = 34*x**19 - 25*x**16 + 70*x**7 + 20*x**3 - 91*x - 86
+
+
+def test_H5():
+    assert gcd(p1, p2, x) == 1
+
+
+def test_H6():
+    assert gcd(expand(p1 * q), expand(p2 * q)) == q
+
+
+def test_H7():
+    p1 = 24*x*y**19*z**8 - 47*x**17*y**5*z**8 + 6*x**15*y**9*z**2 - 3*x**22 + 5
+    p2 = 34*x**5*y**8*z**13 + 20*x**7*y**7*z**7 + 12*x**9*y**16*z**4 + 80*y**14*z
+    assert gcd(p1, p2, x, y, z) == 1
+
+
+def test_H8():
+    p1 = 24*x*y**19*z**8 - 47*x**17*y**5*z**8 + 6*x**15*y**9*z**2 - 3*x**22 + 5
+    p2 = 34*x**5*y**8*z**13 + 20*x**7*y**7*z**7 + 12*x**9*y**16*z**4 + 80*y**14*z
+    q = 11*x**12*y**7*z**13 - 23*x**2*y**8*z**10 + 47*x**17*y**5*z**8
+    assert gcd(p1 * q, p2 * q, x, y, z) == q
+
+
+def test_H9():
+    x = Symbol('x', zero=False)
+    p1 = 2*x**(n + 4) - x**(n + 2)
+    p2 = 4*x**(n + 1) + 3*x**n
+    assert gcd(p1, p2) == x**n
+
+
+def test_H10():
+    p1 = 3*x**4 + 3*x**3 + x**2 - x - 2
+    p2 = x**3 - 3*x**2 + x + 5
+    assert resultant(p1, p2, x) == 0
+
+
+def test_H11():
+    assert resultant(p1 * q, p2 * q, x) == 0
+
+
+def test_H12():
+    num = x**2 - 4
+    den = x**2 + 4*x + 4
+    assert simplify(num/den) == (x - 2)/(x + 2)
+
+
+@XFAIL
+def test_H13():
+    assert simplify((exp(x) - 1) / (exp(x/2) + 1)) == exp(x/2) - 1
+
+
+def test_H14():
+    p = (x + 1) ** 20
+    ep = expand(p)
+    assert ep == (1 + 20*x + 190*x**2 + 1140*x**3 + 4845*x**4 + 15504*x**5
+        + 38760*x**6 + 77520*x**7 + 125970*x**8 + 167960*x**9 + 184756*x**10
+        + 167960*x**11 + 125970*x**12 + 77520*x**13 + 38760*x**14 + 15504*x**15
+        + 4845*x**16 + 1140*x**17 + 190*x**18 + 20*x**19 + x**20)
+    dep = diff(ep, x)
+    assert dep == (20 + 380*x + 3420*x**2 + 19380*x**3 + 77520*x**4
+        + 232560*x**5 + 542640*x**6 + 1007760*x**7 + 1511640*x**8 + 1847560*x**9
+        + 1847560*x**10 + 1511640*x**11 + 1007760*x**12 + 542640*x**13
+        + 232560*x**14 + 77520*x**15 + 19380*x**16 + 3420*x**17 + 380*x**18
+        + 20*x**19)
+    assert factor(dep) == 20*(1 + x)**19
+
+
+def test_H15():
+    assert simplify(Mul(*[x - r for r in solveset(x**3 + x**2 - 7)])) == x**3 + x**2 - 7
+
+
+def test_H16():
+    assert factor(x**100 - 1) == ((x - 1)*(x + 1)*(x**2 + 1)*(x**4 - x**3
+        + x**2 - x + 1)*(x**4 + x**3 + x**2 + x + 1)*(x**8 - x**6 + x**4
+        - x**2 + 1)*(x**20 - x**15 + x**10 - x**5 + 1)*(x**20 + x**15 + x**10
+        + x**5 + 1)*(x**40 - x**30 + x**20 - x**10 + 1))
+
+
+def test_H17():
+    assert simplify(factor(expand(p1 * p2)) - p1*p2) == 0
+
+
+@XFAIL
+def test_H18():
+    # Factor over complex rationals.
+    test = factor(4*x**4 + 8*x**3 + 77*x**2 + 18*x + 153)
+    good = (2*x + 3*I)*(2*x - 3*I)*(x + 1 - 4*I)*(x + 1 + 4*I)
+    assert test == good
+
+
+def test_H19():
+    a = symbols('a')
+    # The idea is to let a**2 == 2, then solve 1/(a-1). Answer is a+1")
+    assert Poly(a - 1).invert(Poly(a**2 - 2)) == a + 1
+
+
+@XFAIL
+def test_H20():
+    raise NotImplementedError("let a**2==2; (x**3 + (a-2)*x**2 - "
+        + "(2*a+3)*x - 3*a) / (x**2-2) = (x**2 - 2*x - 3) / (x-a)")
+
+
+@XFAIL
+def test_H21():
+    raise NotImplementedError("evaluate (b+c)**4 assuming b**3==2, c**2==3. \
+                              Answer is 2*b + 8*c + 18*b**2 + 12*b*c + 9")
+
+
+def test_H22():
+    assert factor(x**4 - 3*x**2 + 1, modulus=5) == (x - 2)**2 * (x + 2)**2
+
+
+def test_H23():
+    f = x**11 + x + 1
+    g = (x**2 + x + 1) * (x**9 - x**8 + x**6 - x**5 + x**3 - x**2 + 1)
+    assert factor(f, modulus=65537) == g
+
+
+def test_H24():
+    phi = AlgebraicNumber(S.GoldenRatio.expand(func=True), alias='phi')
+    assert factor(x**4 - 3*x**2 + 1, extension=phi) == \
+        (x - phi)*(x + 1 - phi)*(x - 1 + phi)*(x + phi)
+
+
+def test_H25():
+    e = (x - 2*y**2 + 3*z**3) ** 20
+    assert factor(expand(e)) == e
+
+
+def test_H26():
+    g = expand((sin(x) - 2*cos(y)**2 + 3*tan(z)**3)**20)
+    assert factor(g, expand=False) == (-sin(x) + 2*cos(y)**2 - 3*tan(z)**3)**20
+
+
+def test_H27():
+    f = 24*x*y**19*z**8 - 47*x**17*y**5*z**8 + 6*x**15*y**9*z**2 - 3*x**22 + 5
+    g = 34*x**5*y**8*z**13 + 20*x**7*y**7*z**7 + 12*x**9*y**16*z**4 + 80*y**14*z
+    h = -2*z*y**7 \
+        *(6*x**9*y**9*z**3 + 10*x**7*z**6 + 17*y*x**5*z**12 + 40*y**7) \
+        *(3*x**22 + 47*x**17*y**5*z**8 - 6*x**15*y**9*z**2 - 24*x*y**19*z**8 - 5)
+    assert factor(expand(f*g)) == h
+
+
+@XFAIL
+def test_H28():
+    raise NotImplementedError("expand ((1 - c**2)**5 * (1 - s**2)**5 * "
+        + "(c**2 + s**2)**10) with c**2 + s**2 = 1. Answer is c**10*s**10.")
+
+
+@XFAIL
+def test_H29():
+    assert factor(4*x**2 - 21*x*y + 20*y**2, modulus=3) == (x + y)*(x - y)
+
+
+def test_H30():
+    test = factor(x**3 + y**3, extension=sqrt(-3))
+    answer = (x + y)*(x + y*(-R(1, 2) - sqrt(3)/2*I))*(x + y*(-R(1, 2) + sqrt(3)/2*I))
+    assert answer == test
+
+
+def test_H31():
+    f = (x**2 + 2*x + 3)/(x**3 + 4*x**2 + 5*x + 2)
+    g = 2 / (x + 1)**2 - 2 / (x + 1) + 3 / (x + 2)
+    assert apart(f) == g
+
+
+@XFAIL
+def test_H32():  # issue 6558
+    raise NotImplementedError("[A*B*C - (A*B*C)**(-1)]*A*C*B (product \
+                              of a non-commuting product and its inverse)")
+
+
+def test_H33():
+    A, B, C = symbols('A, B, C', commutative=False)
+    assert (Commutator(A, Commutator(B, C))
+        + Commutator(B, Commutator(C, A))
+        + Commutator(C, Commutator(A, B))).doit().expand() == 0
+
+
+# I. Trigonometry
+
+def test_I1():
+    assert tan(pi*R(7, 10)) == -sqrt(1 + 2/sqrt(5))
+
+
+@XFAIL
+def test_I2():
+    assert sqrt((1 + cos(6))/2) == -cos(3)
+
+
+def test_I3():
+    assert cos(n*pi) + sin((4*n - 1)*pi/2) == (-1)**n - 1
+
+
+def test_I4():
+    assert refine(cos(pi*cos(n*pi)) + sin(pi/2*cos(n*pi)), Q.integer(n)) == (-1)**n - 1
+
+
+@XFAIL
+def test_I5():
+    assert sin((n**5/5 + n**4/2 + n**3/3 - n/30) * pi) == 0
+
+
+@XFAIL
+def test_I6():
+    raise NotImplementedError("assuming -3*pi<x<-5*pi/2, abs(cos(x)) == -cos(x), abs(sin(x)) == -sin(x)")
+
+
+@XFAIL
+def test_I7():
+    assert cos(3*x)/cos(x) == cos(x)**2 - 3*sin(x)**2
+
+
+@XFAIL
+def test_I8():
+    assert cos(3*x)/cos(x) == 2*cos(2*x) - 1
+
+
+@XFAIL
+def test_I9():
+    # Supposed to do this with rewrite rules.
+    assert cos(3*x)/cos(x) == cos(x)**2 - 3*sin(x)**2
+
+
+def test_I10():
+    assert trigsimp((tan(x)**2 + 1 - cos(x)**-2) / (sin(x)**2 + cos(x)**2 - 1)) is nan
+
+
+@SKIP("hangs")
+@XFAIL
+def test_I11():
+    assert limit((tan(x)**2 + 1 - cos(x)**-2) / (sin(x)**2 + cos(x)**2 - 1), x, 0) != 0
+
+
+@XFAIL
+def test_I12():
+    # This should fail or return nan or something.
+    res = diff((tan(x)**2 + 1 - cos(x)**-2) / (sin(x)**2 + cos(x)**2 - 1), x)
+    assert res is nan # trigsimp(res) gives nan
+
+# J. Special functions.
+
+
+def test_J1():
+    assert bernoulli(16) == R(-3617, 510)
+
+
+def test_J2():
+    assert diff(elliptic_e(x, y**2), y) == (elliptic_e(x, y**2) - elliptic_f(x, y**2))/y
+
+
+@XFAIL
+def test_J3():
+    raise NotImplementedError("Jacobi elliptic functions: diff(dn(u,k), u) == -k**2*sn(u,k)*cn(u,k)")
+
+
+def test_J4():
+    assert gamma(R(-1, 2)) == -2*sqrt(pi)
+
+
+def test_J5():
+    assert polygamma(0, R(1, 3)) == -log(3) - sqrt(3)*pi/6 - EulerGamma - log(sqrt(3))
+
+
+def test_J6():
+    assert mpmath.besselj(2, 1 + 1j).ae(mpc('0.04157988694396212', '0.24739764151330632'))
+
+
+def test_J7():
+    assert simplify(besselj(R(-5,2), pi/2)) == 12/(pi**2)
+
+
+def test_J8():
+    p = besselj(R(3,2), z)
+    q = (sin(z)/z - cos(z))/sqrt(pi*z/2)
+    assert simplify(expand_func(p) -q) == 0
+
+
+def test_J9():
+    assert besselj(0, z).diff(z) == - besselj(1, z)
+
+
+def test_J10():
+    mu, nu = symbols('mu, nu', integer=True)
+    assert assoc_legendre(nu, mu, 0) == 2**mu*sqrt(pi)/gamma((nu - mu)/2 + 1)/gamma((-nu - mu + 1)/2)
+
+
+def test_J11():
+    assert simplify(assoc_legendre(3, 1, x)) == simplify(-R(3, 2)*sqrt(1 - x**2)*(5*x**2 - 1))
+
+
+@slow
+def test_J12():
+    assert simplify(chebyshevt(1008, x) - 2*x*chebyshevt(1007, x) + chebyshevt(1006, x)) == 0
+
+
+def test_J13():
+    a = symbols('a', integer=True, negative=False)
+    assert chebyshevt(a, -1) == (-1)**a
+
+
+def test_J14():
+    p = hyper([S.Half, S.Half], [R(3, 2)], z**2)
+    assert hyperexpand(p) == asin(z)/z
+
+
+@XFAIL
+def test_J15():
+    raise NotImplementedError("F((n+2)/2,-(n-2)/2,R(3,2),sin(z)**2) == sin(n*z)/(n*sin(z)*cos(z)); F(.) is hypergeometric function")
+
+
+@XFAIL
+def test_J16():
+    raise NotImplementedError("diff(zeta(x), x) @ x=0 == -log(2*pi)/2")
+
+
+def test_J17():
+    assert integrate(f((x + 2)/5)*DiracDelta((x - 2)/3) - g(x)*diff(DiracDelta(x - 1), x), (x, 0, 3)) == 3*f(R(4, 5)) + Subs(Derivative(g(x), x), x, 1)
+
+
+@XFAIL
+def test_J18():
+    raise NotImplementedError("define an antisymmetric function")
+
+
+# K. The Complex Domain
+
+def test_K1():
+    z1, z2 = symbols('z1, z2', complex=True)
+    assert re(z1 + I*z2) == -im(z2) + re(z1)
+    assert im(z1 + I*z2) == im(z1) + re(z2)
+
+
+def test_K2():
+    assert abs(3 - sqrt(7) + I*sqrt(6*sqrt(7) - 15)) == 1
+
+
+@XFAIL
+def test_K3():
+    a, b = symbols('a, b', real=True)
+    assert simplify(abs(1/(a + I/a + I*b))) == 1/sqrt(a**2 + (I/a + b)**2)
+
+
+def test_K4():
+    assert log(3 + 4*I).expand(complex=True) == log(5) + I*atan(R(4, 3))
+
+
+def test_K5():
+    x, y = symbols('x, y', real=True)
+    assert tan(x + I*y).expand(complex=True) == (sin(2*x)/(cos(2*x) +
+        cosh(2*y)) + I*sinh(2*y)/(cos(2*x) + cosh(2*y)))
+
+
+def test_K6():
+    assert sqrt(x*y*abs(z)**2)/(sqrt(x)*abs(z)) == sqrt(x*y)/sqrt(x)
+    assert sqrt(x*y*abs(z)**2)/(sqrt(x)*abs(z)) != sqrt(y)
+
+
+def test_K7():
+    y = symbols('y', real=True, negative=False)
+    expr = sqrt(x*y*abs(z)**2)/(sqrt(x)*abs(z))
+    sexpr = simplify(expr)
+    assert sexpr == sqrt(y)
+
+
+def test_K8():
+    z = symbols('z', complex=True)
+    assert simplify(sqrt(1/z) - 1/sqrt(z)) != 0  # Passes
+    z = symbols('z', complex=True, negative=False)
+    assert simplify(sqrt(1/z) - 1/sqrt(z)) == 0  # Fails
+
+
+def test_K9():
+    z = symbols('z', positive=True)
+    assert simplify(sqrt(1/z) - 1/sqrt(z)) == 0
+
+
+def test_K10():
+    z = symbols('z', negative=True)
+    assert simplify(sqrt(1/z) + 1/sqrt(z)) == 0
+
+# This goes up to K25
+
+# L. Determining Zero Equivalence
+
+
+def test_L1():
+    assert sqrt(997) - (997**3)**R(1, 6) == 0
+
+
+def test_L2():
+    assert sqrt(999983) - (999983**3)**R(1, 6) == 0
+
+
+def test_L3():
+    assert simplify((2**R(1, 3) + 4**R(1, 3))**3 - 6*(2**R(1, 3) + 4**R(1, 3)) - 6) == 0
+
+
+def test_L4():
+    assert trigsimp(cos(x)**3 + cos(x)*sin(x)**2 - cos(x)) == 0
+
+
+@XFAIL
+def test_L5():
+    assert log(tan(R(1, 2)*x + pi/4)) - asinh(tan(x)) == 0
+
+
+def test_L6():
+    assert (log(tan(x/2 + pi/4)) - asinh(tan(x))).diff(x).subs({x: 0}) == 0
+
+
+@XFAIL
+def test_L7():
+    assert simplify(log((2*sqrt(x) + 1)/(sqrt(4*x + 4*sqrt(x) + 1)))) == 0
+
+
+@XFAIL
+def test_L8():
+    assert simplify((4*x + 4*sqrt(x) + 1)**(sqrt(x)/(2*sqrt(x) + 1)) \
+        *(2*sqrt(x) + 1)**(1/(2*sqrt(x) + 1)) - 2*sqrt(x) - 1) == 0
+
+
+@XFAIL
+def test_L9():
+    z = symbols('z', complex=True)
+    assert simplify(2**(1 - z)*gamma(z)*zeta(z)*cos(z*pi/2) - pi**2*zeta(1 - z)) == 0
+
+# M. Equations
+
+
+@XFAIL
+def test_M1():
+    assert Equality(x, 2)/2 + Equality(1, 1) == Equality(x/2 + 1, 2)
+
+
+def test_M2():
+    # The roots of this equation should all be real. Note that this
+    # doesn't test that they are correct.
+    sol = solveset(3*x**3 - 18*x**2 + 33*x - 19, x)
+    assert all(s.expand(complex=True).is_real for s in sol)
+
+
+@XFAIL
+def test_M5():
+    assert solveset(x**6 - 9*x**4 - 4*x**3 + 27*x**2 - 36*x - 23, x) == FiniteSet(2**(1/3) + sqrt(3), 2**(1/3) - sqrt(3), +sqrt(3) - 1/2**(2/3) + I*sqrt(3)/2**(2/3), +sqrt(3) - 1/2**(2/3) - I*sqrt(3)/2**(2/3), -sqrt(3) - 1/2**(2/3) + I*sqrt(3)/2**(2/3), -sqrt(3) - 1/2**(2/3) - I*sqrt(3)/2**(2/3))
+
+
+def test_M6():
+    assert set(solveset(x**7 - 1, x)) == \
+        {cos(n*pi*R(2, 7)) + I*sin(n*pi*R(2, 7)) for n in range(0, 7)}
+    # The paper asks for exp terms, but sin's and cos's may be acceptable;
+    # if the results are simplified, exp terms appear for all but
+    # -sin(pi/14) - I*cos(pi/14) and -sin(pi/14) + I*cos(pi/14) which
+    # will simplify if you apply the transformation foo.rewrite(exp).expand()
+
+
+def test_M7():
+    # TODO: Replace solve with solveset, as of now test fails for solveset
+    assert set(solve(x**8 - 8*x**7 + 34*x**6 - 92*x**5 + 175*x**4 - 236*x**3 +
+        226*x**2 - 140*x + 46, x)) == {
+        1 - sqrt(2)*I*sqrt(-sqrt(-3 + 4*sqrt(3)) + 3)/2,
+        1 - sqrt(2)*sqrt(-3 + I*sqrt(3 + 4*sqrt(3)))/2,
+        1 - sqrt(2)*I*sqrt(sqrt(-3 + 4*sqrt(3)) + 3)/2,
+        1 - sqrt(2)*sqrt(-3 - I*sqrt(3 + 4*sqrt(3)))/2,
+        1 + sqrt(2)*I*sqrt(sqrt(-3 + 4*sqrt(3)) + 3)/2,
+        1 + sqrt(2)*sqrt(-3 - I*sqrt(3 + 4*sqrt(3)))/2,
+        1 + sqrt(2)*sqrt(-3 + I*sqrt(3 + 4*sqrt(3)))/2,
+        1 + sqrt(2)*I*sqrt(-sqrt(-3 + 4*sqrt(3)) + 3)/2,
+        }
+
+
+@XFAIL  # There are an infinite number of solutions.
+def test_M8():
+    x = Symbol('x')
+    z = symbols('z', complex=True)
+    assert solveset(exp(2*x) + 2*exp(x) + 1 - z, x, S.Reals) == \
+        FiniteSet(log(1 + z - 2*sqrt(z))/2, log(1 + z + 2*sqrt(z))/2)
+    # This one could be simplified better (the 1/2 could be pulled into the log
+    # as a sqrt, and the function inside the log can be factored as a square,
+    # giving [log(sqrt(z) - 1), log(sqrt(z) + 1)]). Also, there should be an
+    # infinite number of solutions.
+    # x = {log(sqrt(z) - 1), log(sqrt(z) + 1) + i pi} [+ n 2 pi i, + n 2 pi i]
+    # where n is an arbitrary integer.  See url of detailed output above.
+
+
+@XFAIL
+def test_M9():
+    # x = symbols('x')
+    # solutions are 1/2*(1 +/- sqrt(9 + 8*I*pi*n)) for integer n
+    raise NotImplementedError("solveset(exp(2-x**2)-exp(-x),x) has complex solutions.")
+
+
+def test_M10():
+    # TODO: Replace solve with solveset when it gives Lambert solution
+    assert solve(exp(x) - x, x) == [-LambertW(-1)]
+
+
+@XFAIL
+def test_M11():
+    assert solveset(x**x - x, x) == FiniteSet(-1, 1)
+
+
+def test_M12():
+    # TODO: x = [-1, 2*(+/-asinh(1)*I + n*pi}, 3*(pi/6 + n*pi/3)]
+    # TODO: Replace solve with solveset, as of now test fails for solveset
+    assert solve((x + 1)*(sin(x)**2 + 1)**2*cos(3*x)**3, x) == [
+        -1, pi/6, pi/2,
+           - I*log(1 + sqrt(2)),      I*log(1 + sqrt(2)),
+        pi - I*log(1 + sqrt(2)), pi + I*log(1 + sqrt(2)),
+    ]
+
+
+@XFAIL
+def test_M13():
+    n = Dummy('n')
+    assert solveset_real(sin(x) - cos(x), x) == ImageSet(Lambda(n, n*pi - pi*R(7, 4)), S.Integers)
+
+
+@XFAIL
+def test_M14():
+    n = Dummy('n')
+    assert solveset_real(tan(x) - 1, x) == ImageSet(Lambda(n, n*pi + pi/4), S.Integers)
+
+
+def test_M15():
+    n = Dummy('n')
+    got = solveset(sin(x) - S.Half)
+    assert any(got.dummy_eq(i) for i in (
+        Union(ImageSet(Lambda(n, 2*n*pi + pi/6), S.Integers),
+        ImageSet(Lambda(n, 2*n*pi + pi*R(5, 6)), S.Integers)),
+        Union(ImageSet(Lambda(n, 2*n*pi + pi*R(5, 6)), S.Integers),
+        ImageSet(Lambda(n, 2*n*pi + pi/6), S.Integers))))
+
+
+@XFAIL
+def test_M16():
+    n = Dummy('n')
+    assert solveset(sin(x) - tan(x), x) == ImageSet(Lambda(n, n*pi), S.Integers)
+
+
+@XFAIL
+def test_M17():
+    assert solveset_real(asin(x) - atan(x), x) == FiniteSet(0)
+
+
+@XFAIL
+def test_M18():
+    assert solveset_real(acos(x) - atan(x), x) == FiniteSet(sqrt((sqrt(5) - 1)/2))
+
+
+def test_M19():
+    # TODO: Replace solve with solveset, as of now test fails for solveset
+    assert solve((x - 2)/x**R(1, 3), x) == [2]
+
+
+def test_M20():
+    assert solveset(sqrt(x**2 + 1) - x + 2, x) == EmptySet
+
+
+def test_M21():
+    assert solveset(x + sqrt(x) - 2) == FiniteSet(1)
+
+
+def test_M22():
+    assert solveset(2*sqrt(x) + 3*x**R(1, 4) - 2) == FiniteSet(R(1, 16))
+
+
+def test_M23():
+    x = symbols('x', complex=True)
+    # TODO: Replace solve with solveset, as of now test fails for solveset
+    assert solve(x - 1/sqrt(1 + x**2)) == [
+        -I*sqrt(S.Half + sqrt(5)/2), sqrt(Rational(-1, 2) + sqrt(5)/2)]
+
+
+def test_M24():
+    # TODO: Replace solve with solveset, as of now test fails for solveset
+    solution = solve(1 - binomial(m, 2)*2**k, k)
+    answer = log(2/(m*(m - 1)), 2)
+    assert solution[0].expand() == answer.expand()
+
+
+def test_M25():
+    a, b, c, d = symbols(':d', positive=True)
+    x = symbols('x')
+    # TODO: Replace solve with solveset, as of now test fails for solveset
+    assert solve(a*b**x - c*d**x, x)[0].expand() == (log(c/a)/log(b/d)).expand()
+
+
+def test_M26():
+    # TODO: Replace solve with solveset, as of now test fails for solveset
+    assert solve(sqrt(log(x)) - log(sqrt(x))) == [1, exp(4)]
+
+
+def test_M27():
+    x = symbols('x', real=True)
+    b = symbols('b', real=True)
+    # TODO: Replace solve with solveset which gives both [+/- current answer]
+    # note that there is a typo in this test in the wester.pdf; there is no
+    # real solution for the equation as it appears in wester.pdf
+    assert solve(log(acos(asin(x**R(2, 3) - b)) - 1) + 2, x
+        ) == [(b + sin(cos(exp(-2) + 1)))**R(3, 2)]
+
+
+@XFAIL
+def test_M28():
+    assert solveset_real(5*x + exp((x - 5)/2) - 8*x**3, x, assume=Q.real(x)) == [-0.784966, -0.016291, 0.802557]
+
+
+def test_M29():
+    x = symbols('x')
+    assert solveset(abs(x - 1) - 2, domain=S.Reals) == FiniteSet(-1, 3)
+
+
+def test_M30():
+    # TODO: Replace solve with solveset, as of now
+    # solveset doesn't supports assumptions
+    # assert solve(abs(2*x + 5) - abs(x - 2),x, assume=Q.real(x)) == [-1, -7]
+    assert solveset_real(abs(2*x + 5) - abs(x - 2), x) == FiniteSet(-1, -7)
+
+
+def test_M31():
+    # TODO: Replace solve with solveset, as of now
+    # solveset doesn't supports assumptions
+    # assert solve(1 - abs(x) - max(-x - 2, x - 2),x, assume=Q.real(x)) == [-3/2, 3/2]
+    assert solveset_real(1 - abs(x) - Max(-x - 2, x - 2), x) == FiniteSet(R(-3, 2), R(3, 2))
+
+
+@XFAIL
+def test_M32():
+    # TODO: Replace solve with solveset, as of now
+    # solveset doesn't supports assumptions
+    assert solveset_real(Max(2 - x**2, x)- Max(-x, (x**3)/9), x) == FiniteSet(-1, 3)
+
+
+@XFAIL
+def test_M33():
+    # TODO: Replace solve with solveset, as of now
+    # solveset doesn't supports assumptions
+
+    # Second answer can be written in another form. The second answer is the root of x**3 + 9*x**2 - 18 = 0 in the interval (-2, -1).
+    assert solveset_real(Max(2 - x**2, x) - x**3/9, x) == FiniteSet(-3, -1.554894, 3)
+
+
+@XFAIL
+def test_M34():
+    z = symbols('z', complex=True)
+    assert solveset((1 + I) * z + (2 - I) * conjugate(z) + 3*I, z) == FiniteSet(2 + 3*I)
+
+
+def test_M35():
+    x, y = symbols('x y', real=True)
+    assert linsolve((3*x - 2*y - I*y + 3*I).as_real_imag(), y, x) == FiniteSet((3, 2))
+
+
+def test_M36():
+    # TODO: Replace solve with solveset, as of now
+    # solveset doesn't supports solving for function
+    # assert solve(f**2 + f - 2, x) == [Eq(f(x), 1), Eq(f(x), -2)]
+    assert solveset(f(x)**2 + f(x) - 2, f(x)) == FiniteSet(-2, 1)
+
+
+def test_M37():
+    assert linsolve([x + y + z - 6, 2*x + y + 2*z - 10, x + 3*y + z - 10 ], x, y, z) == \
+        FiniteSet((-z + 4, 2, z))
+
+
+def test_M38():
+    a, b, c = symbols('a, b, c')
+    domain = FracField([a, b, c], ZZ).to_domain()
+    ring = PolyRing('k1:50', domain)
+    (k1, k2, k3, k4, k5, k6, k7, k8, k9, k10,
+    k11, k12, k13, k14, k15, k16, k17, k18, k19, k20,
+    k21, k22, k23, k24, k25, k26, k27, k28, k29, k30,
+    k31, k32, k33, k34, k35, k36, k37, k38, k39, k40,
+    k41, k42, k43, k44, k45, k46, k47, k48, k49) = ring.gens
+
+    system = [
+        -b*k8/a + c*k8/a, -b*k11/a + c*k11/a, -b*k10/a + c*k10/a + k2, -k3 - b*k9/a + c*k9/a,
+        -b*k14/a + c*k14/a, -b*k15/a + c*k15/a, -b*k18/a + c*k18/a - k2, -b*k17/a + c*k17/a,
+        -b*k16/a + c*k16/a + k4, -b*k13/a + c*k13/a - b*k21/a + c*k21/a + b*k5/a - c*k5/a,
+        b*k44/a - c*k44/a, -b*k45/a + c*k45/a, -b*k20/a + c*k20/a, -b*k44/a + c*k44/a,
+        b*k46/a - c*k46/a, b**2*k47/a**2 - 2*b*c*k47/a**2 + c**2*k47/a**2, k3, -k4,
+        -b*k12/a + c*k12/a - a*k6/b + c*k6/b, -b*k19/a + c*k19/a + a*k7/c - b*k7/c,
+        b*k45/a - c*k45/a, -b*k46/a + c*k46/a, -k48 + c*k48/a + c*k48/b - c**2*k48/(a*b),
+        -k49 + b*k49/a + b*k49/c - b**2*k49/(a*c), a*k1/b - c*k1/b, a*k4/b - c*k4/b,
+        a*k3/b - c*k3/b + k9, -k10 + a*k2/b - c*k2/b, a*k7/b - c*k7/b, -k9, k11,
+        b*k12/a - c*k12/a + a*k6/b - c*k6/b, a*k15/b - c*k15/b, k10 + a*k18/b - c*k18/b,
+        -k11 + a*k17/b - c*k17/b, a*k16/b - c*k16/b, -a*k13/b + c*k13/b + a*k21/b - c*k21/b + a*k5/b - c*k5/b,
+        -a*k44/b + c*k44/b, a*k45/b - c*k45/b, a*k14/c - b*k14/c + a*k20/b - c*k20/b,
+        a*k44/b - c*k44/b, -a*k46/b + c*k46/b, -k47 + c*k47/a + c*k47/b - c**2*k47/(a*b),
+        a*k19/b - c*k19/b, -a*k45/b + c*k45/b, a*k46/b - c*k46/b, a**2*k48/b**2 - 2*a*c*k48/b**2 + c**2*k48/b**2,
+        -k49 + a*k49/b + a*k49/c - a**2*k49/(b*c), k16, -k17, -a*k1/c + b*k1/c,
+        -k16 - a*k4/c + b*k4/c, -a*k3/c + b*k3/c, k18 - a*k2/c + b*k2/c, b*k19/a - c*k19/a - a*k7/c + b*k7/c,
+        -a*k6/c + b*k6/c, -a*k8/c + b*k8/c, -a*k11/c + b*k11/c + k17, -a*k10/c + b*k10/c - k18,
+        -a*k9/c + b*k9/c, -a*k14/c + b*k14/c - a*k20/b + c*k20/b, -a*k13/c + b*k13/c + a*k21/c - b*k21/c - a*k5/c + b*k5/c,
+        a*k44/c - b*k44/c, -a*k45/c + b*k45/c, -a*k44/c + b*k44/c, a*k46/c - b*k46/c,
+        -k47 + b*k47/a + b*k47/c - b**2*k47/(a*c), -a*k12/c + b*k12/c, a*k45/c - b*k45/c,
+        -a*k46/c + b*k46/c, -k48 + a*k48/b + a*k48/c - a**2*k48/(b*c),
+        a**2*k49/c**2 - 2*a*b*k49/c**2 + b**2*k49/c**2, k8, k11, -k15, k10 - k18,
+        -k17, k9, -k16, -k29, k14 - k32, -k21 + k23 - k31, -k24 - k30, -k35, k44,
+        -k45, k36, k13 - k23 + k39, -k20 + k38, k25 + k37, b*k26/a - c*k26/a - k34 + k42,
+        -2*k44, k45, k46, b*k47/a - c*k47/a, k41, k44, -k46, -b*k47/a + c*k47/a,
+        k12 + k24, -k19 - k25, -a*k27/b + c*k27/b - k33, k45, -k46, -a*k48/b + c*k48/b,
+        a*k28/c - b*k28/c + k40, -k45, k46, a*k48/b - c*k48/b, a*k49/c - b*k49/c,
+        -a*k49/c + b*k49/c, -k1, -k4, -k3, k15, k18 - k2, k17, k16, k22, k25 - k7,
+        k24 + k30, k21 + k23 - k31, k28, -k44, k45, -k30 - k6, k20 + k32, k27 + b*k33/a - c*k33/a,
+        k44, -k46, -b*k47/a + c*k47/a, -k36, k31 - k39 - k5, -k32 - k38, k19 - k37,
+        k26 - a*k34/b + c*k34/b - k42, k44, -2*k45, k46, a*k48/b - c*k48/b,
+        a*k35/c - b*k35/c - k41, -k44, k46, b*k47/a - c*k47/a, -a*k49/c + b*k49/c,
+        -k40, k45, -k46, -a*k48/b + c*k48/b, a*k49/c - b*k49/c, k1, k4, k3, -k8,
+        -k11, -k10 + k2, -k9, k37 + k7, -k14 - k38, -k22, -k25 - k37, -k24 + k6,
+        -k13 - k23 + k39, -k28 + b*k40/a - c*k40/a, k44, -k45, -k27, -k44, k46,
+        b*k47/a - c*k47/a, k29, k32 + k38, k31 - k39 + k5, -k12 + k30, k35 - a*k41/b + c*k41/b,
+        -k44, k45, -k26 + k34 + a*k42/c - b*k42/c, k44, k45, -2*k46, -b*k47/a + c*k47/a,
+        -a*k48/b + c*k48/b, a*k49/c - b*k49/c, k33, -k45, k46, a*k48/b - c*k48/b,
+        -a*k49/c + b*k49/c
+        ]
+    solution = {
+        k49: 0, k48: 0, k47: 0, k46: 0, k45: 0, k44: 0, k41: 0, k40: 0,
+        k38: 0, k37: 0, k36: 0, k35: 0, k33: 0, k32: 0, k30: 0, k29: 0,
+        k28: 0, k27: 0, k25: 0, k24: 0, k22: 0, k21: 0, k20: 0, k19: 0,
+        k18: 0, k17: 0, k16: 0, k15: 0, k14: 0, k13: 0, k12: 0, k11: 0,
+        k10: 0, k9:  0, k8:  0, k7:  0, k6:  0, k5:  0, k4:  0, k3:  0,
+        k2:  0, k1:  0,
+        k34: b/c*k42, k31: k39, k26: a/c*k42, k23: k39
+    }
+    assert solve_lin_sys(system, ring) == solution
+
+
+def test_M39():
+    x, y, z = symbols('x y z', complex=True)
+    # TODO: Replace solve with solveset, as of now
+    # solveset doesn't supports non-linear multivariate
+    assert solve([x**2*y + 3*y*z - 4, -3*x**2*z + 2*y**2 + 1, 2*y*z**2 - z**2 - 1 ]) ==\
+            [{y: 1, z: 1, x: -1}, {y: 1, z: 1, x: 1},\
+             {y: sqrt(2)*I, z: R(1,3) - sqrt(2)*I/3, x: -sqrt(-1 - sqrt(2)*I)},\
+             {y: sqrt(2)*I, z: R(1,3) - sqrt(2)*I/3, x: sqrt(-1 - sqrt(2)*I)},\
+             {y: -sqrt(2)*I, z: R(1,3) + sqrt(2)*I/3, x: -sqrt(-1 + sqrt(2)*I)},\
+             {y: -sqrt(2)*I, z: R(1,3) + sqrt(2)*I/3, x: sqrt(-1 + sqrt(2)*I)}]
+
+# N. Inequalities
+
+
+def test_N1():
+    assert ask(E**pi > pi**E)
+
+
+@XFAIL
+def test_N2():
+    x = symbols('x', real=True)
+    assert ask(x**4 - x + 1 > 0) is True
+    assert ask(x**4 - x + 1 > 1) is False
+
+
+@XFAIL
+def test_N3():
+    x = symbols('x', real=True)
+    assert ask(And(Lt(-1, x), Lt(x, 1)), abs(x) < 1 )
+
+@XFAIL
+def test_N4():
+    x, y = symbols('x y', real=True)
+    assert ask(2*x**2 > 2*y**2, (x > y) & (y > 0)) is True
+
+
+@XFAIL
+def test_N5():
+    x, y, k = symbols('x y k', real=True)
+    assert ask(k*x**2 > k*y**2, (x > y) & (y > 0) & (k > 0)) is True
+
+
+@slow
+@XFAIL
+def test_N6():
+    x, y, k, n = symbols('x y k n', real=True)
+    assert ask(k*x**n > k*y**n, (x > y) & (y > 0) & (k > 0) & (n > 0)) is True
+
+
+@XFAIL
+def test_N7():
+    x, y = symbols('x y', real=True)
+    assert ask(y > 0, (x > 1) & (y >= x - 1)) is True
+
+
+@XFAIL
+@slow
+def test_N8():
+    x, y, z = symbols('x y z', real=True)
+    assert ask(Eq(x, y) & Eq(y, z),
+               (x >= y) & (y >= z) & (z >= x))
+
+
+def test_N9():
+    x = Symbol('x')
+    assert solveset(abs(x - 1) > 2, domain=S.Reals) == Union(Interval(-oo, -1, False, True),
+                                             Interval(3, oo, True))
+
+
+def test_N10():
+    x = Symbol('x')
+    p = (x - 1)*(x - 2)*(x - 3)*(x - 4)*(x - 5)
+    assert solveset(expand(p) < 0, domain=S.Reals) == Union(Interval(-oo, 1, True, True),
+                                            Interval(2, 3, True, True),
+                                            Interval(4, 5, True, True))
+
+
+def test_N11():
+    x = Symbol('x')
+    assert solveset(6/(x - 3) <= 3, domain=S.Reals) == Union(Interval(-oo, 3, True, True), Interval(5, oo))
+
+
+def test_N12():
+    x = Symbol('x')
+    assert solveset(sqrt(x) < 2, domain=S.Reals) == Interval(0, 4, False, True)
+
+
+def test_N13():
+    x = Symbol('x')
+    assert solveset(sin(x) < 2, domain=S.Reals) == S.Reals
+
+
+@XFAIL
+def test_N14():
+    x = Symbol('x')
+    # Gives 'Union(Interval(Integer(0), Mul(Rational(1, 2), pi), false, true),
+    #        Interval(Mul(Rational(1, 2), pi), Mul(Integer(2), pi), true, false))'
+    # which is not the correct answer, but the provided also seems wrong.
+    assert solveset(sin(x) < 1, x, domain=S.Reals) == Union(Interval(-oo, pi/2, True, True),
+                                         Interval(pi/2, oo, True, True))
+
+
+def test_N15():
+    r, t = symbols('r t')
+    # raises NotImplementedError: only univariate inequalities are supported
+    solveset(abs(2*r*(cos(t) - 1) + 1) <= 1, r, S.Reals)
+
+
+def test_N16():
+    r, t = symbols('r t')
+    solveset((r**2)*((cos(t) - 4)**2)*sin(t)**2 < 9, r, S.Reals)
+
+
+@XFAIL
+def test_N17():
+    # currently only univariate inequalities are supported
+    assert solveset((x + y > 0, x - y < 0), (x, y)) == (abs(x) < y)
+
+
+def test_O1():
+    M = Matrix((1 + I, -2, 3*I))
+    assert sqrt(expand(M.dot(M.H))) == sqrt(15)
+
+
+def test_O2():
+    assert Matrix((2, 2, -3)).cross(Matrix((1, 3, 1))) == Matrix([[11],
+                                                                  [-5],
+                                                                  [4]])
+
+# The vector module has no way of representing vectors symbolically (without
+# respect to a basis)
+@XFAIL
+def test_O3():
+    # assert (va ^ vb) | (vc ^ vd) == -(va | vc)*(vb | vd) + (va | vd)*(vb | vc)
+    raise NotImplementedError("""The vector module has no way of representing
+        vectors symbolically (without respect to a basis)""")
+
+def test_O4():
+    from sympy.vector import CoordSys3D, Del
+    N = CoordSys3D("N")
+    delop = Del()
+    i, j, k = N.base_vectors()
+    x, y, z = N.base_scalars()
+    F = i*(x*y*z) + j*((x*y*z)**2) + k*((y**2)*(z**3))
+    assert delop.cross(F).doit() == (-2*x**2*y**2*z + 2*y*z**3)*i + x*y*j + (2*x*y**2*z**2 - x*z)*k
+
+@XFAIL
+def test_O5():
+    #assert grad|(f^g)-g|(grad^f)+f|(grad^g)  == 0
+    raise NotImplementedError("""The vector module has no way of representing
+        vectors symbolically (without respect to a basis)""")
+
+#testO8-O9 MISSING!!
+
+
+def test_O10():
+    L = [Matrix([2, 3, 5]), Matrix([3, 6, 2]), Matrix([8, 3, 6])]
+    assert GramSchmidt(L) == [Matrix([
+                              [2],
+                              [3],
+                              [5]]),
+                              Matrix([
+                              [R(23, 19)],
+                              [R(63, 19)],
+                              [R(-47, 19)]]),
+                              Matrix([
+                              [R(1692, 353)],
+                              [R(-1551, 706)],
+                              [R(-423, 706)]])]
+
+
+def test_P1():
+    assert Matrix(3, 3, lambda i, j: j - i).diagonal(-1) == Matrix(
+        1, 2, [-1, -1])
+
+
+def test_P2():
+    M = Matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
+    M.row_del(1)
+    M.col_del(2)
+    assert M == Matrix([[1, 2],
+                        [7, 8]])
+
+
+def test_P3():
+    A = Matrix([
+        [11, 12, 13, 14],
+        [21, 22, 23, 24],
+        [31, 32, 33, 34],
+        [41, 42, 43, 44]])
+
+    A11 = A[0:3, 1:4]
+    A12 = A[(0, 1, 3), (2, 0, 3)]
+    A21 = A
+    A221 = -A[0:2, 2:4]
+    A222 = -A[(3, 0), (2, 1)]
+    A22 = BlockMatrix([[A221, A222]]).T
+    rows = [[-A11, A12], [A21, A22]]
+    raises(ValueError, lambda: BlockMatrix(rows))
+    B = Matrix(rows)
+    assert B == Matrix([
+        [-12, -13, -14, 13, 11, 14],
+        [-22, -23, -24, 23, 21, 24],
+        [-32, -33, -34, 43, 41, 44],
+        [11, 12, 13, 14, -13, -23],
+        [21, 22, 23, 24, -14, -24],
+        [31, 32, 33, 34, -43, -13],
+        [41, 42, 43, 44, -42, -12]])
+
+
+@XFAIL
+def test_P4():
+    raise NotImplementedError("Block matrix diagonalization not supported")
+
+
+def test_P5():
+    M = Matrix([[7, 11],
+                [3, 8]])
+    assert  M % 2 == Matrix([[1, 1],
+                             [1, 0]])
+
+
+def test_P6():
+    M = Matrix([[cos(x), sin(x)],
+                [-sin(x), cos(x)]])
+    assert M.diff(x, 2) == Matrix([[-cos(x), -sin(x)],
+                                   [sin(x), -cos(x)]])
+
+
+def test_P7():
+    M = Matrix([[x, y]])*(
+        z*Matrix([[1, 3, 5],
+                  [2, 4, 6]]) + Matrix([[7, -9, 11],
+                                        [-8, 10, -12]]))
+    assert M == Matrix([[x*(z + 7) + y*(2*z - 8), x*(3*z - 9) + y*(4*z + 10),
+                         x*(5*z + 11) + y*(6*z - 12)]])
+
+
+def test_P8():
+    M = Matrix([[1, -2*I],
+                [-3*I, 4]])
+    assert M.norm(ord=S.Infinity) == 7
+
+
+def test_P9():
+    a, b, c = symbols('a b c', nonzero=True)
+    M = Matrix([[a/(b*c), 1/c, 1/b],
+                [1/c, b/(a*c), 1/a],
+                [1/b, 1/a, c/(a*b)]])
+    assert factor(M.norm('fro')) == (a**2 + b**2 + c**2)/(abs(a)*abs(b)*abs(c))
+
+
+@XFAIL
+def test_P10():
+    M = Matrix([[1, 2 + 3*I],
+                [f(4 - 5*I), 6]])
+    # conjugate(f(4 - 5*i)) is not simplified to f(4+5*I)
+    assert M.H == Matrix([[1, f(4 + 5*I)],
+                          [2 + 3*I, 6]])
+
+
+@XFAIL
+def test_P11():
+    # raises NotImplementedError("Matrix([[x,y],[1,x*y]]).inv()
+    #   not simplifying to extract common factor")
+    assert Matrix([[x, y],
+                   [1, x*y]]).inv() == (1/(x**2 - 1))*Matrix([[x, -1],
+                                                              [-1/y, x/y]])
+
+
+def test_P11_workaround():
+    # This test was changed to inverse method ADJ because it depended on the
+    # specific form of inverse returned from the 'GE' method which has changed.
+    M = Matrix([[x, y], [1, x*y]]).inv('ADJ')
+    c = gcd(tuple(M))
+    assert MatMul(c, M/c, evaluate=False) == MatMul(c, Matrix([
+        [x*y, -y],
+        [ -1,  x]]), evaluate=False)
+
+
+def test_P12():
+    A11 = MatrixSymbol('A11', n, n)
+    A12 = MatrixSymbol('A12', n, n)
+    A22 = MatrixSymbol('A22', n, n)
+    B = BlockMatrix([[A11, A12],
+                     [ZeroMatrix(n, n), A22]])
+    assert block_collapse(B.I) == BlockMatrix([[A11.I, (-1)*A11.I*A12*A22.I],
+                                               [ZeroMatrix(n, n), A22.I]])
+
+
+def test_P13():
+    M = Matrix([[1,     x - 2,                         x - 3],
+                [x - 1, x**2 - 3*x + 6,       x**2 - 3*x - 2],
+                [x - 2, x**2 - 8,       2*(x**2) - 12*x + 14]])
+    L, U, _ = M.LUdecomposition()
+    assert simplify(L) == Matrix([[1,     0,     0],
+                                  [x - 1, 1,     0],
+                                  [x - 2, x - 3, 1]])
+    assert simplify(U) == Matrix([[1, x - 2, x - 3],
+                                  [0,     4, x - 5],
+                                  [0,     0, x - 7]])
+
+
+def test_P14():
+    M = Matrix([[1, 2, 3, 1, 3],
+                [3, 2, 1, 1, 7],
+                [0, 2, 4, 1, 1],
+                [1, 1, 1, 1, 4]])
+    R, _ = M.rref()
+    assert R == Matrix([[1, 0, -1, 0,  2],
+                        [0, 1,  2, 0, -1],
+                        [0, 0,  0, 1,  3],
+                        [0, 0,  0, 0,  0]])
+
+
+def test_P15():
+    M = Matrix([[-1, 3,  7, -5],
+                [4, -2,  1,  3],
+                [2,  4, 15, -7]])
+    assert M.rank() == 2
+
+
+def test_P16():
+    M = Matrix([[2*sqrt(2), 8],
+                [6*sqrt(6), 24*sqrt(3)]])
+    assert M.rank() == 1
+
+
+def test_P17():
+    t = symbols('t', real=True)
+    M=Matrix([
+        [sin(2*t), cos(2*t)],
+        [2*(1 - (cos(t)**2))*cos(t), (1 - 2*(sin(t)**2))*sin(t)]])
+    assert M.rank() == 1
+
+
+def test_P18():
+    M = Matrix([[1,  0, -2, 0],
+                [-2, 1,  0, 3],
+                [-1, 2, -6, 6]])
+    assert M.nullspace() == [Matrix([[2],
+                                     [4],
+                                     [1],
+                                     [0]]),
+                             Matrix([[0],
+                                     [-3],
+                                     [0],
+                                     [1]])]
+
+
+def test_P19():
+    w = symbols('w')
+    M = Matrix([[1,    1,    1,    1],
+                [w,    x,    y,    z],
+                [w**2, x**2, y**2, z**2],
+                [w**3, x**3, y**3, z**3]])
+    assert M.det() == (w**3*x**2*y   - w**3*x**2*z - w**3*x*y**2 + w**3*x*z**2
+                       + w**3*y**2*z - w**3*y*z**2 - w**2*x**3*y + w**2*x**3*z
+                       + w**2*x*y**3 - w**2*x*z**3 - w**2*y**3*z + w**2*y*z**3
+                       + w*x**3*y**2 - w*x**3*z**2 - w*x**2*y**3 + w*x**2*z**3
+                       + w*y**3*z**2 - w*y**2*z**3 - x**3*y**2*z + x**3*y*z**2
+                       + x**2*y**3*z - x**2*y*z**3 - x*y**3*z**2 + x*y**2*z**3
+                       )
+
+
+@XFAIL
+def test_P20():
+    raise NotImplementedError("Matrix minimal polynomial not supported")
+
+
+def test_P21():
+    M = Matrix([[5, -3, -7],
+                [-2, 1,  2],
+                [2, -3, -4]])
+    assert M.charpoly(x).as_expr() == x**3 - 2*x**2 - 5*x + 6
+
+
+def test_P22():
+    d = 100
+    M = (2 - x)*eye(d)
+    assert M.eigenvals() == {-x + 2: d}
+
+
+def test_P23():
+    M = Matrix([
+        [2, 1, 0, 0, 0],
+        [1, 2, 1, 0, 0],
+        [0, 1, 2, 1, 0],
+        [0, 0, 1, 2, 1],
+        [0, 0, 0, 1, 2]])
+    assert M.eigenvals() == {
+        S('1'): 1,
+        S('2'): 1,
+        S('3'): 1,
+        S('sqrt(3) + 2'): 1,
+        S('-sqrt(3) + 2'): 1}
+
+
+def test_P24():
+    M = Matrix([[611,  196, -192,  407,   -8,  -52,  -49,   29],
+                [196,  899,  113, -192,  -71,  -43,   -8,  -44],
+                [-192,  113,  899,  196,   61,   49,    8,   52],
+                [ 407, -192,  196,  611,    8,   44,   59,  -23],
+                [  -8,  -71,   61,    8,  411, -599,  208,  208],
+                [ -52,  -43,   49,   44, -599,  411,  208,  208],
+                [ -49,   -8,    8,   59,  208,  208,   99, -911],
+                [  29,  -44,   52,  -23,  208,  208, -911,   99]])
+    assert M.eigenvals() == {
+        S('0'): 1,
+        S('10*sqrt(10405)'): 1,
+        S('100*sqrt(26) + 510'): 1,
+        S('1000'): 2,
+        S('-100*sqrt(26) + 510'): 1,
+        S('-10*sqrt(10405)'): 1,
+        S('1020'): 1}
+
+
+def test_P25():
+    MF = N(Matrix([[ 611,  196, -192,  407,   -8,  -52,  -49,   29],
+                   [ 196,  899,  113, -192,  -71,  -43,   -8,  -44],
+                   [-192,  113,  899,  196,   61,   49,    8,   52],
+                   [ 407, -192,  196,  611,    8,   44,   59,  -23],
+                   [  -8,  -71,   61,    8,  411, -599,  208,  208],
+                   [ -52,  -43,   49,   44, -599,  411,  208,  208],
+                   [ -49,   -8,    8,   59,  208,  208,   99, -911],
+                   [  29,  -44,   52,  -23,  208,  208, -911,   99]]))
+
+    ev_1 = sorted(MF.eigenvals(multiple=True))
+    ev_2 = sorted(
+        [-1020.0490184299969, 0.0, 0.09804864072151699, 1000.0, 1000.0,
+        1019.9019513592784, 1020.0, 1020.0490184299969])
+
+    for x, y in zip(ev_1, ev_2):
+        assert abs(x - y) < 1e-12
+
+
+def test_P26():
+    a0, a1, a2, a3, a4 = symbols('a0 a1 a2 a3 a4')
+    M = Matrix([[-a4, -a3, -a2, -a1, -a0,  0,  0,  0,  0],
+                [  1,   0,   0,   0,   0,  0,  0,  0,  0],
+                [  0,   1,   0,   0,   0,  0,  0,  0,  0],
+                [  0,   0,   1,   0,   0,  0,  0,  0,  0],
+                [  0,   0,   0,   1,   0,  0,  0,  0,  0],
+                [  0,   0,   0,   0,   0, -1, -1,  0,  0],
+                [  0,   0,   0,   0,   0,  1,  0,  0,  0],
+                [  0,   0,   0,   0,   0,  0,  1, -1, -1],
+                [  0,   0,   0,   0,   0,  0,  0,  1,  0]])
+    assert M.eigenvals(error_when_incomplete=False) == {
+        S('-1/2 - sqrt(3)*I/2'): 2,
+        S('-1/2 + sqrt(3)*I/2'): 2}
+
+
+def test_P27():
+    a = symbols('a')
+    M = Matrix([[a,  0, 0, 0, 0],
+                [0,  0, 0, 0, 1],
+                [0,  0, a, 0, 0],
+                [0,  0, 0, a, 0],
+                [0, -2, 0, 0, 2]])
+
+    assert M.eigenvects() == [
+        (a, 3, [
+            Matrix([1, 0, 0, 0, 0]),
+            Matrix([0, 0, 1, 0, 0]),
+            Matrix([0, 0, 0, 1, 0])
+        ]),
+        (1 - I, 1, [
+            Matrix([0, (1 + I)/2, 0, 0, 1])
+        ]),
+        (1 + I, 1, [
+            Matrix([0, (1 - I)/2, 0, 0, 1])
+        ]),
+    ]
+
+
+@XFAIL
+def test_P28():
+    raise NotImplementedError("Generalized eigenvectors not supported \
+https://github.com/sympy/sympy/issues/5293")
+
+
+@XFAIL
+def test_P29():
+    raise NotImplementedError("Generalized eigenvectors not supported \
+https://github.com/sympy/sympy/issues/5293")
+
+
+def test_P30():
+    M = Matrix([[1,  0,  0,  1, -1],
+                [0,  1, -2,  3, -3],
+                [0,  0, -1,  2, -2],
+                [1, -1,  1,  0,  1],
+                [1, -1,  1, -1,  2]])
+    _, J = M.jordan_form()
+    assert J == Matrix([[-1, 0, 0, 0, 0],
+                        [0,  1, 1, 0, 0],
+                        [0,  0, 1, 0, 0],
+                        [0,  0, 0, 1, 1],
+                        [0,  0, 0, 0, 1]])
+
+
+@XFAIL
+def test_P31():
+    raise NotImplementedError("Smith normal form not implemented")
+
+
+def test_P32():
+    M = Matrix([[1, -2],
+                [2, 1]])
+    assert exp(M).rewrite(cos).simplify() == Matrix([[E*cos(2), -E*sin(2)],
+                                                     [E*sin(2),  E*cos(2)]])
+
+
+def test_P33():
+    w, t = symbols('w t')
+    M = Matrix([[0,    1,      0,   0],
+                [0,    0,      0, 2*w],
+                [0,    0,      0,   1],
+                [0, -2*w, 3*w**2,   0]])
+    assert exp(M*t).rewrite(cos).expand() == Matrix([
+        [1, -3*t + 4*sin(t*w)/w,  6*t*w - 6*sin(t*w), -2*cos(t*w)/w + 2/w],
+        [0,      4*cos(t*w) - 3, -6*w*cos(t*w) + 6*w,          2*sin(t*w)],
+        [0,  2*cos(t*w)/w - 2/w,     -3*cos(t*w) + 4,          sin(t*w)/w],
+        [0,         -2*sin(t*w),        3*w*sin(t*w),            cos(t*w)]])
+
+
+@XFAIL
+def test_P34():
+    a, b, c = symbols('a b c', real=True)
+    M = Matrix([[a, 1, 0, 0, 0, 0],
+                [0, a, 0, 0, 0, 0],
+                [0, 0, b, 0, 0, 0],
+                [0, 0, 0, c, 1, 0],
+                [0, 0, 0, 0, c, 1],
+                [0, 0, 0, 0, 0, c]])
+    # raises exception, sin(M) not supported. exp(M*I) also not supported
+    # https://github.com/sympy/sympy/issues/6218
+    assert sin(M) == Matrix([[sin(a), cos(a), 0, 0, 0, 0],
+                             [0, sin(a), 0, 0, 0, 0],
+                             [0, 0, sin(b), 0, 0, 0],
+                             [0, 0, 0, sin(c), cos(c), -sin(c)/2],
+                             [0, 0, 0, 0, sin(c), cos(c)],
+                             [0, 0, 0, 0, 0, sin(c)]])
+
+
+@XFAIL
+def test_P35():
+    M = pi/2*Matrix([[2, 1, 1],
+                     [2, 3, 2],
+                     [1, 1, 2]])
+    # raises exception, sin(M) not supported. exp(M*I) also not supported
+    # https://github.com/sympy/sympy/issues/6218
+    assert sin(M) == eye(3)
+
+
+@XFAIL
+def test_P36():
+    M = Matrix([[10, 7],
+                [7, 17]])
+    assert sqrt(M) == Matrix([[3, 1],
+                              [1, 4]])
+
+
+def test_P37():
+    M = Matrix([[1, 1, 0],
+                [0, 1, 0],
+                [0, 0, 1]])
+    assert M**S.Half == Matrix([[1, R(1, 2), 0],
+                                        [0, 1,       0],
+                                        [0, 0,       1]])
+
+
+@XFAIL
+def test_P38():
+    M=Matrix([[0, 1, 0],
+              [0, 0, 0],
+              [0, 0, 0]])
+
+    with raises(AssertionError):
+        # raises ValueError: Matrix det == 0; not invertible
+        M**S.Half
+        # if it doesn't raise then this assertion will be
+        # raised and the test will be flagged as not XFAILing
+        assert None
+
+@XFAIL
+def test_P39():
+    """
+    M=Matrix([
+        [1, 1],
+        [2, 2],
+        [3, 3]])
+    M.SVD()
+    """
+    raise NotImplementedError("Singular value decomposition not implemented")
+
+
+def test_P40():
+    r, t = symbols('r t', real=True)
+    M = Matrix([r*cos(t), r*sin(t)])
+    assert M.jacobian(Matrix([r, t])) == Matrix([[cos(t), -r*sin(t)],
+                                                 [sin(t),  r*cos(t)]])
+
+
+def test_P41():
+    r, t = symbols('r t', real=True)
+    assert hessian(r**2*sin(t),(r,t)) == Matrix([[  2*sin(t),   2*r*cos(t)],
+                                                 [2*r*cos(t), -r**2*sin(t)]])
+
+
+def test_P42():
+    assert wronskian([cos(x), sin(x)], x).simplify() == 1
+
+
+def test_P43():
+    def __my_jacobian(M, Y):
+        return Matrix([M.diff(v).T for v in Y]).T
+    r, t = symbols('r t', real=True)
+    M = Matrix([r*cos(t), r*sin(t)])
+    assert __my_jacobian(M,[r,t]) == Matrix([[cos(t), -r*sin(t)],
+                                             [sin(t),  r*cos(t)]])
+
+
+def test_P44():
+    def __my_hessian(f, Y):
+        V = Matrix([diff(f, v) for v in Y])
+        return  Matrix([V.T.diff(v) for v in Y])
+    r, t = symbols('r t', real=True)
+    assert __my_hessian(r**2*sin(t), (r, t)) == Matrix([
+                                            [  2*sin(t),   2*r*cos(t)],
+                                            [2*r*cos(t), -r**2*sin(t)]])
+
+
+def test_P45():
+    def __my_wronskian(Y, v):
+        M = Matrix([Matrix(Y).T.diff(x, n) for n in range(0, len(Y))])
+        return  M.det()
+    assert __my_wronskian([cos(x), sin(x)], x).simplify() == 1
+
+# Q1-Q6  Tensor tests missing
+
+
+@XFAIL
+def test_R1():
+    i, j, n = symbols('i j n', integer=True, positive=True)
+    xn = MatrixSymbol('xn', n, 1)
+    Sm = Sum((xn[i, 0] - Sum(xn[j, 0], (j, 0, n - 1))/n)**2, (i, 0, n - 1))
+    # sum does not calculate
+    # Unknown result
+    Sm.doit()
+    raise NotImplementedError('Unknown result')
+
+@XFAIL
+def test_R2():
+    m, b = symbols('m b')
+    i, n = symbols('i n', integer=True, positive=True)
+    xn = MatrixSymbol('xn', n, 1)
+    yn = MatrixSymbol('yn', n, 1)
+    f = Sum((yn[i, 0] - m*xn[i, 0] - b)**2, (i, 0, n - 1))
+    f1 = diff(f, m)
+    f2 = diff(f, b)
+    # raises TypeError: solveset() takes at most 2 arguments (3 given)
+    solveset((f1, f2), (m, b), domain=S.Reals)
+
+
+@XFAIL
+def test_R3():
+    n, k = symbols('n k', integer=True, positive=True)
+    sk = ((-1)**k) * (binomial(2*n, k))**2
+    Sm = Sum(sk, (k, 1, oo))
+    T = Sm.doit()
+    T2 = T.combsimp()
+    # returns -((-1)**n*factorial(2*n)
+    #           - (factorial(n))**2)*exp_polar(-I*pi)/(factorial(n))**2
+    assert T2 == (-1)**n*binomial(2*n, n)
+
+
+@XFAIL
+def test_R4():
+# Macsyma indefinite sum test case:
+#(c15) /* Check whether the full Gosper algorithm is implemented
+#   => 1/2^(n + 1) binomial(n, k - 1) */
+#closedform(indefsum(binomial(n, k)/2^n - binomial(n + 1, k)/2^(n + 1), k));
+#Time= 2690 msecs
+#                      (- n + k - 1) binomial(n + 1, k)
+#(d15)               - --------------------------------
+#                                     n
+#                                   2 2  (n + 1)
+#
+#(c16) factcomb(makefact(%));
+#Time= 220 msecs
+#                                 n!
+#(d16)                     ----------------
+#                                n
+#                          2 k! 2  (n - k)!
+# Might be possible after fixing https://github.com/sympy/sympy/pull/1879
+    raise NotImplementedError("Indefinite sum not supported")
+
+
+@XFAIL
+def test_R5():
+    a, b, c, n, k = symbols('a b c n k', integer=True, positive=True)
+    sk = ((-1)**k)*(binomial(a + b, a + k)
+                    *binomial(b + c, b + k)*binomial(c + a, c + k))
+    Sm = Sum(sk, (k, 1, oo))
+    T = Sm.doit()  # hypergeometric series not calculated
+    assert T == factorial(a+b+c)/(factorial(a)*factorial(b)*factorial(c))
+
+
+def test_R6():
+    n, k = symbols('n k', integer=True, positive=True)
+    gn = MatrixSymbol('gn', n + 2, 1)
+    Sm = Sum(gn[k, 0] - gn[k - 1, 0], (k, 1, n + 1))
+    assert Sm.doit() == -gn[0, 0] + gn[n + 1, 0]
+
+
+def test_R7():
+    n, k = symbols('n k', integer=True, positive=True)
+    T = Sum(k**3,(k,1,n)).doit()
+    assert T.factor() == n**2*(n + 1)**2/4
+
+@XFAIL
+def test_R8():
+    n, k = symbols('n k', integer=True, positive=True)
+    Sm = Sum(k**2*binomial(n, k), (k, 1, n))
+    T = Sm.doit() #returns Piecewise function
+    assert T.combsimp() == n*(n + 1)*2**(n - 2)
+
+
+def test_R9():
+    n, k = symbols('n k', integer=True, positive=True)
+    Sm = Sum(binomial(n, k - 1)/k, (k, 1, n + 1))
+    assert Sm.doit().simplify() == (2**(n + 1) - 1)/(n + 1)
+
+
+@XFAIL
+def test_R10():
+    n, m, r, k = symbols('n m r k', integer=True, positive=True)
+    Sm = Sum(binomial(n, k)*binomial(m, r - k), (k, 0, r))
+    T = Sm.doit()
+    T2 = T.combsimp().rewrite(factorial)
+    assert T2 == factorial(m + n)/(factorial(r)*factorial(m + n - r))
+    assert T2 == binomial(m + n, r).rewrite(factorial)
+    # rewrite(binomial) is not working.
+    # https://github.com/sympy/sympy/issues/7135
+    T3 = T2.rewrite(binomial)
+    assert T3 == binomial(m + n, r)
+
+
+@XFAIL
+def test_R11():
+    n, k = symbols('n k', integer=True, positive=True)
+    sk = binomial(n, k)*fibonacci(k)
+    Sm = Sum(sk, (k, 0, n))
+    T = Sm.doit()
+    # Fibonacci simplification not implemented
+    # https://github.com/sympy/sympy/issues/7134
+    assert T == fibonacci(2*n)
+
+
+@XFAIL
+def test_R12():
+    n, k = symbols('n k', integer=True, positive=True)
+    Sm = Sum(fibonacci(k)**2, (k, 0, n))
+    T = Sm.doit()
+    assert T == fibonacci(n)*fibonacci(n + 1)
+
+
+@XFAIL
+def test_R13():
+    n, k = symbols('n k', integer=True, positive=True)
+    Sm = Sum(sin(k*x), (k, 1, n))
+    T = Sm.doit()  # Sum is not calculated
+    assert T.simplify() == cot(x/2)/2 - cos(x*(2*n + 1)/2)/(2*sin(x/2))
+
+
+@XFAIL
+def test_R14():
+    n, k = symbols('n k', integer=True, positive=True)
+    Sm = Sum(sin((2*k - 1)*x), (k, 1, n))
+    T = Sm.doit()  # Sum is not calculated
+    assert T.simplify() == sin(n*x)**2/sin(x)
+
+
+@XFAIL
+def test_R15():
+    n, k = symbols('n k', integer=True, positive=True)
+    Sm = Sum(binomial(n - k, k), (k, 0, floor(n/2)))
+    T = Sm.doit()  # Sum is not calculated
+    assert T.simplify() == fibonacci(n + 1)
+
+
+def test_R16():
+    k = symbols('k', integer=True, positive=True)
+    Sm = Sum(1/k**2 + 1/k**3, (k, 1, oo))
+    assert Sm.doit() == zeta(3) + pi**2/6
+
+
+def test_R17():
+    k = symbols('k', integer=True, positive=True)
+    assert abs(float(Sum(1/k**2 + 1/k**3, (k, 1, oo)))
+               - 2.8469909700078206) < 1e-15
+
+
+def test_R18():
+    k = symbols('k', integer=True, positive=True)
+    Sm = Sum(1/(2**k*k**2), (k, 1, oo))
+    T = Sm.doit()
+    assert T.simplify() == -log(2)**2/2 + pi**2/12
+
+
+@slow
+@XFAIL
+def test_R19():
+    k = symbols('k', integer=True, positive=True)
+    Sm = Sum(1/((3*k + 1)*(3*k + 2)*(3*k + 3)), (k, 0, oo))
+    T = Sm.doit()
+    # assert fails, T not  simplified
+    assert T.simplify() == -log(3)/4 + sqrt(3)*pi/12
+
+
+@XFAIL
+def test_R20():
+    n, k = symbols('n k', integer=True, positive=True)
+    Sm = Sum(binomial(n, 4*k), (k, 0, oo))
+    T = Sm.doit()
+    # assert fails, T not  simplified
+    assert T.simplify() == 2**(n/2)*cos(pi*n/4)/2 + 2**(n - 1)/2
+
+
+@XFAIL
+def test_R21():
+    k = symbols('k', integer=True, positive=True)
+    Sm = Sum(1/(sqrt(k*(k + 1)) * (sqrt(k) + sqrt(k + 1))), (k, 1, oo))
+    T = Sm.doit()  # Sum not calculated
+    assert T.simplify() == 1
+
+
+# test_R22 answer not available in Wester samples
+# Sum(Sum(binomial(n, k)*binomial(n - k, n - 2*k)*x**n*y**(n - 2*k),
+#                 (k, 0, floor(n/2))), (n, 0, oo)) with abs(x*y)<1?
+
+
+@XFAIL
+def test_R23():
+    n, k = symbols('n k', integer=True, positive=True)
+    Sm = Sum(Sum((factorial(n)/(factorial(k)**2*factorial(n - 2*k)))*
+                 (x/y)**k*(x*y)**(n - k), (n, 2*k, oo)), (k, 0, oo))
+    # Missing how to express constraint abs(x*y)<1?
+    T = Sm.doit()  # Sum not calculated
+    assert T == -1/sqrt(x**2*y**2 - 4*x**2 - 2*x*y + 1)
+
+
+def test_R24():
+    m, k = symbols('m k', integer=True, positive=True)
+    Sm = Sum(Product(k/(2*k - 1), (k, 1, m)), (m, 2, oo))
+    assert Sm.doit() == pi/2
+
+
+def test_S1():
+    k = symbols('k', integer=True, positive=True)
+    Pr = Product(gamma(k/3), (k, 1, 8))
+    assert Pr.doit().simplify() == 640*sqrt(3)*pi**3/6561
+
+
+def test_S2():
+    n, k = symbols('n k', integer=True, positive=True)
+    assert Product(k, (k, 1, n)).doit() == factorial(n)
+
+
+def test_S3():
+    n, k = symbols('n k', integer=True, positive=True)
+    assert Product(x**k, (k, 1, n)).doit().simplify() == x**(n*(n + 1)/2)
+
+
+def test_S4():
+    n, k = symbols('n k', integer=True, positive=True)
+    assert Product(1 + 1/k, (k, 1, n -1)).doit().simplify() == n
+
+
+def test_S5():
+    n, k = symbols('n k', integer=True, positive=True)
+    assert (Product((2*k - 1)/(2*k), (k, 1, n)).doit().gammasimp() ==
+            gamma(n + S.Half)/(sqrt(pi)*gamma(n + 1)))
+
+
+@XFAIL
+def test_S6():
+    n, k = symbols('n k', integer=True, positive=True)
+    # Product does not evaluate
+    assert (Product(x**2 -2*x*cos(k*pi/n) + 1, (k, 1, n - 1)).doit().simplify()
+            == (x**(2*n) - 1)/(x**2 - 1))
+
+
+@XFAIL
+def test_S7():
+    k = symbols('k', integer=True, positive=True)
+    Pr = Product((k**3 - 1)/(k**3 + 1), (k, 2, oo))
+    T = Pr.doit()     # Product does not evaluate
+    assert T.simplify() == R(2, 3)
+
+
+@XFAIL
+def test_S8():
+    k = symbols('k', integer=True, positive=True)
+    Pr = Product(1 - 1/(2*k)**2, (k, 1, oo))
+    T = Pr.doit()
+    # Product does not evaluate
+    assert T.simplify() == 2/pi
+
+
+@XFAIL
+def test_S9():
+    k = symbols('k', integer=True, positive=True)
+    Pr = Product(1 + (-1)**(k + 1)/(2*k - 1), (k, 1, oo))
+    T = Pr.doit()
+    # Product produces 0
+    # https://github.com/sympy/sympy/issues/7133
+    assert T.simplify() == sqrt(2)
+
+
+@XFAIL
+def test_S10():
+    k = symbols('k', integer=True, positive=True)
+    Pr = Product((k*(k + 1) + 1 + I)/(k*(k + 1) + 1 - I), (k, 0, oo))
+    T = Pr.doit()
+    # Product does not evaluate
+    assert T.simplify() == -1
+
+
+def test_T1():
+    assert limit((1 + 1/n)**n, n, oo) == E
+    assert limit((1 - cos(x))/x**2, x, 0) == S.Half
+
+
+def test_T2():
+    assert limit((3**x + 5**x)**(1/x), x, oo) == 5
+
+
+def test_T3():
+    assert limit(log(x)/(log(x) + sin(x)), x, oo) == 1
+
+
+def test_T4():
+    assert limit((exp(x*exp(-x)/(exp(-x) + exp(-2*x**2/(x + 1))))
+                 - exp(x))/x, x, oo) == -exp(2)
+
+
+def test_T5():
+    assert  limit(x*log(x)*log(x*exp(x) - x**2)**2/log(log(x**2
+                  + 2*exp(exp(3*x**3*log(x))))), x, oo) == R(1, 3)
+
+
+def test_T6():
+    assert limit(1/n * factorial(n)**(1/n), n, oo) == exp(-1)
+
+
+def test_T7():
+    limit(1/n * gamma(n + 1)**(1/n), n, oo)
+
+
+def test_T8():
+    a, z = symbols('a z', positive=True)
+    assert limit(gamma(z + a)/gamma(z)*exp(-a*log(z)), z, oo) == 1
+
+
+@XFAIL
+def test_T9():
+    z, k = symbols('z k', positive=True)
+    # raises NotImplementedError:
+    #           Don't know how to calculate the mrv of '(1, k)'
+    assert limit(hyper((1, k), (1,), z/k), k, oo) == exp(z)
+
+
+@XFAIL
+def test_T10():
+    # No longer raises PoleError, but should return euler-mascheroni constant
+    assert limit(zeta(x) - 1/(x - 1), x, 1) == integrate(-1/x + 1/floor(x), (x, 1, oo))
+
+@XFAIL
+def test_T11():
+    n, k = symbols('n k', integer=True, positive=True)
+    # evaluates to 0
+    assert limit(n**x/(x*product((1 + x/k), (k, 1, n))), n, oo) == gamma(x)
+
+
+def test_T12():
+    x, t = symbols('x t', real=True)
+    # Does not evaluate the limit but returns an expression with erf
+    assert limit(x * integrate(exp(-t**2), (t, 0, x))/(1 - exp(-x**2)),
+                 x, 0) == 1
+
+
+def test_T13():
+    x = symbols('x', real=True)
+    assert [limit(x/abs(x), x, 0, dir='-'),
+            limit(x/abs(x), x, 0, dir='+')] == [-1, 1]
+
+
+def test_T14():
+    x = symbols('x', real=True)
+    assert limit(atan(-log(x)), x, 0, dir='+') == pi/2
+
+
+def test_U1():
+    x = symbols('x', real=True)
+    assert diff(abs(x), x) == sign(x)
+
+
+def test_U2():
+    f = Lambda(x, Piecewise((-x, x < 0), (x, x >= 0)))
+    assert diff(f(x), x) == Piecewise((-1, x < 0), (1, x >= 0))
+
+
+def test_U3():
+    f = Lambda(x, Piecewise((x**2 - 1, x == 1), (x**3, x != 1)))
+    f1 = Lambda(x, diff(f(x), x))
+    assert f1(x) == 3*x**2
+    assert f1(1) == 3
+
+
+@XFAIL
+def test_U4():
+    n = symbols('n', integer=True, positive=True)
+    x = symbols('x', real=True)
+    d = diff(x**n, x, n)
+    assert d.rewrite(factorial) == factorial(n)
+
+
+def test_U5():
+    # issue 6681
+    t = symbols('t')
+    ans = (
+        Derivative(f(g(t)), g(t))*Derivative(g(t), (t, 2)) +
+        Derivative(f(g(t)), (g(t), 2))*Derivative(g(t), t)**2)
+    assert f(g(t)).diff(t, 2) == ans
+    assert ans.doit() == ans
+
+
+def test_U6():
+    h = Function('h')
+    T = integrate(f(y), (y, h(x), g(x)))
+    assert T.diff(x) == (
+        f(g(x))*Derivative(g(x), x) - f(h(x))*Derivative(h(x), x))
+
+
+@XFAIL
+def test_U7():
+    p, t = symbols('p t', real=True)
+    # Exact differential => d(V(P, T)) => dV/dP DP + dV/dT DT
+    # raises ValueError:  Since there is more than one variable in the
+    # expression, the variable(s) of differentiation must be supplied to
+    # differentiate f(p,t)
+    diff(f(p, t))
+
+
+def test_U8():
+    x, y = symbols('x y', real=True)
+    eq = cos(x*y) + x
+    #  If SymPy had implicit_diff() function this hack could be avoided
+    # TODO: Replace solve with solveset, current test fails for solveset
+    assert idiff(y - eq, y, x) == (-y*sin(x*y) + 1)/(x*sin(x*y) + 1)
+
+
+def test_U9():
+    # Wester sample case for Maple:
+    # O29 := diff(f(x, y), x) + diff(f(x, y), y);
+    #                      /d         \   /d         \
+    #                      |-- f(x, y)| + |-- f(x, y)|
+    #                      \dx        /   \dy        /
+    #
+    # O30 := factor(subs(f(x, y) = g(x^2 + y^2), %));
+    #                                2    2
+    #                        2 D(g)(x  + y ) (x + y)
+    x, y = symbols('x y', real=True)
+    su = diff(f(x, y), x) + diff(f(x, y), y)
+    s2 = su.subs(f(x, y), g(x**2 + y**2))
+    s3 = s2.doit().factor()
+    # Subs not performed, s3 = 2*(x + y)*Subs(Derivative(
+    #   g(_xi_1), _xi_1), _xi_1, x**2 + y**2)
+    # Derivative(g(x*2 + y**2), x**2 + y**2) is not valid in SymPy,
+    # and probably will remain that way. You can take derivatives with respect
+    # to other expressions only if they are atomic, like a symbol or a
+    # function.
+    # D operator should be added to SymPy
+    # See https://github.com/sympy/sympy/issues/4719.
+    assert s3 == (x + y)*Subs(Derivative(g(x), x), x, x**2 + y**2)*2
+
+
+def test_U10():
+    # see issue 2519:
+    assert residue((z**3 + 5)/((z**4 - 1)*(z + 1)), z, -1) == R(-9, 4)
+
+@XFAIL
+def test_U11():
+    # assert (2*dx + dz) ^ (3*dx + dy + dz) ^ (dx + dy + 4*dz) == 8*dx ^ dy ^dz
+    raise NotImplementedError
+
+
+@XFAIL
+def test_U12():
+    # Wester sample case:
+    # (c41) /* d(3 x^5 dy /\ dz + 5 x y^2 dz /\ dx + 8 z dx /\ dy)
+    #    => (15 x^4 + 10 x y + 8) dx /\ dy /\ dz */
+    # factor(ext_diff(3*x^5 * dy ~ dz + 5*x*y^2 * dz ~ dx + 8*z * dx ~ dy));
+    #                      4
+    # (d41)              (10 x y + 15 x  + 8) dx dy dz
+    raise NotImplementedError(
+        "External diff of differential form not supported")
+
+
+def test_U13():
+    assert minimum(x**4 - x + 1, x) == -3*2**R(1,3)/8 + 1
+
+
+@XFAIL
+def test_U14():
+    #f = 1/(x**2 + y**2 + 1)
+    #assert [minimize(f), maximize(f)] == [0,1]
+    raise NotImplementedError("minimize(), maximize() not supported")
+
+
+@XFAIL
+def test_U15():
+    raise NotImplementedError("minimize() not supported and also solve does \
+not support multivariate inequalities")
+
+
+@XFAIL
+def test_U16():
+    raise NotImplementedError("minimize() not supported in SymPy and also \
+solve does not support multivariate inequalities")
+
+
+@XFAIL
+def test_U17():
+    raise NotImplementedError("Linear programming, symbolic simplex not \
+supported in SymPy")
+
+
+def test_V1():
+    x = symbols('x', real=True)
+    assert integrate(abs(x), x) == Piecewise((-x**2/2, x <= 0), (x**2/2, True))
+
+
+def test_V2():
+    assert integrate(Piecewise((-x, x < 0), (x, x >= 0)), x
+        ) == Piecewise((-x**2/2, x < 0), (x**2/2, True))
+
+
+def test_V3():
+    assert integrate(1/(x**3 + 2),x).diff().simplify() == 1/(x**3 + 2)
+
+
+def test_V4():
+    assert integrate(2**x/sqrt(1 + 4**x), x) == asinh(2**x)/log(2)
+
+
+@XFAIL
+def test_V5():
+    # Returns (-45*x**2 + 80*x - 41)/(5*sqrt(2*x - 1)*(4*x**2 - 4*x + 1))
+    assert (integrate((3*x - 5)**2/(2*x - 1)**R(7, 2), x).simplify() ==
+            (-41 + 80*x - 45*x**2)/(5*(2*x - 1)**R(5, 2)))
+
+
+@XFAIL
+def test_V6():
+    # returns RootSum(40*_z**2 - 1, Lambda(_i, _i*log(-4*_i + exp(-m*x))))/m
+    assert (integrate(1/(2*exp(m*x) - 5*exp(-m*x)), x) == sqrt(10)*(
+            log(2*exp(m*x) - sqrt(10)) - log(2*exp(m*x) + sqrt(10)))/(20*m))
+
+
+def test_V7():
+    r1 = integrate(sinh(x)**4/cosh(x)**2)
+    assert r1.simplify() == x*R(-3, 2) + sinh(x)**3/(2*cosh(x)) + 3*tanh(x)/2
+
+
+@XFAIL
+def test_V8_V9():
+#Macsyma test case:
+#(c27) /* This example involves several symbolic parameters
+#   => 1/sqrt(b^2 - a^2) log([sqrt(b^2 - a^2) tan(x/2) + a + b]/
+#                            [sqrt(b^2 - a^2) tan(x/2) - a - b])   (a^2 < b^2)
+#      [Gradshteyn and Ryzhik 2.553(3)] */
+#assume(b^2 > a^2)$
+#(c28) integrate(1/(a + b*cos(x)), x);
+#(c29) trigsimp(ratsimp(diff(%, x)));
+#                        1
+#(d29)             ------------
+#                  b cos(x) + a
+    raise NotImplementedError(
+        "Integrate with assumption not supported")
+
+
+def test_V10():
+    assert integrate(1/(3 + 3*cos(x) + 4*sin(x)), x) == log(4*tan(x/2) + 3)/4
+
+
+def test_V11():
+    r1 = integrate(1/(4 + 3*cos(x) + 4*sin(x)), x)
+    r2 = factor(r1)
+    assert (logcombine(r2, force=True) ==
+            log(((tan(x/2) + 1)/(tan(x/2) + 7))**R(1, 3)))
+
+
+def test_V12():
+    r1 = integrate(1/(5 + 3*cos(x) + 4*sin(x)), x)
+    assert r1 == -1/(tan(x/2) + 2)
+
+
+@XFAIL
+def test_V13():
+    r1 = integrate(1/(6 + 3*cos(x) + 4*sin(x)), x)
+    # expression not simplified, returns: -sqrt(11)*I*log(tan(x/2) + 4/3
+    #   - sqrt(11)*I/3)/11 + sqrt(11)*I*log(tan(x/2) + 4/3 + sqrt(11)*I/3)/11
+    assert r1.simplify() == 2*sqrt(11)*atan(sqrt(11)*(3*tan(x/2) + 4)/11)/11
+
+
+@slow
+@XFAIL
+def test_V14():
+    r1 = integrate(log(abs(x**2 - y**2)), x)
+    # Piecewise result does not simplify to the desired result.
+    assert (r1.simplify() == x*log(abs(x**2  - y**2))
+                            + y*log(x + y) - y*log(x - y) - 2*x)
+
+
+def test_V15():
+    r1 = integrate(x*acot(x/y), x)
+    assert simplify(r1 - (x*y + (x**2 + y**2)*acot(x/y))/2) == 0
+
+
+@XFAIL
+def test_V16():
+    # Integral not calculated
+    assert integrate(cos(5*x)*Ci(2*x), x) == Ci(2*x)*sin(5*x)/5 - (Si(3*x) + Si(7*x))/10
+
+@XFAIL
+def test_V17():
+    r1 = integrate((diff(f(x), x)*g(x)
+                   - f(x)*diff(g(x), x))/(f(x)**2 - g(x)**2), x)
+    # integral not calculated
+    assert simplify(r1 - (f(x) - g(x))/(f(x) + g(x))/2) == 0
+
+
+@XFAIL
+def test_W1():
+    # The function has a pole at y.
+    # The integral has a Cauchy principal value of zero but SymPy returns -I*pi
+    # https://github.com/sympy/sympy/issues/7159
+    assert integrate(1/(x - y), (x, y - 1, y + 1)) == 0
+
+
+@XFAIL
+def test_W2():
+    # The function has a pole at y.
+    # The integral is divergent but SymPy returns -2
+    # https://github.com/sympy/sympy/issues/7160
+    # Test case in Macsyma:
+    # (c6) errcatch(integrate(1/(x - a)^2, x, a - 1, a + 1));
+    # Integral is divergent
+    assert integrate(1/(x - y)**2, (x, y - 1, y + 1)) is zoo
+
+
+@XFAIL
+@slow
+def test_W3():
+    # integral is not  calculated
+    # https://github.com/sympy/sympy/issues/7161
+    assert integrate(sqrt(x + 1/x - 2), (x, 0, 1)) == R(4, 3)
+
+
+@XFAIL
+@slow
+def test_W4():
+    # integral is not  calculated
+    assert integrate(sqrt(x + 1/x - 2), (x, 1, 2)) == -2*sqrt(2)/3 + R(4, 3)
+
+
+@XFAIL
+@slow
+def test_W5():
+    # integral is not  calculated
+    assert integrate(sqrt(x + 1/x - 2), (x, 0, 2)) == -2*sqrt(2)/3 + R(8, 3)
+
+
+@XFAIL
+@slow
+def test_W6():
+    # integral is not  calculated
+    assert integrate(sqrt(2 - 2*cos(2*x))/2, (x, pi*R(-3, 4), -pi/4)) == sqrt(2)
+
+
+def test_W7():
+    a = symbols('a', positive=True)
+    r1 = integrate(cos(x)/(x**2 + a**2), (x, -oo, oo))
+    assert r1.simplify() == pi*exp(-a)/a
+
+
+@XFAIL
+def test_W8():
+    # Test case in Mathematica:
+    # In[19]:= Integrate[t^(a - 1)/(1 + t), {t, 0, Infinity},
+    #                    Assumptions -> 0 < a < 1]
+    # Out[19]= Pi Csc[a Pi]
+    raise NotImplementedError(
+        "Integrate with assumption 0 < a < 1 not supported")
+
+
+@XFAIL
+@slow
+def test_W9():
+    # Integrand with a residue at infinity => -2 pi [sin(pi/5) + sin(2pi/5)]
+    # (principal value)   [Levinson and Redheffer, p. 234] *)
+    r1 = integrate(5*x**3/(1 + x + x**2 + x**3 + x**4), (x, -oo, oo))
+    r2 = r1.doit()
+    assert r2 == -2*pi*(sqrt(-sqrt(5)/8 + 5/8) + sqrt(sqrt(5)/8 + 5/8))
+
+
+@XFAIL
+def test_W10():
+    # integrate(1/[1 + x + x^2 + ... + x^(2 n)], x = -infinity..infinity) =
+    #        2 pi/(2 n + 1) [1 + cos(pi/[2 n + 1])] csc(2 pi/[2 n + 1])
+    # [Levinson and Redheffer, p. 255] => 2 pi/5 [1 + cos(pi/5)] csc(2 pi/5) */
+    r1 = integrate(x/(1 + x + x**2 + x**4), (x, -oo, oo))
+    r2 = r1.doit()
+    assert r2 == 2*pi*(sqrt(5)/4 + 5/4)*csc(pi*R(2, 5))/5
+
+
+@XFAIL
+def test_W11():
+    # integral not calculated
+    assert (integrate(sqrt(1 - x**2)/(1 + x**2), (x, -1, 1)) ==
+            pi*(-1 + sqrt(2)))
+
+
+def test_W12():
+    p = symbols('p', positive=True)
+    q = symbols('q', real=True)
+    r1 = integrate(x*exp(-p*x**2 + 2*q*x), (x, -oo, oo))
+    assert r1.simplify() == sqrt(pi)*q*exp(q**2/p)/p**R(3, 2)
+
+
+@XFAIL
+def test_W13():
+    # Integral not calculated. Expected result is 2*(Euler_mascheroni_constant)
+    r1 = integrate(1/log(x) + 1/(1 - x) - log(log(1/x)), (x, 0, 1))
+    assert r1 == 2*EulerGamma
+
+
+def test_W14():
+    assert integrate(sin(x)/x*exp(2*I*x), (x, -oo, oo)) == 0
+
+
+@XFAIL
+def test_W15():
+    # integral not calculated
+    assert integrate(log(gamma(x))*cos(6*pi*x), (x, 0, 1)) == R(1, 12)
+
+
+def test_W16():
+    assert integrate((1 + x)**3*legendre_poly(1, x)*legendre_poly(2, x),
+                     (x, -1, 1)) == R(36, 35)
+
+
+def test_W17():
+    a, b = symbols('a b', positive=True)
+    assert integrate(exp(-a*x)*besselj(0, b*x),
+                 (x, 0, oo)) == 1/(b*sqrt(a**2/b**2 + 1))
+
+
+def test_W18():
+    assert integrate((besselj(1, x)/x)**2, (x, 0, oo)) == 4/(3*pi)
+
+
+@XFAIL
+def test_W19():
+    # Integral not calculated
+    # Expected result is (cos 7 - 1)/7   [Gradshteyn and Ryzhik 6.782(3)]
+    assert integrate(Ci(x)*besselj(0, 2*sqrt(7*x)), (x, 0, oo)) == (cos(7) - 1)/7
+
+
+@XFAIL
+def test_W20():
+    # integral not calculated
+    assert (integrate(x**2*polylog(3, 1/(x + 1)), (x, 0, 1)) ==
+            -pi**2/36 - R(17, 108) + zeta(3)/4 +
+            (-pi**2/2 - 4*log(2) + log(2)**2 + 35/3)*log(2)/9)
+
+
+def test_W21():
+    assert abs(N(integrate(x**2*polylog(3, 1/(x + 1)), (x, 0, 1)))
+        - 0.210882859565594) < 1e-15
+
+
+def test_W22():
+    t, u = symbols('t u', real=True)
+    s = Lambda(x, Piecewise((1, And(x >= 1, x <= 2)), (0, True)))
+    assert integrate(s(t)*cos(t), (t, 0, u)) == Piecewise(
+        (0, u < 0),
+        (-sin(Min(1, u)) + sin(Min(2, u)), True))
+
+
+@slow
+def test_W23():
+    a, b = symbols('a b', positive=True)
+    r1 = integrate(integrate(x/(x**2 + y**2), (x, a, b)), (y, -oo, oo))
+    assert r1.collect(pi).cancel() == -pi*a + pi*b
+
+
+def test_W23b():
+    # like W23 but limits are reversed
+    a, b = symbols('a b', positive=True)
+    r2 = integrate(integrate(x/(x**2 + y**2), (y, -oo, oo)), (x, a, b))
+    assert r2.collect(pi) == pi*(-a + b)
+
+
+@XFAIL
+@tooslow
+def test_W24():
+    # Not that slow, but does not fully evaluate so simplify is slow.
+    # Maybe also require doit()
+    x, y = symbols('x y', real=True)
+    r1 = integrate(integrate(sqrt(x**2 + y**2), (x, 0, 1)), (y, 0, 1))
+    assert (r1 - (sqrt(2) + asinh(1))/3).simplify() == 0
+
+
+@XFAIL
+@tooslow
+def test_W25():
+    a, x, y = symbols('a x y', real=True)
+    i1 = integrate(
+        sin(a)*sin(y)/sqrt(1 - sin(a)**2*sin(x)**2*sin(y)**2),
+        (x, 0, pi/2))
+    i2 = integrate(i1, (y, 0, pi/2))
+    assert (i2 - pi*a/2).simplify() == 0
+
+
+def test_W26():
+    x, y = symbols('x y', real=True)
+    assert integrate(integrate(abs(y - x**2), (y, 0, 2)),
+                     (x, -1, 1)) == R(46, 15)
+
+
+def test_W27():
+    a, b, c = symbols('a b c')
+    assert integrate(integrate(integrate(1, (z, 0, c*(1 - x/a - y/b))),
+                               (y, 0, b*(1 - x/a))),
+                     (x, 0, a)) == a*b*c/6
+
+
+def test_X1():
+    v, c = symbols('v c', real=True)
+    assert (series(1/sqrt(1 - (v/c)**2), v, x0=0, n=8) ==
+            5*v**6/(16*c**6) + 3*v**4/(8*c**4) + v**2/(2*c**2) + 1 + O(v**8))
+
+
+def test_X2():
+    v, c = symbols('v c', real=True)
+    s1 = series(1/sqrt(1 - (v/c)**2), v, x0=0, n=8)
+    assert (1/s1**2).series(v, x0=0, n=8) == -v**2/c**2 + 1 + O(v**8)
+
+
+def test_X3():
+    s1 = (sin(x).series()/cos(x).series()).series()
+    s2 = tan(x).series()
+    assert s2 == x + x**3/3 + 2*x**5/15 + O(x**6)
+    assert s1 == s2
+
+
+def test_X4():
+    s1 = log(sin(x)/x).series()
+    assert s1 == -x**2/6 - x**4/180 + O(x**6)
+    assert log(series(sin(x)/x)).series() == s1
+
+
+@XFAIL
+def test_X5():
+    # test case in Mathematica syntax:
+    # In[21]:= (* => [a f'(a d) + g(b d) + integrate(h(c y), y = 0..d)]
+    #       + [a^2 f''(a d) + b g'(b d) + h(c d)] (x - d) *)
+    # In[22]:= D[f[a*x], x] + g[b*x] + Integrate[h[c*y], {y, 0, x}]
+    # Out[22]= g[b x] + Integrate[h[c y], {y, 0, x}] + a f'[a x]
+    # In[23]:= Series[%, {x, d, 1}]
+    # Out[23]= (g[b d] + Integrate[h[c y], {y, 0, d}] + a f'[a d]) +
+    #                                    2                               2
+    #             (h[c d] + b g'[b d] + a  f''[a d]) (-d + x) + O[-d + x]
+    h = Function('h')
+    a, b, c, d = symbols('a b c d', real=True)
+    # series() raises NotImplementedError:
+    # The _eval_nseries method should be added to <class
+    # 'sympy.core.function.Subs'> to give terms up to O(x**n) at x=0
+    series(diff(f(a*x), x) + g(b*x) + integrate(h(c*y), (y, 0, x)),
+           x, x0=d, n=2)
+    # assert missing, until exception is removed
+
+
+def test_X6():
+    # Taylor series of nonscalar objects (noncommutative multiplication)
+    # expected result => (B A - A B) t^2/2 + O(t^3)   [Stanly Steinberg]
+    a, b = symbols('a b', commutative=False, scalar=False)
+    assert (series(exp((a + b)*x) - exp(a*x) * exp(b*x), x, x0=0, n=3) ==
+              x**2*(-a*b/2 + b*a/2) + O(x**3))
+
+
+def test_X7():
+    # => sum( Bernoulli[k]/k! x^(k - 2), k = 1..infinity )
+    #    = 1/x^2 - 1/(2 x) + 1/12 - x^2/720 + x^4/30240 + O(x^6)
+    #    [Levinson and Redheffer, p. 173]
+    assert (series(1/(x*(exp(x) - 1)), x, 0, 7) == x**(-2) - 1/(2*x) +
+            R(1, 12) - x**2/720 + x**4/30240 - x**6/1209600 + O(x**7))
+
+
+def test_X8():
+    # Puiseux series (terms with fractional degree):
+    # => 1/sqrt(x - 3/2 pi) + (x - 3/2 pi)^(3/2) / 12 + O([x - 3/2 pi]^(7/2))
+
+    # see issue 7167:
+    x = symbols('x', real=True)
+    assert (series(sqrt(sec(x)), x, x0=pi*3/2, n=4) ==
+            1/sqrt(x - pi*R(3, 2)) + (x - pi*R(3, 2))**R(3, 2)/12 +
+            (x - pi*R(3, 2))**R(7, 2)/160 + O((x - pi*R(3, 2))**4, (x, pi*R(3, 2))))
+
+
+def test_X9():
+    assert (series(x**x, x, x0=0, n=4) == 1 + x*log(x) + x**2*log(x)**2/2 +
+            x**3*log(x)**3/6 + O(x**4*log(x)**4))
+
+
+def test_X10():
+    z, w = symbols('z w')
+    assert (series(log(sinh(z)) + log(cosh(z + w)), z, x0=0, n=2) ==
+            log(cosh(w)) + log(z) + z*sinh(w)/cosh(w) + O(z**2))
+
+
+def test_X11():
+    z, w = symbols('z w')
+    assert (series(log(sinh(z) * cosh(z + w)), z, x0=0, n=2) ==
+            log(cosh(w)) + log(z) + z*sinh(w)/cosh(w) + O(z**2))
+
+
+@XFAIL
+def test_X12():
+    # Look at the generalized Taylor series around x = 1
+    # Result => (x - 1)^a/e^b [1 - (a + 2 b) (x - 1) / 2 + O((x - 1)^2)]
+    a, b, x = symbols('a b x', real=True)
+    # series returns O(log(x-1)**2)
+    # https://github.com/sympy/sympy/issues/7168
+    assert (series(log(x)**a*exp(-b*x), x, x0=1, n=2) ==
+            (x - 1)**a/exp(b)*(1 - (a + 2*b)*(x - 1)/2 + O((x - 1)**2)))
+
+
+def test_X13():
+    assert series(sqrt(2*x**2 + 1), x, x0=oo, n=1) == sqrt(2)*x + O(1/x, (x, oo))
+
+
+@XFAIL
+def test_X14():
+    # Wallis' product => 1/sqrt(pi n) + ...   [Knopp, p. 385]
+    assert series(1/2**(2*n)*binomial(2*n, n),
+                  n, x==oo, n=1) == 1/(sqrt(pi)*sqrt(n)) + O(1/x, (x, oo))
+
+
+@SKIP("https://github.com/sympy/sympy/issues/7164")
+def test_X15():
+    # => 0!/x - 1!/x^2 + 2!/x^3 - 3!/x^4 + O(1/x^5)   [Knopp, p. 544]
+    x, t = symbols('x t', real=True)
+    # raises RuntimeError: maximum recursion depth exceeded
+    # https://github.com/sympy/sympy/issues/7164
+    # 2019-02-17: Raises
+    # PoleError:
+    # Asymptotic expansion of Ei around [-oo] is not implemented.
+    e1 = integrate(exp(-t)/t, (t, x, oo))
+    assert (series(e1, x, x0=oo, n=5) ==
+            6/x**4 + 2/x**3 - 1/x**2 + 1/x + O(x**(-5), (x, oo)))
+
+
+def test_X16():
+    # Multivariate Taylor series expansion => 1 - (x^2 + 2 x y + y^2)/2 + O(x^4)
+    assert (series(cos(x + y), x + y, x0=0, n=4) == 1 - (x + y)**2/2 +
+            O(x**4 + x**3*y + x**2*y**2 + x*y**3 + y**4, x, y))
+
+
+@XFAIL
+def test_X17():
+    # Power series (compute the general formula)
+    # (c41) powerseries(log(sin(x)/x), x, 0);
+    # /aquarius/data2/opt/local/macsyma_422/library1/trgred.so being loaded.
+    #              inf
+    #              ====     i1  2 i1          2 i1
+    #              \        (- 1)   2      bern(2 i1) x
+    # (d41)         >        ------------------------------
+    #              /             2 i1 (2 i1)!
+    #              ====
+    #              i1 = 1
+    # fps does not calculate
+    assert fps(log(sin(x)/x)) == \
+        Sum((-1)**k*2**(2*k - 1)*bernoulli(2*k)*x**(2*k)/(k*factorial(2*k)), (k, 1, oo))
+
+
+@XFAIL
+def test_X18():
+    # Power series (compute the general formula). Maple FPS:
+    # > FormalPowerSeries(exp(-x)*sin(x), x = 0);
+    #                        infinity
+    #                         -----    (1/2 k)                k
+    #                          \      2        sin(3/4 k Pi) x
+    #                           )     -------------------------
+    #                          /                 k!
+    #                         -----
+    #
+    # Now, SymPy returns
+    #      oo
+    #    _____
+    #    \    `
+    #     \        /          k             k\
+    #      \     k |I*(-1 - I)    I*(-1 + I) |
+    #       \   x *|----------- - -----------|
+    #       /      \     2             2     /
+    #      /    ------------------------------
+    #     /                   k!
+    #    /____,
+    #    k = 0
+    k = Dummy('k')
+    assert fps(exp(-x)*sin(x)) == \
+        Sum(2**(S.Half*k)*sin(R(3, 4)*k*pi)*x**k/factorial(k), (k, 0, oo))
+
+
+@XFAIL
+def test_X19():
+    # (c45) /* Derive an explicit Taylor series solution of y as a function of
+    # x from the following implicit relation:
+    #    y = x - 1 + (x - 1)^2/2 + 2/3 (x - 1)^3 + (x - 1)^4 +
+    #        17/10 (x - 1)^5 + ...
+    #    */
+    # x = sin(y) + cos(y);
+    # Time= 0 msecs
+    # (d45)                   x = sin(y) + cos(y)
+    #
+    # (c46) taylor_revert(%, y, 7);
+    raise NotImplementedError("Solve using series not supported. \
+Inverse Taylor series expansion also not supported")
+
+
+@XFAIL
+def test_X20():
+    # Pade (rational function) approximation => (2 - x)/(2 + x)
+    # > numapprox[pade](exp(-x), x = 0, [1, 1]);
+    # bytes used=9019816, alloc=3669344, time=13.12
+    #                                    1 - 1/2 x
+    #                                    ---------
+    #                                    1 + 1/2 x
+    # mpmath support numeric Pade approximant but there is
+    # no symbolic implementation in SymPy
+    # https://en.wikipedia.org/wiki/Pad%C3%A9_approximant
+    raise NotImplementedError("Symbolic Pade approximant not supported")
+
+
+def test_X21():
+    """
+    Test whether `fourier_series` of x periodical on the [-p, p] interval equals
+    `- (2 p / pi) sum( (-1)^n / n sin(n pi x / p), n = 1..infinity )`.
+    """
+    p = symbols('p', positive=True)
+    n = symbols('n', positive=True, integer=True)
+    s = fourier_series(x, (x, -p, p))
+
+    # All cosine coefficients are equal to 0
+    assert s.an.formula == 0
+
+    # Check for sine coefficients
+    assert s.bn.formula.subs(s.bn.variables[0], 0) == 0
+    assert s.bn.formula.subs(s.bn.variables[0], n) == \
+        -2*p/pi * (-1)**n / n * sin(n*pi*x/p)
+
+
+@XFAIL
+def test_X22():
+    # (c52) /* => p / 2
+    #    - (2 p / pi^2) sum( [1 - (-1)^n] cos(n pi x / p) / n^2,
+    #                        n = 1..infinity ) */
+    # fourier_series(abs(x), x, p);
+    #                       p
+    # (e52)                      a  = -
+    #                       0      2
+    #
+    #                       %nn
+    #                   (2 (- 1)    - 2) p
+    # (e53)                a    = ------------------
+    #                 %nn         2    2
+    #                       %pi  %nn
+    #
+    # (e54)                     b    = 0
+    #                      %nn
+    #
+    # Time= 5290 msecs
+    #            inf           %nn            %pi %nn x
+    #            ====       (2 (- 1)    - 2) cos(---------)
+    #            \                    p
+    #          p  >       -------------------------------
+    #            /               2
+    #            ====                %nn
+    #            %nn = 1                     p
+    # (d54)          ----------------------------------------- + -
+    #                       2                 2
+    #                    %pi
+    raise NotImplementedError("Fourier series not supported")
+
+
+def test_Y1():
+    t = symbols('t', positive=True)
+    w = symbols('w', real=True)
+    s = symbols('s')
+    F, _, _ = laplace_transform(cos((w - 1)*t), t, s)
+    assert F == s/(s**2 + (w - 1)**2)
+
+
+def test_Y2():
+    t = symbols('t', positive=True)
+    w = symbols('w', real=True)
+    s = symbols('s')
+    f = inverse_laplace_transform(s/(s**2 + (w - 1)**2), s, t, simplify=True)
+    assert f == cos(t*(w - 1))
+
+
+def test_Y3():
+    t = symbols('t', positive=True)
+    w = symbols('w', real=True)
+    s = symbols('s')
+    F, _, _ = laplace_transform(sinh(w*t)*cosh(w*t), t, s, simplify=True)
+    assert F == w/(s**2 - 4*w**2)
+
+
+def test_Y4():
+    t = symbols('t', positive=True)
+    s = symbols('s')
+    F, _, _ = laplace_transform(erf(3/sqrt(t)), t, s, simplify=True)
+    assert F == 1/s - exp(-6*sqrt(s))/s
+
+
+def test_Y5_Y6():
+# Solve y'' + y = 4 [H(t - 1) - H(t - 2)], y(0) = 1, y'(0) = 0 where H is the
+# Heaviside (unit step) function (the RHS describes a pulse of magnitude 4 and
+# duration 1).  See David A. Sanchez, Richard C. Allen, Jr. and Walter T.
+# Kyner, _Differential Equations: An Introduction_, Addison-Wesley Publishing
+# Company, 1983, p. 211.  First, take the Laplace transform of the ODE
+# => s^2 Y(s) - s + Y(s) = 4/s [e^(-s) - e^(-2 s)]
+# where Y(s) is the Laplace transform of y(t)
+    t = symbols('t', real=True)
+    s = symbols('s')
+    y = Function('y')
+    Y = Function('Y')
+    F = laplace_correspondence(laplace_transform(diff(y(t), t, 2) + y(t)
+                                - 4*(Heaviside(t - 1) - Heaviside(t - 2)),
+                                t, s, noconds=True), {y: Y})
+    D = (
+        -F + s**2*Y(s) - s*y(0) + Y(s) - Subs(Derivative(y(t), t), t, 0) -
+        4*exp(-s)/s + 4*exp(-2*s)/s)
+    assert D == 0
+# Now, solve for Y(s) and then take the inverse Laplace transform
+#   => Y(s) = s/(s^2 + 1) + 4 [1/s - s/(s^2 + 1)] [e^(-s) - e^(-2 s)]
+#   => y(t) = cos t + 4 {[1 - cos(t - 1)] H(t - 1) - [1 - cos(t - 2)] H(t - 2)}
+    Yf = solve(F, Y(s))[0]
+    Yf = laplace_initial_conds(Yf, t, {y: [1, 0]})
+    assert Yf == (s**2*exp(2*s) + 4*exp(s) - 4)*exp(-2*s)/(s*(s**2 + 1))
+    yf = inverse_laplace_transform(Yf, s, t)
+    yf = yf.collect(Heaviside(t-1)).collect(Heaviside(t-2))
+    assert yf == (
+        (4 - 4*cos(t - 1))*Heaviside(t - 1) +
+        (4*cos(t - 2) - 4)*Heaviside(t - 2) +
+        cos(t)*Heaviside(t))
+
+
+@XFAIL
+def test_Y7():
+    # What is the Laplace transform of an infinite square wave?
+    # => 1/s + 2 sum( (-1)^n e^(- s n a)/s, n = 1..infinity )
+    #    [Sanchez, Allen and Kyner, p. 213]
+    t = symbols('t', positive=True)
+    a = symbols('a', real=True)
+    s = symbols('s')
+    F, _, _ = laplace_transform(1 + 2*Sum((-1)**n*Heaviside(t - n*a),
+                                          (n, 1, oo)), t, s)
+    # returns 2*LaplaceTransform(Sum((-1)**n*Heaviside(-a*n + t),
+    #                                (n, 1, oo)), t, s) + 1/s
+    # https://github.com/sympy/sympy/issues/7177
+    assert F == 2*Sum((-1)**n*exp(-a*n*s)/s, (n, 1, oo)) + 1/s
+
+
+@XFAIL
+def test_Y8():
+    assert fourier_transform(1, x, z) == DiracDelta(z)
+
+
+def test_Y9():
+    assert (fourier_transform(exp(-9*x**2), x, z) ==
+            sqrt(pi)*exp(-pi**2*z**2/9)/3)
+
+
+def test_Y10():
+    assert (fourier_transform(abs(x)*exp(-3*abs(x)), x, z).cancel() ==
+            (-8*pi**2*z**2 + 18)/(16*pi**4*z**4 + 72*pi**2*z**2 + 81))
+
+
+@SKIP("https://github.com/sympy/sympy/issues/7181")
+@slow
+def test_Y11():
+    # => pi cot(pi s)   (0 < Re s < 1)   [Gradshteyn and Ryzhik 17.43(5)]
+    x, s = symbols('x s')
+    # raises RuntimeError: maximum recursion depth exceeded
+    # https://github.com/sympy/sympy/issues/7181
+    # Update 2019-02-17 raises:
+    # TypeError: cannot unpack non-iterable MellinTransform object
+    F, _, _ =  mellin_transform(1/(1 - x), x, s)
+    assert F == pi*cot(pi*s)
+
+
+@XFAIL
+def test_Y12():
+    # => 2^(s - 4) gamma(s/2)/gamma(4 - s/2)   (0 < Re s < 1)
+    # [Gradshteyn and Ryzhik 17.43(16)]
+    x, s = symbols('x s')
+    # returns Wrong value -2**(s - 4)*gamma(s/2 - 3)/gamma(-s/2 + 1)
+    # https://github.com/sympy/sympy/issues/7182
+    F, _, _ = mellin_transform(besselj(3, x)/x**3, x, s)
+    assert F == -2**(s - 4)*gamma(s/2)/gamma(-s/2 + 4)
+
+
+@XFAIL
+def test_Y13():
+# Z[H(t - m T)] => z/[z^m (z - 1)]   (H is the Heaviside (unit step) function)                                                 z
+    raise NotImplementedError("z-transform not supported")
+
+
+@XFAIL
+def test_Y14():
+# Z[H(t - m T)] => z/[z^m (z - 1)]   (H is the Heaviside (unit step) function)
+    raise NotImplementedError("z-transform not supported")
+
+
+def test_Z1():
+    r = Function('r')
+    assert (rsolve(r(n + 2) - 2*r(n + 1) + r(n) - 2, r(n),
+                   {r(0): 1, r(1): m}).simplify() == n**2 + n*(m - 2) + 1)
+
+
+def test_Z2():
+    r = Function('r')
+    assert (rsolve(r(n) - (5*r(n - 1) - 6*r(n - 2)), r(n), {r(0): 0, r(1): 1})
+            == -2**n + 3**n)
+
+
+def test_Z3():
+    # => r(n) = Fibonacci[n + 1]   [Cohen, p. 83]
+    r = Function('r')
+    # recurrence solution is correct, Wester expects it to be simplified to
+    # fibonacci(n+1), but that is quite hard
+    expected = ((S(1)/2 - sqrt(5)/2)**n*(S(1)/2 - sqrt(5)/10)
+              + (S(1)/2 + sqrt(5)/2)**n*(sqrt(5)/10 + S(1)/2))
+    sol = rsolve(r(n) - (r(n - 1) + r(n - 2)), r(n), {r(1): 1, r(2): 2})
+    assert sol == expected
+
+
+@XFAIL
+def test_Z4():
+# => [c^(n+1) [c^(n+1) - 2 c - 2] + (n+1) c^2 + 2 c - n] / [(c-1)^3 (c+1)]
+#    [Joan Z. Yu and Robert Israel in sci.math.symbolic]
+    r = Function('r')
+    c = symbols('c')
+    # raises ValueError: Polynomial or rational function expected,
+    #     got '(c**2 - c**n)/(c - c**n)
+    s = rsolve(r(n) - ((1 + c - c**(n-1) - c**(n+1))/(1 - c**n)*r(n - 1)
+                   - c*(1 - c**(n-2))/(1 - c**(n-1))*r(n - 2) + 1),
+           r(n), {r(1): 1, r(2): (2 + 2*c + c**2)/(1 + c)})
+    assert (s - (c*(n + 1)*(c*(n + 1) - 2*c - 2) +
+             (n + 1)*c**2 + 2*c - n)/((c-1)**3*(c+1)) == 0)
+
+
+@XFAIL
+def test_Z5():
+    # Second order ODE with initial conditions---solve directly
+    # transform: f(t) = sin(2 t)/8 - t cos(2 t)/4
+    C1, C2 = symbols('C1 C2')
+    # initial conditions not supported, this is a manual workaround
+    # https://github.com/sympy/sympy/issues/4720
+    eq = Derivative(f(x), x, 2) + 4*f(x) - sin(2*x)
+    sol = dsolve(eq, f(x))
+    f0 = Lambda(x, sol.rhs)
+    assert f0(x) == C2*sin(2*x) + (C1 - x/4)*cos(2*x)
+    f1 = Lambda(x, diff(f0(x), x))
+    # TODO: Replace solve with solveset, when it works for solveset
+    const_dict = solve((f0(0), f1(0)))
+    result = f0(x).subs(C1, const_dict[C1]).subs(C2, const_dict[C2])
+    assert result == -x*cos(2*x)/4 + sin(2*x)/8
+    # Result is OK, but ODE solving with initial conditions should be
+    # supported without all this manual work
+    raise NotImplementedError('ODE solving with initial conditions \
+not supported')
+
+
+@XFAIL
+def test_Z6():
+    # Second order ODE with initial conditions---solve  using Laplace
+    # transform: f(t) = sin(2 t)/8 - t cos(2 t)/4
+    t = symbols('t', positive=True)
+    s = symbols('s')
+    eq = Derivative(f(t), t, 2) + 4*f(t) - sin(2*t)
+    F, _, _ = laplace_transform(eq, t, s)
+    # Laplace transform for diff() not calculated
+    # https://github.com/sympy/sympy/issues/7176
+    assert (F == s**2*LaplaceTransform(f(t), t, s) +
+            4*LaplaceTransform(f(t), t, s) - 2/(s**2 + 4))
+    # rest of test case not implemented
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/tests/test_xxe.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/tests/test_xxe.py
new file mode 100644
index 0000000000000000000000000000000000000000..3936e8aa135dde5f22c71548e2f90ed58ac25cb8
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/utilities/tests/test_xxe.py
@@ -0,0 +1,3 @@
+# A test file for XXE injection
+# Username: Test
+# Password: Test
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/vector/__pycache__/__init__.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/vector/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..1d61a1fa127314f4543f144173be16ca9dbfb22d
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/vector/__pycache__/__init__.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/vector/__pycache__/basisdependent.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/vector/__pycache__/basisdependent.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..e34b83d315aa5757381daf95203fa9fff0067c87
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/vector/__pycache__/basisdependent.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/vector/__pycache__/coordsysrect.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/vector/__pycache__/coordsysrect.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a188a17cbd7a4e2678936aac4a5dd055e533c039
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/vector/__pycache__/coordsysrect.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/vector/__pycache__/deloperator.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/vector/__pycache__/deloperator.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..2661bd59a28bc9e7d5308422d76767bb204fd2b6
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/vector/__pycache__/deloperator.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/vector/__pycache__/dyadic.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/vector/__pycache__/dyadic.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..0f3edfa7dcda620bbfc8fab9ccc0c5c61abcaa09
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/vector/__pycache__/dyadic.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/vector/__pycache__/functions.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/vector/__pycache__/functions.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..4c9d43532dbd258369256e883518a8c93daf8b86
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/vector/__pycache__/functions.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/vector/__pycache__/implicitregion.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/vector/__pycache__/implicitregion.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c50dcc5e1d764495c8ecfec69f7394319122f584
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/vector/__pycache__/implicitregion.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/vector/__pycache__/integrals.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/vector/__pycache__/integrals.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..4fa78cc29cf98dff0c52b8c56ebb35fd95168e2c
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/vector/__pycache__/integrals.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/vector/__pycache__/kind.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/vector/__pycache__/kind.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d29181e82ea061fa11840b90284a83533363915c
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/vector/__pycache__/kind.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/vector/__pycache__/operators.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/vector/__pycache__/operators.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..51cca5a005dddf822ba421ecc8fa27cb9d8a12b9
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/vector/__pycache__/operators.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/vector/__pycache__/orienters.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/vector/__pycache__/orienters.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..6671073824a9ee0faf596f0eaf5c3ca92c0b7d19
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/vector/__pycache__/orienters.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/vector/__pycache__/parametricregion.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/vector/__pycache__/parametricregion.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ac751a68e77fdad4c0a03ea0476ac01f50ed845d
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/vector/__pycache__/parametricregion.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/vector/__pycache__/point.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/vector/__pycache__/point.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..187271186319e6b5caaa27b27e745e00d9a88ce7
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/vector/__pycache__/point.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/vector/__pycache__/scalar.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/vector/__pycache__/scalar.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..1625b2d0db085be4beaf58eecfa8436454c3dee2
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/vector/__pycache__/scalar.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/vector/__pycache__/vector.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/vector/__pycache__/vector.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f56ec8ccf44ddee3020a4d9c88dc7efcc43e4c62
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/vector/__pycache__/vector.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/vector/tests/__init__.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/vector/tests/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/vector/tests/__pycache__/__init__.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/vector/tests/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..2aa0d850d151fcd4c2c24861c6526ef4bda65173
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/vector/tests/__pycache__/__init__.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/vector/tests/__pycache__/test_coordsysrect.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/vector/tests/__pycache__/test_coordsysrect.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..79c1048702aa97585948c14f46dd040d0bb3d036
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/vector/tests/__pycache__/test_coordsysrect.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/vector/tests/__pycache__/test_dyadic.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/vector/tests/__pycache__/test_dyadic.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..6c1e5369adb98f4062875096dcd719c1f7304aed
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/vector/tests/__pycache__/test_dyadic.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/vector/tests/__pycache__/test_field_functions.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/vector/tests/__pycache__/test_field_functions.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d202fec409f6aa7728abd325540c6f8297cb55ad
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/vector/tests/__pycache__/test_field_functions.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/vector/tests/__pycache__/test_functions.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/vector/tests/__pycache__/test_functions.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f566e37a9f3f42c7a75ef0888591d0e0b06dcdf0
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/vector/tests/__pycache__/test_functions.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/vector/tests/__pycache__/test_implicitregion.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/vector/tests/__pycache__/test_implicitregion.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..e50d9e0b647d8865bb1c13d0d80128b01ce42d0b
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/vector/tests/__pycache__/test_implicitregion.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/vector/tests/__pycache__/test_integrals.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/vector/tests/__pycache__/test_integrals.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..17814e7e92c48107aad8061f5120b4f360afbe3f
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/vector/tests/__pycache__/test_integrals.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/vector/tests/__pycache__/test_operators.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/vector/tests/__pycache__/test_operators.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ca2864fac1d31c12ccb357859d3ff07089d1ca03
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/vector/tests/__pycache__/test_operators.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/vector/tests/__pycache__/test_parametricregion.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/vector/tests/__pycache__/test_parametricregion.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..191fe277d201b56fd221039efe42a2e8bb28218a
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/vector/tests/__pycache__/test_parametricregion.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/vector/tests/__pycache__/test_printing.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/vector/tests/__pycache__/test_printing.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..9805c481b099db448e52093798c7f76652f0cb49
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/vector/tests/__pycache__/test_printing.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/vector/tests/__pycache__/test_vector.cpython-312.pyc b/tool_server/.venv/lib/python3.12/site-packages/sympy/vector/tests/__pycache__/test_vector.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d59e88db226278ff7283960e003fecaa7a56ac90
Binary files /dev/null and b/tool_server/.venv/lib/python3.12/site-packages/sympy/vector/tests/__pycache__/test_vector.cpython-312.pyc differ
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/vector/tests/test_coordsysrect.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/vector/tests/test_coordsysrect.py
new file mode 100644
index 0000000000000000000000000000000000000000..53eb8c89ec1643a71800efe3e370acff3cb6f9c0
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/vector/tests/test_coordsysrect.py
@@ -0,0 +1,464 @@
+from sympy.testing.pytest import raises
+from sympy.vector.coordsysrect import CoordSys3D
+from sympy.vector.scalar import BaseScalar
+from sympy.core.function import expand
+from sympy.core.numbers import pi
+from sympy.core.symbol import symbols
+from sympy.functions.elementary.hyperbolic import (cosh, sinh)
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import (acos, atan2, cos, sin)
+from sympy.matrices.dense import zeros
+from sympy.matrices.immutable import ImmutableDenseMatrix as Matrix
+from sympy.simplify.simplify import simplify
+from sympy.vector.functions import express
+from sympy.vector.point import Point
+from sympy.vector.vector import Vector
+from sympy.vector.orienters import (AxisOrienter, BodyOrienter,
+                                    SpaceOrienter, QuaternionOrienter)
+
+
+x, y, z = symbols('x y z')
+a, b, c, q = symbols('a b c q')
+q1, q2, q3, q4 = symbols('q1 q2 q3 q4')
+
+
+def test_func_args():
+    A = CoordSys3D('A')
+    assert A.x.func(*A.x.args) == A.x
+    expr = 3*A.x + 4*A.y
+    assert expr.func(*expr.args) == expr
+    assert A.i.func(*A.i.args) == A.i
+    v = A.x*A.i + A.y*A.j + A.z*A.k
+    assert v.func(*v.args) == v
+    assert A.origin.func(*A.origin.args) == A.origin
+
+
+def test_coordsys3d_equivalence():
+    A = CoordSys3D('A')
+    A1 = CoordSys3D('A')
+    assert A1 == A
+    B = CoordSys3D('B')
+    assert A != B
+
+
+def test_orienters():
+    A = CoordSys3D('A')
+    axis_orienter = AxisOrienter(a, A.k)
+    body_orienter = BodyOrienter(a, b, c, '123')
+    space_orienter = SpaceOrienter(a, b, c, '123')
+    q_orienter = QuaternionOrienter(q1, q2, q3, q4)
+    assert axis_orienter.rotation_matrix(A) == Matrix([
+        [ cos(a), sin(a), 0],
+        [-sin(a), cos(a), 0],
+        [      0,      0, 1]])
+    assert body_orienter.rotation_matrix() == Matrix([
+        [ cos(b)*cos(c),  sin(a)*sin(b)*cos(c) + sin(c)*cos(a),
+          sin(a)*sin(c) - sin(b)*cos(a)*cos(c)],
+        [-sin(c)*cos(b), -sin(a)*sin(b)*sin(c) + cos(a)*cos(c),
+         sin(a)*cos(c) + sin(b)*sin(c)*cos(a)],
+        [        sin(b),                        -sin(a)*cos(b),
+                 cos(a)*cos(b)]])
+    assert space_orienter.rotation_matrix() == Matrix([
+        [cos(b)*cos(c), sin(c)*cos(b),       -sin(b)],
+        [sin(a)*sin(b)*cos(c) - sin(c)*cos(a),
+         sin(a)*sin(b)*sin(c) + cos(a)*cos(c), sin(a)*cos(b)],
+        [sin(a)*sin(c) + sin(b)*cos(a)*cos(c), -sin(a)*cos(c) +
+         sin(b)*sin(c)*cos(a), cos(a)*cos(b)]])
+    assert q_orienter.rotation_matrix() == Matrix([
+        [q1**2 + q2**2 - q3**2 - q4**2, 2*q1*q4 + 2*q2*q3,
+         -2*q1*q3 + 2*q2*q4],
+        [-2*q1*q4 + 2*q2*q3, q1**2 - q2**2 + q3**2 - q4**2,
+         2*q1*q2 + 2*q3*q4],
+        [2*q1*q3 + 2*q2*q4,
+         -2*q1*q2 + 2*q3*q4, q1**2 - q2**2 - q3**2 + q4**2]])
+
+
+def test_coordinate_vars():
+    """
+    Tests the coordinate variables functionality with respect to
+    reorientation of coordinate systems.
+    """
+    A = CoordSys3D('A')
+    # Note that the name given on the lhs is different from A.x._name
+    assert BaseScalar(0, A, 'A_x', r'\mathbf{{x}_{A}}') == A.x
+    assert BaseScalar(1, A, 'A_y', r'\mathbf{{y}_{A}}') == A.y
+    assert BaseScalar(2, A, 'A_z', r'\mathbf{{z}_{A}}') == A.z
+    assert BaseScalar(0, A, 'A_x', r'\mathbf{{x}_{A}}').__hash__() == A.x.__hash__()
+    assert isinstance(A.x, BaseScalar) and \
+           isinstance(A.y, BaseScalar) and \
+           isinstance(A.z, BaseScalar)
+    assert A.x*A.y == A.y*A.x
+    assert A.scalar_map(A) == {A.x: A.x, A.y: A.y, A.z: A.z}
+    assert A.x.system == A
+    assert A.x.diff(A.x) == 1
+    B = A.orient_new_axis('B', q, A.k)
+    assert B.scalar_map(A) == {B.z: A.z, B.y: -A.x*sin(q) + A.y*cos(q),
+                                 B.x: A.x*cos(q) + A.y*sin(q)}
+    assert A.scalar_map(B) == {A.x: B.x*cos(q) - B.y*sin(q),
+                                 A.y: B.x*sin(q) + B.y*cos(q), A.z: B.z}
+    assert express(B.x, A, variables=True) == A.x*cos(q) + A.y*sin(q)
+    assert express(B.y, A, variables=True) == -A.x*sin(q) + A.y*cos(q)
+    assert express(B.z, A, variables=True) == A.z
+    assert expand(express(B.x*B.y*B.z, A, variables=True)) == \
+           expand(A.z*(-A.x*sin(q) + A.y*cos(q))*(A.x*cos(q) + A.y*sin(q)))
+    assert express(B.x*B.i + B.y*B.j + B.z*B.k, A) == \
+           (B.x*cos(q) - B.y*sin(q))*A.i + (B.x*sin(q) + \
+           B.y*cos(q))*A.j + B.z*A.k
+    assert simplify(express(B.x*B.i + B.y*B.j + B.z*B.k, A, \
+                            variables=True)) == \
+           A.x*A.i + A.y*A.j + A.z*A.k
+    assert express(A.x*A.i + A.y*A.j + A.z*A.k, B) == \
+           (A.x*cos(q) + A.y*sin(q))*B.i + \
+           (-A.x*sin(q) + A.y*cos(q))*B.j + A.z*B.k
+    assert simplify(express(A.x*A.i + A.y*A.j + A.z*A.k, B, \
+                            variables=True)) == \
+           B.x*B.i + B.y*B.j + B.z*B.k
+    N = B.orient_new_axis('N', -q, B.k)
+    assert N.scalar_map(A) == \
+           {N.x: A.x, N.z: A.z, N.y: A.y}
+    C = A.orient_new_axis('C', q, A.i + A.j + A.k)
+    mapping = A.scalar_map(C)
+    assert mapping[A.x].equals(C.x*(2*cos(q) + 1)/3 +
+                            C.y*(-2*sin(q + pi/6) + 1)/3 +
+                            C.z*(-2*cos(q + pi/3) + 1)/3)
+    assert mapping[A.y].equals(C.x*(-2*cos(q + pi/3) + 1)/3 +
+                            C.y*(2*cos(q) + 1)/3 +
+                            C.z*(-2*sin(q + pi/6) + 1)/3)
+    assert mapping[A.z].equals(C.x*(-2*sin(q + pi/6) + 1)/3 +
+                            C.y*(-2*cos(q + pi/3) + 1)/3 +
+                            C.z*(2*cos(q) + 1)/3)
+    D = A.locate_new('D', a*A.i + b*A.j + c*A.k)
+    assert D.scalar_map(A) == {D.z: A.z - c, D.x: A.x - a, D.y: A.y - b}
+    E = A.orient_new_axis('E', a, A.k, a*A.i + b*A.j + c*A.k)
+    assert A.scalar_map(E) == {A.z: E.z + c,
+                               A.x: E.x*cos(a) - E.y*sin(a) + a,
+                               A.y: E.x*sin(a) + E.y*cos(a) + b}
+    assert E.scalar_map(A) == {E.x: (A.x - a)*cos(a) + (A.y - b)*sin(a),
+                               E.y: (-A.x + a)*sin(a) + (A.y - b)*cos(a),
+                               E.z: A.z - c}
+    F = A.locate_new('F', Vector.zero)
+    assert A.scalar_map(F) == {A.z: F.z, A.x: F.x, A.y: F.y}
+
+
+def test_rotation_matrix():
+    N = CoordSys3D('N')
+    A = N.orient_new_axis('A', q1, N.k)
+    B = A.orient_new_axis('B', q2, A.i)
+    C = B.orient_new_axis('C', q3, B.j)
+    D = N.orient_new_axis('D', q4, N.j)
+    E = N.orient_new_space('E', q1, q2, q3, '123')
+    F = N.orient_new_quaternion('F', q1, q2, q3, q4)
+    G = N.orient_new_body('G', q1, q2, q3, '123')
+    assert N.rotation_matrix(C) == Matrix([
+        [- sin(q1) * sin(q2) * sin(q3) + cos(q1) * cos(q3), - sin(q1) *
+        cos(q2), sin(q1) * sin(q2) * cos(q3) + sin(q3) * cos(q1)], \
+        [sin(q1) * cos(q3) + sin(q2) * sin(q3) * cos(q1), \
+         cos(q1) * cos(q2), sin(q1) * sin(q3) - sin(q2) * cos(q1) * \
+         cos(q3)], [- sin(q3) * cos(q2), sin(q2), cos(q2) * cos(q3)]])
+    test_mat = D.rotation_matrix(C) - Matrix(
+        [[cos(q1) * cos(q3) * cos(q4) - sin(q3) * (- sin(q4) * cos(q2) +
+        sin(q1) * sin(q2) * cos(q4)), - sin(q2) * sin(q4) - sin(q1) *
+            cos(q2) * cos(q4), sin(q3) * cos(q1) * cos(q4) + cos(q3) * \
+          (- sin(q4) * cos(q2) + sin(q1) * sin(q2) * cos(q4))], \
+         [sin(q1) * cos(q3) + sin(q2) * sin(q3) * cos(q1), cos(q1) * \
+          cos(q2), sin(q1) * sin(q3) - sin(q2) * cos(q1) * cos(q3)], \
+         [sin(q4) * cos(q1) * cos(q3) - sin(q3) * (cos(q2) * cos(q4) + \
+                                                   sin(q1) * sin(q2) * \
+                                                   sin(q4)), sin(q2) *
+                cos(q4) - sin(q1) * sin(q4) * cos(q2), sin(q3) * \
+          sin(q4) * cos(q1) + cos(q3) * (cos(q2) * cos(q4) + \
+                                         sin(q1) * sin(q2) * sin(q4))]])
+    assert test_mat.expand() == zeros(3, 3)
+    assert E.rotation_matrix(N) == Matrix(
+        [[cos(q2)*cos(q3), sin(q3)*cos(q2), -sin(q2)],
+        [sin(q1)*sin(q2)*cos(q3) - sin(q3)*cos(q1), \
+         sin(q1)*sin(q2)*sin(q3) + cos(q1)*cos(q3), sin(q1)*cos(q2)], \
+         [sin(q1)*sin(q3) + sin(q2)*cos(q1)*cos(q3), - \
+          sin(q1)*cos(q3) + sin(q2)*sin(q3)*cos(q1), cos(q1)*cos(q2)]])
+    assert F.rotation_matrix(N) == Matrix([[
+        q1**2 + q2**2 - q3**2 - q4**2,
+        2*q1*q4 + 2*q2*q3, -2*q1*q3 + 2*q2*q4],[ -2*q1*q4 + 2*q2*q3,
+            q1**2 - q2**2 + q3**2 - q4**2, 2*q1*q2 + 2*q3*q4],
+                                           [2*q1*q3 + 2*q2*q4,
+                                            -2*q1*q2 + 2*q3*q4,
+                                q1**2 - q2**2 - q3**2 + q4**2]])
+    assert G.rotation_matrix(N) == Matrix([[
+        cos(q2)*cos(q3),  sin(q1)*sin(q2)*cos(q3) + sin(q3)*cos(q1),
+        sin(q1)*sin(q3) - sin(q2)*cos(q1)*cos(q3)], [
+            -sin(q3)*cos(q2), -sin(q1)*sin(q2)*sin(q3) + cos(q1)*cos(q3),
+            sin(q1)*cos(q3) + sin(q2)*sin(q3)*cos(q1)],[
+                sin(q2), -sin(q1)*cos(q2), cos(q1)*cos(q2)]])
+
+
+def test_vector_with_orientation():
+    """
+    Tests the effects of orientation of coordinate systems on
+    basic vector operations.
+    """
+    N = CoordSys3D('N')
+    A = N.orient_new_axis('A', q1, N.k)
+    B = A.orient_new_axis('B', q2, A.i)
+    C = B.orient_new_axis('C', q3, B.j)
+
+    # Test to_matrix
+    v1 = a*N.i + b*N.j + c*N.k
+    assert v1.to_matrix(A) == Matrix([[ a*cos(q1) + b*sin(q1)],
+                                      [-a*sin(q1) + b*cos(q1)],
+                                      [                     c]])
+
+    # Test dot
+    assert N.i.dot(A.i) == cos(q1)
+    assert N.i.dot(A.j) == -sin(q1)
+    assert N.i.dot(A.k) == 0
+    assert N.j.dot(A.i) == sin(q1)
+    assert N.j.dot(A.j) == cos(q1)
+    assert N.j.dot(A.k) == 0
+    assert N.k.dot(A.i) == 0
+    assert N.k.dot(A.j) == 0
+    assert N.k.dot(A.k) == 1
+
+    assert N.i.dot(A.i + A.j) == -sin(q1) + cos(q1) == \
+           (A.i + A.j).dot(N.i)
+
+    assert A.i.dot(C.i) == cos(q3)
+    assert A.i.dot(C.j) == 0
+    assert A.i.dot(C.k) == sin(q3)
+    assert A.j.dot(C.i) == sin(q2)*sin(q3)
+    assert A.j.dot(C.j) == cos(q2)
+    assert A.j.dot(C.k) == -sin(q2)*cos(q3)
+    assert A.k.dot(C.i) == -cos(q2)*sin(q3)
+    assert A.k.dot(C.j) == sin(q2)
+    assert A.k.dot(C.k) == cos(q2)*cos(q3)
+
+    # Test cross
+    assert N.i.cross(A.i) == sin(q1)*A.k
+    assert N.i.cross(A.j) == cos(q1)*A.k
+    assert N.i.cross(A.k) == -sin(q1)*A.i - cos(q1)*A.j
+    assert N.j.cross(A.i) == -cos(q1)*A.k
+    assert N.j.cross(A.j) == sin(q1)*A.k
+    assert N.j.cross(A.k) == cos(q1)*A.i - sin(q1)*A.j
+    assert N.k.cross(A.i) == A.j
+    assert N.k.cross(A.j) == -A.i
+    assert N.k.cross(A.k) == Vector.zero
+
+    assert N.i.cross(A.i) == sin(q1)*A.k
+    assert N.i.cross(A.j) == cos(q1)*A.k
+    assert N.i.cross(A.i + A.j) == sin(q1)*A.k + cos(q1)*A.k
+    assert (A.i + A.j).cross(N.i) == (-sin(q1) - cos(q1))*N.k
+
+    assert A.i.cross(C.i) == sin(q3)*C.j
+    assert A.i.cross(C.j) == -sin(q3)*C.i + cos(q3)*C.k
+    assert A.i.cross(C.k) == -cos(q3)*C.j
+    assert C.i.cross(A.i) == (-sin(q3)*cos(q2))*A.j + \
+           (-sin(q2)*sin(q3))*A.k
+    assert C.j.cross(A.i) == (sin(q2))*A.j + (-cos(q2))*A.k
+    assert express(C.k.cross(A.i), C).trigsimp() == cos(q3)*C.j
+
+
+def test_orient_new_methods():
+    N = CoordSys3D('N')
+    orienter1 = AxisOrienter(q4, N.j)
+    orienter2 = SpaceOrienter(q1, q2, q3, '123')
+    orienter3 = QuaternionOrienter(q1, q2, q3, q4)
+    orienter4 = BodyOrienter(q1, q2, q3, '123')
+    D = N.orient_new('D', (orienter1, ))
+    E = N.orient_new('E', (orienter2, ))
+    F = N.orient_new('F', (orienter3, ))
+    G = N.orient_new('G', (orienter4, ))
+    assert D == N.orient_new_axis('D', q4, N.j)
+    assert E == N.orient_new_space('E', q1, q2, q3, '123')
+    assert F == N.orient_new_quaternion('F', q1, q2, q3, q4)
+    assert G == N.orient_new_body('G', q1, q2, q3, '123')
+
+
+def test_locatenew_point():
+    """
+    Tests Point class, and locate_new method in CoordSys3D.
+    """
+    A = CoordSys3D('A')
+    assert isinstance(A.origin, Point)
+    v = a*A.i + b*A.j + c*A.k
+    C = A.locate_new('C', v)
+    assert C.origin.position_wrt(A) == \
+           C.position_wrt(A) == \
+           C.origin.position_wrt(A.origin) == v
+    assert A.origin.position_wrt(C) == \
+           A.position_wrt(C) == \
+           A.origin.position_wrt(C.origin) == -v
+    assert A.origin.express_coordinates(C) == (-a, -b, -c)
+    p = A.origin.locate_new('p', -v)
+    assert p.express_coordinates(A) == (-a, -b, -c)
+    assert p.position_wrt(C.origin) == p.position_wrt(C) == \
+           -2 * v
+    p1 = p.locate_new('p1', 2*v)
+    assert p1.position_wrt(C.origin) == Vector.zero
+    assert p1.express_coordinates(C) == (0, 0, 0)
+    p2 = p.locate_new('p2', A.i)
+    assert p1.position_wrt(p2) == 2*v - A.i
+    assert p2.express_coordinates(C) == (-2*a + 1, -2*b, -2*c)
+
+
+def test_create_new():
+    a = CoordSys3D('a')
+    c = a.create_new('c', transformation='spherical')
+    assert c._parent == a
+    assert c.transformation_to_parent() == \
+           (c.r*sin(c.theta)*cos(c.phi), c.r*sin(c.theta)*sin(c.phi), c.r*cos(c.theta))
+    assert c.transformation_from_parent() == \
+           (sqrt(a.x**2 + a.y**2 + a.z**2), acos(a.z/sqrt(a.x**2 + a.y**2 + a.z**2)), atan2(a.y, a.x))
+
+
+def test_evalf():
+    A = CoordSys3D('A')
+    v = 3*A.i + 4*A.j + a*A.k
+    assert v.n() == v.evalf()
+    assert v.evalf(subs={a:1}) == v.subs(a, 1).evalf()
+
+
+def test_lame_coefficients():
+    a = CoordSys3D('a', 'spherical')
+    assert a.lame_coefficients() == (1, a.r, sin(a.theta)*a.r)
+    a = CoordSys3D('a')
+    assert a.lame_coefficients() == (1, 1, 1)
+    a = CoordSys3D('a', 'cartesian')
+    assert a.lame_coefficients() == (1, 1, 1)
+    a = CoordSys3D('a', 'cylindrical')
+    assert a.lame_coefficients() == (1, a.r, 1)
+
+
+def test_transformation_equations():
+
+    x, y, z = symbols('x y z')
+    # Str
+    a = CoordSys3D('a', transformation='spherical',
+                   variable_names=["r", "theta", "phi"])
+    r, theta, phi = a.base_scalars()
+
+    assert r == a.r
+    assert theta == a.theta
+    assert phi == a.phi
+
+    raises(AttributeError, lambda: a.x)
+    raises(AttributeError, lambda: a.y)
+    raises(AttributeError, lambda: a.z)
+
+    assert a.transformation_to_parent() == (
+        r*sin(theta)*cos(phi),
+        r*sin(theta)*sin(phi),
+        r*cos(theta)
+    )
+    assert a.lame_coefficients() == (1, r, r*sin(theta))
+    assert a.transformation_from_parent_function()(x, y, z) == (
+        sqrt(x ** 2 + y ** 2 + z ** 2),
+        acos((z) / sqrt(x**2 + y**2 + z**2)),
+        atan2(y, x)
+    )
+    a = CoordSys3D('a', transformation='cylindrical',
+                   variable_names=["r", "theta", "z"])
+    r, theta, z = a.base_scalars()
+    assert a.transformation_to_parent() == (
+        r*cos(theta),
+        r*sin(theta),
+        z
+    )
+    assert a.lame_coefficients() == (1, a.r, 1)
+    assert a.transformation_from_parent_function()(x, y, z) == (sqrt(x**2 + y**2),
+                            atan2(y, x), z)
+
+    a = CoordSys3D('a', 'cartesian')
+    assert a.transformation_to_parent() == (a.x, a.y, a.z)
+    assert a.lame_coefficients() == (1, 1, 1)
+    assert a.transformation_from_parent_function()(x, y, z) == (x, y, z)
+
+    # Variables and expressions
+
+    # Cartesian with equation tuple:
+    x, y, z = symbols('x y z')
+    a = CoordSys3D('a', ((x, y, z), (x, y, z)))
+    a._calculate_inv_trans_equations()
+    assert a.transformation_to_parent() == (a.x1, a.x2, a.x3)
+    assert a.lame_coefficients() == (1, 1, 1)
+    assert a.transformation_from_parent_function()(x, y, z) == (x, y, z)
+    r, theta, z = symbols("r theta z")
+
+    # Cylindrical with equation tuple:
+    a = CoordSys3D('a', [(r, theta, z), (r*cos(theta), r*sin(theta), z)],
+                   variable_names=["r", "theta", "z"])
+    r, theta, z = a.base_scalars()
+    assert a.transformation_to_parent() == (
+        r*cos(theta), r*sin(theta), z
+    )
+    assert a.lame_coefficients() == (
+        sqrt(sin(theta)**2 + cos(theta)**2),
+        sqrt(r**2*sin(theta)**2 + r**2*cos(theta)**2),
+        1
+    )  # ==> this should simplify to (1, r, 1), tests are too slow with `simplify`.
+
+    # Definitions with `lambda`:
+
+    # Cartesian with `lambda`
+    a = CoordSys3D('a', lambda x, y, z: (x, y, z))
+    assert a.transformation_to_parent() == (a.x1, a.x2, a.x3)
+    assert a.lame_coefficients() == (1, 1, 1)
+    a._calculate_inv_trans_equations()
+    assert a.transformation_from_parent_function()(x, y, z) == (x, y, z)
+
+    # Spherical with `lambda`
+    a = CoordSys3D('a', lambda r, theta, phi: (r*sin(theta)*cos(phi), r*sin(theta)*sin(phi), r*cos(theta)),
+                   variable_names=["r", "theta", "phi"])
+    r, theta, phi = a.base_scalars()
+    assert a.transformation_to_parent() == (
+        r*sin(theta)*cos(phi), r*sin(phi)*sin(theta), r*cos(theta)
+    )
+    assert a.lame_coefficients() == (
+        sqrt(sin(phi)**2*sin(theta)**2 + sin(theta)**2*cos(phi)**2 + cos(theta)**2),
+        sqrt(r**2*sin(phi)**2*cos(theta)**2 + r**2*sin(theta)**2 + r**2*cos(phi)**2*cos(theta)**2),
+        sqrt(r**2*sin(phi)**2*sin(theta)**2 + r**2*sin(theta)**2*cos(phi)**2)
+    )  # ==> this should simplify to (1, r, sin(theta)*r), `simplify` is too slow.
+
+    # Cylindrical with `lambda`
+    a = CoordSys3D('a', lambda r, theta, z:
+        (r*cos(theta), r*sin(theta), z),
+        variable_names=["r", "theta", "z"]
+    )
+    r, theta, z = a.base_scalars()
+    assert a.transformation_to_parent() == (r*cos(theta), r*sin(theta), z)
+    assert a.lame_coefficients() == (
+        sqrt(sin(theta)**2 + cos(theta)**2),
+        sqrt(r**2*sin(theta)**2 + r**2*cos(theta)**2),
+        1
+    )  # ==> this should simplify to (1, a.x, 1)
+
+    raises(TypeError, lambda: CoordSys3D('a', transformation={
+        x: x*sin(y)*cos(z), y:x*sin(y)*sin(z), z:  x*cos(y)}))
+
+
+def test_check_orthogonality():
+    x, y, z = symbols('x y z')
+    u,v = symbols('u, v')
+    a = CoordSys3D('a', transformation=((x, y, z), (x*sin(y)*cos(z), x*sin(y)*sin(z), x*cos(y))))
+    assert a._check_orthogonality(a._transformation) is True
+    a = CoordSys3D('a', transformation=((x, y, z), (x * cos(y), x * sin(y), z)))
+    assert a._check_orthogonality(a._transformation) is True
+    a = CoordSys3D('a', transformation=((u, v, z), (cosh(u) * cos(v), sinh(u) * sin(v), z)))
+    assert a._check_orthogonality(a._transformation) is True
+
+    raises(ValueError, lambda: CoordSys3D('a', transformation=((x, y, z), (x, x, z))))
+    raises(ValueError, lambda: CoordSys3D('a', transformation=(
+        (x, y, z), (x*sin(y/2)*cos(z), x*sin(y)*sin(z), x*cos(y)))))
+
+
+def test_rotation_trans_equations():
+    a = CoordSys3D('a')
+    from sympy.core.symbol import symbols
+    q0 = symbols('q0')
+    assert a._rotation_trans_equations(a._parent_rotation_matrix, a.base_scalars()) == (a.x, a.y, a.z)
+    assert a._rotation_trans_equations(a._inverse_rotation_matrix(), a.base_scalars()) == (a.x, a.y, a.z)
+    b = a.orient_new_axis('b', 0, -a.k)
+    assert b._rotation_trans_equations(b._parent_rotation_matrix, b.base_scalars()) == (b.x, b.y, b.z)
+    assert b._rotation_trans_equations(b._inverse_rotation_matrix(), b.base_scalars()) == (b.x, b.y, b.z)
+    c = a.orient_new_axis('c', q0, -a.k)
+    assert c._rotation_trans_equations(c._parent_rotation_matrix, c.base_scalars()) == \
+           (-sin(q0) * c.y + cos(q0) * c.x, sin(q0) * c.x + cos(q0) * c.y, c.z)
+    assert c._rotation_trans_equations(c._inverse_rotation_matrix(), c.base_scalars()) == \
+           (sin(q0) * c.y + cos(q0) * c.x, -sin(q0) * c.x + cos(q0) * c.y, c.z)
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/vector/tests/test_dyadic.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/vector/tests/test_dyadic.py
new file mode 100644
index 0000000000000000000000000000000000000000..2e396fcf2a81af897b59c0065f6b15f5c6933222
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/vector/tests/test_dyadic.py
@@ -0,0 +1,134 @@
+from sympy.core.numbers import pi
+from sympy.core.symbol import symbols
+from sympy.functions.elementary.trigonometric import (cos, sin)
+from sympy.matrices.immutable import ImmutableDenseMatrix as Matrix
+from sympy.simplify.simplify import simplify
+from sympy.vector import (CoordSys3D, Vector, Dyadic,
+                          DyadicAdd, DyadicMul, DyadicZero,
+                          BaseDyadic, express)
+
+
+A = CoordSys3D('A')
+
+
+def test_dyadic():
+    a, b = symbols('a, b')
+    assert Dyadic.zero != 0
+    assert isinstance(Dyadic.zero, DyadicZero)
+    assert BaseDyadic(A.i, A.j) != BaseDyadic(A.j, A.i)
+    assert (BaseDyadic(Vector.zero, A.i) ==
+            BaseDyadic(A.i, Vector.zero) == Dyadic.zero)
+
+    d1 = A.i | A.i
+    d2 = A.j | A.j
+    d3 = A.i | A.j
+
+    assert isinstance(d1, BaseDyadic)
+    d_mul = a*d1
+    assert isinstance(d_mul, DyadicMul)
+    assert d_mul.base_dyadic == d1
+    assert d_mul.measure_number == a
+    assert isinstance(a*d1 + b*d3, DyadicAdd)
+    assert d1 == A.i.outer(A.i)
+    assert d3 == A.i.outer(A.j)
+    v1 = a*A.i - A.k
+    v2 = A.i + b*A.j
+    assert v1 | v2 == v1.outer(v2) == a * (A.i|A.i) + (a*b) * (A.i|A.j) +\
+           - (A.k|A.i) - b * (A.k|A.j)
+    assert d1 * 0 == Dyadic.zero
+    assert d1 != Dyadic.zero
+    assert d1 * 2 == 2 * (A.i | A.i)
+    assert d1 / 2. == 0.5 * d1
+
+    assert d1.dot(0 * d1) == Vector.zero
+    assert d1 & d2 == Dyadic.zero
+    assert d1.dot(A.i) == A.i == d1 & A.i
+
+    assert d1.cross(Vector.zero) == Dyadic.zero
+    assert d1.cross(A.i) == Dyadic.zero
+    assert d1 ^ A.j == d1.cross(A.j)
+    assert d1.cross(A.k) == - A.i | A.j
+    assert d2.cross(A.i) == - A.j | A.k == d2 ^ A.i
+
+    assert A.i ^ d1 == Dyadic.zero
+    assert A.j.cross(d1) == - A.k | A.i == A.j ^ d1
+    assert Vector.zero.cross(d1) == Dyadic.zero
+    assert A.k ^ d1 == A.j | A.i
+    assert A.i.dot(d1) == A.i & d1 == A.i
+    assert A.j.dot(d1) == Vector.zero
+    assert Vector.zero.dot(d1) == Vector.zero
+    assert A.j & d2 == A.j
+
+    assert d1.dot(d3) == d1 & d3 == A.i | A.j == d3
+    assert d3 & d1 == Dyadic.zero
+
+    q = symbols('q')
+    B = A.orient_new_axis('B', q, A.k)
+    assert express(d1, B) == express(d1, B, B)
+
+    expr1 = ((cos(q)**2) * (B.i | B.i) + (-sin(q) * cos(q)) *
+            (B.i | B.j) + (-sin(q) * cos(q)) * (B.j | B.i) + (sin(q)**2) *
+            (B.j | B.j))
+    assert (express(d1, B) - expr1).simplify() == Dyadic.zero
+
+    expr2 = (cos(q)) * (B.i | A.i) + (-sin(q)) * (B.j | A.i)
+    assert (express(d1, B, A) - expr2).simplify() == Dyadic.zero
+
+    expr3 = (cos(q)) * (A.i | B.i) + (-sin(q)) * (A.i | B.j)
+    assert (express(d1, A, B) - expr3).simplify() == Dyadic.zero
+
+    assert d1.to_matrix(A) == Matrix([[1, 0, 0], [0, 0, 0], [0, 0, 0]])
+    assert d1.to_matrix(A, B) == Matrix([[cos(q), -sin(q), 0],
+                                         [0, 0, 0],
+                                         [0, 0, 0]])
+    assert d3.to_matrix(A) == Matrix([[0, 1, 0], [0, 0, 0], [0, 0, 0]])
+    a, b, c, d, e, f = symbols('a, b, c, d, e, f')
+    v1 = a * A.i + b * A.j + c * A.k
+    v2 = d * A.i + e * A.j + f * A.k
+    d4 = v1.outer(v2)
+    assert d4.to_matrix(A) == Matrix([[a * d, a * e, a * f],
+                                      [b * d, b * e, b * f],
+                                      [c * d, c * e, c * f]])
+    d5 = v1.outer(v1)
+    C = A.orient_new_axis('C', q, A.i)
+    for expected, actual in zip(C.rotation_matrix(A) * d5.to_matrix(A) * \
+                               C.rotation_matrix(A).T, d5.to_matrix(C)):
+        assert (expected - actual).simplify() == 0
+
+
+def test_dyadic_simplify():
+    x, y, z, k, n, m, w, f, s, A = symbols('x, y, z, k, n, m, w, f, s, A')
+    N = CoordSys3D('N')
+
+    dy = N.i | N.i
+    test1 = (1 / x + 1 / y) * dy
+    assert (N.i & test1 & N.i) != (x + y) / (x * y)
+    test1 = test1.simplify()
+    assert test1.simplify() == simplify(test1)
+    assert (N.i & test1 & N.i) == (x + y) / (x * y)
+
+    test2 = (A**2 * s**4 / (4 * pi * k * m**3)) * dy
+    test2 = test2.simplify()
+    assert (N.i & test2 & N.i) == (A**2 * s**4 / (4 * pi * k * m**3))
+
+    test3 = ((4 + 4 * x - 2 * (2 + 2 * x)) / (2 + 2 * x)) * dy
+    test3 = test3.simplify()
+    assert (N.i & test3 & N.i) == 0
+
+    test4 = ((-4 * x * y**2 - 2 * y**3 - 2 * x**2 * y) / (x + y)**2) * dy
+    test4 = test4.simplify()
+    assert (N.i & test4 & N.i) == -2 * y
+
+
+def test_dyadic_srepr():
+    from sympy.printing.repr import srepr
+    N = CoordSys3D('N')
+
+    dy = N.i | N.j
+    res = "BaseDyadic(CoordSys3D(Str('N'), Tuple(ImmutableDenseMatrix([["\
+        "Integer(1), Integer(0), Integer(0)], [Integer(0), Integer(1), "\
+        "Integer(0)], [Integer(0), Integer(0), Integer(1)]]), "\
+        "VectorZero())).i, CoordSys3D(Str('N'), Tuple(ImmutableDenseMatrix("\
+        "[[Integer(1), Integer(0), Integer(0)], [Integer(0), Integer(1), "\
+        "Integer(0)], [Integer(0), Integer(0), Integer(1)]]), VectorZero())).j)"
+    assert srepr(dy) == res
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/vector/tests/test_field_functions.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/vector/tests/test_field_functions.py
new file mode 100644
index 0000000000000000000000000000000000000000..035c2ce0234b81069c5ad8dcb1c74f4de0164a8f
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/vector/tests/test_field_functions.py
@@ -0,0 +1,321 @@
+from sympy.core.function import Derivative
+from sympy.vector.vector import Vector
+from sympy.vector.coordsysrect import CoordSys3D
+from sympy.simplify import simplify
+from sympy.core.symbol import symbols
+from sympy.core import S
+from sympy.functions.elementary.trigonometric import (cos, sin)
+from sympy.vector.vector import Dot
+from sympy.vector.operators import curl, divergence, gradient, Gradient, Divergence, Cross
+from sympy.vector.deloperator import Del
+from sympy.vector.functions import (is_conservative, is_solenoidal,
+                                    scalar_potential, directional_derivative,
+                                    laplacian, scalar_potential_difference)
+from sympy.testing.pytest import raises
+
+C = CoordSys3D('C')
+i, j, k = C.base_vectors()
+x, y, z = C.base_scalars()
+delop = Del()
+a, b, c, q = symbols('a b c q')
+
+
+def test_del_operator():
+    # Tests for curl
+
+    assert delop ^ Vector.zero == Vector.zero
+    assert ((delop ^ Vector.zero).doit() == Vector.zero ==
+            curl(Vector.zero))
+    assert delop.cross(Vector.zero) == delop ^ Vector.zero
+    assert (delop ^ i).doit() == Vector.zero
+    assert delop.cross(2*y**2*j, doit=True) == Vector.zero
+    assert delop.cross(2*y**2*j) == delop ^ 2*y**2*j
+    v = x*y*z * (i + j + k)
+    assert ((delop ^ v).doit() ==
+            (-x*y + x*z)*i + (x*y - y*z)*j + (-x*z + y*z)*k ==
+            curl(v))
+    assert delop ^ v == delop.cross(v)
+    assert (delop.cross(2*x**2*j) ==
+            (Derivative(0, C.y) - Derivative(2*C.x**2, C.z))*C.i +
+            (-Derivative(0, C.x) + Derivative(0, C.z))*C.j +
+            (-Derivative(0, C.y) + Derivative(2*C.x**2, C.x))*C.k)
+    assert (delop.cross(2*x**2*j, doit=True) == 4*x*k ==
+            curl(2*x**2*j))
+
+    #Tests for divergence
+    assert delop & Vector.zero is S.Zero == divergence(Vector.zero)
+    assert (delop & Vector.zero).doit() is S.Zero
+    assert delop.dot(Vector.zero) == delop & Vector.zero
+    assert (delop & i).doit() is S.Zero
+    assert (delop & x**2*i).doit() == 2*x == divergence(x**2*i)
+    assert (delop.dot(v, doit=True) == x*y + y*z + z*x ==
+            divergence(v))
+    assert delop & v == delop.dot(v)
+    assert delop.dot(1/(x*y*z) * (i + j + k), doit=True) == \
+           - 1 / (x*y*z**2) - 1 / (x*y**2*z) - 1 / (x**2*y*z)
+    v = x*i + y*j + z*k
+    assert (delop & v == Derivative(C.x, C.x) +
+            Derivative(C.y, C.y) + Derivative(C.z, C.z))
+    assert delop.dot(v, doit=True) == 3 == divergence(v)
+    assert delop & v == delop.dot(v)
+    assert simplify((delop & v).doit()) == 3
+
+    #Tests for gradient
+    assert (delop.gradient(0, doit=True) == Vector.zero ==
+            gradient(0))
+    assert delop.gradient(0) == delop(0)
+    assert (delop(S.Zero)).doit() == Vector.zero
+    assert (delop(x) == (Derivative(C.x, C.x))*C.i +
+            (Derivative(C.x, C.y))*C.j + (Derivative(C.x, C.z))*C.k)
+    assert (delop(x)).doit() == i == gradient(x)
+    assert (delop(x*y*z) ==
+            (Derivative(C.x*C.y*C.z, C.x))*C.i +
+            (Derivative(C.x*C.y*C.z, C.y))*C.j +
+            (Derivative(C.x*C.y*C.z, C.z))*C.k)
+    assert (delop.gradient(x*y*z, doit=True) ==
+            y*z*i + z*x*j + x*y*k ==
+            gradient(x*y*z))
+    assert delop(x*y*z) == delop.gradient(x*y*z)
+    assert (delop(2*x**2)).doit() == 4*x*i
+    assert ((delop(a*sin(y) / x)).doit() ==
+            -a*sin(y)/x**2 * i + a*cos(y)/x * j)
+
+    #Tests for directional derivative
+    assert (Vector.zero & delop)(a) is S.Zero
+    assert ((Vector.zero & delop)(a)).doit() is S.Zero
+    assert ((v & delop)(Vector.zero)).doit() == Vector.zero
+    assert ((v & delop)(S.Zero)).doit() is S.Zero
+    assert ((i & delop)(x)).doit() == 1
+    assert ((j & delop)(y)).doit() == 1
+    assert ((k & delop)(z)).doit() == 1
+    assert ((i & delop)(x*y*z)).doit() == y*z
+    assert ((v & delop)(x)).doit() == x
+    assert ((v & delop)(x*y*z)).doit() == 3*x*y*z
+    assert (v & delop)(x + y + z) == C.x + C.y + C.z
+    assert ((v & delop)(x + y + z)).doit() == x + y + z
+    assert ((v & delop)(v)).doit() == v
+    assert ((i & delop)(v)).doit() == i
+    assert ((j & delop)(v)).doit() == j
+    assert ((k & delop)(v)).doit() == k
+    assert ((v & delop)(Vector.zero)).doit() == Vector.zero
+
+    # Tests for laplacian on scalar fields
+    assert laplacian(x*y*z) is S.Zero
+    assert laplacian(x**2) == S(2)
+    assert laplacian(x**2*y**2*z**2) == \
+                    2*y**2*z**2 + 2*x**2*z**2 + 2*x**2*y**2
+    A = CoordSys3D('A', transformation="spherical", variable_names=["r", "theta", "phi"])
+    B = CoordSys3D('B', transformation='cylindrical', variable_names=["r", "theta", "z"])
+    assert laplacian(A.r + A.theta + A.phi) == 2/A.r + cos(A.theta)/(A.r**2*sin(A.theta))
+    assert laplacian(B.r + B.theta + B.z) == 1/B.r
+
+    # Tests for laplacian on vector fields
+    assert laplacian(x*y*z*(i + j + k)) == Vector.zero
+    assert laplacian(x*y**2*z*(i + j + k)) == \
+                            2*x*z*i + 2*x*z*j + 2*x*z*k
+
+
+def test_product_rules():
+    """
+    Tests the six product rules defined with respect to the Del
+    operator
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Del
+
+    """
+
+    #Define the scalar and vector functions
+    f = 2*x*y*z
+    g = x*y + y*z + z*x
+    u = x**2*i + 4*j - y**2*z*k
+    v = 4*i + x*y*z*k
+
+    # First product rule
+    lhs = delop(f * g, doit=True)
+    rhs = (f * delop(g) + g * delop(f)).doit()
+    assert simplify(lhs) == simplify(rhs)
+
+    # Second product rule
+    lhs = delop(u & v).doit()
+    rhs = ((u ^ (delop ^ v)) + (v ^ (delop ^ u)) + \
+          ((u & delop)(v)) + ((v & delop)(u))).doit()
+    assert simplify(lhs) == simplify(rhs)
+
+    # Third product rule
+    lhs = (delop & (f*v)).doit()
+    rhs = ((f * (delop & v)) + (v & (delop(f)))).doit()
+    assert simplify(lhs) == simplify(rhs)
+
+    # Fourth product rule
+    lhs = (delop & (u ^ v)).doit()
+    rhs = ((v & (delop ^ u)) - (u & (delop ^ v))).doit()
+    assert simplify(lhs) == simplify(rhs)
+
+    # Fifth product rule
+    lhs = (delop ^ (f * v)).doit()
+    rhs = (((delop(f)) ^ v) + (f * (delop ^ v))).doit()
+    assert simplify(lhs) == simplify(rhs)
+
+    # Sixth product rule
+    lhs = (delop ^ (u ^ v)).doit()
+    rhs = (u * (delop & v) - v * (delop & u) +
+           (v & delop)(u) - (u & delop)(v)).doit()
+    assert simplify(lhs) == simplify(rhs)
+
+
+P = C.orient_new_axis('P', q, C.k)  # type: ignore
+scalar_field = 2*x**2*y*z
+grad_field = gradient(scalar_field)
+vector_field = y**2*i + 3*x*j + 5*y*z*k
+curl_field = curl(vector_field)
+
+
+def test_conservative():
+    assert is_conservative(Vector.zero) is True
+    assert is_conservative(i) is True
+    assert is_conservative(2 * i + 3 * j + 4 * k) is True
+    assert (is_conservative(y*z*i + x*z*j + x*y*k) is
+            True)
+    assert is_conservative(x * j) is False
+    assert is_conservative(grad_field) is True
+    assert is_conservative(curl_field) is False
+    assert (is_conservative(4*x*y*z*i + 2*x**2*z*j) is
+            False)
+    assert is_conservative(z*P.i + P.x*k) is True
+
+
+def test_solenoidal():
+    assert is_solenoidal(Vector.zero) is True
+    assert is_solenoidal(i) is True
+    assert is_solenoidal(2 * i + 3 * j + 4 * k) is True
+    assert (is_solenoidal(y*z*i + x*z*j + x*y*k) is
+            True)
+    assert is_solenoidal(y * j) is False
+    assert is_solenoidal(grad_field) is False
+    assert is_solenoidal(curl_field) is True
+    assert is_solenoidal((-2*y + 3)*k) is True
+    assert is_solenoidal(cos(q)*i + sin(q)*j + cos(q)*P.k) is True
+    assert is_solenoidal(z*P.i + P.x*k) is True
+
+
+def test_directional_derivative():
+    assert directional_derivative(C.x*C.y*C.z, 3*C.i + 4*C.j + C.k) == C.x*C.y + 4*C.x*C.z + 3*C.y*C.z
+    assert directional_derivative(5*C.x**2*C.z, 3*C.i + 4*C.j + C.k) == 5*C.x**2 + 30*C.x*C.z
+    assert directional_derivative(5*C.x**2*C.z, 4*C.j) is S.Zero
+
+    D = CoordSys3D("D", "spherical", variable_names=["r", "theta", "phi"],
+                   vector_names=["e_r", "e_theta", "e_phi"])
+    r, theta, phi = D.base_scalars()
+    e_r, e_theta, e_phi = D.base_vectors()
+    assert directional_derivative(r**2*e_r, e_r) == 2*r*e_r
+    assert directional_derivative(5*r**2*phi, 3*e_r + 4*e_theta + e_phi) == 5*r**2 + 30*r*phi
+
+
+def test_scalar_potential():
+    assert scalar_potential(Vector.zero, C) == 0
+    assert scalar_potential(i, C) == x
+    assert scalar_potential(j, C) == y
+    assert scalar_potential(k, C) == z
+    assert scalar_potential(y*z*i + x*z*j + x*y*k, C) == x*y*z
+    assert scalar_potential(grad_field, C) == scalar_field
+    assert scalar_potential(z*P.i + P.x*k, C) == x*z*cos(q) + y*z*sin(q)
+    assert scalar_potential(z*P.i + P.x*k, P) == P.x*P.z
+    raises(ValueError, lambda: scalar_potential(x*j, C))
+
+
+def test_scalar_potential_difference():
+    point1 = C.origin.locate_new('P1', 1*i + 2*j + 3*k)
+    point2 = C.origin.locate_new('P2', 4*i + 5*j + 6*k)
+    genericpointC = C.origin.locate_new('RP', x*i + y*j + z*k)
+    genericpointP = P.origin.locate_new('PP', P.x*P.i + P.y*P.j + P.z*P.k)
+    assert scalar_potential_difference(S.Zero, C, point1, point2) == 0
+    assert (scalar_potential_difference(scalar_field, C, C.origin,
+                                        genericpointC) ==
+            scalar_field)
+    assert (scalar_potential_difference(grad_field, C, C.origin,
+                                        genericpointC) ==
+            scalar_field)
+    assert scalar_potential_difference(grad_field, C, point1, point2) == 948
+    assert (scalar_potential_difference(y*z*i + x*z*j +
+                                        x*y*k, C, point1,
+                                        genericpointC) ==
+            x*y*z - 6)
+    potential_diff_P = (2*P.z*(P.x*sin(q) + P.y*cos(q))*
+                        (P.x*cos(q) - P.y*sin(q))**2)
+    assert (scalar_potential_difference(grad_field, P, P.origin,
+                                        genericpointP).simplify() ==
+            potential_diff_P.simplify())
+
+
+def test_differential_operators_curvilinear_system():
+    A = CoordSys3D('A', transformation="spherical", variable_names=["r", "theta", "phi"])
+    B = CoordSys3D('B', transformation='cylindrical', variable_names=["r", "theta", "z"])
+    # Test for spherical coordinate system and gradient
+    assert gradient(3*A.r + 4*A.theta) == 3*A.i + 4/A.r*A.j
+    assert gradient(3*A.r*A.phi + 4*A.theta) == 3*A.phi*A.i + 4/A.r*A.j + (3/sin(A.theta))*A.k
+    assert gradient(0*A.r + 0*A.theta+0*A.phi) == Vector.zero
+    assert gradient(A.r*A.theta*A.phi) == A.theta*A.phi*A.i + A.phi*A.j + (A.theta/sin(A.theta))*A.k
+    # Test for spherical coordinate system and divergence
+    assert divergence(A.r * A.i + A.theta * A.j + A.phi * A.k) == \
+           (sin(A.theta)*A.r + cos(A.theta)*A.r*A.theta)/(sin(A.theta)*A.r**2) + 3 + 1/(sin(A.theta)*A.r)
+    assert divergence(3*A.r*A.phi*A.i + A.theta*A.j + A.r*A.theta*A.phi*A.k) == \
+           (sin(A.theta)*A.r + cos(A.theta)*A.r*A.theta)/(sin(A.theta)*A.r**2) + 9*A.phi + A.theta/sin(A.theta)
+    assert divergence(Vector.zero) == 0
+    assert divergence(0*A.i + 0*A.j + 0*A.k) == 0
+    # Test for spherical coordinate system and curl
+    assert curl(A.r*A.i + A.theta*A.j + A.phi*A.k) == \
+           (cos(A.theta)*A.phi/(sin(A.theta)*A.r))*A.i + (-A.phi/A.r)*A.j + A.theta/A.r*A.k
+    assert curl(A.r*A.j + A.phi*A.k) == (cos(A.theta)*A.phi/(sin(A.theta)*A.r))*A.i + (-A.phi/A.r)*A.j + 2*A.k
+
+    # Test for cylindrical coordinate system and gradient
+    assert gradient(0*B.r + 0*B.theta+0*B.z) == Vector.zero
+    assert gradient(B.r*B.theta*B.z) == B.theta*B.z*B.i + B.z*B.j + B.r*B.theta*B.k
+    assert gradient(3*B.r) == 3*B.i
+    assert gradient(2*B.theta) == 2/B.r * B.j
+    assert gradient(4*B.z) == 4*B.k
+    # Test for cylindrical coordinate system and divergence
+    assert divergence(B.r*B.i + B.theta*B.j + B.z*B.k) == 3 + 1/B.r
+    assert divergence(B.r*B.j + B.z*B.k) == 1
+    # Test for cylindrical coordinate system and curl
+    assert curl(B.r*B.j + B.z*B.k) == 2*B.k
+    assert curl(3*B.i + 2/B.r*B.j + 4*B.k) == Vector.zero
+
+def test_mixed_coordinates():
+    # gradient
+    a = CoordSys3D('a')
+    b = CoordSys3D('b')
+    c = CoordSys3D('c')
+    assert gradient(a.x*b.y) == b.y*a.i + a.x*b.j
+    assert gradient(3*cos(q)*a.x*b.x+a.y*(a.x+(cos(q)+b.x))) ==\
+           (a.y + 3*b.x*cos(q))*a.i + (a.x + b.x + cos(q))*a.j + (3*a.x*cos(q) + a.y)*b.i
+    # Some tests need further work:
+    # assert gradient(a.x*(cos(a.x+b.x))) == (cos(a.x + b.x))*a.i + a.x*Gradient(cos(a.x + b.x))
+    # assert gradient(cos(a.x + b.x)*cos(a.x + b.z)) == Gradient(cos(a.x + b.x)*cos(a.x + b.z))
+    assert gradient(a.x**b.y) == Gradient(a.x**b.y)
+    # assert gradient(cos(a.x+b.y)*a.z) == None
+    assert gradient(cos(a.x*b.y)) == Gradient(cos(a.x*b.y))
+    assert gradient(3*cos(q)*a.x*b.x*a.z*a.y+ b.y*b.z + cos(a.x+a.y)*b.z) == \
+           (3*a.y*a.z*b.x*cos(q) - b.z*sin(a.x + a.y))*a.i + \
+           (3*a.x*a.z*b.x*cos(q) - b.z*sin(a.x + a.y))*a.j + (3*a.x*a.y*b.x*cos(q))*a.k + \
+           (3*a.x*a.y*a.z*cos(q))*b.i + b.z*b.j + (b.y + cos(a.x + a.y))*b.k
+    # divergence
+    assert divergence(a.i*a.x+a.j*a.y+a.z*a.k + b.i*b.x+b.j*b.y+b.z*b.k + c.i*c.x+c.j*c.y+c.z*c.k) == S(9)
+    # assert divergence(3*a.i*a.x*cos(a.x+b.z) + a.j*b.x*c.z) == None
+    assert divergence(3*a.i*a.x*a.z + b.j*b.x*c.z + 3*a.j*a.z*a.y) == \
+            6*a.z + b.x*Dot(b.j, c.k)
+    assert divergence(3*cos(q)*a.x*b.x*b.i*c.x) == \
+        3*a.x*b.x*cos(q)*Dot(b.i, c.i) + 3*a.x*c.x*cos(q) + 3*b.x*c.x*cos(q)*Dot(b.i, a.i)
+    assert divergence(a.x*b.x*c.x*Cross(a.x*a.i, a.y*b.j)) ==\
+           a.x*b.x*c.x*Divergence(Cross(a.x*a.i, a.y*b.j)) + \
+           b.x*c.x*Dot(Cross(a.x*a.i, a.y*b.j), a.i) + \
+           a.x*c.x*Dot(Cross(a.x*a.i, a.y*b.j), b.i) + \
+           a.x*b.x*Dot(Cross(a.x*a.i, a.y*b.j), c.i)
+    assert divergence(a.x*b.x*c.x*(a.x*a.i + b.x*b.i)) == \
+                4*a.x*b.x*c.x +\
+                a.x**2*c.x*Dot(a.i, b.i) +\
+                a.x**2*b.x*Dot(a.i, c.i) +\
+                b.x**2*c.x*Dot(b.i, a.i) +\
+                a.x*b.x**2*Dot(b.i, c.i)
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/vector/tests/test_functions.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/vector/tests/test_functions.py
new file mode 100644
index 0000000000000000000000000000000000000000..dfdf9821b6c853755ce12d0cbdfa599bd4f312e4
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/vector/tests/test_functions.py
@@ -0,0 +1,184 @@
+from sympy.vector.vector import Vector
+from sympy.vector.coordsysrect import CoordSys3D
+from sympy.vector.functions import express, matrix_to_vector, orthogonalize
+from sympy.core.numbers import Rational
+from sympy.core.singleton import S
+from sympy.core.symbol import symbols
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import (cos, sin)
+from sympy.matrices.immutable import ImmutableDenseMatrix as Matrix
+from sympy.testing.pytest import raises
+
+N = CoordSys3D('N')
+q1, q2, q3, q4, q5 = symbols('q1 q2 q3 q4 q5')
+A = N.orient_new_axis('A', q1, N.k)  # type: ignore
+B = A.orient_new_axis('B', q2, A.i)
+C = B.orient_new_axis('C', q3, B.j)
+
+
+def test_express():
+    assert express(Vector.zero, N) == Vector.zero
+    assert express(S.Zero, N) is S.Zero
+    assert express(A.i, C) == cos(q3)*C.i + sin(q3)*C.k
+    assert express(A.j, C) == sin(q2)*sin(q3)*C.i + cos(q2)*C.j - \
+        sin(q2)*cos(q3)*C.k
+    assert express(A.k, C) == -sin(q3)*cos(q2)*C.i + sin(q2)*C.j + \
+        cos(q2)*cos(q3)*C.k
+    assert express(A.i, N) == cos(q1)*N.i + sin(q1)*N.j
+    assert express(A.j, N) == -sin(q1)*N.i + cos(q1)*N.j
+    assert express(A.k, N) == N.k
+    assert express(A.i, A) == A.i
+    assert express(A.j, A) == A.j
+    assert express(A.k, A) == A.k
+    assert express(A.i, B) == B.i
+    assert express(A.j, B) == cos(q2)*B.j - sin(q2)*B.k
+    assert express(A.k, B) == sin(q2)*B.j + cos(q2)*B.k
+    assert express(A.i, C) == cos(q3)*C.i + sin(q3)*C.k
+    assert express(A.j, C) == sin(q2)*sin(q3)*C.i + cos(q2)*C.j - \
+        sin(q2)*cos(q3)*C.k
+    assert express(A.k, C) == -sin(q3)*cos(q2)*C.i + sin(q2)*C.j + \
+        cos(q2)*cos(q3)*C.k
+    # Check to make sure UnitVectors get converted properly
+    assert express(N.i, N) == N.i
+    assert express(N.j, N) == N.j
+    assert express(N.k, N) == N.k
+    assert express(N.i, A) == (cos(q1)*A.i - sin(q1)*A.j)
+    assert express(N.j, A) == (sin(q1)*A.i + cos(q1)*A.j)
+    assert express(N.k, A) == A.k
+    assert express(N.i, B) == (cos(q1)*B.i - sin(q1)*cos(q2)*B.j +
+            sin(q1)*sin(q2)*B.k)
+    assert express(N.j, B) == (sin(q1)*B.i + cos(q1)*cos(q2)*B.j -
+            sin(q2)*cos(q1)*B.k)
+    assert express(N.k, B) == (sin(q2)*B.j + cos(q2)*B.k)
+    assert express(N.i, C) == (
+        (cos(q1)*cos(q3) - sin(q1)*sin(q2)*sin(q3))*C.i -
+        sin(q1)*cos(q2)*C.j +
+        (sin(q3)*cos(q1) + sin(q1)*sin(q2)*cos(q3))*C.k)
+    assert express(N.j, C) == (
+        (sin(q1)*cos(q3) + sin(q2)*sin(q3)*cos(q1))*C.i +
+        cos(q1)*cos(q2)*C.j +
+        (sin(q1)*sin(q3) - sin(q2)*cos(q1)*cos(q3))*C.k)
+    assert express(N.k, C) == (-sin(q3)*cos(q2)*C.i + sin(q2)*C.j +
+            cos(q2)*cos(q3)*C.k)
+
+    assert express(A.i, N) == (cos(q1)*N.i + sin(q1)*N.j)
+    assert express(A.j, N) == (-sin(q1)*N.i + cos(q1)*N.j)
+    assert express(A.k, N) == N.k
+    assert express(A.i, A) == A.i
+    assert express(A.j, A) == A.j
+    assert express(A.k, A) == A.k
+    assert express(A.i, B) == B.i
+    assert express(A.j, B) == (cos(q2)*B.j - sin(q2)*B.k)
+    assert express(A.k, B) == (sin(q2)*B.j + cos(q2)*B.k)
+    assert express(A.i, C) == (cos(q3)*C.i + sin(q3)*C.k)
+    assert express(A.j, C) == (sin(q2)*sin(q3)*C.i + cos(q2)*C.j -
+            sin(q2)*cos(q3)*C.k)
+    assert express(A.k, C) == (-sin(q3)*cos(q2)*C.i + sin(q2)*C.j +
+            cos(q2)*cos(q3)*C.k)
+
+    assert express(B.i, N) == (cos(q1)*N.i + sin(q1)*N.j)
+    assert express(B.j, N) == (-sin(q1)*cos(q2)*N.i +
+            cos(q1)*cos(q2)*N.j + sin(q2)*N.k)
+    assert express(B.k, N) == (sin(q1)*sin(q2)*N.i -
+            sin(q2)*cos(q1)*N.j + cos(q2)*N.k)
+    assert express(B.i, A) == A.i
+    assert express(B.j, A) == (cos(q2)*A.j + sin(q2)*A.k)
+    assert express(B.k, A) == (-sin(q2)*A.j + cos(q2)*A.k)
+    assert express(B.i, B) == B.i
+    assert express(B.j, B) == B.j
+    assert express(B.k, B) == B.k
+    assert express(B.i, C) == (cos(q3)*C.i + sin(q3)*C.k)
+    assert express(B.j, C) == C.j
+    assert express(B.k, C) == (-sin(q3)*C.i + cos(q3)*C.k)
+
+    assert express(C.i, N) == (
+        (cos(q1)*cos(q3) - sin(q1)*sin(q2)*sin(q3))*N.i +
+        (sin(q1)*cos(q3) + sin(q2)*sin(q3)*cos(q1))*N.j -
+        sin(q3)*cos(q2)*N.k)
+    assert express(C.j, N) == (
+        -sin(q1)*cos(q2)*N.i + cos(q1)*cos(q2)*N.j + sin(q2)*N.k)
+    assert express(C.k, N) == (
+        (sin(q3)*cos(q1) + sin(q1)*sin(q2)*cos(q3))*N.i +
+        (sin(q1)*sin(q3) - sin(q2)*cos(q1)*cos(q3))*N.j +
+        cos(q2)*cos(q3)*N.k)
+    assert express(C.i, A) == (cos(q3)*A.i + sin(q2)*sin(q3)*A.j -
+            sin(q3)*cos(q2)*A.k)
+    assert express(C.j, A) == (cos(q2)*A.j + sin(q2)*A.k)
+    assert express(C.k, A) == (sin(q3)*A.i - sin(q2)*cos(q3)*A.j +
+            cos(q2)*cos(q3)*A.k)
+    assert express(C.i, B) == (cos(q3)*B.i - sin(q3)*B.k)
+    assert express(C.j, B) == B.j
+    assert express(C.k, B) == (sin(q3)*B.i + cos(q3)*B.k)
+    assert express(C.i, C) == C.i
+    assert express(C.j, C) == C.j
+    assert express(C.k, C) == C.k == (C.k)
+
+    #  Check to make sure Vectors get converted back to UnitVectors
+    assert N.i == express((cos(q1)*A.i - sin(q1)*A.j), N).simplify()
+    assert N.j == express((sin(q1)*A.i + cos(q1)*A.j), N).simplify()
+    assert N.i == express((cos(q1)*B.i - sin(q1)*cos(q2)*B.j +
+            sin(q1)*sin(q2)*B.k), N).simplify()
+    assert N.j == express((sin(q1)*B.i + cos(q1)*cos(q2)*B.j -
+        sin(q2)*cos(q1)*B.k), N).simplify()
+    assert N.k == express((sin(q2)*B.j + cos(q2)*B.k), N).simplify()
+
+
+    assert A.i == express((cos(q1)*N.i + sin(q1)*N.j), A).simplify()
+    assert A.j == express((-sin(q1)*N.i + cos(q1)*N.j), A).simplify()
+
+    assert A.j == express((cos(q2)*B.j - sin(q2)*B.k), A).simplify()
+    assert A.k == express((sin(q2)*B.j + cos(q2)*B.k), A).simplify()
+
+    assert A.i == express((cos(q3)*C.i + sin(q3)*C.k), A).simplify()
+    assert A.j == express((sin(q2)*sin(q3)*C.i + cos(q2)*C.j -
+            sin(q2)*cos(q3)*C.k), A).simplify()
+
+    assert A.k == express((-sin(q3)*cos(q2)*C.i + sin(q2)*C.j +
+            cos(q2)*cos(q3)*C.k), A).simplify()
+    assert B.i == express((cos(q1)*N.i + sin(q1)*N.j), B).simplify()
+    assert B.j == express((-sin(q1)*cos(q2)*N.i +
+            cos(q1)*cos(q2)*N.j + sin(q2)*N.k), B).simplify()
+
+    assert B.k == express((sin(q1)*sin(q2)*N.i -
+            sin(q2)*cos(q1)*N.j + cos(q2)*N.k), B).simplify()
+
+    assert B.j == express((cos(q2)*A.j + sin(q2)*A.k), B).simplify()
+    assert B.k == express((-sin(q2)*A.j + cos(q2)*A.k), B).simplify()
+    assert B.i == express((cos(q3)*C.i + sin(q3)*C.k), B).simplify()
+    assert B.k == express((-sin(q3)*C.i + cos(q3)*C.k), B).simplify()
+    assert C.i == express((cos(q3)*A.i + sin(q2)*sin(q3)*A.j -
+            sin(q3)*cos(q2)*A.k), C).simplify()
+    assert C.j == express((cos(q2)*A.j + sin(q2)*A.k), C).simplify()
+    assert C.k == express((sin(q3)*A.i - sin(q2)*cos(q3)*A.j +
+            cos(q2)*cos(q3)*A.k), C).simplify()
+    assert C.i == express((cos(q3)*B.i - sin(q3)*B.k), C).simplify()
+    assert C.k == express((sin(q3)*B.i + cos(q3)*B.k), C).simplify()
+
+
+def test_matrix_to_vector():
+    m = Matrix([[1], [2], [3]])
+    assert matrix_to_vector(m, C) == C.i + 2*C.j + 3*C.k
+    m = Matrix([[0], [0], [0]])
+    assert matrix_to_vector(m, N) == matrix_to_vector(m, C) == \
+           Vector.zero
+    m = Matrix([[q1], [q2], [q3]])
+    assert matrix_to_vector(m, N) == q1*N.i + q2*N.j + q3*N.k
+
+
+def test_orthogonalize():
+    C = CoordSys3D('C')
+    a, b = symbols('a b', integer=True)
+    i, j, k = C.base_vectors()
+    v1 = i + 2*j
+    v2 = 2*i + 3*j
+    v3 = 3*i + 5*j
+    v4 = 3*i + j
+    v5 = 2*i + 2*j
+    v6 = a*i + b*j
+    v7 = 4*a*i + 4*b*j
+    assert orthogonalize(v1, v2) == [C.i + 2*C.j, C.i*Rational(2, 5) + -C.j/5]
+    # from wikipedia
+    assert orthogonalize(v4, v5, orthonormal=True) == \
+        [(3*sqrt(10))*C.i/10 + (sqrt(10))*C.j/10, (-sqrt(10))*C.i/10 + (3*sqrt(10))*C.j/10]
+    raises(ValueError, lambda: orthogonalize(v1, v2, v3))
+    raises(ValueError, lambda: orthogonalize(v6, v7))
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/vector/tests/test_implicitregion.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/vector/tests/test_implicitregion.py
new file mode 100644
index 0000000000000000000000000000000000000000..3686d847a7f165cb5ba9aeb813e5922aaa17e1e0
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/vector/tests/test_implicitregion.py
@@ -0,0 +1,90 @@
+from sympy.core.relational import Eq
+from sympy.core.singleton import S
+from sympy.abc import x, y, z, s, t
+from sympy.sets import FiniteSet, EmptySet
+from sympy.geometry import Point
+from sympy.vector import ImplicitRegion
+from sympy.testing.pytest import raises
+
+
+def test_ImplicitRegion():
+    ellipse = ImplicitRegion((x, y), (x**2/4 + y**2/16 - 1))
+    assert ellipse.equation == x**2/4 + y**2/16 - 1
+    assert ellipse.variables == (x, y)
+    assert ellipse.degree == 2
+    r = ImplicitRegion((x, y, z), Eq(x**4 + y**2 - x*y, 6))
+    assert r.equation == x**4 + y**2 - x*y - 6
+    assert r.variables == (x, y, z)
+    assert r.degree == 4
+
+
+def test_regular_point():
+    r1 = ImplicitRegion((x,), x**2 - 16)
+    assert r1.regular_point() == (-4,)
+    c1 = ImplicitRegion((x, y), x**2 + y**2 - 4)
+    assert c1.regular_point() == (0, -2)
+    c2 = ImplicitRegion((x, y), (x - S(5)/2)**2 + y**2 - (S(1)/4)**2)
+    assert c2.regular_point() == (S(5)/2, -S(1)/4)
+    c3 = ImplicitRegion((x, y), (y - 5)**2  - 16*(x - 5))
+    assert c3.regular_point() == (5, 5)
+    r2 = ImplicitRegion((x, y), x**2 - 4*x*y - 3*y**2 + 4*x + 8*y - 5)
+    assert r2.regular_point() == (S(4)/7, S(9)/7)
+    r3 = ImplicitRegion((x, y), x**2 - 2*x*y + 3*y**2 - 2*x - 5*y + 3/2)
+    raises(ValueError, lambda: r3.regular_point())
+
+
+def test_singular_points_and_multiplicty():
+    r1 = ImplicitRegion((x, y, z), Eq(x + y + z, 0))
+    assert r1.singular_points() == EmptySet
+    r2 = ImplicitRegion((x, y, z), x*y*z + y**4 -x**2*z**2)
+    assert r2.singular_points() == FiniteSet((0, 0, z), (x, 0, 0))
+    assert r2.multiplicity((0, 0, 0)) == 3
+    assert r2.multiplicity((0, 0, 6)) == 2
+    r3 = ImplicitRegion((x, y, z), z**2 - x**2 - y**2)
+    assert r3.singular_points() == FiniteSet((0, 0, 0))
+    assert r3.multiplicity((0, 0, 0)) == 2
+    r4 = ImplicitRegion((x, y), x**2 + y**2 - 2*x)
+    assert r4.singular_points() == EmptySet
+    assert r4.multiplicity(Point(1, 3)) == 0
+
+
+def test_rational_parametrization():
+    p = ImplicitRegion((x,), x - 2)
+    assert p.rational_parametrization() == (x - 2,)
+
+    line = ImplicitRegion((x, y), Eq(y, 3*x + 2))
+    assert line.rational_parametrization() == (x, 3*x + 2)
+
+    circle1 = ImplicitRegion((x, y), (x-2)**2 + (y+3)**2 - 4)
+    assert circle1.rational_parametrization(parameters=t) == (4*t/(t**2 + 1) + 2, 4*t**2/(t**2 + 1) - 5)
+    circle2 = ImplicitRegion((x, y), (x - S.Half)**2 + y**2 - (S(1)/2)**2)
+
+    assert circle2.rational_parametrization(parameters=t) == (t/(t**2 + 1) + S(1)/2, t**2/(t**2 + 1) - S(1)/2)
+    circle3 = ImplicitRegion((x, y), Eq(x**2 + y**2, 2*x))
+    assert circle3.rational_parametrization(parameters=(t,)) == (2*t/(t**2 + 1) + 1, 2*t**2/(t**2 + 1) - 1)
+
+    parabola = ImplicitRegion((x, y), (y - 3)**2 - 4*(x + 6))
+    assert parabola.rational_parametrization(t) == (-6 + 4/t**2, 3 + 4/t)
+
+    rect_hyperbola = ImplicitRegion((x, y), x*y - 1)
+    assert rect_hyperbola.rational_parametrization(t) == (-1 + (t + 1)/t, t)
+
+    cubic_curve = ImplicitRegion((x, y), x**3 + x**2 - y**2)
+    assert cubic_curve.rational_parametrization(parameters=(t)) == (t**2 - 1, t*(t**2 - 1))
+    cuspidal = ImplicitRegion((x, y), (x**3 - y**2))
+    assert cuspidal.rational_parametrization(t) == (t**2, t**3)
+
+    I = ImplicitRegion((x, y), x**3 + x**2 - y**2)
+    assert I.rational_parametrization(t) == (t**2 - 1, t*(t**2 - 1))
+
+    sphere = ImplicitRegion((x, y, z), Eq(x**2 + y**2 + z**2, 2*x))
+    assert sphere.rational_parametrization(parameters=(s, t)) == (2/(s**2 + t**2 + 1), 2*t/(s**2 + t**2 + 1), 2*s/(s**2 + t**2 + 1))
+
+    conic = ImplicitRegion((x, y), Eq(x**2 + 4*x*y + 3*y**2 + x - y + 10, 0))
+    assert conic.rational_parametrization(t) == (
+        S(17)/2 + 4/(3*t**2 + 4*t + 1), 4*t/(3*t**2 + 4*t + 1) - S(11)/2)
+
+    r1 = ImplicitRegion((x, y), y**2 - x**3 + x)
+    raises(NotImplementedError, lambda: r1.rational_parametrization())
+    r2 = ImplicitRegion((x, y), y**2 - x**3 - x**2 + 1)
+    raises(NotImplementedError, lambda: r2.rational_parametrization())
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/vector/tests/test_integrals.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/vector/tests/test_integrals.py
new file mode 100644
index 0000000000000000000000000000000000000000..84c900d038e214df1ea59a8cd8fb2929005c3674
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/vector/tests/test_integrals.py
@@ -0,0 +1,106 @@
+from sympy.core.numbers import pi
+from sympy.core.singleton import S
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import (cos, sin)
+from sympy.testing.pytest import raises
+from sympy.vector.coordsysrect import CoordSys3D
+from sympy.vector.integrals import ParametricIntegral, vector_integrate
+from sympy.vector.parametricregion import ParametricRegion
+from sympy.vector.implicitregion import ImplicitRegion
+from sympy.abc import x, y, z, u, v, r, t, theta, phi
+from sympy.geometry import Point, Segment, Curve, Circle, Polygon, Plane
+
+C = CoordSys3D('C')
+
+def test_parametric_lineintegrals():
+    halfcircle = ParametricRegion((4*cos(theta), 4*sin(theta)), (theta, -pi/2, pi/2))
+    assert ParametricIntegral(C.x*C.y**4, halfcircle) == S(8192)/5
+
+    curve = ParametricRegion((t, t**2, t**3), (t, 0, 1))
+    field1 = 8*C.x**2*C.y*C.z*C.i + 5*C.z*C.j - 4*C.x*C.y*C.k
+    assert ParametricIntegral(field1, curve) == 1
+    line = ParametricRegion((4*t - 1, 2 - 2*t, t), (t, 0, 1))
+    assert ParametricIntegral(C.x*C.z*C.i - C.y*C.z*C.k, line) == 3
+
+    assert ParametricIntegral(4*C.x**3, ParametricRegion((1, t), (t, 0, 2))) == 8
+
+    helix = ParametricRegion((cos(t), sin(t), 3*t), (t, 0, 4*pi))
+    assert ParametricIntegral(C.x*C.y*C.z, helix) == -3*sqrt(10)*pi
+
+    field2 = C.y*C.i + C.z*C.j + C.z*C.k
+    assert ParametricIntegral(field2, ParametricRegion((cos(t), sin(t), t**2), (t, 0, pi))) == -5*pi/2 + pi**4/2
+
+def test_parametric_surfaceintegrals():
+
+    semisphere = ParametricRegion((2*sin(phi)*cos(theta), 2*sin(phi)*sin(theta), 2*cos(phi)),\
+                            (theta, 0, 2*pi), (phi, 0, pi/2))
+    assert ParametricIntegral(C.z, semisphere) == 8*pi
+
+    cylinder = ParametricRegion((sqrt(3)*cos(theta), sqrt(3)*sin(theta), z), (z, 0, 6), (theta, 0, 2*pi))
+    assert ParametricIntegral(C.y, cylinder) == 0
+
+    cone = ParametricRegion((v*cos(u), v*sin(u), v), (u, 0, 2*pi), (v, 0, 1))
+    assert ParametricIntegral(C.x*C.i + C.y*C.j + C.z**4*C.k, cone) == pi/3
+
+    triangle1 = ParametricRegion((x, y), (x, 0, 2), (y, 0, 10 - 5*x))
+    triangle2 = ParametricRegion((x, y), (y, 0, 10 - 5*x), (x, 0, 2))
+    assert ParametricIntegral(-15.6*C.y*C.k, triangle1) == ParametricIntegral(-15.6*C.y*C.k, triangle2)
+    assert ParametricIntegral(C.z, triangle1) == 10*C.z
+
+def test_parametric_volumeintegrals():
+
+    cube = ParametricRegion((x, y, z), (x, 0, 1), (y, 0, 1), (z, 0, 1))
+    assert ParametricIntegral(1, cube) == 1
+
+    solidsphere1 = ParametricRegion((r*sin(phi)*cos(theta), r*sin(phi)*sin(theta), r*cos(phi)),\
+                            (r, 0, 2), (theta, 0, 2*pi), (phi, 0, pi))
+    solidsphere2 = ParametricRegion((r*sin(phi)*cos(theta), r*sin(phi)*sin(theta), r*cos(phi)),\
+                            (r, 0, 2), (phi, 0, pi), (theta, 0, 2*pi))
+    assert ParametricIntegral(C.x**2 + C.y**2, solidsphere1) == -256*pi/15
+    assert ParametricIntegral(C.x**2 + C.y**2, solidsphere2) == 256*pi/15
+
+    region_under_plane1 = ParametricRegion((x, y, z), (x, 0, 3), (y, 0, -2*x/3 + 2),\
+                                    (z, 0, 6 - 2*x - 3*y))
+    region_under_plane2 = ParametricRegion((x, y, z), (x, 0, 3), (z, 0, 6 - 2*x - 3*y),\
+                                    (y, 0, -2*x/3 + 2))
+
+    assert ParametricIntegral(C.x*C.i + C.j - 100*C.k, region_under_plane1) == \
+        ParametricIntegral(C.x*C.i + C.j - 100*C.k, region_under_plane2)
+    assert ParametricIntegral(2*C.x, region_under_plane2) == -9
+
+def test_vector_integrate():
+    halfdisc = ParametricRegion((r*cos(theta), r* sin(theta)), (r, -2, 2), (theta, 0, pi))
+    assert vector_integrate(C.x**2, halfdisc) == 4*pi
+    assert vector_integrate(C.x, ParametricRegion((t, t**2), (t, 2, 3))) == -17*sqrt(17)/12 + 37*sqrt(37)/12
+
+    assert  vector_integrate(C.y**3*C.z, (C.x, 0, 3), (C.y, -1, 4)) == 765*C.z/4
+
+    s1 = Segment(Point(0, 0), Point(0, 1))
+    assert vector_integrate(-15*C.y, s1) == S(-15)/2
+    s2 = Segment(Point(4, 3, 9), Point(1, 1, 7))
+    assert vector_integrate(C.y*C.i, s2) == -6
+
+    curve = Curve((sin(t), cos(t)), (t, 0, 2))
+    assert vector_integrate(5*C.z, curve) == 10*C.z
+
+    c1 = Circle(Point(2, 3), 6)
+    assert vector_integrate(C.x*C.y, c1) == 72*pi
+    c2 = Circle(Point(0, 0), Point(1, 1), Point(1, 0))
+    assert vector_integrate(1, c2) == c2.circumference
+
+    triangle = Polygon((0, 0), (1, 0), (1, 1))
+    assert vector_integrate(C.x*C.i - 14*C.y*C.j, triangle) == 0
+    p1, p2, p3, p4 = [(0, 0), (1, 0), (5, 1), (0, 1)]
+    poly = Polygon(p1, p2, p3, p4)
+    assert vector_integrate(-23*C.z, poly) == -161*C.z - 23*sqrt(17)*C.z
+
+    point = Point(2, 3)
+    assert vector_integrate(C.i*C.y, point) == ParametricIntegral(C.y*C.i, ParametricRegion((2, 3)))
+
+    c3 = ImplicitRegion((x, y), x**2 + y**2 - 4)
+    assert vector_integrate(45, c3) == 180*pi
+    c4 = ImplicitRegion((x, y), (x - 3)**2 + (y - 4)**2 - 9)
+    assert vector_integrate(1, c4) == 6*pi
+
+    pl = Plane(Point(1, 1, 1), Point(2, 3, 4), Point(2, 2, 2))
+    raises(ValueError, lambda: vector_integrate(C.x*C.z*C.i + C.k, pl))
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/vector/tests/test_operators.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/vector/tests/test_operators.py
new file mode 100644
index 0000000000000000000000000000000000000000..5734edadd00547c67d6f864b50afd966ad8392a6
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/vector/tests/test_operators.py
@@ -0,0 +1,43 @@
+from sympy.vector import CoordSys3D, Gradient, Divergence, Curl, VectorZero, Laplacian
+from sympy.printing.repr import srepr
+
+R = CoordSys3D('R')
+s1 = R.x*R.y*R.z  # type: ignore
+s2 = R.x + 3*R.y**2  # type: ignore
+s3 = R.x**2 + R.y**2 + R.z**2  # type: ignore
+v1 = R.x*R.i + R.z*R.z*R.j  # type: ignore
+v2 = R.x*R.i + R.y*R.j + R.z*R.k  # type: ignore
+v3 = R.x**2*R.i + R.y**2*R.j + R.z**2*R.k  # type: ignore
+
+
+def test_Gradient():
+    assert Gradient(s1) == Gradient(R.x*R.y*R.z)
+    assert Gradient(s2) == Gradient(R.x + 3*R.y**2)
+    assert Gradient(s1).doit() == R.y*R.z*R.i + R.x*R.z*R.j + R.x*R.y*R.k
+    assert Gradient(s2).doit() == R.i + 6*R.y*R.j
+
+
+def test_Divergence():
+    assert Divergence(v1) == Divergence(R.x*R.i + R.z*R.z*R.j)
+    assert Divergence(v2) == Divergence(R.x*R.i + R.y*R.j + R.z*R.k)
+    assert Divergence(v1).doit() == 1
+    assert Divergence(v2).doit() == 3
+    # issue 22384
+    Rc = CoordSys3D('R', transformation='cylindrical')
+    assert Divergence(Rc.i).doit() == 1/Rc.r
+
+
+def test_Curl():
+    assert Curl(v1) == Curl(R.x*R.i + R.z*R.z*R.j)
+    assert Curl(v2) == Curl(R.x*R.i + R.y*R.j + R.z*R.k)
+    assert Curl(v1).doit() == (-2*R.z)*R.i
+    assert Curl(v2).doit() == VectorZero()
+
+
+def test_Laplacian():
+    assert Laplacian(s3) == Laplacian(R.x**2 + R.y**2 + R.z**2)
+    assert Laplacian(v3) == Laplacian(R.x**2*R.i + R.y**2*R.j + R.z**2*R.k)
+    assert Laplacian(s3).doit() == 6
+    assert Laplacian(v3).doit() == 2*R.i + 2*R.j + 2*R.k
+    assert srepr(Laplacian(s3)) == \
+            'Laplacian(Add(Pow(R.x, Integer(2)), Pow(R.y, Integer(2)), Pow(R.z, Integer(2))))'
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/vector/tests/test_parametricregion.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/vector/tests/test_parametricregion.py
new file mode 100644
index 0000000000000000000000000000000000000000..e785b96744f9e2c39e91b997fcb70f8a921256bd
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/vector/tests/test_parametricregion.py
@@ -0,0 +1,97 @@
+from sympy.core.numbers import pi
+from sympy.functions.elementary.trigonometric import (cos, sin)
+from sympy.vector.coordsysrect import CoordSys3D
+from sympy.vector.parametricregion import ParametricRegion, parametric_region_list
+from sympy.geometry import Point, Segment, Curve, Ellipse, Line, Parabola, Polygon
+from sympy.testing.pytest import raises
+from sympy.abc import a, b, r, t, x, y, z, theta, phi
+
+
+C = CoordSys3D('C')
+
+def test_ParametricRegion():
+
+    point = ParametricRegion((3, 4))
+    assert point.definition == (3, 4)
+    assert point.parameters == ()
+    assert point.limits == {}
+    assert point.dimensions == 0
+
+    # line x = y
+    line_xy = ParametricRegion((y, y), (y, 1, 5))
+    assert line_xy .definition == (y, y)
+    assert line_xy.parameters == (y,)
+    assert line_xy.dimensions == 1
+
+    # line y = z
+    line_yz = ParametricRegion((x,t,t), x, (t, 1, 2))
+    assert line_yz.definition == (x,t,t)
+    assert line_yz.parameters == (x, t)
+    assert line_yz.limits == {t: (1, 2)}
+    assert line_yz.dimensions == 1
+
+    p1 = ParametricRegion((9*a, -16*b), (a, 0, 2), (b, -1, 5))
+    assert p1.definition == (9*a, -16*b)
+    assert p1.parameters == (a, b)
+    assert p1.limits == {a: (0, 2), b: (-1, 5)}
+    assert p1.dimensions == 2
+
+    p2 = ParametricRegion((t, t**3), t)
+    assert p2.parameters == (t,)
+    assert p2.limits == {}
+    assert p2.dimensions == 0
+
+    circle = ParametricRegion((r*cos(theta), r*sin(theta)), r, (theta, 0, 2*pi))
+    assert circle.definition == (r*cos(theta), r*sin(theta))
+    assert circle.dimensions == 1
+
+    halfdisc = ParametricRegion((r*cos(theta), r*sin(theta)), (r, -2, 2), (theta, 0, pi))
+    assert halfdisc.definition == (r*cos(theta), r*sin(theta))
+    assert halfdisc.parameters == (r, theta)
+    assert halfdisc.limits == {r: (-2, 2), theta: (0, pi)}
+    assert halfdisc.dimensions == 2
+
+    ellipse = ParametricRegion((a*cos(t), b*sin(t)), (t, 0, 8))
+    assert ellipse.parameters == (t,)
+    assert ellipse.limits == {t: (0, 8)}
+    assert ellipse.dimensions == 1
+
+    cylinder = ParametricRegion((r*cos(theta), r*sin(theta), z), (r, 0, 1), (theta, 0, 2*pi), (z, 0, 4))
+    assert cylinder.parameters == (r, theta, z)
+    assert cylinder.dimensions == 3
+
+    sphere = ParametricRegion((r*sin(phi)*cos(theta),r*sin(phi)*sin(theta), r*cos(phi)),
+                                r, (theta, 0, 2*pi), (phi, 0, pi))
+    assert sphere.definition == (r*sin(phi)*cos(theta),r*sin(phi)*sin(theta), r*cos(phi))
+    assert sphere.parameters == (r, theta, phi)
+    assert sphere.dimensions == 2
+
+    raises(ValueError, lambda: ParametricRegion((a*t**2, 2*a*t), (a, -2)))
+    raises(ValueError, lambda: ParametricRegion((a, b), (a**2, sin(b)), (a, 2, 4, 6)))
+
+
+def test_parametric_region_list():
+
+    point = Point(-5, 12)
+    assert parametric_region_list(point) == [ParametricRegion((-5, 12))]
+
+    e = Ellipse(Point(2, 8), 2, 6)
+    assert parametric_region_list(e, t) == [ParametricRegion((2*cos(t) + 2, 6*sin(t) + 8), (t, 0, 2*pi))]
+
+    c = Curve((t, t**3), (t, 5, 3))
+    assert parametric_region_list(c) == [ParametricRegion((t, t**3), (t, 5, 3))]
+
+    s = Segment(Point(2, 11, -6), Point(0, 2, 5))
+    assert parametric_region_list(s, t) == [ParametricRegion((2 - 2*t, 11 - 9*t, 11*t - 6), (t, 0, 1))]
+    s1 = Segment(Point(0, 0), (1, 0))
+    assert parametric_region_list(s1, t) == [ParametricRegion((t, 0), (t, 0, 1))]
+    s2 = Segment(Point(1, 2, 3), Point(1, 2, 5))
+    assert parametric_region_list(s2, t) == [ParametricRegion((1, 2, 2*t + 3), (t, 0, 1))]
+    s3 = Segment(Point(12, 56), Point(12, 56))
+    assert parametric_region_list(s3) == [ParametricRegion((12, 56))]
+
+    poly = Polygon((1,3), (-3, 8), (2, 4))
+    assert parametric_region_list(poly, t) == [ParametricRegion((1 - 4*t, 5*t + 3), (t, 0, 1)), ParametricRegion((5*t - 3, 8 - 4*t), (t, 0, 1)), ParametricRegion((2 - t, 4 - t), (t, 0, 1))]
+
+    p1 = Parabola(Point(0, 0), Line(Point(5, 8), Point(7,8)))
+    raises(ValueError, lambda: parametric_region_list(p1))
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/vector/tests/test_printing.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/vector/tests/test_printing.py
new file mode 100644
index 0000000000000000000000000000000000000000..ae76905e967bdf93485f135c6a69f968e1208986
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/vector/tests/test_printing.py
@@ -0,0 +1,221 @@
+# -*- coding: utf-8 -*-
+from sympy.core.function import Function
+from sympy.integrals.integrals import Integral
+from sympy.printing.latex import latex
+from sympy.printing.pretty import pretty as xpretty
+from sympy.vector import CoordSys3D, Del, Vector, express
+from sympy.abc import a, b, c
+from sympy.testing.pytest import XFAIL
+
+
+def pretty(expr):
+    """ASCII pretty-printing"""
+    return xpretty(expr, use_unicode=False, wrap_line=False)
+
+
+def upretty(expr):
+    """Unicode pretty-printing"""
+    return xpretty(expr, use_unicode=True, wrap_line=False)
+
+
+# Initialize the basic and tedious vector/dyadic expressions
+# needed for testing.
+# Some of the pretty forms shown denote how the expressions just
+# above them should look with pretty printing.
+N = CoordSys3D('N')
+C = N.orient_new_axis('C', a, N.k)  # type: ignore
+v = []
+d = []
+v.append(Vector.zero)
+v.append(N.i)  # type: ignore
+v.append(-N.i)  # type: ignore
+v.append(N.i + N.j)  # type: ignore
+v.append(a*N.i)  # type: ignore
+v.append(a*N.i - b*N.j)  # type: ignore
+v.append((a**2 + N.x)*N.i + N.k)  # type: ignore
+v.append((a**2 + b)*N.i + 3*(C.y - c)*N.k)  # type: ignore
+f = Function('f')
+v.append(N.j - (Integral(f(b)) - C.x**2)*N.k)  # type: ignore
+upretty_v_8 = """\
+      ⎛   2   ⌠        ⎞    \n\
+j_N + ⎜x_C  - ⎮ f(b) db⎟ k_N\n\
+      ⎝       ⌡        ⎠    \
+"""
+pretty_v_8 = """\
+j_N + /         /       \\\n\
+      |   2    |        |\n\
+      |x_C  -  | f(b) db|\n\
+      |        |        |\n\
+      \\       /         / \
+"""
+
+v.append(N.i + C.k)  # type: ignore
+v.append(express(N.i, C))  # type: ignore
+v.append((a**2 + b)*N.i + (Integral(f(b)))*N.k)  # type: ignore
+upretty_v_11 = """\
+⎛ 2    ⎞        ⎛⌠        ⎞    \n\
+⎝a  + b⎠ i_N  + ⎜⎮ f(b) db⎟ k_N\n\
+                ⎝⌡        ⎠    \
+"""
+pretty_v_11 = """\
+/ 2    \\ + /  /       \\\n\
+\\a  + b/ i_N| |        |\n\
+           | | f(b) db|\n\
+           | |        |\n\
+           \\/         / \
+"""
+
+for x in v:
+    d.append(x | N.k)  # type: ignore
+s = 3*N.x**2*C.y  # type: ignore
+upretty_s = """\
+         2\n\
+3⋅y_C⋅x_N \
+"""
+pretty_s = """\
+         2\n\
+3*y_C*x_N \
+"""
+
+# This is the pretty form for ((a**2 + b)*N.i + 3*(C.y - c)*N.k) | N.k
+upretty_d_7 = """\
+⎛ 2    ⎞                                     \n\
+⎝a  + b⎠ (i_N|k_N)  + (3⋅y_C - 3⋅c) (k_N|k_N)\
+"""
+pretty_d_7 = """\
+/ 2    \\ (i_N|k_N) + (3*y_C - 3*c) (k_N|k_N)\n\
+\\a  + b/                                    \
+"""
+
+
+def test_str_printing():
+    assert str(v[0]) == '0'
+    assert str(v[1]) == 'N.i'
+    assert str(v[2]) == '(-1)*N.i'
+    assert str(v[3]) == 'N.i + N.j'
+    assert str(v[8]) == 'N.j + (C.x**2 - Integral(f(b), b))*N.k'
+    assert str(v[9]) == 'C.k + N.i'
+    assert str(s) == '3*C.y*N.x**2'
+    assert str(d[0]) == '0'
+    assert str(d[1]) == '(N.i|N.k)'
+    assert str(d[4]) == 'a*(N.i|N.k)'
+    assert str(d[5]) == 'a*(N.i|N.k) + (-b)*(N.j|N.k)'
+    assert str(d[8]) == ('(N.j|N.k) + (C.x**2 - ' +
+                         'Integral(f(b), b))*(N.k|N.k)')
+
+
+@XFAIL
+def test_pretty_printing_ascii():
+    assert pretty(v[0]) == '0'
+    assert pretty(v[1]) == 'i_N'
+    assert pretty(v[5]) == '(a) i_N + (-b) j_N'
+    assert pretty(v[8]) == pretty_v_8
+    assert pretty(v[2]) == '(-1) i_N'
+    assert pretty(v[11]) == pretty_v_11
+    assert pretty(s) == pretty_s
+    assert pretty(d[0]) == '(0|0)'
+    assert pretty(d[5]) == '(a) (i_N|k_N) + (-b) (j_N|k_N)'
+    assert pretty(d[7]) == pretty_d_7
+    assert pretty(d[10]) == '(cos(a)) (i_C|k_N) + (-sin(a)) (j_C|k_N)'
+
+
+def test_pretty_print_unicode_v():
+    assert upretty(v[0]) == '0'
+    assert upretty(v[1]) == 'i_N'
+    assert upretty(v[5]) == '(a) i_N + (-b) j_N'
+    # Make sure the printing works in other objects
+    assert upretty(v[5].args) == '((a) i_N, (-b) j_N)'
+    assert upretty(v[8]) == upretty_v_8
+    assert upretty(v[2]) == '(-1) i_N'
+    assert upretty(v[11]) == upretty_v_11
+    assert upretty(s) == upretty_s
+    assert upretty(d[0]) == '(0|0)'
+    assert upretty(d[5]) == '(a) (i_N|k_N) + (-b) (j_N|k_N)'
+    assert upretty(d[7]) == upretty_d_7
+    assert upretty(d[10]) == '(cos(a)) (i_C|k_N) + (-sin(a)) (j_C|k_N)'
+
+
+def test_latex_printing():
+    assert latex(v[0]) == '\\mathbf{\\hat{0}}'
+    assert latex(v[1]) == '\\mathbf{\\hat{i}_{N}}'
+    assert latex(v[2]) == '- \\mathbf{\\hat{i}_{N}}'
+    assert latex(v[5]) == ('\\left(a\\right)\\mathbf{\\hat{i}_{N}} + ' +
+                           '\\left(- b\\right)\\mathbf{\\hat{j}_{N}}')
+    assert latex(v[6]) == ('\\left(\\mathbf{{x}_{N}} + a^{2}\\right)\\mathbf{\\hat{i}_' +
+                          '{N}} + \\mathbf{\\hat{k}_{N}}')
+    assert latex(v[8]) == ('\\mathbf{\\hat{j}_{N}} + \\left(\\mathbf{{x}_' +
+                           '{C}}^{2} - \\int f{\\left(b \\right)}\\,' +
+                           ' db\\right)\\mathbf{\\hat{k}_{N}}')
+    assert latex(s) == '3 \\mathbf{{y}_{C}} \\mathbf{{x}_{N}}^{2}'
+    assert latex(d[0]) == '(\\mathbf{\\hat{0}}|\\mathbf{\\hat{0}})'
+    assert latex(d[4]) == ('\\left(a\\right)\\left(\\mathbf{\\hat{i}_{N}}{\\middle|}' +
+                           '\\mathbf{\\hat{k}_{N}}\\right)')
+    assert latex(d[9]) == ('\\left(\\mathbf{\\hat{k}_{C}}{\\middle|}' +
+                           '\\mathbf{\\hat{k}_{N}}\\right) + \\left(' +
+                           '\\mathbf{\\hat{i}_{N}}{\\middle|}\\mathbf{' +
+                           '\\hat{k}_{N}}\\right)')
+    assert latex(d[11]) == ('\\left(a^{2} + b\\right)\\left(\\mathbf{\\hat{i}_{N}}' +
+                            '{\\middle|}\\mathbf{\\hat{k}_{N}}\\right) + ' +
+                            '\\left(\\int f{\\left(b \\right)}\\, db\\right)\\left(' +
+                            '\\mathbf{\\hat{k}_{N}}{\\middle|}\\mathbf{' +
+                            '\\hat{k}_{N}}\\right)')
+
+def test_issue_23058():
+    from sympy import symbols, sin, cos, pi, UnevaluatedExpr
+
+    delop = Del()
+    CC_   = CoordSys3D("C")
+    y     = CC_.y
+    xhat  = CC_.i
+
+    t = symbols("t")
+    ten = symbols("10", positive=True)
+    eps, mu = 4*pi*ten**(-11), ten**(-5)
+
+    Bx = 2 * ten**(-4) * cos(ten**5 * t) * sin(ten**(-3) * y)
+    vecB = Bx * xhat
+    vecE = (1/eps) * Integral(delop.cross(vecB/mu).doit(), t)
+    vecE = vecE.doit()
+
+    vecB_str = """\
+⎛     ⎛y_C⎞    ⎛  5  ⎞⎞    \n\
+⎜2⋅sin⎜───⎟⋅cos⎝10 ⋅t⎠⎟ i_C\n\
+⎜     ⎜  3⎟           ⎟    \n\
+⎜     ⎝10 ⎠           ⎟    \n\
+⎜─────────────────────⎟    \n\
+⎜           4         ⎟    \n\
+⎝         10          ⎠    \
+"""
+    vecE_str = """\
+⎛   4    ⎛  5  ⎞    ⎛y_C⎞ ⎞    \n\
+⎜-10 ⋅sin⎝10 ⋅t⎠⋅cos⎜───⎟ ⎟ k_C\n\
+⎜                   ⎜  3⎟ ⎟    \n\
+⎜                   ⎝10 ⎠ ⎟    \n\
+⎜─────────────────────────⎟    \n\
+⎝           2⋅π           ⎠    \
+"""
+
+    assert upretty(vecB) == vecB_str
+    assert upretty(vecE) == vecE_str
+
+    ten = UnevaluatedExpr(10)
+    eps, mu = 4*pi*ten**(-11), ten**(-5)
+
+    Bx = 2 * ten**(-4) * cos(ten**5 * t) * sin(ten**(-3) * y)
+    vecB = Bx * xhat
+
+    vecB_str = """\
+⎛    -4    ⎛    5⎞    ⎛      -3⎞⎞     \n\
+⎝2⋅10  ⋅cos⎝t⋅10 ⎠⋅sin⎝y_C⋅10  ⎠⎠ i_C \
+"""
+    assert upretty(vecB) == vecB_str
+
+def test_custom_names():
+    A = CoordSys3D('A', vector_names=['x', 'y', 'z'],
+                   variable_names=['i', 'j', 'k'])
+    assert A.i.__str__() == 'A.i'
+    assert A.x.__str__() == 'A.x'
+    assert A.i._pretty_form == 'i_A'
+    assert A.x._pretty_form == 'x_A'
+    assert A.i._latex_form == r'\mathbf{{i}_{A}}'
+    assert A.x._latex_form == r"\mathbf{\hat{x}_{A}}"
diff --git a/tool_server/.venv/lib/python3.12/site-packages/sympy/vector/tests/test_vector.py b/tool_server/.venv/lib/python3.12/site-packages/sympy/vector/tests/test_vector.py
new file mode 100644
index 0000000000000000000000000000000000000000..daba6d6a02c87b41a8bf801eee9b9045897d0003
--- /dev/null
+++ b/tool_server/.venv/lib/python3.12/site-packages/sympy/vector/tests/test_vector.py
@@ -0,0 +1,342 @@
+from sympy.core import Rational, S, Add, Mul, I
+from sympy.simplify import simplify, trigsimp
+from sympy.core.function import (Derivative, Function, diff)
+from sympy.core.numbers import pi
+from sympy.core.symbol import symbols
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import (cos, sin)
+from sympy.integrals.integrals import Integral
+from sympy.matrices.immutable import ImmutableDenseMatrix as Matrix
+from sympy.vector.vector import Vector, BaseVector, VectorAdd, \
+     VectorMul, VectorZero
+from sympy.vector.coordsysrect import CoordSys3D
+from sympy.vector.vector import Cross, Dot, cross
+from sympy.testing.pytest import raises
+from sympy.vector.kind import VectorKind
+from sympy.core.kind import NumberKind
+from sympy.testing.pytest import XFAIL
+
+
+C = CoordSys3D('C')
+
+i, j, k = C.base_vectors()
+a, b, c = symbols('a b c')
+
+
+def test_cross():
+    v1 = C.x * i + C.z * C.z * j
+    v2 = C.x * i + C.y * j + C.z * k
+    assert Cross(v1, v2) == Cross(C.x*C.i + C.z**2*C.j, C.x*C.i + C.y*C.j + C.z*C.k)
+    assert Cross(v1, v2).doit() == C.z**3*C.i + (-C.x*C.z)*C.j + (C.x*C.y - C.x*C.z**2)*C.k
+    assert cross(v1, v2) == C.z**3*C.i + (-C.x*C.z)*C.j + (C.x*C.y - C.x*C.z**2)*C.k
+    assert Cross(v1, v2) == -Cross(v2, v1)
+    # XXX: Cannot use Cross here. See XFAIL test below:
+    assert cross(v1, v2) + cross(v2, v1) == Vector.zero
+
+
+@XFAIL
+def test_cross_xfail():
+    v1 = C.x * i + C.z * C.z * j
+    v2 = C.x * i + C.y * j + C.z * k
+    assert Cross(v1, v2) + Cross(v2, v1) == Vector.zero
+
+
+def test_dot():
+    v1 = C.x * i + C.z * C.z * j
+    v2 = C.x * i + C.y * j + C.z * k
+    assert Dot(v1, v2) == Dot(C.x*C.i + C.z**2*C.j, C.x*C.i + C.y*C.j + C.z*C.k)
+    assert Dot(v1, v2).doit() == C.x**2 + C.y*C.z**2
+    assert Dot(v2, v1).doit() == C.x**2 + C.y*C.z**2
+    assert Dot(v1, v2) == Dot(v2, v1)
+
+
+def test_vector_sympy():
+    """
+    Test whether the Vector framework confirms to the hashing
+    and equality testing properties of SymPy.
+    """
+    v1 = 3*j
+    assert v1 == j*3
+    assert v1.components == {j: 3}
+    v2 = 3*i + 4*j + 5*k
+    v3 = 2*i + 4*j + i + 4*k + k
+    assert v3 == v2
+    assert v3.__hash__() == v2.__hash__()
+
+
+def test_kind():
+    assert C.i.kind is VectorKind(NumberKind)
+    assert C.j.kind is VectorKind(NumberKind)
+    assert C.k.kind is VectorKind(NumberKind)
+
+    assert C.x.kind is NumberKind
+    assert C.y.kind is NumberKind
+    assert C.z.kind is NumberKind
+
+    assert Mul._kind_dispatcher(NumberKind, VectorKind(NumberKind)) is VectorKind(NumberKind)
+    assert Mul(2, C.i).kind is VectorKind(NumberKind)
+
+    v1 = C.x * i + C.z * C.z * j
+    v2 = C.x * i + C.y * j + C.z * k
+    assert v1.kind is VectorKind(NumberKind)
+    assert v2.kind is VectorKind(NumberKind)
+
+    assert (v1 + v2).kind is VectorKind(NumberKind)
+    assert Add(v1, v2).kind is VectorKind(NumberKind)
+    assert Cross(v1, v2).doit().kind is VectorKind(NumberKind)
+    assert VectorAdd(v1, v2).kind is VectorKind(NumberKind)
+    assert VectorMul(2, v1).kind is VectorKind(NumberKind)
+    assert VectorZero().kind is VectorKind(NumberKind)
+
+    assert v1.projection(v2).kind is VectorKind(NumberKind)
+    assert v2.projection(v1).kind is VectorKind(NumberKind)
+
+
+def test_vectoradd():
+    assert isinstance(Add(C.i, C.j), VectorAdd)
+    v1 = C.x * i + C.z * C.z * j
+    v2 = C.x * i + C.y * j + C.z * k
+    assert isinstance(Add(v1, v2), VectorAdd)
+
+    # https://github.com/sympy/sympy/issues/26121
+
+    E = Matrix([C.i, C.j, C.k]).T
+    a = Matrix([1, 2, 3])
+    av = E*a
+
+    assert av[0].kind == VectorKind()
+    assert isinstance(av[0], VectorAdd)
+
+
+def test_vector():
+    assert isinstance(i, BaseVector)
+    assert i != j
+    assert j != k
+    assert k != i
+    assert i - i == Vector.zero
+    assert i + Vector.zero == i
+    assert i - Vector.zero == i
+    assert Vector.zero != 0
+    assert -Vector.zero == Vector.zero
+
+    v1 = a*i + b*j + c*k
+    v2 = a**2*i + b**2*j + c**2*k
+    v3 = v1 + v2
+    v4 = 2 * v1
+    v5 = a * i
+
+    assert isinstance(v1, VectorAdd)
+    assert v1 - v1 == Vector.zero
+    assert v1 + Vector.zero == v1
+    assert v1.dot(i) == a
+    assert v1.dot(j) == b
+    assert v1.dot(k) == c
+    assert i.dot(v2) == a**2
+    assert j.dot(v2) == b**2
+    assert k.dot(v2) == c**2
+    assert v3.dot(i) == a**2 + a
+    assert v3.dot(j) == b**2 + b
+    assert v3.dot(k) == c**2 + c
+
+    assert v1 + v2 == v2 + v1
+    assert v1 - v2 == -1 * (v2 - v1)
+    assert a * v1 == v1 * a
+
+    assert isinstance(v5, VectorMul)
+    assert v5.base_vector == i
+    assert v5.measure_number == a
+    assert isinstance(v4, Vector)
+    assert isinstance(v4, VectorAdd)
+    assert isinstance(v4, Vector)
+    assert isinstance(Vector.zero, VectorZero)
+    assert isinstance(Vector.zero, Vector)
+    assert isinstance(v1 * 0, VectorZero)
+
+    assert v1.to_matrix(C) == Matrix([[a], [b], [c]])
+
+    assert i.components == {i: 1}
+    assert v5.components == {i: a}
+    assert v1.components == {i: a, j: b, k: c}
+
+    assert VectorAdd(v1, Vector.zero) == v1
+    assert VectorMul(a, v1) == v1*a
+    assert VectorMul(1, i) == i
+    assert VectorAdd(v1, Vector.zero) == v1
+    assert VectorMul(0, Vector.zero) == Vector.zero
+    raises(TypeError, lambda: v1.outer(1))
+    raises(TypeError, lambda: v1.dot(1))
+
+
+def test_vector_magnitude_normalize():
+    assert Vector.zero.magnitude() == 0
+    assert Vector.zero.normalize() == Vector.zero
+
+    assert i.magnitude() == 1
+    assert j.magnitude() == 1
+    assert k.magnitude() == 1
+    assert i.normalize() == i
+    assert j.normalize() == j
+    assert k.normalize() == k
+
+    v1 = a * i
+    assert v1.normalize() == (a/sqrt(a**2))*i
+    assert v1.magnitude() == sqrt(a**2)
+
+    v2 = a*i + b*j + c*k
+    assert v2.magnitude() == sqrt(a**2 + b**2 + c**2)
+    assert v2.normalize() == v2 / v2.magnitude()
+
+    v3 = i + j
+    assert v3.normalize() == (sqrt(2)/2)*C.i + (sqrt(2)/2)*C.j
+
+
+def test_vector_simplify():
+    A, s, k, m = symbols('A, s, k, m')
+
+    test1 = (1 / a + 1 / b) * i
+    assert (test1 & i) != (a + b) / (a * b)
+    test1 = simplify(test1)
+    assert (test1 & i) == (a + b) / (a * b)
+    assert test1.simplify() == simplify(test1)
+
+    test2 = (A**2 * s**4 / (4 * pi * k * m**3)) * i
+    test2 = simplify(test2)
+    assert (test2 & i) == (A**2 * s**4 / (4 * pi * k * m**3))
+
+    test3 = ((4 + 4 * a - 2 * (2 + 2 * a)) / (2 + 2 * a)) * i
+    test3 = simplify(test3)
+    assert (test3 & i) == 0
+
+    test4 = ((-4 * a * b**2 - 2 * b**3 - 2 * a**2 * b) / (a + b)**2) * i
+    test4 = simplify(test4)
+    assert (test4 & i) == -2 * b
+
+    v = (sin(a)+cos(a))**2*i - j
+    assert trigsimp(v) == (2*sin(a + pi/4)**2)*i + (-1)*j
+    assert trigsimp(v) == v.trigsimp()
+
+    assert simplify(Vector.zero) == Vector.zero
+
+
+def test_vector_equals():
+    assert (2*i).equals(j) is False
+    assert i.equals(i) is True
+
+    # https://github.com/sympy/sympy/issues/25915
+    A = (sqrt(2) + sqrt(6)) / sqrt(sqrt(3) + 2)
+    assert (A*i).equals(2*i) is True
+    assert (A*i).equals(3*i) is False
+
+    # Test comparing vectors in different coordinate systems
+    D = C.orient_new_axis('D', pi/2, C.k)
+    assert (D.i).equals(C.j) is True
+    assert (D.i).equals(C.i) is False
+
+
+def test_vector_conjugate():
+    # https://github.com/sympy/sympy/issues/27094
+    assert (I*i + (1 + I)*j + 2*k).conjugate() == -I*i + (1 - I)*j + 2*k
+
+
+def test_vector_dot():
+    assert i.dot(Vector.zero) == 0
+    assert Vector.zero.dot(i) == 0
+    assert i & Vector.zero == 0
+
+    assert i.dot(i) == 1
+    assert i.dot(j) == 0
+    assert i.dot(k) == 0
+    assert i & i == 1
+    assert i & j == 0
+    assert i & k == 0
+
+    assert j.dot(i) == 0
+    assert j.dot(j) == 1
+    assert j.dot(k) == 0
+    assert j & i == 0
+    assert j & j == 1
+    assert j & k == 0
+
+    assert k.dot(i) == 0
+    assert k.dot(j) == 0
+    assert k.dot(k) == 1
+    assert k & i == 0
+    assert k & j == 0
+    assert k & k == 1
+
+    raises(TypeError, lambda: k.dot(1))
+
+
+def test_vector_cross():
+    assert i.cross(Vector.zero) == Vector.zero
+    assert Vector.zero.cross(i) == Vector.zero
+
+    assert i.cross(i) == Vector.zero
+    assert i.cross(j) == k
+    assert i.cross(k) == -j
+    assert i ^ i == Vector.zero
+    assert i ^ j == k
+    assert i ^ k == -j
+
+    assert j.cross(i) == -k
+    assert j.cross(j) == Vector.zero
+    assert j.cross(k) == i
+    assert j ^ i == -k
+    assert j ^ j == Vector.zero
+    assert j ^ k == i
+
+    assert k.cross(i) == j
+    assert k.cross(j) == -i
+    assert k.cross(k) == Vector.zero
+    assert k ^ i == j
+    assert k ^ j == -i
+    assert k ^ k == Vector.zero
+
+    assert k.cross(1) == Cross(k, 1)
+
+
+def test_projection():
+    v1 = i + j + k
+    v2 = 3*i + 4*j
+    v3 = 0*i + 0*j
+    assert v1.projection(v1) == i + j + k
+    assert v1.projection(v2) == Rational(7, 3)*C.i + Rational(7, 3)*C.j + Rational(7, 3)*C.k
+    assert v1.projection(v1, scalar=True) == S.One
+    assert v1.projection(v2, scalar=True) == Rational(7, 3)
+    assert v3.projection(v1) == Vector.zero
+    assert v3.projection(v1, scalar=True) == S.Zero
+
+
+def test_vector_diff_integrate():
+    f = Function('f')
+    v = f(a)*C.i + a**2*C.j - C.k
+    assert Derivative(v, a) == Derivative((f(a))*C.i +
+                                          a**2*C.j + (-1)*C.k, a)
+    assert (diff(v, a) == v.diff(a) == Derivative(v, a).doit() ==
+            (Derivative(f(a), a))*C.i + 2*a*C.j)
+    assert (Integral(v, a) == (Integral(f(a), a))*C.i +
+            (Integral(a**2, a))*C.j + (Integral(-1, a))*C.k)
+
+
+def test_vector_args():
+    raises(ValueError, lambda: BaseVector(3, C))
+    raises(TypeError, lambda: BaseVector(0, Vector.zero))
+
+
+def test_srepr():
+    from sympy.printing.repr import srepr
+    res = "CoordSys3D(Str('C'), Tuple(ImmutableDenseMatrix([[Integer(1), "\
+            "Integer(0), Integer(0)], [Integer(0), Integer(1), Integer(0)], "\
+            "[Integer(0), Integer(0), Integer(1)]]), VectorZero())).i"
+    assert srepr(C.i) == res
+
+
+def test_scalar():
+    from sympy.vector import CoordSys3D
+    C = CoordSys3D('C')
+    v1 = 3*C.i + 4*C.j + 5*C.k
+    v2 = 3*C.i - 4*C.j + 5*C.k
+    assert v1.is_Vector is True
+    assert v1.is_scalar is False
+    assert (v1.dot(v2)).is_scalar is True
+    assert (v1.cross(v2)).is_scalar is False