feat: Add Copy to Clipboard with Interactive Preview to Excel Add-in

.pytest_cache/.gitignore

@@ -0,0 +1,2 @@
+# Created by pytest automatically.
+*

.pytest_cache/CACHEDIR.TAG

@@ -0,0 +1,4 @@
+Signature: 8a477f597d28d172789f06886806bc55
+# This file is a cache directory tag created by pytest.
+# For information about cache directory tags, see:
+#	https://bford.info/cachedir/spec.html

.pytest_cache/v/cache/lastfailed

@@ -0,0 +1,3 @@
+{
+  "tests/unit/test_dtos.py": true
+}

.pytest_cache/v/cache/nodeids

@@ -0,0 +1,68 @@
+[
+  "tests/unit/test_domain_models.py::TestAnomalyPoint::test_create_anomaly",
+  "tests/unit/test_domain_models.py::TestAnomalyPoint::test_deviation_percentage",
+  "tests/unit/test_domain_models.py::TestAnomalyPoint::test_is_above_expected",
+  "tests/unit/test_domain_models.py::TestAnomalyPoint::test_severity_high",
+  "tests/unit/test_domain_models.py::TestAnomalyPoint::test_severity_low",
+  "tests/unit/test_domain_models.py::TestAnomalyPoint::test_severity_medium",
+  "tests/unit/test_domain_models.py::TestAnomalyPoint::test_to_dict",
+  "tests/unit/test_domain_models.py::TestForecastConfig::test_create_valid_config",
+  "tests/unit/test_domain_models.py::TestForecastConfig::test_default_config",
+  "tests/unit/test_domain_models.py::TestForecastConfig::test_empty_quantiles",
+  "tests/unit/test_domain_models.py::TestForecastConfig::test_invalid_prediction_length",
+  "tests/unit/test_domain_models.py::TestForecastConfig::test_median_auto_added",
+  "tests/unit/test_domain_models.py::TestForecastConfig::test_quantile_out_of_range",
+  "tests/unit/test_domain_models.py::TestForecastConfig::test_quantiles_sorted",
+  "tests/unit/test_domain_models.py::TestForecastResult::test_create_valid_result",
+  "tests/unit/test_domain_models.py::TestForecastResult::test_empty_result_raises_error",
+  "tests/unit/test_domain_models.py::TestForecastResult::test_get_interval",
+  "tests/unit/test_domain_models.py::TestForecastResult::test_get_quantile",
+  "tests/unit/test_domain_models.py::TestForecastResult::test_get_quantile_not_found",
+  "tests/unit/test_domain_models.py::TestForecastResult::test_median_length_mismatch",
+  "tests/unit/test_domain_models.py::TestForecastResult::test_quantile_length_mismatch",
+  "tests/unit/test_domain_models.py::TestTimeSeries::test_create_valid_series",
+  "tests/unit/test_domain_models.py::TestTimeSeries::test_empty_series_raises_error",
+  "tests/unit/test_domain_models.py::TestTimeSeries::test_get_subset",
+  "tests/unit/test_domain_models.py::TestTimeSeries::test_non_numeric_values_raise_error",
+  "tests/unit/test_domain_models.py::TestTimeSeries::test_null_values_raise_error",
+  "tests/unit/test_domain_models.py::TestTimeSeries::test_timestamps_length_mismatch",
+  "tests/unit/test_domain_models.py::TestTimeSeries::test_to_dict",
+  "tests/unit/test_interfaces.py::TestIDataTransformer::test_cannot_instantiate",
+  "tests/unit/test_interfaces.py::TestIDataTransformer::test_is_abstract",
+  "tests/unit/test_interfaces.py::TestIForecastModel::test_cannot_instantiate",
+  "tests/unit/test_interfaces.py::TestIForecastModel::test_is_abstract",
+  "tests/unit/test_interfaces.py::TestIForecastModel::test_validate_context_empty_dataframe",
+  "tests/unit/test_interfaces.py::TestIForecastModel::test_validate_context_missing_columns",
+  "tests/unit/test_interfaces.py::TestIForecastModel::test_validate_context_null_values",
+  "tests/unit/test_interfaces.py::TestIForecastModel::test_validate_context_success",
+  "tests/unit/test_logger.py::TestLogger::test_logger_custom_level",
+  "tests/unit/test_logger.py::TestLogger::test_logger_different_levels",
+  "tests/unit/test_logger.py::TestLogger::test_logger_has_handler",
+  "tests/unit/test_logger.py::TestLogger::test_logger_level_from_settings",
+  "tests/unit/test_logger.py::TestLogger::test_logger_no_duplicate_handlers",
+  "tests/unit/test_logger.py::TestLogger::test_logger_output",
+  "tests/unit/test_logger.py::TestLogger::test_setup_logger_basic",
+  "tests/unit/test_services.py::TestAnomalyService::test_detect_anomalies_length_mismatch",
+  "tests/unit/test_services.py::TestAnomalyService::test_detect_anomalies_success",
+  "tests/unit/test_services.py::TestAnomalyService::test_get_anomaly_summary",
+  "tests/unit/test_services.py::TestAnomalyService::test_init_service",
+  "tests/unit/test_services.py::TestBacktestMetrics::test_create_metrics",
+  "tests/unit/test_services.py::TestBacktestMetrics::test_to_dict",
+  "tests/unit/test_services.py::TestBacktestService::test_calculate_metrics",
+  "tests/unit/test_services.py::TestBacktestService::test_init_service",
+  "tests/unit/test_services.py::TestBacktestService::test_simple_backtest_invalid_test_length",
+  "tests/unit/test_services.py::TestBacktestService::test_simple_backtest_success",
+  "tests/unit/test_services.py::TestForecastService::test_forecast_multi_series",
+  "tests/unit/test_services.py::TestForecastService::test_forecast_multi_series_empty_list",
+  "tests/unit/test_services.py::TestForecastService::test_forecast_univariate_invalid_series",
+  "tests/unit/test_services.py::TestForecastService::test_forecast_univariate_success",
+  "tests/unit/test_services.py::TestForecastService::test_init_service",
+  "tests/unit/test_settings.py::TestSettings::test_cors_origins_is_list",
+  "tests/unit/test_settings.py::TestSettings::test_default_values",
+  "tests/unit/test_settings.py::TestSettings::test_get_settings_singleton",
+  "tests/unit/test_settings.py::TestSettings::test_settings_from_env",
+  "tests/unit/test_settings.py::TestSettings::test_settings_module_instance",
+  "tests/unit/test_settings.py::TestSettingsValidation::test_api_version_format",
+  "tests/unit/test_settings.py::TestSettingsValidation::test_device_map_valid",
+  "tests/unit/test_settings.py::TestSettingsValidation::test_log_level_valid"
+]

Dockerfile

@@ -1,45 +1,32 @@
-# Dockerfile optimizado para HuggingFace Spaces
 FROM python:3.11-slim
 
-# Variables de entorno
-ENV PYTHONUNBUFFERED=1 \
-    PYTHONDONTWRITEBYTECODE=1 \
-    PORT=7860
+ENV DEBIAN_FRONTEND=noninteractive
+ENV CHRONOS_MODEL_ID=amazon/chronos-2
+ENV DEVICE_MAP=cpu
+ENV PYTHONUNBUFFERED=1
 
-# Directorio de trabajo
 WORKDIR /app
 
-# Instalar dependencias del sistema
-RUN apt-get update && \
-    apt-get install -y --no-install-recommends \
+RUN apt-get update && apt-get install -y --no-install-recommends \
     build-essential \
     curl \
-    && rm -rf /var/lib/apt/lists/*
+    openssl \
+ && rm -rf /var/lib/apt/lists/*
 
-# Copiar requirements
 COPY requirements.txt .
 
-# Instalar dependencias Python
-RUN pip install --no-cache-dir --upgrade pip && \
-    pip install --no-cache-dir -r requirements.txt
+RUN pip install --no-cache-dir --upgrade pip \
+    && pip install --no-cache-dir -r requirements.txt
 
-# Copiar código de la aplicación
-COPY app/ ./app/
+COPY app ./app
 
-# Copiar archivos estáticos del Excel Add-in
-COPY static/ ./static/
+# Crear directorio para certificados
+RUN mkdir -p /app/certs
 
-# Crear usuario no-root
-RUN useradd -m -u 1000 user && \
-    chown -R user:user /app
-USER user
+EXPOSE 8000
 
-# Exponer puerto (HF Spaces usa 7860 por defecto)
-EXPOSE 7860
+# Script de inicio que genera certificados si no existen y ejecuta uvicorn
+COPY entrypoint.sh /app/entrypoint.sh
+RUN chmod +x /app/entrypoint.sh
 
-# Health check
-HEALTHCHECK --interval=30s --timeout=10s --start-period=5s --retries=3 \
-    CMD curl -f http://localhost:7860/health || exit 1
-
-# Comando de inicio
-CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "7860"]
+CMD ["/app/entrypoint.sh"]

app/api/routes/__init__.py

@@ -1,17 +0,0 @@
-"""
-API Routes package.
-
-Contiene todos los endpoints de la API organizados por funcionalidad.
-"""
-
-from .health import router as health_router
-from .forecast import router as forecast_router
-from .anomaly import router as anomaly_router
-from .backtest import router as backtest_router
-
-__all__ = [
-    "health_router",
-    "forecast_router",
-    "anomaly_router",
-    "backtest_router"
-]

excel-forecasting-api/.gitattributes

@@ -0,0 +1,35 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

excel-forecasting-api/Dockerfile

@@ -0,0 +1,34 @@
+FROM python:3.11-slim
+
+ENV DEBIAN_FRONTEND=noninteractive
+ENV CHRONOS_MODEL_ID=amazon/chronos-2
+ENV DEVICE_MAP=cpu
+ENV PYTHONUNBUFFERED=1
+ENV ENABLE_SSL=false
+
+WORKDIR /app
+
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    build-essential \
+    curl \
+    openssl \
+    git \
+ && rm -rf /var/lib/apt/lists/*
+
+COPY requirements.txt .
+
+RUN pip install --no-cache-dir --upgrade pip \
+    && pip install --no-cache-dir -r requirements.txt
+
+COPY app ./app
+
+# Crear directorio para certificados
+RUN mkdir -p /app/certs
+
+EXPOSE 7860
+
+# Script de inicio que genera certificados si no existen y ejecuta uvicorn
+COPY entrypoint.sh /app/entrypoint.sh
+RUN chmod +x /app/entrypoint.sh
+
+CMD ["/app/entrypoint.sh"]

excel-forecasting-api/app/main.py

@@ -0,0 +1,649 @@
+import os
+from typing import List, Dict, Optional
+
+import numpy as np
+import pandas as pd
+from fastapi import FastAPI, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel, Field
+
+from chronos import Chronos2Pipeline
+
+
+# =========================
+# Configuración del modelo
+# =========================
+
+MODEL_ID = os.getenv("CHRONOS_MODEL_ID", "amazon/chronos-2")
+DEVICE_MAP = os.getenv("DEVICE_MAP", "cpu")  # "cpu" o "cuda"
+ALLOWED_ORIGINS_ENV = os.getenv("ALLOWED_ORIGINS")
+ALLOWED_ORIGINS = (
+    [origin.strip() for origin in ALLOWED_ORIGINS_ENV.split(",") if origin.strip()]
+    if ALLOWED_ORIGINS_ENV
+    else ["*"]
+)
+
+app = FastAPI(
+    title="Chronos-2 Universal Forecasting API",
+    description=(
+        "Servidor local (Docker) para pronósticos con Chronos-2: univariante, "
+        "multivariante, covariables, escenarios, anomalías y backtesting."
+    ),
+    version="1.0.0",
+)
+
+# Configurar CORS para Excel Add-in
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=ALLOWED_ORIGINS,
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Carga única del modelo al iniciar el proceso
+pipeline = Chronos2Pipeline.from_pretrained(MODEL_ID, device_map=DEVICE_MAP)
+
+
+# =========================
+# Modelos Pydantic comunes
+# =========================
+
+class BaseForecastConfig(BaseModel):
+    prediction_length: int = Field(
+        7, description="Horizonte de predicción (número de pasos futuros)"
+    )
+    quantile_levels: List[float] = Field(
+        default_factory=lambda: [0.1, 0.5, 0.9],
+        description="Cuantiles para el pronóstico probabilístico",
+    )
+    start_timestamp: Optional[str] = Field(
+        default=None,
+        description=(
+            "Fecha/hora inicial del histórico (formato ISO). "
+            "Si no se especifica, se usan índices enteros."
+        ),
+    )
+    freq: str = Field(
+        "D",
+        description="Frecuencia temporal (p.ej. 'D' diario, 'H' horario, 'W' semanal...).",
+    )
+
+
+class UnivariateSeries(BaseModel):
+    values: List[float]
+
+
+class MultiSeriesItem(BaseModel):
+    series_id: str
+    values: List[float]
+
+
+class CovariatePoint(BaseModel):
+    """
+    Punto temporal usado tanto para contexto (histórico) como para covariables futuras.
+    """
+    timestamp: Optional[str] = None      # opcional si se usan índices enteros
+    id: Optional[str] = None             # id de serie, por defecto 'series_0'
+    target: Optional[float] = None       # valor de la variable objetivo (histórico)
+    covariates: Dict[str, float] = Field(
+        default_factory=dict,
+        description="Nombre -> valor de cada covariable dinámica.",
+    )
+
+
+# =========================
+# 1) Healthcheck
+# =========================
+
+@app.get("/health")
+def health():
+    """
+    Devuelve información básica del estado del servidor y el modelo cargado.
+    """
+    return {
+        "status": "ok",
+        "model_id": MODEL_ID,
+        "device_map": DEVICE_MAP,
+    }
+
+
+# =========================
+# 2) Pronóstico univariante
+# =========================
+
+class ForecastUnivariateRequest(BaseForecastConfig):
+    series: UnivariateSeries
+
+
+class ForecastUnivariateResponse(BaseModel):
+    timestamps: List[str]
+    median: List[float]
+    quantiles: Dict[str, List[float]]  # "0.1" -> [..], "0.9" -> [..]
+
+
+@app.post("/forecast_univariate", response_model=ForecastUnivariateResponse)
+def forecast_univariate(req: ForecastUnivariateRequest):
+    """
+    Pronóstico para una sola serie temporal (univariante, sin covariables).
+    Pensado para uso directo desde Excel u otras herramientas sencillas.
+    """
+    values = req.series.values
+    n = len(values)
+    if n == 0:
+        raise HTTPException(status_code=400, detail="La serie no puede estar vacía.")
+
+    # Construimos contexto como DataFrame largo (id, timestamp, target)
+    if req.start_timestamp:
+        timestamps = pd.date_range(
+            start=pd.to_datetime(req.start_timestamp),
+            periods=n,
+            freq=req.freq,
+        )
+    else:
+        timestamps = pd.RangeIndex(start=0, stop=n, step=1)
+
+    context_df = pd.DataFrame(
+        {
+            "id": ["series_0"] * n,
+            "timestamp": timestamps,
+            "target": values,
+        }
+    )
+
+    pred_df = pipeline.predict_df(
+        context_df,
+        prediction_length=req.prediction_length,
+        quantile_levels=req.quantile_levels,
+        id_column="id",
+        timestamp_column="timestamp",
+        target="target",
+    )
+
+    pred_df = pred_df.sort_values("timestamp")
+    timestamps_out = pred_df["timestamp"].astype(str).tolist()
+    median = pred_df["predictions"].astype(float).tolist()
+
+    quantiles_dict: Dict[str, List[float]] = {}
+    for q in req.quantile_levels:
+        key = f"{q:.3g}"
+        if key in pred_df.columns:
+            quantiles_dict[key] = pred_df[key].astype(float).tolist()
+
+    return ForecastUnivariateResponse(
+        timestamps=timestamps_out,
+        median=median,
+        quantiles=quantiles_dict,
+    )
+
+
+# =========================
+# 3) Multi-serie (multi-id)
+# =========================
+
+class ForecastMultiSeriesRequest(BaseForecastConfig):
+    series_list: List[MultiSeriesItem]
+
+
+class SeriesForecast(BaseModel):
+    series_id: str
+    timestamps: List[str]
+    median: List[float]
+    quantiles: Dict[str, List[float]]
+
+
+class ForecastMultiSeriesResponse(BaseModel):
+    forecasts: List[SeriesForecast]
+
+
+@app.post("/forecast_multi_id", response_model=ForecastMultiSeriesResponse)
+def forecast_multi_id(req: ForecastMultiSeriesRequest):
+    """
+    Pronóstico para múltiples series (por ejemplo, varios SKU o tiendas).
+    """
+    if not req.series_list:
+        raise HTTPException(status_code=400, detail="Debes enviar al menos una serie.")
+
+    frames = []
+    for item in req.series_list:
+        n = len(item.values)
+        if n == 0:
+            continue
+        if req.start_timestamp:
+            timestamps = pd.date_range(
+                start=pd.to_datetime(req.start_timestamp),
+                periods=n,
+                freq=req.freq,
+            )
+        else:
+            timestamps = pd.RangeIndex(start=0, stop=n, step=1)
+
+        frames.append(
+            pd.DataFrame(
+                {
+                    "id": [item.series_id] * n,
+                    "timestamp": timestamps,
+                    "target": item.values,
+                }
+            )
+        )
+
+    if not frames:
+        raise HTTPException(status_code=400, detail="Todas las series están vacías.")
+
+    context_df = pd.concat(frames, ignore_index=True)
+
+    pred_df = pipeline.predict_df(
+        context_df,
+        prediction_length=req.prediction_length,
+        quantile_levels=req.quantile_levels,
+        id_column="id",
+        timestamp_column="timestamp",
+        target="target",
+    )
+
+    forecasts: List[SeriesForecast] = []
+    for series_id, group in pred_df.groupby("id"):
+        group = group.sort_values("timestamp")
+        timestamps_out = group["timestamp"].astype(str).tolist()
+        median = group["predictions"].astype(float).tolist()
+        quantiles_dict: Dict[str, List[float]] = {}
+        for q in req.quantile_levels:
+            key = f"{q:.3g}"
+            if key in group.columns:
+                quantiles_dict[key] = group[key].astype(float).tolist()
+
+        forecasts.append(
+            SeriesForecast(
+                series_id=series_id,
+                timestamps=timestamps_out,
+                median=median,
+                quantiles=quantiles_dict,
+            )
+        )
+
+    return ForecastMultiSeriesResponse(forecasts=forecasts)
+
+
+# =========================
+# 4) Pronóstico con covariables
+# =========================
+
+class ForecastWithCovariatesRequest(BaseForecastConfig):
+    context: List[CovariatePoint]
+    future: Optional[List[CovariatePoint]] = None
+
+
+class ForecastWithCovariatesResponse(BaseModel):
+    # filas con todas las columnas de pred_df serializadas como string
+    pred_df: List[Dict[str, str]]
+
+
+@app.post("/forecast_with_covariates", response_model=ForecastWithCovariatesResponse)
+def forecast_with_covariates(req: ForecastWithCovariatesRequest):
+    """
+    Pronóstico con información de covariables (promos, precio, clima...) tanto
+    en el histórico (context) como en futuros posibles (future).
+    """
+    if not req.context:
+        raise HTTPException(status_code=400, detail="El contexto no puede estar vacío.")
+
+    ctx_rows = []
+    for p in req.context:
+        if p.target is None:
+            continue
+        row = {
+            "id": p.id or "series_0",
+            "timestamp": p.timestamp,
+            "target": p.target,
+        }
+        for k, v in p.covariates.items():
+            row[k] = v
+        ctx_rows.append(row)
+
+    context_df = pd.DataFrame(ctx_rows)
+    if "timestamp" not in context_df or context_df["timestamp"].isna().any():
+        context_df["timestamp"] = pd.RangeIndex(start=0, stop=len(context_df), step=1)
+
+    future_df = None
+    if req.future:
+        fut_rows = []
+        for p in req.future:
+            row = {
+                "id": p.id or "series_0",
+                "timestamp": p.timestamp,
+            }
+            for k, v in p.covariates.items():
+                row[k] = v
+            fut_rows.append(row)
+        future_df = pd.DataFrame(fut_rows)
+        if "timestamp" not in future_df or future_df["timestamp"].isna().any():
+            future_df["timestamp"] = pd.RangeIndex(
+                start=context_df["timestamp"].max() + 1,
+                stop=context_df["timestamp"].max() + 1 + len(future_df),
+                step=1,
+            )
+
+    pred_df = pipeline.predict_df(
+        context_df,
+        future_df=future_df,
+        prediction_length=req.prediction_length,
+        quantile_levels=req.quantile_levels,
+        id_column="id",
+        timestamp_column="timestamp",
+        target="target",
+    )
+
+    pred_df = pred_df.sort_values(["id", "timestamp"])
+    out_records: List[Dict[str, str]] = []
+    for _, row in pred_df.iterrows():
+        record = {k: str(v) for k, v in row.items()}
+        out_records.append(record)
+
+    return ForecastWithCovariatesResponse(pred_df=out_records)
+
+
+# =========================
+# 5) Multivariante (varios targets)
+# =========================
+
+class MultivariateContextPoint(BaseModel):
+    timestamp: Optional[str] = None
+    id: Optional[str] = None
+    targets: Dict[str, float]            # p.ej. {"demand": 100, "returns": 5}
+    covariates: Dict[str, float] = Field(default_factory=dict)
+
+
+class ForecastMultivariateRequest(BaseForecastConfig):
+    context: List[MultivariateContextPoint]
+    target_columns: List[str]            # nombres de columnas objetivo
+
+
+class ForecastMultivariateResponse(BaseModel):
+    pred_df: List[Dict[str, str]]
+
+
+@app.post("/forecast_multivariate", response_model=ForecastMultivariateResponse)
+def forecast_multivariate(req: ForecastMultivariateRequest):
+    """
+    Pronóstico multivariante: múltiples columnas objetivo (p.ej. demanda y devoluciones).
+    """
+    if not req.context:
+        raise HTTPException(status_code=400, detail="El contexto no puede estar vacío.")
+    if not req.target_columns:
+        raise HTTPException(status_code=400, detail="Debes indicar columnas objetivo.")
+
+    rows = []
+    for p in req.context:
+        base = {
+            "id": p.id or "series_0",
+            "timestamp": p.timestamp,
+        }
+        for t_name, t_val in p.targets.items():
+            base[t_name] = t_val
+        for k, v in p.covariates.items():
+            base[k] = v
+        rows.append(base)
+
+    context_df = pd.DataFrame(rows)
+    if "timestamp" not in context_df or context_df["timestamp"].isna().any():
+        context_df["timestamp"] = pd.RangeIndex(start=0, stop=len(context_df), step=1)
+
+    pred_df = pipeline.predict_df(
+        context_df,
+        prediction_length=req.prediction_length,
+        quantile_levels=req.quantile_levels,
+        id_column="id",
+        timestamp_column="timestamp",
+        target=req.target_columns,
+    )
+
+    pred_df = pred_df.sort_values(["id", "timestamp"])
+    out_records = [{k: str(v) for k, v in row.items()} for _, row in pred_df.iterrows()]
+    return ForecastMultivariateResponse(pred_df=out_records)
+
+
+# =========================
+# 6) Escenarios (what-if)
+# =========================
+
+class ScenarioDefinition(BaseModel):
+    name: str
+    future_covariates: List[CovariatePoint]
+
+
+class ScenarioForecast(BaseModel):
+    name: str
+    pred_df: List[Dict[str, str]]
+
+
+class ForecastScenariosRequest(BaseForecastConfig):
+    context: List[CovariatePoint]
+    scenarios: List[ScenarioDefinition]
+
+
+class ForecastScenariosResponse(BaseModel):
+    scenarios: List[ScenarioForecast]
+
+
+@app.post("/forecast_scenarios", response_model=ForecastScenariosResponse)
+def forecast_scenarios(req: ForecastScenariosRequest):
+    """
+    Evaluación de múltiples escenarios (what-if) cambiando las covariables futuras
+    (por ejemplo, promo ON/OFF, diferentes precios, etc.).
+    """
+    if not req.context:
+        raise HTTPException(status_code=400, detail="El contexto no puede estar vacío.")
+    if not req.scenarios:
+        raise HTTPException(status_code=400, detail="Debes definir al menos un escenario.")
+
+    ctx_rows = []
+    for p in req.context:
+        if p.target is None:
+            continue
+        row = {
+            "id": p.id or "series_0",
+            "timestamp": p.timestamp,
+            "target": p.target,
+        }
+        for k, v in p.covariates.items():
+            row[k] = v
+        ctx_rows.append(row)
+
+    context_df = pd.DataFrame(ctx_rows)
+    if "timestamp" not in context_df or context_df["timestamp"].isna().any():
+        context_df["timestamp"] = pd.RangeIndex(start=0, stop=len(context_df), step=1)
+
+    results: List[ScenarioForecast] = []
+
+    for scen in req.scenarios:
+        fut_rows = []
+        for p in scen.future_covariates:
+            row = {
+                "id": p.id or "series_0",
+                "timestamp": p.timestamp,
+            }
+            for k, v in p.covariates.items():
+                row[k] = v
+            fut_rows.append(row)
+        future_df = pd.DataFrame(fut_rows)
+        if "timestamp" not in future_df or future_df["timestamp"].isna().any():
+            future_df["timestamp"] = pd.RangeIndex(
+                start=context_df["timestamp"].max() + 1,
+                stop=context_df["timestamp"].max() + 1 + len(future_df),
+                step=1,
+            )
+
+        pred_df = pipeline.predict_df(
+            context_df,
+            future_df=future_df,
+            prediction_length=req.prediction_length,
+            quantile_levels=req.quantile_levels,
+            id_column="id",
+            timestamp_column="timestamp",
+            target="target",
+        )
+        pred_df = pred_df.sort_values(["id", "timestamp"])
+        out_records = [{k: str(v) for k, v in row.items()} for _, row in pred_df.iterrows()]
+
+        results.append(ScenarioForecast(name=scen.name, pred_df=out_records))
+
+    return ForecastScenariosResponse(scenarios=results)
+
+
+# =========================
+# 7) Detección de anomalías
+# =========================
+
+class AnomalyDetectionRequest(BaseModel):
+    context: UnivariateSeries
+    recent_observed: List[float]
+    prediction_length: int = 7
+    quantile_low: float = 0.05
+    quantile_high: float = 0.95
+
+
+class AnomalyPoint(BaseModel):
+    index: int
+    value: float
+    predicted_median: float
+    lower: float
+    upper: float
+    is_anomaly: bool
+
+
+class AnomalyDetectionResponse(BaseModel):
+    anomalies: List[AnomalyPoint]
+
+
+@app.post("/detect_anomalies", response_model=AnomalyDetectionResponse)
+def detect_anomalies(req: AnomalyDetectionRequest):
+    """
+    Marca como anomalías los puntos observados recientes que caen fuera del
+    intervalo [quantile_low, quantile_high] del pronóstico.
+    """
+    n_hist = len(req.context.values)
+    if n_hist == 0:
+        raise HTTPException(status_code=400, detail="La serie histórica no puede estar vacía.")
+    if len(req.recent_observed) != req.prediction_length:
+        raise HTTPException(
+            status_code=400,
+            detail="recent_observed debe tener la misma longitud que prediction_length.",
+        )
+
+    context_df = pd.DataFrame(
+        {
+            "id": ["series_0"] * n_hist,
+            "timestamp": pd.RangeIndex(start=0, stop=n_hist, step=1),
+            "target": req.context.values,
+        }
+    )
+
+    quantiles = sorted({req.quantile_low, 0.5, req.quantile_high})
+    pred_df = pipeline.predict_df(
+        context_df,
+        prediction_length=req.prediction_length,
+        quantile_levels=quantiles,
+        id_column="id",
+        timestamp_column="timestamp",
+        target="target",
+    ).sort_values("timestamp")
+
+    q_low_col = f"{req.quantile_low:.3g}"
+    q_high_col = f"{req.quantile_high:.3g}"
+
+    anomalies: List[AnomalyPoint] = []
+    for i, (obs, (_, row)) in enumerate(zip(req.recent_observed, pred_df.iterrows())):
+        lower = float(row[q_low_col])
+        upper = float(row[q_high_col])
+        median = float(row["predictions"])
+        is_anom = (obs < lower) or (obs > upper)
+        anomalies.append(
+            AnomalyPoint(
+                index=i,
+                value=obs,
+                predicted_median=median,
+                lower=lower,
+                upper=upper,
+                is_anomaly=is_anom,
+            )
+        )
+
+    return AnomalyDetectionResponse(anomalies=anomalies)
+
+
+# =========================
+# 8) Backtest simple
+# =========================
+
+class BacktestRequest(BaseModel):
+    series: UnivariateSeries
+    prediction_length: int = 7
+    test_length: int = 28
+
+
+class BacktestMetrics(BaseModel):
+    mae: float
+    mape: float
+    wql: float  # Weighted Quantile Loss aproximada para el cuantil 0.5
+
+
+class BacktestResponse(BaseModel):
+    metrics: BacktestMetrics
+    forecast_median: List[float]
+    forecast_timestamps: List[str]
+    actuals: List[float]
+
+
+@app.post("/backtest_simple", response_model=BacktestResponse)
+def backtest_simple(req: BacktestRequest):
+    """
+    Backtest sencillo: separamos un tramo final de la serie como test, pronosticamos
+    ese tramo y calculamos métricas MAE / MAPE / WQL.
+    """
+    values = np.array(req.series.values, dtype=float)
+    n = len(values)
+    if n <= req.test_length:
+        raise HTTPException(
+            status_code=400,
+            detail="La serie debe ser más larga que test_length.",
+        )
+
+    train = values[: n - req.test_length]
+    test = values[n - req.test_length :]
+
+    context_df = pd.DataFrame(
+        {
+            "id": ["series_0"] * len(train),
+            "timestamp": pd.RangeIndex(start=0, stop=len(train), step=1),
+            "target": train.tolist(),
+        }
+    )
+
+    pred_df = pipeline.predict_df(
+        context_df,
+        prediction_length=req.test_length,
+        quantile_levels=[0.5],
+        id_column="id",
+        timestamp_column="timestamp",
+        target="target",
+    ).sort_values("timestamp")
+
+    forecast = pred_df["predictions"].to_numpy(dtype=float)
+    timestamps = pred_df["timestamp"].astype(str).tolist()
+
+    mae = float(np.mean(np.abs(test - forecast)))
+    eps = 1e-8
+    mape = float(np.mean(np.abs((test - forecast) / (test + eps)))) * 100.0
+    tau = 0.5
+    diff = test - forecast
+    wql = float(np.mean(np.maximum(tau * diff, (tau - 1) * diff)))
+
+    metrics = BacktestMetrics(mae=mae, mape=mape, wql=wql)
+
+    return BacktestResponse(
+        metrics=metrics,
+        forecast_median=forecast.tolist(),
+        forecast_timestamps=timestamps,
+        actuals=test.tolist(),
+    )

excel-forecasting-api/entrypoint.sh

@@ -0,0 +1,33 @@
+#!/bin/bash
+set -euo pipefail
+
+PORT="${PORT:-7860}"
+ENABLE_SSL="${ENABLE_SSL:-true}"
+
+mkdir -p /app/certs
+
+if [ "${ENABLE_SSL}" = "true" ]; then
+    if [ ! -f /app/certs/server.key ] || [ ! -f /app/certs/server.crt ]; then
+        echo "Generating self-signed SSL certificates"
+        openssl req -x509 -newkey rsa:2048 \
+            -keyout /app/certs/server.key \
+            -out /app/certs/server.crt \
+            -days 365 -nodes \
+            -subj "/C=US/ST=State/L=City/O=Chronos2/CN=localhost"
+        chmod 644 /app/certs/server.*
+    else
+        echo "Reusing existing SSL certificates"
+    fi
+
+    echo "Starting HTTPS server on port ${PORT}"
+    exec uvicorn app.main:app \
+        --host 0.0.0.0 \
+        --port "${PORT}" \
+        --ssl-keyfile /app/certs/server.key \
+        --ssl-certfile /app/certs/server.crt
+else
+    echo "Starting HTTP server on port ${PORT}"
+    exec uvicorn app.main:app \
+        --host 0.0.0.0 \
+        --port "${PORT}"
+fi

excel-forecasting-api/requirements.txt

@@ -0,0 +1,9 @@
+--index-url https://download.pytorch.org/whl/cpu
+--extra-index-url https://pypi.org/simple
+
+torch==2.9.0+cpu
+chronos-forecasting>=2.0.0
+pandas[pyarrow]
+fastapi
+uvicorn[standard]
+numpy

pytest.ini

@@ -0,0 +1,22 @@
+[pytest]
+# Pytest configuration
+testpaths = tests
+python_files = test_*.py
+python_classes = Test*
+python_functions = test_*
+
+# Output options
+addopts = 
+    -v
+    --strict-markers
+    --tb=short
+    --disable-warnings
+
+# Coverage options (cuando se use pytest-cov)
+# addopts += --cov=app --cov-report=html --cov-report=term-missing
+
+# Markers
+markers =
+    unit: Unit tests
+    integration: Integration tests
+    slow: Slow tests

static/taskpane/taskpane.css

@@ -306,3 +306,223 @@ body {
 .results-log::-webkit-scrollbar-thumb:hover {
     background: #555;
 }
+
+/* ====================================================================
+   FORECAST PREVIEW & COPY TO CLIPBOARD
+   ==================================================================== */
+
+/* Forecast Preview Card */
+.forecast-preview-card {
+    background: white;
+    border-radius: 12px;
+    padding: 16px;
+    margin-bottom: 20px;
+    box-shadow: 0 4px 12px rgba(0,0,0,0.1);
+    border: 2px solid #667eea;
+    animation: slideIn 0.3s ease-out;
+}
+
+@keyframes slideIn {
+    from {
+        opacity: 0;
+        transform: translateY(-10px);
+    }
+    to {
+        opacity: 1;
+        transform: translateY(0);
+    }
+}
+
+.preview-header {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    margin-bottom: 12px;
+    padding-bottom: 12px;
+    border-bottom: 2px solid #f0f0f0;
+}
+
+.preview-header h3 {
+    font-size: 16px;
+    font-weight: 600;
+    color: #667eea;
+    margin: 0;
+}
+
+.preview-count {
+    font-size: 12px;
+    background: #667eea;
+    color: white;
+    padding: 4px 12px;
+    border-radius: 12px;
+    font-weight: 500;
+}
+
+.preview-table-container {
+    max-height: 200px;
+    overflow-y: auto;
+    margin-bottom: 12px;
+    border-radius: 6px;
+    border: 1px solid #e5e7eb;
+}
+
+.preview-table {
+    width: 100%;
+    border-collapse: collapse;
+    font-size: 12px;
+}
+
+.preview-table thead {
+    position: sticky;
+    top: 0;
+    background: #f9fafb;
+    z-index: 1;
+}
+
+.preview-table th {
+    padding: 8px;
+    text-align: left;
+    font-weight: 600;
+    color: #374151;
+    border-bottom: 2px solid #e5e7eb;
+}
+
+.preview-table td {
+    padding: 8px;
+    border-bottom: 1px solid #f0f0f0;
+    color: #4b5563;
+}
+
+.preview-table tbody tr:hover {
+    background: #f9fafb;
+}
+
+.preview-table .preview-more td {
+    text-align: center;
+    font-style: italic;
+    color: #9ca3af;
+}
+
+.preview-actions {
+    display: flex;
+    flex-direction: column;
+    gap: 8px;
+}
+
+.btn-copy-forecast {
+    width: 100%;
+    font-size: 14px;
+    font-weight: 600;
+    padding: 12px;
+    background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+    box-shadow: 0 2px 8px rgba(102, 126, 234, 0.3);
+}
+
+.btn-copy-forecast:hover {
+    transform: translateY(-1px);
+    box-shadow: 0 4px 12px rgba(102, 126, 234, 0.4);
+}
+
+.preview-hint {
+    text-align: center;
+    font-size: 11px;
+    color: #6b7280;
+    padding: 8px;
+    background: #f9fafb;
+    border-radius: 6px;
+}
+
+/* Copy Toast Notification */
+.copy-toast {
+    position: fixed;
+    top: 20px;
+    right: 20px;
+    z-index: 9999;
+    background: linear-gradient(135deg, #10b981 0%, #059669 100%);
+    color: white;
+    padding: 16px 20px;
+    border-radius: 12px;
+    box-shadow: 0 8px 24px rgba(16, 185, 129, 0.4);
+    opacity: 0;
+    transform: translateX(100px);
+    transition: all 0.3s ease-out;
+}
+
+.copy-toast.show {
+    opacity: 1;
+    transform: translateX(0);
+}
+
+.toast-content {
+    display: flex;
+    align-items: center;
+    gap: 12px;
+}
+
+.toast-icon {
+    font-size: 24px;
+}
+
+.toast-text {
+    font-size: 14px;
+    font-weight: 600;
+}
+
+/* Copy Fallback Modal */
+.copy-fallback-modal {
+    position: fixed;
+    top: 0;
+    left: 0;
+    right: 0;
+    bottom: 0;
+    z-index: 10000;
+    background: rgba(0, 0, 0, 0.5);
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    padding: 20px;
+    animation: fadeIn 0.2s;
+}
+
+@keyframes fadeIn {
+    from { opacity: 0; }
+    to { opacity: 1; }
+}
+
+.copy-fallback-modal .modal-content {
+    background: white;
+    border-radius: 12px;
+    padding: 24px;
+    max-width: 500px;
+    width: 100%;
+    box-shadow: 0 20px 60px rgba(0,0,0,0.3);
+}
+
+.copy-fallback-modal h3 {
+    margin: 0 0 12px 0;
+    font-size: 18px;
+    color: #1f2937;
+}
+
+.copy-fallback-modal p {
+    margin: 0 0 12px 0;
+    font-size: 13px;
+    color: #6b7280;
+}
+
+.copy-textarea {
+    width: 100%;
+    height: 200px;
+    padding: 12px;
+    border: 2px solid #e5e7eb;
+    border-radius: 6px;
+    font-family: 'Courier New', monospace;
+    font-size: 11px;
+    resize: vertical;
+    margin-bottom: 12px;
+}
+
+.copy-textarea:focus {
+    outline: none;
+    border-color: #667eea;
+}

static/taskpane/taskpane.js

@@ -136,6 +136,213 @@ async function writeToRange(data, startCell) {
     });
 }
 
+// ====================================================================
+// COPY TO CLIPBOARD FUNCTIONALITY
+// ====================================================================
+
+/**
+ * Format forecast results as TSV (Tab-Separated Values)
+ * Excel automatically recognizes TSV and creates a table
+ */
+function formatForecastAsTSV(timestamps, median, q10, q90) {
+    // Header row
+    let tsv = 'Date\tForecast\tLower 10%\tUpper 90%\n';
+    
+    // Data rows
+    for (let i = 0; i < timestamps.length; i++) {
+        const date = timestamps[i] || `Period ${i + 1}`;
+        const med = median[i]?.toFixed(2) || '';
+        const lower = q10[i]?.toFixed(2) || '';
+        const upper = q90[i]?.toFixed(2) || '';
+        
+        tsv += `${date}\t${med}\t${lower}\t${upper}\n`;
+    }
+    
+    return tsv;
+}
+
+/**
+ * Copy forecast results to clipboard
+ */
+async function copyForecastToClipboard(timestamps, median, q10, q90) {
+    try {
+        console.log('[copyToClipboard] Formatting data...');
+        
+        // Format as TSV
+        const tsv = formatForecastAsTSV(timestamps, median, q10, q90);
+        
+        console.log('[copyToClipboard] TSV length:', tsv.length);
+        console.log('[copyToClipboard] Preview:', tsv.substring(0, 200));
+        
+        // Copy to clipboard using Clipboard API
+        await navigator.clipboard.writeText(tsv);
+        
+        console.log('[copyToClipboard] ✅ Copied successfully');
+        
+        // User feedback
+        log('✅ Forecast copied to clipboard! Paste in Excel with Ctrl+V', 'success');
+        showCopySuccessNotification();
+        
+        return true;
+    } catch (error) {
+        console.error('[copyToClipboard] ❌ Error:', error);
+        
+        // Fallback: Show modal with selectable text
+        showCopyFallbackModal(formatForecastAsTSV(timestamps, median, q10, q90));
+        log('⚠️ Please select and copy the text manually', 'warning');
+        
+        return false;
+    }
+}
+
+/**
+ * Show temporary success notification
+ */
+function showCopySuccessNotification() {
+    // Create toast notification
+    const toast = document.createElement('div');
+    toast.className = 'copy-toast';
+    toast.innerHTML = `
+        <div class="toast-content">
+            <span class="toast-icon">📋</span>
+            <span class="toast-text">Copied to clipboard!</span>
+        </div>
+    `;
+    
+    document.body.appendChild(toast);
+    
+    // Animate in
+    setTimeout(() => toast.classList.add('show'), 10);
+    
+    // Remove after 3 seconds
+    setTimeout(() => {
+        toast.classList.remove('show');
+        setTimeout(() => toast.remove(), 300);
+    }, 3000);
+}
+
+/**
+ * Show fallback modal if clipboard API fails
+ */
+function showCopyFallbackModal(text) {
+    // Create modal
+    const modal = document.createElement('div');
+    modal.className = 'copy-fallback-modal';
+    modal.innerHTML = `
+        <div class="modal-content">
+            <h3>Copy Forecast Results</h3>
+            <p>Select all text below and copy (Ctrl+C or Cmd+C):</p>
+            <textarea readonly class="copy-textarea">${text}</textarea>
+            <button onclick="this.parentElement.parentElement.remove()" class="btn btn-secondary">
+                Close
+            </button>
+        </div>
+    `;
+    
+    document.body.appendChild(modal);
+    
+    // Auto-select text
+    const textarea = modal.querySelector('.copy-textarea');
+    textarea.focus();
+    textarea.select();
+}
+
+/**
+ * Show forecast preview with copy button
+ */
+function showForecastPreview(forecastData) {
+    const { timestamps, median, q10, q90 } = forecastData;
+    
+    // Create preview HTML
+    let previewHTML = `
+        <div class="forecast-preview-card">
+            <div class="preview-header">
+                <h3>📊 Forecast Preview</h3>
+                <span class="preview-count">${timestamps.length} periods</span>
+            </div>
+            <div class="preview-table-container">
+                <table class="preview-table">
+                    <thead>
+                        <tr>
+                            <th>Date</th>
+                            <th>Forecast</th>
+                            <th>Lower</th>
+                            <th>Upper</th>
+                        </tr>
+                    </thead>
+                    <tbody>
+    `;
+    
+    // Show first 5 rows
+    const displayRows = Math.min(5, timestamps.length);
+    for (let i = 0; i < displayRows; i++) {
+        previewHTML += `
+            <tr>
+                <td>${timestamps[i] || `P${i+1}`}</td>
+                <td>${median[i].toFixed(2)}</td>
+                <td>${q10[i].toFixed(2)}</td>
+                <td>${q90[i].toFixed(2)}</td>
+            </tr>
+        `;
+    }
+    
+    if (timestamps.length > 5) {
+        previewHTML += `
+            <tr class="preview-more">
+                <td colspan="4">... and ${timestamps.length - 5} more rows</td>
+            </tr>
+        `;
+    }
+    
+    previewHTML += `
+                    </tbody>
+                </table>
+            </div>
+            <div class="preview-actions">
+                <button class="btn btn-primary btn-copy-forecast" onclick="copyLastForecast()">
+                    📋 Copy to Clipboard
+                </button>
+                <div class="preview-hint">
+                    💡 Click to copy, then paste in Excel with Ctrl+V
+                </div>
+            </div>
+        </div>
+    `;
+    
+    // Find or create preview container
+    let previewContainer = document.getElementById('forecast-preview');
+    if (!previewContainer) {
+        previewContainer = document.createElement('div');
+        previewContainer.id = 'forecast-preview';
+        
+        // Insert after results log
+        const resultsCard = document.querySelector('.results-card');
+        if (resultsCard) {
+            resultsCard.parentNode.insertBefore(previewContainer, resultsCard);
+        } else {
+            document.querySelector('.container').appendChild(previewContainer);
+        }
+    }
+    
+    previewContainer.innerHTML = previewHTML;
+    
+    // Scroll to preview
+    previewContainer.scrollIntoView({ behavior: 'smooth', block: 'nearest' });
+}
+
+/**
+ * Copy last forecast (called from button)
+ */
+function copyLastForecast() {
+    if (!window.lastForecastData) {
+        log('⚠️ No forecast data available to copy', 'warning');
+        return;
+    }
+    
+    const { timestamps, median, q10, q90 } = window.lastForecastData;
+    copyForecastToClipboard(timestamps, median, q10, q90);
+}
+
 async function writeForecastResults(timestamps, median, q10, q90, startRow) {
     return Excel.run(async (context) => {
         try {
@@ -248,6 +455,17 @@ async function forecastUnivariate() {
         
         log(`Received forecast for ${data.timestamps.length} periods`, 'success');
         
+        // Store forecast data globally for copy function
+        window.lastForecastData = {
+            timestamps: data.timestamps,
+            median: data.median,
+            q10: data.quantiles['0.1'],
+            q90: data.quantiles['0.9']
+        };
+        
+        // Show preview with copy button
+        showForecastPreview(window.lastForecastData);
+        
         // Escribir resultados
         await Excel.run(async (context) => {
             const selection = context.workbook.getSelectedRange();