Added UUID & Media Metadata

helperfunctions.py

@@ -1,7 +1,29 @@
 import os
+import time
+import uuid
+import hashlib
 import subprocess
 
 
+def generate_uuid(user_ip, url):
+    """
+    Generates a uuid based on User IP, URL & timestamp
+    """
+    # Converting User IP to bytes and Hashing it using SHA-1
+    user_ip_bytes = user_ip.encode('utf-8')
+    hashed_user_ip = hashlib.sha1(user_ip_bytes).hexdigest()
+    
+    # Converting URL to bytes and Hashing it using SHA-1
+    url_bytes = url.encode('utf-8')
+    hashed_url = hashlib.sha1(url_bytes).hexdigest()
+
+    # Combining Hashed User IP, URL and Current Timestamp to Create a Unique Identifier
+    unique_id = f"{hashed_user_ip}-{hashed_url}-{int(time.time())}"
+
+    # Generate a UUID from the Unique Identifier
+    uuid_value = uuid.uuid5(uuid.NAMESPACE_URL, unique_id)
+    return str(uuid_value)
+
 def extract_audio(video_path):
     """
     Extract audio from a video file (MP4 or WebM) and save it as an MP3 file using ffmpeg.
@@ -62,7 +84,6 @@ def convert_to_srt_time_format(seconds):
     '''
     Converts seconds into .srt format
     '''
-
     try:
         hours = seconds // 3600
         seconds %= 3600
@@ -78,7 +99,6 @@ def save_translated_subtitles(subtitles, media_path):
     '''
     Saves the translated subtitles into .srt file
     '''
-
     try:
         # Converting to SRT Format
         srt_content = ""
@@ -103,4 +123,23 @@ def save_translated_subtitles(subtitles, media_path):
         return subtitles_filename
     
     except Exception as e:
-        print(f"Error in save_translated_subtitles: {e}")
+        print(f"Error in save_translated_subtitles: {e}")
+
+def convert_audio(input_file, audio_format, audio_quality):
+    '''
+    Converts the audio according to the given audio parameters
+    '''
+    try:
+        # Getting Output File Path
+        output_file = f"{input_file.rsplit('.', 1)[0]}_converted.{audio_format}"
+
+        # Running the command using Subprocess
+        command = [
+            'ffmpeg', '-i', input_file,
+            '-b:a', audio_quality[:-3], output_file, 
+            '-loglevel', 'quiet'
+        ]
+        subprocess.run(command)
+    
+    except Exception as e:
+        print(f"Error in convert_audio: {e}")

main.py

@@ -1,22 +1,44 @@
 import os
 import json
 
-# import pytorch_test
-
 import uvicorn
 from fastapi import FastAPI, Request
 from fastapi.middleware.cors import CORSMiddleware
+from contextlib import asynccontextmanager
 
+from models import load_models
+from helperfunctions import *
 from media_download import YoutubeDownloader
 # from transcription import StableWhisper
 # from summarizer import Extract_Summary, AudioBookNarration
 # from audiobook import AudioBook
-from helperfunctions import *
+
+global MODELS
 
 
 ### API Configurations
 
-app = FastAPI()
+# Context Manager for FastAPI Start/Shutdown
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+
+    ## FastAPI Startup Code
+    
+    # TODO
+    # Loading ML models
+    print('Loading ML Models..')
+    MODELS = load_models()
+    print('ML Models Loaded!')
+    
+    yield
+
+    ## FastAPI Shutdown Code
+    
+    # Cleaning ML Models & Releasing the Resources
+    MODELS.clear()
+
+# Initializing FastAPI App
+app = FastAPI(lifespan=lifespan)
 
 # Output Directory for Files Storage
 output_folder = 'Output'
@@ -44,9 +66,9 @@ app.add_middleware(
 @app.get("/get_media_metadata")
 async def get_media_metadata(request: Request, url: str):
 
-    # Getting User's IP
-    # user_ip = request.client.host
-    user_ip = 1
+    # Getting User's IP & Generating UUID
+    user_ip = request.client.host
+    user_id = generate_uuid(user_ip, url)
 
     # Getting User's Youtube Downloader
     youtube_downloader = YoutubeDownloader(url, output_folder)
@@ -59,67 +81,55 @@ async def get_media_metadata(request: Request, url: str):
     
     if status:
         # Storing Info in the context for this user's session
-        users_context[user_ip] = dict()
-        users_context[user_ip]['downloader'] = youtube_downloader
-        # users_context[user_ip]['media_metadata'] = media_metadata
-        users_context[user_ip]['url'] = url
+        users_context[user_id] = dict()
+        users_context[user_id]['downloader'] = youtube_downloader
+        # users_context[user_id]['media_metadata'] = media_metadata
+        users_context[user_id]['url'] = url
     
-    return {'status': status, 'media_metadata': media_metadata}
+    return {'status': status, 'user_id': user_id, 'media_metadata': media_metadata}
 
 
 @app.get("/get_media_formats")
-async def get_media_formats(request: Request):
-
-    # Getting User's IP
-    # user_ip = request.client.host
-    user_ip = 1
+async def get_media_formats(user_id: str):
     
     # Downloading Media for User
-    media_formats = users_context[user_ip]['downloader'].get_media_formats()
+    media_formats = users_context[user_id]['downloader'].get_media_formats()
     
     # Getting Status
     status = 1 if media_formats else 0
 
     if status:
         # Storing Media Info in the context for this user's session
-        users_context[user_ip]['media_formats'] = media_formats
+        users_context[user_id]['media_formats'] = media_formats
     
     return {'status': status, 'media_formats': media_formats}
 
 
 @app.get("/download_media")
-async def download_media(request: Request, media_type: str, media_format: str, media_quality: str):
-
-    # Getting User's IP
-    # user_ip = request.client.host
-    user_ip = 1
+async def download_media(user_id: str, media_type: str, media_format: str, media_quality: str):
     
     # Downloading Media for User
-    media_path = users_context[user_ip]['downloader'].download(media_type, media_format, media_quality)
+    media_path = users_context[user_id]['downloader'].download(media_type, media_format, media_quality)
     
     # Getting Status
     status = 1 if media_path else 0
 
     if status:
         # Storing Media Info in the context for this user's session
-        users_context[user_ip]['media_path'] = media_path
-        users_context[user_ip]['media_type'] = media_type
+        users_context[user_id]['media_path'] = media_path
+        users_context[user_id]['media_type'] = media_type
     
     return {'status': status, 'media_path': media_path}
 
 
 @app.get("/get_transcript")
-async def get_transcript(request: Request, subtitle_format: str = 'srt', word_level: bool = False):
-    
-    # Getting User's IP
-    # user_ip = request.client.host
-    user_ip = 1
+async def get_transcript(user_id: str, subtitle_format: str = 'srt', word_level: bool = False):
     
     # Retrieving the media_path from the context for this user's session
-    media_path = users_context[user_ip]['media_path']
+    media_path = users_context[user_id]['media_path']
 
     # Checking if the media_type is Video, then extract it's audio
-    media_type = users_context[user_ip]['media_type']
+    media_type = users_context[user_id]['media_type']
     if media_type == 'video':
         media_path = extract_audio(media_path)
 
@@ -144,21 +154,17 @@ async def get_transcript(request: Request, subtitle_format: str = 'srt', word_le
 
     if status:
         # Storing Transcript Info in the context for this user's session
-        users_context[user_ip]['transcript'] = transcript
-        users_context[user_ip]['transcript_path'] = transcript_path
+        users_context[user_id]['transcript'] = transcript
+        users_context[user_id]['transcript_path'] = transcript_path
     
     return {'status': status, "transcript": transcript}
 
 
 @app.get("/get_translation")
-async def get_translation(request: Request, target_language: str = 'en'):
-    
-    # Getting User's IP
-    # user_ip = request.client.host
-    user_ip = 1
+async def get_translation(user_id: str, target_language: str = 'en'):
     
     # Retrieving the transcript from the context for this user's session
-    transcript = users_context[user_ip]['transcript']
+    transcript = users_context[user_id]['transcript']
 
     # # # NLLB based Translation
     # nllb_translator = Translation(transcript, transcript['language'], target_language, 'output_path')
@@ -180,24 +186,20 @@ async def get_translation(request: Request, target_language: str = 'en'):
 
     if status:
         # Storing Translated Transcript Info in the context for this user's session
-        users_context[user_ip]['translated_transcript'] = translated_transcript
-        users_context[user_ip]['translated_subtitles'] = translated_subtitles
-        # users_context[user_ip]['transcript_path'] = transcript_path
+        users_context[user_id]['translated_transcript'] = translated_transcript
+        users_context[user_id]['translated_subtitles'] = translated_subtitles
+        # users_context[user_id]['transcript_path'] = transcript_path
     
     return {'status': status, "transcript": translated_transcript, "subtitles": translated_subtitles}
 
 
 @app.get("/get_summary")
-async def get_summary(request: Request, Summary_type: str, Summary_strategy: str, Target_Person_type: str,
+async def get_summary(user_id: str, Summary_type: str, Summary_strategy: str, Target_Person_type: str,
                       Response_length:  str, Writing_style: str, text_input: str = None):
-    
-    # Getting User's IP
-    # user_ip = request.client.host
-    user_ip = 1
 
     # Getting Transcript if not provided
     if not text_input:
-        text_input = users_context[user_ip]['transcript']
+        text_input = users_context[user_id]['transcript']
     
     # # Extracting Summary
     # summary_extractor = Extract_Summary(text_input=text_input)
@@ -219,22 +221,18 @@ async def get_summary(request: Request, Summary_type: str, Summary_strategy: str
 
     if status:
         # Storing Summary Info in the context for this user's session
-        users_context[user_ip]['summary'] = output
+        users_context[user_id]['summary'] = output
     
     return {'status': status, "summary": output}
 
 
 @app.get("/get_key_info")
-async def get_key_info(request: Request, Summary_type: str, Summary_strategy: str, Target_Person_type: str, 
+async def get_key_info(user_id: str, Summary_type: str, Summary_strategy: str, Target_Person_type: str, 
                        Response_length: str, Writing_style: str, text_input: str = None):
-    
-    # Getting User's IP
-    # user_ip = request.client.host
-    user_ip = 1
 
     # Getting Transcript if not provided
     if not text_input:
-        text_input = users_context[user_ip]['transcript']
+        text_input = users_context[user_id]['transcript']
     
     # # Extracting Summary
     # summary_extractor = Extract_Summary(text_input=text_input)
@@ -256,52 +254,18 @@ async def get_key_info(request: Request, Summary_type: str, Summary_strategy: st
 
     if status:
         # Storing Key Info in the context for this user's session
-        users_context[user_ip]['key_info'] = output
+        users_context[user_id]['key_info'] = output
     
     return {'status': status, "key_info": output}
 
 
-# @app.get("/get_narration")
-# async def get_narration(request: Request, narration_style: str, text_input: str = None):
-    
-#     # Getting User's IP
-#     # user_ip = request.client.host
-#     user_ip = 1
-
-#     # Getting Transcript if not provided
-#     if not text_input:
-#         text_input = users_context[user_ip]['transcript']
-    
-#     # # Extracting Narration
-#     # narrator = AudioBookNarration(text_input=text_input)
-#     # output = narrator.define_chain(narration_style=narration_style)
-
-#     temp_dir = 'temp'
-#     file_path = os.path.join(temp_dir, 'narration.txt')
-#     with open(file_path, 'r') as file:
-#         output = file.read()
-    
-
-#     # Getting Status
-#     status = 1 if output else 0
-
-#     if status:
-#         # Storing Narration Info in the context for this user's session
-#         users_context[user_ip]['narration'] = output
-    
-#     return {'status': status, "narration": output}
-
-
 @app.get("/get_audiobook")
-async def get_audiobook(request: Request, output_type : str, narration_style: str, speaker: str = "male", text_input: str = None):
-
-    # Getting User's IP
-    # user_ip = request.client.host
-    user_ip = 1
+async def get_audiobook(user_id: str, narration_style: str, speaker: str = "male", text_input: str = None, 
+                        audio_format: str = "mp3", audio_quality: str = "128kbps"):
 
     # Getting Transcript if not provided
     if not text_input:
-        text_input = users_context[user_ip]['transcript']
+        text_input = users_context[user_id]['transcript']
     
     # # Extracting Narration
 
@@ -312,6 +276,9 @@ async def get_audiobook(request: Request, output_type : str, narration_style: st
     # audiobook = AudioBook(output_folder=output_folder)
     # audio_path = audiobook.generate_audio_from_text(output, speaker=speaker, filename="output_audio")
     
+    # # Converting the Audio to Required Audio Parameters
+    # audio_path = convert_audio(audio_path, audio_format, audio_quality)
+    
     temp_dir = 'temp'
     file_path = os.path.join(temp_dir, 'narration.txt')
 
@@ -322,29 +289,28 @@ async def get_audiobook(request: Request, output_type : str, narration_style: st
 
     if status:
         # Storing Audiobook path in the context for this user's session
-        users_context[user_ip]['audiobook_path'] = audio_path
+        users_context[user_id]['audiobook_path'] = audio_path
     
     return {'status': status, "audiobook_path": audio_path}
 
 
 @app.get("/get_rendered_video")
-async def get_rendered_video(request: Request, subtitles_type: str = 'original'):
+async def get_rendered_video(user_id: str, video_format: str, video_quality: str, subtitles_type: str = 'original'):
 
-    # Getting User's IP
-    # user_ip = request.client.host
-    user_ip = 1
+    # # Retrieving the media_path from the context for this user's session
+    # media_path = users_context[user_id]['media_path']
 
-    # Retrieving the media_path from the context for this user's session
-    media_path = users_context[user_ip]['media_path']
+    # Downloading Video with Required Video Parameters for User
+    media_path = users_context[user_id]['downloader'].download('video', video_format, video_quality)
     
     # Getting Required Subtitles
-    if subtitles_type == 'original':
-        subtitles_path = users_context[user_ip]['transcript_path']
+    if subtitles_type.lower() == 'original':
+        subtitles_path = users_context[user_id]['transcript_path']
 
-    elif subtitles_type == 'translated':
+    elif subtitles_type.lower() == 'translated':
 
         # Getting Translated Subtitles from the context for this user's session
-        translated_subtitles = users_context[user_ip]['translated_subtitles']
+        translated_subtitles = users_context[user_id]['translated_subtitles']
 
         # Saving Translated Subtitles
         subtitles_path = save_translated_subtitles(translated_subtitles, media_path)

media_download.py

@@ -2,7 +2,9 @@ import os
 import re
 import json
 import time
+import locale
 import subprocess
+from yt_dlp import YoutubeDL
 
 import numpy as np
 import pandas as pd
@@ -71,6 +73,7 @@ class YoutubeDownloader(MediaDownloader):
         self.thumbnail_url = self.youtube.thumbnail_url
         self.streams = self.youtube.streams
         self.streams_df, self.media_formats_dict = self._get_supported_media_formats()
+        self.num_likes, self.num_views = self._get_num_likes_views()
         
     def get_media_formats(self):
         '''
@@ -78,17 +81,45 @@ class YoutubeDownloader(MediaDownloader):
         '''
         return self.media_formats_dict
     
+    def _get_num_likes_views(self):
+        '''
+        Returns the number of likes & views in the video
+        '''
+
+        with YoutubeDL() as ydl:
+            info = ydl.extract_info(self.url, download=False)
+            num_likes = info.get('like_count', None)
+            num_views = info.get('view_count', None)
+            # num_comments = info.get('comment_count', None)
+
+        return num_likes, num_views
+    
     def get_media_metadata(self):
         '''
         Returns a dictionary for media metadata
         '''
         media_info = {
-            'title': self.title,
-            'media_length': self.media_length,
+            'title': self.title, 
+            'num_likes': self.__format_number(self.num_likes), 
+            'num_views': self.__format_number(self.num_views), 
+            'media_length': self.media_length, 
             'thumbnail_url': self.thumbnail_url
         }
         return media_info
     
+    @staticmethod
+    def __format_number(num):
+        '''
+        Returns the formatted number
+        E.g: Given input 123456789, it returns 123,456,789
+        '''
+        # Setting the Locale
+        locale.setlocale(locale.LC_ALL, '')
+
+        # Formatting the Number with Commas
+        num = locale.format_string("%d", num, grouping=True)
+        return num
+
     @staticmethod
     def __get_quality_int(media_quality):
         '''

models.py

@@ -0,0 +1,23 @@
+import os
+import sys
+import torch
+
+
+def load_models():
+    '''
+    Checks CUDA availability & loads models
+    '''
+    try:
+        print(f"CUDA Available: {torch.cuda.is_available()}")
+        print(f"CUDA Device: {torch.cuda.get_device_name(torch.cuda.current_device())}")
+        
+        # TODO: Load Models Code Here (Refactor Exisitng Models Loading)
+        MODELS = {}
+        return MODELS
+
+    except KeyboardInterrupt:
+        print('Interrupted')
+        try:
+            sys.exit(0)
+        except SystemExit:
+            os._exit(0)

pytorch_test.py

@@ -1,4 +0,0 @@
-import torch
-
-print(f"CUDA available: {torch.cuda.is_available()}")
-print(f"CUDA device: {torch.cuda.get_device_name(torch.cuda.current_device())}")