feat: modularize differential equations interfaces and add utility functions for parsing and evaluation

maths/differential_equations/differential_equations_interface.py

@@ -16,143 +16,76 @@ import math # To make math functions available in eval scope for ODEs
 # Import the solver functions
 from maths.differential_equations.solve_first_order_ode import solve_first_order_ode
 from maths.differential_equations.solve_second_order_ode import solve_second_order_ode
+from maths.differential_equations.ode_interface_utils import parse_float_list, parse_time_span, string_to_ode_func
 
 # --- Helper Functions ---
 
-def parse_float_list(input_str: str, expected_len: int = 0) -> List[float]:
-    """Parses a comma-separated string of floats into a list."""
-    try:
-        if not input_str.strip():
-            if expected_len > 0: # If expecting specific number, empty is error
-                 raise ValueError("Input string is empty.")
-            return [] # Allow empty list if not expecting specific length
-
-        parts = [float(p.strip()) for p in input_str.split(',') if p.strip()]
-        if expected_len > 0 and len(parts) != expected_len:
-            raise ValueError(f"Expected {expected_len} values, but got {len(parts)}.")
-        return parts
-    except ValueError as e:
-        raise gr.Error(f"Invalid format for list of numbers. Use comma-separated floats. Error: {e}")
-
-def parse_time_span(time_span_str: str) -> Tuple[float, float]:
-    """Parses a comma-separated string for time span (t_start, t_end)."""
-    parts = parse_float_list(time_span_str, expected_len=2)
-    if parts[0] >= parts[1]:
-        raise gr.Error("t_start must be less than t_end for the time span.")
-    return (parts[0], parts[1])
-
-def string_to_ode_func(lambda_str: str, expected_args: Tuple[str, ...]) -> Callable:
-    """
-    Converts a string representation of a Python lambda function into a callable.
-    Includes a basic check for 'lambda' keyword and argument count.
-
-    Args:
-        lambda_str: The string, e.g., "lambda t, y: -y" or "lambda t, y, dy_dt: -0.1*dy_dt -y".
-        expected_args: A tuple of expected argument names, e.g., ('t', 'y') or ('t', 'y', 'dy_dt').
-
-    Returns:
-        A callable function.
-    Raises:
-        gr.Error: If the string is not a valid lambda or has wrong argument structure.
-    """
-    lambda_str = lambda_str.strip()
-    if not lambda_str.startswith("lambda"):
-        raise gr.Error("ODE function must be a Python lambda string (e.g., 'lambda t, y: -y').")
-
-    try:
-        # Basic check for argument names within the lambda definition part (before ':')
-        # This is a heuristic and not a full AST parse for safety here, as eval is the main concern.
-        lambda_def_part = lambda_str.split(":")[0]
-        for arg_name in expected_args:
-            if arg_name not in lambda_def_part:
-                raise gr.Error(f"Lambda function string does not seem to contain expected argument: '{arg_name}'. Expected args: {expected_args}")
-
-        # The eval environment will have access to common math functions and numpy (np)
-        # This is where the security risk lies.
-        safe_eval_globals = {
-            "np": np,
-            "math": math,
-            "sin": math.sin, "cos": math.cos, "tan": math.tan,
-            "exp": math.exp, "log": math.log, "log10": math.log10,
-            "sqrt": math.sqrt, "fabs": math.fabs, "pow": math.pow,
-            "pi": math.pi, "e": math.e
-        }
-        # User must use 'math.func' or 'np.func' for most things not listed above.
-
-        func = eval(lambda_str, safe_eval_globals, {})
-        if not callable(func):
-            raise gr.Error("The provided string did not evaluate to a callable function.")
-        return func
-    except SyntaxError as se:
-        raise gr.Error(f"Syntax error in lambda function: {se}. Ensure it's valid Python syntax.")
-    except Exception as e:
-        raise gr.Error(f"Error evaluating lambda function string: {e}. Ensure it's a valid lambda returning the derivative(s).")
-
+# (Keep the helper functions here if needed, otherwise they can be removed as they are now in ode_interface_utils.py)
 
 # --- Gradio Interface for First-Order ODEs ---
-first_order_ode_interface = gr.Interface(
-    fn=lambda ode_str, t_span_str, y0_str, t_eval_count, method: solve_first_order_ode(
-        string_to_ode_func(ode_str, ('t', 'y')),
-        parse_time_span(t_span_str),
-        parse_float_list(y0_str), # y0 can be a list for systems
-        int(t_eval_count),
-        method
-    ),
-    inputs=[
-        gr.Textbox(label="ODE Function (lambda t, y: ...)",
-                   placeholder="e.g., lambda t, y: -y*t  OR for system lambda t, y: [y[1], -0.1*y[1] - y[0]]",
-                   info="Define dy/dt or a system [dy1/dt, dy2/dt,...]. `y` is a list/array for systems."),
-        gr.Textbox(label="Time Span (t_start, t_end)", placeholder="e.g., 0,10"),
-        gr.Textbox(label="Initial Condition(s) y(t_start)", placeholder="e.g., 1 OR for system 1,0"),
-        gr.Slider(minimum=10, maximum=1000, value=100, step=10, label="Evaluation Points Count"),
-        gr.Radio(choices=['RK45', 'LSODA', 'BDF', 'RK23', 'DOP853'], value='RK45', label="Solver Method")
-    ],
-    outputs=[
-        gr.Image(label="Solution Plot", type="filepath", show_label=True, visible=lambda res: res['success'] and res['plot_path'] is not None),
-        gr.Textbox(label="Solver Message"),
-        gr.Textbox(label="Success Status"),
-        gr.JSON(label="Raw Data (t, y values)", visible=lambda res: res['success']) # For users to copy if needed
-    ],
-    title="First-Order ODE Solver",
-    description="Solves dy/dt = f(t,y) or a system of first-order ODEs. " \
-                "WARNING: Uses eval() for the ODE function string - potential security risk. " \
-                "For systems, `y` in lambda is `[y1, y2, ...]`, return `[dy1/dt, dy2/dt, ...]`. " \
-                "Example (Damped Oscillator): ODE: lambda t, y: [y[1], -0.5*y[1] - y[0]], y0: 1,0, Timespan: 0,20",
-    flagging_mode="manual"
-)
-
-# --- Gradio Interface for Second-Order ODEs ---
-second_order_ode_interface = gr.Interface(
-    fn=lambda ode_str, t_span_str, y0_val_str, dy0_dt_val_str, t_eval_count, method: solve_second_order_ode(
-        string_to_ode_func(ode_str, ('t', 'y', 'dy_dt')), # Note: dy_dt is one variable name here
-        parse_time_span(t_span_str),
-        parse_float_list(y0_val_str, expected_len=1)[0], # y0 is a single float
-        parse_float_list(dy0_dt_val_str, expected_len=1)[0], # dy0_dt is a single float
-        int(t_eval_count),
-        method
-    ),
-    inputs=[
-        gr.Textbox(label="ODE Function (lambda t, y, dy_dt: ...)",
-                   placeholder="e.g., lambda t, y, dy_dt: -0.1*dy_dt - math.sin(y)",
-                   info="Define d²y/dt². `y` is current value, `dy_dt` is current first derivative."),
-        gr.Textbox(label="Time Span (t_start, t_end)", placeholder="e.g., 0,20"),
-        gr.Textbox(label="Initial y(t_start)", placeholder="e.g., 1.0"),
-        gr.Textbox(label="Initial dy/dt(t_start)", placeholder="e.g., 0.0"),
-        gr.Slider(minimum=10, maximum=1000, value=100, step=10, label="Evaluation Points Count"),
-        gr.Radio(choices=['RK45', 'LSODA', 'BDF', 'RK23', 'DOP853'], value='RK45', label="Solver Method")
-    ],
-    outputs=[
-        gr.Image(label="Solution Plot (y(t) and dy/dt(t))", type="filepath", show_label=True, visible=lambda res: res['success'] and res['plot_path'] is not None),
-        gr.Textbox(label="Solver Message"),
-        gr.Textbox(label="Success Status"),
-        gr.JSON(label="Raw Data (t, y, dy_dt values)", visible=lambda res: res['success'])
-    ],
-    title="Second-Order ODE Solver",
-    description="Solves d²y/dt² = f(t, y, dy/dt). " \
-                "WARNING: Uses eval() for the ODE function string - potential security risk. " \
-                "Example (Pendulum): ODE: lambda t, y, dy_dt: -9.81/1.0 * math.sin(y), y0: math.pi/4, dy0/dt: 0, Timespan: 0,10",
-    flagging_mode="manual"
-)
+# first_order_ode_interface = gr.Interface(
+#     fn=lambda ode_str, t_span_str, y0_str, t_eval_count, method: solve_first_order_ode(
+#         string_to_ode_func(ode_str, ('t', 'y')),
+#         parse_time_span(t_span_str),
+#         parse_float_list(y0_str), # y0 can be a list for systems
+#         int(t_eval_count),
+#         method
+#     ),
+#     inputs=[
+#         gr.Textbox(label="ODE Function (lambda t, y: ...)",
+#                    placeholder="e.g., lambda t, y: -y*t  OR for system lambda t, y: [y[1], -0.1*y[1] - y[0]]",
+#                    info="Define dy/dt or a system [dy1/dt, dy2/dt,...]. `y` is a list/array for systems."),
+#         gr.Textbox(label="Time Span (t_start, t_end)", placeholder="e.g., 0,10"),
+#         gr.Textbox(label="Initial Condition(s) y(t_start)", placeholder="e.g., 1 OR for system 1,0"),
+#         gr.Slider(minimum=10, maximum=1000, value=100, step=10, label="Evaluation Points Count"),
+#         gr.Radio(choices=['RK45', 'LSODA', 'BDF', 'RK23', 'DOP853'], value='RK45', label="Solver Method")
+#     ],
+#     outputs=[
+#         gr.Image(label="Solution Plot", type="filepath", show_label=True, visible=lambda res: res['success'] and res['plot_path'] is not None),
+#         gr.Textbox(label="Solver Message"),
+#         gr.Textbox(label="Success Status"),
+#         gr.JSON(label="Raw Data (t, y values)", visible=lambda res: res['success']) # For users to copy if needed
+#     ],
+#     title="First-Order ODE Solver",
+#     description="Solves dy/dt = f(t,y) or a system of first-order ODEs. " \
+#                 "WARNING: Uses eval() for the ODE function string - potential security risk. " \
+#                 "For systems, `y` in lambda is `[y1, y2, ...]`, return `[dy1/dt, dy2/dt, ...]`. " \
+#                 "Example (Damped Oscillator): ODE: lambda t, y: [y[1], -0.5*y[1] - y[0]], y0: 1,0, Timespan: 0,20",
+#     flagging_mode="manual"
+# )
+
+# # --- Gradio Interface for Second-Order ODEs ---
+# second_order_ode_interface = gr.Interface(
+#     fn=lambda ode_str, t_span_str, y0_val_str, dy0_dt_val_str, t_eval_count, method: solve_second_order_ode(
+#         string_to_ode_func(ode_str, ('t', 'y', 'dy_dt')), # Note: dy_dt is one variable name here
+#         parse_time_span(t_span_str),
+#         parse_float_list(y0_val_str, expected_len=1)[0], # y0 is a single float
+#         parse_float_list(dy0_dt_val_str, expected_len=1)[0], # dy0_dt is a single float
+#         int(t_eval_count),
+#         method
+#     ),
+#     inputs=[
+#         gr.Textbox(label="ODE Function (lambda t, y, dy_dt: ...)",
+#                    placeholder="e.g., lambda t, y, dy_dt: -0.1*dy_dt - math.sin(y)",
+#                    info="Define d²y/dt². `y` is current value, `dy_dt` is current first derivative."),
+#         gr.Textbox(label="Time Span (t_start, t_end)", placeholder="e.g., 0,20"),
+#         gr.Textbox(label="Initial y(t_start)", placeholder="e.g., 1.0"),
+#         gr.Textbox(label="Initial dy/dt(t_start)", placeholder="e.g., 0.0"),
+#         gr.Slider(minimum=10, maximum=1000, value=100, step=10, label="Evaluation Points Count"),
+#         gr.Radio(choices=['RK45', 'LSODA', 'BDF', 'RK23', 'DOP853'], value='RK45', label="Solver Method")
+#     ],
+#     outputs=[
+#         gr.Image(label="Solution Plot (y(t) and dy/dt(t))", type="filepath", show_label=True, visible=lambda res: res['success'] and res['plot_path'] is not None),
+#         gr.Textbox(label="Solver Message"),
+#         gr.Textbox(label="Success Status"),
+#         gr.JSON(label="Raw Data (t, y, dy_dt values)", visible=lambda res: res['success'])
+#     ],
+#     title="Second-Order ODE Solver",
+#     description="Solves d²y/dt² = f(t, y, dy/dt). " \
+#                 "WARNING: Uses eval() for the ODE function string - potential security risk. " \
+#                 "Example (Pendulum): ODE: lambda t, y, dy_dt: -9.81/1.0 * math.sin(y), y0: math.pi/4, dy0/dt: 0, Timespan: 0,10",
+#     flagging_mode="manual"
+# )
 
 # Example usage for testing (can be removed)
 if __name__ == '__main__':

maths/differential_equations/differential_equations_tab.py

@@ -1,7 +1,6 @@
 import gradio as gr
-from maths.differential_equations.differential_equations_interface import (
-    first_order_ode_interface, second_order_ode_interface
-)
+from maths.differential_equations.solve_first_order_ode import first_order_ode_interface
+from maths.differential_equations.solve_second_order_ode import second_order_ode_interface
 
 differential_equations_interfaces_list = [first_order_ode_interface, second_order_ode_interface]
 differential_equations_tab_names = ["First Order ODE", "Second Order ODE"]

maths/differential_equations/ode_interface_utils.py

@@ -0,0 +1,52 @@
+"""
+Helper functions for parsing and ODE lambda string evaluation for ODE solvers.
+"""
+import gradio as gr
+import numpy as np
+from typing import List, Tuple, Callable
+import math
+
+def parse_float_list(input_str: str, expected_len: int = 0) -> List[float]:
+    try:
+        if not input_str.strip():
+            if expected_len > 0:
+                raise ValueError("Input string is empty.")
+            return []
+        parts = [float(p.strip()) for p in input_str.split(',') if p.strip()]
+        if expected_len > 0 and len(parts) != expected_len:
+            raise ValueError(f"Expected {expected_len} values, but got {len(parts)}.")
+        return parts
+    except ValueError as e:
+        raise gr.Error(f"Invalid format for list of numbers. Use comma-separated floats. Error: {e}")
+
+def parse_time_span(time_span_str: str) -> Tuple[float, float]:
+    parts = parse_float_list(time_span_str, expected_len=2)
+    if parts[0] >= parts[1]:
+        raise gr.Error("t_start must be less than t_end for the time span.")
+    return (parts[0], parts[1])
+
+def string_to_ode_func(lambda_str: str, expected_args: Tuple[str, ...]) -> Callable:
+    lambda_str = lambda_str.strip()
+    if not lambda_str.startswith("lambda"):
+        raise gr.Error("ODE function must be a Python lambda string (e.g., 'lambda t, y: -y').")
+    try:
+        lambda_def_part = lambda_str.split(":")[0]
+        for arg_name in expected_args:
+            if arg_name not in lambda_def_part:
+                raise gr.Error(f"Lambda function string does not seem to contain expected argument: '{arg_name}'. Expected args: {expected_args}")
+        safe_eval_globals = {
+            "np": np,
+            "math": math,
+            "sin": math.sin, "cos": math.cos, "tan": math.tan,
+            "exp": math.exp, "log": math.log, "log10": math.log10,
+            "sqrt": math.sqrt, "fabs": math.fabs, "pow": math.pow,
+            "pi": math.pi, "e": math.e
+        }
+        func = eval(lambda_str, safe_eval_globals, {})
+        if not callable(func):
+            raise gr.Error("The provided string did not evaluate to a callable function.")
+        return func
+    except SyntaxError as se:
+        raise gr.Error(f"Syntax error in lambda function: {se}. Ensure it's valid Python syntax.")
+    except Exception as e:
+        raise gr.Error(f"Error evaluating lambda function string: {e}. Ensure it's a valid lambda returning the derivative(s).")

maths/differential_equations/solve_second_order_ode.py

@@ -6,6 +6,8 @@ import numpy as np
 from scipy.integrate import solve_ivp
 from typing import Callable, List, Tuple, Dict, Any, Union
 import matplotlib.pyplot as plt
+from maths.differential_equations.ode_interface_utils import parse_float_list, parse_time_span, string_to_ode_func
+import gradio as gr
 
 def solve_second_order_ode(
     ode_func_second_order: Callable[[float, float, float], float],
@@ -74,3 +76,36 @@ def solve_second_order_ode(
             'success': False,
             'plot_path': None
         }
+
+# --- Gradio Interface for Second-Order ODEs ---
+second_order_ode_interface = gr.Interface(
+    fn=lambda ode_str, t_span_str, y0_val_str, dy0_dt_val_str, t_eval_count, method: solve_second_order_ode(
+        string_to_ode_func(ode_str, ('t', 'y', 'dy_dt')),
+        parse_time_span(t_span_str),
+        parse_float_list(y0_val_str, expected_len=1)[0],
+        parse_float_list(dy0_dt_val_str, expected_len=1)[0],
+        int(t_eval_count),
+        method
+    ),
+    inputs=[
+        gr.Textbox(label="ODE Function (lambda t, y, dy_dt: ...)",
+                   placeholder="e.g., lambda t, y, dy_dt: -0.1*dy_dt - math.sin(y)",
+                   info="Define d²y/dt². `y` is current value, `dy_dt` is current first derivative."),
+        gr.Textbox(label="Time Span (t_start, t_end)", placeholder="e.g., 0,20"),
+        gr.Textbox(label="Initial y(t_start)", placeholder="e.g., 1.0"),
+        gr.Textbox(label="Initial dy/dt(t_start)", placeholder="e.g., 0.0"),
+        gr.Slider(minimum=10, maximum=1000, value=100, step=10, label="Evaluation Points Count"),
+        gr.Radio(choices=['RK45', 'LSODA', 'BDF', 'RK23', 'DOP853'], value='RK45', label="Solver Method")
+    ],
+    outputs=[
+        gr.Image(label="Solution Plot (y(t) and dy/dt(t))", type="filepath", show_label=True, visible=lambda res: res['success'] and res['plot_path'] is not None),
+        gr.Textbox(label="Solver Message"),
+        gr.Textbox(label="Success Status"),
+        gr.JSON(label="Raw Data (t, y, dy_dt values)", visible=lambda res: res['success'])
+    ],
+    title="Second-Order ODE Solver",
+    description="Solves d²y/dt² = f(t, y, dy/dt). "
+                "WARNING: Uses eval() for the ODE function string - potential security risk. "
+                "Example (Pendulum): ODE: lambda t, y, dy_dt: -9.81/1.0 * math.sin(y), y0: math.pi/4, dy0/dt: 0, Timespan: 0,10",
+    flagging_mode="manual"
+)