From a693b454bd048bf508409d916519800a1ae95a5b Mon Sep 17 00:00:00 2001 From: Saransh Kumar Date: Sat, 4 Apr 2026 23:28:14 -0400 Subject: [PATCH 1/6] fix merge conflicts --- app/agent/executor.py | 58 +- app/agent/graph.py | 6 +- app/agent/planner.py | 18 +- app/agent/state.py | 4 +- app/api/chat_routes.py | 14 +- app/api/routes.py | 17 +- app/api/workspace.py | 98 +-- app/config.py | 1 + app/data/registry.py | 1205 ++++++++++++++++++++++++++ app/data/semantic_model.py | 218 ++--- app/prompts/planner_compiled.j2 | 3 + app/prompts/planner_repair.j2 | 2 + app/schemas.py | 24 + app/services/analysis_run.py | 4 +- data/source_registry.duckdb | Bin 0 -> 13381632 bytes tests/test_api.py | 108 ++- tests/test_source_registry.py | 85 ++ ui/src/api/chat.ts | 9 +- ui/src/api/types.ts | 1 + ui/src/components/app/ChatInput.tsx | 2 +- ui/src/components/app/UploadCard.tsx | 4 + ui/src/hooks/useChat.ts | 4 + ui/src/types/upload.ts | 2 + 23 files changed, 1587 insertions(+), 300 deletions(-) create mode 100644 app/data/registry.py create mode 100644 data/source_registry.duckdb create mode 100644 tests/test_source_registry.py diff --git a/app/agent/executor.py b/app/agent/executor.py index b9915e5..d8e58af 100644 --- a/app/agent/executor.py +++ b/app/agent/executor.py @@ -61,15 +61,18 @@ def _register_artifacts(conn: duckdb.DuckDBPyConnection, state: AnalysisState) - def _execute_sql(state: AnalysisState, step: dict[str, Any]) -> ArtifactSummary: - conn = new_duckdb_connection() - _register_artifacts(conn, state) - frame = conn.execute(step["code"]).fetchdf() - state["artifacts"][step["output_alias"]] = frame - return _summarize_artifact(step["output_alias"], frame) + conn = new_duckdb_connection(state.get("dataset_context")) + try: + _register_artifacts(conn, state) + frame = conn.execute(step["code"]).fetchdf() + state["artifacts"][step["output_alias"]] = frame + return _summarize_artifact(step["output_alias"], frame) + finally: + conn.close() def _execute_pandas(state: AnalysisState, step: dict[str, Any]) -> ArtifactSummary: - context = get_semantic_context() + context = get_semantic_context(state.get("source_ids")) local_env: dict[str, Any] = { **context.raw_views, **context.semantic_views, @@ -112,26 +115,29 @@ def preflight_compiled_plan(state: AnalysisState, compiled_plan: dict[str, Any]) Steps are checked in order so later queries can reference earlier output aliases. """ - conn = new_duckdb_connection() - _register_artifacts(conn, state) - rows = list(compiled_plan.get("plan") or []) - rows.sort(key=lambda r: r["id"] if isinstance(r, dict) else r.id) - - for row in rows: - internal = compiled_plan_row_to_internal(row) - sql = internal["code"].strip().rstrip(";") - try: - preview = conn.execute(f"SELECT * FROM ({sql}) AS __planera_preflight LIMIT 0").fetchdf() - conn.register(internal["output_alias"], preview) - except Exception as exc: - return { - "status": "failed", - "failed_step_id": internal["id"], - "error": str(exc), - "query": internal["code"], - } - - return {"status": "success"} + conn = new_duckdb_connection(state.get("dataset_context")) + try: + _register_artifacts(conn, state) + rows = list(compiled_plan.get("plan") or []) + rows.sort(key=lambda r: r["id"] if isinstance(r, dict) else r.id) + + for row in rows: + internal = compiled_plan_row_to_internal(row) + sql = internal["code"].strip().rstrip(";") + try: + preview = conn.execute(f"SELECT * FROM ({sql}) AS __planera_preflight LIMIT 0").fetchdf() + conn.register(internal["output_alias"], preview) + except Exception as exc: + return { + "status": "failed", + "failed_step_id": internal["id"], + "error": str(exc), + "query": internal["code"], + } + + return {"status": "success"} + finally: + conn.close() def _try_sql_step( diff --git a/app/agent/graph.py b/app/agent/graph.py index 0bc9ef3..076944b 100644 --- a/app/agent/graph.py +++ b/app/agent/graph.py @@ -28,7 +28,7 @@ def _append_error(state: AnalysisState, step: str, message: str, recoverable: bo def load_schema_context_node(state: AnalysisState) -> AnalysisState: step_name = "load_schema_context_node" _append_trace(state, step_name, "started", {}) - context = get_semantic_context() + context = get_semantic_context(state.get("source_ids")) state["dataset_context"] = context.schema_manifest _append_trace( state, @@ -162,8 +162,8 @@ def build_graph(): return graph.compile() -def run_analysis(query: str) -> AnalysisState: +def run_analysis(query: str, source_ids: list[str] | None = None) -> AnalysisState: """Execute the full workflow for a single user query.""" workflow = build_graph() - return workflow.invoke(create_initial_state(query)) + return workflow.invoke(create_initial_state(query, source_ids=source_ids)) diff --git a/app/agent/planner.py b/app/agent/planner.py index 0c9892a..5fc8bdb 100644 --- a/app/agent/planner.py +++ b/app/agent/planner.py @@ -38,7 +38,11 @@ def _field_terms(*values: str) -> set[str]: def _column_relevance_score(column: dict[str, Any], question_terms: set[str]) -> int: - column_terms = _field_terms(column.get("name", "")) + column_terms = _field_terms( + column.get("name", ""), + column.get("original_name", ""), + column.get("source_path", ""), + ) for hint in column.get("semantic_hints") or []: column_terms.update(_field_terms(hint)) @@ -50,10 +54,20 @@ def _column_relevance_score(column: dict[str, Any], question_terms: set[str]) -> def _relation_relevance_score(relation: dict[str, Any], question_terms: set[str]) -> int: - score = len(_field_terms(relation.get("name", ""), relation.get("grain", "")) & question_terms) * 4 + score = len( + _field_terms( + relation.get("name", ""), + relation.get("grain", ""), + relation.get("source_name", ""), + json.dumps(relation.get("lineage", {}), default=str), + ) + & question_terms + ) * 4 score += sum(_column_relevance_score(column, question_terms) for column in relation.get("columns") or []) for mapping in relation.get("semantic_mappings") or []: score += len(_field_terms(mapping.get("concept", "")) & question_terms) * 5 + if relation.get("is_primary"): + score += 3 return score diff --git a/app/agent/state.py b/app/agent/state.py index 18a1a7d..c940ed7 100644 --- a/app/agent/state.py +++ b/app/agent/state.py @@ -11,6 +11,7 @@ class AnalysisState(TypedDict): """Explicit state carried through the analytics workflow.""" query: str + source_ids: list[str] dataset_context: dict[str, Any] intent: str metric: str @@ -27,11 +28,12 @@ class AnalysisState(TypedDict): errors: list[dict[str, Any]] -def create_initial_state(query: str) -> AnalysisState: +def create_initial_state(query: str, source_ids: list[str] | None = None) -> AnalysisState: """Return the initial workflow state for a new request.""" return AnalysisState( query=query, + source_ids=list(source_ids or []), dataset_context={}, intent="", metric="", diff --git a/app/api/chat_routes.py b/app/api/chat_routes.py index 0c5f72c..58df79d 100644 --- a/app/api/chat_routes.py +++ b/app/api/chat_routes.py @@ -15,6 +15,7 @@ from app.auth.deps import get_current_user from app.config import get_settings +from app.data.registry import get_upload_source_ids from app.db.session import get_db from app.models.conversation import Conversation, Message from app.models.user import User @@ -146,8 +147,19 @@ def chat_turn( db.add(user_msg) db.flush() + requested_source_ids = list(dict.fromkeys(body.source_ids or [])) + if requested_source_ids: + valid_source_ids = get_upload_source_ids(requested_source_ids) + if len(valid_source_ids) != len(requested_source_ids): + raise HTTPException( + status_code=status.HTTP_400_BAD_REQUEST, + detail={"message": "Attach a valid uploaded data source before running analysis."}, + ) + else: + valid_source_ids = None + try: - analysis_run = run_stored_analysis(body.query) + analysis_run = run_stored_analysis(body.query, source_ids=valid_source_ids) analysis_result = analysis_run.response inspection_payload = analysis_run.inspection except Exception as exc: # pragma: no cover - defensive API fallback diff --git a/app/api/routes.py b/app/api/routes.py index da1cd92..8a421ff 100644 --- a/app/api/routes.py +++ b/app/api/routes.py @@ -14,6 +14,7 @@ from app.models.user import User from app.schemas import AnalyzeRequest, AnalyzeResponse, HealthResponse, InspectionData, InspectionResponse, SampleQuestionsResponse, UploadResponse from app.services.analysis_run import run_stored_analysis +from app.data.registry import get_upload_source_ids from app.utils.constants import SAMPLE_QUESTIONS from app.utils.logging import get_logger @@ -103,8 +104,22 @@ def inspection_details( def analyze(request: AnalyzeRequest) -> AnalyzeResponse: """Run analytics without persistence (see OpenAPI ``description`` — prefer ``POST /chat`` for product flows).""" + requested_source_ids = list(dict.fromkeys(request.source_ids or [])) + if not requested_source_ids: + raise HTTPException( + status_code=status.HTTP_400_BAD_REQUEST, + detail={"message": "Upload and attach at least one CSV or JSON data source before running analysis."}, + ) + + valid_source_ids = get_upload_source_ids(requested_source_ids) + if len(valid_source_ids) != len(requested_source_ids): + raise HTTPException( + status_code=status.HTTP_400_BAD_REQUEST, + detail={"message": "Attach a valid uploaded data source before running analysis."}, + ) + try: - return run_stored_analysis(request.query).response + return run_stored_analysis(request.query, source_ids=valid_source_ids).response except Exception as exc: # pragma: no cover - defensive API fallback logger.exception("Analyze request failed", extra={"query": request.query}) settings = get_settings() diff --git a/app/api/workspace.py b/app/api/workspace.py index e9b47a2..c67b238 100644 --- a/app/api/workspace.py +++ b/app/api/workspace.py @@ -4,17 +4,13 @@ import json import re -import tempfile -from dataclasses import dataclass from datetime import datetime, timezone -from io import BytesIO -from pathlib import Path from threading import Lock from typing import Any from uuid import uuid4 -import pandas as pd - +from app.data.registry import clear_source_registry, ingest_source +from app.data.semantic_model import clear_semantic_context_cache from app.schemas import AnalyzeResponse, ArtifactSummary, InspectionData, MetadataItem, ResultTableData, TraceEntry, UploadedAsset, ValidationCheck @@ -29,58 +25,22 @@ _STORE_LOCK = Lock() _INSPECTIONS: dict[str, InspectionData] = {} -_UPLOAD_DIR = Path(tempfile.gettempdir()) / "planera_uploads" - - -@dataclass -class StoredUpload: - """Backend-only metadata for uploaded files.""" - - asset: UploadedAsset - file_path: Path - - -_UPLOADS: dict[str, StoredUpload] = {} def clear_workspace_state() -> None: """Reset in-memory upload/inspection storage for tests.""" with _STORE_LOCK: - for stored in _UPLOADS.values(): - if stored.file_path.exists(): - stored.file_path.unlink(missing_ok=True) - _UPLOADS.clear() _INSPECTIONS.clear() + clear_source_registry() + clear_semantic_context_cache() def profile_upload(filename: str, content: bytes) -> UploadedAsset: - """Profile an uploaded CSV/TSV file and persist it to a temp location.""" - - safe_name = Path(filename or "upload.csv").name - frame = _read_uploaded_frame(safe_name, content) - row_count = int(len(frame)) - column_count = int(len(frame.columns)) - asset = UploadedAsset( - id=_short_id("upload"), - name=safe_name, - type=_derive_file_type(safe_name), - source="Workspace upload", - sizeLabel=_bytes_to_size(len(content)), - uploadedAt=_now_iso(), - status="verified", - rows=row_count, - columns=column_count, - summary=_build_upload_summary(frame, row_count, column_count), - ) - - _UPLOAD_DIR.mkdir(parents=True, exist_ok=True) - file_path = _UPLOAD_DIR / f"{asset.id}_{safe_name}" - file_path.write_bytes(content) - - with _STORE_LOCK: - _UPLOADS[asset.id] = StoredUpload(asset=asset, file_path=file_path) + """Persist an uploaded structured dataset to the source registry.""" + asset = ingest_source(filename, content) + clear_semantic_context_cache() return asset @@ -100,35 +60,6 @@ def get_inspection(inspection_id: str) -> InspectionData | None: return _INSPECTIONS.get(inspection_id) -def _read_uploaded_frame(filename: str, content: bytes) -> pd.DataFrame: - if not content: - raise ValueError("Uploaded file is empty.") - - suffix = Path(filename).suffix.lower() - buffer = BytesIO(content) - - try: - if suffix in {".csv"}: - return pd.read_csv(buffer) - if suffix in {".tsv", ".tab"}: - return pd.read_csv(buffer, sep="\t") - if suffix in {".txt"}: - return pd.read_csv(buffer, sep=None, engine="python") - except Exception as exc: # pragma: no cover - pandas error details vary - raise ValueError(f"Could not parse {filename} as a structured text dataset.") from exc - - raise ValueError("Only CSV, TSV, TAB, and TXT uploads are currently supported.") - - -def _build_upload_summary(frame: pd.DataFrame, row_count: int, column_count: int) -> str: - preview_columns = [str(column) for column in list(frame.columns[:4])] - column_label = ", ".join(preview_columns) - suffix = "..." if column_count > 4 else "" - if column_label: - return f"Profiled {row_count} rows across {column_count} columns. Leading columns: {column_label}{suffix}." - return f"Profiled {row_count} rows across {column_count} columns." - - def _build_inspection(inspection_id: str, prompt: str, response: AnalyzeResponse) -> InspectionData: executed_steps = response.executed_steps or [] primary_artifact = _pick_primary_artifact(response) @@ -463,20 +394,5 @@ def _short_id(prefix: str) -> str: return f"{prefix}_{uuid4().hex[:8]}" -def _derive_file_type(filename: str) -> str: - suffix = Path(filename).suffix.lstrip(".").upper() - return suffix or "FILE" - - -def _bytes_to_size(num_bytes: int) -> str: - if num_bytes < 1024: - return f"{num_bytes} B" - if num_bytes < 1024 * 1024: - return f"{num_bytes / 1024:.1f} KB" - if num_bytes < 1024 * 1024 * 1024: - return f"{num_bytes / (1024 * 1024):.1f} MB" - return f"{num_bytes / (1024 * 1024 * 1024):.1f} GB" - - def _now_iso() -> str: return datetime.now(timezone.utc).replace(microsecond=0).isoformat().replace("+00:00", "Z") diff --git a/app/config.py b/app/config.py index 7c9d9d8..4e975cd 100644 --- a/app/config.py +++ b/app/config.py @@ -20,6 +20,7 @@ class Settings(BaseSettings): api_host: str = "0.0.0.0" api_port: int = 8000 data_dir: Path = Field(default=BASE_DIR / "data") + registry_path: Path = Field(default=BASE_DIR / "data" / "source_registry.duckdb") crm_path: Path = Field(default=BASE_DIR / "data" / "crm.csv") subscriptions_path: Path = Field(default=BASE_DIR / "data" / "subscriptions.csv") crm_dataset_dir: Path = Field(default=BASE_DIR / "data" / "CRM+Sales+Opportunities") diff --git a/app/data/registry.py b/app/data/registry.py new file mode 100644 index 0000000..8800b38 --- /dev/null +++ b/app/data/registry.py @@ -0,0 +1,1205 @@ +"""Persistent DuckDB-backed source registry and source-package ingestion.""" + +from __future__ import annotations + +import json +import re +from dataclasses import dataclass, field +from datetime import datetime, timezone +from hashlib import sha256 +from io import BytesIO +from pathlib import Path +from typing import Any +from uuid import uuid4 + +import duckdb +import pandas as pd + +from app.config import get_settings +from app.data.loader import load_data +from app.schemas import SchemaColumn, SchemaConceptMapping, SchemaJoinKey, SchemaManifest, SchemaRelation, UploadedAsset + + +_SOURCES_TABLE = "__planera_registry_data_sources" +_RELATIONS_TABLE = "__planera_registry_source_relations" +_COLUMNS_TABLE = "__planera_registry_source_columns" +_LINKS_TABLE = "__planera_registry_source_links" +_SYSTEM_COLUMNS = {"record_id", "parent_record_id", "ordinal"} +_SEMANTIC_ALIAS_LEXICON: dict[str, list[str]] = { + "owner": ["agent", "rep", "representative", "sales rep", "assignee"], + "manager": ["manager", "lead", "supervisor", "team lead"], + "regional_office": ["region", "regional office", "office", "territory"], + "account_id": ["account", "customer", "client", "account identifier"], + "deal_id": ["deal", "opportunity", "opportunity identifier"], + "deal_value": ["revenue", "deal size", "amount", "value"], + "stage": ["status stage", "pipeline stage"], + "segment": ["customer segment", "market segment"], + "pipeline_velocity_days": ["pipeline velocity", "cycle time", "sales cycle length"], +} + + +@dataclass(frozen=True) +class SourceLinkPackage: + """Explicit relation link stored in the registry.""" + + left_source_id: str + left_relation_name: str + right_source_id: str + right_relation_name: str + join_keys: list[dict[str, str]] + link_type: str = "explicit" + is_explicit: bool = True + metadata: dict[str, Any] = field(default_factory=dict) + + +@dataclass(frozen=True) +class RelationPackage: + """One materialized relation plus its normalized schema metadata.""" + + relation: SchemaRelation + frame: pd.DataFrame + + +@dataclass(frozen=True) +class SourcePackage: + """Unified internal representation for uploaded or built-in sources.""" + + source_id: str + source_name: str + source_slug: str + source_kind: str + source_format: str + origin: str + file_name: str + file_type: str + size_bytes: int + raw_payload: bytes | None + relations: list[RelationPackage] + links: list[SourceLinkPackage] = field(default_factory=list) + metadata: dict[str, Any] = field(default_factory=dict) + + @property + def primary_relation_name(self) -> str: + primary = next((item.relation.name for item in self.relations if item.relation.is_primary), self.relations[0].relation.name) + return primary + + +def get_registry_path() -> Path: + """Return the on-disk DuckDB registry path.""" + + return get_settings().registry_path + + +def _connect_registry(read_only: bool = False) -> duckdb.DuckDBPyConnection: + path = get_registry_path() + path.parent.mkdir(parents=True, exist_ok=True) + conn = duckdb.connect(database=str(path), read_only=read_only) + if not read_only: + _ensure_registry_tables(conn) + return conn + + +def _ensure_registry_tables(conn: duckdb.DuckDBPyConnection) -> None: + conn.execute( + f""" + CREATE TABLE IF NOT EXISTS {_SOURCES_TABLE} ( + source_id TEXT PRIMARY KEY, + source_name TEXT, + source_slug TEXT, + source_kind TEXT, + source_format TEXT, + origin TEXT, + file_name TEXT, + file_type TEXT, + size_bytes BIGINT, + created_at TEXT, + content_hash TEXT, + primary_relation_name TEXT, + relation_count INTEGER, + row_count INTEGER, + status TEXT, + raw_payload BLOB, + metadata_json TEXT + ) + """ + ) + conn.execute( + f""" + CREATE TABLE IF NOT EXISTS {_RELATIONS_TABLE} ( + relation_name TEXT PRIMARY KEY, + source_id TEXT, + kind TEXT, + is_primary BOOLEAN, + parent_relation TEXT, + row_count BIGINT, + grain TEXT, + identifier_columns_json TEXT, + time_columns_json TEXT, + measure_columns_json TEXT, + dimension_columns_json TEXT, + lineage_json TEXT + ) + """ + ) + conn.execute( + f""" + CREATE TABLE IF NOT EXISTS {_COLUMNS_TABLE} ( + source_id TEXT, + relation_name TEXT, + ordinal INTEGER, + column_name TEXT, + dtype TEXT, + type_family TEXT, + original_name TEXT, + source_path TEXT, + nullable BOOLEAN, + semantic_hints_json TEXT + ) + """ + ) + conn.execute( + f""" + CREATE TABLE IF NOT EXISTS {_LINKS_TABLE} ( + link_id TEXT PRIMARY KEY, + left_source_id TEXT, + left_relation_name TEXT, + right_source_id TEXT, + right_relation_name TEXT, + link_type TEXT, + is_explicit BOOLEAN, + join_keys_json TEXT, + metadata_json TEXT + ) + """ + ) + + +def clear_source_registry() -> None: + """Remove the persisted registry database.""" + + path = get_registry_path() + if path.exists(): + path.unlink() + from app.data.semantic_model import clear_semantic_context_cache + + clear_semantic_context_cache() + + +def _now_iso() -> str: + return datetime.now(timezone.utc).replace(microsecond=0).isoformat().replace("+00:00", "Z") + + +def _short_id(prefix: str) -> str: + return f"{prefix}_{uuid4().hex[:8]}" + + +def _slugify(value: str) -> str: + cleaned = re.sub(r"[^a-zA-Z0-9]+", "_", value.strip().lower()).strip("_") + cleaned = re.sub(r"_+", "_", cleaned) + return cleaned[:48] or "source" + + +def _safe_identifier(value: str) -> str: + normalized = _slugify(value) + if normalized[0].isdigit(): + return f"c_{normalized}" + return normalized + + +def _derive_file_type(filename: str, source_format: str) -> str: + suffix = Path(filename).suffix.lstrip(".").upper() + if suffix: + return suffix + return source_format.upper() or "FILE" + + +def _split_identifier(value: str) -> list[str]: + cleaned = re.sub(r"([a-z0-9])([A-Z])", r"\1_\2", value) + return [token.lower() for token in re.split(r"[^a-zA-Z0-9]+", cleaned) if token] + + +def _type_family(dtype: str) -> str: + lower = dtype.lower() + if any(token in lower for token in ("int", "float", "double", "decimal")): + return "number" + if "bool" in lower: + return "boolean" + if any(token in lower for token in ("datetime", "timestamp", "date")): + return "datetime" + if any(token in lower for token in ("object", "string", "category")): + return "string" + return "unknown" + + +def _semantic_hints(column_name: str, original_name: str = "", source_path: str = "") -> list[str]: + tokens = _split_identifier(column_name) + hints = {column_name, column_name.replace("_", " ")} + if original_name: + hints.add(original_name) + hints.add(original_name.replace("_", " ")) + if source_path: + hints.add(source_path) + hints.add(source_path.replace(".", " ")) + hints.update(tokens) + if column_name.endswith("_id"): + base = column_name[: -len("_id")].replace("_", " ").strip() + if base: + hints.add(f"{base} id") + hints.add(f"{base} identifier") + + for key, aliases in _SEMANTIC_ALIAS_LEXICON.items(): + key_tokens = set(_split_identifier(key)) + if column_name == key or key_tokens.issubset(set(tokens)): + hints.update(aliases) + + return sorted(hint for hint in hints if hint) + + +def _build_semantic_mappings(columns: list[SchemaColumn]) -> list[SchemaConceptMapping]: + concept_to_columns: dict[str, set[str]] = {} + for column in columns: + for hint in column.semantic_hints: + normalized_hint = hint.strip().lower() + if not normalized_hint or normalized_hint == column.name.lower(): + continue + concept_to_columns.setdefault(normalized_hint, set()).add(column.name) + + mappings: list[SchemaConceptMapping] = [] + for concept, mapped_columns in sorted(concept_to_columns.items()): + if len(concept) < 4: + continue + mappings.append(SchemaConceptMapping(concept=concept, columns=sorted(mapped_columns))) + return mappings[:20] + + +def _is_identifier_column(column_name: str, series: pd.Series) -> bool: + lowered = column_name.lower() + if lowered == "id" or lowered.endswith("_id"): + return True + non_null = series.dropna() + return bool(len(non_null) == len(series) and len(non_null) > 0 and non_null.nunique(dropna=False) == len(series)) + + +def _infer_grain(name: str, frame: pd.DataFrame, identifier_columns: list[str]) -> str: + if identifier_columns: + primary = identifier_columns[0] + if primary.lower().endswith("_id"): + entity = primary[: -len("_id")].replace("_", " ").strip() + if entity: + return f"Approximately one row per {entity}" + return f"Rows can be keyed by {primary}" + return f"Rows represent records in {name}" + + +def _normalize_scalar(value: Any) -> Any: + if isinstance(value, (str, int, float, bool)) or value is None: + return value + if isinstance(value, (datetime, pd.Timestamp)): + return pd.Timestamp(value) + return json.dumps(value, default=str) + + +def _parse_text_bool(series: pd.Series) -> pd.Series | None: + non_null = series.dropna().astype(str).str.strip().str.lower() + if non_null.empty: + return None + if set(non_null.unique()).issubset({"true", "false"}): + mapped = series.map( + lambda item: None + if pd.isna(item) + else str(item).strip().lower() == "true" + ) + return mapped.astype("boolean") + return None + + +def _parse_text_numeric(series: pd.Series) -> pd.Series | None: + non_null = series.dropna() + if non_null.empty: + return None + parsed = pd.to_numeric(non_null, errors="coerce") + if parsed.notna().sum() != len(non_null): + return None + return pd.to_numeric(series, errors="coerce") + + +def _parse_text_datetime(column_name: str, series: pd.Series) -> pd.Series | None: + lowered_name = column_name.lower() + if not ( + any(token in lowered_name for token in ("date", "time", "timestamp")) + or lowered_name.endswith("_at") + or lowered_name == "at" + ): + return None + non_null = series.dropna() + if non_null.empty: + return None + parsed = pd.to_datetime(non_null, errors="coerce", utc=False) + if parsed.notna().sum() / len(non_null) < 0.8: + return None + return pd.to_datetime(series, errors="coerce", utc=False) + + +def _coerce_frame_types(frame: pd.DataFrame) -> pd.DataFrame: + coerced = frame.copy() + for column_name in coerced.columns: + series = coerced[column_name] + if pd.api.types.is_bool_dtype(series) or pd.api.types.is_numeric_dtype(series) or pd.api.types.is_datetime64_any_dtype(series): + continue + if not (pd.api.types.is_object_dtype(series) or pd.api.types.is_string_dtype(series)): + continue + + parsed = _parse_text_bool(series) + if parsed is None: + parsed = _parse_text_numeric(series) + if parsed is None: + parsed = _parse_text_datetime(str(column_name), series) + if parsed is not None: + coerced[column_name] = parsed + return coerced.convert_dtypes() + + +def _rename_system_columns(frame: pd.DataFrame) -> pd.DataFrame: + renamed = frame.copy() + next_names: dict[str, str] = {} + for column in renamed.columns: + safe_name = _safe_identifier(str(column)) + candidate = safe_name + if candidate in _SYSTEM_COLUMNS: + candidate = f"{candidate}_value" + counter = 2 + while candidate in next_names.values(): + candidate = f"{safe_name}_{counter}" + counter += 1 + next_names[column] = candidate + return renamed.rename(columns=next_names) + + +def _ensure_record_id(frame: pd.DataFrame) -> pd.DataFrame: + framed = frame.copy() + if "record_id" in framed.columns: + framed = framed.rename(columns={"record_id": "record_id_value"}) + framed.insert(0, "record_id", [f"record_{index + 1}" for index in range(len(framed))]) + return framed + + +def _schema_relation_for_frame( + *, + relation_name: str, + source_id: str, + source_name: str, + frame: pd.DataFrame, + kind: str, + is_primary: bool, + parent_relation: str | None, + join_keys: list[SchemaJoinKey], + lineage: dict[str, Any], + column_paths: dict[str, dict[str, str]] | None = None, +) -> SchemaRelation: + column_paths = column_paths or {} + columns: list[SchemaColumn] = [] + identifier_columns: list[str] = [] + time_columns: list[str] = [] + measure_columns: list[str] = [] + dimension_columns: list[str] = [] + + for column_name in frame.columns: + dtype = str(frame[column_name].dtype) + family = _type_family(dtype) + path_meta = column_paths.get(str(column_name), {}) + column = SchemaColumn( + name=str(column_name), + dtype=dtype, + type_family=family, + original_name=path_meta.get("original_name", str(column_name)), + source_path=path_meta.get("source_path", str(column_name)), + nullable=bool(frame[column_name].isna().any()), + semantic_hints=_semantic_hints( + str(column_name), + original_name=path_meta.get("original_name", str(column_name)), + source_path=path_meta.get("source_path", str(column_name)), + ), + ) + columns.append(column) + + if _is_identifier_column(str(column_name), frame[column_name]): + identifier_columns.append(str(column_name)) + if family == "datetime": + time_columns.append(str(column_name)) + elif family == "number": + measure_columns.append(str(column_name)) + else: + dimension_columns.append(str(column_name)) + + return SchemaRelation( + name=relation_name, + kind=kind, + source_id=source_id, + source_name=source_name, + is_primary=is_primary, + parent_relation=parent_relation, + row_count=int(len(frame)), + grain=_infer_grain(relation_name, frame, identifier_columns), + identifier_columns=identifier_columns, + time_columns=time_columns, + measure_columns=measure_columns, + dimension_columns=dimension_columns, + join_keys=join_keys, + lineage=lineage, + columns=columns, + semantic_mappings=_build_semantic_mappings(columns), + ) + + +def _source_filter_sql(source_ids: list[str] | None) -> tuple[str, list[str]]: + if not source_ids: + return "", [] + placeholders = ", ".join(["?"] * len(source_ids)) + return f" WHERE source_id IN ({placeholders})", list(source_ids) + + +def _link_filter_sql(source_ids: list[str] | None) -> tuple[str, list[str]]: + if not source_ids: + return "", [] + placeholders = ", ".join(["?"] * len(source_ids)) + return ( + f" WHERE left_source_id IN ({placeholders}) AND right_source_id IN ({placeholders})", + list(source_ids) + list(source_ids), + ) + + +def _read_uploaded_frame(filename: str, content: bytes) -> pd.DataFrame: + if not content: + raise ValueError("Uploaded file is empty.") + + suffix = Path(filename).suffix.lower() + buffer = BytesIO(content) + try: + if suffix in {".csv"}: + return pd.read_csv(buffer) + if suffix in {".tsv", ".tab"}: + return pd.read_csv(buffer, sep="\t") + if suffix in {".txt"}: + return pd.read_csv(buffer, sep=None, engine="python") + except Exception as exc: # pragma: no cover - pandas errors vary + raise ValueError(f"Could not parse {filename} as a structured text dataset.") from exc + + raise ValueError("Only CSV, TSV, TAB, TXT, and JSON uploads are currently supported.") + + +def _build_uploaded_asset(package: SourcePackage) -> UploadedAsset: + primary = next(item for item in package.relations if item.relation.is_primary) + visible_columns = [column.name for column in primary.relation.columns if column.name != "record_id"] + relation_count = len(package.relations) + summary = ( + f"Persisted {primary.relation.row_count} rows across {len(visible_columns)} columns" + f" into {relation_count} relation{'s' if relation_count != 1 else ''}. " + f"Primary relation: {package.primary_relation_name}." + ) + return UploadedAsset( + id=package.source_id, + name=package.file_name, + type=package.file_type, + source=package.origin, + sizeLabel=_bytes_to_size(package.size_bytes), + uploadedAt=_now_iso(), + status="verified", + rows=primary.relation.row_count, + columns=len(visible_columns), + relationCount=relation_count, + primaryRelationName=package.primary_relation_name, + summary=summary, + ) + + +def _bytes_to_size(num_bytes: int) -> str: + if num_bytes < 1024: + return f"{num_bytes} B" + if num_bytes < 1024 * 1024: + return f"{num_bytes / 1024:.1f} KB" + if num_bytes < 1024 * 1024 * 1024: + return f"{num_bytes / (1024 * 1024):.1f} MB" + return f"{num_bytes / (1024 * 1024 * 1024):.1f} GB" + + +def _persist_source_package(conn: duckdb.DuckDBPyConnection, package: SourcePackage) -> None: + created_at = _now_iso() + conn.execute("BEGIN TRANSACTION") + try: + for relation in package.relations: + conn.execute(f'DELETE FROM {_RELATIONS_TABLE} WHERE relation_name = ?', [relation.relation.name]) + conn.execute(f'DELETE FROM {_COLUMNS_TABLE} WHERE relation_name = ?', [relation.relation.name]) + temp_name = f"tmp_{uuid4().hex[:8]}" + conn.register(temp_name, relation.frame) + conn.execute(f'DROP TABLE IF EXISTS "{relation.relation.name}"') + conn.execute(f'CREATE TABLE "{relation.relation.name}" AS SELECT * FROM "{temp_name}"') + conn.unregister(temp_name) + conn.execute( + f""" + INSERT INTO {_RELATIONS_TABLE} ( + relation_name, source_id, kind, is_primary, parent_relation, row_count, grain, + identifier_columns_json, time_columns_json, measure_columns_json, dimension_columns_json, lineage_json + ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) + """, + [ + relation.relation.name, + package.source_id, + relation.relation.kind, + relation.relation.is_primary, + relation.relation.parent_relation, + relation.relation.row_count, + relation.relation.grain, + json.dumps(relation.relation.identifier_columns), + json.dumps(relation.relation.time_columns), + json.dumps(relation.relation.measure_columns), + json.dumps(relation.relation.dimension_columns), + json.dumps(relation.relation.lineage), + ], + ) + column_rows = [ + ( + package.source_id, + relation.relation.name, + ordinal, + column.name, + column.dtype, + column.type_family, + column.original_name, + column.source_path, + column.nullable, + json.dumps(column.semantic_hints), + ) + for ordinal, column in enumerate(relation.relation.columns, start=1) + ] + if column_rows: + conn.executemany( + f""" + INSERT INTO {_COLUMNS_TABLE} ( + source_id, relation_name, ordinal, column_name, dtype, type_family, + original_name, source_path, nullable, semantic_hints_json + ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?) + """, + column_rows, + ) + + conn.execute(f'DELETE FROM {_LINKS_TABLE} WHERE left_source_id = ? OR right_source_id = ?', [package.source_id, package.source_id]) + for link in package.links: + conn.execute( + f""" + INSERT INTO {_LINKS_TABLE} ( + link_id, left_source_id, left_relation_name, right_source_id, right_relation_name, + link_type, is_explicit, join_keys_json, metadata_json + ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?) + """, + [ + _short_id("link"), + link.left_source_id, + link.left_relation_name, + link.right_source_id, + link.right_relation_name, + link.link_type, + link.is_explicit, + json.dumps(link.join_keys), + json.dumps(link.metadata), + ], + ) + + primary = next(item for item in package.relations if item.relation.is_primary) + row_count = primary.relation.row_count + content_hash = sha256(package.raw_payload or b"").hexdigest() + conn.execute(f'DELETE FROM {_SOURCES_TABLE} WHERE source_id = ?', [package.source_id]) + conn.execute( + f""" + INSERT INTO {_SOURCES_TABLE} ( + source_id, source_name, source_slug, source_kind, source_format, origin, file_name, file_type, + size_bytes, created_at, content_hash, primary_relation_name, relation_count, row_count, status, raw_payload, metadata_json + ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) + """, + [ + package.source_id, + package.source_name, + package.source_slug, + package.source_kind, + package.source_format, + package.origin, + package.file_name, + package.file_type, + package.size_bytes, + created_at, + content_hash, + package.primary_relation_name, + len(package.relations), + row_count, + "verified", + package.raw_payload, + json.dumps(package.metadata), + ], + ) + conn.execute("COMMIT") + except Exception: + conn.execute("ROLLBACK") + raise + + +def _build_primary_relation_name(source_slug: str, source_id: str) -> str: + return f"{source_slug}_{source_id.split('_')[-1]}" + + +def _build_child_relation_name(primary_relation_name: str, path_segments: tuple[str, ...]) -> str: + suffix = "__".join(_safe_identifier(segment) for segment in path_segments) + return f"{primary_relation_name}__{suffix}" + + +def _ingest_csv_source(filename: str, content: bytes) -> SourcePackage: + safe_name = Path(filename or "upload.csv").name + frame = _ensure_record_id(_rename_system_columns(_read_uploaded_frame(safe_name, content))) + frame = _coerce_frame_types(frame) + source_id = _short_id("source") + source_slug = _slugify(Path(safe_name).stem) + relation_name = _build_primary_relation_name(source_slug, source_id) + column_paths = { + str(column): { + "original_name": str(column), + "source_path": str(column), + } + for column in frame.columns + } + relation = _schema_relation_for_frame( + relation_name=relation_name, + source_id=source_id, + source_name=safe_name, + frame=frame, + kind="table", + is_primary=True, + parent_relation=None, + join_keys=[], + lineage={"format": "csv", "json_path": "$"}, + column_paths=column_paths, + ) + return SourcePackage( + source_id=source_id, + source_name=safe_name, + source_slug=source_slug, + source_kind="upload", + source_format="csv", + origin="Workspace upload", + file_name=safe_name, + file_type=_derive_file_type(safe_name, "csv"), + size_bytes=len(content), + raw_payload=content, + relations=[RelationPackage(relation=relation, frame=frame)], + ) + + +def _ingest_json_source(filename: str, content: bytes) -> SourcePackage: + safe_name = Path(filename or "upload.json").name + try: + payload = json.loads(content.decode("utf-8")) + except Exception as exc: # pragma: no cover - json errors vary + raise ValueError(f"Could not parse {safe_name} as JSON.") from exc + + if isinstance(payload, dict): + records = [payload] + elif isinstance(payload, list) and all(isinstance(item, dict) for item in payload): + records = payload + elif isinstance(payload, list) and not payload: + records = [] + else: + raise ValueError("JSON uploads must contain a top-level object or an array of objects.") + + source_id = _short_id("source") + source_slug = _slugify(Path(safe_name).stem) + primary_relation_name = _build_primary_relation_name(source_slug, source_id) + + relation_rows: dict[tuple[str, ...], list[dict[str, Any]]] = {(): []} + relation_column_paths: dict[tuple[str, ...], dict[str, dict[str, str]]] = {(): {"record_id": {"original_name": "record_id", "source_path": "$.record_id"}}} + relation_parents: dict[tuple[str, ...], str | None] = {(): None} + relation_links: list[SourceLinkPackage] = [] + + def remember_column(path_key: tuple[str, ...], column_name: str, original_name: str, source_path: str) -> None: + relation_column_paths.setdefault(path_key, {}) + relation_column_paths[path_key][column_name] = {"original_name": original_name, "source_path": source_path} + + def walk_object( + obj: dict[str, Any], + *, + path_key: tuple[str, ...], + row: dict[str, Any], + record_id: str, + full_path: tuple[str, ...], + ) -> None: + for raw_key, value in obj.items(): + safe_key = _safe_identifier(str(raw_key)) + full_column_path = full_path + (str(raw_key),) + if safe_key in _SYSTEM_COLUMNS: + safe_key = f"{safe_key}_value" + if isinstance(value, dict): + walk_object( + value, + path_key=path_key, + row=row, + record_id=record_id, + full_path=full_column_path, + ) + continue + if isinstance(value, list): + handle_array( + value, + parent_relation_path=path_key, + parent_relation_name=primary_relation_name if not path_key else _build_child_relation_name(primary_relation_name, path_key), + parent_record_id=record_id, + array_path=path_key + (safe_key,), + full_path=full_column_path, + ) + continue + + column_name = "__".join(_safe_identifier(part) for part in full_column_path[len(path_key) :]) + if column_name in _SYSTEM_COLUMNS: + column_name = f"{column_name}_value" + row[column_name] = _normalize_scalar(value) + remember_column(path_key, column_name, str(raw_key), ".".join(full_column_path)) + + def handle_array( + values: list[Any], + *, + parent_relation_path: tuple[str, ...], + parent_relation_name: str, + parent_record_id: str, + array_path: tuple[str, ...], + full_path: tuple[str, ...], + ) -> None: + relation_rows.setdefault(array_path, []) + relation_column_paths.setdefault( + array_path, + { + "record_id": {"original_name": "record_id", "source_path": ".".join(full_path) + ".record_id"}, + "parent_record_id": {"original_name": "parent_record_id", "source_path": ".".join(full_path) + ".parent_record_id"}, + "ordinal": {"original_name": "ordinal", "source_path": ".".join(full_path) + ".ordinal"}, + }, + ) + relation_parents[array_path] = parent_relation_name + relation_name = _build_child_relation_name(primary_relation_name, array_path) + if not any(link.right_relation_name == relation_name for link in relation_links): + relation_links.append( + SourceLinkPackage( + left_source_id=source_id, + left_relation_name=parent_relation_name, + right_source_id=source_id, + right_relation_name=relation_name, + join_keys=[{"left_column": "record_id", "right_column": "parent_record_id"}], + link_type="parent_child", + is_explicit=False, + metadata={"json_path": ".".join(full_path), "parent_relation_path": ".".join(parent_relation_path)}, + ) + ) + for index, item in enumerate(values): + child_record_id = f"{parent_record_id}__{_safe_identifier(array_path[-1])}_{index + 1}" + child_row = { + "record_id": child_record_id, + "parent_record_id": parent_record_id, + "ordinal": index, + } + if isinstance(item, dict): + walk_object(item, path_key=array_path, row=child_row, record_id=child_record_id, full_path=full_path) + elif isinstance(item, list): + handle_array( + item, + parent_relation_path=array_path, + parent_relation_name=relation_name, + parent_record_id=child_record_id, + array_path=array_path + ("value",), + full_path=full_path + ("value",), + ) + else: + child_row["value"] = _normalize_scalar(item) + remember_column(array_path, "value", "value", ".".join(full_path)) + relation_rows[array_path].append(child_row) + + for index, item in enumerate(records, start=1): + if not isinstance(item, dict): + raise ValueError("JSON uploads must contain objects at the top level.") + row = {"record_id": f"record_{index}"} + walk_object(item, path_key=(), row=row, record_id=row["record_id"], full_path=()) + relation_rows[()].append(row) + + primary_frame = pd.DataFrame(relation_rows[()]) + if "record_id" not in primary_frame.columns: + primary_frame["record_id"] = pd.Series(dtype="string") + primary_frame = _coerce_frame_types(primary_frame) + relations: list[RelationPackage] = [ + RelationPackage( + relation=_schema_relation_for_frame( + relation_name=primary_relation_name, + source_id=source_id, + source_name=safe_name, + frame=primary_frame, + kind="table", + is_primary=True, + parent_relation=None, + join_keys=[], + lineage={"format": "json", "json_path": "$"}, + column_paths=relation_column_paths.get((), {}), + ), + frame=primary_frame, + ) + ] + + for relation_path in sorted(key for key in relation_rows if key): + relation_name = _build_child_relation_name(primary_relation_name, relation_path) + frame = _coerce_frame_types(pd.DataFrame(relation_rows[relation_path])) + join_keys = [ + SchemaJoinKey( + target_relation=relation_parents[relation_path] or primary_relation_name, + source_column="parent_record_id", + target_column="record_id", + link_type="parent_child", + ) + ] + relations.append( + RelationPackage( + relation=_schema_relation_for_frame( + relation_name=relation_name, + source_id=source_id, + source_name=safe_name, + frame=frame, + kind="table", + is_primary=False, + parent_relation=relation_parents[relation_path], + join_keys=join_keys, + lineage={"format": "json", "json_path": ".".join(relation_path)}, + column_paths=relation_column_paths.get(relation_path, {}), + ), + frame=frame, + ) + ) + + return SourcePackage( + source_id=source_id, + source_name=safe_name, + source_slug=source_slug, + source_kind="upload", + source_format="json", + origin="Workspace upload", + file_name=safe_name, + file_type=_derive_file_type(safe_name, "json"), + size_bytes=len(content), + raw_payload=content, + relations=relations, + links=relation_links, + ) + + +def _build_builtin_source_package() -> SourcePackage: + bundle = load_data() + source_id = "source_builtin_crm" + source_name = "CRM Sales Opportunities" + relations: list[RelationPackage] = [] + for relation_name, frame in bundle.raw_views.items(): + normalized = _coerce_frame_types(_rename_system_columns(frame)) + relation = _schema_relation_for_frame( + relation_name=relation_name, + source_id=source_id, + source_name=source_name, + frame=normalized, + kind="view", + is_primary=False, + parent_relation=None, + join_keys=[], + lineage={"format": "builtin", "json_path": "$", "reference_date": bundle.reference_date}, + column_paths={str(column): {"original_name": str(column), "source_path": str(column)} for column in normalized.columns}, + ) + relations.append(RelationPackage(relation=relation, frame=normalized)) + + semantic_frame = _coerce_frame_types(_ensure_record_id(_rename_system_columns(bundle.crm))) + semantic_relation = _schema_relation_for_frame( + relation_name="opportunities_enriched", + source_id=source_id, + source_name=source_name, + frame=semantic_frame, + kind="view", + is_primary=True, + parent_relation=None, + join_keys=[], + lineage={"format": "builtin", "json_path": "$", "reference_date": bundle.reference_date}, + column_paths={str(column): {"original_name": str(column), "source_path": str(column)} for column in semantic_frame.columns}, + ) + relations.append(RelationPackage(relation=semantic_relation, frame=semantic_frame)) + return SourcePackage( + source_id=source_id, + source_name=source_name, + source_slug="crm_sales_opportunities", + source_kind="builtin", + source_format="builtin", + origin="Planera semantic model", + file_name="crm_sales_opportunities", + file_type="BUILTIN", + size_bytes=0, + raw_payload=None, + relations=relations, + metadata={"reference_date": bundle.reference_date, "source": bundle.source}, + ) + + +def ensure_builtin_sources() -> None: + """Seed the registry with the built-in CRM source once.""" + + conn = _connect_registry(read_only=False) + try: + row = conn.execute(f"SELECT COUNT(*) FROM {_SOURCES_TABLE} WHERE source_kind = 'builtin'").fetchone() + if row and int(row[0]) > 0: + return + _persist_source_package(conn, _build_builtin_source_package()) + finally: + conn.close() + + +def ingest_source(filename: str, content: bytes) -> UploadedAsset: + """Persist a CSV/JSON upload into the registry and return its UI summary.""" + + safe_name = Path(filename or "upload.csv").name + suffix = Path(safe_name).suffix.lower() + if suffix == ".json": + package = _ingest_json_source(safe_name, content) + else: + package = _ingest_csv_source(safe_name, content) + conn = _connect_registry(read_only=False) + try: + _persist_source_package(conn, package) + finally: + conn.close() + from app.data.semantic_model import clear_semantic_context_cache + + clear_semantic_context_cache() + return _build_uploaded_asset(package) + + +def create_source_link( + left_relation_name: str, + left_column: str, + right_relation_name: str, + right_column: str, +) -> None: + """Create an explicit registry join path between two existing relations.""" + + ensure_builtin_sources() + conn = _connect_registry(read_only=False) + try: + rows = conn.execute( + f""" + SELECT relation_name, source_id + FROM {_RELATIONS_TABLE} + WHERE relation_name IN (?, ?) + """, + [left_relation_name, right_relation_name], + ).fetchall() + relation_to_source = {row[0]: row[1] for row in rows} + if left_relation_name not in relation_to_source or right_relation_name not in relation_to_source: + raise ValueError("Both relations must exist before creating an explicit source link.") + conn.execute( + f""" + INSERT INTO {_LINKS_TABLE} ( + link_id, left_source_id, left_relation_name, right_source_id, right_relation_name, + link_type, is_explicit, join_keys_json, metadata_json + ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?) + """, + [ + _short_id("link"), + relation_to_source[left_relation_name], + left_relation_name, + relation_to_source[right_relation_name], + right_relation_name, + "explicit", + True, + json.dumps([{"left_column": left_column, "right_column": right_column}]), + json.dumps({}), + ], + ) + finally: + conn.close() + from app.data.semantic_model import clear_semantic_context_cache + + clear_semantic_context_cache() + + +def _load_link_map(conn: duckdb.DuckDBPyConnection, source_ids: list[str] | None = None) -> dict[str, list[SchemaJoinKey]]: + filter_sql, params = _link_filter_sql(source_ids) + rows = conn.execute( + f""" + SELECT left_source_id, left_relation_name, right_source_id, right_relation_name, link_type, join_keys_json + FROM {_LINKS_TABLE} + {filter_sql} + """, + params, + ).fetchall() + link_map: dict[str, list[SchemaJoinKey]] = {} + for row in rows: + _, left_relation_name, _, right_relation_name, link_type, join_keys_json = row + join_rows = json.loads(join_keys_json or "[]") + for join_row in join_rows: + left_key = SchemaJoinKey( + target_relation=right_relation_name, + source_column=join_row["left_column"], + target_column=join_row["right_column"], + link_type="parent_child" if link_type == "parent_child" else "explicit", + ) + right_key = SchemaJoinKey( + target_relation=left_relation_name, + source_column=join_row["right_column"], + target_column=join_row["left_column"], + link_type="parent_child" if link_type == "parent_child" else "explicit", + ) + link_map.setdefault(left_relation_name, []).append(left_key) + link_map.setdefault(right_relation_name, []).append(right_key) + return link_map + + +def get_schema_manifest(source_ids: list[str] | None = None) -> dict[str, Any]: + """Return the normalized schema manifest for the requested scope.""" + + ensure_builtin_sources() + conn = _connect_registry(read_only=True) + try: + filter_sql, params = _source_filter_sql(source_ids) + relation_rows = conn.execute( + f""" + SELECT relation_name, source_id, kind, is_primary, parent_relation, row_count, grain, + identifier_columns_json, time_columns_json, measure_columns_json, dimension_columns_json, lineage_json + FROM {_RELATIONS_TABLE} + {filter_sql} + ORDER BY source_id, is_primary DESC, relation_name + """, + params, + ).fetchall() + source_names = { + row[0]: row[1] + for row in conn.execute( + f"SELECT source_id, source_name FROM {_SOURCES_TABLE}{filter_sql}", + params, + ).fetchall() + } + link_map = _load_link_map(conn, source_ids) + relations: list[SchemaRelation] = [] + for row in relation_rows: + relation_name, source_id, kind, is_primary, parent_relation, row_count, grain, identifier_columns_json, time_columns_json, measure_columns_json, dimension_columns_json, lineage_json = row + column_rows = conn.execute( + f""" + SELECT column_name, dtype, type_family, original_name, source_path, nullable, semantic_hints_json + FROM {_COLUMNS_TABLE} + WHERE relation_name = ? + ORDER BY ordinal + """, + [relation_name], + ).fetchall() + columns = [ + SchemaColumn( + name=column_name, + dtype=dtype, + type_family=type_family, + original_name=original_name or column_name, + source_path=source_path or column_name, + nullable=bool(nullable), + semantic_hints=json.loads(semantic_hints_json or "[]"), + ) + for column_name, dtype, type_family, original_name, source_path, nullable, semantic_hints_json in column_rows + ] + relation = SchemaRelation( + name=relation_name, + kind=kind, + source_id=source_id, + source_name=source_names.get(source_id, source_id), + is_primary=bool(is_primary), + parent_relation=parent_relation, + row_count=int(row_count), + grain=grain or "", + identifier_columns=json.loads(identifier_columns_json or "[]"), + time_columns=json.loads(time_columns_json or "[]"), + measure_columns=json.loads(measure_columns_json or "[]"), + dimension_columns=json.loads(dimension_columns_json or "[]"), + join_keys=link_map.get(relation_name, []), + lineage=json.loads(lineage_json or "{}"), + columns=columns, + semantic_mappings=_build_semantic_mappings(columns), + ) + relations.append(relation) + + bundle = load_data() + reference_date = bundle.reference_date + manifest = SchemaManifest( + reference_date=reference_date, + source="source_registry", + dialect="duckdb", + relations=relations, + views=[ + { + "name": relation.name, + "source_id": relation.source_id, + "source_name": relation.source_name, + "row_count": relation.row_count, + "is_primary": relation.is_primary, + "columns": [{"name": column.name, "dtype": column.dtype} for column in relation.columns], + } + for relation in relations + ], + ) + return manifest.model_dump() + finally: + conn.close() + + +def load_relation_frames(source_ids: list[str] | None = None) -> dict[str, pd.DataFrame]: + """Load materialized relation tables for the requested scope.""" + + ensure_builtin_sources() + conn = _connect_registry(read_only=True) + try: + filter_sql, params = _source_filter_sql(source_ids) + names = [ + row[0] + for row in conn.execute( + f"SELECT relation_name FROM {_RELATIONS_TABLE}{filter_sql} ORDER BY relation_name", + params, + ).fetchall() + ] + return {name: conn.execute(f'SELECT * FROM "{name}"').fetchdf() for name in names} + finally: + conn.close() + + +def get_registered_relation_names(source_ids: list[str] | None = None) -> list[str]: + """Return visible relation names for the requested scope.""" + + ensure_builtin_sources() + conn = _connect_registry(read_only=True) + try: + filter_sql, params = _source_filter_sql(source_ids) + return [ + row[0] + for row in conn.execute( + f"SELECT relation_name FROM {_RELATIONS_TABLE}{filter_sql} ORDER BY relation_name", + params, + ).fetchall() + ] + finally: + conn.close() + + +def get_upload_source_ids(source_ids: list[str] | None = None) -> list[str]: + """Return matching uploaded source ids for the provided ids.""" + + if not source_ids: + return [] + conn = _connect_registry(read_only=False) + try: + placeholders = ", ".join(["?"] * len(source_ids)) + rows = conn.execute( + f""" + SELECT source_id + FROM {_SOURCES_TABLE} + WHERE source_kind = 'upload' AND source_id IN ({placeholders}) + ORDER BY source_id + """, + list(dict.fromkeys(source_ids)), + ).fetchall() + return [row[0] for row in rows] + finally: + conn.close() diff --git a/app/data/semantic_model.py b/app/data/semantic_model.py index 3cdcef6..64f07f9 100644 --- a/app/data/semantic_model.py +++ b/app/data/semantic_model.py @@ -1,8 +1,7 @@ -"""Dataset views and schema manifest for planner and executor.""" +"""Registry-backed dataset views and schema manifest for planner and executor.""" from __future__ import annotations -import re from dataclasses import dataclass from functools import lru_cache from typing import Any @@ -10,8 +9,7 @@ import duckdb import pandas as pd -from app.data.loader import load_data -from app.schemas import SchemaColumn, SchemaConceptMapping, SchemaManifest, SchemaRelation +from app.data.registry import ensure_builtin_sources, get_registered_relation_names, get_registry_path, get_schema_manifest, load_relation_frames @dataclass(frozen=True) @@ -25,175 +23,65 @@ class SemanticContext: schema_manifest: dict[str, Any] -_SEMANTIC_ALIAS_LEXICON: dict[str, list[str]] = { - "owner": ["agent", "rep", "representative", "sales rep", "assignee"], - "manager": ["manager", "lead", "supervisor", "team lead"], - "regional_office": ["region", "regional office", "office", "territory"], - "account_id": ["account", "customer", "client", "account identifier"], - "deal_id": ["deal", "opportunity", "opportunity identifier"], - "deal_value": ["revenue", "deal size", "amount", "value"], - "stage": ["status stage", "pipeline stage"], - "segment": ["customer segment", "market segment"], - "pipeline_velocity_days": ["pipeline velocity", "cycle time", "sales cycle length"], -} - - -def _split_identifier(value: str) -> list[str]: - cleaned = re.sub(r"([a-z0-9])([A-Z])", r"\1_\2", value) - tokens = [token.lower() for token in re.split(r"[^a-zA-Z0-9]+", cleaned) if token] - return tokens - - -def _type_family(dtype: str) -> str: - lower = dtype.lower() - if any(token in lower for token in ("int", "float", "double", "decimal")): - return "number" - if "bool" in lower: - return "boolean" - if any(token in lower for token in ("datetime", "timestamp", "date")): - return "datetime" - if any(token in lower for token in ("object", "string", "category")): - return "string" - return "unknown" - - -def _semantic_hints(column_name: str) -> list[str]: - tokens = _split_identifier(column_name) - hints = {column_name, column_name.replace("_", " ")} - hints.update(tokens) - if column_name.endswith("_id"): - base = column_name[: -len("_id")].replace("_", " ").strip() - if base: - hints.add(f"{base} id") - hints.add(f"{base} identifier") - - for key, aliases in _SEMANTIC_ALIAS_LEXICON.items(): - key_tokens = set(_split_identifier(key)) - if column_name == key or key_tokens.issubset(set(tokens)): - hints.update(aliases) - - return sorted(hint for hint in hints if hint) - - -def _is_identifier_column(column_name: str, series: pd.Series) -> bool: - lowered = column_name.lower() - if lowered == "id" or lowered.endswith("_id"): - return True - non_null = series.dropna() - return bool(len(non_null) == len(series) and len(non_null) > 0 and non_null.nunique(dropna=False) == len(series)) - - -def _infer_grain(name: str, frame: pd.DataFrame, identifier_columns: list[str]) -> str: - if identifier_columns: - primary = identifier_columns[0] - if primary.lower().endswith("_id"): - entity = primary[: -len("_id")].replace("_", " ").strip() - if entity: - return f"Approximately one row per {entity}" - return f"Rows can be keyed by {primary}" - return f"Rows represent records in {name}" - - -def _build_semantic_mappings(columns: list[SchemaColumn]) -> list[SchemaConceptMapping]: - concept_to_columns: dict[str, set[str]] = {} - for column in columns: - for hint in column.semantic_hints: - normalized_hint = hint.strip().lower() - if not normalized_hint or normalized_hint == column.name.lower(): - continue - concept_to_columns.setdefault(normalized_hint, set()).add(column.name) - - mappings: list[SchemaConceptMapping] = [] - for concept, mapped_columns in sorted(concept_to_columns.items()): - if len(concept) < 4: - continue - mappings.append( - SchemaConceptMapping( - concept=concept, - columns=sorted(mapped_columns), - ) - ) - return mappings[:20] - - -def _relation_for_frame(name: str, frame: pd.DataFrame, kind: str = "view") -> SchemaRelation: - columns: list[SchemaColumn] = [] - identifier_columns: list[str] = [] - time_columns: list[str] = [] - measure_columns: list[str] = [] - dimension_columns: list[str] = [] - - for column_name in frame.columns: - dtype = str(frame[column_name].dtype) - family = _type_family(dtype) - column = SchemaColumn( - name=column_name, - dtype=dtype, - type_family=family, - semantic_hints=_semantic_hints(column_name), - ) - columns.append(column) - - if _is_identifier_column(column_name, frame[column_name]): - identifier_columns.append(column_name) - if family == "datetime": - time_columns.append(column_name) - elif family == "number": - measure_columns.append(column_name) - else: - dimension_columns.append(column_name) - - return SchemaRelation( - name=name, - kind=kind, - row_count=int(len(frame)), - grain=_infer_grain(name, frame, identifier_columns), - identifier_columns=identifier_columns, - time_columns=time_columns, - measure_columns=measure_columns, - dimension_columns=dimension_columns, - columns=columns, - semantic_mappings=_build_semantic_mappings(columns), - ) - +def _source_ids_key(source_ids: list[str] | tuple[str, ...] | None) -> tuple[str, ...]: + if not source_ids: + return () + return tuple(sorted(source_ids)) -@lru_cache(maxsize=1) -def get_semantic_context() -> SemanticContext: - """Build and cache views plus a schema-only manifest for planning.""" - bundle = load_data() - raw_views = {name: frame.copy() for name, frame in bundle.raw_views.items()} - semantic_views = {"opportunities_enriched": bundle.crm.copy()} - all_frames = {**raw_views, **semantic_views} - relations = [_relation_for_frame(name, frame, kind="view") for name, frame in all_frames.items()] - schema_manifest = SchemaManifest( - reference_date=bundle.reference_date, - source=bundle.source, - dialect="duckdb", - relations=relations, - views=[ - { - "name": relation.name, - "row_count": relation.row_count, - "columns": [{"name": column.name, "dtype": column.dtype} for column in relation.columns], - } - for relation in relations - ], - ).model_dump() +@lru_cache(maxsize=32) +def _get_semantic_context_cached(source_ids_key: tuple[str, ...]) -> SemanticContext: + ensure_builtin_sources() + source_ids = list(source_ids_key) if source_ids_key else None + manifest = get_schema_manifest(source_ids) + frames = load_relation_frames(source_ids) + primary_names = {relation["name"] for relation in manifest.get("relations", []) if relation.get("is_primary")} + raw_views = {name: frame for name, frame in frames.items() if name not in primary_names} + semantic_views = {name: frame for name, frame in frames.items() if name in primary_names} return SemanticContext( - reference_date=bundle.reference_date, - source=bundle.source, + reference_date=manifest.get("reference_date", ""), + source=manifest.get("source", ""), raw_views=raw_views, semantic_views=semantic_views, - schema_manifest=schema_manifest, + schema_manifest=manifest, ) -def new_duckdb_connection() -> duckdb.DuckDBPyConnection: - """Create an in-memory DuckDB connection with curated views registered.""" +def get_semantic_context(source_ids: list[str] | tuple[str, ...] | None = None) -> SemanticContext: + """Build and cache views plus a schema-only manifest for planning.""" + + return _get_semantic_context_cached(_source_ids_key(source_ids)) + + +def clear_semantic_context_cache() -> None: + """Clear cached registry-backed semantic contexts.""" + + _get_semantic_context_cached.cache_clear() + + +def new_duckdb_connection(dataset_context: dict[str, Any] | None = None) -> duckdb.DuckDBPyConnection: + """Create an in-memory DuckDB connection exposing only the requested relations.""" + + ensure_builtin_sources() + relation_names = [ + relation["name"] + for relation in (dataset_context or {}).get("relations", []) + if relation.get("name") + ] + if not relation_names: + relation_names = [ + view["name"] + for view in (dataset_context or {}).get("views", []) + if view.get("name") + ] + if not relation_names: + relation_names = get_registered_relation_names() - context = get_semantic_context() conn = duckdb.connect(database=":memory:") - for name, frame in {**context.raw_views, **context.semantic_views}.items(): - conn.register(name, frame) + registry_path = str(get_registry_path()).replace("'", "''") + conn.execute(f"ATTACH '{registry_path}' AS registry_db") + + for relation_name in relation_names: + escaped = relation_name.replace('"', '""') + conn.execute(f'CREATE VIEW "{escaped}" AS SELECT * FROM registry_db."{escaped}"') return conn diff --git a/app/prompts/planner_compiled.j2 b/app/prompts/planner_compiled.j2 index d57d691..74c9587 100644 --- a/app/prompts/planner_compiled.j2 +++ b/app/prompts/planner_compiled.j2 @@ -10,6 +10,9 @@ Rules: - Use only these registered relation names: {{ relation_names_json }} - Use exact column names only. Never invent, normalize, paraphrase, or rename a column. - Use semantic mappings only to translate user language into exact schema fields. +- Prefer relations where "is_primary" is true before reaching for child relations. +- Only join relations when the schema subset exposes an explicit path in "join_keys". +- For nested JSON child relations, use the exact join columns from "join_keys" instead of guessing parent-child keys. - Do not assume the question premise is true. First verify the main metric or comparison before planning causal or grouped breakdowns. - Prefer SQL over multiple trivial splits; combine logic when one query suffices. - No imports, file I/O, network calls, or plotting. diff --git a/app/prompts/planner_repair.j2 b/app/prompts/planner_repair.j2 index 8e697d2..ada2780 100644 --- a/app/prompts/planner_repair.j2 +++ b/app/prompts/planner_repair.j2 @@ -8,6 +8,8 @@ Rules: - updated_step must use "type": "sql", the same id as the failed step ({{ failed_step_id }}), and a fixed "query". - Use only exact relation and column names from the schema manifest. - Use semantic mappings only to translate user language into exact schema fields. +- Prefer relations where "is_primary" is true before using child relations. +- Only join relations when the schema manifest exposes the join path in "join_keys". - Do not invent fields or rename columns. Original plan: diff --git a/app/schemas.py b/app/schemas.py index 61c27e5..ba30286 100644 --- a/app/schemas.py +++ b/app/schemas.py @@ -12,6 +12,7 @@ class AnalyzeRequest(BaseModel): """Incoming analysis request.""" query: str = Field(..., min_length=3, examples=["Why did pipeline velocity drop this week?"]) + source_ids: list[str] = Field(default_factory=list) class TraceEvent(BaseModel): @@ -99,9 +100,23 @@ class SchemaColumn(BaseModel): name: str = Field(..., min_length=1) dtype: str = Field(..., min_length=1) type_family: Literal["string", "number", "boolean", "datetime", "unknown"] = "unknown" + original_name: str = "" + source_path: str = "" + nullable: bool = True semantic_hints: list[str] = Field(default_factory=list) +class SchemaJoinKey(BaseModel): + """One explicit relation-level join path available to the planner.""" + + model_config = ConfigDict(extra="forbid") + + target_relation: str = Field(..., min_length=1) + source_column: str = Field(..., min_length=1) + target_column: str = Field(..., min_length=1) + link_type: Literal["parent_child", "explicit"] = "explicit" + + class SchemaRelation(BaseModel): """One normalized table or view available to the planner.""" @@ -109,12 +124,18 @@ class SchemaRelation(BaseModel): name: str = Field(..., min_length=1) kind: Literal["table", "view"] = "view" + source_id: str = "" + source_name: str = "" + is_primary: bool = False + parent_relation: str | None = None row_count: int = 0 grain: str = "" identifier_columns: list[str] = Field(default_factory=list) time_columns: list[str] = Field(default_factory=list) measure_columns: list[str] = Field(default_factory=list) dimension_columns: list[str] = Field(default_factory=list) + join_keys: list[SchemaJoinKey] = Field(default_factory=list) + lineage: dict[str, Any] = Field(default_factory=dict) columns: list[SchemaColumn] = Field(default_factory=list) semantic_mappings: list[SchemaConceptMapping] = Field(default_factory=list) @@ -266,6 +287,7 @@ class ChatSubmitRequest(BaseModel): conversation_id: int | str | None = None query: str = Field(..., min_length=3) + source_ids: list[str] = Field(default_factory=list) @field_validator("conversation_id", mode="before") @classmethod @@ -334,6 +356,8 @@ class UploadedAsset(BaseModel): status: Literal["uploaded", "profiling", "verified", "error"] rows: int | None = None columns: int | None = None + relationCount: int | None = None + primaryRelationName: str | None = None summary: str | None = None diff --git a/app/services/analysis_run.py b/app/services/analysis_run.py index e779925..8a55000 100644 --- a/app/services/analysis_run.py +++ b/app/services/analysis_run.py @@ -25,10 +25,10 @@ class StoredAnalysisRun: inspection: InspectionData -def run_stored_analysis(query: str) -> StoredAnalysisRun: +def run_stored_analysis(query: str, source_ids: list[str] | None = None) -> StoredAnalysisRun: """Run `run_analysis`, persist inspection to process memory, return API + inspection objects.""" - state = run_analysis(query) + state = run_analysis(query, source_ids=source_ids) base = AnalyzeResponse( analysis=state["analysis"], trace=state.get("trace", []), diff --git a/data/source_registry.duckdb b/data/source_registry.duckdb new file mode 100644 index 0000000000000000000000000000000000000000..f9fc5723d2cfadfad57d7caf579bc30ac55b40e9 GIT binary patch literal 13381632 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 AsdWohC7~f&qqbow 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� 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 z8#*j&=&=3+X81LIlA`?#4k*Yh%*yINbja+&eue$Ah6ZLA%+4wtGIZ#m*#$%UXZ0T( z2xj#QW(~?3S}=4#R$(A(=)j>v`xOixGO&NakbwiW3HNx;9@qb*G%HwESyEUWEV4@( z6Q^j?WIt~TR+h{zIXlOgR+@G;jMl(qiuUuC)XL!OU}dmOC$lI}9ZVhOOYNW8Z*bp! z{re8+m)ggd8adN;`hQ}Ty6EhN`9uH#1Q0*~0R#|0009ILKmY**5I_I{1Q0*~0R#|0 z009ILKmY**5I_I{1Q0*~0R#|0009ILKmY**5I_I{1Q0*~0R#|0009ILKmY**5I_I{ z1Q0*~0R#|0009ILKmY**5I_I{1Q0*~0R#|0009ILKmY**5I_I{1Q0*~0R#|0009IL zKmY**5I_I{1Q0*~0R#|0009ILKmY**5I_I{1Q0*~0R#|0009ILKmY**5I_I{1Q0*~ z0R#|0009ILKmY**5I_I{1Q0*~0R#|0009ILKmY**5I_I{1Q0*~0R#|0009ILKmY** z5I_I{1Q0*~0R#|0009ILKmY**5I_I{1Q0*~0R#|0009ILKmY**5I_I{1Q0*~0R#|0 z009ILKmY**5I_I{1Q0*~0R#|0009ILKmY**5I_I{1Q0*~0R#|0009ILKmY**5I_I{ z1Q0*~0R#|0009ILKmY**5I_I{1Q0*~0R#|0009ILKmY**5I_I{1Q0*~0R#|0009IL zKmY**5I_I{1Q0*~0R#|0009ILKmY**5I_I{1Q0*~0R#|0009ILKmY**5I_I{1Q0*~ z0R#|0009ILKmY**5I_I{1Q0*~0R#|0009ILKmY**5I_I{1Q0*~0R#|0009ILKmY** z5I_I{1Q0*~0R#|0009ILKmY**5I_I{1Q0*~0R#|0009ILKmY**5I_I{1Q0*~0R#|0 z009ILKmY**5I_I{1Q0*~0R#|0009ILKmY**5I_I{1Q0*~0R#|0009ILKmY**5I_I{ z1Q0*~0R#|0009ILKmY**5I_I{1Q0*~0R#|0009ILKmY**5I_I{1Q0*~0R#|0009IL zKmY**5I_I{1Q0*~0R#|0009ILKmY**5I_I{1Q0*~0R#|0009ILKmY**5I_I{1Q0*~ z0R#|0009ILKmY**5I_I{1Q0*~0R#|0009ILKmY**5I_I{1Q0*~0R#|0009ILKmY** z5I_I{1Q0*~0R#|0009ILKmY**5I_I{1Q0*~0R#|0009ILKmY**5I_I{1Q0*~0R#|0 z009ILKmY**5I_I{1Q0*~0R#|0009ILKmY**5I_I{1Q0*~0R#|0009ILKmY**5I_I{ z1Q0*~0R#|0009ILKmY**5I_I{1Q0*~0R#|0009ILKmY**5I_I{1Q0*~0R#|0009IL zKmY**5I_I{1Q0*~0R#|0009ILKmY**5I_I{1Q0*~0R#|0009ILKmY**5I_I{1Q0*~ z0R#|0009ILKmY**5I_I{1Q0*~0R#|0009ILKmY**5I_I{1Q0*~0R#|0009ILKmY** z5I_I{1Q0*~0R#|0009ILKmY**5I_I{1Q0*~0R#|0009ILKmY**5I_I{1Q0*~0R#|0 z009ILKmY**5I_I{1Q0*~0R#|0009ILKmY**5I_I{1Q0*~0R#|0009ILKmY**5I_I{ z1Q0*~0R#|0009ILKmY**5I_I{1Q0*~0R#|0009ILKmY**5I_I{1Q0*~0R#|0009IL zKmY**5I_I{1Q0*~0R#|0009ILKmY**5I_I{1Q0*~0R#|0009ILKmY**5I_I{1Q0*~ z0R#|0009ILKmY**5I_I{1Q0*~0R#|0009ILKmY**5I_I{1Q7VYN?>JL!j9=*G#pOU zQTr6*6zy(GC~(FYKoe6QkHcG5XAKPOvPyD4-Dn0tg_0 z00IagfB*srAbeYRJ$pFhvnaExN|na{ZurR9MljVMGb+I`ti zyOl(Jc2%^WSC&`aP*o8q4Ep}H#{b*?f4RL;mtSGpX*)he``JIU|De8^S$#7HPU|;x zSk};C{RhnOYx*Qb`&n2pBrv;R$n3zNKvBPe1%>?!3I_y&!6E&NiiQr#%E}yAG-yCk zVQ@$=t8i%M?5v{T?1I7}Lk9LM3JeSc`wt3g6Yeo~KlAzX@&AG_PV;P9?B`9v%97b7 zL06)O#xGE`pJ&&bRZ`TaEHEb+U)Zltc2OX{uz#PNU|GDDFeXYd;mqePi|iBv0tg_0 z00IagfB*srAb1N-Bb-C1pWv!I)&l z{)!zHqZB=gJrr%Q^Qy|{Ru%?l70fLutu85>RaiO4on_kTBU90<7^m1uF;US@zo{fR z@83sFcDHRmyV^hhNytx)%=p!r`LSm{)6RUJo&TW5Ur_9+n5{Tdagm~(o?W2>pId1cYm@_ALh!a$j?An3axxFA^MD_G!**aWT%mR0|U z^UqlRhx5+({^$Gs*O^+N^x06W*q~^Q2P$5wc&(zHesyXjowG`cQv3K)i-LjDGlOS# zWXEP+o%)L;+tD*Aw5yys(aI1(JLk-5c1~sRreN9JpdAd(sVFU95DZq?MShV&ck5Rw z9aW0m6m5P;QMBj4PQN;}ureszqFF`y>+Y{waLR$z!OCAuEi5gs3PzThd3EGpYOw4& zyXe^!f4PXZY|KW*kYXFf;ffO!Cn?(LS4Svr3Y7l)1JKc&&DFDR3YL}^mQ*j$J{DBj z#JPTvokk{9xvBkmicQ(S7h4bvRL%-&!Gh9~DqU3n6QBB`2rmoA{+DvnlqZ&h5Q z7*e#;|Ci3I5?ns7ELiEX2CthV)SrdV3{=l`kE^0IP&P}KzPsq0K$#B69jpvqS5jW4 zJX1b2^wGaJDjknaWBxZ)Tzf{B(Om*0 z)C}N&jmXSst~hp>k+|+~S!691il0tR*XdTF?y7cmw_u`&XBw~*ZNLFJv7@k#(I)nT zye1ntF$uPVk^NvY64+4;Ys+?G4>1AOu%NXcY}qE;`#-17+g+#XoT~a&)!Til>syaB zUH#VE@8$Ep=kl+5&nW~DKmY**5I_I{1Q0*~0R#|0009ILKmY**5I_I{1Q0*~0R#|0 z009ILKmY**5I_I{1Q0*~0R#|0009ILKmY**5I_I{1Q0*~0R#|0009ILKmY**5I_I{ z1Q0*~0R#|0009ILKmY**5I_I{1Q0*~0R#|0009ILKmY**5I_I{1Q0*~0R#|0009IL zKmY**5I_I{1Q0*~0R#|0009ILKmY**5I_I{1Q0*~0R#|0009ILKmY**5I_I{1Q0*~ z0R#|0009ILKmY**5I_I{1Q0*~0R#|0009ILKmY**5I_I{1Q0*~0R#|0009ILKmY** z5I_I{1Q0*~0R#|0009ILKmY**5I_I{1Q0*~0R#|0009ILKmY**5I_I{1Q0*~0R#|0 z009ILKmY**5I_I{1Q0*~0R#|0009ILKmY**5I_I{1Q0*~0R#|0009ILKmY**5I_I{ z1Q0*~0R#|0009ILKmY**5I_I{1Q0*~0R#|0009ILKmY**5I_I{1Q0*~0R#|0009IL zKmY**5I_I{1Q0*~0R#|0009ILKmY**5I_I{1Q0*~0R#|0009ILKmY**5I_I{1Q0*~ z0R#|0009ILKmY**5I_I{1Q0*~0R#|0009ILKmY**5I_I{1Q0*~0R#|0009ILKmY** z5I_I{1Q0*~0R#|0009ILKmY**5I_I{1Q0*~0R#|0009ILKmY**5I_I{1Q0*~0R#|0 z009ILKmY**5I_I{1Q0*~0R#|0009ILKmY**5I_I{1Q0*~0R#|0009ILKmY**5I_I{ z1Q0*~0R#|0009ILKmY**5I_I{1Q0*~0R#|0009ILKmY**5I_I{1Q0*~0R#|0009IL zKmY**5I_I{1Q0*~0R#|0009ILKmY**5I_I{1Q0*~0R#|0009ILKmY**5I_I{1Q0*~ z0R#|0009ILKmY**5I_I{1Q0*~0R#|0009ILKmY**5I_I{1Q0*~0R#|0009ILKmY** z5I_I{1Q0*~0R#|0009ILKmY**5I_I{1Q0*~0R#|0009ILKmY**5I_I{1Q0*~0R#|0 z009ILKmY**5I_I{1Q0*~0R#|0009ILKmY**5I_I{1Q0*~0R#|0009ILKmY**5I_I{ z1Q0*~0R#|0009ILKmY**5I_I{1Q0*~0R#|0009ILKmY**5I_I{1Q0*~0R#|0009IL zKmY**5I_I{1Q0*~0R#|0009ILKmY**5I_I{1Q0*~0R#|0009ILKmY**5I_I{1Q0*~ z0R#|0009ILKmY**5I_I{1Q0*~0R#|0009ILKmY**5I_I{1Q0*~0R#|0009ILKmY** z5I_I{1Q0*~0R#|0009ILKmY**5I_I{1coQ@%ay-;`{~!bf8z2+krN$C-qYc=te19W zC3Z;joqtD%y0c!|nU&ZfO>KWd-l4?wOKSOQezm`Q)6MJpo7x^VzdAqF{;K7x`PKgV z_E&w>_NYF)yUwt52G#S=XEYdQGN-Y~dy=WO(J zA`BkB>Gk)VJ)4@H>c%yh`s?n$s2hvA@fNLowLNNnb!VmSe8}HK zrOqGKQ!QW3ua1|RUu};%Ui&&v-?mrP{khs6)yMaIP}`$!U;EpHJ140AYJ1f2QvKEZ zdHqd-(A?Nq9XEA5Q~Tk&J?eIRMm#B2PeRp`Xx}I4Y7pbQJ$HEaSI0}u-xOq6ps*ff zoSs<-r|ziLEyyUB7S5HH!oUR?H}@W7hV-tNB%bwR|7i3)1dyt_Hvf7EF<@Y`5)c*SRS9gkP`^i6A0>0RGOrH3kN$G-%{k;bl<2IS;Z)X8@Yi%*b0%(X zvg)tS2Q|Oi9`$rZEnoFl^Q&uD)b^|XYJ1fF`p&QVZE>Z8towS0AdJ0!N; zV$}Ai{Z;d;{_1>Cw_i2C+Fvz)?m!Od1+_hDezlpZzwi0ny*)|XukQF&n3nwA+tu<1 z1^ZRKFhjixok(NY1Fr6QeQ%j+dsGi~3-i5aRQs#8U(K(!$M=z5^;h$&J9yPc^;g@Y z_SbiQ)koca)%U-e$_{vZ@%-ZH=R^{e79en|7w1K%9o_$;I8CR6bmsbGDz)YIRXXj&)r+>Kqn9ph-z{;-#)zV~Sv zr_mjorEVkYoKgF$w#Rq*>N$qm9yR}{`>38p>#w@c_uXIBN6nviH~zexO7G<-XPZd{ zzFmFq7e{?N_T7GU9;xG{wqKoZ>Typ!*HhcCmap!I)b^<5tNGRO>U}@d*psRG)%K{K z>h_}MSI@Q8Z}(8YeM3E$SKFiJSACk+Nj1e5lXlhjax}s0vhR1*s_|5ND)|b&_;ysi zU5wF~qWp_Me*)^ktG` zA*@f`8N4qJ6q4tC52yB127Y9+AsS8HoCQCjq07#vut zt<-12>3TR5AE0It*y-k!F^GAfYx%tY{ePKDuab@#g?yZLpgw>TWdf~?A7xskYL0Xy)PaHdZs(iE*A?+*&`|9CLtzMq4#GOqsUFQBM>&0Ew(n8G8^e3%t zJrD-}#*}7*9sRa-=5XoI?MH6kgtlH22LE!m-quRh=7Y_p^V6ro!!svuKVI(M)}2fD zue6MEIoNIEGjo5-wQ@5Wwb@3OAlt+WvB5?WlNUBGf_c_rRhJ51o`g~5jo$bGq? zwzycUFRxT9%N6TTSgluPY-bX6$aZoaHn_dzur#05oBhe2EbF!1wRcs+_I=sjrEqS+ zre@Yev)hcfC0{;M4@=8odAe->Mz7knbsKxkYm93yw655DNO^ho&qTK}&;I-UanBwo z%{O+PseNkpP#DzWe5pEZgc+S%C{?XJ?JpdNjtjM_DK>VxZQab<^$)WDzG1Pl7|vI! z;q(Kc?c^)V=MCX}`+?w!7$I`ZeEG_TaqjB}*8lw6itQ=dNA}8@m3rNVXnHZMS8DP8 z+}`Hf7{mjMcJ!*$R+h3ewC-$f34`C?8%_R8cPhK@19mitjx&djoIH8x=&@7XcQqZ4 zGkY>O;MTU@76w0~A8A}uj~_X9Dx5iaa#NamC=A}KA81@t%g0JHM~@xqL3J`7hpat@ z&6CE-!1Qzv2k|3e@JxKnnNViI4aqEU?VX;kEQbs6nc41+`@pLfOYt1eKP}m7MOSPS zkGAd9jwJKAy7PyZ&$r}kojk|F;KMuQz5L{2y;feCX`F4^iPYZY_pDt`-Hroo>6a~8 zA8cE+qeHyIZR$&F3r~f?Q+D;iY_L}ugDaB?lD$(jyC;ooF8h?)=TSwQFI(GO*f*Yc(c3OHoGKv$~xCiUdq@Z zL_Kc=T}$&TbM1qeym)`5+8#n&k-Rutt1sAjh0VaGvn@LdtJN!WcHnGH-#1&C53_bo z)`$3|<@1Z}r!f1MDt|AWK6idOBM95?PH!?=arsQmrn((B?<-l**V>lrZ3A71LbG}} zAIERm?YeUP5EbD7zOF&z)ii$F!--mM^kT~O}+b~ zc>CpVecKz}boy=gOm~@H({@Zt=I`pnY_O*s++@*zFdLQelBm%W`>nhuF0WW(6n`Iz z{&`ul&i}GFuD^TMT4K96%X^xm_le#w=ZjSoU=!I=K zaTyn)GIpfOi1Wn%G*x9S-WO%vmC9;wA~XW|h0v;74(Ba6URZF|*gugpBH%rsCV}G-c6t7;bLF?|G%Gv*EmGQzn_x_M2@R!CbuEHQHt;4Yq}(MryLD zip<#_zpZw6JlUh|I1C=X>Gk)VJ)3%)PyGZ;U4y(%UK=a>A&$f5;q#FK%z)TR7YX zs;6Ybt-ZZ8-|g{TetVBd8APCH<5jfw3}Wl!Z?i*;yic=wi7eD3=%|m7dZQyBqu5-g z>hC+h@9|a3SM&S!X&$?gc%B6OR}9!#H4<0HK|M26=Y^VIxXlOEr$c1XWd&Oiq72_>C#t5pwW#e^+oR@J z+oSG%R3EkdYJT7C_r3Q~$4hNb(awI<_N(LTyL@$is_jwBSMwKbsgvqcwEQ0She_Oj zWol@B_gmc$soSM`TW#O{P2u+Ni#pC~`+b+Mj&BbnsVwSzQ2VRqPc^QGU)1u|@$I1r z17%Tf`>rmj>JVjQT(#0mWTA?yJZkys3|8Bt=J&nDs_pSTLs)obsE}V7=a}2zp5||^4XA4KZW+ai}q2TcU?!Tr`jq=@?aXW?c?MeCDTfp~QSUDj^w+~4OF}C-#qjv}(fWSBlaH=}a zqfg%v@FS4K{nz>_-G8a-()~t=5l0L?Ese94Q9CylwjBtAuV2@^j?EH&=lYg}&)m?q zu+8p9mVAMH^HQ^JtFxrVU)Gy=VcWh0l3EL3M{3<3xs zu#E-A?JcI9Pn*VLL0b~{U$>3tGhIUf0R#|0U`zzY?G$cIhLvu567c;NR!)e)f;La% zNwEkZ&`BVP`>*emhu09;GyzUoH;tN#5I~^d0-L*_?V2$7FR5F%S;Buz-MY;ZK4G_R zYq?XKt$Ew51#Q>oEoeKvai_L3L%UO()t0%SExt*e!8~cVsk5ba`x}v+v_g;DvlV>P zqj?A*FlGY2-vTTMXA<|{P>|-(3#00Ib%y1+NT})+xsRNfP(pIQ9?#3@nfxVq||ZLR>L0cffvpa6?K!009ILKw#ViIDZ(o z5g)DoHsXnX@5Odq7<|gU%5>xAY?koY)h!7>c}?5WwHIyP(zO?D>e4l~4BA%MUb3nX#>^T(Kgu5Uj9 z&Lg(pm~N*Y4Yq{shA?>Oh0QD0EaA^u6TWn7+Y+{0Hg5^rEqP1WDjPQzs0{7yYgXIF z61LW*YhMo5Z@>0e6AgH2@tXUFRIB9mnSkY$FrJ%F29t}WN;!J|R1kbFnD~5PcfgAt zVdL&^@fWRLh|1V;pQWrfG|m(MQx0}bl$&3&&$GIH-7BAGZKpj0eL(<$q6u(5S+o(M zJp&0OasLYjDuh2qV6+8TG8ZqI>lTy|VibRx?<#&1X(0k5D?kV^vO`D15kLR|1cD^) zzu6x}B;7)ovHP zw&tR=____dl4IA#9i*QZ27i26^Yu8E@LQL+B>aafS`z;EE1NISxpe2OUH7pgO4^&c zI3)85kW=mg6RS3QBo~-83c1kv3KQ#KQdt;$_&K{GW-gd$t?`gO-f-gdTkMjScf8}C zqsI;(f19guGOn=i8Xx%uD_}0z)mr1}nT2rbj#}MnESDC}m6pQwi)e1nsBuRaeDcrZ zlH#^opC)F5V9qY}agX>Dr}d70a&=#Jwbg2A>aJ=Sb+l9sr_P2CxQ^N_z@taMv|szz z*)_hVx*XOQ>lLfVxqZ*e>bK%sHb=m=^&$E9J z*SND~Fk|}F)vrDDjSu|Br>|ST`f7Fc%b$Aa6Kn6izR}GVS{u=4zY`bN+lW5<_l;{V z7+T#Qi;L^A?q7&A@5%1>GvEBkN5Arg=6-+is~=zc&G%*Zd*}KF*m)A~41?ADS~sq7 zd-@x#7rAMB1*_-je;Dr-+O|=fN6XQKwTbkuS~WFw(-*qQH9qoF*)=wAEX$?3Z8_^x z*DRt(Uz?}(@!5ZsUE>|4dTHuxZ7JGVRu&e*`qW)+^NbGz{nz-+#he<$>T?g!6Nim4%4+?rLS(c7*E# zYDeVgk(xqQ?T4Qbs{Qa&apufUnpM)tk6EV1qqVY!e%v;lvp+pm_t*HzTxPqqA=J(laTsrl9MQroZktNGRTtNGRT z`1VoTug*_({;1`v?N{?px(%VnpX&Ik?eU#o{m@JuU$yldfs`}uG7kYuTe5v$*=RA-*@|8E4E+t@zMTdAA4)_ zz^e5$0-v@ZquYDKy#*QSMy4LL)s05oh>KRf+8#B(y3YWZq@-}6Te3f25-`{8!8OJwMgn3%y3iG zaaR3(Z^x>J8Z@irtDb84*T&)$NJahuHax3hq{ zadj?@R}nw}0R%=x!1pJRqvAk28v;q(e-MxDEszsrbi1{SpCE&i(Ct0h=-qGyiuMkN z+PhJ2zuI5&BY*$`2yBi3=aZY`oL5UzaM5%vMsIg<>@C7j&meri&Eb2-sqI%k19tcI zdvV^7=A^6b$|)u{S#?$CMQ+78FR1-h+pp$V+oOIKua>X+tNEohEH;K}`&ECnJ!*e_ z=U07lHjAMptL;&J)cLQLukLq;2A5Ni+8(vPYJSyUoe%2vtL9hxtLD!c#-Syv?NRfq z4ORVp&u6tgYJb)IMQe}Re)WP3^(u5C4Ru7iB}(`ntM>`Q9U{{Z-qq z=2zR}`v|Z4tNGP4deukuSKA}@H~GB(C4u;Na(>mRbvqsQ?`nHgA9XuW%UAci!}e<} zPi>FdUp2q#ug(W`J67|n{Z;d~j^D6|F9 zCO@BPs9TKhJ)FA5sO?e9S7)@^9yPyuMDl#*C*KBN?XU0rs;Al>-}9$v+poIERsGfc zzWsgA2jAPT@A*@-@k&C~o~Nlgf7JY{k2>GH=1(wRYMScJCsik}{jm0{+ku*2?XQ|& zJ+D#QullR=L2ZxfqvrSB9`#PV1AL~@bd#xg_0-1q2(EuCYaClVcVm~Y;ETWLu;)Ez z5cuA=sdw{Mw-I&DsQp#jZVwf$=O>i$P0x&$kd?kQIS80reo(RsabIAdoAdzA=_t5HBFmg8=*U9+1d_z%~(B4>Hoh zMe~homrM2KupYSJVn4yfHW~Z2Zumag;Na3m-YFr8`~OC#JiO*XfO+Zxl_C*9009KX zP9P`9xT91rO`WYR*(Vrxtt>2r^{KmDkZ~13##YS|-$8)-G3Qn}P%i@GAV9EFv{6pt z{+DfSyVy@}t-rcm`aW)Ntp>Ft&{-fa$Ox;;_0oK_OzQ1nW5tvUGWHT=bS5p%tLj?E z;UoF3AbD#(@ zND}vdck_JoeeR=QM&ikG} zYWs`U9@SILuYR?K@BG=Z#pIcAey*~z5Uq~7yINTe%Nv(qT+#an7rqBq#aAb%T0Z%= zR$$b}chuYOd-RKT^5ChzN!>sQHWbzKrkpH7*lpsXAWj zd{F0`+8*^L{JzImEnoFiw=XrnZ%?(qYJ1fD>ikqsfz|C%9WUSItDb6me9s59 zJ*vOzqwXJk&o}k>tM)hYOyd4mD2G0E9Ez4-9cOhrQ0KMp_V_Meop-9II)CoGYS(Gy zKlSsD4xxp8+eNZA>Jw6Ep=^FpUX@%W^j*H%Uv-mG`>Wo9AK#~XYI}U|4^@A4`&IK7%|~sIy1f)_zNz~kb^fTH zMa!>_ubN-&uUfvE-}ih_=a29G$+inAlDPl2_JLIC)v4*b{PrGoPVs#xRejV=k&{;FEO>Z9gY$IEwq)u(8udcOCEs=vCusQK0L^6jIxN8MhE zHs9L!Fr8D>`J;LkEx$UxYJRo9YWZsZ&ZFP{syZLk{J!@mn;2R&e`WWf+fKxmcD2RH z+YTR%ok*M)aulov|2v-5h$`i(dK{A+Ee7Q zqiqO`n?Tc&sHPwzzS<&KUlL{4U1<5@+e+EJZQWyS%~CD~tMNDTxm{8@uo^GjIUC$q z4nDZrc-$NYKXvWeS}Ngxy{;wUuUixT^!k<@U%sIw;dgFqNw|1ZOTuTK*OKtW^IH=B z{R>(WK6-OY!o#<;B)tEHEeYRlP5A1q%{gufgKEp~|Hbe(I4r{#?ABeWgePplS}NgR z*Gz zGOM<@pd;&({>!G(cnCe(IZ+nD;!R~o7?_v+t!*<8-}L%>&YpE!4nGk9yHH?y~-QynU8gd=SsMz<)55Tk=BFCl;c0tg^bB!MLE zKUAbPd1%YHox*t_q{uN6@ckB6c8HPl(FlRX7|lGo8Vhj1Vj>`b00IagfWWX%$dkA~ zS@^VleBDy2#v&)zul$99wjOHd#+tR;!r-f^RezT7+o@H5mhgnF`fFLlX3PFIYZ2Rx zo4Sb2YGV#Q(P{8+FSlJ;4i`NDmHvW9O2ynnE+(;&I|Luiq7!5)I z0R#}({sO*F%tu{tu*GYK!r(Kho3>fPzfRq>%@Y2(-L!3E@!CXm2evDFT)cMJ-4iW+ z2e!D33sD&z@4(imDh%v~co|FOY8!W8b5C7u={vBAwY@B}w$tTOJXP#|Z|(W~Fm4wo%_^X+Hu86i$FsjmD59aew^%9fcbt8iW7>2q2Iv zko{THqzjTPf^kn>1QW+ggc!M^ynp}#2q1s}0!;#ZYTtx0>Q9rn|JbPagZ6tD$O$pr zCnI?uk`Q8e9~mk@009ILKmY**5I|r{1$K(Hs|(s}MO4$>*pAq@RN7a$Zrq;D628-# z@F!PCOT1EFDS9At(O3IdimtE9vLd2~@CBT$Rnq&naJE zYPJ1fR^Q^aYDVy6P)_3hP@6s%b^2Z5~;;1Zy%lBZq-5I_KdK?JfxjHb_enm*&{C9dEa z&_PCnza4b}&Id<*1ZjVpKoa+#YOeJgPov1KmY** z5I~@~0*!bgjuh;=cK3)b1E07UtlBLB*4Er9OgRYRYx8$++&18782sri&G!+og#Y@& zmW0pU+MIAK48FhR_m9UHsJj~t?2W!TC;l#-iTmuC)oJ%G2!$8n3}-6t-puw@JJBP#9zQPQLUh@C$8XMQR22q`QO+dpe^pkku}fTQL&(*d z{!SaQ*2nU%%RjMxUH*svbL+hZda0%Tn{&F+#WP@U7+C4s_M3Bxb{kH&VY#i2p9ml@ zJb|KZUq##h3{RSp5E#CIy8W_!4Sx(MadZUKd&sFhizBSHwkz{3w1`W}i;u=3v`{J4 z{OYbyEq{#jCvpGxjxhmUM*sl?iYLHvuXtn9sYQ%eCmmkvCXgLs#LL?+a&J)TSdm9Z6hn-`_0&qg-IIDadNmLh-YWdMr093 z3_UG$vxQJiUzl?;4E{Q`uFVp@a%=NCwo|tBELuk9ma$#BGg`;CJL{`gCJ));4JS^& z#Xd24$2;yhdhGD=x49K%>94S96mp^KLbjx`FnH*f_C%R?wXU2yU9Fa;?y81SjiqWh zbvAs!)p(7QiK8sJ#!r4NyT)z{&eqrJ$u&Om{=M0KoLLB`?x@wRkLA+BxzbV?xIW&T z(Z}6k@X3pDN%4xm=v#f_b%u?s(Z5X~QRd&yuJ$$6xzb#vI%n0sy;hAUp{w??jA}3R zKA4xj5!bl0WiaDrt*(CUp>KTPH$Hvc`bxpo)h~bQp--&6_xeVqExy))OFw3lEBPXz zuD!kVPvgvcvg>~4n;-e;SH93(_ZPqV@wMN4UvAyceZ?$#t^2uWP<3zgqt5#PWT&=MJ$ws=x32jp(Z_$mkY;_ZDP~+nYRF z_TfOzA;!1Ay0gt`Cdu1G!1w%D%lAD$)%K|QM}1oO-v6j4Z{z0gd;X~7tNQ!iepMg! zM}jyY^Sr^3`!r%WrSt)~2ZK_nlu| zrr`kv2f`D%XEUoBtF?|c5J%i7fZYWtgljOIIhce|LTw;)4p4EaY(K;3vp zt9R|KRr~9E=hNQ80;XJDz&6pOu@+Fb@i?$Ld} zP3im0Pi?>Nw=LB6sFO+cROf@*9<{$}`_=qvd(^jm)$&z;HNUz*UTweXueL|+ukZY- zkGj36`PKHQKI;5e%UAces*jpqZI9YtHNV<^@{f$bhhBW;#UK3RN56HIwRp<@k1mXl zp4Y>fTD?4dB>8zbnv&Pq|Iw~CdOmYx=CJ(;qFw0?_J6bsh@PJbtEbB)d%^<&1Q0*~ z0R#|0009ILKmY**5I_I{1Q0*~0R#|0009ILKmY**5I_I{1Q0*~0R#|0009ILKmY** z5I_I{1Q0*~0R#|0009ILKmY**5I_I{1Q0*~0R#|0009ILKmY**5I_I{1Q0*~0R#|0 z009ILKmY**5I_I{1Q0*~0R#|0009ILKmY**5I_I{1Q0*~0R#|0009ILKmY**5I_I{ z1Q0*~0R#|0009ILKmY**5I_I{1Q0*~0R#|0009ILKmY**5I_I{1Q0*~0R#|0009IL zKmY**5I_I{1Q0*~0R#|0009ILKmY**5I_I{1Q0*~0R#|0009ILKmY**5I_I{1Q0*~ z0R#|0009ILKmY**5I_I{1Q0*~0R#|0009ILKmY**5I_I{1Q0*~0R#|0009ILKmY** z5I_I{1Q0*~0R#|0009ILKmY**5I_I{1Q0*~0R#|0009ILKmY**5I_I{1Q0*~0R#|0 z009ILKmY**5I_I{1Q0*~0R#|0009ILKmY**5I_I{1Q0*~0R#|0009ILKmY**5I_I{ z1Q0*~0R#|0009ILKmY**5I_I{1Q0*~0R#|0009ILKmY**5I_I{1Q0*~0R#|0009IL zKmY**5I_I{1Q0*~0R#|0009ILKmY**5I_I{1Q0*~0R#|0009ILKmY**5I_I{1Q0*~ z0R#|0009ILKmY**5I_I{1Q0*~0R#|0009ILKmY**5I_I{1Q0*~0R#|0009ILKmY** z5I_I{1Q0*~0R#|0009ILKmY**5I_I{1Q0*~0R#|0009ILKmY**5I_I{1Q0*~0R#|0 z009ILKmY**5I_I{1Q0*~0R#|0009ILKmY**5I_I{1Q0*~0R#|0009ILKmY**5I_I{ z1Q0*~0R#|0009ILKmY**5I_I{1Q0*~0R#|0009ILKmY**5I_I{1Q0*~0R#|0009IL zKmY**5I_I{1Q0*~0R#|0009ILKmY**5I_I{1Q0*~0R#|0009ILKmY**5I_I{1Q0*~ z0R#|0009ILKmY**5I_I{1Q0*~0R#|0009ILKmY**5I_I{1Q0*~0R#|0009ILKmY** z5I_I{1Q0*~0R#|0009ILKmY**5I_I{1Q0*~0R#|0009ILKmY**5I_I{1Q0*~0R#|0 z009ILKmY**5I_I{1Q0*~0R#|0009ILKmY**5I_I{1Q0*~0R#|0009ILKmY**5I_I{ z1Q0*~0R#|0009ILKmY**5I_I{1Q0*~0R#|0009ILKmY**5I_I{1Q0*~0R#|0009IL zKmY**5I_I{1Q0*~0R#|0009ILKmY**5I_I{1Q0*~0R#|0009ILKmY**5I_I{1Q0*~ z0R#|0009ILKmY**5I_I{1Q0*~0R#|0009ILKmY**5I_I{1Q0*~0R#|0009ILKmY** z5I_I{1Q0*~0R#|0009ILKmY**5I_I{1Q0*~0R#|0009ILKmY**5I_I{1Q0*~0R#|0 z009ILKmY**5I_I{1Q0*~0R#|0009ILKmY**5I_I{1Q0*~0R#|0009ILKmY**5I_I{ z1Q0*~0R#|0009ILKmY**5I_I{1Q0*~0R#|0009ILKmY**5I_I{1Q0*~0R#|0009IL zKmY**5I_I{1Q0*~0R%=?VD3l%=V$MG_UgYiX+5~k{*Qjv!5KmGpmpqs z{eQLnA3d*!Gqrko`tbC0WjS0}nm*E+aM&{0<0|`q%Ko2Bp1W-BrzOXaiR9-l`+1%H zzr+5Io}W2#IxZ>tJ$kr&joX!sdVhb?5R_yZVyi# zyS;QGJbvih$x}xUpFDK(=($rTj+Sme5}qrC$B)k*nmu6DQBzK6^5pnLT&> z)R7Y>tccjjc{Tc-_L{UjQCp&)4}|r~Y$c2ZO7{DL{U80j_rZhlpH5fG2VZrtcKF~c z4$iDBE!P&p`oUK{c(7Vp2rd0|xpeS7uQ*s)4i}aVzRLb)>Hd`{Im-US%jXZi>d1Ru z;S$drafyfD^F#0XA**AD{eNZh^TGGn6CMa4fB*srAbc2~@ zKyAO;9a5Cc+d;xHq}XW2C4ad@8Q%f zMs1H;zB;4T_Ne*QBhsGK?CAcBIv-R|wZFdetDb6me9s?synMI6`wUCxQ2o{XzWsfB z`rdwh&!3`=*X8Ny*Y!7b{;2s?A9cR@&cDB_U^;{9*}`BZH}}QAE^CR+vB@@^;|=3kD7nfeN@k)^;g~Z`|hvmqvoG%-JrYtu9olH)A#;x z)VE*X?N{fII$mn~)%m6#@6>ZWwf$=O>i$PP0315X9P=YomP2UceE2pgZx#ARHF%Gi-A zBhC~5(^OR$tnQAo?n-677);(#s+XqD)|RZgyH*w!!ur%*uDV#W-|8OOlU-d{U9Okr z1FP=s;nH$6fUY{@h#o@kcE+D#DR}V*ST7C(vm4sSS8ft^|Cz-7>OQS|!9&TR9(vVE z-FDgQ->La~E!X8!4@JJ)yO>aNm!w2;m{b+z5- zRNOrf%0ch7y*{(Hnfk)?QlmEabSSkgX4ZCYr82)=X6PhE8bO_XP|t2=Y|8_xc~8{Qm^ zoqOu4>woMrrf+gnkBv+1?AaiC5ADdD8%GWuIey!rqqkXi+*8*byN^ipNLF-;Q}MCv z>cZR49hy0M^oUjGp1SH@JxF!WWmi{QT&&fXSE^Q>d+Ms|e=1&xAk%xcWUy?FZgS@p zd)9Y%^2@*UnT_cXKkvJa$uM|yXXb=>AgotrD`DBl+*3zphlS|T--P&Nc6E&+Be(Un z`L4QT!e>_(9Svuro8PzslBL=1pmH(0x(5%|!`ZMN9aY>@SKVtGC1qE)zJwrE-Ny09 z7F%cRc$33qWa*x|+H6gF^oVQQDCR=@)QYpk|5&z-oLA)?H*58BSYLYOJFQOl)YW-e zqpU&dJek?gMnyriPjpXRowklVdJIzMTQloiS)8wx%5k0U=@9F@FSE{fF4d~h$)5Go zJ#}>^H)a~7pYP7B^X;|z{Y#6b8LQJhb#*qc@ZXpj7ouX)yQg>v;(uD_&?DIgIX83G z2lSQibd?Ta5=^O8Q%bOEj_taH7sBVTyvdjL`#vV0#8a!s2pTl`6yV6qW*ooOwr%qX=?y0Nv)r~$6($mLtj=k}YXgb>YHKx;a*;P8| z&hJ9|6i%DqqX4^xg*# z#-nAGx~Hzv(%?OPCg-U9o<<05l|Gm}b(JQ=D9_Iw7Bfeo?EcK1YH~D=P6OOiS7CZ? zx?(Q0&$wjZ?MJ**bvgIv9hhfUmX>RFg_hOnp1L~i61M1(bkdb{L8;TWvTtBtJ6Jo{Y;+>^wrPofO=->fp`W*{Y;*^I&H>9k3no#v-hg*aBP*j zr>@fUk-4vq<^Em%vg`b74gy~E6De*3N*=#^f` z9YjOVIZ_U@7VB`%QD3jc_TQJX0o_5^M$J8Sqn17%_f=`mI~W~C?bg9JipK^#9{1kU zoyqYyzK%NYt>r^Tn;ef1IokB`*cFp8;~E;#zwz4ePJ5Y89;b;ff@p#-6(*cevNvhMf<3YmYzUmw>Ozx}B0mJ0J>Rip7Ze9@0IROj>ooYE8{qo9E6W=9FLE?9ZdRo?25^l zack?3_;~Dcz98>->|$f9(>--{ro&`cl2qq_VRBz}4j3l)Rp)?Va$j{07$)~s=b&M7 zUzH9TChL`E%<-;avR;dAlR0M^E;hD}(miz>WjajmtI|u^=Tt5xwo2VoS7|yt?yJ(y z;c>LfOTy!!?eg3pCUL*rXL5a&PcoSKhh@EsuD14C@(;^;EjDEa4U_w-bkH!luSy3E zlY6gpPjXm(ai_y_w7eoYLZ5OQM*6VqipiJ@YwM5ruP{U$2)p0wowimCihioUYLCN zG zrTbT2VXKg$kE`5MH&xcZBQ$mV$ry{Z^+zhF^)zQixm(g@mAa>{QlpL@$$RC!_td__ zG+y2H@=nL&tP7RW$75H_g{YX0OJ-fpmk)eAb|p!54tPB7tIh$B$9>f~;PJSxItM)- z_f_ej$K$>#9rSptSDG=&yB?4AT5O{n^myD?rGp-i`>J%%Y5_oX88^`%{QwCcRdtFOujJudfE>7d8u-Yd1s%HrelRHx(eiRkR3aV_x) zcOsBJF1unfX5QNRBR>0ZIj1@tmur=oF#3WFJ7tZZx;pKfM50G>^5IIl(Dhuv<+M7p z-@bMgWz?BoDCkO(>KyRx>%Qt7@a^lq>KyRx>%QvDdHcGNF#l}{td+I7phsizm^y;=76D9}Urd8IVt08{R z#tz=)U|$&Q>+tnTjSIDk^Dj4?Db85Xl6C>^k=t&vnJK>a55DhNU9|b*yT88YhIuA& z|9;<9QT`AGinbjLv1>yq%J+V5D2=3$Z6gqcuJ&cU<(99%b+_uXASPKYx_;xB_-1UQ z7-DRjF&oj2jQXy>Xs1j?YtM*I%k^fD`utq)2u~0wpn$r4aVlKEK`cO%lDPk}0yKpt z^dOKEVz`?;uZI{x;6BCh7GkKopdNZh76cGL0D)~Nz$xf(2bJURa6NsOHg5BO-1_T# z{`f9GC$wn#qMX)S7suc2!lxI$2gXPFN!)+AkFqHf0R#|0009IB5#SVh5Iz1@74ZF* zLiZ4(^(({(G1M_6KLQ98UcmRRHU}Vy`>)7(nPdbIKwxwPShzbnV->a3_i-;L#CYp` zsT$TxQ?@{=^-hxUm!9(}#%N6=T8jVz2yCVR@5XMXHgyeCAc_009A=r6g}`PA_zoG= zKIDWLZP#GDlFPhRTJom_iZ=Drt?T|9@6L2L8s!|LK0im+A#he0R#}(egf(# z*7g&iM+l6M0NeZ4jx{0b*7|3M81}_cVGyi;(ao3aY4qr2S=7<3?N8xr-&Ob)(!gye zki`902_56WC}532*4<;!N4ki>Rtfk%5%yjFR=H7cF$EeCL)*7sxG%G`&o10k_t{1K zy_UU%7{%-`twI2SUIaK4^`b-`1O^pI;{N2vpr!Hm2q1t!Q3P^A4ENRb7Gi`aN{0>~ zIdsg081c8*6Jiu)0BHvTegydR!jCJZB7gt_tpe&>I_#fY1=GI|c%@_#@L!WIbO^r< z*siWEDB8Tp2{C3?mX>P^VckNE#&>v6mtBZ4viFZF8hzKf(vm^l1-1M+zqSado<&>O zrnbMO`~14e0;9hF*<`M+)iM9O5|IIcZ6m<`bF_vsJG6+eyqH+O@?v)*7av)S*4S=U zYm>PD+O4X;2=)5j4~}~IMHnO6fB*srAb(W+<)Ep^_(6f-~@c{r(He#L|_~RvLlPh2f}(~wi1?YF_e4i7DG)&f5L|s<2YI9 zGXe-8fB*u;6Y#x`eUo~e#QoQAQgu{=fM0>85X0_3J24vsbHT-6^4!aupPCE@)CS`z-WHQ`Iv)>J!w?dq0<$FFHg_~^AQ3IE8x z&m&dFH(L{a`}&p~zh*bjO8v>>H?FPCMPEeNxGa7)NOOJkrk4C4eqKw$k37F6;knj? zZ@i!-$EBNF625p#OTv>cY)SalTbmPhhr#id-+$h&=-=p=Wq5Q)OTtg=Y)Sa*)`TzZ zYRU0Cc5{GKp`Y8cuC*hMaGSKO&L`~4;Zym4!ItNx5`H!{{p?TvS!()O!jGknv|As$tLB7nk9TOH4QD{Vrm*%!hc9jLrZu(H4QD{XH(PA z5j4DM+jdHem-sp)44znGeSmhf{n{SqxJFs)@T z|8#0HTEd4?v&|CTpPFr!@E5HKUr$Xx%kf94>1PRFOie#acrrEpEa6vE)6WuqCN=#m z;h&{unnbh>NgkQ4hmvGr{ZCw9nYBE}mkEUju zCH&*mY_o)akeY3l@Yk&g-%3qC%kkyZ^s|KDOHDsZ_^s6RvxHwvO+QQcxzzNtgr82$ zHcR-&so7=;f7zPwN2%#I83yI%>1V(Ho=v|*%YI91S;B9nCZi>MI<+sfgnyfwewOgD z)bz82|1CA!Ea5|`*=7mvPt7(1PR# zq^6%G{C}+pf0mklmg8$S{Sq!anSJAIP!3)irR=)To;AONzEoSO&xF&5qQyClr=fcX z-R5WXu(61~P&zK-LR7|%R2gxe_@9kzFEyEXyxOWO&CJwRs>@4Jb*1@mX?l6RI-9G} zqrd8&vC*9i_M}>NvC(jA$dip{Hu)Qm{_1$#CQOE4(xt$*DD`{^X;iLJkX! zN(A_*ZEL5(VEc!S-TXu_8|@vxI}92}+X*|Bns{h$C76icC40p7mPwYESRfc5kS8WA z%d@&6bm4&LEj+KM`E2JT&h)D{yYMYlH5DKH`tlF zMPReR8{-r09>?O={IQs?RPT>RVqZDf8~rk!F%DPGhqKFW^fF$*CVsv1U>z{Q`#KeJ zZ6ibHQuf77%pSnX(scOl#reuiWjP{CQD6DaTBSODe|SDq*{07zxLhiimP^@#@KmtF zX8g{J!Nil%neT*?T3d@Ygp1K^O^?&}*jtho+06z!;^DSjFMsRX-teZ=Z@Xu@%UDbw z3WMbB{Z)%N_mqR1);CZKVCRB~owjj4a+%vW4@EKS%QmuDhU(28qx!crFvLhw!KSZ zAJMYq*p8)Md)IUv`9&{ToU*ay?VhXKeyZ&+ZnU{=+oN5YUbjDtcT!pNp&VSjTv-S^ zXSr@6EG@0nyX3l|Yz0-9qFr3a3NN>LAC~6Atmdq(wNB6UFyv0s@3(hBZKpmPTsJmJw>MP@kdYw(w$FFoVuw|mY(%z(v$7Eu!WqW$kWotSfS(a4`pKZ!_ zIv%a9ZS8TI+7Uni0R#|00D-L)NIvg>UiVh`zM(*l2A3 zzaI7dPtit5-F}PKe%j+*Ac_0Gt7An)+b)aNo{o51@ZzZZjC%XkA>T|?x@x63axT!;aq9SF8&XK&jk~o59~_X=n<`kwQB+5GA=}AbiCxU zQI##wv};c@E~yI_7Uyf{7ovM4E{F4WW!S=kt1f+or&!(7@e<(7OD=!KE=Nr+a{H1! zZ9Mwx)D!Uv>isQ-G0)5Y&WC>e+b_H3)$4Wr@b~Ti-JQSpSxXqC#%JQ|7c%>0z)82B z{eWF?JV-51m`lcBoeAgXDk}@o<(79>ZSj10>Ml1})~x8!ALCme-e47Z^8HkvZGr;QQ`)vPTQ} zGp`p^cgE_;*M4z-qV8OMx8L{9RV`ojSIZZN%X@aU{l4?7Cp*6LtNm5C7qxt~zv=|? z-5%9P&9C-X-QLyq_%2^>`uooBdwkXM)%?DF3O0SZHz$evZ|R=1V-7VE zSI0p;GgRk=n!h7P#*1qCYW|EWN!mn#q8&HX`QtnPCJseURjK=*o(e5+Cg0;*w0DNp zp%}OMp!#%(EV`^?J3&X zkJ^59e0`U%&QG;HYWZsZqAhh&eTtUf!~QUd`(KzETHpOv_e1J-IhpEB_g{SXw|fiH zIn;4h+wZ%4b$rvk@BW)QAJqP;`Mb9`okJ~O9p7|q!~g9LWj&QGzEYP|b%-)Du3G6O zvQWiUGqrqm2CMB+^ZVXn)%N(F@#=V~?JwH+s_jwzN4FP+dE2A1=R6X%OCap>h?0~{q;Q`)VEMZ-LomQSihUp#i02HX_Ls)obsE}V7=a}2pDIj)d^Tj%PoaJ9qJ7#^_V5MN`Jm<>ev6A;;<%mi6?-&j-F6cg z_3f)@`_D#*5l0LbVz@_i8{LVE!D@VyTSs1w?ptd&LEc*q9$sxco*xF2(QR#;eqU<& z{lD2wo>Lhv+MR(@3BSCvCE?LsEeRjm9o?Nbh*GVQJEB`he@~RscI)W6-M+bAo<3~1 z2Tq6b!a`UN)^Ak3C$6l| z+Uy3+?R|^8{_pm#-(mT2Tec=wva{_TVco>ynXw~A&%OPyn>GAI0D-X)NaFq%jZKGr zchntdeb+AUbSWkzjJ*{!e?%X7IvkUvDuf_w=eZ_YuARm zjO~iNWo$Et8}_!0ZRSYhsarH>OZB2hAB*O!wv(BCJ6$ftby#g@!fO1~)n@Ae#oAcU z))+7TMF0T=iXq_pP+g2((h39+Kw$d|u#Rmmu-h(li<7qNr%g%R|B~%L(di)q2q1s} z0^3Vq+)m-P*XYrk%@*+e7FOevjx_vmZT|eded&D{GyT5At#pcV|efL*wkni@W{%U@;{p$W_mk6r1M=U;2%U3>Y{Ob1NyLZ079e&j3|LLoCN&l(imGkcM zYv*gF<>N==Z%JHkd|{#sEw1zxTBuF;o!|G=@!fvP-^Kz--2bv|+(o)Jo&rTXMH$ag z=)KpBSMOFna*q0W%BZ*B$Cz%XGIK(VbG6!hSgK})81dJ>$CphH`O}N-#7bWfKmY** z#z`QF`(HjzeGURO#8C5(m*)8O)^~{E`%}^J8!@fNIUz=AW~R1MU5-MG^DL0kNPXq@ zy(y~gRu2^{km@X4wDI-b9(Dex`PKHT3s%%am)f4rv!(r2wS3jHy~g3DsGe%=YJb)I zs=qql)c*R;ul84Mk6ON(f7IKfw%>Ptb$jvMo@9Yk68C?%x9UcH-uZ5SPKfc6SJuOs zTD?q&;caHh1^b=~YJ=2M0z!<=!oJ5>Enm&wxp(cas)r;szuJEFluw=iYJ1wnI;W`R ztDc=}AN*C-Q>{_$ubN-=SLd7BU$s5sR=)54s{U$zwf(;HtJ{n3_HYeGXJP3A49ncP zwDwoCLyK|{eWm%@+LJ;2Y@(5CZLRJ5C+zT2bjo7Mcj+n?u_m#&^$srmEj%}ZB( z)ckq%=B4{CKd;`rbanex$4i~hzRS;Z$V*qpOYLu7y?N_qRE~dppe5m7T-B2B@YO8|tJkz7e5*C#53g;>@$1($fA7V_tc6u^%EW#4 zEU+HW20{Fl;q#U1{nN*e%~(9;p1OF-x)MFYBqWQo+V~HO9)%NPl@AR-ws>1qGT$_73l-mAoW^JxR!|vOvg|!)9SmJtQ z)w!pxbMgJq`lWmFo4`-LBtvl|i>&}@$s{62gBTdF&J$Ue)OSS6sqE+Xfy6TST)opBO&(Ewa-jHuU zaolQiPhD-z+w?{;7uv_6(W>ZQ%eIm8`CYc`(CSP!gwWO5yk&2c)Lds0_rD_9E#=pp zy`9gj*c(9$VcqI>PhH)%ql_N$+{v!HYn>gp_Q*Kt?{QaW_x^URv-36|Rhn$`!>sht z>`f(n_u_nIrm}36x~HzE@uiCc=w4`_cggl|O=*2AaF8+lWOmowrf*$yPhHpkb~J4U z=$dUP59RC&-qSeGuu30Hp1Mly5A;g+wY^8`HhQZe^Ozo=@azZ!`#!Cq-73?aJn<6& z1h!tFXm1^Cy~udCfcY@q<4^AqKmdVW1sah^TWHb#CRaMl*FuXV?!Ud)M)}RBzMJj0 zHI$A(T7XlyvH5eG84X4N0Z#(zbyoXVgH}1GLec0ley1DT-qNk0G zVi7<90Tb~379hw7Ab0-Gg3 zh_qSK!>Nby8jd5SAb>#h0Z{a44Kd;mh1xz5A+8vF#<2e$+>jCwKmdWR0!iGTtSRW4 zoeT(!iU8*kqcT$C+0I5>(eDzr+rr?3FKoW0v?csSYr=oOwQUL8i#Bfw+lw}J37gf{ zSi;8Awej4Z=rsZejE?~4cjGhG^mNDqN!*`YKrrOODGq`D1z5rsf9(%T*!rJB{3QYi zATaI%gh-<`0~oK-8ZTOlK#>I+A2BsAT}$HrS4ANPOW1sk9s6-#vXqMe0tg_0!1fj3 z{9*f!?RMzdU`y8yg~3-ZYhJo$3BPS$QNMA2HcNQIz6ZVK?rXPf-qN*O@|Lbul9keS z_qEE^rg@{l-n{E<`LlQmfuvw#d|Oj~Cyb%_@0)CSZ9b zjOV0vX|Yr(N6+02<#x%n?P?A-T7xNv@x$BF8;y#VhbZTlgng9vmKNaFru9W(JF z0s{yTk`I8#pUMI`Ax835#8HUR`mMw_5Ms#6`~d<(7vNAabW#dL009KHM1Z%LwuHTV zrAgd>yn9Y^WC-Mh7~#7Y=PNUn<#?$~J*+NI&$v%9Z2c0SVq{2?ga85vAbpYd2B}zj|X!!pCoFN%+X~S`r?5eoMk%v?hGz1uZ!~dvi;|C*r$L*(Wsd zCpB%&{F&5OFIu~Q;@0K@z9$S)jk4c=%s%7U=$IwEcSlRYpSLD_-M()=^(X(?ZqSrU z`0VcHyJqd4wR`;9ownwJiPY_(E(VjOnVH&3b$Q8Ryrt57xHP>Sx)?9MSSDJ_7WXtR z<3iV4Of{+sgTEW)+|^oJa>@U>sJ7ZleI}ef=W4sg&5(X-d&CSgI`=>&d{?yLS#|EI zt1f*sobwAV?G*{ixL8^N; z-p1Ru=z9;&%-5E}_=Dk=>V9yL>K?awklDLj%-^&*6+QZ!E0^|1^|kFn9y~Z(t1pzI zrMK>>(|ny?T{+mD+!oLFb{V~M7Z6%)?y0M-dH1+c%!R0!4maW3$azD~&Hmh;v21l_ z-XbLd-6%<_^Z#e>{$nJ$?u3AMcKu_svAvG9=Zjg(ZgreokjK8Bp5F^x`~$=x_6`(> zgm`b&>Zz{rws&TF=Yjdcd2Bm-jn(xu z`d`E>W{Y;lQI@9uPCRDJHxKSyqC*)DYB)Stri=8}*hoA3Zp?1%k2K1xm(-CNTtViHU0iG>KQgMdcVOm4dyq;MjGDtubdj`ON-fJPnM?-{?-aF{lNi2hwoIkhxdS6ouVs^pv7#lPd|CgeR^uxtHvi4W6sIpWotD87PCdb zy**q}%^RtjTVBByB_BVeS4}a8y=wJ6j5%emT5SE%+c~D>p}p$lQ9^UdUUh%WgL>8d zB}dN2{zdD-z3MI29UQ>vG3scRijvW?DSOqTrZIcs;Fy#5s-t)RyPH2z&;vfUIdTVg ztd{=nK^{Xu}8?d-Qjex~$LA&=_wW#KeLwnVtWv{wF=0Uyc{*p)URd2EGyE{|AS1n3L%c55u-uM61n3JNoP>o}>m@SUcz1OTo zjbrx6PUu08UX+a3llQKBuUU(#CJH+3HS4j0PJ7LItf13gvmPtxwAZXh4|;moyH>{b zuEPt}krCV$iz9dMHEU7L;RjJsvT{i8Ix;Zzdl_@e-nH2JqqlQR$wPbB$)kkkl)dZz zm8dC6C^# z-eTQ%ccy-?T9k~IP1&m!HI3O5J0SbO6n+S{uZHBA(A%3gKym}9o?&|Y=&D4{uJuev|xLA~n!l1J}V zZ?W#+tVxf};eG#~D86Tt6Cm(m6PWbZK_50B?Il2fz}+HH`~>E1+1_clb8tbsZ)~%} z{<(VGkTpvu`hU0`GjS3A3!nJuFI~7W?bcZTJrua-J*-Pr1PJs6hWGt{a)-k$zz&5O z0t5&UAh07a{uZNu*YLg4&QC}FAily%lRJwYI5PwY5Fjw6fIGA)0j*vt4e$H^6bl0H zlYoBf*3g4HhJ9aNG`G`0D*d5Uwi>M%%&b%@{?;xA&v1*8Kt5>G?f%}*mnk2#BSw1& z5FkK+009Df1qQbk>C1=*iWkyP4Te+y9^%`j8xN;q#a&u|)Z`OurF(YA0j}kxf4pb3 z;aKo@_l$TP3%;^v#N$}-PAqt(6km<>za#nGKb?M1*#E7~{g-2IQ%+oA2DsjSgorvhDx;fAwqXkINc6ZOp)t zqlIt8@2|#%-P~-HU)oG#eZ1V*%*z+@t3^Xcf2Gy&}o{?Yh|e`d3nceXmMi1^aa zywE?=iio3w#T+BzH~-c6h%csLYMbQ?DPphjN?xw*&`x>yyz|@rh$nA4VEYI3jT=9B z^M_ygxBoJJf;JpB?#7Mp{l=TW{_bDW&!u*ZPI;8{h8l{{G+jd*A=f(RTmVfBEHi|NYO8Z};vfqqjbYPv)f?2S?rghV?r? z9Dc=mlkZUv-H7v@zt#Vt;l3e(<2dT212zt%*V>zV4&DAIF2|4f)vt|@IC`@58l5oskNDle4^{W6z8F6i z?=;qv>KF3?a1k*^f}W<0Z~v$9ZOk{e*4wXdq)xAwujg5NW21;TuG0&xAN}8cO-DF8 zQsKYZe;XTncEkxj>e@b)iGa8kVewSM7!tS{v2ue7!|66;^uZ1ti8 z+}V*2jt~3R$cVp(o{Mk&yMEZQjSQ<{BY!ChjSu$bFUBb|96aFAU~hh{UwCY=cx4#u z*AEQ#)nA?<*jNAQbiv;K)&#-c{!YK}zP(p{X7C@CWA80LGdrL9n&J>09lLeXcgZ-o zzWrYhZr*M$8oO}JetYAHS5^_`oB#c`h57M)AB7)wf!P0Rn?H4%^9 z_1^)G{&2hNzxU{y(l0sb_D@>>{S$7_r1ekw-!>;LKk5FObo(dupS1j>+dpafNw?>A z`%Jq1lOCUw9zT=TKk4>QT7GA&?9uab_8CVaXt0% zkqez>si@}gBey8|6NikRvJ^3gV^S>@G53z1Qq(k2%;(0ovl!?)Eq zZ08U^IOgQN>e8UH;h0p%3VP6>dq@3GD#r?XUXVt=+sB#ePG{>)?xp}uYaTU zP+ofI7PncWS08u6eDTG`ovG^x7ZU6hTJ)e1h!raAC?zHprPTQV4ZP(uIK6m@}PkKBIZiDvSVif<#Yxh%= zoqrVGzg@cAM={HwL+2+wQciQoDyW2b3_S-Rk zr+MCvHhz%mw7+h>H*a_UcI)U~CGepa`1ChU{>r(nuitn$B+8M}AA_X%;h)acia()C zpB|r$lup?+pVhM2$kHz|`crL~%Lou4K!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7 z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+ z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7 z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+ z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7 z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N z0t5&UAV7cs0RjXF5FkK+0D-$-;Mvc;^`C#|=gz%yCYo|CQp&sS?M{~0tF`6j>ioh= zzmcco@zF>rZ+Dt`r~7Qyy;>^W7tbGwl=8vyn2Bk0`S#X&yU`phKN(qyk@8f*!;wE8 zDdk^mcdm4|8d+Z6UE`p*qxHP_(ici+WBqcZl-H`Y#b>JX&r}yaKf7{%e&u{^?&arV z`GrU+&zBn2*;;jBb!l#CEvwEo=2lm$EBVse%JSS|mNnP1MzyvuUtP=>YmL>}Ms2m( zY*v@%s;eujD{Hkr$f(z#-Fv-GMVz!PDZiR`T5GMmFHnx>Gm%oBZFhU^jl5HDHD?+d z?d{Fp>1=jpwpu-%)n*o|sp+K?kscc6*RH1}CISQq5FkK+009C72oNAZfB*pk1PBly zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7 z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+ z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7 z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+ z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs z0RjXF5FkK+009C72oNAZfB*pk1PBlyaQg**;gA2`zxm6by>!om5$dr>DPM1GUa2oE zWXlVyv)OPH&P0ALQp&sS?M{~0n+uI>exbV3FERRhyVJ}&-Gg5rxBjD1OC?guZ(6@z zZ}swxZa+-vfyh1)Ddk&@PQKZzXO~;+%@^YN&qhl5#cP%Id@WvRuWxT`R?e3zoji+5 z>#b&GCZ4ojxjg#fu$tX6*DsYywW#N(BBlIV<<)L`v%b~nT~3wtwGTlO z$wB6k009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7 z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+ z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7 z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+ z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk 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 zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7 z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+ z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7 z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+ z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U 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 zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7 z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+ z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7 z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+ z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly 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 zjUsC&uIysbwR);*FL$yyZow0HD}!FZ>~3uDOXsNVm&^J@~SPZ5FkK+009C72oNAZ zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7 z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+ z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7 z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+ z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs 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 zxV~k10RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7 z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+ z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7 z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+ z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs 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 literal 0 HcmV?d00001 diff --git a/tests/test_api.py b/tests/test_api.py index c99c639..68e1bae 100644 --- a/tests/test_api.py +++ b/tests/test_api.py @@ -62,7 +62,7 @@ def test_sample_questions_endpoint(client: TestClient) -> None: def test_analyze_endpoint_structure(client: TestClient) -> None: - def fake_run_analysis(query: str) -> dict: # noqa: ARG001 + def fake_run_analysis(query: str, source_ids=None) -> dict: # noqa: ARG001 return { "analysis": "## Summary\nPipeline velocity improved.\n", "trace": [{"step": "planner_compiled_node", "status": "completed", "details": {"objective": "x"}}], @@ -95,7 +95,12 @@ def fake_run_analysis(query: str) -> dict: # noqa: ARG001 original = analysis_run.run_analysis analysis_run.run_analysis = fake_run_analysis try: - response = client.post("/analyze", json={"query": "Why did pipeline velocity drop this week?"}) + upload_response = client.post( + "/uploads", + files={"file": ("pipeline.csv", BytesIO(b"stage,amount\nopen,10\nwon,25\n"), "text/csv")}, + ) + source_id = upload_response.json()["asset"]["id"] + response = client.post("/analyze", json={"query": "Why did pipeline velocity drop this week?", "source_ids": [source_id]}) finally: analysis_run.run_analysis = original assert response.status_code == 200 @@ -108,7 +113,7 @@ def fake_run_analysis(query: str) -> dict: # noqa: ARG001 def test_analyze_endpoint_returns_http_500_on_failure(client: TestClient) -> None: - def fake_run_analysis(query: str) -> dict: # noqa: ARG001 + def fake_run_analysis(query: str, source_ids=None) -> dict: # noqa: ARG001 raise RuntimeError("planner exploded") import app.services.analysis_run as analysis_run @@ -116,7 +121,12 @@ def fake_run_analysis(query: str) -> dict: # noqa: ARG001 original = analysis_run.run_analysis analysis_run.run_analysis = fake_run_analysis try: - response = client.post("/analyze", json={"query": "Why did pipeline velocity drop this week?"}) + upload_response = client.post( + "/uploads", + files={"file": ("pipeline.csv", BytesIO(b"stage,amount\nopen,10\nwon,25\n"), "text/csv")}, + ) + source_id = upload_response.json()["asset"]["id"] + response = client.post("/analyze", json={"query": "Why did pipeline velocity drop this week?", "source_ids": [source_id]}) finally: analysis_run.run_analysis = original @@ -140,10 +150,34 @@ def test_upload_endpoint_profiles_csv(client: TestClient) -> None: assert payload["asset"]["rows"] == 2 assert payload["asset"]["columns"] == 2 assert payload["asset"]["status"] == "verified" + assert payload["asset"]["relationCount"] == 1 + assert payload["asset"]["primaryRelationName"] + + +def test_upload_endpoint_profiles_json(client: TestClient) -> None: + response = client.post( + "/uploads", + files={ + "file": ( + "orders.json", + BytesIO( + b'[{"order_id":"o1","customer":{"name":"Ada"},"items":[{"sku":"A1","qty":2}]}]' + ), + "application/json", + ) + }, + ) + + assert response.status_code == 200 + payload = response.json() + assert payload["asset"]["type"] == "JSON" + assert payload["asset"]["rows"] == 1 + assert payload["asset"]["relationCount"] == 2 + assert payload["asset"]["primaryRelationName"] def test_inspection_endpoint_returns_stored_inspection(client: TestClient) -> None: - def fake_run_analysis(query: str) -> dict: # noqa: ARG001 + def fake_run_analysis(query: str, source_ids=None) -> dict: # noqa: ARG001 return { "analysis": "## Summary\nPipeline velocity improved.\n", "trace": [{"step": "planner_compiled_node", "status": "completed", "details": {"objective": "x"}}], @@ -175,7 +209,15 @@ def fake_run_analysis(query: str) -> dict: # noqa: ARG001 original = analysis_run.run_analysis analysis_run.run_analysis = fake_run_analysis try: - analyze_response = client.post("/analyze", json={"query": "Why did pipeline velocity drop this week?"}) + upload_response = client.post( + "/uploads", + files={"file": ("pipeline.csv", BytesIO(b"stage,amount\nopen,10\nwon,25\n"), "text/csv")}, + ) + source_id = upload_response.json()["asset"]["id"] + analyze_response = client.post( + "/analyze", + json={"query": "Why did pipeline velocity drop this week?", "source_ids": [source_id]}, + ) finally: analysis_run.run_analysis = original @@ -194,3 +236,57 @@ def test_inspection_endpoint_returns_404_for_unknown_id(client: TestClient) -> N response = client.get("/inspections/inspect_missing") assert response.status_code == 404 assert response.json()["detail"]["message"] == "Inspection not found." + + +def test_analyze_endpoint_forwards_source_ids(client: TestClient) -> None: + captured: dict[str, object] = {} + + def fake_run_analysis(query: str, source_ids=None) -> dict: + captured["query"] = query + captured["source_ids"] = source_ids + return { + "analysis": "## Summary\nScoped analysis.\n", + "trace": [], + "executed_steps": [], + "errors": [], + } + + import app.services.analysis_run as analysis_run + + original = analysis_run.run_analysis + analysis_run.run_analysis = fake_run_analysis + try: + upload_response = client.post( + "/uploads", + files={"file": ("pipeline.csv", BytesIO(b"stage,amount\nopen,10\nwon,25\n"), "text/csv")}, + ) + source_id = upload_response.json()["asset"]["id"] + response = client.post("/analyze", json={"query": "Use this upload", "source_ids": [source_id]}) + finally: + analysis_run.run_analysis = original + + assert response.status_code == 200 + assert captured["query"] == "Use this upload" + assert captured["source_ids"] == [source_id] + + +def test_analyze_endpoint_requires_uploaded_source_before_run_analysis(client: TestClient) -> None: + import app.services.analysis_run as analysis_run + + called = False + original = analysis_run.run_analysis + + def fake_run_analysis(query: str, source_ids=None) -> dict: + nonlocal called + called = True + return {"analysis": "", "trace": [], "executed_steps": [], "errors": []} + + analysis_run.run_analysis = fake_run_analysis + try: + response = client.post("/analyze", json={"query": "Why did pipeline velocity drop this week?"}) + finally: + analysis_run.run_analysis = original + + assert response.status_code == 400 + assert response.json()["detail"]["message"] == "Upload and attach at least one CSV or JSON data source before running analysis." + assert called is False diff --git a/tests/test_source_registry.py b/tests/test_source_registry.py new file mode 100644 index 0000000..077915c --- /dev/null +++ b/tests/test_source_registry.py @@ -0,0 +1,85 @@ +"""Tests for the persistent source registry and registry-backed manifests.""" + +from __future__ import annotations + +from app.agent.planner import _schema_subset_for_question +from app.data.registry import create_source_link, get_schema_manifest, ingest_source +from app.data.semantic_model import get_semantic_context + + +def _relation_by_name(manifest: dict, relation_name: str) -> dict: + return next(relation for relation in manifest["relations"] if relation["name"] == relation_name) + + +def test_registry_manifest_includes_builtin_primary_relation() -> None: + manifest = get_schema_manifest() + + relation = _relation_by_name(manifest, "opportunities_enriched") + assert relation["source_id"] == "source_builtin_crm" + assert relation["is_primary"] is True + assert relation["source_name"] == "CRM Sales Opportunities" + + +def test_nested_json_upload_creates_primary_and_child_relations() -> None: + asset = ingest_source( + "orders.json", + b'[{"order_id":"o1","customer":{"name":"Ada"},"items":[{"sku":"A1","qty":2},{"sku":"B2","qty":1}]}]', + ) + + manifest = get_schema_manifest([asset.id]) + root = _relation_by_name(manifest, asset.primaryRelationName) + child = next(relation for relation in manifest["relations"] if relation["name"].startswith(f"{asset.primaryRelationName}__")) + + assert asset.relationCount == 2 + assert root["is_primary"] is True + assert any(column["name"] == "customer__name" and column["source_path"] == "customer.name" for column in root["columns"]) + assert child["parent_relation"] == asset.primaryRelationName + assert any(join["target_relation"] == asset.primaryRelationName for join in child["join_keys"]) + assert {column["name"] for column in child["columns"]} >= {"record_id", "parent_record_id", "ordinal", "sku", "qty"} + + +def test_unrelated_sources_do_not_auto_link_even_with_shared_column_names() -> None: + customers = ingest_source("customers.csv", b"customer_id,name\nc1,Ada\nc2,Ben\n") + orders = ingest_source("orders.csv", b"customer_id,amount\nc1,100\nc2,50\n") + + manifest = get_schema_manifest([customers.id, orders.id]) + customers_relation = _relation_by_name(manifest, customers.primaryRelationName) + orders_relation = _relation_by_name(manifest, orders.primaryRelationName) + + assert customers_relation["join_keys"] == [] + assert orders_relation["join_keys"] == [] + + +def test_explicit_source_links_appear_in_manifest() -> None: + customers = ingest_source("customers.csv", b"customer_id,name\nc1,Ada\nc2,Ben\n") + orders = ingest_source("orders.csv", b"customer_id,amount\nc1,100\nc2,50\n") + + create_source_link(customers.primaryRelationName, "customer_id", orders.primaryRelationName, "customer_id") + manifest = get_schema_manifest([customers.id, orders.id]) + customers_relation = _relation_by_name(manifest, customers.primaryRelationName) + orders_relation = _relation_by_name(manifest, orders.primaryRelationName) + + assert any(join["target_relation"] == orders.primaryRelationName and join["source_column"] == "customer_id" for join in customers_relation["join_keys"]) + assert any(join["target_relation"] == customers.primaryRelationName and join["source_column"] == "customer_id" for join in orders_relation["join_keys"]) + + +def test_semantic_context_scopes_to_selected_sources() -> None: + asset = ingest_source("inventory.csv", b"sku,stock\nA1,10\nB2,3\n") + + full_context = get_semantic_context().schema_manifest + scoped_context = get_semantic_context([asset.id]).schema_manifest + + assert any(relation["name"] == "opportunities_enriched" for relation in full_context["relations"]) + assert not any(relation["name"] == "opportunities_enriched" for relation in scoped_context["relations"]) + assert any(relation["name"] == asset.primaryRelationName for relation in scoped_context["relations"]) + + +def test_schema_subset_prefers_relevant_uploaded_primary_relation() -> None: + ingest_source("inventory.csv", b"sku,stock\nA1,10\nB2,3\n") + invoices = ingest_source("invoices.csv", b"invoice_id,invoice_amount,status\ni1,100,paid\ni2,250,due\n") + ingest_source("campaigns.csv", b"campaign,spend\nspring,1200\nsummer,950\n") + + manifest = get_schema_manifest() + subset = _schema_subset_for_question(manifest, "Which invoice amount is highest?") + + assert any(relation["name"] == invoices.primaryRelationName for relation in subset["relations"]) diff --git a/ui/src/api/chat.ts b/ui/src/api/chat.ts index 15daccf..bb8b7eb 100644 --- a/ui/src/api/chat.ts +++ b/ui/src/api/chat.ts @@ -9,6 +9,7 @@ import { requestWithAuth, ApiError } from "@/api/client"; import { cacheInspection } from "@/api/inspections"; import { conversationTitleFromPrompt, mapAnalyzeResponseToUi } from "@/api/mappers"; import type { + AnalyzeApiRequest, AnalyzeApiResponse, ApiChatTurnResponse, ApiConversationDetailResponse, @@ -143,10 +144,13 @@ export async function submitChatPrompt(payload: ChatRequest, accessToken: string } try { - const body: Record = { query: payload.prompt }; + const body: AnalyzeApiRequest & { conversation_id?: number } = { query: payload.prompt }; if (payload.conversationId && isBackendConversationId(payload.conversationId)) { body.conversation_id = Number.parseInt(payload.conversationId, 10); } + if (payload.attachmentIds?.length) { + body.source_ids = payload.attachmentIds; + } const raw = await requestWithAuth("/chat", accessToken, { method: "POST", @@ -177,6 +181,9 @@ export async function submitChatPrompt(payload: ChatRequest, accessToken: string fallback: false, }; } catch (error) { + if (error instanceof ApiError && error.status && error.status >= 400 && error.status < 500) { + throw error; + } if (!shouldFallbackToDemo) throw error; await sleep(850); diff --git a/ui/src/api/types.ts b/ui/src/api/types.ts index 282b910..78a6818 100644 --- a/ui/src/api/types.ts +++ b/ui/src/api/types.ts @@ -34,6 +34,7 @@ export interface InspectionResponse { /** Body for the server's stateless `POST /analyze` (debug only — the UI sends `POST /chat` instead). */ export interface AnalyzeApiRequest { query: string; + source_ids?: string[]; } export interface AnalyzeTraceEvent { diff --git a/ui/src/components/app/ChatInput.tsx b/ui/src/components/app/ChatInput.tsx index f8b113e..266d77c 100644 --- a/ui/src/components/app/ChatInput.tsx +++ b/ui/src/components/app/ChatInput.tsx @@ -122,7 +122,7 @@ export function ChatInput({ {isUploading ? : null} Attach file - CSV, TSV, SQL exports, or connected data sources + CSV, JSON, TSV, SQL exports, or connected data sources - CSV, JSON, TSV, SQL exports, or connected data sources + CSV or JSON only + + + {error ? : null} + + {uploads.length ? ( +
+ {uploads.map((asset) => ( + + ))} +
+ ) : ( + + )} + + ); +} diff --git a/ui/src/components/marketing/HowItWorks.tsx b/ui/src/components/marketing/HowItWorks.tsx index f1b5dc8..90a048e 100644 --- a/ui/src/components/marketing/HowItWorks.tsx +++ b/ui/src/components/marketing/HowItWorks.tsx @@ -10,7 +10,7 @@ const steps = [ { number: "02", title: "Connect or upload data", - description: "Point the workspace at a database or bring in CSV and TSV files for quick analysis.", + description: "Point the workspace at a database or bring in CSV and JSON files for quick analysis.", }, { number: "03", diff --git a/ui/src/data/mockUploads.ts b/ui/src/data/mockUploads.ts deleted file mode 100644 index 421feb4..0000000 --- a/ui/src/data/mockUploads.ts +++ /dev/null @@ -1,42 +0,0 @@ -import type { UploadedAsset } from "@/types/upload"; -import { bytesToSize, shortId } from "@/lib/utils"; - -export const seededUploads: UploadedAsset[] = [ - { - id: "upload_finance_q2", - name: "finance_forecast_q2.csv", - type: "CSV", - source: "Workspace upload", - sizeLabel: "2.4 MB", - uploadedAt: "2026-03-25T09:12:00.000Z", - status: "verified", - rows: 18240, - columns: 12, - summary: "Quarterly revenue, margin, and plan variance by region and product line.", - }, - { - id: "upload_product_health", - name: "product_health.tsv", - type: "TSV", - source: "Workspace upload", - sizeLabel: "864 KB", - uploadedAt: "2026-03-24T18:40:00.000Z", - status: "profiling", - rows: 6420, - columns: 8, - summary: "Engagement, retention, and activation metrics across product surfaces.", - }, -]; - -export function createUploadedAsset(file: File): UploadedAsset { - return { - id: shortId("upload"), - name: file.name, - type: file.name.split(".").pop()?.toUpperCase() ?? "FILE", - source: "Workspace upload", - sizeLabel: bytesToSize(file.size), - uploadedAt: new Date().toISOString(), - status: "uploaded", - summary: "Freshly uploaded dataset ready for profiling and analysis.", - }; -} diff --git a/ui/src/hooks/useUpload.test.tsx b/ui/src/hooks/useUpload.test.tsx index 9334a06..e0fb101 100644 --- a/ui/src/hooks/useUpload.test.tsx +++ b/ui/src/hooks/useUpload.test.tsx @@ -14,12 +14,12 @@ afterEach(() => { }); describe("useUpload", () => { - it("seeds demo uploads only in demo-only mode", async () => { + it("starts with an empty upload list in demo-only mode", async () => { const useUpload = await loadUseUpload("demo"); const { result } = renderHook(() => useUpload()); - expect(result.current.uploads.length).toBeGreaterThan(0); - expect(result.current.latestUploadMode).toBe("demo"); + expect(result.current.uploads).toHaveLength(0); + expect(result.current.latestUploadMode).toBeNull(); }); it("starts with an empty upload list outside demo-only mode", async () => { diff --git a/ui/src/hooks/useUpload.ts b/ui/src/hooks/useUpload.ts index dacd1eb..7d10216 100644 --- a/ui/src/hooks/useUpload.ts +++ b/ui/src/hooks/useUpload.ts @@ -1,16 +1,12 @@ import { useState } from "react"; import { uploadDataset } from "@/api/uploads"; -import { isDemoOnlyMode } from "@/config/env"; -import { seededUploads } from "@/data/mockUploads"; import type { UploadedAsset } from "@/types/upload"; export function useUpload() { - const [uploads, setUploads] = useState(() => (isDemoOnlyMode ? seededUploads : [])); + const [uploads, setUploads] = useState([]); const [isUploading, setIsUploading] = useState(false); const [error, setError] = useState(null); - const [latestUploadMode, setLatestUploadMode] = useState<"live" | "demo" | null>(() => - isDemoOnlyMode && seededUploads.length > 0 ? "demo" : null, - ); + const [latestUploadMode, setLatestUploadMode] = useState<"live" | "demo" | null>(null); const uploadFile = async (file: File) => { setIsUploading(true); diff --git a/ui/src/lib/constants.ts b/ui/src/lib/constants.ts index 50627ea..3796ff6 100644 --- a/ui/src/lib/constants.ts +++ b/ui/src/lib/constants.ts @@ -43,7 +43,7 @@ export const homepageFeatureCards = [ }, { title: "Data upload and profiling", - description: "Bring CSV, TSV, and database data into the workflow and see freshness, shape, and quality at a glance.", + description: "Bring CSV and JSON data into the workflow and see freshness, shape, and quality at a glance.", }, { title: "Execution transparency", diff --git a/ui/src/lib/uploads.ts b/ui/src/lib/uploads.ts new file mode 100644 index 0000000..9e9ccd6 --- /dev/null +++ b/ui/src/lib/uploads.ts @@ -0,0 +1,6 @@ +export const UPLOAD_ACCEPT = ".csv,.json,application/json,text/csv"; + +export function isSupportedUploadFile(file: Pick): boolean { + const normalized = file.name.trim().toLowerCase(); + return normalized.endsWith(".csv") || normalized.endsWith(".json"); +} diff --git a/ui/src/pages/AppPage.tsx b/ui/src/pages/AppPage.tsx index 386fa6a..dc936f5 100644 --- a/ui/src/pages/AppPage.tsx +++ b/ui/src/pages/AppPage.tsx @@ -5,7 +5,7 @@ import { ChatThread } from "@/components/app/ChatThread"; import { InspectionPanel } from "@/components/app/InspectionPanel"; import { InsightCard } from "@/components/app/InsightCard"; import { Sidebar } from "@/components/app/Sidebar"; -import { UploadCard } from "@/components/app/UploadCard"; +import { UploadsPanel } from "@/components/app/UploadsPanel"; import { StatusBadge } from "@/components/app/StatusBadge"; import { Button } from "@/components/shared/Button"; import { Card } from "@/components/shared/Card"; @@ -100,7 +100,7 @@ export function AppPage() { uiStore.setActiveSection(section); }; - const handleUpload = async (file: File) => { + const handleChatUpload = async (file: File) => { try { const asset = await uploadFile(file); setAttachments((current) => [asset, ...current].slice(0, 2)); @@ -110,6 +110,15 @@ export function AppPage() { } }; + const handleUploadsSectionUpload = async (file: File) => { + try { + await uploadFile(file); + handleSectionChange("uploads"); + } catch { + // Upload errors are surfaced through the hook state and UI. + } + }; + const handleSubmit = async () => { const success = await sendPrompt(draft, attachments); if (success) { @@ -150,7 +159,7 @@ export function AppPage() { setDraft(prompt); handleSectionChange("chats"); }} - onUpload={(file) => void handleUpload(file)} + onUpload={(file) => void handleChatUpload(file)} onRemoveAttachment={(assetId) => setAttachments((current) => current.filter((asset) => asset.id !== assetId))} attachments={attachments} isSubmitting={isSubmitting} @@ -160,21 +169,7 @@ export function AppPage() { ); const uploadsView = ( - - {uploadError ? : null} - {uploads.length ? ( -
- {uploads.map((asset) => ( - - ))} -
- ) : ( - - )} - + void handleUploadsSectionUpload(file)} /> ); const savedView = ( From 86c2a995941a8d2eb7aa8c6c538bddfd7245a8f3 Mon Sep 17 00:00:00 2001 From: Saransh Kumar Date: Sun, 5 Apr 2026 17:27:41 -0400 Subject: [PATCH 3/6] feat: auto-attach uploaded files in chat --- ui/src/hooks/useActiveUploads.test.tsx | 51 +++++++++++++++++++++++++ ui/src/hooks/useActiveUploads.ts | 52 ++++++++++++++++++++++++++ ui/src/pages/AppPage.tsx | 14 +++---- 3 files changed, 109 insertions(+), 8 deletions(-) create mode 100644 ui/src/hooks/useActiveUploads.test.tsx create mode 100644 ui/src/hooks/useActiveUploads.ts diff --git a/ui/src/hooks/useActiveUploads.test.tsx b/ui/src/hooks/useActiveUploads.test.tsx new file mode 100644 index 0000000..f6d2ff6 --- /dev/null +++ b/ui/src/hooks/useActiveUploads.test.tsx @@ -0,0 +1,51 @@ +import { renderHook, waitFor } from "@testing-library/react"; +import { act } from "react"; +import { describe, expect, it } from "vitest"; +import { useActiveUploads } from "@/hooks/useActiveUploads"; +import type { UploadedAsset } from "@/types/upload"; + +function createAsset(id: string, name: string): UploadedAsset { + return { + id, + name, + type: "CSV", + source: "Workspace upload", + sizeLabel: "1.0 KB", + uploadedAt: new Date().toISOString(), + status: "verified", + }; +} + +describe("useActiveUploads", () => { + it("defaults all visible uploads to active", () => { + const uploads = [createAsset("source_1", "orders.csv"), createAsset("source_2", "customers.csv")]; + const { result } = renderHook(({ items }) => useActiveUploads(items), { + initialProps: { items: uploads }, + }); + + expect(result.current.activeUploadIds).toEqual(["source_1", "source_2"]); + expect(result.current.activeUploads.map((asset) => asset.id)).toEqual(["source_1", "source_2"]); + }); + + it("keeps removals but auto-adds newly uploaded files", async () => { + const first = createAsset("source_1", "orders.csv"); + const second = createAsset("source_2", "customers.csv"); + const third = createAsset("source_3", "inventory.csv"); + const { result, rerender } = renderHook(({ items }) => useActiveUploads(items), { + initialProps: { items: [first, second] }, + }); + + act(() => { + result.current.removeActiveUpload("source_1"); + }); + + act(() => { + rerender({ items: [first, second, third] }); + }); + + await waitFor(() => { + expect(result.current.activeUploadIds).toEqual(["source_2", "source_3"]); + expect(result.current.activeUploads.map((asset) => asset.id)).toEqual(["source_2", "source_3"]); + }); + }); +}); diff --git a/ui/src/hooks/useActiveUploads.ts b/ui/src/hooks/useActiveUploads.ts new file mode 100644 index 0000000..bcb6306 --- /dev/null +++ b/ui/src/hooks/useActiveUploads.ts @@ -0,0 +1,52 @@ +import { useEffect, useMemo, useRef, useState } from "react"; +import type { UploadedAsset } from "@/types/upload"; + +function mergeActiveUploadIds( + currentIds: string[], + previousVisibleIds: string[], + uploads: UploadedAsset[], +): string[] { + const visibleIds = uploads.map((asset) => asset.id); + const next = currentIds.filter((id) => visibleIds.includes(id)); + const newIds = visibleIds.filter((id) => !previousVisibleIds.includes(id)); + + for (const id of newIds) { + if (!next.includes(id)) { + next.push(id); + } + } + + return next; +} + +export function useActiveUploads(uploads: UploadedAsset[]) { + const [activeUploadIds, setActiveUploadIds] = useState([]); + const previousVisibleIdsRef = useRef([]); + + useEffect(() => { + const previousVisibleIds = previousVisibleIdsRef.current; + setActiveUploadIds((current) => { + const next = mergeActiveUploadIds(current, previousVisibleIds, uploads); + if (next.length === current.length && next.every((id, index) => id === current[index])) { + return current; + } + return next; + }); + previousVisibleIdsRef.current = uploads.map((asset) => asset.id); + }, [uploads]); + + const activeUploads = useMemo( + () => uploads.filter((asset) => activeUploadIds.includes(asset.id)), + [activeUploadIds, uploads], + ); + + const removeActiveUpload = (assetId: string) => { + setActiveUploadIds((current) => current.filter((id) => id !== assetId)); + }; + + return { + activeUploadIds, + activeUploads, + removeActiveUpload, + }; +} diff --git a/ui/src/pages/AppPage.tsx b/ui/src/pages/AppPage.tsx index dc936f5..4c5c0cb 100644 --- a/ui/src/pages/AppPage.tsx +++ b/ui/src/pages/AppPage.tsx @@ -16,13 +16,13 @@ import { Spinner } from "@/components/shared/Spinner"; import { savedAnalyses } from "@/data/mockInsights"; import { env, isDemoOnlyMode } from "@/config/env"; import { useChat } from "@/hooks/useChat"; +import { useActiveUploads } from "@/hooks/useActiveUploads"; import { useInspectionPanel } from "@/hooks/useInspectionPanel"; import { useResponsiveSidebar } from "@/hooks/useResponsiveSidebar"; import { useUpload } from "@/hooks/useUpload"; import { AppLayout } from "@/layouts/AppLayout"; import { formatCompactNumber } from "@/lib/utils"; import { uiStore } from "@/store/uiStore"; -import type { UploadedAsset } from "@/types/upload"; type SidebarSection = "chats" | "uploads" | "saved" | "dashboards"; @@ -50,8 +50,8 @@ export function AppPage() { } = useChat(); const inspection = useInspectionPanel(); const [draft, setDraft] = useState(""); - const [attachments, setAttachments] = useState([]); const [activeSection, setActiveSection] = useState(() => uiStore.getActiveSection() as SidebarSection); + const { activeUploads, removeActiveUpload } = useActiveUploads(uploads); const currentTitle = useMemo(() => { if (activeSection === "uploads") return "Data uploads"; @@ -102,8 +102,7 @@ export function AppPage() { const handleChatUpload = async (file: File) => { try { - const asset = await uploadFile(file); - setAttachments((current) => [asset, ...current].slice(0, 2)); + await uploadFile(file); handleSectionChange("chats"); } catch { // Upload errors are surfaced through the hook state and UI. @@ -120,10 +119,9 @@ export function AppPage() { }; const handleSubmit = async () => { - const success = await sendPrompt(draft, attachments); + const success = await sendPrompt(draft, activeUploads); if (success) { setDraft(""); - setAttachments([]); } handleSectionChange("chats"); }; @@ -160,8 +158,8 @@ export function AppPage() { handleSectionChange("chats"); }} onUpload={(file) => void handleChatUpload(file)} - onRemoveAttachment={(assetId) => setAttachments((current) => current.filter((asset) => asset.id !== assetId))} - attachments={attachments} + onRemoveAttachment={removeActiveUpload} + attachments={activeUploads} isSubmitting={isSubmitting} isUploading={isUploading} /> From 0763ab80c6fcd399f6ed30a19cd37a76e409dd91 Mon Sep 17 00:00:00 2001 From: Saransh Kumar Date: Sun, 5 Apr 2026 17:47:09 -0400 Subject: [PATCH 4/6] feat: persist uploads per user --- app/api/chat_routes.py | 4 +- app/api/routes.py | 40 ++++++++-- app/config.py | 1 + app/data/registry.py | 48 ++++++++++-- app/main.py | 2 +- app/models/__init__.py | 3 +- app/models/upload.py | 44 +++++++++++ app/models/user.py | 6 ++ app/uploads/__init__.py | 1 + app/uploads/service.py | 133 ++++++++++++++++++++++++++++++++ app/uploads/storage.py | 34 ++++++++ tests/test_api.py | 107 +++++++++++++++++++++++-- tests/test_conversations.py | 42 +++++++++- ui/src/api/uploads.ts | 19 ++++- ui/src/hooks/useUpload.test.tsx | 91 +++++++++++++++++++--- ui/src/hooks/useUpload.ts | 41 +++++++++- 16 files changed, 572 insertions(+), 44 deletions(-) create mode 100644 app/models/upload.py create mode 100644 app/uploads/__init__.py create mode 100644 app/uploads/service.py create mode 100644 app/uploads/storage.py diff --git a/app/api/chat_routes.py b/app/api/chat_routes.py index 58df79d..5dfa109 100644 --- a/app/api/chat_routes.py +++ b/app/api/chat_routes.py @@ -15,7 +15,6 @@ from app.auth.deps import get_current_user from app.config import get_settings -from app.data.registry import get_upload_source_ids from app.db.session import get_db from app.models.conversation import Conversation, Message from app.models.user import User @@ -31,6 +30,7 @@ ) from app.services.analysis_run import run_stored_analysis from app.services.inspection_persistence import save_inspection_for_assistant_message +from app.uploads.service import get_authorized_source_ids from app.utils.logging import get_logger @@ -149,7 +149,7 @@ def chat_turn( requested_source_ids = list(dict.fromkeys(body.source_ids or [])) if requested_source_ids: - valid_source_ids = get_upload_source_ids(requested_source_ids) + valid_source_ids = get_authorized_source_ids(db, current_user, requested_source_ids) if len(valid_source_ids) != len(requested_source_ids): raise HTTPException( status_code=status.HTTP_400_BAD_REQUEST, diff --git a/app/api/routes.py b/app/api/routes.py index 8a421ff..04bbae0 100644 --- a/app/api/routes.py +++ b/app/api/routes.py @@ -5,16 +5,16 @@ from fastapi import APIRouter, Depends, File, HTTPException, UploadFile, status from sqlalchemy.orm import Session -from app.api.workspace import get_inspection, profile_upload -from app.auth.deps import get_current_user_optional +from app.api.workspace import get_inspection +from app.auth.deps import get_current_user, get_current_user_optional from app.config import get_settings from app.db.session import get_db from app.models.conversation import Conversation from app.models.inspection_snapshot import InspectionSnapshot from app.models.user import User -from app.schemas import AnalyzeRequest, AnalyzeResponse, HealthResponse, InspectionData, InspectionResponse, SampleQuestionsResponse, UploadResponse +from app.schemas import AnalyzeRequest, AnalyzeResponse, HealthResponse, InspectionData, InspectionResponse, SampleQuestionsResponse, UploadedAsset, UploadResponse from app.services.analysis_run import run_stored_analysis -from app.data.registry import get_upload_source_ids +from app.uploads.service import create_user_upload, get_authorized_source_ids, list_user_uploads from app.utils.constants import SAMPLE_QUESTIONS from app.utils.logging import get_logger @@ -38,13 +38,33 @@ def sample_questions() -> SampleQuestionsResponse: return SampleQuestionsResponse(questions=SAMPLE_QUESTIONS) +@router.get("/uploads", response_model=list[UploadedAsset]) +def list_uploads( + current_user: User = Depends(get_current_user), + db: Session = Depends(get_db), +) -> list[UploadedAsset]: + """Return uploads owned by the signed-in user.""" + + return list_user_uploads(db, current_user) + + @router.post("/uploads", response_model=UploadResponse) -async def upload_dataset(file: UploadFile = File(...)) -> UploadResponse: +async def upload_dataset( + file: UploadFile = File(...), + current_user: User = Depends(get_current_user), + db: Session = Depends(get_db), +) -> UploadResponse: """Accept a workspace upload and return a profiled asset summary.""" contents = await file.read() try: - asset = profile_upload(file.filename or "upload.csv", contents) + asset = create_user_upload( + db, + current_user, + filename=file.filename or "upload.csv", + content_type=file.content_type, + content=contents, + ) except ValueError as exc: raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail={"message": str(exc)}) from exc return UploadResponse(asset=asset, fallback=False) @@ -101,7 +121,11 @@ def inspection_details( "Response shape aligns with the analysis/trace/steps portion of `POST /chat`." ), ) -def analyze(request: AnalyzeRequest) -> AnalyzeResponse: +def analyze( + request: AnalyzeRequest, + current_user: User = Depends(get_current_user), + db: Session = Depends(get_db), +) -> AnalyzeResponse: """Run analytics without persistence (see OpenAPI ``description`` — prefer ``POST /chat`` for product flows).""" requested_source_ids = list(dict.fromkeys(request.source_ids or [])) @@ -111,7 +135,7 @@ def analyze(request: AnalyzeRequest) -> AnalyzeResponse: detail={"message": "Upload and attach at least one CSV or JSON data source before running analysis."}, ) - valid_source_ids = get_upload_source_ids(requested_source_ids) + valid_source_ids = get_authorized_source_ids(db, current_user, requested_source_ids) if len(valid_source_ids) != len(requested_source_ids): raise HTTPException( status_code=status.HTTP_400_BAD_REQUEST, diff --git a/app/config.py b/app/config.py index 4e975cd..52a683f 100644 --- a/app/config.py +++ b/app/config.py @@ -21,6 +21,7 @@ class Settings(BaseSettings): api_port: int = 8000 data_dir: Path = Field(default=BASE_DIR / "data") registry_path: Path = Field(default=BASE_DIR / "data" / "source_registry.duckdb") + upload_storage_dir: Path = Field(default=BASE_DIR / "data" / "uploads", alias="UPLOAD_STORAGE_DIR") crm_path: Path = Field(default=BASE_DIR / "data" / "crm.csv") subscriptions_path: Path = Field(default=BASE_DIR / "data" / "subscriptions.csv") crm_dataset_dir: Path = Field(default=BASE_DIR / "data" / "CRM+Sales+Opportunities") diff --git a/app/data/registry.py b/app/data/registry.py index 2d6ea6b..71d0e19 100644 --- a/app/data/registry.py +++ b/app/data/registry.py @@ -606,6 +606,7 @@ def _persist_source_package(conn: duckdb.DuckDBPyConnection, package: SourcePack primary = next(item for item in package.relations if item.relation.is_primary) row_count = primary.relation.row_count content_hash = sha256(package.raw_payload or b"").hexdigest() + raw_payload = None if package.source_kind == "upload" else package.raw_payload conn.execute(f'DELETE FROM {_SOURCES_TABLE} WHERE source_id = ?', [package.source_id]) conn.execute( f""" @@ -630,7 +631,7 @@ def _persist_source_package(conn: duckdb.DuckDBPyConnection, package: SourcePack len(package.relations), row_count, "verified", - package.raw_payload, + raw_payload, json.dumps(package.metadata), ], ) @@ -649,11 +650,11 @@ def _build_child_relation_name(primary_relation_name: str, path_segments: tuple[ return f"{primary_relation_name}__{suffix}" -def _ingest_csv_source(filename: str, content: bytes) -> SourcePackage: +def _ingest_csv_source(filename: str, content: bytes, source_id: str | None = None) -> SourcePackage: safe_name = Path(filename or "upload.csv").name frame = _ensure_record_id(_rename_system_columns(_read_uploaded_frame(safe_name, content))) frame = _coerce_frame_types(frame) - source_id = _short_id("source") + source_id = source_id or _short_id("source") source_slug = _slugify(Path(safe_name).stem) relation_name = _build_primary_relation_name(source_slug, source_id) column_paths = { @@ -690,7 +691,7 @@ def _ingest_csv_source(filename: str, content: bytes) -> SourcePackage: ) -def _ingest_json_source(filename: str, content: bytes) -> SourcePackage: +def _ingest_json_source(filename: str, content: bytes, source_id: str | None = None) -> SourcePackage: safe_name = Path(filename or "upload.json").name try: payload = json.loads(content.decode("utf-8")) @@ -706,7 +707,7 @@ def _ingest_json_source(filename: str, content: bytes) -> SourcePackage: else: raise ValueError("JSON uploads must contain a top-level object or an array of objects.") - source_id = _short_id("source") + source_id = source_id or _short_id("source") source_slug = _slugify(Path(safe_name).stem) primary_relation_name = _build_primary_relation_name(source_slug, source_id) @@ -892,15 +893,15 @@ def ensure_builtin_sources() -> None: """Backward-compatible no-op now that uploads are the only runtime data sources.""" -def ingest_source(filename: str, content: bytes) -> UploadedAsset: +def ingest_source(filename: str, content: bytes, *, source_id: str | None = None) -> UploadedAsset: """Persist a CSV/JSON upload into the registry and return its UI summary.""" safe_name = Path(filename or "upload.csv").name suffix = Path(safe_name).suffix.lower() if suffix == ".json": - package = _ingest_json_source(safe_name, content) + package = _ingest_json_source(safe_name, content, source_id=source_id) elif suffix == ".csv": - package = _ingest_csv_source(safe_name, content) + package = _ingest_csv_source(safe_name, content, source_id=source_id) else: raise ValueError("Only CSV and JSON uploads are currently supported.") conn = _connect_registry(read_only=False) @@ -914,6 +915,37 @@ def ingest_source(filename: str, content: bytes) -> UploadedAsset: return _build_uploaded_asset(package) +def delete_source(source_id: str) -> None: + """Remove one uploaded source and all of its relations from the registry.""" + + conn = _connect_registry(read_only=False) + try: + relation_names = [ + row[0] + for row in conn.execute( + f"SELECT relation_name FROM {_RELATIONS_TABLE} WHERE source_id = ?", + [source_id], + ).fetchall() + ] + conn.execute("BEGIN TRANSACTION") + try: + conn.execute(f"DELETE FROM {_COLUMNS_TABLE} WHERE source_id = ?", [source_id]) + conn.execute(f"DELETE FROM {_LINKS_TABLE} WHERE left_source_id = ? OR right_source_id = ?", [source_id, source_id]) + conn.execute(f"DELETE FROM {_RELATIONS_TABLE} WHERE source_id = ?", [source_id]) + conn.execute(f"DELETE FROM {_SOURCES_TABLE} WHERE source_id = ?", [source_id]) + for relation_name in relation_names: + conn.execute(f'DROP TABLE IF EXISTS "{relation_name}"') + conn.execute("COMMIT") + except Exception: + conn.execute("ROLLBACK") + raise + finally: + conn.close() + from app.data.semantic_model import clear_semantic_context_cache + + clear_semantic_context_cache() + + def create_source_link( left_relation_name: str, left_column: str, diff --git a/app/main.py b/app/main.py index 4085152..22616ba 100644 --- a/app/main.py +++ b/app/main.py @@ -24,7 +24,7 @@ async def lifespan(_app: FastAPI): from app.db.base import Base from app.db.session import get_engine - from app.models import Conversation, InspectionSnapshot, Message, User # noqa: F401 + from app.models import Conversation, InspectionSnapshot, Message, UploadRecord, User # noqa: F401 Base.metadata.create_all(bind=get_engine()) yield diff --git a/app/models/__init__.py b/app/models/__init__.py index 4649a41..580bf2c 100644 --- a/app/models/__init__.py +++ b/app/models/__init__.py @@ -2,6 +2,7 @@ from app.models.conversation import Conversation, Message from app.models.inspection_snapshot import InspectionSnapshot +from app.models.upload import UploadRecord from app.models.user import User -__all__ = ["Conversation", "InspectionSnapshot", "Message", "User"] +__all__ = ["Conversation", "InspectionSnapshot", "Message", "UploadRecord", "User"] diff --git a/app/models/upload.py b/app/models/upload.py new file mode 100644 index 0000000..3f16b6b --- /dev/null +++ b/app/models/upload.py @@ -0,0 +1,44 @@ +"""User-owned uploaded source metadata.""" + +from __future__ import annotations + +from datetime import datetime, timezone +from typing import TYPE_CHECKING + +from sqlalchemy import DateTime, ForeignKey, Integer, String +from sqlalchemy.orm import Mapped, mapped_column, relationship + +from app.db.base import Base + +if TYPE_CHECKING: + from app.models.user import User + + +def _utc_now() -> datetime: + return datetime.now(timezone.utc) + + +class UploadRecord(Base): + __tablename__ = "uploads" + + source_id: Mapped[str] = mapped_column(String(64), primary_key=True) + user_id: Mapped[int] = mapped_column(ForeignKey("users.id", ondelete="CASCADE"), index=True, nullable=False) + original_filename: Mapped[str] = mapped_column(String(512), nullable=False) + storage_path: Mapped[str] = mapped_column(String(1024), nullable=False) + content_type: Mapped[str] = mapped_column(String(255), nullable=False, default="application/octet-stream") + size_bytes: Mapped[int] = mapped_column(Integer, nullable=False) + content_hash: Mapped[str] = mapped_column(String(128), nullable=False) + status: Mapped[str] = mapped_column(String(32), nullable=False, default="verified") + rows: Mapped[int | None] = mapped_column(Integer, nullable=True) + columns: Mapped[int | None] = mapped_column(Integer, nullable=True) + relation_count: Mapped[int | None] = mapped_column(Integer, nullable=True) + primary_relation_name: Mapped[str | None] = mapped_column(String(255), nullable=True) + created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), default=_utc_now, nullable=False) + updated_at: Mapped[datetime] = mapped_column( + DateTime(timezone=True), + default=_utc_now, + onupdate=_utc_now, + nullable=False, + ) + + user: Mapped[User] = relationship("User", back_populates="uploads") diff --git a/app/models/user.py b/app/models/user.py index dcdd9df..48cea3f 100644 --- a/app/models/user.py +++ b/app/models/user.py @@ -12,6 +12,7 @@ if TYPE_CHECKING: from app.models.conversation import Conversation + from app.models.upload import UploadRecord def _utc_now() -> datetime: @@ -32,3 +33,8 @@ class User(Base): back_populates="user", cascade="all, delete-orphan", ) + uploads: Mapped[list[UploadRecord]] = relationship( + "UploadRecord", + back_populates="user", + cascade="all, delete-orphan", + ) diff --git a/app/uploads/__init__.py b/app/uploads/__init__.py new file mode 100644 index 0000000..dd275ba --- /dev/null +++ b/app/uploads/__init__.py @@ -0,0 +1 @@ +"""Upload persistence services.""" diff --git a/app/uploads/service.py b/app/uploads/service.py new file mode 100644 index 0000000..d092696 --- /dev/null +++ b/app/uploads/service.py @@ -0,0 +1,133 @@ +"""User-owned upload persistence and authorization helpers.""" + +from __future__ import annotations + +from datetime import timezone +from hashlib import sha256 +from pathlib import Path +from uuid import uuid4 + +from sqlalchemy import select +from sqlalchemy.orm import Session + +from app.data.registry import delete_source, ingest_source +from app.models.upload import UploadRecord +from app.models.user import User +from app.schemas import UploadedAsset +from app.uploads.storage import LocalUploadBlobStore + + +def _short_source_id() -> str: + return f"source_{uuid4().hex[:8]}" + + +def _to_uploaded_at(value) -> str: + if value.tzinfo is None: + value = value.replace(tzinfo=timezone.utc) + return value.astimezone(timezone.utc).replace(microsecond=0).isoformat().replace("+00:00", "Z") + + +def _asset_from_record(record: UploadRecord) -> UploadedAsset: + relation_count = record.relation_count or 0 + summary = None + if record.rows is not None and record.columns is not None: + summary = ( + f"Persisted {record.rows} rows across {record.columns} columns" + f" into {relation_count} relation{'s' if relation_count != 1 else ''}." + ) + if record.primary_relation_name: + summary = f"{summary} Primary relation: {record.primary_relation_name}." + + return UploadedAsset( + id=record.source_id, + name=record.original_filename, + type=Path(record.original_filename).suffix.lstrip(".").upper() or "FILE", + source="Workspace upload", + sizeLabel=_bytes_to_size(record.size_bytes), + uploadedAt=_to_uploaded_at(record.created_at), + status=record.status, # type: ignore[arg-type] + rows=record.rows, + columns=record.columns, + relationCount=record.relation_count, + primaryRelationName=record.primary_relation_name, + summary=summary, + ) + + +def _bytes_to_size(num_bytes: int) -> str: + if num_bytes < 1024: + return f"{num_bytes} B" + if num_bytes < 1024 * 1024: + return f"{num_bytes / 1024:.1f} KB" + if num_bytes < 1024 * 1024 * 1024: + return f"{num_bytes / (1024 * 1024):.1f} MB" + return f"{num_bytes / (1024 * 1024 * 1024):.1f} GB" + + +def list_user_uploads(db: Session, user: User) -> list[UploadedAsset]: + rows = db.execute( + select(UploadRecord) + .where(UploadRecord.user_id == user.id) + .order_by(UploadRecord.created_at.desc(), UploadRecord.source_id.desc()) + ).scalars() + return [_asset_from_record(row) for row in rows] + + +def get_authorized_source_ids(db: Session, user: User, source_ids: list[str] | None = None) -> list[str]: + unique_source_ids = list(dict.fromkeys(source_ids or [])) + if not unique_source_ids: + return [] + + owned_rows = db.execute( + select(UploadRecord.source_id) + .where(UploadRecord.user_id == user.id, UploadRecord.source_id.in_(unique_source_ids)) + ).scalars() + owned_ids = set(owned_rows) + return [source_id for source_id in unique_source_ids if source_id in owned_ids] + + +def create_user_upload( + db: Session, + user: User, + *, + filename: str, + content_type: str | None, + content: bytes, + blob_store: LocalUploadBlobStore | None = None, +) -> UploadedAsset: + store = blob_store or LocalUploadBlobStore() + source_id = _short_source_id() + storage_path = store.save(user_id=user.id, upload_id=source_id, filename=filename, content=content) + + try: + asset = ingest_source(filename, content, source_id=source_id) + except Exception: + store.delete(storage_path) + raise + + record = UploadRecord( + source_id=source_id, + user_id=user.id, + original_filename=filename, + storage_path=str(storage_path), + content_type=content_type or "application/octet-stream", + size_bytes=len(content), + content_hash=sha256(content).hexdigest(), + status=asset.status, + rows=asset.rows, + columns=asset.columns, + relation_count=asset.relationCount, + primary_relation_name=asset.primaryRelationName, + ) + db.add(record) + + try: + db.commit() + except Exception: + db.rollback() + delete_source(source_id) + store.delete(storage_path) + raise + + db.refresh(record) + return _asset_from_record(record) diff --git a/app/uploads/storage.py b/app/uploads/storage.py new file mode 100644 index 0000000..53adab3 --- /dev/null +++ b/app/uploads/storage.py @@ -0,0 +1,34 @@ +"""Blob storage for raw uploaded files.""" + +from __future__ import annotations + +from pathlib import Path + +from app.config import get_settings + + +class LocalUploadBlobStore: + """Persist raw uploads under a stable per-user filesystem path.""" + + def __init__(self, root: Path | None = None) -> None: + self.root = root or get_settings().upload_storage_dir + + def save(self, *, user_id: int, upload_id: str, filename: str, content: bytes) -> Path: + suffix = Path(filename).suffix.lower() + upload_dir = self.root / str(user_id) / upload_id + upload_dir.mkdir(parents=True, exist_ok=True) + path = upload_dir / f"original{suffix}" + path.write_bytes(content) + return path + + def delete(self, storage_path: str | Path) -> None: + path = Path(storage_path) + if path.exists(): + path.unlink() + current = path.parent + root = self.root.resolve() + while current.exists() and current != root: + if any(current.iterdir()): + break + current.rmdir() + current = current.parent diff --git a/tests/test_api.py b/tests/test_api.py index cabb6a4..0ce768d 100644 --- a/tests/test_api.py +++ b/tests/test_api.py @@ -16,6 +16,7 @@ def client(tmp_path, monkeypatch): monkeypatch.setenv("DATABASE_PATH", str(tmp_path / "api_test.sqlite")) monkeypatch.setenv("REGISTRY_PATH", str(tmp_path / "api_source_registry.duckdb")) + monkeypatch.setenv("UPLOAD_STORAGE_DIR", str(tmp_path / "uploads")) get_settings.cache_clear() reset_engine_and_session() with TestClient(app) as test_client: @@ -62,6 +63,12 @@ def test_sample_questions_endpoint(client: TestClient) -> None: assert len(payload["questions"]) >= 3 +def _signup(client: TestClient, email: str, password: str = "password123") -> str: + response = client.post("/auth/signup", json={"email": email, "password": password}) + assert response.status_code == 200, response.text + return response.json()["access_token"] + + def test_analyze_endpoint_structure(client: TestClient) -> None: def fake_run_analysis(query: str, source_ids=None) -> dict: # noqa: ARG001 return { @@ -96,12 +103,19 @@ def fake_run_analysis(query: str, source_ids=None) -> dict: # noqa: ARG001 original = analysis_run.run_analysis analysis_run.run_analysis = fake_run_analysis try: + token = _signup(client, "analyze-structure@example.com") + headers = {"Authorization": f"Bearer {token}"} upload_response = client.post( "/uploads", files={"file": ("pipeline.csv", BytesIO(b"stage,amount\nopen,10\nwon,25\n"), "text/csv")}, + headers=headers, ) source_id = upload_response.json()["asset"]["id"] - response = client.post("/analyze", json={"query": "Why did pipeline velocity drop this week?", "source_ids": [source_id]}) + response = client.post( + "/analyze", + json={"query": "Why did pipeline velocity drop this week?", "source_ids": [source_id]}, + headers=headers, + ) finally: analysis_run.run_analysis = original assert response.status_code == 200 @@ -122,12 +136,19 @@ def fake_run_analysis(query: str, source_ids=None) -> dict: # noqa: ARG001 original = analysis_run.run_analysis analysis_run.run_analysis = fake_run_analysis try: + token = _signup(client, "analyze-failure@example.com") + headers = {"Authorization": f"Bearer {token}"} upload_response = client.post( "/uploads", files={"file": ("pipeline.csv", BytesIO(b"stage,amount\nopen,10\nwon,25\n"), "text/csv")}, + headers=headers, ) source_id = upload_response.json()["asset"]["id"] - response = client.post("/analyze", json={"query": "Why did pipeline velocity drop this week?", "source_ids": [source_id]}) + response = client.post( + "/analyze", + json={"query": "Why did pipeline velocity drop this week?", "source_ids": [source_id]}, + headers=headers, + ) finally: analysis_run.run_analysis = original @@ -137,10 +158,21 @@ def fake_run_analysis(query: str, source_ids=None) -> dict: # noqa: ARG001 assert payload["detail"]["error"] == "planner exploded" -def test_upload_endpoint_profiles_csv(client: TestClient) -> None: +def test_upload_endpoint_requires_auth(client: TestClient) -> None: + response = client.post( + "/uploads", + files={"file": ("pipeline.csv", BytesIO(b"stage,amount\nopen,10\n"), "text/csv")}, + ) + + assert response.status_code == 401 + + +def test_upload_endpoint_profiles_csv(client: TestClient, tmp_path) -> None: + token = _signup(client, "upload-csv@example.com") response = client.post( "/uploads", files={"file": ("pipeline.csv", BytesIO(b"stage,amount\nopen,10\nwon,25\n"), "text/csv")}, + headers={"Authorization": f"Bearer {token}"}, ) assert response.status_code == 200 @@ -153,9 +185,15 @@ def test_upload_endpoint_profiles_csv(client: TestClient) -> None: assert payload["asset"]["status"] == "verified" assert payload["asset"]["relationCount"] == 1 assert payload["asset"]["primaryRelationName"] + assert any((tmp_path / "uploads").rglob("original.csv")) + + uploads_response = client.get("/uploads", headers={"Authorization": f"Bearer {token}"}) + assert uploads_response.status_code == 200 + assert [asset["id"] for asset in uploads_response.json()] == [payload["asset"]["id"]] def test_upload_endpoint_profiles_json(client: TestClient) -> None: + token = _signup(client, "upload-json@example.com") response = client.post( "/uploads", files={ @@ -167,6 +205,7 @@ def test_upload_endpoint_profiles_json(client: TestClient) -> None: "application/json", ) }, + headers={"Authorization": f"Bearer {token}"}, ) assert response.status_code == 200 @@ -178,9 +217,11 @@ def test_upload_endpoint_profiles_json(client: TestClient) -> None: def test_upload_endpoint_rejects_unsupported_file_types(client: TestClient) -> None: + token = _signup(client, "upload-unsupported@example.com") response = client.post( "/uploads", files={"file": ("pipeline.tsv", BytesIO(b"stage\tamount\nopen\t10\n"), "text/tab-separated-values")}, + headers={"Authorization": f"Bearer {token}"}, ) assert response.status_code == 400 @@ -220,14 +261,18 @@ def fake_run_analysis(query: str, source_ids=None) -> dict: # noqa: ARG001 original = analysis_run.run_analysis analysis_run.run_analysis = fake_run_analysis try: + token = _signup(client, "inspection@example.com") + headers = {"Authorization": f"Bearer {token}"} upload_response = client.post( "/uploads", files={"file": ("pipeline.csv", BytesIO(b"stage,amount\nopen,10\nwon,25\n"), "text/csv")}, + headers=headers, ) source_id = upload_response.json()["asset"]["id"] analyze_response = client.post( "/analyze", json={"query": "Why did pipeline velocity drop this week?", "source_ids": [source_id]}, + headers=headers, ) finally: analysis_run.run_analysis = original @@ -267,12 +312,15 @@ def fake_run_analysis(query: str, source_ids=None) -> dict: original = analysis_run.run_analysis analysis_run.run_analysis = fake_run_analysis try: + token = _signup(client, "analyze-forward@example.com") + headers = {"Authorization": f"Bearer {token}"} upload_response = client.post( "/uploads", files={"file": ("pipeline.csv", BytesIO(b"stage,amount\nopen,10\nwon,25\n"), "text/csv")}, + headers=headers, ) source_id = upload_response.json()["asset"]["id"] - response = client.post("/analyze", json={"query": "Use this upload", "source_ids": [source_id]}) + response = client.post("/analyze", json={"query": "Use this upload", "source_ids": [source_id]}, headers=headers) finally: analysis_run.run_analysis = original @@ -294,10 +342,59 @@ def fake_run_analysis(query: str, source_ids=None) -> dict: analysis_run.run_analysis = fake_run_analysis try: - response = client.post("/analyze", json={"query": "Why did pipeline velocity drop this week?"}) + token = _signup(client, "analyze-requires-upload@example.com") + response = client.post( + "/analyze", + json={"query": "Why did pipeline velocity drop this week?"}, + headers={"Authorization": f"Bearer {token}"}, + ) finally: analysis_run.run_analysis = original assert response.status_code == 400 assert response.json()["detail"]["message"] == "Upload and attach at least one CSV or JSON data source before running analysis." assert called is False + + +def test_uploads_and_analysis_are_scoped_to_the_signed_in_user(client: TestClient) -> None: + owner = _signup(client, "owner-uploads@example.com") + intruder = _signup(client, "intruder-uploads@example.com") + owner_headers = {"Authorization": f"Bearer {owner}"} + intruder_headers = {"Authorization": f"Bearer {intruder}"} + + upload_response = client.post( + "/uploads", + files={"file": ("pipeline.csv", BytesIO(b"stage,amount\nopen,10\nwon,25\n"), "text/csv")}, + headers=owner_headers, + ) + source_id = upload_response.json()["asset"]["id"] + + owner_list = client.get("/uploads", headers=owner_headers) + intruder_list = client.get("/uploads", headers=intruder_headers) + + assert [asset["id"] for asset in owner_list.json()] == [source_id] + assert intruder_list.json() == [] + + import app.services.analysis_run as analysis_run + + called = False + original = analysis_run.run_analysis + + def fake_run_analysis(query: str, source_ids=None) -> dict: + nonlocal called + called = True + return {"analysis": "", "trace": [], "executed_steps": [], "errors": []} + + analysis_run.run_analysis = fake_run_analysis + try: + forbidden = client.post( + "/analyze", + json={"query": "Use someone else's upload", "source_ids": [source_id]}, + headers=intruder_headers, + ) + finally: + analysis_run.run_analysis = original + + assert forbidden.status_code == 400 + assert forbidden.json()["detail"]["message"] == "Attach a valid uploaded data source before running analysis." + assert called is False diff --git a/tests/test_conversations.py b/tests/test_conversations.py index d731f9d..e1dfa7b 100644 --- a/tests/test_conversations.py +++ b/tests/test_conversations.py @@ -13,6 +13,8 @@ @pytest.fixture def chat_client(tmp_path, monkeypatch): monkeypatch.setenv("DATABASE_PATH", str(tmp_path / "chat_test.sqlite")) + monkeypatch.setenv("REGISTRY_PATH", str(tmp_path / "chat_source_registry.duckdb")) + monkeypatch.setenv("UPLOAD_STORAGE_DIR", str(tmp_path / "uploads")) get_settings.cache_clear() reset_engine_and_session() with TestClient(app) as client: @@ -27,7 +29,7 @@ def _signup(client: TestClient, email: str, password: str = "password123") -> st return r.json()["access_token"] -def _fake_analysis_state(query: str) -> dict: # noqa: ARG001 +def _fake_analysis_state(query: str, source_ids=None) -> dict: # noqa: ARG001 return { "analysis": "## Demo\nHello from fake analysis.\n", "trace": [{"step": "planner_compiled_node", "status": "completed", "details": {}}], @@ -228,3 +230,41 @@ def test_persisted_inspection_forbidden_for_other_user(chat_client: TestClient) forbidden = chat_client.get(f"/inspections/{inspection_id}", headers={"Authorization": f"Bearer {intruder}"}) assert forbidden.status_code == 403 + + +def test_chat_rejects_uploads_owned_by_another_user(chat_client: TestClient) -> None: + import app.services.analysis_run as analysis_run + + owner = _signup(chat_client, "owner-upload-chat@example.com") + intruder = _signup(chat_client, "intruder-upload-chat@example.com") + owner_headers = {"Authorization": f"Bearer {owner}"} + intruder_headers = {"Authorization": f"Bearer {intruder}"} + + upload_response = chat_client.post( + "/uploads", + headers=owner_headers, + files={"file": ("pipeline.csv", b"stage,amount\nopen,10\nwon,25\n", "text/csv")}, + ) + source_id = upload_response.json()["asset"]["id"] + + called = False + original = analysis_run.run_analysis + + def fake_run_analysis(query: str, source_ids=None) -> dict: + nonlocal called + called = True + return {"analysis": "", "trace": [], "executed_steps": [], "errors": []} + + analysis_run.run_analysis = fake_run_analysis + try: + response = chat_client.post( + "/chat", + headers=intruder_headers, + json={"query": "Use another user's upload", "source_ids": [source_id]}, + ) + finally: + analysis_run.run_analysis = original + + assert response.status_code == 400 + assert response.json()["detail"]["message"] == "Attach a valid uploaded data source before running analysis." + assert called is False diff --git a/ui/src/api/uploads.ts b/ui/src/api/uploads.ts index 0a213f5..7185b8f 100644 --- a/ui/src/api/uploads.ts +++ b/ui/src/api/uploads.ts @@ -1,16 +1,29 @@ -import { ApiError, request } from "@/api/client"; +import { ApiError, requestWithAuth } from "@/api/client"; import type { UploadResponse } from "@/api/types"; +import type { UploadedAsset } from "@/types/upload"; import { isSupportedUploadFile } from "@/lib/uploads"; -export async function uploadDataset(file: File): Promise { +export async function fetchUploads(accessToken: string | null): Promise { + if (!accessToken) { + throw new ApiError("Not authenticated."); + } + + return requestWithAuth("/uploads", accessToken); +} + + +export async function uploadDataset(file: File, accessToken: string | null): Promise { if (!isSupportedUploadFile(file)) { throw new ApiError("Only CSV and JSON files are supported."); } + if (!accessToken) { + throw new ApiError("Not authenticated."); + } const formData = new FormData(); formData.append("file", file); - const response = await request("/uploads", { + const response = await requestWithAuth("/uploads", accessToken, { method: "POST", body: formData, }); diff --git a/ui/src/hooks/useUpload.test.tsx b/ui/src/hooks/useUpload.test.tsx index e0fb101..6b30b38 100644 --- a/ui/src/hooks/useUpload.test.tsx +++ b/ui/src/hooks/useUpload.test.tsx @@ -1,32 +1,101 @@ -import { renderHook } from "@testing-library/react"; +import { act, renderHook, waitFor } from "@testing-library/react"; import { afterEach, describe, expect, it, vi } from "vitest"; +import type { UploadedAsset } from "@/types/upload"; -async function loadUseUpload(mode: "demo" | "hybrid" | "live") { +function createAsset(id: string, name: string): UploadedAsset { + return { + id, + name, + type: "CSV", + source: "Workspace upload", + sizeLabel: "1.0 KB", + uploadedAt: new Date().toISOString(), + status: "verified", + }; +} + +async function loadUseUpload(options?: { + isReady?: boolean; + isAuthenticated?: boolean; + token?: string | null; + fetchedUploads?: UploadedAsset[]; +}) { vi.resetModules(); - vi.stubEnv("VITE_API_FALLBACK_MODE", mode); + const fetchUploads = vi.fn().mockResolvedValue(options?.fetchedUploads ?? []); + const uploadDataset = vi.fn().mockResolvedValue({ + asset: createAsset("source_uploaded", "orders.csv"), + fallback: false, + }); + + vi.doMock("@/hooks/useAuth", () => ({ + useAuth: () => ({ + user: + options?.isAuthenticated === false + ? null + : { id: 1, email: "test@example.com", display_name: null, created_at: new Date().toISOString() }, + token: options?.token ?? "token_123", + isReady: options?.isReady ?? true, + isAuthenticated: options?.isAuthenticated ?? true, + login: vi.fn(), + signUp: vi.fn(), + logout: vi.fn(), + }), + })); + vi.doMock("@/api/uploads", () => ({ + fetchUploads, + uploadDataset, + })); + const module = await import("@/hooks/useUpload"); - return module.useUpload; + return { useUpload: module.useUpload, fetchUploads, uploadDataset }; } afterEach(() => { - vi.unstubAllEnvs(); vi.resetModules(); + vi.clearAllMocks(); }); describe("useUpload", () => { - it("starts with an empty upload list in demo-only mode", async () => { - const useUpload = await loadUseUpload("demo"); + it("stays empty when the user is not authenticated", async () => { + const { useUpload, fetchUploads } = await loadUseUpload({ isAuthenticated: false, token: null }); const { result } = renderHook(() => useUpload()); expect(result.current.uploads).toHaveLength(0); expect(result.current.latestUploadMode).toBeNull(); + expect(fetchUploads).not.toHaveBeenCalled(); }); - it("starts with an empty upload list outside demo-only mode", async () => { - const useUpload = await loadUseUpload("hybrid"); + it("hydrates uploads for the signed-in user", async () => { + const fetchedUploads = [createAsset("source_1", "orders.csv"), createAsset("source_2", "customers.csv")]; + const { useUpload, fetchUploads } = await loadUseUpload({ fetchedUploads }); const { result } = renderHook(() => useUpload()); - expect(result.current.uploads).toHaveLength(0); - expect(result.current.latestUploadMode).toBeNull(); + await waitFor(() => { + expect(result.current.uploads).toHaveLength(2); + }); + + expect(fetchUploads).toHaveBeenCalledWith("token_123"); + expect(result.current.latestUploadMode).toBe("live"); + }); + + it("prepends a newly uploaded file", async () => { + const fetchedUploads = [createAsset("source_existing", "customers.csv")]; + const uploadedAsset = createAsset("source_uploaded", "orders.csv"); + const { useUpload, uploadDataset } = await loadUseUpload({ fetchedUploads }); + uploadDataset.mockResolvedValue({ asset: uploadedAsset, fallback: false }); + + const { result } = renderHook(() => useUpload()); + + await waitFor(() => { + expect(result.current.uploads).toHaveLength(1); + }); + + await act(async () => { + await result.current.uploadFile(new File(["order_id\n1"], "orders.csv", { type: "text/csv" })); + }); + + expect(uploadDataset).toHaveBeenCalled(); + expect(result.current.uploads.map((asset) => asset.id)).toEqual(["source_uploaded", "source_existing"]); + expect(result.current.latestUploadMode).toBe("live"); }); }); diff --git a/ui/src/hooks/useUpload.ts b/ui/src/hooks/useUpload.ts index 7d10216..466a755 100644 --- a/ui/src/hooks/useUpload.ts +++ b/ui/src/hooks/useUpload.ts @@ -1,20 +1,53 @@ -import { useState } from "react"; -import { uploadDataset } from "@/api/uploads"; +import { useEffect, useState } from "react"; +import { fetchUploads, uploadDataset } from "@/api/uploads"; +import { useAuth } from "@/hooks/useAuth"; import type { UploadedAsset } from "@/types/upload"; export function useUpload() { + const { token, isReady, isAuthenticated } = useAuth(); const [uploads, setUploads] = useState([]); const [isUploading, setIsUploading] = useState(false); const [error, setError] = useState(null); const [latestUploadMode, setLatestUploadMode] = useState<"live" | "demo" | null>(null); + useEffect(() => { + if (!isReady) return; + + if (!isAuthenticated || !token) { + setUploads([]); + setLatestUploadMode(null); + setError(null); + return; + } + + let cancelled = false; + + const load = async () => { + setError(null); + try { + const nextUploads = await fetchUploads(token); + if (cancelled) return; + setUploads(nextUploads); + setLatestUploadMode(nextUploads.length > 0 ? "live" : null); + } catch (err) { + if (cancelled) return; + setError(err instanceof Error ? err.message : "Unable to load uploads."); + } + }; + + void load(); + return () => { + cancelled = true; + }; + }, [isAuthenticated, isReady, token]); + const uploadFile = async (file: File) => { setIsUploading(true); setError(null); try { - const response = await uploadDataset(file); - setUploads((current) => [response.asset, ...current]); + const response = await uploadDataset(file, token); + setUploads((current) => [response.asset, ...current.filter((asset) => asset.id !== response.asset.id)]); setLatestUploadMode(response.fallback ? "demo" : "live"); return response.asset; } catch (err) { From 7e2b4f4a8f057afe925c9b1551bb7a7f0c8fe983 Mon Sep 17 00:00:00 2001 From: Saransh Kumar Date: Sun, 5 Apr 2026 17:53:09 -0400 Subject: [PATCH 5/6] feat: add upload deletion and simplify sidebar --- app/api/routes.py | 22 +++++++-- app/uploads/service.py | 22 +++++++++ tests/test_api.py | 22 +++++++++ ui/src/api/uploads.ts | 11 +++++ ui/src/components/app/Sidebar.test.tsx | 46 +++++++++++++++++++ ui/src/components/app/Sidebar.tsx | 27 ----------- ui/src/components/app/UploadCard.tsx | 21 ++++++++- ui/src/components/app/UploadsPanel.test.tsx | 50 ++++++++++++++++++++- ui/src/components/app/UploadsPanel.tsx | 11 ++++- ui/src/hooks/useUpload.test.tsx | 21 ++++++++- ui/src/hooks/useUpload.ts | 27 ++++++++++- ui/src/pages/AppPage.tsx | 20 +++++++-- 12 files changed, 258 insertions(+), 42 deletions(-) create mode 100644 ui/src/components/app/Sidebar.test.tsx diff --git a/app/api/routes.py b/app/api/routes.py index 04bbae0..a3a450c 100644 --- a/app/api/routes.py +++ b/app/api/routes.py @@ -2,7 +2,7 @@ from __future__ import annotations -from fastapi import APIRouter, Depends, File, HTTPException, UploadFile, status +from fastapi import APIRouter, Depends, File, HTTPException, Response, UploadFile, status from sqlalchemy.orm import Session from app.api.workspace import get_inspection @@ -14,7 +14,7 @@ from app.models.user import User from app.schemas import AnalyzeRequest, AnalyzeResponse, HealthResponse, InspectionData, InspectionResponse, SampleQuestionsResponse, UploadedAsset, UploadResponse from app.services.analysis_run import run_stored_analysis -from app.uploads.service import create_user_upload, get_authorized_source_ids, list_user_uploads +from app.uploads.service import create_user_upload, delete_user_upload, get_authorized_source_ids, list_user_uploads from app.utils.constants import SAMPLE_QUESTIONS from app.utils.logging import get_logger @@ -70,6 +70,20 @@ async def upload_dataset( return UploadResponse(asset=asset, fallback=False) +@router.delete("/uploads/{source_id}", status_code=status.HTTP_204_NO_CONTENT) +def delete_upload( + source_id: str, + current_user: User = Depends(get_current_user), + db: Session = Depends(get_db), +) -> Response: + """Delete one upload owned by the signed-in user.""" + + deleted = delete_user_upload(db, current_user, source_id) + if not deleted: + raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail={"message": "Upload not found."}) + return Response(status_code=status.HTTP_204_NO_CONTENT) + + @router.get("/inspections/{inspection_id}", response_model=InspectionResponse) def inspection_details( inspection_id: str, @@ -115,7 +129,7 @@ def inspection_details( description=( "**Not the primary product API.** For normal use, authenticated clients should call " "`POST /chat`, which persists conversations, messages, and inspection snapshots.\n\n" - "This endpoint runs the same analytics pipeline without auth, without database persistence, " + "This endpoint runs the same analytics pipeline with auth but without conversation/database persistence, " "and keeps the inspection payload only in process memory (lost on restart). Use it for " "local debugging, Swagger/Postman checks, and quick stateless demos.\n\n" "Response shape aligns with the analysis/trace/steps portion of `POST /chat`." @@ -126,7 +140,7 @@ def analyze( current_user: User = Depends(get_current_user), db: Session = Depends(get_db), ) -> AnalyzeResponse: - """Run analytics without persistence (see OpenAPI ``description`` — prefer ``POST /chat`` for product flows).""" + """Run analytics with auth but without persistence (see OpenAPI ``description`` — prefer ``POST /chat``).""" requested_source_ids = list(dict.fromkeys(request.source_ids or [])) if not requested_source_ids: diff --git a/app/uploads/service.py b/app/uploads/service.py index d092696..7f6c91a 100644 --- a/app/uploads/service.py +++ b/app/uploads/service.py @@ -131,3 +131,25 @@ def create_user_upload( db.refresh(record) return _asset_from_record(record) + + +def delete_user_upload( + db: Session, + user: User, + source_id: str, + *, + blob_store: LocalUploadBlobStore | None = None, +) -> bool: + record = db.get(UploadRecord, source_id) + if record is None or record.user_id != user.id: + return False + + store = blob_store or LocalUploadBlobStore() + storage_path = record.storage_path + db.delete(record) + db.commit() + try: + delete_source(source_id) + finally: + store.delete(storage_path) + return True diff --git a/tests/test_api.py b/tests/test_api.py index 0ce768d..63499b1 100644 --- a/tests/test_api.py +++ b/tests/test_api.py @@ -398,3 +398,25 @@ def fake_run_analysis(query: str, source_ids=None) -> dict: assert forbidden.status_code == 400 assert forbidden.json()["detail"]["message"] == "Attach a valid uploaded data source before running analysis." assert called is False + + +def test_delete_upload_removes_file_and_listing(client: TestClient, tmp_path) -> None: + owner = _signup(client, "delete-owner@example.com") + intruder = _signup(client, "delete-intruder@example.com") + owner_headers = {"Authorization": f"Bearer {owner}"} + intruder_headers = {"Authorization": f"Bearer {intruder}"} + + upload_response = client.post( + "/uploads", + files={"file": ("orders.json", BytesIO(b'[{"order_id":"o1"}]'), "application/json")}, + headers=owner_headers, + ) + source_id = upload_response.json()["asset"]["id"] + + forbidden = client.delete(f"/uploads/{source_id}", headers=intruder_headers) + assert forbidden.status_code == 404 + + delete_response = client.delete(f"/uploads/{source_id}", headers=owner_headers) + assert delete_response.status_code == 204 + assert client.get("/uploads", headers=owner_headers).json() == [] + assert not any((tmp_path / "uploads").rglob("original.json")) diff --git a/ui/src/api/uploads.ts b/ui/src/api/uploads.ts index 7185b8f..d226595 100644 --- a/ui/src/api/uploads.ts +++ b/ui/src/api/uploads.ts @@ -29,3 +29,14 @@ export async function uploadDataset(file: File, accessToken: string | null): Pro }); return { ...response, fallback: false }; } + + +export async function deleteUpload(sourceId: string, accessToken: string | null): Promise { + if (!accessToken) { + throw new ApiError("Not authenticated."); + } + + await requestWithAuth(`/uploads/${sourceId}`, accessToken, { + method: "DELETE", + }); +} diff --git a/ui/src/components/app/Sidebar.test.tsx b/ui/src/components/app/Sidebar.test.tsx new file mode 100644 index 0000000..19363e5 --- /dev/null +++ b/ui/src/components/app/Sidebar.test.tsx @@ -0,0 +1,46 @@ +import { render, screen } from "@testing-library/react"; +import { MemoryRouter } from "react-router-dom"; +import { describe, expect, it, vi } from "vitest"; +import { Sidebar } from "@/components/app/Sidebar"; +import { AuthContext } from "@/context/auth-context"; + +describe("Sidebar", () => { + it("does not render a recent uploads section", () => { + render( + + + + + , + ); + + expect(screen.queryByText("Recent uploads")).not.toBeInTheDocument(); + }); +}); diff --git a/ui/src/components/app/Sidebar.tsx b/ui/src/components/app/Sidebar.tsx index ed01f7d..943e6f5 100644 --- a/ui/src/components/app/Sidebar.tsx +++ b/ui/src/components/app/Sidebar.tsx @@ -1,19 +1,16 @@ import { Link } from "react-router-dom"; import { Button } from "@/components/shared/Button"; import { Drawer } from "@/components/shared/Drawer"; -import { UploadCard } from "@/components/app/UploadCard"; import { useAuth } from "@/hooks/useAuth"; import { sidebarNavItems } from "@/lib/constants"; import { classNames } from "@/lib/classNames"; import { formatRelativeTime } from "@/lib/utils"; import type { Conversation } from "@/types/chat"; -import type { UploadedAsset } from "@/types/upload"; type SidebarSection = "chats" | "uploads" | "saved" | "dashboards"; interface SidebarProps { conversations: Conversation[]; - uploads: UploadedAsset[]; activeSection: SidebarSection; activeConversationId: string; collapsed: boolean; @@ -67,7 +64,6 @@ function BrandMark({ showExpandCue = false }: { showExpandCue?: boolean }) { function SidebarContent({ conversations, - uploads, activeSection, activeConversationId, collapsed, @@ -200,29 +196,6 @@ function SidebarContent({
)} - {!collapsed ? ( -
-
-

Recent uploads

- -
-
- {uploads.slice(0, 2).map((asset) => ( - - ))} -
-
- ) : null} - {!collapsed && user ?

{user.email}

: null}
- +
+ + {onDelete ? ( + + ) : null} +
{asset.summary ?

{asset.summary}

: null} {(asset.rows || asset.columns) && ( diff --git a/ui/src/components/app/UploadsPanel.test.tsx b/ui/src/components/app/UploadsPanel.test.tsx index 4a2dd6d..c699a95 100644 --- a/ui/src/components/app/UploadsPanel.test.tsx +++ b/ui/src/components/app/UploadsPanel.test.tsx @@ -8,7 +8,16 @@ afterEach(() => { describe("UploadsPanel", () => { it("renders a file picker restricted to csv and json", () => { - render(); + render( + , + ); expect(screen.getByRole("button", { name: "Upload file" })).toBeInTheDocument(); expect(screen.getByTestId("uploads-panel-file-input")).toHaveAttribute( @@ -19,7 +28,16 @@ describe("UploadsPanel", () => { it("forwards selected files to the upload callback", () => { const onUpload = vi.fn(); - render(); + render( + , + ); const input = screen.getByTestId("uploads-panel-file-input"); const file = new File(["order_id,total\n1,25"], "orders.csv", { type: "text/csv" }); @@ -28,4 +46,32 @@ describe("UploadsPanel", () => { expect(onUpload).toHaveBeenCalledWith(file); }); + + it("renders a delete action for each uploaded file", () => { + const onDelete = vi.fn(); + render( + , + ); + + fireEvent.click(screen.getByRole("button", { name: "Delete orders.json" })); + + expect(onDelete).toHaveBeenCalledWith("source_1"); + }); }); diff --git a/ui/src/components/app/UploadsPanel.tsx b/ui/src/components/app/UploadsPanel.tsx index 829ee78..35b3ab4 100644 --- a/ui/src/components/app/UploadsPanel.tsx +++ b/ui/src/components/app/UploadsPanel.tsx @@ -12,10 +12,12 @@ interface UploadsPanelProps { uploads: UploadedAsset[]; error: string | null; isUploading: boolean; + deletingUploadId: string | null; onUpload: (file: File) => void; + onDelete: (assetId: string) => void; } -export function UploadsPanel({ uploads, error, isUploading, onUpload }: UploadsPanelProps) { +export function UploadsPanel({ uploads, error, isUploading, deletingUploadId, onUpload, onDelete }: UploadsPanelProps) { const fileInputRef = useRef(null); return ( @@ -51,7 +53,12 @@ export function UploadsPanel({ uploads, error, isUploading, onUpload }: UploadsP {uploads.length ? (
{uploads.map((asset) => ( - + ))}
) : ( diff --git a/ui/src/hooks/useUpload.test.tsx b/ui/src/hooks/useUpload.test.tsx index 6b30b38..45e459f 100644 --- a/ui/src/hooks/useUpload.test.tsx +++ b/ui/src/hooks/useUpload.test.tsx @@ -26,6 +26,7 @@ async function loadUseUpload(options?: { asset: createAsset("source_uploaded", "orders.csv"), fallback: false, }); + const deleteUpload = vi.fn().mockResolvedValue(undefined); vi.doMock("@/hooks/useAuth", () => ({ useAuth: () => ({ @@ -44,10 +45,11 @@ async function loadUseUpload(options?: { vi.doMock("@/api/uploads", () => ({ fetchUploads, uploadDataset, + deleteUpload, })); const module = await import("@/hooks/useUpload"); - return { useUpload: module.useUpload, fetchUploads, uploadDataset }; + return { useUpload: module.useUpload, fetchUploads, uploadDataset, deleteUpload }; } afterEach(() => { @@ -98,4 +100,21 @@ describe("useUpload", () => { expect(result.current.uploads.map((asset) => asset.id)).toEqual(["source_uploaded", "source_existing"]); expect(result.current.latestUploadMode).toBe("live"); }); + + it("removes a deleted file from the upload list", async () => { + const fetchedUploads = [createAsset("source_existing", "customers.csv"), createAsset("source_delete", "orders.csv")]; + const { useUpload, deleteUpload } = await loadUseUpload({ fetchedUploads }); + const { result } = renderHook(() => useUpload()); + + await waitFor(() => { + expect(result.current.uploads).toHaveLength(2); + }); + + await act(async () => { + await result.current.deleteUpload("source_delete"); + }); + + expect(deleteUpload).toHaveBeenCalledWith("source_delete", "token_123"); + expect(result.current.uploads.map((asset) => asset.id)).toEqual(["source_existing"]); + }); }); diff --git a/ui/src/hooks/useUpload.ts b/ui/src/hooks/useUpload.ts index 466a755..bcdc2f5 100644 --- a/ui/src/hooks/useUpload.ts +++ b/ui/src/hooks/useUpload.ts @@ -1,5 +1,5 @@ import { useEffect, useState } from "react"; -import { fetchUploads, uploadDataset } from "@/api/uploads"; +import { deleteUpload as deleteUploadRequest, fetchUploads, uploadDataset } from "@/api/uploads"; import { useAuth } from "@/hooks/useAuth"; import type { UploadedAsset } from "@/types/upload"; @@ -7,6 +7,7 @@ export function useUpload() { const { token, isReady, isAuthenticated } = useAuth(); const [uploads, setUploads] = useState([]); const [isUploading, setIsUploading] = useState(false); + const [deletingUploadId, setDeletingUploadId] = useState(null); const [error, setError] = useState(null); const [latestUploadMode, setLatestUploadMode] = useState<"live" | "demo" | null>(null); @@ -59,11 +60,35 @@ export function useUpload() { } }; + const deleteUpload = async (sourceId: string) => { + setDeletingUploadId(sourceId); + setError(null); + + try { + await deleteUploadRequest(sourceId, token); + let remainingCount = 0; + setUploads((current) => { + const next = current.filter((asset) => asset.id !== sourceId); + remainingCount = next.length; + return next; + }); + setLatestUploadMode(remainingCount > 0 ? "live" : null); + } catch (err) { + const message = err instanceof Error ? err.message : "Unable to delete file."; + setError(message); + throw err; + } finally { + setDeletingUploadId(null); + } + }; + return { uploads, isUploading, + deletingUploadId, error, latestUploadMode, uploadFile, + deleteUpload, }; } diff --git a/ui/src/pages/AppPage.tsx b/ui/src/pages/AppPage.tsx index 4c5c0cb..8887d65 100644 --- a/ui/src/pages/AppPage.tsx +++ b/ui/src/pages/AppPage.tsx @@ -35,7 +35,15 @@ const dashboardMetrics = [ export function AppPage() { const { isMobile, collapsed, mobileOpen, closeMobileSidebar, toggleSidebar } = useResponsiveSidebar(); - const { uploads, isUploading, error: uploadError, latestUploadMode, uploadFile } = useUpload(); + const { + uploads, + isUploading, + deletingUploadId, + error: uploadError, + latestUploadMode, + uploadFile, + deleteUpload, + } = useUpload(); const { conversations, activeConversation, @@ -167,7 +175,14 @@ export function AppPage() { ); const uploadsView = ( - void handleUploadsSectionUpload(file)} /> + void handleUploadsSectionUpload(file)} + onDelete={(assetId) => void deleteUpload(assetId)} + /> ); const savedView = ( @@ -236,7 +251,6 @@ export function AppPage() { sidebar={ Date: Sun, 5 Apr 2026 19:10:36 -0400 Subject: [PATCH 6/6] fix issues with file uploads --- app/db/schema_compat.py | 144 ++++++++++++++++++++++++++++++++++++++++ app/main.py | 5 +- tests/test_api.py | 82 +++++++++++++++++++++++ 3 files changed, 230 insertions(+), 1 deletion(-) create mode 100644 app/db/schema_compat.py diff --git a/app/db/schema_compat.py b/app/db/schema_compat.py new file mode 100644 index 0000000..3a26c8f --- /dev/null +++ b/app/db/schema_compat.py @@ -0,0 +1,144 @@ +"""Small SQLite compatibility migrations for local development databases.""" + +from __future__ import annotations + +from sqlalchemy import inspect, text +from sqlalchemy.engine import Engine + +_UPLOADS_TABLE = "uploads" +_LEGACY_UPLOADS_TABLE = "uploads__legacy_schema_compat" +_EXPECTED_UPLOAD_COLUMNS = { + "source_id", + "user_id", + "original_filename", + "storage_path", + "content_type", + "size_bytes", + "content_hash", + "status", + "rows", + "columns", + "relation_count", + "primary_relation_name", + "created_at", + "updated_at", +} + + +def ensure_sqlite_schema_compatibility(engine: Engine) -> None: + """Upgrade legacy local SQLite tables that predate the current ORM shape.""" + + _migrate_uploads_table_if_needed(engine) + + +def _migrate_uploads_table_if_needed(engine: Engine) -> None: + inspector = inspect(engine) + if _UPLOADS_TABLE not in inspector.get_table_names(): + return + + columns = inspector.get_columns(_UPLOADS_TABLE) + column_names = {column["name"] for column in columns} + pk_columns = [column["name"] for column in columns if column.get("primary_key")] + if column_names == _EXPECTED_UPLOAD_COLUMNS and pk_columns == ["source_id"]: + return + + if _LEGACY_UPLOADS_TABLE in inspector.get_table_names(): + raise RuntimeError( + "Cannot migrate the uploads table because a previous temporary migration table still exists: " + f"{_LEGACY_UPLOADS_TABLE}." + ) + + select_sql = _build_upload_copy_select(column_names) + with engine.begin() as connection: + connection.execute(text(f"ALTER TABLE {_UPLOADS_TABLE} RENAME TO {_LEGACY_UPLOADS_TABLE}")) + connection.execute( + text( + f""" + CREATE TABLE {_UPLOADS_TABLE} ( + source_id VARCHAR(64) NOT NULL PRIMARY KEY, + user_id INTEGER NOT NULL, + original_filename VARCHAR(512) NOT NULL, + storage_path VARCHAR(1024) NOT NULL, + content_type VARCHAR(255) NOT NULL DEFAULT 'application/octet-stream', + size_bytes INTEGER NOT NULL, + content_hash VARCHAR(128) NOT NULL, + status VARCHAR(32) NOT NULL DEFAULT 'verified', + rows INTEGER, + columns INTEGER, + relation_count INTEGER, + primary_relation_name VARCHAR(255), + created_at DATETIME NOT NULL, + updated_at DATETIME NOT NULL, + FOREIGN KEY(user_id) REFERENCES users (id) ON DELETE CASCADE + ) + """ + ) + ) + connection.execute( + text( + f""" + INSERT INTO {_UPLOADS_TABLE} ( + source_id, + user_id, + original_filename, + storage_path, + content_type, + size_bytes, + content_hash, + status, + rows, + columns, + relation_count, + primary_relation_name, + created_at, + updated_at + ) + {select_sql} + """ + ) + ) + connection.execute(text(f"DROP TABLE {_LEGACY_UPLOADS_TABLE}")) + connection.execute(text("CREATE INDEX IF NOT EXISTS ix_uploads_user_id ON uploads (user_id)")) + + +def _build_upload_copy_select(column_names: set[str]) -> str: + def has_column(name: str) -> bool: + return name in column_names + + def quoted(name: str) -> str: + return f'"{name}"' + + def first_present(*names: str, default: str) -> str: + for name in names: + if has_column(name): + return quoted(name) + return default + + source_id_expr = first_present( + "source_id", + "upload_id", + default="('source_' || lower(hex(randomblob(4))))", + ) + content_type_expr = first_present("content_type", default="'application/octet-stream'") + status_expr = first_present("status", default="'verified'") + created_at_expr = first_present("created_at", default="CURRENT_TIMESTAMP") + updated_at_expr = first_present("updated_at", "created_at", default="CURRENT_TIMESTAMP") + + return f""" + SELECT + COALESCE(NULLIF({source_id_expr}, ''), 'source_' || lower(hex(randomblob(4)))) AS source_id, + {first_present("user_id", default='0')} AS user_id, + {first_present("original_filename", default="'upload.csv'")} AS original_filename, + {first_present("storage_path", default="''")} AS storage_path, + COALESCE({content_type_expr}, 'application/octet-stream') AS content_type, + {first_present("size_bytes", default='0')} AS size_bytes, + {first_present("content_hash", default="''")} AS content_hash, + COALESCE({status_expr}, 'verified') AS status, + {first_present("rows", default='NULL')} AS rows, + {first_present("columns", default='NULL')} AS columns, + {first_present("relation_count", default='NULL')} AS relation_count, + {first_present("primary_relation_name", default='NULL')} AS primary_relation_name, + COALESCE({created_at_expr}, CURRENT_TIMESTAMP) AS created_at, + COALESCE({updated_at_expr}, COALESCE({created_at_expr}, CURRENT_TIMESTAMP)) AS updated_at + FROM {_LEGACY_UPLOADS_TABLE} + """ diff --git a/app/main.py b/app/main.py index 22616ba..5f495b1 100644 --- a/app/main.py +++ b/app/main.py @@ -23,10 +23,13 @@ async def lifespan(_app: FastAPI): """Create database tables on startup (SQLite file demo; no Alembic in this phase).""" from app.db.base import Base + from app.db.schema_compat import ensure_sqlite_schema_compatibility from app.db.session import get_engine from app.models import Conversation, InspectionSnapshot, Message, UploadRecord, User # noqa: F401 - Base.metadata.create_all(bind=get_engine()) + engine = get_engine() + Base.metadata.create_all(bind=engine) + ensure_sqlite_schema_compatibility(engine) yield diff --git a/tests/test_api.py b/tests/test_api.py index 63499b1..fbb7da8 100644 --- a/tests/test_api.py +++ b/tests/test_api.py @@ -1,6 +1,7 @@ """API response structure tests.""" from io import BytesIO +import sqlite3 import pytest from fastapi.testclient import TestClient @@ -228,6 +229,87 @@ def test_upload_endpoint_rejects_unsupported_file_types(client: TestClient) -> N assert response.json()["detail"]["message"] == "Only CSV and JSON uploads are currently supported." +def test_upload_endpoint_migrates_legacy_uploads_table(tmp_path, monkeypatch) -> None: + db_path = tmp_path / "legacy_uploads.sqlite" + registry_path = tmp_path / "legacy_registry.duckdb" + upload_dir = tmp_path / "uploads" + + conn = sqlite3.connect(db_path) + conn.execute( + """ + CREATE TABLE uploads ( + id INTEGER NOT NULL PRIMARY KEY, + upload_id VARCHAR(64) NOT NULL, + user_id INTEGER NOT NULL, + source_id VARCHAR(64) NOT NULL, + original_filename VARCHAR(255) NOT NULL, + file_type VARCHAR(32) NOT NULL, + storage_path VARCHAR(1024) NOT NULL, + content_type VARCHAR(255), + size_bytes BIGINT NOT NULL, + content_hash VARCHAR(64) NOT NULL, + status VARCHAR(32) NOT NULL, + rows INTEGER, + columns INTEGER, + relation_count INTEGER, + primary_relation_name VARCHAR(255), + summary TEXT, + created_at DATETIME NOT NULL, + updated_at DATETIME NOT NULL + ) + """ + ) + conn.execute( + """ + INSERT INTO uploads ( + id, upload_id, user_id, source_id, original_filename, file_type, storage_path, content_type, + size_bytes, content_hash, status, rows, columns, relation_count, primary_relation_name, summary, + created_at, updated_at + ) VALUES ( + 1, 'legacy_upload_1', 999, 'legacy_source_1', 'legacy.csv', 'CSV', '/tmp/legacy.csv', 'text/csv', + 12, 'abc123', 'verified', 1, 2, 1, 'legacy_relation', 'legacy summary', + '2026-04-01 12:00:00', '2026-04-01 12:00:00' + ) + """ + ) + conn.commit() + conn.close() + + monkeypatch.setenv("DATABASE_PATH", str(db_path)) + monkeypatch.setenv("REGISTRY_PATH", str(registry_path)) + monkeypatch.setenv("UPLOAD_STORAGE_DIR", str(upload_dir)) + get_settings.cache_clear() + reset_engine_and_session() + + try: + with TestClient(app) as legacy_client: + token = _signup(legacy_client, "legacy-migration@example.com") + response = legacy_client.post( + "/uploads", + files={"file": ("pipeline.csv", BytesIO(b"stage,amount\nopen,10\n"), "text/csv")}, + headers={"Authorization": f"Bearer {token}"}, + ) + + assert response.status_code == 200, response.text + + uploads_response = legacy_client.get("/uploads", headers={"Authorization": f"Bearer {token}"}) + assert uploads_response.status_code == 200 + assert len(uploads_response.json()) == 1 + finally: + get_settings.cache_clear() + reset_engine_and_session() + + migrated_conn = sqlite3.connect(db_path) + columns = [row[1] for row in migrated_conn.execute("PRAGMA table_info(uploads)").fetchall()] + source_ids = [row[0] for row in migrated_conn.execute("SELECT source_id FROM uploads ORDER BY source_id").fetchall()] + migrated_conn.close() + + assert "upload_id" not in columns + assert "file_type" not in columns + assert "source_id" in columns + assert source_ids == ["legacy_source_1", uploads_response.json()[0]["id"]] + + def test_inspection_endpoint_returns_stored_inspection(client: TestClient) -> None: def fake_run_analysis(query: str, source_ids=None) -> dict: # noqa: ARG001 return {