File size: 4,576 Bytes
2379054
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
"""
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