ls-algorithm-plugin-sdk 0.3.5__tar.gz → 0.3.7__tar.gz

{ls_algorithm_plugin_sdk-0.3.5 → ls_algorithm_plugin_sdk-0.3.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ls-algorithm-plugin-sdk
-Version: 0.3.5
+Version: 0.3.7
 Summary: Protocol-independent runtime SDK for dataset algorithms
 Author: Ling Robotics
 License: Proprietary
@@ -71,11 +71,19 @@ sudo /srv/camera-space-mano/.venv/bin/algorithm-plugin configure \
   --api-key "$LDP_INTERNAL_API_KEY" \
   --port 9030 \
   --cluster production \
-  --gpu-ids 0,1
+  --gpu-ids 0,1 \
+  --log-retention-days 7 \
+  --output-retention-days 2 \
+  --scratch-retention-days 2
 ```
 
 重复执行 configure 需要显式提供 `--force`。
 
+配置部署的服务会启动独立清理进程，每小时扫描一次。仅删除创建超过日志保留期且
+末行状态为 `succeeded` 的任务日志；`outputRoot` 和 `scratchRoot` 下超过对应保留期
+未修改的数据也会被删除。清理记录按天写入 `<repository>/logs/cleanup-YYYYMMDD.log`，
+包含清理时间、路径和字节数；清理记录自身不会被自动删除。
+
 确认输出后执行：
 
 ```bash

{ls_algorithm_plugin_sdk-0.3.5 → ls_algorithm_plugin_sdk-0.3.7}/README.md

@@ -55,11 +55,19 @@ sudo /srv/camera-space-mano/.venv/bin/algorithm-plugin configure \
   --api-key "$LDP_INTERNAL_API_KEY" \
   --port 9030 \
   --cluster production \
-  --gpu-ids 0,1
+  --gpu-ids 0,1 \
+  --log-retention-days 7 \
+  --output-retention-days 2 \
+  --scratch-retention-days 2
 ```
 
 重复执行 configure 需要显式提供 `--force`。
 
+配置部署的服务会启动独立清理进程，每小时扫描一次。仅删除创建超过日志保留期且
+末行状态为 `succeeded` 的任务日志；`outputRoot` 和 `scratchRoot` 下超过对应保留期
+未修改的数据也会被删除。清理记录按天写入 `<repository>/logs/cleanup-YYYYMMDD.log`，
+包含清理时间、路径和字节数；清理记录自身不会被自动删除。
+
 确认输出后执行：
 
 ```bash
@@ -81,4 +89,4 @@ sudo systemctl status camera-space-mano.service --no-pager
 ```bash
 python -m pip install .
 python -m unittest discover -s tests -v
-```
+```

{ls_algorithm_plugin_sdk-0.3.5 → ls_algorithm_plugin_sdk-0.3.7}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "ls-algorithm-plugin-sdk"
-version = "0.3.5"
+version = "0.3.7"
 description = "Protocol-independent runtime SDK for dataset algorithms"
 readme = "README.md"
 requires-python = ">=3.10"

ls_algorithm_plugin_sdk-0.3.7/src/algorithm_plugin_sdk/cleanup.py

@@ -0,0 +1,336 @@
+from __future__ import annotations
+
+import json
+import multiprocessing
+import os
+import shutil
+import time
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+DEFAULT_LOG_RETENTION_DAYS = 7
+DEFAULT_OUTPUT_RETENTION_DAYS = 2
+DEFAULT_SCRATCH_RETENTION_DAYS = 2
+SCAN_INTERVAL_SECONDS = 60 * 60
+
+_AUDIT_LOG_PREFIX = "cleanup-"
+_SECONDS_PER_DAY = 24 * 60 * 60
+
+
+def _write_audit(log_dir: Path, event: str, **values: Any) -> None:
+    log_dir.mkdir(parents=True, exist_ok=True)
+    timestamp = datetime.now().astimezone()
+    path = log_dir / f"{_AUDIT_LOG_PREFIX}{timestamp:%Y%m%d}.log"
+    payload = {
+        "timestamp": timestamp.isoformat(),
+        "event": event,
+        **values,
+    }
+    with path.open("a", encoding="utf-8", buffering=1) as stream:
+        stream.write(json.dumps(payload, ensure_ascii=False, default=str) + "\n")
+
+
+def _job_logs(log_dir: Path) -> list[Path]:
+    return sorted(
+        path
+        for path in log_dir.glob("*.log")
+        if not path.name.startswith(_AUDIT_LOG_PREFIX) and path.is_file()
+    )
+
+
+def _request_roots(path: Path) -> tuple[set[Path], set[Path]]:
+    output_roots: set[Path] = set()
+    scratch_roots: set[Path] = set()
+    with path.open(encoding="utf-8", errors="replace") as stream:
+        for line in stream:
+            try:
+                payload = json.loads(line)
+            except json.JSONDecodeError:
+                continue
+            if payload.get("event") != "request":
+                continue
+            output_root = _safe_root(payload.get("outputRoot"))
+            scratch_root = _safe_root(payload.get("scratchRoot"))
+            if output_root is not None:
+                output_roots.add(output_root)
+            if scratch_root is not None:
+                scratch_roots.add(scratch_root)
+    return output_roots, scratch_roots
+
+
+def _safe_root(value: Any) -> Path | None:
+    if not isinstance(value, str) or not value.strip():
+        return None
+    path = Path(value).expanduser()
+    if not path.is_absolute():
+        return None
+    resolved = path.resolve()
+    if resolved == Path(resolved.anchor):
+        return None
+    return resolved
+
+
+def _last_nonempty_line(path: Path) -> str:
+    with path.open("rb") as stream:
+        stream.seek(0, os.SEEK_END)
+        position = stream.tell()
+        data = b""
+        while position > 0:
+            read_size = min(8192, position)
+            position -= read_size
+            stream.seek(position)
+            data = stream.read(read_size) + data
+            lines = data.splitlines()
+            if position == 0 or len(lines) > 1:
+                for line in reversed(lines):
+                    if line.strip():
+                        return line.decode("utf-8", errors="replace")
+        return ""
+
+
+def _succeeded(path: Path) -> bool:
+    try:
+        payload = json.loads(_last_nonempty_line(path))
+    except (OSError, json.JSONDecodeError):
+        return False
+    return payload.get("state") == "succeeded"
+
+
+def _log_created_at(path: Path) -> float:
+    timestamp, separator, _ = path.name.partition("-")
+    if separator and len(timestamp) == 14 and timestamp.isdigit():
+        try:
+            return datetime.strptime(timestamp, "%Y%m%d%H%M%S").replace(
+                tzinfo=timezone.utc
+            ).timestamp()
+        except ValueError:
+            pass
+    stat = path.stat()
+    return getattr(stat, "st_birthtime", stat.st_ctime)
+
+
+def _tree_stats(path: Path) -> tuple[int, float]:
+    stat = path.lstat()
+    total_size = stat.st_size if not path.is_dir() or path.is_symlink() else 0
+    latest_mtime = stat.st_mtime
+    if path.is_dir() and not path.is_symlink():
+        for root, directories, files in os.walk(path, followlinks=False):
+            root_path = Path(root)
+            for name in (*directories, *files):
+                child = root_path / name
+                try:
+                    child_stat = child.lstat()
+                except FileNotFoundError:
+                    continue
+                latest_mtime = max(latest_mtime, child_stat.st_mtime)
+                if not child.is_dir() or child.is_symlink():
+                    total_size += child_stat.st_size
+    return total_size, latest_mtime
+
+
+def _delete(path: Path) -> None:
+    if path.is_dir() and not path.is_symlink():
+        shutil.rmtree(path)
+    else:
+        path.unlink()
+
+
+def cleanup_once(
+    log_dir: str | Path,
+    *,
+    log_retention_days: int = DEFAULT_LOG_RETENTION_DAYS,
+    output_retention_days: int = DEFAULT_OUTPUT_RETENTION_DAYS,
+    scratch_retention_days: int = DEFAULT_SCRATCH_RETENTION_DAYS,
+    known_output_roots: set[Path] | None = None,
+    known_scratch_roots: set[Path] | None = None,
+    now: float | None = None,
+) -> tuple[set[Path], set[Path]]:
+    directory = Path(log_dir).expanduser().resolve()
+    directory.mkdir(parents=True, exist_ok=True)
+    output_roots = known_output_roots if known_output_roots is not None else set()
+    scratch_roots = known_scratch_roots if known_scratch_roots is not None else set()
+    current_time = time.time() if now is None else now
+    started_at = datetime.now().astimezone().isoformat()
+    deleted_count = 0
+    deleted_bytes = 0
+    error_count = 0
+
+    logs = _job_logs(directory)
+    for path in logs:
+        try:
+            discovered_output, discovered_scratch = _request_roots(path)
+        except OSError as exc:
+            error_count += 1
+            _write_audit(
+                directory,
+                "scan_failed",
+                category="log",
+                path=str(path),
+                error=f"{type(exc).__name__}: {exc}",
+            )
+            continue
+        output_roots.update(discovered_output)
+        scratch_roots.update(discovered_scratch)
+
+    def remove(path: Path, category: str, size: int) -> None:
+        nonlocal deleted_count, deleted_bytes, error_count
+        try:
+            _delete(path)
+        except FileNotFoundError:
+            return
+        except OSError as exc:
+            error_count += 1
+            _write_audit(
+                directory,
+                "delete_failed",
+                category=category,
+                path=str(path),
+                sizeBytes=size,
+                error=f"{type(exc).__name__}: {exc}",
+            )
+            return
+        deleted_count += 1
+        deleted_bytes += size
+        _write_audit(
+            directory,
+            "deleted",
+            category=category,
+            path=str(path),
+            sizeBytes=size,
+        )
+
+    log_cutoff = current_time - log_retention_days * _SECONDS_PER_DAY
+    for path in logs:
+        try:
+            if _log_created_at(path) < log_cutoff and _succeeded(path):
+                remove(path, "log", path.stat().st_size)
+        except OSError as exc:
+            error_count += 1
+            _write_audit(
+                directory,
+                "scan_failed",
+                category="log",
+                path=str(path),
+                error=f"{type(exc).__name__}: {exc}",
+            )
+
+    protected = directory.resolve()
+    for category, roots, retention_days in (
+        ("output", output_roots, output_retention_days),
+        ("scratch", scratch_roots, scratch_retention_days),
+    ):
+        cutoff = current_time - retention_days * _SECONDS_PER_DAY
+        for root in sorted(roots):
+            if not root.is_dir():
+                continue
+            try:
+                entries = list(root.iterdir())
+            except OSError as exc:
+                error_count += 1
+                _write_audit(
+                    directory,
+                    "scan_failed",
+                    category=category,
+                    path=str(root),
+                    error=f"{type(exc).__name__}: {exc}",
+                )
+                continue
+            for path in entries:
+                resolved = path.resolve()
+                if (
+                    resolved == protected
+                    or resolved in protected.parents
+                    or protected in resolved.parents
+                ):
+                    continue
+                try:
+                    size, latest_mtime = _tree_stats(path)
+                    if latest_mtime < cutoff:
+                        remove(path, category, size)
+                except OSError as exc:
+                    error_count += 1
+                    _write_audit(
+                        directory,
+                        "scan_failed",
+                        category=category,
+                        path=str(path),
+                        error=f"{type(exc).__name__}: {exc}",
+                    )
+
+    _write_audit(
+        directory,
+        "scan_completed",
+        startedAt=started_at,
+        finishedAt=datetime.now().astimezone().isoformat(),
+        deletedCount=deleted_count,
+        deletedBytes=deleted_bytes,
+        errorCount=error_count,
+    )
+    return output_roots, scratch_roots
+
+
+def _cleanup_loop(
+    log_dir: str,
+    log_retention_days: int,
+    output_retention_days: int,
+    scratch_retention_days: int,
+    stop_event: Any,
+) -> None:
+    output_roots: set[Path] = set()
+    scratch_roots: set[Path] = set()
+    while True:
+        try:
+            cleanup_once(
+                log_dir,
+                log_retention_days=log_retention_days,
+                output_retention_days=output_retention_days,
+                scratch_retention_days=scratch_retention_days,
+                known_output_roots=output_roots,
+                known_scratch_roots=scratch_roots,
+            )
+        except Exception as exc:
+            _write_audit(
+                Path(log_dir),
+                "scan_crashed",
+                error=f"{type(exc).__name__}: {exc}",
+            )
+        if stop_event.wait(SCAN_INTERVAL_SECONDS):
+            return
+
+
+class CleanupProcess:
+    def __init__(
+        self,
+        log_dir: str | Path,
+        *,
+        log_retention_days: int = DEFAULT_LOG_RETENTION_DAYS,
+        output_retention_days: int = DEFAULT_OUTPUT_RETENTION_DAYS,
+        scratch_retention_days: int = DEFAULT_SCRATCH_RETENTION_DAYS,
+    ) -> None:
+        context = multiprocessing.get_context("spawn")
+        self._stop_event = context.Event()
+        self._process = context.Process(
+            target=_cleanup_loop,
+            args=(
+                str(Path(log_dir).expanduser().resolve()),
+                log_retention_days,
+                output_retention_days,
+                scratch_retention_days,
+                self._stop_event,
+            ),
+            name="algorithm-plugin-cleanup",
+            daemon=True,
+        )
+
+    def start(self) -> None:
+        self._process.start()
+
+    def stop(self) -> None:
+        if not self._process.is_alive():
+            return
+        self._stop_event.set()
+        self._process.join(timeout=5)
+        if self._process.is_alive():
+            self._process.terminate()
+            self._process.join(timeout=5)

{ls_algorithm_plugin_sdk-0.3.5 → ls_algorithm_plugin_sdk-0.3.7}/src/algorithm_plugin_sdk/cli_impl/configure.py

@@ -10,6 +10,11 @@ import sys
 from pathlib import Path
 from urllib.parse import urlparse
 
+from ..cleanup import (
+    DEFAULT_LOG_RETENTION_DAYS,
+    DEFAULT_OUTPUT_RETENTION_DAYS,
+    DEFAULT_SCRATCH_RETENTION_DAYS,
+)
 from ..deployment import (
     DEFAULT_CONFIG_NAME,
     DeploymentConfig,
@@ -31,6 +36,13 @@ SERVICE_NAME_PATTERN = re.compile(
 )
 
 
+def _retention_days(value: str) -> int:
+    days = int(value)
+    if days < 0:
+        raise argparse.ArgumentTypeError("retention days must be non-negative")
+    return days
+
+
 def configure_parser(parser: argparse.ArgumentParser) -> None:
     parser.add_argument(
         "algorithm",
@@ -72,6 +84,24 @@ def configure_parser(parser: argparse.ArgumentParser) -> None:
         action="store_true",
         help="override request output paths with <repository>/.output/<job-id>",
     )
+    parser.add_argument(
+        "--log-retention-days",
+        type=_retention_days,
+        default=DEFAULT_LOG_RETENTION_DAYS,
+        help=f"successful log retention in days (default: {DEFAULT_LOG_RETENTION_DAYS})",
+    )
+    parser.add_argument(
+        "--output-retention-days",
+        type=_retention_days,
+        default=DEFAULT_OUTPUT_RETENTION_DAYS,
+        help=f"output retention in days (default: {DEFAULT_OUTPUT_RETENTION_DAYS})",
+    )
+    parser.add_argument(
+        "--scratch-retention-days",
+        type=_retention_days,
+        default=DEFAULT_SCRATCH_RETENTION_DAYS,
+        help=f"scratch retention in days (default: {DEFAULT_SCRATCH_RETENTION_DAYS})",
+    )
     parser.add_argument(
         "--gpu-ids",
         type=gpu_ids,
@@ -426,6 +456,9 @@ def generate_config(
         gpu_ids=args.gpu_ids,
         environment=dict(args.env),
         default_parameters=args.default_parameters,
+        log_retention_days=args.log_retention_days,
+        output_retention_days=args.output_retention_days,
+        scratch_retention_days=args.scratch_retention_days,
     )
     config.save()
     return config

{ls_algorithm_plugin_sdk-0.3.5 → ls_algorithm_plugin_sdk-0.3.7}/src/algorithm_plugin_sdk/cli_impl/run.py

@@ -34,7 +34,7 @@ def configure_parser(parser: argparse.ArgumentParser) -> None:
     parser.add_argument("--parameters", type=json_object)
     parser.add_argument("--request-file", type=Path)
     parser.add_argument("--scratch-dir")
-    parser.add_argument("--algorithm-log", type=Path)
+    parser.add_argument("--log", type=Path)
     parser.set_defaults(handler=execute)
 
 
@@ -139,10 +139,10 @@ def execute(args: argparse.Namespace) -> int:
     )
     try:
         with ExitStack() as stack:
-            if args.algorithm_log is not None:
-                args.algorithm_log.parent.mkdir(parents=True, exist_ok=True)
+            if args.log is not None:
+                args.log.parent.mkdir(parents=True, exist_ok=True)
                 stream = stack.enter_context(
-                    args.algorithm_log.open("w", encoding="utf-8", buffering=1)
+                    args.log.open("w", encoding="utf-8", buffering=1)
                 )
                 stack.enter_context(redirect_stdout(stream))
                 stack.enter_context(redirect_stderr(stream))

{ls_algorithm_plugin_sdk-0.3.5 → ls_algorithm_plugin_sdk-0.3.7}/src/algorithm_plugin_sdk/cli_impl/serve.py

@@ -4,6 +4,7 @@ import argparse
 import os
 from pathlib import Path
 
+from ..cleanup import CleanupProcess
 from ..deployment import DEFAULT_CONFIG_NAME, DeploymentConfig
 from ..gpu_isolation import apply_gpu_isolation
 from ..loader import load_algorithm
@@ -139,12 +140,25 @@ def execute(args: argparse.Namespace) -> int:
         raise RuntimeError(
             "compute registration requires the generated release-manifest.json; run configure first"
         )
-    run_server(
-        manager,
-        host=args.host,
-        port=args.port,
-        webui=args.webui,
-        token=os.getenv("LDP_PLUGIN_TOKEN") or None,
-        lifecycle=registration,
-    )
+    cleanup = None
+    if config is not None and service is not None:
+        cleanup = CleanupProcess(
+            config.repository / "logs",
+            log_retention_days=int(service["logRetentionDays"]),
+            output_retention_days=int(service["outputRetentionDays"]),
+            scratch_retention_days=int(service["scratchRetentionDays"]),
+        )
+        cleanup.start()
+    try:
+        run_server(
+            manager,
+            host=args.host,
+            port=args.port,
+            webui=args.webui,
+            token=os.getenv("LDP_PLUGIN_TOKEN") or None,
+            lifecycle=registration,
+        )
+    finally:
+        if cleanup is not None:
+            cleanup.stop()
     return 0

{ls_algorithm_plugin_sdk-0.3.5 → ls_algorithm_plugin_sdk-0.3.7}/src/algorithm_plugin_sdk/deployment.py

@@ -11,6 +11,11 @@ from pathlib import Path
 from typing import Any
 from urllib.parse import urlparse
 
+from .cleanup import (
+    DEFAULT_LOG_RETENTION_DAYS,
+    DEFAULT_OUTPUT_RETENTION_DAYS,
+    DEFAULT_SCRATCH_RETENTION_DAYS,
+)
 from .loader import ALGORITHM_ENTRY_POINT_GROUP, load_algorithm
 from .release import ReleaseManifest
 
@@ -148,6 +153,9 @@ class DeploymentConfig:
         default_parameters: dict[str, Any] | None = None,
         local_scratch: bool = False,
         local_output: bool = False,
+        log_retention_days: int = DEFAULT_LOG_RETENTION_DAYS,
+        output_retention_days: int = DEFAULT_OUTPUT_RETENTION_DAYS,
+        scratch_retention_days: int = DEFAULT_SCRATCH_RETENTION_DAYS,
     ) -> "DeploymentConfig":
         repository = repository_root(root)
         _make_repository_importable(repository)
@@ -196,6 +204,9 @@ class DeploymentConfig:
                 "gpuIds": configured_gpu_ids,
                 "token": token or None,
                 "defaultParameters": dict(default_parameters or {}),
+                "logRetentionDays": log_retention_days,
+                "outputRetentionDays": output_retention_days,
+                "scratchRetentionDays": scratch_retention_days,
             },
             "registration": registration,
             "environment": dict(sorted((environment or {}).items())),
@@ -275,6 +286,15 @@ class DeploymentConfig:
         for name in ("localScratch", "localOutput"):
             if not isinstance(service.get(name, False), bool):
                 raise RuntimeError(f"service {name} must be a boolean")
+        retention_defaults = {
+            "logRetentionDays": DEFAULT_LOG_RETENTION_DAYS,
+            "outputRetentionDays": DEFAULT_OUTPUT_RETENTION_DAYS,
+            "scratchRetentionDays": DEFAULT_SCRATCH_RETENTION_DAYS,
+        }
+        for name, default in retention_defaults.items():
+            value = service.setdefault(name, default)
+            if isinstance(value, bool) or not isinstance(value, int) or value < 0:
+                raise RuntimeError(f"service {name} must be a non-negative integer")
         gpu_ids = service.get("gpuIds")
         if not isinstance(gpu_ids, list) or any(
             isinstance(gpu_id, bool) or not isinstance(gpu_id, int) or gpu_id < 0

{ls_algorithm_plugin_sdk-0.3.5 → ls_algorithm_plugin_sdk-0.3.7}/src/algorithm_plugin_sdk/service.py

@@ -348,6 +348,11 @@ class ExecutionManager:
             "acceptedAt": record.accepted_at,
         }
 
+    def _resources(self) -> dict[str, Any]:
+        if not self.gpu_ids:
+            return {}
+        return {"gpuIds": list(self.gpu_ids)}
+
     def manifest(self) -> dict[str, Any]:
         metadata = self.runner.algorithm.metadata()
         capabilities = {
@@ -361,6 +366,7 @@ class ExecutionManager:
             manifest = self.release_manifest.plugin_manifest(
                 max_concurrency=self.max_concurrent_executions,
                 capabilities=capabilities,
+                resources=self._resources(),
             )
             manifest["metadata"] = metadata.to_dict()
             return manifest
@@ -374,6 +380,7 @@ class ExecutionManager:
             "maxConcurrency": self.max_concurrent_executions,
             "capabilities": capabilities,
             "metadata": metadata.to_dict(),
+            "resources": self._resources(),
         }
 
     def heartbeat(self) -> dict[str, Any]:
@@ -391,6 +398,7 @@ class ExecutionManager:
             "activeExecutions": len(active),
             "maxConcurrency": self.max_concurrent_executions,
             "executions": active,
+            "resources": self._resources(),
         }
 
     def status(self, execution_id: str) -> dict[str, Any]:

{ls_algorithm_plugin_sdk-0.3.5 → ls_algorithm_plugin_sdk-0.3.7}/src/ls_algorithm_plugin_sdk.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ls-algorithm-plugin-sdk
-Version: 0.3.5
+Version: 0.3.7
 Summary: Protocol-independent runtime SDK for dataset algorithms
 Author: Ling Robotics
 License: Proprietary
@@ -71,11 +71,19 @@ sudo /srv/camera-space-mano/.venv/bin/algorithm-plugin configure \
   --api-key "$LDP_INTERNAL_API_KEY" \
   --port 9030 \
   --cluster production \
-  --gpu-ids 0,1
+  --gpu-ids 0,1 \
+  --log-retention-days 7 \
+  --output-retention-days 2 \
+  --scratch-retention-days 2
 ```
 
 重复执行 configure 需要显式提供 `--force`。
 
+配置部署的服务会启动独立清理进程，每小时扫描一次。仅删除创建超过日志保留期且
+末行状态为 `succeeded` 的任务日志；`outputRoot` 和 `scratchRoot` 下超过对应保留期
+未修改的数据也会被删除。清理记录按天写入 `<repository>/logs/cleanup-YYYYMMDD.log`，
+包含清理时间、路径和字节数；清理记录自身不会被自动删除。
+
 确认输出后执行：
 
 ```bash

{ls_algorithm_plugin_sdk-0.3.5 → ls_algorithm_plugin_sdk-0.3.7}/src/ls_algorithm_plugin_sdk.egg-info/SOURCES.txt

@@ -2,6 +2,7 @@ README.md
 pyproject.toml
 src/algorithm_plugin_sdk/__init__.py
 src/algorithm_plugin_sdk/algorithm.py
+src/algorithm_plugin_sdk/cleanup.py
 src/algorithm_plugin_sdk/cli.py
 src/algorithm_plugin_sdk/context.py
 src/algorithm_plugin_sdk/deployment.py
@@ -34,6 +35,7 @@ src/ls_algorithm_plugin_sdk.egg-info/dependency_links.txt
 src/ls_algorithm_plugin_sdk.egg-info/entry_points.txt
 src/ls_algorithm_plugin_sdk.egg-info/requires.txt
 src/ls_algorithm_plugin_sdk.egg-info/top_level.txt
+tests/test_cleanup.py
 tests/test_cli.py
 tests/test_configure.py
 tests/test_cut.py

ls_algorithm_plugin_sdk-0.3.7/tests/test_cleanup.py

@@ -0,0 +1,98 @@
+import json
+import os
+import tempfile
+import unittest
+from datetime import datetime, timezone
+from pathlib import Path
+
+from algorithm_plugin_sdk.cleanup import cleanup_once
+
+
+class CleanupTests(unittest.TestCase):
+    def test_removes_only_expired_success_logs_and_stale_data(self) -> None:
+        with tempfile.TemporaryDirectory() as directory:
+            root = Path(directory)
+            logs = root / "logs"
+            output = root / ".output"
+            scratch = root / ".scratch"
+            logs.mkdir()
+            output.mkdir()
+            scratch.mkdir()
+            now = datetime(2026, 9, 21, tzinfo=timezone.utc).timestamp()
+
+            success = logs / "20260901000000-success.log"
+            failed = logs / "20260901000000-failed.log"
+            recent = logs / "20260920000000-recent.log"
+            request = {
+                "event": "request",
+                "outputRoot": str(output),
+                "scratchRoot": str(scratch),
+            }
+            success.write_text(
+                json.dumps(request)
+                + "\n"
+                + json.dumps({**request, "outputRoot": "/"})
+                + "\n"
+                + json.dumps({"state": "succeeded"})
+                + "\n",
+                encoding="utf-8",
+            )
+            failed.write_text(
+                json.dumps(request) + "\n" + json.dumps({"state": "failed"}) + "\n",
+                encoding="utf-8",
+            )
+            recent.write_text(
+                json.dumps(request) + "\n" + json.dumps({"state": "succeeded"}) + "\n",
+                encoding="utf-8",
+            )
+
+            old_output = output / "old-job"
+            old_output.mkdir()
+            old_file = old_output / "result.bin"
+            old_file.write_bytes(b"result")
+            old_scratch = scratch / "old.tmp"
+            old_scratch.write_bytes(b"scratch")
+            recent_output = output / "recent-job"
+            recent_output.mkdir()
+            recent_file = recent_output / "result.bin"
+            recent_file.write_bytes(b"recent")
+            old_time = now - 3 * 86400
+            for path in (old_file, old_output, old_scratch):
+                os.utime(path, (old_time, old_time))
+
+            cleanup_once(logs, now=now)
+
+            self.assertFalse(success.exists())
+            self.assertTrue(failed.exists())
+            self.assertTrue(recent.exists())
+            self.assertFalse(old_output.exists())
+            self.assertFalse(old_scratch.exists())
+            self.assertTrue(recent_output.exists())
+
+            audit_logs = list(logs.glob("cleanup-*.log"))
+            self.assertEqual(len(audit_logs), 1)
+            entries = [
+                json.loads(line)
+                for line in audit_logs[0].read_text(encoding="utf-8").splitlines()
+            ]
+            deleted = [entry for entry in entries if entry["event"] == "deleted"]
+            self.assertEqual(len(deleted), 3)
+            self.assertTrue(all("timestamp" in entry for entry in deleted))
+            self.assertTrue(all(entry["sizeBytes"] > 0 for entry in deleted))
+            self.assertEqual(entries[-1]["event"], "scan_completed")
+            self.assertIn("startedAt", entries[-1])
+            self.assertIn("finishedAt", entries[-1])
+
+    def test_never_deletes_cleanup_audit_logs(self) -> None:
+        with tempfile.TemporaryDirectory() as directory:
+            logs = Path(directory)
+            audit = logs / "cleanup-20200101.log"
+            audit.write_text(json.dumps({"state": "succeeded"}) + "\n", encoding="utf-8")
+
+            cleanup_once(logs, log_retention_days=0)
+
+            self.assertTrue(audit.exists())
+
+
+if __name__ == "__main__":
+    unittest.main()

{ls_algorithm_plugin_sdk-0.3.5 → ls_algorithm_plugin_sdk-0.3.7}/tests/test_configure.py

@@ -142,6 +142,9 @@ class ConfigureTests(unittest.TestCase):
                 "--scratch-dir", "scratch",
                 "--local-scratch",
                 "--local-output",
+                "--log-retention-days", "8",
+                "--output-retention-days", "3",
+                "--scratch-retention-days", "4",
                 "--gpu-ids", "2,0",
                 "--service-token", "secret",
                 "--default-parameters", '{"batchSize": 8, "mode": "fast"}',
@@ -159,6 +162,9 @@ class ConfigureTests(unittest.TestCase):
         self.assertEqual(args.scratch_dir, "scratch")
         self.assertTrue(args.local_scratch)
         self.assertTrue(args.local_output)
+        self.assertEqual(args.log_retention_days, 8)
+        self.assertEqual(args.output_retention_days, 3)
+        self.assertEqual(args.scratch_retention_days, 4)
         self.assertEqual(args.gpu_ids, [2, 0])
         self.assertEqual(args.service_token, "secret")
         self.assertEqual(
@@ -220,6 +226,9 @@ class ConfigureTests(unittest.TestCase):
             gpu_ids=[3, 1],
             environment={"DEMO_MODE": "fast"},
             default_parameters={},
+            log_retention_days=7,
+            output_retention_days=2,
+            scratch_retention_days=2,
         )
         config.save.assert_called_once_with()
 

{ls_algorithm_plugin_sdk-0.3.5 → ls_algorithm_plugin_sdk-0.3.7}/tests/test_deployment.py

@@ -87,6 +87,9 @@ class DeploymentConfigTests(unittest.TestCase):
             self.assertEqual(loaded.payload["service"]["gpuIds"], [3, 1])
             self.assertTrue(loaded.payload["service"]["localScratch"])
             self.assertTrue(loaded.payload["service"]["localOutput"])
+            self.assertEqual(loaded.payload["service"]["logRetentionDays"], 7)
+            self.assertEqual(loaded.payload["service"]["outputRetentionDays"], 2)
+            self.assertEqual(loaded.payload["service"]["scratchRetentionDays"], 2)
             manifest_path = root / "release-manifest.json"
             manifest = json.loads(manifest_path.read_text(encoding="utf-8"))
             self.assertEqual(
@@ -142,6 +145,25 @@ class DeploymentConfigTests(unittest.TestCase):
             )
             self.assertEqual(registration["namespace"], "ignored")
 
+    def test_old_service_config_receives_retention_defaults(self) -> None:
+        config = DeploymentConfig(
+            Path("/tmp/algorithm-plugin.json"),
+            {
+                "service": {
+                    "port": 9000,
+                    "maxConcurrency": 1,
+                    "gpuIds": [],
+                    "defaultParameters": {},
+                }
+            },
+        )
+
+        config._validate_service()
+
+        self.assertEqual(config.payload["service"]["logRetentionDays"], 7)
+        self.assertEqual(config.payload["service"]["outputRetentionDays"], 2)
+        self.assertEqual(config.payload["service"]["scratchRetentionDays"], 2)
+
     def test_repository_is_importable_during_generate_and_load(self) -> None:
         with tempfile.TemporaryDirectory() as directory:
             root = Path(directory)

{ls_algorithm_plugin_sdk-0.3.5 → ls_algorithm_plugin_sdk-0.3.7}/tests/test_registration.py

@@ -43,7 +43,7 @@ class PluginRegistrationAgentTests(unittest.TestCase):
                 "status": "ready",
                 "activeExecutions": 0,
                 "maxConcurrency": 1,
-                "resources": {},
+                "resources": {"gpuIds": [0, 1]},
             }
             agent = PluginRegistrationAgent(
                 settings,
@@ -64,6 +64,10 @@ class PluginRegistrationAgentTests(unittest.TestCase):
         self.assertNotIn("implementationDigest", registration["manifest"])
         self.assertNotIn("metadata", registration["manifest"])
         self.assertTrue(client.calls[1][0].endswith("/instance-1/heartbeat"))
+        self.assertEqual(
+            client.calls[1][1]["resources"],
+            {"gpuIds": [0, 1]},
+        )
 
     def test_default_instance_key_is_stable_and_not_release_specific(self) -> None:
         first = stable_instance_key("camera_space_mano")

{ls_algorithm_plugin_sdk-0.3.5 → ls_algorithm_plugin_sdk-0.3.7}/tests/test_runner.py

@@ -318,7 +318,7 @@ class AlgorithmRunnerTests(unittest.TestCase):
                 "gpu_ids": None,
                 "parameters": None,
                 "scratch_dir": None,
-                "algorithm_log": None,
+                "log": None,
                 "algorithm": "test:CancelledAlgorithm",
             },
         )()

{ls_algorithm_plugin_sdk-0.3.5 → ls_algorithm_plugin_sdk-0.3.7}/tests/test_sdk_automation.py

@@ -24,12 +24,16 @@ class SdkAutomationTests(unittest.TestCase):
         manager = ExecutionManager(
             AlgorithmRunner(RecordingAlgorithm()),
             release_manifest=release,
+            gpu_ids=[0, 1, 2, 3, 4, 5, 6],
         )
         manifest = manager.manifest()
         self.assertEqual(manifest["implementationDigest"], f"sha256:{'2' * 64}")
         self.assertTrue(manifest["capabilities"]["cli"])
         self.assertTrue(manifest["capabilities"]["webui"])
         self.assertTrue(manifest["capabilities"]["httpService"])
+        resources = {"gpuIds": [0, 1, 2, 3, 4, 5, 6]}
+        self.assertEqual(manifest["resources"], resources)
+        self.assertEqual(manager.heartbeat()["resources"], resources)
         manager.close()
 
     def test_registration_is_inactive_when_no_deployment_is_configured(self) -> None:

{ls_algorithm_plugin_sdk-0.3.5 → ls_algorithm_plugin_sdk-0.3.7}/tests/test_serve.py

@@ -28,6 +28,9 @@ class ServeTests(unittest.TestCase):
                 "gpuIds": [0],
                 "webui": False,
                 "defaultParameters": {},
+                "logRetentionDays": 7,
+                "outputRetentionDays": 2,
+                "scratchRetentionDays": 2,
             }
         }
         config.process_environment.return_value = dict(os.environ)
@@ -59,6 +62,7 @@ class ServeTests(unittest.TestCase):
                 return_value=None,
             ),
             patch("algorithm_plugin_sdk.cli_impl.serve.run_server"),
+            patch("algorithm_plugin_sdk.cli_impl.serve.CleanupProcess") as cleanup_class,
             patch("algorithm_plugin_sdk.cli_impl.serve.os.chdir"),
         ):
             self.assertEqual(execute(args), 0)
@@ -67,6 +71,8 @@ class ServeTests(unittest.TestCase):
         self.assertTrue(manager_kwargs["local_scratch"])
         self.assertTrue(manager_kwargs["local_output"])
         self.assertEqual(manager_kwargs["repository"], config.repository)
+        cleanup_class.return_value.start.assert_called_once_with()
+        cleanup_class.return_value.stop.assert_called_once_with()
 
 
 if __name__ == "__main__":

{ls_algorithm_plugin_sdk-0.3.5 → ls_algorithm_plugin_sdk-0.3.7}/tests/test_service.py

@@ -40,6 +40,16 @@ class ExecutionManagerTests(unittest.TestCase):
         manager.close()
         self.assertEqual(algorithm.calls[0].gpu_ids, [3, 1])
 
+    def test_reports_configured_gpu_resources(self) -> None:
+        manager = ExecutionManager(
+            AlgorithmRunner(RecordingAlgorithm()),
+            gpu_ids=[0, 1, 2, 3, 4, 5, 6],
+        )
+        resources = {"gpuIds": [0, 1, 2, 3, 4, 5, 6]}
+        self.assertEqual(manager.manifest()["resources"], resources)
+        self.assertEqual(manager.heartbeat()["resources"], resources)
+        manager.close()
+
     def test_fills_missing_parameters_from_configured_defaults(self) -> None:
         algorithm = RecordingAlgorithm()
         manager = ExecutionManager(