speclogician 0.0.0b1__py3-none-any.whl → 0.0.0.dev1__py3-none-any.whl

speclogician/state/state.py

@@ -1,418 +1,212 @@
 #
 #   Imandra Inc.
 #
-#   speclogician/state/state.py
+#   state.py
 #
 
 import os
 from pathlib import Path
-from pydantic import BaseModel, Field
-
-from ..modeling.spec_stats import refresh_spec_stats
-from ..logic import analyze_change
-from ..data.refs import DocRef, SrcCodeRef
-from ..data.traces import TestTrace, LogTrace
-from ..utils import console
-from .inst import StateInstance, InstancesList, calc_diff
-from .recommender import Recommender, Recommendation, ChangeFailure
-
-from .change import (
-    StateChange,
-    DomainModelBaseEdit,
-    PredicateAdd,
-    PredicateEdit,
-    PredicateRemove,
-    TransitionAdd,
-    TransitionEdit,
-    TransitionRemove,
-    ScenarioAdd,
-    ScenarioEdit,
-    ScenarioRemove,
-    AddTestTrace,
-    EditTestTrace,
-    AddLogTrace,
-    EditLogTrace,
-    RemoveTraceArtifact,
-    AddDocRef,
-    EditDocRef,
-    AddSrcCodeRef,
-    EditSrcCodeRef,
-    RemoveDataArtifact,
-    LinkArtifactsComponents,
-    RemoveArtComponentLink
-)
-from .change_result import (
-    ProcessChangeResult,
-    ProcessChangeError,
-    ProcessChangeSuccess,
-)
+from pydantic import BaseModel
 
-class State(BaseModel):
+from rich.table import Table, Column
+from rich.text import Text
+
+from speclogician.modeling.model import Model
+from speclogician.data.mapping import ArtifactMap
+from speclogician.data.container import ArtifactContainer
+from speclogician.state.change import ModelChange
+from speclogician.modeling.report import ArtifactReport
+from speclogician.utils import console
+
+
+
+class StateReport(BaseModel):
+    pass
+
+
+class StateInstance(BaseModel):
     """
-    SpecLogician state instance container
+    State Instance class
     """
-    file_location : str | None = Field(default=None)
-    instances : list[StateInstance] = [StateInstance()]
-    stash : list[StateInstance] = Field(default_factory=list[StateInstance]) # we'll use this to store discarded instances
 
-    def curr_state(self) -> StateInstance:
-        """  """
-        return self.instances[0]
+    state_idx : int
+    model : Model = Model() # Latest domain model
+    art_container : ArtifactContainer = ArtifactContainer() # This keeps us 
+    art_map : ArtifactMap = ArtifactMap() # Artifact map
 
-    def inst_list(self):
-        """ Return a InstancesList (for pretty printing) """
-        return InstancesList(states=self.instances)
-    
-    def process_change(
-        self,
-        change: StateChange,
-        json_only: bool = False,
-    ) -> ProcessChangeResult:
-        """
-        Apply a change and return a structured result.
+    changes : list[ModelChange] = []
 
-        - json_only=False: returns object payload for rich printing / internal callers.
-        - json_only=True : returns JSON-safe payload (summaries + json dumps).
+    def get_matched_stats (self) -> dict[str, int]:
+        """ 
+        State has the info about mappings from data artifacts to model components and vice versa.
+        We need to compute the stats here
         """
 
-        old_state: StateInstance = self.curr_state()
-
-        # Create a new candidate instance (deterministic snapshot + change list)
-        state_copy = old_state.model_copy(deep=True)
-        state_copy.update_created_at()
-        state_copy.changes = [change]
+        stats : dict[str, int] = {}
+        stats['scenarios_matched'] = 0
+        stats['predicates_matched'] = 0
+        stats['test_traces_matched'] = 0
+        stats['log_traces_matched'] = 0
+        stats['src_code_arts_matched'] = 0
+        stats['doc_arts_matched'] = 0
+ 
+        for s in self.model.scenarios:
+            if s.comp_id in self.art_map.comp_to_art_map:
+                stats['scenarios_matched'] += 1
+        
+        for p in self.model.domain_model.action_preds + self.model.domain_model.state_preds:
+            if p.comp_id in self.art_map.comp_to_art_map:
+                stats['predicates_matched'] += 1
+        
+        for tt in self.art_container.test_traces:
+            if tt.art_id in self.art_map.art_to_comp_map:
+                stats['test_traces_matched'] += 1
+        
+        for lt in self.art_container.log_traces:
+            if lt.art_id in self.art_map.art_to_comp_map:
+                stats['log_traces_matched'] += 1
+        
+        for sa in self.art_container.src_code:
+            if sa.art_id in self.art_map.art_to_comp_map:
+                stats['src_code_arts_matched'] += 1
 
-        # 1) Apply change to state
-        try:
-            new_state: StateInstance = self.run_change_command(state_copy, change)
-        except Exception as e:
-            # recommendations still useful on failure (triage)
-            failure = ChangeFailure(
-                change=change.__class__.__name__,
-                stage="apply_change",
-                error_type=type(e).__name__,
-                error=str(e),
-            )
-            # NOTE: no new_state exists; we recommend against old_state
-            recs = Recommender().recommend(old_state, old_state, failure=failure)
-
-            return ProcessChangeError(
-                ok=False,
-                stage="apply_change",
-                error=e,
-                change=change,
-                old_state=old_state,
-                # If your ProcessChangeError supports it, include recs:
-                # recommendations=recs,
-            )
+        for dr in self.art_container.doc_ref:
+            if dr.art_id in self.art_map.art_to_comp_map:
+                stats['doc_arts_matched'] += 1
+            
+        return stats
 
-        # 2) Perform logical analysis
-        try:
-            analyze_change(
-                spec=new_state.spec,
-                art_map=new_state.art_map,
-                art_cont=new_state.art_container,
-                change=change,
-                json_only=json_only,
-            )
-        except Exception as e:
-            failure = ChangeFailure(
-                change=change.__class__.__name__,
-                stage="analyze_change",
-                error_type=type(e).__name__,
-                error=str(e),
-            )
-            recs = Recommender().recommend(old_state, new_state, failure=failure)
-            # Optionally store on the candidate for debugging:
-            new_state.recommendations = recs
-
-            return ProcessChangeError(
-                ok=False,
-                stage="analyze_change",
-                error=e,
-                change=change,
-                old_state=old_state,
-                # If supported:
-                # new_state=new_state,
-                # recommendations=recs,
-            )
+    def summary(self) -> dict[str,int|str]:
+        """ Return a dict with various StateInstance statistics """
 
-        # 3) Update stats (should not crash the whole pipeline ideally, but keeping your behavior)
-        try:
-            new_state.art_container.refresh_stats(new_state.art_map)
-            refresh_spec_stats(new_state.spec, art_map=new_state.art_map)
-        except Exception as e:
-            failure = ChangeFailure(
-                change=change.__class__.__name__,
-                stage="refresh_stats",
-                error_type=type(e).__name__,
-                error=str(e),
-            )
-            recs = Recommender().recommend(old_state, new_state, failure=failure)
-            new_state.recommendations = recs
-
-            return ProcessChangeError(
-                ok=False,
-                stage="refresh_stats",
-                error=e,
-                change=change,
-                old_state=old_state,
-                # new_state=new_state,
-            )
 
-        # 4) Commit (newest at index 0)
-        self.instances.insert(0, new_state)
+        matched_stats = self.get_matched_stats()
 
-        # 5) Diff (old -> new), only if we actually have a previous instance
-        try:
-            if len(self.instances) >= 2:
-                # old = self.instances[1], new = self.instances[0]
-                self.instances[0].state_diff = calc_diff(self.instances[1], self.instances[0])
-            else:
-                self.instances[0].state_diff = None
-        except Exception as e:
-            failure = ChangeFailure(
-                change=change.__class__.__name__,
-                stage="calc_diff",
-                error_type=type(e).__name__,
-                error=str(e),
-            )
-            # We *do* have a committed new state now
-            recs = Recommender().recommend(old_state, self.instances[0], failure=failure)
-            self.instances[0].recommendations = recs
-
-            return ProcessChangeError(
-                ok=False,
-                stage="calc_diff",
-                error=e,
-                change=change,
-                old_state=old_state,
-                # new_state=self.instances[0],
-            )
+        s : dict[str, int|str] = {}
 
-        # 6) Compute recommendations (success path)
-        try:
-            # old is previous instance if it exists; otherwise old_state (same as new baseline)
-            prev = self.instances[1] if len(self.instances) >= 2 else self.instances[0]
-            self.instances[0].recommendations = Recommender().recommend(prev, self.instances[0])
-        except Exception as e:
-            # Recommender should never take down the CLI; but if it does, degrade gracefully.
-            self.instances[0].recommendations = [
-                Recommendation(
-                    text=f"Recommender failed: {type(e).__name__}: {e}",
-                    kind="warning",
-                    priority=5,
-                )
-            ]
-
-        # 7) Success
-        return ProcessChangeSuccess(
-            ok=True,
-            stage="ok",
-            change=change,
-            old_state=(self.instances[1] if len(self.instances) >= 2 else old_state),
-            new_state=self.instances[0],
-            state_diff=self.instances[0].state_diff,
-            new_num_instances=len(self.instances),
-            # If your success model includes it:
-            # recommendations=self.instances[0].recommendations,
-        )
-    
-    def run_change_command (
-            self,
-            s : StateInstance,
-            change : StateChange,
-        ) -> StateInstance:
-        """ 
-        Process change
-        """
+        s['idx'] = str(self.state_idx)
 
-        if isinstance (change, DomainModelBaseEdit):
-            s.spec.domain_model.set_base(change.new_base_src)
+        
+        s['changes'] = ",\n".join(map (lambda x: x.short_str(), self.changes))
+        
+        model_info = self.model.info()
 
-        elif isinstance (change, PredicateAdd):
-            if s.spec.domain_model.pred_exists(change.pred_name):
-                raise ValueError (f"Predicate with name {change.pred_name} already exists")            
+        s['domain_status'] = f"{model_info.domain_iml_status}"
 
-            s.spec.domain_model.add_predicate(change.pred_name, change.pred_type, change.pred_src)
+        # Predicates 
+        s['predicates'] = f"{model_info.preds_total} ({model_info.preds_errored}/45%; {matched_stats['predicates_matched']}/55%)"
 
-        elif isinstance (change, PredicateEdit):
-            if not s.spec.domain_model.pred_exists(change.pred_name):
-                raise ValueError (f"Predicate with name {change.pred_name} doesn't exist")
+        # Scenarios
+        s['scenarios'] = f"{model_info.scenarios_total} ({model_info.scenarios_errored}/45%; {matched_stats['scenarios_matched']}/55%)"
 
-            s.spec.domain_model.edit_predicate(change.pred_name, change.pred_src)
+        art_info = self.art_container.info()
 
-        elif isinstance (change, PredicateRemove):
-            if not s.spec.domain_model.pred_exists(change.pred_name):
-                raise ValueError (f"Predicate with name {change.pred_name} doesn't exist")
-            
-            s.spec.domain_model.rem_predicate(change.pred_name)
+        # Test traces
+        s['test_data'] = "250 (122/45%; 100/55%)"
+        s['log_data'] = "250 (122/45%; 100/55%)"
+        s['src_code_arts'] = "1200 (450/500%)"
+        s['doc_arts'] = "1200 (230/45%)"
 
-        elif isinstance (change, TransitionAdd):
-            if s.spec.domain_model.trans_exists(change.trans_name):
-                raise ValueError (f"Transition with this name {change.trans_name} already exists!")
+        return s
 
-            s.spec.domain_model.add_transition(name=change.trans_name, src_code=change.trans_src)
+    def short_summary(self):
+        """ """
+        return f'=> hello, again {1+1}'
 
-        elif isinstance (change, TransitionEdit):
-            if not s.spec.domain_model.trans_exists(change.trans_name):
-                raise ValueError (f"Transition with this name {change.trans_name} doesn't exist")
-            s.spec.domain_model.edit_transition(name=change.trans_name, src_code=change.trans_src)
+    def report(self) -> StateReport:
+        """
+        Generate a full report
+        """
 
-        elif isinstance (change, TransitionRemove):
-            if not s.spec.domain_model.trans_exists(change.trans_name):
-                raise ValueError (f"Transition with this name {change.trans_name} doesn't exist")
-            
-            s.spec.domain_model.rem_transition(change.trans_name)
+        model_report = self.model.report()
+        artifact_report = ArtifactReport()
 
-        elif isinstance(change, ScenarioAdd):
-            if s.spec.scenario_exists(change.scenario_name):
-                raise ValueError(f"Scenario with this name {change.scenario_name} already exists")
+        return StateReport (
+            model_report=model_report, 
+            artifact_report=artifact_report
+        )
 
-            s.spec.add_scenario(
-                change.scenario_name,
-                change.given,
-                change.when,
-                change.then,
-            )
+class InstancesList(BaseModel):
+    """
+    """
+    states : list[StateInstance]
 
-        elif isinstance (change, ScenarioEdit):
-            if not s.spec.scenario_exists(change.scenario_name):
-                raise ValueError (f"Scenario with the name '{change.scenario_name}' does not exist!")
-            
-            s.spec.edit_scenario(
-                change.scenario_name, 
-                change.given, 
-                change.when, change.then
-            )
+    def __rich__(self):
+        """ """
+        
+        columns = [
+            Column(header='State ID', justify="center")
+            , Column(header='Changes', justify="center")
+            , Column(header='Domain model', justify="center")
+            , Column(header='Preds\n # (Errors, Used)', justify="center")
+            , Column(header='Scenarios\n # (Errors, Used)', justify="center")
+            , Column(header='Test traces\n # (Formalized, Matched)', justify="center")
+            , Column(header='Log traces\n # (Formalized, Matched)', justify="center")
+            , Column(header='Src code arts\n # (Matched)', justify="center")
+            , Column(header='Doc arts\n # (Matched)', justify="center")
+        ]
+
+        t = Table (
+            *columns
+            , title="SpecLogician State List"
+            , expand = True
+            , highlight=True
+            #, padding=(0, 1) # Optional padding adjustments
+            , show_edge=False
+            #, show_lines=True
+        )
 
-        elif isinstance (change, ScenarioRemove):
-            if not s.spec.scenario_exists(change.scenario_name):
-                raise ValueError (f"Scenario with the name '{change.scenario_name}' does not exist!")
-
-            s.spec.rem_scenario(change.scenario_name)
-
-        # Test Traces
-
-        elif isinstance(change, AddTestTrace):
-            tr = TestTrace(
-                art_id=change.art_id,
-                # TraceArtifact core
-                given=change.given,
-                when=change.when,
-                then=change.then,
-                time=change.time,
-                # TestTrace specific
-                name=change.name,
-                filepath=change.filepath,
-                language=change.language,
-                contents=change.contents,
-            )
-            s.art_container.add_trace(tr)
-
-        elif isinstance(change, EditTestTrace):
-            # Use model_fields_set so passing None explicitly can clear fields.
-            patch: dict[str, object] = {}
-            for f in change.model_fields_set:
-                if f == "art_id":
-                    continue
-                patch[f] = getattr(change, f)
-            s.art_container.edit_trace(change.art_id, patch)
-
-        elif isinstance(change, AddLogTrace):
-            tr = LogTrace(
-                art_id=change.art_id,
-                # TraceArtifact core
-                given=change.given,
-                when=change.when,
-                then=change.then,
-                time=change.time,
-                # LogTrace specific
-                filename=change.filename,
-                contents=change.contents,
-            )
-            s.art_container.add_trace(tr)
-
-        elif isinstance(change, EditLogTrace):
-            patch: dict[str, object] = {}
-            for f in change.model_fields_set:
-                if f == "art_id":
-                    continue
-                patch[f] = getattr(change, f)
-            s.art_container.edit_trace(change.art_id, patch)
-
-        elif isinstance(change, RemoveTraceArtifact):
-            s.art_container.rem_trace(change.art_id)
-
-        # --- Data artifact changes (DocRef / SrcCodeRef) -----------------------------
-
-        elif isinstance(change, AddDocRef):
-            # Build DocRef and add via container API
-            s.art_container.add_data_art(
-                DocRef(
-                    art_id=change.art_id,
-                    text=change.text,
-                    meta=change.meta,
-                )
+        for s in self.states[::-1]:
+            ss = s.summary()
+            t.add_row(
+                Text(ss['idx']),
+                Text(ss['changes']),
+                Text(ss['domain_status']),
+                Text(ss['predicates']),
+                Text(ss['scenarios']),
+                Text(ss['test_data']),
+                Text(ss['log_data']),
+                Text(ss['src_code_arts']),
+                Text(ss['doc_arts'])
             )
+        return t
 
-        elif isinstance(change, EditDocRef):
-            # Patch-edit via container API (only update provided fields)
-            patch: dict[str, object] = {}
-            if change.text is not None:
-                patch["text"] = change.text
-            if change.meta is not None:
-                patch["meta"] = change.meta
-
-            if patch:
-                s.art_container.edit_data_art(change.art_id, patch)
-
-        elif isinstance(change, AddSrcCodeRef):
-            # Build SrcCodeRef and add via container API
-            s.art_container.add_data_art(
-                SrcCodeRef(
-                    art_id=change.art_id,
-                    src_code=change.src_code,
-                    language=change.language,
-                    file_path=change.file_path,
-                    iml_code=change.iml_code,
-                    meta=change.meta,
-                )
-            )
+class State(BaseModel):
+    """
+    TestLogician state (contains the various test formalizations)
+    """
 
-        elif isinstance(change, EditSrcCodeRef):
-            # Patch-edit via container API (only update provided fields)
-            patch: dict[str, object] = {}
-            if change.src_code is not None:
-                patch["src_code"] = change.src_code
-            if change.language is not None:
-                patch["language"] = change.language
-            if change.file_path is not None:
-                patch["file_path"] = change.file_path
-            if change.iml_code is not None:
-                patch["iml_code"] = change.iml_code
-            if change.meta is not None:
-                patch["meta"] = change.meta
+    instances : list[StateInstance] = []
+    curr_state_idx : int = -1
 
-            if patch:
-                s.art_container.edit_data_art(change.art_id, patch)
+    def set_curr_state_idx(self, new_idx:int) -> None:
+        """
+        Set the state instance cursor to `new_idx`
+        """
 
-        elif isinstance(change, RemoveDataArtifact):
-            s.art_container.rem_data_art(change.art_id)
+        self.curr_state_idx = new_idx
 
-        elif isinstance (change, LinkArtifactsComponents):
-            s.art_map.add_connection(art_id=change.art_id, comp_name=change.comp_name)
+    def curr_state(self) -> StateInstance:
+        return self.instances[self.curr_state_idx]
 
-        elif isinstance (change, RemoveArtComponentLink):
-            s.art_map.rem_connection(artifact_id=change.art_id, comp_name=change.comp_name)
+    def inst_list(self):
+        """ """
+        return InstancesList(states=self.instances)
 
-        else:
-            raise Exception(f"Unrecognized state change: {type(change).__name__}")
+    def process_change(
+            self,
+            change : ModelChange,
+            cut_new_instance : bool = True
+        ):
+        """ 
+        Process change
+        """
 
-        return s
+        self.curr_state().model.proc_change(change)
 
     def to_json(self):
-        """ """
+        """
+        """
         return self.model_dump_json()
 
     @staticmethod
@@ -422,44 +216,34 @@ class State(BaseModel):
         """
         return State.model_validate_json(j)
     
-    def save(self, dirpath : str | None | Path = None):
+    def save(self, dirpath:str):
         """
-        Save State to the specified directory
         """
-
-        if dirpath is None:
-            if self.file_location is None:
-                dirpath = os.getcwd()
-                filepath = os.path.join(dirpath, 'sl_state.json')
-                console.print(f"Saving the state in CWD: {dirpath}")
-            else:
-                filepath = self.file_location
-        else:
-            filepath = os.path.join(dirpath, 'sl_state.json')
-        
-        with open(filepath, 'w') as outfile:
+        with open(os.path.join(dirpath, 'sl_state.json'), 'w') as outfile:
             print(self.to_json(), file=outfile)
 
-    def save_to_path (self, path : Path) -> None:
-        """ Save State to a specific filepath """
-        try:
-            with open(path, 'w') as outfile:
-                print(self.to_json(), file=outfile)
-        except Exception as e:
-            raise ValueError(f"Failed to write state to disk [path = {path}]: {e}")
-
     @staticmethod
-    def from_dir (dirpath : str | Path):
-        """
-        Load State from specified directory
-        """
+    def from_dir (dirpath:str):
         try:
             state_path = os.path.join(dirpath, "sl_state.json")
             data = Path(state_path).read_text()
-            state = State.from_json(data)
-            state.file_location = state_path
-        except Exception as e:
-            console.print(f"Encountered error: {e}")
+            state = State.from_json(data)    
+        except:
             return None
         
         return state
+
+if __name__ == "__main__":
+
+    states = [
+        StateInstance(state_idx=1),
+        StateInstance(state_idx=2),
+        StateInstance(state_idx=3),
+        StateInstance(state_idx=4),
+        StateInstance(state_idx=5),
+        StateInstance(state_idx=6)
+    ]
+
+    il = InstancesList(states=states)
+
+    console.print(il.__rich__())

speclogician/tui/box.tcss

@@ -0,0 +1,10 @@
+Screen {
+    layout: grid;
+    grid-size: 2;
+    grid-columns: 1fr 2fr;
+}
+
+.box {
+    height: 100%;
+    border: solid green;
+}