Upload 2 files

apis/ourdata.py

@@ -0,0 +1,91 @@
+import logging
+import random
+import asyncio
+import concurrent.futures
+
+from helpercodes.image_functions import generate_image, _encode_image_to_base64
+from helpercodes.ourdata_advanced import get_links, generate_gpt_prompt_our_data, get_dataset_dict
+
+
+def _process_single_style(style_key, keywords_list, data):
+    """
+    Processes a single style synchronously:
+      1. Samples keywords.
+      2. Retrieves relevant images/links from DataFrame.
+      3. Generates GPT prompt and final image.
+      4. Builds the final response dictionary (title, body, des, images).
+    Returns:
+      A dictionary with { title, body, des, images } or None if there's an issue.
+    """
+    logging.info(f"Working on style '{style_key}'...")
+
+    if not keywords_list:
+        # If style has no keywords, skip
+        return None
+
+    sampled_keywords = random.sample(keywords_list, min(len(keywords_list), 5))
+    input_keywords = ", ".join(sampled_keywords)
+
+    # Filter DF to match this style
+    df_subset = data[data['styles'] == style_key].copy()
+    if df_subset.empty:
+        return None
+
+    # Get top-2 relevant images from DF
+    results = get_links(df_subset, input_keywords)
+    if len(results) < 2:
+        return None
+
+    # Generate GPT prompt and final image
+    prompt = generate_gpt_prompt_our_data(results)
+    logging.info(f"Prompt: {prompt}")
+    image = generate_image(prompt, '1:1', "None")
+
+    return image
+
+
+async def process_our_data():
+    """
+    Randomly picks 5 keywords from each style (if available),
+    finds top-2 relevant images, calls GPT for a prompt, and
+    streams the generated images in a Gradio Gallery.
+    This version uses multi-threading to process each style concurrently.
+    """
+    logging.info("Processing our data...")
+    response = []
+
+    # Get data, style dictionary
+    data, style_dict = get_dataset_dict()
+
+    # We'll gather coroutines so that each style is processed in a thread
+    loop = asyncio.get_running_loop()
+
+    # Collect async tasks here
+    tasks = []
+    with concurrent.futures.ThreadPoolExecutor() as executor:
+        for style_key, keywords_list in style_dict.items():
+            # Schedule the synchronous processing function in a separate thread
+            tasks.append(
+                loop.run_in_executor(
+                    executor,
+                    _process_single_style,  # function to run
+                    style_key,  # arguments
+                    keywords_list,
+                    data
+                )
+            )
+            break
+
+        # Await all results
+        results = await asyncio.gather(*tasks)
+
+    # Filter out any None values (cases where we skip)
+    for r in results:
+        if r is not None:
+            response.append(r)
+
+    return response
+
+
+def process_our_data_sync():
+    return asyncio.run(process_our_data())

apis/userdata.py

@@ -0,0 +1,77 @@
+import logging
+import asyncio
+from concurrent.futures import ThreadPoolExecutor
+
+from helpercodes.image_functions import generate_image
+from helpercodes.user_data import generate_gpt_prompt, _encode_image_to_base64
+
+
+def _generate_prompt_and_image(pos: str, neg: str, category: str, story_instruction: str,
+                               sentiment, image_elements, is_text, text_elements, input_prompt, non_compliant, emotion,
+                               aspect_ratio, design):
+
+    # Generate the GPT prompt
+    prompt = generate_gpt_prompt(
+        pos,
+        neg,
+        category,
+        story_instruction,
+        sentiment, image_elements, is_text, text_elements, input_prompt, non_compliant, emotion
+    )
+
+    # Generate the image from the prompt
+    image = generate_image(prompt, aspect_ratio, design)
+
+    return image
+
+
+async def process_custom_data(pos, category, neg, sentiment, image_elements, is_text, text_elements, input_prompt,
+                              non_compliant, emotion, aspect_ratio, design):
+
+
+    logging.info("Processing custom data...")
+
+    # The two different instructions
+    instruction_var = (
+        "which should have new offers, revised text and graphics but style should remain same"
+    )
+    instruction_same = (
+        "which should have new offers and revised text but graphics and style should remain same"
+    )
+
+    # We'll use asyncio's event loop to run blocking code in a ThreadPoolExecutor
+    loop = asyncio.get_running_loop()
+
+    # Create the thread pool
+    with ThreadPoolExecutor() as executor:
+        # Schedule both tasks in parallel
+        future_var = loop.run_in_executor(
+            executor,
+            _generate_prompt_and_image,
+            pos,
+            neg,
+            category,
+            instruction_var,
+            sentiment, image_elements, is_text, text_elements, input_prompt,
+            non_compliant, emotion, aspect_ratio, design
+        )
+        future_same = loop.run_in_executor(
+            executor,
+            _generate_prompt_and_image,
+            pos,
+            neg,
+            category,
+            instruction_same,
+            sentiment, image_elements, is_text, text_elements, input_prompt,
+            non_compliant, emotion, aspect_ratio, design
+        )
+
+        # Wait for both images to finish
+        image_var, image_same = await asyncio.gather(future_var, future_same)
+
+    return image_var, image_same
+
+def process_user_data_sync(pos, category, neg, sentiment, image_elements, is_text, text_elements, input_prompt,
+                              non_compliant, emotion, aspect_ratio, design):
+    return asyncio.run(process_custom_data(pos, category, neg, sentiment, image_elements, is_text, text_elements, input_prompt,
+                              non_compliant, emotion, aspect_ratio, design))