satif-ai 0.2.8__py3-none-any.whl → 0.2.9__py3-none-any.whl

satif_ai/{code_builders/transformation.py → transformation_builders/syncpulse.py}

@@ -8,7 +8,9 @@ from typing import Any, Dict, List, Optional, Union
 from agents import Agent, Runner, function_tool
 from agents.mcp.server import MCPServer
 from mcp import ClientSession
-from satif_core import AsyncCodeBuilder, CodeBuilder, SDIFDatabase
+from satif_core import AsyncTransformationBuilder
+from satif_core.types import FilePath
+from satif_sdk.code_executors.local_executor import LocalCodeExecutor
 from satif_sdk.comparators import get_comparator
 from satif_sdk.representers import get_representer
 from satif_sdk.transformers import CodeTransformer
@@ -61,7 +63,10 @@ async def execute_transformation(code: str) -> str:
     if INPUT_SDIF_PATH is None or OUTPUT_TARGET_FILES is None:
         return "Error: Transformation context not initialized"
 
-    code_transformer = CodeTransformer(function=code)
+    code_transformer = CodeTransformer(
+        function=code,
+        code_executor=LocalCodeExecutor(disable_security_warning=True),
+    )
     generated_output_path = code_transformer.export(INPUT_SDIF_PATH)
 
     comparisons = []
@@ -120,19 +125,7 @@ async def execute_transformation(code: str) -> str:
     return "\n".join(comparisons)
 
 
-class TransformationCodeBuilder(CodeBuilder):
-    def __init__(self, output_example: Path | List[Path] | Dict[str, Path]):
-        self.output_example = output_example
-
-    def build(
-        self,
-        sdif: Path | SDIFDatabase,
-        instructions: Optional[str] = None,
-    ) -> str:
-        pass
-
-
-class TransformationAsyncCodeBuilder(AsyncCodeBuilder):
+class SyncpulseTransformationBuilder(AsyncTransformationBuilder):
     """This class is used to build a transformation code that will be used to transform a SDIF database into a set of files following the format of the given output files."""
 
     def __init__(
@@ -147,23 +140,18 @@ class TransformationAsyncCodeBuilder(AsyncCodeBuilder):
 
     async def build(
         self,
-        sdif: Path,  # This will now be relative to project root (MCP server CWD)
-        output_target_files: Dict[Union[str, Path], str] | List[Path],
-        output_sdif: Optional[Path] = None,  # This will now be relative or None
+        sdif: Path,
+        output_target_files: Dict[FilePath, str] | List[FilePath] | FilePath,
+        output_sdif: Optional[Path] = None,
         instructions: str = "",
         schema_only: bool = False,
-        representer_options_for_build: Optional[Dict[str, Any]] = None,
+        representer_kwargs: Optional[Dict[str, Any]] = None,
     ) -> str:
         global INPUT_SDIF_PATH, OUTPUT_TARGET_FILES, SCHEMA_ONLY
-        # INPUT_SDIF_PATH is used by execute_transformation tool, needs to be accessible from where that tool runs.
-        # If execute_transformation runs in the same process as the builder, absolute path is fine.
-        # If it were a separate context, this might need adjustment.
-        # For now, assume execute_transformation can access absolute paths if needed for its *input SDIF*.
-        # However, the sdif for MCP URIs must be relative.
+
         INPUT_SDIF_PATH = Path(sdif).resolve()
         SCHEMA_ONLY = schema_only
-        # Paths for MCP URIs are now expected to be relative to MCP server CWD (project root)
-        # So, use them directly as strings.
+        # We must encode the path because special characters are not allowed in mcp read_resource()
         input_sdif_mcp_uri_path = base64.b64encode(str(sdif).encode()).decode()
         output_sdif_mcp_uri_path = (
             base64.b64encode(str(output_sdif).encode()).decode()
@@ -205,9 +193,14 @@ class TransformationAsyncCodeBuilder(AsyncCodeBuilder):
 
         # OUTPUT_TARGET_FILES keys are absolute paths to original example files for local reading by representers/comparators.
         # Values are agent-facing filenames.
-        if isinstance(output_target_files, list):
+        if isinstance(output_target_files, FilePath):
+            OUTPUT_TARGET_FILES = {
+                Path(output_target_files).resolve(): Path(output_target_files).name
+            }
+        elif isinstance(output_target_files, list):
             OUTPUT_TARGET_FILES = {
-                file_path.resolve(): file_path.name for file_path in output_target_files
+                Path(file_path).resolve(): Path(file_path).name
+                for file_path in output_target_files
             }
         elif isinstance(output_target_files, dict):
             temp_map = {}
@@ -229,7 +222,7 @@ class TransformationAsyncCodeBuilder(AsyncCodeBuilder):
                     # Representer uses the absolute path (file_key_abs_path) to read the example file.
                     representer = get_representer(file_key_abs_path)
                     representation, used_params = representer.represent(
-                        file_key_abs_path, **(representer_options_for_build or {})
+                        file_key_abs_path, **(representer_kwargs or {})
                     )
                     output_representation[agent_facing_name] = {
                         "representation": representation,

satif_ai/utils/__init__.py

@@ -0,0 +1,5 @@
+from .merge_sdif import merge_sdif_files
+from .openai_mcp import OpenAICompatibleMCP
+from .zip import extract_zip_archive_async
+
+__all__ = ["merge_sdif_files", "extract_zip_archive_async", "OpenAICompatibleMCP"]

satif_ai/utils/merge_sdif.py

@@ -0,0 +1,22 @@
+from pathlib import Path
+from typing import List
+
+
+async def merge_sdif_files(sdif_paths: List[Path], output_dir: Path) -> Path:
+    """Placeholder function to merge multiple SDIF files into one.
+
+    Args:
+        sdif_paths: A list of paths to the SDIF files to merge.
+        output_dir: The directory where the merged file should be saved.
+
+    Returns:
+        Path to the merged SDIF file.
+    """
+    if not sdif_paths:
+        raise ValueError("No SDIF files provided for merging.")
+
+    if len(sdif_paths) == 1:
+        return sdif_paths[0]  # No merge needed
+
+    # TODO: Implement SDIF merge
+    raise NotImplementedError("Merge not implemented yet.")

satif_ai/utils/openai_mcp.py

@@ -0,0 +1,97 @@
+import logging
+from typing import Any
+
+from agents.mcp.server import CallToolResult, MCPServer, MCPTool
+from fastmcp import FastMCP
+
+logger = logging.getLogger(__name__)
+
+
+class OpenAICompatibleMCP(MCPServer):
+    def __init__(self, mcp: FastMCP):
+        self.mcp = mcp
+        self._is_connected = False  # Track connection state
+
+    async def connect(self):
+        """Connect to the server.
+        For FastMCP, connection is managed externally when the server is run.
+        This method marks the wrapper as connected.
+        """
+        # Assuming FastMCP instance is already running and configured.
+        # No specific connect action required for the FastMCP instance itself here,
+        # as its lifecycle (run, stop) is managed outside this wrapper.
+        logger.info(
+            f"OpenAICompatibleMCP: Simulating connection to FastMCP server '{self.mcp.name}'."
+        )
+        self._is_connected = True
+
+    @property
+    def name(self) -> str:
+        """A readable name for the server."""
+        return self.mcp.name
+
+    async def cleanup(self):
+        """Cleanup the server.
+        For FastMCP, cleanup is managed externally. This method marks the wrapper as disconnected.
+        """
+        # Similar to connect, actual server cleanup is external.
+        logger.info(
+            f"OpenAICompatibleMCP: Simulating cleanup for FastMCP server '{self.mcp.name}'."
+        )
+        self._is_connected = False
+
+    async def list_tools(self) -> list[MCPTool]:
+        """List the tools available on the server."""
+        if not self._is_connected:
+            # Or raise an error, depending on desired behavior for disconnected state
+            raise RuntimeError(
+                "OpenAICompatibleMCP.list_tools called while not connected."
+            )
+
+        # FastMCP's get_tools() returns a dict[str, fastmcp.tools.tool.Tool]
+        # Each fastmcp.tools.tool.Tool has a to_mcp_tool(name=key) method
+        # MCPTool is an alias for mcp.types.Tool
+        try:
+            fastmcp_tools = await self.mcp.get_tools()
+            mcp_tools_list = [
+                tool.to_mcp_tool(name=key) for key, tool in fastmcp_tools.items()
+            ]
+            return mcp_tools_list
+        except Exception as e:
+            logger.error(
+                f"Error listing tools from FastMCP server '{self.mcp.name}': {e}",
+                exc_info=True,
+            )
+            raise e
+
+    async def call_tool(
+        self, tool_name: str, arguments: dict[str, Any] | None
+    ) -> CallToolResult:
+        """Invoke a tool on the server."""
+        if not self._is_connected:
+            logger.warning(
+                f"OpenAICompatibleMCP.call_tool '{tool_name}' called while not connected."
+            )
+            # Return an error CallToolResult
+            return CallToolResult(
+                content=[{"type": "text", "text": "Server not connected"}], isError=True
+            )
+
+        try:
+            # FastMCP's _mcp_call_tool is a protected member, but seems to be what we need.
+            # It returns: list[TextContent | ImageContent | EmbeddedResource]
+            # This matches the 'content' part of CallToolResult.
+            # We need to handle potential errors and wrap the result.
+            content = await self.mcp._mcp_call_tool(tool_name, arguments or {})
+            return CallToolResult(content=content, isError=False)
+        except Exception as e:
+            logger.error(
+                f"Error calling tool '{tool_name}' on FastMCP server '{self.mcp.name}': {e}",
+                exc_info=True,
+            )
+            error_message = f"Error calling tool '{tool_name}': {type(e).__name__}: {e}"
+            # Ensure content is a list of valid MCP content items, even for errors.
+            # A TextContent is a safe choice.
+            return CallToolResult(
+                content=[{"type": "text", "text": error_message}], isError=True
+            )

satif_ai/utils/zip.py

@@ -0,0 +1,120 @@
+import asyncio
+import logging
+import zipfile
+from pathlib import Path
+from typing import List, Tuple
+
+logger = logging.getLogger(__name__)
+
+# Constants for ZIP file processing, kept local to this utility or passed as args if needed
+_IGNORED_ZIP_MEMBER_PREFIXES = ("__MACOSX/",)
+_IGNORED_ZIP_FILENAME_PREFIXES = ("._",)
+_IGNORED_ZIP_FILENAMES = (".DS_Store",)
+
+
+async def extract_zip_archive_async(
+    zip_path: Path,
+    extract_to: Path,
+    ignored_member_prefixes: Tuple[str, ...] = _IGNORED_ZIP_MEMBER_PREFIXES,
+    ignored_filename_prefixes: Tuple[str, ...] = _IGNORED_ZIP_FILENAME_PREFIXES,
+    ignored_filenames: Tuple[str, ...] = _IGNORED_ZIP_FILENAMES,
+) -> List[Path]:
+    """
+    Asynchronously extracts a ZIP archive to a specified directory, filtering out ignored files.
+
+    Args:
+        zip_path: Path to the ZIP archive.
+        extract_to: Directory where the contents will be extracted.
+        ignored_member_prefixes: Tuple of member path prefixes to ignore.
+        ignored_filename_prefixes: Tuple of filename prefixes to ignore.
+        ignored_filenames: Tuple of exact filenames to ignore.
+
+    Returns:
+        A list of paths to the successfully extracted files.
+
+    Raises:
+        ValueError: If the zip_path is invalid or corrupted.
+        RuntimeError: If any other error occurs during extraction.
+    """
+
+    def blocking_extract() -> List[Path]:
+        extracted_file_paths = []
+        logger.info(f"Extracting ZIP archive '{zip_path.name}' to '{extract_to}'...")
+        try:
+            extract_to.mkdir(
+                parents=True, exist_ok=True
+            )  # Ensure extract_to directory exists
+
+            with zipfile.ZipFile(zip_path, "r") as zip_ref:
+                # Security: Preliminary check for unsafe paths before extraction
+                for member_name in zip_ref.namelist():
+                    if member_name.startswith(("/", "..")):
+                        logger.error(
+                            f"Skipping potentially unsafe path in ZIP: {member_name}"
+                        )
+                        # Depending on security policy, might raise an error here
+                        continue
+
+                # Extract all members
+                zip_ref.extractall(extract_to)
+
+            # After extractall, collect all *file* paths, applying filters
+            # This second pass of filtering ensures that even if extractall creates them,
+            # we don't return paths to ignored files.
+            for root, _, files in extract_to.walk():
+                for filename in files:
+                    full_path = root / filename
+                    # Create a path relative to 'extract_to' to check against member prefixes
+                    # This ensures that '__MACOSX/file.txt' is correctly ignored,
+                    # not just a top-level '__MACOSX' directory.
+                    try:
+                        relative_path_to_check = full_path.relative_to(extract_to)
+                    except ValueError:
+                        # This can happen if full_path is not under extract_to,
+                        # which ideally shouldn't occur if zip_ref.extractall worked as expected
+                        # and target_path checks were effective.
+                        logger.warning(
+                            f"File {full_path} seems to be outside extraction root {extract_to}. Skipping."
+                        )
+                        continue
+
+                    path_str_to_check_prefixes = str(relative_path_to_check)
+
+                    if not (
+                        any(
+                            path_str_to_check_prefixes.startswith(p)
+                            for p in ignored_member_prefixes
+                        )
+                        or any(
+                            full_path.name.startswith(p)
+                            for p in ignored_filename_prefixes
+                        )
+                        or full_path.name in ignored_filenames
+                    ):
+                        extracted_file_paths.append(full_path)
+                    else:
+                        logger.debug(f"Ignoring file post-extraction: {full_path}")
+
+            if not extracted_file_paths:
+                logger.warning(
+                    f"ZIP archive '{zip_path.name}' is empty or contains no processable files after filtering."
+                )
+            else:
+                logger.info(
+                    f"Successfully extracted {len(extracted_file_paths)} file(s) from '{zip_path.name}'."
+                )
+            return extracted_file_paths
+        except zipfile.BadZipFile as e:
+            logger.error(
+                f"Invalid or corrupted ZIP file: {zip_path.name}", exc_info=True
+            )
+            raise ValueError(f"Invalid or corrupted ZIP file: {zip_path.name}") from e
+        except Exception as e:
+            logger.error(
+                f"Failed to extract ZIP archive '{zip_path.name}': {e}", exc_info=True
+            )
+            raise RuntimeError(
+                f"Unexpected error during ZIP extraction for '{zip_path.name}'"
+            ) from e
+
+    return await asyncio.to_thread(blocking_extract)

{satif_ai-0.2.8.dist-info → satif_ai-0.2.9.dist-info}/METADATA

@@ -1,10 +1,11 @@
 Metadata-Version: 2.3
 Name: satif-ai
-Version: 0.2.8
+Version: 0.2.9
 Summary: AI Agents for Satif
 License: MIT
-Author: Bryan Djafer
-Author-email: bryan.djafer@syncpulse.fr
+Author: Syncpulse
+Maintainer: Bryan Djafer
+Maintainer-email: bryan.djafer@syncpulse.fr
 Requires-Python: >=3.10,<4.0
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3

satif_ai-0.2.9.dist-info/RECORD

@@ -0,0 +1,19 @@
+satif_ai/__init__.py,sha256=cqJ6Kd9IolVodPi9yOBPnfhYQXH5a1JgRB3HfLOtP_4,611
+satif_ai/adapters/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+satif_ai/adapters/tidy.py,sha256=lcJXFmzEgCFy1W57kgbMOkoFTPLOkrvHC6NHVRKn-04,18549
+satif_ai/standardize.py,sha256=TgAB_nhcHY8zqlfT1PpgfgSswqdE-ly-dheQz-7NC7Q,5674
+satif_ai/standardizers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+satif_ai/standardizers/ai.py,sha256=5vv-Rs6s_9FA21uM2iepTsbv6f3adZ8wFteOcW53z_s,21458
+satif_ai/standardizers/ai_csv.py,sha256=tMibsTp55sHJ56r7cYKjb5b0Hm6rdnV3TeA0EppIWJg,25371
+satif_ai/transform.py,sha256=iy9prkBCknRcsSXWOY_NwtNojQVcRW_luYFwkcjOnPw,5600
+satif_ai/transformation_builders/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+satif_ai/transformation_builders/syncpulse.py,sha256=c59BZicNnqs3NDKpflBAPqw42pGb6nYB2Zps0ChGyaM,11368
+satif_ai/utils/__init__.py,sha256=F-usaCt_vX872mXvtukuZdNMPnkVqDb8RaDgox2uow4,212
+satif_ai/utils/merge_sdif.py,sha256=-BXsCaLDHEtKOQRWOKyVCNefFwkyVygFQs8NeeFONFA,663
+satif_ai/utils/openai_mcp.py,sha256=duCQZXG0mBs9DOOFIUvzraJhxD2IDzegWO9iOiLfFwY,3938
+satif_ai/utils/zip.py,sha256=G_GK8629Iw0TLFCQJfnqOscv7MoKF5zdzxvEAbL7Gss,5186
+satif_ai-0.2.9.dist-info/LICENSE,sha256=kS8EN6yAaGZd7V5z6GKSn_x3ozcZltrfRky4vMPRCw8,1072
+satif_ai-0.2.9.dist-info/METADATA,sha256=Vq62i6fUx8sKaM2mYVqRfGReHCTcFG_P6mW1otnx8GY,696
+satif_ai-0.2.9.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+satif_ai-0.2.9.dist-info/entry_points.txt,sha256=Mz2SwYALjktap1bF-Q3EWBgiZVNT6QJCVsCs_fCV33Y,43
+satif_ai-0.2.9.dist-info/RECORD,,

satif_ai/code_builders/adaptation.py

@@ -1,9 +0,0 @@
-from satif_core.code_builders.base import AsyncCodeBuilder, CodeBuilder
-
-
-class AdaptationCodeBuilder(CodeBuilder):
-    pass
-
-
-class AdaptationAsyncCodeBuilder(AsyncCodeBuilder):
-    pass

satif_ai-0.2.8.dist-info/RECORD

@@ -1,13 +0,0 @@
-satif_ai/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-satif_ai/adapters/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-satif_ai/adapters/tidy.py,sha256=2oYj7Gz3vOQtzcpoJI4JbftWlMKvOWL8rdwthjg-zUE,19884
-satif_ai/code_builders/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-satif_ai/code_builders/adaptation.py,sha256=E29YM0S6pMtAfB0uzSUexoeWKwXfF8iJVyYUCKWQz5k,188
-satif_ai/code_builders/transformation.py,sha256=5B7a6lDv-gqQo83F8fQeSw2gHpDgznoDfjXsASkLc60,11870
-satif_ai/standardizers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-satif_ai/standardizers/ai_csv.py,sha256=c0CKnIib610GgwGqaF8NaqT_P4pZ2BupO-BTSNuIhoc,25385
-satif_ai-0.2.8.dist-info/LICENSE,sha256=kS8EN6yAaGZd7V5z6GKSn_x3ozcZltrfRky4vMPRCw8,1072
-satif_ai-0.2.8.dist-info/METADATA,sha256=CZBbNd1A-KL8eoOzmmz7bW3ue4HGOC2Qic60wQ-v6z8,670
-satif_ai-0.2.8.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-satif_ai-0.2.8.dist-info/entry_points.txt,sha256=Mz2SwYALjktap1bF-Q3EWBgiZVNT6QJCVsCs_fCV33Y,43
-satif_ai-0.2.8.dist-info/RECORD,,