qplotter 1.6.0__py3-none-any.whl

qplot/windows/_widgets/__init__.py

@@ -0,0 +1,23 @@
+from .details_tables import CopyableTableWidget
+from .dropbox import (
+    expandingComboBox,
+    picker_1d,
+)
+from .operations import operations_widget
+from .preview import PreviewTab
+from .toolbar import QDock_context
+from .treeWidgets import (
+    RunList,
+    moreInfo,
+)
+
+__all__ = [
+    "expandingComboBox",
+    "CopyableTableWidget",
+    "moreInfo",
+    "picker_1d",
+    "PreviewTab",
+    "RunList",
+    "QDock_context",
+    "operations_widget",
+    ]

qplot/windows/_widgets/_run_formatting.py

@@ -0,0 +1,387 @@
+import html
+from datetime import datetime
+
+
+def run_tooltip_text(metadata):
+    """
+    Builds the summary shown when hovering over a run table row.
+
+    """
+    sweep = format_parameter_list_html(metadata.get("sweep_parameters"))
+    measure = format_parameter_list_html(metadata.get("measure_parameters"))
+    status = html.escape(format_run_status(metadata))
+    exception_row = ""
+    if run_failed(metadata):
+        summary = html.escape(measurement_exception_summary(metadata))
+        exception_row = (
+            "<tr>"
+            "<td style='padding:0 0.5em 0 0'>Exception</td>"
+            f"<td style='padding:0'>{summary}</td>"
+            "</tr>"
+        )
+
+    return (
+        "<table style='margin:0; border-spacing:0; border-collapse:collapse'>"
+        "<tr>"
+        "<td style='padding:0 0.5em 0 0'>Sweep</td>"
+        f"<td nowrap='nowrap' style='padding:0; white-space:nowrap'>({sweep})</td>"
+        "</tr>"
+        "<tr>"
+        "<td style='padding:0 0.5em 0 0'>Measure</td>"
+        f"<td nowrap='nowrap' style='padding:0; white-space:nowrap'>({measure})</td>"
+        "</tr>"
+        "<tr>"
+        "<td style='padding:0 0.5em 0 0'>Status</td>"
+        f"<td style='padding:0'>{status}</td>"
+        "</tr>"
+        f"{exception_row}"
+        "</table>"
+    )
+
+
+def run_tooltip_plain_text(metadata):
+    sweep = format_parameter_list(metadata.get("sweep_parameters"))
+    measure = format_parameter_list(metadata.get("measure_parameters"))
+    lines = [
+        f"{'Sweep':<7}({sweep})",
+        f"Measure ({measure})",
+        f"Status  {format_run_status(metadata)}",
+    ]
+    if run_failed(metadata):
+        lines.append(f"Exception {measurement_exception_summary(metadata)}")
+
+    return "\n".join(lines)
+
+
+def format_parameter_list(parameters):
+    if not parameters:
+        return "unknown"
+    return ", ".join(str(parameter) for parameter in parameters)
+
+
+def format_parameter_list_html(parameters):
+    if not parameters:
+        return "unknown"
+    return ",&nbsp;".join(html.escape(str(parameter)) for parameter in parameters)
+
+
+def run_is_complete(metadata):
+    return bool(metadata.get("completed_timestamp") or metadata.get("is_completed"))
+
+
+def run_was_interrupted(metadata):
+    exception = metadata.get("measurement_exception")
+    return exception is not None and "KeyboardInterrupt" in str(exception).strip()
+
+
+def run_failed(metadata):
+    exception = metadata.get("measurement_exception")
+    return bool(
+        exception is not None
+        and str(exception).strip()
+        and not run_was_interrupted(metadata)
+    )
+
+
+def measurement_exception_summary(metadata, maximum_length=200):
+    exception = str(metadata.get("measurement_exception") or "")
+    summary = next(
+        (line.strip() for line in reversed(exception.splitlines()) if line.strip()),
+        "",
+    )
+    if len(summary) > maximum_length:
+        return f"{summary[: maximum_length - 1]}…"
+    return summary
+
+
+def format_run_status(metadata):
+    """Return the detailed status used in a run's tooltip."""
+    state = format_run_state(metadata)
+    if run_was_interrupted(metadata):
+        return f"Interrupted ({format_setpoint_progress_percent(metadata)})"
+    if state == "Failed":
+        return f"{state} ({format_interrupted_progress_percent(metadata)})"
+    return state
+
+
+def format_run_state(metadata):
+    """Return the canonical, concise label for a run's current state."""
+    if run_was_interrupted(metadata):
+        return _format_state_with_setpoint_progress("Interrupted", metadata)
+    if run_failed(metadata):
+        return "Failed"
+    if run_is_complete(metadata):
+        return "Completed"
+    if metadata.get("is_completed") is not None and not bool(metadata["is_completed"]):
+        return _format_state_with_setpoint_progress("Running", metadata)
+    return "unknown"
+
+
+def _format_state_with_setpoint_progress(state, metadata):
+    progress = format_setpoint_progress_percent(metadata)
+    return f"{state} ({progress})"
+
+
+def format_progress(metadata):
+    progress = format_progress_percent(metadata)
+    if progress == "unknown":
+        return "unknown% complete"
+    return f"{progress} complete"
+
+
+def format_progress_percent(metadata):
+    if run_is_complete(metadata):
+        return "100%"
+
+    percent = progress_percent_value(metadata)
+    if percent is None:
+        return "unknown"
+
+    return f"{percent:.1f}%"
+
+
+def progress_percent_value(metadata):
+    expected = metadata.get("expected_results")
+    count = metadata.get("result_count")
+    return _progress_percent_value(metadata, count, expected)
+
+
+def setpoint_progress_percent_value(metadata):
+    """Return the percentage of known setpoints that have been measured."""
+    percent = _progress_percent_value(
+        metadata,
+        metadata.get("read_setpoint_count"),
+        metadata.get("setpoint_count"),
+        maximum=100,
+    )
+    if percent is not None:
+        return percent
+
+    # The cheap detail pass exposes result-row progress before the distinct
+    # setpoint query completes. Both counts include the same measurement
+    # multiplicity, so their ratio is a valid early setpoint-progress value.
+    return _progress_percent_value(
+        metadata,
+        metadata.get("result_count"),
+        metadata.get("expected_results"),
+        maximum=100,
+    )
+
+
+def format_setpoint_progress_percent(metadata):
+    percent = setpoint_progress_percent_value(metadata)
+    if percent is None:
+        return "unknown"
+    return f"{percent:.1f}%"
+
+
+def interrupted_progress_percent_value(metadata):
+    expected = None
+    if metadata.get("setpoint_count_source") != "observed":
+        expected = metadata.get("setpoint_count")
+    if not expected and metadata.get("expected_results_source") != "observed":
+        expected = metadata.get("expected_results")
+    count = metadata.get("read_setpoint_count")
+    if count is None:
+        count = metadata.get("result_count")
+    return _progress_percent_value(metadata, count, expected, maximum=100)
+
+
+def _progress_percent_value(metadata, count, expected, maximum=None):
+    if not expected or count is None:
+        return None
+
+    try:
+        if maximum is None:
+            maximum = 100 if run_is_complete(metadata) else 99.9
+        return max(0, min(maximum, (float(count) / float(expected)) * 100))
+    except (TypeError, ValueError, ZeroDivisionError):
+        return None
+
+
+def format_interrupted_progress_percent(metadata):
+    percent = interrupted_progress_percent_value(metadata)
+    if percent is None:
+        return "unknown"
+    return f"{percent:.1f}%"
+
+
+def complete_cell_sort_value(metadata):
+    if run_was_interrupted(metadata):
+        return setpoint_progress_percent_value(metadata)
+    if run_failed(metadata):
+        return interrupted_progress_percent_value(metadata)
+    if run_is_complete(metadata):
+        return 100
+    return setpoint_progress_percent_value(metadata)
+
+
+def format_complete_cell(metadata):
+    """Return the run-table status label.
+
+    Kept under its historic name for callers, but deliberately shares the
+    Overview's canonical status wording.
+    """
+    return format_run_state(metadata)
+
+
+def format_timestamp(timestamp):
+    if not timestamp:
+        return "unknown"
+    try:
+        return datetime.fromtimestamp(timestamp).strftime("%Y-%m-%d %H:%M:%S")
+    except (TypeError, ValueError, OSError, OverflowError):
+        return "unknown"
+
+
+def time_taken_seconds(metadata):
+    started = metadata.get("run_timestamp")
+    if not started:
+        return None
+
+    completed = metadata.get("completed_timestamp")
+    if completed:
+        end = completed
+    elif run_is_complete(metadata):
+        return None
+    elif metadata.get("database_modified_timestamp"):
+        end = metadata.get("database_modified_timestamp")
+    else:
+        return None
+    try:
+        return max(0, float(end) - float(started))
+    except (TypeError, ValueError):
+        return None
+
+
+def format_time_taken_seconds(metadata):
+    seconds = time_taken_seconds(metadata)
+    if seconds is None:
+        return "unknown"
+    return f"{seconds:,.1f} s"
+
+
+def format_run_duration(metadata):
+    seconds = time_taken_seconds(metadata)
+    if seconds is None:
+        return "unknown"
+
+    if seconds < 10:
+        return f"{seconds:.2f} s"
+    if seconds < 100:
+        return f"{seconds:.1f} s"
+    return f"{seconds:.0f} s"
+
+
+def format_duration_dhms(seconds):
+    total_seconds = int(round(seconds))
+    days, remainder = divmod(total_seconds, 24 * 60 * 60)
+    hours, remainder = divmod(remainder, 60 * 60)
+    minutes, seconds = divmod(remainder, 60)
+    return f"{days}d {hours}h {minutes}m {seconds}s"
+
+
+def format_storage_size(bytes_value):
+    if bytes_value is None:
+        return "unknown"
+
+    try:
+        size = float(bytes_value)
+    except (TypeError, ValueError):
+        return "unknown"
+
+    if size < 0:
+        return "unknown"
+
+    units = ["B", "KB", "MB", "GB", "TB"]
+    unit_index = 0
+    while size >= 1024 and unit_index < len(units) - 1:
+        size /= 1024
+        unit_index += 1
+
+    if unit_index == 0:
+        return f"{int(size)} B"
+    if size < 10:
+        return f"{size:.1f} {units[unit_index]}"
+    return f"{size:.0f} {units[unit_index]}"
+
+
+def format_point_count(metadata):
+    expected = metadata.get("setpoint_count", metadata.get("expected_results"))
+    acquired = metadata.get("read_setpoint_count")
+    shape = metadata.get("setpoint_shape") or metadata.get("point_shape")
+    if shape:
+        try:
+            shape_values = [int(size) for size in shape]
+            shape_parts = " × ".join(f"{size:,}" for size in shape_values)
+        except (TypeError, ValueError):
+            shape_values = []
+            shape_parts = ""
+
+        duplicate_count = one_dimensional_duplicate_point_count(metadata, shape_values)
+        if duplicate_count is not None:
+            return duplicate_count
+
+        if (
+            acquired is not None
+            and expected
+            and metadata.get("setpoint_shape_source") == "planned"
+            and acquired != expected
+        ):
+            try:
+                return f"{int(acquired):,} / {int(expected):,} = {shape_parts}"
+            except (TypeError, ValueError):
+                pass
+        if expected:
+            return f"{int(expected):,} = {shape_parts}"
+        if shape_parts:
+            return shape_parts
+
+    if expected:
+        return f"{int(expected):,}"
+
+    # With no physical result rows, logical multiplicity is immaterial: the
+    # acquired logical count is exactly zero.  Positive MAX(id) values remain
+    # internal until a structural layout proves their logical interpretation.
+    if type(metadata.get("result_count")) is int and metadata["result_count"] == 0:
+        return "0"
+
+    return "unknown"
+
+
+def point_count_sort_value(metadata):
+    for name in ("setpoint_count", "expected_results"):
+        value = metadata.get(name)
+        if type(value) is int and value >= 0:
+            return value
+    if type(metadata.get("result_count")) is int and metadata["result_count"] == 0:
+        return 0
+    return None
+
+
+def one_dimensional_duplicate_point_count(metadata, shape_values=None):
+    expected = metadata.get("setpoint_count", metadata.get("expected_results"))
+    shape = metadata.get("setpoint_shape") or metadata.get("point_shape")
+    if shape_values is None:
+        if not shape:
+            return None
+        try:
+            shape_values = [int(size) for size in shape]
+        except (TypeError, ValueError):
+            return None
+
+    if len(shape_values) != 1:
+        return None
+
+    try:
+        expected_count = int(expected)
+    except (TypeError, ValueError):
+        return None
+
+    if expected_count != shape_values[0]:
+        return None
+    return f"{expected_count:,}"
+
+
+def measured_parameter_count(metadata):
+    return len(metadata.get("measure_parameters") or [])