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

speclogician/agent/funcs.py

@@ -0,0 +1,29 @@
+#
+#   Imandra Inc.
+#
+#   agent.py
+#
+
+
+import sys
+from pathlib import Path
+
+from ..state.state import State
+from ..llms.llmtools import test_formalizer
+from ..llms.overlay import Overlay
+
+def process_test_file ( 
+        path : Path,
+        state : State,
+        overlay : Overlay
+    ) -> State:
+    """
+    Process a file state to the state
+    """
+
+    try:
+        tf = test_formalizer (str(path), overlay, state)
+    except Exception as e:
+        raise Exception (f"Failed to process test file: []")
+
+    return state.add_test_formalization(tf)

speclogician/cmd/agent_cmd.py

@@ -0,0 +1,89 @@
+#
+#   Imandra Inc.
+#
+#   agent_cmd.py
+#
+
+import typer
+import os
+from pathlib import Path
+from typing import Annotated
+
+from rich.progress import track
+
+from ..llms.overlay import Overlays
+from ..agent.funcs import process_test_file
+from ..state.state import State
+from ..utils import console
+from ..utils.load import load_overlays, load_state
+
+app = typer.Typer()
+
+
+@app.command(help="Add a single file to the formalization state")
+def proc_test_file (
+        filepath : Annotated[str, typer.Argument()],
+        overlay_name : Annotated[str, typer.Argument(help="Overlay to use. It should also contain the file extension we'll use")]
+    ):
+
+    overlays = load_overlays()
+    state = load_state()
+    
+    tgt_path = Path(filepath).parent / filepath
+
+    overlay = overlays.get(overlay_name)
+    if overlay is None:
+        console.print(f":warning: Could not find an overlay named {overlay_name}!")
+        return
+    
+    try: 
+        process_test_file(tgt_path, state, overlay)
+    except Exception as e:
+        console.print(f"🛑 Caught an error when adding file: {e}")
+        return
+    
+    # Add the state definition here
+
+    typer.secho(f"✅ Successfully added {filepath} to the formalization state!")
+
+@app.command(help="Run full cycle formalization for a specified directory")
+def proc_test_dir (
+        dirpath : Annotated[str, typer.Argument(help="Target directory with tests that should be formalized")],
+        overlay_name : Annotated[str, typer.Argument(help="Overlay to use. It should also contain the file extension we'll use")],
+        clean : Annotated[bool, typer.Option(help="Should we override any tests from these files already present in the state?")] = False
+    ):
+    
+    state = load_state()
+
+    overlays = load_overlays()
+    overlay = overlays.get(overlay_name)
+
+    if overlay is None:
+        typer.secho(f"🛑 Could not find an overlay named {overlay_name}!", err=True)
+        return
+    
+    filepaths = os.listdir(dirpath)
+    filepaths = list(filter(lambda x: x.endswith(overlay.ext.strip()), filepaths))
+
+    console.print(f"Identified {len(filepaths)} to process")
+
+    count = 0
+
+    for i in track(range(len(filepaths)), description=f"Processing {dirpath}..."):
+
+        try:
+            process_test_file(Path(filepaths[i]), state, overlay)
+        except Exception as e:
+            console.print(f"Failed on {filepaths[i]}: {e}")
+
+        count += 1
+
+    console.print(f":robot:Processed {count} files!")
+
+    try:
+        state.save(dirpath)
+    except Exception as e:
+        typer.echo(f"🛑 Caught error when saving the formalization state: {e}")
+        return
+ 
+    typer.secho(f"✅ Successfully saved the formalization state to {dirpath}")

speclogician/cmd/data_cmd.py

@@ -0,0 +1,24 @@
+#
+#   Imandra Inc.
+#
+#   data_cmd.py
+#   
+
+import typer
+from typing import Annotated
+
+app = typer.Typer()
+
+@app.command(name="list")
+def data_list():
+    """
+    List the available data sources
+    """
+    pass
+
+tests_app = typer.Typer()
+@tests_app.command(name="tests")
+def list (
+        max_num_tests : Annotated[int, typer.Argument(help="Maximum number of tests to displayed")]
+    ):
+    pass

speclogician/cmd/model_cmd.py

@@ -0,0 +1,42 @@
+#   
+#   Imandra Inc.
+#
+#   model_cmd.py
+#
+
+import typer
+from typing import Annotated
+from rich.syntax import Syntax
+
+from ..utils import console
+from ..utils.load import load_state
+
+app = typer.Typer()
+
+@app.command(name="summary", help="")
+def summary():
+    """
+    """
+
+    state = load_state()
+
+    console.print(state.curr_state().model.report())
+
+@app.command(name="code", help="Generate the IML code for the Domain Model")
+def get_code(
+        filepath : Annotated[str|None, typer.Option(help="Output filepath")] = None
+    ):
+
+    state = load_state()
+
+    console.print(Syntax(state.curr_state().model.domain_model.to_iml(), "OCaml"))
+
+    if filepath is not None:
+        try:
+            with open(filepath, 'w') as outfile:
+                print(state.curr_state().model.domain_model.to_iml(), file=outfile)
+        except Exception as e:
+            console.print(f"🛑 Failed to write domain model to disk: {e}",)
+            return
+
+    console.print(f"✅ Successfully wrote domain model to disk: {filepath}")

speclogician/cmd/overlay_cmd.py

@@ -0,0 +1,30 @@
+#
+#   Imandra Inc.
+#   
+#   overlay_cmd.py
+#
+
+from typing import Annotated
+from rich import print as printr
+import typer
+
+from ..utils.load import load_overlays
+
+app = typer.Typer()
+
+@app.command(name="list", help="list the available overlays")
+def list_():
+    overlays = load_overlays()
+    overlays.list_overlays()
+
+@app.command(name="view", help="View individual template")
+def view(
+        name : Annotated[str, typer.Argument(help="Name of the template to view")]
+    ):
+
+    overlays = load_overlays()
+    if name not in overlays.names():
+        typer.secho(f"🛑 No template with name {name} found!", err=True)
+        return
+    
+    printr(overlays.get(name))

speclogician/cmd/scenario_cmd.py

@@ -0,0 +1,61 @@
+#
+#   Imandra Inc.
+#
+#   scenario_cmd.py
+#
+
+import typer
+
+from ..state.state import State
+from ..utils.load import load_state
+
+from typing import Annotated
+
+
+app = typer.Typer()
+
+@app.command(name="summary", help="Summary of the available scenarios")
+def summary():
+    """ 
+    """
+    
+    state = load_state()
+
+@app.command(name="view", help="View a specific scenario")
+def view(
+    sc_id : int,
+    scenario_name : str
+    ):
+    """
+    """
+    
+    state = load_state()
+
+@app.command(name="rm", help="Remove a scenario")
+def rm_scenario():
+    """ 
+    """
+    
+    state = load_state()
+
+@app.command(name="add", help="Add a scenario")
+def add_scenario(
+        name : Annotated[str, typer.Argument(help="Name to be given to the scenario, must be unique")] 
+    ):
+    """ 
+    """
+    state = load_state()
+
+@app.command(name="edit", help="Edit a scenario")
+def edit_scenario():
+    """ 
+    """
+    
+    state = load_state()
+
+@app.command(name="search", help="Search for a particular scenario by predicate/transition functions")
+def search(q : str):
+    """ 
+    """
+
+    state = load_state()

speclogician/cmd/state_cmd.py

@@ -0,0 +1,52 @@
+#  
+#   Imandra Inc.
+#
+#   state_cmd.py
+#
+
+import typer
+import sys
+from typing import Annotated
+
+from ..state.state import State
+from ..utils import console
+from ..utils.load import load_state
+
+global state
+state : State
+
+app = typer.Typer()
+
+@app.command(name="list", help="List all state instances")
+def list_states (
+        max_num_states : Annotated[int, typer.Argument(help="Maximum number of states")]=10
+    ):
+    """ 
+    List the state instances
+    """
+    state = load_state()
+    console.print(state.inst_list())
+
+@app.command(name="set", help="Set current state to a specific idx in the list")
+def set (
+        state_idx : Annotated[int, typer.Argument(help="")]
+    ):
+
+    state = load_state()
+
+    try:
+        state.set_curr_state_idx (state_idx)
+    except Exception as e:
+        console.print(f"Caught error: {e}")
+        sys.exit(0)
+
+    console.print("Update current state idx to {state_idx}")
+
+@app.command(name="summary", help="Provide summary of the current state instance")
+def summary():
+    """
+    Provide a summary of the current state
+    """
+
+    state : State = load_state()
+    console.print(state.curr_state().report())

speclogician/data/artifact.py

@@ -1,63 +1,21 @@
 #
 #   Imandra Inc.
 #
-#   speclogician/data/artifact.py
+#   artifact.py
 #
 
-from __future__ import annotations
-
 import uuid
-from pydantic import BaseModel, Field, field_validator
-from ..utils import IMLValidity
+from pydantic import BaseModel, Field
 
 class Artifact(BaseModel):
     """
-    Base class for an Artifact
     """
-    # Assigned task ID, new one created if not provided
-    art_id : str | None = Field(default_factory=lambda: str(uuid.uuid4()))
-
-    @field_validator("art_id", mode="before")
-    @classmethod
-    def _coerce_none_to_uuid(cls, v:str|None):
-        if v is None:
-            return str(uuid.uuid4())
-        return v
-
-class TraceIMLValidity(BaseModel):
-    iml_valid: IMLValidity
-    err: str | None = None
-
-class TraceScenarioMatchResult(BaseModel):
-    scenario_name: str
-    iml_valid: bool
-    err: str | None = None
-    when_matches: bool = False
-    given_matches: bool = False
-    transition_matches: bool = False
+    art_id : str = Field(default_factory=lambda: str(uuid.uuid4())) # assigned task ID, new one created if not provided
 
 class TraceArtifact(Artifact):
-    """
-    Concrete execution trace:
-    - given : concrete state value
-    - when  : optional concrete action value
-    - then  : optional resulting state value
-    """
-
-    given: str                              # state
-    when: str | None = None                 # action (optional)
-    then: str | None = None                 # state (optional)
-
-    iml_validity: TraceIMLValidity = Field(
-        default_factory=lambda: TraceIMLValidity(
-            iml_valid=IMLValidity.UNKNOWN,
-            err=None,
-        )
-    )
-    time: str = ""
+    
+    given : str
+    when : str
+    then : str
 
-class DataArtifact(Artifact):
-    """
-    Data may be either source code or documentation
-    """
-    pass
+    valid_iml : bool = False