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

speclogician/modeling/predicates.py

@@ -1,37 +1,34 @@
 #
 #   Imandra Inc.
 #
-#   speclogician/modeling/predicates.py
+#   predicates.py
 #
 
-from typing import Literal
-from enum import StrEnum
 
-from .component import SrcComponent
+from .component import ModelComponent
 
-class PredicateType(StrEnum):
-    STATE = "state"
-    ACTION = "action"
-
-class StatePredicate(SrcComponent):
+class StatePredicate(ModelComponent):
     """
-    Predicate on the state only
     """
-    kind: Literal["state_predicate"] = "state_predicate"
+    name : str # name of the predicate
+    body : str # actual implementation
 
     def __str__ (self):
-        """ """
+        """
+        """
         return f"{self.name} s"
 
     def to_iml (self):
-        """ Return the IML representation of the StatePredicate  """
-        return f"let {self.name} (s : state) : bool = \n {self.src_code}\n"
+        """
+        """
+        return f"let {self.name} (s : state) : bool = \n {self.body}\n"
 
-class ActionPredicate(SrcComponent):
+class ActionPredicate(ModelComponent):
     """
     Predicate involving a state and an action
     """
-    kind: Literal["action_predicate"] = "action_predicate"
+    name : str # name of the predicate
+    body : str # body
 
     def __str__(self):
         """
@@ -40,20 +37,21 @@ class ActionPredicate(SrcComponent):
 
     def to_iml(self):
         """
-        Return the IML representation of the ActionPredicate
+        Convert to IML here
         """
-        return f"let {self.name} (s : state) (a : action) : bool = \n {self.src_code}\n"
+        return f"let {self.name} (s : state) (a : action) : bool = \n {self.body}\n"
 
-class Transition(SrcComponent):
+class Transition(ModelComponent):
     """
     Transition functions are used to update the state
     """
-    kind: Literal["transition"] = "transition"
+    name : str # Name of the transition function
+    body : str # Name of the 
+
     def __str__ (self):
         return f"{self.name} s a"
 
     def to_iml (self):
         """
-        Return the IML representation of the transition
         """
-        return f"let {self.name} (s : state) (a : action) : state = \n {self.src_code}"
+        return f"let {self.name} (s : state) (a : action) : state = \n {self.body}"

speclogician/modeling/report.py

@@ -0,0 +1,33 @@
+#
+#   Imandra Inc.
+#
+#   report.py
+#
+
+from pydantic import BaseModel
+
+class DomainModelReport(BaseModel):
+    """
+    Domain model report
+    """
+    pass
+
+class ScenarioReport(BaseModel):
+    """
+    Scenario report
+    """
+
+    num_scenarios : int
+    num_failed : int
+    num_conflicted : int
+
+class ModelReport(BaseModel):
+    """
+    """
+    dmodel_report : DomainModelReport
+    scenario_report : ScenarioReport
+
+class ArtifactReport(BaseModel):
+    """
+    """
+    pass

speclogician/modeling/scenario.py

@@ -1,93 +1,40 @@
 #
 #   Imandra Inc.
 #
-#   speclogician/modeling/scenario.py
+#   scenario.py
 #
 
-from __future__ import annotations
-
-from typing import TypeAlias, Sequence
-from pydantic import BaseModel, Field, field_validator, model_validator
-
-from .component import ModelComponent, validate_iml_identifier
-
-
-class ScenarioDelta(BaseModel):
-    """We'll use this to edit Scenarios."""
-    add: list[str] = Field(default_factory=list)
-    remove: list[str] = Field(default_factory=list)
-
-    @field_validator("add", "remove")
-    @classmethod
-    def _dedup_and_strip(cls, xs: list[str]) -> list[str]:
-        # normalize, drop empties, dedup preserving order
-        out: list[str] = []
-        seen: set[str] = set()
-        for x in xs:
-            x = x.strip()
-            if not x or x in seen:
-                continue
-            out.append(x)
-            seen.add(x)
-        return out
-
-    @field_validator("add", "remove")
-    @classmethod
-    def _validate_identifiers(cls, xs: list[str]) -> list[str]:
-        # Reuse the canonical IML identifier validation
-        for x in xs:
-            validate_iml_identifier(x)
-        return xs
-
-    @model_validator(mode="after")
-    def _no_overlap(self) -> "ScenarioDelta":
-        overlap = set(self.add) & set(self.remove)
-        if overlap:
-            raise ValueError(f"Names cannot be both added and removed: {sorted(overlap)}")
-        return self
-
-    def is_empty(self) -> bool:
-        return not self.add and not self.remove
-
-    def is_add_only(self) -> bool:
-        return not self.remove
-
-class Valid(BaseModel):
-    """ The scenario's valid """
-    pass
-
-class Inconsistent(BaseModel):
-    """ Scenario is inconsistent - the combination of predicates is unsatisfiable """
-    pass
-
-class Missing(BaseModel):
-    """ Referenced model components are missing """
-    missing_preds : list[str] = Field(default_factory=list)
-    missing_trans : list[str] = Field(default_factory=list)
-
-ComponentStatus : TypeAlias = Valid | Inconsistent | Missing
+from rich.table import Table
+from rich.syntax import Syntax
+
+from pydantic import BaseModel
+from .component import ModelComponent
+from .predicates import (
+    StatePredicate, 
+    ActionPredicate,
+    Transition
+)
+from .domain import DomainModel
+from ..utils.imx import check_instance
+
 
 class Scenario(ModelComponent):
     """ 
-    Scenario contains 
+    Concrete clauses are direct translations of the test cases 
     """
-
     name : str
 
-    # Predicates and transition functions are components
-    component_status : ComponentStatus = Valid()
-
-    given: Sequence[str] = Field(default_factory=list)
-    when: Sequence[str] = Field(default_factory=list)
-    then: Sequence[str] = Field(default_factory=list)
-
+    given : list[str]
+    when : list[str]
+    then : list[str]
 
     # When we check the DomainModel and this is missing, 
     # we'll then set these fields
-    preds_missing : list[str] = Field(default_factory=list)
-    trans_missing : list[str] = Field(default_factory=list)
+    preds_missing : list[str] = []
+    trans_missing : list[str] = []
 
     # These contain consistency checks
+    # TODO we'll expand these later with details on
     # why precisely they're inconsistent
     given_preds_consistent : bool = True
     when_preds_consistent : bool = True
@@ -102,22 +49,90 @@ class Scenario(ModelComponent):
         when_str = "\n&& ".join(map(lambda x: f"{x} s a", self.when))
 
         match (len(self.given), len(self.when)):
-            case (0, 0):
-                return ""
-            case (_, 0):
-                return given_str
-            case (0, _):
-                return when_str
-            case (_, _):
-                return f"{given_str} \n&& {when_str}"
+            case (0, 0): return ""
+            case (_, 0): return given_str
+            case (0, _): return when_str
+            case (_, _): return f"{given_str} \n&& {when_str}"
+
+    def check_state_preds (self, model:DomainModel) -> bool:
+        """
+        Check that the state predicates are consistent (i.e. there's an instance)
+        """
+
+        state_preds_str = "\n&& ".join(map(lambda x: f"{x} s", self.given))
+
+        instance_query = f"""
+let pred_check (s : state) = 
+{state_preds_str}
+
+instance(pred_check)
+"""
+        print (instance_query)
+
+        return check_instance(model.to_iml(), instance_query)
+    
+    def check_action_preds (self, model:DomainModel) -> bool:
+        """
+        Check that the action predicates are consistent (i.e. there's an instance that satisfies them)
+        """
+
+        if len(self.when) == 0: return True
+
+        action_preds_str = "\n&& ".join(map(lambda x: f"{x} s a", self.when))
+
+        instance_query = f"""
+let pred_check (s : state) (a : action) =
+{action_preds_str}
+
+instance(pred_check)
+"""
+        print (instance_query)
+
+        return check_instance(model.to_iml(), instance_query)
+
+    def check_all_preds(self, model:DomainModel) -> bool:
+        """
+        Will return True if there's an instance for all the 
+        """
+
+        if len(self.when) == 0 and len(self.given) == 0:
+            return True
+        
+        instance_query = f"""
+
+let pred_check (s : state) (a : action) =
+{self.pred_calls_to_iml()} 
+
+instance(pred_check)
+"""
+
+        return check_instance(model.to_iml(), instance_query)
+
+    def check_preds (self, model:DomainModel):
+        """ 
+        Check the predicates and update their status
+        """
+
+        self.preds_missing = []
+        for p in self.given + self.when:
+            if not model.pred_exists(p):
+                self.preds_missing.append(p)
+
+        self.trans_missing = []
+        for t in self.then:
+            if not model.trans_exists(t):
+                self.trans_missing.append(t)
+
+        self.given_preds_consistent = self.check_state_preds(model)
+        self.when_preds_consistent = self.check_action_preds(model)
+        self.all_preds_consistent = self.check_all_preds(model)
 
     def eval_transition (self, state_val:str, act_val:str) -> str:
         """
         Given concrete state and action values, evaluate the set of transitions
         """
 
-        if len(self.then) == 0:
-            return state_val
+        if len(self.then) == 0: return state_val
 
         trans_iml = ""
         for t in self.then:
@@ -139,12 +154,12 @@ class Scenario(ModelComponent):
 
 {when_str}
 """     
+
         return s
 
     def full_model_to_iml(self):
         """
-        Create the full model (we omit the 'else' at the end because this is intended to be used with 
-        other scenarios
+        Create the full model
         """
         given_str = "&& \n".join(map(str, self.given))
         when_str = "&& \n".join(map(str, self.when))
@@ -159,4 +174,21 @@ in let when_true =
 in if given_true && when_true then
 ({then_str})
 """
-        return s
+        return s
+    
+    def __rich__ (self):
+        table = Table("Attribute", "Value", show_lines=True)
+
+        table.add_row("Name", self.name)
+
+        table.add_row("Given predicates", Syntax("\n".join(self.given), 'OCaml'))
+        table.add_row("When predicates", Syntax("\n".join(self.when), 'OCaml'))
+        table.add_row("Then transitions", Syntax("\n".join(self.then), 'OCaml'))
+
+        return table
+
+class FormalizationReponse(BaseModel):
+    """ """
+    test_name_str : str
+    scenarios : list[Scenario]
+    domain_model : str

speclogician/sl_cmd.py

@@ -0,0 +1,76 @@
+#
+#   Imandra Inc.
+#
+#   sl_cmd.py
+#
+
+from cmd2 import Cmd
+
+class SpecLogicianCmdApp(Cmd):
+    """
+    """
+
+    def __init__ (self):
+        """
+        """
+        Cmd.__init__(self, include_py=True)
+   
+        pass
+
+    def do_data_view(self):
+        """
+        """
+        pass
+
+    def do_data_tests(self):
+        """ """
+        pass
+
+    def do_data_tests_view(self):
+        """
+        """
+        pass
+
+    def do_scenario_view(self):
+        """
+        """
+        pass
+
+    def do_scenario_list (self):
+        """
+        """
+        pass
+
+    def do_scenario_update(self):
+        """
+        """
+        pass
+
+    def do_scenario_rm(self):
+        """
+        """
+        pass
+
+    def do_dmodel_view(self, _):
+        """
+        Print out the whole domain model
+        """
+        pass
+
+    def do_dmodel_predicates_state(self, _):
+        """ Print just the state predicates """
+        pass
+
+    def do_dmodel_predicates_action(self, _):
+        """ """
+        pass
+
+    def do_dmodel_transitions(self, _):
+        """ """
+        pass
+
+if __name__ == "__main__":
+    import sys
+
+    c = SpecLogicianCmdApp()
+    sys.exit(c.cmdloop())