speclogician 0.0.0b1__py3-none-any.whl

speclogician/presentation/builders/data_artifact.py

@@ -0,0 +1,42 @@
+#
+#   Imandra Inc.
+#
+#   speclogician/presentation/builders/data_artifact.py
+#
+
+from __future__ import annotations
+
+from speclogician.presentation.ctx import RenderCtx
+from speclogician.presentation.models.data_artifact import (
+    DataArtifactCorePM,
+    DocRefPM,
+    SrcCodeRefPM,
+)
+
+from speclogician.data.refs import DocRef, SrcCodeRef  # adjust if needed
+
+
+def _build_core(art_id: str) -> DataArtifactCorePM:
+    return DataArtifactCorePM(art_id=art_id)
+
+
+def build_doc_ref_pm(d: DocRef, ctx: RenderCtx) -> DocRefPM:
+    # Text is the artifact; keep it unless you want a separate ctx flag for "heavy text"
+    text = d.text if getattr(ctx, "show_code", True) else d.text
+    return DocRefPM(
+        core=_build_core(d.art_id),
+        text=text,
+        meta=d.meta,
+    )
+
+
+def build_src_code_ref_pm(s: SrcCodeRef, ctx: RenderCtx) -> SrcCodeRefPM:
+    show = getattr(ctx, "show_code", True)
+    return SrcCodeRefPM(
+        core=_build_core(s.art_id),
+        src_code=s.src_code if show else "",
+        language=s.language,
+        file_path=s.file_path,
+        iml_code=s.iml_code if show else None,
+        meta=s.meta,
+    )

speclogician/presentation/builders/domain.py

@@ -0,0 +1,54 @@
+#
+#   Imandra Inc.
+#
+#   speclogician/presentation/builders/domain.py
+#
+
+from __future__ import annotations
+
+from speclogician.modeling.domain import DomainModel
+from speclogician.presentation.ctx import RenderCtx
+from speclogician.presentation.models.domain import (
+    DomainModelPM,
+    DomainCountsPM,
+    DomainCodePM,
+)
+
+
+def build_domain_model_pm(dm: DomainModel, ctx: RenderCtx) -> DomainModelPM:
+    counts = DomainCountsPM(
+        base_status=dm.base_status,
+        base_has_state=dm.base_has_state,
+        base_has_action=dm.base_has_action,
+        num_state_preds_total=dm.num_state_preds_total,
+        num_state_preds_valid_logic=dm.num_state_preds_valid_logic,
+        num_state_preds_matched=dm.num_state_preds_matched,
+        num_action_preds_total=dm.num_action_preds_total,
+        num_action_preds_valid_logic=dm.num_action_preds_valid_logic,
+        num_action_preds_matched=dm.num_action_preds_matched,
+        num_preds_total=dm.num_preds_total,
+        num_preds_valid_logic=dm.num_preds_valid_logic,
+        num_preds_matched=dm.num_preds_matched,
+        num_trans_total=dm.num_trans_total,
+        num_trans_valid_logic=dm.num_trans_valid_logic,
+        num_trans_matched=dm.num_trans_matched,
+    )
+
+    # Always construct code PM for stable JSON; keep fields empty unless requested.
+    code = DomainCodePM()
+
+    if not ctx.show_stats_only and ctx.show_code:
+        # Base
+        if getattr(ctx, "show_base", True):
+            code.base = dm.base or ""
+
+        # Predicates
+        if getattr(ctx, "show_predicates", True):
+            code.state_preds_iml = "\n\n".join(p.to_iml() for p in dm.state_preds).strip()
+            code.action_preds_iml = "\n\n".join(p.to_iml() for p in dm.action_preds).strip()
+
+        # Transitions
+        if getattr(ctx, "show_transitions", True):
+            code.transitions_iml = "\n\n".join(t.to_iml() for t in dm.transitions).strip()
+
+    return DomainModelPM(counts=counts, code=code)

speclogician/presentation/builders/instances_list.py

@@ -0,0 +1,38 @@
+#
+#   Imandra Inc.
+#
+#   speclogician/presentation/builders/instances_list.py
+#
+
+from __future__ import annotations
+
+from speclogician.presentation.ctx import RenderCtx
+from speclogician.presentation.models.instances_list import InstancesListPM, InstancesListRowPM
+from speclogician.presentation.builders.state_instance_summary import build_state_instance_summary_pm
+from speclogician.state.inst import StateInstance
+
+
+def _changes_str(si: StateInstance) -> str:
+    if not (si.changes or []):
+        return "-"
+
+    parts: list[str] = []
+    for ch in si.changes:
+        short = getattr(ch, "short_str", None)
+        parts.append(short() if callable(short) else ch.__class__.__name__)
+    return ", ".join(parts)
+
+
+def build_instances_list_pm(states: list[StateInstance], ctx: RenderCtx) -> InstancesListPM:
+    rows: list[InstancesListRowPM] = []
+    for idx, si in enumerate(states):
+        state_label = "latest" if idx == 0 else str(idx)
+        rows.append(
+            InstancesListRowPM(
+                state_label=state_label,
+                changes=_changes_str(si),
+                summary=build_state_instance_summary_pm(si, ctx=ctx),
+            )
+        )
+
+    return InstancesListPM(rows=rows)

speclogician/presentation/builders/predicate.py

@@ -0,0 +1,51 @@
+#   
+#   Imandra Inc.
+#
+#   speclogician/presentation/builders/predicate.py
+#
+
+from __future__ import annotations
+
+from speclogician.modeling.predicates import ActionPredicate, PredicateType, StatePredicate, Transition
+from speclogician.presentation.ctx import RenderCtx
+from speclogician.presentation.builders._links import build_links_pm
+from speclogician.presentation.models.predicate import PredicatePM, TransitionPM
+
+
+def build_predicate_pm(p: StatePredicate | ActionPredicate, ctx: RenderCtx) -> PredicatePM:
+    pred_type = PredicateType.STATE if isinstance(p, StatePredicate) else PredicateType.ACTION
+    signature = f"{p.name} s" if pred_type == PredicateType.STATE else f"{p.name} s a"
+
+    # Prefer to_iml if present (yours is)
+    iml = p.to_iml() if hasattr(p, "to_iml") else ""
+
+    return PredicatePM(
+        kind=p.kind,  # "state_predicate" | "action_predicate"
+        comp_id=p.comp_id,
+        name=p.name,
+        last_updated=p.last_updated,
+        pred_type=pred_type,
+        signature=signature,
+        src_code=p.src_code or "",
+        iml=iml,
+        is_iml_valid=p.is_iml_valid,
+        iml_error=p.iml_error,
+        links=build_links_pm(p.comp_id, ctx),
+    )
+
+
+def build_transition_pm(t: Transition, ctx: RenderCtx) -> TransitionPM:
+    signature = f"{t.name} s a"
+    iml = t.to_iml() if hasattr(t, "to_iml") else ""
+
+    return TransitionPM(
+        comp_id=t.comp_id,
+        name=t.name,
+        last_updated=t.last_updated,
+        signature=signature,
+        src_code=t.src_code or "",
+        iml=iml,
+        is_iml_valid=t.is_iml_valid,
+        iml_error=t.iml_error,
+        links=build_links_pm(t.comp_id, ctx),
+    )

speclogician/presentation/builders/recommendations.py

@@ -0,0 +1,41 @@
+#
+#   Imandra Inc.
+#
+#   speclogician/presentation/builders/recommendations.py
+#
+
+from __future__ import annotations
+
+from speclogician.presentation.ctx import RenderCtx
+from speclogician.presentation.models.recommendations import (
+    RecommendationsPM,
+    RecommendationPM,
+)
+from speclogician.state.recommender import Recommendation
+
+
+def build_recommendations_pm(
+    recs: list[Recommendation] | None,
+    ctx: RenderCtx,
+) -> RecommendationsPM:
+    rs = list(recs or [])
+
+    # UI wants stable ordering: priority asc, then kind, then text
+    rs.sort(key=lambda r: (r.priority, r.kind, r.text))
+
+    items = [RecommendationPM(kind=r.kind, priority=r.priority, text=r.text) for r in rs]
+
+    # counts
+    n_error = sum(1 for r in items if r.kind == "error")
+    n_warn = sum(1 for r in items if r.kind == "warning")
+    n_next = sum(1 for r in items if r.kind == "next")
+    n_info = sum(1 for r in items if r.kind == "info")
+
+    return RecommendationsPM(
+        count=len(items),
+        items=items,
+        num_error=n_error,
+        num_warning=n_warn,
+        num_next=n_next,
+        num_info=n_info,
+    )

speclogician/presentation/builders/scenario.py

@@ -0,0 +1,41 @@
+#
+#   Imandra Inc.
+#
+#   speclogician/presentation/builders/scenario.py
+#
+
+from __future__ import annotations
+
+from speclogician.presentation.ctx import RenderCtx
+from speclogician.modeling.scenario import Scenario, Missing, Inconsistent
+from speclogician.presentation.models.scenario import (
+    ScenarioPM,
+    ScenarioStatusPM,
+)
+
+
+def build_scenario_pm(sc: Scenario, ctx: RenderCtx) -> ScenarioPM:
+    # status
+    st = sc.component_status
+    if isinstance(st, Missing):
+        status = ScenarioStatusPM(
+            kind="missing",
+            missing_preds=list(st.missing_preds),
+            missing_trans=list(st.missing_trans),
+        )
+    elif isinstance(st, Inconsistent):
+        status = ScenarioStatusPM(kind="inconsistent")
+    else:
+        status = ScenarioStatusPM(kind="valid")
+
+    return ScenarioPM(
+        comp_id=sc.comp_id,
+        name=sc.name,
+        status=status,
+        given=list(sc.given),
+        when=list(sc.when),
+        then=list(sc.then),
+        given_preds_consistent=sc.given_preds_consistent,
+        when_preds_consistent=sc.when_preds_consistent,
+        all_preds_consistent=sc.all_preds_consistent,
+    )

speclogician/presentation/builders/scenario_complement.py

@@ -0,0 +1,82 @@
+#
+#   Imandra Inc.
+#
+#   speclogician/presentation/builders/scenario_complement.py
+#
+
+from __future__ import annotations
+
+from speclogician.presentation.ctx import RenderCtx
+from speclogician.presentation.models.scenario_complement import (
+    ScenarioComplementPM,
+    ScenarioComplementRegionPM,
+)
+
+from speclogician.modeling.complement import ScenarioComplement, _fingerprint_region
+
+
+def _safe_list(x) -> list:
+    try:
+        return list(x or [])
+    except Exception:
+        return []
+
+
+def build_scenario_complement_pm(
+    comp: ScenarioComplement | None,
+    ctx: RenderCtx,
+    *,
+    preview_limit: int = 10,
+    constraints_preview_limit: int = 3,
+) -> ScenarioComplementPM:
+    if comp is None:
+        return ScenarioComplementPM(count_regions=0, regions_preview=[])
+
+    regs = _safe_list(getattr(comp, "regions", None))
+    count = len(regs)
+
+    # show only a few regions in the UI
+    preview_regs = regs[: max(0, int(preview_limit))]
+
+    items: list[ScenarioComplementRegionPM] = []
+    for r in preview_regs:
+        fp = _fingerprint_region(r)
+
+        constraints = _safe_list(getattr(r, "constraints_str", None))
+        invariant = (getattr(r, "invariant_str", None) or None)
+        model_eval = (getattr(r, "model_eval_str", None) or None)
+
+        # model_str can be dict-like; stringify for display
+        model_obj = getattr(r, "model_str", None)
+        if model_obj is None:
+            model_s = None
+        else:
+            try:
+                model_s = str(model_obj)
+            except Exception:
+                model_s = "<unprintable>"
+
+        # If ctx.show_code is False, keep it extra light.
+        if not ctx.show_code:
+            invariant = None
+            model_s = None
+            model_eval = None
+            constraints_preview: list[str] = []
+        else:
+            constraints_preview = [str(c) for c in constraints[: max(0, int(constraints_preview_limit))]]
+
+        items.append(
+            ScenarioComplementRegionPM(
+                fp=fp,
+                num_constraints=len(constraints),
+                invariant=invariant,
+                model=model_s,
+                model_eval=model_eval,
+                constraints_preview=constraints_preview,
+            )
+        )
+
+    return ScenarioComplementPM(
+        count_regions=count,
+        regions_preview=items,
+    )

speclogician/presentation/builders/smart_find.py

@@ -0,0 +1,39 @@
+#
+#   Imandra Inc.
+#
+#   speclogician/presentation/builders/smart_find.py
+#
+
+from __future__ import annotations
+
+from speclogician.data.container import SmartFindResults
+from speclogician.presentation.ctx import RenderCtx
+from speclogician.presentation.models.smart_find import (
+    SmartFindPM,
+    SmartFindCountsPM,
+    SmartFindItemsPM,
+)
+
+from speclogician.presentation.builders.trace import build_test_trace_pm, build_log_trace_pm
+from speclogician.presentation.builders.data_artifact import build_doc_ref_pm, build_src_code_ref_pm
+
+
+def build_smart_find_pm(res: SmartFindResults, ctx: RenderCtx) -> SmartFindPM:
+    counts = SmartFindCountsPM(
+        needle=res.needle,
+        num_test_traces=len(res.test_traces),
+        num_log_traces=len(res.log_traces),
+        num_doc_refs=len(res.doc_refs),
+        num_src_code_refs=len(res.src_code_refs),
+    )
+
+    items = SmartFindItemsPM()
+
+    # If stats-only, skip the heavy lists.
+    if not ctx.show_stats_only:
+        items.test_traces = [build_test_trace_pm(t, ctx) for t in res.test_traces]
+        items.log_traces = [build_log_trace_pm(t, ctx) for t in res.log_traces]
+        items.doc_refs = [build_doc_ref_pm(d, ctx) for d in res.doc_refs]
+        items.src_code_refs = [build_src_code_ref_pm(s, ctx) for s in res.src_code_refs]
+
+    return SmartFindPM(counts=counts, items=items)

speclogician/presentation/builders/spec.py

@@ -0,0 +1,39 @@
+#
+#   Imandra Inc.
+#
+#   speclogician/presentation/builders/spec.py
+#
+
+from __future__ import annotations
+
+from speclogician.modeling.spec import Spec
+from speclogician.presentation.ctx import RenderCtx
+from speclogician.presentation.builders.domain import build_domain_model_pm
+from speclogician.presentation.builders.scenario_complement import (
+    build_scenario_complement_pm,
+)
+from speclogician.presentation.models.spec import SpecPM, SpecCountsPM
+
+
+def build_spec_pm(spec: Spec, ctx: RenderCtx) -> SpecPM:
+    dm_pm = build_domain_model_pm(spec.domain_model, ctx)
+
+    counts = SpecCountsPM(
+        num_sc_total=spec.num_sc_total,
+        num_sc_missing=spec.num_sc_missing,
+        num_sc_matched=spec.num_sc_matched,
+        num_sc_inconsistent=spec.num_sc_inconsistent,
+        num_sc_conflicted=spec.num_sc_conflicted,
+    )
+
+    scenario_names = [s.name for s in (spec.scenarios or [])]
+
+    return SpecPM(
+        domain=dm_pm,
+        counts=counts,
+        scenario_names=scenario_names,
+        scenario_complement=build_scenario_complement_pm(
+            getattr(spec, "scenario_comp", None),
+            ctx,
+        ),
+    )

speclogician/presentation/builders/state_diff.py

@@ -0,0 +1,150 @@
+#
+#   Imandra Inc.
+#
+#   speclogician/presentation/builders/state_diff.py
+#
+
+from __future__ import annotations
+
+from typing import Any
+
+from speclogician.presentation.ctx import RenderCtx
+from speclogician.presentation.models.state_diff import (
+    StateDiffPM,
+    DiffSectionPM,
+    DiffRowPM,
+)
+from speclogician.state.diff import StateDiff, ValueDiff, ComparisonOutcome
+
+
+def _outcome(vd: ValueDiff[Any]) -> ComparisonOutcome:
+    if vd.comp_func:
+        return vd.comp_func(vd.before, vd.after)
+    if vd.before == vd.after:
+        return ComparisonOutcome.NO_CHANGE
+    return ComparisonOutcome.UNKNOWN
+
+
+def _message(vd: ValueDiff[Any]) -> str:
+    oc = _outcome(vd)
+    b = vd.before
+    a = vd.after
+
+    match oc:
+        case ComparisonOutcome.UNKNOWN:
+            return f"{vd.label}: Unknown: {b} -> {a}"
+        case ComparisonOutcome.NO_CHANGE:
+            return f"{vd.label}: No change: {b} -> {a}"
+        case ComparisonOutcome.NO_CHANGE_GOOD:
+            return f"{vd.label}: No change (good): {b} -> {a}"
+        case ComparisonOutcome.NO_CHANGE_BAD:
+            return f"{vd.label}: No change (bad): {b} -> {a}"
+        case ComparisonOutcome.IMPROVED:
+            return f"{vd.label}: Improvement: {b} -> {a}"
+        case ComparisonOutcome.DECLINED:
+            return f"{vd.label}: Decline: {b} -> {a}"
+        case _:
+            return f"{vd.label}: {b} -> {a}"
+
+
+def _row(vd: ValueDiff[Any]) -> DiffRowPM:
+    return DiffRowPM(
+        label=vd.label,
+        before=vd.before,
+        after=vd.after,
+        outcome=_outcome(vd),
+        message=_message(vd),
+    )
+
+
+def build_state_diff_pm(sd: StateDiff, ctx: RenderCtx) -> StateDiffPM:
+    sections: list[DiffSectionPM] = []
+
+    def add(title: str, vds: list[ValueDiff[Any]]) -> None:
+        rows = [_row(vd) for vd in vds if vd.is_different()]
+        if rows:
+            sections.append(DiffSectionPM(title=title, rows=rows))
+
+    # ---- Domain model ----
+    add("Domain Model: Base", [sd.base_status, sd.base_has_state, sd.base_has_action])
+
+    add(
+        "Domain Model: State predicates",
+        [
+            sd.num_state_preds_total,
+            sd.num_state_preds_matched,
+            sd.num_state_preds_valid_logic,
+            sd.num_state_preds_errored,
+        ],
+    )
+
+    add(
+        "Domain Model: Action predicates",
+        [
+            sd.num_action_preds_total,
+            sd.num_action_preds_matched,
+            sd.num_action_preds_valid_logic,
+            sd.num_action_preds_errored,
+        ],
+    )
+
+    add(
+        "Domain Model: Predicates (total)",
+        [
+            sd.num_preds_total,
+            sd.num_preds_matched,
+            sd.num_preds_valid_logic,
+            sd.num_preds_errored,
+        ],
+    )
+
+    add(
+        "Domain Model: Transitions",
+        [
+            sd.num_trans_total,
+            sd.num_trans_matched,
+            sd.num_trans_valid_logic,
+            sd.num_trans_errored,
+        ],
+    )
+
+    # ---- Scenarios + conflicts ----
+    add(
+        "Scenarios",
+        [
+            sd.num_sc_total,
+            sd.num_sc_missing,
+            sd.num_sc_matched,
+            sd.num_sc_inconsistent,
+        ],
+    )
+
+    add(
+        "Scenario conflicts",
+        [
+            sd.num_sc_conflicted,
+            sd.num_sc_overlap,
+            sd.num_sc_consumed,
+        ],
+    )
+
+    # ---- Artifacts ----
+    add(
+        "Test traces",
+        [
+            sd.num_test_traces_total,
+            sd.num_test_traces_logic_good,
+            sd.num_test_traces_matched,
+        ],
+    )
+
+    add(
+        "Log traces",
+        [
+            sd.num_log_traces_total,
+            sd.num_log_traces_logic_good,
+            sd.num_log_traces_matched,
+        ],
+    )
+
+    return StateDiffPM(has_changes=bool(sections), sections=sections)

speclogician/presentation/builders/state_instance.py

@@ -0,0 +1,42 @@
+#
+#   Imandra Inc.
+#
+#   speclogician/presentation/builders/state_instance.py
+#
+
+from __future__ import annotations
+
+from speclogician.presentation.ctx import RenderCtx
+from speclogician.presentation.models.state_instance import StateInstancePM
+from speclogician.presentation.builders.state_instance_summary import (
+    build_state_instance_summary_pm,
+)
+
+from speclogician.presentation.builders.spec import build_spec_pm
+from speclogician.presentation.builders.container import build_artifact_container_pm
+from speclogician.presentation.builders.state_diff import build_state_diff_pm
+from speclogician.presentation.builders.recommendations import build_recommendations_pm
+
+from speclogician.state.inst import StateInstance
+
+
+def build_state_instance_pm(si: StateInstance, ctx: RenderCtx) -> StateInstancePM:
+    summary_pm = build_state_instance_summary_pm(si, ctx)
+
+    recommendations_pm = build_recommendations_pm(si.recommendations, ctx)
+
+    pm = StateInstancePM(summary=summary_pm, recommendations=recommendations_pm)
+
+    # -----------------
+    # Heavy parts (optional)
+    # -----------------
+    if not ctx.show_stats_only:
+        pm.spec = build_spec_pm(si.spec, ctx)
+        pm.artifacts = build_artifact_container_pm(si.art_container, ctx)
+
+        if si.state_diff is not None:
+            pm.state_diff = build_state_diff_pm(si.state_diff, ctx)
+        else:
+            pm.state_diff = None
+
+    return pm