ls-algorithm-plugin-sdk 0.3.6__py3-none-any.whl → 0.3.7__py3-none-any.whl

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)

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

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

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

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.6.dist-info → ls_algorithm_plugin_sdk-0.3.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ls-algorithm-plugin-sdk
-Version: 0.3.6
+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.6.dist-info → ls_algorithm_plugin_sdk-0.3.7.dist-info}/RECORD

@@ -1,8 +1,9 @@
 algorithm_plugin_sdk/__init__.py,sha256=OKj2VcNXTwZmRgPlECI6QUBlxW1YLtflr4RAgs6w064,1223
 algorithm_plugin_sdk/algorithm.py,sha256=INjX-ygMQfHk8D1AZbEEdCw1P4VNQLGF989lP1J1H1k,1025
+algorithm_plugin_sdk/cleanup.py,sha256=B8SiIoTj6oxOFkCQO4Cufl2JamsGQoFCoi2FdOCG4u0,10945
 algorithm_plugin_sdk/cli.py,sha256=20cjY2JXNQOFS-7ys5sNi-y9-1CObf-GYOTkjJ0Q6WI,1419
 algorithm_plugin_sdk/context.py,sha256=Kj-eDZg7PgX6xNzrWrQs37UfepTP8fXv4_8hCgsAIDA,11016
-algorithm_plugin_sdk/deployment.py,sha256=5WlZfML9ymWrAFsmdX-bBHTP2kuVY4WO5wKHs35Dkd4,14936
+algorithm_plugin_sdk/deployment.py,sha256=D4OlpIjPsd1UcfTa1RoGOc4ehAo2ZPOQcoQOB98vaz4,15960
 algorithm_plugin_sdk/errors.py,sha256=DNmI2c36Pd7K6tTaonqfEgpBzwX0o6pXzYrc8r2Z--k,730
 algorithm_plugin_sdk/gpu_isolation.py,sha256=toXUQ1vfzfLPiideJ8dWkfa9NW2Lc8V0sbNx-75YTjg,794
 algorithm_plugin_sdk/loader.py,sha256=XKmyqbJMoUMdKoo2eRQFGdbsmlz6NBgtUeIdqzumJFs,2561
@@ -11,14 +12,14 @@ algorithm_plugin_sdk/models.py,sha256=FIwUm8QDK8L37pV7AcCMnmYlDP-2l93zp8yc0KSu4y
 algorithm_plugin_sdk/registration.py,sha256=s5oQkf12_uRjdA4CYMYM8SDQjhsk1rzDDF-3w36U_lA,10474
 algorithm_plugin_sdk/release.py,sha256=KM-kRM1oFYMgjDFnXdu6BLR1b4dsvWWDCEgTNq8cb3w,9439
 algorithm_plugin_sdk/runner.py,sha256=583Y9_7efvW5rrmM2nt316NEpCRO6kd8dKYjFRjgtCk,3183
-algorithm_plugin_sdk/service.py,sha256=HQLDW5nlGGXJNZ0KMFU4I1rPzWHMf_LlE-tsY42PHnc,31045
+algorithm_plugin_sdk/service.py,sha256=zCEhUMjboVTNqnQSKc1czzjdQOlXVa94y38P8McfWyE,31320
 algorithm_plugin_sdk/webui_app.py,sha256=Gvt2FPt0xZBjYi39sqTQqcosllifYeJam49_mGfkEVw,1530
 algorithm_plugin_sdk/cli_impl/__init__.py,sha256=uLknQVGipNd7eSJegDHZS0NVowMa0qAaOf63wFI3zHM,78
-algorithm_plugin_sdk/cli_impl/configure.py,sha256=hO9vwFfZ4yqeQUyYc3heE1MDLK1lppN69OoF2zeVVaM,13761
+algorithm_plugin_sdk/cli_impl/configure.py,sha256=270-0DVxciyxsdipoi16DKL38n1vQft_REx_scJu1SU,14924
 algorithm_plugin_sdk/cli_impl/cut.py,sha256=R3ecRzDHffJZNqbJaKeX4S4hUFdQl2afXAfklkX1Ah0,19764
 algorithm_plugin_sdk/cli_impl/parsing.py,sha256=TDX45Spu4WMrczuzTMN9ZC2SYyHE11OPBCvN45yPsxs,1399
 algorithm_plugin_sdk/cli_impl/run.py,sha256=1FuOpYYOAp-iyc8-KRSVch33v3D3Zd6j2oGUkgYi9PI,6001
-algorithm_plugin_sdk/cli_impl/serve.py,sha256=1Ma08MHMjKk9wKO8tGdymVvedcGC-jaKdaUCVBTPMro,5187
+algorithm_plugin_sdk/cli_impl/serve.py,sha256=spsGFb3ay__YWnOkvo-FWisDJzCZRaHuAxJCG4hkvQY,5724
 algorithm_plugin_sdk/examples/__init__.py,sha256=WxZZzUzxKhqZg3KibVY-7CB960DNjt6IfjciZ8JXbq0,57
 algorithm_plugin_sdk/examples/example_algorithm.py,sha256=j2RsVaRPxpJn3kK6_H_JqAceKTpJE8txNm-oTrH2v6E,3787
 algorithm_plugin_sdk/examples/simulated_algorithm.py,sha256=bIaneSMM09CJfV5-oGuZ5QwBDWV1u-7Fn0WDN1TuwGw,2944
@@ -26,8 +27,8 @@ algorithm_plugin_sdk/webui/__init__.py,sha256=cvtaktJXz_DYG4QbV5ppoqY2bFaMLuiUcT
 algorithm_plugin_sdk/webui/app.css,sha256=5HGDKlbUFLZMgCknlRuwCjiNcCr8poIF5YGHchyaamE,2965
 algorithm_plugin_sdk/webui/app.js,sha256=0YsXsocEY3yDseG3jh0RhzI8xo_bYmsbSxdN3FdCswQ,7657
 algorithm_plugin_sdk/webui/index.html,sha256=Z222OuaacWdbr0s-sjJq6wmg45u96tIneM5-LP55Z8I,2261
-ls_algorithm_plugin_sdk-0.3.6.dist-info/METADATA,sha256=2Hq86ZVOEuL6xLDMbPvJBgC_w67uF1JXIiAguEh7mNA,2709
-ls_algorithm_plugin_sdk-0.3.6.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
-ls_algorithm_plugin_sdk-0.3.6.dist-info/entry_points.txt,sha256=TU0R_TxuB5OuOiZ5BHOEmUPtHvN3v8ARUW8d3PztHcE,67
-ls_algorithm_plugin_sdk-0.3.6.dist-info/top_level.txt,sha256=8lsgxZ8HJGLlzJ5Rt8CiVzw9Ccme286i3akbmeMjBos,21
-ls_algorithm_plugin_sdk-0.3.6.dist-info/RECORD,,
+ls_algorithm_plugin_sdk-0.3.7.dist-info/METADATA,sha256=Czb68efzbr0tPKqCkD5uc45Rn92P1Auha-rCNC-ovqQ,3205
+ls_algorithm_plugin_sdk-0.3.7.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+ls_algorithm_plugin_sdk-0.3.7.dist-info/entry_points.txt,sha256=TU0R_TxuB5OuOiZ5BHOEmUPtHvN3v8ARUW8d3PztHcE,67
+ls_algorithm_plugin_sdk-0.3.7.dist-info/top_level.txt,sha256=8lsgxZ8HJGLlzJ5Rt8CiVzw9Ccme286i3akbmeMjBos,21
+ls_algorithm_plugin_sdk-0.3.7.dist-info/RECORD,,