Update app.py

app.py

@@ -1,2 +1,524 @@
+from flask import Flask, render_template, request, jsonify, send_file, session, redirect, url_for
+from functools import wraps
+from functools import update_wrapper
 import os
-os.system("python app_rvc.py --language czech")
+from app_rvc2 import SoniTranslate, TTS_Info
+from soni_translate.language_configuration import LANGUAGES_LIST, LANGUAGES, LANGUAGES_UNIDIRECTIONAL
+import yt_dlp
+from datetime import datetime
+import re
+import shutil
+
+app = Flask(__name__)
+app.secret_key = 'koala123'  # Změňte na bezpečné heslo
+
+# Heslo pro přístup k aplikaci
+APP_PASSWORD = 'koala123'  # Změňte na požadované heslo
+
+# Middleware pro kontrolu přihlášení
+def login_required(f):
+    @wraps(f)
+    def decorated_function(*args, **kwargs):
+        if 'logged_in' not in session:
+            return redirect(url_for('login'))
+        return f(*args, **kwargs)
+    return decorated_function
+
+@app.route('/login', methods=['GET', 'POST'])
+def login():
+    if request.method == 'POST':
+        if request.form['password'] == APP_PASSWORD:
+            session['logged_in'] = True
+            return redirect(url_for('index'))
+        return render_template('login.html', error='Nesprávné heslo')
+    return render_template('login.html')
+
+@app.route('/logout')
+def logout():
+    session.pop('logged_in', None)
+    return redirect(url_for('login'))
+
+soni = SoniTranslate()
+
+# Přidání cesty pro servírování výsledných videí
+@app.route('/outputs/<path:filename>')
+def serve_output(filename):
+    return send_file('outputs/' + filename)
+
+@app.route('/uploads/<path:filename>')
+def serve_upload(filename):
+    return send_file('uploads/' + filename)
+
+@app.route('/exports/<path:filename>')
+def serve_export(filename):
+    return send_file('exports/' + filename)
+
+@app.route('/')
+@login_required
+def index():
+    return render_template('index_new.html', 
+                         languages=LANGUAGES_LIST,
+                         tts_voices=soni.tts_info.tts_list())
+
+def create_project_folder(project_name):
+    # Vytvoření názvu složky ve formátu DD-MM-YYYY-H:M-project_name
+    current_time = datetime.now()
+    sanitized_name = re.sub(r'[<>:"/\\|?*]', '_', project_name)  # Nahrazení neplatných znaků
+    folder_name = current_time.strftime("%d-%m-%Y-%H-%M-") + sanitized_name
+    
+    # Vytvoření složky v exports
+    project_path = os.path.join('exports', folder_name)
+    os.makedirs(project_path, exist_ok=True)
+    return project_path
+
+@app.route('/translate', methods=['POST'])
+@login_required
+def translate():
+    try:
+        data = request.form
+        files = request.files
+
+        # Kontrola manuální korekce
+        manual_correction = data.get('translation_correction', 'off') == 'on'
+
+        # Vytvoření projektové složky
+        project_name = data.get('project_name', 'untitled')
+        project_path = create_project_folder(project_name)
+
+        # Handle file upload or YouTube URL
+        media_file = None
+        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)
+            os.makedirs(project_path, exist_ok=True)
+            media_filer.save(upload_paths)
+            media_file = upload_paths
+            print("Video saved to project:", media_file)
+        elif 'downloaded_video_path' in data and data['downloaded_video_path'].strip():
+            # Použít stažené video z YouTube
+            downloaded_path = data['downloaded_video_path'].strip()
+            if os.path.exists(downloaded_path):
+                media_file = downloaded_path
+                print("Using downloaded YouTube video:", media_file)
+            else:
+                return jsonify({'success': False, 'error': 'Stažené video nebylo nalezeno'})
+        elif 'url' in data and data['url'].strip():
+            # Handle YouTube URL
+            url = data['url'].strip()
+            if 'youtube.com' in url or 'youtu.be' in url:
+                try:
+                    media_file, thumbnail_url = download_youtube_video(url, project_path)
+                    # Copy downloaded file to video.mp4
+                    final_path = os.path.join(project_path, "video.mp4")
+                    shutil.copy(media_file, final_path)
+                    media_file = final_path
+                    print("YouTube video downloaded to:", media_file)
+                except Exception as e:
+                    return jsonify({'success': False, 'error': f'YouTube download failed: {str(e)}'})
+            else:
+                return jsonify({'success': False, 'error': 'Invalid YouTube URL'})
+
+        # Pokud je zapnuta manuální korekce, uložit cestu k videu do session
+        if manual_correction and media_file:
+            session['current_video_path'] = media_file
+            print(f"Uloženo do session: {media_file}")
+
+        if not media_file:
+            return jsonify({'success': False, 'error': 'No video file or valid YouTube URL provided'})
+
+        # Get parameters
+        source_lang = data.get('source_language', 'Automatic detection')
+        target_lang = data.get('target_language', 'English (en)')
+        max_speakers = int(data.get('max_speakers', 1))
+        
+        # Get edited subtitles if available
+        edited_subtitles = data.get('edited_subtitles')
+        
+        # If edited subtitles are available, save them to a temporary file
+        subtitle_file = None
+        if edited_subtitles:
+            # If edited subtitles are provided, use target language as source language
+            # since the subtitles are already in the target language
+            source_lang = target_lang
+            get_translated_text=False
+            get_video_from_text_json=True
+            text_json=edited_subtitles
+            os.makedirs('uploads', exist_ok=True)
+            subtitle_file = os.path.join('uploads', 'edited_subtitles.srt')
+            with open(subtitle_file, 'w', encoding='utf-8') as f:
+                f.write(edited_subtitles)
+        else:
+            get_translated_text=False
+            get_video_from_text_json=False
+            text_json=""
+        tts_voices = {}
+        for i in range(max_speakers):
+            voice_key = f'tts_voice{i:02d}'
+            if voice_key in data:
+                tts_voices[voice_key] = data[voice_key]      
+
+        # Process the translation
+        result = soni.multilingual_media_conversion(
+            media_file=media_file,
+            link_media="",
+            directory_input="",
+            origin_language=source_lang,
+            target_language=target_lang,
+            max_speakers=max_speakers,
+            get_translated_text=get_translated_text,
+            get_video_from_text_json=get_video_from_text_json,
+            text_json=text_json,
+            max_accelerate_audio=1.0,
+            acceleration_rate_regulation=False,
+            **tts_voices,
+            is_gui=True
+        )
+        
+        if isinstance(result, list):
+            # Přesun výstupních souborů do projektové složky
+            new_paths = []
+            for file_path in result:
+                if os.path.exists(file_path):
+                    new_path = os.path.join(project_path, os.path.basename(file_path))
+                    shutil.move(file_path, new_path)
+                    # Převedení na relativní cestu pro frontend
+                    relative_path = os.path.relpath(new_path, 'exports')
+                    new_paths.append(f'/exports/{relative_path.replace(os.sep, "/")}')
+            
+            # Převedení originálního videa na relativní cestu
+            original_video_path = None
+            if media_file and os.path.exists(media_file):
+                original_video_path = f'/exports/{os.path.relpath(media_file, "exports").replace(os.sep, "/")}'
+            
+            return jsonify({
+                'success': True,
+                'video': new_paths[0] if new_paths else None,
+                'original_video': original_video_path,
+                'files': new_paths
+            })
+        else:
+            return jsonify({'success': False, 'error': str(result)})
+
+    except Exception as e:
+        # Clean up temporary subtitle file in case of error
+        if 'subtitle_file' in locals() and subtitle_file and os.path.exists(subtitle_file):
+            os.remove(subtitle_file)
+        return jsonify({'success': False, 'error': str(e)})
+
+def download_youtube_video(url, project_path):
+    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}")
+    
+    ydl_opts = {
+        'format': 'bestvideo[ext=mp4]+bestaudio[ext=m4a]/best[ext=mp4]/best',
+        'outtmpl': output_path,
+        'noplaylist': True,
+        'quiet': False,
+        'no_warnings': False,
+        'extract_flat': False,
+        'verbose': True
+    }
+    
+    try:
+        with yt_dlp.YoutubeDL(ydl_opts) as ydl:
+            info = ydl.extract_info(url, download=False)
+            thumbnail_url = info.get('thumbnail', '')
+            ydl.download([url])
+            return output_path, thumbnail_url
+    except Exception as e:
+        print(f"Error downloading video: {str(e)}")
+        raise
+
+@app.route('/download_youtube', methods=['POST'])
+@login_required
+def download_yt():
+    try:
+        url = request.form.get('url')
+        if not url:
+            return jsonify({'success': False, 'error': 'URL není zadána'})
+            
+        print(f"Received download request for URL: {url}")
+        
+        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')
+                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)}'})
+        else:
+            return jsonify({'success': False, 'error': 'Není platná YouTube URL'})
+            
+    except Exception as e:
+        print(f"Route error: {str(e)}")
+        return jsonify({'success': False, 'error': f'Chyba: {str(e)}'})
+
+@app.route('/get_subtitles', methods=['POST'])
+@login_required
+def get_subtitles():
+    try:
+        data = request.form
+        files = request.files
+
+        # Vytvoření projektové složky
+        project_name = data.get('project_name', 'untitled')
+        project_path = create_project_folder(project_name)
+
+        # Get file or URL or directory
+        media_file = None
+        link_media = ""
+        directory_input = ""
+        
+        # Handle file upload
+        if 'video' in files and files['video'].filename:
+            media_filer = files['video']
+            custom_filename = "video.mp4"
+            upload_paths = os.path.join(project_path, custom_filename)
+            os.makedirs(project_path, exist_ok=True)
+            media_filer.save(upload_paths)
+            media_file = upload_paths
+            print("Video saved to project:", media_file)
+
+            # Also save to uploads folder
+            upload_path = os.path.join('uploads', custom_filename)
+            os.makedirs('uploads', exist_ok=True)
+            shutil.copy(media_file, upload_path)
+            print("Video copied to uploads:", upload_path)
+            
+            # Save video path to session
+            session['video_path'] = media_file
+        
+        # Handle URL
+        elif 'url' in data and data['url'].strip():
+            link_media = data['url'].strip()
+            print("URL provided:", link_media)
+            session['video_url'] = link_media
+        
+        # Handle directory
+        elif 'directory' in data and data['directory'].strip():
+            directory_input = data['directory'].strip()
+            print("Directory provided:", directory_input)
+            session['directory_path'] = directory_input
+
+        # Get parameters
+        source_lang = data.get('source_language', 'Automatic detection')
+        target_lang = data.get('target_language', 'English (en)')
+        
+        # Process to get subtitles
+        result = soni.multilingual_media_conversion(
+            media_file=media_file,
+            link_media=link_media,
+            directory_input=directory_input,
+            origin_language=source_lang,
+            target_language=target_lang,
+            get_translated_text=True,
+            is_gui=True
+        )
+
+        # Save subtitles to session
+        if result:
+            session['subtitles'] = result
+            print("Subtitles saved to session")
+
+        print("Subtitles result:", result)
+        return jsonify({
+            'success': True, 
+            'subtitles': result,
+            'video_path': session.get('video_path'),
+            'video_url': session.get('video_url'),
+            'directory_path': session.get('directory_path')
+        })
+    except Exception as e:
+        print("Error in get_subtitles:", str(e))
+        return jsonify({'success': False, 'error': str(e)})
+
+@app.route('/edit_subtitles', methods=['POST'])
+@login_required
+def edit_subtitles():
+    try:
+        data = request.json
+        subtitle_text = data.get('subtitle_text', '')
+        
+        # Process the edited subtitles
+        # This would integrate with your existing subtitle processing logic
+        return jsonify({'success': True, 'message': 'Subtitles updated successfully'})
+    except Exception as e:
+        return jsonify({'success': False, 'error': str(e)})
+
+@app.route('/voice_imitation', methods=['POST'])
+@login_required
+def voice_imitation():
+    try:
+        data = request.form
+        files = request.files
+        
+        voice_imitation_enabled = data.get('voice_imitation', 'false').lower() == 'true'
+        voice_imitation_method = data.get('voice_imitation_method', 'freevc')
+        voice_imitation_max_segments = int(data.get('voice_imitation_max_segments', 3))
+        voice_imitation_vocals_dereverb = data.get('voice_imitation_vocals_dereverb', 'false').lower() == 'true'
+        voice_imitation_remove_previous = data.get('voice_imitation_remove_previous', 'true').lower() == 'true'
+        
+        return jsonify({'success': True})
+    except Exception as e:
+        return jsonify({'success': False, 'error': str(e)})
+
+@app.route('/get_voice_models', methods=['GET'])
+@login_required
+def get_voice_models():
+    try:
+        method = request.args.get('method', 'RVC')
+        models_dir = 'weights'
+        
+        if not os.path.exists(models_dir):
+            return jsonify({'success': False, 'error': 'Models directory not found'})
+            
+        # Get all .pth files from the weights directory
+        models = [f for f in os.listdir(models_dir) if f.endswith('.pth')]
+        
+        return jsonify({'success': True, 'models': models})
+    except Exception as e:
+        return jsonify({'success': False, 'error': str(e)})
+
+@app.route('/subtitle_settings', methods=['POST'])
+@login_required
+def subtitle_settings():
+    try:
+        data = request.form
+        
+        # Get subtitle settings
+        output_format = data.get('subtitle_format', 'srt')
+        soft_subtitles = data.get('soft_subtitles', 'false').lower() == 'true'
+        burn_subtitles = data.get('burn_subtitles', 'false').lower() == 'true'
+        
+        # Get Whisper settings
+        literalize_numbers = data.get('literalize_numbers', 'true').lower() == 'true'
+        vocal_refinement = data.get('vocal_refinement', 'false').lower() == 'true'
+        segment_duration = int(data.get('segment_duration', 15))
+        whisper_model = data.get('whisper_model', 'large-v3')
+        compute_type = data.get('compute_type', 'float16')
+        batch_size = int(data.get('batch_size', 8))
+        
+        # Get text segmentation settings
+        text_segmentation = data.get('text_segmentation', 'sentence')
+        divide_text_by = data.get('divide_text_by', '')
+        
+        # Get diarization and translation settings
+        diarization_model = data.get('diarization_model', 'pyannote_2.1')
+        translation_process = data.get('translation_process', 'google_translator_batch')
+        
+        return jsonify({'success': True})
+    except Exception as e:
+        return jsonify({'success': False, 'error': str(e)})
+
+@app.route('/output_settings', methods=['POST'])
+@login_required
+def output_settings():
+    try:
+        data = request.form
+        
+        # Get output settings
+        output_type = data.get('output_type', 'video (mp4)')
+        output_name = data.get('output_name', '')
+        play_sound = data.get('play_sound', 'true').lower() == 'true'
+        enable_cache = data.get('enable_cache', 'true').lower() == 'true'
+        preview = data.get('preview', 'false').lower() == 'true'
+        
+        return jsonify({'success': True})
+    except Exception as e:
+        return jsonify({'success': False, 'error': str(e)})
+
+@app.route('/save_srt', methods=['POST'])
+@login_required
+def save_srt():
+    try:
+        data = request.json
+        srt_content = data.get('srt_content')
+        project_name = data.get('project_name')
+        
+        if not srt_content or not project_name:
+            return jsonify({'success': False, 'error': 'Missing required data'})
+        video_path = session.get('video_path')
+
+        # Create project directory with timestamp like in /translate
+        #timestamp = datetime.now().strftime("%d-%m-%Y-%H-%M")
+        #project_path = os.path.join('exports', f"{timestamp}-{project_name}")
+        #os.makedirs(project_path, exist_ok=True)
+        if video_path:
+            # Úprava řetězce pomocí regulárních výrazů
+            cleaned_path = re.sub(r'^exports\\', '', video_path)  # Odstraní 'exports\' na začátku
+            cleaned_path = re.sub(r'\\video\.mp4$', '', cleaned_path)  # Odstraní '\video.mp4' na konci
+
+            print(cleaned_path)
+        else:
+            print("Hodnota video_path není v session.")
+
+        project_path = os.path.join('exports', cleaned_path)
+
+
+        # Save SRT file in the same directory as video
+        srt_path = os.path.join(project_path, 'titulky.srt')
+        with open(srt_path, 'w', encoding='utf-8') as f:
+            f.write(srt_content)
+            
+        return jsonify({'success': True})
+    except Exception as e:
+        return jsonify({'success': False, 'error': str(e)})
+
+@app.route('/purge', methods=['POST'])
+@login_required
+def purge_folders():
+    try:
+        # Seznam složek k vymazání
+        folders = ['outputs', 'audio']
+        
+        for folder in folders:
+            if os.path.exists(folder):
+                # Vymaže obsah složky
+                for filename in os.listdir(folder):
+                    file_path = os.path.join(folder, filename)
+                    try:
+                        if os.path.isfile(file_path) or os.path.islink(file_path):
+                            os.unlink(file_path)
+                        elif os.path.isdir(file_path):
+                            shutil.rmtree(file_path)
+                    except Exception as e:
+                        print(f'Failed to delete {file_path}. Reason: {e}')
+        
+        return jsonify({'success': True, 'message': 'Složky byly úspěšně vymazány'})
+    except Exception as e:
+        return jsonify({'success': False, 'error': str(e)})
+
+@app.route('/get_current_video_path', methods=['GET'])
+@login_required
+def get_current_video_path():
+    video_path = session.get('current_video_path')
+    if video_path:
+        return jsonify({
+            'success': True, 
+            'video_path': video_path,
+            'filename': os.path.basename(video_path)
+        })
+    return jsonify({'success': False, 'error': 'No video path in session'})
+
+#if __name__ == '__main__':
+#    app.run(debug=True)