speclogician 0.0.0b1__py3-none-any.whl

speclogician/presentation/preview/fixtures/domain_model.py

@@ -0,0 +1,162 @@
+#
+#   Imandra Inc.
+#
+#   speclogician/presentation/preview/fixtures/domain_model.py
+#
+
+from __future__ import annotations
+
+from speclogician.modeling.domain import BaseStatus
+from speclogician.presentation.models.domain import (
+    DomainCountsPM,
+    DomainCodePM,
+    DomainModelPM,
+)
+from speclogician.presentation.ctx import RenderCtx
+
+
+# -----------------------------------------------------------------------------
+# PM builders (variants)
+# -----------------------------------------------------------------------------
+
+def make_domain_model_pm(ctx: RenderCtx, variant: str = "typical") -> DomainModelPM:
+    v = (variant or "typical").lower()
+    if v == "minimal":
+        return minimal_domain_model_pm()
+    if v == "edge":
+        return edge_domain_model_pm()
+    return typical_domain_model_pm()
+
+
+def minimal_domain_model_pm() -> DomainModelPM:
+    # Minimal = almost empty, base unknown, no code.
+    counts = DomainCountsPM(
+        base_status=BaseStatus.UNKNOWN,
+        base_has_state=False,
+        base_has_action=False,
+        num_state_preds_total=0,
+        num_state_preds_valid_logic=0,
+        num_state_preds_matched=0,
+        num_action_preds_total=0,
+        num_action_preds_valid_logic=0,
+        num_action_preds_matched=0,
+        num_preds_total=0,
+        num_preds_valid_logic=0,
+        num_preds_matched=0,
+        num_trans_total=0,
+        num_trans_valid_logic=0,
+        num_trans_matched=0,
+    )
+    code = DomainCodePM(
+        base="",
+        state_preds_iml="",
+        action_preds_iml="",
+        transitions_iml="",
+    )
+    return DomainModelPM(counts=counts, code=code)
+
+
+def typical_domain_model_pm() -> DomainModelPM:
+    # Typical = sane + readable, some matched/valid numbers.
+    counts = DomainCountsPM(
+        base_status=BaseStatus.VALID,
+        base_has_state=True,
+        base_has_action=True,
+        # state preds
+        num_state_preds_total=4,
+        num_state_preds_valid_logic=3,
+        num_state_preds_matched=2,
+        # action preds
+        num_action_preds_total=3,
+        num_action_preds_valid_logic=3,
+        num_action_preds_matched=1,
+        # totals
+        num_preds_total=7,
+        num_preds_valid_logic=6,
+        num_preds_matched=3,
+        # transitions
+        num_trans_total=2,
+        num_trans_valid_logic=2,
+        num_trans_matched=1,
+    )
+    code = DomainCodePM(
+        base=(
+            "type state = { x : int }\n"
+            "type action = int\n"
+        ),
+        state_preds_iml=(
+            "let pred_eq_ten (s: state) = s.x = 10\n"
+            "let pred_lt_ten (s: state) = s.x < 10\n"
+            "let pred_gt_zero (s: state) = s.x > 0\n"
+        ),
+        action_preds_iml=(
+            "let act_gt_x (s: state) (a: action) = a > s.x\n"
+            "let act_eq_zero (_s: state) (a: action) = a = 0\n"
+        ),
+        transitions_iml=(
+            "let step1 (s: state) (a: action) : state = { x = s.x + a }\n"
+            "let step2 (_s: state) (a: action) : state = { x = a }\n"
+        ),
+    )
+    return DomainModelPM(counts=counts, code=code)
+
+
+def edge_domain_model_pm() -> DomainModelPM:
+    # Edge = stress the renderer: long code, weird counts, invalid base.
+    counts = DomainCountsPM(
+        base_status=BaseStatus.INVALID_IML,
+        base_has_state=True,
+        base_has_action=False,
+        # state preds
+        num_state_preds_total=12,
+        num_state_preds_valid_logic=7,
+        num_state_preds_matched=0,
+        # action preds
+        num_action_preds_total=0,
+        num_action_preds_valid_logic=0,
+        num_action_preds_matched=0,
+        # totals
+        num_preds_total=12,
+        num_preds_valid_logic=7,
+        num_preds_matched=0,
+        # transitions
+        num_trans_total=5,
+        num_trans_valid_logic=2,
+        num_trans_matched=0,
+    )
+    code = DomainCodePM(
+        base=(
+            "type state = {\n"
+            "  x : int;\n"
+            "  (* missing action type on purpose to simulate INVALID base *)\n"
+            "}\n"
+        ),
+        state_preds_iml=(
+            "(* many predicates, including a long one to wrap *)\n"
+            + "\n".join(
+                f"let pred_{i} (s: state) = s.x = {i}"
+                for i in range(1, 10)
+            )
+            + "\n"
+            "let pred_very_long (s: state) = "
+            "(s.x > 0 && s.x < 1000000 && (s.x mod 3 = 0 || s.x mod 5 = 0))\n"
+        ),
+        action_preds_iml="",  # missing because base_has_action=False
+        transitions_iml=(
+            "(* some transitions, one intentionally sketchy *)\n"
+            "let step_ok (s: state) (_a: int) : state = { x = s.x }\n"
+            "let step_weird (s: state) (a: int) : state = { x = s.x + (a + 1) }\n"
+            "(* malformed-ish snippet *)\n"
+            "let step_bad (s: state) (a: int) : state = { x = s.x + }\n"
+        ),
+    )
+    return DomainModelPM(counts=counts, code=code)
+
+
+# -----------------------------------------------------------------------------
+# renderer adapter (matches other fixtures style)
+# -----------------------------------------------------------------------------
+
+def render(pm: DomainModelPM, ctx: RenderCtx):
+    from speclogician.presentation.renderers.domain import render_domain_model
+    return render_domain_model(pm, ctx=ctx)

speclogician/presentation/preview/fixtures/instances_list.py

@@ -0,0 +1,162 @@
+#
+#   Imandra Inc.
+#
+#   speclogician/presentation/preview/fixtures/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.models.state_instance_summary import StateInstanceSummaryPM
+from speclogician.utils import IMLValidity
+from speclogician.modeling.domain import BaseStatus
+
+
+# -----------------------------------------------------------------------------
+# helpers
+# -----------------------------------------------------------------------------
+
+def _summary(
+    *,
+    created_at: str,
+    num_changes: int,
+    base_status: BaseStatus = BaseStatus.UNKNOWN,
+    base_has_state: bool = False,
+    base_has_action: bool = False,
+    num_preds_total: int = 0,
+    num_preds_matched: int = 0,
+    num_trans_total: int = 0,
+    num_trans_valid_logic: int = 0,
+    num_sc_total: int = 0,
+    num_sc_missing: int = 0,
+    num_sc_inconsistent: int = 0,
+    num_sc_conflicted: int = 0,
+    num_test_traces_total: int = 0,
+    num_test_traces_logic_good: int = 0,
+    num_log_traces_total: int = 0,
+    num_log_traces_logic_good: int = 0,
+) -> StateInstanceSummaryPM:
+    return StateInstanceSummaryPM(
+        created_at=created_at,
+        num_changes=num_changes,
+        base_status=base_status,
+        base_has_state=base_has_state,
+        base_has_action=base_has_action,
+        num_preds_total=num_preds_total,
+        num_preds_matched=num_preds_matched,
+        num_trans_total=num_trans_total,
+        num_trans_valid_logic=num_trans_valid_logic,
+        num_sc_total=num_sc_total,
+        num_sc_missing=num_sc_missing,
+        num_sc_inconsistent=num_sc_inconsistent,
+        num_sc_conflicted=num_sc_conflicted,
+        num_test_traces_total=num_test_traces_total,
+        num_test_traces_logic_good=num_test_traces_logic_good,
+        num_log_traces_total=num_log_traces_total,
+        num_log_traces_logic_good=num_log_traces_logic_good,
+    )
+
+
+# -----------------------------------------------------------------------------
+# fixtures
+# -----------------------------------------------------------------------------
+
+def minimal_instances_list_pm() -> InstancesListPM:
+    return InstancesListPM(rows=[])
+
+
+def typical_instances_list_pm() -> InstancesListPM:
+    return InstancesListPM(
+        rows=[
+            InstancesListRowPM(
+                state_label="latest",
+                changes="DomainModelBaseEdit, PredicateAdd",
+                summary=_summary(
+                    created_at="2026-01-09T10:12:00Z",
+                    num_changes=2,
+                    base_status=BaseStatus.VALID,
+                    base_has_state=True,
+                    base_has_action=True,
+                    num_preds_total=12,
+                    num_preds_matched=7,
+                    num_trans_total=4,
+                    num_trans_valid_logic=3,
+                    num_sc_total=9,
+                    num_sc_missing=1,
+                    num_test_traces_total=8,
+                    num_test_traces_logic_good=6,
+                    num_log_traces_total=4,
+                    num_log_traces_logic_good=4,
+                ),
+            ),
+            InstancesListRowPM(
+                state_label="1",
+                changes="PredicateEdit",
+                summary=_summary(
+                    created_at="2026-01-09T09:55:10Z",
+                    num_changes=1,
+                    base_status=BaseStatus.VALID,
+                    base_has_state=True,
+                    base_has_action=True,
+                    num_preds_total=11,
+                    num_preds_matched=6,
+                    num_trans_total=4,
+                    num_trans_valid_logic=3,
+                    num_sc_total=8,
+                    num_sc_missing=0,
+                    num_test_traces_total=7,
+                    num_test_traces_logic_good=6,
+                    num_log_traces_total=3,
+                    num_log_traces_logic_good=3,
+                ),
+            ),
+        ]
+    )
+
+
+def edge_instances_list_pm() -> InstancesListPM:
+    return InstancesListPM(
+        rows=[
+            InstancesListRowPM(
+                state_label="latest",
+                changes="",
+                summary=_summary(
+                    created_at="2026-01-09T10:12:00.123456Z",
+                    num_changes=0,
+                    base_status=BaseStatus.UNKNOWN,
+                    base_has_state=False,
+                    base_has_action=False,
+                    num_preds_total=0,
+                    num_preds_matched=0,
+                    num_trans_total=0,
+                    num_trans_valid_logic=0,
+                    num_sc_total=0,
+                    num_sc_missing=0,
+                    num_test_traces_total=0,
+                    num_test_traces_logic_good=0,
+                    num_log_traces_total=0,
+                    num_log_traces_logic_good=0,
+                ),
+            )
+        ]
+    )
+
+def make_instances_list_pm(ctx: RenderCtx, variant: str = "typical") -> InstancesListPM:
+    v = (variant or "typical").strip().lower()
+
+    if v == "minimal":
+        return minimal_instances_list_pm()
+
+    if v == "edge":
+        return edge_instances_list_pm()
+
+    return typical_instances_list_pm()
+
+
+def render(pm: InstancesListPM, ctx : RenderCtx):
+    from speclogician.presentation.renderers.instances_list import render_instances_list
+    return render_instances_list(pm, ctx=ctx)

speclogician/presentation/preview/fixtures/predicate.py

@@ -0,0 +1,184 @@
+#
+#   Imandra Inc.
+#
+#   speclogician/presentation/preview/fixtures/predicate.py
+#
+
+from __future__ import annotations
+
+from datetime import datetime, timezone
+from speclogician.presentation.ctx import RenderCtx
+from speclogician.presentation.models.predicate import (
+    PredicatePM,
+    TransitionPM,
+    LinkedArtifactsPM,
+)
+from speclogician.modeling.predicates import PredicateType
+from speclogician.utils import IMLValidity
+
+
+NOW = datetime(2026, 1, 9, 10, 12, tzinfo=timezone.utc)
+
+
+# -----------------------------------------------------------------------------
+# Shared helpers
+# -----------------------------------------------------------------------------
+
+def _minimal_links() -> LinkedArtifactsPM:
+    return LinkedArtifactsPM()
+
+
+def _typical_links() -> LinkedArtifactsPM:
+    return LinkedArtifactsPM(
+        total=4,
+        test_traces=2,
+        log_traces=1,
+        doc_refs=1,
+        src_code_refs=0,
+        unresolved_ids=0,
+        art_ids=["tt-1", "tt-2", "log-1", "doc-1"],
+    )
+
+
+def _edge_links() -> LinkedArtifactsPM:
+    return LinkedArtifactsPM(
+        total=12,
+        test_traces=5,
+        log_traces=3,
+        doc_refs=2,
+        src_code_refs=1,
+        unresolved_ids=1,
+        art_ids=[f"art-{i}" for i in range(12)],
+    )
+
+
+# -----------------------------------------------------------------------------
+# PredicatePM variants
+# -----------------------------------------------------------------------------
+
+def _predicate_minimal() -> PredicatePM:
+    return PredicatePM(
+        kind="state_predicate",
+        comp_id="pred-min",
+        name="",
+        last_updated=NOW,
+        pred_type=PredicateType.STATE,
+        signature="",
+        src_code="",
+        iml="",
+        is_iml_valid=IMLValidity.UNKNOWN,
+        iml_error=None,
+        links=_minimal_links(),
+    )
+
+
+def _predicate_typical() -> PredicatePM:
+    return PredicatePM(
+        kind="state_predicate",
+        comp_id="pred-001",
+        name="pred_eq_ten",
+        last_updated=NOW,
+        pred_type=PredicateType.STATE,
+        signature="state -> bool",
+        src_code="s.x = 10",
+        iml="let pred_eq_ten (s: state) = s.x = 10",
+        is_iml_valid=IMLValidity.VALID,
+        iml_error=None,
+        links=_typical_links(),
+    )
+
+
+def _predicate_edge() -> PredicatePM:
+    return PredicatePM(
+        kind="action_predicate",
+        comp_id="pred-edge-999",
+        name="pred_complex_action_condition_with_long_name",
+        last_updated=NOW,
+        pred_type=PredicateType.ACTION,
+        signature="state -> action -> bool",
+        src_code="a.qty > s.max_qty &&\n(a.price > 0 || a.kind = Market)",
+        iml=(
+            "let pred_complex_action_condition_with_long_name (s: state) (a: action) =\n"
+            "  a.qty > s.max_qty && (a.price > 0 || a.kind = Market)"
+        ),
+        is_iml_valid=IMLValidity.INVALID,
+        iml_error="Type error: cannot compare int and option<int> in expression a.price > 0",
+        links=_edge_links(),
+    )
+
+
+def make_predicate_pm(ctx: RenderCtx, variant: str = "typical") -> PredicatePM:
+    v = (variant or "typical").strip().lower()
+    if v == "minimal":
+        return _predicate_minimal()
+    if v == "edge":
+        return _predicate_edge()
+    return _predicate_typical()
+
+def render_predicate(pm: PredicatePM, ctx: RenderCtx):
+    from speclogician.presentation.renderers.predicate import render_predicate
+    return render_predicate(pm, ctx=ctx)
+
+# -----------------------------------------------------------------------------
+# TransitionPM variants
+# -----------------------------------------------------------------------------
+
+def _transition_minimal() -> TransitionPM:
+    return TransitionPM(
+        kind="transition",
+        comp_id="trans-min",
+        name="",
+        last_updated=NOW,
+        signature="",
+        src_code="",
+        iml="",
+        is_iml_valid=IMLValidity.UNKNOWN,
+        iml_error=None,
+        links=_minimal_links(),
+    )
+
+
+def _transition_typical() -> TransitionPM:
+    return TransitionPM(
+        kind="transition",
+        comp_id="trans-001",
+        name="step1",
+        last_updated=NOW,
+        signature="state -> action -> state",
+        src_code="{ x = s.x + a }",
+        iml="let step1 (s: state) (a: action) : state =\n  { x = s.x + a }",
+        is_iml_valid=IMLValidity.VALID,
+        iml_error=None,
+        links=_typical_links(),
+    )
+
+
+def _transition_edge() -> TransitionPM:
+    return TransitionPM(
+        kind="transition",
+        comp_id="trans-edge-888",
+        name="step_with_very_long_and_descriptive_name",
+        last_updated=NOW,
+        signature="state -> action -> state",
+        src_code="{ x = if a > 0 then s.x + a else false }",
+        iml=(
+            "let step_with_very_long_and_descriptive_name (s: state) (a: action) : state =\n"
+            "  { x = if a > 0 then s.x + a else false }"
+        ),
+        is_iml_valid=IMLValidity.INVALID,
+        iml_error="Type error: expected int, got bool in field x",
+        links=_edge_links(),
+    )
+
+
+def make_transition_pm(ctx: RenderCtx, variant: str = "typical") -> TransitionPM:
+    v = (variant or "typical").strip().lower()
+    if v == "minimal":
+        return _transition_minimal()
+    if v == "edge":
+        return _transition_edge()
+    return _transition_typical()
+
+def render_transition(pm: TransitionPM, ctx: RenderCtx):
+    from speclogician.presentation.renderers.predicate import render_transition
+    return render_transition(pm, ctx=ctx)

speclogician/presentation/preview/fixtures/scenario.py

@@ -0,0 +1,84 @@
+#
+#   Imandra Inc.
+#
+#   speclogician/presentation/preview/fixtures/scenario.py
+#
+
+from __future__ import annotations
+
+from speclogician.presentation.ctx import RenderCtx
+from speclogician.presentation.models.scenario import (
+    ScenarioPM,
+    ScenarioStatusPM,
+)
+
+# -----------------------------------------------------------------------------
+# variants
+# -----------------------------------------------------------------------------
+
+def _minimal() -> ScenarioPM:
+    return ScenarioPM(
+        comp_id="sc:0000",
+        name="",
+        status=ScenarioStatusPM(kind="valid"),
+        given=[],
+        when=[],
+        then=[],
+        given_preds_consistent=True,
+        when_preds_consistent=True,
+        all_preds_consistent=True,
+    )
+
+
+def _typical() -> ScenarioPM:
+    return ScenarioPM(
+        comp_id="sc:0001",
+        name="scenario_1",
+        status=ScenarioStatusPM(kind="valid"),
+        given=["pred_eq_ten", "pred_ne_ten"],
+        when=["act_gt_x"],
+        then=["step1"],
+        given_preds_consistent=True,
+        when_preds_consistent=True,
+        all_preds_consistent=True,
+    )
+
+
+def _edge() -> ScenarioPM:
+    return ScenarioPM(
+        comp_id="sc:9999",
+        name="scenario_" + ("very_long_name_" * 6) + "end",
+        status=ScenarioStatusPM(
+            kind="missing",
+            missing_preds=["pred_missing_1", "pred_missing_2"],
+            missing_trans=["step_missing"],
+        ),
+        given=["pred_eq_ten", "pred_missing_1"],
+        when=["act_gt_x", "act_weird_pred"],
+        then=["step1", "step_missing"],
+        given_preds_consistent=False,
+        when_preds_consistent=False,
+        all_preds_consistent=False,
+    )
+
+
+# -----------------------------------------------------------------------------
+# public fixture entrypoint (matches PreviewSpec.make)
+# -----------------------------------------------------------------------------
+
+def make_scenario_pm(ctx: RenderCtx, variant: str = "typical") -> ScenarioPM:
+    v = (variant or "typical").lower().strip()
+    if v == "minimal":
+        return _minimal()
+    if v == "edge":
+        return _edge()
+    return _typical()
+
+
+# -----------------------------------------------------------------------------
+# renderer adapter (matches other fixtures style)
+# -----------------------------------------------------------------------------
+
+def render(pm: ScenarioPM, ctx: RenderCtx):
+    from speclogician.presentation.renderers.scenario import render_scenario
+    return render_scenario(pm, ctx=ctx)

speclogician/presentation/preview/fixtures/scenario_complement.py

@@ -0,0 +1,81 @@
+#
+#   Imandra Inc.
+#
+#   speclogician/presentation/preview/fixtures/scenario_complement.py
+#
+
+from __future__ import annotations
+
+from speclogician.presentation.models.scenario_complement import (
+    ScenarioComplementPM,
+    ScenarioComplementRegionPM,
+)
+
+
+def make_scenario_complement_pm(variant: str = "typical") -> ScenarioComplementPM:
+    v = (variant or "typical").strip().lower()
+
+    if v == "empty":
+        return ScenarioComplementPM(
+            count_regions=0,
+            regions_preview=[],
+            regions_all=None,
+        )
+
+    if v == "edge":
+        preview = [
+            ScenarioComplementRegionPM(
+                fp="a3f91c0d12e9ab01",
+                num_constraints=12,
+                invariant="x >= 0",
+                model="{x = 0}",
+                model_eval="ok",
+                constraints_preview=["x >= 0", "y = 1", "z != 3"],
+            ),
+            ScenarioComplementRegionPM(
+                fp="bb92e44caa10fe88",
+                num_constraints=7,
+                invariant="balance < limit",
+                model="{balance = 5, limit = 10}",
+                model_eval="ok",
+                constraints_preview=["balance < limit", "limit = 10"],
+            ),
+            ScenarioComplementRegionPM(
+                fp="0f12caa903bc9e77",
+                num_constraints=3,
+                invariant=None,
+                model=None,
+                model_eval=None,
+                constraints_preview=["flag = true"],
+            ),
+        ]
+        return ScenarioComplementPM(
+            count_regions=42,
+            regions_preview=preview,
+            regions_all=None,
+        )
+
+    # typical
+    preview = [
+        ScenarioComplementRegionPM(
+            fp="e19caa903bc9e771",
+            num_constraints=4,
+            invariant="state_ok",
+            model="{s = {...}}",
+            model_eval="ok",
+            constraints_preview=["state_ok", "x != 0"],
+        ),
+        ScenarioComplementRegionPM(
+            fp="a2ff10d12e9ab013",
+            num_constraints=2,
+            invariant=None,
+            model="{x = 1}",
+            model_eval="ok",
+            constraints_preview=["x = 1"],
+        ),
+    ]
+    return ScenarioComplementPM(
+        count_regions=7,
+        regions_preview=preview,
+        regions_all=None,
+    )