ls-algorithm-plugin-sdk 0.3.1__tar.gz → 0.3.3__tar.gz

{ls_algorithm_plugin_sdk-0.3.1 → ls_algorithm_plugin_sdk-0.3.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ls-algorithm-plugin-sdk
-Version: 0.3.1
+Version: 0.3.3
 Summary: Protocol-independent runtime SDK for dataset algorithms
 Author: Ling Robotics
 License: Proprietary

{ls_algorithm_plugin_sdk-0.3.1 → ls_algorithm_plugin_sdk-0.3.3}/pyproject.toml

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

{ls_algorithm_plugin_sdk-0.3.1 → ls_algorithm_plugin_sdk-0.3.3}/src/algorithm_plugin_sdk/cli_impl/configure.py

@@ -16,7 +16,7 @@ from ..deployment import (
     repository_root,
     stable_instance_key,
 )
-from .parsing import environment, gpu_ids
+from .parsing import environment, gpu_ids, json_object
 
 
 SYSTEMD_UNIT_DIR = Path("/etc/systemd/system")
@@ -56,7 +56,11 @@ def configure_parser(parser: argparse.ArgumentParser) -> None:
         action=argparse.BooleanOptionalAction,
         default=True,
     )
-    parser.add_argument("--max-concurrency", type=int, default=1)
+    parser.add_argument(
+        "--max-concurrency",
+        type=int,
+        help="maximum concurrent executions (default: GPU count, or 1)",
+    )
     parser.add_argument("--scratch-dir")
     parser.add_argument(
         "--gpu-ids",
@@ -64,6 +68,12 @@ def configure_parser(parser: argparse.ArgumentParser) -> None:
         default=[],
         help="GPU IDs injected into every service execution",
     )
+    parser.add_argument(
+        "--default-parameters",
+        type=json_object,
+        default={},
+        help="JSON object used to fill missing request parameters",
+    )
     parser.add_argument("--service-token")
     parser.add_argument(
         "--compute-url",
@@ -139,10 +149,18 @@ def render_systemd_unit(
     repository: Path,
     config_path: Path,
     service_name: str,
+    gpu_ids: list[int] | None = None,
 ) -> str:
     root = repository.resolve()
+    working_directory = root / "jobs"
     launcher = root / ".venv" / "bin" / "algorithm-plugin"
     config = config_path.resolve()
+    environment = ["Environment=PYTHONUNBUFFERED=1"]
+    if gpu_ids:
+        environment.append(
+            "Environment=CUDA_VISIBLE_DEVICES="
+            + ",".join(str(gpu_id) for gpu_id in gpu_ids)
+        )
     return "\n".join(
         (
             "[Unit]",
@@ -153,12 +171,13 @@ def render_systemd_unit(
             "[Service]",
             "Type=simple",
             "User=root",
-            f"WorkingDirectory={_escape_systemd_path(root)}",
+            f"WorkingDirectory={_escape_systemd_path(working_directory)}",
             (
                 f"ExecStart={_quote_systemd_path(launcher)} "
                 f"serve --config {_quote_systemd_path(config)}"
             ),
-            "Environment=PYTHONUNBUFFERED=1",
+            *environment,
+            "LimitNOFILE=524288",
             "Restart=on-failure",
             "RestartSec=5s",
             "",
@@ -376,6 +395,11 @@ def generate_config(
     args: argparse.Namespace,
     repository: Path,
 ) -> DeploymentConfig:
+    max_concurrency = (
+        args.max_concurrency
+        if args.max_concurrency is not None
+        else max(len(args.gpu_ids), 1)
+    )
     config = DeploymentConfig.generate(
         output=args.config_output,
         root=repository,
@@ -383,12 +407,13 @@ def generate_config(
         host=args.host,
         port=args.port,
         webui=args.webui,
-        max_concurrency=args.max_concurrency,
+        max_concurrency=max_concurrency,
         scratch_dir=args.scratch_dir,
         token=args.service_token,
         registration=registration_from_args(args, repository),
         gpu_ids=args.gpu_ids,
         environment=dict(args.env),
+        default_parameters=args.default_parameters,
     )
     config.save()
     return config
@@ -407,6 +432,7 @@ def execute(args: argparse.Namespace) -> int:
         repository=repository,
         config_path=config_path,
         service_name=service_name,
+        gpu_ids=args.gpu_ids,
     )
 
     inspect_systemd_unit(
@@ -414,6 +440,7 @@ def execute(args: argparse.Namespace) -> int:
         content=unit,
         force=args.force,
     )
+    (repository / "jobs").mkdir(exist_ok=True)
     config = generate_config(args, repository)
     unit_path, changed = write_systemd_unit(
         service_name=service_name,

{ls_algorithm_plugin_sdk-0.3.1 → ls_algorithm_plugin_sdk-0.3.3}/src/algorithm_plugin_sdk/cli_impl/run.py

@@ -17,6 +17,7 @@ from typing import Any, Iterator
 
 from ..context import ExecutionContext, ProgressSnapshot
 from ..errors import ExecutionCancelled
+from ..gpu_isolation import apply_gpu_isolation
 from ..loader import load_algorithm
 from ..models import AlgorithmRequest
 from ..runner import AlgorithmRunner
@@ -125,6 +126,10 @@ def cancel_on_interrupt(
 
 def execute(args: argparse.Namespace) -> int:
     request = request_from_args(args)
+    request = replace(
+        request,
+        gpu_ids=apply_gpu_isolation(request.gpu_ids),
+    )
     progress = TerminalProgress()
     context = ExecutionContext(
         f"cli-{id(args)}",

{ls_algorithm_plugin_sdk-0.3.1 → ls_algorithm_plugin_sdk-0.3.3}/src/algorithm_plugin_sdk/cli_impl/serve.py

@@ -5,6 +5,7 @@ import os
 from pathlib import Path
 
 from ..deployment import DEFAULT_CONFIG_NAME, DeploymentConfig
+from ..gpu_isolation import apply_gpu_isolation
 from ..loader import load_algorithm
 from ..registration import PluginRegistrationAgent
 from ..release import ReleaseManifest
@@ -78,9 +79,12 @@ def configure_parser(parser: argparse.ArgumentParser) -> None:
 
 
 def execute(args: argparse.Namespace) -> int:
+    config: DeploymentConfig | None = None
+    service: dict[str, object] | None = None
     if args.config:
-        config = DeploymentConfig.load(args.config)
-        config.save()
+        # Apply the process mask before refreshing/loading the algorithm.  A
+        # repository module may import CUDA during module import.
+        config = DeploymentConfig.load(args.config, refresh=False)
         service = config.payload["service"]
         args.algorithm = config.algorithm_reference
         args.host = str(service["host"])
@@ -96,6 +100,11 @@ def execute(args: argparse.Namespace) -> int:
     elif not args.algorithm:
         raise ValueError("algorithm is required unless --config is provided")
 
+    args.gpu_ids = apply_gpu_isolation(args.gpu_ids)
+    if config is not None:
+        config.refresh()
+        config.save()
+
     algorithm_reference = str(args.algorithm)
     algorithm = load_algorithm(algorithm_reference)
 
@@ -105,6 +114,10 @@ def execute(args: argparse.Namespace) -> int:
     release = ReleaseManifest.discover(algorithm, start=Path.cwd(), required=False)
     manager = ExecutionManager(
         AlgorithmRunner(algorithm),
+        default_parameters=(
+            service.get("defaultParameters", {})
+            if service is not None else None
+        ),
         max_concurrent_executions=args.max_concurrent_executions,
         scratch_dir=args.scratch_dir,
         gpu_ids=args.gpu_ids,
@@ -113,6 +126,7 @@ def execute(args: argparse.Namespace) -> int:
         retry_seconds=args.retry_seconds,
         retry_jitter_ratio=args.retry_jitter_ratio,
         release_manifest=release,
+        repository=(config.repository if config is not None else Path.cwd()),
     )
     registration = PluginRegistrationAgent.from_env(manager.manifest, manager.heartbeat)
     if registration is not None and release is None:

{ls_algorithm_plugin_sdk-0.3.1 → ls_algorithm_plugin_sdk-0.3.3}/src/algorithm_plugin_sdk/deployment.py

@@ -145,6 +145,7 @@ class DeploymentConfig:
         registration: dict[str, str] | None,
         gpu_ids: list[int] | None = None,
         environment: dict[str, str] | None = None,
+        default_parameters: dict[str, Any] | None = None,
     ) -> "DeploymentConfig":
         repository = repository_root(root)
         _make_repository_importable(repository)
@@ -190,6 +191,7 @@ class DeploymentConfig:
                 "scratchDir": _absolute(scratch_dir, repository),
                 "gpuIds": configured_gpu_ids,
                 "token": token or None,
+                "defaultParameters": dict(default_parameters or {}),
             },
             "registration": registration,
             "environment": dict(sorted((environment or {}).items())),
@@ -273,6 +275,16 @@ class DeploymentConfig:
         ) or len(gpu_ids) != len(set(gpu_ids)):
             raise RuntimeError("service gpuIds must be unique non-negative integers")
 
+        default_parameters = service.get("defaultParameters", {})
+        if not isinstance(default_parameters, dict):
+            raise RuntimeError("defaultParameters must be an object")
+        if any(not isinstance(key, str) for key in default_parameters):
+            raise RuntimeError("defaultParameters keys must be strings")
+        try:
+            json.dumps(default_parameters)
+        except (TypeError, ValueError) as exc:
+            raise RuntimeError("defaultParameters must be JSON serializable") from exc
+
     def _validate_registration(self) -> None:
         registration = self.payload.get("registration")
         if registration is None:

ls_algorithm_plugin_sdk-0.3.3/src/algorithm_plugin_sdk/gpu_isolation.py

@@ -0,0 +1,27 @@
+from __future__ import annotations
+
+import os
+from collections.abc import Sequence
+
+
+def apply_gpu_isolation(gpu_ids: Sequence[int] | None) -> list[int]:
+    """Mask physical GPUs for this process and return local GPU ordinals."""
+    if gpu_ids is None:
+        return []
+
+    physical_gpu_ids = list(gpu_ids)
+    if any(
+        isinstance(gpu_id, bool)
+        or not isinstance(gpu_id, int)
+        or gpu_id < 0
+        for gpu_id in physical_gpu_ids
+    ) or len(physical_gpu_ids) != len(set(physical_gpu_ids)):
+        raise ValueError("gpu_ids must be unique non-negative integers")
+
+    if not physical_gpu_ids:
+        return []
+
+    os.environ["CUDA_VISIBLE_DEVICES"] = ",".join(
+        str(gpu_id) for gpu_id in physical_gpu_ids
+    )
+    return list(range(len(physical_gpu_ids)))

ls_algorithm_plugin_sdk-0.3.3/src/algorithm_plugin_sdk/log_manager.py

@@ -0,0 +1,76 @@
+from __future__ import annotations
+
+import json
+import logging
+import re
+import threading
+from pathlib import Path
+from typing import Any
+
+from .context import utc_now
+
+_SAFE_NAME = re.compile(r"[^A-Za-z0-9._-]+")
+
+
+def _safe_name(value: str) -> str:
+    cleaned = _SAFE_NAME.sub("_", str(value).strip()).strip("._")
+    return cleaned or "job"
+
+
+class ExecutionLog:
+    """Per-execution, line-buffered log sink attached to context.logger."""
+
+    def __init__(self, *, log_dir: str | Path, job_id: str, execution_id: str, logger: logging.Logger) -> None:
+        directory = Path(log_dir).expanduser()
+        directory.mkdir(parents=True, exist_ok=True)
+        path = directory / f"{_safe_name(job_id)}.log"
+        if path.exists():
+            path = directory / f"{_safe_name(job_id)}-{_safe_name(execution_id)}.log"
+        self.path = path
+        self._stream = path.open("a", encoding="utf-8", buffering=1)
+        self._lock = threading.RLock()
+        self._handler = _FlushFileHandler(self._stream)
+        self._handler.setFormatter(logging.Formatter("%(asctime)s %(levelname)s %(message)s"))
+        self._handler.setLevel(logging.DEBUG)
+        self.logger = logger
+        self.logger.setLevel(logging.DEBUG)
+        self.logger.addHandler(self._handler)
+        self._closed = False
+
+    def write_event(self, event: str, **values: Any) -> None:
+        payload = {"event": event, "timestamp": utc_now(), **values}
+        with self._lock:
+            if self._closed:
+                return
+            self._stream.write(json.dumps(payload, ensure_ascii=False, default=str) + "\n")
+            self._stream.flush()
+
+    def close(self) -> None:
+        with self._lock:
+            if self._closed:
+                return
+            self._closed = True
+            self.logger.removeHandler(self._handler)
+            self._handler.close()
+            self._stream.close()
+
+
+class _FlushFileHandler(logging.Handler):
+    def __init__(self, stream: Any) -> None:
+        super().__init__()
+        self.stream = stream
+        self._lock = threading.RLock()
+
+    def emit(self, record: logging.LogRecord) -> None:
+        try:
+            with self._lock:
+                self.stream.write(self.format(record) + "\n")
+                self.stream.flush()
+        except Exception:
+            self.handleError(record)
+
+    def close(self) -> None:
+        try:
+            self.stream.flush()
+        finally:
+            super().close()

{ls_algorithm_plugin_sdk-0.3.1 → ls_algorithm_plugin_sdk-0.3.3}/src/algorithm_plugin_sdk/service.py

@@ -10,12 +10,14 @@ import uuid
 from concurrent.futures import Future, ThreadPoolExecutor
 from contextlib import asynccontextmanager
 from dataclasses import dataclass, field, replace
+from pathlib import Path
 from typing import Any, Callable
 
 from .context import ExecutionContext, ProgressSnapshot, utc_now
 from .errors import (ExecutionCancelled, ExecutionNotFinished,
                      ExecutionNotFound, IdempotencyConflict)
 from .models import AlgorithmRequest, AlgorithmResult
+from .log_manager import ExecutionLog
 from .release import ReleaseManifest
 from .runner import AlgorithmRunner
 from .webui_app import announce_webui, mount_webui
@@ -34,6 +36,8 @@ logger = logging.getLogger(__name__)
 class ExecutionRecord:
     execution_id: str
     request: AlgorithmRequest
+    job_id: str
+    task_id: str
     accepted_at: str
     state: str = "accepted"
     started_at: str | None = None
@@ -41,6 +45,7 @@ class ExecutionRecord:
     result: AlgorithmResult | None = None
     error: str | None = None
     context: ExecutionContext | None = None
+    log: ExecutionLog | None = None
     future: Future[None] | None = None
     attempt: int = 0
     max_attempts: int = 1
@@ -113,8 +118,11 @@ class ExecutionManager:
         self,
         runner: AlgorithmRunner,
         *,
+        default_parameters: dict[str, Any] | None = None,
         max_concurrent_executions: int = 1,
         scratch_dir: str | None = None,
+        repository: str | Path | None = None,
+        log_dir: str | Path | None = None,
         gpu_ids: list[int] | None = None,
         runner_factory: RunnerFactory | None = None,
         max_attempts: int = MAX_ATTEMPTS,
@@ -144,7 +152,15 @@ class ExecutionManager:
         self._runner_factory = runner_factory or (
             lambda: AlgorithmRunner(algorithm_class())
         )
+        if default_parameters is not None and not isinstance(default_parameters, dict):
+            raise ValueError("default_parameters must be a JSON object")
+        self.default_parameters = dict(default_parameters or {})
         self.scratch_dir = scratch_dir
+        self.log_dir = (
+            Path(log_dir).expanduser()
+            if log_dir is not None
+            else (Path(repository).expanduser() / "logs" if repository is not None else None)
+        )
         self.gpu_ids = configured_gpu_ids
         self.max_concurrent_executions = max_concurrent_executions
         self.max_attempts = max_attempts
@@ -180,9 +196,16 @@ class ExecutionManager:
         request: AlgorithmRequest,
         *,
         idempotency_key: str | None = None,
+        job_id: str | None = None,
+        task_id: str | None = None,
     ) -> dict[str, Any]:
         if self.gpu_ids is not None:
             request = replace(request, gpu_ids=self.gpu_ids)
+        if self.default_parameters:
+            request = replace(
+                request,
+                parameters={**self.default_parameters, **request.parameters},
+            )
         self.start()
         canonical_request = json.dumps(
             request.to_dict(), ensure_ascii=False, sort_keys=True, separators=(",", ":")
@@ -201,9 +224,13 @@ class ExecutionManager:
                         "acceptedAt": record.accepted_at,
                     }
         execution_id = f"exec-{uuid.uuid4().hex}"
+        resolved_job_id = str(job_id or execution_id)
+        resolved_task_id = str(task_id or execution_id)
         record = ExecutionRecord(
             execution_id=execution_id,
             request=request,
+            job_id=resolved_job_id,
+            task_id=resolved_task_id,
             accepted_at=utc_now(),
             max_attempts=self.max_attempts,
         )
@@ -217,6 +244,30 @@ class ExecutionManager:
             ),
             progress_callback=record.add_progress,
         )
+        if self.log_dir is not None:
+            record.log = ExecutionLog(
+                log_dir=self.log_dir,
+                job_id=record.job_id,
+                execution_id=record.execution_id,
+                logger=record.context.logger,
+            )
+            workspace = record.request.workspace or {}
+            record.log.write_event(
+                "request",
+                jobId=record.job_id,
+                taskId=record.task_id,
+                job_id=record.job_id,
+                task_id=record.task_id,
+                executionId=record.execution_id,
+                execution_id=record.execution_id,
+                inputs=[item.to_dict() for item in record.request.inputs],
+                inputRoot=workspace.get("inputRoot"),
+                outputRoot=workspace.get("outputRoot"),
+                scratchRoot=workspace.get("scratchRoot") or self.scratch_dir,
+                merge=record.request.merge,
+                parameters=record.request.parameters,
+                gpuIds=record.request.gpu_ids,
+            )
         with self._lock:
             if self._closed:
                 raise RuntimeError("execution manager is closed")
@@ -328,6 +379,9 @@ class ExecutionManager:
             cancelled_before_start = bool(record.future and record.future.cancel())
             if cancelled_before_start:
                 record.set_state("cancelled", error=reason)
+                if record.log is not None:
+                    record.log.write_event("result", state="cancelled", error=reason)
+                    record.log.close()
             return {
                 "executionId": execution_id,
                 "state": record.state,
@@ -349,6 +403,9 @@ class ExecutionManager:
             record.context.cancel("service shutdown")
             if record.future and record.future.cancel():
                 record.set_state("cancelled", error="service shutdown")
+                if record.log is not None:
+                    record.log.write_event("result", state="cancelled", error="service shutdown")
+                    record.log.close()
         self._executor.shutdown(wait=True, cancel_futures=True)
         self.runner.close()
 
@@ -362,17 +419,28 @@ class ExecutionManager:
     def _run(self, record: ExecutionRecord) -> None:
         record.set_state("running")
         assert record.context is not None
+        if record.log is not None:
+            record.log.write_event("started", jobId=record.job_id, taskId=record.task_id)
         try:
             result = self._run_with_restarts(record)
         except ExecutionCancelled as exc:
             record.context.mark_unfinished("cancelled", str(exc))
             record.set_state("cancelled", error=str(exc))
+            if record.log is not None:
+                record.log.write_event("result", state="cancelled", error=str(exc))
         except Exception as exc:
             error = f"{type(exc).__name__}: {exc}"
             record.context.mark_unfinished("failed", error)
             record.set_state("failed", error=error)
+            if record.log is not None:
+                record.log.write_event("result", state="failed", error=error)
         else:
             record.set_state(result.status, result=result)
+            if record.log is not None:
+                record.log.write_event("result", state=record.state, result=result.to_dict())
+        finally:
+            if record.log is not None:
+                record.log.close()
 
     def _run_with_restarts(self, record: ExecutionRecord) -> AlgorithmResult:
         assert record.context is not None
@@ -585,7 +653,12 @@ def create_app(
     async def create_execution(request: Request) -> Any:
         try:
             body = await request.json()
-            execution_request = AlgorithmRequest.from_dict(body)
+            if not isinstance(body, dict):
+                raise ValueError("request body must be a mapping")
+            job_id = next((body.get(name) for name in ("jobId", "job_id") if body.get(name)), None)
+            task_id = next((body.get(name) for name in ("taskId", "task_id") if body.get(name)), None)
+            request_body = {key: value for key, value in body.items() if key not in {"jobId", "job_id", "taskId", "task_id"}}
+            execution_request = AlgorithmRequest.from_dict(request_body)
             if execution_request.workspace is None:
                 raise ValueError("workspace is required")
         except Exception as exc:
@@ -593,9 +666,14 @@ def create_app(
                 status_code=422,
                 content={"error": f"{type(exc).__name__}: {exc}"},
             )
+        idempotency_key = request.headers.get("Idempotency-Key")
+        job_id = job_id or next((request.headers.get(name) for name in ("X-LDP-Job-ID", "X-Job-ID", "Job-ID") if request.headers.get(name)), None)
+        task_id = task_id or next((request.headers.get(name) for name in ("X-LDP-Task-ID", "X-Task-ID", "Task-ID") if request.headers.get(name)), None)
         return manager.submit(
             execution_request,
-            idempotency_key=request.headers.get("Idempotency-Key"),
+            idempotency_key=idempotency_key,
+            job_id=job_id or idempotency_key,
+            task_id=task_id,
         )
 
     @application.get("/v1/executions/{execution_id}")

{ls_algorithm_plugin_sdk-0.3.1 → ls_algorithm_plugin_sdk-0.3.3}/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.1
+Version: 0.3.3
 Summary: Protocol-independent runtime SDK for dataset algorithms
 Author: Ling Robotics
 License: Proprietary

{ls_algorithm_plugin_sdk-0.3.1 → ls_algorithm_plugin_sdk-0.3.3}/src/ls_algorithm_plugin_sdk.egg-info/SOURCES.txt

@@ -6,7 +6,9 @@ src/algorithm_plugin_sdk/cli.py
 src/algorithm_plugin_sdk/context.py
 src/algorithm_plugin_sdk/deployment.py
 src/algorithm_plugin_sdk/errors.py
+src/algorithm_plugin_sdk/gpu_isolation.py
 src/algorithm_plugin_sdk/loader.py
+src/algorithm_plugin_sdk/log_manager.py
 src/algorithm_plugin_sdk/models.py
 src/algorithm_plugin_sdk/registration.py
 src/algorithm_plugin_sdk/release.py
@@ -34,6 +36,7 @@ src/ls_algorithm_plugin_sdk.egg-info/top_level.txt
 tests/test_cli.py
 tests/test_configure.py
 tests/test_deployment.py
+tests/test_gpu_isolation.py
 tests/test_models.py
 tests/test_registration.py
 tests/test_release.py

{ls_algorithm_plugin_sdk-0.3.1 → ls_algorithm_plugin_sdk-0.3.3}/tests/test_configure.py

@@ -142,6 +142,7 @@ class ConfigureTests(unittest.TestCase):
                 "--scratch-dir", "scratch",
                 "--gpu-ids", "2,0",
                 "--service-token", "secret",
+                "--default-parameters", '{"batchSize": 8, "mode": "fast"}',
                 "--env", "DEMO_MODE=fast",
                 "--force",
             ]
@@ -156,6 +157,10 @@ class ConfigureTests(unittest.TestCase):
         self.assertEqual(args.scratch_dir, "scratch")
         self.assertEqual(args.gpu_ids, [2, 0])
         self.assertEqual(args.service_token, "secret")
+        self.assertEqual(
+            args.default_parameters,
+            {"batchSize": 8, "mode": "fast"},
+        )
         self.assertEqual(args.env, [("DEMO_MODE", "fast")])
         self.assertTrue(args.force)
 
@@ -200,15 +205,29 @@ class ConfigureTests(unittest.TestCase):
             host="0.0.0.0",
             port=9000,
             webui=True,
-            max_concurrency=1,
+            max_concurrency=2,
             scratch_dir=None,
             token=None,
             registration=None,
             gpu_ids=[3, 1],
             environment={"DEMO_MODE": "fast"},
+            default_parameters={},
         )
         config.save.assert_called_once_with()
 
+    def test_defaults_max_concurrency_to_one_without_gpus(self) -> None:
+        repository = Path("/srv/demo").resolve()
+        args = build_parser().parse_args(["configure", "--local"])
+        config = Mock()
+
+        with patch(
+            "algorithm_plugin_sdk.cli_impl.configure.DeploymentConfig.generate",
+            return_value=config,
+        ) as generate:
+            generate_config(args, repository)
+
+        self.assertEqual(generate.call_args.kwargs["max_concurrency"], 1)
+
     def test_requires_complete_registration_unless_local(self) -> None:
         with patch.dict(os.environ, {}, clear=True):
             args = build_parser().parse_args(["configure"])
@@ -323,10 +342,11 @@ class ConfigureTests(unittest.TestCase):
             "[Service]\n"
             "Type=simple\n"
             "User=root\n"
-            "WorkingDirectory=/srv/demo algorithm\n"
+            "WorkingDirectory=/srv/demo algorithm/jobs\n"
             'ExecStart="/srv/demo algorithm/.venv/bin/algorithm-plugin" '
             'serve --config "/srv/demo algorithm/algorithm-plugin.json"\n'
             "Environment=PYTHONUNBUFFERED=1\n"
+            "LimitNOFILE=524288\n"
             "Restart=on-failure\n"
             "RestartSec=5s\n"
             "\n"
@@ -490,6 +510,9 @@ class ConfigureTests(unittest.TestCase):
                 "algorithm_plugin_sdk.cli_impl.configure.inspect_systemd_unit",
                 return_value=(unit_path, True),
             ) as inspect_unit,
+            patch(
+                "algorithm_plugin_sdk.cli_impl.configure.Path.mkdir",
+            ) as mkdir,
             patch(
                 "algorithm_plugin_sdk.cli_impl.configure.generate_config",
                 return_value=config,
@@ -505,10 +528,19 @@ class ConfigureTests(unittest.TestCase):
         self.assertEqual(result, 0)
         require_root.assert_called_once_with()
         validate_runtime.assert_called_once_with(repository)
+        mkdir.assert_called_once_with(exist_ok=True)
         generate.assert_called_once_with(args, repository)
         inspect_unit.assert_called_once()
         write_unit.assert_called_once()
         self.assertIn("User=root", inspect_unit.call_args.kwargs["content"])
+        self.assertIn(
+            "LimitNOFILE=524288",
+            inspect_unit.call_args.kwargs["content"],
+        )
+        self.assertIn(
+            "WorkingDirectory=/srv/demo/jobs",
+            inspect_unit.call_args.kwargs["content"],
+        )
         self.assertEqual(
             output.getvalue(),
             "Configured repository: /srv/demo\n"

{ls_algorithm_plugin_sdk-0.3.1 → ls_algorithm_plugin_sdk-0.3.3}/tests/test_deployment.py

@@ -70,6 +70,7 @@ class DeploymentConfigTests(unittest.TestCase):
                     registration=None,
                     gpu_ids=[3, 1],
                     environment={"DEMO_SETTING": "yes"},
+                    default_parameters={"batchSize": 8, "mode": "fast"},
                 )
                 config.save()
                 loaded = DeploymentConfig.load(config.path)
@@ -77,6 +78,10 @@ class DeploymentConfigTests(unittest.TestCase):
             self.assertEqual(loaded.payload["schemaVersion"], CONFIG_SCHEMA)
             self.assertEqual(loaded.payload["algorithm"]["type"], "demo_algorithm")
             self.assertEqual(loaded.payload["algorithm"]["version"], "1.2.3")
+            self.assertEqual(
+                loaded.payload["service"]["defaultParameters"],
+                {"batchSize": 8, "mode": "fast"},
+            )
             self.assertEqual(loaded.payload["service"]["gpuIds"], [3, 1])
             manifest_path = root / "release-manifest.json"
             manifest = json.loads(manifest_path.read_text(encoding="utf-8"))

ls_algorithm_plugin_sdk-0.3.3/tests/test_gpu_isolation.py

@@ -0,0 +1,38 @@
+import os
+import unittest
+from pathlib import Path
+from unittest.mock import patch
+
+from algorithm_plugin_sdk.cli_impl.configure import render_systemd_unit
+from algorithm_plugin_sdk.gpu_isolation import apply_gpu_isolation
+
+
+class GpuIsolationTests(unittest.TestCase):
+    @patch.dict(os.environ, {}, clear=True)
+    def test_masks_physical_ids_and_returns_local_ordinals(self) -> None:
+        self.assertEqual(apply_gpu_isolation([3, 1]), [0, 1])
+        self.assertEqual(os.environ["CUDA_VISIBLE_DEVICES"], "3,1")
+
+    @patch.dict(os.environ, {"CUDA_VISIBLE_DEVICES": "7"}, clear=True)
+    def test_empty_gpu_ids_preserve_existing_mask(self) -> None:
+        self.assertEqual(apply_gpu_isolation(None), [])
+        self.assertEqual(apply_gpu_isolation([]), [])
+        self.assertEqual(os.environ["CUDA_VISIBLE_DEVICES"], "7")
+
+    def test_rejects_invalid_gpu_ids(self) -> None:
+        for gpu_ids in ([1, 1], [-1], [True]):
+            with self.subTest(gpu_ids=gpu_ids), self.assertRaises(ValueError):
+                apply_gpu_isolation(gpu_ids)
+
+    def test_systemd_unit_sets_physical_gpu_mask(self) -> None:
+        unit = render_systemd_unit(
+            repository=Path("/srv/demo"),
+            config_path=Path("/srv/demo/algorithm-plugin.json"),
+            service_name="demo",
+            gpu_ids=[3, 1],
+        )
+        self.assertIn("Environment=CUDA_VISIBLE_DEVICES=3,1", unit)
+
+
+if __name__ == "__main__":
+    unittest.main()

{ls_algorithm_plugin_sdk-0.3.1 → ls_algorithm_plugin_sdk-0.3.3}/tests/test_runner.py

@@ -1,3 +1,4 @@
+import os
 import unittest
 from io import StringIO
 from unittest.mock import Mock, patch
@@ -115,6 +116,31 @@ class AlgorithmRunnerTests(unittest.TestCase):
 
         self.assertEqual(request.gpu_ids, [3, 1])
         self.assertEqual(request.inputs[0].input_dataset, "/data/input")
+    def test_execute_isolates_and_maps_cli_gpu_ids(self) -> None:
+        args = build_parser().parse_args(
+            [
+                "run",
+                "test:Algorithm",
+                "--input",
+                '{"input_dataset":"/data/input","output":"/data/output"}',
+                "--gpu-ids",
+                "3,1",
+            ]
+        )
+        algorithm = RecordingAlgorithm()
+
+        with (
+            patch.dict(os.environ, {}, clear=True),
+            patch(
+                "algorithm_plugin_sdk.cli_impl.run.load_algorithm",
+                return_value=algorithm,
+            ),
+        ):
+            self.assertEqual(execute_run(args), 0)
+            self.assertEqual(os.environ["CUDA_VISIBLE_DEVICES"], "3,1")
+
+        self.assertEqual(algorithm.calls[0].gpu_ids, [0, 1])
+
 
     def test_serve_uses_service_restart_defaults(self) -> None:
         args = build_parser().parse_args(["serve", "test:Algorithm"])

{ls_algorithm_plugin_sdk-0.3.1 → ls_algorithm_plugin_sdk-0.3.3}/tests/test_service.py

@@ -37,6 +37,26 @@ class ExecutionManagerTests(unittest.TestCase):
         manager.close()
         self.assertEqual(algorithm.calls[0].gpu_ids, [3, 1])
 
+    def test_fills_missing_parameters_from_configured_defaults(self) -> None:
+        algorithm = RecordingAlgorithm()
+        manager = ExecutionManager(
+            AlgorithmRunner(algorithm),
+            default_parameters={"batchSize": 8, "mode": "accurate"},
+        )
+        request = AlgorithmRequest(
+            inputs=self._request().inputs,
+            parameters={"batchSize": 16},
+        )
+
+        accepted = manager.submit(request)
+        manager._record(accepted["executionId"]).future.result(timeout=2)
+        manager.close()
+
+        self.assertEqual(
+            algorithm.calls[0].parameters,
+            {"batchSize": 16, "mode": "accurate"},
+        )
+
     def test_runs_the_same_algorithm_contract(self) -> None:
         manager = ExecutionManager(AlgorithmRunner(RecordingAlgorithm()))
         accepted = manager.submit(