generation update

App/Generate/Prompts/Example.json

@@ -0,0 +1,67 @@
+[
+  {
+    "narration": "Welcome to 'Weird History Facts', where we uncover the bizarre truths hidden in the past! Our first tale takes us back to ancient Egypt and a pharaoh's unusual obsession... Let the images unfold with this prompt: ",
+    "images_prompt": [
+      "Ancient Egypt, mysterious, hieroglyphics, desert, pyramids, Canon EOS 5D, 24-70mm, midday, harsh shadows, cinematic, Kodak Ektar 100, highly realistic, bright desert sun"
+    ]
+  },
+  {
+    "narration": "Pharaoh Khafra, builder of the second largest pyramid at Giza, had a peculiar fixation with... onions! Yes, this mighty ruler was convinced that onions held the key to eternal life. So much so, that he demanded his workers be paid in onions instead of gold. Imagine, an entire civilization fueled by the power of... well, tears and pungent breath. Now, let's move on to a different type of tear-jerker.",
+    "images_prompt": [
+      "Pharaoh Khafra, regal, onion-shaped crown, golden tears, onion field, Nikon D850, 70-200mm, morning, soft focus, dramatic, Ilford Delta 3200, moderately realistic, warm golden light",
+      "Ancient Egyptian workers, onion currency, onion necklaces, desert market, Canon EOS 5D, 35mm, noon, harsh sunlight, vibrant, Agfa Vista 200, highly realistic, strong natural light"
+    ]
+  },
+  {
+    "narration": "Next, we travel to medieval Europe, where a strange tax was once levied. It's a hair-raising tale, so brace yourselves and imagine the following: ",
+    "images_prompt": [
+      "Medieval Europe, stone castle, moat, colorful flags, cloudy sky, DJI Mavic, 12mm, afternoon, overcast, ethereal, Fuji Pro 400H, highly realistic, soft natural light"
+    ]
+  },
+  {
+    "narration": "In the 11th century, England introduced a 'beard tax' to discourage the fashion of wearing beards. Yes, King Henry I decided that beards were a sign of witchcraft and demanded a tax from any man who wished to keep his facial hair. So, if you thought shaving was a hassle nowadays, be glad you didn't live in medieval England! Now, let's whisk away to a different kind of whiskers.",
+    "images_prompt": [
+      "King Henry I, bearded, throne, angry, beard tax scroll, Sony A7R, 50mm, evening, dramatic lighting, cinematic, Ilford Pan 100, highly realistic, warm candlelight",
+      "Medieval man, shaving, scared of tax collector, humorous, Nikon D850, 85mm, morning, soft natural light, intimate, Kodak Portra 400, moderately realistic, window light"
+    ]
+  },
+  {
+    "narration": "Our next story involves a famous explorer and a rather unusual method of navigation. Prepare to set sail with this prompt: ",
+    "images_prompt": [
+      "Ocean voyage, 15th century, stormy seas, sailing ship, dramatic sky, Hasselblad H6D, 24mm, afternoon, dramatic, Fuji Pro 400H, highly realistic, harsh sunlight"
+    ]
+  },
+  {
+    "narration": "Christopher Columbus, the famous Italian explorer, believed that the tail of the Milky Way galaxy was a surefire way to navigate. He used it as a compass during his voyages, believing it pointed directly to the North Star. Imagine, one of history's greatest explorers relying on the stars for more than just romantic stargazing! Now, let's navigate to a different kind of star power.",
+    "images_prompt": [
+      "Christopher Columbus, night sky, sailing ship, Milky Way, compass, Canon EOS 5D, 14mm, nighttime, starry, Kodak Ektar 100, highly realistic, moonlight",
+      "Milky Way galaxy, tail, stars, abstract, cosmic, DJI Mavic, 10mm, night, vibrant, Agfa Vista 200, moderately realistic, nebula light"
+    ]
+  },
+  {
+    "narration": "In the world of entertainment, we've had our fair share of oddities. Let's shine a spotlight on one such curious case with this prompt: ",
+    "images_prompt": [
+      "Vaudeville stage, early 20th century, colorful lights, crowded theater, Canon EOS 5D, 24-70mm, evening, vibrant, cinematic, Kodak Portra 400, highly realistic, stage lighting"
+    ]
+  },
+  {
+    "narration": "The famous escape artist Harry Houdini had a secret weapon for his acts—his mother! Before each performance, she would secretly lock him in a set of handcuffs, ensuring he could escape from any pair. A heartwarming and slightly bizarre tale of motherly love. Now, let's unlock the next story, which is equally as intriguing.",
+    "images_prompt": [
+      "Harry Houdini, handcuffed, stage, concerned, mother in audience, Nikon D850, 85mm, night, dramatic, Ilford Delta 3200, highly realistic, stage lighting",
+      "Vintage handcuffs, key, wooden table, soft focus, intimate, Sony A7R, 90mm, afternoon, warm lighting, nostalgic, Fuji Pro 400H, moderately realistic, window light"
+    ]
+  },
+  {
+    "narration": "Our final tale involves a famous artist and their rather peculiar palette. Get ready to paint a picture with this prompt: ",
+    "images_prompt": [
+      "Artist's studio, 19th century, canvas, paint tubes, natural light, Hasselblad H6D, 50mm, morning, soft, nostalgic, Kodak Ektar 100, highly realistic, warm morning light"
+    ]
+  },
+  {
+    "narration": "Vincent van Gogh, the post-impressionist master, is known for his vibrant use of color. But did you know he also ate his paints? Yes, van Gogh suffered from pica, a condition causing him to eat non-food items. He believed consuming his paints would bring him closer to his art. A bizarre and slightly dangerous way to embrace your passion! And with that, we conclude our journey through weird history facts.",
+    "images_prompt": [
+      "Vincent van Gogh, paint palette, eating paint, concerned friend, Nikon D850, 35mm, afternoon, soft natural light, intimate, Kodak Portra 400, highly realistic, window light",
+      "Vibrant paint tubes, still life, colorful, abstract, Sony A7R, 90mm, morning, ethereal, Fuji Pro 400H, moderately realistic, soft light"
+    ]
+  }
+]

App/Generate/Prompts/StoryGen.py

@@ -0,0 +1,23 @@
+Prompt = """
+Generate a variety of high-quality prompts for Stable Diffusion XL (SDXL), the latest image generation model. With SDXL, you can create realistic images with improved face generation, and stunning art with shorter prompts with this format: "[TYPE OF IMAGE] [SUBJECT] [ENVIRONMENT] [5 ACTION WORDS], [COMPOSITION], [MODIFIERS], [PHOTOGRAPHY TERMS], [ART MEDIUM], [ART STYLE], [ARTIST STYLE], [ENHANCEMENTS]
+
+Let's break down the components of the composition format:
+
+[TYPE OF IMAGE]: Specifies the type of image being generated, such as photography, illustration, painting, etc.
+[SUBJECT]: The main focus or central element of the image.
+[ENVIRONMENT]: Describes the setting or backdrop in which the subject is placed.
+[5 ACTION WORDS]: Specifies the action or state of being of the subject, adding dynamism or emotion. NOT MORE THAN 5 WORDS
+[COMPOSITION]: Refers to the arrangement or organization of elements within the image, providing guidance to the AI model on how to frame the scene.
+[MODIFIERS]: Additional elements that can enhance the composition, such as camera angles, perspectives, or spatial relationships.
+[PHOTOGRAPHY TERMS]: Describes elements related to photography, such as shot type, lighting, composition techniques, etc.
+[ART MEDIUM]: Specifies the medium or materials used in artistic expression, such as digital illustration, oil painting, etc.
+[ART STYLE]: Defines the overall artistic style or aesthetic of the image.
+[ARTIST STYLE]: Optionally, specifies a particular artist or artistic influence that informs the style or composition of the image.
+[ENHANCEMENTS]: Additional modifiers that enhance the image quality or provide specific details, such as HDR, vivid colors, etc.
+
+    Remember these parts are just placeholders to guide you!
+My JOB IS AT RISK HERE.
+Just make sure that images have a coherent and are visually appealing, to keep the viewers engaged, and the prompt should be coherent meaning they should go together.
+Make sure that the json keys are spelled correctly. Take a deep breath in every step for extra concentation
+Now, create an engaging video using images and narration. The videos should be about {topic}. the output should be a json containing a list of objects with keys "narration" which is the narration of the video during that scene and a "image_prompts" which is a list of sdxl  prompts during the narration You need create an appropriate number of  image_prompts, proportional to the length of the current objects narration. It should match so as to make the story good and engaging. Only output the json markdown
+"""

App/Generate/Prompts/StoryGen.text

@@ -0,0 +1,21 @@
+Generate a variety of high-quality prompts for Stable Diffusion XL (SDXL), the latest image generation model. With SDXL, you can create realistic images with improved face generation, and stunning art with shorter prompts with this format: "[TYPE OF IMAGE] [SUBJECT] [ENVIRONMENT] [5 ACTION WORDS], [COMPOSITION], [MODIFIERS], [PHOTOGRAPHY TERMS], [ART MEDIUM], [ART STYLE], [ARTIST STYLE], [ENHANCEMENTS]
+
+Let's break down the components of the composition format:
+
+[TYPE OF IMAGE]: Specifies the type of image being generated, such as photography, illustration, painting, etc.
+[SUBJECT]: The main focus or central element of the image.
+[ENVIRONMENT]: Describes the setting or backdrop in which the subject is placed.
+[5 ACTION WORDS]: Specifies the action or state of being of the subject, adding dynamism or emotion. NOT MORE THAN 5 WORDS
+[COMPOSITION]: Refers to the arrangement or organization of elements within the image, providing guidance to the AI model on how to frame the scene.
+[MODIFIERS]: Additional elements that can enhance the composition, such as camera angles, perspectives, or spatial relationships.
+[PHOTOGRAPHY TERMS]: Describes elements related to photography, such as shot type, lighting, composition techniques, etc.
+[ART MEDIUM]: Specifies the medium or materials used in artistic expression, such as digital illustration, oil painting, etc.
+[ART STYLE]: Defines the overall artistic style or aesthetic of the image.
+[ARTIST STYLE]: Optionally, specifies a particular artist or artistic influence that informs the style or composition of the image.
+[ENHANCEMENTS]: Additional modifiers that enhance the image quality or provide specific details, such as HDR, vivid colors, etc.
+
+    Remember these parts are just placeholders to guide you!
+My JOB IS AT RISK HERE.
+Just make sure that images have a coherent and are visually appealing, to keep the viewers engaged, and the prompt should be coherent meaning they should go together.
+Make sure that the json keys are spelled correctly. Take a deep breath in every step for extra concentation
+Now, create an engaging video using images and narration. The videos should be about {topic}. the output should be a json containing a list of objects with keys "narration" which is the narration of the video during that scene and a "image_prompts" which is a list of sdxl  prompts during the narration You need create an appropriate number of  image_prompts, proportional to the length of the current objects narration. It should match so as to make the story good and engaging. Only output the json markdown

App/Generate/Schema.py

@@ -0,0 +1,7 @@
+from typing import List, Optional
+from pydantic import BaseModel, HttpUrl
+from pydantic import validator
+
+
+class GeneratorRequest(BaseModel):
+    prompt: str

App/Generate/Story/Story.py

@@ -0,0 +1,55 @@
+import json
+from pydantic import BaseModel
+from typing import List
+
+
+class Scene(BaseModel):
+    narration: str
+    image_prompts: List[str]
+
+    def num_images(self):
+        return len(self.image_prompts)
+
+
+class Story(BaseModel):
+    scenes: List[Scene]
+
+    @classmethod
+    def from_dict(cls, data):
+        # Parse JSON string into list of dictionaries
+        json_data = data
+        for item in json_data:
+            if "image_prompts" in item and "narration" not in item:
+                for key in item.keys():
+                    if key != "image_prompts":
+                        item["narration"] = item.pop(key)
+                        break
+
+        # Convert JSON data into list of Scene objects
+        scenes = [Scene(**item) for item in json_data]
+        # Return Story object with all scenes
+        return cls(scenes=scenes)
+
+    @classmethod
+    def parse_markdown(cls, markdown_str):
+        # Extract JSON part from markdown string
+        try:
+            json_str = markdown_str.split("```json")[1].split("```")[0].strip()
+        except:
+            pass
+        return cls.from_dict(data=json.loads(json_str))
+
+    @property
+    def all_narrations(self):
+        return [scene.narration for scene in self.scenes]
+
+    @property
+    def all_images(self):
+        # return [scene.images_prompt for scene in self.scenes]
+        results = []
+        for scene in self.scenes:
+            results.extend(scene.images_prompt)
+        return results
+
+    def num_images_in_scene(self, scene_index):
+        return self.scenes[scene_index].num_images()

App/Generate/database/DescriptAPI.py

@@ -0,0 +1,196 @@
+import asyncio
+import aiohttp
+import os, uuid
+from collections import deque
+import wave
+import uuid
+from pydub import AudioSegment
+
+
+import wave
+import struct
+
+
+def concatenate_wave_files(input_file_paths, output_file_path):
+    """
+    Concatenates multiple wave files and saves the result to a new file.
+
+    :param input_file_paths: A list of paths to the input wave files.
+    :param output_file_path: The path to the output wave file.
+    """
+    # Check if input file paths are provided
+    if not input_file_paths:
+        raise ValueError("No input file paths provided.")
+
+    # Validate output file path
+    if not output_file_path:
+        raise ValueError("Output file path is empty.")
+
+    # Validate input file paths
+    for input_file_path in input_file_paths:
+        if not input_file_path:
+            raise ValueError("Empty input file path found.")
+
+    # Validate and get parameters from the first input file
+    with wave.open(input_file_paths[0], "rb") as input_file:
+        n_channels = input_file.getnchannels()
+        sampwidth = input_file.getsampwidth()
+        framerate = input_file.getframerate()
+        comptype = input_file.getcomptype()
+        compname = input_file.getcompname()
+
+    # Open the output file for writing
+    output_file = wave.open(output_file_path, "wb")
+    output_file.setnchannels(n_channels)
+    output_file.setsampwidth(sampwidth)
+    output_file.setframerate(framerate)
+    output_file.setcomptype(comptype, compname)
+
+    # Concatenate and write data from all input files to the output file
+    for input_file_path in input_file_paths:
+        with wave.open(input_file_path, "rb") as input_file:
+            output_file.writeframes(input_file.readframes(input_file.getnframes()))
+
+    # Close the output file
+    output_file.close()
+
+    print(
+        f"Successfully concatenated {len(input_file_paths)} files into {output_file_path}"
+    )
+
+
+# # Example usage
+# input_files = ["./tmp/" + i for i in os.listdir("./tmp")]
+# output_file = "./concatenated_output.wav"
+# concatenate_wave_files(input_files, output_file)
+
+
+def concatenate_wav_files(input_files, file_directory):
+    print(input_files)
+    output_file = file_directory + str(uuid.uuid4()) + "final.wav"
+    # Initialize variables for output file
+    output = None
+    output_params = None
+
+    try:
+        # Open output file for writing
+        output = wave.open(output_file, "wb")
+
+        # Loop through input files
+        for input_file in input_files:
+            with wave.open(input_file, "rb") as input_wav:
+                # If this is the first input file, set output file parameters
+                if output_params is None:
+                    output_params = input_wav.getparams()
+                    output.setparams(output_params)
+                # Otherwise, ensure consistency of parameters
+                else:
+                    pass
+                    # if input_wav.getparams() != output_params:
+                    #     raise ValueError(
+                    #         "Input file parameters do not match output file parameters."
+                    #     )
+
+                # Read data from input file and write to output file
+                output.writeframes(input_wav.readframes(input_wav.getnframes()))
+    finally:
+        # Close output file
+        if output is not None:
+            output.close()
+    return (output_file,)
+
+
+class Speak:
+    def __init__(self, api_url="https://yakova-embedding.hf.space", dir="./tmp"):
+        self.api_url = api_url
+        self.dir = dir
+
+    async def _make_request(self, method, endpoint, json=None):
+        async with aiohttp.ClientSession() as session:
+            async with getattr(session, method)(
+                f"{self.api_url}/{endpoint}", json=json
+            ) as response:
+                return await response.json()
+
+    async def say(self, text, speaker="Tabitha"):
+        data = {"text": text, "speaker": speaker}
+
+        response_data = await self._make_request("post", "descript_tts", json=data)
+        tts_id = response_data["id"]
+
+        # Poll the status endpoint until the TTS is ready
+        while True:
+            status_data = await self._make_request(
+                "post", "descript_status", json={"id": tts_id}
+            )
+            print(status_data)
+            if "status" in status_data:
+                if status_data["status"] == "done":
+                    audio_url = status_data["url"]
+                    temp = await self.download_file(audio_url)
+                    return audio_url, temp
+            else:
+                pass
+
+            await asyncio.sleep(1)
+
+    async def download_file(self, url):
+        filename = str(uuid.uuid4()) + ".wav"
+        os.makedirs(self.dir, exist_ok=True)
+        save_path = os.path.join(self.dir, filename)
+        async with aiohttp.ClientSession() as session:
+            async with session.get(url) as response:
+                if response.status == 200:
+                    with open(save_path, "wb") as file:
+                        while True:
+                            chunk = await response.content.read(1024)
+                            if not chunk:
+                                break
+                            file.write(chunk)
+
+        return save_path
+
+
+async def process_narrations(narrations):
+    speak = Speak()
+    tasks = deque()
+    results = []
+    files = []
+
+    async def process_task():
+        while tasks:
+            text = tasks.popleft()
+            result = await speak.say(text)
+            _, temp = result
+            results.append(result)
+            files.append(temp)
+
+    for narration in narrations:
+        tasks.append(narration)
+        if len(tasks) >= 2:
+            await asyncio.gather(*[process_task() for _ in range(2)])
+
+    # Process remaining tasks
+    await asyncio.gather(*[process_task() for _ in range(len(tasks))])
+    concatinated_file = concatenate_wav_files(files, speak.dir)
+
+    wav_file = AudioSegment.from_file(concatinated_file, format="wav")
+    duration_in_seconds = int(len(wav_file) / 1000)
+
+    return results, (concatinated_file, duration_in_seconds)
+
+
+# # Example narrations
+# narrations = [
+#     "Welcome to a journey through some of history's strangest moments!",
+#     "Did you know that in ancient Rome, mustaches were a big deal?",
+# ]
+
+
+# # Run the asyncio event loop
+# async def main():
+#     results = await process_narrations(narrations)
+#     print("Results:", results)
+
+
+# asyncio.run(main())

App/Generate/database/Model.py

@@ -0,0 +1,301 @@
+import databases
+import orm
+import asyncio, os
+import uuid, random
+from pydub import AudioSegment
+from .DescriptAPI import Speak
+from .Vercel import AsyncImageGenerator
+import aiohttp
+from typing import List
+
+database_url = "sqlite+aiosqlite:///ok.db"
+database = databases.Database(database_url)
+models = orm.ModelRegistry(database=database)
+
+
+class Project(orm.Model):
+    tablename = "projects"
+    start = 0
+    registry = models
+    fields = {
+        "id": orm.Integer(primary_key=True),
+        "name": orm.String(max_length=10_000),
+        "aspect_ratio": orm.Float(allow_null=True, default=0),
+        "transcript": orm.JSON(allow_null=True, default=[]),
+        "duration": orm.Integer(allow_null=True, default=0),
+        "assets": orm.JSON(allow_null=True, default=[]),
+        "links": orm.JSON(allow_null=True, default=[]),
+        "constants": orm.JSON(allow_null=True, default={}),
+    }
+
+    """
+        assets.extend(
+        [
+            {"type": "video", "sequence": video_sequence},
+            {
+                "type": "audio",
+                "sequence": [
+                    {
+                        "type": "audio",
+                        "name": "transcript.wav",
+                        "start": trans_start,
+                        "end": trans_end,
+                        "props": {
+                            "startFrom": trans_start * 30,
+                            "endAt": trans_end * 30,
+                            "volume": 5,
+                        },
+                    },
+                ],
+            },
+            {
+                "type": "background",
+                "sequence": [
+                    {
+                        "type": "background",
+                        "name": "background.mp3",
+                        "start": trans_start,
+                        "end": trans_end,
+                        "props": {
+                            "startFrom": trans_start * 30,
+                            "endAt": trans_end * 30,
+                            "volume": 0.4,
+                        },
+                    },
+                ],
+            },
+        ]
+    )
+
+    
+                {
+                "type": "image",
+                "name": file_name,
+                "start": image["start"],
+                "end": image["end"],
+            }
+"""
+
+    async def get_all_scenes(self):
+        return await Scene.objects.filter(project=self).all()
+
+    async def generate_json(self):
+        project_scenes: List[Scene] = await self.get_all_scenes()
+        self.links = []
+        self.assets = []
+        image_assets = []
+        video_assets = []
+        audio_assets = []
+
+        transitions = [
+            "WaveRight_transparent.webm",
+            "WaveLeft_transparent.webm",
+            # "WaveBlue_transparent.webm",
+            # "Wave_transparent.webm",
+            # "Swirl_transparent.webm",
+            # "Snow_transparent.webm",
+            # "Likes_transparent.webm",
+            # "Lightning_transparent.webm",
+            # "Happy_transparent.webm",
+            # "Fire_transparent.webm",
+            # "CurlingWave_transparent.webm",
+            # "Cloud_transparent.webm",
+        ]
+
+        self.links.append(
+            {
+                "file_name": "sfx_1.mp3",
+                "link": "https://dm0qx8t0i9gc9.cloudfront.net/previews/audio/BsTwCwBHBjzwub4i4/camera-shutter-05_MJn9CZV__NWM.mp3?type=preview&origin=AUDIOBLOCKS&timestamp_ms=1715270679690&publicKey=kUhrS9sKVrQMTvByQMAGMM0jwRbJ4s31HTPVkfDGmwGhYqzmWJHsjIw5fZCkI7ba&organizationId=105711&apiVersion=2.0&stockItemId=2248&resolution=&endUserId=414d29f16694d76c58e7998200a8dcf6f28dc165&projectId=f734c6d7-e39d-4c1d-8f41-417f94cd37ce&searchId=4b01b35a-fafc-45fb-9f40-e98849cb71ac&searchPageId=f24f4c5b-9976-4fd3-9bac-d217d87c723d",
+            }
+        )
+        for scene in project_scenes:
+            _, file_name = os.path.split(scene.narration_path)
+            self.duration += scene.narration_duration + 1  ## added one for spaces
+            self.links.append({"file_name": file_name, "link": scene.narration_link})
+
+            # narration
+            audio_assets.append(
+                {
+                    "type": "audio",
+                    "name": file_name,
+                    "start": self.start,
+                    "end": self.start + scene.narration_duration + 1,
+                    "props": {
+                        "startFrom": 0,
+                        "endAt": scene.narration_duration * 30,
+                        "volume": 5,
+                    },
+                }
+            )
+
+            ## images and transitions
+            for image in scene.images:
+                file_name = str(uuid.uuid4()) + ".png"
+                self.links.append({"file_name": file_name, "link": image})
+                image_assets.append(
+                    {
+                        "type": "image",
+                        "name": file_name,
+                        "start": self.start,
+                        "end": self.start + scene.image_duration,
+                    }
+                )
+                self.start = self.start + scene.image_duration
+
+                ## transitions between images
+                video_assets.append(
+                    {
+                        "type": "video",
+                        "name": "Effects/" + random.choice(transitions),
+                        "start": self.start - 1,
+                        "end": self.start + 2,
+                        "props": {
+                            "startFrom": 1 * 30,
+                            "endAt": 3 * 30,
+                            "volume": 0,
+                        },
+                    }
+                )
+
+        self.assets.append({"type": "audio", "sequence": audio_assets})
+        ## add the images to assets
+        self.assets.append({"type": "image", "sequence": image_assets})
+        self.assets.append(
+            {"type": "video", "sequence": video_assets},
+        )
+        self.constants = {
+            "duration": self.duration * 30,
+            "height": 1920,
+            "width": 1080,
+        }
+
+        await self.update(**self.__dict__)
+        return {"links": self.links, "assets": self.assets, "constants": self.constants}
+
+    async def generate_transcript(self):
+        pass
+
+
+class Scene(orm.Model):
+    tts = Speak()
+    tablename = "scenes"
+    registry = models
+    fields = {
+        "id": orm.Integer(primary_key=True),
+        "project": orm.ForeignKey(Project),
+        "images": orm.JSON(default=None),
+        "narration": orm.String(max_length=10_000, allow_null=True, default=""),
+        "image_prompts": orm.JSON(default=None),
+        "narration_duration": orm.Float(allow_null=True, default=0),
+        "image_duration": orm.Float(allow_null=True, default=0),
+        "narration_path": orm.String(
+            max_length=100,
+            allow_null=True,
+            default="",
+        ),
+        "narration_link": orm.String(max_length=10_000, allow_null=True, default=""),
+    }
+
+    async def generate_scene_data(self):
+        # Run narrate() and generate_images() concurrently
+        await asyncio.gather(self.narrate(), self.generate_images())
+        self.calculate_durations()
+
+    async def narrate(self):
+        link, path = await self._retry_narration_generation()
+        self.narration_path = path
+        self.narration_link = link
+
+    async def _retry_narration_generation(self):
+
+        retry_count = 0
+        while retry_count < 3:
+            try:
+                return await self.tts.say(text=self.narration)
+            except Exception as e:
+                print(f"Failed to generate narration: {e}")
+                retry_count += 1
+                await asyncio.sleep(1)  # Add delay before retrying
+
+        print("Failed to generate narration after 3 attempts.")
+
+    def calculate_durations(self):
+        wav_file = AudioSegment.from_file(self.narration_path, format="wav")
+        self.narration_duration = int(len(wav_file) / 1000)
+        self.image_duration = self.narration_duration / len(self.image_prompts)
+
+    async def generate_images(self):
+        self.images = []
+        async with aiohttp.ClientSession() as session:
+            image_generator = AsyncImageGenerator(session)
+            for payload in self.image_prompts:
+                result = await image_generator.generate_image(payload)
+                status = await image_generator.fetch_image_status(result["id"])
+                self.images.extend(status["output"])
+
+
+class Transition(orm.Model):
+    tablename = "transitions"
+    registry = models
+    fields = {
+        "id": orm.Integer(primary_key=True),
+        "name": orm.String(max_length=100),
+        "file_path": orm.String(max_length=100),
+    }
+
+
+class BackgroundMusic(orm.Model):
+    tablename = "background_music"
+    registry = models
+    fields = {
+        "id": orm.Integer(primary_key=True),
+        "name": orm.String(max_length=100),
+        "file_path": orm.String(max_length=100),
+    }
+
+
+# class Testy(orm.Model):
+#     tablename = "asd"
+#     registry = models
+#     fields = {
+#         "id": orm.Integer(primary_key=True),
+#         "duration": orm.Float(allow_null=True,default=None),
+#         "area": orm.Float(allow_null=True,default=None),
+#         "radius": orm.Float(allow_null=True,default=None),
+#     }
+
+#     def calculate_durations(self):
+#         self.area = self.radius**2 * 3.14
+#         pass
+
+
+# # Create the tables
+async def create_tables():
+    datas = {
+        "narration": "Welcome to a journey through some of history's strangest moments! Get ready to explore the bizarre, the unusual, and the downright weird.",
+        "image_prompts": [
+            "Vintage book opening, revealing strange facts, mixed media collage, curious and intriguing, mysterious, eccentric, macro lens, soft lighting, conceptual photography, cross-processed film, surreal, warm tones, textured paper."
+        ],
+    }
+
+    await models._create_all(database_url)
+    x = await Project.objects.create(name="avatar")
+    scene = await Scene.objects.create(project=x)
+    scene.narration = datas["narration"]
+    scene.image_prompts = datas["image_prompts"]
+
+    await scene.generate_scene_data()
+    await scene.objects.update(**scene.__dict__)
+    p = await x.get_all_scenes()
+    print(p)
+    print(scene.__dict__)
+
+
+# asyncio.run(create_tables())
+# # Run the function to create tables
+# await create_tables()
+
+# # Example usage:
+# await Note.objects.create(text="Buy the groceries.", completed=False)
+# note = await Note.objects.get(id=1)
+# print(note)

App/Generate/database/Test.py

@@ -0,0 +1,102 @@
+import aiohttp
+import asyncio
+import json
+import random
+import secrets
+
+
+async def generate_with_playground(prompt, resolution):
+    nevPrompt = "text, watermark, blurry, haze, low contrast, low quality, underexposed, ugly, deformed, boring, bad quality, cartoon, ((disfigured)), ((bad art)), ((deformed)), ((poorly drawn)), ((extra limbs)), ((close up)), ((b&w)), weird colors, blurry, ugly, tiling, poorly drawn hands, poorly drawn feet, poorly drawn face, out of frame, extra limbs, disfigured, body out of frame, blurry, bad anatomy, blurred, watermark, grainy, signature, cut off, draft, low detail, low quality, double face, 2 faces, cropped, ugly, low-res, tiling, grainy, cropped, ostentatious, ugly, oversaturated, grain, low resolution, disfigured, blurry, bad anatomy, disfigured, poorly drawn face, mutant, mutated, extra limb, ugly, poorly drawn hands, missing limbs, blurred, floating limbs, disjointed limbs, deformed hands, blurred, out of focus, long neck, long body, ugly, disgusting, childish, cut off cropped, distorted, imperfect, surreal, bad hands, text, error, extra digit, fewer digits, cropped , worst quality, low quality, normal quality, jpeg artifacts, signature, watermark, username, blurry, artist name, Lots of hands, extra limbs, extra fingers, conjoined fingers, deformed fingers, old, ugly eyes, imperfect eyes, skewed eyes , unnatural face, stiff face, stiff body, unbalanced body, unnatural body, lacking body, details are not clear, cluttered, details are sticky, details are low, distorted details, ugly hands, imperfect hands, (mutated hands and fingers:1.5), (long body :1.3), (mutation, poorly drawn :1.2) bad hands, fused ha nd, missing hand, disappearing arms, hands, disappearing thigh, disappearing calf, disappearing legs, ui, missing fingers"
+    width, height = None, None
+    if resolution == "Square":
+        width = 1024
+        height = 1024
+    elif resolution == "Wide":
+        width = 1280
+        height = 768
+    elif resolution == "Portrait":
+        width = 768
+        height = 1280
+
+    session_hash = generate_session_hash()
+    random_digit = generate_random_digits()
+    root_url = "https://playgroundai-playground-v2-5.hf.space/--replicas/bdj8s"
+
+    url_join_queue = f"https://playgroundai-playground-v2-5.hf.space/queue/join?fn_index=3&session_hash={session_hash}"
+    headers = {"Content-Type": "application/json"}
+    async with aiohttp.ClientSession() as session:
+        async with session.get(url_join_queue) as resp:
+            async for line in resp.content:
+                temp = line.decode().replace("data: ", "")
+                print(temp, "here")
+                try:
+                    temp = eval(temp)
+                except:
+                    continue
+                print(type(temp))
+                data = temp
+                if data["msg"] == "send_data":
+                    event_id = data.get("event_id")
+                    await session.post(
+                        "https://playgroundai-playground-v2-5.hf.space/queue/data",
+                        json={
+                            "data": [
+                                prompt,
+                                nevPrompt,
+                                True,
+                                random_digit,
+                                width,
+                                height,
+                                3,
+                                True,
+                            ],
+                            "event_data": None,
+                            "fn_index": 3,
+                            "trigger_id": 6,
+                            "session_hash": session_hash,
+                            "event_id": event_id,
+                        },
+                    )
+                elif data["msg"] == "process_completed":
+                    image_paths = data["output"]["data"][0]
+                    print(image_paths, "hererereere")
+                    first_image_path = (
+                        image_paths[0]["image"]["path"] if image_paths else None
+                    )
+                    if first_image_path:
+                        print(first_image_path)
+                        full_url = f"{root_url}/file={first_image_path}"
+                        return {
+                            "images": [{"url": full_url}],
+                            "modelUsed": "Playground",
+                        }
+                    else:
+                        raise ValueError(
+                            "No image path found in the process_completed message."
+                        )
+
+
+async def fetch_and_extract_root_url(url):
+    async with aiohttp.ClientSession() as session:
+        async with session.get(url) as resp:
+            return await resp.text()
+
+
+def generate_session_hash():
+    chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"
+    return "".join(secrets.choice(chars) for _ in range(5))
+
+
+def generate_random_digits():
+    return random.randint(100000000, 999999999)
+
+
+async def main():
+    prompt = "COMICBOOK ILLUSTRATION Medea, Jason, two sons, black background, 8k"
+    resolution = "Square"
+    result = await generate_with_playground(prompt, resolution)
+    print(result)
+
+
+# Run the main function
+asyncio.run(main())

App/Generate/database/Vercel.py

@@ -0,0 +1,104 @@
+import aiohttp, asyncio, pprint
+from collections import deque
+
+
+class AsyncImageGenerator:
+    def __init__(self, session):
+        self.session = session
+        self.base = "https://auto-svg.vercel.app/"
+
+    async def generate_image(self, payload, max_retries=50):
+        retries = 0
+        while retries < max_retries:
+            try:
+                url = f"{self.base}/predictions"
+                data = {
+                    "input": {
+                        "width": 1024,
+                        "height": 1024,
+                        "prompt": payload,
+                        "scheduler": "DPMSolver++",
+                        "num_outputs": 1,
+                        "guidance_scale": 2,
+                        "negative_prompt": "",
+                        # "negative_prompt": "ugly, deformed, noisy, blurry, distorted, out of focus, bad anatomy, extra limbs, poorly drawn face, poorly drawn hands, missing fingers, color, 3D, 2D, video game, cgi, plastic, fake, artificial, smooth",
+                        "negative_prompt": "text, watermark, blurry, haze, low contrast, low quality, underexposed, ugly, deformed, boring, bad quality, cartoon, ((disfigured)), ((bad art)), ((deformed)), ((poorly drawn)), ((extra limbs)), ((close up)), ((b&w)), weird colors, blurry, ugly, tiling, poorly drawn hands, poorly drawn feet, poorly drawn face, out of frame, extra limbs, disfigured, body out of frame, blurry, bad anatomy, blurred, watermark, grainy, signature, cut off, draft, low detail, low quality, double face, 2 faces, cropped, ugly, low-res, tiling, grainy, cropped, ostentatious, ugly, oversaturated, grain, low resolution, disfigured, blurry, bad anatomy, disfigured, poorly drawn face, mutant, mutated, extra limb, ugly, poorly drawn hands, missing limbs, blurred, floating limbs, disjointed limbs, deformed hands, blurred, out of focus, long neck, long body, ugly, disgusting, childish, cut off cropped, distorted, imperfect, surreal, bad hands, text, error, extra digit, fewer digits, cropped , worst quality, low quality, normal quality, jpeg artifacts, signature, watermark, username, blurry, artist name, Lots of hands, extra limbs, extra fingers, conjoined fingers, deformed fingers, old, ugly eyes, imperfect eyes, skewed eyes , unnatural face, stiff face, stiff body, unbalanced body, unnatural body, lacking body, details are not clear, cluttered, details are sticky, details are low, distorted details, ugly hands, imperfect hands, (mutated hands and fingers:1.5), (long body :1.3), (mutation, poorly drawn :1.2) bad hands, fused ha nd, missing hand, disappearing arms, hands, disappearing thigh, disappearing calf, disappearing legs, ui, missing fingers",
+                        "num_inference_steps": 25,
+                    },
+                    "path": "models/playgroundai/playground-v2.5-1024px-aesthetic/versions/a45f82a1382bed5c7aeb861dac7c7d191b0fdf74d8d57c4a0e6ed7d4d0bf7d24",
+                }
+
+                async with self.session.post(url, json=data) as response:
+                    response.raise_for_status()
+                    return await response.json()
+            except aiohttp.ClientResponseError as e:
+                if e.status == 500:
+                    retries += 1
+                    print(f"Retry {retries} after 500 error")
+                    await asyncio.sleep(1)  # Add a delay before retrying
+                else:
+                    raise e
+
+        # If max retries reached, raise an exception
+        raise Exception("Max retries reached")
+
+    async def fetch_image_status(self, image_id):
+        url = f"https://replicate.com/api/predictions/{image_id}"
+        async with self.session.get(url) as response:
+            response.raise_for_status()
+            temp = await response.json()
+            status = temp
+            while status["status"] != "succeeded":
+                status = await self._fetch_image_status(image_id)
+                await asyncio.sleep(3)
+            return status
+
+    async def _fetch_image_status(self, image_id):
+        url = f"https://replicate.com/api/predictions/{image_id}"
+        async with self.session.get(url) as response:
+            response.raise_for_status()
+            temp = await response.json()
+            status = temp
+            return status
+
+
+async def process_images(payloads):
+    async with aiohttp.ClientSession() as session:
+        image_generator = AsyncImageGenerator(session)
+        tasks = deque()
+        results = []
+
+        async def process_task():
+            while tasks:
+                payload = tasks.popleft()
+                result = await image_generator.generate_image(payload)
+                status = await image_generator.fetch_image_status(result["id"])
+                print(status["output"])
+                results.extend(status["output"])
+
+        for payload in payloads:
+            tasks.append(payload)
+            if len(tasks) >= 2:
+                await asyncio.gather(*[process_task() for _ in range(2)])
+
+        # Process remaining tasks
+        await asyncio.gather(*[process_task() for _ in range(len(tasks))])
+
+        return results
+
+
+# # Example payloads
+# payloads = [
+#     """
+# Roman gladiator fighting a crocodile in the Colosseum, ancient Roman entertainment, oil painting, gruesome and thrilling, blood-stained sand, telephoto lens, afternoon golden hour lighting, cinematic film style, realistic with dramatic shadows
+# """
+# ]
+
+
+# # Run the asyncio event loop
+# async def main():
+#     results = await process_images(payloads)
+#     pprint.pprint(results)
+
+
+# asyncio.run(main())

App/Generate/generatorRoutes.py

@@ -0,0 +1,63 @@
+from fastapi import APIRouter, HTTPException, status, BackgroundTasks, UploadFile, Query
+from .Schema import GeneratorRequest
+from .utils.GroqInstruct import chatbot
+from .Story.Story import Story
+import asyncio, pprint, json
+from tqdm import tqdm
+from .database.Model import models, database_url, Scene, Project
+from .utils.RenderVideo import RenderVideo
+from .Prompts.StoryGen import Prompt
+
+
+async def update_scene(model_scene):
+    await model_scene.generate_scene_data()
+    await model_scene.update(**model_scene.__dict__)
+
+
+async def main(request: GeneratorRequest):
+    topic = request.prompt
+    renderr = RenderVideo()
+
+    await models._create_all(database_url)
+    message = chatbot(Prompt.format(topic=topic))
+
+    generated_story = Story.from_dict(message["scenes"])
+
+    print("Generated Story ✅")
+
+    x = await Project.objects.create(name=topic[0:100])
+
+    # Assuming generated_story.scenes is a list of scenes
+    scene_updates = []
+    with tqdm(total=len(generated_story.scenes)) as pbar:
+        for i in range(0, len(generated_story.scenes), 2):
+            batch = generated_story.scenes[i : i + 2]  # Get a batch of two story scenes
+            batch_updates = []
+
+            for story_scene in batch:
+                model_scene = await Scene.objects.create(project=x)
+                model_scene.image_prompts = story_scene.image_prompts
+                model_scene.narration = story_scene.narration
+                await model_scene.update(**model_scene.__dict__)
+                batch_updates.append(
+                    update_scene(model_scene)
+                )  # Append update coroutine to batch_updates
+            scene_updates.extend(batch_updates)  # Accumulate updates for later awaiting
+            await asyncio.gather(
+                *batch_updates
+            )  # Await update coroutines for this batch
+            pbar.update(len(batch))  # Increment progress bar by the size of the batch
+
+    temp = await x.generate_json()
+    await renderr.render_video(temp)
+
+
+generator_router = APIRouter(tags=["video-Generator"])
+
+
+@generator_router.post("/generate_video")
+async def generate_video(
+    videoRequest: GeneratorRequest, background_task: BackgroundTasks
+):
+    background_task.add_task(main, videoRequest)
+    return {"task_id": "started"}

App/Generate/utils/Bing.py

@@ -0,0 +1,53 @@
+import aiohttp
+import json
+import re
+
+
+class Bing:
+    def __init__(self):
+        self.url = "https://api.groq.com/openai/v1/chat/completions"
+        self.headers = {
+            "Authorization": "Bearer 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",
+            "accept": "application/json",
+            "content-type": "application/json",
+        }
+
+    @staticmethod
+    def remove_links(text):
+        # Remove links
+        cleaned_text = re.sub(r"\[\d+\]:\shttps?://\S+\s?\"\"", "", text)
+
+        # Remove other weird characters
+        # cleaned_text = re.sub(r'[^a-zA-Z0-9\s.,?!-]', '', cleaned_text)
+
+        return cleaned_text
+
+    async def chat(self, message, remove_links=False, content=False):
+        messages = [
+            {"role": "user", "content": message},
+            {"role": "assistant", "content": "You are an amazing Youtuber"},
+            # Add more messages as needed
+        ]
+
+        payload = {
+            "messages": messages,
+            "stream": False,
+            "model": "mixtral-8x7b-32768",
+            "temperature": 0.5,
+            "presence_penalty": 0,
+            "frequency_penalty": 0,
+            "top_p": 1,
+        }
+
+        async with aiohttp.ClientSession() as session:
+            async with session.post(
+                self.url, headers=self.headers, data=json.dumps(payload)
+            ) as response:
+                result = await response.json()
+                # print(result)
+                # result = json.loads(result)
+                assistant_message_content = result["choices"][0]["message"]["content"]
+                # print(assistant_message_content)
+                if remove_links:
+                    return self.remove_links(assistant_message_content)
+                return assistant_message_content

App/Generate/utils/GroqInstruct.py

@@ -0,0 +1,77 @@
+import os
+import instructor
+from groq import Groq
+
+from pydantic import BaseModel, Field
+
+from typing import List, Dict
+from pydantic import BaseModel
+
+
+class Scene(BaseModel):
+    narration: str
+    image_prompts: List[str]
+
+
+class VideoOutput(BaseModel):
+    scenes: List[Scene]
+
+
+client = Groq(api_key="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")
+
+# By default, the patch function will patch the ChatCompletion.create and ChatCompletion.create methods to support the response_model parameter
+client = instructor.from_groq(client, mode=instructor.Mode.JSON)
+
+
+# Now, we can use the response_model parameter using only a base model
+# rather than having to use the OpenAISchema class
+
+
+def chatbot(prompt):
+
+    response: VideoOutput = client.chat.completions.create(
+        model="mixtral-8x7b-32768",
+        # model="gemma-7b-it",
+        # model="llama2-70b-4096",
+        # model="llama3-70b-8192",
+        max_tokens=5000,
+        response_model=VideoOutput,
+        # kwargs={
+        #     # "temperature": 1,
+        #     "max_tokens": 5000,
+        #     # "top_p": 1,
+        #     "stream": False,
+        #     "stop": None,
+        # },
+        messages=[
+            {
+                "role": "system",
+                "content": """Take a deep breath. You are an amazing story teller, you keep your audience engaged here is an example of one of your stories:
+                Title : Why are Jews so rich
+                 it starts in
+medieval Europe the church and Islamic
+law both prohibit money lending but not
+Jews they loan money and interest makes
+them very wealthy so wealthy that even
+powerful monarchs borrow from them by
+the 17th century they become key members
+of Royal courts known as Court Jews
+financial advisers to Kings and Queens
+when the world transitioned from
+monarchy to democracy Jewish people with
+their centuries of experience were the
+first to take advantage of new banking
+infrastructures today however the world
+is very different Muslims Christians
+Jews everyone enjoys interest
+                
+                
+                """,
+            },
+            {
+                "role": "user",
+                "content": prompt,
+            },
+        ],
+    )
+    return response.dict()

App/Generate/utils/HuggingChat.py

@@ -0,0 +1,36 @@
+from hugchat import hugchat
+from hugchat.login import Login
+
+
+email = "mihorag447@vikinoko.com"
+passwd = "IamstewpedW!23@"
+# Log in to huggingface and grant authorization to huggingchat
+sign = Login(email, passwd)
+cookies = sign.login()
+
+# # Save cookies to the local directory
+cookie_path_dir = "./cookies_snapshot"
+sign.saveCookiesToDir(cookie_path_dir)
+
+# Load cookies when you restart your program:
+# sign = login(email, None)
+cookies = sign.loadCookiesFromDir(cookie_path_dir)
+
+
+# Create a ChatBot
+chatbot = hugchat.ChatBot(
+    cookies=cookies.get_dict(),
+    system_prompt="You are an amazing youtuber. A true creative master genius",
+)
+
+model_index = 0
+models = chatbot.get_available_llm_models()
+print(chatbot.active_model)
+if not chatbot.active_model.name == "CohereForAI/c4ai-command-r-plus":
+    for model in models:
+        print(model.name, "switching..")
+        if model.name == "CohereForAI/c4ai-command-r-plus":
+            model_index = models.index(model)
+            break
+print(chatbot.current_conversation.system_prompt)
+chatbot.switch_llm(model_index)

App/Generate/utils/RenderVideo.py

@@ -0,0 +1,24 @@
+import aiohttp, json
+
+
+class RenderVideo:
+    def __init__(self, url="https://yakova-rectifier.hf.space/create-video"):
+        self.url = url
+
+    @staticmethod
+    def _parse_response(response: str) -> dict:
+        return json.loads(response)
+
+    async def post_request(self, data: dict) -> dict:
+        headers = {"Accept": "application/json", "Content-Type": "application/json"}
+        async with aiohttp.ClientSession() as session:
+            async with session.post(
+                self.url, data=json.dumps(data), headers=headers
+            ) as resp:
+                response = await resp.text()
+                result = self._parse_response(response)
+        return result
+
+    async def render_video(self, data) -> dict:
+        result = await self.post_request(data)
+        return result

App/Generate/utils/VideoEditor.py

@@ -0,0 +1,90 @@
+from pydantic import BaseModel, Field, validator
+from typing import List, Dict
+
+
+
+transitions = [
+    "WaveRight_transparent.webm",
+    "WaveLeft_transparent.webm",
+    "WaveBlue_transparent.webm",
+    "Wave_transparent.webm",
+    "Swirl_transparent.webm",
+    "Snow_transparent.webm",
+    "Likes_transparent.webm",
+    "Lightning_transparent.webm",
+    "Happy_transparent.webm",
+    "Fire_transparent.webm",
+    "CurlingWave_transparent.webm",
+    "Cloud_transparent.webm",
+]
+
+
+class Asset(BaseModel):
+    type: str
+    sequence: List[Dict]
+
+    @validator("sequence")
+    def check_duration(cls, sequence):
+        for item in sequence:
+            start = item.get("start", 0)
+            end = item.get("end", 0)
+            duration = (end - start) * 30  # Assuming 30 fps
+            if duration <= 1:
+                raise ValueError("Asset duration must be greater than 1 frame.")
+        return sequence
+
+
+class Link(BaseModel):
+    file_name: str
+    link: str
+
+
+class Remotion(BaseModel):
+    links: List[Link] = []
+    assets: List[Asset] = []
+    constants: Dict[str, int] = {"duration": 3840, "height": 1920, "width": 1080}
+    scenes: int
+    total_duration: int
+
+    def generate_image_links(self):
+        for i in range(self.scenes):
+            image_file_name = f"image_{i}.png"
+            image_link = f"https://image.lexica.art/full_webp/{i}.png"
+            self.links.append(Link(file_name=image_file_name, link=image_link))
+
+
+def concatenate_wav_files(input):
+    # Initialize variables for output file
+    output = None
+    output_params = None
+    output_file =  ''
+    try:
+        # Open output file for writing
+        output = wave.open(output_file, "wb")
+
+        # Loop through input files
+        for input_file in input_files:
+            with wave.open(input_file, "rb") as input_wav:
+                # If this is the first input file, set output file parameters
+                if output_params is None:
+                    output_params = input_wav.getparams()
+                    output.setparams(output_params)
+                # Otherwise, ensure consistency of parameters
+                else:
+                    if input_wav.getparams() != output_params:
+                        raise ValueError(
+                            "Input file parameters do not match output file parameters."
+                        )
+
+                # Read data from input file and write to output file
+                output.writeframes(input_wav.readframes(input_wav.getnframes()))
+    finally:
+        # Close output file
+        if output is not None:
+            output.close()
+
+
+# # Example usage
+# input_files = ["file1.wav", "file2.wav", "file3.wav"]
+# output_file = "output.wav"
+# concatenate_wav_files(input_files, output_file)

App/app.py

@@ -2,6 +2,7 @@ from fastapi import FastAPI, BackgroundTasks
 from .Editor.editorRoutes import videditor_router
 from App import bot
 from App.utilis import WorkerClient, SERVER_STATE
+from .Generate.generatorRoutes import generator_router
 
 app = FastAPI()
 manager = WorkerClient()
@@ -22,3 +23,4 @@ def read_root():
 
 
 app.include_router(videditor_router)
+app.include_router(generator_router)

Remotion-app/JsonMaker.py

@@ -0,0 +1,29 @@
+from pydantic import BaseModel
+from typing import List, Optional
+from pydantic import validator
+import os, json
+
+
+class Assets(BaseModel):
+    type: str
+    sequence: List[dict]
+
+    @validator("type")
+    def valid_type(cls, v):
+        if v not in ["video", "audio", "text", "image", "sfx", "background"]:
+            raise ValueError("Invalid asset type")
+        return v
+
+
+def CreateFiles(assets: List[Assets], asset_dir: str):
+    for asset in assets:
+        filename = f"{asset.type.capitalize()}Sequences.json"
+        # Convert dictionary to JSON string
+        json_string = json.dumps(asset.sequence)
+
+        # Create directory if it doesn't exist
+        os.makedirs(asset_dir, exist_ok=True)
+        print(os.path.join(asset_dir, filename))
+        # Write JSON string to file
+        with open(os.path.join(asset_dir, filename), "w") as f:
+            f.write(json_string)

requirements.txt

@@ -20,4 +20,8 @@ asgiref
 pipx
 cryptg
 aiohttp
-python-multipart
+instructor==1.2.0
+groq==0.5.0
+python-multipart
+orm[aiosqlite]
+pydub