ls-algorithm-plugin-sdk 0.3.3__py3-none-any.whl → 0.3.5__py3-none-any.whl

algorithm_plugin_sdk/cli.py

@@ -5,6 +5,7 @@ import logging
 import sys
 
 from .cli_impl import configure as configure_command
+from .cli_impl import cut as cut_command
 from .cli_impl import run as run_command
 from .cli_impl import serve as serve_command
 
@@ -22,6 +23,9 @@ def build_parser() -> argparse.ArgumentParser:
     configure_command.configure_parser(
         subs.add_parser("configure", help="configure an existing Algorithm repository for systemd")
     )
+    cut_command.configure_parser(
+        subs.add_parser("cut", help="cut each dataset episode to a maximum duration")
+    )
     return parser
 
 

algorithm_plugin_sdk/cli_impl/configure.py

@@ -62,6 +62,16 @@ def configure_parser(parser: argparse.ArgumentParser) -> None:
         help="maximum concurrent executions (default: GPU count, or 1)",
     )
     parser.add_argument("--scratch-dir")
+    parser.add_argument(
+        "--local-scratch",
+        action="store_true",
+        help="override request scratchRoot with <repository>/.scratch",
+    )
+    parser.add_argument(
+        "--local-output",
+        action="store_true",
+        help="override request output paths with <repository>/.output/<job-id>",
+    )
     parser.add_argument(
         "--gpu-ids",
         type=gpu_ids,
@@ -409,6 +419,8 @@ def generate_config(
         webui=args.webui,
         max_concurrency=max_concurrency,
         scratch_dir=args.scratch_dir,
+        local_scratch=args.local_scratch,
+        local_output=args.local_output,
         token=args.service_token,
         registration=registration_from_args(args, repository),
         gpu_ids=args.gpu_ids,

algorithm_plugin_sdk/cli_impl/cut.py

@@ -0,0 +1,551 @@
+from __future__ import annotations
+
+import argparse
+import csv
+import json
+import re
+import shutil
+import subprocess
+from collections import defaultdict
+from pathlib import Path
+from typing import Any
+
+import pyarrow as pa
+import pyarrow.parquet as pq
+
+
+EPISODE_FILE_PATTERN = re.compile(r"episode[-_](\d+)")
+FILE_PATTERN = re.compile(r"file-(\d+)")
+VIDEO_SUFFIXES = {".avi", ".mkv", ".mov", ".mp4", ".webm"}
+
+
+def positive_minutes(value: str) -> float:
+    try:
+        minutes = float(value)
+    except ValueError as exc:
+        raise argparse.ArgumentTypeError("minutes must be a number") from exc
+    if minutes <= 0:
+        raise argparse.ArgumentTypeError("minutes must be greater than zero")
+    return minutes
+
+
+def configure_parser(parser: argparse.ArgumentParser) -> None:
+    parser.add_argument("input_dataset", type=Path)
+    parser.add_argument("output_path", type=Path)
+    parser.add_argument(
+        "--minutes",
+        type=positive_minutes,
+        required=True,
+        help="maximum duration retained from the start of each episode",
+    )
+    parser.set_defaults(handler=execute)
+
+
+def _source_name(path: Path, data_root: Path) -> str:
+    relative = path.relative_to(data_root)
+    parts = []
+    for part in relative.parts[:-1]:
+        if part.startswith("chunk-"):
+            break
+        parts.append(part)
+    return "/".join(parts)
+
+
+def _replace_column(table: pa.Table, name: str, values: list[int]) -> pa.Table:
+    index = table.column_names.index(name)
+    return table.set_column(
+        index,
+        name,
+        pa.array(values, type=table.schema.field(name).type),
+    )
+
+
+def _read_json_lines(path: Path) -> list[dict[str, Any]]:
+    if not path.is_file():
+        return []
+    return [
+        json.loads(line)
+        for line in path.read_text(encoding="utf-8").splitlines()
+        if line.strip()
+    ]
+
+
+def _write_json_lines(path: Path, rows: list[dict[str, Any]]) -> None:
+    path.write_text(
+        "".join(json.dumps(row, ensure_ascii=False) + "\n" for row in rows),
+        encoding="utf-8",
+    )
+
+
+def _episode_tables(root: Path) -> list[tuple[Path, pa.Table]]:
+    result = []
+    for path in sorted((root / "meta" / "episodes").glob("**/*.parquet")):
+        result.append((path, pq.read_table(path)))
+    return result
+
+
+def _episode_rows(tables: list[tuple[Path, pa.Table]]) -> list[dict[str, Any]]:
+    return [row for _, table in tables for row in table.to_pylist()]
+
+
+def _table_time_values(table: pa.Table, fps: float) -> list[float]:
+    if "timestamp" in table.column_names:
+        return [float(value) for value in table["timestamp"].to_pylist()]
+    if "frame_index" in table.column_names:
+        return [float(value) / fps for value in table["frame_index"].to_pylist()]
+    return [index / fps for index in range(table.num_rows)]
+
+
+def _candidate_lengths(
+    paths: list[Path], data_root: Path, seconds: float, fps: float
+) -> dict[int, int]:
+    counts: dict[str, dict[int, int]] = defaultdict(lambda: defaultdict(int))
+    first_timestamps: dict[tuple[str, int], float] = {}
+    for path in paths:
+        schema = pq.read_schema(path)
+        if "episode_index" not in schema.names:
+            raise ValueError(f"data parquet lacks episode_index: {path}")
+        columns = ["episode_index"]
+        for candidate in ("timestamp", "frame_index"):
+            if candidate in schema.names:
+                columns.append(candidate)
+                break
+        table = pq.read_table(path, columns=columns)
+        source = _source_name(path, data_root)
+        episodes = [int(value) for value in table["episode_index"].to_pylist()]
+        timestamps = _table_time_values(table, fps)
+        for episode, timestamp in zip(episodes, timestamps):
+            key = (source, episode)
+            first = first_timestamps.setdefault(key, timestamp)
+            if timestamp <= first + seconds + 1e-9:
+                counts[source][episode] += 1
+
+    episodes = {episode for values in counts.values() for episode in values}
+    if not episodes:
+        raise ValueError("no episode rows found in data parquet files")
+    lengths = {
+        episode: min(
+            values[episode] for values in counts.values() if episode in values
+        )
+        for episode in episodes
+    }
+    return lengths
+
+
+def _probe_frames(path: Path) -> int:
+    command = [
+        "ffprobe",
+        "-v",
+        "error",
+        "-select_streams",
+        "v:0",
+        "-show_entries",
+        "stream=nb_frames",
+        "-of",
+        "json",
+        str(path),
+    ]
+    try:
+        result = subprocess.run(
+            command, check=True, capture_output=True, text=True
+        )
+        stream = json.loads(result.stdout)["streams"][0]
+        value = stream.get("nb_frames")
+        if value not in (None, "N/A"):
+            return int(value)
+
+        command.insert(command.index("-show_entries"), "-count_frames")
+        command[command.index("stream=nb_frames")] = "stream=nb_read_frames"
+        result = subprocess.run(
+            command, check=True, capture_output=True, text=True
+        )
+        value = json.loads(result.stdout)["streams"][0].get("nb_read_frames")
+        if value not in (None, "N/A"):
+            return int(value)
+    except (subprocess.CalledProcessError, KeyError, ValueError, json.JSONDecodeError) as exc:
+        raise RuntimeError(f"cannot inspect video frames: {path}") from exc
+    raise RuntimeError(f"video does not report a frame count: {path}")
+
+
+def _chunk_index(path: Path) -> int | None:
+    for part in path.parts:
+        if part.startswith("chunk-"):
+            try:
+                return int(part.removeprefix("chunk-"))
+            except ValueError:
+                return None
+    return None
+
+
+def _media_episodes(path: Path, root: Path, rows: list[dict[str, Any]]) -> list[int]:
+    direct = EPISODE_FILE_PATTERN.search(path.stem)
+    if direct:
+        return [int(direct.group(1))]
+
+    file_match = FILE_PATTERN.search(path.stem)
+    if not file_match:
+        raise ValueError(f"cannot determine episode for media file: {path}")
+    file_index = int(file_match.group(1))
+    chunk_index = _chunk_index(path)
+    relative = path.relative_to(root).as_posix()
+    kind = relative.split("/", 1)[0]
+    matches = []
+    for row in rows:
+        episode = int(row.get("episode_index", -1))
+        for key, value in row.items():
+            if not key.startswith(f"{kind}/") or not key.endswith("/file_index"):
+                continue
+            feature = key[len(kind) + 1 : -len("/file_index")]
+            chunk_key = key[: -len("file_index")] + "chunk_index"
+            if (
+                int(value) == file_index
+                and (chunk_index is None or int(row.get(chunk_key, -1)) == chunk_index)
+                and feature in relative
+            ):
+                matches.append(episode)
+                break
+    return sorted(set(matches)) or [file_index]
+
+
+def _copy_static_tree(source: Path, output: Path) -> None:
+    skipped = {"data", "videos", "depths", "sensors"}
+
+    def ignore(directory: str, names: list[str]) -> set[str]:
+        return skipped.intersection(names) if Path(directory) == source else set()
+
+    shutil.copytree(source, output, ignore=ignore)
+
+
+def _write_data(
+    paths: list[Path],
+    source_root: Path,
+    output_root: Path,
+    limits: dict[int, int],
+    fps: float,
+) -> tuple[dict[str, dict[int, dict[str, float | int]]], dict[str, int]]:
+    seen: dict[str, dict[int, int]] = defaultdict(lambda: defaultdict(int))
+    global_index: dict[str, int] = defaultdict(int)
+    metrics: dict[str, dict[int, dict[str, float | int]]] = defaultdict(dict)
+
+    for path in paths:
+        table = pq.read_table(path)
+        source = _source_name(path, source_root)
+        episodes = [int(value) for value in table["episode_index"].to_pylist()]
+        timestamps = _table_time_values(table, fps)
+        keep = []
+        frame_indexes = []
+        indexes = []
+        for row_index, (episode, timestamp) in enumerate(zip(episodes, timestamps)):
+            ordinal = seen[source][episode]
+            seen[source][episode] += 1
+            if ordinal >= limits[episode]:
+                continue
+            keep.append(row_index)
+            frame_indexes.append(ordinal)
+            indexes.append(global_index[source])
+            global_index[source] += 1
+            episode_metrics = metrics[source].setdefault(
+                episode,
+                {
+                    "from_index": indexes[-1],
+                    "to_index": indexes[-1] + 1,
+                    "from_timestamp": timestamp,
+                    "to_timestamp": timestamp,
+                    "length": 0,
+                },
+            )
+            episode_metrics["to_index"] = indexes[-1] + 1
+            episode_metrics["to_timestamp"] = timestamp
+            episode_metrics["length"] = int(episode_metrics["length"]) + 1
+
+        trimmed = table.take(pa.array(keep, type=pa.int64()))
+        if "frame_index" in trimmed.column_names:
+            trimmed = _replace_column(trimmed, "frame_index", frame_indexes)
+        if "index" in trimmed.column_names:
+            trimmed = _replace_column(trimmed, "index", indexes)
+        destination = output_root / path.relative_to(source_root.parent)
+        destination.parent.mkdir(parents=True, exist_ok=True)
+        pq.write_table(trimmed, destination)
+    return metrics, dict(global_index)
+
+
+def _copy_or_cut_video(source: Path, destination: Path, frames: int) -> None:
+    source_frames = _probe_frames(source)
+    destination.parent.mkdir(parents=True, exist_ok=True)
+    if source_frames <= frames:
+        shutil.copy2(source, destination)
+        return
+    depth_video = "depth" in source.as_posix().lower()
+    codec = ["-c:v", "libx264rgb", "-crf", "0"] if depth_video else [
+        "-c:v",
+        "libx264",
+        "-crf",
+        "20",
+    ]
+    subprocess.run(
+        [
+            "ffmpeg",
+            "-y",
+            "-loglevel",
+            "error",
+            "-i",
+            str(source),
+            "-map",
+            "0:v:0",
+            "-frames:v",
+            str(frames),
+            *codec,
+            "-preset",
+            "veryfast",
+            "-an",
+            str(destination),
+        ],
+        check=True,
+    )
+    actual = _probe_frames(destination)
+    if actual != frames:
+        raise RuntimeError(
+            f"video frame count mismatch for {destination}: expected {frames}, got {actual}"
+        )
+
+
+def _sensor_episode(path: Path, rows: list[dict[str, Any]], root: Path) -> int:
+    match = EPISODE_FILE_PATTERN.search(path.stem)
+    if match:
+        return int(match.group(1))
+    relative = path.relative_to(root).as_posix()
+    matches = {
+        int(row["episode_index"])
+        for row in rows
+        for key, value in row.items()
+        if key.startswith("sensors/") and key.endswith("/path") and value == relative
+    }
+    if len(matches) != 1:
+        raise ValueError(f"cannot determine episode for sensor file: {path}")
+    return matches.pop()
+
+
+def _copy_sensors(
+    source: Path,
+    output: Path,
+    episode_rows: list[dict[str, Any]],
+    end_times: dict[int, float],
+) -> dict[str, dict[str, float | int]]:
+    metrics = {}
+    sensor_root = source / "sensors"
+    if not sensor_root.exists():
+        return metrics
+    for path in sorted(sensor_root.glob("**/*")):
+        if not path.is_file():
+            continue
+        destination = output / path.relative_to(source)
+        destination.parent.mkdir(parents=True, exist_ok=True)
+        if path.suffix.lower() != ".csv":
+            shutil.copy2(path, destination)
+            continue
+        episode = _sensor_episode(path, episode_rows, source)
+        with path.open(newline="", encoding="utf-8") as stream:
+            reader = csv.DictReader(stream)
+            rows = list(reader)
+            fieldnames = reader.fieldnames or []
+        if "timestamp" in fieldnames and rows:
+            first_timestamp = float(rows[0]["timestamp"])
+            maximum = first_timestamp + end_times[episode] + 1e-9
+            rows = [row for row in rows if float(row["timestamp"]) <= maximum]
+        if "imu_index" in fieldnames:
+            for index, row in enumerate(rows):
+                row["imu_index"] = str(index)
+        with destination.open("w", newline="", encoding="utf-8") as stream:
+            writer = csv.DictWriter(stream, fieldnames=fieldnames)
+            writer.writeheader()
+            writer.writerows(rows)
+        relative = path.relative_to(source).as_posix()
+        metrics[relative] = {
+            "from_index": 0,
+            "to_index": len(rows),
+            "from_timestamp": float(rows[0]["timestamp"]) if rows and "timestamp" in fieldnames else 0.0,
+            "to_timestamp": float(rows[-1]["timestamp"]) if rows and "timestamp" in fieldnames else 0.0,
+        }
+    return metrics
+
+
+def _update_episode_row(
+    row: dict[str, Any],
+    limits: dict[int, int],
+    offsets: dict[int, int],
+    source_metrics: dict[str, dict[int, dict[str, float | int]]],
+    sensor_metrics: dict[str, dict[str, float | int]],
+    end_times: dict[int, float],
+) -> None:
+    episode = int(row["episode_index"])
+    length = limits[episode]
+    for key in list(row):
+        if key == "length" or key.endswith("_length"):
+            row[key] = length
+    for key in ("duration", "duration_s"):
+        if key in row:
+            row[key] = min(float(row[key]), end_times[episode])
+    if "dataset_from_index" in row:
+        row["dataset_from_index"] = offsets[episode]
+    if "dataset_to_index" in row:
+        row["dataset_to_index"] = offsets[episode] + length
+
+    for source, episodes in source_metrics.items():
+        values = episodes.get(episode)
+        if values is None:
+            continue
+        prefix = f"data/{source}/" if source else "data/"
+        for field in ("from_index", "to_index", "from_timestamp", "to_timestamp"):
+            key = prefix + field
+            if key in row:
+                row[key] = values[field]
+
+    for key, value in list(row.items()):
+        if key.startswith(("videos/", "depths/")) and key.endswith("/to_timestamp"):
+            prefix = key[: -len("to_timestamp")]
+            row[key] = float(row.get(prefix + "from_timestamp", 0.0)) + end_times[episode]
+        if key.startswith("sensors/") and key.endswith("/path") and value in sensor_metrics:
+            prefix = key[: -len("path")]
+            for field, metric_value in sensor_metrics[value].items():
+                metric_key = prefix + field
+                if metric_key in row:
+                    row[metric_key] = metric_value
+
+
+def cut_dataset(input_dataset: Path, output_path: Path, minutes: float) -> None:
+    source = input_dataset.expanduser().resolve()
+    output = output_path.expanduser().resolve()
+    if not source.is_dir():
+        raise NotADirectoryError(f"input dataset does not exist: {source}")
+    if output.exists():
+        raise FileExistsError(f"output path already exists: {output}")
+    if output.is_relative_to(source):
+        raise ValueError("output path must be outside the input dataset")
+    data_root = source / "data"
+    data_paths = sorted(data_root.glob("**/*.parquet"))
+    if not data_paths:
+        raise ValueError(f"no data parquet files found under {data_root}")
+
+    info_path = source / "meta" / "info.json"
+    info = json.loads(info_path.read_text(encoding="utf-8"))
+    fps = float(info.get("fps", 30.0))
+    limits = _candidate_lengths(data_paths, data_root, minutes * 60, fps)
+    episode_tables = _episode_tables(source)
+    episode_rows = _episode_rows(episode_tables)
+
+    media_paths = sorted(
+        path
+        for directory in (source / "videos", source / "depths")
+        if directory.exists()
+        for path in directory.glob("**/*")
+        if path.is_file() and path.suffix.lower() in VIDEO_SUFFIXES
+    )
+    media_episodes = {}
+    for path in media_paths:
+        episodes = _media_episodes(path, source, episode_rows)
+        if len(episodes) != 1:
+            raise ValueError(
+                f"media file contains multiple episodes and cannot be cut safely: {path}"
+            )
+        episode = episodes[0]
+        if episode not in limits:
+            raise ValueError(f"media references unknown episode {episode}: {path}")
+        media_episodes[path] = episode
+        limits[episode] = min(limits[episode], _probe_frames(path))
+
+    if any(length <= 0 for length in limits.values()):
+        raise ValueError("the requested cut produced an empty episode")
+
+    try:
+        _copy_static_tree(source, output)
+        source_metrics, source_totals = _write_data(
+            data_paths, data_root, output, limits, fps
+        )
+        end_times = {
+            episode: min(
+                float(episodes[episode]["to_timestamp"])
+                - float(episodes[episode]["from_timestamp"])
+                for episodes in source_metrics.values()
+                if episode in episodes
+            )
+            for episode in limits
+        }
+
+        for path, episode in media_episodes.items():
+            _copy_or_cut_video(
+                path, output / path.relative_to(source), limits[episode]
+            )
+        for directory in (source / "videos", source / "depths"):
+            if not directory.exists():
+                continue
+            for path in directory.glob("**/*"):
+                if path.is_file() and path not in media_episodes:
+                    destination = output / path.relative_to(source)
+                    destination.parent.mkdir(parents=True, exist_ok=True)
+                    shutil.copy2(path, destination)
+        sensor_metrics = _copy_sensors(
+            source, output, episode_rows, end_times
+        )
+
+        offsets = {}
+        offset = 0
+        for episode in sorted(limits):
+            offsets[episode] = offset
+            offset += limits[episode]
+
+        for original_path, table in episode_tables:
+            rows = table.to_pylist()
+            for row in rows:
+                _update_episode_row(
+                    row,
+                    limits,
+                    offsets,
+                    source_metrics,
+                    sensor_metrics,
+                    end_times,
+                )
+            destination = output / original_path.relative_to(source)
+            pq.write_table(pa.Table.from_pylist(rows, schema=table.schema), destination)
+
+        jsonl_path = output / "meta" / "episodes.jsonl"
+        jsonl_rows = _read_json_lines(jsonl_path)
+        for row in jsonl_rows:
+            _update_episode_row(
+                row,
+                limits,
+                offsets,
+                source_metrics,
+                sensor_metrics,
+                end_times,
+            )
+        if jsonl_path.exists():
+            _write_json_lines(jsonl_path, jsonl_rows)
+
+        info["total_frames"] = sum(limits.values())
+        if isinstance(info.get("source_frame_counts"), dict):
+            info["source_frame_counts"] = {
+                source_name: source_totals.get(source_name, 0)
+                for source_name in info["source_frame_counts"]
+            }
+        (output / "meta" / "info.json").write_text(
+            json.dumps(info, ensure_ascii=False, indent=2) + "\n",
+            encoding="utf-8",
+        )
+    except Exception:
+        shutil.rmtree(output, ignore_errors=True)
+        raise
+
+
+def execute(args: argparse.Namespace) -> int:
+    cut_dataset(args.input_dataset, args.output_path, args.minutes)
+    print(
+        json.dumps(
+            {
+                "input": str(args.input_dataset),
+                "output": str(args.output_path),
+                "minutes": args.minutes,
+            },
+            ensure_ascii=False,
+        )
+    )
+    return 0

algorithm_plugin_sdk/cli_impl/serve.py

@@ -81,6 +81,8 @@ def configure_parser(parser: argparse.ArgumentParser) -> None:
 def execute(args: argparse.Namespace) -> int:
     config: DeploymentConfig | None = None
     service: dict[str, object] | None = None
+    local_scratch = False
+    local_output = False
     if args.config:
         # Apply the process mask before refreshing/loading the algorithm.  A
         # repository module may import CUDA during module import.
@@ -91,6 +93,8 @@ def execute(args: argparse.Namespace) -> int:
         args.port = int(service["port"])
         args.max_concurrent_executions = int(service["maxConcurrency"])
         args.scratch_dir = service.get("scratchDir")
+        local_scratch = bool(service.get("localScratch", False))
+        local_output = bool(service.get("localOutput", False))
         args.gpu_ids = list(service.get("gpuIds", []))
         args.webui = bool(service.get("webui"))
         values = config.process_environment()
@@ -120,6 +124,8 @@ def execute(args: argparse.Namespace) -> int:
         ),
         max_concurrent_executions=args.max_concurrent_executions,
         scratch_dir=args.scratch_dir,
+        local_scratch=local_scratch,
+        local_output=local_output,
         gpu_ids=args.gpu_ids,
         runner_factory=create_runner,
         max_attempts=args.max_attempts,

algorithm_plugin_sdk/deployment.py

@@ -146,6 +146,8 @@ class DeploymentConfig:
         gpu_ids: list[int] | None = None,
         environment: dict[str, str] | None = None,
         default_parameters: dict[str, Any] | None = None,
+        local_scratch: bool = False,
+        local_output: bool = False,
     ) -> "DeploymentConfig":
         repository = repository_root(root)
         _make_repository_importable(repository)
@@ -189,6 +191,8 @@ class DeploymentConfig:
                 "webui": webui,
                 "maxConcurrency": max_concurrency,
                 "scratchDir": _absolute(scratch_dir, repository),
+                "localScratch": local_scratch,
+                "localOutput": local_output,
                 "gpuIds": configured_gpu_ids,
                 "token": token or None,
                 "defaultParameters": dict(default_parameters or {}),
@@ -268,6 +272,9 @@ class DeploymentConfig:
             raise RuntimeError("service port must be in [1, 65535]")
         if concurrency < 1:
             raise RuntimeError("service maxConcurrency must be positive")
+        for name in ("localScratch", "localOutput"):
+            if not isinstance(service.get(name, False), bool):
+                raise RuntimeError(f"service {name} must be a boolean")
         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/log_manager.py

@@ -10,6 +10,9 @@ from typing import Any
 from .context import utc_now
 
 _SAFE_NAME = re.compile(r"[^A-Za-z0-9._-]+")
+_TIMESTAMP_GLOB = "[0-9]" * 14
+_FILE_LOCKS_GUARD = threading.Lock()
+_FILE_LOCKS: dict[Path, threading.RLock] = {}
 
 
 def _safe_name(value: str) -> str:
@@ -17,20 +20,61 @@ def _safe_name(value: str) -> str:
     return cleaned or "job"
 
 
+def _file_lock(path: Path) -> threading.RLock:
+    with _FILE_LOCKS_GUARD:
+        return _FILE_LOCKS.setdefault(path, threading.RLock())
+
+
+def _timestamp_prefix() -> str:
+    return utc_now().replace("-", "").replace(":", "").replace("T", "")[:14]
+
+
+def _job_log_path(directory: Path, job_id: str) -> Path:
+    safe_job_id = _safe_name(job_id)
+    pattern = f"{_TIMESTAMP_GLOB}-{safe_job_id}.log"
+    with _FILE_LOCKS_GUARD:
+        existing = sorted(directory.glob(pattern))
+        if existing:
+            return existing[0]
+        timestamp = _timestamp_prefix()
+        path = directory / f"{timestamp}-{safe_job_id}.log"
+        path.touch(exist_ok=True)
+        return path
+
+
 class ExecutionLog:
-    """Per-execution, line-buffered log sink attached to context.logger."""
+    """Per-job, 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:
+    def __init__(
+        self,
+        *,
+        log_dir: str | Path,
+        job_id: str,
+        execution_id: str,
+        logger: logging.Logger,
+        task_id: str | None = None,
+    ) -> None:
+        resolved_task_id = task_id or execution_id
+        self._event_context = {
+            "jobId": job_id,
+            "taskId": resolved_task_id,
+            "executionId": execution_id,
+            "job_id": job_id,
+            "task_id": resolved_task_id,
+            "execution_id": execution_id,
+        }
         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"
+        path = _job_log_path(directory, job_id)
         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._lock = _file_lock(path)
+        self._handler = _FlushFileHandler(self._stream, self._lock)
+        self._handler.setFormatter(
+            logging.Formatter(
+                f"%(asctime)s %(levelname)s [executionId={execution_id}] %(message)s"
+            )
+        )
         self._handler.setLevel(logging.DEBUG)
         self.logger = logger
         self.logger.setLevel(logging.DEBUG)
@@ -38,7 +82,12 @@ class ExecutionLog:
         self._closed = False
 
     def write_event(self, event: str, **values: Any) -> None:
-        payload = {"event": event, "timestamp": utc_now(), **values}
+        payload = {
+            "event": event,
+            "timestamp": utc_now(),
+            **self._event_context,
+            **values,
+        }
         with self._lock:
             if self._closed:
                 return
@@ -56,10 +105,10 @@ class ExecutionLog:
 
 
 class _FlushFileHandler(logging.Handler):
-    def __init__(self, stream: Any) -> None:
+    def __init__(self, stream: Any, lock: threading.RLock) -> None:
         super().__init__()
         self.stream = stream
-        self._lock = threading.RLock()
+        self._lock = lock
 
     def emit(self, record: logging.LogRecord) -> None:
         try:

algorithm_plugin_sdk/service.py

@@ -6,6 +6,7 @@ import logging
 import random
 import threading
 import time
+import traceback
 import uuid
 from concurrent.futures import Future, ThreadPoolExecutor
 from contextlib import asynccontextmanager
@@ -123,6 +124,8 @@ class ExecutionManager:
         scratch_dir: str | None = None,
         repository: str | Path | None = None,
         log_dir: str | Path | None = None,
+        local_scratch: bool = False,
+        local_output: bool = False,
         gpu_ids: list[int] | None = None,
         runner_factory: RunnerFactory | None = None,
         max_attempts: int = MAX_ATTEMPTS,
@@ -138,6 +141,17 @@ class ExecutionManager:
             raise ValueError("retry_seconds must be positive")
         if not 0 <= retry_jitter_ratio <= 1:
             raise ValueError("retry_jitter_ratio must be in [0, 1]")
+        if not isinstance(local_scratch, bool) or not isinstance(
+            local_output, bool
+        ):
+            raise ValueError("local_scratch and local_output must be booleans")
+        repository_path = (
+            Path(repository).expanduser().resolve()
+            if repository is not None
+            else None
+        )
+        if (local_scratch or local_output) and repository_path is None:
+            raise ValueError("repository is required for local scratch or output")
         configured_gpu_ids = None if gpu_ids is None else list(gpu_ids)
         if configured_gpu_ids is not None and (
             any(
@@ -156,10 +170,19 @@ class ExecutionManager:
             raise ValueError("default_parameters must be a JSON object")
         self.default_parameters = dict(default_parameters or {})
         self.scratch_dir = scratch_dir
+        self._local_scratch_root = (
+            repository_path / ".scratch" if local_scratch else None
+        )
+        self._local_output_root = (
+            repository_path / ".output" if local_output else None
+        )
+        for local_root in (self._local_scratch_root, self._local_output_root):
+            if local_root is not None:
+                local_root.mkdir(parents=True, exist_ok=True)
         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)
+            else (repository_path / "logs" if repository_path is not None else None)
         )
         self.gpu_ids = configured_gpu_ids
         self.max_concurrent_executions = max_concurrent_executions
@@ -191,6 +214,46 @@ class ExecutionManager:
             self.runner.start()
             self._started = True
 
+    def _apply_local_paths(
+        self,
+        request: AlgorithmRequest,
+        job_id: str,
+    ) -> AlgorithmRequest:
+        workspace = dict(request.workspace or {})
+        inputs = request.inputs
+        if self._local_scratch_root is not None:
+            workspace["scratchRoot"] = str(self._local_scratch_root)
+        if self._local_output_root is not None:
+            workspace["outputRoot"] = str(self._local_output_root)
+            job_output = self._job_output_dir(job_id)
+            if len(inputs) == 1:
+                output_paths = [job_output]
+            else:
+                output_paths = [
+                    job_output / f"{index}-{Path(item.output).name or 'output'}"
+                    for index, item in enumerate(inputs)
+                ]
+                for output_path in output_paths:
+                    output_path.mkdir(parents=True, exist_ok=True)
+            inputs = [
+                replace(item, output=str(output_path))
+                for item, output_path in zip(inputs, output_paths)
+            ]
+        return replace(request, inputs=inputs, workspace=workspace or None)
+
+    def _job_output_dir(self, job_id: str) -> Path:
+        assert self._local_output_root is not None
+        if Path(job_id).name != job_id or job_id in {"", ".", ".."}:
+            raise ValueError(f"job ID is unsafe for local output: {job_id!r}")
+        output = (self._local_output_root / job_id).resolve()
+        if (
+            output == self._local_output_root
+            or self._local_output_root not in output.parents
+        ):
+            raise ValueError(f"job output escapes local root: {job_id!r}")
+        output.mkdir(parents=True, exist_ok=True)
+        return output
+
     def submit(
         self,
         request: AlgorithmRequest,
@@ -226,6 +289,7 @@ class ExecutionManager:
         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)
+        request = self._apply_local_paths(request, resolved_job_id)
         record = ExecutionRecord(
             execution_id=execution_id,
             request=request,
@@ -237,10 +301,9 @@ class ExecutionManager:
         record.context = ExecutionContext(
             execution_id,
             [item.input_dataset for item in request.inputs],
-            scratch_dir=(
-                record.request.workspace["scratchRoot"]
-                if record.request.workspace is not None
-                else self.scratch_dir
+            scratch_dir=(record.request.workspace or {}).get(
+                "scratchRoot",
+                self.scratch_dir,
             ),
             progress_callback=record.add_progress,
         )
@@ -248,6 +311,7 @@ class ExecutionManager:
             record.log = ExecutionLog(
                 log_dir=self.log_dir,
                 job_id=record.job_id,
+                task_id=record.task_id,
                 execution_id=record.execution_id,
                 logger=record.context.logger,
             )
@@ -430,10 +494,16 @@ class ExecutionManager:
                 record.log.write_event("result", state="cancelled", error=str(exc))
         except Exception as exc:
             error = f"{type(exc).__name__}: {exc}"
+            stack_trace = traceback.format_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)
+                record.log.write_event(
+                    "result",
+                    state="failed",
+                    error=error,
+                    traceback=stack_trace,
+                )
         else:
             record.set_state(result.status, result=result)
             if record.log is not None:
@@ -466,7 +536,7 @@ class ExecutionManager:
                         self.retry_seconds * (1 - self.retry_jitter_ratio),
                         self.retry_seconds * (1 + self.retry_jitter_ratio),
                     )
-                    logger.warning(
+                    record.context.logger.warning(
                         "algorithm execution %s failed on attempt %d/%d; "
                         "releasing and restarting algorithm in %.3f seconds: %s: %s",
                         record.execution_id,
@@ -475,16 +545,18 @@ class ExecutionManager:
                         delay,
                         type(exc).__name__,
                         exc,
+                        exc_info=True,
                     )
                 else:
                     delay = 0.0
-                    logger.error(
+                    record.context.logger.error(
                         "algorithm execution %s exhausted %d attempts; "
                         "releasing and restarting algorithm for future requests: %s: %s",
                         record.execution_id,
                         self.max_attempts,
                         type(exc).__name__,
                         exc,
+                        exc_info=True,
                     )
             finally:
                 self._release_runner()

{ls_algorithm_plugin_sdk-0.3.3.dist-info → ls_algorithm_plugin_sdk-0.3.5.dist-info}/METADATA

@@ -1,11 +1,12 @@
 Metadata-Version: 2.4
 Name: ls-algorithm-plugin-sdk
-Version: 0.3.3
+Version: 0.3.5
 Summary: Protocol-independent runtime SDK for dataset algorithms
 Author: Ling Robotics
 License: Proprietary
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
+Requires-Dist: pyarrow>=14
 Provides-Extra: service
 Requires-Dist: fastapi<1,>=0.110; extra == "service"
 Requires-Dist: pydantic<3,>=2.0; extra == "service"
@@ -40,6 +41,16 @@ algorithm-plugin run camera-space-mano \
 
 `--gpu-ids` 和 `--parameters` 可省略，也可用 `--request-file` 读取完整请求 JSON。
 
+## 数据集裁剪
+
+将每个 episode 裁剪为最多指定分钟数，并同步更新 Parquet、视频、传感器 CSV 和元数据：
+
+```bash
+algorithm-plugin cut /data/input_dataset /data/output_dataset --minutes 1.5
+```
+
+支持 LeRobot v2/v3 的 `episode_*`、`file-*` 和多数据源目录布局。视频裁剪需要系统已安装 `ffmpeg` 与 `ffprobe`。
+
 ## 配置现有仓库
 
 目标算法仓库必须满足：

{ls_algorithm_plugin_sdk-0.3.3.dist-info → ls_algorithm_plugin_sdk-0.3.5.dist-info}/RECORD

@@ -1,23 +1,24 @@
 algorithm_plugin_sdk/__init__.py,sha256=OKj2VcNXTwZmRgPlECI6QUBlxW1YLtflr4RAgs6w064,1223
 algorithm_plugin_sdk/algorithm.py,sha256=INjX-ygMQfHk8D1AZbEEdCw1P4VNQLGF989lP1J1H1k,1025
-algorithm_plugin_sdk/cli.py,sha256=V9HFJ98iyhM1q6PZqd-366g1AoKuieC_Fn4u9RJcMNI,1252
+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=nx4-26vs5OqO6miBf6GegZIhdvOgFaw9MdjpTHZNDPo,14583
+algorithm_plugin_sdk/deployment.py,sha256=5WlZfML9ymWrAFsmdX-bBHTP2kuVY4WO5wKHs35Dkd4,14936
 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
-algorithm_plugin_sdk/log_manager.py,sha256=ktVVvf4khqXiYENr1QRpSf7yTG4HBzxW2AOHIZElDuE,2457
+algorithm_plugin_sdk/log_manager.py,sha256=fmqSivxi-BCOWs4Qomms9nHZC7MRl5NUVuRiTL0J12Q,3723
 algorithm_plugin_sdk/models.py,sha256=FIwUm8QDK8L37pV7AcCMnmYlDP-2l93zp8yc0KSu4yo,12196
 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=HcO8PmtPczogi0an7irajsRCD-11GAH8pnE7rOHOLSM,28004
+algorithm_plugin_sdk/service.py,sha256=HQLDW5nlGGXJNZ0KMFU4I1rPzWHMf_LlE-tsY42PHnc,31045
 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=OlYuNnPZXHbaoWKfBpFivyP8lZk2QQpvMN572hAjriA,13353
+algorithm_plugin_sdk/cli_impl/configure.py,sha256=hO9vwFfZ4yqeQUyYc3heE1MDLK1lppN69OoF2zeVVaM,13761
+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=C4raNwhj4KZJc7_aTJeoiwNMQtgeXyMWyLTZEVUL0mM,6041
-algorithm_plugin_sdk/cli_impl/serve.py,sha256=BBxjFjOI8bORzNij9DbKccAdt4zNzX_vqZyyKtliGSg,4936
+algorithm_plugin_sdk/cli_impl/serve.py,sha256=1Ma08MHMjKk9wKO8tGdymVvedcGC-jaKdaUCVBTPMro,5187
 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
@@ -25,8 +26,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.3.dist-info/METADATA,sha256=iLerkePM3Ff_GG0oA4TAdTsidnxYJxP1pmsSaIARMJw,2317
-ls_algorithm_plugin_sdk-0.3.3.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
-ls_algorithm_plugin_sdk-0.3.3.dist-info/entry_points.txt,sha256=TU0R_TxuB5OuOiZ5BHOEmUPtHvN3v8ARUW8d3PztHcE,67
-ls_algorithm_plugin_sdk-0.3.3.dist-info/top_level.txt,sha256=8lsgxZ8HJGLlzJ5Rt8CiVzw9Ccme286i3akbmeMjBos,21
-ls_algorithm_plugin_sdk-0.3.3.dist-info/RECORD,,
+ls_algorithm_plugin_sdk-0.3.5.dist-info/METADATA,sha256=Smgf_xFlGbqL5k73zGtyUKpY7VMvkfDRd-_ZNEFyGWM,2709
+ls_algorithm_plugin_sdk-0.3.5.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+ls_algorithm_plugin_sdk-0.3.5.dist-info/entry_points.txt,sha256=TU0R_TxuB5OuOiZ5BHOEmUPtHvN3v8ARUW8d3PztHcE,67
+ls_algorithm_plugin_sdk-0.3.5.dist-info/top_level.txt,sha256=8lsgxZ8HJGLlzJ5Rt8CiVzw9Ccme286i3akbmeMjBos,21
+ls_algorithm_plugin_sdk-0.3.5.dist-info/RECORD,,