add: new endpoint product page-->batch nto,cto,mto generation

app.py

@@ -2,6 +2,7 @@ import mimetypes
 import os
 import tempfile
 import time
+from dataclasses import dataclass
 from typing import List
 
 import requests
@@ -11,15 +12,27 @@ from starlette.responses import JSONResponse
 from supabase import create_client
 
 from src.components.each_necklace_video_gen import EachVideoCreator
+from src.components.product_page_nto_cto_gen import ProductPageImageGeneration
 from src.components.vidgen import VideoCreator
 from src.utils.logs import logger
 
 supabase_url = os.getenv('SUPABASE_URL')
 supabase_key = os.getenv('SUPABASE_KEY')
 supabase = create_client(supabase_url, supabase_key)
+
+prod_page = ProductPageImageGeneration()
+
+
+@dataclass
+class MakeupColors:
+    lipstick: str
+    eyeliner: str
+    eyeshadow: str
+
+
 app = FastAPI()
 
-RESOURCES_DIR = "/app/resources/"
+RESOURCES_DIR = "resources"
 
 os.makedirs(RESOURCES_DIR, exist_ok=True)
 TEMP_VIDEO_DIR = f"{RESOURCES_DIR}/temp_video"
@@ -337,6 +350,68 @@ async def get_information():
     return JSONResponse(content=json, status_code=200)
 
 
+def ensure_json_serializable(data):
+    if isinstance(data, list):
+        return [ensure_json_serializable(item) for item in data]
+    elif isinstance(data, dict):
+        return {key: ensure_json_serializable(value) for key, value in data.items()}
+    elif hasattr(data, "__dict__"):
+        return ensure_json_serializable(data.__dict__)
+    else:
+        return data
+
+
+@app.post("/product_page_image_generation")
+async def product_page_image_generation(model_image: str, necklace_id: str, necklace_category: str, storename: str,
+                                        x_offset: str,
+                                        y_offset: str,
+                                        clothing_list: List[str],
+                                        makeup_colors: MakeupColors):
+    try:
+        model_name = model_image.split("/")[-1].split(".")[0]
+
+        model_image_path = download_image(model_image)
+
+        if model_image_path is None:
+            return JSONResponse(content={"status": "error", "message": "Failed to download model image"},
+                                status_code=400)
+
+        response = prod_page.process_full_tryon_sequence(
+            model_image_path,
+            necklace_id,
+            {
+                "id": necklace_id,
+                "category": necklace_category,
+                "store_name": storename,
+                "offset_x": x_offset,
+                "offset_y": y_offset
+            },
+
+            clothing_list,
+            makeup_colors,
+            model_name=model_name
+        )
+
+        nto_results = response["nto_results"]
+        cto_results = response["cto_results"]
+        mto_results = response["mto_results"]
+
+        json_response = {
+            "status": "success",
+            "message": "Product page images generated successfully.",
+            "nto_results": ensure_json_serializable(nto_results),
+            "cto_results": ensure_json_serializable(cto_results),
+            "mto_results": ensure_json_serializable(mto_results)
+        }
+
+        return JSONResponse(content=json_response, status_code=200)
+
+
+
+    except Exception as e:
+        return JSONResponse(content={"status": "error", "message": str(e)}, status_code=500)
+
+
 if __name__ == "__main__":
     import uvicorn
 

src/components/product_page_nto_cto_gen.py

@@ -0,0 +1,272 @@
+import os
+from dataclasses import dataclass
+from typing import List, Dict, Optional
+
+import requests
+from supabase import create_client
+
+from src.utils.logs import logger
+
+supabase_url = os.getenv('SUPABASE_URL')
+supabase_key = os.getenv('SUPABASE_KEY')
+supabase = create_client(supabase_url, supabase_key)
+
+
+@dataclass
+class MakeupColors:
+    lipstick: str
+    eyeliner: str
+    eyeshadow: str
+
+
+class ProductPageImageGeneration:
+    def __init__(self):
+        self.nto_endpoint = "https://techconspartners-cfgvigrclbw4urtwcjficydv0edz7x.hf.space/necklaceTryOnID"
+        self.cto_endpoint = "https://techconspartners-cfgvigrclbw4urtwcjficydv0edz7x.hf.space/clothingTryOnV2"
+        self.mto_endpoint = "https://techconspartners-cfgvigrclbw4urtwcjficydv0edz7x.hf.space/makeup_tryon/tryon"
+        self.destination_bucket = "ProductPageOutputs"
+
+    def generate_filename(self,
+                          base_id: str,
+                          model_name: str,
+                          try_on_type: str,
+                          item_type: Optional[str] = None,
+                          makeup_colors: Optional[MakeupColors] = None) -> str:
+        """Generate a consistent filename for storage"""
+        parts = [base_id, model_name, try_on_type]
+
+        if item_type and not isinstance(item_type, MakeupColors):
+            logger.info(f"Item type: {item_type}")
+            parts.append(item_type.replace(' ', '_'))
+
+        if makeup_colors:
+            colors_str = f"lip_{makeup_colors.lipstick}_eye_{makeup_colors.eyeliner}_shadow_{makeup_colors.eyeshadow}"
+            parts.append(colors_str.replace(' ', '_'))
+
+        return f"{'-'.join(parts)}.png"
+
+    def check_file_exists(self, filename: str) -> bool:
+        """Check if file already exists in Supabase storage"""
+        try:
+            supabase.storage.from_(self.destination_bucket).get_public_url(filename)
+            return True
+        except:
+            return False
+
+    def upload_to_supabase(self, image_content: bytes, filename: str) -> str:
+        """Upload or replace file in Supabase storage"""
+        try:
+            # Delete existing file if it exists
+            if self.check_file_exists(filename):
+                try:
+                    supabase.storage.from_(self.destination_bucket).remove([filename])
+                except Exception as e:
+                    logger.error(f"Error deleting existing file {filename}: {str(e)}")
+
+            # Upload new file
+            result = supabase.storage.from_(self.destination_bucket).upload(
+                filename,
+                image_content,
+                {"content-type": "image/png"}
+            )
+
+            return supabase.storage.from_(self.destination_bucket).get_public_url(filename)
+        except Exception as e:
+            print(f"Error uploading {filename}: {str(e)}")
+            return ""
+
+    def process_necklace_tryon(self,
+                               image_path: str,
+                               necklace_id: str,
+                               category: str,
+                               store_name: str,
+                               offset_x: float,
+                               offset_y: float) -> dict:
+        """Process a necklace try-on request"""
+        try:
+            with open(image_path, 'rb') as img_file:
+                files = {
+                    'image': (os.path.basename(image_path), img_file, 'image/jpeg')
+                }
+                data = {
+                    'necklaceImageId': necklace_id,
+                    'necklaceCategory': category,
+                    'storename': store_name,
+                    'offset_x': str(offset_x),
+                    'offset_y': str(offset_y)
+                }
+                response = requests.post(self.nto_endpoint, files=files, data=data)
+                response.raise_for_status()
+                logger.info(f"Necklace Try on Completed for {necklace_id}")
+                return response.json()
+        except Exception as e:
+            print(f"Error in necklace try-on: {str(e)}")
+            return None
+
+    def process_clothing_tryon(self, image_path: str, clothing_type: str) -> dict:
+        """Process a clothing try-on request"""
+        try:
+            with open(image_path, 'rb') as img_file:
+                files = {
+                    'image': (os.path.basename(image_path), img_file, 'image/jpeg')
+                }
+                data = {
+                    'clothing_type': clothing_type
+                }
+                response = requests.post(self.cto_endpoint, files=files, data=data)
+                response.raise_for_status()
+                logger.info(f"Clothing Try on Completed for {clothing_type}")
+                return response.json()
+
+        except Exception as e:
+            logger.info(f"Error in clothing try-on: {str(e)}")
+            return None
+
+    def process_makeup_tryon(self,
+                             image_path: str,
+                             makeup_colors: MakeupColors) -> dict:
+        """Process a makeup try-on request"""
+        try:
+            with open(image_path, 'rb') as img_file:
+                files = {
+                    'image': (os.path.basename(image_path), img_file, 'image/jpeg')
+                }
+                data = {
+                    'lipstick_color': makeup_colors.lipstick,
+                    'eyeliner_color': makeup_colors.eyeliner,
+                    'eyeshadow_color': makeup_colors.eyeshadow
+                }
+                response = requests.post(self.mto_endpoint, files=files, data=data)
+                response.raise_for_status()
+                logger.info(f"Makeup Try on Completed for {makeup_colors}")
+                return response.json()
+        except Exception as e:
+            print(f"Error in makeup try-on: {str(e)}")
+            return None
+
+    def process_full_tryon_sequence(self,
+                                    model_image_path: str,
+                                    model_id: str,
+                                    necklace_config: Dict,
+                                    clothing_list: List[str],
+                                    makeup_colors: MakeupColors,
+                                    model_name) -> dict:
+        """Process a complete sequence of try-ons"""
+        results = {
+            "nto_results": [],
+            "cto_results": [],
+            "mto_results": []
+        }
+
+        # 1. First, process necklace try-on
+        nto_response = self.process_necklace_tryon(
+            model_image_path,
+            necklace_config['id'],
+            necklace_config['category'],
+            necklace_config['store_name'],
+            necklace_config['offset_x'],
+            necklace_config['offset_y']
+        )
+
+        if nto_response and 'output' in nto_response:
+            try:
+                image_response = requests.get(nto_response['output'])
+                filename = self.generate_filename(model_id, model_name, "nto", necklace_config['category'])
+                url = self.upload_to_supabase(image_response.content, filename)
+                if url:
+                    results["nto_results"].append({
+                        "necklace_id": necklace_config['id'],
+                        "url": url
+                    })
+            except Exception as e:
+                print(f"Error processing necklace result: {str(e)}")
+
+        # 2. Process each clothing type
+        for clothing_type in clothing_list:
+            cto_response = self.process_clothing_tryon(model_image_path, clothing_type)
+
+            if cto_response and cto_response.get("code") == 200:
+                try:
+                    # Get the clothing try-on result
+                    cto_image = requests.get(cto_response['output'])
+
+                    # Save clothing result
+                    filename = self.generate_filename(model_id, "cto", clothing_type)
+                    cto_url = self.upload_to_supabase(cto_image.content, filename)
+
+                    if cto_url:
+                        results["cto_results"].append({
+                            "clothing_type": clothing_type,
+                            "url": cto_url
+                        })
+
+                    # 3. Apply makeup to clothing result
+                    temp_path = f"temp_{model_id}_{clothing_type}.png"
+                    with open(temp_path, 'wb') as f:
+                        f.write(cto_image.content)
+
+                    mto_response = self.process_makeup_tryon(temp_path, makeup_colors)
+                    os.remove(temp_path)  # Clean up temp file
+
+                    if mto_response and mto_response.get("code") == 200:
+                        mto_image = requests.get(mto_response['output'])
+                        filename = self.generate_filename(
+                            model_id,
+                            model_name,
+                            "mto",
+                            item_type=clothing_type,
+                            makeup_colors=makeup_colors
+                        )
+                        mto_url = self.upload_to_supabase(mto_image.content, filename)
+
+                        if mto_url:
+                            results["mto_results"].append({
+                                "clothing_type": clothing_type,
+                                "makeup_colors": makeup_colors,
+                                "url": mto_url
+                            })
+
+                            logger.info(f"Makeup Try on Completed for {clothing_type}")
+
+                except Exception as e:
+                    logger.error(f"Error processing {clothing_type}: {str(e)}")
+                    print(f"Error processing {clothing_type}: {str(e)}")
+
+        return results
+
+
+# Example usage:
+"""
+processor = FashionTryOnProcessor()
+
+# Configuration
+necklace_config = {
+    "id": "necklace123",
+    "category": "traditional",
+    "store_name": "jewelry_store",
+    "offset_x": 0,
+    "offset_y": 0
+}
+
+clothing_list = ["silk saree", "kurti", "casual dress"]
+
+makeup_colors = MakeupColors(
+    lipstick="Carmine Red",
+    eyeliner="Black",
+    eyeshadow="Maroon"
+)
+
+# Process everything
+results = processor.process_full_tryon_sequence(
+    model_image_path="path/to/model/image.jpg",
+    model_id="model123",
+    necklace_config=necklace_config,
+    clothing_list=clothing_list,
+    makeup_colors=makeup_colors
+)
+
+# Print results
+print("Necklace try-ons:", len(results["nto_results"]))
+print("Clothing try-ons:", len(results["cto_results"]))
+print("Makeup try-ons:", len(results["mto_results"]))
+"""