Modified some part, still WIP

app.py

@@ -1,186 +1,35 @@
-import os
-import dataclasses
-import io
-from PIL import Image
+"""Driver File."""
 import gradio as gr
+import core
+import parameters
 
-import aws_utils
-
-AWS_BUCKET = os.getenv("AWS_BUCKET")
-os.environ["AWS_ACCESS_KEY_ID"] = os.getenv("AWS_ACCESS_KEY_ID")
-os.environ["AWS_SECRET_ACCESS_KEY"] = os.getenv("AWS_SECRET_ACCESS_KEY")
-os.environ["S3_BUCKET_NAME"] = os.getenv("AWS_BUCKET")
-
-
-@dataclasses.dataclass
-class ComicFrame:
-    description: str
-    narration: str
-    character_dilouge: str
-    character: str
-    compositions: list
-
-
-def list_current_dir(bucket_name: str, folder_path: str = "") -> list:
-    response = aws_utils.S3_CLIENT.list_objects_v2(
-        Bucket=bucket_name, Prefix=folder_path, Delimiter="/"
-    )
-
-    # Check if the bucket contains objects
-    folders = []
-    if "CommonPrefixes" in response:
-        for prefix in response["CommonPrefixes"]:
-            folders.append(prefix["Prefix"])
-    return folders
-
-
-def load_data_inner(episodes_data: list, current_episode: int, current_frame: int):
-    images = []
-    curr_frame = episodes_data[current_episode][current_frame]
-    # Loading the 0th frame of 0th scene in 0th episode.
-    for comps in curr_frame.compositions:
-        data = aws_utils.fetch_from_s3(comps)
-        images.append(Image.open(io.BytesIO(data)))
-
-    return (
-        images,
-        episodes_data,
-        current_episode,
-        current_frame,
-        curr_frame.description,
-        curr_frame.narration,
-        curr_frame.character,
-        curr_frame.character_dilouge,
-    )
-
-
-def load_metadata_fn(comic_id: str):
-    # Logic to load and return images based on comic_id and episode
-    # You can replace this with actual image paths or generation logic
-    print(f"Getting episodes for comic id: {comic_id}")
-    episodes_data = {}
-    episode_idx = []
-    for folder in list_current_dir(AWS_BUCKET, f"{comic_id}/episodes/"):
-        if "episode" in folder:
-            json_path = f"s3://{AWS_BUCKET}/{folder}episode.json"
-            idx = int(folder.split("/")[2].split("-")[-1])
-            episode_idx.append(idx)
-            data = eval(aws_utils.fetch_from_s3(source=json_path).decode("utf-8"))
-            comic_frames = []
-            for scene in data["scenes"]:
-                for frame in scene["frames"]:
-                    comic_frames.append(
-                        ComicFrame(
-                            description=frame["description"],
-                            narration=frame["narration"],
-                            character=frame["audio_cue_character"],
-                            character_dilouge=frame["audio_cue_text"],
-                            compositions=[
-                                comp["image"] for comp in frame["compositions"]
-                            ],
-                        )
-                    )
-            episodes_data[idx] = comic_frames
-    current_episode, current_frame = min(episode_idx), 0
-    return (
-        gr.update(choices=episode_idx, value=episode_idx[0]),
-        gr.update(
-            choices=range(len(episodes_data[current_episode])), value=current_frame
-        ),
-        episodes_data
-    )
-
-
-def load_data_next(episodes_data: list, current_episode: int, current_frame: int):
-    if current_frame + 1 < len(episodes_data[current_episode]):
-        current_frame += 1
-    elif current_episode + 1 < len(episodes_data):
-        current_episode += 1
-        current_frame = 0
-    else:
-        return [], current_episode, current_frame
-    return (
-        gr.update(value=current_episode),
-        gr.update(value=current_frame),
-        *load_data_inner(episodes_data, current_episode, current_frame),
-    )
-
-
-def load_data_prev(episodes_data: list, current_episode: int, current_frame: int):
-    if current_frame - 1 >= 0:
-        current_frame -= 1
-    elif current_episode - 1 > min(list(episodes_data.keys())):
-        current_episode -= 1
-        current_frame = 0
-    else:
-        return [], current_episode, current_frame
-    return (
-        gr.update(value=current_episode),
-        gr.update(value=current_frame),
-        *load_data_inner(episodes_data, current_episode, current_frame),
-    )
-
-
-def load_from_dropdown(
-    episodes_data: dict, selected_episode, selected_frame,
-):
-    return (
-        gr.update(value=selected_episode),
-        gr.update(value=selected_frame),
-        *load_data_inner(episodes_data, selected_episode, selected_frame),
-    )
-
-
-def load_dropdown_fn(selected_episode):
-    return (
-        gr.update(value=selected_episode),
-        gr.update(value=0),
-        selected_episode,
-        0,
-    )
-
-def load_dropdown_fn_v2(selected_frame):
-    return selected_frame
-
-
-def save_image(
-    selected_image,
-    comic_id: str,
-    current_episode: int,
-    current_frame: int,
-):
-    # Implement your AWS S3 save logic here
-    # print(f"Saving image: {selected_image}")
-    with Image.open(selected_image[0]) as img:
-        # Convert and save as JPG
-        img_bytes = io.BytesIO()
-        img.convert("RGB").save(img_bytes, "JPEG")
-        img_bytes.seek(0)
-
-        aws_utils.save_to_s3(
-            AWS_BUCKET,
-            f"{comic_id}/episodes/episode-{current_episode}/images",
-            img_bytes,
-            f"{current_frame}.jpg",
-        )
-    gr.Info("Saved Image successfully!")
-
-
+############################################ LAYOUT ############################################
 with gr.Blocks() as demo:
     selected_image = gr.State(None)
     current_episode = gr.State(-1)
+    current_scene = gr.State(-1)
     current_frame = gr.State(-1)
     episodes_data = gr.State({})
+    current_frame_data = gr.State(None)
 
     with gr.Row():
-        comic_id = gr.Textbox(label="Enter Comic ID:", placeholder="Enter Comic ID")
+        with gr.Column():
+            comic_id = gr.Textbox(label="Enter Comic ID:", placeholder="Enter Comic ID")
         load_metadata = gr.Button("Load Metadata")
 
     # Display information about current Image
     with gr.Row():
-        episode_dropdown = gr.Dropdown(choices=[], label="Current Episode", interactive=True)
-        frame_dropdown = gr.Dropdown(choices=[], label="Current Frame", interactive=True)
-        load_images = gr.Button("Load Images")
+        episode_dropdown = gr.Dropdown(
+            choices=[], label="Current Episode", interactive=True
+        )
+        frame_dropdown = gr.Dropdown(
+            choices=[], label="Current Frame", interactive=True
+        )
+        with gr.Column():
+            load_images = gr.Button("Load Images")
+            developer = gr.Checkbox(
+                value=False, label="Enable Developer Mode", visible=False
+            )
 
     images = gr.Gallery(
         label="Select an Image", elem_id="image_select", columns=4, height=300
@@ -192,7 +41,8 @@ with gr.Blocks() as demo:
 
     with gr.Row():
         character = gr.Textbox(label="Character", interactive=False)
-        dialouge = gr.Textbox(label="dialouge", interactive=False)
+        dialouge = gr.Textbox(label="Dialouge", interactive=False)
+        location = gr.Textbox(label="Location", interactive=False)
 
     # buttons to interact with the data
     with gr.Row():
@@ -200,38 +50,81 @@ with gr.Blocks() as demo:
         save_button = gr.Button("Save Image")
         next_button = gr.Button("Next Image")
 
+    with gr.Column(visible=False) as developer_options:
+        with gr.Column():
+            setting = gr.Textbox(label="Frame Setting")
+            with gr.Row():
+                with gr.Column():
+                    gr.Markdown("## Composition #1")
+                    prompt_1 = gr.TextArea(label="Image Prompt")
+                    # shot_1 = gr.Textbox(label="Shot Type")
+                    seed_1 = gr.Textbox(label="Generation Seed")
+                with gr.Column():
+                    gr.Markdown("## Composition #2")
+                    prompt_2 = gr.TextArea(label="Image Prompt")
+                    # shot_2 = gr.Textbox(label="Shot Type")
+                    seed_2 = gr.Textbox(label="Generation Seed")
+            with gr.Row():
+                with gr.Column():
+                    gr.Markdown("## Composition #3")
+                    prompt_3 = gr.TextArea(label="Image Prompt")
+                    # shot_3 = gr.Textbox(label="Shot Type")
+                    seed_3 = gr.Textbox(label="Generation Seed")
+                with gr.Column():
+                    gr.Markdown("## Composition #4")
+                    prompt_4 = gr.TextArea(label="Image Prompt")
+                    # shot_4 = gr.Textbox(label="Shot Type")
+                    seed_4 = gr.Textbox(label="Generation Seed")
+            regenerate_comps_btn = gr.Button(value="Regenerate Compositions")
+
+        with gr.Column():
+            negative_prompt = gr.TextArea(value="", label="Negative Prompt", )
+            chars = gr.Textbox(value="[]", label="Related Characters")
+            with gr.Row():
+                height = gr.Textbox(value="1024", label="Image Height")
+                width = gr.Textbox(value="1024", label="Image Width")
+                visual_style = gr.Dropdown(
+                    choices=parameters.VISUAL_CHOICES, label="Current Visual Style", interactive=True
+                )
+        
+        with gr.Row():
+            regenerate_btn = gr.Button("Regenerate")
+            save_btn = gr.Button("Save")
+
+############################################ EVENTS ############################################
     load_metadata.click(
-        load_metadata_fn,
+        core.load_metadata_fn,
         inputs=[comic_id],
         outputs=[
             episode_dropdown,
             frame_dropdown,
-            episodes_data
+            episodes_data,
+            developer,
         ],
     )
 
     episode_dropdown.input(
-        load_dropdown_fn,
+        core.load_dropdown_fn,
         inputs=[episode_dropdown],
         outputs=[
             episode_dropdown,
             frame_dropdown,
             current_episode,
             current_frame,
-        ]
+        ],
     )
 
     frame_dropdown.input(
-        load_dropdown_fn_v2,
+        core.load_dropdown_fn_v2,
         inputs=[frame_dropdown],
         outputs=[
             current_frame,
-        ]
+        ],
     )
 
     load_images.click(
-        load_from_dropdown,
-        inputs=[episodes_data, episode_dropdown, frame_dropdown],
+        core.load_from_dropdown,
+        inputs=[episodes_data, current_episode, current_frame, developer],
         outputs=[
             episode_dropdown,
             frame_dropdown,
@@ -243,7 +136,18 @@ with gr.Blocks() as demo:
             image_description,
             narration,
             character,
-            dialouge
+            dialouge,
+            location,
+            setting,
+            prompt_1,
+            seed_1,
+            prompt_2,
+            seed_2,
+            prompt_3,
+            seed_3,
+            prompt_4,
+            seed_4,
+            chars,
         ],
     )
 
@@ -254,7 +158,7 @@ with gr.Blocks() as demo:
     images.select(get_select_index, images, selected_image)
 
     next_button.click(
-        load_data_next,
+        core.load_data_next,
         inputs=[episodes_data, current_episode, current_frame],
         outputs=[
             episode_dropdown,
@@ -267,12 +171,23 @@ with gr.Blocks() as demo:
             image_description,
             narration,
             character,
-            dialouge
+            dialouge,
+            location,
+            setting,
+            prompt_1,
+            seed_1,
+            prompt_2,
+            seed_2,
+            prompt_3,
+            seed_3,
+            prompt_4,
+            seed_4,
+            chars,
         ],
     )
 
     prev_button.click(
-        load_data_prev,
+        core.load_data_prev,
         inputs=[episodes_data, current_episode, current_frame],
         outputs=[
             episode_dropdown,
@@ -285,12 +200,23 @@ with gr.Blocks() as demo:
             image_description,
             narration,
             character,
-            dialouge
+            dialouge,
+            location,
+            setting,
+            prompt_1,
+            seed_1,
+            prompt_2,
+            seed_2,
+            prompt_3,
+            seed_3,
+            prompt_4,
+            seed_4,
+            chars,
         ],
     )
 
     save_button.click(
-        save_image,
+        core.save_image,
         inputs=[
             selected_image,
             comic_id,
@@ -300,4 +226,22 @@ with gr.Blocks() as demo:
         outputs=[],
     )
 
-demo.launch(auth=("admin", "Qrt@12*34#immersfy"), share=True, ssr_mode=False)
+    developer.change(
+        core.toggle_developer_options,
+        inputs=[developer],
+        outputs=[developer_options],
+    )
+
+    regenerate_comps_btn.click(
+        core.regenerate_composition_data,
+        inputs=[],
+        outputs=[]
+    )
+
+    regenerate_btn.click(
+        core.regenerate_data,
+        inputs=[],
+        outputs=[]
+    )
+
+demo.launch(auth=("admin", "Qrt@12*34#immersfy"), share=True, ssr_mode=False)

core.py

@@ -0,0 +1,269 @@
+"""House of all specific functions used to control data flow."""
+from typing import List
+from PIL import Image
+import gradio as gr
+import dataclasses
+import io
+import jinja2
+
+import aws_utils
+import parameters
+import script_gen
+import io as iowrapper
+
+AWS_BUCKET = parameters.AWS_BUCKET
+
+
+@dataclasses.dataclass
+class Composition:
+    prompt: str
+    shot_type: str
+    seed: int
+    image: str
+
+
+@dataclasses.dataclass
+class ComicFrame:
+    description: str
+    narration: str
+    character_dilouge: str
+    character: str
+    compositions: List[Composition] = dataclasses.field(default_factory=list)
+    location: str
+    setting: str
+    all_characters: list
+
+
+
+def list_current_dir(bucket_name: str, folder_path: str = "") -> list:
+    response = aws_utils.S3_CLIENT.list_objects_v2(
+        Bucket=bucket_name, Prefix=folder_path, Delimiter="/"
+    )
+
+    # Check if the bucket contains objects
+    folders = []
+    if "CommonPrefixes" in response:
+        for prefix in response["CommonPrefixes"]:
+            folders.append(prefix["Prefix"])
+    return folders
+
+
+def load_data_inner(
+    episodes_data: list, current_episode: int, current_frame: int, is_developer: bool
+):
+    images = []
+    curr_frame = episodes_data[current_episode][current_frame]
+    # Loading the 0th frame of 0th scene in 0th episode.
+    for comp in curr_frame.compositions:
+        data = aws_utils.fetch_from_s3(comp.image)
+        images.append(Image.open(io.BytesIO(data)))
+
+    return (
+        images,
+        episodes_data,
+        current_episode,
+        current_frame,
+        gr.Textbox(value=curr_frame.description, interactive=is_developer),
+        gr.Textbox(value=curr_frame.narration, interactive=is_developer),
+        gr.Textbox(value=curr_frame.character, interactive=is_developer),
+        gr.Textbox(value=curr_frame.character_dilouge, interactive=is_developer),
+        gr.Textbox(value=curr_frame.location, interactive=is_developer),
+        curr_frame.setting,
+        curr_frame.compositions[0].prompt,
+        curr_frame.compositions[0].seed,
+        curr_frame.compositions[1].prompt,
+        curr_frame.compositions[1].seed,
+        curr_frame.compositions[2].prompt,
+        curr_frame.compositions[2].seed,
+        curr_frame.compositions[3].prompt,
+        curr_frame.compositions[3].seed,
+        curr_frame.all_characters,
+    )
+
+
+def load_metadata_fn(comic_id: str):
+    # Logic to load and return images based on comic_id and episode
+    # You can replace this with actual image paths or generation logic
+    print(f"Getting episodes for comic id: {comic_id}")
+    episodes_data = {}
+    episode_idx = []
+    for folder in list_current_dir(AWS_BUCKET, f"{comic_id}/episodes/"):
+        if "episode" in folder:
+            json_path = f"s3://{AWS_BUCKET}/{folder}episode.json"
+            idx = int(folder.split("/")[2].split("-")[-1])
+            episode_idx.append(idx)
+            data = eval(aws_utils.fetch_from_s3(source=json_path).decode("utf-8"))
+            comic_frames = []
+            for scene in data["scenes"]:
+                for frame in scene["frames"]:
+                    comic_frames.append(
+                        ComicFrame(
+                            description=frame["description"],
+                            narration=frame["narration"],
+                            character=frame["audio_cue_character"],
+                            character_dilouge=frame["audio_cue_text"],
+                            compositions=[
+                                Composition(**comp) for comp in frame["compositions"]
+                            ],
+                            location=frame["location"],
+                            setting=frame["frame_setting"],
+                            all_characters=[
+                                char["name"] for char in frame["characters"]
+                            ],
+                        )
+                    )
+            episodes_data[idx] = comic_frames
+    current_episode, current_frame = min(episode_idx), 0
+    return (
+        gr.update(choices=episode_idx, value=episode_idx[0]),
+        gr.update(
+            choices=range(len(episodes_data[current_episode])), value=current_frame
+        ),
+        episodes_data,
+        gr.Checkbox(visible=True),
+    )
+
+
+def load_data_next(episodes_data: list, current_episode: int, current_frame: int):
+    if current_frame + 1 < len(episodes_data[current_episode]):
+        current_frame += 1
+    elif current_episode + 1 < len(episodes_data):
+        current_episode += 1
+        current_frame = 0
+    else:
+        return [], current_episode, current_frame
+    return (
+        gr.update(value=current_episode),
+        gr.update(value=current_frame),
+        *load_data_inner(episodes_data, current_episode, current_frame),
+    )
+
+
+def load_data_prev(episodes_data: list, current_episode: int, current_frame: int):
+    if current_frame - 1 >= 0:
+        current_frame -= 1
+    elif current_episode - 1 > min(list(episodes_data.keys())):
+        current_episode -= 1
+        current_frame = 0
+    else:
+        return [], current_episode, current_frame
+    return (
+        gr.update(value=current_episode),
+        gr.update(value=current_frame),
+        *load_data_inner(episodes_data, current_episode, current_frame),
+    )
+
+
+def load_from_dropdown(
+    episodes_data: dict, selected_episode: int, selected_frame: int, is_developer: bool
+):
+    return (
+        gr.update(value=selected_episode),
+        gr.update(value=selected_frame),
+        *load_data_inner(episodes_data, selected_episode, selected_frame),
+    )
+
+
+def load_dropdown_fn(selected_episode):
+    return (
+        gr.update(value=selected_episode),
+        gr.update(value=0),
+        selected_episode,
+        0,
+    )
+
+
+def load_dropdown_fn_v2(selected_frame):
+    return selected_frame
+
+
+def save_image(
+    selected_image,
+    comic_id: str,
+    current_episode: int,
+    current_frame: int,
+):
+    # Implement your AWS S3 save logic here
+    # print(f"Saving image: {selected_image}")
+    with Image.open(selected_image[0]) as img:
+        # Convert and save as JPG
+        img_bytes = io.BytesIO()
+        img.convert("RGB").save(img_bytes, "JPEG")
+        img_bytes.seek(0)
+
+        aws_utils.save_to_s3(
+            AWS_BUCKET,
+            f"{comic_id}/episode-{current_episode}/images",
+            img_bytes,
+            f"{current_frame}.jpg",
+        )
+    gr.Info("Saved Image successfully!")
+
+
+def toggle_developer_options(is_developer: bool):
+    if is_developer:
+        return gr.Column(visible=True)
+    gr.Column(visible=False)
+
+
+def regenerate_composition_data(
+    description: str,
+    narration: str,
+    character: str,
+    dialouge: str,
+    location: str,
+    frame_setting: str,
+    current_episode: int,
+    current_scene: int,
+    current_frame: int,
+    episodes_data: dict,
+):
+    print(
+        f"Generating compositions for episode: {current_episode} and scene: {current_scene} and frame: {}."
+    )
+    prompt_dict = {
+        "system": script_gen.generate_image_compositions_instruction,
+        "user": jinja2.Template(
+            source=script_gen.generate_image_compositions_user_prompt
+        ).render(
+            {
+                "FRAME": dataclasses.asdict(frame),
+            }
+        ),
+    }
+
+    compositions = llm.generate_valid_json_response(prompt_dict)
+    print(compositions)
+    frame.compositions = [
+        Composition(**composition)
+        for composition in compositions["compositions"]
+    ]
+    
+
+def regenerate_data(
+    frame_data: ComicFrame, 
+):
+    # for 
+    payload = {
+        "prompt": composition.prompt,
+        "characters": related_chars,
+        "parameters": {
+            "height": parameters.IMG_HEIGHT,
+            "width": parameters.IMG_WIDTH,
+            "visual_style": visual_style,
+            "seed": seed_val,
+        },
+    }
+
+    data = iowrapper.get_valid_post_response(
+        url=parameters.MODEL_SERVER_URL + "/generate_image",
+        payload=payload,
+    )
+    image_data = io.BytesIO(base64.b64decode(data["image"]))
+    path = aws_utils.save_to_s3(
+        parameters.AWS_BUCKET,
+        f"{self.id}/episodes/episode-{episode_num}/compositions/scene-{scene_num}/frame-{frame_num}",
+        image_data,
+        f"{num}.jpg",
+    )
+    pass

io.py

@@ -0,0 +1,50 @@
+from typing import Any
+from typing import Dict
+from typing import List
+from typing import Tuple
+
+import parameters
+import requests
+
+def send_post_request(url: str, payload: dict) -> Tuple[Dict[str, Any], int]:
+    """
+    Sends a POST request to the given URL with the provided payload.
+
+    Args:
+        url (str): The target URL.
+        payload (dict): The JSON payload to send.
+
+    Returns:
+        Tuple[Dict[str, Any], int]: The JSON response and status code from the request.
+    """
+    response = requests.post(url, json=payload)
+
+    return response.json(), response.status_code
+
+
+def get_valid_post_response(url: str, payload: dict) -> Dict[str, Any]:
+    """
+    Assures a response by wrapping up the request sending utility in a for loop with maximum retries.
+
+    Args:
+        url (str): The target URL.
+        payload (dict): The JSON payload to send.
+
+    Returns:
+        Dict[str, Any]: The JSON response from the request.
+    """
+    for _ in range(parameters.MAX_TRIES):
+        try:
+            response, status_code = send_post_request(url, payload)
+            if status_code != 200:
+                continue
+            return response
+        except:
+            continue
+
+    print(
+        f"Max retries exceeded with POST request for url: {url} with payload:\n{payload}\n"
+    )
+    return {
+        "error": f"Max retries exceeded with POST request for url: {url} with payload:\n{payload}\n"
+    }

openai_wrapper.py

@@ -0,0 +1,86 @@
+"""Model wrapper to interact with OpenAI models."""
+import abc
+import ast
+from typing import Mapping
+
+import openai
+
+import parameters
+
+
+class OpenAIModel(abc.ABC):
+    API_KEY = ""
+    # TODO(Maani): Add support for more generation options like:
+    # 1. temperature
+    # 2. top-p
+    # 3. stop sequences
+    # 4. num_outputs
+    # 5. response_format
+    # 6. seed
+
+    def __init__(self, model_name: str, API_KEY: str):
+        try:
+            self.client = openai.OpenAI(
+                # This is the default and can be omitted
+                api_key=API_KEY
+            )
+            self.model_name = model_name
+        except Exception as exc:
+            raise Exception(
+                f"Failed to initialize OpenAI model client. See traceback for more details.",
+            ) from exc
+
+    def prepare_input(self, prompt_dict: Mapping[str, str]) -> str:
+        conversation = []
+        try:
+            for role, content in prompt_dict.items():
+                conversation.append({"role": role, "content": content})
+            return conversation
+        except Exception as exc:
+            raise Exception(
+                f"Incomplete Prompt Dictionary Passed. Expected to have atleast a role and it's content.\nPassed dict: {prompt_dict}",
+            ) from exc
+
+    def generate_response(
+        self,
+        prompt_dict: Mapping[str, str],
+        max_output_tokens: int = None,
+        temperature: int = 0.6,
+        response_format: dict = None,
+    ) -> str:
+        conversation = self.prepare_input(prompt_dict)
+        try:
+            response = self.client.chat.completions.create(
+                model=self.model_name,
+                messages=conversation,
+                max_tokens=max_output_tokens if max_output_tokens else None,
+                temperature=temperature,
+                response_format=response_format,
+            )
+            return response.choices[0].message.content
+        except Exception as exc:
+            raise Exception(
+                f"Exception in generating model response.\nModel name: {self.model_name}\nInput prompt: {str(conversation)}",
+            ) from exc
+
+    def generate_valid_json_response(
+        self,
+        prompt_dict: Mapping[str, str],
+        max_output_tokens: int = None,
+        temperature: int = 0.6,
+    ) -> str:
+        """Generate a response with retries, returning a valid JSON."""
+        for _ in range(parameters.MAX_TRIES):
+            try:
+                model_response = self.generate_response(
+                    prompt_dict, max_output_tokens, temperature, {"type": "json_object"}
+                )
+                return ast.literal_eval(model_response)
+            except Exception as e:
+                continue
+        raise Exception(
+            f"Maximum retries met before valid JSON structure was found.\nModel name: {self.model_name}\nInput prompt: {str(prompt_dict)}"
+        )
+
+
+GPT_4O_MINI = OpenAIModel("gpt-4o-mini", parameters.OPEN_AI_API_KEY)

parameters.py

@@ -0,0 +1,9 @@
+import os
+
+AWS_BUCKET = os.getenv("AWS_BUCKET")
+os.environ["AWS_ACCESS_KEY_ID"] = os.getenv("AWS_ACCESS_KEY_ID")
+os.environ["AWS_SECRET_ACCESS_KEY"] = os.getenv("AWS_SECRET_ACCESS_KEY")
+os.environ["S3_BUCKET_NAME"] = os.getenv("AWS_BUCKET")
+VISUAL_CHOICES = ["DARK", "FLUX", "GHIBLI_COMIC"]
+MAX_TRIES = os.getenv("MAX_TRIES")
+OPEN_AI_API_KEY = os.getenv("OPEN_AI_API_KEY")

requirements.txt

@@ -1,2 +1,7 @@
 boto3==1.35.41
-python-dotenv==1.0.1
+python-dotenv==1.0.1
+Jinja2==3.1.4
+openai==1.23.6
+dacite==1.8.1
+colorlog==6.8.2
+httpx==0.27.2

script_gen.py

@@ -0,0 +1,53 @@
+generate_image_compositions_instruction = """\
+As a visual artist and cinematographer with extensive knowledge of different camera angles, visual styles, and aesthetics, your task is to analyze the provided frame details and create four distinct compositions. Each composition should follow a specific narrative structure in its prompt construction:
+
+1) Output Requirements in json:
+{
+    "compositions": [
+        {
+            "prompt": "Detailed visual description following the structure below (max 77 tokens)",
+            "shot_type": "Optimal cinematographic shot"
+        }
+    ]
+}
+
+2) Prompt Structure (in this specific order):
+   a) Begin with the environment and setting:
+      - Establish the broader landscape/location first
+      - Describe key environmental elements
+      - Set the atmospheric conditions
+      - Define the lighting and mood
+   
+   b) Then layer in the scene elements:
+      - How different parts of the environment interact
+      - Spatial relationships and depth
+      - Textures and materials
+      - Any dynamic elements (movement, weather effects)
+   
+   c) Finally, integrate characters (if applicable):
+      - Their position within the established environment
+      - How they interact with the space
+      - Their expressions and actions as part of the scene
+      
+3) Each composition should:
+   - Flow naturally like a single, cohesive description
+   - Prioritize environmental storytelling
+   - Build the scene progressively from background to foreground
+   - Maintain consistent atmosphere throughout
+
+4) For NO-CHAR compositions:
+   Focus entirely on a and b of the prompt structure, with extra emphasis on:
+   - Environmental details and patterns
+   - Architectural elements
+   - Natural phenomena
+   - Atmospheric qualities
+
+Note: Avoid jumping between environment and character descriptions. Each element should flow naturally into the next, creating a unified visual narrative.
+"""
+
+generate_image_compositions_user_prompt = """\
+Here's are the details:
+
+## Synopsis:
+{{FRAME}}
+"""