testerkit 0.4.0__py3-none-any.whl

testerkit/ui/pages/parts/new.py

@@ -0,0 +1,170 @@
+"""New part creation page."""
+
+from nicegui import ui
+
+from testerkit.ui.shared.components import validate_resource_id
+from testerkit.ui.shared.layout import create_layout
+from testerkit.ui.shared.services import create_part, discover_parts
+
+
+@ui.page("/parts/new")
+def new_part_page():
+    """Create a new part."""
+    create_layout("New Part")
+
+    # Get existing part IDs to check for duplicates
+    existing_ids = {p["id"] for p in discover_parts()}
+
+    # Form state
+    form = {
+        "part_id": "",
+        "name": "",
+        "description": "",
+    }
+    validation = {
+        "id_error": "",
+        "name_error": "",
+    }
+
+    with ui.column().classes("w-full p-6 gap-6"):
+        # Header
+        with ui.row().classes("items-center gap-2"):
+            ui.icon("add_circle").classes("text-slate-600")
+            ui.label("Create New Part").classes("text-lg font-semibold text-slate-700")
+
+        # Form card
+        with ui.card().classes("w-full max-w-xl"):
+            with ui.card_section():
+                ui.label("Part Information").classes("font-semibold mb-4")
+
+                with ui.column().classes("gap-4 w-full"):
+                    # Part ID
+                    with ui.column().classes("gap-1 w-full"):
+                        ui.label("Part ID").classes("text-sm font-medium text-slate-700")
+                        ui.label(
+                            "Unique identifier (lowercase, letters/numbers/hyphens only)"
+                        ).classes("text-xs text-slate-400")
+                        id_input = (
+                            ui.input(
+                                placeholder="e.g., tps54302",
+                            )
+                            .props("outlined dense")
+                            .classes("w-full")
+                        )
+                        ui.label("").classes("text-xs text-red-500").bind_text_from(
+                            validation, "id_error"
+                        )
+
+                        def validate_id(e):
+                            value = e.value.lower().strip()
+                            form["part_id"] = value
+                            id_input.value = value
+                            validation["id_error"] = validate_resource_id(
+                                value, existing_ids, "Part ID"
+                            )
+
+                        id_input.on("change", validate_id)
+
+                    # Name
+                    with ui.column().classes("gap-1 w-full"):
+                        ui.label("Name").classes("text-sm font-medium text-slate-700")
+                        name_input = (
+                            ui.input(
+                                placeholder="e.g., TPS54302 Buck Converter",
+                            )
+                            .props("outlined dense")
+                            .classes("w-full")
+                        )
+                        ui.label("").classes("text-xs text-red-500").bind_text_from(
+                            validation, "name_error"
+                        )
+
+                        def validate_name(e):
+                            value = e.value.strip()
+                            form["name"] = value
+
+                            if not value:
+                                validation["name_error"] = "Name is required"
+                            else:
+                                validation["name_error"] = ""
+
+                        name_input.on("change", validate_name)
+
+                    # Description
+                    with ui.column().classes("gap-1 w-full"):
+                        ui.label("Description").classes("text-sm font-medium text-slate-700")
+                        ui.label("Optional").classes("text-xs text-slate-400")
+                        desc_input = (
+                            ui.textarea(
+                                placeholder="Brief description of the part...",
+                            )
+                            .props("outlined dense")
+                            .classes("w-full")
+                        )
+
+                        def update_description(e):
+                            value = e.value or ""
+                            form["description"] = value.strip()
+
+                        desc_input.on("change", update_description)
+
+            with ui.card_actions().classes("justify-end"):
+                ui.button(
+                    "Cancel",
+                    icon="close",
+                    on_click=lambda: ui.navigate.to("/parts"),
+                ).props("flat")
+
+                def create():
+                    # Validate
+                    if not form["part_id"]:
+                        validation["id_error"] = "Part ID is required"
+                        return
+                    if not form["name"]:
+                        validation["name_error"] = "Name is required"
+                        return
+                    if validation["id_error"] or validation["name_error"]:
+                        ui.notify("Please fix validation errors", type="warning")
+                        return
+
+                    # Create part
+                    result = create_part(
+                        part_id=form["part_id"],
+                        name=form["name"],
+                        description=form["description"],
+                    )
+
+                    if result:
+                        ui.notify(
+                            f"Part '{result['name']}' created successfully",
+                            type="positive",
+                        )
+                        ui.navigate.to(f"/parts/{result['id']}/edit")
+                    else:
+                        ui.notify(
+                            "Part ID already exists",
+                            type="negative",
+                        )
+
+                ui.button(
+                    "Create Part",
+                    icon="add",
+                    on_click=create,
+                ).props("color=primary")
+
+        # Help text
+        with ui.card().classes("w-full max-w-xl bg-blue-50"):
+            with ui.card_section():
+                with ui.row().classes("items-start gap-3"):
+                    ui.icon("lightbulb").classes("text-blue-500 mt-0.5")
+                    with ui.column().classes("gap-1"):
+                        ui.label("What happens next?").classes("font-medium text-blue-700")
+                        ui.label(
+                            "After creating the part, you'll be taken to the edit page "
+                            "where you can add characteristics, test requirements, and more."
+                        ).classes("text-sm text-blue-600")
+                        ui.label(
+                            "You can also upload a datasheet to help extract specifications."
+                        ).classes("text-sm text-blue-600")
+
+        ui.link("← Back to Parts", "/parts").classes("text-blue-600 hover:underline")

testerkit/ui/pages/parts/requirements.py

@@ -0,0 +1,153 @@
+"""Part requirements page for procurement planning."""
+
+from nicegui import ui
+
+from testerkit.ui.shared.components import data_table
+from testerkit.ui.shared.layout import create_layout
+from testerkit.ui.shared.services import (
+    discover_parts,
+    get_all_station_matches_for_part,
+    get_required_capabilities,
+    load_part_model,
+)
+
+
+@ui.page("/parts/{part_id}/requirements")
+def requirements_page(part_id: str):
+    """View required instruments for testing this part.
+
+    This helps with procurement - know what to order early,
+    mock tests while waiting for hardware.
+    """
+    parts = discover_parts()
+    part = next((p for p in parts if p["id"] == part_id), None)
+
+    if part:
+        create_layout(f"{part['name']} - Requirements")
+    else:
+        create_layout("Part Not Found")
+
+    with ui.column().classes("w-full p-6 gap-6"):
+        if part:
+            _render_requirements(part_id, part)
+        else:
+            _render_not_found()
+
+
+def _render_requirements(part_id: str, part: dict):
+    """Render the requirements view."""
+    part_model = load_part_model(part_id)
+
+    # Header with back link
+    with ui.row().classes("items-center gap-4 mb-4"):
+        ui.link(f"← {part['name']}", f"/parts/{part_id}").classes("text-blue-600 hover:underline")
+
+    # Required capabilities card
+    with ui.card().classes("w-full"):
+        with ui.card_section():
+            ui.label("Required Instrument Capabilities").classes("text-lg font-semibold")
+            ui.label(
+                "These capabilities are needed to test this part. "
+                "Order missing instruments early - you can mock in the meantime."
+            ).classes("text-sm text-slate-500")
+
+        with ui.card_section():
+            if part_model:
+                capabilities = get_required_capabilities(part_model)
+                if capabilities:
+                    columns = [
+                        {
+                            "name": "characteristic",
+                            "label": "For Characteristic",
+                            "field": "characteristic",
+                            "align": "left",
+                        },
+                        {"name": "function", "label": "Function", "field": "function"},
+                        {
+                            "name": "direction",
+                            "label": "Instrument Direction",
+                            "field": "direction",
+                        },
+                        {"name": "signals", "label": "Signals", "field": "signals"},
+                    ]
+                    rows = [
+                        {
+                            "characteristic": cap["characteristic"],
+                            "function": cap["function"],
+                            "direction": cap["direction"],
+                            "signals": cap.get("signals", ""),
+                        }
+                        for cap in capabilities
+                    ]
+                    data_table(columns=columns, rows=rows, row_key="characteristic")
+                else:
+                    ui.label(
+                        "No characteristics defined - add characteristics to generate requirements."
+                    ).classes("text-slate-500 italic")
+            else:
+                ui.label("Could not load part model.").classes("text-amber-600")
+
+    # Station coverage card
+    station_matches = get_all_station_matches_for_part(part_id)
+    compatible = station_matches.get("compatible", [])
+    partial = station_matches.get("partial", [])
+
+    with ui.card().classes("w-full mt-4"):
+        with ui.card_section():
+            ui.label("Station Coverage").classes("text-lg font-semibold")
+
+        with ui.card_section():
+            if compatible:
+                with ui.row().classes("items-center gap-2 mb-3"):
+                    ui.icon("check_circle").classes("text-emerald-500")
+                    ui.label(f"{len(compatible)} station(s) fully compatible").classes(
+                        "text-emerald-600 font-medium"
+                    )
+
+            if partial:
+                ui.label("Partially Compatible Stations").classes(
+                    "font-medium text-amber-600 mt-2 mb-2"
+                )
+                ui.label(
+                    "These stations have some capabilities. "
+                    "Add missing instruments to enable full testing."
+                ).classes("text-xs text-slate-500 mb-2")
+
+                for station in partial:
+                    with ui.row().classes("items-center gap-3 py-2 border-b border-slate-100"):
+                        ui.icon("warning").classes("text-amber-500")
+                        with ui.column().classes("flex-1"):
+                            ui.label(station["name"]).classes("font-medium")
+                            with ui.row().classes("gap-1 flex-wrap"):
+                                ui.label("Missing:").classes("text-xs text-slate-500")
+                                for cap in station.get("missing", []):
+                                    ui.badge(cap, color="amber").props("outline dense")
+                        ui.badge(f"{station['coverage']}%", color="amber")
+
+            if not compatible and not partial:
+                with ui.row().classes("items-center gap-2"):
+                    ui.icon("info").classes("text-slate-400")
+                    ui.label("No stations have any required instruments.").classes("text-slate-500")
+                ui.label("Consider creating a station or ordering instruments.").classes(
+                    "text-sm text-slate-400 mt-1"
+                )
+
+    # Action buttons
+    with ui.row().classes("mt-4 gap-3"):
+        ui.button(
+            "View Compatible Stations",
+            icon="memory",
+            on_click=lambda: ui.navigate.to(f"/parts/{part_id}/stations"),
+        ).props("outline")
+        ui.button(
+            "Launch with Mocks",
+            icon="play_arrow",
+            on_click=lambda: ui.navigate.to(f"/launch?part={part_id}&mock=1"),
+        ).props("color=primary")
+
+
+def _render_not_found():
+    """Render part not found message."""
+    with ui.card().classes("w-full p-6 text-center"):
+        ui.label("Part not found.").classes("text-xl text-slate-600")
+        ui.link("← Back to Parts", "/parts").classes("text-blue-600 hover:underline")

testerkit/ui/pages/parts/stations.py

@@ -0,0 +1,199 @@
+"""Part station compatibility page."""
+
+from nicegui import ui
+
+from testerkit.ui.shared.layout import create_layout
+from testerkit.ui.shared.services import (
+    discover_parts,
+    get_all_station_matches_for_part,
+    load_part_model,
+)
+
+
+@ui.page("/parts/{part_id}/stations")
+def part_stations_page(part_id: str):
+    """View station compatibility for this part.
+
+    Shows which stations can fully or partially test this part.
+    Helps with procurement planning and test execution decisions.
+    """
+    parts = discover_parts()
+    part = next((p for p in parts if p["id"] == part_id), None)
+
+    if part:
+        create_layout(f"{part['name']} - Station Compatibility")
+    else:
+        create_layout("Part Not Found")
+
+    with ui.column().classes("w-full p-6 gap-6"):
+        if part:
+            _render_station_compatibility(part_id, part)
+        else:
+            _render_not_found()
+
+
+def _render_station_compatibility(part_id: str, part: dict):
+    """Render the station compatibility view."""
+    part_model = load_part_model(part_id)
+    station_matches = get_all_station_matches_for_part(part_id)
+
+    compatible = station_matches.get("compatible", [])
+    partial = station_matches.get("partial", [])
+    incompatible = station_matches.get("incompatible", [])
+
+    # Header with back link
+    with ui.row().classes("items-center gap-4 mb-4"):
+        ui.link(f"← {part['name']}", f"/parts/{part_id}").classes("text-blue-600 hover:underline")
+
+    # Summary card
+    with ui.card().classes("w-full"):
+        with ui.card_section():
+            ui.label(f"Station Compatibility for {part['name']}").classes("text-lg font-semibold")
+            if part_model:
+                char_count = len(part_model.characteristics)
+                ui.label(f"Matching stations against {char_count} characteristic(s)").classes(
+                    "text-sm text-slate-500"
+                )
+
+        with ui.card_section():
+            with ui.row().classes("gap-6"):
+                with ui.column().classes("items-center"):
+                    ui.label(str(len(compatible))).classes("text-2xl font-bold text-emerald-600")
+                    ui.label("Ready").classes("text-xs text-slate-500")
+                with ui.column().classes("items-center"):
+                    ui.label(str(len(partial))).classes("text-2xl font-bold text-amber-600")
+                    ui.label("Partial").classes("text-xs text-slate-500")
+                with ui.column().classes("items-center"):
+                    ui.label(str(len(incompatible))).classes("text-2xl font-bold text-slate-400")
+                    ui.label("None").classes("text-xs text-slate-500")
+
+    # Fully compatible stations
+    if compatible:
+        with ui.card().classes("w-full mt-4"):
+            with ui.card_section():
+                with ui.row().classes("items-center gap-2"):
+                    ui.icon("check_circle").classes("text-emerald-500")
+                    ui.label("Ready to Test").classes("text-lg font-semibold text-emerald-600")
+                ui.label("These stations have all required instruments.").classes(
+                    "text-sm text-slate-500"
+                )
+
+            with ui.card_section():
+                for station in compatible:
+                    _render_compatible_station(part_id, station)
+
+    # Partially compatible stations
+    if partial:
+        with ui.card().classes("w-full mt-4"):
+            with ui.card_section():
+                with ui.row().classes("items-center gap-2"):
+                    ui.icon("warning").classes("text-amber-500")
+                    ui.label("Needs Additional Instruments").classes(
+                        "text-lg font-semibold text-amber-600"
+                    )
+                ui.label(
+                    "Add missing instruments to enable full testing, or use simulation."
+                ).classes("text-sm text-slate-500")
+
+            with ui.card_section():
+                for station in partial:
+                    _render_partial_station(part_id, station)
+
+    # Incompatible stations (if any exist)
+    if incompatible:
+        with ui.expansion("Incompatible Stations", icon="block").classes("w-full mt-4"):
+            ui.label("These stations have none of the required instruments.").classes(
+                "text-sm text-slate-500 mb-2"
+            )
+            for station in incompatible:
+                with ui.row().classes("items-center gap-3 py-2 border-b border-slate-100"):
+                    ui.icon("block").classes("text-slate-300")
+                    ui.label(station["name"]).classes("text-slate-500")
+                    if station.get("location"):
+                        ui.label(f"({station['location']})").classes("text-xs text-slate-400")
+
+    # No stations at all
+    if not compatible and not partial and not incompatible:
+        with ui.card().classes("w-full mt-4 p-6 text-center"):
+            ui.icon("search_off").classes("text-4xl text-slate-300")
+            ui.label("No stations found").classes("text-lg text-slate-500 mt-2")
+            ui.label("Create a station configuration to enable testing.").classes(
+                "text-sm text-slate-400"
+            )
+            ui.button(
+                "Create Station",
+                icon="add",
+                on_click=lambda: ui.navigate.to("/stations/new"),
+            ).classes("mt-4")
+
+    # Action buttons
+    with ui.row().classes("mt-4 gap-3"):
+        ui.button(
+            "View Requirements",
+            icon="list_alt",
+            on_click=lambda: ui.navigate.to(f"/parts/{part_id}/requirements"),
+        ).props("outline")
+        if compatible:
+            ui.button(
+                "Launch Tests",
+                icon="play_arrow",
+                on_click=lambda: ui.navigate.to(f"/launch?part={part_id}"),
+            ).props("color=primary")
+        else:
+            ui.button(
+                "Launch with Mocks",
+                icon="play_arrow",
+                on_click=lambda: ui.navigate.to(f"/launch?part={part_id}&mock=1"),
+            ).props("color=primary")
+
+
+def _render_compatible_station(part_id: str, station: dict):
+    """Render a fully compatible station row."""
+    with ui.row().classes("items-center justify-between py-3 border-b border-slate-100 w-full"):
+        with ui.column().classes("flex-1"):
+            ui.label(station["name"]).classes("font-semibold")
+            if station.get("location"):
+                ui.label(station["location"]).classes("text-sm text-slate-500")
+        with ui.row().classes("items-center gap-3"):
+            ui.badge("100%", color="green").props("dense")
+            ui.button(
+                "Launch",
+                icon="play_arrow",
+                on_click=lambda _, s=station: ui.navigate.to(
+                    f"/launch?part={part_id}&station={s['id']}"
+                ),
+            ).props("flat dense")
+
+
+def _render_partial_station(part_id: str, station: dict):
+    """Render a partially compatible station row."""
+    with ui.row().classes("items-center justify-between py-3 border-b border-slate-100 w-full"):
+        with ui.column().classes("flex-1"):
+            ui.label(station["name"]).classes("font-semibold")
+            if station.get("location"):
+                ui.label(station["location"]).classes("text-sm text-slate-500")
+            # Show missing capabilities
+            with ui.row().classes("gap-1 flex-wrap mt-1"):
+                ui.label("Missing:").classes("text-xs text-slate-500")
+                for cap in station.get("missing", [])[:5]:  # Limit to 5
+                    ui.badge(cap, color="amber").props("outline dense")
+                if len(station.get("missing", [])) > 5:
+                    ui.badge(f"+{len(station['missing']) - 5} more", color="grey").props(
+                        "outline dense"
+                    )
+        with ui.row().classes("items-center gap-3"):
+            ui.badge(f"{station['coverage']}%", color="amber").props("dense")
+            ui.button(
+                "Mock",
+                icon="play_arrow",
+                on_click=lambda _, s=station: ui.navigate.to(
+                    f"/launch?part={part_id}&station={s['id']}&mock=1"
+                ),
+            ).props("flat dense outline")
+
+
+def _render_not_found():
+    """Render part not found message."""
+    with ui.card().classes("w-full p-6 text-center"):
+        ui.label("Part not found.").classes("text-xl text-slate-600")
+        ui.link("← Back to Parts", "/parts").classes("text-blue-600 hover:underline")

testerkit/ui/pages/profiles/__init__.py

@@ -0,0 +1,4 @@
+"""Profile pages — list + detail."""
+
+# Import pages to register routes
+from testerkit.ui.pages.profiles import detail, list  # noqa: F401

testerkit/ui/pages/profiles/detail.py

@@ -0,0 +1,113 @@
+"""Profile detail page — view one profile's resolved YAML + extends chain."""
+
+import yaml
+from nicegui import ui
+
+from testerkit.ui.shared.components import page_layout
+from testerkit.ui.shared.layout import create_layout
+from testerkit.ui.shared.services import discover_profiles, load_profile_config
+
+
+@ui.page("/profiles/{name}")
+def profile_detail_page(name: str):
+    """One profile — header card + resolved YAML + extends-chain map.
+
+    The YAML is the merged in-memory ProfileConfig (after extends-chain
+    resolution at session start). Read-only — edits land via the
+    file system (no in-browser editor yet).
+    """
+    create_layout(f"Profile · {name}")
+
+    profile = load_profile_config(name)
+
+    with page_layout():
+        if profile is None:
+            with ui.card().classes("w-full p-6 text-center"):
+                ui.label(f"Profile '{name}' not found.").classes("text-xl text-slate-600")
+                ui.link("← Back to Profiles", "/profiles").classes("text-blue-600 hover:underline")
+            return
+
+        # Header row
+        with ui.row().classes("items-center justify-between w-full"):
+            with ui.row().classes("items-center gap-2"):
+                ui.icon("layers").classes("text-slate-600")
+                ui.label(name).classes("text-lg font-semibold text-slate-700")
+            ui.button(
+                "Launch Test",
+                icon="play_arrow",
+                on_click=lambda: ui.navigate.to(f"/launch?test_profile={name}"),
+            ).props("color=primary")
+
+        # Summary card — extends, station_type, fixture, facets
+        with ui.card().classes("w-full"):
+            with ui.card_section():
+                ui.label("Summary").classes("font-semibold")
+            with ui.card_section(), ui.row().classes("gap-6 flex-wrap"):
+                _meta_field("Extends", profile.extends or "—")
+                _meta_field("Station type", profile.station_type or "—")
+                _meta_field("Fixture", profile.fixture or "—")
+                facets_str = ", ".join(f"{k}={v}" for k, v in (profile.facets or {}).items()) or "—"
+                _meta_field("Facets", facets_str)
+                _meta_field("Tests", str(len(profile.tests or {})))
+
+        # Extends chain — walk parents recursively for the visual map
+        chain = _resolve_extends_chain(name)
+        if len(chain) > 1:
+            with ui.card().classes("w-full"):
+                with ui.card_section():
+                    ui.label("Inheritance").classes("font-semibold")
+                    ui.label(
+                        "Parent profiles are applied first; this profile's "
+                        "fields override the merged result."
+                    ).classes("text-xs text-slate-500")
+                with ui.card_section(), ui.row().classes("items-center gap-2"):
+                    for i, link in enumerate(chain):
+                        if i > 0:
+                            ui.icon("arrow_forward", size="sm").classes("text-slate-400")
+                        if link == name:
+                            ui.badge(link, color="primary")
+                        else:
+                            ui.link(link, target=f"/profiles/{link}").classes("text-blue-600")
+
+        # Resolved YAML — single source of truth for what this profile
+        # actually configures
+        with ui.card().classes("w-full"):
+            with ui.card_section():
+                ui.label("Resolved YAML").classes("font-semibold")
+                ui.label("After the extends chain resolves at session start.").classes(
+                    "text-xs text-slate-500"
+                )
+            with ui.card_section():
+                yaml_text = yaml.safe_dump(
+                    profile.model_dump(exclude_none=True),
+                    sort_keys=False,
+                    default_flow_style=False,
+                )
+                ui.code(yaml_text, language="yaml").classes("w-full")
+
+        with ui.row().classes("mt-2"):
+            ui.link("← Back to Profiles", "/profiles").classes("text-blue-600 hover:underline")
+
+
+def _meta_field(label: str, value: str) -> None:
+    with ui.column().classes("gap-0"):
+        ui.label(label).classes("text-xs text-slate-500 uppercase")
+        ui.label(value).classes("text-sm font-medium text-slate-800")
+
+
+def _resolve_extends_chain(name: str) -> list[str]:
+    """Walk the ``extends:`` chain from root → leaf. Stops if a parent
+    isn't a known profile (silently — the runtime resolver would raise).
+    """
+    profiles = {p.name: p for p in discover_profiles()}
+    chain: list[str] = []
+    current = name
+    seen: set[str] = set()
+    while current and current not in seen:
+        seen.add(current)
+        chain.append(current)
+        row = profiles.get(current)
+        if not row or not row.extends:
+            break
+        current = row.extends
+    return list(reversed(chain))