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

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.7.dist-info → satif_ai-0.2.9.dist-info}/METADATA

@@ -1,10 +1,11 @@
 Metadata-Version: 2.3
 Name: satif-ai
-Version: 0.2.7
+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/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/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.
-"""