rgwfuncs 0.0.22__py3-none-any.whl → 0.0.24__py3-none-any.whl

rgwfuncs/__init__.py

@@ -1,5 +1,7 @@
 # This file is automatically generated
 # Dynamically importing functions from modules
 
+from .algebra_lib import compute_algebraic_expression, get_prime_factors_latex, simplify_algebraic_expression, solve_algebraic_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, df_docs, 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 .str_lib import send_telegram_message, str_docs

rgwfuncs/algebra_lib.py

@@ -0,0 +1,186 @@
+import re
+import math
+from sympy import symbols, latex, simplify, solve, diff, Expr
+from sympy.parsing.sympy_parser import parse_expr
+from typing import Tuple, List, Dict, Optional
+
+def compute_algebraic_expression(expression: str) -> float:
+    try:
+        # Direct numerical evaluation
+        # Safely evaluate the expression using the math module
+        numeric_result = eval(expression, {"__builtins__": None, "math": math})
+
+        # Convert to float if possible
+        return float(numeric_result)
+    except Exception as e:
+        raise ValueError(f"Error computing expression: {e}")
+
+def simplify_algebraic_expression(expression: str) -> str:
+
+
+    def recursive_parse_function_call(func_call: str, prefix: str, sym_vars: Dict[str, Expr]) -> Tuple[str, List[Expr]]:
+        # print(f"Parsing function call: {func_call}")
+
+        # Match the function name and arguments
+        match = re.match(fr'{prefix}\.(\w+)\((.*)\)', func_call, re.DOTALL)
+        if not match:
+            raise ValueError(f"Invalid function call: {func_call}")
+
+        func_name = match.group(1)
+        args_str = match.group(2)
+
+        # Check if it's a list for np
+        if prefix == 'np' and args_str.startswith("[") and args_str.endswith("]"):
+            parsed_args = [ast.literal_eval(args_str.strip())]
+        else:
+            parsed_args = []
+            raw_args = re.split(r',(?![^{]*\})', args_str)
+            for arg in raw_args:
+                arg = arg.strip()
+                if re.match(r'\w+\.\w+\(', arg):
+                    # Recursively evaluate the argument if it's another function call
+                    arg_val = recursive_eval_func(re.match(r'\w+\.\w+\(.*\)', arg), sym_vars)
+                    parsed_args.append(parse_expr(arg_val, local_dict=sym_vars))
+                else:
+                    parsed_args.append(parse_expr(arg, local_dict=sym_vars))
+
+        # print(f"Function name: {func_name}, Parsed arguments: {parsed_args}")
+        return func_name, parsed_args
+
+
+    def recursive_eval_func(match: re.Match, sym_vars: Dict[str, Expr]) -> str:
+        # print("152", match)
+        func_call = match.group(0)
+        # print(f"153 Evaluating function call: {func_call}")
+
+        if func_call.startswith("np."):
+            func_name, args = recursive_parse_function_call(func_call, 'np', sym_vars)
+            if func_name == 'diff':
+                expr = args[0]
+                if isinstance(expr, list):
+                    # Calculate discrete difference
+                    diff_result = [expr[i] - expr[i - 1] for i in range(1, len(expr))]
+                    return str(diff_result)
+                # Perform symbolic differentiation
+                diff_result = diff(expr)
+                return str(diff_result)
+
+        if func_call.startswith("math."):
+            func_name, args = recursive_parse_function_call(func_call, 'math', sym_vars)
+            if hasattr(math, func_name):
+                result = getattr(math, func_name)(*args)
+                return str(result)
+
+        if func_call.startswith("sym."):
+            initial_method_match = re.match(r'(sym\.\w+\([^()]*\))(\.(\w+)\((.*?)\))*', func_call, re.DOTALL)
+            if initial_method_match:
+                base_expr_str = initial_method_match.group(1)
+                base_func_name, base_args = recursive_parse_function_call(base_expr_str, 'sym', sym_vars)
+                if base_func_name == 'solve':
+                    solutions = solve(base_args[0], base_args[1])
+                    # print(f"Solutions found: {solutions}")
+
+                method_chain = re.findall(r'\.(\w+)\((.*?)\)', func_call, re.DOTALL)
+                final_solutions = [execute_chained_methods(sol, [(m, [method_args.strip()]) for m, method_args in method_chain], sym_vars) for sol in solutions]
+
+                return "[" + ",".join(latex(simplify(sol)) for sol in final_solutions) + "]"
+
+        raise ValueError(f"Unknown function call: {func_call}")
+
+    def execute_chained_methods(sym_expr: Expr, method_chain: List[Tuple[str, List[str]]], sym_vars: Dict[str, Expr]) -> Expr:
+        for method_name, method_args in method_chain:
+            # print(f"Executing method: {method_name} with arguments: {method_args}")
+            method = getattr(sym_expr, method_name, None)
+            if method:
+                if method_name == 'subs' and isinstance(method_args[0], dict):
+                    kwargs = method_args[0]
+                    kwargs = {parse_expr(k, local_dict=sym_vars): parse_expr(v, local_dict=sym_vars) for k, v in kwargs.items()}
+                    sym_expr = method(kwargs)
+                else:
+                    args = [parse_expr(arg.strip(), local_dict=sym_vars) for arg in method_args]
+                    sym_expr = method(*args)
+            # print(f"Result after {method_name}: {sym_expr}")
+        return sym_expr
+
+
+
+    variable_names = set(re.findall(r'\b[a-zA-Z]\w*\b', expression))
+    sym_vars = {var: symbols(var) for var in variable_names}
+
+    patterns = {
+        #"numpy_diff_brackets": r"np\.diff\(\[.*?\]\)",
+        "numpy_diff_no_brackets": r"np\.diff\([^()]*\)",
+        "math_functions": r"math\.\w+\((?:[^()]*(?:\([^()]*\)[^()]*)*)\)",
+        # "sympy_functions": r"sym\.\w+\([^()]*\)(?:\.\w+\([^()]*\))?",
+    }
+
+    function_pattern = '|'.join(patterns.values())
+
+    # Use a lambda function to pass additional arguments
+    processed_expression = re.sub(function_pattern, lambda match: recursive_eval_func(match, sym_vars), expression)
+    # print("Level 2 processed_expression:", processed_expression)
+
+    try:
+        if processed_expression.startswith('[') and processed_expression.endswith(']'):
+            return processed_expression
+
+        expr = parse_expr(processed_expression, local_dict=sym_vars)
+        final_result = simplify(expr)
+
+        if final_result.free_symbols:
+            latex_result = latex(final_result)
+            return latex_result
+        else:
+            return str(final_result)
+
+    except Exception as e:
+        raise ValueError(f"Error simplifying expression: {e}")
+
+def solve_algebraic_expression(expression: str, variable: str, subs: Optional[Dict[str, float]] = None) -> str:
+    try:
+        # Create symbols for the variables in the expression
+        variable_symbols = set(re.findall(r'\b[a-zA-Z]\w*\b', expression))
+        sym_vars = {var: symbols(var) for var in variable_symbols}
+
+        # Parse the expression and solve it
+        expr = parse_expr(expression, local_dict=sym_vars)
+        var_symbol = symbols(variable)
+        solutions = solve(expr, var_symbol)
+
+        # Apply substitutions if provided
+        if subs:
+            subs_symbols = {symbols(k): v for k, v in subs.items()}
+            solutions = [simplify(sol.subs(subs_symbols)) for sol in solutions]
+
+        # Convert solutions to LaTeX strings if possible
+        latex_solutions = [latex(simplify(sol)) if sol.free_symbols else str(sol) for sol in solutions]
+        result = r"\left[" + ", ".join(latex_solutions) + r"\right]"
+        print("158", result)
+        return result
+
+    except Exception as e:
+        raise ValueError(f"Error solving the expression: {e}")
+
+
+
+def get_prime_factors_latex(n: int) -> str:
+    """
+    Return the prime factors of a number as a LaTeX expression.
+    """
+    factors = []
+    while n % 2 == 0:
+        factors.append(2)
+        n //= 2
+    for i in range(3, int(math.sqrt(n)) + 1, 2):
+        while n % i == 0:
+            factors.append(i)
+            n //= i
+    if n > 2:
+        factors.append(n)
+
+    factor_counts = {factor: factors.count(factor) for factor in set(factors)}
+    latex_factors = [f"{factor}^{{{count}}}" if count > 1 else str(factor) for factor, count in factor_counts.items()]
+    return " \\cdot ".join(latex_factors)
+
+
+

rgwfuncs/df_lib.py

@@ -1708,47 +1708,36 @@ def print_n_frequency_linear(df: pd.DataFrame, n: int, columns: list, order_by:
 
         return report
 
-    def can_convert_keys_to_int(keys):
-        """Helper function to check if all keys can be converted to integers."""
+    def try_parse_numeric(val):
+        """Attempt to parse a value as an integer or float."""
         try:
-            [int(key) for key in keys]
-            return True
+            return int(val)
         except ValueError:
-            return False
+            try:
+                return float(val)
+            except ValueError:
+                return val
 
     def sort_frequency(frequency, order_by):
         keys = frequency.keys()
-        
-        # Determine if we can sort by integer values of keys
-        if can_convert_keys_to_int(keys):
-            keys = list(map(int, keys))  # Convert keys to integers, and keep original order
 
-        if order_by == "ASC":
-            return dict(sorted(frequency.items(), key=lambda item: item[0]))
-        elif order_by == "DESC":
-            return dict(
-                sorted(
-                    frequency.items(),
-                    key=lambda item: item[0],
-                    reverse=True))
-        elif order_by == "FREQ_ASC":
-            return dict(sorted(frequency.items(), key=lambda item: item[1]))
-        elif order_by == "BY_KEYS_ASC":
-            if isinstance(keys[0], int):
-                return dict(sorted(frequency.items(), key=lambda item: int(item[0])))
-            else:
-                return dict(sorted(frequency.items()))
-        elif order_by == "BY_KEYS_DESC":
-            if isinstance(keys[0], int):
-                return dict(sorted(frequency.items(), key=lambda item: int(item[0]), reverse=True))
-            else:
-                return dict(sorted(frequency.items(), reverse=True))
-        else:  # Default to "FREQ_DESC"
-            return dict(
-                sorted(
-                    frequency.items(),
-                    key=lambda item: item[1],
-                    reverse=True))
+        # Convert keys to numerical values where possible, leaving `NaN` as a special string
+        parsed_keys = [(try_parse_numeric(key), key) for key in keys]
+
+        if order_by in {"BY_KEYS_ASC", "BY_KEYS_DESC"}:
+            reverse = order_by == "BY_KEYS_DESC"
+            sorted_items = sorted(frequency.items(), key=lambda item: try_parse_numeric(item[0]), reverse=reverse)
+        else:
+            if order_by == "ASC":
+                sorted_items = sorted(frequency.items(), key=lambda item: item[0])
+            elif order_by == "DESC":
+                sorted_items = sorted(frequency.items(), key=lambda item: item[0], reverse=True)
+            elif order_by == "FREQ_ASC":
+                sorted_items = sorted(frequency.items(), key=lambda item: item[1])
+            else:  # Default to "FREQ_DESC"
+                sorted_items = sorted(frequency.items(), key=lambda item: item[1], reverse=True)
+
+        return dict(sorted_items)
 
     report = generate_linear_report(df, columns, n, order_by)
     print(json.dumps(report, indent=2))

rgwfuncs/docs_lib.py

@@ -0,0 +1,50 @@
+import os
+import inspect
+from typing import Tuple, Optional, Dict, Callable
+import warnings
+
+# Suppress all FutureWarnings
+warnings.filterwarnings("ignore", category=FutureWarning)
+
+def docs(method_type_filter: Optional[str] = None) -> None:
+    """
+    Print a list of function names in alphabetical order from all modules.
+    If method_type_filter is specified, print the docstrings of the functions
+    that match the filter. Using '*' as a filter will print the docstrings 
+    for all functions.
+
+    Parameters:
+        method_type_filter: Optional filter string representing a function name,
+        or '*' to display docstrings for all functions.
+    """
+
+    # Directory containing your modules
+    module_dir = os.path.dirname(__file__)
+    
+    # Iterate over each file in the module directory
+    for filename in sorted(os.listdir(module_dir)):
+        if filename.endswith('.py') and filename != '__init__.py':
+            module_name, _ = os.path.splitext(filename)
+            print(f"\n# {module_name}.py")
+
+            # Import the module
+            module_path = f"rgwfuncs.{module_name}"
+            module = __import__(module_path, fromlist=[module_name])
+
+            # Get all functions from the module
+            functions = {
+                name: obj for name, obj
+                in inspect.getmembers(module, inspect.isfunction)
+                if obj.__module__ == module_path
+            }
+
+            # List function names
+            function_names = sorted(functions.keys())
+            for name in function_names:
+                print(f"{name}")
+
+                # If a filter is provided or '*', print the docstring
+                if method_type_filter and (method_type_filter == '*' or method_type_filter == name):
+                    docstring: Optional[str] = functions[name].__doc__
+                    if docstring:
+                        print(f"\n{name}:\n{docstring}")

{rgwfuncs-0.0.22.dist-info → rgwfuncs-0.0.24.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: rgwfuncs
-Version: 0.0.22
+Version: 0.0.24
 Summary: A functional programming paradigm for mathematical modelling and data science
 Home-page: https://github.com/ryangerardwilson/rgwfunc
 Author: Ryan Gerard Wilson
@@ -1002,22 +1002,31 @@ Print the cascading frequency of top n values for specified columns.
 --------------------------------------------------------------------------------
 
 ### 37. `print_n_frequency_linear`
-Print the linear frequency of top n values for specified columns.
 
-• Parameters:
-  - df (pd.DataFrame)
-  - n (int)
-  - columns (str): Comma-separated columns.
-  - `order_by` (str)
+Prints the linear frequency of the top `n` values for specified columns.
+
+#### Parameters:
+- **df** (`pd.DataFrame`): The DataFrame to analyze.
+- **n** (`int`): The number of top values to print for each column.
+- **columns** (`list`): A list of column names to be analyzed.
+- **order_by** (`str`): The order of frequency. The available options are:
+  - `"ASC"`: Sort keys in ascending lexicographical order.
+  - `"DESC"`: Sort keys in descending lexicographical order.
+  - `"FREQ_ASC"`: Sort the frequencies in ascending order (least frequent first).
+  - `"FREQ_DESC"`: Sort the frequencies in descending order (most frequent first).
+  - `"BY_KEYS_ASC"`: Sort keys in ascending order, numerically if possible, handling special strings like 'NaN' as typical entries.
+  - `"BY_KEYS_DESC"`: Sort keys in descending order, numerically if possible, handling special strings like 'NaN' as typical entries.
+
+#### Example:
 
-• Example:
-    
     from rgwfuncs import print_n_frequency_linear
     import pandas as pd
 
-    df = pd.DataFrame({'City': ['NY','LA','NY','SF','LA','LA']})
-    print_n_frequency_linear(df, 2, 'City', 'FREQ_DESC')
-    
+    df = pd.DataFrame({'City': ['NY', 'LA', 'NY', 'SF', 'LA', 'LA']})
+    print_n_frequency_linear(df, 2, ['City'], 'FREQ_DESC')
+
+This example analyzes the `City` column, printing the top 2 most frequent values in descending order of frequency.
+
 
 --------------------------------------------------------------------------------
 

rgwfuncs-0.0.24.dist-info/RECORD

@@ -0,0 +1,11 @@
+rgwfuncs/__init__.py,sha256=UrSka0KkoaZfLtODgbEbGvo67-L0LK1-e9waRn2a95g,1334
+rgwfuncs/algebra_lib.py,sha256=aayZogB2Rp9JAo5kVHpauqX_R346eI_rIuE5QNEMlKM,7789
+rgwfuncs/df_lib.py,sha256=8KMn4FucI19EFBHUoGOS7R4mo0degg6A6802sjy7BH4,67677
+rgwfuncs/docs_lib.py,sha256=iZlQMNS52FuiblCI0oXJVznSuCndeG6WqZfsm-Xnd7U,1918
+rgwfuncs/str_lib.py,sha256=I5B0WOGaLUGaedMG7hqiKnIqV7Jc9h1RYlgOiC_-iGY,3678
+rgwfuncs-0.0.24.dist-info/LICENSE,sha256=7EI8xVBu6h_7_JlVw-yPhhOZlpY9hP8wal7kHtqKT_E,1074
+rgwfuncs-0.0.24.dist-info/METADATA,sha256=-Nv5cA1xWJNfDSp53_jkaTce5n93hAH7mS7bv2IFWes,35516
+rgwfuncs-0.0.24.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+rgwfuncs-0.0.24.dist-info/entry_points.txt,sha256=j-c5IOPIQ0252EaOV6j6STio56sbXl2C4ym_fQ0lXx0,43
+rgwfuncs-0.0.24.dist-info/top_level.txt,sha256=aGuVIzWsKiV1f2gCb6mynx0zx5ma0B1EwPGFKVEMTi4,9
+rgwfuncs-0.0.24.dist-info/RECORD,,

rgwfuncs-0.0.22.dist-info/RECORD

@@ -1,9 +0,0 @@
-rgwfuncs/__init__.py,sha256=2nrp3c5VmVrKh0Ih6zELL8niH9nAHN0XnObqe-EpxlE,1169
-rgwfuncs/df_lib.py,sha256=nd-F7NGraUINuZUIqYHo2QwUNTjESgBlxKDQbbqlhS8,68050
-rgwfuncs/str_lib.py,sha256=I5B0WOGaLUGaedMG7hqiKnIqV7Jc9h1RYlgOiC_-iGY,3678
-rgwfuncs-0.0.22.dist-info/LICENSE,sha256=7EI8xVBu6h_7_JlVw-yPhhOZlpY9hP8wal7kHtqKT_E,1074
-rgwfuncs-0.0.22.dist-info/METADATA,sha256=aQ86F5Sb5XUGej267Y-hwVuAYqObbuNfy5vcbCxmgYY,34680
-rgwfuncs-0.0.22.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-rgwfuncs-0.0.22.dist-info/entry_points.txt,sha256=j-c5IOPIQ0252EaOV6j6STio56sbXl2C4ym_fQ0lXx0,43
-rgwfuncs-0.0.22.dist-info/top_level.txt,sha256=aGuVIzWsKiV1f2gCb6mynx0zx5ma0B1EwPGFKVEMTi4,9
-rgwfuncs-0.0.22.dist-info/RECORD,,