Spaces:

shukdevdatta123
/

Video-Transcriber

Paused

File size: 11,013 Bytes

import streamlit as st
import moviepy.editor as mp
import speech_recognition as sr
from pydub import AudioSegment
import tempfile
import os
import io
import requests
import execjs
import re
import json

# Function to convert video to audio
def video_to_audio(video_file):
    # Load the video using moviepy
    video = mp.VideoFileClip(video_file)
    
    # Extract audio
    audio = video.audio
    temp_audio_path = tempfile.mktemp(suffix=".mp3")
    
    # Write the audio to a file
    audio.write_audiofile(temp_audio_path)
    return temp_audio_path

# Function to convert MP3 audio to WAV
def convert_mp3_to_wav(mp3_file):
    # Load the MP3 file using pydub
    audio = AudioSegment.from_mp3(mp3_file)
    
    # Create a temporary WAV file
    temp_wav_path = tempfile.mktemp(suffix=".wav")
    
    # Export the audio to the temporary WAV file
    audio.export(temp_wav_path, format="wav")
    return temp_wav_path

# Function to transcribe audio to text
def transcribe_audio(audio_file):
    # Initialize recognizer
    recognizer = sr.Recognizer()
    
    # Load the audio file using speech_recognition
    audio = sr.AudioFile(audio_file)
    
    with audio as source:
        audio_data = recognizer.record(source)
    
    try:
        # Transcribe the audio data to text using Google Web Speech API
        text = recognizer.recognize_google(audio_data)
        return text
    except sr.UnknownValueError:
        return "Audio could not be understood."
    except sr.RequestError:
        return "Could not request results from Google Speech Recognition service."

# Function to get the HTML of the page
def gethtml(url):
    headers = {
        "cache-Control": "no-cache",
        "accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9",
        "accept-encoding": "gzip, deflate, br",
        "accept-language": "en-US,en;q=0.9",
        "content-type": "application/x-www-form-urlencoded",
        "user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/87.0.4280.88 Safari/537.36"
    }
    kv = {"sf_url": url,
          "sf_submit": "",
          "new": "1",
          "lang": "en",
          "app": "",
          "country": "us",
          "os": "Windows",
          "browser": "Chrome"}
    r = requests.post(url="https://en.savefrom.net/savefrom.php", headers=headers, data=kv)
    r.raise_for_status()
    return r.text

# Function to extract the video download URL
def extract_video_url(youtube_url):
    try:
        # Get the HTML content of the YouTube page
        reo = gethtml(youtube_url)
        
        # Try extracting the relevant script tag containing download information
        try:
            reo = reo.split("<script type=\"text/javascript\">")[1].split("</script>")[0]
        except IndexError:
            raise ValueError("Could not find the script containing video data in the HTML response.")
        
        # Modify the script to allow extraction
        reo = reo.replace("(function(){", "(function(){\nthis.alert=function(){};")
        reA = reo.split("\n")
        
        if len(reA) < 3:
            raise ValueError("Could not extract valid script data from the YouTube page.")
        
        # Extract the JSON object containing the video download URLs
        name = reA[len(reA) - 3].split(";")[0] + ";"
        addition = """
        const jsdom = require("jsdom");
        const { JSDOM } = jsdom;
        const dom = new JSDOM(`<!DOCTYPE html><p>Hello world</p>`);
        window = dom.window;
        document = window.document;
        XMLHttpRequest = window.XMLHttpRequest;
        """
        ct = execjs.compile(addition + reo, cwd=r'C:\Users\19308\AppData\Roaming\npm\node_modules')
        text = ct.eval(name.split("=")[1].replace(";", ""))
        
        # Extract and parse the JSON
        try:
            result = re.search('show\((.*?)\);;', text, re.I | re.M)
            if result is None:
                raise ValueError("No valid video download URL found in the extracted data.")
            
            result = result.group(0).replace("show(", "").replace(");;", "")
            j = json.loads(result)
            
            # Ensure the JSON contains the expected download URLs
            if "url" not in j or len(j["url"]) == 0:
                raise ValueError("No valid download links found in the extracted data.")
            
            # Assuming the first video URL is what we want (or try a different index if necessary)
            downurl = j["url"][0]["url"]
            return downurl
        
        except (IndexError, KeyError, json.JSONDecodeError) as e:
            raise ValueError(f"Error occurred while extracting the download URL: {e}")
    
    except Exception as e:
        raise ValueError(f"Error occurred while extracting the download URL: {e}")

# Streamlit app layout
st.title("Video and Audio to Text Transcription")
st.write("Upload a video or audio file to convert it to transcription, or enter a YouTube URL to download the video.")

# Create tabs to separate video, audio, and YouTube download options
tab = st.selectbox("Select the type of file to upload or download", ["Video", "Audio", "YouTube"])

if tab == "Video":
    # File uploader for video
    uploaded_video = st.file_uploader("Upload Video", type=["mp4", "mov", "avi"])

    if uploaded_video is not None:
        # Save the uploaded video file temporarily
        with tempfile.NamedTemporaryFile(delete=False) as tmp_video:
            tmp_video.write(uploaded_video.read())
            tmp_video_path = tmp_video.name

        # Add an "Analyze Video" button
        if st.button("Analyze Video"):
            with st.spinner("Processing video... Please wait."):
                # Convert video to audio
                audio_file = video_to_audio(tmp_video_path)
                
                # Convert the extracted MP3 audio to WAV
                wav_audio_file = convert_mp3_to_wav(audio_file)
                
                # Transcribe audio to text
                transcription = transcribe_audio(wav_audio_file)

                # Show the transcription
                st.text_area("Transcription", transcription, height=300)

                # Store transcription and audio file in session state
                st.session_state.transcription = transcription
                
                # Store the audio file as a BytesIO object in memory
                with open(wav_audio_file, "rb") as f:
                    audio_data = f.read()
                    st.session_state.wav_audio_file = io.BytesIO(audio_data)

                # Cleanup temporary files
                os.remove(tmp_video_path)
                os.remove(audio_file)

    # Check if transcription and audio file are stored in session state
    if 'transcription' in st.session_state and 'wav_audio_file' in st.session_state:
        # Provide the audio file to the user for download
        st.audio(st.session_state.wav_audio_file, format='audio/wav')
        
        # Add download buttons for the transcription and audio
        # Downloadable transcription file
        st.download_button(
            label="Download Transcription",
            data=st.session_state.transcription,
            file_name="transcription.txt",
            mime="text/plain"
        )
        
        # Downloadable audio file
        st.download_button(
            label="Download Audio",
            data=st.session_state.wav_audio_file,
            file_name="converted_audio.wav",
            mime="audio/wav"
        )

elif tab == "Audio":
    # File uploader for audio
    uploaded_audio = st.file_uploader("Upload Audio", type=["wav", "mp3"])

    if uploaded_audio is not None:
        # Save the uploaded audio file temporarily
        with tempfile.NamedTemporaryFile(delete=False) as tmp_audio:
            tmp_audio.write(uploaded_audio.read())
            tmp_audio_path = tmp_audio.name

        # Add an "Analyze Audio" button
        if st.button("Analyze Audio"):
            with st.spinner("Processing audio... Please wait."):
                # Convert audio to WAV if it's in MP3 format
                if uploaded_audio.type == "audio/mpeg":
                    wav_audio_file = convert_mp3_to_wav(tmp_audio_path)
                else:
                    wav_audio_file = tmp_audio_path
                
                # Transcribe audio to text
                transcription = transcribe_audio(wav_audio_file)

                # Show the transcription
                st.text_area("Transcription", transcription, height=300)

                # Store transcription in session state
                st.session_state.transcription_audio = transcription
                
                # Store the audio file as a BytesIO object in memory
                with open(wav_audio_file, "rb") as f:
                    audio_data = f.read()
                    st.session_state.wav_audio_file_audio = io.BytesIO(audio_data)

                # Cleanup temporary audio file
                os.remove(tmp_audio_path)

        # Check if transcription and audio file are stored in session state
        if 'transcription_audio' in st.session_state and 'wav_audio_file_audio' in st.session_state:
            # Provide the audio file to the user for download
            st.audio(st.session_state.wav_audio_file_audio, format='audio/wav')
            
            # Add download buttons for the transcription and audio
            # Downloadable transcription file
            st.download_button(
                label="Download Transcription",
                data=st.session_state.transcription_audio,
                file_name="transcription_audio.txt",
                mime="text/plain"
            )
            
            # Downloadable audio file
            st.download_button(
                label="Download Audio",
                data=st.session_state.wav_audio_file_audio,
                file_name="converted_audio_audio.wav",
                mime="audio/wav"
            )

# Streamlit UI for YouTube video download
elif tab == "YouTube":
    st.title("YouTube Video Downloader")
    st.write("""This app allows you to download YouTube videos in various formats. Simply enter the YouTube URL below and click "Get Download Link".""")

    youtube_url = st.text_input("Enter YouTube Video URL", "https://www.youtube.com/watch?v=YPvtz1lHRiw")

    if st.button("Get Download Link"):
        if youtube_url:
            try:
                download_url = extract_video_url(youtube_url)
                st.success("Download link generated successfully!")
                st.write("Click below to download the video:")
                st.markdown(f"[Download Video]({download_url})", unsafe_allow_html=True)
            except Exception as e:
                st.error(f"Error occurred: {e}")
        else:
            st.error("Please enter a valid YouTube URL.")