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

speclogician/tui/tui.py

@@ -0,0 +1,131 @@
+#
+#   Imandra Inc.
+#
+#   tui.py
+#
+
+from textual.app import App, ComposeResult
+from textual.widgets import (
+    Footer, Header, TabbedContent, TabPane,Static, ListView, ListItem, Label
+)
+from textual.reactive import reactive
+from textual.containers import VerticalScroll
+
+from ..modeling.model import TestFormalization, TLState, Scenario
+from pathlib import Path
+
+class FileItem (ListItem):
+    def __init__(self, label: str) -> None:
+        super().__init__()
+        self.label = label
+
+    def compose( self ) -> ComposeResult:
+        yield Label(Path(self.label).name)
+
+
+class DetailView(Static):
+    """
+    """
+
+    tf : reactive[TestFormalization | None] = reactive(None, always_update=True)
+
+    def watch_tf(self, _, tf:TestFormalization|None) -> None:
+        """
+        """
+        if tf is None: return
+        if not hasattr(self, 'view'): return
+
+        self.view.update(tf.__rich__())
+
+    def compose (self) -> ComposeResult:
+        """
+        """
+        with VerticalScroll():
+            self.view = Static("N/A")
+
+            yield self.view
+
+class PredicateList(Static):
+    """
+    """
+
+    pred_list : reactive[ScenarioPredList | None] = reactive(None, always_update=True)
+
+    def compose(self) -> ComposeResult:
+        """ 
+        """
+        self.view = 
+
+        yield self.view
+
+class SpecLogicianApp(App):
+    """
+    """
+    CSS_PATH = "box.tcss"
+
+    def __init__ (self, tl_state : TLState, **kwargs):
+        super().__init__ (**kwargs)
+
+        self.tl_state = tl_state
+
+    def compose(self) -> ComposeResult:
+        """
+        """
+
+        yield Header()
+
+        with TabbedContent(initial="scenarios"):
+
+            with TabPane("Scenarios", id="scenarios"):
+                self.items = ListView (
+                    *[FileItem(t.filepath) for t in self.tl_state.tfs()],
+                    classes="box",
+                    id="items"
+                )
+                yield self.items 
+
+                self.detail =  DetailView("hello", id="detail", classes="box")
+                yield self.detail
+            
+            with TabPane("Domain Modle", id="model"):
+                self.domain_model = Static(self.tl_state.rich_model())
+                yield self.domain_model
+
+            with TabPane("Concrete Scenarios", id="concrete"):
+                self.concrete_scenarios = PredicateList()
+                self.concrete_scenarios.pred_list = self.tl_state.concrete()
+                yield self.concrete_scenarios
+
+            with TabPane("Predicate Scenarios", id="predicates"):
+                self.predicate_scenarios = PredicateList()
+                self.predciate_scenarios.pred_list = self.tl_state.predicates()
+                yield self.predicate_scenarios
+
+            with TabPane("Abstract Scenarios", id="abstract"):
+                self.abstract_predicates = PredicateList()
+                self.abstract_predicates.pred_list = self.tl_state.abstract()
+                yield self.abstract_predicates()
+
+        yield Footer()
+
+        # Initialize with first model
+        if len(self.tl_state.tfs()) > 0:
+            self.detail.tf = self.tl_state.tf_by_index(0)
+
+    def action_show_tab(self, tab: str) -> None:
+        """Switch to a new tab."""
+        self.get_child_by_type(TabbedContent).active = tab
+
+    def on_list_view_highlighted(self, event: ListView.Highlighted) -> None:
+        """  """
+        self.detail.tf = self.tl_state.tf_by_filepath(event.item.label)
+
+    def on_list_view_selected(self, event: ListView.Selected) -> None:
+        """ """
+        self.detail.tf = self.tl_state.tf_by_index(event.index)
+
+if __name__ == "__main__":
+    sample_state = "../data/broadridge/integration/split_tests/tf_state.json"
+    state = TLState.fromJSON(Path(sample_state).read_text())
+    app = TestLogicianApp(state)
+    app.run()

speclogician/utils/__init__.py

@@ -4,75 +4,6 @@
 #   utils/__init__.py
 #
 
-from __future__ import annotations
-
-import os
-import json
-import typer
-from typing import Any, TypeAlias
-from enum import Enum, StrEnum
 from rich.console import Console
-from rich.theme import Theme
-
-IMANDRA_KEY_ENV = "IMANDRA_UNI_KEY"
-
-
-console = Console(
-    force_terminal=True, 
-    color_system="truecolor", 
-    theme=Theme({"info": "cyan", "ok": "green", "warn": "yellow", "err": "red"})
-)
-
-class IMLValidity (StrEnum):
-    VALID = 'valid'
-    INVALID = 'invalid'
-    UNKNOWN = 'unknown'
-
-
-JSONScalar: TypeAlias = str | int | float | bool | None
-JSONValue: TypeAlias = JSONScalar | list["JSONValue"] | dict[str, "JSONValue"]
-JSONObject: TypeAlias = dict[str, JSONValue]
-
-
-def emit_json(obj: JSONObject) -> None:
-    """
-    Print JSON (never exits).
-    Use this only at the CLI boundary or for debugging.
-    """
-    typer.echo(json.dumps(obj, indent=2, default=_json_default))
-
-
-def _json_default(o: Any) -> Any:
-    # Enums (BaseStatus, PredicateType, etc)
-    if isinstance(o, Enum):
-        return o.value
-    # datetime, Path, etc (best-effort string)
-    try:
-        return str(o)
-    except Exception:
-        return repr(o)
-
-def require_imandra_key() -> None:
-    """
-    Ensure IMANDRA_UNI_KEY is present in the environment.
-    Exit the CLI with a clear message if not.
-    """
-    key = os.getenv(IMANDRA_KEY_ENV)
-
-    if not key:
-        console.print(
-            "[red]✖ ImandraX API key missing[/red]\n\n"
-            "SpecLogician requires an Imandra Universe API key to run.\n\n"
-            "Please set the environment variable:\n\n"
-            f"  export {IMANDRA_KEY_ENV}=<your-api-key>\n\n"
-            "You can obtain a key from Imandra Universe."
-        )
-        raise typer.Exit(code=2)
 
-__all__ = [
-    "require_imandra_key",
-    "emit_json",
-    "_json_default",
-    "IMLValidity",
-    "console"
-]
+console = Console()

speclogician/utils/imx.py

@@ -0,0 +1,195 @@
+#
+#   Imandra Inc.
+#
+#   imx.py
+#
+
+import asyncio
+import sys
+from typing import Literal, TypedDict, assert_never
+
+import typer
+from imandrax_api_models import DecomposeRes, InstanceRes, VerifyRes
+from imandrax_api_models.client import (
+    ImandraXAsyncClient,
+    get_imandrax_async_client,
+    get_imandrax_client,
+)
+from imandrax_api_models.context_utils import (
+    format_decomp_res,
+    format_eval_res,
+    #format_vg_res,
+)
+from iml_query.processing import (
+    extract_decomp_reqs,
+    extract_instance_reqs,
+    extract_verify_reqs,
+)
+from iml_query.processing.decomp import DecompReqArgs
+from iml_query.tree_sitter_utils import get_parser
+
+from enum import StrEnum
+class IMX_Status(StrEnum):
+    """
+    """
+    UNKNOWN = 'Unkown'
+    ADMITTED = 'Admitted'
+    ERROR = 'Error'
+
+
+def check_model(model : str) -> bool:
+    """ 
+    Check that the model is admitted to ImandraX
+    """
+    c = get_imandrax_client()
+    eval_res = c.eval_model(src=model, with_vgs=False, with_decomps=False)
+
+    return format_eval_res(eval_res)
+
+def run_eval(model : str, eval_str : str) -> str:
+    """
+    Run evaluation
+    """
+
+    c = get_imandrax_client()
+    eval_res = c.eval_src(model)
+
+    return ""
+
+
+class VGItem(TypedDict):
+    kind: Literal["verify", "instance"]
+    src: str
+    start_point: tuple[int, int]
+    end_point: tuple[int, int]
+
+def _collect_vgs(iml: str) -> list[VGItem]:
+    tree = get_parser().parse(iml.encode("utf-8"))
+    iml, tree, verify_reqs, verify_req_ranges = extract_verify_reqs(iml, tree)
+    iml, tree, instance_reqs, instance_req_ranges = extract_instance_reqs(iml, tree)
+
+    # Collect
+    vg_items: list[VGItem] = []
+    for req, req_range in zip(verify_reqs, verify_req_ranges, strict=True):
+        vg_items.append(
+            {
+                "kind": "verify",
+                "src": req["src"],
+                "start_point": (req_range.start_point[0], req_range.start_point[1]),
+                "end_point": (req_range.end_point[0], req_range.end_point[1]),
+            }
+        )
+    for req, req_range in zip(instance_reqs, instance_req_ranges, strict=False):
+        vg_items.append(
+            {
+                "kind": "instance",
+                "src": req["src"],
+                "start_point": (req_range.start_point[0], req_range.start_point[1]),
+                "end_point": (req_range.end_point[0], req_range.end_point[1]),
+            }
+        )
+    vg_items.sort(key=lambda x: x["start_point"])
+    return vg_items
+
+def check_instance (model : str, instance_query : str) -> bool:
+    """
+    Run the instance request and return True/False if the instance is Sat
+    """
+    async def _async_check_vg() -> list[VerifyRes | InstanceRes]:
+        iml = model + "\n" + instance_query
+        vgs = _collect_vgs(iml)
+
+        vg_with_idx: list[tuple[int, VGItem]] = [
+            (i, vg) for (i, vg) in enumerate(vgs, 1)
+        ]
+
+        async def _check_vg(
+            vg: VGItem,
+            i: int,
+            c: ImandraXAsyncClient,
+        ) -> VerifyRes | InstanceRes:
+            match vg["kind"]:
+                case "verify":
+                    res = await c.verify_src(src=vg["src"])
+                case "instance":
+                    res = await c.instance_src(src=vg["src"])
+                case _:
+                    assert_never(vg["kind"])
+            #print(f"{i}: {vg['kind']} ({vg['src']})")
+            #print(format_vg_res(res))
+            return res
+
+        async with get_imandrax_async_client() as c:
+            eval_res = await c.eval_model(src=iml)
+            #print(format_eval_res(eval_res, iml))
+            if eval_res.has_errors:
+                print("Error(s) found in IML file. Exiting.")
+                sys.exit(1)
+                return
+            #print("\n" + "=" * 5 + "VG" + "=" * 5 + "\n")
+            tasks = [_check_vg(vg, i, c) for (i, vg) in vg_with_idx]
+            return await asyncio.gather(*tasks)
+
+    vg_res_list = asyncio.run(_async_check_vg())
+
+    if len(vg_res_list) == 0:
+        raise Exception(f"Failed to get response")
+
+    return vg_res_list[0].res_type == 'sat'
+
+class DecompItem(TypedDict):
+    req_args: DecompReqArgs
+    start_point: tuple[int, int]
+    end_point: tuple[int, int]
+
+def _collect_decomps(iml: str) -> list[DecompItem]:
+    tree = get_parser().parse(iml.encode("utf-8"))
+    iml, tree, decomp_reqs, ranges = extract_decomp_reqs(iml, tree)
+
+    decomp_items: list[DecompItem] = [
+        DecompItem(
+            req_args=req,
+            start_point=range_.start_point,
+            end_point=range_.end_point,
+        )
+        for req, range_ in zip(decomp_reqs, ranges, strict=True)
+    ]
+
+    decomp_items.sort(key=lambda x: x["start_point"])
+    return decomp_items
+
+def run_decomp(model : str, decomp_request : str):
+    """
+    Run the decomp request
+    """
+    async def _async_check_decomp() -> list[DecomposeRes]:
+        iml = model + "\n" + decomp_request
+        decomps = _collect_decomps(iml)
+
+        decomp_with_idx: list[tuple[int, DecompItem]] = [
+            (i, decomp) for (i, decomp) in enumerate(decomps, 1)
+        ]
+
+        async def _check_decomp(
+            decomp: DecompItem, i: int, c: ImandraXAsyncClient
+        ) -> DecomposeRes:
+            #print(f"{i}: decompose {decomp['req_args']['name']}")
+            res = await c.decompose(**decomp["req_args"])
+            #print(format_decomp_res(res))
+            return res
+
+        async with get_imandrax_async_client() as c:
+            eval_res = await c.eval_model(src=iml)
+            #print(format_eval_res(eval_res, iml))
+            if eval_res.has_errors:
+                typer.echo("Error(s) found in IML file. Exiting.")
+                sys.exit(1)
+                return
+
+            #print("\n" + "=" * 5 + "Decomp" + "=" * 5 + "\n")
+            tasks = [_check_decomp(decomp, i, c) for (i, decomp) in decomp_with_idx]
+            return await asyncio.gather(*tasks)
+
+    decomp_res_list = asyncio.run(_async_check_decomp())
+
+    return decomp_res_list[0]

speclogician/utils/load.py

@@ -1,166 +1,44 @@
 #
 #   Imandra Inc.
 #
-#   speclogician/utils/load.py
+#   load.py
 #
 
-import json
 import os
-from pathlib import Path
-
-import typer
-from typing import NoReturn
+import sys
 from rich.prompt import Prompt
+from pathlib import Path
 
 from ..state.state import State
+from ..llms.overlay import Overlays
 from .__init__ import console
 
-
-def _emit_json(obj: dict, exit_code: int = 0) -> NoReturn:
-    """Print JSON and exit (useful for CLI / tests)."""
-    typer.echo(json.dumps(obj, indent=2))
-    raise typer.Exit(code=exit_code)
-
-
-def load_state(path: Path | None = None, json: bool = False) -> State:
-    """
-    Load a State either from an explicit JSON path or from the local directory.
-
-    - If `path` is provided:
-        * if it exists: load JSON from it
-        * if it doesn't exist: ask to create it (unless json)
-    - If `path` is None:
-        * load from current directory via State.from_dir()
-        * if missing: ask to create it (unless json)
-
-    If json=True:
-      - emit JSON on success/error and Exit (no prompts).
-    """
-    cwd = Path(os.getcwd())
-
-    def create_new_state(target: Path | None) -> State:
-        """
-        Create a new state and persist it.
-        NOTE: Your State.save() appears to accept a directory path; we use:
-          - cwd when target is None
-          - target.parent when target is a file path
-        """
-        state = State()
-
-        if target is None:
-            state.save(str(cwd))
-            return state
-
-        target = target.expanduser()
-        target.parent.mkdir(parents=True, exist_ok=True)
-        state.save(str(target.parent))
-        return state
-
-    # -------------------------
-    # Case 1: explicit file path
-    # -------------------------
-    if path is not None:
-        path = path.expanduser()
-
-        if path.exists():
-            try:
-                if path.is_dir():
-                    new_state = State.from_dir(dirpath=path)
-                else:
-                    new_state = State.from_json(path.read_text())
-            except Exception as e:
-                if json:
-                    _emit_json(
-                        {
-                            "ok": False,
-                            "error": "failed_to_load_state_json",
-                            "path": str(path),
-                            "message": str(e),
-                        },
-                        exit_code=2,
-                    )
-                console.print(f"[red]Failed to load state JSON:[/] {path}\n{e}")
-                raise
-
-            if json:
-                _emit_json(
-                    {"ok": True, "source": "state_json", "path": str(path)},
-                    exit_code=0,
-                )
-            return new_state
-
-        # File doesn't exist
-        if json:
-            _emit_json(
-                {
-                    "ok": False,
-                    "error": "state_json_not_found",
-                    "path": str(path),
-                    "message": "State JSON file does not exist.",
-                },
-                exit_code=2,
-            )
-
+def load_state():
+    """ """
+    new_state = State.from_dir(dirpath=os.getcwd())
+    if new_state is None:
         answer = Prompt.ask(
-            prompt=f"⚠️ State file not found at {path}. Create a new one?",
-            choices=["Yes", "No"],
+            prompt="⚠️ Couldnt find a state in current directory. Create a new one?", 
+            choices = ["Yes", "No"],
             console=console,
             case_sensitive=False,
-            default="Yes",
-        )
-        if answer.lower() == "no":
-            console.print("Goodbye!")
-            raise typer.Exit(0)
+            default="Yes"
+            )
 
+        if answer == 'No':
+            console.print("Goodbye!")
+            sys.exit(0)
+        
         console.print("Creating a new state!")
-        return create_new_state(path)
 
-    # -------------------------
-    # Case 2: default local dir
-    # -------------------------
-    try:
-        new_state = State.from_dir(dirpath=str(cwd))
-    except Exception as e:
-        if json:
-            _emit_json(
-                {
-                    "ok": False,
-                    "error": "failed_to_load_state_from_dir",
-                    "dir": str(cwd),
-                    "message": str(e),
-                },
-                exit_code=2,
-            )
-        console.print(f"[red]Failed to load state from directory:[/] {cwd}\n{e}")
-        raise
-
-    if new_state is not None:
-        if json:
-            _emit_json({"ok": True, "source": "dir", "dir": str(cwd)}, exit_code=0)
+        state = State()
+        state.save(os.getcwd())
+        return state
+    
+    else:
         return new_state
 
-    # Not found in cwd
-    if json:
-        _emit_json(
-            {
-                "ok": False,
-                "error": "state_not_found_in_dir",
-                "dir": str(cwd),
-                "message": "No state found in current directory.",
-            },
-            exit_code=2,
-        )
-
-    answer = Prompt.ask(
-        prompt="⚠️ Couldn't find a state in current directory. Create a new one?",
-        choices=["Yes", "No"],
-        console=console,
-        case_sensitive=False,
-        default="Yes",
-    )
-    if answer.lower() == "no":
-        console.print("Goodbye!")
-        raise typer.Exit(0)
-
-    console.print("Creating a new state!")
-    return create_new_state(None)
+def load_overlays():
+    """
+    """    
+    return Overlays.from_dir(str(Path(os.path.abspath(__file__)).parent / "../../overlays"))