rgwfuncs 0.0.52__tar.gz → 0.0.54__tar.gz

{rgwfuncs-0.0.52/src/rgwfuncs.egg-info → rgwfuncs-0.0.54}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: rgwfuncs
-Version: 0.0.52
+Version: 0.0.54
 Summary: A functional programming paradigm for mathematical modelling and data science
 Home-page: https://github.com/ryangerardwilson/rgwfunc
 Author: Ryan Gerard Wilson
@@ -370,17 +370,17 @@ Converts a polynomial expression written in Python syntax to a LaTeX formatted s
 
 Expands a polynomial expression written in Python syntax and converts it into a LaTeX formatted string. This function takes algebraic expressions provided as strings using Python's syntax, applies polynomial expansion through SymPy, and translates them into LaTeX representations, suitable for academic or professional documentation. It supports expressions with named variables and provides an option to substitute specific values into the expression before expansion.
 
-- Parameters:
+• Parameters:
   - `expression` (str): The algebraic expression to expand and convert to LaTeX. This string should be formatted using Python syntax acceptable by SymPy.
   - `subs` (Optional[Dict[str, float]]): An optional dictionary of substitutions where the keys are variable names in the expression, and the values are the numbers with which to substitute those variables before expanding.
 
-- Returns:
+• Returns:
   - `str`: The LaTeX formatted string of the expanded expression.
 
-- Raises:
+• Raises:
   - `ValueError`: If the expression cannot be parsed due to syntax errors.
 
-- Example:
+• Example:
 
     from rgwfuncs import expand_polynomial_expression
 
@@ -406,17 +406,17 @@ Expands a polynomial expression written in Python syntax and converts it into a
 
 Factors a polynomial expression written in Python syntax and converts it into a LaTeX formatted string. This function parses an algebraic expression, performs polynomial factoring using SymPy, and converts the factored expression into a LaTeX representation, ideal for academic or professional use. Optional substitutions can be made before factoring.
 
-- Parameters:
+• Parameters:
   - `expression` (str): The polynomial expression to factor and convert to LaTeX. This should be a valid expression formatted using Python syntax.
   - `subs` (Optional[Dict[str, float]]): An optional dictionary of substitutions. The keys are variable names in the expression, and the values are numbers that replace these variables.
 
-- Returns:
+• Returns:
   - `str`: The LaTeX formatted string representing the factored expression.
 
-- Raises:
+• Raises:
   - `ValueError`: If the expression cannot be parsed due to syntax errors.
 
-- Example:
+• Example:
 
     from rgwfuncs import factor_polynomial_expression
 
@@ -441,7 +441,7 @@ Simplifies an algebraic expression in polynomial form and returns it in LaTeX fo
 • Returns:
   - `str`: The simplified expression formatted as a LaTeX string.
 
-• Example Usage:
+• Example:
 
     from rgwfuncs import simplify_polynomial_expression
 
@@ -467,17 +467,17 @@ Simplifies an algebraic expression in polynomial form and returns it in LaTeX fo
 
 Cancels common factors within a polynomial expression written in Python syntax and converts it to a LaTeX formatted string. This function parses an algebraic expression, cancels common factors using SymPy, and translates the reduced expression into a LaTeX representation. It can also accommodate optional substitutions to be made prior to simplification.
 
-- Parameters:
+• Parameters:
   - `expression` (str): The algebraic expression to simplify and convert to LaTeX. This string should be formatted using Python syntax.
   - `subs` (Optional[Dict[str, float]]): An optional dictionary of substitutions where the keys are variable names in the expression, and the values are the numbers to substitute.
 
-- Returns:
+• Returns:
   - `str`: The LaTeX formatted string of the simplified expression. If the expression involves indeterminate forms due to operations like division by zero, a descriptive error message is returned instead.
 
-- Raises:
+• Raises:
   - `ValueError`: If the expression cannot be parsed due to syntax errors or involves undefined operations, such as division by zero.
 
-- Example:
+• Example:
 
     from rgwfuncs import cancel_polynomial_expression
 
@@ -524,13 +524,14 @@ This function plots polynomial functions described by a list of expressions and
   - A value which is a dictionary containing substitutions for the expression. Must include an `"x"` key, either as `"*"` for default domain or a NumPy array.
 - `zoom` (`float`): Determines the numeric axis range from `-zoom` to `+zoom` for both x and y axes (default is `10.0`).
 - `show_legend` (`bool`): Specifies whether to include a legend in the plot (default is `True`).
+- `open_file` (`bool`): If saving to path is not desireable, opens the svg as a temp file, else opens the file from the actual location using the system's default viewer (defaults to False).
+- `save_path` (`Optional[str]`): If specified, saves the output string as a .svg at the indicated path (defaults to None).
 
 • Returns:
 - `str`: The raw SVG markup of the resulting plot.
 
 • Example:
 
-    import subprocess
     from rgwfuncs import plot_polynomial_functions
 
     # Generate the SVG

{rgwfuncs-0.0.52 → rgwfuncs-0.0.54}/README.md

@@ -343,17 +343,17 @@ Converts a polynomial expression written in Python syntax to a LaTeX formatted s
 
 Expands a polynomial expression written in Python syntax and converts it into a LaTeX formatted string. This function takes algebraic expressions provided as strings using Python's syntax, applies polynomial expansion through SymPy, and translates them into LaTeX representations, suitable for academic or professional documentation. It supports expressions with named variables and provides an option to substitute specific values into the expression before expansion.
 
-- Parameters:
+• Parameters:
   - `expression` (str): The algebraic expression to expand and convert to LaTeX. This string should be formatted using Python syntax acceptable by SymPy.
   - `subs` (Optional[Dict[str, float]]): An optional dictionary of substitutions where the keys are variable names in the expression, and the values are the numbers with which to substitute those variables before expanding.
 
-- Returns:
+• Returns:
   - `str`: The LaTeX formatted string of the expanded expression.
 
-- Raises:
+• Raises:
   - `ValueError`: If the expression cannot be parsed due to syntax errors.
 
-- Example:
+• Example:
 
     from rgwfuncs import expand_polynomial_expression
 
@@ -379,17 +379,17 @@ Expands a polynomial expression written in Python syntax and converts it into a
 
 Factors a polynomial expression written in Python syntax and converts it into a LaTeX formatted string. This function parses an algebraic expression, performs polynomial factoring using SymPy, and converts the factored expression into a LaTeX representation, ideal for academic or professional use. Optional substitutions can be made before factoring.
 
-- Parameters:
+• Parameters:
   - `expression` (str): The polynomial expression to factor and convert to LaTeX. This should be a valid expression formatted using Python syntax.
   - `subs` (Optional[Dict[str, float]]): An optional dictionary of substitutions. The keys are variable names in the expression, and the values are numbers that replace these variables.
 
-- Returns:
+• Returns:
   - `str`: The LaTeX formatted string representing the factored expression.
 
-- Raises:
+• Raises:
   - `ValueError`: If the expression cannot be parsed due to syntax errors.
 
-- Example:
+• Example:
 
     from rgwfuncs import factor_polynomial_expression
 
@@ -414,7 +414,7 @@ Simplifies an algebraic expression in polynomial form and returns it in LaTeX fo
 • Returns:
   - `str`: The simplified expression formatted as a LaTeX string.
 
-• Example Usage:
+• Example:
 
     from rgwfuncs import simplify_polynomial_expression
 
@@ -440,17 +440,17 @@ Simplifies an algebraic expression in polynomial form and returns it in LaTeX fo
 
 Cancels common factors within a polynomial expression written in Python syntax and converts it to a LaTeX formatted string. This function parses an algebraic expression, cancels common factors using SymPy, and translates the reduced expression into a LaTeX representation. It can also accommodate optional substitutions to be made prior to simplification.
 
-- Parameters:
+• Parameters:
   - `expression` (str): The algebraic expression to simplify and convert to LaTeX. This string should be formatted using Python syntax.
   - `subs` (Optional[Dict[str, float]]): An optional dictionary of substitutions where the keys are variable names in the expression, and the values are the numbers to substitute.
 
-- Returns:
+• Returns:
   - `str`: The LaTeX formatted string of the simplified expression. If the expression involves indeterminate forms due to operations like division by zero, a descriptive error message is returned instead.
 
-- Raises:
+• Raises:
   - `ValueError`: If the expression cannot be parsed due to syntax errors or involves undefined operations, such as division by zero.
 
-- Example:
+• Example:
 
     from rgwfuncs import cancel_polynomial_expression
 
@@ -497,13 +497,14 @@ This function plots polynomial functions described by a list of expressions and
   - A value which is a dictionary containing substitutions for the expression. Must include an `"x"` key, either as `"*"` for default domain or a NumPy array.
 - `zoom` (`float`): Determines the numeric axis range from `-zoom` to `+zoom` for both x and y axes (default is `10.0`).
 - `show_legend` (`bool`): Specifies whether to include a legend in the plot (default is `True`).
+- `open_file` (`bool`): If saving to path is not desireable, opens the svg as a temp file, else opens the file from the actual location using the system's default viewer (defaults to False).
+- `save_path` (`Optional[str]`): If specified, saves the output string as a .svg at the indicated path (defaults to None).
 
 • Returns:
 - `str`: The raw SVG markup of the resulting plot.
 
 • Example:
 
-    import subprocess
     from rgwfuncs import plot_polynomial_functions
 
     # Generate the SVG

{rgwfuncs-0.0.52 → rgwfuncs-0.0.54}/pyproject.toml

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

{rgwfuncs-0.0.52 → rgwfuncs-0.0.54}/setup.cfg

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

{rgwfuncs-0.0.52 → rgwfuncs-0.0.54}/src/rgwfuncs/algebra_lib.py

@@ -1,16 +1,15 @@
 import re
 import math
 import ast
+import subprocess
+import tempfile
 from sympy import symbols, latex, simplify, solve, diff, Expr, factor, cancel, Eq
 from sympy.core.sympify import SympifyError
 from sympy.core import S
 from sympy.parsing.sympy_parser import parse_expr
 from sympy import __all__ as sympy_functions
 from sympy.parsing.sympy_parser import (standard_transformations, implicit_multiplication_application)
-
 from typing import Tuple, List, Dict, Optional, Any
-
-
 import numpy as np
 import matplotlib.pyplot as plt
 from io import BytesIO
@@ -710,7 +709,9 @@ def solve_homogeneous_polynomial_expression(
 def plot_polynomial_functions(
     functions: List[Dict[str, Dict[str, Any]]],
     zoom: float = 10.0,
-    show_legend: bool = True
+    show_legend: bool = True,
+    open_file: bool = False,
+    save_path: Optional[str] = None,
 ) -> str:
     """
     Plots expressions described by a list of dictionaries of the form:
@@ -742,6 +743,13 @@ def plot_polynomial_functions(
         Sets the numeric axis range from -zoom..+zoom in both x and y.
     show_legend : bool
         Whether to add a legend to the plot (defaults to True).
+    open_file : bool
+        If saving to path is not desirable, opens the SVG as a temp file;  
+        otherwise opens the file from the actual location using the system's  
+        default viewer (defaults to False).
+    save_path : Optional[str]
+        If specified, saves the output string as a .svg at the indicated path  
+        (defaults to None).
 
     Returns
     -------
@@ -764,71 +772,113 @@ def plot_polynomial_functions(
 
         expr_tmp = re.sub(DIFF_PATTERN, diff_replacer, expr_str)
         expr_tmp = expr_tmp.replace("np.", "")
+
+        # Attempt to convert basic Pythonic polynomial expressions to LaTeX
         try:
+            # Suppose you have a helper function python_polynomial_expression_to_latex
+            # If not, you can do a naive replacement or skip
+            from python_latex_helpers import python_polynomial_expression_to_latex
             latex_expr = python_polynomial_expression_to_latex(expr_tmp)
             return latex_expr
         except Exception:
-            # Fallback: just do naive **
+            # Fallback: naive ** -> ^
             return expr_tmp.replace("**", "^")
 
+    def handle_open_and_save(svg_string: str, open_it: bool, path: Optional[str]) -> None:
+        # Save the SVG to a file if a path is provided
+        if path:
+            try:
+                with open(path, 'w', encoding='utf-8') as file:
+                    file.write(svg_string)
+                print(f"[INFO] SVG saved to: {path}")
+            except IOError as e:
+                print(f"[ERROR] Failed to save SVG to {path}. IOError: {e}")
+
+        # Handle opening the file if requested
+        if open_it and path:
+            result = subprocess.run(["xdg-open", path], stderr=subprocess.DEVNULL)
+            if result.returncode != 0:
+                print("[ERROR] Failed to open the SVG file with the default viewer.")
+        elif open_it:
+            with tempfile.NamedTemporaryFile(delete=False, suffix=".svg") as tmpfile:
+                temp_svg_path = tmpfile.name
+                tmpfile.write(svg_string.encode('utf-8'))
+            result = subprocess.run(["xdg-open", temp_svg_path], stderr=subprocess.DEVNULL)
+            if result.returncode != 0:
+                print("[ERROR] Failed to open the SVG file with the default viewer.")
+
     buffer = BytesIO()
     fig, ax = plt.subplots()
 
     for entry in functions:
+        # Each entry is something like {"x**2": {"x": "*", "a": ...}}
         if len(entry) != 1:
-            print("Skipping invalid item. Must have exactly 1 expression->substitutions pair.")
+            print("[WARNING] Skipping invalid item. Must have exactly 1 expression->substitutions pair.")
             continue
 
-        expression, sub_dict = list(entry.items())[0]
+        # Extract the expression string and substitutions
+        expression, sub_dict = next(iter(entry.items()))
+
+        # Check presence of "x"
         if "x" not in sub_dict:
-            print(f"Skipping '{expression}' because sub-dict lacks 'x' key.")
+            print(f"[WARNING] Skipping '{expression}' because there is no 'x' key.")
             continue
 
-        # If "x" is "*", create a default domain
         x_val = sub_dict["x"]
+
+        # 1) If x == "*", generate from -zoom..+zoom
         if isinstance(x_val, str) and x_val == "*":
             x_values = np.linspace(-zoom, zoom, 1201)
-            sub_dict["x"] = x_values
+            sub_dict["x"] = x_values  # might as well update it in place
+        # 2) If x is already a NumPy array, use as-is
         elif isinstance(x_val, np.ndarray):
             x_values = x_val
         else:
-            print(f"Skipping '{expression}' because 'x' is neither '*' nor a NumPy array.")
+            print(f"[WARNING] Skipping '{expression}' because 'x' is neither '*' nor a NumPy array.")
             continue
 
-        # Evaluate the expression
+        # Evaluate the expression with the variables from sub_dict
+        # We'll inject them into an eval() context, including 'np'
         try:
             eval_context = {"np": np}
+            # Put all user-provided variables (like a=1.23) in:
             eval_context.update(sub_dict)
             y_values = eval(expression, {"np": np}, eval_context)
         except Exception as e:
-            print(f"Error evaluating expression '{expression}': {e}")
+            print(f"[ERROR] Could not evaluate '{expression}' -> {e}")
             continue
 
+        # Check we got a NumPy array
         if not isinstance(y_values, np.ndarray):
-            print(f"Skipping '{expression}' because it did not produce a NumPy array.")
+            print(f"[WARNING] Skipping '{expression}' because it did not produce a NumPy array.")
             continue
 
-        # If y_values is shorter than x_values (like np.diff), truncate x
+        # If y is shorter (like np.diff), truncate x
         if len(y_values) < len(x_values):
             x_values = x_values[:len(y_values)]
 
-        # Convert expression to a nice LaTeX string
+        # Convert the expression to a LaTeX label
         label_expr = latexify_expression(expression)
         ax.plot(x_values, y_values, label=rf"${label_expr}$")
 
     # Configure axes
     ax.set_xlim(-zoom, zoom)
     ax.set_ylim(-zoom, zoom)
+
+    # Place spines at center
     ax.spines['left'].set_position('zero')
     ax.spines['bottom'].set_position('zero')
+    # Hide the right and top spines
     ax.spines['right'].set_color('none')
     ax.spines['top'].set_color('none')
-    ax.set_aspect('equal', 'box')
     ax.xaxis.set_ticks_position('bottom')
     ax.yaxis.set_ticks_position('left')
+
+    # Ensure equal aspect ratio
+    ax.set_aspect('equal', 'box')
     ax.grid(True)
 
-    # Show legend
+    # If requested, show the legend
     if show_legend:
         leg = ax.legend(
             loc='upper center',
@@ -837,13 +887,15 @@ def plot_polynomial_functions(
             shadow=True,
             ncol=1
         )
-        plt.savefig(
-            buffer,
-            format='svg',
-            bbox_inches='tight',
-            bbox_extra_artists=[leg]  # ensures the legend is fully captured
-        )
+        plt.savefig(buffer, format='svg', bbox_inches='tight', bbox_extra_artists=[leg])
     else:
         plt.savefig(buffer, format='svg', bbox_inches='tight')
+
     plt.close(fig)
-    return buffer.getvalue().decode('utf-8')
+    svg_string = buffer.getvalue().decode('utf-8')
+
+    # Optionally open/save the file
+    handle_open_and_save(svg_string, open_file, save_path)
+
+    return svg_string
+

{rgwfuncs-0.0.52 → rgwfuncs-0.0.54/src/rgwfuncs.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: rgwfuncs
-Version: 0.0.52
+Version: 0.0.54
 Summary: A functional programming paradigm for mathematical modelling and data science
 Home-page: https://github.com/ryangerardwilson/rgwfunc
 Author: Ryan Gerard Wilson
@@ -370,17 +370,17 @@ Converts a polynomial expression written in Python syntax to a LaTeX formatted s
 
 Expands a polynomial expression written in Python syntax and converts it into a LaTeX formatted string. This function takes algebraic expressions provided as strings using Python's syntax, applies polynomial expansion through SymPy, and translates them into LaTeX representations, suitable for academic or professional documentation. It supports expressions with named variables and provides an option to substitute specific values into the expression before expansion.
 
-- Parameters:
+• Parameters:
   - `expression` (str): The algebraic expression to expand and convert to LaTeX. This string should be formatted using Python syntax acceptable by SymPy.
   - `subs` (Optional[Dict[str, float]]): An optional dictionary of substitutions where the keys are variable names in the expression, and the values are the numbers with which to substitute those variables before expanding.
 
-- Returns:
+• Returns:
   - `str`: The LaTeX formatted string of the expanded expression.
 
-- Raises:
+• Raises:
   - `ValueError`: If the expression cannot be parsed due to syntax errors.
 
-- Example:
+• Example:
 
     from rgwfuncs import expand_polynomial_expression
 
@@ -406,17 +406,17 @@ Expands a polynomial expression written in Python syntax and converts it into a
 
 Factors a polynomial expression written in Python syntax and converts it into a LaTeX formatted string. This function parses an algebraic expression, performs polynomial factoring using SymPy, and converts the factored expression into a LaTeX representation, ideal for academic or professional use. Optional substitutions can be made before factoring.
 
-- Parameters:
+• Parameters:
   - `expression` (str): The polynomial expression to factor and convert to LaTeX. This should be a valid expression formatted using Python syntax.
   - `subs` (Optional[Dict[str, float]]): An optional dictionary of substitutions. The keys are variable names in the expression, and the values are numbers that replace these variables.
 
-- Returns:
+• Returns:
   - `str`: The LaTeX formatted string representing the factored expression.
 
-- Raises:
+• Raises:
   - `ValueError`: If the expression cannot be parsed due to syntax errors.
 
-- Example:
+• Example:
 
     from rgwfuncs import factor_polynomial_expression
 
@@ -441,7 +441,7 @@ Simplifies an algebraic expression in polynomial form and returns it in LaTeX fo
 • Returns:
   - `str`: The simplified expression formatted as a LaTeX string.
 
-• Example Usage:
+• Example:
 
     from rgwfuncs import simplify_polynomial_expression
 
@@ -467,17 +467,17 @@ Simplifies an algebraic expression in polynomial form and returns it in LaTeX fo
 
 Cancels common factors within a polynomial expression written in Python syntax and converts it to a LaTeX formatted string. This function parses an algebraic expression, cancels common factors using SymPy, and translates the reduced expression into a LaTeX representation. It can also accommodate optional substitutions to be made prior to simplification.
 
-- Parameters:
+• Parameters:
   - `expression` (str): The algebraic expression to simplify and convert to LaTeX. This string should be formatted using Python syntax.
   - `subs` (Optional[Dict[str, float]]): An optional dictionary of substitutions where the keys are variable names in the expression, and the values are the numbers to substitute.
 
-- Returns:
+• Returns:
   - `str`: The LaTeX formatted string of the simplified expression. If the expression involves indeterminate forms due to operations like division by zero, a descriptive error message is returned instead.
 
-- Raises:
+• Raises:
   - `ValueError`: If the expression cannot be parsed due to syntax errors or involves undefined operations, such as division by zero.
 
-- Example:
+• Example:
 
     from rgwfuncs import cancel_polynomial_expression
 
@@ -524,13 +524,14 @@ This function plots polynomial functions described by a list of expressions and
   - A value which is a dictionary containing substitutions for the expression. Must include an `"x"` key, either as `"*"` for default domain or a NumPy array.
 - `zoom` (`float`): Determines the numeric axis range from `-zoom` to `+zoom` for both x and y axes (default is `10.0`).
 - `show_legend` (`bool`): Specifies whether to include a legend in the plot (default is `True`).
+- `open_file` (`bool`): If saving to path is not desireable, opens the svg as a temp file, else opens the file from the actual location using the system's default viewer (defaults to False).
+- `save_path` (`Optional[str]`): If specified, saves the output string as a .svg at the indicated path (defaults to None).
 
 • Returns:
 - `str`: The raw SVG markup of the resulting plot.
 
 • Example:
 
-    import subprocess
     from rgwfuncs import plot_polynomial_functions
 
     # Generate the SVG