bring changes to demo app

app/config.py

@@ -5,6 +5,7 @@ from typing import Optional
 from pydantic_settings import BaseSettings
 
 
+os.environ["WEAVE_CAPTURE_CODE"] = "false"
 if os.getenv("HUGGINGFACE_DEMO"):
     OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
     ANTHROPIC_API_KEY = os.getenv("ANTHROPIC_API_KEY")

app/request_handler/extract_handler.py

@@ -9,7 +9,7 @@ from app.core.errors import BadRequestError, VendorError
 from app.schemas.requests import ExtractionRequest
 from app.schemas.responses import APIResponse
 from app.services.factory import AIServiceFactory
-from app.utils.logger import setup_logger
+from app.utils.logger import exception_to_str, setup_logger
 
 logger = setup_logger(__name__)
 settings = get_settings()
@@ -32,16 +32,17 @@ async def handle_extract(request: ExtractionRequest):
                 )
             service = AIServiceFactory.get_service(ai_vendor)
 
-            pil_images = []
+            # pil_images = []
+            pil_images = None  # temporarily removed to save cost
             for url in request.img_urls:
                 try:
-                    response = requests.get(url)
-                    response.raise_for_status()
-                    image = Image.open(BytesIO(response.content))
-                    pil_images.append(image)
+                    # response = requests.get(url)
+                    # response.raise_for_status()
+                    # image = Image.open(BytesIO(response.content))
+                    # pil_images.append(image)
+                    pass
                 except Exception as e:
-                    print(e)
-                    logger.error(f"Failed to download or process image from {url}: {e}")
+                    # logger.error(f"Failed to download or process image from {url}: {exception_to_str(e)}")
                     raise HTTPException(
                         status_code=400,
                         detail=f"Failed to process image from {url}",
@@ -58,20 +59,28 @@ async def handle_extract(request: ExtractionRequest):
             )
             break
         except BadRequestError as e:
-            logger.error("Bad request error: ", e)
+            logger.error(
+                f"Bad request error: {exception_to_str(e)}",
+            )
             raise HTTPException(
-                status_code=400, detail=str(e), headers={"attempt": attempt}
+                status_code=400,
+                detail=exception_to_str(e),
+                headers={"attempt": attempt},
             )
         except ValueError as e:
-            logger.error("Value error: ", e)
+            logger.error(f"Value error: {exception_to_str(e)}")
             raise HTTPException(
-                status_code=400, detail=str(e), headers={"attempt": attempt}
+                status_code=400,
+                detail=exception_to_str(e),
+                headers={"attempt": attempt},
             )
         except VendorError as e:
-            logger.error("Vendor error: ", e)
+            logger.error(f"Vendor error: {exception_to_str(e)}")
             if attempt == request.max_attempts:
                 raise HTTPException(
-                    status_code=500, detail=str(e), headers={"attempt": attempt}
+                    status_code=500,
+                    detail=exception_to_str(e),
+                    headers={"attempt": attempt},
                 )
             else:
                 if request.ai_model in settings.ANTHROPIC_MODELS:
@@ -90,10 +99,10 @@ async def handle_extract(request: ExtractionRequest):
                     )
 
         except HTTPException as e:
-            logger.error("HTTP exception: ", e)
+            logger.error(f"HTTP exception: {exception_to_str(e)}")
             raise e
         except Exception as e:
-            logger.error("Exception: ", e)
+            logger.error("Exception: ", exception_to_str(e))
             if (
                 "overload" in str(e).lower()
                 and request.ai_model in settings.ANTHROPIC_MODELS

app/request_handler/follow_handler.py

@@ -4,7 +4,7 @@ from app.config import get_settings
 from app.core.errors import VendorError
 from app.schemas.requests import FollowSchemaRequest
 from app.services.factory import AIServiceFactory
-from app.utils.logger import setup_logger
+from app.utils.logger import exception_to_str, setup_logger
 
 logger = setup_logger(__name__)
 settings = get_settings()
@@ -34,12 +34,16 @@ async def handle_follow(request: FollowSchemaRequest):
         except ValueError as e:
             if attempt == request.max_attempts:
                 raise HTTPException(
-                    status_code=400, detail=str(e), headers={"attempt": attempt}
+                    status_code=400,
+                    detail=exception_to_str(e),
+                    headers={"attempt": attempt},
                 )
         except VendorError as e:
             if attempt == request.max_attempts:
                 raise HTTPException(
-                    status_code=500, detail=str(e), headers={"attempt": attempt}
+                    status_code=500,
+                    detail=exception_to_str(e),
+                    headers={"attempt": attempt},
                 )
         except Exception as e:
             if attempt == request.max_attempts:

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.logger import exception_to_str
 
 
 def validate_json_data(data: Dict[str, Any], schema: Dict[str, Any]):
@@ -17,7 +18,7 @@ def validate_json_data(data: Dict[str, Any], schema: Dict[str, Any]):
     try:
         jsonschema.validate(instance=data, schema=schema)
     except jsonschema.ValidationError as e:
-        raise VendorError(f"Vendor generated invalid data: {e}")
+        raise VendorError(f"Vendor generated invalid data {exception_to_str(e)}")
 
 
 def validate_json_schema(schema: Dict[str, Any]):
@@ -74,16 +75,56 @@ 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_code += f"    {allowed_value.replace(' ', '_').replace('-', '_').upper()} = '{allowed_value}'\n"
+                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()
+                )
+
+                if "'" in allowed_value:
+                    enum_code += f'    E{enum_name} = "{allowed_value}"\n'
+                else:
+                    enum_code += f"    E{enum_name} = '{allowed_value}'\n"
             enum_code_list.append(enum_code)
             data_type = f"{key.capitalize()}Enum"
 
         if is_list:
             data_type = f"List[{data_type}]"
 
-        master_class_code += (
-            f"    {key}: {data_type} = Field(..., description='{description}')\n"
-        )
+        if "'" in description:
+            master_class_code += (
+                f'    {key}: {data_type} = Field(..., description="{description}")\n'
+            )
+        else:
+            master_class_code += (
+                f"    {key}: {data_type} = Field(..., description='{description}')\n"
+            )
 
     entire_code = import_code + "\n".join(enum_code_list) + "\n" + master_class_code
     exec(entire_code, globals())

app/services/base.py

@@ -45,9 +45,9 @@ class BaseAttributionService(ABC):
             attributes_model,
             ai_model,
             img_urls,
-            product_taxonomy,
+            product_taxonomy if product_taxonomy != "" else "main",
             product_data,
-            # pil_images=pil_images, # temporarily removed for save cost
+            # pil_images=pil_images, # temporarily removed to save cost
             img_paths=img_paths,
         )
         validate_json_data(data, schema)

app/services/service_anthropic.py

@@ -14,14 +14,14 @@ from app.core.prompts import get_prompts
 from app.services.base import BaseAttributionService
 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 setup_logger
+from app.utils.logger import exception_to_str, setup_logger
 
-deployment = os.getenv("DEPLOYMENT", "LOCAL")
-if deployment == "LOCAL":  # local or demo
+env = os.getenv("ENV", "LOCAL")
+if env == "LOCAL":  # local or demo
     weave_project_name = "cfai/attribution-exp"
-elif deployment == "DEV":
+elif env == "DEV":
     weave_project_name = "cfai/attribution-dev"
-elif deployment == "PROD":
+elif env == "PROD":
     weave_project_name = "cfai/attribution-prod"
 
 weave.init(project_name=weave_project_name)
@@ -102,16 +102,32 @@ class AnthropicService(BaseAttributionService):
                 system=system_message,
                 tools=tools,
                 messages=messages,
+                temperature=0.0,
+                top_p=1.0,
+                top_k=1,
             )
         except anthropic.BadRequestError as e:
             raise BadRequestError(e.message)
         except Exception as e:
-            raise VendorError(errors.VENDOR_THROW_ERROR.format(error_message=str(e)))
+            raise VendorError(
+                errors.VENDOR_THROW_ERROR.format(error_message=exception_to_str(e))
+            )
 
         for content in response.content:
             if content.type == "tool_use":
+                if content.input is None or not content.input:
+                    raise VendorError(
+                        errors.VENDOR_THROW_ERROR.format(
+                            error_message="content.input is None or content.input is empty"
+                        )
+                    )
+
                 return content.input
 
+        raise VendorError(
+            errors.VENDOR_THROW_ERROR.format(error_message="No tool_use found")
+        )
+
     @weave.op
     async def follow_schema(self, schema, data):
         logger.info("Following structure via Anthropic...")
@@ -146,7 +162,9 @@ class AnthropicService(BaseAttributionService):
                 messages=messages,
             )
         except Exception as e:
-            raise VendorError(errors.VENDOR_THROW_ERROR.format(error_message=str(e)))
+            raise VendorError(
+                errors.VENDOR_THROW_ERROR.format(error_message=exception_to_str(e))
+            )
 
         for content in response.content:
             if content.type == "tool_use":

app/services/service_openai.py

@@ -9,7 +9,7 @@ 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.logger import setup_logger
+from app.utils.logger import exception_to_str, setup_logger
 
 from ..config import get_settings
 from ..core import errors
@@ -17,12 +17,12 @@ from ..core.errors import BadRequestError, VendorError
 from ..core.prompts import get_prompts
 from .base import BaseAttributionService
 
-deployment = os.getenv("DEPLOYMENT", "LOCAL")
-if deployment == "LOCAL":  # local or demo
+env = os.getenv("ENV", "LOCAL")
+if env == "LOCAL":  # local or demo
     weave_project_name = "cfai/attribution-exp"
-elif deployment == "DEV":
+elif env == "DEV":
     weave_project_name = "cfai/attribution-dev"
-elif deployment == "PROD":
+elif env == "PROD":
     weave_project_name = "cfai/attribution-prod"
 
 weave.init(project_name=weave_project_name)
@@ -111,11 +111,14 @@ class OpenAIService(BaseAttributionService):
                 logprobs=False,
                 # top_logprobs=2,
                 temperature=0.0,
+                top_p=1,
             )
         except openai.BadRequestError as e:
-            raise BadRequestError(str(e))
+            raise BadRequestError(exception_to_str(e))
         except Exception as e:
-            raise VendorError(errors.VENDOR_THROW_ERROR.format(error_message=str(e)))
+            raise VendorError(
+                errors.VENDOR_THROW_ERROR.format(error_message=exception_to_str(e))
+            )
 
         try:
             content = response.choices[0].message.content
@@ -157,7 +160,9 @@ class OpenAIService(BaseAttributionService):
                 temperature=0.0,
             )
         except Exception as e:
-            raise VendorError(errors.VENDOR_THROW_ERROR.format(error_message=str(e)))
+            raise VendorError(
+                errors.VENDOR_THROW_ERROR.format(error_message=exception_to_str(e))
+            )
 
         if response.choices[0].message.refusal:
             logger.info("OpenAI refused to respond to the request")

app/utils/logger.py

@@ -1,6 +1,24 @@
 import logging
 import os
 from logging.handlers import RotatingFileHandler
+import traceback
+
+
+def exception_to_str(e: Exception, max_lines: int = 12) -> str:
+    """
+    Convert an exception to a string, limiting the number of lines.
+    """
+
+    exception_message = "\n".join(str(e).splitlines()[:2])
+    stack_trace = "".join(traceback.format_tb(e.__traceback__))
+
+    exception_str = exception_message + "\n" + stack_trace
+
+    lines = exception_str.splitlines()
+    if len(lines) > max_lines:
+        exception_str = "\n".join(lines[:max_lines]) + "\n... (truncated)"
+
+    return exception_str
 
 
 # Configure logger