fedctl 0.1.0__tar.gz

fedctl-0.1.0/PKG-INFO

@@ -0,0 +1,11 @@
+Metadata-Version: 2.4
+Name: fedctl
+Version: 0.1.0
+Summary: Federated control CLI
+Requires-Python: >=3.11
+Requires-Dist: typer>=0.12.0
+Requires-Dist: tomlkit>=0.12.0
+Requires-Dist: rich>=13.0.0
+Requires-Dist: httpx>=0.27.0
+Requires-Dist: jinja2>=3.1.0
+Requires-Dist: PyYAML>=6.0.0

fedctl-0.1.0/pyproject.toml

@@ -0,0 +1,29 @@
+[build-system]
+requires = ["setuptools>=65", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "fedctl"
+version = "0.1.0"
+description = "Federated control CLI"
+requires-python = ">=3.11"
+dependencies = [
+  "typer>=0.12.0",
+  "tomlkit>=0.12.0",
+  "rich>=13.0.0",
+  "httpx>=0.27.0",
+  "jinja2>=3.1.0",
+  "PyYAML>=6.0.0",
+]
+
+[project.scripts]
+fedctl = "fedctl.cli:app"
+
+[tool.setuptools]
+package-dir = {"" = "src"}
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

fedctl-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

fedctl-0.1.0/src/fedctl/__init__.py

@@ -0,0 +1,4 @@
+"""fedctl package."""
+
+__all__ = ["__version__"]
+__version__ = "0.0.1"

fedctl-0.1.0/src/fedctl/__main__.py

@@ -0,0 +1,11 @@
+"""Module entrypoint for `python -m fedctl`."""
+
+from .cli import app
+
+
+def main() -> None:
+    app()
+
+
+if __name__ == "__main__":
+    main()

fedctl-0.1.0/src/fedctl/build/__init__.py

@@ -0,0 +1,19 @@
+"""Build pipeline for SuperExec images."""
+
+from .build import build_image
+from .dockerfile import render_dockerfile
+from .errors import BuildError
+from .inspect import inspect_project
+from .state import BuildMetadata, load_latest_build, write_latest_build
+from .tagging import default_image_tag
+
+__all__ = [
+    "BuildError",
+    "BuildMetadata",
+    "build_image",
+    "default_image_tag",
+    "inspect_project",
+    "load_latest_build",
+    "render_dockerfile",
+    "write_latest_build",
+]

fedctl-0.1.0/src/fedctl/build/build.py

@@ -0,0 +1,33 @@
+from __future__ import annotations
+
+import subprocess
+from pathlib import Path
+
+from .errors import BuildError
+
+
+def build_image(
+    *,
+    image: str,
+    dockerfile_path: Path,
+    context_dir: Path,
+    no_cache: bool = False,
+    platform: str | None = None,
+    quiet: bool = False,
+) -> None:
+    cmd = ["docker", "build", "-t", image, "-f", str(dockerfile_path)]
+    if no_cache:
+        cmd.append("--no-cache")
+    if quiet:
+        cmd.append("--quiet")
+    if platform:
+        cmd.extend(["--platform", platform])
+    cmd.append(str(context_dir))
+
+    try:
+        result = subprocess.run(cmd, check=False)
+    except FileNotFoundError as exc:
+        raise BuildError("Docker is not installed or not on PATH.") from exc
+
+    if result.returncode != 0:
+        raise BuildError(f"Docker build failed with exit code {result.returncode}.")

fedctl-0.1.0/src/fedctl/build/dockerfile.py

@@ -0,0 +1,15 @@
+from __future__ import annotations
+
+
+def render_dockerfile(flwr_version: str) -> str:
+    return (
+        f"FROM flwr/superexec:{flwr_version}\n"
+        "\n"
+        "WORKDIR /app\n"
+        "\n"
+        "COPY pyproject.toml .\n"
+        "RUN sed -i 's/.*flwr\\[simulation\\].*//' pyproject.toml \\\n"
+        "  && python -m pip install -U --no-cache-dir .\n"
+        "\n"
+        'ENTRYPOINT ["flower-superexec"]\n'
+    )

fedctl-0.1.0/src/fedctl/build/errors.py

@@ -0,0 +1,5 @@
+from __future__ import annotations
+
+
+class BuildError(Exception):
+    """User-facing build errors."""

fedctl-0.1.0/src/fedctl/build/inspect.py

@@ -0,0 +1,38 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+
+from fedctl.project.flwr_inspect import FlwrProjectInfo, inspect_flwr_project, load_pyproject
+
+
+@dataclass(frozen=True)
+class BuildProjectInfo:
+    root: Path
+    pyproject_path: Path
+    project_name: str
+    project_version: str | None
+    flwr_info: FlwrProjectInfo
+
+
+def inspect_project(path: Path) -> BuildProjectInfo:
+    root, doc = load_pyproject(path)
+    pyproject_path = root / "pyproject.toml"
+    flwr_info = inspect_flwr_project(root)
+
+    project = doc.get("project", {}) if isinstance(doc.get("project"), dict) else {}
+    name = project.get("name")
+    if not isinstance(name, str) or not name:
+        raise ValueError("Missing [project].name in pyproject.toml.")
+
+    version = project.get("version")
+    if not isinstance(version, str):
+        version = None
+
+    return BuildProjectInfo(
+        root=root,
+        pyproject_path=pyproject_path,
+        project_name=name,
+        project_version=version,
+        flwr_info=flwr_info,
+    )

fedctl-0.1.0/src/fedctl/build/push.py

@@ -0,0 +1,15 @@
+from __future__ import annotations
+
+import subprocess
+
+from .errors import BuildError
+
+
+def push_image(image: str) -> None:
+    try:
+        result = subprocess.run(["docker", "push", image], check=False)
+    except FileNotFoundError as exc:
+        raise BuildError("Docker is not installed or not on PATH.") from exc
+
+    if result.returncode != 0:
+        raise BuildError(f"Docker push failed with exit code {result.returncode}.")

fedctl-0.1.0/src/fedctl/build/state.py

@@ -0,0 +1,70 @@
+from __future__ import annotations
+
+import json
+import os
+from dataclasses import dataclass
+from datetime import datetime, timezone
+from pathlib import Path
+
+from fedctl.config.paths import user_config_dir
+from .errors import BuildError
+
+
+@dataclass(frozen=True)
+class BuildMetadata:
+    image: str
+    project: str
+    flwr_version: str
+    timestamp: str
+
+    def to_dict(self) -> dict[str, str]:
+        return {
+            "image": self.image,
+            "project": self.project,
+            "flwr_version": self.flwr_version,
+            "timestamp": self.timestamp,
+        }
+
+
+def new_timestamp() -> str:
+    return datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+
+
+def latest_build_path() -> Path:
+    return user_config_dir() / "builds" / "latest.json"
+
+
+def write_latest_build(metadata: BuildMetadata) -> Path:
+    path = latest_build_path()
+    path.parent.mkdir(parents=True, exist_ok=True)
+    payload = json.dumps(metadata.to_dict(), indent=2, sort_keys=True)
+    tmp_path = path.with_suffix(path.suffix + ".tmp")
+    try:
+        tmp_path.write_text(payload, encoding="utf-8")
+        os.replace(tmp_path, path)
+    except OSError as exc:
+        raise BuildError(f"Failed to write build metadata: {exc}") from exc
+    return path
+
+
+def load_latest_build() -> BuildMetadata:
+    path = latest_build_path()
+    if not path.exists():
+        raise BuildError(f"No build metadata found at {path}.")
+    try:
+        raw = json.loads(path.read_text(encoding="utf-8"))
+    except json.JSONDecodeError as exc:
+        raise BuildError(f"Build metadata at {path} is invalid JSON.") from exc
+
+    image = raw.get("image")
+    project = raw.get("project")
+    flwr_version = raw.get("flwr_version")
+    timestamp = raw.get("timestamp")
+    if not all(isinstance(val, str) and val for val in [image, project, flwr_version, timestamp]):
+        raise BuildError(f"Build metadata at {path} is missing required fields.")
+    return BuildMetadata(
+        image=image,
+        project=project,
+        flwr_version=flwr_version,
+        timestamp=timestamp,
+    )

fedctl-0.1.0/src/fedctl/build/tagging.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+
+from datetime import datetime, timezone
+from pathlib import Path
+import subprocess
+
+
+def default_image_tag(project_name: str, *, repo_root: Path | None = None) -> str:
+    suffix = _git_sha(repo_root) or _timestamp()
+    base = project_name.strip() or "superexec"
+    return f"{base}-superexec:{suffix}"
+
+
+def _git_sha(repo_root: Path | None) -> str | None:
+    try:
+        result = subprocess.run(
+            ["git", "rev-parse", "--short", "HEAD"],
+            cwd=str(repo_root) if repo_root else None,
+            check=True,
+            capture_output=True,
+            text=True,
+        )
+    except (subprocess.SubprocessError, FileNotFoundError):
+        return None
+    sha = result.stdout.strip()
+    return sha if sha else None
+
+
+def _timestamp() -> str:
+    return datetime.now(timezone.utc).strftime("%Y%m%d%H%M%S")