ellf-cli 18.0.0__tar.gz → 18.0.2__tar.gz

{ellf_cli-18.0.0/ellf_cli.egg-info → ellf_cli-18.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ellf-cli
-Version: 18.0.0
+Version: 18.0.2
 Summary: Ellf Command Line Interface
 Home-page: https://prodi.gy
 Author: ExplosionAI GmbH

{ellf_cli-18.0.0 → ellf_cli-18.0.2}/ellf_cli/commands/publish_code.py

@@ -6,12 +6,14 @@ import json
 import os
 import subprocess
 import tarfile
+import tempfile
 import time
 import zipfile
+from contextlib import contextmanager
 from dataclasses import dataclass
 from importlib.metadata import PackageNotFoundError, distribution
 from pathlib import Path
-from typing import Optional, Union
+from typing import Iterator, Optional, Union
 from uuid import UUID
 
 import httpx
@@ -44,7 +46,7 @@ class DistPackage:
 
     def __init__(self, path: Path) -> None:
         if path.suffix == ".whl":
-            name, version, _, _2 = parse_wheel_filename(path.name)
+            name, version, _, _ = parse_wheel_filename(path.name)
         else:
             name, version = parse_sdist_filename(path.name)
 
@@ -93,7 +95,7 @@ class ModulePackage:
     def __init__(self, name: str, version_arg: str | None = None) -> None:
         self.name = name
         if version_arg is None:
-            utc_now = datetime.datetime.utcnow()
+            utc_now = datetime.datetime.now(datetime.timezone.utc)
             self.version = f"{utc_now.year}.{utc_now.month}.{utc_now.day}-{utc_now.second + 60 * utc_now.minute + 60 * 60 * utc_now.hour}"
         else:
             self.version = version_arg
@@ -127,7 +129,7 @@ class FilesPackage:
         self.path = path
 
         if version_arg is None:
-            utc_now = datetime.datetime.utcnow()
+            utc_now = datetime.datetime.now(datetime.timezone.utc)
             self.version = f"{utc_now.year}.{utc_now.month}.{utc_now.day}-{utc_now.second + 60 * utc_now.minute + 60 * 60 * utc_now.hour}"
         else:
             self.version = version_arg
@@ -169,14 +171,62 @@ class FilesPackage:
         return output
 
 
+def _unpack_stripped(tar_data: bytes, root: Path) -> None:
+    """Unpack a tar into *root* with its top-level directory removed.
+
+    This is the same re-rooting the broker applies when it lays the
+    package into the image, so what create-meta imports locally is what
+    the cluster will import at runtime.
+    """
+    with tarfile.open(fileobj=io.BytesIO(tar_data), mode="r:*") as tar:
+        for member in tar.getmembers():
+            parts = member.name.split("/", 1)
+            inner = parts[1] if len(parts) > 1 else parts[0]
+            if not inner or inner.startswith("/") or ".." in Path(inner).parts:
+                continue
+            dest = root / inner
+            if member.isdir():
+                dest.mkdir(parents=True, exist_ok=True)
+            elif member.isfile():
+                dest.parent.mkdir(parents=True, exist_ok=True)
+                fileobj = tar.extractfile(member)
+                assert fileobj is not None
+                dest.write_bytes(fileobj.read())
+
+
+@contextmanager
+def _import_root(
+    package: Union[DistPackage, ModulePackage, FilesPackage],
+    source_dir: Path | None,
+    contents: bytes,
+) -> Iterator[Path | None]:
+    """Directory to prepend to PYTHONPATH so create-meta can import the package.
+
+    The broker never installs the package: it strips the sdist's top-level
+    directory and puts the unpacked root on PYTHONPATH. Mirror that here so
+    publishing doesn't require the package to be installed locally.
+    """
+    if isinstance(package, ModulePackage):
+        yield None
+    elif isinstance(package, FilesPackage):
+        yield package.path.resolve().parent
+    elif source_dir is not None:
+        yield source_dir.resolve()
+    else:
+        with tempfile.TemporaryDirectory(prefix="ellf-publish-") as tmp:
+            root = Path(tmp)
+            _unpack_stripped(contents, root)
+            yield root
+
+
 def _run_create_meta(
     package_name: str, *, extra_python_path: Path | None = None
 ) -> str:
     """Run create-meta locally to produce recipe metadata JSON.
 
     If *extra_python_path* is given it is prepended to ``PYTHONPATH`` so
-    that ``create-meta`` can import loose ``.py`` files that aren't
-    installed as packages.
+    that ``create-meta`` can import the package without it being
+    installed.
     """
     env = None
     if extra_python_path is not None:
@@ -200,9 +250,16 @@ def _run_create_meta(
         env=env,
     )
     if result.returncode != 0:
-        raise CLIError(
-            f"create-meta failed (exit {result.returncode}):\n{result.stderr}"
-        )
+        message = f"create-meta failed (exit {result.returncode}):\n{result.stderr}"
+        if "RecipePackageNotFound" in result.stderr:
+            where = f" from {extra_python_path}" if extra_python_path else ""
+            message += (
+                f"\nCould not import '{package_name}'{where}. The package is "
+                "imported by name rather than installed, so the source must "
+                f"contain a '{package_name}' package (a directory with "
+                f"__init__.py) or a '{package_name}.py' module at its top level."
+            )
+        raise CLIError(message)
     return result.stdout.strip()
 
 
@@ -425,10 +482,12 @@ def publish_code(
     if auth.cluster_id is None:
         raise CLIError(Messages.E036)
 
+    source_dir: Path | None = None
     if is_path:
         path = Path(name_or_path)
-        if path.is_dir() and (path / "setup.py").exists():
+        if path.is_dir() and _is_package_dir(path):
             msg.info(f"Building sdist from {name_or_path}")
+            source_dir = path
             package = DistPackage(_make_sdist_if_dir(path))
         elif not path.is_file():
             msg.info(f"Interpreting {name_or_path} as directory of code")
@@ -447,15 +506,13 @@ def publish_code(
         if package_version is None:
             msg.info(f"No version specified. Defaulting to {package.version}")
 
-    # Generate recipe metadata locally
-    # For FilesPackage we need to tell the subprocess where to find the source
-    # so that ``create-meta`` can actually import the module.
-    extra_python_path: Path | None = None
-    if isinstance(package, FilesPackage):
-        src = package.path.resolve()
-        extra_python_path = src.parent if src.is_file() else src.parent
-    with loading("Generating recipe metadata"):
-        meta_json = _run_create_meta(package.name, extra_python_path=extra_python_path)
+    # Generate recipe metadata locally, importing the package from its
+    # source rather than requiring it to be installed.
+    with _import_root(package, source_dir, contents) as extra_python_path:
+        with loading("Generating recipe metadata"):
+            meta_json = _run_create_meta(
+                package.name, extra_python_path=extra_python_path
+            )
 
     meta_list = json.loads(meta_json)
     if len(meta_list) == 0:
@@ -524,16 +581,39 @@ def _is_path(name_or_path: str) -> bool:
         return path.exists()
 
 
+def _is_package_dir(path: Path) -> bool:
+    return (path / "setup.py").exists() or (path / "pyproject.toml").exists()
+
+
 def _make_sdist_if_dir(path: Path) -> Path:
     if not path.is_dir():
         return path
     env = dict(os.environ)
     env["SKIP_CYTHON"] = "1"
-    r = subprocess.run(["python", "setup.py", "sdist"], cwd=path, text=True, env=env)
-    r.check_returncode()
-    dists = list((path / "dist").iterdir())
+    if (path / "setup.py").exists():
+        cmd = ["python", "setup.py", "sdist"]
+    else:
+        # pyproject.toml-only projects have no setup.py to run; `build`
+        # is the standard front-end but isn't a CLI dependency.
+        cmd = ["python", "-m", "build", "--sdist"]
+        probe = subprocess.run(
+            ["python", "-c", "import build"], capture_output=True, text=True
+        )
+        if probe.returncode != 0:
+            raise CLIError(
+                f"{path} has a pyproject.toml but no setup.py, so building "
+                "its sdist needs the 'build' package. Install it with "
+                "`pip install build` and re-run the publish command."
+            )
+    r = subprocess.run(cmd, cwd=path, text=True, env=env)
+    if r.returncode != 0:
+        raise CLIError(f"Building the sdist in {path} failed (exit {r.returncode})")
+    dist_dir = path / "dist"
+    if not dist_dir.is_dir():
+        raise CLIError(f"sdist not created after building in {path}")
+    dists = [p for p in dist_dir.iterdir() if p.is_file()]
     if len(dists) == 0:
-        raise ValueError("sdist not created after subprocess in {path / 'dist'}")
+        raise CLIError(f"sdist not created after building in {dist_dir}")
     # Return last modified file
     return max(dists, key=lambda p: p.stat().st_mtime)
 
@@ -646,6 +726,6 @@ def _read_record(path: Path) -> list[str]:
     output = []
     with path.open("r", encoding="utf8") as file_:
         for line in file_.read().strip().split("\n"):
-            subpath, sha, size = line.split(",")
+            subpath, _, _ = line.split(",")
             output.append(subpath)
     return output

{ellf_cli-18.0.0 → ellf_cli-18.0.2}/ellf_cli/ellf.json

@@ -1,7 +1,7 @@
 {
   "prog": "ellf",
   "help": "Ellf Command Line Interface.",
-  "version": "17.0.206",
+  "version": "18.0.1",
   "extra_key": "_extra",
   "commands": {
     "actions": {

ellf_cli-18.0.2/ellf_cli/version/18.0.0_2026-09-12-10-01-10_patch_8995783a-a9fa-4c4e-90b3-6386a4c481eb

@@ -0,0 +1,3 @@
+18.0.0
+patch
+8995783a-a9fa-4c4e-90b3-6386a4c481eb

ellf_cli-18.0.2/ellf_cli/version/18.0.1_2026-09-12-17-33-30_patch_f6ea2c99-a715-4c4d-876a-23ed8c62a83d

@@ -0,0 +1,3 @@
+18.0.1
+patch
+f6ea2c99-a715-4c4d-876a-23ed8c62a83d

{ellf_cli-18.0.0 → ellf_cli-18.0.2/ellf_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ellf-cli
-Version: 18.0.0
+Version: 18.0.2
 Summary: Ellf Command Line Interface
 Home-page: https://prodi.gy
 Author: ExplosionAI GmbH

{ellf_cli-18.0.0 → ellf_cli-18.0.2}/ellf_cli.egg-info/SOURCES.txt

@@ -261,6 +261,8 @@ ellf_cli/version/17.0.204_2026-09-10-13-02-02_patch_d4ee41e2-d13c-4941-8605-3f1a
 ellf_cli/version/17.0.205_2026-09-10-13-57-50_patch_284df67e-5957-4b0c-bc64-5581db6ddecc
 ellf_cli/version/17.0.206_2026-09-11-10-18-50_patch_1ac7e410-0e62-4eef-bbe4-ebf93c9d0869
 ellf_cli/version/17.0.207_2026-09-11-15-26-02_major_3f1b3ed7-eaac-41f5-b740-0af3331595d9
+ellf_cli/version/18.0.0_2026-09-12-10-01-10_patch_8995783a-a9fa-4c4e-90b3-6386a4c481eb
+ellf_cli/version/18.0.1_2026-09-12-17-33-30_patch_f6ea2c99-a715-4c4d-876a-23ed8c62a83d
 ellf_cli/version/__init__.py
 ellf_cli/version/read_version.py
 tests/test_appdirs.py
@@ -294,6 +296,7 @@ tests/test_plans.py
 tests/test_projects.py
 tests/test_publish_build_poll.py
 tests/test_publish_data.py
+tests/test_publish_import_root.py
 tests/test_publish_requirements.py
 tests/test_pypi_auth.py
 tests/test_query.py

ellf_cli-18.0.2/tests/test_publish_import_root.py

@@ -0,0 +1,120 @@
+"""Tests for how `publish code` makes uninstalled packages importable.
+
+The broker never installs a published package: it strips the sdist's
+top-level directory and puts the unpacked root on PYTHONPATH. Local
+metadata generation must mirror that, or publishing silently requires
+the package to be installed in the developer's environment.
+"""
+
+import io
+import subprocess
+import tarfile
+import zipfile
+from pathlib import Path
+
+import pytest
+
+from ellf_cli.commands.publish_code import (
+    DistPackage,
+    FilesPackage,
+    ModulePackage,
+    _import_root,
+    _is_package_dir,
+    _run_create_meta,
+)
+from ellf_cli.errors import CLIError
+
+
+def _make_sdist(tmp_path, name="my_pkg-1.0.0"):
+    sdist = tmp_path / f"{name}.tar.gz"
+    with tarfile.open(sdist, "w:gz") as tar:
+        for inner, text in [
+            ("PKG-INFO", "Name: my-pkg\nVersion: 1.0.0\n"),
+            ("my_pkg/__init__.py", "def recipe(): pass\n"),
+            ("../escape.py", "evil = True\n"),
+        ]:
+            data = text.encode("utf8")
+            info = tarfile.TarInfo(name=f"{name}/{inner}")
+            info.size = len(data)
+            tar.addfile(info, io.BytesIO(data))
+    return sdist
+
+
+def _make_wheel(tmp_path, name="my_pkg-1.0.0"):
+    wheel = tmp_path / f"{name}-py3-none-any.whl"
+    with zipfile.ZipFile(wheel, "w") as zf:
+        zf.writestr("my_pkg/__init__.py", "def recipe(): pass\n")
+        zf.writestr(f"{name}.dist-info/METADATA", "Name: my-pkg\nVersion: 1.0.0\n")
+    return wheel
+
+
+def test_setup_py_dir_is_its_own_import_root(tmp_path):
+    src = tmp_path / "my_pkg"
+    (src / "my_pkg").mkdir(parents=True)
+    (src / "setup.py").write_text("", encoding="utf8")
+    package = DistPackage(_make_sdist(tmp_path))
+    with _import_root(package, src, package.get_bytes()) as root:
+        assert root == src.resolve()
+
+
+def test_files_dir_import_root_is_parent(tmp_path):
+    src = tmp_path / "my_recipes"
+    src.mkdir()
+    package = FilesPackage(path=src, name="my_recipes")
+    with _import_root(package, None, b"") as root:
+        assert root == tmp_path.resolve()
+
+
+def test_module_package_has_no_import_root():
+    with _import_root(ModulePackage("my_pkg", "1.0.0"), None, b"") as root:
+        assert root is None
+
+
+def test_prebuilt_sdist_is_unpacked_with_top_dir_stripped(tmp_path):
+    package = DistPackage(_make_sdist(tmp_path))
+    with _import_root(package, None, package.get_bytes()) as root:
+        assert root is not None
+        assert (root / "my_pkg" / "__init__.py").is_file()
+        assert not (root / "my_pkg-1.0.0").exists()
+        assert not (root.parent / "escape.py").exists()
+    assert not root.exists()
+
+
+def test_prebuilt_wheel_is_unpacked_with_top_dir_stripped(tmp_path):
+    package = DistPackage(_make_wheel(tmp_path))
+    with _import_root(package, None, package.get_bytes()) as root:
+        assert root is not None
+        assert (root / "my_pkg" / "__init__.py").is_file()
+
+
+def test_is_package_dir_accepts_pyproject_only(tmp_path):
+    assert not _is_package_dir(tmp_path)
+    (tmp_path / "pyproject.toml").write_text("", encoding="utf8")
+    assert _is_package_dir(tmp_path)
+
+
+def test_create_meta_prepends_import_root_to_pythonpath(monkeypatch, tmp_path):
+    seen = {}
+
+    def fake_run(cmd, **kwargs):
+        seen["env"] = kwargs["env"]
+        return subprocess.CompletedProcess(cmd, 0, stdout="[]", stderr="")
+
+    monkeypatch.setenv("PYTHONPATH", "/existing")
+    monkeypatch.setattr(subprocess, "run", fake_run)
+    assert _run_create_meta("my_pkg", extra_python_path=tmp_path) == "[]"
+    assert seen["env"]["PYTHONPATH"].split(":") == [str(tmp_path), "/existing"]
+
+
+def test_create_meta_explains_unimportable_package(monkeypatch, tmp_path):
+    def fake_run(cmd, **_):
+        return subprocess.CompletedProcess(
+            cmd, 1, stdout="", stderr="...RecipePackageNotFound: my_pkg"
+        )
+
+    monkeypatch.setattr(subprocess, "run", fake_run)
+    with pytest.raises(CLIError) as excinfo:
+        _run_create_meta("my_pkg", extra_python_path=Path(tmp_path))
+    text = str(excinfo.value)
+    assert "Could not import 'my_pkg'" in text
+    assert str(tmp_path) in text