Add posibility to get instagram videos and use those videos as base

Author: leamsigc-reflect

Backend/classes/Shorts.py

@@ -236,6 +236,7 @@ def DownloadVideos(self, selectedVideoUrls):
                 )
             try:
                 saved_video_path = save_video(video_url)
+                print(colored(f"[+] Saved video: {saved_video_path}", "green"))
                 video_paths.append(saved_video_path)
             except Exception:
                 print(colored(f"[-] Could not download video: {video_url}", "red"))
@@ -277,19 +278,19 @@ def GenerateVoice(self,voice):
                     }
                 )
             fileId = uuid4()
-            current_tts_path = f"../static/assets/temp/{fileId}.mp3"
+            current_tts_path = os.path.join("static/assets/temp", f"{fileId}.mp3")
             tts(sentence, self.voice, filename=current_tts_path)
 
             # Add the audio clip to the list
             print(colored(f"[X] Save Audio ", "green"))
-            audio_clip = AudioFileClip(f"../static/assets/temp/{fileId}.mp3")
+            audio_clip = AudioFileClip(os.path.join("static/assets/temp", f"{fileId}.mp3"))
             paths.append(audio_clip)
 
         # Combine all TTS files using moviepy
 
         print(colored(f"[X] Start saving the audio ", "green"))
         final_audio = concatenate_audioclips(paths)
-        self.tts_path = f"../static/assets/temp/{uuid4()}.mp3"
+        self.tts_path = os.path.join("static/assets/temp", f"{uuid4()}.mp3")
         final_audio.write_audiofile(self.tts_path)
 
         # Generate the subtitles
@@ -321,17 +322,17 @@ def WriteMetadataToFile(video_title, video_description, video_tags):
             # Remplace spaces with underscores
             fileName = video_title.replace(" ", "_")
 
-            with open(f"../../static/assets/temp/{fileName}.json", "w") as file:
+            with open(os.path.join("static/generated_videos", f"{fileName}.json"), "w") as file:
                 json.dump(metadata, file) 
 
     def AddMusic(self, use_music,custom_song_path=""):
-        video_clip = VideoFileClip(f"../{self.final_video_path}")
+        video_clip = VideoFileClip(f"{self.final_video_path}")
 
         self.final_music_video_path = f"{uuid4()}-music.mp4"
         n_threads = 2
         if use_music:
             # if no song path choose random song
-            song_path = f"../static/assets/music/{custom_song_path}"
+            song_path = os.path.join("static/assets/music", custom_song_path)
             if not custom_song_path:
                 song_path = choose_random_song()
 
@@ -350,9 +351,9 @@ def AddMusic(self, use_music,custom_song_path=""):
             video_clip = video_clip.set_fps(30)
             video_clip = video_clip.set_duration(original_duration)
 
-            video_clip.write_videofile(f"../static/generated_videos/{self.final_music_video_path}", threads=n_threads or 1)
+            video_clip.write_videofile(os.path.join("static/generated_videos", self.final_music_video_path), threads=n_threads or 1)
         else:
-            video_clip.write_videofile(f"../static/generated_videos/{self.final_music_video_path}", threads=n_threads or 1)
+            video_clip.write_videofile(os.path.join("static/generated_videos", self.final_music_video_path), threads=n_threads or 1)
 
     def Stop(self):
         global GENERATING

Backend/classes/instagram_downloader.py

@@ -0,0 +1,82 @@
+import yt_dlp
+import os
+from typing import Optional, Dict, Any
+from datetime import datetime
+
+class InstagramDownloader:
+    def __init__(self, output_path: str = "downloads"):
+        """
+        Initialize the Instagram video downloader
+        
+        Args:
+            output_path (str): Directory where videos will be saved
+        """
+        self.output_path = output_path
+        self._create_output_directory()
+        
+        # Configure yt-dlp options
+        self.ydl_opts = {
+            'format': 'best',  # Download best quality
+            'outtmpl': os.path.join(self.output_path, '%(id)s.%(ext)s'),
+            'quiet': False,
+            'no_warnings': False,
+            'extract_flat': False,
+        }
+
+    def _create_output_directory(self) -> None:
+        """Create the output directory if it doesn't exist"""
+        os.makedirs(self.output_path, exist_ok=True)
+
+    def download_video(self, url: str) -> Dict[str, Any]:
+        """
+        Download a video from Instagram
+        
+        Args:
+            url (str): Instagram video URL
+            
+        Returns:
+            Dict[str, Any]: Information about the downloaded video
+            
+        Raises:
+            Exception: If download fails
+        """
+        try:
+            with yt_dlp.YoutubeDL(self.ydl_opts) as ydl:
+                # Extract video information
+                info = ydl.extract_info(url, download=True)
+                
+                return {
+                    'title': info.get('title', ''),
+                    'filename': ydl.prepare_filename(info),
+                    'duration': info.get('duration'),
+                    'thumbnail': info.get('thumbnail'),
+                    'download_time': datetime.now().isoformat(),
+                    'status': 'success'
+                }
+                
+        except Exception as e:
+            error_info = {
+                'status': 'error',
+                'error_message': str(e),
+                'url': url,
+                'time': datetime.now().isoformat()
+            }
+            raise Exception(f"Failed to download video: {str(e)}") from e
+
+    def update_options(self, new_options: Dict[str, Any]) -> None:
+        """
+        Update yt-dlp options
+        
+        Args:
+            new_options (Dict[str, Any]): New options to update
+        """
+        self.ydl_opts.update(new_options)
+
+    def set_output_template(self, template: str) -> None:
+        """
+        Set custom output template for downloaded files
+        
+        Args:
+            template (str): Output template string
+        """
+        self.ydl_opts['outtmpl'] = os.path.join(self.output_path, template)

Backend/gpt.py

@@ -1,22 +1,29 @@
 import re
 import json
 import g4f
-import openai
+# from openai import OpenAI
 from typing import Tuple, List  
 from termcolor import colored
 from dotenv import load_dotenv
 import os
 import google.generativeai as genai
 
 # Load environment variables
-load_dotenv("../.env")
+if os.path.exists(".env"):
+    load_dotenv(".env")
+else:
+    load_dotenv("../.env")
 
 # Set environment variables
 OPENAI_API_KEY = os.getenv('OPENAI_API_KEY')
-openai.api_key = OPENAI_API_KEY
+# openai.api_key = OPENAI_API_KEY
 GOOGLE_API_KEY = os.getenv('GOOGLE_API_KEY')
 genai.configure(api_key=GOOGLE_API_KEY)
 
+# openaiClient = OpenAI(
+#     api_key=OPENAI_API_KEY ,  # This is the default and can be omitted
+# )
+
 # Configure g4f
 g4f.debug.logging = True  # Enable debug logging
 g4f.debug.version_check = False  # Disable automatic version checking
@@ -34,20 +41,22 @@ def generate_response(prompt: str, ai_model: str) -> str:
     """
 
     if ai_model == 'g4f':
-        response = g4f.ChatCompletion.create(
-            model="gpt-3.5-turbo",
+        client = g4f.Client()
+        response = client.chat.completions.create(
+            model="gpt-4o-mini",
             messages=[{"role": "user", "content": prompt}],
             stream=False
+            # Add any other necessary parameters
         )
-        # Ensure we return a string
-        return response if isinstance(response, str) else str(response)
-
-    elif ai_model in ["gpt3.5-turbo", "gpt4"]:
-        model_name = "gpt-3.5-turbo" if ai_model == "gpt3.5-turbo" else "gpt-4-1106-preview"
-        response = openai.chat.completions.create(
-            model=model_name,
-            messages=[{"role": "user", "content": prompt}],
-        ).choices[0].message.content
+        return response if isinstance(response, str) else str(response.choices[0].message.content)
+
+    # elif ai_model in ["gpt3.5-turbo", "gpt4"]:
+        
+    #     model_name = "gpt-3.5-turbo" if ai_model == "gpt3.5-turbo" else "gpt-4-1106-preview"
+    #     response = openaiClient.chat.completions.create(
+    #         model=model_name,
+    #         messages=[{"role": "user", "content": prompt}],
+    #     ).choices[0].message.content
 
     elif ai_model == 'gemmini':
         model = genai.GenerativeModel('gemini-pro')

Backend/main.py

@@ -3,7 +3,11 @@
 from dotenv import load_dotenv
 
 # Load environment variables
-load_dotenv("../.env")
+# check if .env is in the folder or look one more level up
+if os.path.exists(".env"):
+    load_dotenv(".env")
+else:
+    load_dotenv("../.env")
 # Check if all required environment variables are set
 # This must happen before importing video which uses API keys without checking
 check_env_vars()
@@ -20,8 +24,7 @@
 from apiclient.errors import HttpError
 from flask import Flask, request, jsonify
 from moviepy.config import change_settings
-
-
+from classes.instagram_downloader import InstagramDownloader
 
 # Set environment variables
 SESSION_ID = os.getenv("TIKTOK_SESSION_ID")
@@ -30,7 +33,7 @@
 
 
 # Initialize Flask
-app = Flask(__name__, static_folder="../static", static_url_path="/static")
+app = Flask(__name__, static_folder="static", static_url_path="/static")
 CORS(app)
 
 # Constants
@@ -41,19 +44,55 @@
 
 # Create a method to create all the required folders
 def create_folders():
-    # Create static folder if it doesn't exist
-    if not os.path.exists("../static"):
-        os.makedirs("../static")
-    # Create static/Songs and static/generated_videos folder if it doesn't exist
-    if not os.path.exists("../static/assets"):
-        os.makedirs("../static/assets")
-    if not os.path.exists("../static/generated_videos"):
-        os.makedirs("../static/generated_videos") 
-
+    """Create all required folders for the application"""
+    folders = [
+        "static",
+        "static/assets",
+        "static/assets/temp",
+        "static/assets/subtitles",
+        "static/generated_videos",
+        "static/generated_videos/instagram",
+    ]
+    
+    for folder in folders:
+        folder_path = os.path.join(os.path.dirname(__file__), folder)
+        os.makedirs(folder_path, exist_ok=True)
+        print(f"Created/verified folder: {folder_path}")
 
 # Create folders
 create_folders()
 
+# Instagram video download endpoint
+@app.route("/api/instagram/download", methods=["POST"])
+def download_instagram_video():
+    try:
+        data = request.get_json()
+        video_url = data.get('url')
+        
+        if not video_url:
+            return jsonify({
+                "status": "error",
+                "message": "No Instagram URL provided",
+            }), 400
+
+        # Initialize downloader with output path in static/assets
+        downloader = InstagramDownloader(output_path=os.path.join(os.path.dirname(__file__), "static/generated_videos/instagram"))
+        
+        # Download the video
+        result = downloader.download_video(video_url)
+        
+        return jsonify({
+            "status": "success",
+            "message": "Video downloaded successfully",
+            "data": result
+        })
+        
+    except Exception as e:
+        return jsonify({
+            "status": "error",
+            "message": str(e),
+        }), 500
+
 
 # Generation Endpoint
 @app.route("/api/generate", methods=["POST"])
@@ -64,8 +103,8 @@ def generate():
         GENERATING = True
 
         # Clean
-        clean_dir("../static/assets/temp/")
-        clean_dir("../static/assets/subtitles/")
+        clean_dir("static/assets/temp/")
+        clean_dir("static/assets/subtitles/")
 
 
         # Parse JSON
@@ -209,7 +248,7 @@ def generate_script_only():
     # Set generating to true
     GENERATING = True
 
-    clean_dir("../static/assets/subtitles/")
+    clean_dir("static/assets/subtitles/")
     print(colored("[+] Received script request...", "green"))
 
     data = request.get_json()
@@ -245,8 +284,8 @@ def search_and_download():
     global GENERATING
     GENERATING = True 
      # Clean
-    clean_dir("../static/assets/temp")
-    clean_dir("../static/assets/subtitles")
+    clean_dir("static/assets/temp")
+    clean_dir("static/assets/subtitles")
 
 
     print(colored("[+] Received search and download request...", "green"))
@@ -280,6 +319,7 @@ def search_and_download():
 
     videoClass.CombineVideos()
 
+    # videoClass.GenerateMetadata()
     videoClass.Stop()
 
 
@@ -337,7 +377,7 @@ def addAudio():
 # Get all available songs
 @app.route("/api/getSongs", methods=["GET"])
 def get_songs():
-    songs = os.listdir("../static/assets/music")
+    songs = os.listdir(os.path.join(os.path.dirname(__file__), "static/assets/music"))
     return jsonify({
         "status": "success",
         "message": "Songs retrieved successfully!",
@@ -350,22 +390,25 @@ def get_songs():
 @app.route("/api/getVideos", methods=["GET"])
 def get_videos():
     # Get all videos mp4 only
-    videos = os.listdir("../static/generated_videos")
+    videos = os.listdir(os.path.join(os.path.dirname(__file__), "static/generated_videos"))
     videos = [video for video in videos if video.endswith(".mp4")]
+    instagramVideos = os.listdir(os.path.join(os.path.dirname(__file__), "static/generated_videos/instagram"))
+    instagramVideos = [video for video in instagramVideos if video.endswith(".mp4")]
     return jsonify(
         {
         "status": "success",
         "message": "Videos retrieved successfully!",
         "data": {
-            "videos": videos
+            "videos": videos,
+            "instagram": instagramVideos
             }
         }
     )
 
 # Get all available subtitles
 @app.route("/api/getSubtitles", methods=["GET"])
 def get_subtitles():
-    subtitles = os.listdir("../static/assets/subtitles")
+    subtitles = os.listdir(os.path.join(os.path.dirname(__file__), "static/assets/subtitles"))
     return jsonify(
         {
         "status": "success",
@@ -393,8 +436,9 @@ def get_models():
 
 @app.route("/api/assets", methods=["GET"])
 def get_assets():
-    video_assets = os.listdir("../static/assets/temp")
-    videos = [video for video in videos if video.endswith(".mp4")]
+    assets_path = os.path.join(os.path.dirname(__file__), "static/assets/temp")
+    video_assets = os.listdir(assets_path)
+    videos = [video for video in video_assets if video.endswith(".mp4")]
     return jsonify(
         {
         "status": "success",