basic-open-agent-tools 0.6.2__tar.gz → 0.6.4__tar.gz

{basic_open_agent_tools-0.6.2/src/basic_open_agent_tools.egg-info → basic_open_agent_tools-0.6.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: basic-open-agent-tools
-Version: 0.6.2
+Version: 0.6.4
 Summary: An open foundational toolkit providing essential components for building AI agents with minimal dependencies for local (non-HTTP/API) actions.
 Home-page: https://github.com/open-agent-tools/basic-open-agent-tools
 Author: Open Agent Tools

{basic_open_agent_tools-0.6.2 → basic_open_agent_tools-0.6.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta:__legacy__"
 
 [project]
 name = "basic-open-agent-tools"
-version = "0.6.2"  # Agent-friendly type signatures with enhanced compatibility
+version = "0.6.4"  # Fixed binary and JSON function signatures for agent framework compatibility
 description = "An open foundational toolkit providing essential components for building AI agents with minimal dependencies for local (non-HTTP/API) actions."
 readme = "README.md"
 requires-python = ">=3.8"

{basic_open_agent_tools-0.6.2 → basic_open_agent_tools-0.6.4}/src/basic_open_agent_tools/data/binary_processing.py

@@ -11,17 +11,17 @@ import imghdr
 import mimetypes
 import os
 import struct
-from typing import Any, Dict, Optional
+from typing import Any, Dict
 
 from ..exceptions import DataError
 
 
-def read_binary_file(file_path: str, max_size: Optional[int] = None) -> bytes:
+def read_binary_file(file_path: str, max_size: int = 0) -> bytes:
     """Read binary data from a file.
 
     Args:
         file_path: Path to the binary file
-        max_size: Maximum file size in bytes to read (None for no limit)
+        max_size: Maximum file size in bytes to read (0 for no limit)
 
     Returns:
         Binary data as bytes
@@ -38,8 +38,8 @@ def read_binary_file(file_path: str, max_size: Optional[int] = None) -> bytes:
     if not os.path.isfile(file_path):
         raise FileNotFoundError(f"File not found: {file_path}")
 
-    # Check file size if max_size is specified
-    if max_size is not None:
+    # Check file size if max_size is specified (0 means no limit)
+    if max_size > 0:
         file_size = os.path.getsize(file_path)
         if file_size > max_size:
             raise DataError(
@@ -146,11 +146,11 @@ def decode_binary_data(encoded_data: str, encoding: str = "base64") -> bytes:
         raise ValueError(f"Invalid {encoding} data: {str(e)}")
 
 
-def validate_binary_format(data: Any, expected_format: str) -> bool:
+def validate_binary_format(data: bytes, expected_format: str) -> bool:
     """Validate that binary data matches an expected format.
 
     Args:
-        data: Binary data to validate
+        data: Binary data to validate as bytes
         expected_format: Expected format ("png", "jpeg", "gif", "pdf", etc.)
 
     Returns:

{basic_open_agent_tools-0.6.2 → basic_open_agent_tools-0.6.4}/src/basic_open_agent_tools/data/config_processing.py

@@ -156,6 +156,7 @@ def read_ini_file(file_path: str) -> dict:
     """
     # Check if file exists first (ConfigParser.read doesn't raise FileNotFoundError)
     import os
+
     if not os.path.isfile(file_path):
         raise FileNotFoundError(f"INI file not found: {file_path}")
 
@@ -242,12 +243,16 @@ def validate_config_schema(config_data: dict, schema: dict) -> list:
         if expected_type and not isinstance(config_data[field_name], expected_type):
             actual_type = type(config_data[field_name]).__name__
             expected_type_name = expected_type.__name__
-            errors.append(f"Field '{field_name}' has incorrect type: expected {expected_type_name}, got {actual_type}")
+            errors.append(
+                f"Field '{field_name}' has incorrect type: expected {expected_type_name}, got {actual_type}"
+            )
 
         # Check allowed values
         allowed_values = field_spec.get("allowed_values")
         if allowed_values and config_data[field_name] not in allowed_values:
-            errors.append(f"Field '{field_name}' has invalid value: {config_data[field_name]}. Allowed values: {allowed_values}")
+            errors.append(
+                f"Field '{field_name}' has invalid value: {config_data[field_name]}. Allowed values: {allowed_values}"
+            )
 
     # Check for unknown fields
     for field_name in config_data:
@@ -303,7 +308,9 @@ def merge_config_files(*config_paths: Any, format_type: Optional[str] = None) ->
                 raise DataError(f"Cannot determine format for file: {path}")
 
         if len(detected_formats) > 1:
-            raise DataError(f"Cannot merge files with different formats: {detected_formats}")
+            raise DataError(
+                f"Cannot merge files with different formats: {detected_formats}"
+            )
 
     merged_config: Dict[str, Any] = {}
 

{basic_open_agent_tools-0.6.2 → basic_open_agent_tools-0.6.4}/src/basic_open_agent_tools/data/csv_tools.py

@@ -2,17 +2,16 @@
 
 import csv
 import io
-from pathlib import Path
-from typing import Optional, Union
+from typing import Optional
 
 from ..exceptions import DataError
 
 
-def read_csv_simple(file_path: Union[str, Path], delimiter: str = ',', headers: bool = True) -> list:
+def read_csv_simple(file_path: str, delimiter: str = ",", headers: bool = True) -> list:
     """Read CSV file and return as list of dictionaries.
 
     Args:
-        file_path: Path to the CSV file (string or Path object)
+        file_path: Path to the CSV file as a string
         delimiter: CSV delimiter character (default: ',')
         headers: Whether the CSV file has headers (default: True)
 
@@ -20,7 +19,7 @@ def read_csv_simple(file_path: Union[str, Path], delimiter: str = ',', headers:
         List of dictionaries representing CSV rows with string values
 
     Raises:
-        TypeError: If file_path is not a string or Path object
+        TypeError: If file_path is not a string
         DataError: If file cannot be read or parsed
 
     Example:
@@ -29,9 +28,13 @@ def read_csv_simple(file_path: Union[str, Path], delimiter: str = ',', headers:
         >>> data
         [{'name': 'Alice', 'age': '25'}, {'name': 'Bob', 'age': '30'}]
     """
-    # Check if file_path is a string or a Path-like object
-    if not (isinstance(file_path, str) or hasattr(file_path, '__fspath__')):
-        raise TypeError("file_path must be a string or Path")
+    # Check if file_path is a string or Path object and convert to string
+    if isinstance(file_path, str):
+        file_path_str = file_path
+    elif hasattr(file_path, "__fspath__"):
+        file_path_str = str(file_path)
+    else:
+        raise TypeError("file_path must be a string")
 
     if not isinstance(delimiter, str):
         raise TypeError("delimiter must be a string")
@@ -40,7 +43,7 @@ def read_csv_simple(file_path: Union[str, Path], delimiter: str = ',', headers:
         raise TypeError("headers must be a boolean")
 
     try:
-        with open(file_path, encoding="utf-8", newline="") as csvfile:
+        with open(file_path_str, encoding="utf-8", newline="") as csvfile:
             if headers:
                 dict_reader = csv.DictReader(csvfile, delimiter=delimiter)
                 return [dict(row) for row in dict_reader]
@@ -57,24 +60,26 @@ def read_csv_simple(file_path: Union[str, Path], delimiter: str = ',', headers:
                     result.append(row_dict)
                 return result
     except FileNotFoundError:
-        raise DataError(f"CSV file not found: {file_path}")
+        raise DataError(f"CSV file not found: {file_path_str}")
     except UnicodeDecodeError as e:
-        raise DataError(f"Failed to decode CSV file {file_path}: {e}")
+        raise DataError(f"Failed to decode CSV file {file_path_str}: {e}")
     except csv.Error as e:
-        raise DataError(f"Failed to parse CSV file {file_path}: {e}")
+        raise DataError(f"Failed to parse CSV file {file_path_str}: {e}")
 
 
-def write_csv_simple(data: list, file_path: Union[str, Path], delimiter: str = ',', headers: bool = True) -> None:
+def write_csv_simple(
+    data: list, file_path: str, delimiter: str = ",", headers: bool = True
+) -> None:
     """Write list of dictionaries to CSV file.
 
     Args:
         data: List of dictionaries to write
-        file_path: Path where CSV file will be created (string or Path object)
+        file_path: Path where CSV file will be created as a string
         delimiter: CSV delimiter character (default: ',')
         headers: Whether to write headers (default: True)
 
     Raises:
-        TypeError: If data is not a list, contains non-dictionary items, or file_path is not a string or Path
+        TypeError: If data is not a list, contains non-dictionary items, or file_path is not a string
         DataError: If file cannot be written
 
     Example:
@@ -85,9 +90,13 @@ def write_csv_simple(data: list, file_path: Union[str, Path], delimiter: str = '
     if not isinstance(data, list):
         raise TypeError("data must be a list")
 
-    # Check if file_path is a string or a Path-like object
-    if not (isinstance(file_path, str) or hasattr(file_path, '__fspath__')):
-        raise TypeError("file_path must be a string or Path")
+    # Check if file_path is a string or Path object and convert to string
+    if isinstance(file_path, str):
+        file_path_str = file_path
+    elif hasattr(file_path, "__fspath__"):
+        file_path_str = str(file_path)
+    else:
+        raise TypeError("file_path must be a string")
 
     if not isinstance(delimiter, str):
         raise TypeError("delimiter must be a string")
@@ -97,7 +106,7 @@ def write_csv_simple(data: list, file_path: Union[str, Path], delimiter: str = '
 
     if not data:
         # Write empty file for empty data
-        with open(file_path, "w", encoding="utf-8") as f:
+        with open(file_path_str, "w", encoding="utf-8") as f:
             f.write("")
         return
 
@@ -114,16 +123,16 @@ def write_csv_simple(data: list, file_path: Union[str, Path], delimiter: str = '
                 if key not in fieldnames:
                     fieldnames.append(key)
 
-        with open(file_path, "w", encoding="utf-8", newline="") as csvfile:
+        with open(file_path_str, "w", encoding="utf-8", newline="") as csvfile:
             writer = csv.DictWriter(csvfile, fieldnames=fieldnames, delimiter=delimiter)
             if headers:
                 writer.writeheader()
             writer.writerows(data)
     except OSError as e:
-        raise DataError(f"Failed to write CSV file {file_path}: {e}")
+        raise DataError(f"Failed to write CSV file {file_path_str}: {e}")
 
 
-def csv_to_dict_list(csv_data: str, delimiter: str = ',') -> list:
+def csv_to_dict_list(csv_data: str, delimiter: str = ",") -> list:
     """Convert CSV string to list of dictionaries.
 
     Args:
@@ -158,7 +167,7 @@ def csv_to_dict_list(csv_data: str, delimiter: str = ',') -> list:
         raise DataError(f"Failed to parse CSV data: {e}")
 
 
-def dict_list_to_csv(data: list, delimiter: str = ',') -> str:
+def dict_list_to_csv(data: list, delimiter: str = ",") -> str:
     """Convert list of dictionaries to CSV string.
 
     Args:
@@ -203,18 +212,18 @@ def dict_list_to_csv(data: list, delimiter: str = ',') -> str:
     return output.getvalue()
 
 
-def detect_csv_delimiter(file_path: Union[str, Path], sample_size: int = 1024) -> str:
+def detect_csv_delimiter(file_path: str, sample_size: int = 1024) -> str:
     """Auto-detect CSV delimiter by analyzing file content.
 
     Args:
-        file_path: Path to the CSV file (string or Path object)
+        file_path: Path to the CSV file as a string
         sample_size: Number of characters to sample for detection
 
     Returns:
         Detected delimiter character
 
     Raises:
-        TypeError: If file_path is not a string or Path object, or sample_size is not a positive integer
+        TypeError: If file_path is not a string, or sample_size is not a positive integer
         DataError: If file cannot be read or delimiter cannot be detected
 
     Example:
@@ -223,15 +232,19 @@ def detect_csv_delimiter(file_path: Union[str, Path], sample_size: int = 1024) -
         >>> detect_csv_delimiter("data.tsv")
         '\\t'
     """
-    # Check if file_path is a string or a Path-like object
-    if not (isinstance(file_path, str) or hasattr(file_path, '__fspath__')):
-        raise TypeError("file_path must be a string or Path")
+    # Check if file_path is a string or Path object and convert to string
+    if isinstance(file_path, str):
+        file_path_str = file_path
+    elif hasattr(file_path, "__fspath__"):
+        file_path_str = str(file_path)
+    else:
+        raise TypeError("file_path must be a string")
 
     if not isinstance(sample_size, int) or sample_size <= 0:
         raise TypeError("sample_size must be a positive integer")
 
     try:
-        with open(file_path, encoding="utf-8") as csvfile:
+        with open(file_path_str, encoding="utf-8") as csvfile:
             sample = csvfile.read(sample_size)
 
         if not sample:
@@ -241,27 +254,27 @@ def detect_csv_delimiter(file_path: Union[str, Path], sample_size: int = 1024) -
         delimiter = sniffer.sniff(sample).delimiter
         return delimiter
     except FileNotFoundError:
-        raise DataError(f"CSV file not found: {file_path}")
+        raise DataError(f"CSV file not found: {file_path_str}")
     except UnicodeDecodeError as e:
-        raise DataError(f"Failed to decode CSV file {file_path}: {e}")
+        raise DataError(f"Failed to decode CSV file {file_path_str}: {e}")
     except csv.Error as e:
-        raise DataError(f"Failed to detect delimiter in {file_path}: {e}")
+        raise DataError(f"Failed to detect delimiter in {file_path_str}: {e}")
 
 
 def validate_csv_structure(
-    file_path: Union[str, Path], expected_columns: Optional[list] = None
+    file_path: str, expected_columns: Optional[list] = None
 ) -> bool:
     """Validate CSV file structure and column headers.
 
     Args:
-        file_path: Path to the CSV file (string or Path object)
+        file_path: Path to the CSV file as a string
         expected_columns: List of expected column names (optional)
 
     Returns:
         True if CSV structure is valid
 
     Raises:
-        TypeError: If file_path is not a string or Path object, or expected_columns is not a list
+        TypeError: If file_path is not a string, or expected_columns is not a list
         DataError: If file cannot be read or structure is invalid
 
     Example:
@@ -270,9 +283,13 @@ def validate_csv_structure(
         >>> validate_csv_structure("malformed.csv")
         False
     """
-    # Check if file_path is a string or a Path-like object
-    if not (isinstance(file_path, str) or hasattr(file_path, '__fspath__')):
-        raise TypeError("file_path must be a string or Path")
+    # Check if file_path is a string or Path object and convert to string
+    if isinstance(file_path, str):
+        file_path_str = file_path
+    elif hasattr(file_path, "__fspath__"):
+        file_path_str = str(file_path)
+    else:
+        raise TypeError("file_path must be a string")
 
     if expected_columns is not None and not isinstance(expected_columns, list):
         raise TypeError("expected_columns must be a list or None")
@@ -281,11 +298,11 @@ def validate_csv_structure(
         # Check if file is empty first
         import os
 
-        if os.path.getsize(file_path) == 0:
+        if os.path.getsize(file_path_str) == 0:
             return True  # Empty file is considered valid
 
         # Read first few rows to validate structure
-        data = read_csv_simple(file_path)
+        data = read_csv_simple(file_path_str)
 
         if not data:
             return True  # Empty file is considered valid
@@ -305,7 +322,7 @@ def validate_csv_structure(
         # Re-raise DataError as-is
         raise
     except Exception as e:
-        raise DataError(f"Invalid CSV structure in {file_path}: {e}")
+        raise DataError(f"Invalid CSV structure in {file_path_str}: {e}")
 
 
 def clean_csv_data(data: list, rules: Optional[dict] = None) -> list:

{basic_open_agent_tools-0.6.2 → basic_open_agent_tools-0.6.4}/src/basic_open_agent_tools/data/json_tools.py

@@ -2,17 +2,17 @@
 
 import gzip
 import json
-from typing import Any, Optional
+from typing import Any
 
 from ..exceptions import SerializationError
 
 
-def safe_json_serialize(data: Any, indent: Optional[int] = None) -> str:
+def safe_json_serialize(data: dict, indent: int = 0) -> str:
     """Safely serialize data to JSON string with error handling.
 
     Args:
-        data: Data to serialize to JSON
-        indent: Number of spaces for indentation (None for compact)
+        data: Data to serialize to JSON (accepts any serializable type)
+        indent: Number of spaces for indentation (0 for compact)
 
     Returns:
         JSON string representation of the data
@@ -27,11 +27,13 @@ def safe_json_serialize(data: Any, indent: Optional[int] = None) -> str:
         >>> safe_json_serialize({"a": 1, "b": 2}, indent=2)
         '{\\n  "a": 1,\\n  "b": 2\\n}'
     """
-    if not isinstance(indent, (int, type(None))):
-        raise TypeError("indent must be an integer or None")
+    if not isinstance(indent, int):
+        raise TypeError("indent must be an integer")
 
     try:
-        return json.dumps(data, indent=indent, ensure_ascii=False)
+        # Use None for compact format when indent is 0
+        actual_indent = None if indent == 0 else indent
+        return json.dumps(data, indent=actual_indent, ensure_ascii=False)
     except (TypeError, ValueError) as e:
         raise SerializationError(f"Failed to serialize data to JSON: {e}")
 

{basic_open_agent_tools-0.6.2 → basic_open_agent_tools-0.6.4}/src/basic_open_agent_tools/data/structures.py

@@ -96,7 +96,9 @@ def unflatten_dict(data: Dict[str, Any], separator: str = ".") -> Dict[str, Any]
     return result
 
 
-def get_nested_value_simple(data: Dict[str, Any], key_path: str, default: Any = None) -> Any:
+def get_nested_value_simple(
+    data: Dict[str, Any], key_path: str, default: Any = None
+) -> Any:
     """Safely access nested dictionary values using dot notation.
 
     Args:
@@ -461,7 +463,9 @@ def unflatten_dict_simple(data: Dict[str, Any], separator: str = ".") -> Dict[st
     return unflatten_dict(data, separator)
 
 
-def set_nested_value_simple(data: Dict[str, Any], key_path: str, value: Any) -> Dict[str, Any]:
+def set_nested_value_simple(
+    data: Dict[str, Any], key_path: str, value: Any
+) -> Dict[str, Any]:
     """Set nested dictionary value using dot notation (immutable).
 
     This is an alias for set_nested_value for LLM agent compatibility.
@@ -482,7 +486,9 @@ def set_nested_value_simple(data: Dict[str, Any], key_path: str, value: Any) ->
     return set_nested_value(data, key_path, value)
 
 
-def compare_data_structures_simple(data1: Any, data2: Any, ignore_order: bool = False) -> bool:
+def compare_data_structures_simple(
+    data1: Any, data2: Any, ignore_order: bool = False
+) -> bool:
     """Compare two data structures for equality.
 
     This is an alias for compare_data_structures for LLM agent compatibility.
@@ -524,7 +530,9 @@ def safe_get_simple(data: Dict[str, Any], key: str, default: Any = None) -> Any:
     return safe_get(data, key, default)
 
 
-def remove_empty_values_simple(data: Dict[str, Any], recursive: bool = True) -> Dict[str, Any]:
+def remove_empty_values_simple(
+    data: Dict[str, Any], recursive: bool = True
+) -> Dict[str, Any]:
     """Remove empty values from dictionary.
 
     This is an alias for remove_empty_values for LLM agent compatibility.
@@ -564,7 +572,9 @@ def extract_keys_simple(data: Dict[str, Any], key_pattern: str) -> List[str]:
     return extract_keys(data, key_pattern)
 
 
-def rename_keys_simple(data: Dict[str, Any], key_mapping: Dict[str, str]) -> Dict[str, Any]:
+def rename_keys_simple(
+    data: Dict[str, Any], key_mapping: Dict[str, str]
+) -> Dict[str, Any]:
     """Rename dictionary keys according to mapping.
 
     This is an alias for rename_keys for LLM agent compatibility.

{basic_open_agent_tools-0.6.2 → basic_open_agent_tools-0.6.4}/src/basic_open_agent_tools/data/transform.py

@@ -5,7 +5,9 @@ from typing import Any, Callable, Dict, List, Optional, Union
 from ..exceptions import DataError
 
 
-def transform_data(data: List[Dict[str, Any]], mapping: Dict[str, Union[str, Callable[[Any], Any]]]) -> List[Dict[str, Any]]:
+def transform_data(
+    data: List[Dict[str, Any]], mapping: Dict[str, Union[str, Callable[[Any], Any]]]
+) -> List[Dict[str, Any]]:
     """Apply a transformation mapping to a list of data records.
 
     Args:
@@ -46,11 +48,15 @@ def transform_data(data: List[Dict[str, Any]], mapping: Dict[str, Union[str, Cal
                     try:
                         transformed_record[source_field] = transform(value)
                     except Exception as e:
-                        raise DataError(f"Error transforming field '{source_field}': {e}")
+                        raise DataError(
+                            f"Error transforming field '{source_field}': {e}"
+                        )
                 elif isinstance(transform, str):
                     transformed_record[transform] = value
                 else:
-                    raise DataError(f"Invalid transform for field '{source_field}': must be string or callable")
+                    raise DataError(
+                        f"Invalid transform for field '{source_field}': must be string or callable"
+                    )
 
         # Include fields not in mapping as-is
         for field, value in record.items():
@@ -62,7 +68,9 @@ def transform_data(data: List[Dict[str, Any]], mapping: Dict[str, Union[str, Cal
     return transformed_data
 
 
-def rename_fields(data: List[Dict[str, Any]], field_mapping: Dict[str, str]) -> List[Dict[str, Any]]:
+def rename_fields(
+    data: List[Dict[str, Any]], field_mapping: Dict[str, str]
+) -> List[Dict[str, Any]]:
     """Rename fields in a list of dictionaries.
 
     Args:
@@ -89,7 +97,9 @@ def rename_fields(data: List[Dict[str, Any]], field_mapping: Dict[str, str]) ->
 
     for i, record in enumerate(data):
         if not isinstance(record, dict):
-            raise DataError(f"Record at index {i} is not a dictionary: {type(record).__name__}")
+            raise DataError(
+                f"Record at index {i} is not a dictionary: {type(record).__name__}"
+            )
 
         renamed_record = {}
         for field, value in record.items():
@@ -101,7 +111,9 @@ def rename_fields(data: List[Dict[str, Any]], field_mapping: Dict[str, str]) ->
     return renamed_data
 
 
-def convert_data_types(data: List[Dict[str, Any]], type_mapping: Dict[str, Callable[[Any], Any]]) -> List[Dict[str, Any]]:
+def convert_data_types(
+    data: List[Dict[str, Any]], type_mapping: Dict[str, Callable[[Any], Any]]
+) -> List[Dict[str, Any]]:
     """Convert data types for specified fields.
 
     Args:
@@ -143,7 +155,9 @@ def convert_data_types(data: List[Dict[str, Any]], type_mapping: Dict[str, Calla
     return converted_data
 
 
-def clean_data(data: List[Dict[str, Any]], rules: Dict[str, List[Callable[[Any], Any]]]) -> List[Dict[str, Any]]:
+def clean_data(
+    data: List[Dict[str, Any]], rules: Dict[str, List[Callable[[Any], Any]]]
+) -> List[Dict[str, Any]]:
     """Clean data according to specified rules.
 
     Args:
@@ -186,12 +200,16 @@ def clean_data(data: List[Dict[str, Any]], rules: Dict[str, List[Callable[[Any],
 
                 for cleaner in cleaners:
                     if not callable(cleaner):
-                        raise DataError(f"Cleaner for field '{field}' is not callable: {cleaner}")
+                        raise DataError(
+                            f"Cleaner for field '{field}' is not callable: {cleaner}"
+                        )
 
                     try:
                         value = cleaner(value)
                     except Exception as e:
-                        raise DataError(f"Error applying cleaner to field '{field}': {e}")
+                        raise DataError(
+                            f"Error applying cleaner to field '{field}': {e}"
+                        )
 
                 cleaned_record[field] = value
 
@@ -200,7 +218,9 @@ def clean_data(data: List[Dict[str, Any]], rules: Dict[str, List[Callable[[Any],
     return cleaned_data
 
 
-def deduplicate_records(data: List[Dict[str, Any]], key_fields: Optional[List[str]] = None) -> List[Dict[str, Any]]:
+def deduplicate_records(
+    data: List[Dict[str, Any]], key_fields: Optional[List[str]] = None
+) -> List[Dict[str, Any]]:
     """Remove duplicate records from a list.
 
     Args:
@@ -229,14 +249,18 @@ def deduplicate_records(data: List[Dict[str, Any]], key_fields: Optional[List[st
 
     for i, record in enumerate(data):
         if not isinstance(record, dict):
-            raise DataError(f"Record at index {i} is not a dictionary: {type(record).__name__}")
+            raise DataError(
+                f"Record at index {i} is not a dictionary: {type(record).__name__}"
+            )
 
         # Create a key based on specified fields or all fields
         if key_fields:
             # Check if all key fields are present in the record
             missing_fields = [field for field in key_fields if field not in record]
             if missing_fields:
-                raise DataError(f"Record at index {i} is missing key fields: {missing_fields}")
+                raise DataError(
+                    f"Record at index {i} is missing key fields: {missing_fields}"
+                )
 
             key_values = tuple(record[field] for field in key_fields)
         else:
@@ -249,7 +273,9 @@ def deduplicate_records(data: List[Dict[str, Any]], key_fields: Optional[List[st
     return deduplicated_data
 
 
-def normalize_data(data: List[Dict[str, Any]], rules: Dict[str, Callable[[Any], Any]]) -> List[Dict[str, Any]]:
+def normalize_data(
+    data: List[Dict[str, Any]], rules: Dict[str, Callable[[Any], Any]]
+) -> List[Dict[str, Any]]:
     """Apply normalization functions to data fields.
 
     Args:
@@ -278,7 +304,9 @@ def normalize_data(data: List[Dict[str, Any]], rules: Dict[str, Callable[[Any],
 
     for i, record in enumerate(data):
         if not isinstance(record, dict):
-            raise DataError(f"Record at index {i} is not a dictionary: {type(record).__name__}")
+            raise DataError(
+                f"Record at index {i} is not a dictionary: {type(record).__name__}"
+            )
 
         normalized_record = record.copy()
 
@@ -332,7 +360,9 @@ def pivot_data(
 
     for i, record in enumerate(data):
         if not isinstance(record, dict):
-            raise DataError(f"Record at index {i} is not a dictionary: {type(record).__name__}")
+            raise DataError(
+                f"Record at index {i} is not a dictionary: {type(record).__name__}"
+            )
 
         if (
             index_field not in record
@@ -346,7 +376,9 @@ def pivot_data(
                 missing_fields.append(column_field)
             if value_field not in record:
                 missing_fields.append(value_field)
-            raise DataError(f"Record at index {i} is missing required fields: {missing_fields}")
+            raise DataError(
+                f"Record at index {i} is missing required fields: {missing_fields}"
+            )
 
         index_val = record[index_field]
         column_val = record[column_field]
@@ -360,7 +392,9 @@ def pivot_data(
     return pivoted
 
 
-def transform_data_simple(data: List[Dict[str, Any]], mapping: Dict[str, str]) -> List[Dict[str, Any]]:
+def transform_data_simple(
+    data: List[Dict[str, Any]], mapping: Dict[str, str]
+) -> List[Dict[str, Any]]:
     """Apply a simple transformation mapping to a list of data records.
 
     This is a simplified version of transform_data for LLM agent compatibility.
@@ -398,7 +432,9 @@ def transform_data_simple(data: List[Dict[str, Any]], mapping: Dict[str, str]) -
         for source_field, new_field in mapping.items():
             if source_field in record:
                 if not isinstance(new_field, str):
-                    raise DataError(f"Invalid mapping for field '{source_field}': must be string")
+                    raise DataError(
+                        f"Invalid mapping for field '{source_field}': must be string"
+                    )
                 transformed_record[new_field] = record[source_field]
 
         # Include fields not in mapping as-is
@@ -411,7 +447,9 @@ def transform_data_simple(data: List[Dict[str, Any]], mapping: Dict[str, str]) -
     return transformed_data
 
 
-def rename_fields_simple(data: List[Dict[str, Any]], field_mapping: Dict[str, str]) -> List[Dict[str, Any]]:
+def rename_fields_simple(
+    data: List[Dict[str, Any]], field_mapping: Dict[str, str]
+) -> List[Dict[str, Any]]:
     """Rename fields in a list of dictionaries.
 
     This is an alias for transform_data_simple for LLM agent compatibility.
@@ -431,7 +469,9 @@ def rename_fields_simple(data: List[Dict[str, Any]], field_mapping: Dict[str, st
     return transform_data_simple(data, field_mapping)
 
 
-def convert_data_types_simple(data: List[Dict[str, Any]], type_mapping: Dict[str, str]) -> List[Dict[str, Any]]:
+def convert_data_types_simple(
+    data: List[Dict[str, Any]], type_mapping: Dict[str, str]
+) -> List[Dict[str, Any]]:
     """Convert data types for specified fields using string type names.
 
     This is a simplified version of convert_data_types for LLM agent compatibility.
@@ -462,31 +502,45 @@ def convert_data_types_simple(data: List[Dict[str, Any]], type_mapping: Dict[str
         "str": str,
         "int": int,
         "float": float,
-        "bool": lambda x: bool(x) if x in (0, 1) else x.lower() in ("true", "yes", "1") if isinstance(x, str) else bool(x)
+        "bool": lambda x: bool(x)
+        if x in (0, 1)
+        else x.lower() in ("true", "yes", "1")
+        if isinstance(x, str)
+        else bool(x),
     }
 
     for i, record in enumerate(data):
         if not isinstance(record, dict):
-            raise DataError(f"Record at index {i} is not a dictionary: {type(record).__name__}")
+            raise DataError(
+                f"Record at index {i} is not a dictionary: {type(record).__name__}"
+            )
 
         converted_record = record.copy()
 
         for field, type_name in type_mapping.items():
             if field in converted_record and converted_record[field] is not None:
                 if type_name not in type_functions:
-                    raise DataError(f"Invalid type name: {type_name}. Must be one of: str, int, float, bool")
+                    raise DataError(
+                        f"Invalid type name: {type_name}. Must be one of: str, int, float, bool"
+                    )
 
                 try:
-                    converted_record[field] = type_functions[type_name](converted_record[field])
+                    converted_record[field] = type_functions[type_name](
+                        converted_record[field]
+                    )
                 except ValueError as e:
-                    raise DataError(f"Error converting field '{field}' to {type_name}: {e}")
+                    raise DataError(
+                        f"Error converting field '{field}' to {type_name}: {e}"
+                    )
 
         converted_data.append(converted_record)
 
     return converted_data
 
 
-def clean_data_simple(data: List[Dict[str, Any]], rules: Dict[str, str]) -> List[Dict[str, Any]]:
+def clean_data_simple(
+    data: List[Dict[str, Any]], rules: Dict[str, str]
+) -> List[Dict[str, Any]]:
     """Clean data according to simple string-based rules.
 
     This is a simplified version of clean_data for LLM agent compatibility.
@@ -519,12 +573,14 @@ def clean_data_simple(data: List[Dict[str, Any]], rules: Dict[str, str]) -> List
         "lower": str.lower,
         "upper": str.upper,
         "title": str.title,
-        "capitalize": str.capitalize
+        "capitalize": str.capitalize,
     }
 
     for i, record in enumerate(data):
         if not isinstance(record, dict):
-            raise DataError(f"Record at index {i} is not a dictionary: {type(record).__name__}")
+            raise DataError(
+                f"Record at index {i} is not a dictionary: {type(record).__name__}"
+            )
 
         cleaned_record = record.copy()
 
@@ -534,20 +590,26 @@ def clean_data_simple(data: List[Dict[str, Any]], rules: Dict[str, str]) -> List
                     raise DataError(f"Rule for field '{field}' must be a string")
 
                 if rule not in cleaning_functions:
-                    raise DataError(f"Invalid cleaning rule: {rule}. Must be one of: {', '.join(cleaning_functions.keys())}")
+                    raise DataError(
+                        f"Invalid cleaning rule: {rule}. Must be one of: {', '.join(cleaning_functions.keys())}"
+                    )
 
                 try:
                     value = str(cleaned_record[field])
                     cleaned_record[field] = cleaning_functions[rule](value)
                 except Exception as e:
-                    raise DataError(f"Error applying rule '{rule}' to field '{field}': {e}")
+                    raise DataError(
+                        f"Error applying rule '{rule}' to field '{field}': {e}"
+                    )
 
         cleaned_data.append(cleaned_record)
 
     return cleaned_data
 
 
-def deduplicate_records_simple(data: List[Dict[str, Any]], key_fields: Optional[List[str]] = None) -> List[Dict[str, Any]]:
+def deduplicate_records_simple(
+    data: List[Dict[str, Any]], key_fields: Optional[List[str]] = None
+) -> List[Dict[str, Any]]:
     """Remove duplicate records from a list.
 
     This is a simplified version of deduplicate_records for LLM agent compatibility.
@@ -579,7 +641,9 @@ def deduplicate_records_simple(data: List[Dict[str, Any]], key_fields: Optional[
 
     for i, record in enumerate(data):
         if not isinstance(record, dict):
-            raise DataError(f"Record at index {i} is not a dictionary: {type(record).__name__}")
+            raise DataError(
+                f"Record at index {i} is not a dictionary: {type(record).__name__}"
+            )
 
         # Create a key based on specified fields
         key_values = tuple(str(record.get(field, "")) for field in key_fields)

{basic_open_agent_tools-0.6.2 → basic_open_agent_tools-0.6.4}/src/basic_open_agent_tools/data/validation.py

@@ -175,7 +175,11 @@ def validate_data_types_simple(data: Dict[str, Any], type_map: Dict[str, str]) -
     return True
 
 
-def validate_range_simple(value: Union[int, float], min_val: Optional[Union[int, float]]=None, max_val: Optional[Union[int, float]]=None) -> bool:
+def validate_range_simple(
+    value: Union[int, float],
+    min_val: Optional[Union[int, float]] = None,
+    max_val: Optional[Union[int, float]] = None,
+) -> bool:
     """Validate numeric value is within range.
 
     Args:
@@ -214,7 +218,9 @@ def validate_range_simple(value: Union[int, float], min_val: Optional[Union[int,
     return True
 
 
-def create_validation_report(data: Dict[str, Any], rules: Dict[str, Any]) -> Dict[str, Any]:
+def create_validation_report(
+    data: Dict[str, Any], rules: Dict[str, Any]
+) -> Dict[str, Any]:
     """Create comprehensive validation report for data.
 
     Args:
@@ -320,7 +326,9 @@ def check_required_fields_simple(data: Dict[str, Any], required: List[str]) -> b
     return check_required_fields(data, required)
 
 
-def create_validation_report_simple(data: Dict[str, Any], rules: Dict[str, Any]) -> Dict[str, Any]:
+def create_validation_report_simple(
+    data: Dict[str, Any], rules: Dict[str, Any]
+) -> Dict[str, Any]:
     """Create simplified validation report for data.
 
     This is an alias for create_validation_report for LLM agent compatibility.

{basic_open_agent_tools-0.6.2 → basic_open_agent_tools-0.6.4/src/basic_open_agent_tools.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: basic-open-agent-tools
-Version: 0.6.2
+Version: 0.6.4
 Summary: An open foundational toolkit providing essential components for building AI agents with minimal dependencies for local (non-HTTP/API) actions.
 Home-page: https://github.com/open-agent-tools/basic-open-agent-tools
 Author: Open Agent Tools

{basic_open_agent_tools-0.6.2 → basic_open_agent_tools-0.6.4}/tests/test_data_csv_tools.py

@@ -72,7 +72,7 @@ class TestReadCsvSimple:
 
     def test_read_csv_invalid_types(self):
         """Test with invalid argument types."""
-        with pytest.raises(TypeError, match="file_path must be a string or Path"):
+        with pytest.raises(TypeError, match="file_path must be a string"):
             read_csv_simple(123)
 
         with pytest.raises(TypeError, match="delimiter must be a string"):
@@ -152,7 +152,7 @@ class TestWriteCsvFile:
         with pytest.raises(TypeError, match="data must be a list"):
             write_csv_simple("not a list", csv_file)
 
-        with pytest.raises(TypeError, match="file_path must be a string or Path"):
+        with pytest.raises(TypeError, match="file_path must be a string"):
             write_csv_simple([], 123)
 
         with pytest.raises(TypeError, match="All items in data must be dictionaries"):
@@ -295,7 +295,7 @@ class TestDetectCsvDelimiter:
 
     def test_detect_invalid_types(self):
         """Test with invalid argument types."""
-        with pytest.raises(TypeError, match="file_path must be a string or Path"):
+        with pytest.raises(TypeError, match="file_path must be a string"):
             detect_csv_delimiter(123)
 
         with pytest.raises(TypeError, match="sample_size must be a positive integer"):
@@ -342,7 +342,7 @@ class TestValidateCsvStructure:
 
     def test_validate_invalid_types(self):
         """Test with invalid argument types."""
-        with pytest.raises(TypeError, match="file_path must be a string or Path"):
+        with pytest.raises(TypeError, match="file_path must be a string"):
             validate_csv_structure(123)
 
         with pytest.raises(TypeError, match="expected_columns must be a list or None"):

{basic_open_agent_tools-0.6.2 → basic_open_agent_tools-0.6.4}/tests/test_data_json_tools.py

@@ -47,7 +47,7 @@ class TestSafeJsonSerialize:
 
     def test_serialize_invalid_indent_type(self):
         """Test with invalid indent type."""
-        with pytest.raises(TypeError, match="indent must be an integer or None"):
+        with pytest.raises(TypeError, match="indent must be an integer"):
             safe_json_serialize({"test": "data"}, indent="invalid")
 
     def test_serialize_non_serializable_object(self):