cshortranslate 0.1.0__tar.gz

cshortranslate-0.1.0/.github/workflows/publish.yml

@@ -0,0 +1,45 @@
+name: Publish to PyPI
+
+on:
+  push:
+    tags:
+      - "v*"
+  workflow_dispatch:
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+
+      - name: Install build tools
+        run: pip install build
+
+      - name: Build package
+        run: python -m build
+
+      - name: Upload dist artifacts
+        uses: actions/upload-artifact@v4
+        with:
+          name: dist
+          path: dist/
+
+  publish:
+    needs: build
+    runs-on: ubuntu-latest
+    permissions:
+      id-token: write
+    steps:
+      - name: Download dist artifacts
+        uses: actions/download-artifact@v4
+        with:
+          name: dist
+          path: dist/
+
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1

cshortranslate-0.1.0/.gitignore

@@ -0,0 +1,21 @@
+__pycache__/
+*.py[cod]
+*$py.class
+*.egg-info/
+dist/
+build/
+*.egg
+.eggs/
+
+*.mp4
+*.avi
+*.mkv
+*.mov
+*.srt
+*.ass
+*.sub
+
+.env
+.venv
+venv/
+env/

cshortranslate-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Your Name
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

cshortranslate-0.1.0/PKG-INFO

@@ -0,0 +1,91 @@
+Metadata-Version: 2.4
+Name: cshortranslate
+Version: 0.1.0
+Summary: OCR-based subtitle extraction from video files
+Project-URL: Homepage, https://github.com/yourusername/cshortranslate
+Project-URL: Issues, https://github.com/yourusername/cshortranslate/issues
+Author-email: Your Name <you@example.com>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: chinese,ocr,srt,subtitle,video
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Multimedia :: Sound/Audio
+Classifier: Topic :: Multimedia :: Video
+Requires-Python: >=3.9
+Requires-Dist: numpy
+Requires-Dist: opencv-python
+Requires-Dist: rapidocr-onnxruntime
+Requires-Dist: tqdm
+Provides-Extra: all
+Requires-Dist: av; extra == 'all'
+Requires-Dist: degirum-video-capture; extra == 'all'
+Requires-Dist: ffmpegcv; extra == 'all'
+Provides-Extra: degirum
+Requires-Dist: degirum-video-capture; extra == 'degirum'
+Provides-Extra: ffmpegcv
+Requires-Dist: ffmpegcv; extra == 'ffmpegcv'
+Provides-Extra: pyav
+Requires-Dist: av; extra == 'pyav'
+Description-Content-Type: text/markdown
+
+# cshortranslate
+
+OCR-based subtitle extraction from video files. Designed for extracting Chinese subtitles from long drama videos.
+
+## Installation
+
+```bash
+pip install cshortranslate
+```
+
+For optional video backends:
+
+```bash
+pip install cshortranslate[pyav]      # PyAV backend
+pip install cshortranslate[ffmpegcv]  # ffmpegcv backend
+pip install cshortranslate[all]       # All backends
+```
+
+## Usage
+
+```bash
+cshortranslate video.mp4
+cshortranslate video.mp4 -o output.srt
+cshortranslate video.mp4 --fps 15 --region "bottom:20"
+cshortranslate video.mp4 --preview
+```
+
+### Options
+
+| Option | Description |
+|---|---|
+| `-o, --output` | Output SRT path (default: `<video>.srt`) |
+| `--fps` | Frame extraction rate (default: 10) |
+| `--region` | Subtitle region: `"bottom:15"` for bottom 15%, or `"x,y,w,h"` in pixels |
+| `--preview` | Show first frame with crop overlay for region selection |
+| `--backend` | Video backend: `opencv`, `pyav`, `ffmpegcv`, `degirum` |
+| `--batch-size` | Frames to OCR in parallel (default: 1) |
+| `--num-workers` | OCR worker threads (default: 1) |
+| `--min-chars` | Minimum characters to keep (default: 2) |
+| `--min-dur` | Minimum duration in seconds (default: 0.3) |
+
+## Requirements
+
+- Python 3.9+
+- `rapidocr-onnxruntime`
+- `opencv-python`
+- `tqdm`
+- `numpy`
+
+## License
+
+MIT

cshortranslate-0.1.0/README.md

@@ -0,0 +1,52 @@
+# cshortranslate
+
+OCR-based subtitle extraction from video files. Designed for extracting Chinese subtitles from long drama videos.
+
+## Installation
+
+```bash
+pip install cshortranslate
+```
+
+For optional video backends:
+
+```bash
+pip install cshortranslate[pyav]      # PyAV backend
+pip install cshortranslate[ffmpegcv]  # ffmpegcv backend
+pip install cshortranslate[all]       # All backends
+```
+
+## Usage
+
+```bash
+cshortranslate video.mp4
+cshortranslate video.mp4 -o output.srt
+cshortranslate video.mp4 --fps 15 --region "bottom:20"
+cshortranslate video.mp4 --preview
+```
+
+### Options
+
+| Option | Description |
+|---|---|
+| `-o, --output` | Output SRT path (default: `<video>.srt`) |
+| `--fps` | Frame extraction rate (default: 10) |
+| `--region` | Subtitle region: `"bottom:15"` for bottom 15%, or `"x,y,w,h"` in pixels |
+| `--preview` | Show first frame with crop overlay for region selection |
+| `--backend` | Video backend: `opencv`, `pyav`, `ffmpegcv`, `degirum` |
+| `--batch-size` | Frames to OCR in parallel (default: 1) |
+| `--num-workers` | OCR worker threads (default: 1) |
+| `--min-chars` | Minimum characters to keep (default: 2) |
+| `--min-dur` | Minimum duration in seconds (default: 0.3) |
+
+## Requirements
+
+- Python 3.9+
+- `rapidocr-onnxruntime`
+- `opencv-python`
+- `tqdm`
+- `numpy`
+
+## License
+
+MIT

cshortranslate-0.1.0/cshortranslate/__init__.py

@@ -0,0 +1,3 @@
+"""OCR-based subtitle extraction from video files."""
+
+__version__ = "0.1.0"

cshortranslate-0.1.0/cshortranslate/cli.py

@@ -0,0 +1,158 @@
+import argparse
+import os
+import sys
+
+import cv2
+from tqdm import tqdm
+
+from cshortranslate.ocr_engine import OCREngine
+from cshortranslate.video_processor import VideoProcessor
+from cshortranslate.subtitle_generator import deduplicate, filter_entries, format_srt
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(
+        description="OCR Chinese subtitles from long drama videos"
+    )
+    parser.add_argument("video", help="Path to the video file")
+    parser.add_argument("-o", "--output", help="Output SRT path (default: <video>.srt)")
+    parser.add_argument("--fps", type=int, default=10, help="Frame extraction rate (default: 10)")
+    parser.add_argument(
+        "--region",
+        default=None,
+        help='Subtitle region: "bottom:15" for bottom 15%%, or "x,y,w,h" in pixels',
+    )
+    parser.add_argument(
+        "--preview", action="store_true", help="Show first frame with crop overlay"
+    )
+    parser.add_argument("--lang", default="ch", help="OCR language (default: ch)")
+    parser.add_argument("--min-chars", type=int, default=2, help="Min characters to keep (default: 2)")
+    parser.add_argument("--min-dur", type=float, default=0.3, help="Min duration in seconds (default: 0.3)")
+    parser.add_argument(
+        "--backend",
+        choices=["opencv", "pyav", "ffmpegcv", "degirum"],
+        default="opencv",
+        help="Video decoding backend (default: opencv)",
+    )
+    parser.add_argument("--batch-size", type=int, default=1, help="Number of frames to OCR in parallel (default: 1)")
+    parser.add_argument("--num-workers", type=int, default=1, help="OCR worker threads (default: 1)")
+    return parser.parse_args()
+
+
+def show_preview(video):
+    frame = video.get_preview_frame()
+    if frame is None:
+        print("Error: Could not read preview frame")
+        sys.exit(1)
+
+    region = None
+
+    def mouse_cb(event, x, y, flags, param):
+        nonlocal region
+        if event == cv2.EVENT_LBUTTONDOWN:
+            region = (x, y)
+
+    cv2.namedWindow("Preview - Press ENTER to confirm, ESC to cancel", cv2.WINDOW_NORMAL)
+    cv2.setMouseCallback("Preview - Press ENTER to confirm, ESC to cancel", mouse_cb)
+
+    clone = frame.copy()
+    print("Click on the TOP-LEFT corner of the subtitle region, then press ENTER")
+
+    while True:
+        display = clone.copy()
+        if region:
+            h, w = frame.shape[:2]
+            cv2.rectangle(display, (region[0], region[1]), (w, h), (0, 0, 255), 2)
+        cv2.imshow("Preview - Press ENTER to confirm, ESC to cancel", display)
+        key = cv2.waitKey(30) & 0xFF
+        if key == 13:  # ENTER
+            break
+        elif key == 27:  # ESC
+            region = None
+            break
+
+    cv2.destroyAllWindows()
+
+    if region:
+        h, w = frame.shape[:2]
+        return f"{region[0]},{region[1]},{w - region[0]},{h - region[1]}"
+    return None
+
+
+def main():
+    args = parse_args()
+
+    if not os.path.isfile(args.video):
+        print(f"Error: File not found: {args.video}")
+        sys.exit(1)
+
+    output_path = args.output or os.path.splitext(args.video)[0] + ".srt"
+
+    video = VideoProcessor(args.video, fps=args.fps, backend=args.backend)
+    print(f"Video: {args.video}")
+    print(f"Resolution: {video.width}x{video.height}")
+    print(f"Duration: {video.duration:.1f}s | FPS: {video.video_fps:.1f}")
+    print(f"Extracting at {args.fps} FPS -> {video.get_total_snapshots()} frames")
+
+    region = args.region
+    if args.preview:
+        region = show_preview(video)
+        if region is None:
+            print("No region selected. Using full frame.")
+        else:
+            print(f"Selected region: {region}")
+
+    print(f"Subtitle region: {region or 'full frame (not recommended)'}")
+    print("Running OCR...")
+
+    ocr = OCREngine(num_workers=args.num_workers)
+    entries = []
+
+    try:
+        frame_duration = 1.0 / video.video_fps
+        batch_size = args.batch_size
+        batch_images = []
+        batch_timestamps = []
+
+        for frame, timestamp in tqdm(video.iter_frames(), total=video.get_total_snapshots(), unit="frame"):
+            cropped = video.crop_subtitle_region(frame, region)
+            batch_images.append(cropped)
+            batch_timestamps.append(timestamp)
+
+            if len(batch_images) >= batch_size:
+                texts = ocr.run_batch(batch_images)
+                for text, ts in zip(texts, batch_timestamps):
+                    if text:
+                        entries.append({"text": text, "start": ts, "end": ts + frame_duration})
+                batch_images.clear()
+                batch_timestamps.clear()
+
+        if batch_images:
+            texts = ocr.run_batch(batch_images)
+            for text, ts in zip(texts, batch_timestamps):
+                if text:
+                    entries.append({"text": text, "start": ts, "end": ts + frame_duration})
+    except KeyboardInterrupt:
+        print("\nInterrupted. Saving partial results...")
+    finally:
+        video.release()
+
+    if not entries:
+        print("No subtitles detected.")
+        sys.exit(0)
+
+    print(f"Deduplicating {len(entries)} raw entries...")
+    merged = deduplicate(entries)
+    print(f"Merged to {len(merged)} subtitle blocks")
+    filtered = filter_entries(merged, min_chars=args.min_chars, min_dur=args.min_dur)
+    print(f"After filtering: {len(filtered)} entries")
+
+    srt = format_srt(merged)
+    with open(output_path, "w", encoding="utf-8") as f:
+        f.write(srt)
+
+    print(f"Saved: {output_path}")
+
+
+if __name__ == "__main__":
+    main()

cshortranslate-0.1.0/cshortranslate/ocr_engine.py

@@ -0,0 +1,38 @@
+from concurrent.futures import ThreadPoolExecutor, as_completed
+
+from rapidocr_onnxruntime import RapidOCR
+
+
+class OCREngine:
+    def __init__(self, num_workers=1):
+        self.num_workers = num_workers
+        self._engines = [RapidOCR() for _ in range(num_workers)]
+
+    def run(self, image):
+        result, _ = self._engines[0](image)
+        if not result:
+            return ""
+        texts = [item[1] for item in result]
+        return "\n".join(texts)
+
+    def run_batch(self, images):
+        if self.num_workers == 1:
+            return [self.run(img) for img in images]
+
+        results = [None] * len(images)
+        with ThreadPoolExecutor(max_workers=self.num_workers) as executor:
+            future_to_idx = {
+                executor.submit(self._ocr_single, idx, img): idx
+                for idx, img in enumerate(images)
+            }
+            for future in as_completed(future_to_idx):
+                idx, text = future.result()
+                results[idx] = text
+        return results
+
+    def _ocr_single(self, idx, image):
+        result, _ = self._engines[idx % self.num_workers](image)
+        if not result:
+            return idx, ""
+        texts = [item[1] for item in result]
+        return idx, "\n".join(texts)

cshortranslate-0.1.0/cshortranslate/subtitle_generator.py

@@ -0,0 +1,68 @@
+import re
+from difflib import SequenceMatcher
+
+TIMESTAMP_RE = re.compile(
+    r"^\s*\d{1,2}\s*:\s*\d{2}\s*/\s*\d{1,2}\s*:\s*\d{2}\s*$"
+    r"|^\s*\d{1,2}\s*:\s*\d{2}\s*:\s*\d{2}\s*/\s*\d{1,2}\s*:\s*\d{2}\s*:\s*\d{2}\s*$"
+    r"|^\s*\d{1,2}\s*:\s*\d{2}\s*/\s*\d{2}\s*$"
+)
+
+
+def is_noise(text):
+    return bool(TIMESTAMP_RE.match(text.strip()))
+
+
+def filter_entries(entries, min_chars=2, min_dur=0.3):
+    result = []
+    for e in entries:
+        text = e["text"].strip()
+        if not text:
+            continue
+        if is_noise(text):
+            continue
+        if len(text) < min_chars:
+            continue
+        if (e["end"] - e["start"]) < min_dur:
+            continue
+        result.append(e)
+    return result
+
+
+def deduplicate(entries, threshold=0.85, max_gap=2.0):
+    if not entries:
+        return []
+    merged = [entries[0]]
+    for entry in entries[1:]:
+        prev = merged[-1]
+        cur_text = entry["text"]
+        if not cur_text:
+            continue
+        gap = entry["start"] - prev["end"]
+        if gap > max_gap:
+            merged.append(entry)
+            continue
+        similarity = SequenceMatcher(None, prev["text"], cur_text).ratio()
+        if similarity >= threshold:
+            prev["end"] = entry["end"]
+            prev["text"] = prev["text"] if len(prev["text"]) >= len(cur_text) else cur_text
+        else:
+            merged.append(entry)
+    return merged
+
+
+def format_srt(entries):
+    lines = []
+    for i, entry in enumerate(entries, 1):
+        lines.append(str(i))
+        lines.append(f"{_ts(entry['start'])} --> {_ts(entry['end'])}")
+        lines.append(entry["text"])
+        lines.append("")
+    return "\n".join(lines)
+
+
+def _ts(seconds):
+    h = int(seconds // 3600)
+    m = int((seconds % 3600) // 60)
+    s = int(seconds % 60)
+    ms = int((seconds - int(seconds)) * 1000)
+    return f"{h:02d}:{m:02d}:{s:02d},{ms:03d}"

cshortranslate-0.1.0/cshortranslate/video_processor.py

@@ -0,0 +1,149 @@
+import cv2
+import numpy as np
+
+
+class VideoProcessor:
+    def __init__(self, video_path, fps=10, backend="opencv"):
+        self.video_path = video_path
+        self.fps = fps
+        self.backend = backend
+        self._backend_obj = None
+
+        if backend == "pyav":
+            self._init_pyav()
+        elif backend == "ffmpegcv":
+            self._init_ffmpegcv()
+        elif backend == "degirum":
+            self._init_degirum()
+        else:
+            self._init_opencv()
+
+    def _init_opencv(self):
+        self.cap = cv2.VideoCapture(self.video_path)
+        self.video_fps = self.cap.get(cv2.CAP_PROP_FPS)
+        self.total_frames = int(self.cap.get(cv2.CAP_PROP_FRAME_COUNT))
+        self.width = int(self.cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+        self.height = int(self.cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+        self.duration = self.total_frames / self.video_fps
+        self._step = self.video_fps / self.fps
+
+    def _init_pyav(self):
+        import av
+
+        self._av_container = av.open(self.video_path)
+        stream = self._av_container.streams.video[0]
+        self.video_fps = float(stream.average_rate or stream.rate)
+        self.total_frames = stream.frames or int(stream.duration * stream.time_base * self.video_fps)
+        self.width = stream.codec_context.width
+        self.height = stream.codec_context.height
+        self.duration = self.total_frames / self.video_fps
+        self._step = self.video_fps / self.fps
+        self._av_stream = stream
+
+    def _init_ffmpegcv(self):
+        import ffmpegcv
+
+        self.cap = ffmpegcv.VideoCapture(self.video_path)
+        self.video_fps = self.cap.fps
+        self.total_frames = self.cap.framecount
+        self.width = self.cap.width
+        self.height = self.cap.height
+        self.duration = self.total_frames / self.video_fps
+        self._step = self.video_fps / self.fps
+
+    def _init_degirum(self):
+        import degirum_video_capture
+
+        self.cap = degirum_video_capture.VideoCapture(self.video_path)
+        self.video_fps = self.cap.get(cv2.CAP_PROP_FPS)
+        self.total_frames = int(self.cap.get(cv2.CAP_PROP_FRAME_COUNT))
+        self.width = int(self.cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+        self.height = int(self.cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+        self.duration = self.total_frames / self.video_fps
+        self._step = self.video_fps / self.fps
+
+    def get_preview_frame(self):
+        if self.backend == "pyav":
+            container = self._av_container
+            stream = self._av_stream
+            container.seek(0, stream=stream)
+            for frame in container.decode(video=0):
+                return frame.to_ndarray(format="bgr24")
+            return None
+        else:
+            self.cap.set(cv2.CAP_PROP_POS_FRAMES, 0)
+            ret, frame = self.cap.read()
+            return frame if ret else None
+
+    def crop_subtitle_region(self, frame, region):
+        if region is None:
+            return frame
+        h, w = frame.shape[:2]
+        if isinstance(region, str) and region.startswith("bottom:"):
+            pct = int(region.split(":")[1])
+            y_start = int(h * (100 - pct) / 100)
+            return frame[y_start:, :]
+        parts = [int(p) for p in region.split(",")]
+        x, y, rw, rh = parts
+        return frame[y : y + rh, x : x + rw]
+
+    def iter_frames(self):
+        if self.backend == "pyav":
+            yield from self._iter_pyav()
+        elif self.backend == "ffmpegcv":
+            yield from self._iter_opencv_compat()
+        elif self.backend == "degirum":
+            yield from self._iter_opencv_compat()
+        else:
+            yield from self._iter_opencv()
+
+    def _iter_opencv(self):
+        self.cap.set(cv2.CAP_PROP_POS_FRAMES, 0)
+        frame_idx = 0
+        next_yield = 0.0
+        while True:
+            ret, frame = self.cap.read()
+            if not ret:
+                break
+            if frame_idx >= next_yield:
+                yield frame, frame_idx / self.video_fps
+                next_yield += self._step
+            frame_idx += 1
+
+    def _iter_pyav(self):
+        import av
+
+        container = self._av_container
+        stream = self._av_stream
+        container.seek(0, stream=stream)
+
+        frame_idx = 0
+        next_yield = 0.0
+        for frame in container.decode(video=0):
+            if frame_idx >= next_yield:
+                ndarray = frame.to_ndarray(format="bgr24")
+                yield ndarray, frame_idx / self.video_fps
+                next_yield += self._step
+            frame_idx += 1
+
+    def _iter_opencv_compat(self):
+        self.cap.set(cv2.CAP_PROP_POS_FRAMES, 0)
+        frame_idx = 0
+        next_yield = 0.0
+        while True:
+            ret, frame = self.cap.read()
+            if not ret:
+                break
+            if frame_idx >= next_yield:
+                yield frame, frame_idx / self.video_fps
+                next_yield += self._step
+            frame_idx += 1
+
+    def get_total_snapshots(self):
+        return int(self.total_frames / self._step)
+
+    def release(self):
+        if self.backend == "pyav":
+            self._av_container.close()
+        elif hasattr(self, "cap"):
+            self.cap.release()

cshortranslate-0.1.0/pyproject.toml

@@ -0,0 +1,48 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "cshortranslate"
+version = "0.1.0"
+description = "OCR-based subtitle extraction from video files"
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.9"
+authors = [
+    { name = "Your Name", email = "you@example.com" },
+]
+keywords = ["ocr", "subtitle", "srt", "video", "chinese"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Multimedia :: Video",
+    "Topic :: Multimedia :: Sound/Audio",
+]
+dependencies = [
+    "rapidocr-onnxruntime",
+    "opencv-python",
+    "tqdm",
+    "numpy",
+]
+
+[project.optional-dependencies]
+pyav = ["av"]
+ffmpegcv = ["ffmpegcv"]
+degirum = ["degirum-video-capture"]
+all = ["av", "ffmpegcv", "degirum-video-capture"]
+
+[project.urls]
+Homepage = "https://github.com/yourusername/cshortranslate"
+Issues = "https://github.com/yourusername/cshortranslate/issues"
+
+[project.scripts]
+cshortranslate = "cshortranslate.cli:main"