satif-ai 0.2.6__tar.gz → 0.2.8__tar.gz

{satif_ai-0.2.6 → satif_ai-0.2.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: satif-ai
-Version: 0.2.6
+Version: 0.2.8
 Summary: AI Agents for Satif
 License: MIT
 Author: Bryan Djafer

{satif_ai-0.2.6 → satif_ai-0.2.8}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "satif-ai"
-version = "0.2.6"
+version = "0.2.8"
 description = "AI Agents for Satif"
 authors = [
     {name = "Bryan Djafer", email = "bryan.djafer@syncpulse.fr"}
@@ -47,6 +47,7 @@ lint.ignore = [
     "UP007",
     # We actually do want to import from typing_extensions
     "UP035",
+    "UP038",
     # Relax the convention by _not_ requiring documentation for every function parameter.
     "D417",
     "E501",

{satif_ai-0.2.6 → satif_ai-0.2.8}/satif_ai/code_builders/transformation.py

@@ -19,6 +19,37 @@ OUTPUT_TARGET_FILES: Optional[Dict[Union[str, Path], str]] = None
 SCHEMA_ONLY: Optional[bool] = None
 
 
+def _format_comparison_output(
+    comparison_result: Dict[str, Any],
+    schema_only_mode: Optional[bool],
+    source_file_display_name: str,
+    target_file_display_name: str,
+) -> str:
+    """
+    Formats the comparison result string, with special handling for schema_only mode
+    where files are equivalent due to being empty.
+    """
+    base_message_prefix = f"Comparison for {source_file_display_name} [SOURCE] with {target_file_display_name} [TARGET]:"
+
+    if schema_only_mode is True and comparison_result.get("are_equivalent") is True:
+        details = comparison_result.get("details", {})
+        row_comparison = details.get("row_comparison", {})
+
+        row_count1 = row_comparison.get("row_count1")
+        row_count2 = row_comparison.get("row_count2")
+
+        if (
+            isinstance(row_count1, (int, float))
+            and row_count1 == 0
+            and isinstance(row_count2, (int, float))
+            and row_count2 == 0
+        ):
+            return f"{base_message_prefix} Files have the same headers but are both empty (no data rows). This should not happen. Please verify the instructions and try again."
+
+    # Default formatting if the special condition isn't met
+    return f"{base_message_prefix} {comparison_result}"
+
+
 @function_tool
 async def execute_transformation(code: str) -> str:
     """Executes the transformation code on the input and returns the
@@ -34,7 +65,7 @@ async def execute_transformation(code: str) -> str:
     generated_output_path = code_transformer.export(INPUT_SDIF_PATH)
 
     comparisons = []
-    comparator_kwargs = {"check_structure_only": True}
+    comparator_kwargs = {}
     if SCHEMA_ONLY:
         comparator_kwargs["check_structure_only"] = True
 
@@ -54,9 +85,13 @@ async def execute_transformation(code: str) -> str:
                 comparison = comparator.compare(
                     generated_file_path, output_base_file, **comparator_kwargs
                 )
-                comparisons.append(
-                    f"Comparison for {generated_file_path} [SOURCE] with {output_target_file_name} [TARGET]: {comparison}"
+                formatted_message = _format_comparison_output(
+                    comparison,
+                    SCHEMA_ONLY,
+                    generated_file_path,
+                    output_target_file_name,
                 )
+                comparisons.append(formatted_message)
             else:
                 comparisons.append(
                     f"Error: {output_target_file_name} not found in the generated output"
@@ -70,9 +105,13 @@ async def execute_transformation(code: str) -> str:
             comparison = comparator.compare(
                 generated_output_path, output_file, **comparator_kwargs
             )
-            comparisons.append(
-                f"Comparison for {generated_output_path} [SOURCE] with {output_target_file_name} [TARGET]: {comparison}"
+            formatted_message = _format_comparison_output(
+                comparison,
+                SCHEMA_ONLY,
+                str(generated_output_path),
+                output_target_file_name,
             )
+            comparisons.append(formatted_message)
         else:
             comparisons.append(
                 "Error: Single output file generated but multiple target files expected"
@@ -111,7 +150,7 @@ class TransformationAsyncCodeBuilder(AsyncCodeBuilder):
         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
-        instructions: Optional[str] = None,
+        instructions: str = "",
         schema_only: bool = False,
         representer_options_for_build: Optional[Dict[str, Any]] = None,
     ) -> str:
@@ -220,11 +259,10 @@ class TransformationAsyncCodeBuilder(AsyncCodeBuilder):
                 "output_schema": output_schema_text,
                 "output_sample": output_sample_text
                 if not SCHEMA_ONLY
-                else "Sample not available.",
-                "output_representation": str(
-                    output_representation
-                ),  # Representation keyed by agent-facing name
-                "instructions": instructions,
+                else "Sample not available. File is empty (no data).",
+                "output_representation": str(output_representation),
+                "instructions": instructions
+                or "No instructions provided. Use the output example.",
             },
         )
         agent = Agent(

{satif_ai-0.2.6 → satif_ai-0.2.8}/satif_ai/standardizers/ai_csv.py

@@ -12,12 +12,13 @@ from agents import Agent, Runner, function_tool
 from agents.mcp.server import MCPServerStdio
 from charset_normalizer import detect
 from mcp import ClientSession
-from satif_core.types import Datasource, SDIFPath
+from satif_core.types import Datasource, SDIFPath, StandardizationResult
 from satif_sdk.standardizers.csv import (
+    CSVStandardizer,
+)
+from satif_sdk.utils import (
     DELIMITER_SAMPLE_SIZE,
     ENCODING_SAMPLE_SIZE,
-    CSVStandardizer,
-    SkipColumnsConfig,
 )
 
 logger = logging.getLogger(__name__)
@@ -50,7 +51,7 @@ You are an expert CSV Data Standardization Agent. Your mission is to analyze a g
 
 3.  **Column Analysis and Definition:**
     *   For **each column** you identify that should be included in the final table:
-        *   `identifier_in_csv` (string): This is how the column is found in the *raw CSV data*.
+        *   `original_identifier` (string): This is how the column is found in the *raw CSV data*.
             *   If `has_header` is true, this is the **exact original header name** from the CSV.
             *   If `has_header` is false, this is a **string representation of the 0-based column index** (e.g., "0", "1", "2").
         *   `final_column_name` (string): This is the desired name for the column in the SDIF database table. It **MUST** be:
@@ -76,7 +77,7 @@ You are an expert CSV Data Standardization Agent. Your mission is to analyze a g
         "skip_rows": 0, // Integer for initial N, or sorted list of 0-based indices e.g. [0, 1, 5]
         "columns": [
             {{
-                "identifier_in_csv": "original_header_or_index_string",
+                "original_identifier": "original_header_or_index_string",
                 "final_column_name": "sanitized_snake_case_name",
                 "description": null // Or string value. Null or omit if not generated.
             }}
@@ -88,19 +89,18 @@ You are an expert CSV Data Standardization Agent. Your mission is to analyze a g
 **Tools Available:**
 - `read_csv_sample(encoding: str, delimiter: str, skip_initial_rows: int = 0, row_limit: int = 20, include_row_indices: bool = False)`: Reads a sample from the *beginning* of the file. Crucial for header and initial structure.
 - `read_raw_lines(encoding: str, line_limit: int = 50, start_line: int = 0)`: Reads raw lines. Useful for finding specific rows to skip (empty, repeated headers, footers) by their 0-based index.
-- `get_file_chunk(encoding: str, start_byte: int = 0, end_byte: int = 4096)`: Reads a raw chunk. Good for diagnosing encoding/delimiter issues if `read_csv_sample` returns garbled data or errors.
 
 **General Workflow Guidance:**
-1.  **Initial Probe & Core Params:** Use `read_csv_sample` with initial hints (and `include_row_indices=True`) to examine the first few rows. Verify/correct `encoding` and `delimiter`. If `read_csv_sample` reports errors or shows garbled data, use `get_file_chunk` with different encodings to diagnose. Determine `has_header` by looking at the first non-skipped row.
+1.  **Initial Probe & Core Params:** Use `read_csv_sample` with initial hints (and `include_row_indices=True`) to examine the first few rows. Verify/correct `encoding` and `delimiter`. If `read_csv_sample` reports errors or shows garbled data. Determine `has_header` by looking at the first non-skipped row.
 2.  **Identify Skip Rows:**
     *   If there's metadata/comments at the top, determine how many initial rows to skip and use that for `skip_rows` (integer value).
     *   Use `read_raw_lines` to scan for other rows to skip (e.g., empty lines, comment lines, repeated headers mid-file, summary footers). Collect all 0-based indices of such rows. If you have specific indices, `skip_rows` should be a sorted list of these indices. If you only skip initial N rows, it's an integer.
 3.  **Column Identification & Definition:**
     *   After settling `skip_rows` and `has_header`, call `read_csv_sample` again with `skip_initial_rows` set appropriately (if `skip_rows` is an int) to see the clean data rows and the header (if present).
-    *   If `has_header` is true, the first row from this clean sample gives you the `identifier_in_csv` values (original header names).
-    *   If `has_header` is false, the `identifier_in_csv` for each column will be its 0-based index as a string (e.g., "0", "1", "2", ... for as many columns as you see in the first data row).
+    *   If `has_header` is true, the first row from this clean sample gives you the `original_identifier` values (original header names).
+    *   If `has_header` is false, the `original_identifier` for each column will be its 0-based index as a string (e.g., "0", "1", "2", ... for as many columns as you see in the first data row).
     *   For each column you decide to include:
-        *   Determine its `identifier_in_csv`.
+        *   Determine its `original_identifier`.
         *   Create a clean, descriptive `final_column_name` (snake_case).
         *   If (and ONLY IF) necessary, write a `description` for that column.
 4.  **Table Naming & Description:** Based on the clean data and column names, formulate a `table_name` and, if valuable, a `table_description`.
@@ -273,60 +273,6 @@ async def read_raw_lines(
     )
 
 
-@function_tool
-async def get_file_chunk(
-    encoding: str, start_byte: int | None, end_byte: int | None
-) -> str:
-    if start_byte is None:
-        start_byte = 0
-    if end_byte is None:
-        end_byte = 4096
-    context = _CURRENT_AI_CSV_TOOL_CONTEXT.get()
-    if not context or not context.file_path or not context.file_path.exists():
-        return json.dumps({"error": "File path not found in tool context."})
-    if start_byte < 0 or end_byte < start_byte:
-        return json.dumps({"error": "Invalid byte range specified."})
-
-    chunk_text = ""
-    error_message = None
-    bytes_read = 0
-    try:
-        with open(context.file_path, "rb") as fb:
-            file_size = context.file_path.stat().st_size
-            effective_start_byte = min(start_byte, file_size)
-            fb.seek(effective_start_byte)
-            bytes_to_read = max(0, min(end_byte, file_size) - effective_start_byte)
-            if bytes_to_read > 0:
-                chunk_bytes = fb.read(bytes_to_read)
-                bytes_read = len(chunk_bytes)
-                chunk_text = chunk_bytes.decode(encoding, errors="replace")
-            else:
-                chunk_text = ""
-        return json.dumps(
-            {
-                "chunk": chunk_text,
-                "bytes_read": bytes_read,
-                "requested_range": [start_byte, end_byte],
-                "error": None,
-            }
-        )
-    except (UnicodeDecodeError, ValueError) as e:
-        error_message = f"Failed to decode file chunk: {e}. Used encoding '{encoding}'."
-    except OSError as e:
-        error_message = f"File read error: {e}."
-    except Exception as e:
-        logger.error(f"Unexpected error in get_file_chunk tool: {e}", exc_info=True)
-        error_message = f"Unexpected error reading file chunk: {str(e)}"
-    return json.dumps(
-        {
-            "error": error_message,
-            "chunk": chunk_text,
-            "bytes_read": bytes_read,
-            "requested_range": [start_byte, end_byte],
-        }
-    )
-
-
 # --- AICSVStandardizer Class ---
 class AICSVStandardizer(CSVStandardizer):  # Inherits from the enhanced CSVStandardizer
     def __init__(
@@ -337,19 +283,18 @@ class AICSVStandardizer(CSVStandardizer):  # Inherits from the enhanced CSVStand
         # --- Initial Hints (Optional) ---
         initial_delimiter: Optional[str] = None,
         initial_encoding: Optional[str] = None,
-        # --- Base Class Args Passthrough (some will be overridden by AI) ---
-        default_skip_columns: SkipColumnsConfig = None,  # Keep for base if AI doesn't define cols
     ):
+        # AI will determine the file_configs
         super().__init__(
-            delimiter=None,  # AI will determine
-            encoding=None,  # AI will determine
-            has_header=True,  # AI will determine
-            skip_rows=0,  # AI will determine
-            skip_columns=default_skip_columns,  # Can still be a fallback
-            descriptions=None,  # AI will generate table_description
-            table_names=None,  # AI will generate table_name
-            file_configs=None,  # AI provides all config for the one file
-            column_definitions=None,  # AI will generate column definitions
+            delimiter=None,
+            encoding=None,
+            has_header=True,
+            skip_rows=0,
+            skip_columns=None,
+            descriptions=None,
+            table_names=None,
+            file_configs=None,
+            column_definitions=None,
         )
 
         self.mcp_servers = [mcp_server] if mcp_server else []
@@ -357,7 +302,6 @@ class AICSVStandardizer(CSVStandardizer):  # Inherits from the enhanced CSVStand
         self.llm_model = llm_model
         self._initial_delimiter_hint = initial_delimiter
         self._initial_encoding_hint = initial_encoding
-        # self.generate_description from prompt structure (table_description, column descriptions)
 
     async def _get_initial_guesses(self, file_path: Path) -> Tuple[str, str]:
         """Helper to get initial encoding and delimiter guesses for a single file."""
@@ -419,7 +363,7 @@ class AICSVStandardizer(CSVStandardizer):  # Inherits from the enhanced CSVStand
             agent = Agent(
                 name="CSV Detail Analyzer Agent",
                 mcp_servers=self.mcp_servers,
-                tools=[read_csv_sample, read_raw_lines, get_file_chunk],
+                tools=[read_csv_sample, read_raw_lines],
                 model=self.llm_model,
             )
             logger.info(f"Running CSV Detail Analyzer Agent for {file_path.name}...")
@@ -469,7 +413,7 @@ class AICSVStandardizer(CSVStandardizer):  # Inherits from the enhanced CSVStand
                         raise ValueError(
                             f"Each item in 'columns' list must be a dictionary. Found: {type(col_spec)}"
                         )
-                    req_col_keys = {"identifier_in_csv", "final_column_name"}
+                    req_col_keys = {"original_identifier", "final_column_name"}
                     if not req_col_keys.issubset(col_spec.keys()):
                         missing_col_keys = req_col_keys - col_spec.keys()
                         raise ValueError(
@@ -520,7 +464,7 @@ class AICSVStandardizer(CSVStandardizer):  # Inherits from the enhanced CSVStand
         overwrite: bool = False,
         config: Optional[Dict[str, Any]] = None,
         **kwargs,
-    ) -> Path:
+    ) -> StandardizationResult:
         output_path_obj = Path(output_path)
 
         input_paths: List[Path]
@@ -545,8 +489,6 @@ class AICSVStandardizer(CSVStandardizer):  # Inherits from the enhanced CSVStand
                     f"Input CSV file not found or is not a file: {input_file_path}"
                 )
 
-            # Create a task for each file's analysis
-            # Need to wrap _get_initial_guesses and _run_analysis_agent in a single async co-routine for gather
             async def analyze_file_task(file_path_for_task: Path):
                 logger.info(
                     f"--- Starting AI Analysis for file: {file_path_for_task.name} ---"
@@ -554,86 +496,62 @@ class AICSVStandardizer(CSVStandardizer):  # Inherits from the enhanced CSVStand
                 enc_guess, delim_guess = await self._get_initial_guesses(
                     file_path_for_task
                 )
-                return await self._run_analysis_agent(
+                # Store the raw AI output for this file, potentially to add to StandardizationResult later
+                # This requires _run_analysis_agent to return the raw JSON string or parsed dict
+                ai_params_for_file = await self._run_analysis_agent(
                     file_path_for_task, enc_guess, delim_guess
                 )
+                return file_path_for_task, ai_params_for_file  # Return path with params
 
-            ai_analysis_tasks.append(
-                analyze_file_task(input_file_path)
-            )  # Pass the path to the task
+            ai_analysis_tasks.append(analyze_file_task(input_file_path))
 
         logger.info(f"Starting AI analysis for {len(ai_analysis_tasks)} CSV file(s)...")
+        all_ai_params_results_with_paths: List[Tuple[Path, Dict[str, Any]]] = []
         try:
-            all_ai_params_results = await asyncio.gather(*ai_analysis_tasks)
+            all_ai_params_results_with_paths = await asyncio.gather(*ai_analysis_tasks)
         except Exception as e:
             logger.exception(f"Critical error during concurrent AI analysis phase: {e}")
             raise RuntimeError("AI analysis phase failed.") from e
 
         logger.info(
-            f"AI analysis complete for all {len(all_ai_params_results)} file(s)."
+            f"AI analysis complete for all {len(all_ai_params_results_with_paths)} file(s)."
         )
 
-        # Aggregate parameters for the base CSVStandardizer
-        all_ai_table_names: List[str] = []
-        all_ai_table_descriptions: List[Optional[str]] = []
         all_ai_file_configs: List[Dict[str, Any]] = []
-        all_ai_column_definitions: List[
-            List[Dict[str, Any]]
-        ] = []  # List of lists of col_specs
-
-        for i, ai_params in enumerate(all_ai_params_results):
-            current_file_path = input_paths[i]  # Get corresponding input path
-            logger.info(f"Aggregating AI parameters for: {current_file_path.name}")
-            logger.info(f"  AI Table Name: {ai_params['table_name']}")
-            logger.info(f"  AI Encoding: {ai_params['encoding']}")
-            logger.info(f"  AI Delimiter: '{ai_params['delimiter']}'")
-            logger.info(f"  AI Has Header: {ai_params['has_header']}")
-            logger.info(f"  AI Skip Rows: {ai_params['skip_rows']}")
-            logger.info(
-                f"  AI Table Description: {ai_params.get('table_description') if ai_params.get('table_description') is not None else 'N/A'}"
-            )
-            # logger.info(f"  AI Column Definitions ({len(ai_params['columns'])} cols): {ai_params['columns'][:2]}...") # Log a sample
 
-            all_ai_table_names.append(ai_params["table_name"])
-            all_ai_table_descriptions.append(ai_params.get("table_description"))
+        for file_path, ai_params in all_ai_params_results_with_paths:
+            logger.info(f"Aggregating AI parameters for: {file_path.name}")
 
-            file_conf = {
+            file_conf_for_base = {
+                "table_name": ai_params["table_name"],
+                "description": ai_params.get("table_description"),
                 "encoding": ai_params["encoding"],
                 "delimiter": ai_params["delimiter"],
                 "has_header": ai_params["has_header"],
                 "skip_rows": ai_params["skip_rows"],
-                "skip_columns": None,  # Column selection is handled by column_definitions
+                "column_definitions": ai_params["columns"],
             }
-            all_ai_file_configs.append(file_conf)
-            all_ai_column_definitions.append(
-                ai_params["columns"]
-            )  # This is List[Dict], so we append it directly
+            all_ai_file_configs.append(file_conf_for_base)
 
-        # Instantiate the base CSVStandardizer with aggregated AI-derived parameters
-        logger.info(
-            "Initializing final CSVStandardizer with aggregated AI parameters..."
-        )
-        final_processor = CSVStandardizer(
-            table_names=all_ai_table_names,
-            descriptions=all_ai_table_descriptions,
-            file_configs=all_ai_file_configs,
-            column_definitions=all_ai_column_definitions,
-            skip_columns=self.default_skip_columns,  # Fallback, though ideally not used if AI defines all columns
+        logger.debug(
+            f"Initializing final CSVStandardizer with aggregated AI parameters: {all_ai_file_configs}"
         )
+        final_processor = CSVStandardizer(file_configs=all_ai_file_configs)
 
         try:
             logger.info(
                 f"Executing batch standardization for {len(input_paths)} file(s)..."
             )
-            result_path = final_processor.standardize(
-                datasource=input_paths,  # Pass the original list of Path objects
+            standardization_result = final_processor.standardize(
+                datasource=input_paths,
                 output_path=output_path_obj,
                 overwrite=overwrite,
             )
             logger.info(
-                f"AI CSV Standardization complete for all files. Output: {result_path}"
+                f"AI CSV Standardization complete. Output: {standardization_result.output_path}"
             )
-            return result_path
+
+            return standardization_result
         except Exception as e:
             logger.exception(
                 f"Error during final batch standardization step using AI parameters: {e}"

satif_ai-0.2.6/satif_ai/plot_builders/agent.py

@@ -1,204 +0,0 @@
-import logging
-import re
-from pathlib import Path
-from typing import Optional, Union
-
-from agents import Agent, Runner
-from agents.mcp import MCPServerStdio
-from mcp import ClientSession
-
-from satif_ai.plot_builders.prompt import PLOTTING_AGENT_PROMPT
-from satif_ai.plot_builders.tool import PLOTTING_TOOL_CONTEXT, execute_plotting_code
-
-logger = logging.getLogger(__name__)
-
-
-class PlottingAgent:
-    """Agent that generates Plotly plots from SDIF data based on user instructions."""
-
-    def __init__(
-        self,
-        mcp_server: MCPServerStdio,
-        mcp_session: ClientSession,
-        llm_model: str = "o4-mini",
-    ):
-        self.mcp_server = mcp_server
-        self.mcp_session = mcp_session
-        self.llm_model = llm_model
-
-    def _parse_final_path(self, final_text: str) -> Optional[Path]:
-        """Extracts the path from the success message."""
-        # Regex to find the path after "Success: Plot saved to "
-        match = re.search(r"Success: Plot saved to (.*)", final_text)
-        if match:
-            path_str = match.group(1).strip()
-            try:
-                p = Path(path_str)
-                # Check if it seems plausible (e.g., ends with .html and absolute)
-                # Check for existence here is important
-                if p.is_absolute() and p.name.endswith(".html") and p.exists():
-                    return p
-                elif (
-                    p.exists()
-                ):  # Accept relative path if it exists (less ideal but maybe happens)
-                    logger.warning(
-                        f"Parsed path {p} is not absolute but exists. Accepting."
-                    )
-                    return p.resolve()  # Return resolved absolute path
-            except Exception as e:
-                logger.warning(f"Error validating parsed path '{path_str}': {e}")
-                pass
-        # Fallback checks remain the same
-        if "plot.html" in final_text:
-            potential_path_str = final_text.strip()
-            # Try to extract if it's just the path
-            if Path(potential_path_str).name == "plot.html":
-                try:
-                    potential_path = Path(
-                        potential_path_str
-                    ).resolve()  # Resolve relative paths
-                    if potential_path.exists():
-                        logger.warning(
-                            "Agent returned path directly instead of success message."
-                        )
-                        return potential_path
-                except Exception:
-                    pass
-
-        return None
-
-    async def generate_plot(
-        self, sdif_path: Union[str, Path], instructions: str
-    ) -> Optional[Path]:
-        """
-        Generates a Plotly plot HTML file based on instructions and SDIF data.
-
-        Args:
-            sdif_path: Path to the input SDIF database file.
-            instructions: Natural language instructions for the plot.
-
-        Returns:
-            Path to the generated HTML plot file, or None if generation failed.
-
-        Raises:
-            FileNotFoundError: If the input SDIF file does not exist.
-            RuntimeError: If agent execution fails or context cannot be fetched or plot fails.
-            Exception: For other unexpected errors.
-        """
-        input_path = sdif_path
-        # Set tool context
-        PLOTTING_TOOL_CONTEXT["input_sdif_path"] = input_path
-        PLOTTING_TOOL_CONTEXT["user_instructions"] = instructions
-        PLOTTING_TOOL_CONTEXT["output_plot_path"] = None
-
-        agent_final_output_text = (
-            "Agent did not produce final output."  # Default message
-        )
-
-        try:
-            # Get Initial Context from MCP Resources
-            logger.info(
-                f"Fetching schema and sample for {input_path}..."
-            )  # Changed level to INFO
-            input_schema_str = "Error: Could not get schema."
-            input_sample_str = "Error: Could not get sample."
-            try:
-                input_path_str = str(input_path)
-                schema_uri = f"schema://{input_path_str}"
-                sample_uri = f"sample://{input_path_str}"
-                logger.debug(f"Requesting schema URI: {schema_uri}")
-                logger.debug(f"Requesting sample URI: {sample_uri}")
-
-                input_schema_resource = await self.mcp_session.read_resource(schema_uri)
-                input_sample_resource = await self.mcp_session.read_resource(sample_uri)
-
-                input_schema_str = (
-                    input_schema_resource.contents[0].text
-                    if input_schema_resource.contents
-                    else "Error: Could not get schema (empty response)."
-                )
-                input_sample_str = (
-                    input_sample_resource.contents[0].text
-                    if input_sample_resource.contents
-                    else "Error: Could not get sample (empty response)."
-                )
-
-            except Exception as mcp_err:
-                logger.error(f"Failed to get schema/sample via MCP: {mcp_err}")
-                raise RuntimeError(
-                    f"Failed to get required context via MCP: {mcp_err}"
-                ) from mcp_err
-
-            # Format the prompt
-            formatted_prompt = PLOTTING_AGENT_PROMPT.format(
-                input_sdif_path=str(input_path),
-                input_schema=input_schema_str,
-                input_sample=input_sample_str,
-                user_instructions=instructions,
-            )
-
-            # Instantiate the Agent
-            agent = Agent(
-                name="Plotting Agent",
-                mcp_servers=[self.mcp_server],
-                tools=[execute_plotting_code],
-                model=self.llm_model,
-            )
-
-            # Run the agent
-            logger.info(f"Running Plotting Agent with model {self.llm_model}...")
-            result = await Runner.run(
-                agent,
-                input=formatted_prompt,
-            )
-
-            if not result or not result.final_output:
-                raise RuntimeError(
-                    "Plotting agent execution failed or returned no output."
-                )
-
-            agent_final_output_text = (
-                result.final_output
-            )  # Store for potential error message
-            logger.info(
-                f"Plotting Agent finished. Final output:\n{agent_final_output_text}"
-            )
-
-            # Attempt to parse the path from the agent's final confirmation
-            final_plot_path = self._parse_final_path(agent_final_output_text)
-
-            if final_plot_path:  # Path found and exists
-                logger.info(
-                    f"Successfully confirmed plot generation at: {final_plot_path}"
-                )
-                return final_plot_path
-            else:
-                final_plot_path_from_context = PLOTTING_TOOL_CONTEXT.get(
-                    "output_plot_path"
-                )
-                if (
-                    final_plot_path_from_context
-                    and final_plot_path_from_context.exists()
-                ):
-                    logger.warning(
-                        "Parsed path from final output failed, but tool context has valid path."
-                    )
-                    return final_plot_path_from_context
-                else:
-                    logger.error(
-                        "Agent finished, but could not confirm successful plot generation or find output file."
-                    )
-                    # Include agent output in error for debugging
-                    raise RuntimeError(
-                        f"Agent finished, but plot generation failed or output path couldn't be determined. Agent final output: '{agent_final_output_text}'"
-                    )  # Modified Error
-
-        except Exception as e:
-            logger.exception(f"Error during PlottingAgent generate_plot: {e}")
-            raise  # Re-raise other exceptions
-        finally:
-            # Robust context cleanup using pop
-            PLOTTING_TOOL_CONTEXT.pop("input_sdif_path", None)
-            PLOTTING_TOOL_CONTEXT.pop("user_instructions", None)
-            PLOTTING_TOOL_CONTEXT.pop("output_plot_path", None)
-            logger.debug("Cleared plotting tool context.")

satif_ai-0.2.6/satif_ai/plot_builders/prompt.py

@@ -1,92 +0,0 @@
-# satif/plot_builders/prompt.py
-
-PLOTTING_AGENT_PROMPT = """
-You are an expert Data Visualization Agent specialized in creating insightful and interactive plots using Plotly from data stored in SDIF (SQLite) databases. You are autonomous and **must not ask clarifying questions**.
-
-**Goal:** Generate Python **script code** to create a Plotly visualization based on user instructions and data within the provided SDIF file. **Critically analyze the data (schema, sample) and instructions to infer the user's likely analytical goal. Prepare and transform the data as needed (e.g., cleaning types, handling missing values appropriately for the plot, calculating new fields), choose the most appropriate chart type (e.g., line for trends, bar for comparisons, scatter for correlations, histogram for distributions) and apply necessary data transformations (grouping, aggregation, pivoting) to best represent the data and answer the implied question in the instructions.** Use standard visualization best practices. Your objective is to produce an effective plot, not engage in conversation.
-
-**Execution Context:**
-Your code will be executed in an environment where the following variables are **already defined**:
-- `db`: An instance of `SDIFDatabase`, connected in read-only mode to the input SDIF file (`{input_sdif_path}`).
-- `instructions`: A string containing the user's request (`{user_instructions}`).
-
-**Input SDIF Context:**
-You have access to the following information about the input SDIF database (accessible via the `db` object):
-
-<input_schema>
-{input_schema}
-</input_schema>
-
-<input_sample>
-{input_sample}
-</input_sample>
-
-**Available Tools:**
-1.  `execute_sql(query: str) -> str`: Execute a read-only SQL query against the **input** SDIF database (using the available `db` object, e.g., `db.query(...)`) to inspect data further *before* writing your main plotting code. Use this only if absolutely necessary to confirm data characteristics crucial for choosing the **correct** plot type or transformation (e.g., checking cardinality for grouping, range for binning).
-2.  `execute_plotting_code(code: str) -> str`: Executes the Python **script code** you generate. Your script **MUST** use the pre-defined `db` and `instructions` variables, generate a Plotly figure, and **save it to an HTML file** named `plot.html` in the current directory (e.g., `fig.write_html('plot.html')`). This tool will return the absolute path to the generated 'plot.html' on success, or an error message on failure.
-
-**Workflow:**
-1.  **Analyze & Infer & Select:** Carefully review the user instructions, input schema, and sample data. **Infer the analytical goal. Based on the data types, cardinality, and instructions, determine the necessary data preparation steps (cleaning, type conversion, handling missing values suitable for the plot), select the *most appropriate* Plotly chart type, and identify required data aggregations (e.g., sum, mean, count) or transformations (e.g., grouping, calculating percentages, date extraction) needed to create an insightful visualization.** Do not ask for clarification.
-2.  **Explore (Minimal Use):** Only use `execute_sql` if essential for confirming data properties needed for your chosen preparation/chart/transformation strategy.
-3.  **Code Generation:** Write Python **script code** (NOT a function definition) that:
-    *   Imports necessary libraries (`pandas as pd`, `plotly.express as px` or `plotly.graph_objects as go`).
-    *   Uses the pre-defined `db` object to read the relevant data.
-    *   Uses the `instructions` string variable if helpful for parameterizing the plot (e.g., titles).
-    *   **Performs the necessary data preparation (cleaning, type conversion, handling NaNs/nulls appropriately) and transformations/aggregations identified in step 1 using pandas.**
-    *   Creates the Plotly figure using the **chosen appropriate chart type** and the prepared/transformed/aggregated data. Make axes labels clear and add an informative title.
-    *   **Crucially:** Saves the figure using `fig.write_html('plot.html')`.
-4.  **Execute:** Call the `execute_plotting_code` tool with your generated Python script code string. **You must call this tool.**
-5.  **Finalize:**
-    *   **If `execute_plotting_code` returns a success message:** Respond **only** with the success message provided by the tool (e.g., "Success: Plot saved to /path/to/plot.html").
-    *   **If `execute_plotting_code` returns an error message:** Respond **only** with the error message provided by the tool.
-
-**Example Script Code (Illustrating Transformation & Chart Choice):**
-```python
-import pandas as pd
-import plotly.express as px
-import plotly.graph_objects as go # Import go if needed
-
-# Assume 'db' and 'instructions' are pre-defined
-# Assume instructions = "Show average monthly revenue trend"
-try:
-    # Infer table and columns (e.g., 'transactions' with 'date', 'revenue')
-    df = db.read_table('transactions')
-
-    # --- Data Preparation ---
-    # Ensure date is datetime type
-    df['date'] = pd.to_datetime(df['date'], errors='coerce')
-    # Ensure revenue is numeric, handle errors (e.g., fill with 0 or drop)
-    df['revenue'] = pd.to_numeric(df['revenue'], errors='coerce').fillna(0)
-    # Drop rows where date conversion failed if necessary for plot
-    df = df.dropna(subset=['date'])
-
-    # --- Transformation for Plot ---
-    # Infer appropriate transformation: Group by month and calculate mean revenue
-    df['month'] = df['date'].dt.to_period('M').astype(str)
-    df_agg = df.groupby('month')['revenue'].mean().reset_index()
-
-    # --- Plotting ---
-    # Infer appropriate chart type: Line chart for trend
-    title = f"Average Monthly Revenue Trend (based on: {{instructions[:30]}}...)"
-    fig = px.line(df_agg, x='month', y='revenue', title=title, markers=True,
-                  labels={{'revenue':'Average Revenue', 'month':'Month'}}) # Clear labels
-
-    # Save plot - THIS IS REQUIRED
-    output_path = 'plot.html'
-    fig.write_html(output_path)
-    print(f"Plot successfully saved to {{output_path}}") # Optional print
-
-except Exception as e:
-    print(f"Error during plotting script execution: {{e}}")
-    raise # Re-raise exception
-```
-
-**CRITICAL INSTRUCTIONS:**
-- **DO NOT ask clarifying questions.** Analyze the data and instructions to infer the best approach.
-- **Prepare and transform the data as needed before plotting (handle types, NaNs, aggregate, etc.).**
-- **Choose the MOST APPROPRIATE chart type.**
-- **You MUST generate Python script code, NOT a function definition.**
-- **Your script code MUST use the pre-defined `db` and `instructions` variables.**
-- **You MUST call the `execute_plotting_code` tool with your generated script code.**
-- **Your final response MUST be ONLY the exact success or error message returned by the `execute_plotting_code` tool.** No extra explanations or conversation.
-"""

satif_ai-0.2.6/satif_ai/plot_builders/tool.py

@@ -1,146 +0,0 @@
-import logging
-import sqlite3  # Ensure sqlite3 is imported if needed
-from pathlib import Path
-
-import pandas as pd
-from agents import function_tool
-from satif_sdk import SDIFDatabase
-from satif_sdk.code_executors import CodeExecutionError, LocalCodeExecutor
-
-logger = logging.getLogger(__name__)
-
-# Global or context for the tool (similar to TidyAdapter)
-PLOTTING_TOOL_CONTEXT = {
-    "input_sdif_path": None,
-    "user_instructions": None,
-    "output_plot_path": None,
-}
-
-
-@function_tool
-async def execute_plotting_code(code: str) -> str:
-    """
-    Executes the provided Python plotting script code.
-    The code should use the pre-defined 'db' (SDIFDatabase instance)
-    and 'instructions' (string) variables.
-    The code MUST save the generated Plotly plot to 'plot.html'.
-    Returns the path to the saved plot on success or an error message.
-    """
-    input_sdif_path = PLOTTING_TOOL_CONTEXT.get("input_sdif_path")
-    user_instructions = PLOTTING_TOOL_CONTEXT.get("user_instructions")
-
-    if not input_sdif_path:
-        return "Error: Input SDIF path not found in tool context."
-    # Check existence *before* trying to open
-    if not Path(input_sdif_path).exists():
-        return f"Error: Input SDIF file not found at {input_sdif_path}."
-    if user_instructions is None:
-        # Allow empty instructions, pass empty string
-        user_instructions = ""
-        logger.warning(
-            "User instructions not found in tool context, using empty string."
-        )
-        # return "Error: User instructions not found in tool context."
-
-    # Use LocalCodeExecutor - WARNING: Insecure for untrusted code
-    executor = LocalCodeExecutor()
-
-    expected_output_filename = "plot.html"
-    # Resolve path relative to the current working directory
-    expected_output_path = Path(expected_output_filename).resolve()
-
-    # Clear previous plot if it exists
-    if expected_output_path.exists():
-        try:
-            expected_output_path.unlink()
-        except OSError as e:
-            logger.error(
-                f"Could not remove existing plot file {expected_output_path}: {e}"
-            )
-
-    # Prepare the extra context for the executor
-    db_instance = None
-    try:
-        # Instantiate the DB instance to be passed to the code
-        # Use read-only mode as the code should only read for plotting
-        db_instance = SDIFDatabase(input_sdif_path, read_only=True)
-
-        # Define the context that will be available to the executed code
-        code_context = {
-            "db": db_instance,
-            "instructions": user_instructions,
-            # Add any other context variables if needed by the executor/code
-        }
-
-        # The code provided by the agent is now expected to be a script
-        script_code = f"""
-import pandas as pd
-import plotly.express as px
-import plotly.graph_objects as go
-from pathlib import Path
-from satif.sdif_database.database import SDIFDatabase # Make class available for type hints etc.
-import sqlite3 # For potential use by pandas/db interaction
-
-# Pre-defined variables available:
-# db: SDIFDatabase instance connected to {input_sdif_path}
-# instructions: str = User's instructions
-
-# --- User's Script Code Start ---
-{code}
-# --- User's Script Code End ---
-"""
-        logger.debug(f"Executing plotting script code:\n---\n{code[:500]}...\n---")
-
-        # LocalCodeExecutor.execute expects 'db' and 'datasource' in its signature
-        # We pass our *actual* db instance as part of extra_context which overrides
-        # the dummy 'db' argument passed for signature compliance.
-        executor.execute(
-            code=script_code,
-            db=db_instance,  # Pass instance for signature, but it's also in extra_context
-            datasource=None,  # Not needed
-            extra_context=code_context,  # Pass db and instructions here
-        )
-
-        # Check if the expected output file was created
-        if expected_output_path.exists():
-            logger.info(
-                f"Plotting code executed successfully. Output: {expected_output_path}"
-            )
-            PLOTTING_TOOL_CONTEXT["output_plot_path"] = expected_output_path
-            return f"Success: Plot saved to {expected_output_path}"
-        else:
-            logger.error(
-                "Plotting code executed but output file 'plot.html' not found."
-            )
-            # Check if the error might be within the script's own error handling
-            # (This requires parsing the execution output, which LocalExecutor doesn't provide easily)
-            return "Error: Code executed (possibly with internal errors), but the expected output file 'plot.html' was not created."
-
-    except (
-        CodeExecutionError,
-        sqlite3.Error,
-        FileNotFoundError,
-        ValueError,
-        TypeError,
-    ) as e:
-        logger.error(f"Error executing plotting code or accessing DB: {e}")
-        # Attempt to provide more specific feedback if possible
-        error_message = f"Error executing plotting code: {e}"
-        # Look for common issues like table not found
-        if isinstance(e, pd.io.sql.DatabaseError) and "no such table" in str(e).lower():
-            error_message = f"Error executing plotting code: Table not found. {e}"
-        elif isinstance(e, KeyError):  # Pandas KeyError on column access
-            error_message = f"Error executing plotting code: Column not found or data processing error. {e}"
-
-        return error_message  # Return the formatted error
-    except Exception as e:
-        logger.exception("Unexpected error during plotting code execution via tool.")
-        return f"Unexpected Error during execution: {e}"
-    finally:
-        # Ensure the db instance created here is closed
-        if db_instance:
-            try:
-                db_instance.close()
-                logger.debug("Closed DB instance in plotting tool.")
-            except Exception as close_err:
-                logger.error(f"Error closing DB instance in plotting tool: {close_err}")