praisonaiagents 0.0.23__py3-none-any.whl → 0.0.24__py3-none-any.whl

praisonaiagents/tools/calculator_tools.py

@@ -0,0 +1,278 @@
+"""Tools for performing calculations.
+
+Usage:
+from praisonaiagents.tools import calculator_tools
+result = calculator_tools.evaluate("2 + 2 * 3")
+
+or
+from praisonaiagents.tools import evaluate, solve_equation, convert_units
+result = evaluate("2 + 2 * 3")
+"""
+
+import logging
+from typing import List, Dict, Optional, Any
+from importlib import util
+import math
+
+class CalculatorTools:
+    """Tools for performing calculations."""
+    
+    def __init__(self):
+        """Initialize CalculatorTools."""
+        self._check_dependencies()
+        
+    def _check_dependencies(self):
+        """Check if required packages are installed."""
+        missing = []
+        for package in ['sympy', 'pint']:
+            if util.find_spec(package) is None:
+                missing.append(package)
+        
+        if missing:
+            raise ImportError(
+                f"Required packages not available. Please install: {', '.join(missing)}\n"
+                f"Run: pip install {' '.join(missing)}"
+            )
+
+    def evaluate(
+        self,
+        expression: str,
+        variables: Optional[Dict[str, float]] = None,
+        precision: int = 10
+    ) -> Dict[str, Any]:
+        """Evaluate a mathematical expression."""
+        try:
+            if util.find_spec('sympy') is None:
+                error_msg = "sympy package is not available. Please install it using: pip install sympy"
+                logging.error(error_msg)
+                return {"error": error_msg}
+
+            # Import sympy only when needed
+            import sympy
+
+            # Replace common mathematical functions
+            expression = expression.lower()
+            replacements = {
+                'sin(': 'math.sin(',
+                'cos(': 'math.cos(',
+                'tan(': 'math.tan(',
+                'sqrt(': 'math.sqrt(',
+                'log(': 'math.log(',
+                'exp(': 'math.exp(',
+                'pi': str(math.pi),
+                'e': str(math.e)
+            }
+            for old, new in replacements.items():
+                expression = expression.replace(old, new)
+            
+            # Create safe namespace
+            safe_dict = {
+                'math': math,
+                '__builtins__': None
+            }
+            if variables:
+                safe_dict.update(variables)
+            
+            # Evaluate expression
+            result = eval(expression, safe_dict)
+            
+            # Round to specified precision
+            if isinstance(result, (int, float)):
+                return {"result": round(float(result), precision)}
+            return {"error": "Invalid expression"}
+        except Exception as e:
+            error_msg = f"Error evaluating expression: {str(e)}"
+            logging.error(error_msg)
+            return {"error": error_msg}
+
+    def solve_equation(
+        self,
+        equation: str,
+        variable: str = 'x'
+    ) -> Dict[str, Any]:
+        """Solve a mathematical equation."""
+        try:
+            if util.find_spec('sympy') is None:
+                error_msg = "sympy package is not available. Please install it using: pip install sympy"
+                logging.error(error_msg)
+                return {"error": error_msg}
+
+            # Import sympy only when needed
+            import sympy
+
+            # Parse equation
+            if '=' in equation:
+                left, right = equation.split('=')
+                equation = f"({left}) - ({right})"
+            
+            # Convert to SymPy expression
+            x = sympy.Symbol(variable)
+            expr = sympy.sympify(equation)
+            
+            # Solve equation
+            solutions = sympy.solve(expr, x)
+            
+            # Convert complex solutions to real if possible
+            real_solutions = []
+            for sol in solutions:
+                if sol.is_real:
+                    real_solutions.append(float(sol))
+            
+            return {"solutions": real_solutions} if real_solutions else {"error": "No real solutions found"}
+        except Exception as e:
+            error_msg = f"Error solving equation: {str(e)}"
+            logging.error(error_msg)
+            return {"error": error_msg}
+
+    def convert_units(
+        self,
+        value: float,
+        from_unit: str,
+        to_unit: str
+    ) -> Dict[str, Any]:
+        """Convert between different units."""
+        try:
+            if util.find_spec('pint') is None:
+                error_msg = "pint package is not available. Please install it using: pip install pint"
+                logging.error(error_msg)
+                return {"error": error_msg}
+
+            # Import pint only when needed
+            import pint
+
+            # Create quantity with source unit
+            ureg = pint.UnitRegistry()
+            quantity = value * ureg(from_unit)
+            
+            # Convert to target unit
+            result = quantity.to(to_unit)
+            
+            return {"result": float(result.magnitude)}
+        except Exception as e:
+            error_msg = f"Error converting units: {str(e)}"
+            logging.error(error_msg)
+            return {"error": error_msg}
+
+    def calculate_statistics(
+        self,
+        numbers: List[float]
+    ) -> Dict[str, Any]:
+        """Calculate basic statistics for a list of numbers."""
+        try:
+            if not numbers:
+                return {"error": "No numbers provided"}
+            
+            n = len(numbers)
+            mean = sum(numbers) / n
+            
+            # Calculate variance and std dev
+            squared_diff_sum = sum((x - mean) ** 2 for x in numbers)
+            variance = squared_diff_sum / (n - 1) if n > 1 else 0
+            std_dev = math.sqrt(variance)
+            
+            # Calculate median
+            sorted_nums = sorted(numbers)
+            if n % 2 == 0:
+                median = (sorted_nums[n//2 - 1] + sorted_nums[n//2]) / 2
+            else:
+                median = sorted_nums[n//2]
+            
+            return {
+                "mean": mean,
+                "median": median,
+                "std_dev": std_dev,
+                "variance": variance,
+                "min": min(numbers),
+                "max": max(numbers),
+                "range": max(numbers) - min(numbers),
+                "count": n
+            }
+        except Exception as e:
+            error_msg = f"Error calculating statistics: {str(e)}"
+            logging.error(error_msg)
+            return {"error": error_msg}
+
+    def calculate_financial(
+        self,
+        principal: float,
+        rate: float,
+        time: float,
+        frequency: str = 'yearly'
+    ) -> Dict[str, Any]:
+        """Calculate financial metrics like compound interest."""
+        try:
+            # Convert rate to decimal
+            rate = rate / 100
+            
+            # Get compounding frequency
+            freq_map = {
+                'yearly': 1,
+                'semi-annual': 2,
+                'quarterly': 4,
+                'monthly': 12,
+                'daily': 365
+            }
+            n = freq_map.get(frequency.lower(), 1)
+            
+            # Calculate compound interest
+            amount = principal * (1 + rate/n)**(n*time)
+            interest = amount - principal
+            
+            # Calculate simple interest
+            simple_interest = principal * rate * time
+            
+            return {
+                "final_amount": amount,
+                "compound_interest": interest,
+                "simple_interest": simple_interest,
+                "difference": interest - simple_interest
+            }
+        except Exception as e:
+            error_msg = f"Error calculating financial metrics: {str(e)}"
+            logging.error(error_msg)
+            return {"error": error_msg}
+
+# Create instance for direct function access
+_calculator_tools = CalculatorTools()
+evaluate = _calculator_tools.evaluate
+solve_equation = _calculator_tools.solve_equation
+convert_units = _calculator_tools.convert_units
+calculate_statistics = _calculator_tools.calculate_statistics
+calculate_financial = _calculator_tools.calculate_financial
+
+if __name__ == "__main__":
+    print("\n==================================================")
+    print("CalculatorTools Demonstration")
+    print("==================================================\n")
+
+    print("1. Basic Arithmetic")
+    print("------------------------------")
+    print("2 + 2 =", evaluate("2 + 2")["result"])
+    print("5 * 6 =", evaluate("5 * 6")["result"])
+    print("10 / 3 =", evaluate("10 / 3")["result"])
+    print()
+
+    print("2. Complex Expressions")
+    print("------------------------------")
+    print("(2 + 3) * 4 =", evaluate("(2 + 3) * 4")["result"])
+    print("2^3 + 4 =", evaluate("2^3 + 4")["result"])
+    print("sqrt(16) + 2 =", evaluate("sqrt(16) + 2")["result"])
+    print()
+
+    print("3. Solving Equations")
+    print("------------------------------")
+    result = solve_equation("x^2 - 5*x + 6 = 0")
+    print("x^2 - 5*x + 6 = 0")
+    print("Solutions:", result["solutions"])
+    print()
+
+    print("4. Unit Conversions")
+    print("------------------------------")
+    print("100 meters to kilometers:", convert_units(100, "meters", "kilometers")["result"])
+    print("1 hour to minutes:", convert_units(1, "hours", "minutes")["result"])
+    print("32 fahrenheit to celsius:", convert_units(32, "fahrenheit", "celsius")["result"])
+    print()
+
+    print("==================================================")
+    print("Demonstration Complete")
+    print("==================================================")

praisonaiagents/tools/csv_tools.py

@@ -0,0 +1,266 @@
+"""Tools for working with CSV files.
+
+Usage:
+from praisonaiagents.tools import csv_tools
+df = csv_tools.read_csv("data.csv")
+
+or
+from praisonaiagents.tools import read_csv, write_csv, merge_csv
+df = read_csv("data.csv")
+"""
+
+import logging
+from typing import List, Dict, Union, Optional, Any, TYPE_CHECKING
+from importlib import util
+import json
+import csv
+from pathlib import Path
+
+if TYPE_CHECKING:
+    import pandas as pd
+
+class CSVTools:
+    """Tools for working with CSV files."""
+    
+    def __init__(self):
+        """Initialize CSVTools."""
+        pass
+
+    def _get_pandas(self) -> Optional['pd']:
+        """Get pandas module, installing if needed"""
+        if util.find_spec('pandas') is None:
+            error_msg = "pandas package is not available. Please install it using: pip install pandas"
+            logging.error(error_msg)
+            return None
+        import pandas as pd
+        return pd
+
+    def read_csv(
+        self,
+        filepath: str,
+        encoding: str = 'utf-8',
+        delimiter: str = ',',
+        header: Union[int, List[int], None] = 0,
+        usecols: Optional[List[str]] = None,
+        dtype: Optional[Dict[str, str]] = None,
+        parse_dates: Optional[List[str]] = None,
+        na_values: Optional[List[str]] = None,
+        nrows: Optional[int] = None
+    ) -> List[Dict[str, Any]]:
+        """Read a CSV file with advanced options.
+        
+        Args:
+            filepath: Path to CSV file
+            encoding: File encoding
+            delimiter: Column delimiter
+            header: Row number(s) to use as column names
+            usecols: Columns to read
+            dtype: Dict of column dtypes
+            parse_dates: List of columns to parse as dates
+            na_values: Additional strings to recognize as NA/NaN
+            nrows: Number of rows to read
+            
+        Returns:
+            List of row dicts
+        """
+        try:
+            pd = self._get_pandas()
+            if pd is None:
+                return {"error": "pandas package not available"}
+
+            df = pd.read_csv(
+                filepath,
+                encoding=encoding,
+                delimiter=delimiter,
+                header=header,
+                usecols=usecols,
+                dtype=dtype,
+                parse_dates=parse_dates,
+                na_values=na_values,
+                nrows=nrows
+            )
+            return df.to_dict('records')
+            
+        except Exception as e:
+            error_msg = f"Error reading CSV file {filepath}: {str(e)}"
+            logging.error(error_msg)
+            return {"error": error_msg}
+
+    def write_csv(
+        self,
+        filepath: str,
+        data: List[Dict[str, Any]],
+        encoding: str = 'utf-8',
+        delimiter: str = ',',
+        index: bool = False,
+        header: bool = True,
+        float_format: Optional[str] = None,
+        date_format: Optional[str] = None,
+        mode: str = 'w'
+    ) -> bool:
+        """Write data to a CSV file.
+        
+        Args:
+            filepath: Path to CSV file
+            data: List of row dicts to write
+            encoding: File encoding
+            delimiter: Column delimiter
+            index: Whether to write row indices
+            header: Whether to write column headers
+            float_format: Format string for float values
+            date_format: Format string for date values
+            mode: Write mode ('w' for write, 'a' for append)
+            
+        Returns:
+            bool: Success status
+        """
+        try:
+            pd = self._get_pandas()
+            if pd is None:
+                return False
+
+            df = pd.DataFrame(data)
+            df.to_csv(
+                filepath,
+                encoding=encoding,
+                sep=delimiter,
+                index=index,
+                header=header,
+                float_format=float_format,
+                date_format=date_format,
+                mode=mode
+            )
+            return True
+            
+        except Exception as e:
+            error_msg = f"Error writing CSV file {filepath}: {str(e)}"
+            logging.error(error_msg)
+            return False
+
+    def merge_csv(
+        self,
+        files: List[str],
+        output_file: str,
+        how: str = 'inner',
+        on: Optional[Union[str, List[str]]] = None,
+        suffixes: Optional[tuple] = None
+    ) -> bool:
+        """Merge multiple CSV files.
+        
+        Args:
+            files: List of CSV files to merge
+            output_file: Output file path
+            how: Merge method ('inner', 'outer', 'left', 'right')
+            on: Column(s) to merge on
+            suffixes: Suffixes for overlapping columns
+            
+        Returns:
+            bool: Success status
+        """
+        try:
+            if len(files) < 2:
+                error_msg = "At least two files are required for merging"
+                logging.error(error_msg)
+                return False
+            
+            pd = self._get_pandas()
+            if pd is None:
+                return False
+
+            # Read first file
+            result = pd.read_csv(files[0])
+            
+            # Merge with remaining files
+            for file in files[1:]:
+                df = pd.read_csv(file)
+                result = pd.merge(
+                    result,
+                    df,
+                    how=how,
+                    on=on,
+                    suffixes=suffixes or ('_1', '_2')
+                )
+            
+            # Write merged result
+            result.to_csv(output_file, index=False)
+            return True
+            
+        except Exception as e:
+            error_msg = f"Error merging CSV files: {str(e)}"
+            logging.error(error_msg)
+            return False
+
+# Create instance for direct function access
+_csv_tools = CSVTools()
+read_csv = _csv_tools.read_csv
+write_csv = _csv_tools.write_csv
+merge_csv = _csv_tools.merge_csv
+
+if __name__ == "__main__":
+    print("\n==================================================")
+    print("CSVTools Demonstration")
+    print("==================================================\n")
+    
+    # Create a temporary file for testing
+    import tempfile
+    import os
+    
+    with tempfile.NamedTemporaryFile(suffix='.csv', delete=False) as temp:
+        temp_file = temp.name
+        
+        print("1. Writing CSV File")
+        print("------------------------------")
+        data = [
+            {"name": "Alice", "age": 25, "city": "New York"},
+            {"name": "Bob", "age": 30, "city": "San Francisco"},
+            {"name": "Charlie", "age": 35, "city": "Chicago"}
+        ]
+        result = write_csv(temp_file, data)
+        print(f"Data written successfully: {result}")
+        print()
+        
+        print("2. Reading CSV File")
+        print("------------------------------")
+        read_data = read_csv(temp_file)
+        print("Contents of CSV file:")
+        for row in read_data:
+            print(row)
+        print()
+        
+        print("3. Merging CSV Files")
+        print("------------------------------")
+        # Create a second file for merging
+        with tempfile.NamedTemporaryFile(suffix='.csv', delete=False) as temp2:
+            temp_file2 = temp2.name
+            data2 = [
+                {"name": "Alice", "salary": 75000},
+                {"name": "Bob", "salary": 85000},
+                {"name": "Charlie", "salary": 95000}
+            ]
+            write_csv(temp_file2, data2)
+            
+            # Merge files
+            with tempfile.NamedTemporaryFile(suffix='.csv', delete=False) as temp3:
+                temp_file3 = temp3.name
+                result = merge_csv(
+                    [temp_file, temp_file2],
+                    temp_file3,
+                    how='inner',
+                    on='name'
+                )
+                print(f"Files merged successfully: {result}")
+                if result:
+                    merged_data = read_csv(temp_file3)
+                    print("\nMerged contents:")
+                    for row in merged_data:
+                        print(row)
+                print()
+        
+        # Clean up temporary files
+        os.unlink(temp_file)
+        os.unlink(temp_file2)
+        os.unlink(temp_file3)
+    
+    print("==================================================")
+    print("Demonstration Complete")
+    print("==================================================\n")