first iteration

.gitignore

@@ -0,0 +1,13 @@
+# Python-generated files
+__pycache__/
+*.py[oc]
+build/
+dist/
+wheels/
+*.egg-info
+
+# Virtual environments
+.venv
+
+# sqlite files
+*.db

app/analyzer.py

@@ -0,0 +1,234 @@
+"""Module that defines the TimeSeriesAnalyzer object."""
+
+import os
+from dataclasses import dataclass
+from datetime import datetime
+from typing import Any
+
+import numpy as np
+import polars as pl
+from loguru import logger
+from sqlalchemy import Engine, create_engine, text
+
+from data.get_mock import get_df
+
+
+@dataclass
+class TimeSeriesConfig:
+    """Object with the database connections details.
+
+    Attributes:
+        host: address of the database
+        port: port of the database
+        database: name of the database
+        username: username of the database
+        password: password of the database
+
+    """
+
+    host: str
+    port: int
+    database: str
+    username: str
+    password: str
+
+
+class TimeSeriesAnalyzer:
+    """Handle connections details, and how to compute insights.
+
+    Attributes:
+        use_mock_db: if True, databased if mocked.
+        connection: connection engine
+
+    """
+
+    def __init__(self):
+        self.use_mock_db = os.getenv("USE_MOCK_DB", True)
+        if not self.use_mock_db:
+            self.config = TimeSeriesConfig(
+                host=os.getenv("DB_HOST", "localhost"),
+                port=int(os.getenv("DB_PORT", 5432)),
+                database=os.getenv("DB_NAME", "data"),
+                username=os.getenv("DB_USER", "postgres"),
+                password=os.getenv("DB_PASS", "secretpassword"),
+            )
+        self.connection: Engine
+
+    def connect(self):
+        """Instantiate the database engine."""
+        if self.use_mock_db:
+            logger.info("Connecting to mock SQLite database")
+            self.connection = create_engine("sqlite:///mock.db")
+            self._setup_mock_db()
+        else:
+            logger.info(
+                f"Connecting to TimescaleDB at {self.config.host}:{self.config.port}"
+            )
+            self.connection = create_engine(
+                f"postgresql+psycopg2://{self.config.username}:{self.config.password}@{self.config.host}:{self.config.port}/{self.config.database}"
+            )
+        logger.info("Connected to database!")
+
+    def _setup_mock_db(self):
+        df = get_df()
+        if os.path.exists("./mock.db"):
+            return
+        logger.info(
+            f"""df shape: {df.shape}, size: {df.estimated_size("kb"):,.3f}kb"""
+        )
+        logger.debug(df.head(5))
+
+        with self.connection.connect() as conn:
+            df.write_database(
+                "timeseries_data",
+                conn,
+                if_table_exists="replace",
+                engine_options={},
+            )
+
+    def _ensure_connected(self):
+        if not self.connection:
+            self.connect()
+
+    def get_available_metrics(self) -> list[str]:
+        """Get the list of sensor_id.
+
+        Returns:
+            list of sensors
+
+        """
+        self._ensure_connected()
+        sql = "SELECT DISTINCT sensor_id FROM timeseries_data ORDER BY sensor_id ASC"
+        with self.connection.connect() as conn:
+            rows = conn.execute(text(sql))
+            return [r[0] for r in rows]
+
+    def query_metrics(
+        self,
+        sensor_id: str,
+        start_time: str,
+        end_time: str,
+    ) -> pl.DataFrame:
+        """Run a select query of 1 time serie.
+
+        Args:
+            sensor_id: id of the sensor
+            start_time: iso datetime
+            end_time: iso datetime
+
+        Returns:
+            The expected time serie as a polar DataFrame.
+
+        """
+        self._ensure_connected()
+        start_dt = datetime.fromisoformat(start_time)
+        end_dt = datetime.fromisoformat(end_time)
+
+        query = f"""SELECT timestamp, value FROM timeseries_data
+            WHERE sensor_id = '{sensor_id}' AND timestamp >= '{start_dt}' AND timestamp <= '{end_dt}'
+            ORDER BY timestamp ASC"""
+        with self.connection.connect() as conn:
+            df = pl.read_database(query, conn)
+        return df
+
+    def detect_anomalies(
+        self, data: pl.DataFrame, threshold: float = 1.0
+    ) -> dict[str, Any]:
+        """Detect anomalies in the time series data for a specific sensor.
+
+        Args:
+            data: expect only 1 timeserie with columns datetime and value
+            threshold: default to 1.0
+
+        Returns:
+            {
+            "anomalies_found": int,
+            "anomalies": list[dict[str, int]],
+            "statistics": {
+                "mean": float,
+                "std": float,
+                "min": float,
+                "max": float
+            },
+
+        """
+        mean_val = data["value"].mean()
+        std_val = data["value"].std()
+        data = data.with_columns(
+            ((data["value"] - mean_val).abs() / std_val).alias("z_score")
+        )
+
+        anomalies = (
+            data.filter(data["z_score"] > threshold)
+            .select(
+                [
+                    data["timestamp"].cast(pl.Utf8).alias("timestamp"),
+                    data["value"].cast(pl.Float64),
+                    data["z_score"].cast(pl.Float64).alias("z_score"),
+                    (data["z_score"] > 2.0)
+                    .cast(pl.Utf8)
+                    .alias("severity")
+                    .map_elements(
+                        lambda x: "high" if x else "medium",
+                        return_dtype=pl.String,
+                    ),
+                ]
+            )
+            .to_dicts()
+        )
+        return {
+            "anomalies_found": len(anomalies),
+            "anomalies": anomalies,
+            "statistics": {
+                "mean": mean_val,
+                "std": std_val,
+                "min": data["value"].min(),
+                "max": data["value"].max(),
+            },
+        }
+
+    def calculate_trends(self, data: pl.DataFrame) -> dict[str, Any]:
+        """Calculate trend information such as trend direction and percentage change.
+
+        Args:
+            data: expect only 1 timeserie with columns datetime and value
+
+        Returns:
+            {
+                "trend_direction": Literal["increasing", "decreasing", "stable"],
+                "trend_slope": float,
+                "percentage_change": float,
+                "start_value": float,
+                "end_value": float,
+                "time_period": {
+                    "start": datetime,
+                    "end": datetime,
+                },
+            }
+
+        """
+        values = data["value"]
+        timestamps = data["timestamp"]
+        x = np.arange(len(values))
+        coeffs = np.polyfit(x, values, 1)
+        trend_slope = coeffs[0]
+        pct_change = (
+            ((values[-1] - values[0]) / values[0]) * 100
+            if len(values) > 1
+            else 0
+        )
+        return {
+            "trend_direction": "increasing"
+            if trend_slope > 0
+            else "decreasing"
+            if trend_slope < 0
+            else "stable",
+            "trend_slope": float(trend_slope),
+            "percentage_change": float(pct_change),
+            "start_value": float(values[0]) if len(values) > 0 else 0,
+            "end_value": float(values[-1]) if len(values) > 0 else 0,
+            "time_period": {
+                "start": timestamps[0] if len(timestamps) > 0 else None,
+                "end": timestamps[-1] if len(timestamps) > 0 else None,
+            },
+        }

app/service.py

@@ -0,0 +1,169 @@
+"""Functions meant to be exposed."""
+
+import json
+import threading
+
+from loguru import logger
+
+from app.analyzer import TimeSeriesAnalyzer
+
+analyzer: TimeSeriesAnalyzer
+analyzer_lock = threading.Lock()
+
+
+def ensure_analyzer_connected() -> bool:
+    """Check if the analyzer is connected and log the status."""
+    global analyzer
+    try:
+        if analyzer:
+            pass
+    except NameError:
+        connect_database()
+    return True
+
+
+def connect_database() -> str:
+    """Connect to the TimescaleDB and initialize the analyzer."""
+    global analyzer
+    with analyzer_lock:
+        analyzer = TimeSeriesAnalyzer()
+    analyzer.connect()
+    return "Successfully connected to database"
+
+
+def list_available_metrics() -> str:
+    """List all available metrics from the connected database."""
+    if not ensure_analyzer_connected():
+        return json.dumps({"error": "Database not connected"})
+    metrics = analyzer.get_available_metrics()
+    return json.dumps({"available_metrics": metrics}, indent=2)
+
+
+def query_timeseries(sensor_id: str, start_time: str, end_time: str) -> str:
+    """Query time series data for a specific sensor within a time range."""
+    logger.info("query timeseries")
+    if not ensure_analyzer_connected():
+        return json.dumps({"error": "Database not connected"})
+    data = analyzer.query_metrics(sensor_id, start_time, end_time)
+    result = {
+        "sensor_id": sensor_id,
+        "data_points": len(data),
+        "time_range": {
+            "start": data["timestamp"].min() if not data.is_empty() else None,
+            "end": data["timestamp"].max() if not data.is_empty else None,
+        },
+        "sample_data": data.head(10).to_dicts(),
+    }
+    return json.dumps(result, indent=2, default=str)
+
+
+def detect_anomalies(
+    sensor_id: str, start_time: str, end_time: str, threshold: float = 2.0
+) -> str:
+    """Detect anomalies in the time series data for a specific sensor."""
+    logger.info("detect anomalies")
+    if not ensure_analyzer_connected():
+        return json.dumps({"error": "Database not connected"})
+    data = analyzer.query_metrics(sensor_id, start_time, end_time)
+    anomalies = analyzer.detect_anomalies(data, threshold)
+    return json.dumps(anomalies, indent=2)
+
+
+def analyze_trends(sensor_id: str, start_time: str, end_time: str) -> str:
+    """Analyze trends in the time series data for a specific sensor.
+
+    This function retrieves time series data for the specified sensor within the given time range
+    and calculates trend information such as trend direction and percentage change.
+
+    Args:
+        sensor_id (str): The identifier of the sensor to analyze.
+        start_time (str): The start time of the analysis period in ISO format.
+        end_time (str): The end time of the analysis period in ISO format.
+
+    Returns:
+        str: A JSON string containing trend analysis results including trend direction,
+            percentage change, and start/end values.
+
+    Raises:
+        No direct exceptions, but returns a JSON error message if the database is not connected.
+
+    """
+    logger.info("analyze trends")
+    if not ensure_analyzer_connected():
+        return json.dumps({"error": "Database not connected"})
+    data = analyzer.query_metrics(sensor_id, start_time, end_time)
+    trends = analyzer.calculate_trends(data)
+    return json.dumps(trends, indent=2)
+
+
+def generate_analysis_report(
+    sensor_id: str,
+    start_time: str,
+    end_time: str,
+    include_anomalies: bool = True,
+    include_trends: bool = True,
+    user_question: str | None = None,
+) -> str:
+    """Generate a comprehensive analysis report for a specific sensor.
+
+    This function creates a detailed report containing information about the sensor data,
+    including optional trend analysis and anomaly detection sections based on the parameters.
+
+    Args:
+        sensor_id (str): The identifier of the sensor to analyze.
+        start_time (str): The start time of the analysis period in ISO format.
+        end_time (str): The end time of the analysis period in ISO format.
+        include_anomalies (bool, optional): Whether to include anomaly detection in the report. Defaults to True.
+        include_trends (bool, optional): Whether to include trend analysis in the report. Defaults to True.
+        user_question (str | None, optional): A specific question from the user to be included in the report. Defaults to None.
+
+    Returns:
+        str: A formatted string containing the comprehensive analysis report with requested sections.
+
+    Note:
+        Returns an error message if the database is not connected.
+
+    """
+    logger.info("generate report")
+    if not ensure_analyzer_connected():
+        return "Error: Database not connected. Please connect first."
+    data = analyzer.query_metrics(sensor_id, start_time, end_time)
+    report_sections = []
+    report_sections.append(f"## Analysis Report for {sensor_id}")
+    report_sections.append(f"**Time Period:** {start_time} to {end_time}")
+    report_sections.append(f"**Data Points:** {len(data)}")
+    if user_question:
+        report_sections.append(f"**User Question:** {user_question}")
+    if include_trends:
+        trends = analyzer.calculate_trends(data)
+        report_sections.append("\n### Trend Analysis")
+        report_sections.append(
+            f"- **Direction:** {trends['trend_direction'].title()}"
+        )
+        report_sections.append(
+            f"- **Change:** {trends['percentage_change']:.2f}%"
+        )
+        report_sections.append(
+            f"- **Start Value:** {trends['start_value']:.2f}"
+        )
+        report_sections.append(f"- **End Value:** {trends['end_value']:.2f}")
+    if include_anomalies:
+        anomalies = analyzer.detect_anomalies(data)
+        report_sections.append("\n### Anomaly Detection")
+        report_sections.append(
+            f"- **Anomalies Found:** {anomalies['anomalies_found']}"
+        )
+        if anomalies["anomalies_found"] > 0:
+            report_sections.append("- **Notable Anomalies:**")
+            for anomaly in anomalies["anomalies"][:5]:
+                report_sections.append(
+                    f"  - {anomaly['timestamp']}: {anomaly['value']:.2f} (severity: {anomaly['severity']})"
+                )
+        stats = anomalies["statistics"]
+        report_sections.append("\n### Statistical Summary")
+        report_sections.append(f"- **Mean:** {stats['mean']:.2f}")
+        report_sections.append(f"- **Std Dev:** {stats['std']:.2f}")
+        report_sections.append(f"- **Min:** {stats['min']:.2f}")
+        report_sections.append(f"- **Max:** {stats['max']:.2f}")
+    full_report = "\n".join(report_sections)
+    return full_report

app/ui.py

@@ -0,0 +1,90 @@
+"""Definition of the Gradio UI."""
+
+import gradio as gr
+
+from app.service import (
+    analyze_trends,
+    connect_database,
+    detect_anomalies,
+    generate_analysis_report,
+    list_available_metrics,
+    query_timeseries,
+)
+
+example_sensor = "temperature"
+example_start = "2019-06-15T02:54:00"
+example_end = "2019-06-17T02:54:00"
+
+with gr.Blocks() as demo:
+    gr.Markdown("# TimescaleDB Time Series Analyzer API (Gradio)")
+    with gr.Tab("Connect DB"):
+        connect_btn = gr.Button("Connect to TimescaleDB")
+        connect_out = gr.Textbox(label="Connection Result")
+        connect_btn.click(
+            fn=connect_database,
+            inputs=[],
+            outputs=connect_out,
+        )
+    with gr.Tab("List Metrics"):
+        list_btn = gr.Button("List Available Metrics")
+        list_out = gr.Textbox(label="Metrics")
+        list_btn.click(
+            fn=list_available_metrics,
+            inputs=[],
+            outputs=list_out,
+        )
+    with gr.Tab("Query Timeseries"):
+        sensor_id = gr.Textbox(label="Sensor ID", value=example_sensor)
+        start_time = gr.Textbox(label="Start Time (ISO)", value=example_start)
+        end_time = gr.Textbox(label="End Time (ISO)", value=example_end)
+        query_btn = gr.Button("Query")
+        query_out = gr.Textbox(label="Query Result")
+        query_btn.click(
+            fn=query_timeseries,
+            inputs=[sensor_id, start_time, end_time],
+            outputs=query_out,
+        )
+    with gr.Tab("Detect Anomalies"):
+        sensor_id2 = gr.Textbox(label="Sensor ID", value=example_sensor)
+        start_time2 = gr.Textbox(label="Start Time (ISO)", value=example_start)
+        end_time2 = gr.Textbox(label="End Time (ISO)", value=example_end)
+        threshold = gr.Number(label="Threshold", value=2.0)
+        anomaly_btn = gr.Button("Detect")
+        anomaly_out = gr.Textbox(label="Anomaly Result")
+        anomaly_btn.click(
+            fn=detect_anomalies,
+            inputs=[sensor_id2, start_time2, end_time2, threshold],
+            outputs=anomaly_out,
+        )
+    with gr.Tab("Analyze Trends"):
+        sensor_id3 = gr.Textbox(label="Sensor ID", value=example_sensor)
+        start_time3 = gr.Textbox(label="Start Time (ISO)", value=example_start)
+        end_time3 = gr.Textbox(label="End Time (ISO)", value=example_end)
+        trend_btn = gr.Button("Analyze")
+        trend_out = gr.Textbox(label="Trend Result")
+        trend_btn.click(
+            fn=analyze_trends,
+            inputs=[sensor_id3, start_time3, end_time3],
+            outputs=trend_out,
+        )
+    with gr.Tab("Generate Report"):
+        sensor_id4 = gr.Textbox(label="Sensor ID", value=example_sensor)
+        start_time4 = gr.Textbox(label="Start Time (ISO)", value=example_start)
+        end_time4 = gr.Textbox(label="End Time (ISO)", value=example_end)
+        include_anomalies = gr.Checkbox(label="Include Anomalies", value=True)
+        include_trends = gr.Checkbox(label="Include Trends", value=True)
+        user_question = gr.Textbox(label="User Question", value="")
+        report_btn = gr.Button("Generate Report")
+        report_out = gr.Markdown(label="Report")
+        report_btn.click(
+            fn=generate_analysis_report,
+            inputs=[
+                sensor_id4,
+                start_time4,
+                end_time4,
+                include_anomalies,
+                include_trends,
+                user_question,
+            ],
+            outputs=report_out,
+        )

data/get_mock.py

@@ -0,0 +1,23 @@
+"""Module to mock a timeseries for demo and dev purpouses."""
+
+import polars as pl
+import polars.selectors as cs
+
+
+def get_df() -> pl.DataFrame:
+    """Retrieve a weather dataset from huggingface datasets.
+
+    Returns:
+        a dataframe with 3 columns: datetime, sensor_id, value
+
+    """
+    raw_df = pl.read_parquet(
+        "hf://datasets/afeng/MTBench_weather_temperature/data/train-*.parquet"
+    )
+
+    df = raw_df.explode(*raw_df.columns).sample(fraction=0.01)
+
+    df = df.select(~cs.starts_with("precipitation"))
+    df = df.with_columns(pl.col("DATE").str.to_datetime())
+    df = df.unpivot(cs.numeric(), index="DATE")
+    return df.rename({"DATE": "timestamp", "variable": "sensor_id"})

main.py

@@ -0,0 +1,22 @@
+"""Module to launch the application.
+
+run: `gradio main.py` to run the application
+"""
+
+import sys
+
+from loguru import logger
+
+from app.ui import demo
+
+logger.add(
+    sys.stdout,
+    format="<green>{time}</green> <level>{message}</level>",
+    filter="my_module",
+    level="INFO",
+    colorize=True,
+)
+
+
+if __name__ == "__main__":
+    demo.launch(mcp_server=True)

pyproject.toml

@@ -0,0 +1,50 @@
+[project]
+name = "tscontext"
+version = "0.1.0"
+description = "Add your description here"
+readme = "README.md"
+requires-python = ">=3.12"
+dependencies = [
+    "asyncpg>=0.30.0",
+    "gradio[mcp]>=5.32.1",
+    "ipykernel>=6.29.5",
+    "loguru>=0.7.3",
+    "numpy>=2.2.6",
+    "pandas>=2.2.3",
+    "polars>=1.30.0",
+    "psycopg2-binary>=2.9.10",
+    "pyarrow>=20.0.0",
+    "sqlalchemy>=2.0.41",
+]
+
+
+[tool.ruff]
+include = ["*.py", "*.pyi", "**/pyproject.toml", "*.ipynb"]
+extend-exclude = ["reports/**", "**/__init__.py"]
+line-length = 80
+
+[tool.ruff.lint]
+select = [
+    "F",      # pyflakes
+    "I",      # isort
+    "ISC",    # string literal concatenation.
+    "UP",     # pyupgrade
+    "E",      # pycodestyle
+    "W",      # warning
+    "D",      # pydocstyle
+    "NPY",    # Numpy
+    "SIM101", # flake8-simplify
+    "FA",     # future annotations
+]
+ignore = [
+    'D105',
+    'D107',
+    'D205',
+    'D203',
+    'D213',
+    'D415',
+    'E501',
+    'B011',
+    'B028',
+    'B904',
+]

requirements.txt

@@ -0,0 +1,262 @@
+# This file was autogenerated by uv via the following command:
+#    uv pip compile pyproject.toml -o requirements.txt
+aiofiles==24.1.0
+    # via gradio
+annotated-types==0.7.0
+    # via pydantic
+anyio==4.9.0
+    # via
+    #   gradio
+    #   httpx
+    #   mcp
+    #   sse-starlette
+    #   starlette
+asttokens==3.0.0
+    # via stack-data
+asyncpg==0.30.0
+    # via tscontext (pyproject.toml)
+certifi==2025.4.26
+    # via
+    #   httpcore
+    #   httpx
+    #   requests
+charset-normalizer==3.4.2
+    # via requests
+click==8.2.1
+    # via
+    #   typer
+    #   uvicorn
+comm==0.2.2
+    # via ipykernel
+debugpy==1.8.14
+    # via ipykernel
+decorator==5.2.1
+    # via ipython
+executing==2.2.0
+    # via stack-data
+fastapi==0.115.12
+    # via gradio
+ffmpy==0.6.0
+    # via gradio
+filelock==3.18.0
+    # via huggingface-hub
+fsspec==2025.5.1
+    # via
+    #   gradio-client
+    #   huggingface-hub
+gradio==5.33.0
+    # via tscontext (pyproject.toml)
+gradio-client==1.10.2
+    # via gradio
+greenlet==3.2.2
+    # via sqlalchemy
+groovy==0.1.2
+    # via gradio
+h11==0.16.0
+    # via
+    #   httpcore
+    #   uvicorn
+hf-xet==1.1.3
+    # via huggingface-hub
+httpcore==1.0.9
+    # via httpx
+httpx==0.28.1
+    # via
+    #   gradio
+    #   gradio-client
+    #   mcp
+    #   safehttpx
+httpx-sse==0.4.0
+    # via mcp
+huggingface-hub==0.32.4
+    # via
+    #   gradio
+    #   gradio-client
+idna==3.10
+    # via
+    #   anyio
+    #   httpx
+    #   requests
+ipykernel==6.29.5
+    # via tscontext (pyproject.toml)
+ipython==9.3.0
+    # via ipykernel
+ipython-pygments-lexers==1.1.1
+    # via ipython
+jedi==0.19.2
+    # via ipython
+jinja2==3.1.6
+    # via gradio
+jupyter-client==8.6.3
+    # via ipykernel
+jupyter-core==5.8.1
+    # via
+    #   ipykernel
+    #   jupyter-client
+loguru==0.7.3
+    # via tscontext (pyproject.toml)
+markdown-it-py==3.0.0
+    # via rich
+markupsafe==3.0.2
+    # via
+    #   gradio
+    #   jinja2
+matplotlib-inline==0.1.7
+    # via
+    #   ipykernel
+    #   ipython
+mcp==1.9.0
+    # via gradio
+mdurl==0.1.2
+    # via markdown-it-py
+nest-asyncio==1.6.0
+    # via ipykernel
+numpy==2.2.6
+    # via
+    #   tscontext (pyproject.toml)
+    #   gradio
+    #   pandas
+orjson==3.10.18
+    # via gradio
+packaging==25.0
+    # via
+    #   gradio
+    #   gradio-client
+    #   huggingface-hub
+    #   ipykernel
+pandas==2.3.0
+    # via
+    #   tscontext (pyproject.toml)
+    #   gradio
+parso==0.8.4
+    # via jedi
+pexpect==4.9.0
+    # via ipython
+pillow==11.2.1
+    # via gradio
+platformdirs==4.3.8
+    # via jupyter-core
+polars==1.30.0
+    # via tscontext (pyproject.toml)
+prompt-toolkit==3.0.51
+    # via ipython
+psutil==7.0.0
+    # via ipykernel
+psycopg2-binary==2.9.10
+    # via tscontext (pyproject.toml)
+ptyprocess==0.7.0
+    # via pexpect
+pure-eval==0.2.3
+    # via stack-data
+pyarrow==20.0.0
+    # via tscontext (pyproject.toml)
+pydantic==2.11.5
+    # via
+    #   fastapi
+    #   gradio
+    #   mcp
+    #   pydantic-settings
+pydantic-core==2.33.2
+    # via pydantic
+pydantic-settings==2.9.1
+    # via mcp
+pydub==0.25.1
+    # via gradio
+pygments==2.19.1
+    # via
+    #   ipython
+    #   ipython-pygments-lexers
+    #   rich
+python-dateutil==2.9.0.post0
+    # via
+    #   jupyter-client
+    #   pandas
+python-dotenv==1.1.0
+    # via pydantic-settings
+python-multipart==0.0.20
+    # via
+    #   gradio
+    #   mcp
+pytz==2025.2
+    # via pandas
+pyyaml==6.0.2
+    # via
+    #   gradio
+    #   huggingface-hub
+pyzmq==26.4.0
+    # via
+    #   ipykernel
+    #   jupyter-client
+requests==2.32.3
+    # via huggingface-hub
+rich==14.0.0
+    # via typer
+ruff==0.11.12
+    # via gradio
+safehttpx==0.1.6
+    # via gradio
+semantic-version==2.10.0
+    # via gradio
+shellingham==1.5.4
+    # via typer
+six==1.17.0
+    # via python-dateutil
+sniffio==1.3.1
+    # via anyio
+sqlalchemy==2.0.41
+    # via tscontext (pyproject.toml)
+sse-starlette==2.3.6
+    # via mcp
+stack-data==0.6.3
+    # via ipython
+starlette==0.46.2
+    # via
+    #   fastapi
+    #   gradio
+    #   mcp
+tomlkit==0.13.3
+    # via gradio
+tornado==6.5.1
+    # via
+    #   ipykernel
+    #   jupyter-client
+tqdm==4.67.1
+    # via huggingface-hub
+traitlets==5.14.3
+    # via
+    #   comm
+    #   ipykernel
+    #   ipython
+    #   jupyter-client
+    #   jupyter-core
+    #   matplotlib-inline
+typer==0.16.0
+    # via gradio
+typing-extensions==4.14.0
+    # via
+    #   anyio
+    #   fastapi
+    #   gradio
+    #   gradio-client
+    #   huggingface-hub
+    #   pydantic
+    #   pydantic-core
+    #   sqlalchemy
+    #   typer
+    #   typing-inspection
+typing-inspection==0.4.1
+    # via
+    #   pydantic
+    #   pydantic-settings
+tzdata==2025.2
+    # via pandas
+urllib3==2.4.0
+    # via requests
+uvicorn==0.34.3
+    # via
+    #   gradio
+    #   mcp
+wcwidth==0.2.13
+    # via prompt-toolkit
+websockets==15.0.1
+    # via gradio-client