Update app.py

app.py

@@ -6,159 +6,100 @@ from gtts import gTTS
 import cv2
 import moviepy.editor as mp
 import logging
-from hercai import Hercai
 import uuid
 import time
 import gradio as gr
 import requests
-
-# Configure detailed logging
-log_dir = os.getenv('LOG_DIRECTORY', './')  # Get log directory from environment variable, default to current directory
-LOGGER_FILE_PATH = os.path.join(str(log_dir), 'utils.log')  # Construct the full path to the log file
+from random import randint
+# Configure logging
+log_dir = os.getenv('LOG_DIRECTORY', './')
+LOGGER_FILE_PATH = os.path.join(str(log_dir), 'utils.log')
 
 logging.basicConfig(
     filename=LOGGER_FILE_PATH,
-    filemode='a',  # Append to the log file
-    format='[%(asctime)s] [%(levelname)s] [%(filename)s] [%(lineno)s:%(funcName)s()] %(message)s',  # Log format
-    datefmt='%Y-%b-%d %H:%M:%S'  # Date and time format
+    filemode='a',
+    format='[%(asctime)s] [%(levelname)s] [%(filename)s] [%(lineno)s:%(funcName)s()] %(message)s',
+    datefmt='%Y-%b-%d %H:%M:%S'
 )
-LOGGER = logging.getLogger(__name__)  # Get the logger instance
+LOGGER = logging.getLogger(__name__)
 
-log_level_env = os.getenv('LOG_LEVEL', 'INFO')  # Get log level from environment variable, default to INFO
-log_level_dict = {  # Dictionary mapping log level names to their corresponding numerical values
+log_level_env = os.getenv('LOG_LEVEL', 'INFO')
+log_level_dict = {
     'DEBUG': logging.DEBUG,
     'INFO': logging.INFO,
     'WARNING': logging.WARNING,
     'ERROR': logging.ERROR,
     'CRITICAL': logging.CRITICAL
 }
-# Set the log level based on the environment variable or default to INFO
 if log_level_env in log_level_dict:
     log_level = log_level_dict[log_level_env]
 else:
     log_level = log_level_dict['INFO']
-LOGGER.setLevel(log_level)  # Set the log level for the logger instance
+LOGGER.setLevel(log_level)
 
 
 class Text2Video:
-    """
-    A class to generate videos from text prompts, with detailed logging, model selection, and a user-friendly interface.
-    """
+    """A class to generate videos from text prompts."""
 
     def __init__(self) -> None:
         """
         Initialize the Text2Video class.
+        Args:
+            file_path (str): Path to the configuration file.
         """
-        LOGGER.info("Initializing Text2Video class")
-        self.herc = Hercai("")  # Replace "" with your actual Hercai API key if you have one
-        LOGGER.info("Hercai initialized successfully")
+        # Replace Azure OpenAI with Hercai
+        self.hercai = Hercai("")  # Replace "" with your Hercai API key if you have one
+        self.prodia_model = "stable-diffusion-xl"
+        self.pollinations_model = None
 
-    def get_image(self, img_prompt: str, image_generator: str, image_model: str) -> str:
+    def get_image(self, img_prompt: str) -> str:
         """
-        Generate an image from a text prompt using the selected AI model, with detailed logging and comic book styling.
-
+        Generate an image based on the provided text prompt using Hercai's draw_image method.
         Args:
-            img_prompt (str): The text prompt to generate the image from.
-            image_generator (str): The name of the AI image generation service (Hercai, Prodia, or Pollinations).
-            image_model (str): The specific model to use within the selected AI image generation service.
-
+            img_prompt (str): Text prompt for generating the image.
         Returns:
-            str: The URL of the generated image. Returns an empty string if an error occurred.
+            str: URL of the generated image.
         """
-        LOGGER.info(f"Generating image for prompt: {img_prompt}")
         try:
-            # Create a comic book style prompt
-            modified_prompt = f"Generate a comic book style image with speech bubbles containing the following text: '{img_prompt}'. " \
-                              f"Include elements like vibrant colors, onomatopoeia, and exaggerated expressions to enhance the comic book aesthetic."
-            # Log the modified prompt
-            LOGGER.info(f"Modified prompt for {image_generator}: {modified_prompt}")
-            image_url = ""
-
-            if image_generator == "Hercai":
-                # Log the selected Hercai model
-                LOGGER.info(f"Using Hercai model: {image_model}")
-
-                # Generate the image using Hercai
-                image_result = self.herc.draw_image(model=image_model, prompt=modified_prompt, negative_prompt="Dark and gloomy")
-                # Extract the image URL from the result
-                image_url = image_result["url"]
-
-            elif image_generator == "Prodia":
-                # Log the selected Prodia model
-                LOGGER.info(f"Using Prodia model: {image_model}")
-                # Create the Prodia API call
-                api_url = "https://api.prodia.com/v1/generate"
-                payload = {
-                    "model": image_model,
-                    "prompt": modified_prompt,
-                    "negative_prompt": "Dark and gloomy"
-                }
-                headers = {
-                    "Authorization": "Bearer YOUR_PRODIA_API_KEY"  # Replace YOUR_PRODIA_API_KEY with your actual Prodia API key
-                }
-                response = requests.post(api_url, json=payload, headers=headers)
-                if response.status_code == 200:
-                    image_url = response.json()["url"]
-                    # Log the generated image URL
-                    LOGGER.info(f"Image generated successfully using Prodia: {image_url}")
-                else:
-                    # Log an error if the Prodia API call failed
-                    LOGGER.error(f"Error generating image using Prodia: {response.text}")
-
-            elif image_generator == "Pollinations":
-                # Log the selected Pollinations model
-                LOGGER.info(f"Using Pollinations model: {image_model}")
-                # Implement Pollinations API call here, similar to Prodia
-                # Replace the following placeholder with your Pollinations API call
-                # ...
-
-            # Log the generated image URL
-            LOGGER.info(f"Image generated successfully: {image_url}")
+            # Generate image using Hercai's draw_image method
+            image_result = self.hercai.draw_image(model="v3", prompt=img_prompt, negative_prompt="")
+            image_url = image_result["url"]
             return image_url
 
         except Exception as e:
             # Log any errors encountered during image generation
-            LOGGER.error(f"Error generating image for prompt '{img_prompt}' using {image_generator}: {e}")
+            LOGGER.error(f"Error generating image: {e}")
             return ""
 
     def download_img_from_url(self, image_url: str, image_path: str) -> str:
         """
-        Download an image from a URL to a local file path.
-
+        Download an image from a URL.
         Args:
-            image_url (str): The URL of the image to download.
-            image_path (str): The local file path to save the downloaded image.
-
+            image_url (str): URL of the image to download.
+            image_path (str): Path to save the downloaded image.
         Returns:
-            str: The local file path of the downloaded image. Returns an empty string if an error occurred.
+            str: Path of the downloaded image.
         """
-        LOGGER.info(f"Downloading image from URL: {image_url}")
         try:
-            # Download the image from the URL and save it to the specified path
+            # Download the image from the provided URL and save it to the specified path
             urllib.request.urlretrieve(image_url, image_path)
-
-            LOGGER.info(f"Image downloaded and saved to: {image_path}")
-            return image_path
+            return image_path  # Return the path of the downloaded image if successful
 
         except Exception as e:
             # Log any errors encountered during image download
-            LOGGER.error(f"Error downloading image from URL '{image_url}': {e}")
-            return ""
+            LOGGER.error(f"Error downloading image from URL: {e}")
+            return ""  # Return an empty string if an error occurs
 
     def text_to_audio(self, img_prompt: str, audio_path: str) -> str:
         """
-        Convert text to speech using gTTS and save it as an audio file.
-
+        Convert text to speech and save it as an audio file.
         Args:
-            img_prompt (str): The text to convert to speech.
-            audio_path (str): The local file path to save the generated audio file.
-
+            img_prompt (str): Text to convert to speech.
+            audio_path (str): Path to save the audio file.
         Returns:
-            str: The local file path of the saved audio file. Returns an empty string if an error occurred.
+            str: Path of the saved audio file.
         """
-        LOGGER.info(f"Converting text to audio: {img_prompt}")
         try:
-            # Set the language for speech synthesis (English in this case)
             language = 'en'
 
             # Create a gTTS object to convert text to speech
@@ -167,41 +108,36 @@ class Text2Video:
             # Save the audio file at the specified path
             myobj.save(audio_path)
 
-            LOGGER.info(f"Audio saved to: {audio_path}")
+            # Return the path of the saved audio file if successful
             return audio_path
         except Exception as e:
+
             # Log any errors encountered during text-to-audio conversion
-            LOGGER.error(f"Error converting text '{img_prompt}' to audio: {e}")
+            LOGGER.error(f"Error converting text to audio: {e}")
             return ""
 
-    def get_images_and_audio(self, list_prompts: list, image_generator: str, image_model: str) -> tuple:
+    def get_images_and_audio(self, list_prompts: list) -> tuple:
         """
-        Generate images and corresponding audio files for a list of text prompts using the selected AI model.
-
+        Generate images and corresponding audio files from a list of prompts.
         Args:
-            list_prompts (list): A list of text prompts.
-            image_generator (str): The name of the AI image generation service (Hercai, Prodia, or Pollinations).
-            image_model (str): The specific model to use within the selected AI image generation service.
-
+            list_prompts (list): List of text prompts.
         Returns:
-            tuple: A tuple containing two lists: image paths and audio paths.
+            tuple: A tuple containing lists of image paths and audio paths.
         """
-        LOGGER.info("Generating images and audio for prompts")
-        img_list = []  # List to store image paths
-        audio_paths = []  # List to store audio paths
+        img_list = []  # Initialize an empty list to store image paths
+        audio_paths = []  # Initialize an empty list to store audio paths
         for img_prompt in list_prompts:
-            LOGGER.info(f"Processing prompt: {img_prompt}")
             try:
-                # Generate a unique identifier for the image and audio files
+                # Generate a unique identifier for this file
                 unique_id = uuid.uuid4().hex
 
                 # Construct the image path using the unique identifier
                 image_path = f"{img_prompt[:9]}_{unique_id}.png"
 
-                # Generate the image URL using the selected AI model
-                img_url = self.get_image(img_prompt, image_generator, image_model)
+                # Generate image URL based on the prompt
+                img_url = self.get_image(img_prompt)
 
-                # Download the image from the generated URL
+                # Download and save the image
                 image = self.download_img_from_url(img_url, image_path)
 
                 # Add the image path to the list
@@ -210,159 +146,184 @@ class Text2Video:
                 # Construct the audio path using the unique identifier
                 audio_path = f"{img_prompt[:9]}_{unique_id}.mp3"
 
-                # Convert the text to audio and save it
+                # Convert text to audio and save it
                 audio = self.text_to_audio(img_prompt, audio_path)
 
                 # Add the audio path to the list
                 audio_paths.append(audio)
 
             except Exception as e:
-                # Log any errors encountered during the process
-                LOGGER.error(f"Error processing prompt '{img_prompt}': {e}")
+                LOGGER.error(f"Error processing prompt: {img_prompt}, {e}")
 
-        # Return the lists of image paths and audio paths
-        LOGGER.info("Images and audio generated successfully")
+        # Return lists of image paths and audio paths as a tuple
         return img_list, audio_paths
 
     def create_video_from_images_and_audio(self, image_files: list, audio_files: list, output_path: str) -> None:
         """
-        Generate a video from a list of image files and corresponding audio files.
-
+        Create a video from images and corresponding audio files.
         Args:
-            image_files (list): A list of local file paths to image files.
-            audio_files (list): A list of local file paths to audio files.
-            output_path (str): The local file path where the generated video will be saved.
+            image_files (list): List of image files.
+            audio_files (list): List of audio files.
+            output_path (str): Path to save the output video file.
         """
-        LOGGER.info("Creating video from images and audio")
         try:
-            # Check if the number of images and audio files match
+            # Check if the number of images matches the number of audio files
             if len(image_files) != len(audio_files):
-                # Log an error if the number of image files and audio files don't match
                 LOGGER.error("Error: Number of images doesn't match the number of audio files.")
                 return
 
-            # Create an empty list to store video clips
+            # Initialize an empty list to store video clips
             video_clips = []
 
-            # Loop through each image file and corresponding audio file
             for image_file, audio_file in zip(image_files, audio_files):
-                LOGGER.info(f"Processing image: {image_file}, audio: {audio_file}")
 
-                # Read the image file using OpenCV
+                # Read the image frame
                 frame = cv2.imread(image_file)
 
-                # Load the audio clip using MoviePy
+                # Load the audio clip
                 audio_clip = mp.AudioFileClip(audio_file)
 
-                # Create a video clip from the image and set its duration to the audio clip's duration
+                # Create video clip with image
                 video_clip = mp.ImageClip(image_file).set_duration(audio_clip.duration)
 
-                # Set the audio for the video clip
+                # Set audio for the video clip
                 video_clip = video_clip.set_audio(audio_clip)
 
-                # Append the video clip to the list of video clips
+                # Append the video clip to the list
                 video_clips.append(video_clip)
 
-            # Concatenate all the video clips into a single video clip
+            # Concatenate all video clips into a single clip
             final_clip = mp.concatenate_videoclips(video_clips)
 
-            # Write the final video clip to a file using the specified output path
+            # Write the final video to the output path
             final_clip.write_videofile(output_path, codec='libx264', fps=24)
-
-            LOGGER.info(f"Video created successfully at: {output_path}")
+            print("Video created successfully.")
 
         except Exception as e:
             # Log any errors encountered during video creation
             LOGGER.error(f"Error creating video: {e}")
 
-    def generate_video(self, text: str, image_generator: str, image_model: str) -> str:
+    def generate_video(self, text: list) -> None:
         """
-        Generate a video from a comma-separated string of text prompts using the selected AI model.
-
+        Generate a video from a list of text prompts.
         Args:
-            text (str): A comma-separated string of text prompts, where each prompt represents a scene or frame in the video.
-            image_generator (str): The name of the AI image generation service (Hercai, Prodia, or Pollinations).
-            image_model (str): The specific model to use within the selected AI image generation service.
-
-        Returns:
-            str: The file path of the generated video file. Returns an empty string if an error occurred.
+            list_prompts (list): List of text prompts.
         """
-        LOGGER.info("Generating video from text")
         try:
-            # Split the input text into a list of prompts
             list_prompts = [sentence.strip() for sentence in text.split(",,") if sentence.strip()]
-            LOGGER.info(f"Prompts extracted from text: {list_prompts}")
 
-            # Define the output path for the generated video
-            output_path = "output_video.mp4"
+            # Set the output path for the generated video
+            output_path = "output_video1.mp4"
 
-            # Generate images and corresponding audio files for each prompt using the selected AI model
-            img_list, audio_paths = self.get_images_and_audio(list_prompts, image_generator, image_model)
+            # Generate images and corresponding audio files
+            img_list, audio_paths = self.get_images_and_audio(list_prompts)
 
-            # Create the video from the generated images and audio files
+            # Create video from images and audio
             self.create_video_from_images_and_audio(img_list, audio_paths, output_path)
 
-            LOGGER.info(f"Video generated successfully: {output_path}")
             return output_path
-
         except Exception as e:
+
             # Log any errors encountered during video generation
-            LOGGER.error(f"Error generating video from text '{text}': {e}")
-            return ""
+            LOGGER.error(f"Error generating video: {e}")
 
     def gradio_interface(self):
-        """
-        Creates a user-friendly Gradio interface for the video generation application.
-        """
-        LOGGER.info("Launching Gradio interface")
-        with gr.Blocks(css="style.css", theme='abidlabs/dracula_revamped') as demo:
-            # Set the title of the application
-            gr.HTML("""
-                    <center><h1 style="color:#fff">Comics Video Generator</h1></center>""")
 
-            # Create a text box for user input, allowing them to enter comic book text
-            with gr.Row(elem_id="col-container"):
-                input_text = gr.Textbox(label="Comics Text",
-                                       placeholder="Enter the comics text, separating scenes with double commas (,,)")
+        with gr.Blocks(css="style.css", theme='abidlabs/dracula_revamped') as demo:
+            example_txt = """once upon a time there was a village. It was a nice place to live, except for one thing. people did not like to share.,, One day a visitor came to town. 
+          'Hello. Does anybody have food to share?' He asked. 'No', said everyone.,,
+          That's okay', said the visitor. 'I will make stone soup for everyone'.Then he took a stone and dropped it into a giant pot,,"""
 
-            # Create a dropdown menu for selecting the AI image generation service
-            with gr.Row(elem_id="col-container"):
-                image_generator = gr.Dropdown(label="Image Generator",
-                                             choices=["Hercai", "Prodia", "Pollinations"],
-                                             value="Hercai",
-                                             interactive=True)
+            gr.HTML("""
+                <center><h1 style="color:#fff">Comics Video Generator</h1></center>""")
 
-            # Create a dropdown menu for selecting the specific model within the chosen service
             with gr.Row(elem_id="col-container"):
-                image_model = gr.Dropdown(label="Image Model",
-                                         choices=["v1", "v2", "v3", "simurg", "animefy", "raava", "shonin"],
-                                         value="v3",
-                                         interactive=True)
+                input_text = gr.Textbox(label="Comics Text", placeholder="Enter the comics by double comma separated")
 
-            # Create a button that triggers the video generation process
             with gr.Row(elem_id="col-container"):
                 button = gr.Button("Generate Video")
 
-            # Create a component to display the generated video
             with gr.Row(elem_id="col-container"):
                 output = gr.PlayableVideo()
 
-            # Provide an example to guide users on how to format their input
             with gr.Row(elem_id="col-container"):
-                example_txt = """Once upon a time there was a village. It was a nice place to live, except for one thing. People did not like to share.,, 
-                One day a visitor came to town. 'Hello. Does anybody have food to share?' He asked. 'No', said everyone.,,
-                'That's okay', said the visitor. 'I will make stone soup for everyone'. Then he took a stone and dropped it into a giant pot,,"""
                 example = gr.Examples([example_txt], input_text)
 
-            # Define the button's click event to call the generate_video function with the user's input and model selection
-            button.click(self.generate_video, [input_text, image_generator, image_model], output)
-
-            LOGGER.info("Gradio interface launched successfully")
-            # Launch the Gradio interface
+            button.click(self.generate_video, [input_text], output)
             demo.launch(debug=True)
 
+    # --- Prodia & Pollinations Methods ---
+    def prodia_generate(self, model, prompt, output_file="prodia_output.png"):
+        s = requests.Session()
+        headers = {"user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko)"}
+
+        resp = s.get(
+            "https://api.prodia.com/generate",
+            params={
+                "new": "true", "prompt": prompt, "model": model,
+                "negative_prompt": "verybadimagenegative_v1.3",
+                "steps": "20", "cfg": "7", "seed": randint(1, 10000),
+                "sample": "DPM++ 2M Karras", "aspect_ratio": "square"
+            },
+            headers=headers
+        )
+
+        job_id = resp.json()['job']
+        while True:
+            time.sleep(5)
+            status = s.get(f"https://api.prodia.com/job/{job_id}", headers=headers).json()
+            if status["status"] == "succeeded":
+                img_data = s.get(f"https://images.prodia.xyz/{job_id}.png?download=1", headers=headers).content
+                with open(output_file, 'wb') as f:
+                    f.write(img_data)
+                return output_file
+        return None
+
+    def pollinations_generate(self, prompt, output_file="pollinations_output.png"):
+        response = requests.get(f"https://image.pollinations.ai/prompt/{prompt}{randint(1, 10000)}")
+        if response.status_code == 200:
+            with open(output_file, 'wb') as f:
+                f.write(response.content)
+            return output_file
+        return None
+
+    # --- Hercai Class ---
+    class Hercai:
+        def __init__(self, api_key=None):
+            self.api_key = api_key
+
+        def question(self, model="v3", content="", personality=None):
+            url = f"https://hercai.onrender.com/v3/hercai?question={content}&model={model}"
+            if personality:
+                url += f"&personality={personality}"
+            if self.api_key:
+                url += f"&key={self.api_key}"
+            response = requests.get(url)
+            return response.json()
+
+        def draw_image(self, model="v3", prompt="", negative_prompt=""):
+            url = f"https://hercai.onrender.com/v3/text2image?prompt={prompt}&model={model}&negative_prompt={negative_prompt}"
+            if self.api_key:
+                url += f"&key={self.api_key}"
+            response = requests.get(url)
+            return response.json()
+
+        def beta_question(self, model="v3", content="", personality=None):
+            url = f"https://hercai.onrender.com/beta/hercai?question={content}&model={model}"
+            if personality:
+                url += f"&personality={personality}"
+            if self.api_key:
+                url += f"&key={self.api_key}"
+            response = requests.get(url)
+            return response.json()
+
+        def beta_draw_image(self, model="v3", prompt="", negative_prompt=""):
+            url = f"https://hercai.onrender.com/beta/text2image?prompt={prompt}&model={model}&negative_prompt={negative_prompt}"
+            if self.api_key:
+                url += f"&key={self.api_key}"
+            response = requests.get(url)
+            return response.json()
 
 if __name__ == "__main__":
-    LOGGER.info("Starting application")
-    text2video = Text2Video()  # Create an instance of the Text2Video class
-    text2video.gradio_interface()  # Launch the Gradio interface
+    text2video = Text2Video()
+    text2video.gradio_interface()