rgwfuncs 0.0.33__tar.gz → 0.0.34__tar.gz

{rgwfuncs-0.0.33/src/rgwfuncs.egg-info → rgwfuncs-0.0.34}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: rgwfuncs
-Version: 0.0.33
+Version: 0.0.34
 Summary: A functional programming paradigm for mathematical modelling and data science
 Home-page: https://github.com/ryangerardwilson/rgwfunc
 Author: Ryan Gerard Wilson
@@ -150,6 +150,83 @@ Print a list of available function names in alphabetical order. If a filter is p
 
 --------------------------------------------------------------------------------
 
+## Interactive Shell Function
+
+This section includes functions that facilitate launching an interactive Python shell to inspect and modify local variables within the user's environment.
+
+### 1. `interactive_shell`
+
+#### Usage
+
+Launches an interactive prompt for inspecting and modifying local variables, making all methods in the rgwfuncs library available by default. This REPL (Read-Eval-Print Loop) environment supports command history and autocompletion, making it easier to interact with your Python code.
+
+• Parameters:
+  - `local_vars` (dict, optional): A dictionary of local variables to be accessible within the interactive shell. If not provided, defaults to an empty dictionary.
+
+• Usage:
+  - You can call this function to enter an interactive shell where you can view and modify the variables in the given local scope.
+
+• Example:
+
+    from rgwfuncs import interactive_shell
+    import pandas as pd
+    import numpy as np
+
+    # Example DataFrame
+    df = pd.DataFrame({
+        'id': [1, 2, 3, 4, 5],
+        'name': ['Alice', 'Bob', 'Charlie', 'David', 'Eva'],
+        'age': [30, 25, 35, 28, 22],
+        'city': ['New York', 'Los Angeles', 'Chicago', 'San Francisco', 'Boston']
+    })
+
+    # Function to retrieve the first n rows of a DataFrame
+    def first_n_rows(df, n):
+        return df.head(n).to_dict('records')
+
+    # Launch the interactive shell with local variables
+    interactive_shell(locals())
+
+- Once in the interactive shell, you are greeted with a welcome message. You can access the variables defined in the local scope where `interactive_shell(locals())` was called, including any imported modules such as `pandas` (accessed as `pd`) and `numpy` (accessed as `np`). This means you can directly use these modules in the interactive session. Type `exit()` to quit the shell.
+
+#### Interactive Shell Example Sessions
+
+1. DataFrame Inspection with Pandas:
+
+    Welcome to the rgwfuncs interactive shell.
+    >>> pirst_n_rows(df, 2)
+    Traceback (most recent call last):
+      File "<console>", line 1, in <module>
+    NameError: name 'pirst_n_rows' is not defined. Did you mean: 'first_n_rows'?
+    >>> first_n_rows(df, 2)
+    {'age': '30', 'city': 'New York', 'id': '1', 'name': 'Alice'}
+    {'age': '25', 'city': 'Los Angeles', 'id': '2', 'name': 'Bob'}
+    >>> print(df)
+      id     name age           city
+    0  1    Alice  30       New York
+    1  2      Bob  25    Los Angeles
+    2  3  Charlie  35        Chicago
+    3  4    David  28  San Francisco
+    4  5      Eva  22         Boston
+
+2. Array Operations with NumPy:
+
+    Welcome to the rgwfuncs interactive shell.
+    >>> arr = np.array([1, 2, 3, 4, 5])
+    >>> arr
+    array([1, 2, 3, 4, 5])
+
+These examples illustrate how you can use functions and variables within the interactive shell, handle errors with meaningful suggestions, and perform operations using external libraries like pandas and numpy.
+
+#### Key Features
+
+- Autocompletion: Uses the `rlcompleter` library to provide tab-completion of variables and functions names, enhancing ease of use.
+- History Support: Utilizes `readline` for command-line history, allowing you to navigate through previous commands using the arrow keys.
+
+This function is particularly useful for debugging purposes when you want real-time interaction with your program's execution environment.
+
+--------------------------------------------------------------------------------
+
 ## Algebra Based Functions
 
 This section provides comprehensive functions for handling algebraic expressions, performing tasks such as computation, simplification, solving equations, and prime factorization, all outputted in LaTeX format.

{rgwfuncs-0.0.33 → rgwfuncs-0.0.34}/README.md

@@ -124,6 +124,83 @@ Print a list of available function names in alphabetical order. If a filter is p
 
 --------------------------------------------------------------------------------
 
+## Interactive Shell Function
+
+This section includes functions that facilitate launching an interactive Python shell to inspect and modify local variables within the user's environment.
+
+### 1. `interactive_shell`
+
+#### Usage
+
+Launches an interactive prompt for inspecting and modifying local variables, making all methods in the rgwfuncs library available by default. This REPL (Read-Eval-Print Loop) environment supports command history and autocompletion, making it easier to interact with your Python code.
+
+• Parameters:
+  - `local_vars` (dict, optional): A dictionary of local variables to be accessible within the interactive shell. If not provided, defaults to an empty dictionary.
+
+• Usage:
+  - You can call this function to enter an interactive shell where you can view and modify the variables in the given local scope.
+
+• Example:
+
+    from rgwfuncs import interactive_shell
+    import pandas as pd
+    import numpy as np
+
+    # Example DataFrame
+    df = pd.DataFrame({
+        'id': [1, 2, 3, 4, 5],
+        'name': ['Alice', 'Bob', 'Charlie', 'David', 'Eva'],
+        'age': [30, 25, 35, 28, 22],
+        'city': ['New York', 'Los Angeles', 'Chicago', 'San Francisco', 'Boston']
+    })
+
+    # Function to retrieve the first n rows of a DataFrame
+    def first_n_rows(df, n):
+        return df.head(n).to_dict('records')
+
+    # Launch the interactive shell with local variables
+    interactive_shell(locals())
+
+- Once in the interactive shell, you are greeted with a welcome message. You can access the variables defined in the local scope where `interactive_shell(locals())` was called, including any imported modules such as `pandas` (accessed as `pd`) and `numpy` (accessed as `np`). This means you can directly use these modules in the interactive session. Type `exit()` to quit the shell.
+
+#### Interactive Shell Example Sessions
+
+1. DataFrame Inspection with Pandas:
+
+    Welcome to the rgwfuncs interactive shell.
+    >>> pirst_n_rows(df, 2)
+    Traceback (most recent call last):
+      File "<console>", line 1, in <module>
+    NameError: name 'pirst_n_rows' is not defined. Did you mean: 'first_n_rows'?
+    >>> first_n_rows(df, 2)
+    {'age': '30', 'city': 'New York', 'id': '1', 'name': 'Alice'}
+    {'age': '25', 'city': 'Los Angeles', 'id': '2', 'name': 'Bob'}
+    >>> print(df)
+      id     name age           city
+    0  1    Alice  30       New York
+    1  2      Bob  25    Los Angeles
+    2  3  Charlie  35        Chicago
+    3  4    David  28  San Francisco
+    4  5      Eva  22         Boston
+
+2. Array Operations with NumPy:
+
+    Welcome to the rgwfuncs interactive shell.
+    >>> arr = np.array([1, 2, 3, 4, 5])
+    >>> arr
+    array([1, 2, 3, 4, 5])
+
+These examples illustrate how you can use functions and variables within the interactive shell, handle errors with meaningful suggestions, and perform operations using external libraries like pandas and numpy.
+
+#### Key Features
+
+- Autocompletion: Uses the `rlcompleter` library to provide tab-completion of variables and functions names, enhancing ease of use.
+- History Support: Utilizes `readline` for command-line history, allowing you to navigate through previous commands using the arrow keys.
+
+This function is particularly useful for debugging purposes when you want real-time interaction with your program's execution environment.
+
+--------------------------------------------------------------------------------
+
 ## Algebra Based Functions
 
 This section provides comprehensive functions for handling algebraic expressions, performing tasks such as computation, simplification, solving equations, and prime factorization, all outputted in LaTeX format.

{rgwfuncs-0.0.33 → rgwfuncs-0.0.34}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "rgwfuncs"
-version = "0.0.33"
+version = "0.0.34"
 authors = [
   { name = "Ryan Gerard Wilson", email = "ryangerardwilson@gmail.com" },
 ]

{rgwfuncs-0.0.33 → rgwfuncs-0.0.34}/setup.cfg

@@ -1,6 +1,6 @@
 [metadata]
 name = rgwfuncs
-version = 0.0.33
+version = 0.0.34
 author = Ryan Gerard Wilson
 author_email = ryangerardwilson@gmail.com
 description = A functional programming paradigm for mathematical modelling and data science

{rgwfuncs-0.0.33 → rgwfuncs-0.0.34}/src/rgwfuncs/__init__.py

@@ -4,4 +4,5 @@
 from .algebra_lib import compute_constant_expression, compute_constant_expression_involving_matrices, compute_constant_expression_involving_ordered_series, compute_prime_factors, python_polynomial_expression_to_latex, simplify_polynomial_expression, solve_homogeneous_polynomial_expression
 from .df_lib import append_columns, append_percentile_classification_column, append_ranged_classification_column, append_ranged_date_classification_column, append_rows, append_xgb_labels, append_xgb_logistic_regression_predictions, append_xgb_regression_predictions, bag_union_join, bottom_n_unique_values, cascade_sort, delete_rows, drop_duplicates, drop_duplicates_retain_first, drop_duplicates_retain_last, filter_dataframe, filter_indian_mobiles, first_n_rows, from_raw_data, insert_dataframe_in_sqlite_database, last_n_rows, left_join, limit_dataframe, load_data_from_path, load_data_from_query, load_data_from_sqlite_path, mask_against_dataframe, mask_against_dataframe_converse, numeric_clean, order_columns, print_correlation, print_dataframe, print_memory_usage, print_n_frequency_cascading, print_n_frequency_linear, rename_columns, retain_columns, right_join, send_data_to_email, send_data_to_slack, send_dataframe_via_telegram, sync_dataframe_to_sqlite_database, top_n_unique_values, union_join, update_rows
 from .docs_lib import docs
+from .interactive_shell_lib import interactive_shell
 from .str_lib import send_telegram_message

{rgwfuncs-0.0.33 → rgwfuncs-0.0.34}/src/rgwfuncs/algebra_lib.py

@@ -76,7 +76,7 @@ def compute_constant_expression_involving_matrices(expression: str) -> str:
     Computes the result of a constant expression involving matrices and returns it as a LaTeX string.
 
     Parameters:
-    expression (str): The constant expression involving matrices. Example format includes operations such as "+", 
+    expression (str): The constant expression involving matrices. Example format includes operations such as "+",
     "-", "*", "/".
 
     Returns:
@@ -161,9 +161,9 @@ def compute_constant_expression_involving_matrices(expression: str) -> str:
 
 def compute_constant_expression_involving_ordered_series(expression: str) -> str:
     """
-    Computes the result of a constant expression involving ordered series, and returns it as a Latex string. 
+    Computes the result of a constant expression involving ordered series, and returns it as a Latex string.
     Supports operations lile "+", "-", "*", "/", as well as "dd()" (the discrete difference operator).
-  
+
     The function first applies the discrete difference operator to any series where applicable, then evaluates
     arithmetic operations between series.
 
@@ -261,8 +261,6 @@ def compute_constant_expression_involving_ordered_series(expression: str) -> str
         return f"Error computing ordered series operation: {e}"
 
 
-
-
 def python_polynomial_expression_to_latex(
     expression: str,
     subs: Optional[Dict[str, float]] = None
@@ -549,5 +547,3 @@ def solve_homogeneous_polynomial_expression(
 
     except Exception as e:
         raise ValueError(f"Error solving the expression: {e}")
-
-

rgwfuncs-0.0.34/src/rgwfuncs/interactive_shell_lib.py

@@ -0,0 +1,32 @@
+import code
+import readline
+import rlcompleter  # noqa: F401
+import sys  # noqa: F401
+from typing import Dict, Any
+from .df_lib import *  # noqa: F401, F403, E402
+from .algebra_lib import *  # noqa: F401, F403, E402
+from .str_lib import *  # noqa: F401, F403, E402
+from .docs_lib import *  # noqa: F401, F403, E402
+
+
+def interactive_shell(local_vars: Dict[str, Any]) -> None:
+    """
+    Launches an interactive prompt for inspecting and modifying local variables, making all methods
+    in the rgwfuncs library available by default.
+
+    Parameters:
+        local_vars (dict): Dictionary of local variables to be available in the interactive shell.
+    """
+    if not isinstance(local_vars, dict):
+        raise TypeError("local_vars must be a dictionary")
+
+    readline.parse_and_bind("tab: complete")
+
+    # Make imported functions available in the REPL
+    local_vars.update(globals())
+
+    # Create interactive console with local context
+    console = code.InteractiveConsole(locals=local_vars)
+
+    # Start interactive session
+    console.interact(banner="Welcome to the rgwfuncs interactive shell.")

{rgwfuncs-0.0.33 → rgwfuncs-0.0.34/src/rgwfuncs.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: rgwfuncs
-Version: 0.0.33
+Version: 0.0.34
 Summary: A functional programming paradigm for mathematical modelling and data science
 Home-page: https://github.com/ryangerardwilson/rgwfunc
 Author: Ryan Gerard Wilson
@@ -150,6 +150,83 @@ Print a list of available function names in alphabetical order. If a filter is p
 
 --------------------------------------------------------------------------------
 
+## Interactive Shell Function
+
+This section includes functions that facilitate launching an interactive Python shell to inspect and modify local variables within the user's environment.
+
+### 1. `interactive_shell`
+
+#### Usage
+
+Launches an interactive prompt for inspecting and modifying local variables, making all methods in the rgwfuncs library available by default. This REPL (Read-Eval-Print Loop) environment supports command history and autocompletion, making it easier to interact with your Python code.
+
+• Parameters:
+  - `local_vars` (dict, optional): A dictionary of local variables to be accessible within the interactive shell. If not provided, defaults to an empty dictionary.
+
+• Usage:
+  - You can call this function to enter an interactive shell where you can view and modify the variables in the given local scope.
+
+• Example:
+
+    from rgwfuncs import interactive_shell
+    import pandas as pd
+    import numpy as np
+
+    # Example DataFrame
+    df = pd.DataFrame({
+        'id': [1, 2, 3, 4, 5],
+        'name': ['Alice', 'Bob', 'Charlie', 'David', 'Eva'],
+        'age': [30, 25, 35, 28, 22],
+        'city': ['New York', 'Los Angeles', 'Chicago', 'San Francisco', 'Boston']
+    })
+
+    # Function to retrieve the first n rows of a DataFrame
+    def first_n_rows(df, n):
+        return df.head(n).to_dict('records')
+
+    # Launch the interactive shell with local variables
+    interactive_shell(locals())
+
+- Once in the interactive shell, you are greeted with a welcome message. You can access the variables defined in the local scope where `interactive_shell(locals())` was called, including any imported modules such as `pandas` (accessed as `pd`) and `numpy` (accessed as `np`). This means you can directly use these modules in the interactive session. Type `exit()` to quit the shell.
+
+#### Interactive Shell Example Sessions
+
+1. DataFrame Inspection with Pandas:
+
+    Welcome to the rgwfuncs interactive shell.
+    >>> pirst_n_rows(df, 2)
+    Traceback (most recent call last):
+      File "<console>", line 1, in <module>
+    NameError: name 'pirst_n_rows' is not defined. Did you mean: 'first_n_rows'?
+    >>> first_n_rows(df, 2)
+    {'age': '30', 'city': 'New York', 'id': '1', 'name': 'Alice'}
+    {'age': '25', 'city': 'Los Angeles', 'id': '2', 'name': 'Bob'}
+    >>> print(df)
+      id     name age           city
+    0  1    Alice  30       New York
+    1  2      Bob  25    Los Angeles
+    2  3  Charlie  35        Chicago
+    3  4    David  28  San Francisco
+    4  5      Eva  22         Boston
+
+2. Array Operations with NumPy:
+
+    Welcome to the rgwfuncs interactive shell.
+    >>> arr = np.array([1, 2, 3, 4, 5])
+    >>> arr
+    array([1, 2, 3, 4, 5])
+
+These examples illustrate how you can use functions and variables within the interactive shell, handle errors with meaningful suggestions, and perform operations using external libraries like pandas and numpy.
+
+#### Key Features
+
+- Autocompletion: Uses the `rlcompleter` library to provide tab-completion of variables and functions names, enhancing ease of use.
+- History Support: Utilizes `readline` for command-line history, allowing you to navigate through previous commands using the arrow keys.
+
+This function is particularly useful for debugging purposes when you want real-time interaction with your program's execution environment.
+
+--------------------------------------------------------------------------------
+
 ## Algebra Based Functions
 
 This section provides comprehensive functions for handling algebraic expressions, performing tasks such as computation, simplification, solving equations, and prime factorization, all outputted in LaTeX format.

{rgwfuncs-0.0.33 → rgwfuncs-0.0.34}/src/rgwfuncs.egg-info/SOURCES.txt

@@ -6,11 +6,11 @@ src/rgwfuncs/__init__.py
 src/rgwfuncs/algebra_lib.py
 src/rgwfuncs/df_lib.py
 src/rgwfuncs/docs_lib.py
+src/rgwfuncs/interactive_shell_lib.py
 src/rgwfuncs/str_lib.py
 src/rgwfuncs.egg-info/PKG-INFO
 src/rgwfuncs.egg-info/SOURCES.txt
 src/rgwfuncs.egg-info/dependency_links.txt
 src/rgwfuncs.egg-info/entry_points.txt
 src/rgwfuncs.egg-info/requires.txt
-src/rgwfuncs.egg-info/top_level.txt
-tests/test_algebra_lib.py
+src/rgwfuncs.egg-info/top_level.txt

rgwfuncs-0.0.33/tests/test_algebra_lib.py

@@ -1,144 +0,0 @@
-import sys
-import os
-import math
-
-# flake8: noqa: E402
-# Allow the following import statement to be AFTER sys.path modifications
-sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
-
-from src.rgwfuncs.algebra_lib import (
-    compute_prime_factors,
-    compute_constant_expression,
-    compute_constant_expression_involving_matrices,
-    compute_constant_expression_involving_ordered_series,
-    python_polynomial_expression_to_latex,
-    simplify_polynomial_expression,
-    solve_homogeneous_polynomial_expression)
-
-
-def test_compute_prime_factors():
-    test_cases = [
-        (100, "2^{2} \\cdot 5^{2}"),
-        (60, "2^{2} \\cdot 3 \\cdot 5"),
-        (45, "3^{2} \\cdot 5"),
-        (1, ""),  # Handle case with 1, which has no prime factors
-        (17, "17")  # Prime number itself
-    ]
-
-    for n, expected_output in test_cases:
-        result = compute_prime_factors(n)
-        assert result == expected_output, f"Failed for {n}, got {result}"
-
-
-def test_compute_constant_expression():
-    test_cases = [
-        ("2 + 2", 4.0),
-        ("5 - 3", 2.0),
-        ("3 * 3", 9.0),
-        ("8 / 2", 4.0),
-        ("10 % 3", 1.0),
-        ("math.gcd(36, 60) * math.sin(math.radians(45)) * 10000", 84852.8137423857),
-        # ("np.diff([2,6,9,60])", r"\left[\begin{matrix}4\\3\\51\end{matrix}\right]"),
-    ]
-
-    for input_data, expected_output in test_cases:
-        result = compute_constant_expression(input_data)
-        assert math.isclose(result, expected_output, rel_tol=1e-9), f"Failed for {input_data}, got {result}"
-
-def test_compute_constant_expression_involving_matrices():
-    test_cases = [
-        ("[[2, 6, 9],[1, 3, 5]] + [[1, 2, 3],[4, 5, 6]]", r"\begin{bmatrix}3 & 8 & 12\\5 & 8 & 11\end{bmatrix}"),
-        ("[[10, 10, 10],[2, 4, 6]] - [[5, 3, 2],[1, 2, 1]]", r"\begin{bmatrix}5 & 7 & 8\\1 & 2 & 5\end{bmatrix}"),
-        ("[[2, 4],[6, 8]] * [[1, 0.5],[2, 0.25]]", r"\begin{bmatrix}2 & 2.0\\12 & 2.0\end{bmatrix}"),
-        ("[[8, 16],[32, 64]] / [[2, 2],[8, 16]]", r"\begin{bmatrix}4.0 & 8.0\\4.0 & 4.0\end{bmatrix}"),
-        ("[[2, 6, 9], [1, 3, 5]] + [[1, 2, 3], [4, 5, 6]] - [[1, 1, 1], [1, 1, 1]]", r"\begin{bmatrix}2 & 7 & 11\\4 & 7 & 10\end{bmatrix}"),
-        ("[2, 6, 9] + [1, 2, 3] - [1, 1, 1]", r"\begin{bmatrix}2 & 7 & 11\end{bmatrix}"),
-        ("[[1, 2], [3, 4]] + [[2, 3], [4, 5]] + [[1, 1], [1, 1]]", r"\begin{bmatrix}4 & 6\\8 & 10\end{bmatrix}"),
-        ("[3, 6, 9] - [1, 2, 3] + [5, 5, 5]", r"\begin{bmatrix}7 & 9 & 11\end{bmatrix}"),
-        ("[3, 6, 9] - [1, 2, 3, 4]", r"Operations between matrices must involve matrices of the same dimension"),
-
-        # Edge cases
-        ("[]", r"\begin{bmatrix}\end{bmatrix}"),  # Empty list
-        ("[5]", r"\begin{bmatrix}5\end{bmatrix}"),  # Single-element list
-    ]
-
-    for input_data, expected_output in test_cases:
-        result = compute_constant_expression_involving_matrices(input_data)
-        assert result == expected_output, f"Failed for {input_data}, got {result}"
-
-# Example test function
-
-
-def test_compute_constant_expression_involving_ordered_series():
-    test_cases = [
-        ("[2, 6, 9] + [1, 2, 3]", "[3, 8, 12]"),
-        ("[10, 15, 21] - [5, 5, 5]", "[5, 10, 16]"),
-        ("[2, 4, 6] * [1, 2, 3]", "[2, 8, 18]"),
-        ("[8, 16, 32] / [2, 2, 8]", "[4.0, 8.0, 4.0]"),
-        ("dd([2, 6, 9, 60]) + dd([78, 79, 80])", "Operations between ordered series must involve series of equal length"),
-        ("dd([1, 3, 6, 10]) - dd([0, 1, 1, 2])", "[1, 3, 3]"),
-
-        # Edge cases
-        ("dd([1])", "[]"),  # Single-element list, becomes empty
-        ("dd([])", "[]"),   # Empty list case
-        ("[5]", "[5]"),  # Single-element list, unchanged
-        ("[]", "[]"),    # Empty list
-        ("[4, 3, 51] + [1, 1]", "Operations between ordered series must involve series of equal length"),  # Test unequal lengths
-    ]
-
-    for input_data, expected_output in test_cases:
-        result = compute_constant_expression_involving_ordered_series(input_data)
-        assert result == expected_output, f"Failed for {input_data}, got {result}"
-
-
-def test_python_polynomial_expression_to_latex():
-    test_cases = [
-        # Without substitutions
-        ("x**2 + y**2", None, r"x^{2} + y^{2}"),
-        ("3*a + 4*b", None, r"3 a + 4 b"),
-        ("3*x**3 / (7*y*m**(n+2) + 103)", None, r"\frac{3 x^{3}}{7 m^{n + 2} y + 103}"),
-
-        # With substitutions
-        ("x**2 + y**2", {"x": 3, "y": 4}, r"25"),
-        ("x**2 + y**2", {"x": 3}, r"y^{2} + 9"),
-        ("a*b + b", {"b": 2}, r"2 a + 2"),
-        ("sin(x+z**2) + cos(y)", {"x": 55}, r"cos y + sin \left(z^{2} + 55\right)"),
-        ("sin(x) + cos(y)", {"x": 0}, r"cos y")
-    ]
-
-    for expression, subs, expected_output in test_cases:
-        output = python_polynomial_expression_to_latex(expression, subs)
-        assert output == expected_output, (
-            f"Test failed for expression: {expression} with substitutions: {subs}. "
-            f"Expected {expected_output}, got {output}"
-        )
-
-
-
-def test_simplify_polynomial_expression():
-    test_cases = [
-        # Without substitutions
-        (("(np.diff(3*x**8)) / (np.diff(8*x**30) * 11*y**3)", None), r"\frac{1}{110 x^{22} y^{3}}"),
-
-        # With substitutions
-        (("x**2 + y**2", {"x": 3, "y": 4}), "25"),
-        (("a*b + b", {"b": 2}), r"2 a + 2"),  # Assumes no simplification of `a*b`
-        (("(x**2 + y**2 + z**2)", {"x": 1, "y": 0, "z": 0}), "1")
-    ]
-
-    for (expression, subs), expected_output in test_cases:
-        output = simplify_polynomial_expression(expression, subs)
-        assert output == expected_output, (f"Test failed for expression: {expression} with substitutions: {subs}. Expected {expected_output}, got {output}")
-
-
-def test_solve_homogeneous_polynomial_expression():
-    test_cases = [
-        # Test case with substitutions
-        (("a*x**2 + b*x + c", "x", {"a": 3, "b": 7, "c": 5}), r"\left[-7/6 - sqrt(11)*I/6, -7/6 + sqrt(11)*I/6\right]"),
-    ]
-
-    for (expression, variable, subs), expected_output in test_cases:
-        assert solve_homogeneous_polynomial_expression(expression, variable, subs) == expected_output
-
-
-