update demo app

app/config.py

@@ -12,10 +12,14 @@ if os.getenv("HUGGINGFACE_DEMO"):
 else:
     from app.aws.secrets import get_secret
 
+    ENV = os.getenv("ENV", "LOCAL")
     secrets = get_secret()
-    os.environ["WANDB_API_KEY"] = secrets["WANDB_API_KEY"]
+    if ENV != "PROD":
+        os.environ["WANDB_API_KEY"] = secrets["WANDB_API_KEY"]
     OPENAI_API_KEY = secrets["OPENAI_API_KEY"]
     ANTHROPIC_API_KEY = secrets["ANTHROPIC_API_KEY"]
+    REDIS_PASSWORD = secrets["REDIS_PASSWORD"] if ENV == "PROD" else ""
+    REDIS_USE_SSL = True if ENV == "PROD" or ENV == "UAT" else False
 os.environ["WANDB_BASE_URL"] = "https://api.wandb.ai"
 
 
@@ -59,21 +63,20 @@ class Settings(BaseSettings):
     RATE_LIMIT_PERIOD: int = 60
 
     # Cache Configuration
-    REDIS_URL: Optional[str] = None
-    CACHE_TTL: int = 3600  # 1 hour
+    REDIS_PASSWORD: Optional[str] = REDIS_PASSWORD
+    REDIS_USE_SSL: Optional[bool] = REDIS_USE_SSL
 
     # Logging
     LOG_LEVEL: str = "INFO"
     LOG_FORMAT: str = "json"
 
-    # Timeout Configuration
-    OPENAI_TIMEOUT: float = 30.0
-    ANTHROPIC_TIMEOUT: float = 30.0
-
     # API Keys
     OPENAI_API_KEY: str = OPENAI_API_KEY
     ANTHROPIC_API_KEY: str = ANTHROPIC_API_KEY
 
+    #
+    MAX_DOWNLOAD_RETRY: int = 10  # times
+
     def validate_api_keys(self):
         """Validate that required API keys are present."""
         if not self.OPENAI_API_KEY:

app/core/prompts.py

@@ -6,7 +6,7 @@ from pydantic_settings import BaseSettings
 EXTRACT_INFO_SYSTEM = "You are an expert in structured data extraction. You will be given an image or a set of images of a product and should extract its properties into the given structure."
 
 EXTRACT_INFO_HUMAN = (
-    """Output properties of the {product_taxonomy} product shown in the images. You should use the following product data to assist you, if available:
+    """Output properties of the main product (or {product_taxonomy}) shown in the images. You should use the following product data to assist you, if available:
     
     {product_data}
     

app/schemas/schema_tools.py

@@ -8,6 +8,7 @@ from pydantic import BaseModel, Field  # do not remove this import for exec
 
 from app.core.errors import VendorError
 from app.schemas.requests import Attribute
+from app.utils.converter import to_snake_case
 from app.utils.logger import exception_to_str
 
 
@@ -74,38 +75,8 @@ def convert_attribute_to_model(attributes: Dict[str, Attribute]) -> Dict[str, An
 
         if len(allowed_values) > 0:
             enum_code = f"class {key.capitalize()}Enum(str, Enum):\n"
-            for allowed_value in allowed_values:
-                enum_name = (
-                    allowed_value.replace(" ", "_")
-                    .replace("-", "_")
-                    .replace("&", "AND")
-                    .replace("/", "_OR_")
-                    .replace(":", "__")
-                    .replace("+", "plus")
-                    .replace(",", "_")
-                    .replace(".", "_")
-                    .replace("°", "degree")
-                    .replace("(", "")
-                    .replace(")", "")
-                    .replace("'", "_")
-                    .replace('%', "")
-                    .replace("!", "")
-                    .replace("?", "")
-                    .replace("`", "")
-                    .replace("~", "")
-                    .replace(";", "")
-                    .replace("<", "")
-                    .replace(">", "")
-                    .replace("[", "")
-                    .replace("]", "")
-                    .replace("{", "")
-                    .replace("}", "")
-                    .replace("\\", "")
-                    .replace("|", "")
-                    .replace('–', "_")
-                    .replace('*', "_")
-                    .upper()
-                )
+            for i, allowed_value in enumerate(allowed_values):
+                enum_name = f'{to_snake_case(allowed_value).upper()}_{i}'
 
                 if "'" in allowed_value:
                     enum_code += f'    E{enum_name} = "{allowed_value}"\n'

app/services/base.py

@@ -2,6 +2,7 @@ from abc import ABC, abstractmethod
 from typing import Any, Dict, List, Type, Union
 
 from pydantic import BaseModel
+from app.utils.converter import to_snake_case
 
 from app.schemas.schema_tools import (
     convert_attribute_to_model,
@@ -39,7 +40,19 @@ class BaseAttributionService(ABC):
         img_paths: List[str] = None,
     ) -> Dict[str, Any]:
         # validate_json_schema(schema)
-        attributes_model = convert_attribute_to_model(attributes)
+
+        # create mappings for keys of attributes, to make the key following naming convention of python variables
+        forward_mapping = {}
+        reverse_mapping = {}
+        for i, key in enumerate(attributes.keys()):
+            forward_mapping[key] = f'{to_snake_case(key)}_{i}'
+            reverse_mapping[f'{to_snake_case(key)}_{i}'] = key
+        
+        transformed_attributes = {}
+        for key, value in attributes.items():
+            transformed_attributes[forward_mapping[key]] = value
+
+        attributes_model = convert_attribute_to_model(transformed_attributes)
         schema = attributes_model.model_json_schema()
         data = await self.extract_attributes(
             attributes_model,
@@ -51,7 +64,12 @@ class BaseAttributionService(ABC):
             img_paths=img_paths,
         )
         validate_json_data(data, schema)
-        return data
+
+        # reverse the key mapping to the original keys
+        reverse_data = {}
+        for key, value in data.items():
+            reverse_data[reverse_mapping[key]] = value
+        return reverse_data
 
     async def follow_schema_with_validation(
         self, schema: Dict[str, Any], data: Dict[str, Any]

app/services/service_anthropic.py

@@ -16,15 +16,18 @@ from app.utils.converter import product_data_to_str
 from app.utils.image_processing import get_data_format, get_image_data
 from app.utils.logger import exception_to_str, setup_logger
 
-env = os.getenv("ENV", "LOCAL")
-if env == "LOCAL":  # local or demo
+ENV = os.getenv("ENV", "LOCAL")
+if ENV == "LOCAL":  # local or demo
     weave_project_name = "cfai/attribution-exp"
-elif env == "DEV":
+elif ENV == "DEV":
     weave_project_name = "cfai/attribution-dev"
-elif env == "PROD":
-    weave_project_name = "cfai/attribution-prod"
+elif ENV == "UAT":
+    weave_project_name = "cfai/attribution-uat"
+elif ENV == "PROD":
+    pass
 
-weave.init(project_name=weave_project_name)
+if ENV != "PROD":
+    weave.init(project_name=weave_project_name)
 settings = get_settings()
 prompts = get_prompts()
 logger = setup_logger(__name__)
@@ -102,8 +105,8 @@ class AnthropicService(BaseAttributionService):
                 system=system_message,
                 tools=tools,
                 messages=messages,
-                temperature=0.0,
-                top_p=1.0,
+                # temperature=0.0,
+                # top_p=1e-45,
                 top_k=1,
             )
         except anthropic.BadRequestError as e:

app/services/service_openai.py

@@ -8,7 +8,11 @@ from openai import AsyncOpenAI
 from pydantic import BaseModel
 
 from app.utils.converter import product_data_to_str
-from app.utils.image_processing import get_data_format, get_image_data
+from app.utils.image_processing import (
+    get_data_format,
+    get_image_base64_and_type,
+    get_image_data,
+)
 from app.utils.logger import exception_to_str, setup_logger
 
 from ..config import get_settings
@@ -17,15 +21,18 @@ from ..core.errors import BadRequestError, VendorError
 from ..core.prompts import get_prompts
 from .base import BaseAttributionService
 
-env = os.getenv("ENV", "LOCAL")
-if env == "LOCAL":  # local or demo
+ENV = os.getenv("ENV", "LOCAL")
+if ENV == "LOCAL":  # local or demo
     weave_project_name = "cfai/attribution-exp"
-elif env == "DEV":
+elif ENV == "DEV":
     weave_project_name = "cfai/attribution-dev"
-elif env == "PROD":
-    weave_project_name = "cfai/attribution-prod"
+elif ENV == "UAT":
+    weave_project_name = "cfai/attribution-uat"
+elif ENV == "PROD":
+    pass
 
-weave.init(project_name=weave_project_name)
+if ENV != "PROD":
+    weave.init(project_name=weave_project_name)
 settings = get_settings()
 prompts = get_prompts()
 logger = setup_logger(__name__)
@@ -62,7 +69,6 @@ class OpenAIService(BaseAttributionService):
         pil_images: List[Any] = None,  # do not remove, this is for weave
         img_paths: List[str] = None,
     ) -> Dict[str, Any]:
-        logger.info("Extracting info via OpenAI...")
         text_content = [
             {
                 "type": "text",
@@ -73,14 +79,22 @@ class OpenAIService(BaseAttributionService):
             },
         ]
         if img_urls is not None:
+            base64_data_list = []
+            data_format_list = []
+
+            for img_url in img_urls:
+                base64_data, data_format = get_image_base64_and_type(img_url)
+                base64_data_list.append(base64_data)
+                data_format_list.append(data_format)
+
             image_content = [
                 {
                     "type": "image_url",
                     "image_url": {
-                        "url": img_url,
+                        "url": f"data:image/{data_format};base64,{base64_data}",
                     },
                 }
-                for img_url in img_urls
+                for base64_data, data_format in zip(base64_data_list, data_format_list)
             ]
         elif img_paths is not None:
             image_content = [
@@ -94,6 +108,7 @@ class OpenAIService(BaseAttributionService):
             ]
 
         try:
+            logger.info("Extracting info via OpenAI...")
             response = await self.client.beta.chat.completions.parse(
                 model=ai_model,
                 messages=[
@@ -110,11 +125,12 @@ class OpenAIService(BaseAttributionService):
                 response_format=attributes_model,
                 logprobs=False,
                 # top_logprobs=2,
-                temperature=0.0,
-                top_p=1,
+                # temperature=0.0,
+                top_p=1e-45,
             )
         except openai.BadRequestError as e:
-            raise BadRequestError(exception_to_str(e))
+            error_message = exception_to_str(e)
+            raise BadRequestError(error_message)
         except Exception as e:
             raise VendorError(
                 errors.VENDOR_THROW_ERROR.format(error_message=exception_to_str(e))

app/utils/converter.py

@@ -1,3 +1,4 @@
+import re
 from typing import Dict, List, Union
 
 
@@ -40,3 +41,20 @@ def product_data_to_str(product_data: Dict[str, Union[str, List[str]]]) -> str:
         data_list.append(data_line)
 
     return "\n".join(data_list)
+
+
+def to_snake_case(s):
+    # Remove leading/trailing whitespace and convert to lowercase
+    s = s.strip().lower()
+    # Replace spaces, hyphens, and periods with underscores
+    s = re.sub(r'[\s\-\.\+]', '_', s)
+    # Remove any characters that are not alphanumeric or underscores
+    s = re.sub(r'[^a-z0-9_]', '', s)
+    # Replace multiple underscores with a single one
+    s = re.sub(r'_+', '_', s)
+    # Remove leading digits (Python variable names can't start with a number)
+    s = re.sub(r'^[0-9]+', '', s)
+    # Make sure it doesn't start with an underscore and is not empty
+    if not s or not s[0].isalpha():
+        s = 'var_' + s
+    return s

app/utils/image_processing.py

@@ -1,4 +1,8 @@
 import base64
+import io
+from PIL import Image
+
+import requests
 
 
 def get_image_data(image_path):
@@ -11,4 +15,82 @@ def get_data_format(image_path):
     image_format = image_path.split(".")[-1]
     if image_format == "jpg":
         image_format = "jpeg"
-    return image_format
+    return
+
+
+def get_image_base64_and_type(image_url: str, max_dimension: int = 2048) -> tuple[str | None, str | None]:
+    try:
+        # --- 1. Download the image ---
+        response = requests.get(image_url, stream=True, timeout=20) # Added timeout
+        response.raise_for_status()  # Raise an exception for bad status codes (4xx or 5xx)
+    
+        # Check content type
+        content_type = response.headers.get('content-type')
+        allowed_types = ['image/png', 'image/jpeg', 'image/webp', 'image/gif']
+        if not content_type or content_type not in allowed_types:
+            raise ValueError(f"Unsupported image type: {content_type}. Expected one of {allowed_types}.")
+
+        # --- 2. Open the image using Pillow ---
+        image_data = response.content
+        img = Image.open(io.BytesIO(image_data))
+
+        # Check if the image is animated (GIF)
+        if img.format == 'GIF' and getattr(img, 'is_animated', False):
+            raise ValueError("Animated GIFs are not supported.")
+
+        # --- 3. Check dimensions and resize if necessary ---
+        width, height = img.size
+        longest_dim = max(width, height)
+
+        if longest_dim > max_dimension:
+            # print(f"Image dimensions ({width}x{height}) exceed max dimension ({max_dimension}). Resizing...")
+            if width > height:
+                # Width is the longest dimension
+                new_width = max_dimension
+                new_height = int(height * (max_dimension / width))
+            else:
+                # Height is the longest or they are equal
+                new_height = max_dimension
+                new_width = int(width * (max_dimension / height))
+
+            # Resize the image - Use Resampling.LANCZOS for high-quality downscaling
+            img = img.resize((new_width, new_height), Image.Resampling.LANCZOS)
+            # print(f"Image resized to: {img.size}"
+
+        width, height = img.size
+        shortest_dim = min(width, height)
+
+        if shortest_dim > 768:
+            if width < height:
+                new_width = 768
+                new_height = int(height * (768 / width))
+            else:
+                new_height = 768
+                new_width = int(width * (768 / height))
+            img = img.resize((new_width, new_height), Image.Resampling.LANCZOS)
+        
+
+        # --- 4. Save the image to a byte buffer ---
+        # We need to save the potentially modified image back to bytes
+        buffer = io.BytesIO()
+        # Save with the JPG format. Handle potential format issues.
+        try:
+            img_format = 'JPEG'
+            img.save(buffer, format=img_format, quality=100) 
+        except Exception as save_err:
+            try:
+                # Fallback to PNG if original format saving fails
+                img_format = 'PNG'
+                img.save(buffer, format=img_format)
+            except Exception as png_save_err:
+                raise Exception(f"Failed to save image in PNG format. Error: {png_save_err}")
+
+        image_bytes = buffer.getvalue()
+
+        # --- 5. Encode the image bytes to base64 ---
+        base64_encoded_image = base64.b64encode(image_bytes).decode('utf-8')
+
+        return base64_encoded_image, img_format
+
+    except Exception as e:
+        raise ValueError(f"Invalid image URL: {e}")