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

speclogician/presentation/preview/fixtures/domain_model.py

@@ -1,162 +0,0 @@
-#
-#   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

@@ -1,162 +0,0 @@
-#
-#   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

@@ -1,184 +0,0 @@
-#
-#   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

@@ -1,84 +0,0 @@
-#
-#   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

@@ -1,81 +0,0 @@
-#
-#   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,
-    )