Rollback

Author: FujiwaraChoki

.gitignore

@@ -6,4 +6,5 @@ Songs/
 google-maps-scraper-0.9.7/
 niche.txt
 *.exe
-auto.sh
+auto.sh
+.DS_Store

.python-version

@@ -1 +1 @@
-3.9.7
+3.9

src/classes/Tts.py

@@ -1,4 +1,6 @@
 import os
+import sys
+import site
 
 from config import ROOT_DIR
 from TTS.utils.manage import ModelManager
@@ -15,16 +17,26 @@ def __init__(self) -> None:
         Returns:
             None
         """
-        venv_site_packages = "venv\\Lib\\site-packages"
+        # Detect virtual environment site packages
+        if hasattr(sys, 'real_prefix') or (hasattr(sys, 'base_prefix') and sys.base_prefix != sys.prefix):
+            # We're in a virtual environment
+            site_packages = site.getsitepackages()[0]
+        else:
+            # We're not in a virtual environment, use the user's site packages
+            site_packages = site.getusersitepackages()
 
         # Path to the .models.json file
         models_json_path = os.path.join(
-            ROOT_DIR,
-            venv_site_packages,
+            site_packages,
             "TTS",
             ".models.json",
         )
 
+        # Create directory if it doesn't exist
+        tts_dir = os.path.dirname(models_json_path)
+        if not os.path.exists(tts_dir):
+            os.makedirs(tts_dir)
+
         # Initialize the ModelManager
         self._model_manager = ModelManager(models_json_path)
 
@@ -72,4 +84,4 @@ def synthesize(self, text: str, output_file: str = os.path.join(ROOT_DIR, ".mp",
         self.synthesizer.save_wav(outputs, output_file)
 
         return output_file
-    
+

src/classes/YouTube.py

@@ -72,9 +72,8 @@ def __init__(self, account_uuid: str, account_nickname: str, fp_profile_path: st
         if get_headless():
             self.options.add_argument("--headless")
 
-        # Set the profile path
-        self.options.add_argument("-profile")
-        self.options.add_argument(fp_profile_path)
+        profile = webdriver.FirefoxProfile(self._fp_profile_path)
+        self.options.profile = profile
 
         # Set the service
         self.service: Service = Service(GeckoDriverManager().install())
@@ -226,7 +225,22 @@ def generate_prompts(self) -> List[str]:
         Returns:
             image_prompts (List[str]): Generated List of image prompts.
         """
-        n_prompts = len(self.script) / 3
+        # Check if using G4F for image generation
+        cached_accounts = get_accounts("youtube")
+        account_config = None
+        for account in cached_accounts:
+            if account["id"] == self._account_uuid:
+                account_config = account
+                break
+
+        # Calculate number of prompts based on script length
+        base_n_prompts = len(self.script) / 3
+
+        # If using G4F, limit to 25 prompts
+        if account_config and account_config.get("use_g4f", False):
+            n_prompts = min(base_n_prompts, 25)
+        else:
+            n_prompts = base_n_prompts
 
         prompt = f"""
         Generate {n_prompts} Image Prompts for AI Image Generation,
@@ -279,60 +293,135 @@ def generate_prompts(self) -> List[str]:
                         warning("Failed to generate Image Prompts. Retrying...")
                     return self.generate_prompts()
 
-        self.image_prompts = image_prompts
+        # Limit prompts to max allowed amount
+        if account_config and account_config.get("use_g4f", False):
+            image_prompts = image_prompts[:25]
+        elif len(image_prompts) > n_prompts:
+            image_prompts = image_prompts[:int(n_prompts)]
 
-        # Check the amount of image prompts
-        # and remove if it's more than needed
-        if len(image_prompts) > n_prompts:
-            image_prompts = image_prompts[:n_prompts]
+        self.image_prompts = image_prompts
 
         success(f"Generated {len(image_prompts)} Image Prompts.")
 
         return image_prompts
 
-    def generate_image(self, prompt: str) -> str:
+    def generate_image_g4f(self, prompt: str) -> str:
         """
-        Generates an AI Image based on the given prompt.
+        Generates an AI Image using G4F with SDXL Turbo.
 
         Args:
             prompt (str): Reference for image generation
 
         Returns:
             path (str): The path to the generated image.
         """
-        ok = False
-        while ok == False:
-            url = f"https://hercai.onrender.com/{get_image_model()}/text2image?prompt={prompt}"
+        print(f"Generating Image using G4F: {prompt}")
+        
+        try:
+            from g4f.client import Client
+            
+            client = Client()
+            response = client.images.generate(
+                model="sdxl-turbo",
+                prompt=prompt,
+                response_format="url"
+            )
+            
+            if response and response.data and len(response.data) > 0:
+                # Download image from URL
+                image_url = response.data[0].url
+                image_response = requests.get(image_url)
+                
+                if image_response.status_code == 200:
+                    image_path = os.path.join(ROOT_DIR, ".mp", str(uuid4()) + ".png")
+                    
+                    with open(image_path, "wb") as image_file:
+                        image_file.write(image_response.content)
+                    
+                    if get_verbose():
+                        info(f" => Downloaded Image from {image_url} to \"{image_path}\"\n")
+                    
+                    self.images.append(image_path)
+                    return image_path
+                else:
+                    if get_verbose():
+                        warning(f"Failed to download image from URL: {image_url}")
+                    return None
+            else:
+                if get_verbose():
+                    warning("Failed to generate image using G4F - no data in response")
+                return None
+                
+        except Exception as e:
+            if get_verbose():
+                warning(f"Failed to generate image using G4F: {str(e)}")
+            return None
 
-            r = requests.get(url)
-            parsed = r.json()
+    def generate_image_cloudflare(self, prompt: str, worker_url: str) -> str:
+        """
+        Generates an AI Image using Cloudflare worker.
 
-            if "url" not in parsed or not parsed.get("url"):
-                # Retry
-                if get_verbose():
-                    info(f" => Failed to generate Image for Prompt: {prompt}. Retrying...")
-                ok = False
-            else:
-                ok = True
-                image_url = parsed["url"]
+        Args:
+            prompt (str): Reference for image generation
+            worker_url (str): The Cloudflare worker URL
 
-                if get_verbose():
-                    info(f" => Generated Image: {image_url}")
+        Returns:
+            path (str): The path to the generated image.
+        """
+        print(f"Generating Image using Cloudflare: {prompt}")
 
-                image_path = os.path.join(ROOT_DIR, ".mp", str(uuid4()) + ".png")
-                
-                with open(image_path, "wb") as image_file:
-                    # Write bytes to file
-                    image_r = requests.get(image_url)
+        url = f"{worker_url}?prompt={prompt}&model=sdxl"
+        
+        response = requests.get(url)
+        
+        if response.headers.get('content-type') == 'image/png':
+            image_path = os.path.join(ROOT_DIR, ".mp", str(uuid4()) + ".png")
+            
+            with open(image_path, "wb") as image_file:
+                image_file.write(response.content)
+            
+            if get_verbose():
+                info(f" => Wrote Image to \"{image_path}\"\n")
+            
+            self.images.append(image_path)
+            
+            return image_path
+        else:
+            if get_verbose():
+                warning("Failed to generate image. The response was not a PNG image.")
+            return None
 
-                    image_file.write(image_r.content)
+    def generate_image(self, prompt: str) -> str:
+        """
+        Generates an AI Image based on the given prompt.
 
-                if get_verbose():
-                    info(f" => Wrote Image to \"{image_path}\"\n")
+        Args:
+            prompt (str): Reference for image generation
 
-                self.images.append(image_path)
-                
-                return image_path
+        Returns:
+            path (str): The path to the generated image.
+        """
+        # Get account config from cache
+        cached_accounts = get_accounts("youtube")
+        account_config = None
+        for account in cached_accounts:
+            if account["id"] == self._account_uuid:
+                account_config = account
+                break
+
+        if not account_config:
+            error("Account configuration not found")
+            return None
+
+        # Check if using G4F or Cloudflare
+        if account_config.get("use_g4f", False):
+            return self.generate_image_g4f(prompt)
+        else:
+            worker_url = account_config.get("worker_url")
+            if not worker_url:
+                error("Cloudflare worker URL not configured for this account")
+                return None
+            return self.generate_image_cloudflare(prompt, worker_url)
 
     def generate_script_to_speech(self, tts_instance: TTS) -> str:
         """

src/constants.py

@@ -58,7 +58,7 @@ def parse_model(model_name: str) -> any:
     if model_name == "gpt4":
         return g4f.models.gpt_4
     elif model_name == "gpt35_turbo":
-        return g4f.models.gpt_35_turbo
+        return g4f.models.gpt_4o_mini
     elif model_name == "llama2_7b":
         return g4f.models.llama2_7b
     elif model_name == "llama2_13b":
@@ -69,4 +69,4 @@ def parse_model(model_name: str) -> any:
         return g4f.models.mixtral_8x7b
     else:
         # Default model is gpt3.5-turbo
-        return g4f.models.gpt_35_turbo
+        return g4f.models.gpt_4o_mini

src/main.py

@@ -59,15 +59,34 @@ def main():
                 fp_profile = question(" => Enter the path to the Firefox profile: ")
                 niche = question(" => Enter the account niche: ")
                 language = question(" => Enter the account language: ")
-
-                add_account("youtube", {
+                
+                # Add image generation options
+                info("\n============ IMAGE GENERATION ============", False)
+                print(colored(" 1. G4F (SDXL Turbo)", "cyan"))
+                print(colored(" 2. Cloudflare Worker", "cyan"))
+                info("=======================================", False)
+                print(colored("\nRecommendation: If you're unsure, select G4F (Option 1) as there's no additional setup", "yellow"))
+                info("=======================================\n", False)
+                
+                image_gen_choice = question(" => Select image generation method (1/2): ")
+                
+                account_data = {
                     "id": generated_uuid,
                     "nickname": nickname,
                     "firefox_profile": fp_profile,
                     "niche": niche,
                     "language": language,
+                    "use_g4f": image_gen_choice == "1",
                     "videos": []
-                })
+                }
+                
+                if image_gen_choice == "2":
+                    worker_url = question(" => Enter your Cloudflare worker URL for image generation: ")
+                    account_data["worker_url"] = worker_url
+
+                add_account("youtube", account_data)
+
+                success("Account configured successfully!")
         else:
             table = PrettyTable()
             table.field_names = ["ID", "UUID", "Nickname", "Niche"]
@@ -274,7 +293,6 @@ def job():
                             success("Set up CRON Job.")
                         else:
                             break
-
                     elif user_input == 4:
                         if get_verbose():
                             info(" => Climbing Options Ladder...", False)