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

offline_docker/configure.py

@@ -0,0 +1,282 @@
+"""Interactive / non-interactive repository source configuration."""
+
+from __future__ import annotations
+
+import argparse
+import sys
+from typing import Any
+
+from offline_docker.user_config import (
+    local_only_dict,
+    online_fill_dict,
+    save_user_sources,
+    user_sources_path,
+)
+
+# Helpful placeholders for operators (shown in prompts; Enter keeps empty).
+_HINT_PROGET_URL = "https://proget.vitebsk.energo.net"
+_HINT_PROGET_PYPI = "ve_pypi"
+_HINT_PROGET_NPM = "npm-ve"
+_HINT_PROGET_DEB = "local-deb"
+_HINT_NEXUS_URL = "http://repos.vitebsk.energo.by:8081"
+_HINT_NEXUS_PYPI = "pypi-group"
+_HINT_NEXUS_NPM = "npm-group"
+
+
+def _prompt(label: str, *, hint: str | None = None) -> str:
+    suffix = f" [{hint}]" if hint else ""
+    try:
+        value = input(f"{label}{suffix}: ").strip()
+    except EOFError:
+        return ""
+    return value
+
+
+def _build_sources_dict(
+    *,
+    proget_url: str,
+    proget_pypi: str,
+    proget_npm: str,
+    proget_deb: str,
+    nexus_url: str,
+    nexus_pypi: str,
+    nexus_npm: str,
+    nexus_raw: str,
+    order: list[str] | None = None,
+) -> dict[str, Any]:
+    sources: list[dict[str, Any]] = [
+        {"name": "local", "type": "filesystem", "enabled": True},
+    ]
+    resolve_order = ["local"]
+
+    if proget_url:
+        feeds: dict[str, str] = {}
+        if proget_pypi:
+            feeds["pypi"] = proget_pypi
+        if proget_npm:
+            feeds["npm"] = proget_npm
+        if proget_deb:
+            feeds["deb"] = proget_deb
+        sources.append(
+            {
+                "name": "proget",
+                "type": "proget",
+                "url": proget_url.rstrip("/"),
+                "feeds": feeds,
+                "auth_env": "PROGET_API_KEY",
+                "enabled": True,
+                "publish": False,
+            }
+        )
+        resolve_order.append("proget")
+    else:
+        sources.append(
+            {
+                "name": "proget",
+                "type": "proget",
+                "url": "",
+                "feeds": {},
+                "auth_env": "PROGET_API_KEY",
+                "enabled": False,
+                "publish": False,
+            }
+        )
+
+    if nexus_url:
+        repos: dict[str, str] = {}
+        if nexus_pypi:
+            repos["pypi"] = nexus_pypi
+        if nexus_npm:
+            repos["npm"] = nexus_npm
+        if nexus_raw:
+            repos["raw"] = nexus_raw
+        sources.append(
+            {
+                "name": "nexus",
+                "type": "nexus",
+                "url": nexus_url.rstrip("/"),
+                "repos": repos,
+                "auth_env": "NEXUS_AUTH",
+                "enabled": True,
+                "publish": False,
+            }
+        )
+        resolve_order.append("nexus")
+    else:
+        sources.append(
+            {
+                "name": "nexus",
+                "type": "nexus",
+                "url": "",
+                "repos": {},
+                "auth_env": "NEXUS_AUTH",
+                "enabled": False,
+                "publish": False,
+            }
+        )
+
+    if order:
+        resolve_order = order
+
+    return {
+        "sources": sources,
+        "resolve": {
+            "order": resolve_order,
+            "fill_local": True,
+            "on_miss": "fail",
+        },
+    }
+
+
+def run_configure(args: argparse.Namespace) -> None:
+    if getattr(args, "local_only", False) and getattr(args, "with_upstream", False):
+        print("ERROR: укажите либо --local-only, либо --with-upstream", file=sys.stderr)
+        raise SystemExit(2)
+
+    if getattr(args, "local_only", False):
+        path = save_user_sources(local_only_dict())
+        print(f"Сохранено (local-only): {path}")
+        print("Режим для офлайн/корп VM: cache без явного upstream")
+        print("  (CLI всё ещё может временно добавить PyPI как fallback — см. WARN).")
+        print("Для заполнения кэша с интернета: offdock configure --with-upstream")
+        return
+
+    if getattr(args, "with_upstream", False):
+        path = save_user_sources(online_fill_dict())
+        print(f"Сохранено (local + upstream): {path}")
+        print("Resolve order: local, upstream")
+        print("PyPI: https://pypi.org/simple  |  npm: https://registry.npmjs.org/")
+        return
+
+    interactive = sys.stdin.isatty() and not getattr(args, "non_interactive", False)
+
+    proget_url = (getattr(args, "proget_url", None) or "").strip()
+    nexus_url = (getattr(args, "nexus_url", None) or "").strip()
+    proget_pypi = (getattr(args, "proget_pypi", None) or "").strip()
+    proget_npm = (getattr(args, "proget_npm", None) or "").strip()
+    proget_deb = (getattr(args, "proget_deb", None) or "").strip()
+    nexus_pypi = (getattr(args, "nexus_pypi", None) or "").strip()
+    nexus_npm = (getattr(args, "nexus_npm", None) or "").strip()
+    nexus_raw = (getattr(args, "nexus_raw", None) or "").strip()
+    order_raw = (getattr(args, "order", None) or "").strip()
+
+    flags_given = any(
+        getattr(args, name) is not None
+        for name in (
+            "proget_url",
+            "nexus_url",
+            "proget_pypi",
+            "proget_npm",
+            "proget_deb",
+            "nexus_pypi",
+            "nexus_npm",
+            "nexus_raw",
+            "order",
+        )
+    )
+
+    if interactive and not flags_given:
+        print("Настройка источников пакетов (Enter = пропустить / пусто).")
+        print(f"User config будет записан в: {user_sources_path()}")
+        print()
+        print("— ProGet —")
+        proget_url = _prompt("ProGet base URL", hint=_HINT_PROGET_URL)
+        if proget_url:
+            proget_pypi = _prompt("ProGet PyPI feed", hint=_HINT_PROGET_PYPI) or _HINT_PROGET_PYPI
+            proget_npm = _prompt("ProGet npm feed", hint=_HINT_PROGET_NPM) or _HINT_PROGET_NPM
+            proget_deb = _prompt("ProGet deb feed", hint=_HINT_PROGET_DEB) or _HINT_PROGET_DEB
+        print()
+        print("— Nexus —")
+        nexus_url = _prompt("Nexus base URL", hint=_HINT_NEXUS_URL)
+        if nexus_url:
+            nexus_pypi = _prompt("Nexus PyPI repo", hint=_HINT_NEXUS_PYPI) or _HINT_NEXUS_PYPI
+            nexus_npm = _prompt("Nexus npm repo", hint=_HINT_NEXUS_NPM) or _HINT_NEXUS_NPM
+            nexus_raw = _prompt("Nexus raw repo (optional)", hint="offline-cache-raw")
+        print()
+        order_raw = _prompt(
+            "Resolve order (comma-separated)",
+            hint="local,proget,nexus",
+        )
+
+    # Non-interactive defaults for feed names when URL given without feed flags
+    if proget_url:
+        proget_pypi = proget_pypi or _HINT_PROGET_PYPI
+        proget_npm = proget_npm or _HINT_PROGET_NPM
+        proget_deb = proget_deb or _HINT_PROGET_DEB
+    if nexus_url:
+        nexus_pypi = nexus_pypi or _HINT_NEXUS_PYPI
+        nexus_npm = nexus_npm or _HINT_NEXUS_NPM
+
+    order: list[str] | None = None
+    if order_raw:
+        order = [p.strip() for p in order_raw.split(",") if p.strip()]
+
+    if not proget_url and not nexus_url:
+        # Без корп. реестров на машине с сетью удобнее local+upstream, чем «тихий» local-only.
+        data = online_fill_dict()
+        path = save_user_sources(data)
+        print(f"URL не заданы — сохранён local + upstream (PyPI/npmjs): {path}")
+        print("Только offline-cache: offdock configure --local-only")
+        return
+
+    data = _build_sources_dict(
+        proget_url=proget_url,
+        proget_pypi=proget_pypi,
+        proget_npm=proget_npm,
+        proget_deb=proget_deb,
+        nexus_url=nexus_url,
+        nexus_pypi=nexus_pypi,
+        nexus_npm=nexus_npm,
+        nexus_raw=nexus_raw,
+        order=order,
+    )
+    path = save_user_sources(data)
+    print(f"Сохранено: {path}")
+    print(f"Resolve order: {', '.join(data['resolve']['order'])}")
+    print("Auth (опционально): PROGET_API_KEY, NEXUS_AUTH")
+
+
+def add_configure_parser(sub: argparse._SubParsersAction[argparse.ArgumentParser]) -> None:
+    p = sub.add_parser(
+        "configure",
+        help="Настроить ProGet/Nexus (user-level sources.json)",
+        description=(
+            "Интерактивная или флаги-настройка источников пакетов. "
+            "--with-upstream = local + PyPI/npmjs; --local-only = только offline-cache; "
+            "пустые ProGet/Nexus URL в интерактиве = --with-upstream. "
+            "Не требует --project."
+        ),
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog=(
+            "примеры:\n"
+            "  offdock configure\n"
+            "  offdock configure --with-upstream   # fill cache с PyPI/npmjs\n"
+            "  offdock configure --local-only      # только offline-cache\n"
+            "  offdock configure --proget-url https://proget.example.com \\\n"
+            "      --nexus-url http://nexus.example.com:8081\n"
+        ),
+    )
+    p.add_argument(
+        "--local-only",
+        action="store_true",
+        help="Только offline-cache (офлайн/корп VM)",
+    )
+    p.add_argument(
+        "--with-upstream",
+        action="store_true",
+        help="local + PyPI/npmjs upstream (машина с сетью для cache)",
+    )
+    p.add_argument("--non-interactive", action="store_true", help="Без prompt (только флаги)")
+    p.add_argument("--proget-url", default=None, help="ProGet base URL")
+    p.add_argument("--proget-pypi", default=None, help=f"ProGet PyPI feed (hint: {_HINT_PROGET_PYPI})")
+    p.add_argument("--proget-npm", default=None, help=f"ProGet npm feed (hint: {_HINT_PROGET_NPM})")
+    p.add_argument("--proget-deb", default=None, help=f"ProGet deb feed (hint: {_HINT_PROGET_DEB})")
+    p.add_argument("--nexus-url", default=None, help="Nexus base URL")
+    p.add_argument("--nexus-pypi", default=None, help=f"Nexus PyPI repo (hint: {_HINT_NEXUS_PYPI})")
+    p.add_argument("--nexus-npm", default=None, help=f"Nexus npm repo (hint: {_HINT_NEXUS_NPM})")
+    p.add_argument("--nexus-raw", default=None, help="Nexus raw repo for offline-cache mirror")
+    p.add_argument(
+        "--order",
+        default=None,
+        help="Resolve order, e.g. local,proget,nexus",
+    )

offline_docker/context.py

@@ -0,0 +1,111 @@
+"""Runtime paths derived from ProjectConfig."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+
+from offline_docker.config import ProjectConfig, load_config
+from offline_docker.utils import combined_files_hash
+
+
+@dataclass(frozen=True)
+class ProjectContext:
+    config: ProjectConfig
+    wheels_dir: Path
+    wheels_hash_file: Path
+    debs_dir: Path
+    apt_meta_dir: Path
+    npm_cache_dir: Path
+    docker_cache_dir: Path
+    trivy_cache_dir: Path
+
+    @property
+    def root(self) -> Path:
+        return self.config.root
+
+    @property
+    def offline_cache(self) -> Path:
+        return self.config.offline_cache
+
+    @property
+    def log_dir(self) -> Path:
+        return self.config.log_dir
+
+    @classmethod
+    def from_config(cls, config: ProjectConfig) -> ProjectContext:
+        offline = config.offline_cache
+        wheels = offline / "wheels"
+        return cls(
+            config=config,
+            wheels_dir=wheels,
+            wheels_hash_file=wheels / ".deps.sha256",
+            debs_dir=offline / "debs",
+            apt_meta_dir=offline / "apt-meta",
+            npm_cache_dir=offline / "npm",
+            docker_cache_dir=offline / "docker",
+            trivy_cache_dir=offline / config.trivy.cache_subdir,
+        )
+
+    @classmethod
+    def load(
+        cls,
+        root: Path,
+        *,
+        config_file: Path | None = None,
+    ) -> ProjectContext:
+        config = load_config(root, config_file=config_file)
+        return cls.from_config(config)
+
+    def ensure_offline_dirs(self) -> None:
+        for d in (
+            self.wheels_dir,
+            self.debs_dir,
+            self.apt_meta_dir,
+            self.npm_cache_dir,
+            self.docker_cache_dir,
+            self.trivy_cache_dir,
+        ):
+            d.mkdir(parents=True, exist_ok=True)
+        from offline_docker.oc_discovery import discover_yarn_cache_specs
+
+        for spec in discover_yarn_cache_specs(self.config):
+            (self.offline_cache / spec.cache_subdir).mkdir(parents=True, exist_ok=True)
+            (self.offline_cache / spec.archive_subdir).mkdir(parents=True, exist_ok=True)
+
+    def ensure_log_dir(self) -> None:
+        self.log_dir.mkdir(parents=True, exist_ok=True)
+
+    def offline_build_log(self, stem: str) -> Path:
+        self.ensure_log_dir()
+        return self.log_dir / f"offline-build-{stem}.log"
+
+    def trivy_scan_log(self, target: str) -> Path:
+        self.ensure_log_dir()
+        return self.log_dir / f"trivy-scan-{target}.log"
+
+    def python_deps_hash(self) -> str:
+        paths = self.config.python_lock_paths()
+        if not paths:
+            raise RuntimeError("Python lock files not found")
+        return combined_files_hash(paths)
+
+    def set_offline_cache_env(self) -> None:
+        import os
+
+        os.environ.setdefault("DOCKER_BUILDKIT", "1")
+        os.environ.setdefault("OFFLINE_CACHE", str(self.offline_cache))
+        # Compose additional_contexts on Windows: absolute D:\... often yields empty
+        # BuildKit context (oc: 2B) and fails on source=vendor. Prefer ./relative.
+        try:
+            rel = self.offline_cache.resolve().relative_to(self.root.resolve()).as_posix()
+            oc_compose = rel if rel.startswith(".") else f"./{rel}"
+        except ValueError:
+            oc_compose = self.offline_cache.as_posix()
+        app_key = f"{self.config.app_name.upper()}_OFFLINE_CACHE"
+        existing = os.environ.get(app_key, "")
+        looks_win_abs = bool(existing) and (
+            (len(existing) >= 2 and existing[1] == ":") or existing.startswith("\\\\")
+        )
+        if not existing or looks_win_abs:
+            os.environ[app_key] = oc_compose

offline_docker/defaults.py

@@ -0,0 +1,48 @@
+"""Default values and shared types for offline-docker."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+@dataclass
+class WheelPattern:
+    pattern: str
+    label: str
+
+
+DEFAULT_DEB_PACKAGES = [
+    "locales",
+    "python3.12",
+    "python3.12-venv",
+    "python3.12-dev",
+    "python3-pip",
+    "git",
+    "curl",
+    "wget",
+    "ca-certificates",
+    "gnupg",
+    "libgl1",
+    "libglib2.0-0",
+    "libsm6",
+    "libxext6",
+    "libxrender1",
+    "ffmpeg",
+]
+
+DEFAULT_DOCKER_IMAGES = [
+    "ubuntu:24.04",
+    "node:22-bookworm-slim",
+    "nginx:1.28-alpine",
+    "redis:7-alpine",
+    "aquasec/trivy:latest",
+]
+
+DEFAULT_CRITICAL_WHEELS = [
+    WheelPattern("PyJWT-*.whl", "PyJWT"),
+    WheelPattern("psycopg-*.whl", "psycopg"),
+    WheelPattern("psycopg_binary-*.whl", "psycopg_binary"),
+    WheelPattern("redis-*.whl", "redis"),
+    WheelPattern("sqlalchemy-*.whl", "sqlalchemy"),
+    WheelPattern("alembic-*.whl", "alembic"),
+]

offline_docker/discover.py

@@ -0,0 +1,139 @@
+"""Auto-discovery of Docker/Python/frontend dependencies in a project."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from offline_docker.config import ProjectConfig
+from offline_docker.scan import (
+    ScanInventory,
+    compute_init_gaps,
+    inventory_to_draft_config,
+    recursive_scan,
+)
+
+
+def discover_project(root: Path) -> ProjectConfig:
+    """Recursive scan + role heuristics (shared with init)."""
+    root = root.resolve()
+    inventory = recursive_scan(root)
+    return inventory_to_draft_config(root, inventory)
+
+
+def discover_with_inventory(root: Path) -> tuple[ProjectConfig, ScanInventory]:
+    root = root.resolve()
+    inventory = recursive_scan(root)
+    cfg = inventory_to_draft_config(root, inventory)
+    return cfg, inventory
+
+
+def format_discovery_report(
+    cfg: ProjectConfig,
+    *,
+    inventory: ScanInventory | None = None,
+    gaps: list[str] | None = None,
+) -> str:
+    if inventory is None:
+        inventory = recursive_scan(cfg.root)
+    if gaps is None:
+        gaps = compute_init_gaps(cfg, inventory)
+
+    lines = [
+        f"=== discover: {cfg.root} ===",
+        "",
+        f"Конфиг:          {cfg.config_source or '(не задан)'}",
+        f"App name:         {cfg.app_name}",
+        f"Offline cache:    {cfg.offline_cache}",
+        f"Log dir:          {cfg.log_dir}",
+        "",
+        "Compose:",
+    ]
+    for f in cfg.compose_files or ["(не найдены)"]:
+        lines.append(f"  - {f}")
+    lines.extend(
+        [
+            f"  online:  {cfg.compose_online}",
+            f"  offline: {cfg.compose_offline}",
+            "",
+            "Python lock files:",
+        ]
+    )
+    for f in cfg.python_lock_files:
+        exists = "ok" if cfg.path(f).is_file() else "missing"
+        lines.append(f"  - {f} ({exists})")
+    tv = cfg.torch_version()
+    lines.extend(
+        [
+            f"  torch:   {tv or '(не найден)'}",
+            f"  uv export: {cfg.use_uv_export}",
+            f"  project dir: {cfg.effective_python_project_dir()}",
+            "",
+            "Yarn cache (oc source=yarn):",
+        ]
+    )
+    from offline_docker.oc_discovery import discover_yarn_cache_specs
+
+    yarn_specs = discover_yarn_cache_specs(cfg)
+    for spec in yarn_specs:
+        lines.append(
+            f"  - cache={spec.cache_subdir}, archive={spec.archive_subdir}, "
+            f"arg={spec.version_arg}, dockerfile={spec.source_dockerfile}"
+        )
+    if not yarn_specs:
+        lines.append("  (не требуется)")
+    lines.extend(
+        [
+            "",
+            f"Frontend: {cfg.frontend_dir}/",
+            f"  lock: {cfg.frontend_lock}",
+            "",
+            "Dockerfiles:",
+            f"  base:             {cfg.dockerfiles.base}",
+            f"  base_offline:     {cfg.dockerfiles.base_offline}",
+            f"  backend:          {cfg.dockerfiles.backend}",
+            f"  backend_offline:  {cfg.dockerfiles.backend_offline}",
+            f"  frontend:         {cfg.dockerfiles.frontend}",
+            f"  frontend_offline: {cfg.dockerfiles.frontend_offline}",
+            "",
+            f"APT packages ({len(cfg.deb_packages)}):",
+        ]
+    )
+    for pkg in cfg.deb_packages[:15]:
+        lines.append(f"  - {pkg}")
+    if len(cfg.deb_packages) > 15:
+        lines.append(f"  ... и ещё {len(cfg.deb_packages) - 15}")
+    lines.extend(["", "Docker images:"])
+    for img in cfg.docker_images:
+        lines.append(f"  - {img}")
+    lines.extend(
+        [
+            "",
+            "Image tags:",
+            f"  base:     {cfg.images.base}",
+            f"  backend:  {cfg.images.backend}",
+            f"  frontend: {cfg.images.frontend}",
+        ]
+    )
+    if cfg.deb_extra_repos:
+        lines.extend(["", "Extra APT repos:"])
+        for repo in cfg.deb_extra_repos:
+            lines.append(f"  - {repo.name}")
+
+    if inventory.dockerfiles or inventory.python_files or inventory.package_json_dirs:
+        lines.extend(["", "Scan inventory (recursive):"])
+        lines.append(f"  compose:    {len(inventory.compose_files)}")
+        lines.append(f"  dockerfiles:{len(inventory.dockerfiles)}")
+        lines.append(f"  python:     {len(inventory.python_files)}")
+        lines.append(f"  frontend locks: {len(inventory.frontend_lock_paths)}")
+
+    lines.extend(["", "Missing / to fix:"])
+    if gaps:
+        for g in gaps:
+            lines.append(f"  - {g}")
+    else:
+        lines.append("  (нет — offline-артефакты на месте)")
+
+    lines.extend(["", "Package sources:"])
+    lines.extend(cfg.package_resolver().summary_lines())
+
+    return "\n".join(lines)