Upload 7 files

app.py

@@ -0,0 +1,414 @@
+import streamlit as st
+import os
+from prompts import prompts
+from constants import JSON_SCHEMA_FOR_GPT, UPDATED_MODEL_ONLY_SCHEMA, JSON_SCHEMA_FOR_LOC_ONLY
+from gpt import runAssistant, checkRunStatus, retrieveThread, createAssistant, saveFileOpenAI, startAssistantThread, \
+    create_chat_completion_request_open_ai_for_summary, addMessageToThread, create_image_completion_request_gpt
+from summarizer import create_brand_html, create_langchain_openai_query
+from theme import flux_generated_image, flux_generated_image_seed
+import time
+from PIL import Image
+import io
+
+
+def process_run(st, thread_id, assistant_id):
+    run_id = runAssistant(thread_id, assistant_id)
+    status = 'running'
+    while status != 'completed':
+        with st.spinner('. . .'):
+            time.sleep(20)
+            status = checkRunStatus(thread_id, run_id)
+    thread_messages = retrieveThread(thread_id)
+    for message in thread_messages:
+        if not message['role'] == 'user':
+            return message["content"]
+        else:
+            pass
+
+
+def page1():
+    st.title("Upload Product")
+    st.markdown("<h2 style='color:#FF5733; font-weight:bold;'>Add a Product</h2>", unsafe_allow_html=True)
+    st.markdown("<p style='color:#444;'>Upload your product images, more images you upload better the AI learns</p>",
+                unsafe_allow_html=True)
+    uploaded_files = st.file_uploader("Upload Images", accept_multiple_files=True, key="uploaded_files_key")
+    product_description = st.text_area("Describe the product", value=st.session_state.get("product_description", ""))
+    col1, col2 = st.columns([1, 2])
+    with col1:
+        if st.button("Save"):
+            st.session_state['uploaded_files'] = uploaded_files
+            st.session_state['product_description'] = product_description
+            st.success("Product information saved!")
+    with col2:
+        if st.button("Add product and move to next page"):
+            if not uploaded_files:
+                st.warning("Please upload at least one image.")
+            elif not product_description:
+                st.warning("Please provide a description for the product.")
+            else:
+                st.session_state['uploaded_files'] = uploaded_files
+                st.session_state['product_description'] = product_description
+                st.session_state['page'] = "Page 2"
+
+
+def page2():
+    st.title("Tell us about your shoot preference")
+    st.markdown("<h3 style='color:#444;'>What are you shooting today?</h3>", unsafe_allow_html=True)
+    shoot_type = st.radio("Select your shoot type:", ["Editorial", "Catalogue"], index=0)
+    st.session_state['shoot_type'] = shoot_type
+    brand_link = st.text_input("Add your brand link:", value=st.session_state.get("brand_link", ""))
+    st.session_state['brand_link'] = brand_link
+    if st.button("Get Brand Summary"):
+        if brand_link:
+            brand_summary_html = create_brand_html(brand_link)
+            brand_summary = create_langchain_openai_query(brand_summary_html)
+            st.session_state['brand_summary'] = brand_summary
+            st.success("Brand summary fetched!")
+        else:
+            st.warning("Please add a brand link.")
+    brand_summary_value = st.session_state.get('brand_summary', "")
+    editable_summary = st.text_area("Brand Summary:", value=brand_summary_value, height=100)
+    st.session_state['brand_summary'] = editable_summary
+    product_info = st.text_area("Tell us something about your product:", value=st.session_state.get("product_info", ""))
+    st.session_state['product_info'] = product_info
+    reference_images = st.file_uploader("Upload Reference Images", accept_multiple_files=True,
+                                        key="reference_images_key")
+    st.session_state['reference_images'] = reference_images
+    if st.button("Give Me Ideas"):
+        st.session_state['page'] = "Page 3"
+
+
+def page3():
+    st.title("Scene Suggestions")
+    st.write("Based on your uploaded product and references!")
+    feedback = st.chat_input("Provide feedback:")
+    if not st.session_state.get("assistant_initialized", False):
+        assistant_id = createAssistant("You are a helpful assistant who is an expert in Fashion Shoots.")
+        updated_prompt = prompts["IDEA_GENERATION_PROMPT"].format(
+            brand_details=st.session_state["brand_summary"],
+            product_details=st.session_state["product_info"],
+            type_of_shoot=st.session_state["shoot_type"],
+            json_schema=JSON_SCHEMA_FOR_GPT,
+            product_name=st.session_state["product_description"]
+        )
+        file_locations = []
+        for uploaded_file in st.session_state['uploaded_files']:
+            bytes_data = uploaded_file.getvalue()
+            image = Image.open(io.BytesIO(bytes_data))
+            image.verify()
+            location = f"temp_image_{uploaded_file.name}"
+            with open(location, "wb") as f:
+                f.write(bytes_data)
+            file_locations.append(location)
+            image.close()
+        for uploaded_file in st.session_state['reference_images']:
+            bytes_data = uploaded_file.getvalue()
+            image = Image.open(io.BytesIO(bytes_data))
+            image.verify()
+            location = f"temp2_image_{uploaded_file.name}"
+            with open(location, "wb") as f:
+                f.write(bytes_data)
+            file_locations.append(location)
+            image.close()
+        file_ids = [saveFileOpenAI(location) for location in file_locations]
+        thread_id = startAssistantThread(file_ids, updated_prompt, "yes", "yes")
+        st.session_state.assistant_id = assistant_id
+        st.session_state.thread_id = thread_id
+        st.session_state.assistant_initialized = True
+        regenerate_images(thread_id, assistant_id)
+    if feedback:
+        if 'images' in st.session_state and 'descriptions' in st.session_state:
+            for image_path in st.session_state['images']:
+                os.remove(image_path)
+            del st.session_state['images']
+            del st.session_state['descriptions']
+            del st.session_state["json_descriptions"]
+        addMessageToThread(st.session_state.thread_id, feedback)
+        regenerate_images(st.session_state.thread_id, st.session_state.assistant_id)
+    selected_image_index = None
+    cols = st.columns(1)
+    for i in range(len(st.session_state["images"])):
+        with cols[i]:
+            st.image(st.session_state.images[i], caption=st.session_state.descriptions[i], use_column_width=True)
+            if st.radio(f"Select {i + 1}", [f"Select Image {i + 1}"], key=f"radio_{i}"):
+                selected_image_index = i
+    if selected_image_index is not None and st.button("Refine"):
+        st.session_state.selected_image_index = selected_image_index
+        st.session_state.selected_image = st.session_state.images[selected_image_index]
+        st.session_state.selected_text = st.session_state.descriptions[selected_image_index]
+        st.session_state['page'] = "Page 4"
+    if st.button("Go Back!"):
+        st.session_state.page = "Page 2"
+
+
+def regenerate_images(thread_id, assistant_id):
+    """Helper function to generate images and descriptions."""
+    response_from_process_list = []
+    for _ in range(1):  # Assuming you generate 1 set of image/description
+        response_from_process = process_run(st, thread_id, assistant_id)
+        response_from_process_list.append(response_from_process)
+
+    summary_list = []
+    for final_response in response_from_process_list:
+        prompt_for_idea_summary = prompts["IDEA_SUMMARY_PROMPT"].format(
+            json_schema=str(final_response)
+        )
+        summary = create_chat_completion_request_open_ai_for_summary(prompt_for_idea_summary, "No")
+        summary_list.append(summary)
+
+    # Generate images based on the summaries
+    flux_generated_theme_image = []
+    for summary in summary_list:
+        theme_image = flux_generated_image(summary)
+        flux_generated_theme_image.append(theme_image["file_name"])
+
+    # Save the new images and descriptions in session state
+    st.session_state["images"] = flux_generated_theme_image
+    st.session_state["descriptions"] = summary_list
+    st.session_state["json_descriptions"] = response_from_process_list
+
+
+def page4():
+    import json
+    selected_theme_text_by_user = st.session_state.json_descriptions[st.session_state.selected_image_index]
+    print(selected_theme_text_by_user)
+    schema_for_model_bg = {"type": "object",
+                           "properties": {
+                               "Model": {
+                                   "type": "string",
+                                   "description": "The model name or identifier."
+                               },
+                               "Background": {
+                                   "type": "string",
+                                   "description": "Description or type of the background."
+                               }},
+                           "required": ["Model", "Background"],
+                           "additionalProperties": False
+                           }
+    prompt_to_get_details = (f"You are provided with a brief of a Fashion Shoot : "
+                             f"{st.session_state["json_descriptions"]}).\n Now provide me a JSON which will"
+                             f"have two keys ```Model``` and ```Background```. Provide all detail's"
+                             f"present about model and background in the brief provided by you. Just provide a "
+                             f"natural langauge description. I will use it as description of model and "
+                             f"background needed by the brand Output JSON following the schema")
+    response_from_open_ai = create_chat_completion_request_open_ai_for_summary(prompt_to_get_details,
+                                                                               schema_name="model_bg",
+                                                                               json_schema=schema_for_model_bg,
+                                                                               json_mode="yes")
+    json_response_from_open_ai = json.loads(response_from_open_ai)
+    with (st.sidebar):
+        st.title(st.session_state["product_info"])
+        st.write("Product Image")
+        st.image(st.session_state['uploaded_files'])
+        st.text("Scene Suggestion:")
+        st.image(st.session_state.selected_image)
+        dimensions = st.text_input("Enter Dimensions e.g 3:4, 1:2", key="Dimensions")
+        seed = st.selectbox(
+            "Seed Preference",
+            ("Fixed", "Random"),
+        )
+        if seed == "Fixed":
+            seed_number = st.number_input("Enter an integer:", min_value=1, max_value=100000, value=10, step=1)
+        else:
+            seed_number = 0
+            st.text("Thanks will take care")
+        model_preference = st.selectbox(
+            "Model Preference",
+            ("Create Own/Edit Pre-filled", "Ideas", "Upload Reference"),
+        )
+        if model_preference == "Create Own/Edit Pre-filled":
+            pre_filled_model_details = st.text_area("Model Idea", value=json_response_from_open_ai["Model"],
+                                                    key="Model Idea")
+        elif model_preference == "Ideas":
+            prompt_to_generate_idea = ("Your task is to create model ideas for shoot of a  product of a brand. "
+                                       "The details about the brand: ```{brand_details}.\n The product: {product_name},"
+                                       "which is: ```{product_details}```.\n Reference images for the product and "
+                                       "brands shoot idea is already provided with you. Additionally brand wants to "
+                                       "have a ```{type_of_shoot}``` of the model. Now based on all provided details, "
+                                       "think step by step and provide your ideas about what type of model the brand"
+                                       "should need based on mentioned JSON format. Also provide a combined prompt "
+                                       "which the brand will use to create a shoot image. While creating the "
+                                       "combined prompt as mentioned in the JSON schema, do not miss any details you"
+                                       " mentioned in the JSON.")
+            updated_model_idea_gen_prompt = prompt_to_generate_idea.format(
+                brand_details=st.session_state["brand_summary"],
+                product_details=st.session_state["product_info"],
+                type_of_shoot=st.session_state["shoot_type"],
+                product_name=st.session_state["product_description"]
+
+            )
+            response_for_only_model = create_chat_completion_request_open_ai_for_summary(updated_model_idea_gen_prompt
+                                                                                         , schema_name="model_only",
+                                                                                         json_schema=
+                                                                                         UPDATED_MODEL_ONLY_SCHEMA,
+                                                                                         json_mode="yes")
+            pre_filled_model_details = st.text_area("Model Idea", value=response_for_only_model,
+                                                    key="Model Idea")
+        else:
+            uploaded_files = st.file_uploader("Upload one Model Reference Image here",
+                                              accept_multiple_files=False, key="uploader")
+            bytes_data = uploaded_files.getvalue()
+            image = Image.open(io.BytesIO(bytes_data))
+            image.verify()
+            location = f"temp_image_{uploaded_files.name}"
+            with open(location, "wb") as f:
+                f.write(bytes_data)
+            image.close()
+            prompt_to_generate_idea = ("Follow this JSON Schema : {json_schema_model_only}."
+                                       "Your task is to create model ideas for shoot of a  product of a brand. "
+                                       "The details about the brand: ```{brand_details}.\n The product: {product_name},"
+                                       "which is: ```{product_details}```.\n Reference images for the product and "
+                                       "brands shoot idea is already provided with you. Additionally brand wants to "
+                                       "have a ```{type_of_shoot}``` of the model. Now based on all provided details, "
+                                       "think step by step and provide your ideas about what type of model the brand"
+                                       "should need based on mentioned JSON format. Also provide a combined prompt "
+                                       "which the brand will use to create a shoot image. While creating the "
+                                       "combined prompt as mentioned in the JSON schema, do not miss any details you"
+                                       " mentioned in the JSON.")
+            updated_model_idea_gen_prompt = prompt_to_generate_idea.format(
+                json_schema_model_only=UPDATED_MODEL_ONLY_SCHEMA,
+                brand_details=st.session_state["brand_summary"],
+                product_details=st.session_state["product_info"],
+                type_of_shoot=st.session_state["shoot_type"],
+                product_name=st.session_state["product_description"]
+
+            )
+            json_response = create_image_completion_request_gpt(location, updated_model_idea_gen_prompt)
+            pre_filled_model_details = st.text_area("Model Idea", value=json_response,
+                                                    key="Model Idea")
+        background_preference = st.selectbox(
+            "Background Preference",
+            ("Create Own/Edit Pre-filled", "Ideas", "Upload Reference"),
+        )
+        if background_preference == "Create Own/Edit Pre-filled":
+            pre_filled_background_details = st.text_area("Background Idea",
+                                                         value=json_response_from_open_ai["Background"],
+                                                         key="Background Idea")
+        elif background_preference == "Ideas":
+            prompt_to_generate_idea = ("Follow this JSON Schema : {json_schema_background_only}."
+                                       "Your task is to create location/background ideas for shoot of a  "
+                                       "product of a brand. "
+                                       "The details about the brand: ```{brand_details}.\n The product: {product_name},"
+                                       "which is: ```{product_details}```.\n Reference images for the product and "
+                                       "brands shoot idea is already provided with you. Additionally brand wants to "
+                                       "have a ```{type_of_shoot}``` of the model. Now based on all provided details, "
+                                       "think step by step and provide your ideas about what type of location the brand"
+                                       "should need based on mentioned JSON format. Also provide a combined prompt "
+                                       "which the brand will use to create a shoot image. While creating the "
+                                       "combined prompt as mentioned in the JSON schema, do not miss any details you"
+                                       " mentioned in the JSON.")
+            updated_bg_idea_gen_prompt = prompt_to_generate_idea.format(
+                json_schema_background_only=JSON_SCHEMA_FOR_LOC_ONLY,
+                brand_details=st.session_state["brand_summary"],
+                product_details=st.session_state["product_info"],
+                type_of_shoot=st.session_state["shoot_type"],
+                product_name=st.session_state["product_description"]
+
+            )
+            response_for_only_bg = create_chat_completion_request_open_ai_for_summary(updated_bg_idea_gen_prompt,
+                                                                                      schema_name="bg_o",
+                                                                                      json_schema=JSON_SCHEMA_FOR_LOC_ONLY,
+                                                                                      json_mode="yes")
+            pre_filled_background_details = st.text_area("Background Idea", value=response_for_only_bg,
+                                                         key="Background Idea")
+        else:
+            uploaded_files = st.file_uploader("Upload one Background Reference Image here",
+                                              accept_multiple_files=False, key="uploader")
+            bytes_data = uploaded_files.getvalue()
+            image = Image.open(io.BytesIO(bytes_data))
+            image.verify()
+            location = f"temp2_image_{uploaded_files.name}"
+            with open(location, "wb") as f:
+                f.write(bytes_data)
+            image.close()
+            prompt_to_generate_idea = ("Follow this JSON Schema : {json_schema_bg_only}."
+                                       "Your task is to create Background/Location ideas for shoot of a  "
+                                       "product of a brand. "
+                                       "The details about the brand: ```{brand_details}.\n The product: {product_name},"
+                                       "which is: ```{product_details}```.\n Reference images for the product and "
+                                       "brands shoot idea is already provided with you. Additionally brand wants to "
+                                       "have a ```{type_of_shoot}``` of the model. Now based on all provided details, "
+                                       "think step by step and provide your ideas about what type of location the brand"
+                                       "should need based on mentioned JSON format. Also provide a combined prompt "
+                                       "which the brand will use to create a shoot image. While creating the "
+                                       "combined prompt as mentioned in the JSON schema, do not miss any details you"
+                                       " mentioned in the JSON.")
+            updated_bg_idea_gen_prompt = prompt_to_generate_idea.format(
+                json_schema_bg_only=JSON_SCHEMA_FOR_LOC_ONLY,
+                brand_details=st.session_state["brand_summary"],
+                product_details=st.session_state["product_info"],
+                type_of_shoot=st.session_state["shoot_type"],
+                product_name=st.session_state["product_description"]
+
+            )
+            json_response = create_image_completion_request_gpt(location, updated_bg_idea_gen_prompt)
+            pre_filled_background_details = st.text_area("Background Idea", value=json_response,
+                                                         key="Background Idea")
+        start_chat = st.button("Start Chat")
+    if "mood_chat_messages" not in st.session_state:
+        st.session_state["mood_chat_messages"] = []
+    if seed and dimensions and model_preference and background_preference:
+        if start_chat:
+            final_mood_board_image_prompt = prompts["FINAL_PROMPT_GENERATION"].format(
+                brand_details=st.session_state["brand_summary"],
+                product_details=st.session_state["product_info"],
+                type_of_shoot=st.session_state["shoot_type"],
+                product_name=st.session_state["product_description"],
+                model_details=pre_filled_model_details,
+                location_details=pre_filled_background_details,
+                theme_details=str(selected_theme_text_by_user),
+                chat_history=str(st.session_state["mood_chat_messages"])
+            )
+            prompt_for_flux_mood_board = create_chat_completion_request_open_ai_for_summary(
+                final_mood_board_image_prompt, "No", system_message=prompts["SYSTEM_PROMPT_FOR_MOOD_BOARD"])
+            if seed == "Fixed":
+                generated_flux_image = flux_generated_image_seed(prompt_for_flux_mood_board, seed_number, dimensions)
+            else:
+                generated_flux_image = flux_generated_image(prompt_for_flux_mood_board)
+            st.session_state["mood_chat_messages"].append({
+                "role": "AI",
+                "message": prompt_for_flux_mood_board,
+                "image": generated_flux_image["file_name"]
+            })
+        # for message in st.session_state["mood_chat_messages"]:
+          #  if message["role"] == "AI":
+           #     st.write(f"Caimera AI: {message['message']}")
+            #    st.image(message['image'])
+            #else:
+             #   st.write(f"**You**: {message['message']}")
+        user_input = st.chat_input("Type your message here...")
+        if user_input:
+            st.session_state["mood_chat_messages"].append({"role": "User", "message": user_input})
+            prompt_for_flux_mood_board_n = create_chat_completion_request_open_ai_for_summary(
+                user_input, "No", system_message=prompts["SYSTEM_PROMPT_FOR_MOOD_BOARD"])
+            if seed == "Fixed":
+                generated_flux_image_n = flux_generated_image_seed(prompt_for_flux_mood_board_n, seed_number,
+                                                                   dimensions)
+            else:
+                generated_flux_image_n = flux_generated_image(prompt_for_flux_mood_board_n)
+            st.session_state["mood_chat_messages"].append({
+                "role": "AI",
+                "message": prompt_for_flux_mood_board_n,
+                "image": generated_flux_image_n["file_name"]
+            })
+        for message in st.session_state["mood_chat_messages"]:
+            if message["role"] == "AI":
+                st.write(f"**AI**: {message['message']}")
+                st.image(message['image'])
+            else:
+                st.write(f"**You**: {message['message']}")
+        print(seed_number)
+
+
+if 'page' not in st.session_state:
+    st.session_state.page = "Page 1"
+
+# Routing between pages
+if st.session_state.page == "Page 1":
+    page1()
+elif st.session_state.page == "Page 2":
+    page2()
+elif st.session_state.page == "Page 3":
+    page3()
+elif st.session_state.page == "Page 4":
+    page4()

constants.py

@@ -0,0 +1,131 @@
+JSON_SCHEMA_FOR_GPT = """
+{
+  "title": "Fashion Campaign Ideas",
+  "type": "array",
+  "items": {
+    "type": "object",
+    "properties": {
+      "model": {
+        "type": "object",
+        "properties": {
+          "ethnicity": {
+            "type": "string",
+            "description": "The ethnicity of the model"
+          },
+          "age": {
+            "type": "integer",
+            "description": "The age of the model"
+          },
+          "gender": {
+            "type": "string",
+            "enum": ["male", "female", "non-binary"],
+            "description": "The gender of the model"
+          }
+        },
+        "required": ["ethnicity", "age", "gender"]
+      },
+      "location": {
+        "type": "string",
+        "description": "The location or setting for the shoot"
+      },
+      "mood": {
+        "type": "string",
+        "description": "The overall mood or atmosphere for the shoot"
+      },
+      "emotion": {
+        "type": "string",
+        "description": "The primary emotion to be conveyed in the shoot"
+      },
+      "accessories": {
+        "type": "array",
+        "items": {
+          "type": "string",
+          "description": "Accessories included in the fashion shoot (e.g., sunglasses, handbags, jewelry)"
+        }
+      },
+      "pose": {
+        "type": "string",
+        "description": "The type of pose the model will be holding during the shoot"
+      },
+      "target_market": {
+        "type": "string",
+        "description": "The target audience for the fashion piece"
+      },
+      "reasoning": {
+        "type": "string",
+        "description": "Explanation of why this particular campaign is suggested for the product"
+      },
+      "final_prompt": {
+        "type": "string",
+        "description": "The combined fashion shoot prompt, summarizing all details",
+        "readonly": true
+      }
+    },
+    "required": ["model", "location", "mood", "emotion", "accessories", "pose", "target_market", "reasoning"],
+    "definitions": {
+      "generateFinalPrompt": {
+        "description": "Generate the final prompt by combining all the inputs into a cohesive sentence.",
+        "template": "{mood} photoshoot in {location} featuring a {model.ethnicity}, {model.age}-year-old {model.gender} model wearing accessories like {accessories}. The model holds a {pose} pose, conveying a sense of {emotion}, aimed at the {target_market} market. Reasoning: {reasoning}"
+      }
+    }
+  }
+}"""
+
+UPDATED_MODEL_ONLY_SCHEMA = {
+  "type": "object",
+  "properties": {
+    "model": {
+      "type": "object",
+      "properties": {
+        "ethnicity": {
+          "type": "string",
+          "description": "The ethnicity of the model"
+        },
+        "age": {
+          "type": "integer",
+          "description": "The age of the model"
+        },
+        "gender": {
+          "type": "string",
+          "enum": ["male", "female", "non-binary"],
+          "description": "The gender of the model"
+        },
+        "model_prompt": {
+          "type": "string",
+          "description": "The prompt used to generate the model details"
+        },
+        "reasoning": {
+          "type": "string",
+          "description": "The reasoning behind the model selection"
+        },
+        "background": {
+          "type": "string",
+          "description": "The background information about the model"
+        }
+      },
+      "required": ["ethnicity", "age", "gender", "model_prompt", "reasoning", "background"],
+      "additionalProperties": False
+    }
+  },
+  "required": ["model"],
+  "additionalProperties": False
+}
+
+JSON_SCHEMA_FOR_LOC_ONLY = {
+  "type": "object",
+  "properties": {
+    "location": {
+      "type": "string",
+      "description": "The location or setting for the shoot"
+    },
+    "location_prompt": {
+      "type": "string",
+      "description": "The prompt or instruction related to the location"
+    },
+    "reasoning": {
+      "type": "string",
+      "description": "The reasoning or rationale behind selecting this location"
+    }
+  },
+  "required": ["location", "location_prompt", "reasoning"]
+}

gpt.py

@@ -0,0 +1,198 @@
+from openai import OpenAI
+import os
+import base64
+import requests
+from prompts import prompts
+from constants import JSON_SCHEMA_FOR_GPT
+
+OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
+
+client = OpenAI(api_key=OPENAI_API_KEY)
+model = "gpt-4o"
+title = "Caimera Mood board Expert"
+
+
+def createAssistant(instruction_prompt):
+    instructions = instruction_prompt
+    assistant = client.beta.assistants.create(
+        name=title,
+        instructions=instructions,
+        model=model
+    )
+    return assistant.id
+
+
+def saveFileOpenAI(location):
+    with open(location, "rb") as f:
+        file = client.files.create(file=f, purpose="vision")
+    os.remove(location)
+    return file.id
+
+
+def startAssistantThread(file_id_enum, prompt_n, image_needed, json_mode_needed_or_not):
+    if json_mode_needed_or_not == "yes":
+        if image_needed == "yes":
+            messages = [
+                {
+                    "role": "user",
+                    "content": [
+                        {
+                            "type": "text",
+                            "text": prompt_n
+                        }
+                    ],
+                }
+            ]
+            for file_id in file_id_enum:
+                messages[0]["content"].append({
+                    "type": "image_file",
+                    "image_file": {"file_id": file_id}
+                })
+        else:
+            messages = [
+                {
+                    "role": "user",
+                    "content": prompt_n}]
+        thread = client.beta.threads.create(messages=messages)
+    else:
+        if image_needed == "yes":
+            messages = [
+                {
+                    "role": "user",
+                    "content": [
+                        {
+                            "type": "text",
+                            "text": prompt_n
+                        }
+                    ],
+                }
+            ]
+            for file_id in file_id_enum:
+                messages[0]["content"].append({
+                    "type": "image_file",
+                    "image_file": {"file_id": file_id}
+                })
+        else:
+            messages = [
+                {
+                    "role": "user",
+                    "content": prompt_n}]
+        thread = client.beta.threads.create(messages=messages)
+    return thread.id
+
+
+def runAssistant(thread_id, assistant_id):
+    run = client.beta.threads.runs.create(thread_id=thread_id, assistant_id=assistant_id)
+    return run.id
+
+
+def checkRunStatus(thread_id, run_id):
+    run = client.beta.threads.runs.retrieve(thread_id=thread_id, run_id=run_id)
+    return run.status
+
+
+def retrieveThread(thread_id):
+    thread_messages = client.beta.threads.messages.list(thread_id)
+    list_messages = thread_messages.data
+    thread_messages = []
+    for message in list_messages:
+        obj = {}
+        obj['content'] = message.content[0].text.value
+        obj['role'] = message.role
+        thread_messages.append(obj)
+    return thread_messages[::-1]
+
+
+def addMessageToThread(thread_id, prompt_n):
+    thread_message = client.beta.threads.messages.create(thread_id, role="user", content=prompt_n)
+
+
+def create_chat_completion_request_open_ai_for_summary(prompt, json_mode, schema_name="",
+                                                       json_schema="",
+                                                       system_message="You are expert in Fashion "
+                                                                      "Shoots"):
+    import requests
+    if json_mode == "No":
+        url = "https://api.openai.com/v1/chat/completions"
+        headers = {
+            "Content-Type": "application/json",
+            "Authorization": f"Bearer {OPENAI_API_KEY}"
+        }
+        data = {
+            "model": "gpt-4o",
+            "messages": [
+                {
+                    "role": "system",
+                    "content": system_message
+                },
+                {
+                    "role": "user",
+                    "content": prompt
+                }
+            ]
+        }
+        response = requests.post(url, headers=headers, json=data)
+        json_response = response.json()
+    else:
+        url = "https://api.openai.com/v1/chat/completions"
+        headers = {
+            "Content-Type": "application/json",
+            "Authorization": f"Bearer {OPENAI_API_KEY}"
+        }
+        data = {
+            "model": "gpt-4o",
+            "messages": [
+                {
+                    "role": "system",
+                    "content": "You are expert in creating prompts for Fashion Shoots."
+                },
+                {
+                    "role": "user",
+                    "content": prompt
+                }
+            ],
+            "response_format": {"type": "json_schema", "json_schema": {"name": schema_name, "strict": True, "schema":
+                json_schema}}
+        }
+        response = requests.post(url, headers=headers, json=data)
+        json_response = response.json()
+    print(json_response)
+    return json_response["choices"][0]["message"]["content"]
+
+
+def encode_image(image_path):
+    with open(image_path, "rb") as image_file:
+        return base64.b64encode(image_file.read()).decode('utf-8')
+
+
+def create_image_completion_request_gpt(image_path, prompt):
+    base64_image = encode_image(image_path)
+    headers = {
+        "Content-Type": "application/json",
+        "Authorization": f"Bearer {OPENAI_API_KEY}"
+    }
+    payload = {
+        "model": "gpt-4o",
+        "messages": [
+            {
+                "role": "user",
+                "content": [
+                    {
+                        "type": "text",
+                        "text": prompt
+                    },
+                    {
+                        "type": "image_url",
+                        "image_url": {
+                            "url": f"data:image/jpeg;base64,{base64_image}"
+                        }
+                    }
+                ]
+            }
+        ],
+        "max_tokens": 300
+    }
+    response = requests.post("https://api.openai.com/v1/chat/completions",
+                             headers=headers, json=payload)
+    json_resp = response.json()
+    return json_resp["choices"][0]["message"]["content"]

prompts.py

@@ -0,0 +1,72 @@
+prompts = {
+    "SYSTEM_PROMPT_FOR_MOOD_BOARD": """Act as a fashion stylist to generate detailed prompts for creating AI images 
+    tailored for a fashion brand. Consider brand aesthetics, current fashion trends, color theory, brand themes, 
+    and styles. \n
+    # Steps: \n
+    1. **Understand the Brand Aesthetics**: Analyze the brand's core values, style, and image. 
+    Consider what makes their fashion unique and who their target audience is.\n
+    2. **Incorporate Fashion Trends**: Identify current fashion trends that align with the brand's aesthetics. 
+    Consider elements like cuts, patterns, and colors that are relevant and fresh.\n
+    3. **Apply Color Theory**: Use color theory to choose a palette that complements the brand's existing themes 
+    and stands out in AI-generated images.\n
+    4. **Focus on Brand Theme**: Consider how each element in your prompt sustains the brand's overall theme or 
+    narrative. This could involve mood, setting, or cultural references.\n
+    5. **Detail the Image Composition**: Specify the composition elements such as the setting, pose, and styling 
+    details. Consider using adjectives that communicate the desired mood and visual appeal.\n
+    # Output Format:\n
+    Each prompt should be a descriptive paragraph. The paragraph should include:\n
+    - Brand aesthetics and themes\n
+    - Relevant fashion trends and items\n
+    - Color palette and implications from color theory\n
+    - Desired mood and setting for the image\n
+    - Any specific styling or composition notes\n
+    # Examples\n
+    **Example 1 Input:**\n
+    - Brand: [Elegance Couture]\n
+    - Current Fashion Trends: [Minimalistic cut dresses, soft hues]\n
+    - Brand Theme: [Classic Elegance]\n
+    **Example 1 Output:**\n
+    fashion photography featuring a minimalistic cut dress that embodies the classic elegance of Elegance Couture. 
+    The scene should be a soft, diffused setting with an ivory and blush color palette, reflecting a 
+    serene yet sophisticated atmosphere. The model should pose with graceful ease, against an opulent 
+    vintage backdrop, enhancing the brand's luxurious appeal.\n
+    **Example 2 Input:**\n
+    - Brand: [Urban Vogue]\n
+    - Current Fashion Trends: [Bold prints, oversized jackets]\n
+    - Brand Theme: [Edgy and Vibrant]\n
+    **Example 2 Output:**\n
+    realistic edgy photo that showcases Urban Vogue’s edgy and vibrant style. 
+    The outfit should include an oversized jacket with a bold zebra print, 
+    set against a dynamic urban landscape. The color scheme should be striking, 
+    with electric blues and deep reds. The model should exhibit a confident pose, 
+    capturing the bold energy and spirit of the city.\n
+    # Notes\n
+    - Ensure each prompt aligns with the specific preferences and branding guidelines of the fashion label.\n
+    - Think creatively about settings and poses to invent memorable and distinctive images.\n
+    - Consider lighting and texture elements that could enhance the visual output of the AI image model.""",
+    "IDEA_GENERATION_PROMPT": "Provide output in JSON schema, ```JSON SCHEMA ```: ```{json_schema}```.\n"
+                              "Your task is to create shoot ideas for a product of a brand. "
+                              "The details about the brand: ```{brand_details}.\n The product: {product_name}, "
+                              "which is: "
+                              "```{product_details}```.\n Reference images for the product and brands shoot idea is"
+                              "already provided with you. Additionally brand wants to have a ```{type_of_shoot}```."
+                              "Now based on all provided details, think step by step and provide your ideas in the"
+                              "mentioned JSON format. Also provide a combined prompt which the brand will use to create"
+                              "a shoot image. While creating the combined prompt as mentioned in the JSON schema, do "
+                              "not miss any details you mentioned in other parts of the JSON for example for idea 1 "
+                              "take location, model, product_reasoning everything in account for combined prompt.",
+    "IDEA_SUMMARY_PROMPT": """{json_schema}\nThis contains details about a brand a final prompt.
+    Now understand and summarize , and create a master prompt which will be used by a Fashion brand to create shoots. 
+    You final prompt should be to the point, it should be in same style that is present in final prompt key inside the 
+    JSON, also do not any details from location, model, final prompt etc.
+     IN OUTPUT JUST GIVE ME THE FINAL PROMPT NOTHING ELSE. NO OTHER EXTRA TEXTS NEEDED""",
+    "FINAL_PROMPT_GENERATION": "You have generate prompt to create fashion images as mentioned in the system"
+                               "message based on provided context. Details about the brand: ```{brand_details}\n"
+                               "The product: {product_name}, which is: ```{product_details}```. The brand is looking"
+                               "for Specific model of style:{model_details}, location : {location_details}. The brand"
+                               "is looking for this specific theme: {theme_details}."
+                               "The brand"
+                               "is shooting : {type_of_shoot} photography. Also take the chat history in account(if "
+                               "present / needed) : {chat_history} to iterate the prompt. Now Based on the provided"
+                               "information create a high quality prompt for a Fashion image for the brand."
+}

requirements.txt

@@ -0,0 +1,9 @@
+openai
+replicate
+requests
+pillow
+langchain
+unstructured
+tiktoken
+langchain-community
+nltk

summarizer.py

@@ -0,0 +1,36 @@
+import os
+import base64
+from langchain.docstore.document import Document
+from langchain.text_splitter import CharacterTextSplitter
+from langchain.llms.openai import OpenAI
+from langchain.chains.summarize import load_summarize_chain
+from langchain.document_loaders import UnstructuredURLLoader
+import nltk
+import openai
+
+nltk.download('punkt')
+OPENAI_API_KEY = "sk-proj-uCiflA45fuchFdjkbNJ7T3BlbkFJF5WiEf2zHkttr7s9kijX"
+
+
+def create_brand_html(brand_link):
+    urls = [brand_link]
+    loader = UnstructuredURLLoader(urls=urls)
+    data = loader.load()
+    chunk_size = 3000
+    chunk_overlap = 200
+    text_splitter = CharacterTextSplitter(
+        chunk_size=chunk_size,
+        chunk_overlap=chunk_overlap,
+        length_function=len,
+    )
+    texts = text_splitter.split_text(data[0].page_content)
+    docs = [Document(page_content=t) for t in texts[:]]
+    return docs
+
+
+def create_langchain_openai_query(docs):
+    openai.api_key = OPENAI_API_KEY
+    llm = OpenAI(temperature=0, openai_api_key=openai.api_key)
+    map_reduce_chain = load_summarize_chain(llm, chain_type="map_reduce")
+    output = map_reduce_chain.run(docs)
+    return output

theme.py

@@ -0,0 +1,67 @@
+import random
+import replicate
+import base64
+import os
+
+os.environ["REPLICATE_API_TOKEN"] = os.getenv("REPLICATE_API_TOKEN")
+
+
+def create_flux_request(prompt_for_image_generation):
+    payload = {
+        "prompt": prompt_for_image_generation,
+        "guidance": 3.5,
+        "num_outputs": 1,
+        "aspect_ratio": "3:4"
+    }
+    output = replicate.run(
+        "black-forest-labs/flux-dev",
+        input=payload
+    )
+    return output
+
+
+def flux_generated_image(prompt_for_image_generation):
+    try:
+        flux_response_object = create_flux_request(prompt_for_image_generation)
+        data_uri = flux_response_object[0].url
+        header, encoded = data_uri.split(',', 1)
+        file_data = base64.b64decode(encoded)
+        random_int_for_file_prefix = random.randint(1, 1000000)
+        output_image_file_name = f"{random_int_for_file_prefix}_ide_theme_image.png"
+        with open(output_image_file_name, "wb") as f:
+            f.write(file_data)
+        return {"success": True, "file_name": output_image_file_name}
+    except Exception as e:
+        return {"success": False, "error": e}
+
+
+def create_flux_request_seed(prompt_for_image_generation, seed, aspect_ratio):
+    print(f"YE SEED HAI MEPE:{seed}")
+    payload = {
+        "prompt": prompt_for_image_generation,
+        "guidance": 3.5,
+        "num_outputs": 1,
+        "aspect_ratio": str(aspect_ratio),
+        "seed": int(seed)
+
+    }
+    output = replicate.run(
+        "black-forest-labs/flux-dev",
+        input=payload
+    )
+    return output
+
+
+def flux_generated_image_seed(prompt_for_image_generation, seed, aspect_ratio):
+    try:
+        flux_response_object = create_flux_request_seed(prompt_for_image_generation, seed, aspect_ratio)
+        data_uri = flux_response_object[0].url
+        header, encoded = data_uri.split(',', 1)
+        file_data = base64.b64decode(encoded)
+        random_int_for_file_prefix = random.randint(1, 1000000)
+        output_image_file_name = f"{random_int_for_file_prefix}_ide_theme_image.png"
+        with open(output_image_file_name, "wb") as f:
+            f.write(file_data)
+        return {"success": True, "file_name": output_image_file_name}
+    except Exception as e:
+        return {"success": False, "error": e}