Spaces:
Sleeping
Sleeping
| """ | |
| In-memory session store. Each browser session gets a UUID that acts as the | |
| key for all uploaded files, extracted features, and training results. | |
| No database needed — data is ephemeral and cleared after SESSION_TTL_SECS. | |
| """ | |
| import time | |
| import threading | |
| import uuid | |
| from dataclasses import dataclass, field | |
| from typing import Any | |
| from config import SESSION_TTL_SECS | |
| class Session: | |
| session_id: str | |
| created_at: float = field(default_factory=time.time) | |
| last_active: float = field(default_factory=time.time) | |
| # Step 2 — uploaded files | |
| uploaded_files: list[dict] = field(default_factory=list) # [{filename, filepath, class_label, flange_id, area_id}] | |
| lab_files: list[dict] = field(default_factory=list) # test files for CORAL | |
| # Step 3 — extracted hits (stored as list of float lists to avoid numpy pickling issues) | |
| hits: dict = field(default_factory=dict) # {waveforms, labels, flange_groups, area_groups} | |
| processing_stats: dict = field(default_factory=dict) | |
| # Step 4 — features | |
| features: dict = field(default_factory=dict) # {X_feat, feature_names, X_pca, pca_components} | |
| lab_features: dict = field(default_factory=dict) # features for lab test files | |
| # Step 5 — training results keyed by model name | |
| training_results: dict = field(default_factory=dict) # {"SVM": ModelResult, ...} | |
| training_tasks: dict = field(default_factory=dict) # task_id → model_name (for WebSocket routing) | |
| # Step 6 — ensemble | |
| ensemble_result: dict = field(default_factory=dict) | |
| # Step 7 / 8 — CORAL | |
| coral_result: dict = field(default_factory=dict) | |
| # Arbitrary scratch storage for any additional data | |
| extra: dict = field(default_factory=dict) | |
| def touch(self): | |
| self.last_active = time.time() | |
| def is_expired(self) -> bool: | |
| return (time.time() - self.last_active) > SESSION_TTL_SECS | |
| class SessionManager: | |
| """Thread-safe in-memory session store with automatic TTL cleanup.""" | |
| def __init__(self): | |
| self._store: dict[str, Session] = {} | |
| self._lock = threading.Lock() | |
| self._start_cleanup_thread() | |
| def create(self) -> Session: | |
| session_id = str(uuid.uuid4()) | |
| session = Session(session_id=session_id) | |
| with self._lock: | |
| self._store[session_id] = session | |
| return session | |
| def get(self, session_id: str) -> Session | None: | |
| with self._lock: | |
| s = self._store.get(session_id) | |
| if s and not s.is_expired(): | |
| s.touch() | |
| return s | |
| if s and s.is_expired(): | |
| del self._store[session_id] | |
| return None | |
| def require(self, session_id: str) -> Session: | |
| """Get session or raise ValueError (used in routes).""" | |
| s = self.get(session_id) | |
| if s is None: | |
| raise ValueError(f"Session '{session_id}' not found or expired.") | |
| return s | |
| def delete(self, session_id: str): | |
| with self._lock: | |
| self._store.pop(session_id, None) | |
| def count(self) -> int: | |
| with self._lock: | |
| return len(self._store) | |
| def _cleanup(self): | |
| while True: | |
| time.sleep(300) # check every 5 minutes | |
| with self._lock: | |
| expired = [sid for sid, s in self._store.items() if s.is_expired()] | |
| for sid in expired: | |
| del self._store[sid] | |
| def _start_cleanup_thread(self): | |
| t = threading.Thread(target=self._cleanup, daemon=True) | |
| t.start() | |
| # Singleton — imported everywhere | |
| session_manager = SessionManager() | |