push

.gitignore

@@ -0,0 +1,146 @@
+# 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
+
+# uv stuff
+.python-version
+uv.lock
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMan stuff
+*.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/
+
+
+# Project-specific ignores
+# Modal deployment files
+.modal/
+modal_volumes/
+
+# Gradio temporary files
+gradio_cached_examples/
+flagged/
+
+# AI/ML artifacts
+models/
+data/
+experiments/
+wandb/
+mlruns/

asr.py

@@ -0,0 +1,200 @@
+import modal
+import uuid
+
+MODEL_NAME = "nvidia/parakeet-tdt-0.6b-v2"
+
+def download_model():
+    try: 
+        import nemo.collections.asr as nemo_asr # type: ignore
+        nemo_asr.models.ASRModel.from_pretrained(MODEL_NAME)
+    except ImportError:
+        pass
+
+asr_image = (
+    modal.Image.debian_slim(python_version="3.12")
+    .apt_install("git", "ffmpeg")
+    .pip_install(
+        "torch",
+        "librosa",
+        "omegaconf",
+        "lightning",
+        "cuda-python>=12.3",
+        "git+https://github.com/NVIDIA/multi-storage-client.git",
+        "nemo_toolkit[asr] @ git+https://github.com/NVIDIA/NeMo@main",
+        extra_options="-U",
+        gpu="A10G",
+    )
+    .run_function(
+        download_model,
+        gpu="A10G",
+    )
+)
+
+with asr_image.imports():
+    import nemo.collections.asr as nemo_asr # type: ignore
+    from nemo.collections.asr.parts.submodules.rnnt_decoding import RNNTDecodingConfig # type: ignore
+    from nemo.collections.asr.parts.utils.streaming_utils import BatchedFrameASRTDT # type: ignore
+    from nemo.collections.asr.parts.utils.transcribe_utils import get_buffered_pred_feat_rnnt # type: ignore
+    import math
+    import torch # type: ignore
+    from omegaconf import OmegaConf # type: ignore
+    import librosa # type: ignore
+    import os
+
+app = modal.App(name="clipscript-asr-service")
+
+# This must be the same volume object used in processing.py
+upload_volume = modal.Volume.from_name(
+    "clipscript-uploads", create_if_missing=True
+)
+
+@app.cls(
+    image=asr_image,
+    gpu="A10G",
+    scaledown_window=600,
+    volumes={"/data": upload_volume},  # Mount the shared volume
+)
+class ASR:
+    @modal.enter()
+    def startup(self):
+        print("loading model...")
+        self.model = nemo_asr.models.ASRModel.from_pretrained(MODEL_NAME)
+        print("model loaded.")
+        
+        self.model.freeze()
+        torch.set_grad_enabled(False)
+        
+        # Configure for buffered inference
+        model_cfg = self.model._cfg
+        OmegaConf.set_struct(model_cfg.preprocessor, False)
+        model_cfg.preprocessor.dither = 0.0
+        model_cfg.preprocessor.pad_to = 0
+        OmegaConf.set_struct(model_cfg.preprocessor, True)
+        
+        # Setup decoding for TDT model
+        decoding_cfg = RNNTDecodingConfig()
+        decoding_cfg.strategy = "greedy"  # TDT requires greedy
+        decoding_cfg.preserve_alignments = True
+        decoding_cfg.fused_batch_size = -1
+        
+        if hasattr(self.model, 'change_decoding_strategy'):
+            self.model.change_decoding_strategy(decoding_cfg)
+        
+        # Calculate timing parameters
+        self.feature_stride = model_cfg.preprocessor['window_stride']
+        self.model_stride = 4  # TDT model stride
+        self.model_stride_in_secs = self.feature_stride * self.model_stride
+        
+        # Buffered inference parameters
+        self.chunk_len_in_secs = 15.0
+        self.total_buffer_in_secs = 20.0
+        self.batch_size = 64 
+        self.max_steps_per_timestep = 15
+        
+        # Calculate chunk parameters
+        self.tokens_per_chunk = math.ceil(self.chunk_len_in_secs / self.model_stride_in_secs)
+        
+        print("ASR setup complete with buffered inference support.")
+
+    def _get_audio_duration(self, audio_path: str) -> float:
+        try:
+            duration = librosa.get_duration(path=audio_path)
+            return duration
+        except Exception:
+            # Fallback: estimate from file size (rough approximation)
+            file_size = os.path.getsize(audio_path)
+            # Rough estimate: 16kHz, 16-bit mono = ~32KB per second
+            return file_size / 32000
+    
+    def _simple_transcribe(self, audio_path: str) -> str:
+        print("Using simple transcription...")
+        output = self.model.transcribe([audio_path])
+        
+        if not output or not hasattr(output[0], "text"):
+            return ""
+        
+        return output[0].text
+    
+    def _buffered_transcribe(self, audio_path: str) -> str:
+        print("Using buffered transcription...")
+        
+        # Setup TDT frame processor
+        frame_asr = BatchedFrameASRTDT(
+            asr_model=self.model,
+            frame_len=self.chunk_len_in_secs,
+            total_buffer=self.total_buffer_in_secs,
+            batch_size=self.batch_size,
+            max_steps_per_timestep=self.max_steps_per_timestep,
+            stateful_decoding=False,
+        )
+        
+        # Calculate delay for TDT
+        mid_delay = math.ceil((self.chunk_len_in_secs + (self.total_buffer_in_secs - self.chunk_len_in_secs) / 2) / self.model_stride_in_secs)
+        
+        # Process with buffered inference
+        hyps = get_buffered_pred_feat_rnnt(
+            asr=frame_asr,
+            tokens_per_chunk=self.tokens_per_chunk,
+            delay=mid_delay,
+            model_stride_in_secs=self.model_stride_in_secs,
+            batch_size=self.batch_size,
+            manifest=None,
+            filepaths=[audio_path],
+            accelerator='gpu',
+        )
+        
+        # Extract transcription
+        if hyps and len(hyps) > 0:
+            return hyps[0].text
+        
+        return ""
+
+    @modal.method()
+    def transcribe(self, audio_filename: str = None, audio_bytes: bytes = None, use_buffered: bool | None = None) -> dict[str, str]:
+        audio_path = None
+        temp_audio_path = None
+        try:
+            if audio_filename:
+                audio_path = f"/data/{audio_filename}"
+            elif audio_bytes:
+                # When bytes are passed, they must be written to a file for librosa/nemo to read.
+                temp_audio_path = f"/tmp/input_{uuid.uuid4()}.wav"
+                with open(temp_audio_path, "wb") as f:
+                    f.write(audio_bytes)
+                audio_path = temp_audio_path
+            else:
+                raise ValueError("Either 'audio_filename' or 'audio_bytes' must be provided.")
+            
+            if not os.path.exists(audio_path):
+                return {"text": "", "error": f"Audio file not found at path: {audio_path}"}
+            
+            # Determine transcription method
+            if use_buffered is None:
+                duration = self._get_audio_duration(audio_path)
+                use_buffered = duration > 1800.0  # 30 minutes
+                print(f"Audio duration: {duration:.1f}s, using {'buffered' if use_buffered else 'simple'} transcription")
+            
+            if use_buffered:
+                text = self._buffered_transcribe(audio_path)
+            else:
+                text = self._simple_transcribe(audio_path)
+            
+            print("transcription complete.")
+            return {"text": text, "error": ""}
+            
+        except Exception as e:
+            print(f"Transcription error: {e}")
+            return {"text": "", "error": str(e)}
+        finally:
+            if temp_audio_path and os.path.exists(temp_audio_path):
+                os.remove(temp_audio_path)
+
+    @modal.method()
+    def transcribe_simple(self, audio_filename: str = None, audio_bytes: bytes = None) -> dict[str, str]:
+        """Force simple transcription (for compatibility)"""
+        return self.transcribe(audio_filename=audio_filename, audio_bytes=audio_bytes, use_buffered=False)
+    
+    @modal.method()
+    def transcribe_buffered(self, audio_filename: str = None, audio_bytes: bytes = None) -> dict[str, str]:
+        """Force buffered transcription"""
+        return self.transcribe(audio_filename=audio_filename, audio_bytes=audio_bytes, use_buffered=True)

main.py

@@ -0,0 +1,360 @@
+from functools import wraps
+import logging
+import gradio as gr
+import os
+import modal
+from openai import OpenAI
+from dotenv import load_dotenv
+import re
+import time
+import uuid
+import yt_dlp
+import tempfile
+import shutil
+from pathlib import Path
+
+load_dotenv()
+
+
+process_media_remotely = modal.Function.from_name("clipscript-processing-service", "process_media")
+asr_handle = modal.Cls.from_name("clipscript-asr-service", "ASR")
+upload_volume = modal.Volume.from_name("clipscript-uploads", create_if_missing=True)
+
+
+llm = "deepseek/deepseek-r1-0528:free"
+api_key = os.environ.get("OPENROUTER_API_KEY")
+
+
+def retry_on_rate_limit(max_retries: int = 5, base_delay: float = 2.0):
+    """Decorator for exponential backoff on rate limits"""
+    def decorator(func):
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            delay = base_delay
+            for attempt in range(max_retries):
+                try:
+                    return func(*args, **kwargs)
+                except Exception as e:
+                    # Check for 429 status code in different ways
+                    status_code = getattr(getattr(e, 'response', None), 'status_code', None)
+                    if status_code == 429 or '429' in str(e) or 'rate limit' in str(e).lower():
+                        logging.warning(f"Rate limit hit. Retrying in {delay:.1f} seconds...")
+                        time.sleep(delay)
+                        delay *= 2
+                    else:
+                        raise
+            raise Exception("Max retries exceeded due to rate limits or other persistent errors.")
+        return wrapper
+    return decorator
+
+
+def extract_youtube_video_id(url: str) -> str:
+    """Extract YouTube video ID from various YouTube URL formats."""
+    patterns = [
+        r'(?:youtube\.com\/watch\?v=|youtu\.be\/|youtube\.com\/embed\/|youtube\.com\/v\/)([^&\n?#]+)',
+        r'youtube\.com\/watch\?.*v=([^&\n?#]+)'
+    ]
+    
+    for pattern in patterns:
+        match = re.search(pattern, url)
+        if match:
+            return match.group(1)
+    return None
+
+def get_youtube_thumbnail_url(video_id: str) -> str:
+    """Get the high quality thumbnail URL for a YouTube video."""
+    return f"https://img.youtube.com/vi/{video_id}/maxresdefault.jpg"
+
+client = OpenAI(
+    base_url="https://openrouter.ai/api/v1",
+    api_key=api_key,
+)
+
+def download_and_convert_youtube_audio(url: str) -> str:
+    """
+    Downloads audio from a YouTube URL and converts it to a 16kHz mono WAV file.
+    Uses a temporary directory for all intermediate files, ensuring cleanup.
+    Returns the path to the final temporary WAV file.
+    """
+    temp_dir = tempfile.mkdtemp()
+    try:
+        output_tmpl = os.path.join(temp_dir, "audio.%(ext)s")
+        ydl_opts = {
+            "format": "bestaudio/best",
+            "outtmpl": output_tmpl,
+            "postprocessors": [{
+                'key': 'FFmpegExtractAudio',
+                'preferredcodec': 'wav',
+            }],
+            'postprocessor_args': {
+                'extractaudio': ['-ar', '16000', '-ac', '1']
+            },
+            "quiet": True,
+        }
+
+        with yt_dlp.YoutubeDL(ydl_opts) as ydl:
+            ydl.download([url])
+
+        # Find the downloaded .wav file
+        downloaded_files = list(Path(temp_dir).glob("*.wav"))
+        if not downloaded_files:
+            raise FileNotFoundError("yt-dlp failed to create a WAV file. The video might be protected or unavailable.")
+
+        # Move the final file to a new temporary location so we can clean up the directory
+        source_path = downloaded_files[0]
+        fd, dest_path = tempfile.mkstemp(suffix=".wav")
+        os.close(fd)
+        shutil.move(source_path, dest_path)
+        
+        return dest_path
+    finally:
+        shutil.rmtree(temp_dir)
+
+def handle_transcription(file, url):
+    if not file and not (url and url.strip()):
+        gr.Warning("Please upload a file or enter a URL.")
+        return "Error: Please upload a file or enter a URL."
+
+    gr.Info("Starting secure transcription... This might take a moment.")
+    
+    try:
+        result = None
+        if url and url.strip():
+            video_id = extract_youtube_video_id(url)
+            if video_id:
+                converted_wav_path = None
+                try:
+                    print(f"Detected YouTube URL. Processing locally: {url}")
+                    converted_wav_path = download_and_convert_youtube_audio(url)
+                    
+                    # Read audio bytes and call ASR service
+                    with open(converted_wav_path, "rb") as f:
+                        audio_bytes = f.read()
+
+                    print("Sending audio bytes to ASR service.")
+                    result = asr_handle().transcribe.remote(audio_bytes=audio_bytes)
+                finally:
+                    # Clean up the final temp file
+                    if converted_wav_path and os.path.exists(converted_wav_path):
+                        os.remove(converted_wav_path)
+
+            else:
+                # Process other URLs remotely and securely.
+                print(f"Sending URL to Modal for processing: {url}")
+                result = process_media_remotely.remote(url=url)
+        elif file is not None:
+            # For file uploads:
+            # 1. Generate a unique ID for the file.
+            upload_id = f"upload-{uuid.uuid4()}"
+            print(f"Uploading file to Modal volume with ID: {upload_id}")
+            
+            # 2. Upload the local file to the remote volume 
+            with upload_volume.batch_upload() as batch:
+                batch.put_file(file, upload_id)
+            
+            # 3. Trigger remote processing by passing the upload ID.
+            print(f"Sending upload ID to Modal for processing: {upload_id}")
+            result = process_media_remotely.remote(upload_id=upload_id)
+
+        if result.get("error"):
+            return f"Error from ASR service: {result['error']}"
+
+        return result["text"]
+
+    except Exception as e:
+        print(f"An error occurred: {e}")
+        # It's good practice to remove the local temp file if it exists
+        if file and os.path.exists(file):
+            os.remove(file)
+        return f"Error: {str(e)}"
+    finally:
+        # Gradio's gr.File widget creates a temporary file. We should clean it up.
+        if file and os.path.exists(file):
+            os.remove(file)
+
+def add_transcript_to_chat(transcript: str):
+    if transcript.startswith("Error"):
+        gr.Error("Transcription failed. Please check the logs.")
+        return []
+    gr.Info("Transcript ready! Generating blog post...")
+    # Return empty list for display but store transcript for LLM processing
+    return []
+
+def user_chat(user_message: str, history: list):
+    return "", history + [{"role": "user", "content": user_message}]
+
+@retry_on_rate_limit(max_retries=3, base_delay=1.0)
+def _stream_chat_response(history: list, system_prompt: str, transcript: str = None):
+    if not history and not transcript:
+        # Don't do anything if there's no history and no transcript
+        return
+
+    if transcript.startswith("Error"):
+        return
+    # Include transcript as first user message if provided, but don't display it
+    messages = [{"role": "system", "content": system_prompt}]
+    if transcript:
+        messages.append({"role": "user", "content": transcript})
+    messages.extend(history)
+    
+    stream = client.chat.completions.create(
+        model=llm,
+        messages=messages,
+        stream=True
+    )
+
+    history.append({"role": "assistant", "content": ""})
+    response_content = ""
+    for chunk in stream:
+        content = chunk.choices[0].delta.content
+        if content:
+            response_content += content
+            history[-1]["content"] = response_content
+            yield history
+
+def generate_blog_post(history: list, transcript: str, context: str):
+    system_prompt = """You are an expert blog writer and editor. Your task is to transform a raw video transcription into a well-structured, engaging, and publish-ready blog post in Markdown format.
+Core Mandate: Erase the Video Origin
+This is a critical function. The reader must not know the content came from a video.
+Eliminate all video-specific language: Remove phrases like "in this video," "thanks for watching," "as you can see here," "welcome to the channel," etc.
+Scrub all platform calls-to-action: No "like and subscribe," "hit the bell icon," or "comment below."
+Remove sponsor messages and ads: Completely omit any sponsor mentions.
+Rephrase visual references: Convert "look at this screen" to a description of the information itself (e.g., "The data reveals that...").
+Content & Formatting Rules:
+Title: Create a compelling, SEO-friendly H1 title.
+Structure: Use ## for main headings and ### for subheadings to create a logical flow.
+Readability: Use short paragraphs, bulleted/numbered lists, and bolding for key terms.
+Refine Prose: Convert conversational speech into clean, professional writing.
+Remove all filler words (um, uh, like, you know).
+Fix grammar and consolidate rambling sentences.
+Flow: Start with a strong introduction and end with a concise summary or conclusion.
+Your output must be a complete, polished article in Markdown."""
+    
+    # Combine transcript with additional context if provided
+    full_transcript = transcript
+    if context and context.strip():
+        full_transcript = f"{transcript}\n\n--- Additional Context ---\n{context.strip()}\n\nThis is some additional context relevant to the transcription above."
+    
+    yield from _stream_chat_response(history, system_prompt, full_transcript)
+    
+def bot_chat(history: list):
+    system_prompt = "You are a helpful assistant that helps refine a blog post created from an audio transcript. The user will provide instructions for changes and you will return only the updated blog post."
+    yield from _stream_chat_response(history, system_prompt)
+
+def update_thumbnail_display(url: str):
+    """Update the thumbnail display when YouTube URL is entered."""
+    if not url or not url.strip():
+        return gr.update(visible=False, value=None)
+    
+    video_id = extract_youtube_video_id(url)
+    if video_id:
+        thumbnail_url = get_youtube_thumbnail_url(video_id)
+        return gr.update(visible=True, value=thumbnail_url)
+    else:
+        return gr.update(visible=False, value=None)
+
+# Gradio Interface
+theme = gr.themes.Ocean()
+with gr.Blocks(title="ClipScript", theme=theme) as demo:
+    gr.Markdown("# 🎬➡️📝 ClipScript: Video-to-Blog Transformer", elem_classes="hero-title")
+
+    gr.Markdown("### Upload an audio file, or provide a YouTube/direct URL *of any size*.")
+    with gr.Row():
+        # Column 1: File input, URL input, and thumbnail
+        with gr.Column(scale=1):
+            file_input = gr.File(label="Upload any audio file", type="filepath", height=200, file_types=["audio", ".webm", ".mp3", ".mp4", ".m4a", ".ogg", ".wav"])
+            
+            with gr.Row():
+                with gr.Column():
+                    url_input = gr.Textbox(
+                        label="YouTube(Recommended) or Direct Audio URL",
+                        placeholder="youtube.com/watch?v=... OR xyz.com/audio.mp3",
+                        scale=2
+                    )
+            
+                # YouTube thumbnail display
+                thumbnail_display = gr.Image(
+                    label="Thumbnail",
+                    visible=False,
+                    height=100,
+                    show_download_button=False,
+                    interactive=False,
+                    scale=2
+                )
+        
+        # Column 2: Transcript view
+        with gr.Column(scale=2):
+            transcript_output = gr.Textbox(label="Transcription POWERED by Modal Labs", lines=12, interactive=True, show_copy_button=True)
+
+    transcribe_button = gr.Button("Blogify", variant="primary")
+
+    gr.Markdown("---")
+
+    # Add Context section
+    context_input = gr.Textbox(
+        label="Additional Context",
+        placeholder="Enter any additional context, code, articles, or any references that relate to the video content...",
+        lines=5,
+        interactive=True
+    )
+
+    chatbot = gr.Chatbot(
+        label="Blog Post", type="messages", height=500, show_copy_all_button=True, show_copy_button=True, show_share_button=True
+    )
+    chat_input = gr.Textbox(
+        label="Your message",
+        placeholder="Refine the blog post or ask for changes...",
+        container=False,
+    )
+    clear_button = gr.ClearButton([chat_input, chatbot])
+
+
+    # Event handlers to disable/enable inputs based on usage
+    def on_file_upload(file):
+        if file is not None:
+            return gr.update(interactive=False), gr.update(visible=False, value=None)
+        else:
+            return gr.update(interactive=True), gr.update(visible=False, value=None)
+
+    def on_url_change(url):
+        if url and url.strip():
+            thumbnail_update = update_thumbnail_display(url)
+            return gr.update(interactive=False), thumbnail_update
+        else:
+            return gr.update(interactive=True), gr.update(visible=False, value=None)
+
+    file_input.change(fn=on_file_upload, inputs=file_input, outputs=[url_input, thumbnail_display])
+    url_input.change(fn=on_url_change, inputs=url_input, outputs=[file_input, thumbnail_display])
+
+    # Chained events for blog generation
+    (
+        transcribe_button.click(
+            fn=handle_transcription,
+            inputs=[file_input, url_input],
+            outputs=transcript_output,
+        )
+        .then(
+            fn=lambda: gr.update(value=None, interactive=True),
+            outputs=file_input,
+            queue=False,
+        )
+        .then(
+            fn=add_transcript_to_chat,
+            inputs=transcript_output,
+            outputs=chatbot,
+            queue=False,
+        )
+        .then(fn=generate_blog_post, inputs=[chatbot, transcript_output, context_input], outputs=chatbot)
+    )
+
+    # Event handler for follow-up chat
+    chat_input.submit(
+        fn=user_chat,
+        inputs=[chat_input, chatbot],
+        outputs=[chat_input, chatbot],
+        queue=False,
+    ).then(fn=bot_chat, inputs=chatbot, outputs=chatbot)
+
+
+if __name__ == "__main__":
+    demo.launch()

processing.py

@@ -0,0 +1,123 @@
+import modal
+import uuid
+
+sandbox_image = (
+    modal.Image.debian_slim()
+    .apt_install("ffmpeg")
+)
+
+app = modal.App(
+    "clipscript-processing-service",
+)
+
+asr_handle = modal.Cls.from_name("clipscript-asr-service", "ASR")
+
+# A persistent, named volume to stage file uploads from the Gradio app.
+upload_volume = modal.Volume.from_name(
+    "clipscript-uploads", create_if_missing=True
+)
+
+@app.function(
+    image=sandbox_image,
+    volumes={"/data": upload_volume},
+    cpu=2.0,
+    memory=4096,
+    timeout=7200,
+    retries=modal.Retries(
+        max_retries=3,
+        backoff_coefficient=2.0,
+        initial_delay=1.0,
+    ),
+)
+def process_media(url: str = None, upload_id: str = None):
+    """
+    Securely processes media from a URL or a file from the upload Volume using a Sandbox.
+
+    This function orchestrates a Sandbox to perform the download and conversion,
+    then passes the resulting audio bytes to the ASR service.
+    """
+    output_filename = f"processed-{uuid.uuid4()}.wav"
+    output_wav_path_in_sandbox = f"/tmp/{output_filename}"
+    audio_bytes = None
+
+    sb = None
+    try:
+        volumes = {"/data": upload_volume} if upload_id else {}
+        
+        sb = modal.Sandbox.create(
+            image=sandbox_image,
+            volumes=volumes,
+        )
+        
+        cmd = []
+        if url:
+            print(f"Sandbox: Downloading and converting from non-YouTube URL: {url}")
+            cmd = [
+                'ffmpeg', '-i', url,
+                '-ar', '16000', '-ac', '1', '-y', output_wav_path_in_sandbox
+            ]
+        elif upload_id:
+            print(f"Sandbox: Converting uploaded file: {upload_id}")
+            # Input path is on the mounted volume
+            uploaded_file_path_in_sandbox = f"/data/{upload_id}"
+            cmd = [
+                'ffmpeg', '-i', uploaded_file_path_in_sandbox,
+                '-ar', '16000', '-ac', '1', '-y', output_wav_path_in_sandbox
+            ]
+        else:
+            raise ValueError("Either 'url' or 'upload_id' must be provided.")
+
+        print("Sandbox: Executing FFMPEG...")
+        p = sb.exec(*cmd)
+        p.wait()
+
+        if p.returncode != 0:
+            stderr = p.stderr.read()
+            raise RuntimeError(f"ffmpeg execution failed: {stderr}")
+
+        print("Sandbox: Process complete. Reading WAV data from sandbox's filesystem.")
+        
+        # Read the file directly from the sandbox's filesystem.
+        with sb.open(output_wav_path_in_sandbox, "rb") as f:
+            audio_bytes = f.read()
+
+    except Exception as e:
+        print(f"Error during sandbox processing: {e}")
+        raise
+    finally:
+        if sb:
+            print("Terminating sandbox.")
+            sb.terminate()
+
+    if not audio_bytes:
+        raise RuntimeError("Processing failed to produce audio data.")
+
+    # If we processed a user upload, we can now clean up the original file.
+    if upload_id:
+        try:
+            print(f"Cleaning up original upload {upload_id} from volume.")
+            upload_volume.remove_file(upload_id)
+            upload_volume.commit()
+        except Exception as e:
+            # This is not a critical error, so we just warn.
+            print(f"Warning: Failed to clean up {upload_id} from volume: {e}")
+
+    print("Sending audio bytes to ASR service.")
+    
+    # Retry ASR service call with exponential backoff
+    max_asr_retries = 3
+    result = None
+    for attempt in range(max_asr_retries):
+        try:
+            # Pass the audio bytes directly to the ASR service
+            result = asr_handle.transcribe.remote(audio_bytes=audio_bytes)
+            break
+        except Exception as e:
+            if attempt == max_asr_retries - 1:
+                raise e
+            wait_time = 2 ** attempt
+            print(f"ASR service attempt {attempt + 1} failed: {e}. Retrying in {wait_time}s...")
+            import time
+            time.sleep(wait_time)
+
+    return result 

pyproject.toml

@@ -0,0 +1,14 @@
+[project]
+name = "clipscript"
+version = "0.1.0"
+description = "Add your description here"
+readme = "README.md"
+requires-python = ">=3.13"
+dependencies = [
+    "gradio>=5.33.1",
+    "gradio-client>=1.10.3",
+    "modal>=1.0.3",
+    "openai>=1.86.0",
+    "python-dotenv>=1.1.0",
+    "yt-dlp>=2025.6.9",
+]