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

speclogician/logic/api/scenario.py

@@ -1,102 +0,0 @@
-#
-#   Imandra Inc.
-#
-#   speclogician/logic/api/scenario.py
-#
-
-import asyncio
-from .client import SpecLogicianImandraX
-from speclogician.modeling.scenario import Scenario
-from speclogician.modeling.spec import Spec
-
-
-async def check_state_preds_async(sc: Scenario, spec: Spec) -> bool:
-    if len(sc.given) == 0:
-        return True
-    
-    async with SpecLogicianImandraX() as ix:
-        res = await ix.check_scenario_consistent(
-            domain_model=spec.domain_model,
-            scenario=sc,
-            check_state_preds=True,
-            check_action_preds=False
-        )
-
-        return res.is_consistent
-
-def check_state_preds(sc: Scenario, spec: Spec) -> bool:
-    return asyncio.run(check_state_preds_async(sc, spec))
-
-
-async def check_action_preds_async(sc: Scenario, spec: Spec) -> bool:
-    if len(sc.when) == 0:
-        return True
-
-    async with SpecLogicianImandraX() as ix:
-        res = await ix.check_scenario_consistent(
-            domain_model=spec.domain_model,
-            scenario=sc,
-            check_state_preds=False,
-            check_action_preds=True
-        )
-        return res.is_consistent
-
-def check_action_preds (sc: Scenario, spec: Spec) -> bool:
-    return asyncio.run(check_action_preds_async(sc, spec))
-
-async def check_all_preds_async(sc : Scenario, spec : Spec) -> bool:
-    if len(sc.given) == 0 and len(sc.when) == 0:
-        return True
-    
-    async with SpecLogicianImandraX() as ix:
-        res = await ix.check_scenario_consistent(
-            domain_model=spec.domain_model,
-            scenario=sc,
-            check_state_preds=True,
-            check_action_preds=True
-        )
-        return res.is_consistent
-
-def check_all_preds (sc: Scenario, spec: Spec) -> bool:
-    return asyncio.run(check_all_preds_async(sc, spec))
-
-def check_scenario(sc : Scenario, spec : Spec) -> None:
-    """
-    Check if all the specified predicates/transitions are actually present in the domain model,
-    and if so, check that the predicates are consistent
-    """
-
-    # First, let's check that all the predicates exist..
-    sc.preds_missing = []
-    for p in list(sc.given) + list(sc.when):
-        if not spec.domain_model.pred_exists(p):
-            sc.preds_missing.append(p)
-
-    sc.trans_missing = []
-    for t in sc.then:
-        if not spec.domain_model.trans_exists(t):
-            sc.trans_missing.append(t)
-
-    sc.given_preds_consistent = check_state_preds(sc, spec)
-    sc.when_preds_consistent = check_action_preds(sc, spec)
-    sc.all_preds_consistent = check_all_preds(sc, spec)
-
-
-async def check_intersection_async(sc1: Scenario, sc2: Scenario, spec: Spec) -> bool:
-    """
-    Async: return True iff scenarios intersect (SAT).
-    """
-    async with SpecLogicianImandraX() as ix:
-        res = await ix.check_scenarios_intersect(
-            domain_model=spec.domain_model,
-            sc_a=sc1,
-            sc_b=sc2,
-        )
-        return res.do_they_intersect
-
-def check_intersection(sc1: Scenario, sc2: Scenario, spec: Spec) -> bool:
-    """
-    Sync wrapper around `check_intersection_async`.
-    Returns True iff scenarios intersect (SAT).
-    """
-    return asyncio.run(check_intersection_async(sc1, sc2, spec))

speclogician/logic/api/traces.py

@@ -1,59 +0,0 @@
-#
-#   Imandra Inc.
-#
-#   speclogician/logic/api/traces.py
-#
-
-from __future__ import annotations
-
-import asyncio
-
-from .client import SpecLogicianImandraX
-from speclogician.modeling.domain import DomainModel
-from speclogician.modeling.scenario import Scenario
-from speclogician.data.artifact import TraceArtifact, TraceIMLValidity, TraceScenarioMatchResult
-
-
-async def check_trace_iml_validity_async(
-    tr: TraceArtifact,
-    model: DomainModel,
-) -> TraceIMLValidity:
-    """
-    Check that trace snippets typecheck against the domain model.
-    """
-    async with SpecLogicianImandraX() as ix:
-        v = await ix.check_trace_iml_validity(tr=tr, model=model)
-        tr.iml_validity = v
-        return v
-
-def check_trace_iml_validity (
-    tr: TraceArtifact,
-    model: DomainModel,
-) -> TraceIMLValidity:
-    """
-    Sync wrapper around check_trace_iml_validity_async.
-    """
-    return asyncio.run(check_trace_iml_validity_async(tr, model))
-
-
-async def check_trace_match_async(
-    tr: TraceArtifact,
-    s: Scenario,
-    model: DomainModel,
-) -> TraceScenarioMatchResult:
-    """
-    Check whether the trace matches a scenario (given/when predicates + transition result).
-    Assumes check_trace_iml_validity is either called inside or is handled by the async method.
-    """
-    async with SpecLogicianImandraX() as ix:
-        return await ix.check_trace_match(tr=tr, s=s, model=model)
-
-def check_trace_match(
-    tr: TraceArtifact,
-    s: Scenario,
-    model: DomainModel,
-) -> TraceScenarioMatchResult:
-    """
-    Sync wrapper around check_trace_match_async.
-    """
-    return asyncio.run(check_trace_match_async(tr, s, model))

speclogician/logic/lib/__init__.py

@@ -1,19 +0,0 @@
-#
-#   Imandra Inc.
-#
-#   speclogician/logic/lib/__init__.py
-#
-
-from .domain_model import check_domain_model
-from .predicates import check_predicates
-from .transitions import check_transitions
-from .scenarios import check_scenarios
-from .traces import check_traces
-
-__all__ = [
-    "check_domain_model",
-    "check_predicates",
-    "check_transitions",
-    "check_scenarios",
-    "check_traces",
-]

speclogician/logic/lib/complement.py

@@ -1,107 +0,0 @@
-#
-#   Imandra Inc.
-#
-#   speclogician/logic/lib/complement.py
-#
-
-from __future__ import annotations
-
-import asyncio
-from typing import Optional
-
-from speclogician.modeling.domain import BaseStatus
-from speclogician.modeling.complement import ScenarioComplement
-from speclogician.modeling.spec import Spec
-
-from ..api.decomp import decomp_complement_async
-
-
-def _is_iml_invalid(x: object) -> bool:
-    """
-    Best-effort check for IML invalidity without hard-coding exact enum imports.
-    Works with:
-      - IMLValidity.INVALID enum
-      - string/repr containing "IMLValidity.INVALID"
-      - literal "invalid"
-    """
-    v = getattr(x, "is_iml_valid", None)
-    if v is None:
-        return False
-
-    # enum-style
-    try:
-        if getattr(v, "name", None) == "INVALID":
-            return True
-    except Exception:
-        pass
-
-    # string-style
-    s = str(v)
-    return (s == "invalid") or ("IMLValidity.INVALID" in s)
-
-
-def _spec_is_decomposable_for_complement(spec: Spec) -> tuple[bool, str]:
-    dm = spec.domain_model
-
-    # 1) base must be good
-    if getattr(dm, "base_status", None) != BaseStatus.VALID:
-        return False, f"base_status={getattr(dm, 'base_status', None)}"
-
-    # 2) must have scenarios
-    scs = list(getattr(spec, "scenarios", []) or [])
-    if len(scs) == 0:
-        return False, "no_scenarios"
-
-    # 3) scenarios should be internally consistent (avoid wasting time)
-    if any(getattr(sc, "all_preds_consistent", True) is False for sc in scs):
-        return False, "has_inconsistent_scenarios"
-
-    # 4) avoid complement if any predicate/transition is IML-invalid
-    bad: list[tuple[str, str]] = []
-
-    for p in list(getattr(dm, "state_preds", [])) + list(getattr(dm, "action_preds", [])):
-        if _is_iml_invalid(p):
-            bad.append(("pred", getattr(p, "name", "<unknown>")))
-
-    for t in list(getattr(dm, "transitions", [])):
-        if _is_iml_invalid(t):
-            bad.append(("trans", getattr(t, "name", "<unknown>")))
-
-    if bad:
-        return False, f"iml_invalid={bad[:3]}{'...' if len(bad) > 3 else ''}"
-
-    return True, "ok"
-
-
-def maybe_update_spec_complement(spec: Spec) -> Optional[ScenarioComplement]:
-    """
-    Policy-level helper (SYNC):
-
-      - decides whether it is *appropriate* to compute complement
-      - if not appropriate, clears stale complement
-      - if appropriate, calls ImandraX via API-layer decomp and stores result
-
-    NOTE:
-      - This is intentionally sync to fit the state pipeline.
-      - It runs the async decomp using asyncio.run().
-      - If called inside an existing event loop, it will gracefully skip and
-        leave complement cleared (to avoid stale info).
-    """
-    ok, _why = _spec_is_decomposable_for_complement(spec)
-    if not ok:
-        # Prevent stale coverage info from hanging around.
-        spec.scenario_comp = None
-        return None
-
-    try:
-        comp = asyncio.run(decomp_complement_async(spec))
-    except RuntimeError:
-        # "asyncio.run() cannot be called from a running event loop"
-        # This should be rare in CLI, but can happen in notebooks/tests.
-        # Prefer "clear rather than stale".
-        spec.scenario_comp = None
-        return None
-
-    spec.scenario_comp = comp
-    return comp
-

speclogician/logic/lib/domain_model.py

@@ -1,59 +0,0 @@
-#
-#   Imandra Inc.
-#
-#   speclogician/logic/lib/domain_model.py
-#
-
-import asyncio
-
-from speclogician.modeling.domain import BaseStatus
-from speclogician.modeling.spec import Spec
-from speclogician.logic.api import SpecLogicianImandraX
-from speclogician.utils import console
-
-def check_domain_model(spec: Spec, json_only: bool = False) -> None:
-    """
-    Updates:
-    - spec.domain_model.base_has_state
-    - spec.domain_model.base_has_action
-    - spec.domain_model.base_status  (via ImandraX)
-    """
-    dm = spec.domain_model
-
-    if not json_only:
-        console.print("[bold cyan]Logician[/bold cyan] Checking domain model base")
-
-    # Local checks
-    dm.base_has_state = dm.state_specified()
-    dm.base_has_action = dm.action_specified()
-
-    if not json_only:
-        console.print(
-            f"  • has state type : {'✓' if dm.base_has_state else '✗'}\n"
-            f"  • has action type: {'✓' if dm.base_has_action else '✗'}"
-        )
-
-    # Build "base-only" model and ask ImandraX to load/typecheck it
-    base_src = dm.make_iml_model([], [], [])
-
-    async def _check() -> bool:
-        async with SpecLogicianImandraX() as ix:
-            res = await ix.load_model(base_src)
-            return not bool(getattr(res, "has_errors", False))
-
-    try:
-        ok = asyncio.run(_check())
-    except Exception as e:
-        dm.base_status = BaseStatus.UNKNOWN
-        if not json_only:
-            console.print("[yellow]⚠ Unable to check base model via ImandraX[/yellow]")
-            console.print(f"[dim]{e}[/dim]")
-        return
-
-    dm.base_status = BaseStatus.VALID if ok else BaseStatus.INVALID_IML
-
-    if not json_only:
-        if dm.base_status is BaseStatus.VALID:
-            console.print("[green]✓ Base domain model is valid IML[/green]")
-        else:
-            console.print("[red]✗ Base domain model is invalid IML[/red]")

speclogician/logic/lib/predicates.py

@@ -1,151 +0,0 @@
-#
-#   Imandra Inc.
-#   
-#   speclogician/logic/lib/predicates.py
-#
-
-import asyncio
-
-from rich.progress import Progress
-
-from speclogician.modeling.spec import Spec
-from speclogician.logic.api import SpecLogicianImandraX
-from speclogician.utils import IMLValidity, console
-
-def check_predicates(
-    spec: Spec,
-    names: list[str] = [],
-    json_only: bool = False,
-) -> None:
-    """
-    Check predicate IML validity via ImandraX and write results into predicate objects:
-        - predicate.is_iml_valid
-        - predicate.iml_error
-    If `names` is non-empty, checks only those predicate names; otherwise checks all.
-    """
-
-    dm = spec.domain_model
-
-    # Resolve which predicates to check (by name), across state+action predicates.
-    all_state = list(dm.state_preds)
-    all_action = list(dm.action_preds)
-
-    if names:
-        name_set = set(names)
-        state_to_check = [p for p in all_state if p.name in name_set]
-        action_to_check = [p for p in all_action if p.name in name_set]
-
-        # If a name was requested but doesn't exist, we can't attach the result to a predicate.
-        # We *log* it (non-json) but do not raise.
-        if not json_only:
-            known = {p.name for p in all_state} | {p.name for p in all_action}
-            missing = [n for n in names if n not in known]
-            if missing:
-                console.print(f"[yellow]Logician[/yellow] Unknown predicate name(s) requested: {missing}")
-    else:
-        state_to_check = all_state
-        action_to_check = all_action
-
-    # Helper: stringify ImandraX eval_model errors (best effort)
-    def _errs_to_str(res: object) -> str:
-        es = getattr(res, "errors", None) or []
-        if es:
-            return "\n".join(str(e) for e in es)
-        return "ImandraX eval_model: has_errors=True"
-
-    async def _check_all() -> None:
-        async with SpecLogicianImandraX() as ix:
-            # --- State predicates ---
-            for p in state_to_check:
-                src = dm.make_iml_model([p.name], [], [])
-                try:
-                    r = await ix.load_model(src)
-                    has_err = bool(getattr(r, "has_errors", False))
-                    p.is_iml_valid = IMLValidity.INVALID if has_err else IMLValidity.VALID
-                    p.iml_error = None if not has_err else _errs_to_str(r)
-                except Exception as e:
-                    p.is_iml_valid = IMLValidity.UNKNOWN
-                    p.iml_error = str(e)
-
-            # --- Action predicates ---
-            for p in action_to_check:
-                src = dm.make_iml_model([], [p.name], [])
-                try:
-                    r = await ix.load_model(src)
-                    has_err = bool(getattr(r, "has_errors", False))
-                    p.is_iml_valid = IMLValidity.INVALID if has_err else IMLValidity.VALID
-                    p.iml_error = None if not has_err else _errs_to_str(r)
-                except Exception as e:
-                    p.is_iml_valid = IMLValidity.UNKNOWN
-                    p.iml_error = str(e)
-
-    if not json_only:
-        console.print("[bold cyan]Logician[/bold cyan] Checking predicate IML validity")
-
-    # Show progress only in non-json mode
-    if not json_only:
-        with Progress(transient=True) as progress:
-            t_state = progress.add_task("Checking state predicates", total=len(state_to_check))
-            t_action = progress.add_task("Checking action predicates", total=len(action_to_check))
-
-            # We still do the actual work in one ImandraX session; progress is updated as we go.
-            async def _check_with_progress() -> None:
-                async with SpecLogicianImandraX() as ix:
-                    for p in state_to_check:
-                        src = dm.make_iml_model([p.name], [], [])
-                        try:
-                            r = await ix.load_model(src)
-                            has_err = bool(getattr(r, "has_errors", False))
-                            p.is_iml_valid = IMLValidity.INVALID if has_err else IMLValidity.VALID
-                            p.iml_error = None if not has_err else _errs_to_str(r)
-                        except Exception as e:
-                            p.is_iml_valid = IMLValidity.UNKNOWN
-                            p.iml_error = str(e)
-                        progress.advance(t_state)
-
-                    for p in action_to_check:
-                        src = dm.make_iml_model([], [p.name], [])
-                        try:
-                            r = await ix.load_model(src)
-                            has_err = bool(getattr(r, "has_errors", False))
-                            p.is_iml_valid = IMLValidity.INVALID if has_err else IMLValidity.VALID
-                            p.iml_error = None if not has_err else _errs_to_str(r)
-                        except Exception as e:
-                            p.is_iml_valid = IMLValidity.UNKNOWN
-                            p.iml_error = str(e)
-                        progress.advance(t_action)
-
-            try:
-                asyncio.run(_check_with_progress())
-            except Exception as e:
-                # If the whole checking run fails (e.g. credentials/network),
-                # we don't have per-predicate errors; mark checked ones as unknown.
-                for p in state_to_check + action_to_check:
-                    p.is_iml_valid = IMLValidity.UNKNOWN
-                    p.iml_error = str(e)
-    else:
-        # No progress bar, just run.
-        try:
-            asyncio.run(_check_all())
-        except Exception as e:
-            for p in state_to_check + action_to_check:
-                p.is_iml_valid = IMLValidity.UNKNOWN
-                p.iml_error = str(e)
-
-    # Refresh domain-model predicate stats (global, not just filtered set)
-    dm.num_state_preds_total = len(all_state)
-    dm.num_action_preds_total = len(all_action)
-
-    dm.num_state_preds_valid_logic = sum(1 for p in all_state if getattr(p, "is_iml_valid", IMLValidity.UNKNOWN) == IMLValidity.VALID)
-    dm.num_action_preds_valid_logic = sum(1 for p in all_action if getattr(p, "is_iml_valid", IMLValidity.UNKNOWN) == IMLValidity.VALID)
-
-    dm.num_preds_total = dm.num_state_preds_total + dm.num_action_preds_total
-    dm.num_preds_valid_logic = dm.num_state_preds_valid_logic + dm.num_action_preds_valid_logic
-
-    if not json_only:
-        console.print(
-            f"[green]✓[/green] Predicates checked. "
-            f"state_valid={dm.num_state_preds_valid_logic}/{dm.num_state_preds_total}, "
-            f"action_valid={dm.num_action_preds_valid_logic}/{dm.num_action_preds_total}"
-        )
-