New change

attr_extraction/services.py

@@ -2807,22 +2807,34 @@ class ProductAttributeService:
         if len(float_numbers) < 2:
             return ""
         
-        # If we have 3 dimensions, remove the smallest one (usually thickness/depth)
-        # This handles cases like "16 x 1.5 x 20" -> keep 16 and 20, drop 1.5
-        if len(float_numbers) >= 3:
-            # Sort and remove the smallest
-            float_numbers_sorted = sorted(float_numbers, reverse=True)
-            float_numbers = float_numbers_sorted[:2]
-        
-        # Convert to integers for dimension matching
-        int_numbers = [int(num) for num in float_numbers]
+        # If we have 3 dimensions, it's likely Width x Depth x Height
+        # For wall art, depth is usually small (< 5), so we keep first and last
+        if len(float_numbers) == 3:
+            # Keep first and last values (width and height), skip middle (depth)
+            float_numbers = [float_numbers[0], float_numbers[2]]
+        elif len(float_numbers) > 3:
+            # If more than 3 dimensions, keep the two largest
+            float_numbers = sorted(float_numbers)[-2:]
+        else:
+            # Just 2 dimensions, use as is
+            float_numbers = float_numbers[:2]
+        
+        # Format numbers: use integer if whole, else one decimal
+        formatted_numbers = []
+        for num in float_numbers:
+            if num.is_integer():
+                formatted_numbers.append(str(int(num)))
+            else:
+                formatted_numbers.append(f"{num:.1f}")
         
         # Sort to ensure consistent order (smaller x larger)
-        int_numbers.sort()
+        formatted_numbers.sort(key=lambda x: float(x))
         
         # Return formatted dimension
-        return f"{int_numbers[0]}x{int_numbers[1]}"
+        return f"{formatted_numbers[0]}x{formatted_numbers[1]}"
 
+    
+    
     @staticmethod
     def normalize_value_for_matching(value: str, attr_name: str = "") -> str:
         """
@@ -3222,20 +3234,20 @@ If an attribute is not present, do not include it in the response.
 
     @staticmethod
     def normalize_against_product_text(
-        product_text: str,
-        mandatory_attrs: Dict[str, List[str]],
-        source_map: Dict[str, str],
-        threshold_abs: float = 0.65,
-        margin: float = 0.15,
-        allow_multiple: bool = False,
-        sem_weight: float = 0.8,
-        lex_weight: float = 0.2,
-        extracted_attrs: Optional[Dict[str, List[Dict[str, str]]]] = None,
-        relationships: Optional[Dict[str, float]] = None,
-        use_dynamic_thresholds: bool = True,
-        use_adaptive_margin: bool = True,
-        use_semantic_clustering: bool = True
-    ) -> dict:
+    product_text: str,
+    mandatory_attrs: Dict[str, List[str]],
+    source_map: Dict[str, str],
+    threshold_abs: float = 0.65,
+    margin: float = 0.15,
+    allow_multiple: bool = False,
+    sem_weight: float = 0.8,
+    lex_weight: float = 0.2,
+    extracted_attrs: Optional[Dict[str, List[Dict[str, str]]]] = None,
+    relationships: Optional[Dict[str, float]] = None,
+    use_dynamic_thresholds: bool = True,
+    use_adaptive_margin: bool = True,
+    use_semantic_clustering: bool = True
+) -> dict:
         """
         Score each allowed value against the product_text with dynamic thresholds.
         Returns dict with values in array format: [{"value": "...", "source": "..."}]
@@ -3251,26 +3263,42 @@ If an attribute is not present, do not include it in the response.
         for attr, allowed_values in mandatory_attrs.items():
             scores: List[Tuple[str, float]] = []
             
-            # Normalize product text for dimension matching if needed
-            normalized_product_text = product_text
+            # Check if this is a dimension attribute
             is_dimension_attr = any(keyword in attr.lower() for keyword in ['dimension', 'size', 'measurement'])
+            
+            # Normalize product text once for dimension matching
+            normalized_product_text = ProductAttributeService.normalize_dimension_text(product_text) if is_dimension_attr else ""
 
             for val in allowed_values:
-                # For dimension attributes, try normalized matching first
+                # For dimension attributes, try exact normalized matching first
                 if is_dimension_attr:
+                    # Normalize the allowed value from the list
                     normalized_val = ProductAttributeService.normalize_dimension_text(val)
-                    normalized_pt = ProductAttributeService.normalize_dimension_text(product_text)
                     
-                    # If we find exact normalized match, give it highest score
-                    if normalized_val and normalized_pt and normalized_val == normalized_pt:
-                        scores.append((val, 0.99))
-                        continue
-                    # Also check if dimension appears anywhere in the text
-                    elif normalized_val and normalized_val in normalized_pt:
-                        scores.append((val, 0.95))
+                    # If we have both normalized values and they match exactly, give highest score
+                    if normalized_val and normalized_product_text and normalized_val == normalized_product_text:
+                        scores.append((val, 1.0))
                         continue
+                    
+                    # Also check if the normalized value appears in the original product text
+                    # This handles cases where the format might be slightly different
+                    if normalized_val:
+                        # Extract just the numbers for flexible matching
+                        val_numbers = normalized_val.split('x')
+                        # Check if both numbers appear in the product text in close proximity
+                        text_lower = product_text.lower()
+                        if all(num in text_lower for num in val_numbers):
+                            # Calculate proximity score
+                            idx1 = text_lower.find(val_numbers[0])
+                            idx2 = text_lower.find(val_numbers[1])
+                            if idx1 != -1 and idx2 != -1:
+                                distance = abs(idx2 - idx1)
+                                # If numbers are close together (within 20 characters), high score
+                                if distance < 20:
+                                    scores.append((val, 0.95))
+                                    continue
                 
-                # Standard semantic matching
+                # Standard semantic matching for all attributes
                 contexts = [val, f"for {val}", f"use in {val}", f"suitable for {val}", f"{val} room"]
                 ctx_embs = [model_embedder.encode(c, convert_to_tensor=True) for c in contexts]
                 sem_sim = max(float(util.cos_sim(pt_emb, ce).item()) for ce in ctx_embs)
@@ -3311,8 +3339,7 @@ If an attribute is not present, do not include it in the response.
                     best_cluster = next((c for c in clusters if best_val in c), [best_val])
 
                 for val, sc in scores[1:]:
-                    # Skip values with very low scores - they're likely not relevant
-                    # For dimension attributes, be even more strict
+                    # Skip values with very low scores
                     min_score = 0.4 if is_dimension_attr else 0.3
                     if sc < min_score:
                         continue
@@ -3356,6 +3383,7 @@ If an attribute is not present, do not include it in the response.
 
         return extracted
 
+
     @staticmethod
     def extract_attributes(
         product_text: str,