app_pages/video_translator.py

import streamlit as st
import tempfile
import replicate
import os
import requests
from dotenv import load_dotenv

load_dotenv()


def render_video_translator(uid: str):
    st.markdown("####  Video Translator")

    uploaded_file = st.file_uploader(
        "Upload a video to translate",
        type=["mp4", "mov", "avi", "mkv", "webm"]
    )

    output_language = st.selectbox(
        "Select target translation language:",
        [  "English",
        "Spanish",
        "French",
        "Hindi",
        "Italian",
        "German",
        "Polish",
        "Portuguese",
        "Chinese",
        "Japanese",
        "Dutch",
        "Turkish",
        "Korean",
        "Danish",
        "Arabic",
        "Romanian",
        "Mandarin",
        "Filipino",
        "Swedish",
        "Indonesian",
        "Ukrainian",
        "Greek",
        "Czech",
        "Bulgarian",
        "Malay",
        "Slovak",
        "Croatian",
        "Tamil",
        "Finnish",
        "Russian",
        "Afrikaans (South Africa)",
        "Albanian (Albania)",
        "Amharic (Ethiopia)",
        "Arabic (Algeria)",
        "Arabic (Bahrain)",
        "Arabic (Egypt)",
        "Arabic (Iraq)",
        "Arabic (Jordan)",
        "Arabic (Kuwait)",
        "Arabic (Lebanon)",
        "Arabic (Libya)",
        "Arabic (Morocco)",
        "Arabic (Oman)",
        "Arabic (Qatar)",
        "Arabic (Saudi Arabia)",
        "Arabic (Syria)",
        "Arabic (Tunisia)",
        "Arabic (United Arab Emirates)",
        "Arabic (Yemen)",
        "Armenian (Armenia)",
        "Azerbaijani (Latin, Azerbaijan)",
        "Bangla (Bangladesh)",
        "Basque",
        "Bengali (India)",
        "Bosnian (Bosnia and Herzegovina)",
        "Bulgarian (Bulgaria)",
        "Burmese (Myanmar)",
        "Catalan",
        "Chinese (Cantonese, Traditional)",
        "Chinese (Jilu Mandarin, Simplified)",
        "Chinese (Mandarin, Simplified)",
        "Chinese (Northeastern Mandarin, Simplified)",
        "Chinese (Southwestern Mandarin, Simplified)",
        "Chinese (Taiwanese Mandarin, Traditional)",
        "Chinese (Wu, Simplified)",
        "Chinese (Zhongyuan Mandarin Henan, Simplified)",
        "Chinese (Zhongyuan Mandarin Shaanxi, Simplified)",
        "Croatian (Croatia)",
        "Czech (Czechia)",
        "Danish (Denmark)",
        "Dutch (Belgium)",
        "Dutch (Netherlands)",
        "English (Australia)",
        "English (Canada)",
        "English (Hong Kong SAR)",
        "English (India)",
        "English (Ireland)",
        "English (Kenya)",
        "English (New Zealand)",
        "English (Nigeria)",
        "English (Philippines)",
        "English (Singapore)",
        "English (South Africa)",
        "English (Tanzania)",
        "English (UK)",
        "English (United States)",
        "Estonian (Estonia)",
        "Filipino (Philippines)",
        "Finnish (Finland)",
        "French (Belgium)",
        "French (Canada)",
        "French (France)",
        "French (Switzerland)",
        "Galician",
        "Georgian (Georgia)",
        "German (Austria)",
        "German (Germany)",
        "German (Switzerland)",
        "Greek (Greece)",
        "Gujarati (India)",
        "Hebrew (Israel)",
        "Hindi (India)",
        "Hungarian (Hungary)",
        "Icelandic (Iceland)",
        "Indonesian (Indonesia)",
        "Irish (Ireland)",
        "Italian (Italy)",
        "Japanese (Japan)",
        "Javanese (Latin, Indonesia)",
        "Kannada (India)",
        "Kazakh (Kazakhstan)",
        "Khmer (Cambodia)",
        "Korean (Korea)",
        "Lao (Laos)",
        "Latvian (Latvia)",
        "Lithuanian (Lithuania)",
        "Macedonian (North Macedonia)",
        "Malay (Malaysia)",
        "Malayalam (India)",
        "Maltese (Malta)",
        "Marathi (India)",
        "Mongolian (Mongolia)",
        "Nepali (Nepal)",
        "Norwegian Bokmål (Norway)",
        "Pashto (Afghanistan)",
        "Persian (Iran)",
        "Polish (Poland)",
        "Portuguese (Brazil)",
        "Portuguese (Portugal)",
        "Romanian (Romania)",
        "Russian (Russia)",
        "Serbian (Latin, Serbia)",
        "Sinhala (Sri Lanka)",
        "Slovak (Slovakia)",
        "Slovenian (Slovenia)",
        "Somali (Somalia)",
        "Spanish (Argentina)",
        "Spanish (Bolivia)",
        "Spanish (Chile)",
        "Spanish (Colombia)",
        "Spanish (Costa Rica)",
        "Spanish (Cuba)",
        "Spanish (Dominican Republic)",
        "Spanish (Ecuador)",
        "Spanish (El Salvador)",
        "Spanish (Equatorial Guinea)",
        "Spanish (Guatemala)",
        "Spanish (Honduras)",
        "Spanish (Mexico)",
        "Spanish (Nicaragua)",
        "Spanish (Panama)",
        "Spanish (Paraguay)",
        "Spanish (Peru)",
        "Spanish (Puerto Rico)",
        "Spanish (Spain)",
        "Spanish (United States)",
        "Spanish (Uruguay)",
        "Spanish (Venezuela)",
        "Sundanese (Indonesia)",
        "Swahili (Kenya)",
        "Swahili (Tanzania)",
        "Swedish (Sweden)",
        "Tamil (India)",
        "Tamil (Malaysia)",
        "Tamil (Singapore)",
        "Tamil (Sri Lanka)",
        "Telugu (India)",
        "Thai (Thailand)",
        "Turkish (Türkiye)",
        "Ukrainian (Ukraine)",
        "Urdu (India)",
        "Urdu (Pakistan)",
        "Uzbek (Latin, Uzbekistan)",
        "Vietnamese (Vietnam)",
        "Welsh (United Kingdom)",
        "Zulu (South Africa)",
        "English - Your Accent",
        "English - American Accent"
      ],
    )

    translate_clicked = st.button(
        "Translate Video",
        type="primary",
        width='stretch',
        disabled=uploaded_file is None
    )

    if uploaded_file:
        st.success(f"Uploaded: `{uploaded_file.name}` ({uploaded_file.size / 1024 / 1024:.2f} MB)")
        st.markdown("###  Original Video")
        col1, col2 = st.columns([1,1])  
        with col1:
            st.video(uploaded_file)
        

    if translate_clicked and uploaded_file:
        with st.spinner("Translating video... please wait "):
            try:
                
                with tempfile.NamedTemporaryFile(delete=False, suffix=".mp4") as tmp:
                    tmp.write(uploaded_file.read())
                    video_path = tmp.name

                
                st.info(f"Translating to {output_language}...")
                model_version = "heygen/video-translate"

                with open(video_path, "rb") as video_file:
                    output = replicate.run(
                        model_version,
                        input={
                            "video": video_file,
                            "output_language": output_language
                        }
                    )

                
                output_url = None
                if isinstance(output, str):
                    output_url = output
                elif isinstance(output, list):
                    output_url = output[0]
                elif hasattr(output, "url"):
                    
                    output_url = output.url
                else:
                    st.error(" Unexpected output format from Replicate model.")
                    st.json(str(output))
                    return

                st.success(" Translation complete!")
                st.markdown("### Translated Video")
                col1, col2 = st.columns([1,1])
                with col1:
                    st.video(output_url)
               

               
                response = requests.get(output_url)
                translated_path = os.path.join(tempfile.gettempdir(), f"translated_{uploaded_file.name}")
                with open(translated_path, "wb") as f:
                    f.write(response.content)

                st.download_button(
                    label=" Download Translated Video",
                    data=open(translated_path, "rb").read(),
                    file_name=f"translated_{uploaded_file.name}",
                    mime="video/mp4",
                    width='stretch'
                )

            except Exception as e:
                st.error(f" Translation failed: {str(e)}")