Update app/utils.py

app/utils.py

@@ -94,7 +94,7 @@ class OCRModel:
             
         except Exception as e:
             logger.error(f"Error in OCR processing: {str(e)}", exc_info=True)
-            if os.path.exists(temp_image_path):
+            if 'temp_image_path' in locals() and os.path.exists(temp_image_path):
                 os.remove(temp_image_path)
             return f"Error processing image: {str(e)}"
 
@@ -111,93 +111,151 @@ class AllergyAnalyzer:
             nltk.download('punkt_tab')
         
         self.allergy_data = self.load_allergy_data()
+        if self.allergy_data is None:
+            raise ValueError("Failed to load allergy data from dataset")
         self.ocr_model = OCRModel()
     
     def load_allergy_data(self):
         """تحميل بيانات الحساسيات من ملف Excel"""
         try:
-            df = pd.read_excel(self.dataset_path, header=None)
+            # قراءة ملف الإكسل مع تحديد أن الصف الأول هو العناوين
+            df = pd.read_excel(self.dataset_path, header=0)
             
             allergy_dict = {}
             
             for index, row in df.iterrows():
-                allergy_name = row.iloc[0].strip().lower()
-                ingredients = [str(ingredient).strip().lower() for ingredient in row[1:] if pd.notna(ingredient)]
-                allergy_dict[allergy_name] = ingredients
+                # الحصول على اسم الحساسية من العمود الأول
+                allergy_name = str(row.iloc[0]).strip().lower()
+                if not allergy_name:
+                    continue
                 
+                # الحصول على المكونات من الأعمدة التالية
+                ingredients = []
+                for col in range(1, len(row)):
+                    ingredient = str(row.iloc[col]).strip().lower()
+                    if ingredient and ingredient != 'nan':
+                        ingredients.append(ingredient)
+                
+                allergy_dict[allergy_name] = ingredients
+            
+            logger.info(f"Successfully loaded allergy data with {len(allergy_dict)} categories")
             return allergy_dict
         
         except Exception as e:
             logger.error(f"Error loading allergy data: {str(e)}", exc_info=True)
+            return None
     
     def tokenize_text(self, text):
         """تقسيم النص إلى كلمات"""
-        tokens = nltk.word_tokenize(text)
-        return [w.lower() for w in tokens if w.isalpha()]
+        try:
+            tokens = nltk.word_tokenize(text)
+            return [w.lower() for w in tokens if w.isalpha()]
+        except Exception as e:
+            logger.error(f"Error tokenizing text: {str(e)}")
+            return []
     
     def check_allergen_in_excel(self, token):
         """التحقق من وجود التوكن في ملف الإكسل"""
-        for allergy_name, ingredients in self.allergy_data.items():
-            if token in ingredients:
-                return allergy_name  # Return the allergy name if token is found
-        return None
+        try:
+            if not self.allergy_data:
+                return None
+                
+            for allergy_name, ingredients in self.allergy_data.items():
+                if token in ingredients:
+                    return allergy_name
+            return None
+        except Exception as e:
+            logger.error(f"Error checking allergen in Excel: {str(e)}")
+            return None
     
     def check_allergy_risk(self, ingredient, api_key):
         """الاستعلام من Claude API عن الحساسيات"""
-        prompt = f"""
-You are a professional food safety expert specializing in allergen classification and risk assessment. Analyze the ingredient '{ingredient}' and determine whether it poses any allergy risk. Respond with 'Yes' or 'No'.
-"""
-        url = "https://api.anthropic.com/v1/messages"
-        headers = {
-            "x-api-key": api_key,
-            "content-type": "application/json",
-        }
-        
-        data = {
-            "model": "claude-3-opus-20240229",
-            "messages": [{"role": "user", "content": prompt}],
-            "max_tokens": 10,
-        }
-        
         try:
+            prompt = f"""
+You are a professional food safety expert. Analyze the ingredient '{ingredient}' and determine which of these allergen categories it belongs to: 
+dairy, eggs, peanuts, soy, tree nuts, wheat, fish, shellfish, sesame. 
+Respond only with the category name or 'None' if not found.
+"""
+            url = "https://api.anthropic.com/v1/messages"
+            headers = {
+                "x-api-key": api_key,
+                "content-type": "application/json",
+                "anthropic-version": "2023-06-01"
+            }
+            
+            data = {
+                "model": "claude-3-opus-20240229",
+                "messages": [{"role": "user", "content": prompt}],
+                "max_tokens": 10
+            }
+            
             response = requests.post(url, json=data, headers=headers)
+            response.raise_for_status()
             
             response_json = response.json()
             
             if "content" in response_json and isinstance(response_json["content"], list):
-                return response_json["content"][0]["text"].strip().lower() == 'yes'
+                result = response_json["content"][0]["text"].strip().lower()
+                # التحقق من أن النتيجة هي واحدة من الحساسيات المعروفة
+                if result in self.allergy_data:
+                    return result
+                return None
                 
         except Exception as e:
             logger.error(f"Error querying Claude API: {str(e)}")
         
-        return False
+        return None
     
     def analyze_image(self, image, claude_api_key=None):
         """تحليل الصورة للكشف عن الحساسيات"""
         try:
+            if not self.allergy_data:
+                raise ValueError("Allergy data not loaded")
+            
             # استخراج النص من الصورة
             extracted_text = self.ocr_model.process_image(image)
+            if extracted_text.startswith("Error processing image"):
+                raise ValueError(extracted_text)
+            
+            logger.info(f"Extracted text: {extracted_text[:200]}...")
             
             # تحويل النص إلى tokens
             tokens = self.tokenize_text(extracted_text)
+            if not tokens:
+                raise ValueError("No tokens extracted from text")
             
-            detected_allergens = {}
+            database_matches = {}
+            claude_matches = {}
             
             for token in tokens:
-                allergy_from_excel = self.check_allergen_in_excel(token)
-                
-                if allergy_from_excel:
-                    detected_allergens[token] = allergy_from_excel
-                
-                elif claude_api_key:  # إذا لم يُوجد في ملف الإكسل، استدعِ Claude API
-                    is_allergen_risky = self.check_allergy_risk(token, claude_api_key)
-                    detected_allergens[token] = 'API Risk' if is_allergen_risky else 'Safe'
+                # البحث أولاً في قاعدة البيانات
+                allergy = self.check_allergen_in_excel(token)
+                if allergy:
+                    if allergy not in database_matches:
+                        database_matches[allergy] = []
+                    database_matches[allergy].append(token)
+                elif claude_api_key:
+                    # إذا لم يُوجد في ملف الإكسل، استدعِ Claude API
+                    allergy = self.check_allergy_risk(token, claude_api_key)
+                    if allergy:
+                        if allergy not in claude_matches:
+                            claude_matches[allergy] = []
+                        claude_matches[allergy].append(token)
+            
+            detected_allergens = list(database_matches.keys()) + list(claude_matches.keys())
             
             return {
                 "extracted_text": extracted_text,
                 "detected_allergens": detected_allergens,
+                "database_matches": database_matches,
+                "claude_matches": claude_matches,
                 "analyzed_tokens": tokens,
+                "success": True
             }
         
         except Exception as e:
             logger.error(f"Error analyzing image: {str(e)}", exc_info=True)
+            return {
+                "error": str(e),
+                "success": False
+            }