cookies

app.py

@@ -17,16 +17,16 @@ import tempfile
 load_dotenv()
 
 # Create directories with proper permissions
-for directory in ['/tmp/transformers_cache', '/tmp/hf_home', '/tmp/cache']:
+for directory in ["/tmp/transformers_cache", "/tmp/hf_home", "/tmp/cache"]:
     os.makedirs(directory, exist_ok=True)
     # Ensure the directory is writeable
     os.chmod(directory, 0o777)
 
 # Set environment variables after creating directories
-os.environ['TRANSFORMERS_CACHE'] = '/tmp/transformers_cache'
-os.environ['HF_HOME'] = '/tmp/hf_home'
-os.environ['XDG_CACHE_HOME'] = '/tmp/cache'
-os.environ['PYTHONHTTPSVERIFY'] = '0'  # Added to help with SSL issues
+os.environ["TRANSFORMERS_CACHE"] = "/tmp/transformers_cache"
+os.environ["HF_HOME"] = "/tmp/hf_home"
+os.environ["XDG_CACHE_HOME"] = "/tmp/cache"
+os.environ["PYTHONHTTPSVERIFY"] = "0"  # Added to help with SSL issues
 
 app = Flask(__name__)
 
@@ -34,6 +34,7 @@ logging.basicConfig(level=logging.INFO)
 
 MODEL_NAME = "google/pegasus-xsum"
 
+
 def convert_audio_to_mp3(audio_bytes, original_format=None):
     try:
         logging.info(f"Converting audio from {original_format} to MP3 in memory...")
@@ -47,45 +48,51 @@ def convert_audio_to_mp3(audio_bytes, original_format=None):
         logging.error(f"Error converting audio to MP3: {e}")
         raise ValueError(f"Error converting audio to MP3: {e}")
 
+
 @lru_cache(maxsize=1)
 def load_whisper_model():
     return whisper.load_model("base")
 
+
 @lru_cache(maxsize=1)
 def load_pegasus_model():
     tokenizer = PegasusTokenizer.from_pretrained(MODEL_NAME)
     model = PegasusForConditionalGeneration.from_pretrained(MODEL_NAME)
     return tokenizer, model
 
+
 def transcribe_audio_with_whisper(audio_data, timeout=180):  # 3 minute timeout
     try:
         logging.info("Transcribing audio data")
         start_time = time.time()
         model = load_whisper_model()
-        
+
         with tempfile.NamedTemporaryFile(suffix=".mp3", delete=True) as temp_file:
             if isinstance(audio_data, io.BytesIO):
                 temp_file.write(audio_data.getvalue())
             else:
                 temp_file.write(audio_data)
             temp_file.flush()
-            
+
             # Add timeout monitoring
             result = model.transcribe(temp_file.name)
             elapsed = time.time() - start_time
             logging.info(f"Transcription completed in {elapsed:.2f} seconds")
-        
+
         return result["text"]
     except Exception as e:
         logging.error(f"Error in audio transcription: {e}")
         raise ValueError(f"Error in audio transcription: {e}")
 
+
 def summarize_text_with_pegasus(text, tokenizer, model):
     try:
-        inputs = tokenizer(text, truncation=True, padding="longest", return_tensors="pt")
+        inputs = tokenizer(
+            text, truncation=True, padding="longest", return_tensors="pt"
+        )
         total_tokens = len(inputs["input_ids"][0])
-        min_summary_length = max(math.ceil(total_tokens / 4), 75)  
-        max_summary_length = max(math.ceil(total_tokens / 3), 200) 
+        min_summary_length = max(math.ceil(total_tokens / 4), 75)
+        max_summary_length = max(math.ceil(total_tokens / 3), 200)
 
         if min_summary_length >= max_summary_length:
             min_summary_length = max_summary_length - 1
@@ -95,76 +102,166 @@ def summarize_text_with_pegasus(text, tokenizer, model):
             num_beams=5,
             min_length=min_summary_length,
             max_length=max_summary_length,
-            early_stopping=True
+            early_stopping=True,
         )
 
         summary = tokenizer.decode(summary_ids[0], skip_special_tokens=True)
-        summary = remove_repeated_sentences(summary)  
+        summary = remove_repeated_sentences(summary)
         return summary
     except Exception as e:
         logging.error(f"Error in text summarization: {e}")
         raise ValueError(f"Error in text summarization: {e}")
 
+
 def download_audio_from_youtube(url):
     buffer = io.BytesIO()
-    
+
+    # Create a temp directory for cookies with correct permissions
+    cookie_dir = tempfile.mkdtemp()
+    cookies_path = os.path.join(cookie_dir, "cookies.txt")
+
+    # Create an empty cookies file with appropriate permissions
+    with open(cookies_path, "w") as f:
+        f.write("")
+    os.chmod(cookies_path, 0o666)
+
     ydl_opts = {
-        'format': 'bestaudio/best',
-        'postprocessors': [{
-            'key': 'FFmpegExtractAudio',
-            'preferredcodec': 'mp3',
-            'preferredquality': '192',
-        }],
-        'outtmpl': '-',
-        'logtostderr': True,
-        'quiet': False, 
-        'no_warnings': False,
-        'extract_audio': True,
-        'nocheckcertificate': True,
-        'ignoreerrors': True,
-        'no_color': True,
-        'geo_bypass': True,
-        'cookies': '/tmp/cookies.txt'
+        "format": "bestaudio/best",
+        "postprocessors": [
+            {
+                "key": "FFmpegExtractAudio",
+                "preferredcodec": "mp3",
+                "preferredquality": "192",
+            }
+        ],
+        "outtmpl": "-",
+        "logtostderr": True,
+        "quiet": False,
+        "no_warnings": False,
+        "extract_audio": True,
+        "nocheckcertificate": True,
+        "ignoreerrors": True,
+        "no_color": True,
+        "geo_bypass": True,
+        "cookies": cookies_path,  # Use our temp cookies file
+        "socket_timeout": 30,
+        "retries": 3,
     }
-    
+
     try:
         logging.info(f"Downloading audio from YouTube: {url}")
-        
-        cert_path = os.path.join(tempfile.gettempdir(), 'cacert.pem')
+
+        # Handle SSL certificate issues
+        cert_path = os.path.join(tempfile.gettempdir(), "cacert.pem")
         import certifi
-        with open(cert_path, 'wb') as f:
-            f.write(certifi.where().encode())
-        
-        os.environ['SSL_CERT_FILE'] = cert_path
-        os.environ['REQUESTS_CA_BUNDLE'] = cert_path
-
-        with tempfile.NamedTemporaryFile(suffix=".%(ext)s") as temp_file:
-            ydl_opts['outtmpl'] = temp_file.name
-
-            with YoutubeDL(ydl_opts) as ydl:
-                info = ydl.extract_info(url, download=True)
-                if not info:
-                    raise ValueError("Could not fetch video information")
-                
-                audio_file_path = ydl.prepare_filename(info).replace('.webm', '.mp3').replace('.m4a', '.mp3')
-                
-                if not os.path.exists(audio_file_path):
-                    raise ValueError(f"Downloaded file {audio_file_path} does not exist")
-                with open(audio_file_path, 'rb') as audio_file:
-                    buffer = io.BytesIO(audio_file.read())
-                    buffer.seek(0)
-        
+
+        with open(cert_path, "wb") as f:
+            f.write(open(certifi.where(), "rb").read())
+
+        os.environ["SSL_CERT_FILE"] = cert_path
+        os.environ["REQUESTS_CA_BUNDLE"] = cert_path
+
+        # Create a proper temporary file for the download
+        with tempfile.NamedTemporaryFile(suffix=".%(ext)s", delete=False) as temp_file:
+            output_path = temp_file.name
+            ydl_opts["outtmpl"] = output_path
+
+            try:
+                with YoutubeDL(ydl_opts) as ydl:
+                    # Add more info messages for debugging
+                    logging.info(f"Starting YouTube download with options: {ydl_opts}")
+                    info = ydl.extract_info(url, download=True)
+
+                    if not info:
+                        raise ValueError("Could not fetch video information")
+
+                    # Construct the output filename based on yt-dlp's naming pattern
+                    audio_file_path = ydl.prepare_filename(info)
+
+                    # Handle different possible extensions
+                    for ext in [".mp3", ".webm.mp3", ".m4a.mp3"]:
+                        possible_path = audio_file_path.replace(".webm", ext).replace(
+                            ".m4a", ext
+                        )
+                        if os.path.exists(possible_path):
+                            audio_file_path = possible_path
+                            break
+
+                    logging.info(f"Audio downloaded to: {audio_file_path}")
+
+                    if not os.path.exists(audio_file_path):
+                        raise ValueError(
+                            f"Downloaded file {audio_file_path} does not exist"
+                        )
+
+                    # Read the file and clean up
+                    with open(audio_file_path, "rb") as audio_file:
+                        buffer = io.BytesIO(audio_file.read())
+                        buffer.seek(0)
+
+                    # Remove the temporary file
+                    try:
+                        os.unlink(audio_file_path)
+                    except Exception as cleanup_err:
+                        logging.warning(f"Could not remove temp file: {cleanup_err}")
+            except Exception as ydl_err:
+                logging.error(f"YoutubeDL error: {ydl_err}")
+                # Try alternative download method - direct URL only, no fancy features
+                logging.info("Attempting alternative download method...")
+
+                simple_opts = {
+                    "format": "bestaudio",
+                    "outtmpl": output_path,
+                    "nocheckcertificate": True,
+                    "quiet": True,
+                    "no_warnings": True,
+                    "geo_bypass": True,
+                }
+
+                with YoutubeDL(simple_opts) as ydl:
+                    info = ydl.extract_info(url, download=True)
+                    if not info:
+                        raise ValueError("Could not fetch video information")
+
+                    audio_file_path = ydl.prepare_filename(info)
+
+                    if not os.path.exists(audio_file_path):
+                        raise ValueError(
+                            f"Downloaded file {audio_file_path} does not exist"
+                        )
+
+                    # Read the file
+                    with open(audio_file_path, "rb") as audio_file:
+                        buffer = io.BytesIO(audio_file.read())
+                        buffer.seek(0)
+
+                    # Convert to MP3 if needed
+                    if not audio_file_path.endswith(".mp3"):
+                        buffer = convert_audio_to_mp3(
+                            buffer.getvalue(),
+                            original_format=audio_file_path.split(".")[-1],
+                        )
+
+        # Clean up the temp directory
+        try:
+            os.unlink(cookies_path)
+            os.rmdir(cookie_dir)
+        except:
+            pass
+
         return buffer
     except Exception as e:
-        logging.error(f"Unexpected error downloading audio: {e}")
+        logging.error(f"Unexpected error downloading audio: {e}", exc_info=True)
         raise ValueError(f"Error downloading audio from YouTube: {e}")
 
+
 def allowed_file(filename):
-    ALLOWED_EXTENSIONS = {'mp3', 'aac', 'flac', 'm4a'}
-    return '.' in filename and filename.rsplit('.', 1)[1].lower() in ALLOWED_EXTENSIONS
+    ALLOWED_EXTENSIONS = {"mp3", "aac", "flac", "m4a"}
+    return "." in filename and filename.rsplit(".", 1)[1].lower() in ALLOWED_EXTENSIONS
+
 
 def remove_repeated_sentences(text):
-    sentences = re.split(r'(?<=[.!?]) +', text)
+    sentences = re.split(r"(?<=[.!?]) +", text)
     unique_sentences = []
     seen_sentences = set()
 
@@ -173,44 +270,56 @@ def remove_repeated_sentences(text):
         if normalized_sentence not in seen_sentences:
             unique_sentences.append(sentence)
             seen_sentences.add(normalized_sentence)
-    
-    return ' '.join(unique_sentences)
 
-@app.route('/')
+    return " ".join(unique_sentences)
+
+
+@app.route("/")
 def index():
-    return render_template('index.html')
+    return render_template("index.html")
+
 
-@app.route('/transcribe', methods=['POST'])
+@app.route("/transcribe", methods=["POST"])
 def transcribe():
     try:
         audio_data = None
-        
-        if 'url' in request.form and request.form['url']:
-            youtube_url = request.form['url']
+
+        if "url" in request.form and request.form["url"]:
+            youtube_url = request.form["url"]
             try:
                 audio_data = download_audio_from_youtube(youtube_url)
             except ValueError as e:
                 if "bot" in str(e).lower() or "sign in" in str(e).lower():
-                    return jsonify({
-                        "error": "YouTube bot protection is preventing download. Please try uploading an audio file directly instead."
-                    }), 400
+                    return (
+                        jsonify(
+                            {
+                                "error": "YouTube bot protection is preventing download. Please try uploading an audio file directly instead."
+                            }
+                        ),
+                        400,
+                    )
                 else:
                     raise e
-        elif 'file' in request.files:
-            audio_file = request.files['file']
+        elif "file" in request.files:
+            audio_file = request.files["file"]
             if not audio_file.filename:
                 return jsonify({"error": "No file selected."}), 400
             if not allowed_file(audio_file.filename):
-                return jsonify({"error": "Invalid file type. Please upload an audio file."}), 400
-            
+                return (
+                    jsonify(
+                        {"error": "Invalid file type. Please upload an audio file."}
+                    ),
+                    400,
+                )
+
             audio_bytes = audio_file.read()
-            file_format = audio_file.filename.rsplit('.', 1)[1].lower()
+            file_format = audio_file.filename.rsplit(".", 1)[1].lower()
             audio_data = convert_audio_to_mp3(audio_bytes, original_format=file_format)
         else:
             return jsonify({"error": "No audio file or URL provided."}), 400
-        
+
         transcription = transcribe_audio_with_whisper(audio_data)
-        
+
         if transcription:
             tokenizer, model = load_pegasus_model()
             summary = summarize_text_with_pegasus(transcription, tokenizer, model)
@@ -223,5 +332,6 @@ def transcribe():
         logging.error(f"An unexpected error occurred: {e}")
         return jsonify({"error": "An unexpected error occurred."}), 500
 
+
 if __name__ == "__main__":
-    app.run(debug=False, port=7860)
+    app.run(debug=False, port=7860)

cookies.txt

@@ -0,0 +1,25 @@
+# Netscape HTTP Cookie File
+# http://curl.haxx.se/rfc/cookie_spec.html
+# This is a generated file!  Do not edit.
+
+.youtube.com	TRUE	/	TRUE	1757583616	LOGIN_INFO	AFmmF2swRQIgF5soRcTt7lXEUwtEb9FQ03f3Zne-yFkluBcpRitRS0cCIQDHcRE8XvCDS5zB4ePxdQXqh00tGRM9ezMV4nxLLjwbSQ:QUQ3MjNmeC1pYTRYWk9LS3puUHNkcnFmNHo0TlZzLXNlZjFjR0hxbEQ5V1RxS01ZWi1sdFg1YmtZV2l3VWhZamVnWEVTSFl0aThHdzZpLUFPblo2OUV3R1FQRUQ1bk9MdjIyOTBNTGdzV2c5UHZFZF8yLUhndzRjSGlaY0FWUGZhSUFDWTdXVjBiSFBiOWhreVBpeDQwSmF2ZW41MEdKa3lB
+.youtube.com	TRUE	/	TRUE	1743453779	PREF	f6=40000000&tz=Asia.Calcutta&f7=100&f4=4000000&f5=20000
+.youtube.com	TRUE	/	FALSE	1758370753	SID	g.a000vAjBDLZiKTwFsr7nRci5AJ3PYlXIk521CwbzSfsgcm0CTGlm9jbO5NwfjuH5H1Qr5z0HXQACgYKAR8SARQSFQHGX2MiJqDM__zo-eqJfVihPqytixoVAUF8yKrKi8L6mcfaoWGoI6WPxzE00076
+.youtube.com	TRUE	/	TRUE	1758370753	__Secure-1PSID	g.a000vAjBDLZiKTwFsr7nRci5AJ3PYlXIk521CwbzSfsgcm0CTGlm6JC1od1z-48MA6Sv28P7VAACgYKARwSARQSFQHGX2MiySMQYDZvaNIE-EzqdtCY4xoVAUF8yKoE8ZajtSE3-Rqj1mAgPd0n0076
+.youtube.com	TRUE	/	TRUE	1758370753	__Secure-3PSID	g.a000vAjBDLZiKTwFsr7nRci5AJ3PYlXIk521CwbzSfsgcm0CTGlmm5FMAoD2WmQf548Ici8uggACgYKAeUSARQSFQHGX2MisjOIaF3Qbnkqtng4E0OKpxoVAUF8yKqKOH2WNAkTP-D0GJU1BOJQ0076
+.youtube.com	TRUE	/	FALSE	1758370753	HSID	AQcV7hFsmKBsEpVkg
+.youtube.com	TRUE	/	TRUE	1758370753	SSID	A4XuUoqh-YH4zEXtj
+.youtube.com	TRUE	/	FALSE	1758370753	APISID	35X1TXslDGOfvkls/AqaxLrfKzyD0r6kIf
+.youtube.com	TRUE	/	TRUE	1758370753	SAPISID	GBBt8GIdptNKShZG/AlcodBpo3nf7ZTgQl
+.youtube.com	TRUE	/	TRUE	1758370753	__Secure-1PAPISID	GBBt8GIdptNKShZG/AlcodBpo3nf7ZTgQl
+.youtube.com	TRUE	/	TRUE	1758370753	__Secure-3PAPISID	GBBt8GIdptNKShZG/AlcodBpo3nf7ZTgQl
+.youtube.com	TRUE	/	TRUE	0	wide	0
+.youtube.com	TRUE	/	TRUE	1758400964	__Secure-1PSIDTS	sidts-CjIB7pHptY0gCyLdqftBIBXJTy7bBUtmmovoL9p9TI3uoJasEmwAlzpVO49C3Eapsb6yBBAA
+.youtube.com	TRUE	/	TRUE	1758400964	__Secure-3PSIDTS	sidts-CjIB7pHptY0gCyLdqftBIBXJTy7bBUtmmovoL9p9TI3uoJasEmwAlzpVO49C3Eapsb6yBBAA
+.youtube.com	TRUE	/	FALSE	1758400981	SIDCC	AKEyXzUWhRPhQu0yzPaM9FKj-Qa8MePFc5ETqbUvRnvJIBxOm8P5IFTk0YpIuA3tEGjkyX_GCw
+.youtube.com	TRUE	/	TRUE	1758400981	__Secure-1PSIDCC	AKEyXzUjf4BOyFFV20k_f4BqobIoTYoUzehByNXxjrlY-DoO_ej73h6h7SGhscYvR09iiF1WOA
+.youtube.com	TRUE	/	TRUE	1758400981	__Secure-3PSIDCC	AKEyXzXvgXjidduS-LM-pE5IhSUSxWRv9sS0MOuTpwqwAd3duFZsxnDjdjot864-04kzzdpUSzg
+.youtube.com	TRUE	/	TRUE	1758400977	VISITOR_INFO1_LIVE	Xbmcd6Kbxkc
+.youtube.com	TRUE	/	TRUE	1758400977	VISITOR_PRIVACY_METADATA	CgJJThIEGgAgJw%3D%3D
+.youtube.com	TRUE	/	TRUE	0	YSC	CEEJWnuAkNs
+.youtube.com	TRUE	/	TRUE	1758369465	__Secure-ROLLOUT_TOKEN	CJWHp_C1vvL0iQEQ0serveWLjAMYp4mH_9SijAM%3D