Update app.py

app.py

@@ -23,6 +23,7 @@ PROXY_USER = ""  # Změňte na vaše uživatelské jméno
 PROXY_PASS = ""  # Změňte na vaše heslo
 
 
+
 # Middleware pro kontrolu přihlášení
 def login_required(f):
     @wraps(f)
@@ -216,183 +217,242 @@ def translate():
         return jsonify({'success': False, 'error': str(e)})
 
 def get_youtube_cookies():
+    print("Získávám cookies pomocí automatického přihlášení...")
+    options = webdriver.ChromeOptions()
+    # Removed headless mode as it often causes issues with Google login
+    options.add_argument('--no-sandbox')
+    options.add_argument('--disable-dev-shm-usage')
+    options.add_argument('--disable-blink-features=AutomationControlled')
+    options.add_argument('--disable-notifications')
+    options.add_experimental_option('excludeSwitches', ['enable-automation'])
+    options.add_experimental_option('useAutomationExtension', False)
+    
     try:
-        # Vytvoříme dočasný soubor pro cookies
-        cookie_file = tempfile.mktemp()
+        driver_manager = ChromeDriverManager()
+        driver_path = driver_manager.install()
+        service = Service(driver_path)
+        
+        print(f"Používám ChromeDriver z: {driver_path}")
+        driver = webdriver.Chrome(service=service, options=options)
+        
+        # Add undetected characteristics
+        driver.execute_script("Object.defineProperty(navigator, 'webdriver', {get: () => undefined})")
+        
+        wait = WebDriverWait(driver, 30)  # Increased timeout
         
-        # Získáme cookies z prohlížečů
-        cookies = []
+        print("Přihlašuji se do Google účtu...")
+        driver.get('https://accounts.google.com/signin/v2/identifier?service=youtube')
+        
+        # Wait for and interact with email field
+        email_input = wait.until(EC.presence_of_element_located((By.CSS_SELECTOR, 'input[type="email"]')))
+        email_input.clear()
+        email_input.send_keys("[email protected]")
+        email_input.send_keys(Keys.RETURN)
+        
+        # Wait for and interact with password field
         try:
-            cookies.extend(list(browser_cookie3.chrome(domain_name='.youtube.com')))
-        except:
-            print("Nepodařilo se získat cookies z Chrome")
+            password_input = wait.until(EC.presence_of_element_located((By.CSS_SELECTOR, 'input[type="password"]')))
+            password_input.clear()
+            password_input.send_keys("Guildwars1!")
+            password_input.send_keys(Keys.RETURN)
+        except TimeoutException:
+            print("⚠ Timeout při čekání na pole pro heslo. Možná je vyžadováno ruční ověření.")
+            driver.quit()
+            return None
         
+        # Wait for successful login and redirect to YouTube
+        print("Přecházím na YouTube...")
         try:
-            cookies.extend(list(browser_cookie3.firefox(domain_name='.youtube.com')))
-        except:
-            print("Nepodařilo se získat cookies z Firefox")
+            wait.until(lambda driver: "youtube.com" in driver.current_url)
+        except TimeoutException:
+            driver.get('https://www.youtube.com')
             
-        try:
-            cookies.extend(list(browser_cookie3.edge(domain_name='.youtube.com')))
-        except:
-            print("Nepodařilo se získat cookies z Edge")
+        wait.until(EC.presence_of_element_located((By.ID, "logo")))
         
+        # Get and save cookies
+        cookies = driver.get_cookies()
         if not cookies:
-            print("Nebyly nalezeny žádné cookies")
+            print("⚠ Nepodařilo se získat cookies. Přihlášení možná selhalo.")
+            driver.quit()
             return None
             
-        # Zapíšeme cookies do souboru ve formátu Netscape
-        with open(cookie_file, 'w', encoding='utf-8') as f:
+        cookies_file = os.path.join(os.path.dirname(__file__), 'youtube.cookies')
+        
+        with open(cookies_file, 'w', encoding='utf-8') as f:
             f.write("# Netscape HTTP Cookie File\n")
             f.write("# https://curl.haxx.se/rfc/cookie_spec.html\n")
             f.write("# This is a generated file!  Do not edit.\n\n")
             
             for cookie in cookies:
-                secure = "TRUE" if cookie.secure else "FALSE"
-                domain = cookie.domain if cookie.domain.startswith('.') else '.' + cookie.domain
-                path = cookie.path or "/"
-                expires = int(cookie.expires) if cookie.expires else 0
-                name = cookie.name
-                value = cookie.value
-                
-                # Formát: domain\tdomain_specified\tpath\tsecure\texpiry\tname\tvalue
-                f.write(f"{domain}\tTRUE\t{path}\t{secure}\t{expires}\t{name}\t{value}\n")
-        
-        print(f"Cookies byly úspěšně uloženy do: {cookie_file}")
-        return cookie_file
+                secure = "TRUE" if cookie.get('secure', False) else "FALSE"
+                domain = cookie['domain'] if cookie['domain'].startswith('.') else '.' + cookie['domain']
+                path = cookie.get('path', '/')
+                expires = str(int(cookie.get('expiry', 0)) if cookie.get('expiry') else 0)
+                f.write(f"{domain}\tTRUE\t{path}\t{secure}\t{expires}\t{cookie['name']}\t{cookie['value']}\n")
+        
+        print(f"✓ Cookies úspěšně uloženy do: {cookies_file}")
+        driver.quit()
+        return cookies_file
+        
     except Exception as e:
-        print(f"Chyba při získávání cookies: {str(e)}")
+        print(f"⚠ Chyba při získávání cookies: {str(e)}")
+        if 'driver' in locals():
+            driver.quit()
         return None
 
 def download_youtube_video(url, project_path, proxy=None, proxy_user=None, proxy_pass=None):
-    if not url:
-        raise Exception("No URL provided")
-        
-    if not ('youtube.com' in url or 'youtu.be' in url):
-        raise Exception("Not a valid YouTube URL")
-
-    filename = datetime.now().strftime("%Y%m%d_%H%M%S") + ".mp4"
-    output_path = os.path.join(project_path, 'original_' + filename)
-    
-    print(f"Starting download for URL: {url}")
-    print(f"Output path: {output_path}")
-    
-    # Cesta k souboru s cookies
-    cookies_file = os.path.join(os.path.dirname(__file__), 'youtube.cookies')
-    print(f"Hledám cookies v: {cookies_file}")
-    
-    # Základní konfigurace
-    ydl_opts = {
-        'format': 'bv*[ext=mp4]+ba[ext=m4a]/b[ext=mp4] / bv*+ba/b',
-        'outtmpl': output_path,
-        'noplaylist': True,
-        'quiet': False,
-        'no_warnings': False,
-        'extract_flat': False,
-        'verbose': True,
-        'merge_output_format': 'mp4',  # Vynutí výstup v MP4
-        'postprocessors': [{
-            'key': 'FFmpegVideoConvertor',
-            'preferedformat': 'mp4',
-        }],
-        'http_headers': {  # Add common headers
-            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/96.0.4664.93 Safari/537.36',
-            'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
-            'Accept-Language': 'en-us,en;q=0.5',
-            'Sec-Fetch-Mode': 'navigate'
-        }
-    }
-    
-    # Přidáme cookies pokud existují
-    if os.path.exists(cookies_file):
-        print(f"✓ Soubor cookies nalezen: {cookies_file}")
-        try:
-            with open(cookies_file, 'r', encoding='utf-8') as f:
-                first_line = f.readline().strip()
-                print(f"První řádek cookies souboru: {first_line}")
-                cookie_count = sum(1 for line in f if line.strip() and not line.startswith('#'))
-                print(f"Počet načtených cookies: {cookie_count}")
-            
-            ydl_opts['cookiefile'] = cookies_file
-            print("✓ Cookies byly úspěšně přidány do konfigurace")
-        except Exception as e:
-            print(f"⚠ Chyba při čtení cookies souboru: {str(e)}")
-    else:
-        print("⚠ VAROVÁNÍ: Soubor s cookies nebyl nalezen!")
-        print("  - Zkontrolujte, že soubor youtube.cookies existuje ve správné složce")
-        print("  - Některá videa nemusí být dostupná bez přihlášení")
-    
+    """Stáhne video z YouTube"""
     try:
         print("\nZahajuji stahování videa...")
-        with yt_dlp.YoutubeDL(ydl_opts) as ydl:
+        
+        # Prepare the API request
+        api_url = 'https://7701-185-68-219-242.ngrok-free.app/download-video'
+        headers = {
+            'Accept': '*/*',  # Accept any content type
+            'Content-Type': 'application/json'
+        }
+        payload = {
+            'url': url,
+            'api_key': '5as4d4f12sxdf45sfg46vawd74879ad5sd5AF4g6d8f4hfgb5'
+        }
+
+        print(f"Odesílám požadavek na API: {api_url}")
+        print(f"Payload: {payload}")
+        
+        # Make the API request with proper JSON encoding
+        response = requests.post(
+            api_url,
+            headers=headers,
+            json=payload,
+            stream=True
+        )
+        
+        print(f"Status code: {response.status_code}")
+        print(f"Response headers: {dict(response.headers)}")
+        
+        if response.status_code != 200:
+            error_message = f"API request failed with status code {response.status_code}"
             try:
-                # First try with format selection
-                info = ydl.extract_info(url, download=False)
-                print("\nDostupné formáty:")
-                if hasattr(ydl, 'list_formats'):
-                    ydl.list_formats(info)
-                
-                thumbnail_url = info.get('thumbnail', '')
-                print("✓ Informace o videu úspěšně získány")
-                
-                # Try downloading with current format
-                ydl.download([url])
-            except Exception as format_error:
-                if "Requested format is not available" in str(format_error):
-                    print("⚠ Požadovaný formát není dostupný, zkouším alternativní formát...")
-                    # Try with a more basic format
-                    ydl_opts['format'] = 'best'
-                    with yt_dlp.YoutubeDL(ydl_opts) as ydl2:
-                        ydl2.download([url])
-                else:
-                    raise format_error
-                    
-            print("✓ Video úspěšně staženo")
-            return output_path, thumbnail_url
+                error_message += f": {response.text[:200]}"
+            except Exception as e:
+                error_message += f" (Error reading response: {str(e)})"
+            raise Exception(error_message)
             
-    except Exception as e:
-        error_str = str(e)
-        if "Sign in to confirm your age" in error_str or "Sign in to this account" in error_str or "Private video" in error_str:
-            error_msg = "Video vyžaduje přihlášení. Cookies pravděpodobně vypršely nebo nefungují."
-            print(f"⚠ {error_msg}")
-            print("  - Zkuste se přihlásit do YouTube")
-            print("  - Exportujte nové cookies")
-            print("  - Nahraďte stávající youtube.cookies novým souborem")
-            raise Exception(error_msg)
+        # Get content type and suggested filename from headers
+        content_type = response.headers.get('Content-Type', '').lower()
+        content_disp = response.headers.get('Content-Disposition', '')
+        
+        print(f"Content-Type: {content_type}")
+        print(f"Content-Disposition: {content_disp}")
+        
+        video_path = os.path.join(project_path, "video.mp4")
+        total_size = 0
+
+        print("Začínám stahovat video po částech...")
+        with open(video_path, 'wb') as f:
+            for chunk in response.iter_content(chunk_size=8192):
+                if chunk:
+                    chunk_size = len(chunk)
+                    total_size += chunk_size
+                    f.write(chunk)
+                    print(f"\rStaženo: {total_size / (1024*1024):.2f} MB", end='', flush=True)
+        
+        print("\nKontroluji stažený soubor...")
+        if os.path.exists(video_path):
+            final_size = os.path.getsize(video_path)
+            print(f"Velikost souboru: {final_size / (1024*1024):.2f} MB")
+            
+            if final_size > 0:
+                print(f"✓ Video bylo úspěšně staženo do: {video_path}")
+                return video_path
+            else:
+                os.remove(video_path)
+                raise Exception("Stažený soubor je prázdný")
         else:
-            error_msg = f"Nepodařilo se stáhnout video. Chyba: {error_str}"
-            print(f"⚠ {error_msg}")
-            raise Exception(error_msg)
+            raise Exception("Soubor nebyl vytvořen")
+            
+    except Exception as e:
+        print(f"Chyba při stahování videa: {str(e)}")
+        if 'video_path' in locals() and os.path.exists(video_path):
+            os.remove(video_path)
+        return None
 
 @app.route('/download_youtube', methods=['POST'])
 @login_required
 def download_yt():
     try:
+        # Get data from form submission
         url = request.form.get('url')
+        project_name = request.form.get('project_name', '')
+        
         if not url:
             return jsonify({'success': False, 'error': 'URL není zadána'})
             
-        print(f"Received download request for URL: {url}")
-        #print(f"Using proxy: {PROXY_URL}")
+        if not any(x in url.lower() for x in ['youtube.com', 'youtu.be']):
+            return jsonify({'success': False, 'error': 'Není platná YouTube URL'})
+            
+        project_path = create_project_folder(project_name)
+        if not project_path:
+            return jsonify({'success': False, 'error': 'Nepodařilo se vytvořit složku projektu'})
+
+        # Get thumbnail from API
+        api_url = 'https://7701-185-68-219-242.ngrok-free.app/download-thumbnail'
+        headers = {
+            'accept': 'application/json',
+            'Content-Type': 'application/json'
+        }
+        payload = {
+            'url': url,
+            'api_key': '5as4d4f12sxdf45sfg46vawd74879ad5sd5AF4g6d8f4hfgb5'
+        }
         
-        if any(x in url.lower() for x in ['youtube.com', 'youtu.be']):
-            os.makedirs('uploads', exist_ok=True)
-            try:
-                file_path, thumbnail_url = download_youtube_video(url, 'uploads') #, PROXY_URL, PROXY_USER, PROXY_PASS
-                if os.path.exists(file_path):
-                    return jsonify({
-                        'success': True, 
-                        'file_path': file_path,
-                        'filename': os.path.basename(file_path),
-                        'thumbnail_url': thumbnail_url
-                    })
-                else:
-                    return jsonify({'success': False, 'error': 'Soubor nebyl vytvořen po stažení'})
-            except Exception as e:
-                print(f"Download error: {str(e)}")
-                return jsonify({'success': False, 'error': f'Chyba při stahování: {str(e)}'})
+        # Get thumbnail URL with error handling
+        thumbnail_url = None  # Initialize as None
+        try:
+            print(f"Sending request to thumbnail API with payload: {payload}")
+            thumbnail_response = requests.post(api_url, headers=headers, json=payload)
+            print(f"Thumbnail API response status: {thumbnail_response.status_code}")
+            print(f"Thumbnail API response content: {thumbnail_response.text}")
+            
+            if thumbnail_response.status_code == 200:
+                try:
+                    thumbnail_data = thumbnail_response.json()
+                    if isinstance(thumbnail_data, dict):
+                        thumbnail_url = thumbnail_data.get('thumbnail_url')
+                        if not thumbnail_url:
+                            # Extract video ID and use YouTube thumbnail URL directly
+                            video_id = None
+                            if 'youtube.com/watch?v=' in url:
+                                video_id = url.split('watch?v=')[1].split('&')[0]
+                            elif 'youtu.be/' in url:
+                                video_id = url.split('youtu.be/')[1].split('?')[0]
+                            
+                            if video_id:
+                                thumbnail_url = f'https://img.youtube.com/vi/{video_id}/maxresdefault.jpg'
+                    
+                    print(f"Final thumbnail URL: {thumbnail_url}")
+                except ValueError as e:
+                    print(f"Error parsing thumbnail JSON: {str(e)}")
+                    # Fallback to direct YouTube thumbnail
+                    if 'youtube.com/watch?v=' in url:
+                        video_id = url.split('watch?v=')[1].split('&')[0]
+                        thumbnail_url = f'https://img.youtube.com/vi/{video_id}/maxresdefault.jpg'
+        except Exception as e:
+            print(f"Error getting thumbnail: {str(e)}")
+
+        video_path = download_youtube_video(url, project_path)
+        
+        if video_path and os.path.exists(video_path):
+            session['video_path'] = video_path
+            session['project_path'] = project_path
+            return jsonify({
+                'success': True,
+                'file_path': video_path,
+                'filename': os.path.basename(video_path),
+                'thumbnail_url': thumbnail_url
+            })
         else:
-            return jsonify({'success': False, 'error': 'Není platná YouTube URL'})
+            return jsonify({'success': False, 'error': 'Nepodařilo se stáhnout video'})
             
     except Exception as e:
         print(f"Route error: {str(e)}")
@@ -416,6 +476,7 @@ def get_subtitles():
         
         # Handle file upload
         if 'video' in files and files['video'].filename:
+            # Handle file upload
             media_filer = files['video']
             custom_filename = "video.mp4"
             upload_paths = os.path.join(project_path, custom_filename)
@@ -645,49 +706,7 @@ def get_current_video_path():
         })
     return jsonify({'success': False, 'error': 'No video path in session'})
 
-def export_youtube_cookies():
-    try:
-        cookies_file = os.path.join(os.path.dirname(__file__), 'youtube.cookies')
-        print(f"Exportuji cookies do: {cookies_file}")
-        
-        # Seznam prohlížečů běžně dostupných na Windows
-        browsers = ['chrome', 'firefox', 'edge']
-        
-        for browser in browsers:
-            try:
-                print(f"Zkouším získat cookies z prohlížeče: {browser}")
-                ydl_opts = {
-                    'cookiesfrombrowser': (browser,),
-                    'quiet': True,
-                }
-                
-                with yt_dlp.YoutubeDL(ydl_opts) as ydl:
-                    print(f"Zkouším získat cookies z prohlížeče: {browser}")
-                    # Vytvoříme dočasný soubor pro cookies
-                    cookie_file = tempfile.mktemp()
-                    ydl_opts['cookiefile'] = cookie_file
-                    
-                    # Pokusíme se získat cookies
-                    try:
-                        ydl.extract_info("https://www.youtube.com", download=False)
-                    except:
-                        pass
-                    
-                    # Pokud se soubor vytvořil, zkopírujeme ho
-                    if os.path.exists(cookie_file):
-                        shutil.copy2(cookie_file, cookies_file)
-                        print(f"Cookies úspěšně exportovány z {browser} do {cookies_file}")
-                        return cookies_file
-            except Exception as e:
-                print(f"Nepodařilo se exportovat cookies z {browser}: {str(e)}")
-                continue
-                
-        print("Nepodařilo se exportovat cookies z žádného prohlížeče")
-        return None
-    except Exception as e:
-        print(f"Chyba při exportu cookies: {str(e)}")
-        return None
-
 # Pokud je skript spuštěn přímo, exportujeme cookies
 if __name__ == "__main__":
-    export_youtube_cookies()
+    get_youtube_cookies()
+