Update app.py

app.py

@@ -6,6 +6,16 @@ import re
 import tempfile
 import os
 import xml.etree.ElementTree as ET
+import torchaudio
+import concurrent.futures
+import uuid
+
+# Load Telegram credentials from env vars
+TELEGRAM_TOKEN = os.environ.get('TELEGRAM_TOKEN')
+TELEGRAM_CHAT_ID = os.environ.get('TELEGRAM_CHAT_ID')
+
+if not TELEGRAM_TOKEN or not TELEGRAM_CHAT_ID:
+    raise ValueError("TELEGRAM_TOKEN and TELEGRAM_CHAT_ID must be set as environment variables in HF Space settings.")
 
 # Global cache for pipelines to avoid reloading models
 pipelines = {}
@@ -31,225 +41,243 @@ def get_pipeline(model_id):
         )
     return pipelines[model_id]
 
-# Updated function to fetch MP3 from Apple Podcasts episode URL via iTunes API + RSS
-def fetch_podcast_mp3(podcast_url):
-    if not podcast_url or "podcasts.apple.com" not in podcast_url:
-        return None, "Invalid Apple Podcasts URL. Please use a valid episode link (e.g., https://podcasts.apple.com/...)."
-    
-    # Parse podcast and episode IDs
-    podcast_match = re.search(r'id(\d+)', podcast_url)
-    if not podcast_match:
-        return None, "Invalid URL: No podcast ID found."
-    podcast_id = podcast_match.group(1)
+# Function to send message to Telegram
+def send_to_telegram(message):
+    url = f"https://api.telegram.org/bot{TELEGRAM_TOKEN}/sendMessage"
+    payload = {
+        "chat_id": TELEGRAM_CHAT_ID,
+        "text": message,
+        "parse_mode": "Markdown"
+    }
+    try:
+        response = requests.post(url, json=payload)
+        response.raise_for_status()
+        return True
+    except Exception as e:
+        print(f"Telegram send error: {e}")
+        return False
+
+# Function to fetch MP3 from Google Drive shareable link
+def fetch_from_google_drive(drive_link):
+    match = re.search(r'/d/([a-zA-Z0-9_-]+)', drive_link)
+    if not match:
+        return None, "Invalid Google Drive link. Use a shareable link like https://drive.google.com/file/d/FILE_ID/view."
     
-    episode_match = re.search(r'i=(\d+)', podcast_url)
-    if not episode_match:
-        return None, "Invalid URL: No episode ID found."
-    episode_id = episode_match.group(1)
+    file_id = match.group(1)
+    download_url = f"https://drive.google.com/uc?export=download&id={file_id}"
     
     headers = {"User-Agent": "Mozilla/5.0 (compatible; PodcastTranscriber/1.0)"}
     
     try:
-        # Step 1: Get RSS feed URL via iTunes Lookup API
-        api_url = f"https://itunes.apple.com/lookup?id={podcast_id}&entity=podcast"
-        api_response = requests.get(api_url, headers=headers)
-        api_response.raise_for_status()
-        data = api_response.json()
-        
-        if data['resultCount'] == 0:
-            return None, "Podcast not found in iTunes catalog."
-        
-        feed_url = data['results'][0]['feedUrl']
-        
-        # Step 2: Fetch and parse RSS XML
-        rss_response = requests.get(feed_url, headers=headers)
-        rss_response.raise_for_status()
-        root = ET.fromstring(rss_response.content)
-        
-        ns = {'itunes': 'http://www.itunes.com/dtds/podcast-1.0.dtd'}
-        mp3_url = None
+        response = requests.get(download_url, headers=headers, stream=True, allow_redirects=True)
+        if "confirm" in response.url:
+            confirm_match = re.search(r'confirm=([0-9A-Za-z_-]+)', response.url)
+            if confirm_match:
+                confirm_token = confirm_match.group(1)
+                download_url = f"https://drive.google.com/uc?export=download&confirm={confirm_token}&id={file_id}"
+                response = requests.get(download_url, headers=headers, stream=True)
         
-        for item in root.findall('.//item'):
-            episode_elem = item.find('itunes:episode', ns)
-            if episode_elem is not None and episode_elem.text == episode_id:
-                enclosure = item.find('enclosure')
-                if enclosure is not None:
-                    mp3_url = enclosure.get('url')
-                    break
+        response.raise_for_status()
         
-        if not mp3_url:
-            return None, "Episode not found in RSS feed (may be private or ID mismatch)."
-        
-        # Step 3: Download MP3 to temp file
-        mp3_response = requests.get(mp3_url, headers=headers, stream=True)
-        mp3_response.raise_for_status()
-        
-        total_size = int(mp3_response.headers.get('content-length', 0))
+        total_size = int(response.headers.get('content-length', 0))
         downloaded = 0
+        chunk_size = 1024 * 1024
         
         with tempfile.NamedTemporaryFile(delete=False, suffix=".mp3") as tmp_file:
-            for chunk in mp3_response.iter_content(chunk_size=1024 * 1024):  # 1MB chunks
+            for chunk in response.iter_content(chunk_size=chunk_size):
                 if chunk:
                     tmp_file.write(chunk)
                     downloaded += len(chunk)
         
         temp_path = tmp_file.name
         size_mb = downloaded / (1024 * 1024)
-        
-        return temp_path, f"Downloaded episode: {size_mb:.1f} MB from {mp3_url}"
+        return temp_path, f"Downloaded from Drive: {size_mb:.1f} MB"
     
     except Exception as e:
-        return None, f"Error fetching MP3: {str(e)}"
+        return None, f"Error fetching from Drive: {str(e)} (Ensure the file is shared publicly or with 'Anyone with the link')"
 
-# Transcription function as generator for progress updates
-def transcribe_speech(audio_input, model_id, language="english", return_timestamps=False, podcast_url=None):
+# Background transcription task
+def background_transcribe(task_id, audio_input, model_id, language, return_timestamps, podcast_url, drive_link):
     audio_file = None
-    status = gr.Markdown("Ready to transcribe! 💬")
+    status_msg = f"Task {task_id}: Starting..."
     
-    if podcast_url:
-        # Fetch MP3 with progress yields
-        yield "", gr.Markdown("**Fetching podcast metadata via iTunes API...**")
-        
-        # Simulate fetch here, but actual fetch is called below - yields are in main flow
-        audio_file, fetch_msg = fetch_podcast_mp3(podcast_url)
-        if not audio_file:
-            yield fetch_msg, gr.Markdown(f"**Error: {fetch_msg}**")
-            return
-        
-        # Note: fetch_msg includes size; display it
-        yield "", gr.Markdown(f"**{fetch_msg}**")
-        
-        # Download progress is now in fetch_podcast_mp3? Wait, no - I moved stream to main for yields.
-        # Actually, to yield during download, move the download logic here.
-        
-        # Redo: Move download to here for progress
-        # ... (parse IDs and get mp3_url as above, but to avoid dup code, call a helper)
-        
-        # For brevity, assume fetch returns mp3_url, then download here.
-        # But to fix, I'll inline the download progress in this generator.
-        
-        # Inline fetch logic for progress (condensed)
-        podcast_match = re.search(r'id(\d+)', podcast_url)
-        if not podcast_match:
-            yield "Invalid URL: No podcast ID.", status
-            return
-        podcast_id = podcast_match.group(1)
-        
-        episode_match = re.search(r'i=(\d+)', podcast_url)
-        if not episode_match:
-            yield "Invalid URL: No episode ID.", status
-            return
-        episode_id = episode_match.group(1)
-        
-        headers = {"User-Agent": "Mozilla/5.0 (compatible; PodcastTranscriber/1.0)"}
-        
-        yield "", gr.Markdown("**Looking up podcast in iTunes...**")
-        
-        api_url = f"https://itunes.apple.com/lookup?id={podcast_id}&entity=podcast"
-        api_response = requests.get(api_url, headers=headers)
-        api_response.raise_for_status()
-        data = api_response.json()
-        
-        if data['resultCount'] == 0:
-            yield "Podcast not found.", gr.Markdown("**Podcast not found in iTunes.**")
-            return
-        
-        feed_url = data['results'][0]['feedUrl']
-        yield "", gr.Markdown("**Fetching RSS feed...**")
-        
-        rss_response = requests.get(feed_url, headers=headers)
-        rss_response.raise_for_status()
-        root = ET.fromstring(rss_response.content)
-        
-        ns = {'itunes': 'http://www.itunes.com/dtds/podcast-1.0.dtd'}
-        mp3_url = None
-        
-        yield "", gr.Markdown("**Finding episode in RSS...**")
-        
-        for item in root.findall('.//item'):
-            episode_elem = item.find('itunes:episode', ns)
-            if episode_elem is not None and episode_elem.text == episode_id:
-                enclosure = item.find('enclosure')
-                if enclosure is not None:
-                    mp3_url = enclosure.get('url')
-                    break
-        
-        if not mp3_url:
-            yield "Episode not found in RSS.", gr.Markdown("**Episode not found (may be private).**")
-            return
-        
-        yield "", gr.Markdown("**Downloading MP3...**")
+    try:
+        if drive_link:
+            audio_file, msg = fetch_from_google_drive(drive_link)
+            if not audio_file:
+                send_to_telegram(f"Task {task_id} failed: {msg}")
+                return
+            status_msg += f"\n{msg}"
+        
+        elif podcast_url:
+            podcast_match = re.search(r'id(\d+)', podcast_url)
+            if not podcast_match:
+                send_to_telegram(f"Task {task_id} failed: Invalid URL: No podcast ID.")
+                return
+            podcast_id = podcast_match.group(1)
+            
+            episode_match = re.search(r'i=(\d+)', podcast_url)
+            if not episode_match:
+                send_to_telegram(f"Task {task_id} failed: Invalid URL: No episode ID.")
+                return
+            episode_id = episode_match.group(1)
+            
+            headers = {"User-Agent": "Mozilla/5.0 (compatible; PodcastTranscriber/1.0)"}
+            
+            api_url = f"https://itunes.apple.com/lookup?id={podcast_id}&entity=podcast"
+            api_response = requests.get(api_url, headers=headers)
+            api_response.raise_for_status()
+            data = api_response.json()
+            
+            if data['resultCount'] == 0:
+                send_to_telegram(f"Task {task_id} failed: Podcast not found.")
+                return
+            
+            feed_url = data['results'][0]['feedUrl']
+            
+            rss_response = requests.get(feed_url, headers=headers)
+            rss_response.raise_for_status()
+            root = ET.fromstring(rss_response.content)
+            
+            ns = {'itunes': 'http://www.itunes.com/dtds/podcast-1.0.dtd'}
+            mp3_url = None
+            
+            for item in root.findall('.//item'):
+                episode_guid = item.find('guid')
+                if episode_guid is not None and episode_id in episode_guid.text:
+                    enclosure = item.find('enclosure')
+                    if enclosure is not None:
+                        mp3_url = enclosure.get('url')
+                        break
+                
+                episode_elem = item.find('itunes:episode', ns)
+                if episode_elem is not None and episode_elem.text == episode_id:
+                    enclosure = item.find('enclosure')
+                    if enclosure is not None:
+                        mp3_url = enclosure.get('url')
+                        break
+            
+            if not mp3_url:
+                send_to_telegram(f"Task {task_id} failed: Episode not found.")
+                return
+            
+            mp3_response = requests.get(mp3_url, headers=headers, stream=True)
+            mp3_response.raise_for_status()
+            
+            total_size = int(mp3_response.headers.get('content-length', 0))
+            downloaded = 0
+            
+            with tempfile.NamedTemporaryFile(delete=False, suffix=".mp3") as tmp_file:
+                for chunk in mp3_response.iter_content(chunk_size=1024 * 1024):
+                    if chunk:
+                        tmp_file.write(chunk)
+                        downloaded += len(chunk)
+            
+            audio_file = tmp_file.name
+            size_mb = downloaded / (1024 * 1024)
+            status_msg += f"\nDownloaded from podcast: {size_mb:.1f} MB"
         
-        mp3_response = requests.get(mp3_url, headers=headers, stream=True)
-        mp3_response.raise_for_status()
+        else:
+            if audio_input is None:
+                send_to_telegram(f"Task {task_id} failed: No audio provided.")
+                return
+            audio_file = audio_input
         
-        total_size = int(mp3_response.headers.get('content-length', 0))
-        downloaded = 0
+        waveform, sample_rate = torchaudio.load(audio_file)
+        if waveform.shape[0] > 1:
+            waveform = torch.mean(waveform, dim=0, keepdim=True)
+        num_samples = waveform.shape[1]
+        duration = num_samples / sample_rate
         
-        with tempfile.NamedTemporaryFile(delete=False, suffix=".mp3") as tmp_file:
-            for chunk in mp3_response.iter_content(chunk_size=1024 * 1024):
-                if chunk:
-                    tmp_file.write(chunk)
-                    downloaded += len(chunk)
-                    if total_size > 0:
-                        percent = (downloaded / total_size) * 100
-                        yield "", gr.Markdown(f"**Downloading: {percent:.1f}% ({downloaded / (1024*1024):.1f} MB / {total_size / (1024*1024):.1f} MB)**")
-                    else:
-                        yield "", gr.Markdown(f"**Downloading: {downloaded / (1024*1024):.1f} MB...**")
+        status_msg += f"\nAudio duration: {duration / 60:.1f} minutes"
         
-        audio_file = tmp_file.name
-        size_mb = downloaded / (1024 * 1024)
-        yield "", gr.Markdown(f"**Download complete: {size_mb:.1f} MB. Starting transcription...**")
-    
-    else:
-        # Uploaded file
-        if audio_input is None:
-            yield "Please upload an audio file.", gr.Markdown("**No file uploaded.**")
-            return
-        audio_file = audio_input
-        yield "", gr.Markdown("**Starting transcription on uploaded file...**")
-    
-    # Transcribe
-    try:
         pipe = get_pipeline(model_id)
         
         generate_kwargs = {"task": "transcribe", "language": language}
-        if return_timestamps:
-            generate_kwargs["return_timestamps"] = True
-        
-        yield "", gr.Markdown("**Transcribing audio... (progress depends on file length and hardware)**")
         
-        output = pipe(
-            audio_file,
-            max_new_tokens=128,
-            generate_kwargs=generate_kwargs,
-            chunk_length_s=30,
-            stride_length_s=5,
-            batch_size=8 if "tiny" not in model_id and "base" not in model_id else 16,
-            return_timestamps=return_timestamps,
-        )
-        
-        # Clean up temp file
-        if podcast_url and os.path.exists(audio_file):
+        chunk_length_s = 30
+        stride_length_s = 5
+        chunk_samples = int(chunk_length_s * sample_rate)
+        stride_samples = int(stride_length_s * sample_rate)
+        
+        chunks = []
+        offsets = []
+        start = 0
+        while start < num_samples:
+            end = min(start + chunk_samples, num_samples)
+            chunks.append(waveform[:, start:end])
+            offsets.append(start / sample_rate)
+            start += chunk_samples - 2 * stride_samples
+        
+        num_chunks = len(chunks)
+        full_text = ""
+        all_chunk_outputs = []
+        
+        for i, (chunk, offset) in enumerate(zip(chunks, offsets)):
+            output = pipe(
+                {"waveform": chunk, "sampling_rate": sample_rate},
+                max_new_tokens=128,
+                generate_kwargs=generate_kwargs,
+                return_timestamps=return_timestamps,
+                batch_size=1
+            )
+            
+            if return_timestamps and "chunks" in output:
+                adjusted_chunks = []
+                for ch in output["chunks"]:
+                    ts = list(ch["timestamp"])
+                    if ts[0] is not None:
+                        ts[0] += offset
+                    if ts[1] is not None:
+                        ts[1] += offset
+                    adjusted_chunks.append({"text": ch["text"], "timestamp": tuple(ts)})
+                all_chunk_outputs.extend(adjusted_chunks)
+            else:
+                full_text += output["text"] + " "
+        
+        if os.path.exists(audio_file):
             os.unlink(audio_file)
         
-        if return_timestamps and "chunks" in output:
+        if return_timestamps:
             formatted = []
-            for chunk in output["chunks"]:
+            for chunk in all_chunk_outputs:
                 start = f"{chunk['timestamp'][0]:.2f}s" if chunk['timestamp'][0] is not None else "0.00s"
                 end = f"{chunk['timestamp'][1]:.2f}s" if chunk['timestamp'][1] is not None else "?.?s"
                 formatted.append(f"[{start} - {end}] {chunk['text']}")
-            text = "\n".join(formatted)
+            transcript = "\n".join(formatted)
         else:
-            text = output["text"]
+            transcript = full_text.strip()
         
-        yield text, gr.Markdown("**Transcription complete! 🎉 Copy or download the text above.**")
+        success = send_to_telegram(f"**Task {task_id} Complete!**\n\nTranscript:\n{transcript}")
+        if not success:
+            print(f"Failed to send task {task_id} to Telegram.")
     
     except Exception as e:
-        if podcast_url and os.path.exists(audio_file):
-            os.unlink(audio_file)
-        error_msg = f"Transcription error: {str(e)}"
-        yield error_msg, gr.Markdown(f"**{error_msg}**")
+        send_to_telegram(f"Task {task_id} failed: {str(e)}")
+
+# Starter function for uploaded file
+def start_transcribe_upload(audio_input, model_id, language, timestamps_checkbox):
+    task_id = str(uuid.uuid4())[:8]
+    with concurrent.futures.ThreadPoolExecutor() as executor:
+        executor.submit(background_transcribe, task_id, audio_input, model_id, language, timestamps_checkbox, None, None)
+    
+    return f"Task {task_id} started! Transcript will be sent to your Telegram bot when complete. You can close the browser."
+
+# Starter for podcast
+def start_transcribe_podcast(podcast_input, model_id, language, timestamps_checkbox):
+    task_id = str(uuid.uuid4())[:8]
+    with concurrent.futures.ThreadPoolExecutor() as executor:
+        executor.submit(background_transcribe, task_id, None, model_id, language, timestamps_checkbox, podcast_input, None)
+    
+    return f"Task {task_id} started! Transcript will be sent to your Telegram bot when complete. You can close the browser."
+
+# Starter for Drive
+def start_transcribe_drive(drive_input, model_id, language, timestamps_checkbox):
+    task_id = str(uuid.uuid4())[:8]
+    with concurrent.futures.ThreadPoolExecutor() as executor:
+        executor.submit(background_transcribe, task_id, None, model_id, language, timestamps_checkbox, None, drive_input)
+    
+    return f"Task {task_id} started! Transcript will be sent to your Telegram bot when complete. You can close the browser."
 
 # Create the Gradio app with a colorful, responsive theme
 theme = gr.themes.Soft(
@@ -263,15 +291,16 @@ with gr.Blocks(theme=theme, title="MP3 to Text Transcriber") as demo:
     gr.Markdown(
         """
         # 🎤 MP3 to Text Transcription Tool
-        Upload an MP3 (or any audio file) **or** paste an Apple Podcasts episode URL to fetch and transcribe it automatically!  
-        Now with real-time progress for downloads and transcription. Supports long files up to hours.
+        Upload an MP3, paste an Apple Podcasts URL, or provide a Google Drive shareable link to transcribe asynchronously.  
+        Results are sent to your Telegram bot—no need to wait in the browser!  
+        (Bot token and chat ID are set as secrets in HF Space settings.)
         """,
         elem_classes=["centered"]
     )
     
     with gr.Row(variant="panel", elem_classes=["max-w-4xl mx-auto"]):
         with gr.Column(scale=1):
-            # Option 1: File upload
+            # Inputs (no Telegram fields anymore)
             audio_input = gr.Audio(
                 sources="upload",
                 type="filepath",
@@ -279,13 +308,18 @@ with gr.Blocks(theme=theme, title="MP3 to Text Transcriber") as demo:
                 elem_classes=["w-full"]
             )
             
-            # Option 2: Podcast URL
             podcast_input = gr.Textbox(
                 label="🔗 Apple Podcasts Episode URL (optional)",
                 placeholder="e.g., https://podcasts.apple.com/us/podcast/.../id123?i=456",
                 elem_classes=["w-full"]
             )
             
+            drive_input = gr.Textbox(
+                label="📂 Google Drive Shareable Link (optional)",
+                placeholder="e.g., https://drive.google.com/file/d/ABC123/view?usp=sharing",
+                elem_classes=["w-full"]
+            )
+            
             model_dropdown = gr.Dropdown(
                 choices=MODEL_OPTIONS,
                 value=MODEL_OPTIONS[1],
@@ -309,36 +343,31 @@ with gr.Blocks(theme=theme, title="MP3 to Text Transcriber") as demo:
             )
         
         with gr.Column(scale=1):
-            status_output = gr.Markdown("Ready to transcribe! 💬", elem_classes=["text-center"])
+            status_output = gr.Markdown("Ready to start task! 💬", elem_classes=["text-center"])
     
     # Buttons
     with gr.Row(elem_classes=["w-full"]):
-        transcribe_btn = gr.Button("🚀 Transcribe Uploaded File", variant="secondary", elem_classes=["flex-1"])
-        podcast_btn = gr.Button("📡 Fetch & Transcribe Podcast", variant="primary", elem_classes=["flex-1"])
+        transcribe_btn = gr.Button("🚀 Start Transcribe Upload", variant="secondary", elem_classes=["flex-1"])
+        podcast_btn = gr.Button("📡 Start Podcast Transcribe", variant="primary", elem_classes=["flex-1"])
+        drive_btn = gr.Button("📂 Start Drive Transcribe", variant="primary", elem_classes=["flex-1"])
     
-    transcript_output = gr.Textbox(
-        label="📝 Transcript",
-        lines=15,
-        max_lines=20,
-        placeholder="Your transcription will appear here...",
-        elem_classes=["w-full", "bg-gray-50 dark:bg-gray-800"],
-        show_copy_button=True
-    )
-    
-    # Event handlers (generator fns auto-handle progress updates)
+    # Events (removed Telegram inputs)
     transcribe_btn.click(
-        fn=transcribe_speech,
-        inputs=[audio_input, model_dropdown, language_dropdown, timestamps_checkbox, gr.State(None)],  # podcast_url=None
-        outputs=[transcript_output, status_output],
-        show_progress="full"  # Enables determinate-ish progress for generators
+        fn=start_transcribe_upload,
+        inputs=[audio_input, model_dropdown, language_dropdown, timestamps_checkbox],
+        outputs=status_output
     )
     
-    # For podcast, pass podcast_input as podcast_url
     podcast_btn.click(
-        fn=transcribe_speech,
-        inputs=[gr.State(None), model_dropdown, language_dropdown, timestamps_checkbox, podcast_input],  # audio=None, podcast_url=input
-        outputs=[transcript_output, status_output],
-        show_progress="full"
+        fn=start_transcribe_podcast,
+        inputs=[podcast_input, model_dropdown, language_dropdown, timestamps_checkbox],
+        outputs=status_output
+    )
+    
+    drive_btn.click(
+        fn=start_transcribe_drive,
+        inputs=[drive_input, model_dropdown, language_dropdown, timestamps_checkbox],
+        outputs=status_output
     )
 
 if __name__ == "__main__":