rgwfuncs 0.0.33__tar.gz → 0.0.35__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: rgwfuncs
-Version: 0.0.33
+Version: 0.0.35
 Summary: A functional programming paradigm for mathematical modelling and data science
 Home-page: https://github.com/ryangerardwilson/rgwfunc
 Author: Ryan Gerard Wilson
@@ -135,7 +135,7 @@ To display all docstrings, use:
 
 --------------------------------------------------------------------------------
 
-## Documentation Access Functions
+## Documentation Access
 
 ### 1. docs
 Print a list of available function names in alphabetical order. If a filter is provided, print the docstrings of functions containing the term.
@@ -150,6 +150,60 @@ Print a list of available function names in alphabetical order. If a filter is p
 
 --------------------------------------------------------------------------------
 
+## Interactive Shell
+
+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`
+
+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. This function is particularly useful for debugging purposes when you want real-time interaction with your program's execution environment.
+
+• 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']
+    })
+
+    # Launch the interactive shell with local variables
+    interactive_shell(locals())
+
+Subsequently, in the interactive shell you can use any library in your python file, as well as all rgwfuncs methods (even if they are not imported). Notice, that while pandas and numpy are available in the shell as a result of importing them in the above script, the rgwfuncs method `first_n_rows` was not imported - yet is available for use.
+
+    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
+    >>> arr = np.array([1, 2, 3, 4, 5])
+    >>> arr
+    array([1, 2, 3, 4, 5])
+
+--------------------------------------------------------------------------------
+
 ## 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.35}/README.md

@@ -109,7 +109,7 @@ To display all docstrings, use:
 
 --------------------------------------------------------------------------------
 
-## Documentation Access Functions
+## Documentation Access
 
 ### 1. docs
 Print a list of available function names in alphabetical order. If a filter is provided, print the docstrings of functions containing the term.
@@ -124,6 +124,60 @@ Print a list of available function names in alphabetical order. If a filter is p
 
 --------------------------------------------------------------------------------
 
+## Interactive Shell
+
+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`
+
+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. This function is particularly useful for debugging purposes when you want real-time interaction with your program's execution environment.
+
+• 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']
+    })
+
+    # Launch the interactive shell with local variables
+    interactive_shell(locals())
+
+Subsequently, in the interactive shell you can use any library in your python file, as well as all rgwfuncs methods (even if they are not imported). Notice, that while pandas and numpy are available in the shell as a result of importing them in the above script, the rgwfuncs method `first_n_rows` was not imported - yet is available for use.
+
+    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
+    >>> arr = np.array([1, 2, 3, 4, 5])
+    >>> arr
+    array([1, 2, 3, 4, 5])
+
+--------------------------------------------------------------------------------
+
 ## 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.35}/pyproject.toml

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

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

@@ -1,6 +1,6 @@
 [metadata]
 name = rgwfuncs
-version = 0.0.33
+version = 0.0.35
 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.35}/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.35}/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.35/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.35/src/rgwfuncs.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: rgwfuncs
-Version: 0.0.33
+Version: 0.0.35
 Summary: A functional programming paradigm for mathematical modelling and data science
 Home-page: https://github.com/ryangerardwilson/rgwfunc
 Author: Ryan Gerard Wilson
@@ -135,7 +135,7 @@ To display all docstrings, use:
 
 --------------------------------------------------------------------------------
 
-## Documentation Access Functions
+## Documentation Access
 
 ### 1. docs
 Print a list of available function names in alphabetical order. If a filter is provided, print the docstrings of functions containing the term.
@@ -150,6 +150,60 @@ Print a list of available function names in alphabetical order. If a filter is p
 
 --------------------------------------------------------------------------------
 
+## Interactive Shell
+
+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`
+
+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. This function is particularly useful for debugging purposes when you want real-time interaction with your program's execution environment.
+
+• 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']
+    })
+
+    # Launch the interactive shell with local variables
+    interactive_shell(locals())
+
+Subsequently, in the interactive shell you can use any library in your python file, as well as all rgwfuncs methods (even if they are not imported). Notice, that while pandas and numpy are available in the shell as a result of importing them in the above script, the rgwfuncs method `first_n_rows` was not imported - yet is available for use.
+
+    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
+    >>> arr = np.array([1, 2, 3, 4, 5])
+    >>> arr
+    array([1, 2, 3, 4, 5])
+
+--------------------------------------------------------------------------------
+
 ## 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.35}/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
-
-
-