""" State Manager - Clean project state management """ from dataclasses import dataclass, field from typing import Dict, Any, Optional, List from datetime import datetime import json import pandas as pd @dataclass class ProjectState: """Complete project state management""" project_name: str = "Unknown" version: int = 1 created_at: str = field(default_factory=lambda: datetime.now().isoformat()) updated_at: str = field(default_factory=lambda: datetime.now().isoformat()) # Track data chainages: List[float] = field(default_factory=list) track_names: Dict[int, str] = field(default_factory=dict) mapd: Dict[int, Dict] = field(default_factory=dict) # Engineering data calculations: Dict[int, Dict] = field(default_factory=dict) limits: Dict[str, float] = field(default_factory=dict) # QA data qa_findings: List[Dict] = field(default_factory=list) qa_summary: Dict = field(default_factory=dict) # Project info project_info: Dict[str, str] = field(default_factory=dict) # Standards standards_version: str = "NR/L2/TRK/2500" custom_standards: Dict = field(default_factory=dict) def update(self, **kwargs): """Update state with new values""" for key, value in kwargs.items(): if hasattr(self, key): setattr(self, key, value) self.updated_at = datetime.now().isoformat() self.version += 1 def get_calculation(self, track_no: int, parameter: str, chainage: float) -> Optional[float]: """Get a specific calculation value""" track_data = self.calculations.get(track_no, {}) return track_data.get(parameter, {}).get(chainage) def has_data(self) -> bool: """Check if state has data""" return bool(self.calculations) and bool(self.chainages) def to_dict(self) -> Dict: """Convert to dictionary for serialization""" return { "project_name": self.project_name, "version": self.version, "created_at": self.created_at, "updated_at": self.updated_at, "chainages": self.chainages, "track_names": self.track_names, "mapd": self.mapd, "calculations": self.calculations, "limits": self.limits, "qa_findings": self.qa_findings, "qa_summary": self.qa_summary, "project_info": self.project_info, "standards_version": self.standards_version, "custom_standards": self.custom_standards } @classmethod def from_dict(cls, data: Dict) -> 'ProjectState': """Create state from dictionary""" state = cls() for key, value in data.items(): if hasattr(state, key): setattr(state, key, value) return state def to_json(self) -> str: """Serialize to JSON""" return json.dumps(self.to_dict(), default=str) @classmethod def from_json(cls, json_str: str) -> 'ProjectState': """Deserialize from JSON""" data = json.loads(json_str) return cls.from_dict(data) @classmethod def from_session_state(cls, session_state) -> 'ProjectState': """ Build a ProjectState from a live Streamlit st.session_state (or any dict-like object with the same keys). This is the bridge that was previously missing: code such as mcp/prompts/project_chat.py used to call ProjectState() with no arguments, which always produced an empty, disconnected state regardless of what project was actually loaded in the running app. Usage (from within the Streamlit app, where st.session_state is real): state = ProjectState.from_session_state(st.session_state) """ state = cls() get = session_state.get if hasattr(session_state, "get") else lambda k, d=None: session_state[k] if k in session_state else d state.project_name = get("project_info", {}).get("project_name", "Unknown") if get("project_info") else "Unknown" state.version = get("version", 1) state.chainages = get("chainages", []) state.track_names = get("track_names", {}) state.mapd = get("mapd", {}) state.calculations = get("calculations", {}) state.limits = get("limits", {}) state.qa_findings = get("qa_findings", []) state.qa_summary = get("qa_summary", {}) state.project_info = get("project_info", {}) return state