Update SRT Processing Tool - Convert to Gradio for HF Spaces

.gitignore

@@ -0,0 +1,196 @@
+output
+
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# UV
+#   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#uv.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/latest/usage/project/#working-with-version-control
+.pdm.toml
+.pdm-python
+.pdm-build/
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+# Abstra
+# Abstra is an AI-powered process automation framework.
+# Ignore directories containing user credentials, local state, and settings.
+# Learn more at https://abstra.io/docs
+.abstra/
+
+# Visual Studio Code
+#  Visual Studio Code specific template is maintained in a separate VisualStudioCode.gitignore 
+#  that can be found at https://github.com/github/gitignore/blob/main/Global/VisualStudioCode.gitignore
+#  and can be added to the global gitignore or merged into this file. However, if you prefer, 
+#  you could uncomment the following to ignore the enitre vscode folder
+# .vscode/
+
+# Ruff stuff:
+.ruff_cache/
+
+# PyPI configuration file
+.pypirc
+
+# Cursor
+#  Cursor is an AI-powered code editor. `.cursorignore` specifies files/directories to
+#  exclude from AI features like autocomplete and code analysis. Recommended for sensitive data
+#  refer to https://docs.cursor.com/context/ignore-files
+.cursorignore
+.cursorindexingignore

README.md

@@ -1,14 +1,164 @@
 ---
 title: SRT Processing Tool
-emoji: ⚡
-colorFrom: green
-colorTo: gray
+emoji: 🎬
+colorFrom: blue
+colorTo: purple
 sdk: gradio
-sdk_version: 6.4.0
+sdk_version: 4.0.0
 app_file: app.py
 pinned: false
-license: apache-2.0
-short_description: A production-ready web application for processing SRT subtit
+license: mit
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# 🎬 SRT Processing Tool
+
+A production-ready web application for processing SRT subtitle files, powered by Gradio and ready for Hugging Face Spaces.
+
+**Resegment and translate your subtitle files easily in your browser!**
+
+## ✨ Features
+
+- **🔄 SRT Resegmentation**: Optimize subtitle segments by character limits, respecting punctuation boundaries
+- **🌍 SRT Translation**: Translate subtitle files using AI (OpenAI, Aliyun DashScope, or OpenRouter)
+- **⚡ Automatic Resegmentation**: Translation automatically includes resegmentation for optimal chunk sizes
+- **🚀 Production Ready**: Optimized for Hugging Face Spaces deployment
+
+## 🚀 Live Demo
+
+**Try it live:** [https://huggingface.co/spaces/BiliSakura/SRT-Processing-Tool](https://huggingface.co/spaces/BiliSakura/SRT-Processing-Tool)
+
+This app is deployed on Hugging Face Spaces! To deploy your own version:
+
+1. Fork this repository
+2. Go to [Hugging Face Spaces](https://huggingface.co/spaces)
+3. Create a new Space
+4. Connect your GitHub repository
+5. Select Gradio as the SDK
+6. Set the app file to `app.py`
+7. Add your API keys as secrets (see below)
+8. Deploy!
+
+## 🔑 API Keys Configuration
+
+For translation features, add your API keys as secrets in Hugging Face Spaces:
+
+1. Go to your Space settings
+2. Navigate to "Variables and secrets"
+3. Add the following secrets:
+
+### Required Secrets (choose based on provider):
+
+- **Aliyun DashScope**: `DASHSCOPE_API_KEY`
+- **OpenAI**: `OPENAI_API_KEY`
+- **OpenRouter**: `OPENROUTER_API_KEY`
+
+### Optional Secrets (for OpenRouter attribution):
+
+- `OPENROUTER_SITE_URL` (maps to `HTTP-Referer`)
+- `OPENROUTER_APP_TITLE` (maps to `X-Title`)
+
+## 📦 Local Installation
+
+```bash
+# Clone the repository
+git clone https://huggingface.co/spaces/BiliSakura/SRT-Processing-Tool
+cd SRT-Processing-Tool
+
+# Create virtual environment
+python -m venv venv
+source venv/bin/activate  # On Windows: venv\Scripts\activate
+
+# Install dependencies
+pip install -r requirements.txt
+```
+
+## 🏃 Local Run
+
+```bash
+python app.py
+```
+
+The app will be available at `http://localhost:7860`
+
+## 📖 Usage
+
+1. Open the app in your browser
+2. Upload your SRT file
+3. Choose operation:
+   - **Translate only**: Translate subtitles to target language
+   - **Resegment only**: Optimize subtitle segments by character limits
+4. Configure settings:
+   - **Translation Settings**: Target language, provider, model, workers
+   - **Resegmentation Settings**: Maximum characters per segment
+5. Click "🚀 Process SRT File"
+6. Download your processed file!
+
+## 🔧 Configuration
+
+### Default Models
+
+- **OpenAI**: `gpt-4.1` (uses Responses API)
+- **Aliyun DashScope**: `qwen-max`
+- **OpenRouter**: `openai/gpt-4o`
+
+### Environment Variables
+
+You can also use a `.env` file for local development:
+
+```env
+# Aliyun DashScope
+DASHSCOPE_API_KEY=your_key_here
+
+# OpenAI
+OPENAI_API_KEY=your_key_here
+
+# OpenRouter
+OPENROUTER_API_KEY=your_key_here
+OPENROUTER_SITE_URL=https://your-site.com
+OPENROUTER_APP_TITLE=Your App Title
+
+# Optional: override model for all providers
+MODEL=your_model_name
+```
+
+## 💻 CLI Usage
+
+You can also use the SRT processor from the command line:
+
+```bash
+# Resegment only
+python tools/srt_processor.py input.srt output.srt --operation resegment --max-chars 125
+
+# Translate (OpenAI)
+python tools/srt_processor.py input.srt output.srt --operation translate --target-lang zh --provider openai --model gpt-4.1 --workers 5
+
+# Translate (OpenRouter)
+python tools/srt_processor.py input.srt output.srt --operation translate --target-lang zh --provider openrouter --model openai/gpt-4o --workers 5
+
+# Translate (DashScope)
+python tools/srt_processor.py input.srt output.srt --operation translate --target-lang zh --provider dashscope --model qwen-max --workers 5
+```
+
+## 🏗️ Project Structure
+
+```
+.
+├── app.py                 # Main Gradio application
+├── tools/
+│   ├── __init__.py
+│   └── srt_processor.py   # Core SRT processing logic
+├── requirements.txt       # Python dependencies
+└── README.md             # This file
+```
+
+## 📝 License
+
+MIT License
+
+## 🤝 Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+---
+
+**Made with ❤️ for subtitle processing**

app.py

@@ -0,0 +1,302 @@
+"""
+SRT Processing Tool - Gradio Interface
+Production-ready for Hugging Face Spaces
+"""
+
+import os
+import tempfile
+import gradio as gr
+from tools import process_srt_file
+from dotenv import load_dotenv
+
+# Load environment variables from .env if present
+load_dotenv(override=True)
+
+
+def process_srt_interface(
+    file_path,
+    operation,
+    target_lang,
+    provider,
+    model,
+    workers,
+    max_chars,
+):
+    """
+    Process SRT file based on user inputs.
+    
+    Args:
+        file_path: Path to uploaded file from Gradio
+        operation: "translate" or "resegment"
+        target_lang: Target language code (for translation)
+        provider: Translation provider ("Aliyun (DashScope)", "OpenAI", "OpenRouter")
+        model: Model name (optional)
+        workers: Number of concurrent workers
+        max_chars: Maximum characters per segment
+    
+    Returns:
+        Tuple of (output_file_path, success_message)
+    """
+    if file_path is None:
+        return None, "❌ Please upload an SRT file first."
+    
+    try:
+        # Map provider names to internal router values
+        provider_map = {
+            "Aliyun (DashScope)": "dashscope",
+            "OpenAI": "openai",
+            "OpenRouter": "openrouter",
+        }
+        router = provider_map.get(provider, "dashscope")
+        
+        # Map operation names to internal values
+        operation_map = {
+            "Translate only": "translate",
+            "Resegment only": "resegment",
+        }
+        operation_value = operation_map.get(operation, "resegment")
+        
+        # Validate inputs
+        if operation_value == "translate" and not target_lang:
+            return None, "❌ Target language is required for translation."
+        
+        # Use the uploaded file path directly
+        temp_input_path = file_path
+        
+        # Create temporary output file
+        with tempfile.NamedTemporaryFile(delete=False, suffix=".srt") as temp_output:
+            temp_output_path = temp_output.name
+        
+        # Process the file
+        process_srt_file(
+            temp_input_path,
+            temp_output_path,
+            operation=operation_value,
+            max_chars=int(max_chars),
+            target_lang=target_lang if operation_value == "translate" else None,
+            model=model if model else None,
+            workers=int(workers),
+            router=router,
+        )
+        
+        # Generate output filename
+        input_filename = os.path.splitext(os.path.basename(file_path))[0]
+        if operation_value == "translate":
+            output_filename = f"{input_filename}_{target_lang}.srt"
+        else:
+            output_filename = f"{input_filename}_resentenced.srt"
+        
+        # Read the output file and create download file
+        with open(temp_output_path, "r", encoding="utf-8") as f:
+            output_content = f.read()
+        
+        # Create a temporary file for download with proper name
+        download_dir = tempfile.gettempdir()
+        download_path = os.path.join(download_dir, output_filename)
+        with open(download_path, "w", encoding="utf-8") as download_file:
+            download_file.write(output_content)
+        
+        # Clean up temporary output file
+        try:
+            os.remove(temp_output_path)
+        except Exception:
+            pass
+        
+        success_msg = f"✅ Processing complete! ({operation})"
+        return download_path, success_msg
+        
+    except Exception as e:
+        # Clean up on error
+        try:
+            if "temp_output_path" in locals():
+                os.remove(temp_output_path)
+        except Exception:
+            pass
+        return None, f"❌ Processing failed: {str(e)}"
+
+
+def create_interface():
+    """Create and configure the Gradio interface."""
+    
+    with gr.Blocks(title="SRT Processing Tool", theme=gr.themes.Soft()) as app:
+        gr.Markdown(
+            """
+            # 🎬 SRT Processing Tool
+            
+            Process and translate your subtitle files with AI-powered tools!
+            
+            **Features:**
+            - 🔄 **Resegment** SRT files to optimize character limits per segment
+            - 🌍 **Translate** SRT files using AI (OpenAI, Aliyun DashScope, or OpenRouter)
+            - ⚡ **Automatic Resegmentation**: Translation automatically includes resegmentation for optimal chunk sizes
+            """
+        )
+        
+        with gr.Row():
+            with gr.Column(scale=1):
+                gr.Markdown("### 📤 Upload & Settings")
+                
+                uploaded_file = gr.File(
+                    label="Upload SRT File",
+                    file_types=[".srt"],
+                    type="filepath",
+                )
+                
+                operation = gr.Radio(
+                    label="Processing Operation",
+                    choices=["Translate only", "Resegment only"],
+                    value="Translate only",
+                    info="Choose what operation to perform on the SRT file",
+                )
+                
+                with gr.Accordion("Translation Settings", open=True, visible=True) as translation_accordion:
+                    target_lang = gr.Textbox(
+                        label="Target Language Code",
+                        placeholder="e.g., fr, es, de, zh",
+                        value="zh",
+                        info="ISO language code for translation",
+                    )
+                    
+                    provider = gr.Dropdown(
+                        label="Translation Provider",
+                        choices=["Aliyun (DashScope)", "OpenAI", "OpenRouter"],
+                        value="Aliyun (DashScope)",
+                        info="Choose the translation provider",
+                    )
+                    
+                    model = gr.Textbox(
+                        label="Model Name",
+                        placeholder="Leave blank for default",
+                        value="qwen-max",
+                        info="Model to use (defaults: qwen-max for DashScope, gpt-4.1 for OpenAI, openai/gpt-4o for OpenRouter)",
+                    )
+                    
+                    workers = gr.Slider(
+                        label="Concurrent Workers",
+                        minimum=1,
+                        maximum=50,
+                        value=25,
+                        step=1,
+                        info="Number of parallel translation requests",
+                    )
+                
+                with gr.Accordion("Resegmentation Settings", open=True) as resegment_accordion:
+                    max_chars = gr.Slider(
+                        label="Maximum Characters per Segment",
+                        minimum=10,
+                        maximum=500,
+                        value=125,
+                        step=5,
+                        info="Controls how the SRT is resegmented before translation",
+                    )
+                
+                process_btn = gr.Button("🚀 Process SRT File", variant="primary", size="lg")
+                
+                info_box = gr.Markdown(
+                    """
+                    **ℹ️ Note:** Translation automatically includes resegmentation for optimal chunk sizes.
+                    
+                    **API Keys:** Set these as secrets in Hugging Face Spaces:
+                    - `DASHSCOPE_API_KEY` for Aliyun DashScope
+                    - `OPENAI_API_KEY` for OpenAI
+                    - `OPENROUTER_API_KEY` for OpenRouter
+                    """
+                )
+            
+            with gr.Column(scale=1):
+                gr.Markdown("### 📥 Results")
+                
+                status_output = gr.Textbox(
+                    label="Status",
+                    interactive=False,
+                    value="Waiting for file upload...",
+                )
+                
+                output_file = gr.File(
+                    label="Download Processed SRT",
+                    visible=False,
+                )
+        
+        # Update UI visibility based on operation
+        def update_ui(selected_operation):
+            """Update UI components visibility based on selected operation."""
+            if selected_operation == "Translate only":
+                return (
+                    gr.update(visible=True, open=True),  # translation_accordion
+                    gr.update(visible=True, open=True),  # resegment_accordion
+                    gr.update(value="qwen-max"),  # model default
+                )
+            else:  # Resegment only
+                return (
+                    gr.update(visible=False),  # translation_accordion
+                    gr.update(visible=True, open=True),  # resegment_accordion
+                    gr.update(value=""),  # model empty
+                )
+        
+        operation.change(
+            fn=update_ui,
+            inputs=[operation],
+            outputs=[translation_accordion, resegment_accordion, model],
+        )
+        
+        # Update model placeholder based on provider
+        def update_model_placeholder(selected_provider):
+            """Update model placeholder text based on provider."""
+            defaults = {
+                "Aliyun (DashScope)": "qwen-max",
+                "OpenAI": "gpt-4.1",
+                "OpenRouter": "openai/gpt-4o",
+            }
+            return gr.update(value=defaults.get(selected_provider, ""))
+        
+        provider.change(
+            fn=update_model_placeholder,
+            inputs=[provider],
+            outputs=[model],
+        )
+        
+        # Process button click handler
+        def handle_process(file_path, op, lang, prov, mod, wrk, chars):
+            """Handle the process button click."""
+            result_file, message = process_srt_interface(
+                file_path, op, lang, prov, mod, wrk, chars
+            )
+            
+            if result_file:
+                return (
+                    gr.update(value=message, visible=True),
+                    gr.update(value=result_file, visible=True, label=f"Download: {os.path.basename(result_file)}")
+                )
+            else:
+                return (
+                    gr.update(value=message, visible=True),
+                    gr.update(visible=False)
+                )
+        
+        process_btn.click(
+            fn=handle_process,
+            inputs=[uploaded_file, operation, target_lang, provider, model, workers, max_chars],
+            outputs=[status_output, output_file],
+        )
+        
+        # Update status when file is uploaded
+        uploaded_file.change(
+            fn=lambda x: gr.update(value="✅ File uploaded! Configure settings and click 'Process SRT File'.") if x else gr.update(value="Waiting for file upload..."),
+            inputs=[uploaded_file],
+            outputs=[status_output],
+        )
+    
+    return app
+
+
+# Create the Gradio interface
+demo = create_interface()
+
+# For Hugging Face Spaces, expose the demo variable
+# For local development, launch the app
+if __name__ == "__main__":
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=False,
+    )

requirements.txt

@@ -0,0 +1,3 @@
+gradio>=4.0.0
+openai>=1.0.0
+python-dotenv>=1.0.0

tools/__init__.py

@@ -0,0 +1 @@
+from .srt_processor import translate_srt, resegment_srt, process_srt_file

tools/srt_processor.py

@@ -0,0 +1,586 @@
+"""
+Unified SRT processing module combining resegmentation and translation functionality.
+"""
+
+import os
+import re
+import concurrent.futures
+from typing import List, Tuple, Optional
+from dotenv import load_dotenv
+from openai import OpenAI
+
+# Load environment variables from .env if present
+load_dotenv(override=True)
+
+
+# ============================================================================
+# Core SRT Utilities
+# ============================================================================
+
+
+def read_srt(file_path: str) -> str:
+    """Read SRT file content."""
+    with open(file_path, "r", encoding="utf-8") as f:
+        return f.read()
+
+
+def write_srt(file_path: str, content: str) -> None:
+    """Write content to SRT file."""
+    with open(file_path, "w", encoding="utf-8") as f:
+        f.write(content)
+
+
+def parse_srt_blocks(srt_content: str) -> List[Tuple[str, str, List[str]]]:
+    """
+    Parse SRT content into blocks.
+    Returns list of (index, time, text_lines).
+    """
+    blocks = re.split(r"\n\s*\n", srt_content.strip(), flags=re.MULTILINE)
+    parsed: List[Tuple[str, str, List[str]]] = []
+    for block in blocks:
+        lines = block.strip().splitlines()
+        if len(lines) < 3:
+            continue
+        index = lines[0].strip()
+        time_line = lines[1].strip()
+        text_lines = [line.rstrip() for line in lines[2:]]
+        parsed.append((index, time_line, text_lines))
+    return parsed
+
+
+def parse_srt_block(block: str) -> Optional[Tuple[str, str, List[str]]]:
+    """Parse a single SRT block."""
+    lines = block.strip().splitlines()
+    if len(lines) < 3:
+        return None
+    index = lines[0]
+    time = lines[1]
+    text_lines = lines[2:]
+    return index, time, text_lines
+
+
+def build_srt_block(index: int, start_time: str, end_time: str, text: str) -> str:
+    """Build SRT block with index, time range, and text."""
+    return f"{index}\n{start_time} --> {end_time}\n{text}"
+
+
+def build_srt_block_from_lines(index: str, time: str, text_lines: List[str]) -> str:
+    """Build SRT block from parsed components."""
+    return f"{index}\n{time}\n" + "\n".join(text_lines)
+
+
+# ============================================================================
+# Time Utilities
+# ============================================================================
+
+
+def extract_times(time_line: str) -> Tuple[str, str]:
+    """Extract start and end times from time line."""
+    # Expected format: HH:MM:SS,mmm --> HH:MM:SS,mmm
+    parts = [p.strip() for p in time_line.split("-->")]
+    if len(parts) != 2:
+        raise ValueError(f"Invalid time line: {time_line}")
+    return parts[0], parts[1]
+
+
+def time_str_to_ms(t: str) -> int:
+    """Convert time string to milliseconds."""
+    # HH:MM:SS,mmm
+    hms, ms = t.split(",")
+    hours, minutes, seconds = hms.split(":")
+    total_ms = (
+        int(hours) * 3600 * 1000
+        + int(minutes) * 60 * 1000
+        + int(seconds) * 1000
+        + int(ms)
+    )
+    return total_ms
+
+
+def ms_to_time_str(ms: int) -> str:
+    """Convert milliseconds to time string."""
+    if ms < 0:
+        ms = 0
+    hours = ms // (3600 * 1000)
+    ms %= 3600 * 1000
+    minutes = ms // (60 * 1000)
+    ms %= 60 * 1000
+    seconds = ms // 1000
+    millis = ms % 1000
+    return f"{hours:02d}:{minutes:02d}:{seconds:02d},{millis:03d}"
+
+
+# ============================================================================
+# Text Processing Utilities
+# ============================================================================
+
+
+def ends_with_preferred_punctuation(text: str) -> bool:
+    """Check if text ends with preferred punctuation."""
+    stripped = text.rstrip()
+    return stripped.endswith(".") or stripped.endswith(",")
+
+
+def normalize_whitespace(text: str) -> str:
+    """Normalize whitespace in text."""
+    return re.sub(r"\s+", " ", text).strip()
+
+
+def count_chars(text: str) -> int:
+    """Count characters including spaces after normalization."""
+    return len(text)
+
+
+def split_text_into_chunks_by_chars_with_punctuation(
+    text: str, max_chars: int
+) -> List[str]:
+    """Split text into chunks respecting punctuation boundaries."""
+    text = normalize_whitespace(text)
+    chunks: List[str] = []
+    i = 0
+    n = len(text)
+    while i < n:
+        remaining = text[i:]
+        if len(remaining) <= max_chars:
+            chunks.append(remaining.strip())
+            break
+        window = remaining[:max_chars]
+        # Prefer last '.' or ',' within the window
+        last_dot = window.rfind(".")
+        last_comma = window.rfind(",")
+        cut_at = max(last_dot, last_comma)
+        if cut_at != -1:
+            end = cut_at + 1
+        else:
+            # If no punctuation found, look for the last space to avoid cutting words
+            last_space = window.rfind(" ")
+            if last_space != -1:
+                end = last_space
+            else:
+                # If no space found, we have to cut at max_chars (single long word)
+                end = max_chars
+        chunk = remaining[:end].strip()
+        if chunk:
+            chunks.append(chunk)
+        i += end
+        # Skip any following spaces before next chunk
+        while i < n and text[i] == " ":
+            i += 1
+    return [c for c in chunks if c]
+
+
+# ============================================================================
+# Translation Functionality
+# ============================================================================
+
+
+def translate_text(
+    text: str, target_lang: str, model: str, router: str = "dashscope"
+) -> str:
+    """Translate text using specified provider."""
+    if router == "dashscope":
+        client = OpenAI(
+            api_key=os.getenv("DASHSCOPE_API_KEY"),
+            base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",
+        )
+        prompt = (
+            f"Translate the following subtitle text to {target_lang}. "
+            "Do not translate timestamps or numbers. Only translate the spoken text. "
+            "Return only the translated text, no explanations or formatting.\n\n"
+            f"{text}"
+        )
+        response = client.chat.completions.create(
+            model=model,
+            messages=[
+                {
+                    "role": "system",
+                    "content": "You are a helpful assistant that translates subtitles.",
+                },
+                {"role": "user", "content": prompt},
+            ],
+            temperature=0.3,
+            max_tokens=1024,
+        )
+        return response.choices[0].message.content.strip()
+
+    elif router == "openrouter":
+        client = OpenAI(
+            api_key=os.getenv("OPENROUTER_API_KEY"),
+            base_url="https://openrouter.ai/api/v1",
+        )
+        prompt = (
+            f"Translate the following subtitle text to {target_lang}. "
+            "Do not translate timestamps or numbers. Only translate the spoken text. "
+            "Return only the translated text, no explanations or formatting.\n\n"
+            f"{text}"
+        )
+        # Optional attribution headers
+        extra_headers = {}
+        referer = os.getenv("OPENROUTER_SITE_URL")
+        app_title = os.getenv("OPENROUTER_APP_TITLE")
+        if referer:
+            extra_headers["HTTP-Referer"] = referer
+        if app_title:
+            extra_headers["X-Title"] = app_title
+        response = client.chat.completions.create(
+            model=model,
+            messages=[
+                {
+                    "role": "system",
+                    "content": "You are a helpful assistant that translates subtitles.",
+                },
+                {"role": "user", "content": prompt},
+            ],
+            temperature=0.3,
+            max_tokens=1024,
+            extra_headers=extra_headers,
+        )
+        return response.choices[0].message.content.strip()
+
+    elif router == "openai":
+        client = OpenAI()
+        prompt = (
+            f"Translate the following subtitle text to {target_lang}. "
+            "Do not translate timestamps or numbers. Only translate the spoken text. "
+            "Return only the translated text, no explanations or formatting.\n\n"
+            f"{text}"
+        )
+        try:
+            # Use Responses API for newer models (e.g., gpt-4.1, gpt-4o)
+            if model and (model.startswith("gpt-4.1") or model.startswith("gpt-4o")):
+                response = client.responses.create(
+                    model=model,
+                    input=prompt,
+                    instructions="You are a helpful assistant that translates subtitles.",
+                    temperature=0.3,
+                    max_output_tokens=1024,
+                )
+                # Prefer helper if available
+                try:
+                    return response.output_text.strip()
+                except Exception:
+                    # Fallback parsing if helper is unavailable
+                    try:
+                        segments = []
+                        if hasattr(response, "output") and response.output:
+                            for content_item in response.output[0].content:
+                                text_val = getattr(content_item, "text", None)
+                                if text_val:
+                                    segments.append(text_val)
+                        if segments:
+                            return "\n".join(segments).strip()
+                    except Exception:
+                        pass
+                    return str(response).strip()
+            else:
+                # Backward compatibility: use Chat Completions for older models
+                response = client.chat.completions.create(
+                    model=model,
+                    messages=[
+                        {
+                            "role": "system",
+                            "content": "You are a helpful assistant that translates subtitles.",
+                        },
+                        {"role": "user", "content": prompt},
+                    ],
+                    temperature=0.3,
+                    max_tokens=1024,
+                )
+                return response.choices[0].message.content.strip()
+        except Exception as e:
+            # Last-resort fallback to ensure we return something
+            return str(e)
+    else:
+        return f"Unsupported provider: {router}"
+
+
+def translate_block(args: Tuple[str, str, str, str]) -> str:
+    """Translate a single SRT block."""
+    block, target_lang, model, router = args
+    parsed = parse_srt_block(block)
+    if not parsed:
+        return block
+    index, time, text_lines = parsed
+    text = "\n".join(text_lines)
+    if text.strip():
+        translated_text = translate_text(text, target_lang, model=model, router=router)
+        translated_text_lines = translated_text.splitlines() or [translated_text]
+    else:
+        translated_text_lines = text_lines
+    translated_block = build_srt_block_from_lines(index, time, translated_text_lines)
+    return translated_block
+
+
+def translate_srt(
+    input_path: str,
+    output_path: str,
+    target_lang: str,
+    model: Optional[str] = None,
+    workers: int = 15,
+    router: str = "dashscope",
+    max_chars: int = 125,
+) -> str:
+    """Translate SRT file using specified provider with resegmentation."""
+    # Check API keys based on router
+    if router == "openai":
+        api_key = os.getenv("OPENAI_API_KEY")
+        if not api_key:
+            raise RuntimeError(
+                "Error: OPENAI_API_KEY not found in environment variables."
+            )
+        if not model:
+            model = os.getenv("MODEL") or "gpt-4.1"
+    elif router == "openrouter":
+        openrouter_key = os.getenv("OPENROUTER_API_KEY")
+        if not openrouter_key:
+            raise RuntimeError(
+                "Error: OPENROUTER_API_KEY not found in environment variables."
+            )
+        if not model:
+            model = os.getenv("MODEL") or "openai/gpt-4o"
+    elif router == "dashscope":
+        dashscope_key = os.getenv("DASHSCOPE_API_KEY")
+        if not dashscope_key:
+            raise RuntimeError(
+                "Error: DASHSCOPE_API_KEY not found in environment variables."
+            )
+        if not model:
+            model = os.getenv("MODEL") or "qwen-max"
+    else:
+        raise RuntimeError(
+            f"Error: Unknown provider '{router}'. Expected one of: openai, openrouter, dashscope."
+        )
+
+    # First resegment the SRT to get optimal chunks for translation
+    srt_content = read_srt(input_path)
+    parsed_blocks = parse_srt_blocks(srt_content)
+    resegmented_blocks = resegment_blocks(parsed_blocks, max_chars)
+
+    # Now translate the resegmented blocks
+    block_args = [(block, target_lang, model, router) for block in resegmented_blocks]
+    translated_blocks = []
+    with concurrent.futures.ThreadPoolExecutor(max_workers=workers) as executor:
+        for translated_block in executor.map(translate_block, block_args):
+            translated_blocks.append(translated_block)
+    translated_content = "\n\n".join(translated_blocks)
+    write_srt(output_path, translated_content)
+    return output_path
+
+
+# ============================================================================
+# Resegmentation Functionality
+# ============================================================================
+
+
+def resegment_blocks(
+    parsed_blocks: List[Tuple[str, str, List[str]]], max_chars: int
+) -> List[str]:
+    """Resegment SRT blocks based on character limit."""
+    output_blocks: List[str] = []
+
+    current_index = 1
+    group_start_time: str = ""
+    group_end_time: str = ""
+    group_text_parts: List[str] = []
+    group_char_count = 0
+
+    def flush_group():
+        nonlocal current_index, group_start_time, group_end_time, group_text_parts, group_char_count
+        if group_char_count > 0 and group_text_parts:
+            block_text = normalize_whitespace(" ".join(group_text_parts))
+            output_blocks.append(
+                build_srt_block(
+                    current_index, group_start_time, group_end_time, block_text
+                )
+            )
+            current_index += 1
+            group_start_time = ""
+            group_end_time = ""
+            group_text_parts = []
+            group_char_count = 0
+
+    for _, time_line, text_lines in parsed_blocks:
+        start_time_str, end_time_str = extract_times(time_line)
+        start_ms = time_str_to_ms(start_time_str)
+        end_ms = time_str_to_ms(end_time_str)
+        duration_ms = max(0, end_ms - start_ms)
+
+        text = normalize_whitespace(" ".join(text_lines))
+        if not text:
+            continue
+
+        this_count = count_chars(text)
+
+        # If adding this block would exceed the limit, flush the current group first
+        if group_char_count > 0 and (group_char_count + this_count) > max_chars:
+            flush_group()
+
+        # If the single block itself exceeds max_chars, split it internally
+        if this_count > max_chars:
+            # Ensure any pending group is flushed before inserting split pieces
+            flush_group()
+            sub_texts = split_text_into_chunks_by_chars_with_punctuation(
+                text, max_chars
+            )
+            # Distribute timings proportionally by character count
+            total_chars = sum(count_chars(st) for st in sub_texts) or 1
+            accumulated_ms = 0
+            for idx, st in enumerate(sub_texts):
+                chars_in_chunk = count_chars(st) or 1
+                # compute chunk duration (last chunk takes remaining to avoid rounding drift)
+                if idx < len(sub_texts) - 1:
+                    chunk_ms = int(duration_ms * (chars_in_chunk / total_chars))
+                else:
+                    chunk_ms = max(0, duration_ms - accumulated_ms)
+                chunk_start_ms = start_ms + accumulated_ms
+                chunk_end_ms = chunk_start_ms + chunk_ms
+                accumulated_ms += chunk_ms
+
+                output_blocks.append(
+                    build_srt_block(
+                        current_index,
+                        ms_to_time_str(chunk_start_ms),
+                        ms_to_time_str(chunk_end_ms),
+                        st,
+                    )
+                )
+                current_index += 1
+            # Done with this overlong block
+            continue
+
+        # Otherwise, safe to merge this whole block into the group
+        if group_char_count == 0:
+            group_start_time = start_time_str
+        group_text_parts.append(text)
+        group_end_time = end_time_str
+        group_char_count += this_count
+
+        # Prefer flushing on punctuation at the end of this block
+        if ends_with_preferred_punctuation(text):
+            flush_group()
+        elif group_char_count >= max_chars:
+            flush_group()
+
+    # Flush any remaining group
+    if group_char_count > 0:
+        flush_group()
+
+    return output_blocks
+
+
+def resegment_srt(input_path: str, output_path: str, max_chars: int = 125) -> str:
+    """Resegment SRT file based on character limit."""
+    srt_content = read_srt(input_path)
+    parsed = parse_srt_blocks(srt_content)
+    merged_blocks = resegment_blocks(parsed, max_chars=max_chars)
+    output_content = "\n\n".join(merged_blocks) + "\n"
+    write_srt(output_path, output_content)
+    return output_path
+
+
+# ============================================================================
+# Combined Processing Functions
+# ============================================================================
+
+
+def process_srt_file(
+    input_path: str,
+    output_path: str,
+    operation: str = "resegment",
+    max_chars: int = 125,
+    target_lang: Optional[str] = None,
+    model: Optional[str] = None,
+    workers: int = 15,
+    router: str = "dashscope",
+) -> str:
+    """
+    Process SRT file with specified operation.
+
+    Args:
+        input_path: Path to input SRT file
+        output_path: Path to output SRT file
+        operation: "resegment" or "translate"
+        max_chars: Maximum characters per segment (for resegmentation)
+        target_lang: Target language code (for translation)
+        model: Model to use for translation
+        workers: Number of concurrent workers for translation
+        router: Translation provider ("dashscope", "openai", "openrouter")
+
+    Returns:
+        Path to output file
+    """
+    if operation == "resegment":
+        return resegment_srt(input_path, output_path, max_chars)
+    elif operation == "translate":
+        if not target_lang:
+            raise ValueError("target_lang is required for translation")
+        return translate_srt(
+            input_path, output_path, target_lang, model, workers, router, max_chars
+        )
+    else:
+        raise ValueError(
+            f"Unknown operation: {operation}. Must be 'resegment' or 'translate'"
+        )
+
+
+# ============================================================================
+# CLI Interface (for backward compatibility)
+# ============================================================================
+
+if __name__ == "__main__":
+    import argparse
+
+    parser = argparse.ArgumentParser(
+        description="Unified SRT processing tool for resegmentation and translation. Translation automatically includes resegmentation for optimal chunk sizes."
+    )
+    parser.add_argument("input", help="Input SRT file path")
+    parser.add_argument("output", help="Output SRT file path")
+    parser.add_argument(
+        "--operation",
+        choices=["resegment", "translate"],
+        default="resegment",
+        help="Operation to perform (default: resegment)",
+    )
+    parser.add_argument(
+        "--max-chars",
+        dest="max_chars",
+        type=int,
+        default=125,
+        help="Maximum characters per segment (default: 125)",
+    )
+    parser.add_argument(
+        "--target-lang", help="Target language code (e.g., fr, es, de, zh)"
+    )
+    parser.add_argument(
+        "--model", help="Model to use for translation (default: value of MODEL in .env)"
+    )
+    parser.add_argument(
+        "--workers",
+        type=int,
+        default=25,
+        help="Number of concurrent workers for translation (default: 25)",
+    )
+    parser.add_argument(
+        "--provider",
+        choices=["openai", "dashscope", "openrouter"],
+        default="dashscope",
+        help="Translation provider (default: dashscope)",
+    )
+
+    args = parser.parse_args()
+
+    try:
+        result = process_srt_file(
+            args.input,
+            args.output,
+            operation=args.operation,
+            max_chars=args.max_chars,
+            target_lang=args.target_lang,
+            model=args.model,
+            workers=args.workers,
+            router=args.provider,
+        )
+        print(f"Processing complete. Output written to {result}")
+    except Exception as e:
+        print(f"Error: {e}")
+        exit(1)