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

offline_docker/hooks.py

@@ -0,0 +1,84 @@
+"""Project hooks for offline-cache (e.g. vendor binaries)."""
+
+from __future__ import annotations
+
+import os
+import sys
+from pathlib import Path
+
+from offline_docker import docker_cmd
+from offline_docker.config import CacheHook
+from offline_docker.context import ProjectContext
+
+
+def _resolve_command(hook: CacheHook, root: Path) -> list[str] | None:
+    """Pick win/sh/script command for the current platform."""
+    is_win = os.name == "nt"
+    if is_win and hook.win:
+        return list(hook.win)
+    if (not is_win) and hook.sh:
+        return list(hook.sh)
+    if hook.script:
+        script = root / hook.script
+        if not script.is_file():
+            raise SystemExit(
+                f"ERROR: hooks.after_cache[{hook.name}]: нет файла {hook.script}"
+            )
+        if script.suffix.lower() == ".ps1":
+            return [
+                "powershell",
+                "-NoProfile",
+                "-ExecutionPolicy",
+                "Bypass",
+                "-File",
+                str(script),
+            ]
+        if script.suffix.lower() in {".sh", ".bash"}:
+            return ["bash", str(script)]
+        if script.suffix.lower() in {".bat", ".cmd"}:
+            return ["cmd", "/c", str(script)]
+        if os.access(script, os.X_OK):
+            return [str(script)]
+        return [sys.executable, str(script)]
+    if is_win and hook.sh and not hook.win:
+        # fallback: try bash (Git Bash / WSL path) only if sh provided alone
+        return list(hook.sh)
+    if (not is_win) and hook.win and not hook.sh:
+        return list(hook.win)
+    return None
+
+
+def run_after_cache_hooks(ctx: ProjectContext) -> None:
+    """Run project hooks.after_cache (download vendor, etc.)."""
+    hooks = list(ctx.config.after_cache_hooks)
+    if not hooks:
+        return
+
+    print("========================================")
+    print(" hooks.after_cache")
+    print(f" Project: {ctx.root}")
+    print("========================================")
+    print()
+
+    env = {
+        "OFFLINE_CACHE": str(ctx.offline_cache),
+        f"{ctx.config.app_name.upper()}_OFFLINE_CACHE": str(ctx.offline_cache),
+    }
+
+    for hook in hooks:
+        cmd = _resolve_command(hook, ctx.root)
+        if not cmd:
+            raise SystemExit(
+                f"ERROR: hooks.after_cache[{hook.name}]: укажите win/sh или script"
+            )
+        # Resolve relative script tokens in argv to absolute under project root
+        resolved: list[str] = []
+        for part in cmd:
+            p = Path(part)
+            if (not p.is_absolute()) and (ctx.root / part).is_file():
+                resolved.append(str(ctx.root / part))
+            else:
+                resolved.append(part)
+        print(f">>> hook {hook.name}: {' '.join(resolved)}")
+        docker_cmd.run(resolved, cwd=ctx.root, env=env)
+        print()

offline_docker/init_cmd.py

@@ -0,0 +1,54 @@
+"""offline-docker init: recursive scan → draft .offline-docker.json."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from offline_docker.config import project_config_to_dict
+from offline_docker.discover import discover_with_inventory, format_discovery_report
+from offline_docker.scan import compute_init_gaps, resolve_init_output_path
+
+
+def run_init(root: Path, *, dry_run: bool = False) -> Path:
+    """Build draft config JSON. Returns output path (even on dry-run)."""
+    root = root.resolve()
+    cfg, inventory = discover_with_inventory(root)
+    cfg.config_source = "(init draft)"
+    gaps = compute_init_gaps(cfg, inventory)
+    out_path = resolve_init_output_path(root)
+    out_rel = out_path.name
+
+    data = project_config_to_dict(cfg)
+    data["_init"] = {
+        "tool": "offline-docker",
+        "command": "init",
+        "output": out_rel,
+        "gaps": gaps,
+    }
+
+    report = format_discovery_report(cfg, inventory=inventory, gaps=gaps)
+    print(report)
+    print()
+
+    if dry_run:
+        print(f"[dry-run] черновик НЕ записан (цель: {out_rel})")
+        if gaps:
+            print(f"[dry-run] gaps: {len(gaps)}")
+        return out_path
+
+    out_path.write_text(
+        json.dumps(data, ensure_ascii=False, indent=2) + "\n",
+        encoding="utf-8",
+    )
+    print(f"Черновик записан: {out_path}")
+    if out_rel == ".offline-docker.generated.json":
+        print(
+            "Канонический .offline-docker.json/.yaml не изменён "
+            "(уже существует в проекте)."
+        )
+    if gaps:
+        print(f"Доработайте вручную ({len(gaps)} пункт(ов) в _init.gaps и секции Missing).")
+    else:
+        print("Gaps пусты — проверьте пути и при необходимости переименуйте в канон.")
+    return out_path

offline_docker/load_images.py

@@ -0,0 +1,34 @@
+"""Load Docker images from offline-cache/docker/*.tar."""
+
+from __future__ import annotations
+
+from offline_docker import docker_cmd
+from offline_docker.context import ProjectContext
+
+
+def load_docker_images(ctx: ProjectContext) -> None:
+    print("=== load-docker-images ===")
+    print(f"Каталог: {ctx.docker_cache_dir}")
+    print()
+
+    if not ctx.docker_cache_dir.is_dir():
+        print(
+            f"WARN: каталог {ctx.docker_cache_dir} не найден - пропуск",
+            flush=True,
+        )
+        return
+
+    tars = sorted(ctx.docker_cache_dir.glob("*.tar"))
+    if not tars:
+        print(
+            f"WARN: нет .tar в {ctx.docker_cache_dir} - выполните offdock cache images",
+            flush=True,
+        )
+        return
+
+    for tar_path in tars:
+        print(f">>> load {tar_path.name}")
+        docker_cmd.run(["docker", "load", "-i", str(tar_path)])
+
+    print()
+    print(f"=== Готово: загружено {len(tars)} образов ===")

offline_docker/oc_discovery.py

@@ -0,0 +1,206 @@
+"""Discover offline-cache oc:// bind mounts from project Dockerfiles."""
+
+from __future__ import annotations
+
+import os
+import re
+from dataclasses import dataclass
+from pathlib import Path
+
+from offline_docker.config import ProjectConfig
+
+_OC_MOUNT_RE = re.compile(
+    r"from=oc,source=([^,]+),target=([^,\s]+)",
+    re.IGNORECASE,
+)
+_TAR_ARCHIVE_RE = re.compile(
+    r'tar\s+-xzf\s+"/oc-[^/]+/([^"]+)"',
+    re.IGNORECASE,
+)
+_NODE_FROM_RE = re.compile(r"^FROM\s+(node:[^\s]+)\s+AS\s+", re.MULTILINE | re.IGNORECASE)
+_WORKDIR_RE = re.compile(r"^WORKDIR\s+(/[^\s#]+)", re.MULTILINE)
+_GIT_CLONE_RE = re.compile(
+    r'git\s+clone\b[^\n]*--branch\s+"([^"]+)"\s*\\?\s*\n\s*(\S+\.git)',
+    re.MULTILINE | re.IGNORECASE,
+)
+_ARG_DEFAULT_RE = re.compile(r"^ARG\s+(\w+)=([^\s#]+)", re.MULTILINE)
+_COMPOSE_ARG_DEFAULT_RE = re.compile(
+    r"^\s*(\w+):\s*\$\{\1:-([^}]+)\}",
+    re.MULTILINE,
+)
+
+
+@dataclass(frozen=True)
+class YarnCacheSpec:
+    cache_subdir: str
+    node_image: str
+    archive_subdir: str
+    archive_name_template: str
+    version_arg: str
+    frontend_dir: str
+    git_url: str
+    git_tag_prefix: str
+    source_dockerfile: str
+
+
+def offline_dockerfile_paths(cfg: ProjectConfig) -> list[Path]:
+    found: list[Path] = []
+    seen: set[Path] = set()
+    for pattern in ("**/*Dockerfile.offline", "**/*.Dockerfile.offline"):
+        for path in sorted(cfg.root.glob(pattern)):
+            if path.is_file() and path not in seen:
+                seen.add(path)
+                found.append(path)
+    return found
+
+
+def discover_yarn_cache_specs(cfg: ProjectConfig) -> list[YarnCacheSpec]:
+    specs: list[YarnCacheSpec] = []
+    seen_keys: set[tuple[str, str]] = set()
+
+    for dockerfile in offline_dockerfile_paths(cfg):
+        text = dockerfile.read_text(encoding="utf-8", errors="replace")
+        if "source=yarn" not in text:
+            continue
+        spec = _parse_yarn_spec(cfg, dockerfile, text)
+        if spec is None:
+            continue
+        key = (spec.cache_subdir, spec.archive_subdir)
+        if key in seen_keys:
+            continue
+        seen_keys.add(key)
+        specs.append(spec)
+    return specs
+
+
+def yarn_cache_needed(cfg: ProjectConfig) -> bool:
+    return bool(discover_yarn_cache_specs(cfg))
+
+
+def archive_tar_path(cfg: ProjectConfig, spec: YarnCacheSpec) -> Path:
+    version = resolve_build_arg(cfg, spec.version_arg, cfg.path(spec.source_dockerfile))
+    name = spec.archive_name_template.format(version=version)
+    return cfg.offline_cache / spec.archive_subdir / name
+
+
+def resolve_build_arg(cfg: ProjectConfig, arg_name: str, dockerfile: Path) -> str:
+    env_val = os.environ.get(arg_name, "").strip()
+    if env_val:
+        return env_val
+
+    if dockerfile.is_file():
+        for match in _ARG_DEFAULT_RE.finditer(dockerfile.read_text(encoding="utf-8", errors="replace")):
+            if match.group(1) == arg_name:
+                return match.group(2).strip('"').strip("'")
+
+    for compose_name in (
+        cfg.compose_offline,
+        cfg.compose_online,
+        *cfg.compose_build,
+        *cfg.compose_files,
+    ):
+        compose = cfg.path(compose_name)
+        if not compose.is_file():
+            continue
+        text = compose.read_text(encoding="utf-8", errors="replace")
+        pattern = re.compile(
+            rf"^\s*{re.escape(arg_name)}:\s*\$\{{{re.escape(arg_name)}:-([^}}]+)\}}",
+            re.MULTILINE,
+        )
+        match = pattern.search(text)
+        if match:
+            return match.group(1).strip().strip('"').strip("'")
+
+    raise RuntimeError(
+        f"не удалось определить значение build-arg {arg_name} "
+        f"(Dockerfile/compose/env {arg_name})"
+    )
+
+
+def _parse_yarn_spec(cfg: ProjectConfig, dockerfile: Path, text: str) -> YarnCacheSpec | None:
+    yarn_subdir: str | None = None
+    archive_subdir: str | None = None
+    for source, _target in _OC_MOUNT_RE.findall(text):
+        if source == "yarn":
+            yarn_subdir = source
+        elif source not in {"wheels", "npm", "debs"} and archive_subdir is None:
+            archive_subdir = source
+
+    if yarn_subdir is None:
+        return None
+
+    tar_match = _TAR_ARCHIVE_RE.search(text)
+    if tar_match is None or archive_subdir is None:
+        return None
+
+    archive_literal = tar_match.group(1)
+    version_arg, template = _split_archive_template(archive_literal)
+    if version_arg is None:
+        return None
+
+    node_image = _NODE_FROM_RE.search(text)
+    if node_image is None:
+        node_image_name = cfg.node_image
+    else:
+        node_image_name = node_image.group(1)
+
+    frontend_dir = _frontend_dir_from_workdir(text)
+    git_url, tag_prefix = _find_git_source(cfg, version_arg, dockerfile)
+
+    rel = dockerfile.relative_to(cfg.root).as_posix()
+    return YarnCacheSpec(
+        cache_subdir=yarn_subdir,
+        node_image=node_image_name,
+        archive_subdir=archive_subdir,
+        archive_name_template=template,
+        version_arg=version_arg,
+        frontend_dir=frontend_dir,
+        git_url=git_url,
+        git_tag_prefix=tag_prefix,
+        source_dockerfile=rel,
+    )
+
+
+def _split_archive_template(archive_literal: str) -> tuple[str | None, str]:
+    match = re.search(r"\$\{(\w+)\}", archive_literal)
+    if not match:
+        return None, archive_literal
+    arg = match.group(1)
+    template = archive_literal.replace(f"${{{arg}}}", "{version}")
+    return arg, template
+
+
+def _frontend_dir_from_workdir(text: str) -> str:
+    workdirs = _WORKDIR_RE.findall(text)
+    for path in reversed(workdirs):
+        if path.endswith("/frontend") or path == "/frontend":
+            return path.split("/")[-1] if "/" in path else path
+    return "frontend"
+
+
+def _find_git_source(cfg: ProjectConfig, version_arg: str, offline_dockerfile: Path) -> tuple[str, str]:
+    candidates: list[Path] = []
+    if offline_dockerfile.name.endswith(".offline"):
+        online_name = offline_dockerfile.name[: -len(".offline")]
+        sibling = offline_dockerfile.parent / online_name
+        if sibling.is_file():
+            candidates.append(sibling)
+
+    for dockerfile in sorted(cfg.root.glob("**/Dockerfile*")):
+        if dockerfile.is_file() and dockerfile not in candidates:
+            candidates.append(dockerfile)
+
+    for dockerfile in candidates:
+        if dockerfile.name.endswith(".offline"):
+            continue
+        text = dockerfile.read_text(encoding="utf-8", errors="replace")
+        for branch_tpl, repo in _GIT_CLONE_RE.findall(text):
+            if f"${{{version_arg}}}" not in branch_tpl and version_arg not in branch_tpl:
+                continue
+            prefix = branch_tpl.split("${", 1)[0]
+            if prefix in {"", "v"}:
+                return repo, prefix or "v"
+            return repo, prefix
+    raise RuntimeError(
+        f"не найден git clone для build-arg {version_arg} в Dockerfile проекта"
+    )

offline_docker/resolve.py

@@ -0,0 +1,306 @@
+"""Build ordered package index chains from configured sources."""
+
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass, field
+from typing import Any, Iterable
+
+from offline_docker.sources.base import Ecosystem, PackageSource
+from offline_docker.sources.filesystem import FilesystemSource
+from offline_docker.sources.nexus import NexusSource
+from offline_docker.sources.proget import ProGetSource
+from offline_docker.sources.upstream import UpstreamSource
+
+
+@dataclass
+class ResolvePolicy:
+    order: list[str] = field(default_factory=lambda: ["local"])
+    fill_local: bool = True
+    on_miss: str = "fail"  # fail | warn
+
+
+@dataclass
+class CacheSettings:
+    sources: list[PackageSource] = field(default_factory=list)
+    resolve: ResolvePolicy = field(default_factory=ResolvePolicy)
+    cache_config_origin: str = "default"  # default | user | project
+
+    def by_name(self) -> dict[str, PackageSource]:
+        return {s.name: s for s in self.sources}
+
+    def ordered_enabled(self) -> list[PackageSource]:
+        by_name = self.by_name()
+        result: list[PackageSource] = []
+        seen: set[str] = set()
+        for name in self.resolve.order:
+            src = by_name.get(name)
+            if src is None or not src.enabled or name in seen:
+                continue
+            result.append(src)
+            seen.add(name)
+        return result
+
+
+class PackageResolver:
+    def __init__(self, settings: CacheSettings) -> None:
+        self.settings = settings
+
+    def sources(self) -> list[PackageSource]:
+        return self.settings.ordered_enabled()
+
+    def index_urls(self, ecosystem: Ecosystem) -> list[str]:
+        urls: list[str] = []
+        seen: set[str] = set()
+        for src in self.sources():
+            for url in src.index_urls(ecosystem):
+                key = url.rstrip("/")
+                if key in seen:
+                    continue
+                seen.add(key)
+                urls.append(url)
+        return urls
+
+    def pypi_index_chain(self) -> list[str]:
+        return self.index_urls("pypi")
+
+    def npm_registries(self) -> list[str]:
+        return self.index_urls("npm")
+
+    def primary_npm_registry(self) -> str | None:
+        regs = self.npm_registries()
+        return regs[0] if regs else None
+
+    def apt_mirrors(self) -> list[str]:
+        return self.index_urls("apt")
+
+    def has_remote_indexes(self) -> bool:
+        return bool(self.pypi_index_chain() or self.npm_registries() or self.apt_mirrors())
+
+    def is_local_only(self) -> bool:
+        return all(getattr(s, "source_type", "") == "filesystem" for s in self.sources())
+
+    def nexus_sources(self) -> list[NexusSource]:
+        return [s for s in self.sources() if isinstance(s, NexusSource)]
+
+    def proget_sources(self) -> list[ProGetSource]:
+        return [s for s in self.sources() if isinstance(s, ProGetSource)]
+
+    def summary_lines(self) -> list[str]:
+        lines = [
+            f"Cache config:     {self.settings.cache_config_origin}",
+            f"Resolve order:    {', '.join(self.settings.resolve.order)}",
+            f"fill_local:       {self.settings.resolve.fill_local}",
+            f"on_miss:          {self.settings.resolve.on_miss}",
+            "Sources:",
+        ]
+        by_name = self.settings.by_name()
+        for name in self.settings.resolve.order:
+            src = by_name.get(name)
+            if src is None:
+                lines.append(f"  - {name}: (missing)")
+                continue
+            status = "on" if src.enabled else "off"
+            lines.append(f"  - {name} [{src.source_type}] {status}")
+            for eco in ("pypi", "npm", "apt"):
+                urls = src.index_urls(eco)  # type: ignore[arg-type]
+                for u in urls:
+                    lines.append(f"      {eco}: {u}")
+        pypi = self.pypi_index_chain()
+        if pypi:
+            lines.append(f"Effective pypi:   {' -> '.join(pypi)}")
+        npm = self.npm_registries()
+        if npm:
+            lines.append(f"Effective npm:    {' -> '.join(npm)}")
+        return lines
+
+
+def _parse_resolve(raw: Any) -> ResolvePolicy:
+    if not isinstance(raw, dict):
+        return ResolvePolicy()
+    order = raw.get("order")
+    order_list = [str(x) for x in order] if isinstance(order, list) and order else ["local"]
+    return ResolvePolicy(
+        order=order_list,
+        fill_local=bool(raw.get("fill_local", True)),
+        on_miss=str(raw.get("on_miss", "fail")),
+    )
+
+
+def source_from_dict(item: dict[str, Any]) -> PackageSource | None:
+    stype = str(item.get("type", "")).lower()
+    name = str(item.get("name", stype or "source"))
+    enabled = bool(item.get("enabled", True))
+    if stype in ("filesystem", "local"):
+        return FilesystemSource(name=name, enabled=enabled)
+    if stype == "upstream":
+        return UpstreamSource(
+            name=name,
+            enabled=enabled,
+            pypi_index=str(item.get("pypi_index", "https://pypi.org/simple")),
+            npm_registry=str(item.get("npm_registry", "https://registry.npmjs.org/")),
+            pytorch_index=str(item["pytorch_index"]) if item.get("pytorch_index") else None,
+        )
+    if stype == "nexus":
+        repos = item.get("repos") if isinstance(item.get("repos"), dict) else {}
+        return NexusSource(
+            name=name,
+            url=str(item.get("url", "")),
+            repos={str(k): str(v) for k, v in repos.items()},
+            auth_env=str(item.get("auth_env", "NEXUS_AUTH")),
+            enabled=enabled,
+            publish=bool(item.get("publish", False)),
+            raw_repo=str(item["raw_repo"]) if item.get("raw_repo") else None,
+        )
+    if stype == "proget":
+        feeds = item.get("feeds") if isinstance(item.get("feeds"), dict) else {}
+        return ProGetSource(
+            name=name,
+            url=str(item.get("url", "")),
+            feeds={str(k): str(v) for k, v in feeds.items()},
+            auth_env=str(item.get("auth_env", "PROGET_API_KEY")),
+            enabled=enabled,
+            publish=bool(item.get("publish", False)),
+        )
+    return None
+
+
+def sources_from_cache_dict(data: dict[str, Any]) -> CacheSettings:
+    sources: list[PackageSource] = []
+    raw_sources = data.get("sources")
+    if isinstance(raw_sources, list):
+        for item in raw_sources:
+            if isinstance(item, dict):
+                src = source_from_dict(item)
+                if src is not None:
+                    sources.append(src)
+    if not any(getattr(s, "source_type", "") == "filesystem" for s in sources):
+        sources.insert(0, FilesystemSource())
+    resolve = _parse_resolve(data.get("resolve"))
+    # Drop empty remote URLs from order effectively via enabled=False on sources
+    return CacheSettings(sources=sources, resolve=resolve)
+
+
+def default_local_only() -> CacheSettings:
+    return CacheSettings(
+        sources=[FilesystemSource()],
+        resolve=ResolvePolicy(order=["local"]),
+        cache_config_origin="default",
+    )
+
+
+def apply_env_order_override(settings: CacheSettings) -> CacheSettings:
+    raw = os.environ.get("OFFLINE_RESOLVE_ORDER", "").strip()
+    if not raw:
+        return settings
+    order = [part.strip() for part in raw.split(",") if part.strip()]
+    if order:
+        settings.resolve.order = order
+    return settings
+
+
+def merge_cache_settings(
+    *,
+    user_data: dict[str, Any] | None,
+    project_data: dict[str, Any] | None,
+    pypi_index: str,
+    pytorch_index: str,
+) -> CacheSettings:
+    """Project cache section wins entirely when present; else user; else local-only.
+
+    Legacy python.pypi_index is exposed as optional upstream when remotes exist
+    or when explicitly enabled in sources.
+    """
+    origin = "default"
+    data: dict[str, Any] | None = None
+    if project_data is not None:
+        data = project_data
+        origin = "project"
+    elif user_data is not None:
+        data = user_data
+        origin = "user"
+
+    if data is None:
+        settings = default_local_only()
+    else:
+        settings = sources_from_cache_dict(data)
+        settings.cache_config_origin = origin
+
+    # Ensure filesystem local always present
+    if not any(getattr(s, "source_type", "") == "filesystem" for s in settings.sources):
+        settings.sources.insert(0, FilesystemSource())
+
+    # If no remote HTTP indexes and no explicit upstream, keep local-only.
+    # Attach implicit upstream only when present in sources or when order asks for it.
+    by_name = {s.name: s for s in settings.sources}
+    if "upstream" in settings.resolve.order and "upstream" not in by_name:
+        settings.sources.append(
+            UpstreamSource(
+                enabled=True,
+                pypi_index=pypi_index,
+                pytorch_index=pytorch_index,
+            )
+        )
+    else:
+        for s in settings.sources:
+            if isinstance(s, UpstreamSource) and s.enabled:
+                if not s.pytorch_index:
+                    s.pytorch_index = pytorch_index
+                if s.pypi_index == "https://pypi.org/simple" and pypi_index:
+                    s.pypi_index = pypi_index.rstrip("/")
+
+    return apply_env_order_override(settings)
+
+
+def build_resolver_from_dicts(
+    *,
+    user_data: dict[str, Any] | None,
+    project_cache: dict[str, Any] | None,
+    pypi_index: str,
+    pytorch_index: str,
+) -> PackageResolver:
+    settings = merge_cache_settings(
+        user_data=user_data,
+        project_data=project_cache,
+        pypi_index=pypi_index,
+        pytorch_index=pytorch_index,
+    )
+    return PackageResolver(settings)
+
+
+def pip_index_chain_for_download(
+    resolver: PackageResolver,
+    *,
+    pypi_index: str,
+    pytorch_index: str,
+) -> tuple[list[str], bool]:
+    """HTTP indexes for download-wheels.
+
+    Returns (chain, used_local_only_fallback).
+    When sources.json is local-only, chain is empty — we temporarily use
+    project/env PyPI + PyTorch indexes so download-* can fill the cache.
+    Prefer `offdock configure --with-upstream` to make that explicit.
+    """
+    chain = list(resolver.pypi_index_chain())
+    used_fallback = False
+    if not chain:
+        chain = [pypi_index, pytorch_index]
+        used_fallback = True
+    elif pytorch_index and pytorch_index.rstrip("/") not in {
+        u.rstrip("/") for u in chain
+    }:
+        chain.append(pytorch_index)
+
+    # PYPI_INDEX env forces first index when set explicitly
+    if os.environ.get("PYPI_INDEX"):
+        forced = pypi_index.rstrip("/")
+        chain = [pypi_index] + [
+            u for u in chain if u.rstrip("/") != forced
+        ]
+    return chain, used_fallback
+
+
+def iter_publish_targets(resolver: PackageResolver) -> Iterable[PackageSource]:
+    for src in resolver.sources():
+        if getattr(src, "publish", False):
+            yield src