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

speclogician/logic/main.py

@@ -1,246 +0,0 @@
-#
-#   Imandra Inc.
-#
-#   speclogician/logic/main.py
-#
-
-from __future__ import annotations
-
-from ..modeling.spec import Spec
-from ..data.container import ArtifactContainer
-from ..data.mapping import ArtifactMap
-
-from ..state.change import (
-    StateChange,
-    DomainModelBaseEdit,
-    PredicateAdd,
-    PredicateEdit,
-    PredicateRemove,
-    TransitionAdd,
-    TransitionEdit,
-    TransitionRemove,
-    ScenarioAdd,
-    ScenarioEdit,
-    ScenarioRemove,
-    AddTestTrace,
-    EditTestTrace,
-    AddLogTrace,
-    EditLogTrace
-)
-
-from .lib.domain_model import check_domain_model
-from .lib.predicates import check_predicates
-from .lib.transitions import check_transitions
-from .lib.scenarios import check_scenarios
-from .lib.traces import check_traces
-from .lib.complement import maybe_update_spec_complement
-
-from ..utils import console
-
-
-def _hdr(title: str, subtitle: str | None = None, json_only: bool = False) -> None:
-    if json_only:
-        return
-    from rich.panel import Panel
-    from rich.text import Text
-
-    console.print(
-        Panel(
-            Text(subtitle or ""),
-            title=f"[bold]Logician[/bold] · {title}",
-            border_style="cyan",
-        )
-    )
-
-
-def _note(msg: str, json_only: bool = False) -> None:
-    if not json_only:
-        console.print(msg)
-
-def analyze_change(
-    spec: Spec,
-    art_cont: ArtifactContainer,
-    art_map: ArtifactMap,
-    change: StateChange,
-    json_only: bool = False,
-) -> None:
-    """
-    Top-level entry for logical analysis post-change event.
-
-    Only performs logic checks when relevant.
-    All other change types are treated as no-ops here.
-    """
-
-    # ----------------------------
-    # Domain base model changed
-    # ----------------------------
-    if isinstance(change, DomainModelBaseEdit):
-        _hdr("DomainModelBaseEdit", "Rechecking domain model and all dependent logic", json_only=json_only)
-        check_domain_model(spec, json_only=json_only)
-        check_predicates(spec, json_only=json_only)
-        check_transitions(spec, json_only=json_only)
-        check_scenarios(spec, json_only=json_only)
-        check_traces(spec, art_cont=art_cont, art_map=art_map, traces=[], json_only=json_only)
-
-        try:
-            maybe_update_spec_complement(spec)
-        except Exception as e:
-            _note(f"[yellow]⚠[/yellow] Complement update failed (non-fatal): {type(e).__name__}: {e}", json_only=json_only)
-
-        _note("[green]✓[/green] Domain analysis complete", json_only=json_only)
-        return
-
-    # ----------------------------
-    # Predicates changed
-    # ----------------------------
-    if isinstance(change, (PredicateAdd, PredicateEdit)):
-        _hdr("Predicate change", f"Predicate: [bold]{change.pred_name}[/bold]", json_only=json_only)
-        check_predicates(spec, names=[change.pred_name], json_only=json_only)
-        check_scenarios(spec, predicates=[change.pred_name], json_only=json_only)
-        check_traces(spec, art_cont=art_cont, art_map=art_map, traces=[], json_only=json_only)
-
-        try:
-            maybe_update_spec_complement(spec)
-        except Exception as e:
-            _note(f"[yellow]⚠[/yellow] Complement update failed (non-fatal): {type(e).__name__}: {e}", json_only=json_only)
-
-        _note("[green]✓[/green] Predicate analysis complete", json_only=json_only)
-        return
-
-    if isinstance(change, PredicateRemove):
-        _hdr("Predicate removed", f"[bold]{change.pred_name}[/bold]", json_only=json_only)
-        check_scenarios(spec, predicates=[change.pred_name], json_only=json_only)
-        check_traces(spec, art_cont=art_cont, art_map=art_map, traces=[], json_only=json_only)
-
-        try:
-            maybe_update_spec_complement(spec)
-        except Exception as e:
-            _note(f"[yellow]⚠[/yellow] Complement update failed (non-fatal): {type(e).__name__}: {e}", json_only=json_only)
-
-        _note("[green]✓[/green] Scenario refresh complete", json_only=json_only)
-        return
-
-    # ----------------------------
-    # Transitions changed
-    # ----------------------------
-    if isinstance(change, (TransitionAdd, TransitionEdit)):
-        _hdr("Transition change", f"Transition: [bold]{change.trans_name}[/bold]", json_only=json_only)
-        check_transitions(spec, names=[change.trans_name], json_only=json_only)
-        check_scenarios(spec, transitions=[change.trans_name], json_only=json_only)
-        check_traces(spec, art_cont=art_cont, art_map=art_map, traces=[], json_only=json_only)
-
-        try:
-            maybe_update_spec_complement(spec)
-        except Exception as e:
-            _note(f"[yellow]⚠[/yellow] Complement update failed (non-fatal): {type(e).__name__}: {e}", json_only=json_only)
-
-        _note("[green]✓[/green] Transition analysis complete", json_only=json_only)
-        return
-
-    if isinstance(change, TransitionRemove):
-        _hdr("Transition removed", f"[bold]{change.trans_name}[/bold]", json_only=json_only)
-        check_scenarios(spec, transitions=[change.trans_name], json_only=json_only)
-        check_traces(spec, art_cont=art_cont, art_map=art_map, traces=[], json_only=json_only)
-
-        try:
-            maybe_update_spec_complement(spec)
-        except Exception as e:
-            _note(f"[yellow]⚠[/yellow] Complement update failed (non-fatal): {type(e).__name__}: {e}", json_only=json_only)
-
-        _note("[green]✓[/green] Scenario refresh complete", json_only=json_only)
-        return
-
-    # ----------------------------
-    # Scenarios changed
-    # ----------------------------
-    if isinstance(change, (ScenarioAdd, ScenarioEdit)):
-        _hdr("Scenario change", f"Scenario: [bold]{change.scenario_name}[/bold]", json_only=json_only)
-        check_scenarios(spec, names=[change.scenario_name], json_only=json_only)
-        check_traces(spec, art_cont=art_cont, art_map=art_map, traces=[], json_only=json_only)
-
-        try:
-            maybe_update_spec_complement(spec)
-        except Exception as e:
-            _note(f"[yellow]⚠[/yellow] Complement update failed (non-fatal): {type(e).__name__}: {e}", json_only=json_only)
-
-        _note("[green]✓[/green] Scenario analysis complete", json_only=json_only)
-        return
-
-    if isinstance(change, ScenarioRemove):
-        _hdr("Scenario removed", "Refreshing scenarios, predicates, and traces", json_only=json_only)
-        check_scenarios(spec, json_only=json_only)
-        check_predicates(spec, json_only=json_only)
-        check_traces(spec=spec, art_cont=art_cont, art_map=art_map, traces=[], json_only=json_only)
-
-        try:
-            maybe_update_spec_complement(spec)
-        except Exception as e:
-            _note(f"[yellow]⚠[/yellow] Complement update failed (non-fatal): {type(e).__name__}: {e}", json_only=json_only)
-
-        _note("[green]✓[/green] Full refresh complete", json_only=json_only)
-        return
-
-    # ----------------------------
-    # Trace artifacts changed
-    # ----------------------------
-    if isinstance(change, AddTestTrace):
-        if not art_cont.test_traces:
-            return
-
-        tt = art_cont.test_traces[-1]
-        # best-effort sanity check; no-op if mismatch
-        if change.art_id is not None and tt.art_id != change.art_id:
-            pass
-
-        assert tt.art_id is not None
-
-        check_traces(
-            spec=spec,
-            art_cont=art_cont,
-            art_map=art_map,
-            traces=[tt.art_id],
-            json_only=json_only,
-        )
-
-        _note("[green]✓[/green] Trace analysis complete", json_only=json_only)
-        return
-
-    if isinstance(change, AddLogTrace):
-        if not art_cont.log_traces:
-            return
-
-        lt = art_cont.log_traces[-1]
-        if change.art_id is not None and lt.art_id != change.art_id:
-            pass
-
-        assert lt.art_id is not None
-
-        check_traces(
-            spec=spec,
-            art_cont=art_cont,
-            art_map=art_map,
-            traces=[lt.art_id],
-            json_only=json_only,
-        )
-
-        _note("[green]✓[/green] Trace analysis complete", json_only=json_only)
-        return
-
-    if isinstance(change, (EditTestTrace, EditLogTrace)):
-        check_traces(
-            spec=spec,
-            art_cont=art_cont,
-            art_map=art_map,
-            traces=[change.art_id],
-            json_only=json_only,
-        )
-
-        _note("[green]✓[/green] Trace analysis complete", json_only=json_only)
-        return
-
-    # ----------------------------
-    # Explicit no-op branch
-    # ----------------------------
-    # All remaining change types (data artifacts, mapping edits, etc.)
-    # are intentionally ignored here and handled elsewhere.
-    return

speclogician/logic/strings.py

@@ -1,194 +0,0 @@
-#
-#   Imandra Inc.
-#
-#   speclogician/logic/strings.py
-#
-
-
-from __future__ import annotations
-
-import re
-from typing import Sequence
-
-from ..modeling.scenario import Scenario
-
-def parens(x: str) -> str:
-    x = x.strip()
-    return x if (x.startswith("(") and x.endswith(")")) else f"({x})"
-
-
-def and_all(conjuncts: Sequence[str]) -> str:
-    if not conjuncts:
-        return "true"
-    return " && ".join(parens(c) for c in conjuncts)
-
-
-def mk_predicates_only_instance_src(
-    name: str,
-    *,
-    given: Sequence[str],     # state predicate names: p : state -> bool
-    when: Sequence[str],      # action predicate names: q : state -> action -> bool (state first!)
-    state_type: str = "state",
-    action_type: str = "action",
-    state_var: str = "s",
-    action_var: str = "a",
-) -> str:
-    """
-    Consistency query: only predicates (given/when), no transitions.
-
-    Produces:
-          (p1 s) && (q1 s a) && ...
-    """
-    lines : list[str] = ["fun (s : state) (a : action) -> "]
-
-    exprs: list[str] = []
-    exprs += [f"{p} {state_var}" for p in given]
-    exprs += [f"{q} {state_var} {action_var}" for q in when]
-
-    lines.append(f"    {and_all(exprs)}")
-    result =  "\n".join(lines)
-
-    return result
-
-
-def mk_same_action_trace_instance_src(
-    name: str,
-    *,
-    given: Sequence[str],        # state predicate names
-    when: Sequence[str],         # action predicate names
-    transitions: Sequence[str],  # transition fn names: t : state -> action -> state
-    state_type: str = "state",
-    action_type: str = "action",
-    state0_var: str = "s0",
-    action_var: str = "a",
-    when_each_step: bool = True,  # apply action predicates at each pre-state
-) -> str:
-    """
-    Trace query: transitions applied sequentially using the SAME action `a`.
-
-    Produces:
-
-      instance <name> :
-        let s0 : state = s0 in
-        let a  : action = a  in
-        let s1 = t0 s0 a in
-        let s2 = t1 s1 a in
-          (given(s0)) && (when(s0,a)) && (when(s1,a)) ...
-
-    Note: for N transitions, `when` is applied to s0..s{N-1} if when_each_step=True.
-    """
-    lines: list[str] = [f"instance {name} :"]
-
-    # typed existentials
-    lines.append(f"  let {state0_var} : {state_type} = {state0_var} in")
-    lines.append(f"  let {action_var} : {action_type} = {action_var} in")
-
-    # let-chain states
-    # s0 already exists; create s1..sN
-    for i, tname in enumerate(transitions):
-        si = state0_var if i == 0 else f"s{i}"
-        si1 = f"s{i+1}"
-        lines.append(f"  let {si1} = {tname} {si} {action_var} in")
-
-    exprs: list[str] = []
-    exprs += [f"{p} {state0_var}" for p in given]
-
-    if when_each_step:
-        for i in range(len(transitions)):
-            si = state0_var if i == 0 else f"s{i}"
-            exprs += [f"{q} {si} {action_var}" for q in when]
-    else:
-        exprs += [f"{q} {state0_var} {action_var}" for q in when]
-
-    lines.append(f"    {and_all(exprs)}")
-    return "\n".join(lines)
-
-
-def mk_scenario_expr(sc: Scenario, *, s_var: str = "s", a_var: str = "a") -> str:
-    parts: list[str] = []
-    parts += [f"({p} {s_var})" for p in sc.given]
-    parts += [f"({q} {s_var} {a_var})" for q in sc.when]
-    return "true" if not parts else " && ".join(parts)
-
-def mk_spec_disjunction_expr(scenarios: Sequence[Scenario]) -> str:
-    disj = " || ".join(f"({mk_scenario_expr(sc)})" for sc in scenarios)
-    return "false" if not disj else disj
-
-def mk_goal_def(goal_name: str, goal_expr: str, *, needs_action: bool) -> str:
-    if needs_action:
-        return (
-            f"let {goal_name} (s : state) (a : action) : bool =\n"
-            f"  {goal_expr}\n"
-        )
-    else:
-        return (
-            f"let {goal_name} (s : state) : bool =\n"
-            f"  {goal_expr}\n"
-        )
-
-def collect_pred_names(scenarios: Sequence[Scenario]) -> tuple[list[str], list[str]]:
-    state_names: list[str] = []
-    action_names: list[str] = []
-    for sc in scenarios:
-        state_names += list(sc.given)
-        action_names += list(sc.when)
-    return state_names, action_names
-
-LET_RE = re.compile(r"^\s*let\s+([a-zA-Z_][a-zA-Z0-9_']*)\s*(?::\s*[^=]+)?=\s*(.+)$", re.DOTALL)
-
-def normalize_optional(s: str | None) -> str | None:
-    if s is None:
-        return None
-    s2 = s.strip()
-    return s2 if s2 else None
-
-def mk_typed_let(binding_src: str, *, expected_type: str, default_name: str) -> tuple[str, str]:
-    """
-    Returns: (let_src, bound_name)
-    Accepts either:
-      - `let x = ...` (or `let x : t = ...`)  -> keeps x
-      - `<expr>`                              -> wraps as `let <default_name> : expected_type = (<expr>)`
-    """
-    m = LET_RE.match(binding_src.strip())
-    if m:
-        name = m.group(1)
-        # Keep user's let as-is; we just trust their annotation (or lack of).
-        # (Type errors will be caught by eval_model.)
-        return binding_src.strip(), name
-
-    name = default_name
-    let_src = f"let {name} : {expected_type} = (\n{binding_src.strip()}\n)"
-    return let_src, name
-
-def mk_instance_src_for_expr(*, name: str, expr: str, needs_action: bool) -> str:
-    # Assumes `state` and (optionally) `action` exist in the model context.
-    # `expr` must be boolean and can mention `s` and optionally `a`.
-    if needs_action:
-        return f"""
-instance {name} =
-  {{ s : state; a : action }}
-  where {expr}
-"""
-    return f"""
-instance {name} =
-  {{ s : state }}
-  where {expr}
-"""
-
-def errs_to_string(eval_res: object) -> str | None:
-    """
-    Your eval_model result looks like it may have .has_errors and .errors.
-    Convert to a multi-line string.
-    """
-    if not bool(getattr(eval_res, "has_errors", False)):
-        return None
-
-    errs = getattr(eval_res, "errors", None)
-    if not errs:
-        return "Domain/trace model has errors"
-
-    # errs items could be strings or structured; stringify safely
-    lines: list[str] = []
-    for e in errs:
-        lines.append(str(e))
-    return "\n".join(lines)

speclogician/logic/utils.py

@@ -1,135 +0,0 @@
-#
-#   Imandra Inc.
-#
-#   speclogician/logic/utils.py
-#
-
-from __future__ import annotations
-
-from typing import Any, Literal
-
-InstanceStatus = Literal["sat", "unsat", "unknown", "err"]
-
-_ONEOF_CANDIDATES = ("result", "res", "outcome", "status", "response")
-
-def instance_status(res: Any) -> InstanceStatus:
-
-    # 1) Prefer oneof introspection if available
-    for oneof_name in _ONEOF_CANDIDATES:
-        try:
-            which = res.WhichOneof(oneof_name)
-        except Exception:
-            continue
-        if which in ("sat", "unsat", "unknown", "err"):
-            return which  # type: ignore[return-value]
-
-    # 2) Fallback to HasField checks
-    for k in ("sat", "unsat", "unknown", "err"):
-        try:
-            if res.HasField(k):
-                return k  # type: ignore[return-value]
-        except Exception:
-            pass
-
-    # 3) Conservative fallback
-    return "unknown"
-
-
-def instance_is_sat(res: Any) -> bool:
-    return res.sat is not None
-
-def instance_model(res: Any) -> Any | None:
-    """
-    Returns Model if SAT, else None.
-    """
-    return res.sat.model.src if res.sat is not None and res.sat.model is not None else None 
-
-def instance_model_src(res: Any) -> str | None:
-    """
-    Returns Model.src if SAT, else None.
-    """
-    m = instance_model(res)
-    if m is None:
-        return None
-    return getattr(m, "src", None)
-
-
-def instance_model_artifact(res: Any) -> Any | None:
-    """
-    Returns Model.artifact if SAT, else None.
-    """
-    m = instance_model(res)
-    if m is None:
-        return None
-    return getattr(m, "artifact", None)
-
-
-def instance_unsat_proof(res: Any) -> str | None:
-    """
-    Returns Unsat.proof_pp if UNSAT, else None.
-    """
-    if instance_status(res) != "unsat":
-        return None
-    try:
-        return res.unsat.proof_pp
-    except Exception:
-        return None
-
-
-def instance_unknown_reason(res: Any) -> str | None:
-    """
-    Returns unknown StringMsg content if available.
-    `_utils_pb2.StringMsg` typically stores a `msg` or `value` field; handle both.
-    """
-    if instance_status(res) != "unknown":
-        return None
-    u = getattr(res, "unknown", None)
-    if u is None:
-        return None
-    return getattr(u, "msg", None) or getattr(u, "value", None) or str(u)
-
-
-def instance_has_errors(res: Any) -> bool:
-    try:
-        return len(res.errors) > 0
-    except Exception:
-        return False
-
-
-def instance_to_jsonable(res: Any) -> dict[str, Any]:
-    """
-    Minimal, stable JSONable view for SpecLogician logs/CLI:
-      - status
-      - model.src (if sat)
-      - unsat.proof_pp (if unsat)
-      - unknown reason (if unknown)
-      - errors count (+ optionally stringified errors)
-      - task (stringified)
-    """
-    st = instance_status(res)
-    out: dict[str, Any] = {
-        "status": st,
-        "has_errors": instance_has_errors(res),
-        "errors_count": len(res.errors) if hasattr(res, "errors") else 0,
-    }
-
-    if st == "sat":
-        m = res.sat.model
-        out["model"] = {
-            "m_type": str(getattr(m, "m_type", "")),
-            "src": getattr(m, "src", ""),
-            # artifact can be huge; include a string repr unless you want deeper extraction
-            "artifact": str(getattr(m, "artifact", "")),
-        }
-    elif st == "unsat":
-        out["proof_pp"] = getattr(res.unsat, "proof_pp", "")
-    elif st == "unknown":
-        out["reason"] = instance_unknown_reason(res)
-    elif st == "err":
-        out["reason"] = "err"
-
-    # Task is protobuf; stringify safely
-    if hasattr(res, "task"):
-        out["task"] = str(res.task)
-
-    return out

speclogician/modeling/complement.py

@@ -1,104 +0,0 @@
-#
-#   Imandra Inc.
-#
-#   speclogician/modeling/complement.py
-#
-
-from __future__ import annotations
-
-import hashlib
-import json
-from typing import Sequence, Iterable
-
-from pydantic import BaseModel
-from imandrax_api_models import RegionStr
-
-
-class ScenarioComplement(BaseModel):
-    """Result of running region decomposition on all the combined scenarios."""
-    regions: Sequence[RegionStr]
-
-
-class ScenarioComplementDiff(BaseModel):
-    """
-    Difference between two scenario complements (before -> after),
-    computed using stable fingerprints of regions.
-
-    We store only fingerprints by default (regions can be huge).
-    """
-    num_regions_before: int
-    num_regions_after: int
-    regions_added: list[str]      # fingerprints that appear in after but not before
-    regions_removed: list[str]    # fingerprints that appear in before but not after
-
-
-def _canon_region_str(r: RegionStr) -> str:
-    """
-    Produce a deterministic string representation of a RegionStr.
-
-    We prefer a canonical JSON-ish blob rather than str(r) because:
-      - __repr__ / __str__ may change
-      - dict ordering may vary
-    """
-    # constraints_str is typically a list of strings
-    constraints = list(getattr(r, "constraints_str", []) or [])
-
-    invariant = getattr(r, "invariant_str", "") or ""
-    model_eval = getattr(r, "model_eval_str", "") or ""
-
-    # model_str can be dict-like (often {'s': '{x = 0}'}). Canonicalize ordering.
-    model = getattr(r, "model_str", None)
-    if isinstance(model, dict):
-        # stringify values to avoid non-jsonable shapes
-        model_items = {str(k): str(v) for k, v in sorted(model.items(), key=lambda kv: str(kv[0]))}
-    elif model is None:
-        model_items = {}
-    else:
-        # fallback: stringify
-        model_items = {"_": str(model)}
-
-    payload = {
-        "constraints": constraints,
-        "invariant": invariant,
-        "model": model_items,
-        "model_eval": model_eval,
-    }
-
-    # separators for stable compact encoding
-    return json.dumps(payload, sort_keys=True, separators=(",", ":"))
-
-
-def _fingerprint_region(r: RegionStr | str) -> str:
-    """
-    Stable-ish fingerprint for a RegionStr (or a raw string region).
-    """
-    if isinstance(r, RegionStr):
-        s = _canon_region_str(r)
-    else:
-        s = str(r)
-
-    h = hashlib.sha256(s.encode("utf-8")).hexdigest()
-    # short prefix is plenty for diffs + UI, but keep full if you prefer
-    return h[:16]
-
-
-def _fingerprints(regions: Iterable[RegionStr | str]) -> set[str]:
-    return {_fingerprint_region(r) for r in regions}
-
-
-def diff_scenario_complement(before: ScenarioComplement, after: ScenarioComplement) -> ScenarioComplementDiff:
-    before_regions = list(before.regions or [])
-    after_regions = list(after.regions or [])
-
-    bf = _fingerprints(before_regions)
-    af = _fingerprints(after_regions)
-
-    added = sorted(list(af - bf))
-    removed = sorted(list(bf - af))
-
-    return ScenarioComplementDiff(
-        num_regions_before=len(before_regions),
-        num_regions_after=len(after_regions),
-        regions_added=added,
-        regions_removed=removed,
-    )