rgwfuncs 0.0.101__py3-none-any.whl → 0.0.106__py3-none-any.whl

rgwfuncs/__init__.py

@@ -3,6 +3,5 @@
 
 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, load_fresh_data_or_pull_from_cache, 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 .interactive_shell_lib import interactive_shell
-from .algebra_lib import cancel_polynomial_expression, compute_constant_expression, compute_constant_expression_involving_matrices, compute_constant_expression_involving_ordered_series, compute_prime_factors, expand_polynomial_expression, factor_polynomial_expression, plot_polynomial_functions, plot_x_points_of_polynomial_functions, python_polynomial_expression_to_latex, simplify_polynomial_expression, solve_homogeneous_polynomial_expression
 from .docs_lib import docs
-from .str_lib import send_telegram_message
+from .str_lib import heading, send_telegram_message, sub_heading, title

rgwfuncs/interactive_shell_lib.py

@@ -7,7 +7,6 @@ import os
 import atexit
 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
 

rgwfuncs/str_lib.py

@@ -1,12 +1,21 @@
+import sys
+import time
 import os
 import json
 import requests
 from typing import Tuple, Optional, Union, Dict
+from collections import defaultdict
 import warnings
+from pyfiglet import Figlet
+from datetime import datetime
 
 # Suppress all FutureWarnings
 warnings.filterwarnings("ignore", category=FutureWarning)
 
+# Module-level variables
+_PRINT_HEADING_CURRENT_CALL = 0
+_PRINT_SUBHEADING_COUNTS = defaultdict(int)  # Tracks sub-headings per heading
+_CURRENT_HEADING_NUMBER = 0
 
 def send_telegram_message(preset_name: str, message: str, config: Optional[Union[str, dict]] = None) -> None:
     """
@@ -104,3 +113,164 @@ def send_telegram_message(preset_name: str, message: str, config: Optional[Union
     # Send the message
     response = requests.post(url, json=payload)
     response.raise_for_status()
+
+def title(text: str, font: str = "slant", typing_speed: float = 0.005) -> None:
+    """
+    Print text as ASCII art with a typewriter effect using the specified font (default: slant),
+    indented by 4 spaces. All output, including errors and separators, is printed with the
+    typewriter effect within this function.
+
+    Args:
+        text (str): The text to convert to ASCII art.
+        font (str, optional): The pyfiglet font to use. Defaults to "slant".
+        typing_speed (float, optional): Delay between printing each character in seconds.
+                                      Defaults to 0.005.
+
+    Raises:
+        ValueError: If the specified font is invalid or unavailable.
+        RuntimeError: If there is an error generating the ASCII art.
+    """
+    # ANSI color codes
+    heading_color = '\033[92m'  # Bright green for headings
+    reset_color = '\033[0m'     # Reset to default
+
+    try:
+        # Initialize Figlet with the specified font
+        figlet = Figlet(font=font)
+        # Generate ASCII art
+        ascii_art = figlet.renderText(text)
+        # Indent each line by 4 spaces
+        indented_ascii_art = '\n'.join('    ' + line for line in ascii_art.splitlines())
+
+        # Print ASCII art with typewriter effect
+        print(heading_color, end='')
+        for char in indented_ascii_art + '\n':
+            print(char, end='', flush=True)
+            if char != '\n':  # Don't delay on newlines
+                time.sleep(typing_speed)
+        print(reset_color, end='')
+
+        # Print separator line with typewriter effect
+        print(heading_color, end='')
+        for char in '=' * 79 + '\n':
+            print(char, end='', flush=True)
+            if char != '\n':
+                time.sleep(typing_speed)
+        print(reset_color, end='')
+
+    except Exception as e:
+        error_msg = ''
+        if "font" in str(e).lower():
+            error_msg = f"Invalid or unavailable font: {font}. Ensure the font is supported by pyfiglet.\n"
+            print(reset_color, end='')
+            for char in error_msg:
+                print(char, end='', flush=True)
+                if char != '\n':
+                    time.sleep(typing_speed)
+            raise ValueError(error_msg)
+        error_msg = f"Error generating ASCII art for \"{text}\" with font {font}: {e}\n"
+        print(reset_color, end='')
+        for char in error_msg:
+            print(char, end='', flush=True)
+            if char != '\n':
+                time.sleep(typing_speed)
+        raise RuntimeError(error_msg)
+
+def heading(text: str, typing_speed: float = 0.005) -> None:
+    """
+    Print a heading with the specified text in uppercase,
+    formatted as '[current_call] TEXT' with a timestamp and typewriter effect.
+    Ensures the formatted heading is <= 50 characters and total line is 79 characters.
+    Adds empty lines before and after the heading.
+
+    Args:
+        text (str): The heading text to print.
+        typing_speed (float, optional): Delay between printing each character in seconds.
+                                      Defaults to 0.005.
+    """
+    global _PRINT_HEADING_CURRENT_CALL, _CURRENT_HEADING_NUMBER, _PRINT_SUBHEADING_COUNTS
+
+    # Increment heading call
+    _PRINT_HEADING_CURRENT_CALL += 1
+    _CURRENT_HEADING_NUMBER = _PRINT_HEADING_CURRENT_CALL
+    _PRINT_SUBHEADING_COUNTS[_CURRENT_HEADING_NUMBER] = 0  # Reset sub-heading count
+
+    # ANSI color codes
+    color = '\033[92m'  # Bright green for headings
+    reset_color = '\033[0m'
+
+    # Format heading
+    prefix = f"[{_PRINT_HEADING_CURRENT_CALL}] "
+    max_text_length = 50 - len(prefix)
+    formatted_text = text.upper()[:max_text_length]
+    heading = f"{prefix}{formatted_text}"
+
+    # Get timestamp
+    timestamp = f"[{datetime.now().strftime('%Y-%m-%d %H:%M:%S')}]"
+
+    # Calculate padding
+    padding_length = 79 - len(heading) - 1 - len(timestamp) - 1  # Spaces before padding and timestamp
+    padding = '=' * padding_length if padding_length > 0 else ''
+    full_line = f"{heading} {padding} {timestamp}"
+
+    # Print with line breaks and typewriter effect
+    print()  # Empty line before
+    print(color, end='')
+    for char in full_line + '\n':
+        print(char, end='', flush=True)
+        if char != '\n':
+            time.sleep(typing_speed)
+    print(reset_color, end='')
+    print()  # Empty line after
+
+def sub_heading(text: str, typing_speed: float = 0.005) -> None:
+    """
+    Print a sub-heading under the most recent heading, formatted as
+    '[heading_num.sub_heading_num] TEXT' with a timestamp and typewriter effect.
+    Ensures the formatted sub-heading is <= 50 characters and total line is 79 characters.
+    Adds empty lines before and after the sub-heading.
+
+    Args:
+        text (str): The sub-heading text to print.
+        typing_speed (float, optional): Delay between printing each character in seconds.
+                                      Defaults to 0.005.
+
+    Raises:
+        ValueError: If no heading has been called.
+    """
+    global _PRINT_SUBHEADING_COUNTS, _CURRENT_HEADING_NUMBER
+
+    if _CURRENT_HEADING_NUMBER == 0:
+        raise ValueError("No heading called before sub_heading.")
+
+    # Increment sub-heading count
+    _PRINT_SUBHEADING_COUNTS[_CURRENT_HEADING_NUMBER] += 1
+    current_sub = _PRINT_SUBHEADING_COUNTS[_CURRENT_HEADING_NUMBER]
+
+    # ANSI color codes
+    color = '\033[92m'  # Bright green for sub-headings
+    reset_color = '\033[0m'
+
+    # Format sub-heading
+    prefix = f"[{_CURRENT_HEADING_NUMBER}.{current_sub}] "
+    max_text_length = 50 - len(prefix)
+    formatted_text = text.lower()[:max_text_length]
+    sub_heading = f"{prefix}{formatted_text}"
+
+    # Get timestamp
+    timestamp = f"[{datetime.now().strftime('%Y-%m-%d %H:%M:%S')}]"
+
+    # Calculate padding
+    padding_length = 79 - len(sub_heading) - 1 - len(timestamp) - 1  # Spaces before padding and timestamp
+    padding = '-' * padding_length if padding_length > 0 else ''
+    full_line = f"{sub_heading} {padding} {timestamp}"
+
+    # Print with line breaks and typewriter effect
+    print()  # Empty line before
+    print(color, end='')
+    for char in full_line + '\n':
+        print(char, end='', flush=True)
+        if char != '\n':
+            time.sleep(typing_speed)
+    print(reset_color, end='')
+    print()  # Empty line after

{rgwfuncs-0.0.101.dist-info → rgwfuncs-0.0.106.dist-info}/METADATA

@@ -1,8 +1,8 @@
 Metadata-Version: 2.4
 Name: rgwfuncs
-Version: 0.0.101
+Version: 0.0.106
 Summary: A functional programming paradigm for mathematical modelling and data science
-Home-page: https://github.com/ryangerardwilson/rgwfunc
+Home-page: https://github.com/ryangerardwilson/rgwfuncs
 Author: Ryan Gerard Wilson
 Author-email: Ryan Gerard Wilson <ryangerardwilson@gmail.com>
 Project-URL: Homepage, https://github.com/ryangerardwilson/rgwfuncs
@@ -24,16 +24,18 @@ Requires-Dist: requests
 Requires-Dist: slack-sdk
 Requires-Dist: google-api-python-client
 Requires-Dist: boto3
+Requires-Dist: pyfiglet
 Dynamic: license-file
 
 # RGWFUNCS
 
 ***By Ryan Gerard Wilson (https://ryangerardwilson.com)***
 
+`rgwfuncs` keeps your Python data science and ML code clean by avoiding types defined in external libraries. Foreign types make debugging a nightmare—rgwfuncs uses functional and procedural paradigms, ensuring your types stay local and under your control.
 
-This library is meant to protect your eyes (and brain) from OOP syntax. It is unbelievably sad that some of the best work done in creating math and data science libraries in Python has been corrupted by the OOP mind-virus. 
+It wraps complex data science patterns into clear, reusable functions with well-defined, type-casted returns. No wrestling with weird objects you don’t have time to decipher—just simple, predictable outputs that make your life easier. You get the power of Python’s best libraries without the headache of their opaque classes.
 
-By creating a functional-programming wrapper around these libraries, we aim to soothe. This library assumes a Linux environment and the existence of a `.rgwfuncsrc` file for certain features (like database querying, sending data to Slack, etc.).
+Built for Linux, some features (like database queries or Slack integration) require a .rgwfuncsrc file. With rgwfuncs, your code is debug-friendly, maintainable, and refreshingly straightforward—because type-casted functions beat cryptic objects every time.
 
 --------------------------------------------------------------------------------
 
@@ -47,7 +49,7 @@ Install the package using:
 
 ## Create a `.rgwfuncsrc` File
 
-A `.rgwfuncsrc` file (located at `vi ~/.rgwfuncsrc) is required for MSSQL, CLICKHOUSE, MYSQL, GOOGLE BIG QUERY, SLACK, TELEGRAM, and GMAIL integrations.
+A `.rgwfuncsrc` file (located in the current, or any parent directory) is required for MSSQL, CLICKHOUSE, MYSQL, GOOGLE BIG QUERY, SLACK, TELEGRAM, and GMAIL integrations.
 
     {
       "db_presets" : [
@@ -218,410 +220,6 @@ Subsequently, in the interactive shell you can use any library in your python fi
 
 --------------------------------------------------------------------------------
 
-## 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.
-
-### 1. `compute_prime_factors`
-
-Computes prime factors of a number and presents them in LaTeX format.
-
-• Parameters:
-  - `n` (int): The integer to factorize.
-
-• Returns:
-  - `str`: Prime factorization in LaTeX.
-
-• Example:
-
-    from rgwfuncs import compute_prime_factors
-    factors_1 = compute_prime_factors(100)
-    print(factors_1)  # Output: "2^{2} \cdot 5^{2}"
-
-    factors_2 = compute_prime_factors(60)
-    print(factors_2)  # Output: "2^{2} \cdot 3 \cdot 5"
-
-    factors_3 = compute_prime_factors(17)
-    print(factors_3)  # Output: "17"
-
---------------------------------------------------------------------------------
-
-### 2. `compute_constant_expression`
-
-Computes the numerical result of a given expression, which can evaluate to a constant, represented as a float. Evaluates an constant expression provided as a string and returns the computed result. Supports various arithmetic operations, including addition, subtraction, multiplication, division, and modulo, as well as mathematical functions from the math module.
-
-• Parameters:
-  - `expression` (str): The constant expression to compute. This should be a string consisting of arithmetic operations and Python's math module functions.
-
-• Returns:
-  - `float`: The computed numerical result.
-
-• Example:
-
-    from rgwfuncs import compute_constant_expression
-    result1 = compute_constant_expression("2 + 2")
-    print(result1)  # Output: 4.0
-
-    result2 = compute_constant_expression("10 % 3")
-    print(result2)  # Output: 1.0
-
-    result3 = compute_constant_expression("math.gcd(36, 60) * math.sin(math.radians(45)) * 10000")
-    print(result3)  # Output: 84852.8137423857
-
---------------------------------------------------------------------------------
-
-### 3. `compute_constant_expression_involving_matrices`
-
-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 "+", "-", "*", "/".
-
-• Returns:
-  - `str`: The LaTeX-formatted string representation of the computed matrix, or an error message if the operations cannot be performed due to dimensional mismatches.
-
-• Example:
-
-    from rgwfuncs import compute_constant_expression_involving_matrices
-
-    # Example with addition of 2D matrices
-    result = compute_constant_expression_involving_matrices("[[2, 6, 9], [1, 3, 5]] + [[1, 2, 3], [4, 5, 6]]")
-    print(result)  # Output: \begin{bmatrix}3 & 8 & 12\\5 & 8 & 11\end{bmatrix}
-
-    # Example of mixed operations with 1D matrices treated as 2D
-    result = compute_constant_expression_involving_matrices("[3, 6, 9] + [1, 2, 3] - [2, 2, 2]")
-    print(result)  # Output: \begin{bmatrix}2 & 6 & 10\end{bmatrix}
-
-    # Example with dimension mismatch
-    result = compute_constant_expression_involving_matrices("[[4, 3, 51]] + [[1, 1]]")
-    print(result)  # Output: Operations between matrices must involve matrices of the same dimension
-
---------------------------------------------------------------------------------
-
-### 4. `compute_constant_expression_involving_ordered_series`
-
-Computes the result of a constant expression involving ordered series, and returns it as a Latex string. 
-
-
-• Parameters:
-  - `expression` (str): A series operation expression. Supports operations such as "+", "-", "*", "/", and `dd()` for discrete differences.
-
-• Returns:
-  - `str`: The string representation of the resultant series after performing operations, or an error message if series lengths do not match.
-
-• Example:
-
-    from rgwfuncs import compute_constant_expression_involving_ordered_series
-
-    # Example with addition and discrete differences
-    result = compute_constant_expression_involving_ordered_series("dd([2, 6, 9, 60]) + dd([78, 79, 80])")
-    print(result)  # Output: [4, 3, 51] + [1, 1]
-
-    # Example with elementwise subtraction
-    result = compute_constant_expression_involving_ordered_series("[10, 15, 21] - [5, 5, 5]")
-    print(result)  # Output: [5, 10, 16]
-
-    # Example with length mismatch
-    result = compute_constant_expression_involving_ordered_series("[4, 3, 51] + [1, 1]")
-    print(result)  # Output: Operations between ordered series must involve series of equal length
-
---------------------------------------------------------------------------------
-
-### 5. `python_polynomial_expression_to_latex`
-
-Converts a polynomial expression written in Python syntax to a LaTeX formatted string. This function parses algebraic expressions provided as strings using Python’s syntax and translates them into equivalent LaTeX representations, making them suitable for academic or professional documentation. The function supports inclusion of named variables, with an option to substitute specific values into the expression.
-
-• Parameters:
-  - `expression` (str): The algebraic expression to convert to LaTeX. This should be a string formatted with 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.
-
-• Returns:
-  - `str`: The LaTeX formatted string equivalent to the provided expression.
-
-• Raises:
-  - `ValueError`: If the expression cannot be parsed due to syntax errors.
-
-• Example:
-
-    from rgwfuncs import python_polynomial_expression_to_latex
-    
-    # Convert a simple polynomial expression to LaTeX format
-    latex_result1 = python_polynomial_expression_to_latex("x**2 + y**2")
-    print(latex_result1)  # Output: "x^{2} + y^{2}"
-    
-    # Convert polynomial expression with substituted values
-    latex_result2 = python_polynomial_expression_to_latex("x**2 + y**2", {"x": 3, "y": 4})
-    print(latex_result2)  # Output: "25"
-    
-    # Another example with partial substitution
-    latex_result3 = python_polynomial_expression_to_latex("x**2 + y**2", {"x": 3})
-    print(latex_result3)  # Output: "y^{2} + 9"
-    
-    # Trigonometric functions included with symbolic variables
-    latex_result4 = python_polynomial_expression_to_latex("sin(x+z**2) + cos(y)", {"x": 55})
-    print(latex_result4)  # Output: "cos y + sin \\left(z^{2} + 55\\right)"
-    
-    # Simplified trigonometric functions example with substitution
-    latex_result5 = python_polynomial_expression_to_latex("sin(x) + cos(y)", {"x": 0})
-    print(latex_result5)  # Output: "cos y"
-
---------------------------------------------------------------------------------
-
-### 6. `expand_polynomial_expression`
-
-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:
-  - `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:
-  - `str`: The LaTeX formatted string of the expanded expression.
-
-• Raises:
-  - `ValueError`: If the expression cannot be parsed due to syntax errors.
-
-• Example:
-
-    from rgwfuncs import expand_polynomial_expression
-
-    # Expand a simple polynomial expression and convert to LaTeX
-    latex_result1 = expand_polynomial_expression("(x + y)**2")
-    print(latex_result1)  # Output: "x^{2} + 2 x y + y^{2}"
-
-    # Expand polynomial expression with substituted values
-    latex_result2 = expand_polynomial_expression("(x + y)**2", {"x": 3, "y": 4})
-    print(latex_result2)  # Output: "49"
-
-    # Another example with partial substitution
-    latex_result3 = expand_polynomial_expression("(x + y)**2", {"x": 3})
-    print(latex_result3)  # Output: "y^{2} + 6 y + 9"
-
-    # Handling trigonometric functions with symbolic variables
-    latex_result4 = expand_polynomial_expression("sin(x + z**2) + cos(y)", {"x": 55})
-    print(latex_result4)  # Output: "cos y + sin \\left(z^{2} + 55\\right)"
-
---------------------------------------------------------------------------------
-
-### 7. `factor_polynomial_expression`
-
-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:
-  - `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:
-  - `str`: The LaTeX formatted string representing the factored expression.
-
-• Raises:
-  - `ValueError`: If the expression cannot be parsed due to syntax errors.
-
-• Example:
-
-    from rgwfuncs import factor_polynomial_expression
-
-    # Factor a polynomial expression and convert to LaTeX
-    latex_result1 = factor_polynomial_expression("x**2 - 4")
-    print(latex_result1)  # Output: "\left(x - 2\right) \left(x + 2\right)"
-
-    # Factor with substituted values
-    latex_result2 = factor_polynomial_expression("x**2 - y**2", {"y": 3})
-    print(latex_result2)  # Output: "\left(x - 3\right) \left(x + 3\right)"
-
---------------------------------------------------------------------------------
-
-### 8. `simplify_polynomial_expression`
-
-Simplifies an algebraic expression in polynomial form and returns it in LaTeX format. Takes an algebraic expression, in polynomial form, written in Python syntax and simplifies it. The result is returned as a LaTeX formatted string, suitable for academic or professional documentation.
-
-• Parameters:
-  - `expression` (str): The algebraic expression, in polynomial form, to simplify. For instance, the expression 'np.diff(8*x**30) where as 'np.diff([2,5,9,11)' is not a polynomial.
-  - `subs` (Optional[Dict[str, float]]): An optional dictionary of substitutions where keys are variable names and values are the numbers to substitute them with.
-
-• Returns:
-  - `str`: The simplified expression formatted as a LaTeX string.
-
-• Example:
-
-    from rgwfuncs import simplify_polynomial_expression
-
-    # Example 1: Simplifying a polynomial expression without substitutions
-    simplified_expr1 = simplify_polynomial_expression("2*x + 3*x")
-    print(simplified_expr1)  # Output: "5 x"
-
-    # Example 2: Simplifying a complex expression involving derivatives
-    simplified_expr2 = simplify_polynomial_expression("(np.diff(3*x**8)) / (np.diff(8*x**30) * 11*y**3)")
-    print(simplified_expr2)  # Output: r"\frac{1}{110 x^{22} y^{3}}"
-
-    # Example 3: Simplifying with substitutions
-    simplified_expr3 = simplify_polynomial_expression("x**2 + y**2", subs={"x": 3, "y": 4})
-    print(simplified_expr3)  # Output: "25"
-
-    # Example 4: Simplifying with partial substitution
-    simplified_expr4 = simplify_polynomial_expression("a*b + b", subs={"b": 2})
-    print(simplified_expr4)  # Output: "2 a + 2"
-
---------------------------------------------------------------------------------
-
-### 9. `cancel_polynomial_expression`
-
-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:
-  - `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:
-  - `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:
-  - `ValueError`: If the expression cannot be parsed due to syntax errors or involves undefined operations, such as division by zero.
-
-• Example:
-
-    from rgwfuncs import cancel_polynomial_expression
-
-    # Cancel common factors within a polynomial expression
-    latex_result1 = cancel_polynomial_expression("(x**2 - 4) / (x - 2)")
-    print(latex_result1)  # Output: "x + 2"
-
-    # Cancel with substituted values
-    latex_result2 = cancel_polynomial_expression("(x**2 - 4) / (x - 2)", {"x": 2})
-    print(latex_result2)  # Output: "Undefined result. This could be a division by zero error."
-
---------------------------------------------------------------------------------
-
-### 10. `solve_homogeneous_polynomial_expression`
-
-Solves a homogeneous polynomial expression for a specified variable and returns solutions in LaTeX format. Assumes that the expression is homoegeneous (i.e. equal to zero), and solves for a designated variable. May optionally include substitutions for other variables in the equation. The solutions are provided as a LaTeX formatted string. The method solves equations for specified variables, with optional substitutions, returning LaTeX-formatted solutions.
-
-• Parameters:
-  - `expression` (str): A string of the homogeneous polynomial expression to solve.
-  - `variable` (str): The variable to solve for.
-  - `subs` (Optional[Dict[str, float]]): Substitutions for variables.
-
-• Returns:
-  - `str`: Solutions formatted in LaTeX.
-
-• Example:
-
-    from rgwfuncs import solve_homogeneous_polynomial_expression
-    solutions1 = solve_homogeneous_polynomial_expression("a*x**2 + b*x + c", "x", {"a": 3, "b": 7, "c": 5})
-    print(solutions1)  # Output: "\left[-7/6 - sqrt(11)*I/6, -7/6 + sqrt(11)*I/6\right]"
-
-    solutions2 = solve_homogeneous_polynomial_expression("x**2 - 4", "x")
-    print(solutions2)  # Output: "\left[-2, 2\right]"
-    
---------------------------------------------------------------------------------
-
-### 11. `plot_polynomial_functions`
-
-This function plots polynomial functions described by a list of expressions and their corresponding substitution dictionaries. It generates SVG markup of the plots, with options for specifying the domain, axis zoom, and legend display.
-
-• Parameters:
-- `functions` (`List[Dict[str, Dict[str, Any]]]`): A list of dictionaries, each containing:
-  - A key which is a string representing a Python/NumPy expression (e.g., `"x**2"`, `"np.diff(x,2)"`).
-  - 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:
-
-    from rgwfuncs import plot_polynomial_functions
-
-    # Generate the SVG
-    plot_svg_string = plot_polynomial_functions(
-        functions=[
-            {"x**2": {"x": "*"}},  # Single expression, "*" means plot all discernable points
-            {"x**2/(2 + a) + a": {"x": np.linspace(-3, 4, 101), "a": 1.23}},
-            {"np.diff(x**3, 2)": {"x": np.linspace(-2, 2, 10)}}
-        ],
-        zoom=2,
-        open_file=True,
-        save_path="plot_polynomial_functions_example_1.svg"
-    )
-
-• Displaying the SVG:
-
-![Plot](./media/plot_polynomial_functions_example_1.svg)
-
---------------------------------------------------------------------------------
-
-### 12. `plot_x_points_of_polynomial_functions`
-
-This function plots one or more expressions described by a list of dictionaries. For each item in the list, the function evaluates the given Python/NumPy expression at the specified x-values (converted to NumPy arrays if they are Python lists) and plots the resulting points on a single figure.
-
-• Parameters:  
-- `functions` (`List[Dict[str, Dict[str, Any]]]`): A list of one or more items, each of which has exactly one key-value pair:  
-  - Key (`str`): A valid Python/NumPy expression (e.g., `x**2`, `np.sin(x)`, `x - a`).  
-  - Value (`Dict[str, Any]`): Must assign `x` a value
-- `zoom` (`float`):  Numeric range from -zoom to +zoom on both x and y axes (default 10.0).  
-- `show_legend` (`bool`): If True, includes a legend (default True).  
-- `open_file` (bool):
-  - If True and `save_path` is given, opens that file with the system viewer.  
-  - If True and `save_path` is None, writes to a temporary file and opens it (default False).  
-- `save_path` (`Optional[str]`): If specified, writes the resulting SVG to this path (default None).  
-
-• Returns:  
-- `str`: The raw SVG markup of the resulting scatter plot.
-
-• Example:
-
-    from rgwfuncs import plot_x_points_of_polynomial_functions
-    import numpy as np
-
-    svg_output = plot_x_points_of_polynomial_functions(
-        functions=[
-            {"x**2": {"x": np.array([-2, -1, 0, 1, 2])}},
-            {"np.sin(x)": {"x": np.linspace(0, 2*np.pi, 5)}},
-            {"x - 3": {"x": np.array([-2, 0, 2, 4, 6])}}
-        ],
-        zoom=6,
-        show_legend=True,
-        open_file=True,
-        save_path="plot_x_points_of_polynomial_functions_example_5.svg"
-    )
-
-• Displaying the SVG:
-
-![Plot](./media/plot_x_points_of_polynomial_functions_example_5.svg)
-
---------------------------------------------------------------------------------
-
-## String Based Functions
-
-### 1. send_telegram_message
-
-Send a message to a Telegram chat using a specified preset from your configuration file.
-
-• Parameters:
-  - `preset_name` (str): The name of the preset to use for sending the message. This should match a preset in the configuration file.
-  - `message` (str): The message text that you want to send to the Telegram chat.
-  - config (Optional[Union[str, dict]], optional): Configuration source. Can be:
-    - None: Uses default path '~/.rgwfuncsrc'
-    - str: Path to a JSON configuration file
-    - dict: Direct configuration dictionary
-
-• Raises:
-  - `RuntimeError`: If the preset is not found in the configuration file or if necessary details (bot token or chat ID) are missing.
-
-• Example:
-
-    from rgwfuncs import send_telegram_message
-    
-    preset_name = "daily_updates"
-    message = "Here is your daily update!"
-
-    send_telegram_message(preset_name, message)
-
---------------------------------------------------------------------------------
-
 ## Dataframe Based Functions
 
 Below is a quick reference of available functions, their purpose, and basic usage examples.

rgwfuncs-0.0.106.dist-info/RECORD

@@ -0,0 +1,11 @@
+rgwfuncs/__init__.py,sha256=XIbMHeEimBLNcX2PK7uQGquG-eAYXsetVEJrlBZIH5U,1295
+rgwfuncs/df_lib.py,sha256=3foomRHlunCpf_accTcqfdgwDmSPIVkVCnlWJ4ag4XQ,76947
+rgwfuncs/docs_lib.py,sha256=i63NzX-V8cGhikYdtkRGAEe2VcuwpXxDUyTRa9xI7l8,1972
+rgwfuncs/interactive_shell_lib.py,sha256=YeJBW9YgH5Nv77ONdOyIKFgtf0ItXStdlKGN9GGf8bU,4228
+rgwfuncs/str_lib.py,sha256=ZI-SNVFy__theOl0HifLiRXtLQ3bJ8kfKzEiwiAEbOg,11391
+rgwfuncs-0.0.106.dist-info/licenses/LICENSE,sha256=jLvt20gcUZYB8UOvyBvyKQ1qhYYhD__qP7ZDx2lPFkU,1062
+rgwfuncs-0.0.106.dist-info/METADATA,sha256=hWc25xg1tl2OM7VcZa876gz37n9lV0XsyL1qkLGzVf0,42972
+rgwfuncs-0.0.106.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+rgwfuncs-0.0.106.dist-info/entry_points.txt,sha256=j-c5IOPIQ0252EaOV6j6STio56sbXl2C4ym_fQ0lXx0,43
+rgwfuncs-0.0.106.dist-info/top_level.txt,sha256=aGuVIzWsKiV1f2gCb6mynx0zx5ma0B1EwPGFKVEMTi4,9
+rgwfuncs-0.0.106.dist-info/RECORD,,