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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: basic-open-agent-tools
-Version: 0.7.2
+Version: 0.7.3
 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.3}/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.3"  # Remove Any types from function parameters for Google ADK 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.7.2 → basic_open_agent_tools-0.7.3}/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.3"
 
 # Modular structure
 from . import data, exceptions, file_system, text, types

{basic_open_agent_tools-0.7.2 → basic_open_agent_tools-0.7.3}/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.3}/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.3}/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.3}/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.3/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.3
 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.3}/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.3}/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