pyetool 0.1.0__tar.gz

pyetool-0.1.0/.claude/settings.local.json

@@ -0,0 +1,8 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(uv run *)",
+      "Bash(uv sync *)"
+    ]
+  }
+}

pyetool-0.1.0/.envrc

@@ -0,0 +1 @@
+UV_CACHE_DIR="$TMPDIR/.uv-cache"

pyetool-0.1.0/.gitignore

@@ -0,0 +1,3 @@
+.env
+
+*.pyc

pyetool-0.1.0/.python-version

@@ -0,0 +1 @@
+3.13

pyetool-0.1.0/CLAUDE.md

@@ -0,0 +1,24 @@
+# 项目目标
+这个项目是为了提升个人生产力而制作的一系列 Python 工具。
+
+# 行为规范
+- `用中文与我对话`，`代码和注释使用英文，包括docstring`，`文档允许中英混合`。
+- AI是可替换的助力，不要在任何地方体现claude的存在。
+- 设计决策总是等我确认后才执行。
+
+# 设计理念
+- 所有可利用的“资源”都应该对象化，比如某个网页(like, playwright page)，web API，shell command(like ffmpeg), etc。如此一来，所有东西都可以用 Python 粘在一起。
+- Runnable python module: 功能足够独立使用的module都应该有自己的cli。cli都是可以用pipeline组合的。
+
+# 偏好
+- 偏好functional programming做局部实现。
+- 比起module+纯函数，偏好用class做更灵活的显式封装。
+- 只对功能本身进行测试，不对其中的算法过程进行测试。测试时，如无必要无需mock，尽量使用真实测试数据进行测试(如果你无法准备此数据，应通知我)。冒烟测试可以做one-time check。trivial的测试越少越好。
+- Correctness > Readability(IMPORTANT) > Algorithm Efficiency。代码应该着重强化可读性.
+  - naming应该考究，上下文中已有的信息无需反复出现。
+  - 不同逻辑的代码块之间应该以空行分隔。
+  - 尽可能标注typing.
+  - 外部规则、人为协定、无法从代码中推断的东西、有意为之的trick，应该加注释。复杂算法需要加注释。其他情况下，注释尽量少。
+
+# 规范
+- 用pydantic model写data model.

pyetool-0.1.0/PKG-INFO

@@ -0,0 +1,28 @@
+Metadata-Version: 2.4
+Name: pyetool
+Version: 0.1.0
+Summary: Add your description here
+Requires-Python: >=3.13
+Requires-Dist: click>=8.3.3
+Requires-Dist: google-genai>=2.0.1
+Requires-Dist: pydantic>=2.13.4
+Requires-Dist: python-dotenv>=1.2.2
+Requires-Dist: rich>=15.0.0
+Requires-Dist: tos>=2.9.0
+Description-Content-Type: text/markdown
+
+# Pyetool
+
+A personal efficiency enhancing tool
+
+## sprint 1
+- pexel api
+- video downloader
+- video resource object, understand method
+- audio resource object, transcribe method
+- bilibili page object, data & action
+
+## sprint 2
+- GIF resource object, understand method
+- music resource object, understand method
+- resource management

pyetool-0.1.0/README.md

@@ -0,0 +1,15 @@
+# Pyetool
+
+A personal efficiency enhancing tool
+
+## sprint 1
+- pexel api
+- video downloader
+- video resource object, understand method
+- audio resource object, transcribe method
+- bilibili page object, data & action
+
+## sprint 2
+- GIF resource object, understand method
+- music resource object, understand method
+- resource management

pyetool-0.1.0/main.py

@@ -0,0 +1,6 @@
+def main():
+    print("Hello from pyetool!")
+
+
+if __name__ == "__main__":
+    main()

pyetool-0.1.0/pyetool/tool/ffmpeg/__init__.py

@@ -0,0 +1,28 @@
+"""Object-oriented wrappers around ffmpeg and ffprobe."""
+
+from .ffmpeg import FFmpeg
+from .ffprobe import FFprobe
+from .model import (
+    ChapterInfo,
+    FormatInfo,
+    ProbeResult,
+    ProgramInfo,
+    StreamInfo,
+)
+from .typing import AudioCodec, LogLevel, Preset, VideoCodec
+from .util import hms
+
+__all__ = [
+    "AudioCodec",
+    "ChapterInfo",
+    "FFmpeg",
+    "FFprobe",
+    "FormatInfo",
+    "LogLevel",
+    "Preset",
+    "ProbeResult",
+    "ProgramInfo",
+    "StreamInfo",
+    "VideoCodec",
+    "hms",
+]

pyetool-0.1.0/pyetool/tool/ffmpeg/ffmpeg.py

@@ -0,0 +1,228 @@
+"""FFmpeg command builder and runner."""
+
+from pathlib import Path
+import shutil
+import subprocess
+from typing import Self
+
+from pyetool.util.monad import Err, Ok, Result
+
+from .typing import AudioCodec, Preset, VideoCodec
+
+
+class FFmpeg:
+    """FFmpeg command builder and runner."""
+    def __init__(self) -> None:
+        if shutil.which("ffmpeg") is None:
+            raise RuntimeError("FFmpeg is not installed or not found in PATH.")
+        self._init_state()
+
+    def _init_state(self) -> None:
+        self._input_file: str = ''
+        self._start_time: float | None = None
+        self._duration: float | None = None
+        self._end_time: float | None = None
+        self._video_filters: list[str] = []
+        self._strip_audio: bool = False
+        self._strip_video: bool = False
+        self._codec_name: VideoCodec | None = None
+        self._video_bitrate: str | None = None
+        self._frame_rate: float | None = None
+        self._crf: int | None = None
+        self._preset: Preset | None = None
+        self._acodec_name: AudioCodec | None = None
+        self._audio_bitrate: str | None = None
+        self._audio_sampling_rate: int | None = None
+        self._n_audio_channel: int | None = None
+        self._format: str | None = None
+        self._maps: list[str] = []
+        self._metadata: list[tuple[str, str]] = []
+        self._overwrite: bool = True
+        self._output_file: str = ''
+
+    def input_file(self, f: str | Path) -> Self:
+        """Set the source file to process (maps to `-i`)."""
+        self._input_file = str(f)
+        return self
+
+    def start_time(self, seconds: float) -> Self:
+        """Where to start reading from the source, in seconds (maps to `-ss`, placed before `-i` for fast seek). For `"HH:MM:SS"` input, convert via `hms()` first."""
+        self._start_time = seconds
+        return self
+
+    def duration(self, seconds: float) -> Self:
+        """Maximum output duration in seconds (maps to `-t`); stops when reached. Pair with `start_time` to cut a clip."""
+        self._duration = seconds
+        return self
+
+    def end_time(self, seconds: float) -> Self:
+        """Stop reading at this timestamp of the source, in seconds (maps to `-to`). Use this OR `duration`, not both."""
+        self._end_time = seconds
+        return self
+
+    def add_video_filter(self, video_filter: str) -> Self:
+        """Append a video filter such as `scale=1280:720`, crop, or watermark (maps to `-vf`). Multiple filters are joined with commas and applied in order."""
+        self._video_filters.append(video_filter)
+        return self
+
+    def add_video_filters(self, video_filters: list[str]) -> Self:
+        """Bulk append video filters; same semantics as `add_video_filter`."""
+        self._video_filters.extend(video_filters)
+        return self
+
+    def get_video_filters(self) -> list[str]:
+        """Return the current list of video filters."""
+        return self._video_filters
+
+    def clear_video_filters(self) -> Self:
+        """Clear all video filters. Useful when reusing the builder and the previous filters should not carry over."""
+        self._video_filters.clear()
+        return self
+
+    def strip_audio(self, yes: bool = True) -> Self:
+        """Drop the audio track, keep video only (maps to `-an`). Pass `yes=False` to undo for state reuse."""
+        self._strip_audio = yes
+        return self
+
+    def strip_video(self, yes: bool = True) -> Self:
+        """Drop the video track, keep audio only (maps to `-vn`); common for extracting audio from a video. Pass `yes=False` to undo."""
+        self._strip_video = yes
+        return self
+
+    def codec(self, name: VideoCodec) -> Self:
+        """Set the video encoder (maps to `-c:v`, equivalent to the older `-vcodec`). `copy` muxes the source stream untouched — the target container must accept that codec or ffmpeg will error."""
+        self._codec_name = name
+        return self
+
+    def video_bitrate(self, b: str) -> Self:
+        """Video bitrate (maps to `-b:v`), e.g. `"2M"`, `"800k"`."""
+        self._video_bitrate = b
+        return self
+
+    def frame_rate(self, r: float) -> Self:
+        """Output frame rate in fps (maps to `-r`), e.g. 24, 30, 60."""
+        self._frame_rate = r
+        return self
+
+    def crf(self, value: int) -> Self:
+        """x264/x265 quality knob (maps to `-crf`), range 0–51. Lower is sharper but larger; 18–28 is the typical band."""
+        self._crf = value
+        return self
+
+    def preset(self, p: Preset) -> Self:
+        """x264/x265 speed-vs-compression trade-off (maps to `-preset`). Faster preset → larger file; slower preset → better compression."""
+        self._preset = p
+        return self
+
+    def acodec(self, name: AudioCodec) -> Self:
+        """Set the audio encoder (maps to `-c:a`, equivalent to the older `-acodec`). `copy` muxes the source stream untouched — the target container must accept that codec."""
+        self._acodec_name = name
+        return self
+
+    def audio_bitrate(self, b: str) -> Self:
+        """Audio bitrate (maps to `-b:a`), e.g. `"192k"`, `"128k"`."""
+        self._audio_bitrate = b
+        return self
+
+    def audio_sampling_rate(self, hz: int) -> Self:
+        """Audio sampling rate in Hz (maps to `-ar`). Common values: 44100 (CD), 48000 (video), 16000 (speech)."""
+        self._audio_sampling_rate = hz
+        return self
+
+    def n_audio_channel(self, n_channel: int) -> Self:
+        """Number of audio channels (maps to `-ac`): 1=mono, 2=stereo, 6=5.1."""
+        self._n_audio_channel = n_channel
+        return self
+
+    def format(self, fmt: str) -> Self:
+        """Force the output container format (maps to `-f`), e.g. `"mp4"`, `"matroska"`. Useful when the output has no extension or to override the inferred default."""
+        self._format = fmt
+        return self
+
+    def add_map(self, stream: str) -> Self:
+        """Pick which streams to keep (maps to `-map`, can be called multiple times). E.g. `"0:v:0"` = first video stream of input 0, `"0:a"` = all audio streams of input 0. Needed for multi-track or subtitle scenarios."""
+        self._maps.append(stream)
+        return self
+
+    def add_metadata(self, key: str, value: str) -> Self:
+        """Write a metadata entry (maps to `-metadata key=value`, can be called multiple times), e.g. title, artist, comment."""
+        self._metadata.append((key, value))
+        return self
+
+    def overwrite(self, yes: bool = True) -> Self:
+        """Whether to overwrite the output file if it exists. `True` → `-y` (default), `False` → `-n` (abort if exists)."""
+        self._overwrite = yes
+        return self
+
+    def output_file(self, f: str | Path) -> Self:
+        """Set the output file path. Defaults to overwriting an existing file; call `overwrite(False)` to disable."""
+        self._output_file = str(f)
+        return self
+
+    def reset(self) -> Self:
+        """Clear every configured option, returning the builder to its just-constructed state."""
+        self._init_state()
+        return self
+
+    def run(self) -> Result[Path]:
+        """Invoke ffmpeg. On success returns `Ok(Path(output_file))`; on non-zero exit returns `Err(returncode, stderr)`."""
+        if not self._input_file:
+            raise RuntimeError("input file missing")
+        if not self._output_file:
+            raise RuntimeError("output file not specified")
+
+        args: list[str] = []
+
+        if self._start_time is not None:
+            args.extend(["-ss", str(self._start_time)])
+
+        args.extend(["-i", self._input_file])
+
+        if self._duration is not None:
+            args.extend(["-t", str(self._duration)])
+        if self._end_time is not None:
+            args.extend(["-to", str(self._end_time)])
+
+        if self._video_filters:
+            args.extend(["-vf", ",".join(self._video_filters)])
+
+        if self._strip_audio:
+            args.append("-an")
+        if self._strip_video:
+            args.append("-vn")
+
+        if self._codec_name is not None:
+            args.extend(["-c:v", self._codec_name])
+        if self._video_bitrate is not None:
+            args.extend(["-b:v", self._video_bitrate])
+        if self._frame_rate is not None:
+            args.extend(["-r", str(self._frame_rate)])
+        if self._crf is not None:
+            args.extend(["-crf", str(self._crf)])
+        if self._preset is not None:
+            args.extend(["-preset", self._preset])
+
+        if self._acodec_name is not None:
+            args.extend(["-c:a", self._acodec_name])
+        if self._audio_bitrate is not None:
+            args.extend(["-b:a", self._audio_bitrate])
+        if self._audio_sampling_rate is not None:
+            args.extend(["-ar", str(self._audio_sampling_rate)])
+        if self._n_audio_channel is not None:
+            args.extend(["-ac", str(self._n_audio_channel)])
+
+        for stream in self._maps:
+            args.extend(["-map", stream])
+        for key, value in self._metadata:
+            args.extend(["-metadata", f"{key}={value}"])
+
+        if self._format is not None:
+            args.extend(["-f", self._format])
+
+        args.append("-y" if self._overwrite else "-n")
+        args.append(self._output_file)
+
+        completed = subprocess.run(["ffmpeg", *args], capture_output=True, text=True, check=False)
+        if completed.returncode != 0:
+            return Err(returncode=completed.returncode, err=completed.stderr)
+        return Ok(Path(self._output_file))

pyetool-0.1.0/pyetool/tool/ffmpeg/ffprobe.py

@@ -0,0 +1,139 @@
+"""FFprobe command builder and runner for inspecting media files."""
+
+import json
+from pathlib import Path
+import shutil
+import subprocess
+from typing import Self
+
+from pyetool.util.monad import Err, Ok, Result
+
+from .model import ProbeResult
+from .typing import LogLevel
+
+
+class FFprobe:
+    """FFprobe command builder and runner for inspecting media files."""
+    def __init__(self) -> None:
+        if shutil.which("ffprobe") is None:
+            raise RuntimeError("FFprobe is not installed or not found in PATH.")
+        self._init_state()
+
+    def _init_state(self) -> None:
+        self._input_file: str = ''
+        self._loglevel: LogLevel | None = None
+        self._include_format: bool = False
+        self._include_streams: bool = False
+        self._include_packets: bool = False
+        self._include_frames: bool = False
+        self._include_chapters: bool = False
+        self._include_programs: bool = False
+        self._include_entries: str | None = None
+        self._select_streams: str | None = None
+        self._count_frames: bool = False
+        self._count_packets: bool = False
+
+    def input_file(self, f: str | Path) -> Self:
+        """Set the media file to inspect (maps to `-i`)."""
+        self._input_file = str(f)
+        return self
+
+    def loglevel(self, level: LogLevel) -> Self:
+        """Set logging verbosity (maps to `-v`). Use `"error"` to suppress banners and only see real errors."""
+        self._loglevel = level
+        return self
+
+    def include_format(self, yes: bool = True) -> Self:
+        """Include container-level info (duration, bitrate, format name, tags) in the output (maps to `-show_format`)."""
+        self._include_format = yes
+        return self
+
+    def include_streams(self, yes: bool = True) -> Self:
+        """Include per-stream info (codec, resolution, channels, sample rate, etc.) in the output (maps to `-show_streams`)."""
+        self._include_streams = yes
+        return self
+
+    def include_packets(self, yes: bool = True) -> Self:
+        """Include packet-level info (maps to `-show_packets`). Verbose; only useful for low-level debugging."""
+        self._include_packets = yes
+        return self
+
+    def include_frames(self, yes: bool = True) -> Self:
+        """Include frame-level info (maps to `-show_frames`). Very verbose; slow on long files."""
+        self._include_frames = yes
+        return self
+
+    def include_chapters(self, yes: bool = True) -> Self:
+        """Include chapter info (maps to `-show_chapters`)."""
+        self._include_chapters = yes
+        return self
+
+    def include_programs(self, yes: bool = True) -> Self:
+        """Include program info (maps to `-show_programs`); relevant for MPEG-TS and similar containers."""
+        self._include_programs = yes
+        return self
+
+    def include_entries(self, spec: str) -> Self:
+        """Restrict the output to specific entries (maps to `-show_entries`), e.g. `"stream=codec_name,width,height"` or `"format=duration"`."""
+        self._include_entries = spec
+        return self
+
+    def select_streams(self, spec: str) -> Self:
+        """Limit which streams are reported (maps to `-select_streams`), e.g. `"v"` = all video, `"a:0"` = first audio, `"s"` = subtitles."""
+        self._select_streams = spec
+        return self
+
+    def count_frames(self, yes: bool = True) -> Self:
+        """Count frames per stream (maps to `-count_frames`). Requires decoding, so it is slow but exact."""
+        self._count_frames = yes
+        return self
+
+    def count_packets(self, yes: bool = True) -> Self:
+        """Count packets per stream (maps to `-count_packets`). Cheaper than `count_frames`."""
+        self._count_packets = yes
+        return self
+
+    def reset(self) -> Self:
+        """Clear every configured option, returning the builder to its just-constructed state."""
+        self._init_state()
+        return self
+
+    def run(self) -> Result[ProbeResult]:
+        """Invoke ffprobe with JSON output forced internally. On success returns `Ok(ProbeResult)`; on non-zero exit returns `Err`."""
+        if not self._input_file:
+            raise RuntimeError("input file missing")
+
+        args: list[str] = ["-of", "json"]
+
+        if self._loglevel is not None:
+            args.extend(["-v", self._loglevel])
+        if self._select_streams is not None:
+            args.extend(["-select_streams", self._select_streams])
+        if self._include_entries is not None:
+            args.extend(["-show_entries", self._include_entries])
+
+        if self._include_format:
+            args.append("-show_format")
+        if self._include_streams:
+            args.append("-show_streams")
+        if self._include_packets:
+            args.append("-show_packets")
+        if self._include_frames:
+            args.append("-show_frames")
+        if self._include_chapters:
+            args.append("-show_chapters")
+        if self._include_programs:
+            args.append("-show_programs")
+
+        if self._count_frames:
+            args.append("-count_frames")
+        if self._count_packets:
+            args.append("-count_packets")
+
+        args.extend(["-i", self._input_file])
+
+        completed = subprocess.run(["ffprobe", *args], capture_output=True, text=True, check=False)
+        if completed.returncode != 0:
+            return Err(returncode=completed.returncode, err=completed.stderr)
+
+        return Ok(ProbeResult.model_validate(json.loads(completed.stdout)))

pyetool-0.1.0/pyetool/tool/ffmpeg/model.py

@@ -0,0 +1,88 @@
+"""Pydantic models for parsed ffprobe JSON output.
+
+Each model uses `extra="allow"`, so any unknown field returned by a future ffprobe version is
+preserved on `model_extra` and accessible without changing this file.
+"""
+
+from typing import Any, Literal
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class _ProbeModel(BaseModel):
+    """Base for ffprobe section models. Unknown fields are preserved on `model_extra` as the raw-escape hatch."""
+    model_config = ConfigDict(extra="allow")
+
+
+class FormatInfo(_ProbeModel):
+    """ffprobe `format` section — container-level info."""
+    filename: str = ""
+    format_name: str = ""
+    format_long_name: str | None = None
+    duration: float | None = None
+    size: int | None = None
+    bit_rate: int | None = None
+    nb_streams: int = 0
+    nb_programs: int = 0
+    start_time: float | None = None
+    probe_score: int | None = None
+    tags: dict[str, str] = Field(default_factory=dict)
+
+
+class StreamInfo(_ProbeModel):
+    """ffprobe `streams[i]` element — per-stream info. Video-only and audio-only fields stay `None` for streams of the other type."""
+    index: int = 0
+    codec_name: str = ""
+    codec_long_name: str | None = None
+    codec_type: Literal["video", "audio", "subtitle", "data", "attachment"] = "data"
+    profile: str | None = None
+    duration: float | None = None
+    bit_rate: int | None = None
+    nb_frames: int | None = None
+    tags: dict[str, str] = Field(default_factory=dict)
+
+    # video-only
+    width: int | None = None
+    height: int | None = None
+    pix_fmt: str | None = None
+    r_frame_rate: str | None = None
+    avg_frame_rate: str | None = None
+    display_aspect_ratio: str | None = None
+
+    # audio-only
+    sample_rate: int | None = None
+    channels: int | None = None
+    channel_layout: str | None = None
+    sample_fmt: str | None = None
+
+
+class ChapterInfo(_ProbeModel):
+    """ffprobe `chapters[i]` element."""
+    id: int = 0
+    time_base: str = ""
+    start: int = 0
+    start_time: float = 0.0
+    end: int = 0
+    end_time: float = 0.0
+    tags: dict[str, str] = Field(default_factory=dict)
+
+
+class ProgramInfo(_ProbeModel):
+    """ffprobe `programs[i]` element. Mostly relevant for MPEG-TS and similar multi-program containers."""
+    program_id: int = 0
+    program_num: int = 0
+    nb_streams: int = 0
+    pmt_pid: int | None = None
+    pcr_pid: int | None = None
+    tags: dict[str, str] = Field(default_factory=dict)
+    streams: list[StreamInfo] = Field(default_factory=list)
+
+
+class ProbeResult(_ProbeModel):
+    """Parsed ffprobe JSON output. Each section is populated only when the corresponding `include_*` flag was set."""
+    format: FormatInfo | None = None
+    streams: list[StreamInfo] = Field(default_factory=list)
+    chapters: list[ChapterInfo] = Field(default_factory=list)
+    programs: list[ProgramInfo] = Field(default_factory=list)
+    packets: list[dict[str, Any]] = Field(default_factory=list)
+    frames: list[dict[str, Any]] = Field(default_factory=list)

pyetool-0.1.0/pyetool/tool/ffmpeg/typing.py

@@ -0,0 +1,24 @@
+"""Literal type aliases for ffmpeg / ffprobe CLI option values."""
+
+from typing import Literal
+
+
+VideoCodec = Literal[
+    "libx264",     # H.264. Best compatibility — browsers, phones, hardware decoders all support it. Universal default.
+    "libx265",     # H.265/HEVC. ~50% smaller files at the same quality, but slower to encode, weaker hardware support, and licensing concerns.
+    "libvpx-vp9",  # VP9. Royalty-free, better compression than H.264. Common for WebM/YouTube; encoding is very slow.
+    "copy",        # No re-encoding — source stream is muxed as-is. Use for clip cutting, container remux, and other lossless ops.
+]
+AudioCodec = Literal[
+    "aac",          # De-facto default for MP4/MOV/TS containers. Excellent compatibility; 128–256 kbps is plenty for everyday use.
+    "libmp3lame",   # MP3. Universal compatibility, but lower quality per bitrate than AAC/Opus; use only when .mp3 output is required.
+    "libopus",      # Best quality per bitrate, especially for voice / low bitrates. Native in WebM/Ogg/Matroska; spotty support in MP4.
+    "copy",         # No re-encoding — same semantics as VideoCodec's copy.
+]
+Preset = Literal[
+    "ultrafast", "superfast", "veryfast", "faster",
+    "fast", "medium", "slow", "slower", "veryslow",
+]
+LogLevel = Literal[
+    "quiet", "panic", "fatal", "error", "warning", "info", "verbose", "debug", "trace",
+]

pyetool-0.1.0/pyetool/tool/ffmpeg/util.py

@@ -0,0 +1,16 @@
+"""ffmpeg-related helpers."""
+
+
+def hms(s: str) -> float:
+    """Parse `"HH:MM:SS"`, `"MM:SS"`, or `"SS"` (fractional seconds allowed) into a float second count.
+
+    Examples: `hms("00:01:30") == 90.0`, `hms("1:30.5") == 90.5`, `hms("12.5") == 12.5`.
+    """
+    parts = s.split(":")
+    if not 1 <= len(parts) <= 3:
+        raise ValueError(f"invalid time format: {s!r}")
+
+    seconds = 0.0
+    for part in parts:
+        seconds = seconds * 60 + float(part)
+    return seconds

pyetool-0.1.0/pyetool/tool/obj_storage/__init__.py

@@ -0,0 +1,12 @@
+"""Object storage abstraction with a pluggable backend, plus a Volcano TOS implementation."""
+
+from .cli import cli
+from .factory import obj_storage
+from .volc_tos import VolcTosBackend
+
+
+__all__ = [
+    "cli",  # pyproject script depends on it
+    "VolcTosBackend",
+    "obj_storage",
+]

pyetool-0.1.0/pyetool/tool/obj_storage/backend.py

@@ -0,0 +1,17 @@
+"""Protocol that any object storage backend must satisfy."""
+
+from pathlib import Path
+from typing import Protocol
+
+from pyetool.util.monad import Result
+
+
+class ObjStorageBackend(Protocol):
+    def put(self, file_path: Path | str, key: str) -> Result[str]:
+        ...
+
+    def get(self, key: str, file_path: Path | str) -> Result[Path]:
+        ...
+
+    def delete(self, key: str) -> Result[None]:
+        ...