basic-open-agent-tools 0.7.2__tar.gz → 0.7.4__tar.gz

{basic_open_agent_tools-0.7.2/src/basic_open_agent_tools.egg-info → basic_open_agent_tools-0.7.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: basic-open-agent-tools
-Version: 0.7.2
+Version: 0.7.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.7.2 → basic_open_agent_tools-0.7.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta:__legacy__"
 
 [project]
 name = "basic-open-agent-tools"
-version = "0.7.2"  # Remove structures, archives, and object serialization for agent compatibility
+version = "0.7.4"  # Clean up module structure and remove transform functionality
 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.7.2 → basic_open_agent_tools-0.7.4}/src/basic_open_agent_tools/__init__.py

@@ -6,7 +6,7 @@ with minimal dependencies for local (non-HTTP/API) actions.
 
 from typing import List
 
-__version__ = "0.7.2"
+__version__ = "0.7.4"
 
 # Modular structure
 from . import data, exceptions, file_system, text, types
@@ -17,12 +17,10 @@ from .helpers import (
     list_all_available_tools,
     load_all_data_tools,
     load_all_filesystem_tools,
-    load_all_read_only_tools,
     load_all_text_tools,
     load_data_config_tools,
     load_data_csv_tools,
     load_data_json_tools,
-    load_data_transformation_tools,
     load_data_validation_tools,
     merge_tool_lists,
 )
@@ -51,11 +49,9 @@ __all__: List[str] = [
     "load_all_filesystem_tools",
     "load_all_text_tools",
     "load_all_data_tools",
-    "load_all_read_only_tools",
     "load_data_json_tools",
     "load_data_csv_tools",
     "load_data_validation_tools",
-    "load_data_transformation_tools",
     "load_data_config_tools",
     "merge_tool_lists",
     "get_tool_info",

{basic_open_agent_tools-0.7.2 → basic_open_agent_tools-0.7.4}/src/basic_open_agent_tools/data/__init__.py

@@ -5,7 +5,6 @@ This module provides data processing and manipulation tools organized into logic
 - json_tools: JSON serialization, compression, and validation
 - csv_tools: CSV file processing, parsing, and cleaning
 - validation: Data validation and schema checking
-- transform: Data transformation, cleaning, and normalization
 - config_processing: Configuration file processing (YAML, TOML, INI)
 """
 
@@ -38,15 +37,6 @@ from .json_tools import (
     safe_json_serialize,
     validate_json_string,
 )
-from .transform import (
-    clean_data,
-    convert_data_types,
-    deduplicate_records,
-    normalize_data,
-    pivot_data,
-    rename_fields,
-    transform_data,
-)
 from .validation import (
     check_required_fields,
     create_validation_report,
@@ -71,14 +61,6 @@ __all__: List[str] = [
     "detect_csv_delimiter",
     "validate_csv_structure",
     "clean_csv_data",
-    # Data transformation
-    "transform_data",
-    "rename_fields",
-    "convert_data_types",
-    "clean_data",
-    "deduplicate_records",
-    "normalize_data",
-    "pivot_data",
     # Validation
     "validate_schema_simple",
     "check_required_fields",

{basic_open_agent_tools-0.7.2 → basic_open_agent_tools-0.7.4}/src/basic_open_agent_tools/data/config_processing.py

@@ -2,7 +2,7 @@
 
 import configparser
 import json
-from typing import Any, Dict, Optional
+from typing import List, Union
 
 from ..exceptions import DataError
 
@@ -102,7 +102,7 @@ def read_toml_file(file_path: str) -> dict:
 
     try:
         with open(file_path, "rb") as f:
-            result: Dict[Any, Any] = tomli.load(f)
+            result: dict = tomli.load(f)
             return result
     except FileNotFoundError:
         raise FileNotFoundError(f"TOML file not found: {file_path}")
@@ -262,12 +262,12 @@ def validate_config_schema(config_data: dict, schema: dict) -> list:
     return errors
 
 
-def merge_config_files(*config_paths: Any, format_type: Optional[str] = None) -> dict:
+def merge_config_files(config_paths: Union[str, List[str]], format_type: str) -> dict:
     """Merge multiple configuration files into a single dictionary.
 
     Args:
-        *config_paths: Paths to configuration files (either as separate arguments or a list)
-        format_type: Format of the files ("yaml", "toml", "ini", or None for auto-detect)
+        config_paths: Paths to configuration files (either a single path or list of paths)
+        format_type: Format of the files ("yaml", "toml", "ini", or "json")
 
     Returns:
         Merged configuration dictionary
@@ -277,58 +277,29 @@ def merge_config_files(*config_paths: Any, format_type: Optional[str] = None) ->
         DataError: If files cannot be read or merged
 
     Example:
-        >>> merge_config_files("base.yaml", "override.yaml", format_type="yaml")
-        {"database": {"host": "override-host", "port": 5432}}
-        >>> merge_config_files(["base.yaml", "override.yaml"], format_type="yaml")
+        >>> merge_config_files(["base.yaml", "override.yaml"], "yaml")
         {"database": {"host": "override-host", "port": 5432}}
+        >>> merge_config_files("single.yaml", "yaml")
+        {"database": {"host": "localhost", "port": 5432}}
     """
-    # Handle both list input and variable arguments
-    paths = []
-    if len(config_paths) == 1 and isinstance(config_paths[0], list):
-        paths = config_paths[0]
+    # Handle both single string and list input
+    if isinstance(config_paths, str):
+        paths = [config_paths]
     else:
-        paths = list(config_paths)
+        paths = config_paths
 
     if not paths:
         raise ValueError("No configuration files provided")
 
-    # Check if all files have the same format if format_type is not specified
-    if format_type is None and len(paths) > 1:
-        detected_formats = set()
-        for path in paths:
-            if path.endswith((".yml", ".yaml")):
-                detected_formats.add("yaml")
-            elif path.endswith(".toml"):
-                detected_formats.add("toml")
-            elif path.endswith(".ini"):
-                detected_formats.add("ini")
-            elif path.endswith(".json"):
-                detected_formats.add("json")
-            else:
-                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}"
-            )
+    # Validate format_type
+    valid_formats = ["yaml", "toml", "ini", "json"]
+    if format_type not in valid_formats:
+        raise ValueError(f"format_type must be one of {valid_formats}")
 
-    merged_config: Dict[str, Any] = {}
+    merged_config: dict = {}
 
     for config_path in paths:
-        # Auto-detect format if not specified
-        if format_type is None:
-            if config_path.endswith((".yml", ".yaml")):
-                file_format = "yaml"
-            elif config_path.endswith(".toml"):
-                file_format = "toml"
-            elif config_path.endswith(".ini"):
-                file_format = "ini"
-            elif config_path.endswith(".json"):
-                file_format = "json"
-            else:
-                raise DataError(f"Cannot determine format for file: {config_path}")
-        else:
-            file_format = format_type
+        file_format = format_type
 
         # Read the file
         if file_format == "yaml":

{basic_open_agent_tools-0.7.2 → basic_open_agent_tools-0.7.4}/src/basic_open_agent_tools/data/json_tools.py

@@ -2,12 +2,12 @@
 
 import gzip
 import json
-from typing import Any
+from typing import Union, cast
 
 from ..exceptions import SerializationError
 
 
-def safe_json_serialize(data: dict, indent: int = 0) -> str:
+def safe_json_serialize(data: Union[dict, list, str, int, float, bool], indent: int) -> str:
     """Safely serialize data to JSON string with error handling.
 
     Args:
@@ -38,7 +38,7 @@ def safe_json_serialize(data: dict, indent: int = 0) -> str:
         raise SerializationError(f"Failed to serialize data to JSON: {e}")
 
 
-def safe_json_deserialize(json_str: str) -> Any:
+def safe_json_deserialize(json_str: str) -> Union[dict, list, str, int, float, bool, None]:
     """Safely deserialize JSON string to Python object with error handling.
 
     Args:
@@ -61,7 +61,7 @@ def safe_json_deserialize(json_str: str) -> Any:
         raise TypeError("Input must be a string")
 
     try:
-        return json.loads(json_str)
+        return cast(Union[dict, list, str, int, float, bool, None], json.loads(json_str))
     except (json.JSONDecodeError, ValueError) as e:
         raise SerializationError(f"Failed to deserialize JSON string: {e}")
 
@@ -91,7 +91,7 @@ def validate_json_string(json_str: str) -> bool:
         return False
 
 
-def compress_json_data(data: Any) -> bytes:
+def compress_json_data(data: Union[dict, list, str, int, float, bool]) -> bytes:
     """Compress JSON data for storage or transmission.
 
     Args:
@@ -110,13 +110,13 @@ def compress_json_data(data: Any) -> bytes:
         True
     """
     try:
-        json_str = safe_json_serialize(data)
+        json_str = safe_json_serialize(data, 0)
         return gzip.compress(json_str.encode("utf-8"))
     except Exception as e:
         raise SerializationError(f"Failed to compress JSON data: {e}")
 
 
-def decompress_json_data(compressed_data: bytes) -> Any:
+def decompress_json_data(compressed_data: bytes) -> Union[dict, list, str, int, float, bool, None]:
     """Decompress and deserialize JSON data.
 
     Args:

{basic_open_agent_tools-0.7.2 → basic_open_agent_tools-0.7.4}/src/basic_open_agent_tools/data/validation.py

@@ -1,11 +1,11 @@
 """Data validation utilities for AI agents."""
 
-from typing import Any, Dict, List, Optional, Union
+from typing import Dict, List, Optional, Union
 
 from ..exceptions import ValidationError
 
 
-def validate_schema_simple(data: Any, schema: Dict[str, Any]) -> bool:
+def validate_schema_simple(data: Union[dict, list, str, int, float, bool], schema: dict) -> bool:
     """Validate data against a JSON Schema-style schema.
 
     Args:
@@ -34,7 +34,7 @@ def validate_schema_simple(data: Any, schema: Dict[str, Any]) -> bool:
         raise
 
 
-def _validate_against_schema(data: Any, schema: Dict[str, Any]) -> None:
+def _validate_against_schema(data: Union[dict, list, str, int, float, bool], schema: dict) -> None:
     """Internal helper to validate data against schema."""
     schema_type = schema.get("type")
 
@@ -88,7 +88,7 @@ def _validate_against_schema(data: Any, schema: Dict[str, Any]) -> None:
             raise ValidationError(f"Expected null, got {type(data).__name__}")
 
 
-def check_required_fields(data: Dict[str, Any], required: List[str]) -> bool:
+def check_required_fields(data: dict, required: List[str]) -> bool:
     """Check if all required fields are present in data.
 
     Args:
@@ -122,7 +122,7 @@ def check_required_fields(data: Dict[str, Any], required: List[str]) -> bool:
     return True
 
 
-def validate_data_types_simple(data: Dict[str, Any], type_map: Dict[str, str]) -> bool:
+def validate_data_types_simple(data: dict, type_map: Dict[str, str]) -> bool:
     """Check that field types match expectations.
 
     Args:
@@ -219,8 +219,8 @@ def validate_range_simple(
 
 
 def create_validation_report(
-    data: Dict[str, Any], rules: Dict[str, Any]
-) -> Dict[str, Any]:
+    data: dict, rules: dict
+) -> dict:
     """Create comprehensive validation report for data.
 
     Args:
@@ -303,7 +303,7 @@ def create_validation_report(
     }
 
 
-def check_required_fields_simple(data: Dict[str, Any], required: List[str]) -> bool:
+def check_required_fields_simple(data: dict, required: List[str]) -> bool:
     """Check if all required fields are present in data.
 
     This is an alias for check_required_fields for LLM agent compatibility.
@@ -327,8 +327,8 @@ def check_required_fields_simple(data: Dict[str, Any], required: List[str]) -> b
 
 
 def create_validation_report_simple(
-    data: Dict[str, Any], rules: Dict[str, Any]
-) -> Dict[str, Any]:
+    data: dict, rules: dict
+) -> dict:
     """Create simplified validation report for data.
 
     This is an alias for create_validation_report for LLM agent compatibility.

{basic_open_agent_tools-0.7.2 → basic_open_agent_tools-0.7.4}/src/basic_open_agent_tools/file_system/operations.py

@@ -150,7 +150,7 @@ def delete_file(file_path: str) -> bool:
         raise FileSystemError(f"Failed to delete file {path}: {e}")
 
 
-def delete_directory(directory_path: str, recursive: bool = False) -> bool:
+def delete_directory(directory_path: str, recursive: bool) -> bool:
     """Delete a directory.
 
     Args:

{basic_open_agent_tools-0.7.2 → basic_open_agent_tools-0.7.4}/src/basic_open_agent_tools/helpers.py

@@ -166,36 +166,6 @@ def load_data_validation_tools() -> List[Callable[..., Any]]:
     return tools
 
 
-def load_data_transformation_tools() -> List[Callable[..., Any]]:
-    """Load data transformation tools as a list of callable functions.
-
-    Returns:
-        List of data transformation tool functions
-
-    Example:
-        >>> transform_tools = load_data_transformation_tools()
-        >>> len(transform_tools) == 7
-        True
-    """
-    from .data import transform
-
-    tools = []
-    transform_function_names = [
-        "transform_data",
-        "rename_fields",
-        "convert_data_types",
-        "clean_data",
-        "deduplicate_records",
-        "normalize_data",
-        "pivot_data",
-    ]
-
-    for name in transform_function_names:
-        func = getattr(transform, name)
-        if callable(func):
-            tools.append(func)
-
-    return tools
 
 
 
@@ -320,116 +290,6 @@ def get_tool_info(tool: Callable[..., Any]) -> Dict[str, Any]:
     }
 
 
-def load_all_read_only_tools() -> List[Callable[..., Any]]:
-    """Load all read-only tools (non-destructive operations) from all modules.
-
-    This function returns tools that only read, analyze, validate, or transform data
-    without modifying files, creating new files, or performing destructive operations.
-    Perfect for agents that need to analyze and process information safely.
-
-    Returns:
-        List of all read-only tool functions from file_system, data, and text modules
-
-    Example:
-        >>> read_only_tools = load_all_read_only_tools()
-        >>> len(read_only_tools) > 35  # Should have 35+ read-only tools
-        True
-    """
-    tools = []
-
-    # File System Read-Only Tools (11 tools)
-    fs_read_only = [
-        "file_exists",
-        "directory_exists",
-        "get_file_info",
-        "get_file_size",
-        "is_empty_directory",
-        "read_file_to_string",
-        "list_directory_contents",
-        "list_all_directory_contents",
-        "generate_directory_tree",
-        "validate_path",
-        "validate_file_content",
-    ]
-
-    for name in fs_read_only:
-        func = getattr(file_system, name)
-        if callable(func):
-            tools.append(func)
-
-    # Text Processing Tools (10 tools - ALL are read-only)
-    tools.extend(load_all_text_tools())
-
-    # Data Read-Only Tools (21 tools)
-    from .data import (
-        config_processing,
-        csv_tools,
-        json_tools,
-        transform,
-        validation,
-    )
-
-    # JSON read-only tools (2)
-    data_json_read_only = ["safe_json_deserialize", "validate_json_string"]
-    for name in data_json_read_only:
-        func = getattr(json_tools, name)
-        if callable(func):
-            tools.append(func)
-
-    # CSV read-only tools (4)
-    data_csv_read_only = [
-        "read_csv_simple",
-        "csv_to_dict_list",
-        "detect_csv_delimiter",
-        "validate_csv_structure",
-    ]
-    for name in data_csv_read_only:
-        func = getattr(csv_tools, name)
-        if callable(func):
-            tools.append(func)
-
-    # Config read-only tools (4)
-    data_config_read_only = [
-        "read_yaml_file",
-        "read_toml_file",
-        "read_ini_file",
-        "validate_config_schema",
-    ]
-    for name in data_config_read_only:
-        func = getattr(config_processing, name)
-        if callable(func):
-            tools.append(func)
-
-
-
-
-    # Validation tools (5 - ALL are read-only)
-    data_validation_read_only = [
-        "validate_schema_simple",
-        "check_required_fields",
-        "validate_data_types_simple",
-        "validate_range_simple",
-        "create_validation_report",
-    ]
-    for name in data_validation_read_only:
-        func = getattr(validation, name)
-        if callable(func):
-            tools.append(func)
-
-
-    # Transform read-only tools (4 - analysis/cleaning without modification)
-    data_transform_read_only = [
-        "clean_data",
-        "deduplicate_records",
-        "normalize_data",
-        "convert_data_types",
-    ]
-    for name in data_transform_read_only:
-        func = getattr(transform, name)
-        if callable(func):
-            tools.append(func)
-
-    return tools
 
 
 def list_all_available_tools() -> Dict[str, List[Dict[str, Any]]]:
@@ -449,5 +309,4 @@ def list_all_available_tools() -> Dict[str, List[Dict[str, Any]]]:
         "file_system": [get_tool_info(tool) for tool in load_all_filesystem_tools()],
         "text": [get_tool_info(tool) for tool in load_all_text_tools()],
         "data": [get_tool_info(tool) for tool in load_all_data_tools()],
-        "read_only": [get_tool_info(tool) for tool in load_all_read_only_tools()],
     }

{basic_open_agent_tools-0.7.2 → basic_open_agent_tools-0.7.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.7.2
+Version: 0.7.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.7.2 → basic_open_agent_tools-0.7.4}/src/basic_open_agent_tools.egg-info/SOURCES.txt

@@ -16,7 +16,6 @@ src/basic_open_agent_tools/data/__init__.py
 src/basic_open_agent_tools/data/config_processing.py
 src/basic_open_agent_tools/data/csv_tools.py
 src/basic_open_agent_tools/data/json_tools.py
-src/basic_open_agent_tools/data/transform.py
 src/basic_open_agent_tools/data/validation.py
 src/basic_open_agent_tools/file_system/__init__.py
 src/basic_open_agent_tools/file_system/info.py
@@ -31,7 +30,6 @@ src/basic_open_agent_tools/utilities/__init__.py
 tests/test_data_config_processing.py
 tests/test_data_csv_tools.py
 tests/test_data_json_tools.py
-tests/test_data_transform.py
 tests/test_data_validation.py
 tests/test_file_system_tools.py
 tests/test_helpers.py

{basic_open_agent_tools-0.7.2 → basic_open_agent_tools-0.7.4}/tests/test_data_config_processing.py

@@ -12,7 +12,6 @@ from basic_open_agent_tools.data.config_processing import (
     validate_config_schema,
     write_ini_file,
 )
-from basic_open_agent_tools.exceptions import DataError
 
 # Import optional dependencies if available
 try:
@@ -229,7 +228,7 @@ class TestMergeConfigFiles:
             write_ini_file(config2, temp2_path)
 
             # Merge configs
-            merged = merge_config_files(temp1_path, temp2_path)
+            merged = merge_config_files([temp1_path, temp2_path], "ini")
 
             # Verify
             assert merged["server"]["host"] == "localhost"
@@ -247,7 +246,7 @@ class TestMergeConfigFiles:
     def test_merge_config_files_no_paths(self):
         """Test merging with no config paths."""
         with pytest.raises(ValueError):
-            merge_config_files()
+            merge_config_files([], "ini")
 
     def test_merge_config_files_mixed_formats(self):
         """Test merging files with different formats."""
@@ -263,8 +262,8 @@ class TestMergeConfigFiles:
             write_ini_file(config, temp1_path)
 
             # Try to merge different formats
-            with pytest.raises(DataError):
-                merge_config_files(temp1_path, temp2_path)
+            with pytest.raises(ValueError):  # Now raises ValueError for invalid format
+                merge_config_files([temp1_path, temp2_path], "invalid_format")
 
         finally:
             # Clean up

{basic_open_agent_tools-0.7.2 → basic_open_agent_tools-0.7.4}/tests/test_data_json_tools.py

@@ -18,13 +18,13 @@ class TestSafeJsonSerialize:
     def test_serialize_dict(self):
         """Test serializing a dictionary."""
         data = {"name": "test", "value": 42}
-        result = safe_json_serialize(data)
+        result = safe_json_serialize(data, 0)
         assert result == '{"name": "test", "value": 42}'
 
     def test_serialize_list(self):
         """Test serializing a list."""
         data = [1, 2, 3]
-        result = safe_json_serialize(data)
+        result = safe_json_serialize(data, 0)
         assert result == "[1, 2, 3]"
 
     def test_serialize_with_indent(self):
@@ -37,12 +37,12 @@ class TestSafeJsonSerialize:
     def test_serialize_unicode(self):
         """Test serializing Unicode characters."""
         data = {"message": "Hello 世界"}
-        result = safe_json_serialize(data)
+        result = safe_json_serialize(data, 0)
         assert "世界" in result
 
     def test_serialize_none(self):
         """Test serializing None."""
-        result = safe_json_serialize(None)
+        result = safe_json_serialize(None, 0)
         assert result == "null"
 
     def test_serialize_invalid_indent_type(self):
@@ -59,7 +59,7 @@ class TestSafeJsonSerialize:
         with pytest.raises(
             SerializationError, match="Failed to serialize data to JSON"
         ):
-            safe_json_serialize({"obj": CustomClass()})
+            safe_json_serialize({"obj": CustomClass()}, 0)
 
 
 class TestSafeJsonDeserialize:
@@ -147,7 +147,7 @@ class TestCompressJsonData:
         """Test compressing larger data for better compression."""
         data = {"repeated": "data" * 100, "numbers": list(range(100))}
         compressed = compress_json_data(data)
-        original_json = safe_json_serialize(data)
+        original_json = safe_json_serialize(data, 0)
 
         # Compressed should be smaller than original for repetitive data
         assert len(compressed) < len(original_json.encode("utf-8"))
@@ -226,7 +226,7 @@ class TestRoundTripSerialization:
         ]
 
         for original in test_cases:
-            serialized = safe_json_serialize(original)
+            serialized = safe_json_serialize(original, 0)
             deserialized = safe_json_deserialize(serialized)
             assert deserialized == original
 

{basic_open_agent_tools-0.7.2 → basic_open_agent_tools-0.7.4}/tests/test_helpers.py

@@ -225,6 +225,7 @@ class TestHelperFunctions:
         # Should have expected categories
         assert "file_system" in tools
         assert "text" in tools
+        assert "data" in tools
 
         # Each category should contain tool info
         for _category, category_tools in tools.items():