flowmarg / core /state_manager.py
akash
Deploy to Hugging Face (source code only, no binary files)
2379054
Raw History Blame Contribute Delete
4.58 kB
"""
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