offline-docker-cli 2.2.2__py3-none-any.whl

offline_docker/tui/runner.py

@@ -0,0 +1,87 @@
+"""Background action runner with stdout/stderr bridge for TUI."""
+
+from __future__ import annotations
+
+import io
+import sys
+import threading
+import traceback
+from collections.abc import Callable
+from typing import Any
+
+from offline_docker.actions import run_action
+from offline_docker.context import ProjectContext
+
+
+class _LineBridge(io.TextIOBase):
+    """Text stream that forwards complete lines to a callback."""
+
+    encoding = "utf-8"
+
+    def __init__(self, on_line: Callable[[str], None]) -> None:
+        super().__init__()
+        self._on_line = on_line
+        self._buf = ""
+
+    def writable(self) -> bool:
+        return True
+
+    def write(self, s: str) -> int:  # type: ignore[override]
+        if not s:
+            return 0
+        self._buf += s
+        while "\n" in self._buf:
+            line, self._buf = self._buf.split("\n", 1)
+            self._on_line(line.rstrip("\r"))
+        return len(s)
+
+    def flush(self) -> None:
+        if self._buf:
+            self._on_line(self._buf.rstrip("\r"))
+            self._buf = ""
+
+
+def run_action_captured(
+    name: str,
+    ctx: ProjectContext,
+    *,
+    on_line: Callable[[str], None],
+    on_done: Callable[[int, str | None], None],
+    **opts: Any,
+) -> threading.Thread:
+    """Start run_action in a daemon thread; stream prints via on_line."""
+
+    def worker() -> None:
+        bridge = _LineBridge(on_line)
+        old_out, old_err = sys.stdout, sys.stderr
+        sys.stdout = bridge  # type: ignore[assignment]
+        sys.stderr = bridge  # type: ignore[assignment]
+        code = 0
+        err: str | None = None
+        try:
+            run_action(name, ctx, **opts)
+        except SystemExit as exc:
+            if exc.code is None:
+                code = 0
+            elif isinstance(exc.code, int):
+                code = exc.code
+            else:
+                code = 1
+                err = str(exc.code)
+        except Exception as exc:  # noqa: BLE001 — surface to TUI log
+            code = 1
+            err = f"{type(exc).__name__}: {exc}"
+            on_line(err)
+            on_line(traceback.format_exc())
+        finally:
+            try:
+                bridge.flush()
+            except Exception:  # noqa: BLE001
+                pass
+            sys.stdout = old_out
+            sys.stderr = old_err
+            on_done(code, err)
+
+    thread = threading.Thread(target=worker, name=f"offline-docker-{name}", daemon=True)
+    thread.start()
+    return thread

offline_docker/tui/screens.py

@@ -0,0 +1,333 @@
+"""Textual screens for offline-docker TUI."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from textual.app import ComposeResult
+from textual.binding import Binding
+from textual.containers import Horizontal, Vertical
+from textual.screen import ModalScreen, Screen
+from textual.widgets import (
+    Button,
+    Checkbox,
+    DataTable,
+    Footer,
+    Header,
+    Input,
+    Label,
+    ListItem,
+    ListView,
+    RichLog,
+    Static,
+)
+
+from offline_docker.actions import PROJECT_ACTIONS
+from offline_docker.discover import format_discovery_report
+from offline_docker.status import CacheStatusReport, collect_cache_status
+from offline_docker.tui.runner import run_action_captured
+
+
+class CommandListView(ListView):
+    """Click highlights an item; Enter posts Selected (run)."""
+
+    def _on_list_item__child_clicked(self, event: ListItem._ChildClicked) -> None:
+        event.stop()
+        self.focus()
+        self.index = self._nodes.index(event.item)
+
+
+# User-facing command list (order matters).
+_COMMANDS: list[tuple[str, str]] = [
+    ("discover", "Discover dependencies"),
+    ("cache-check", "Validate offline-cache"),
+    ("cache", "Download full offline-cache"),
+    ("cache-wheels", "Download wheels"),
+    ("cache-debs", "Download debs"),
+    ("cache-npm", "Download npm cache"),
+    ("cache-yarn", "Download yarn cache"),
+    ("cache-images", "Download docker images"),
+    ("cache-trivy", "Download Trivy DB"),
+    ("cache-load", "Load docker images"),
+    ("build", "Build offline (base/backend/frontend)"),
+    ("build-base", "Build base offline"),
+    ("up", "Compose up offline"),
+    ("up-online", "Up online (compose_online)"),
+    ("down", "Compose down"),
+    ("scan:backend", "Trivy scan backend"),
+    ("scan:frontend", "Trivy scan frontend"),
+]
+
+
+class DiscoverModal(ModalScreen[None]):
+    """Modal with discover report text."""
+
+    BINDINGS = [Binding("escape", "dismiss", "Close", show=True)]
+
+    def __init__(self, report: str) -> None:
+        super().__init__()
+        self._report = report
+
+    def compose(self) -> ComposeResult:
+        with Vertical(id="discover-modal"):
+            yield Static("Discover report", classes="title")
+            log = RichLog(highlight=False, markup=False, id="discover-log")
+            yield log
+            yield Button("Close", id="close-discover", variant="primary")
+
+    def on_mount(self) -> None:
+        log = self.query_one("#discover-log", RichLog)
+        for line in self._report.splitlines():
+            log.write(line)
+
+    def on_button_pressed(self, event: Button.Pressed) -> None:
+        if event.button.id == "close-discover":
+            self.dismiss()
+
+
+class HomeScreen(Screen[None]):
+    """Project path, cache status, commands, live log."""
+
+    BINDINGS = [
+        Binding("r", "refresh", "Refresh", show=True),
+        Binding("d", "discover", "Discover", show=True),
+        Binding("q", "quit", "Quit", show=True),
+    ]
+
+    CSS = """
+    #project-row {
+        height: auto;
+        margin: 0 1;
+    }
+    #project-input {
+        width: 1fr;
+    }
+    #summary {
+        margin: 0 1;
+        height: 1;
+        color: $text-muted;
+    }
+    #status-table {
+        height: 12;
+        margin: 0 1;
+    }
+    #flags {
+        height: auto;
+        margin: 0 1;
+    }
+    #commands {
+        height: 10;
+        margin: 0 1;
+        border: solid $primary;
+    }
+    #run-log {
+        height: 1fr;
+        margin: 0 1 1 1;
+        border: solid $accent;
+    }
+    #actions-row {
+        height: auto;
+        margin: 0 1;
+    }
+    """
+
+    def __init__(self) -> None:
+        super().__init__()
+        self._running = False
+        self._selected_command: str | None = None
+
+    def compose(self) -> ComposeResult:
+        app = self.app
+        from offline_docker.tui.app import OfflineDockerApp
+
+        assert isinstance(app, OfflineDockerApp)
+        yield Header(show_clock=False)
+        with Vertical():
+            yield Static("offdock TUI", classes="title")
+            with Horizontal(id="project-row"):
+                yield Label("Project:")
+                yield Input(value=str(app.project), id="project-input")
+                yield Button("Load", id="btn-load", variant="primary")
+                yield Button("Refresh", id="btn-refresh")
+            yield Static("", id="summary")
+            yield DataTable(id="status-table", zebra_stripes=True)
+            with Horizontal(id="flags"):
+                yield Checkbox("no-cache", id="flag-no-cache")
+                yield Checkbox("lab (up)", id="flag-lab")
+                yield Checkbox("online (up/down)", id="flag-online")
+                yield Checkbox("no-build", id="flag-no-build")
+                yield Checkbox("no-deps", id="flag-no-deps")
+            yield Label("Commands (Enter / Run):")
+            yield CommandListView(id="commands", *self._command_items())
+            with Horizontal(id="actions-row"):
+                yield Button("Run", id="btn-run", variant="success")
+                yield Button("Discover report", id="btn-discover")
+            yield RichLog(highlight=False, markup=False, id="run-log", wrap=True)
+        yield Footer()
+
+    @staticmethod
+    def _command_items() -> list[ListItem]:
+        items: list[ListItem] = []
+        for key, title in _COMMANDS:
+            items.append(ListItem(Label(f"{title}  ({key})"), id=f"cmd-{key.replace(':', '-')}"))
+        return items
+
+    def on_mount(self) -> None:
+        table = self.query_one("#status-table", DataTable)
+        table.add_columns("Level", "Label", "Detail")
+        table.cursor_type = "row"
+        self.action_refresh()
+
+    def _app(self):
+        from offline_docker.tui.app import OfflineDockerApp
+
+        app = self.app
+        assert isinstance(app, OfflineDockerApp)
+        return app
+
+    def action_refresh(self) -> None:
+        self._reload_status()
+
+    def action_discover(self) -> None:
+        self._show_discover()
+
+    def action_quit(self) -> None:
+        self.app.exit()
+
+    def on_button_pressed(self, event: Button.Pressed) -> None:
+        bid = event.button.id
+        if bid == "btn-load":
+            self._load_project_from_input()
+        elif bid == "btn-refresh":
+            self._reload_status()
+        elif bid == "btn-discover":
+            self._show_discover()
+        elif bid == "btn-run":
+            self._run_selected()
+
+    def on_list_view_highlighted(self, event: ListView.Highlighted) -> None:
+        idx = event.list_view.index
+        if idx is None or idx < 0 or idx >= len(_COMMANDS):
+            return
+        self._selected_command = _COMMANDS[idx][0]
+
+    def on_list_view_selected(self, event: ListView.Selected) -> None:
+        idx = event.list_view.index
+        if idx is None or idx < 0 or idx >= len(_COMMANDS):
+            return
+        self._selected_command = _COMMANDS[idx][0]
+        self._run_selected()
+
+    def _load_project_from_input(self) -> None:
+        raw = self.query_one("#project-input", Input).value.strip()
+        if not raw:
+            self.notify("Укажите путь к проекту", severity="warning")
+            return
+        path = Path(raw).expanduser().resolve()
+        if not path.is_dir():
+            self.notify(f"Каталог не найден: {path}", severity="error")
+            return
+        try:
+            self._app().set_project(path)
+        except Exception as exc:  # noqa: BLE001
+            self.notify(f"Не удалось загрузить конфиг: {exc}", severity="error")
+            return
+        self.notify(f"Проект: {path}")
+        self._reload_status()
+
+    def _reload_status(self) -> None:
+        app = self._app()
+        try:
+            report = collect_cache_status(app.ctx)
+        except Exception as exc:  # noqa: BLE001
+            self.notify(f"Status error: {exc}", severity="error")
+            return
+        self._fill_status(report)
+
+    def _fill_status(self, report: CacheStatusReport) -> None:
+        summary = self.query_one("#summary", Static)
+        mode = " soft" if report.soft else ""
+        summary.update(
+            f"cache={report.offline_cache}  "
+            f"OK={report.ok_count} WARN={report.warn_count} ERROR={report.error_count}{mode}  "
+            f"resolve={' -> '.join(report.resolve_order)}"
+        )
+        table = self.query_one("#status-table", DataTable)
+        table.clear()
+        for item in report.items:
+            table.add_row(item.level.upper(), item.label, item.detail or "")
+
+    def _show_discover(self) -> None:
+        try:
+            text = format_discovery_report(self._app().ctx.config)
+        except Exception as exc:  # noqa: BLE001
+            self.notify(f"Discover error: {exc}", severity="error")
+            return
+        self.app.push_screen(DiscoverModal(text))
+
+    def _flag(self, widget_id: str) -> bool:
+        return self.query_one(f"#{widget_id}", Checkbox).value
+
+    def _run_selected(self) -> None:
+        if self._running:
+            self.notify("Уже выполняется команда", severity="warning")
+            return
+        key = self._selected_command
+        if not key:
+            lv = self.query_one("#commands", ListView)
+            if lv.index is not None and 0 <= lv.index < len(_COMMANDS):
+                key = _COMMANDS[lv.index][0]
+        if not key:
+            self.notify("Выберите команду", severity="warning")
+            return
+
+        name = key
+        opts: dict = {
+            "no_cache": self._flag("flag-no-cache"),
+            "lab": self._flag("flag-lab"),
+            "online": self._flag("flag-online"),
+            "no_build": self._flag("flag-no-build"),
+            "no_deps": self._flag("flag-no-deps"),
+        }
+        if key.startswith("scan:"):
+            name = "scan"
+            opts["target"] = key.split(":", 1)[1]
+        if name == "up-online":
+            name = "up"
+            opts["online"] = True
+            opts["lab"] = False
+        if opts.get("lab") and opts.get("online"):
+            self.notify("--lab и --online взаимоисключающие; снимите один флаг", severity="warning")
+            return
+
+        if name not in PROJECT_ACTIONS:
+            self.notify(f"Неизвестная команда: {name}", severity="error")
+            return
+
+        log = self.query_one("#run-log", RichLog)
+        log.clear()
+        log.write(f">>> {name} {opts}")
+        self._running = True
+        self.query_one("#btn-run", Button).disabled = True
+
+        app = self._app()
+
+        def on_line(line: str) -> None:
+            app.call_from_thread(log.write, line)
+
+        def on_done(code: int, err: str | None) -> None:
+            def finish() -> None:
+                self._running = False
+                self.query_one("#btn-run", Button).disabled = False
+                if err:
+                    log.write(f"!!! {err}")
+                log.write(f"=== exit {code} ===")
+                if code == 0:
+                    self.notify(f"{name}: OK")
+                    self._reload_status()
+                else:
+                    self.notify(f"{name}: failed ({code})", severity="error")
+
+            app.call_from_thread(finish)
+
+        run_action_captured(name, app.ctx, on_line=on_line, on_done=on_done, **opts)

offline_docker/user_config.py

@@ -0,0 +1,89 @@
+"""User-level sources config (~/.config/offline-docker/sources.json)."""
+
+from __future__ import annotations
+
+import json
+import os
+import sys
+from pathlib import Path
+from typing import Any
+
+
+def user_config_dir() -> Path:
+    override = os.environ.get("OFFLINE_DOCKER_CONFIG_DIR")
+    if override:
+        return Path(override).expanduser().resolve()
+    if sys.platform == "win32":
+        base = os.environ.get("APPDATA")
+        if base:
+            return Path(base) / "offline-docker"
+    xdg = os.environ.get("XDG_CONFIG_HOME")
+    if xdg:
+        return Path(xdg).expanduser() / "offline-docker"
+    return Path.home() / ".config" / "offline-docker"
+
+
+def user_sources_path() -> Path:
+    return user_config_dir() / "sources.json"
+
+
+def local_only_dict() -> dict[str, Any]:
+    """Offline / corp VM: только offline-cache (без HTTP index в resolve.order)."""
+    return {
+        "sources": [
+            {"name": "local", "type": "filesystem", "enabled": True},
+        ],
+        "resolve": {
+            "order": ["local"],
+            "fill_local": True,
+            "on_miss": "fail",
+        },
+    }
+
+
+def online_fill_dict() -> dict[str, Any]:
+    """Машина с сетью: local + PyPI/npmjs upstream для download-* (fill_local)."""
+    return {
+        "sources": [
+            {"name": "local", "type": "filesystem", "enabled": True},
+            {
+                "name": "upstream",
+                "type": "upstream",
+                "enabled": True,
+                "pypi_index": "https://pypi.org/simple",
+                "npm_registry": "https://registry.npmjs.org/",
+            },
+        ],
+        "resolve": {
+            "order": ["local", "upstream"],
+            "fill_local": True,
+            "on_miss": "fail",
+        },
+    }
+
+
+def load_user_sources() -> dict[str, Any] | None:
+    path = user_sources_path()
+    if not path.is_file():
+        return None
+    try:
+        data = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError):
+        return None
+    if not isinstance(data, dict):
+        return None
+    return data
+
+
+def save_user_sources(data: dict[str, Any]) -> Path:
+    path = user_sources_path()
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(
+        json.dumps(data, ensure_ascii=False, indent=2) + "\n",
+        encoding="utf-8",
+    )
+    return path
+
+
+def user_config_exists() -> bool:
+    return user_sources_path().is_file()

offline_docker/utils.py

@@ -0,0 +1,73 @@
+"""Shared helpers: hashes, docker mount paths."""
+
+from __future__ import annotations
+
+import hashlib
+import re
+from pathlib import Path
+
+
+def docker_mount_path(path: Path | str) -> str:
+    """Host path for Docker -v mounts (Windows: D:/... with forward slashes)."""
+    p = Path(path).resolve()
+    return str(p).replace("\\", "/")
+
+
+def file_sha256(path: Path) -> str:
+    h = hashlib.sha256()
+    with path.open("rb") as f:
+        for chunk in iter(lambda: f.read(1024 * 1024), b""):
+            h.update(chunk)
+    return h.hexdigest()
+
+
+def combined_files_hash(paths: list[Path]) -> str:
+    parts = "|".join(file_sha256(p) for p in paths if p.is_file())
+    return hashlib.sha256(parts.encode()).hexdigest()
+
+
+def read_torch_version(path: Path) -> str:
+    for line in path.read_text(encoding="utf-8").splitlines():
+        line = line.strip()
+        if line.startswith("torch=="):
+            return line.split("==", 1)[1].strip()
+    raise RuntimeError(f"torch==VERSION not found in {path}")
+
+
+_APT_INSTALL_RE = re.compile(
+    r"apt-get\s+install\b(?:[^\n\\]|\\\s*\n)+",
+    re.MULTILINE,
+)
+
+
+def parse_apt_packages_from_dockerfiles(*dockerfiles: Path) -> list[str]:
+    """Extract package names from apt-get install lines in Dockerfiles."""
+    packages: list[str] = []
+    seen: set[str] = set()
+    skip = {
+        "apt-get",
+        "install",
+        "-y",
+        "--no-install-recommends",
+        "&&",
+        "rm",
+        "-rf",
+        "/var/lib/apt/lists/*",
+    }
+
+    for dockerfile in dockerfiles:
+        if not dockerfile.is_file():
+            continue
+        text = dockerfile.read_text(encoding="utf-8", errors="replace")
+        for block in _APT_INSTALL_RE.findall(text):
+            block = block.replace("\\\n", " ")
+            for token in re.split(r"[\s\\]+", block):
+                token = token.strip().strip('"').strip("'")
+                if not token or token in skip or token.startswith("-"):
+                    continue
+                if token.startswith("/") or "=" in token:
+                    continue
+                if token not in seen:
+                    seen.add(token)
+                    packages.append(token)
+    return packages

offline_docker/validate.py

@@ -0,0 +1,53 @@
+"""Validate offline-cache completeness."""
+
+from __future__ import annotations
+
+from offline_docker.context import ProjectContext
+from offline_docker.status import collect_cache_status
+
+
+def _format_item_line(level: str, label: str, detail: str) -> str:
+    if level == "ok":
+        if not detail:
+            return f"OK: {label}"
+        if detail.startswith("/") or ":\\" in detail or detail.startswith("\\\\"):
+            return f"OK: {label} -> {detail}"
+        if detail.endswith("файлов") or detail.isdigit():
+            return f"OK: {label} - {detail}"
+        if detail.startswith("соответствует"):
+            return f"OK: {label} {detail}" if "hash" in label or "cache" in label else f"OK: {label} {detail}"
+        # paths / archive names / generic
+        if "/" in detail or "\\" in detail or detail.endswith(".tar") or detail.endswith(".tar.gz"):
+            return f"OK: {label} -> {detail}"
+        return f"OK: {label} - {detail}" if " " in detail else f"OK: {label} -> {detail}"
+    if level == "skip":
+        return f"SKIP: {label} ({detail})" if detail else f"SKIP: {label}"
+    prefix = "WARN" if level == "warn" else "ERROR"
+    msg = detail or label
+    return f"{prefix}: {msg}"
+
+
+def validate_offline_cache(ctx: ProjectContext) -> None:
+    report = collect_cache_status(ctx)
+
+    print("=== cache check ===")
+    print(f"Project:       {report.project}")
+    print(f"OFFLINE_CACHE: {report.offline_cache}")
+    print(f"Resolve:       {' -> '.join(report.resolve_order)}")
+    print(f"on_miss:       {report.on_miss}")
+    if report.soft:
+        print("Mode:          soft (WARN instead of ERROR when remotes configured)")
+    print()
+
+    for item in report.items:
+        line = _format_item_line(item.level, item.label, item.detail)
+        if item.level in ("warn", "error"):
+            print(line, flush=True)
+        else:
+            print(line)
+
+    print()
+    if report.error_count:
+        print(f"=== FAILED: {report.error_count} ошибок ===", flush=True)
+        raise SystemExit(1)
+    print("=== cache check: OK ===")