shikiru-cli 0.2.0__py3-none-any.whl

shikiru/dashboard/blocker_evidence.py

@@ -0,0 +1,122 @@
+"""The evidence disclosure of a task's Blockers: quota readings, notes and raw events."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from rich.console import Group
+from rich.table import Table
+
+from shikiru.clock import to_local
+from shikiru.domain.levels import displayed_pct
+from shikiru.domain.quota_waits import (
+    QUOTA_NOT_REPORTED,
+    provider_reset_text,
+    quota_window_label,
+)
+from shikiru.ui.age import AGE_NOW, format_short_age
+from shikiru.ui.section import grey
+from shikiru.ui.tokens import SECONDARY_TEXT_COLOR
+
+if TYPE_CHECKING:
+    from collections.abc import Sequence
+    from datetime import datetime, timedelta
+
+    from rich.console import RenderableType
+    from rich.text import Text
+
+    from shikiru.dashboard.contract import BlockerEvidenceView, QuotaEvidenceView, QuotaReadingView
+
+_OBSERVED_PREFIX = "observed"
+_AGO_SUFFIX = "ago"
+_JUST_NOW = "just now"
+_DIFFERENT_TIMES = "at different times"
+_RANGE_SEPARATOR = " to "
+_WINDOW_HEADER = "Window"
+_USED_HEADER = "Used"
+_RESET_HEADER = "Provider reset"
+_NO_READING = "No provider quota reading is recorded."
+_NO_CURRENT_READING = "No current provider quota reading is available."
+_COLUMN_GAP = 2
+
+
+def evidence_headline(evidence: BlockerEvidenceView, now: datetime) -> str | None:
+    """Return how old the observations are: one age, or the span of differing ages."""
+    ages = sorted(
+        [now - reading.observed_at for quota in evidence.quotas for reading in quota.readings]
+        + [now - observed for observed in evidence.observed_at]
+    )
+    if not ages:
+        return None
+    newest, oldest = ages[0], ages[-1]
+    newest_age = _observed_age(newest)
+    oldest_age = _observed_age(oldest)
+    if newest == oldest:
+        return f"{_OBSERVED_PREFIX} {newest_age}"
+    if newest_age == oldest_age:
+        return f"{_OBSERVED_PREFIX} {_DIFFERENT_TIMES} ({oldest_age})"
+    return f"{_OBSERVED_PREFIX} {newest_age}{_RANGE_SEPARATOR}{oldest_age}"
+
+
+def evidence_body(evidence: BlockerEvidenceView, now: datetime) -> RenderableType:
+    """Return the normal evidence: each provider's readings and reset, then the notes.
+
+    A provider label heads each group only when more than one provider is blocked.
+    """
+    labelled = len(evidence.quotas) > 1
+    parts: list[RenderableType] = []
+    for quota in evidence.quotas:
+        if labelled:
+            parts.append(grey(quota.agent))
+        parts.append(_quota_block(quota, to_local(now)))
+    parts.extend(grey(note) for note in evidence.notes)
+    return Group(*parts)
+
+
+def raw_evidence_text(evidence: BlockerEvidenceView) -> Text:
+    """Return the raw events in grey: exact timestamps, event references and diagnostics."""
+    return grey("\n".join(evidence.raw))
+
+
+def _quota_block(quota: QuotaEvidenceView, now: datetime) -> RenderableType:
+    if quota.readings:
+        parts: list[RenderableType] = [_readings_table(quota.readings, now)]
+    elif quota.has_recorded_readings:
+        parts = [grey(_NO_CURRENT_READING)]
+    else:
+        parts = [grey(_NO_READING)]
+    if quota.retry_note is not None:
+        parts.append(grey(quota.retry_note))
+    return Group(*parts)
+
+
+def _readings_table(readings: Sequence[QuotaReadingView], now: datetime) -> Table:
+    table = Table(
+        box=None,
+        show_edge=False,
+        pad_edge=False,
+        padding=(0, _COLUMN_GAP, 0, 0),
+        header_style=SECONDARY_TEXT_COLOR,
+        style=SECONDARY_TEXT_COLOR,
+    )
+    table.add_column(_WINDOW_HEADER)
+    table.add_column(_USED_HEADER, justify="right")
+    table.add_column(_RESET_HEADER)
+    for reading in readings:
+        table.add_row(
+            quota_window_label(reading.window).capitalize(),
+            f"{displayed_pct(reading.used_pct)}%",
+            _reset_text(reading.resets_at, now),
+        )
+    return table
+
+
+def _reset_text(resets_at: datetime | None, now: datetime) -> str:
+    if resets_at is None:
+        return QUOTA_NOT_REPORTED
+    return provider_reset_text(to_local(resets_at), now)
+
+
+def _observed_age(age: timedelta) -> str:
+    short = format_short_age(age)
+    return _JUST_NOW if short == AGE_NOW else f"{short} {_AGO_SUFFIX}"

shikiru/dashboard/blocker_rows.py

@@ -0,0 +1,84 @@
+"""The Blockers rows of the briefing's Problems group: each cause, next step and occupants."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from rich.cells import cell_len
+from rich.text import Text
+
+from shikiru.clock import to_local
+from shikiru.domain.quota_waits import quota_clock_text
+from shikiru.domain.scheduling import WaitReason
+from shikiru.domain.tasks import Status
+from shikiru.ui.glyphs import GLYPH_WARNING
+from shikiru.ui.section import Row, grey
+from shikiru.ui.tokens import ALERT_COLOR, AMBER, SECONDARY_TEXT_COLOR, STYLE_BOLD
+
+if TYPE_CHECKING:
+    from datetime import datetime
+
+    from shikiru.dashboard.contract import TaskBlockerView, TaskDetailView, TaskReferenceView
+
+BLOCKERS_LABEL = "Blockers"
+_BOLD_AMBER = f"{STYLE_BOLD} {AMBER}"
+_BOLD_ALERT = f"{STYLE_BOLD} {ALERT_COLOR}"
+_COLUMN_GAP = "  "
+
+
+def blocker_rows(view: TaskDetailView, now: datetime) -> list[Row]:
+    """Return the Blockers rows: each blocker's warning headline, then its grey detail lines.
+
+    The label sits on the first row only, and every line lines up under the value column. A quota
+    wait's clock is worded for `now`, so the countdown moves with the clock. A blocker waiting on a
+    cancelled task turns the alert colour.
+    """
+    rows: list[Row] = []
+    for index, blocker in enumerate(view.blockers):
+        alert = _waits_on_cancelled(view, blocker)
+        label = grey(BLOCKERS_LABEL) if index == 0 else Text()
+        rows.append((label, (_headline(blocker, now, alert),)))
+        rows.extend((Text(), (grey(line),)) for line in blocker.details)
+        rows.extend((Text(), (line,)) for line in _occupant_lines(blocker.related_tasks))
+    return rows
+
+
+def _headline(blocker: TaskBlockerView, now: datetime, alert: bool) -> Text:
+    cause = blocker.headline
+    if blocker.quota_wait is not None:
+        quota = blocker.quota_wait
+        description, remaining = quota_clock_text(quota.agent, to_local(quota.until), to_local(now))
+        cause = f"{description} (in {remaining})"
+    return Text.assemble(
+        (GLYPH_WARNING, _BOLD_ALERT if alert else _BOLD_AMBER),
+        (f" {cause}", ALERT_COLOR if alert else ""),
+    )
+
+
+def _occupant_lines(tasks: tuple[TaskReferenceView, ...]) -> list[Text]:
+    id_width = max((cell_len(task.task_id) for task in tasks), default=0)
+    title_width = max((cell_len(task.title) for task in tasks), default=0)
+    return [
+        Text(
+            f"{_pad_cells(task.task_id, id_width)}{_COLUMN_GAP}"
+            f"{_pad_cells(task.title, title_width)}{_COLUMN_GAP}{task.status}",
+            style=ALERT_COLOR if task.status == Status.CANCELLED.value else SECONDARY_TEXT_COLOR,
+        )
+        for task in tasks
+    ]
+
+
+def _pad_cells(text: str, width: int) -> str:
+    return f"{text}{' ' * (width - cell_len(text))}"
+
+
+def _waits_on_cancelled(view: TaskDetailView, blocker: TaskBlockerView) -> bool:
+    if blocker.kind == WaitReason.DEPENDENCY.value:
+        if view.relationships is None:
+            return False
+        return _any_cancelled(view.relationships.blocking_dependencies)
+    return _any_cancelled(blocker.related_tasks)
+
+
+def _any_cancelled(tasks: tuple[TaskReferenceView, ...]) -> bool:
+    return any(task.status == Status.CANCELLED.value for task in tasks)