artemis_framework 0.4.0__tar.gz → 0.4.2__tar.gz

{artemis_framework-0.4.0 → artemis_framework-0.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: artemis_framework
-Version: 0.4.0
+Version: 0.4.2
 Summary: A package for doing great things!
 License: MIT
 License-File: LICENSE

artemis_framework-0.4.2/artemis_framework/asphodel/tui/widgets/key_list.py

@@ -0,0 +1,371 @@
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass, field
+from typing import Callable
+
+from rich.text import Text
+from textual.app import ComposeResult
+from textual.binding import Binding
+from textual.message import Message
+from textual.widgets import DataTable, Label
+
+
+@dataclass
+class KeyInfo:
+    fingerprint: str
+    key_id: str
+    uids: list[str]
+    name: str
+    algorithm: str
+    expires: str
+    trust: str
+    has_secret: bool
+
+    @classmethod
+    def from_gnupg_dict(
+        cls,
+        pub_dict: dict,
+        secret_fingerprints: set[str]
+    ) -> "KeyInfo":
+        fp = pub_dict.get("fingerprint", "")
+        key_id = fp[-16:] if len(fp) >= 16 else fp
+        uids = pub_dict.get("uids", []) or ["<no UID>"]
+        name = _first_uid_name(uids[0])
+        algo = _format_algorithm(pub_dict)
+        expires = _format_expiry(pub_dict.get("expires", ""))
+        trust = _expand_trust(pub_dict.get("ownertrust", pub_dict.get("trust", "?")))
+        has_sec = fp in secret_fingerprints
+
+        return cls(
+            fingerprint=fp,
+            key_id=key_id,
+            uids=uids,
+            name=name,
+            algorithm=algo,
+            expires=expires,
+            trust=trust,
+            has_secret=has_sec
+        )
+
+
+_COLUMNS: list[tuple[str, int]] = [
+    ("✦", 3),
+    ("Name / UID", 28),
+    ("Key ID", 18),
+    ("Algorithm", 12),
+    ("Expires", 12),
+    ("Trust", 14),
+]
+
+
+class KeyListWidget(DataTable):
+
+    class CursorMoved(Message):
+        def __init__(self, key_info: KeyInfo) -> None:
+            super().__init__()
+            self.key_info = key_info
+
+    class KeyConfirmed(Message):
+        def __init__(self, key_info: KeyInfo) -> None:
+            super().__init__()
+            self.key_info = key_info
+
+    class SelectionChanged(Message):
+        def __init__(self, fingerprints: frozenset[str]) -> None:
+            super().__init__()
+            self.fingerprints = fingerprints
+
+    BINDINGS = [
+        Binding("space", "toggle_select", "Add » selection", show=True),
+        Binding("escape", "clear_select", "Clear selection", show=True),
+        Binding("enter", "confirm_key", "Confirm", show=True),
+        Binding("r", "refresh_table", "Refresh", show=True),
+    ]
+
+    DEFAULT_CSS = """
+    KeyListWidget {
+        height: 1fr;
+        border: double $primary-darken-1;
+        scrollbar-color: $primary;
+        scrollbar-color-hover: $primary-lighten-1;
+        background: $surface;
+    }
+    KeyListWidget:focus {
+        border: double $primary;
+        background: $background;
+    }
+    KeyListWidget > .datatable--header {
+        background: $primary-darken-2;
+        color: $text-muted;
+        text-style: bold;
+    }
+    KeyListWidget > .datatable--cursor {
+        background: $primary-darken-1;
+        color: $text;
+    }
+    KeyListWidget:focus > .datatable--cursor {
+        background: $primary;
+        color: $background;
+        text-style: bold;
+    }
+    KeyListWidget > .datatable--even-row {
+        background: $surface;
+    }
+    KeyListWidget > .datatable--odd-row {
+        background: $background;
+    }
+    """
+
+    def __init__(
+        self,
+        gpg=None,
+        *,
+        confirm_callback: Callable[[KeyInfo], None] | None = None,
+        **kwargs
+    ) -> None:
+        super().__init__(
+            cursor_type="row",
+            zebra_stripes=True,
+            **kwargs
+        )
+        self._gpg = gpg
+        self._confirm_callback = confirm_callback
+
+        self._key_map: dict[str, KeyInfo] = {}
+        self._row_key_to_fp: dict[str, str] = {}
+        self._selected_fps: set[str] = set()
+
+    def on_mount(self) -> None:
+        for label, width in _COLUMNS:
+            self.add_column(label, width=width)
+        if self._gpg is not None:
+            self.load(self._gpg)
+
+    def load(self, gpg) -> None:
+        self._gpg = gpg
+        self.clear(columns=False)
+        self._key_map.clear()
+        self._row_key_to_fp.clear()
+        self._selected_fps.clear()
+
+        pub_keys = gpg.list_keys(False)
+        secret_fps = {k["fingerprint"] for k in gpg.list_keys(True)}
+
+        for pub_dict in pub_keys:
+            info = KeyInfo.from_gnupg_dict(pub_dict, secret_fps)
+            self._key_map[info.fingerprint] = info
+            row_key = info.fingerprint
+            self._row_key_to_fp[row_key] = info.fingerprint
+            self.add_row(
+                *self._build_row_cells(info, selected=False),
+                key=row_key
+            )
+
+    def refresh_keys(self, gpg=None) -> None:
+        self.load(gpg or self._gpg)
+
+    def get_selected(self) -> frozenset[str]:
+        return frozenset(self._selected_fps)
+
+    def get_cursor_key(self) -> KeyInfo | None:
+        return self._info_at_cursor()
+
+    def clear_selection(self) -> None:
+        self.action_clear_select()
+
+    def select_by_fingerprint(self, fingerprint: str) -> None:
+        if fingerprint in self._key_map:
+            self._selected_fps.add(fingerprint)
+            self._redraw_row(fingerprint)
+            self.post_message(self.SelectionChanged(self.get_selected()))
+
+    def on_data_table_row_highlighted(
+        self,
+        event: DataTable.RowHighlighted
+    ) -> None:
+        event.stop()
+        fp = self._row_key_to_fp.get(str(event.row_key.value), "")
+        info = self._key_map.get(fp)
+        if info:
+            self.post_message(self.CursorMoved(info))
+
+    def action_toggle_select(self) -> None:
+        info = self._info_at_cursor()
+        if info is None:
+            return
+        fp = info.fingerprint
+        if fp in self._selected_fps:
+            self._selected_fps.discard(fp)
+        else:
+            self._selected_fps.add(fp)
+        self._redraw_row(fp)
+        self.post_message(self.SelectionChanged(self.get_selected()))
+
+    def action_clear_select(self) -> None:
+        fps_to_redraw = set(self._selected_fps)
+        self._selected_fps.clear()
+        for fp in fps_to_redraw:
+            self._redraw_row(fp)
+        self.post_message(self.SelectionChanged(self.get_selected()))
+
+    def action_confirm_key(self) -> None:
+        info = self._info_at_cursor()
+        if info is None:
+            return
+        self.post_message(self.KeyConfirmed(info))
+        if self._confirm_callback:
+            self._confirm_callback(info)
+
+    def action_refresh_table(self) -> None:
+        if self._gpg:
+            self.load(self._gpg)
+
+    def _info_at_cursor(self) -> KeyInfo | None:
+        if self.row_count == 0:
+            return None
+        try:
+            fp_list = list(self._row_key_to_fp.values())
+            if self.cursor_row >= len(fp_list):
+                return None
+            fp = fp_list[self.cursor_row]
+            return self._key_map.get(fp)
+        except Exception:
+            return None
+
+    def _build_row_cells(
+        self,
+        info: KeyInfo,
+        *,
+        selected: bool
+    ) -> tuple[Text | str, ...]:
+        sel_marker = "▶" if selected else " "
+        sec_marker = "✦" if info.has_secret else "•"
+        indicator = Text(f"{sel_marker}{sec_marker}", no_wrap=True)
+        if selected:
+            indicator.stylize("bold yellow")
+        elif info.has_secret:
+            indicator.stylize("bold cyan")
+        else:
+            indicator.stylize("dim")
+
+        name_cell = Text(info.name[:26], no_wrap=True)
+        if info.has_secret:
+            name_cell.stylize("cyan")
+
+        key_id_cell = Text(info.key_id, no_wrap=True, style="dim")
+
+        algo_cell = Text(info.algorithm, no_wrap=True)
+
+        expires_cell = Text(info.expires, no_wrap=True)
+        if info.expires.lower() not in ("never", ""):
+            expires_cell.stylize("yellow")
+
+        trust_cell = Text(info.trust, no_wrap=True)
+        trust_cell.stylize(_trust_style(info.trust))
+
+        return (
+            indicator,
+            name_cell,
+            key_id_cell,
+            algo_cell,
+            expires_cell,
+            trust_cell,
+        )
+
+    def _redraw_row(self, fingerprint: str) -> None:
+        info = self._key_map.get(fingerprint)
+        if info is None:
+            return
+
+        selected = fingerprint in self._selected_fps
+        cells = self._build_row_cells(info, selected=selected)
+        col_keys = [col.key for col in self.columns.values()]
+        for col_key, cell_value in zip(col_keys, cells):
+            try:
+                self.update_cell(
+                    row_key=fingerprint,
+                    column_key=col_key,
+                    value=cell_value,
+                    update_width=False
+                )
+            except Exception:
+                pass
+
+
+def _first_uid_name(uid: str) -> str:
+    m = re.match(r"^([^<(]+)", uid)
+    return m.group(1).strip() if m else uid.strip()
+
+
+def _format_algorithm(key_dict: dict) -> str:
+    algo = key_dict.get("algo", "")
+    length = key_dict.get("length", "")
+    curve = key_dict.get("curve", "")
+
+    algo_names = {
+        "1": "RSA",
+        "2": "RSA",
+        "3": "RSA",
+        "17": "DSA",
+        "18": "ECDH",
+        "19": "ECDSA",
+        "22": "EdDSA",
+    }
+    name = algo_names.get(str(algo), str(algo))
+
+    if curve:
+        curve_short = {
+            "ed25519": "255",
+            "cv25519": "255",
+            "nistp256": "P256",
+            "nistp384": "P384",
+            "nistp521": "P521",
+        }.get(curve.lower(), curve)
+        return f"{name} {curve_short}"
+
+    if length:
+        return f"{name} {length}"
+
+    return name
+
+
+def _format_expiry(expires: str) -> str:
+    if not expires:
+        return "never"
+    try:
+        import datetime
+        ts = int(expires)
+
+        return datetime.datetime.fromtimestamp(ts).strftime("%Y-%m-%d")
+    except (ValueError, OSError):
+        return expires
+
+
+def _expand_trust(code: str) -> str:
+    return {
+        "u": "ultimate",
+        "f": "full",
+        "m": "marginal",
+        "n": "not trusted",
+        "e": "expired",
+        "r": "revoked",
+        "?": "unknown",
+        "-": "unknown",
+        "q": "undefined",
+    }.get(code.lower(), code)
+
+
+def _trust_style(trust_label: str) -> str:
+    return {
+        "ultimate": "bold green",
+        "full": "green",
+        "marginal": "yellow",
+        "not trusted": "dim red",
+        "expired": "bold red",
+        "revoked": "bold red",
+        "unknown": "dim",
+        "undefined": "dim",
+    }.get(trust_label, "")
+
+

artemis_framework-0.4.2/artemis_framework/asphodel/tui/widgets/operation_log.py

@@ -0,0 +1,115 @@
+from __future__ import annotations
+
+import datetime
+from pathlib import Path
+from typing import Literal
+
+from rich.text import Text
+from textual.app import ComposeResult
+from textual.binding import Binding
+from textual.widgets import RichLog
+
+
+Level = Literal["OK", "ERR", "WARN", "INFO"]
+
+
+_LEVEL_STYLE: dict[str, tuple[str, str]] = {
+    "OK": ("[OK]   ", "green"),
+    "ERR": ("[ERR]  ", "bold red"),
+    "WARN": ("[WARN] ", "yellow"),
+    "INFO": ("[INFO] ", "dim white"),
+}
+
+_LEVEL_ALIASES: dict[str, str] = {
+    "ok": "OK",
+    "err": "ERR",
+    "error": "ERR",
+    "warn": "WARN",
+    "warning": "WARN",
+    "info": "INFO",
+}
+
+
+def _normalize_level(level: str) -> str:
+    return _LEVEL_ALIASES.get(level.lower(),  _LEVEL_ALIASES.get(level, "INFO"))
+
+
+class OperationLogWidget(RichLog):
+    DEFAULT_CSS = ""
+    COMPONENT_CLASSES = {"operation-log"}
+
+    def __init__(self, **kwargs) -> None:
+        super().__init__(
+            highlight=False,
+            markup=False,
+            wrap=True,
+            **kwargs
+        )
+        self._plain_lines: list[str] = []
+
+    def log(self, message: str, level: str = "INFO") -> None:
+        canonical = _normalize_level(level)
+        prefix, color = _LEVEL_STYLE[canonical]
+        timestamp = _timestamp()
+
+        line = Text()
+        line.append(timestamp, style="dim")
+        line.append(" "*3)
+        line.append(prefix, style=color)
+        line.append(" "*3)
+        line.append(message, style=color if canonical == "ERR" else "")
+
+        plain = f"[{timestamp}]     {prefix}  {message}"
+        self._plain_lines.append(plain)
+
+        self.write(line)
+
+    def log_result(
+        self,
+        ok: bool,
+        label: str,
+        detail: str | None = None
+    ) -> None:
+        self.log(label, level="OK" if ok else "ERR")
+        if detail:
+            self.log(detail, level="INFO")
+
+    def log_separator(self, label: str = "") -> None:
+        width = 60
+        if label:
+            pad = max(0, (width - len(label) - 2) // 2)
+            text = f"{'-' * pad} {label} {'-'* pad}"
+        else:
+            text = "-" * width
+
+        line = Text(text, style="dim")
+        self._plain_lines.append(text)
+        self.write(line)
+
+    def clear(self) -> None:
+        super().clear()
+        self._plain_lines.clear()
+
+    def save(self, path: Path | str | None = None) -> Path | None:
+        if not self._plain_lines:
+            self.log("Log is empty - nothing to save.", level="WARN")
+            return None
+
+        if path is None:
+            stamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
+            path = Path.cwd() / f"asphodel_pgp_log_{stamp}.log"
+
+        dest = Path(path)
+        try:
+            dest.parent.mkdir(parents=True, exist_ok=True)
+            dest.write_text("\n".join(self._plain_lines) + "\n", encoding="utf-8")
+
+            self.log(f"Log saved » {dest}", level="OK")
+            return dest
+        except OSError as exc:
+            self.log(f"Failed to save log: {exc}", level="ERR")
+            return None
+
+
+def _timestamp() -> str:
+    return datetime.datetime.now().strftime("%H:%M:%S")

{artemis_framework-0.4.0 → artemis_framework-0.4.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "artemis_framework"
-version = "0.4.0"
+version = "0.4.2"
 description = "A package for doing great things!"
 authors = ["Dylan Garrett"]
 license = "MIT"