Simplify translations - GGUF model with GPU is fast enough

models/natlas_model.py

@@ -395,89 +395,22 @@ class NATLaSTransformersModel:
     
     def translate_batch(self, texts: List[str], target_language: str) -> List[str]:
         """
-        Translate multiple texts in a SINGLE model call.
+        Translate multiple texts using individual translations.
         
-        This is much faster than translating each text separately because:
-        - Only ONE model inference instead of N inferences
-        - Reduces total time from O(N * inference_time) to O(inference_time)
-        
-        Example: 10 translations in ~30-60 seconds instead of ~5+ minutes
+        With GGUF model + GPU, individual translations are fast enough!
         """
         if target_language == "en" or not texts:
             return texts
         
-        # Filter out empty texts and track their positions
-        non_empty_texts = []
-        positions = []
-        for i, text in enumerate(texts):
+        results = []
+        for text in texts:
             if text and text.strip():
-                non_empty_texts.append(text.strip())
-                positions.append(i)
-        
-        if not non_empty_texts:
-            return texts
-        
-        lang_name = LANGUAGE_NAMES.get(target_language, target_language)
-        
-        # Build numbered list for batch translation
-        numbered_texts = "\n".join([f"{i+1}. {text}" for i, text in enumerate(non_empty_texts)])
-        
-        prompt = f"""Translate each numbered item below to {lang_name}. 
-Return ONLY the translations in the same numbered format. Do not add explanations.
-
-{numbered_texts}"""
-        
-        system_prompt = f"You are a professional translator. Translate each numbered item to {lang_name}. Return only the numbered translations, nothing else."
-        
-        # Calculate max tokens based on total input length
-        total_chars = sum(len(t) for t in non_empty_texts)
-        max_tokens = min(total_chars * 4, 2000)  # Cap at 2000 tokens
-        
-        logger.info(f"🚀 Batch translating {len(non_empty_texts)} texts to {lang_name}...")
-        
-        result = self.generate(
-            prompt=prompt,
-            system_prompt=system_prompt,
-            max_new_tokens=max_tokens,
-            temperature=0.3,
-            repetition_penalty=1.1
-        )
-        
-        if not result:
-            logger.warning("⚠️ Batch translation failed - returning originals")
-            return texts
-        
-        # Parse the numbered results
-        translations = self._parse_numbered_translations(result, len(non_empty_texts))
-        
-        # Build final result list
-        final_results = list(texts)  # Copy original
-        for idx, pos in enumerate(positions):
-            if idx < len(translations) and translations[idx]:
-                final_results[pos] = translations[idx]
-        
-        logger.info(f"✅ Batch translation complete: {len(translations)} items")
-        return final_results
-    
-    def _parse_numbered_translations(self, result: str, expected_count: int) -> List[str]:
-        """Parse numbered translation results."""
-        translations = []
-        lines = result.strip().split('\n')
+                translated = self.translate(text, target_language)
+                results.append(translated if translated else text)
+            else:
+                results.append(text)
         
-        for line in lines:
-            line = line.strip()
-            if not line:
-                continue
-            
-            # Try to extract numbered items (e.g., "1. Translation" or "1) Translation")
-            match = re.match(r'^\d+[\.\)]\s*(.+)$', line)
-            if match:
-                translations.append(match.group(1).strip())
-            elif line and not line[0].isdigit():
-                # Line without number - might be continuation or standalone
-                if translations:
-                    # Append to last translation if it seems like continuation
-                    pass
+        return results
                 else:
                     translations.append(line)
         
@@ -611,63 +544,20 @@ class NATLaSModel:
     
     def translate_batch(self, texts: List[str], target_language: str, use_cache: bool = True) -> List[str]:
         """
-        Translate multiple texts efficiently using batch translation.
+        Translate multiple texts using individual translations.
         
-        This method:
-        1. Checks cache for already-translated texts
-        2. Sends remaining texts in ONE batch call to the model
-        3. Caches new translations
-        
-        Result: ~5x faster than individual translations!
+        With the smaller GGUF model + GPU, individual translations are fast enough!
         """
         if target_language == "en" or not texts:
             return texts
         
-        # Separate cached and uncached texts
-        results = [None] * len(texts)
-        uncached_texts = []
-        uncached_indices = []
-        
+        results = []
         for i, text in enumerate(texts):
             if not text or not text.strip():
-                results[i] = text
-                continue
-            
-            cache_key = f"{target_language}:{hash(text)}"
-            if use_cache and cache_key in self._cache:
-                results[i] = self._cache[cache_key]
-                logger.info(f"📦 Cache hit for text {i+1}")
-            else:
-                uncached_texts.append(text)
-                uncached_indices.append(i)
-        
-        # If all texts were cached, return immediately
-        if not uncached_texts:
-            logger.info("📦 All translations from cache!")
-            return results
-        
-        # Batch translate uncached texts
-        logger.info(f"🚀 Batch translating {len(uncached_texts)} texts ({len(texts) - len(uncached_texts)} cached)...")
-        
-        translated = self.model.translate_batch(uncached_texts, target_language)
-        
-        # Store results and cache them
-        for idx, original_idx in enumerate(uncached_indices):
-            if idx < len(translated) and translated[idx]:
-                results[original_idx] = translated[idx]
-                # Cache the translation
-                if use_cache:
-                    cache_key = f"{target_language}:{hash(uncached_texts[idx])}"
-                    self._cache[cache_key] = translated[idx]
+                results.append(text)
             else:
-                # Fallback to original text
-                results[original_idx] = texts[original_idx]
-        
-        # Clean cache if too large
-        if len(self._cache) > 500:
-            keys = list(self._cache.keys())[:100]
-            for k in keys:
-                del self._cache[k]
+                translated = self.translate(text, target_language, use_cache)
+                results.append(translated)
         
         return results
     

services/diagnosis_generator.py

@@ -1,14 +1,11 @@
 """
-FarmEyes Diagnosis Generator Service (OPTIMIZED)
-=================================================
+FarmEyes Diagnosis Generator Service
+====================================
 Generates complete multilingual diagnosis reports by combining:
 - Disease detection results (from YOLO model)
 - Knowledge base information (symptoms, treatments, costs)
 - N-ATLaS translations (Hausa, Yoruba, Igbo)
 
-OPTIMIZATION: Uses batch translation to reduce N-ATLaS calls from 20+ to just 1-2.
-This improves translation speed from ~5 minutes to ~30-60 seconds.
-
 Produces farmer-friendly reports with actionable treatment recommendations.
 """
 
@@ -187,8 +184,6 @@ class DiagnosisGenerator:
     """
     Generates complete multilingual diagnosis reports.
     Combines disease detection, knowledge base, and translation services.
-    
-    OPTIMIZED: Uses batch translation for 5x faster performance.
     """
     
     def __init__(self, auto_load_models: bool = False):
@@ -205,7 +200,7 @@ class DiagnosisGenerator:
         # Load services
         self._init_services(auto_load_models)
         
-        logger.info("DiagnosisGenerator initialized (OPTIMIZED with batch translation)")
+        logger.info("DiagnosisGenerator initialized")
     
     def _init_services(self, auto_load_models: bool) -> None:
         """Initialize required services."""
@@ -301,7 +296,7 @@ class DiagnosisGenerator:
         return self._build_report(detection_result, language)
     
     # =========================================================================
-    # REPORT BUILDING (OPTIMIZED WITH BATCH TRANSLATION)
+    # REPORT BUILDING
     # =========================================================================
     
     def _build_report(
@@ -332,435 +327,168 @@ class DiagnosisGenerator:
         report.confidence_level = detection_result.get_confidence_level()
         
         if detection_result.is_healthy:
-            self._build_healthy_report_optimized(report, detection_result, language)
+            self._build_healthy_report(report, detection_result, language)
         else:
-            self._build_disease_report_optimized(report, detection_result, language)
+            self._build_disease_report(report, detection_result, language)
         
         return report
     
-    def _build_healthy_report_optimized(
+    def _build_healthy_report(
         self,
         report: DiagnosisReport,
         detection_result,
         language: str
     ) -> None:
-        """Build report for healthy plant detection using batch translation."""
-        
-        # Skip translation for English
-        if language == "en":
-            report.disease_name = detection_result.display_name or "Healthy Plant"
-            report.summary_message = f"Great news! Your {detection_result.crop_type} plant appears to be healthy. Continue with good farming practices to maintain plant health."
-            report.healthy_message = detection_result.healthy_message or report.summary_message
-            
-            if detection_result.maintenance_tips:
-                report.maintenance_tips = detection_result.maintenance_tips[:6]
-            else:
-                report.maintenance_tips = [
-                    "Continue regular monitoring for early disease detection",
-                    "Maintain proper watering and fertilization",
-                    "Keep the field free of weeds",
-                    "Practice crop rotation",
-                    "Use disease-free planting materials"
-                ]
-            report.expected_yield = detection_result.expected_yield
-            return
-        
-        # Collect all texts to translate in one batch
-        texts_to_translate = []
-        text_keys = []  # Track what each text is for
-        
-        # 1. Disease name
-        texts_to_translate.append(detection_result.display_name or "Healthy Plant")
-        text_keys.append("disease_name")
+        """Build report for healthy plant detection."""
+        # Disease name (translated)
+        report.disease_name = self._translate(
+            detection_result.display_name or "Healthy Plant",
+            language
+        )
         
-        # 2. Summary message
+        # Summary message
         summary_en = f"Great news! Your {detection_result.crop_type} plant appears to be healthy. Continue with good farming practices to maintain plant health."
-        texts_to_translate.append(summary_en)
-        text_keys.append("summary_message")
+        report.summary_message = self._translate(summary_en, language)
         
-        # 3. Healthy message
+        # Healthy message
         if detection_result.healthy_message:
-            texts_to_translate.append(detection_result.healthy_message)
-            text_keys.append("healthy_message")
+            report.healthy_message = self._translate(
+                detection_result.healthy_message,
+                language
+            )
+        else:
+            report.healthy_message = report.summary_message
         
-        # 4. Maintenance tips
+        # Maintenance tips
         if detection_result.maintenance_tips:
-            tips = detection_result.maintenance_tips[:6]
+            report.maintenance_tips = self._translate_list(
+                detection_result.maintenance_tips[:6],
+                language
+            )
         else:
-            tips = [
+            # Default tips
+            default_tips = [
                 "Continue regular monitoring for early disease detection",
                 "Maintain proper watering and fertilization",
                 "Keep the field free of weeds",
                 "Practice crop rotation",
                 "Use disease-free planting materials"
             ]
+            report.maintenance_tips = self._translate_list(default_tips, language)
         
-        tip_start_idx = len(texts_to_translate)
-        for tip in tips:
-            texts_to_translate.append(tip)
-            text_keys.append("maintenance_tip")
-        
-        # BATCH TRANSLATE ALL AT ONCE
-        logger.info(f"🚀 Batch translating {len(texts_to_translate)} texts for healthy report...")
-        translated = self._translate_batch(texts_to_translate, language)
-        
-        # Apply translations
-        idx = 0
-        report.disease_name = translated[idx]; idx += 1
-        report.summary_message = translated[idx]; idx += 1
-        
-        if "healthy_message" in text_keys:
-            report.healthy_message = translated[idx]; idx += 1
-        else:
-            report.healthy_message = report.summary_message
-        
-        # Maintenance tips
-        report.maintenance_tips = translated[tip_start_idx:]
+        # Expected yield
         report.expected_yield = detection_result.expected_yield
     
-    def _build_disease_report_optimized(
+    def _build_disease_report(
         self,
         report: DiagnosisReport,
         detection_result,
         language: str
     ) -> None:
-        """
-        Build report for disease detection using BATCH translation.
-        
-        OPTIMIZATION: Instead of 20+ individual translate() calls,
-        we collect ALL texts and translate them in 1-2 batch calls.
-        This reduces time from ~5 minutes to ~30-60 seconds.
-        """
-        
-        # Set non-translated fields first
+        """Build report for disease detection."""
+        # Disease information
+        report.disease_name = self._translate(
+            detection_result.display_name,
+            language
+        )
         report.disease_name_scientific = detection_result.scientific_name
         report.disease_category = detection_result.category
+        
+        # Severity
+        report.severity_level = self._translate(
+            detection_result.severity_level.replace("_", " ").title(),
+            language
+        )
         report.severity_scale = detection_result.severity_scale
+        report.severity_description = self._translate(
+            detection_result.severity_description,
+            language
+        )
+        
+        # Summary message
+        summary_en = self._create_summary_message(detection_result)
+        report.summary_message = self._translate(summary_en, language)
+        
+        # Symptoms
+        if detection_result.symptoms:
+            report.symptoms = self._translate_list(
+                detection_result.symptoms[:6],
+                language
+            )
+        
+        # Transmission
+        if detection_result.transmission:
+            report.transmission = self._translate_list(
+                detection_result.transmission[:5],
+                language
+            )
+        
+        # Yield impact
         report.yield_loss_min = detection_result.yield_loss_min
         report.yield_loss_max = detection_result.yield_loss_max
+        yield_msg_en = f"This disease can cause {detection_result.yield_loss_min}% to {detection_result.yield_loss_max}% yield loss if not treated."
+        report.yield_loss_message = self._translate(yield_msg_en, language)
+        
+        # Treatments
+        self._build_treatment_sections(report, detection_result, language)
+        
+        # Costs
         report.treatment_cost_min = detection_result.treatment_cost_min
         report.treatment_cost_max = detection_result.treatment_cost_max
+        cost_msg_en = f"Estimated treatment cost: ₦{detection_result.treatment_cost_min:,} to ₦{detection_result.treatment_cost_max:,} per hectare."
+        report.cost_message = self._translate(cost_msg_en, language)
+        
+        # Prevention
+        if detection_result.prevention:
+            report.prevention_tips = self._translate_list(
+                detection_result.prevention[:6],
+                language
+            )
         
-        # Expert contact (no translation needed)
+        # Health projection
+        self._build_health_projection(report, detection_result, language)
+        
+        # Expert contact
         expert = detection_result.expert_contact
         if expert:
             report.expert_institution = expert.get("institution", "")
             report.expert_location = expert.get("location", "")
             report.expert_services = expert.get("services", "")
-        
-        # Skip translation for English
-        if language == "en":
-            self._build_disease_report_english(report, detection_result)
-            return
-        
-        # =====================================================================
-        # COLLECT ALL TEXTS FOR BATCH TRANSLATION
-        # =====================================================================
-        
-        texts_to_translate = []
-        text_mapping = []  # Track (field_name, index_in_list_or_none)
-        
-        # 1. Disease name
-        texts_to_translate.append(detection_result.display_name)
-        text_mapping.append(("disease_name", None))
-        
-        # 2. Severity level
-        texts_to_translate.append(detection_result.severity_level.replace("_", " ").title())
-        text_mapping.append(("severity_level", None))
-        
-        # 3. Severity description
-        texts_to_translate.append(detection_result.severity_description)
-        text_mapping.append(("severity_description", None))
-        
-        # 4. Summary message
-        summary_en = self._create_summary_message(detection_result)
-        texts_to_translate.append(summary_en)
-        text_mapping.append(("summary_message", None))
-        
-        # 5. Yield loss message
-        yield_msg_en = f"This disease can cause {detection_result.yield_loss_min}% to {detection_result.yield_loss_max}% yield loss if not treated."
-        texts_to_translate.append(yield_msg_en)
-        text_mapping.append(("yield_loss_message", None))
-        
-        # 6. Cost message
-        cost_msg_en = f"Estimated treatment cost: ₦{detection_result.treatment_cost_min:,} to ₦{detection_result.treatment_cost_max:,} per hectare."
-        texts_to_translate.append(cost_msg_en)
-        text_mapping.append(("cost_message", None))
-        
-        # 7. Symptoms (list)
-        symptoms = detection_result.symptoms[:6] if detection_result.symptoms else []
-        for i, symptom in enumerate(symptoms):
-            texts_to_translate.append(symptom)
-            text_mapping.append(("symptom", i))
-        
-        # 8. Transmission (list)
-        transmission = detection_result.transmission[:5] if detection_result.transmission else []
-        for i, trans in enumerate(transmission):
-            texts_to_translate.append(trans)
-            text_mapping.append(("transmission", i))
-        
-        # 9. Prevention tips (list)
-        prevention = detection_result.prevention[:6] if detection_result.prevention else []
-        for i, tip in enumerate(prevention):
-            texts_to_translate.append(tip)
-            text_mapping.append(("prevention", i))
-        
-        # 10. Treatment texts
-        treatments = detection_result.treatments
-        treatment_texts = self._collect_treatment_texts(treatments)
-        treatment_start_idx = len(texts_to_translate)
-        for item in treatment_texts:
-            text = item[0]
-            mapping_info = item[1]  # This is a tuple that can have 2 or 3 elements
-            texts_to_translate.append(text)
-            text_mapping.append(mapping_info)
-        
-        # 11. Health projection messages
-        projection = detection_result.health_projection
-        projection_texts = []
-        if projection:
-            for stage, info in projection.items():
-                if isinstance(info, dict) and info.get("message"):
-                    texts_to_translate.append(info.get("message", ""))
-                    text_mapping.append(("projection", stage))
-                    projection_texts.append((stage, info.get("recovery_chance_percent", 0)))
-        
-        # =====================================================================
-        # BATCH TRANSLATE ALL TEXTS IN ONE CALL
-        # =====================================================================
-        
-        logger.info(f"🚀 Batch translating {len(texts_to_translate)} texts for disease report...")
-        translated = self._translate_batch(texts_to_translate, language)
-        
-        # =====================================================================
-        # APPLY TRANSLATIONS TO REPORT
-        # =====================================================================
-        
-        # Initialize lists
-        report.symptoms = [""] * len(symptoms)
-        report.transmission = [""] * len(transmission)
-        report.prevention_tips = [""] * len(prevention)
-        
-        # Process each translated text
-        for idx, (field, sub_idx) in enumerate(text_mapping):
-            value = translated[idx] if idx < len(translated) else ""
-            
-            if field == "disease_name":
-                report.disease_name = value
-            elif field == "severity_level":
-                report.severity_level = value
-            elif field == "severity_description":
-                report.severity_description = value
-            elif field == "summary_message":
-                report.summary_message = value
-            elif field == "yield_loss_message":
-                report.yield_loss_message = value
-            elif field == "cost_message":
-                report.cost_message = value
-            elif field == "symptom":
-                report.symptoms[sub_idx] = value
-            elif field == "transmission":
-                report.transmission[sub_idx] = value
-            elif field == "prevention":
-                report.prevention_tips[sub_idx] = value
-            elif field == "projection":
-                # sub_idx is the stage name
-                if sub_idx not in report.health_projection:
-                    report.health_projection[sub_idx] = {}
-                report.health_projection[sub_idx]["message"] = value
-                # Find recovery chance from projection_texts
-                for stage, chance in projection_texts:
-                    if stage == sub_idx:
-                        report.health_projection[sub_idx]["recovery_chance_percent"] = chance
-        
-        # Apply treatment translations
-        self._apply_treatment_translations(
-            report, 
-            treatments, 
-            translated[treatment_start_idx:], 
-            text_mapping[treatment_start_idx:]
-        )
-        
-        # Set current projection
-        self._set_current_projection(report, detection_result)
-        
-        logger.info("✅ Disease report built with batch translation")
     
-    def _build_disease_report_english(
-        self,
-        report: DiagnosisReport,
-        detection_result
-    ) -> None:
-        """Build English report without translation."""
-        report.disease_name = detection_result.display_name
-        report.severity_level = detection_result.severity_level.replace("_", " ").title()
-        report.severity_description = detection_result.severity_description
-        report.summary_message = self._create_summary_message(detection_result)
-        report.yield_loss_message = f"This disease can cause {detection_result.yield_loss_min}% to {detection_result.yield_loss_max}% yield loss if not treated."
-        report.cost_message = f"Estimated treatment cost: ₦{detection_result.treatment_cost_min:,} to ₦{detection_result.treatment_cost_max:,} per hectare."
-        
-        report.symptoms = detection_result.symptoms[:6] if detection_result.symptoms else []
-        report.transmission = detection_result.transmission[:5] if detection_result.transmission else []
-        report.prevention_tips = detection_result.prevention[:6] if detection_result.prevention else []
-        
-        # Build treatments without translation
-        self._build_treatment_sections_english(report, detection_result)
-        
-        # Health projection
-        projection = detection_result.health_projection
-        if projection:
-            for stage, info in projection.items():
-                if isinstance(info, dict):
-                    report.health_projection[stage] = {
-                        "recovery_chance_percent": info.get("recovery_chance_percent", 0),
-                        "message": info.get("message", "")
-                    }
-        
-        self._set_current_projection(report, detection_result)
-    
-    def _collect_treatment_texts(self, treatments: Dict) -> List[Tuple[str, Tuple]]:
-        """Collect all treatment texts that need translation."""
-        texts = []
-        
-        # Cultural/immediate actions
-        cultural = treatments.get("cultural", [])
-        for i, t in enumerate(cultural[:4]):
-            if t.get("method"):
-                texts.append((t.get("method", ""), ("cultural_method", i)))
-            if t.get("description"):
-                texts.append((t.get("description", ""), ("cultural_desc", i)))
-        
-        # Chemical treatments
-        chemical = treatments.get("chemical", [])
-        for i, t in enumerate(chemical[:3]):
-            if t.get("application_method"):
-                texts.append((t.get("application_method", ""), ("chemical_app", i)))
-            # Safety precautions
-            for j, precaution in enumerate(t.get("safety_precautions", [])[:3]):
-                texts.append((precaution, ("chemical_safety", i, j)))
-        
-        # Biological treatments
-        biological = treatments.get("biological", [])
-        for i, t in enumerate(biological[:2]):
-            if t.get("method"):
-                texts.append((t.get("method", ""), ("bio_method", i)))
-            if t.get("description"):
-                texts.append((t.get("description", ""), ("bio_desc", i)))
-        
-        # Traditional treatments
-        traditional = treatments.get("traditional", [])
-        for i, t in enumerate(traditional[:3]):
-            if t.get("method"):
-                texts.append((t.get("method", ""), ("trad_method", i)))
-            if t.get("description"):
-                texts.append((t.get("description", ""), ("trad_desc", i)))
-        
-        # Resistant varieties notes
-        varieties = treatments.get("resistant_varieties", [])
-        for i, v in enumerate(varieties[:3]):
-            if v.get("notes"):
-                texts.append((v.get("notes", ""), ("variety_notes", i)))
-        
-        return texts
-    
-    def _apply_treatment_translations(
-        self,
-        report: DiagnosisReport,
-        treatments: Dict,
-        translated: List[str],
-        mapping: List[Tuple]
-    ) -> None:
-        """Apply translated treatment texts to report."""
-        
-        # Build translation lookup
-        trans_lookup = {}
-        for idx, map_info in enumerate(mapping):
-            if idx < len(translated):
-                trans_lookup[map_info] = translated[idx]
-        
-        # Cultural/immediate actions
-        cultural = treatments.get("cultural", [])
-        for i, t in enumerate(cultural[:4]):
-            action = {
-                "action": trans_lookup.get(("cultural_method", i), t.get("method", "")),
-                "description": trans_lookup.get(("cultural_desc", i), t.get("description", "")),
-                "effectiveness": t.get("effectiveness", ""),
-                "timing": t.get("timing", "")
-            }
-            report.immediate_actions.append(action)
-        
-        # Chemical treatments
-        chemical = treatments.get("chemical", [])
-        for i, t in enumerate(chemical[:3]):
-            safety = []
-            for j in range(3):
-                key = ("chemical_safety", i, j)
-                if key in trans_lookup:
-                    safety.append(trans_lookup[key])
-                elif j < len(t.get("safety_precautions", [])):
-                    safety.append(t.get("safety_precautions", [])[j])
-            
-            treatment = {
-                "product_name": t.get("product_name", ""),
-                "local_brands": t.get("local_brands", []),
-                "dosage": t.get("dosage", ""),
-                "frequency": t.get("frequency", ""),
-                "application_method": trans_lookup.get(("chemical_app", i), t.get("application_method", "")),
-                "cost_min": t.get("cost_ngn_min", 0),
-                "cost_max": t.get("cost_ngn_max", 0),
-                "effectiveness": t.get("effectiveness", ""),
-                "safety_precautions": safety
-            }
-            report.chemical_treatments.append(treatment)
-        
-        # Biological treatments
-        biological = treatments.get("biological", [])
-        for i, t in enumerate(biological[:2]):
-            treatment = {
-                "method": trans_lookup.get(("bio_method", i), t.get("method", "")),
-                "description": trans_lookup.get(("bio_desc", i), t.get("description", "")),
-                "effectiveness": t.get("effectiveness", ""),
-                "source": t.get("source", "")
-            }
-            report.organic_treatments.append(treatment)
+    def _create_summary_message(self, detection_result) -> str:
+        """Create English summary message for disease detection."""
+        severity = detection_result.severity_level.replace("_", " ")
+        confidence_pct = int(detection_result.confidence * 100)
         
-        # Traditional treatments
-        traditional = treatments.get("traditional", [])
-        for i, t in enumerate(traditional[:3]):
-            treatment = {
-                "method": trans_lookup.get(("trad_method", i), t.get("method", "")),
-                "description": trans_lookup.get(("trad_desc", i), t.get("description", "")),
-                "cost": t.get("cost_ngn", 0),
-                "effectiveness": t.get("effectiveness", "")
-            }
-            report.traditional_treatments.append(treatment)
+        if detection_result.confidence >= 0.85:
+            confidence_text = "high confidence"
+        elif detection_result.confidence >= 0.60:
+            confidence_text = "moderate confidence"
+        else:
+            confidence_text = "low confidence"
         
-        # Resistant varieties
-        varieties = treatments.get("resistant_varieties", [])
-        for i, v in enumerate(varieties[:3]):
-            variety = {
-                "name": v.get("variety_name", ""),
-                "resistance_level": v.get("resistance_level", ""),
-                "source": v.get("source", ""),
-                "cost": v.get("cost_ngn_per_bundle", 0),
-                "notes": trans_lookup.get(("variety_notes", i), v.get("notes", ""))
-            }
-            report.resistant_varieties.append(variety)
+        return (
+            f"We detected {detection_result.display_name} in your {detection_result.crop_type} "
+            f"with {confidence_text} ({confidence_pct}%). "
+            f"This is a {severity} severity disease. "
+            f"Please follow the treatment recommendations below to protect your crop."
+        )
     
-    def _build_treatment_sections_english(
+    def _build_treatment_sections(
         self,
         report: DiagnosisReport,
-        detection_result
+        detection_result,
+        language: str
     ) -> None:
-        """Build treatment sections without translation (English)."""
+        """Build all treatment sections of the report."""
         treatments = detection_result.treatments
         
-        # Immediate actions
+        # Immediate actions (cultural practices)
         cultural = treatments.get("cultural", [])
         for t in cultural[:4]:
             action = {
-                "action": t.get("method", ""),
-                "description": t.get("description", ""),
+                "action": self._translate(t.get("method", ""), language),
+                "description": self._translate(t.get("description", ""), language),
                 "effectiveness": t.get("effectiveness", ""),
                 "timing": t.get("timing", "")
             }
@@ -774,20 +502,26 @@ class DiagnosisGenerator:
                 "local_brands": t.get("local_brands", []),
                 "dosage": t.get("dosage", ""),
                 "frequency": t.get("frequency", ""),
-                "application_method": t.get("application_method", ""),
+                "application_method": self._translate(
+                    t.get("application_method", ""),
+                    language
+                ),
                 "cost_min": t.get("cost_ngn_min", 0),
                 "cost_max": t.get("cost_ngn_max", 0),
                 "effectiveness": t.get("effectiveness", ""),
-                "safety_precautions": t.get("safety_precautions", [])[:3]
+                "safety_precautions": self._translate_list(
+                    t.get("safety_precautions", [])[:3],
+                    language
+                )
             }
             report.chemical_treatments.append(treatment)
         
-        # Biological treatments
+        # Biological/organic treatments
         biological = treatments.get("biological", [])
         for t in biological[:2]:
             treatment = {
-                "method": t.get("method", ""),
-                "description": t.get("description", ""),
+                "method": self._translate(t.get("method", ""), language),
+                "description": self._translate(t.get("description", ""), language),
                 "effectiveness": t.get("effectiveness", ""),
                 "source": t.get("source", "")
             }
@@ -797,8 +531,8 @@ class DiagnosisGenerator:
         traditional = treatments.get("traditional", [])
         for t in traditional[:3]:
             treatment = {
-                "method": t.get("method", ""),
-                "description": t.get("description", ""),
+                "method": self._translate(t.get("method", ""), language),
+                "description": self._translate(t.get("description", ""), language),
                 "cost": t.get("cost_ngn", 0),
                 "effectiveness": t.get("effectiveness", "")
             }
@@ -812,51 +546,51 @@ class DiagnosisGenerator:
                 "resistance_level": v.get("resistance_level", ""),
                 "source": v.get("source", ""),
                 "cost": v.get("cost_ngn_per_bundle", 0),
-                "notes": v.get("notes", "")
+                "notes": self._translate(v.get("notes", ""), language)
             }
             report.resistant_varieties.append(variety)
     
-    def _set_current_projection(
+    def _build_health_projection(
         self,
         report: DiagnosisReport,
-        detection_result
+        detection_result,
+        language: str
     ) -> None:
-        """Set current projection based on confidence."""
+        """Build health projection section."""
+        projection = detection_result.health_projection
+        
+        if not projection:
+            return
+        
+        # Translate all projection stages
+        for stage, info in projection.items():
+            if isinstance(info, dict):
+                report.health_projection[stage] = {
+                    "recovery_chance_percent": info.get("recovery_chance_percent", 0),
+                    "message": self._translate(info.get("message", ""), language)
+                }
+        
+        # Set current projection based on confidence
+        # Higher confidence often correlates with more visible/advanced symptoms
         if detection_result.confidence >= 0.85:
+            # Clear symptoms suggest moderate to severe infection
             stage = "moderate_infection"
         elif detection_result.confidence >= 0.60:
+            # Some symptoms visible - likely early detection
             stage = "early_detection"
         else:
+            # Low confidence - could be very early
             stage = "early_detection"
         
         if stage in report.health_projection:
             report.current_projection = report.health_projection[stage]
     
-    def _create_summary_message(self, detection_result) -> str:
-        """Create English summary message for disease detection."""
-        severity = detection_result.severity_level.replace("_", " ")
-        confidence_pct = int(detection_result.confidence * 100)
-        
-        if detection_result.confidence >= 0.85:
-            confidence_text = "high confidence"
-        elif detection_result.confidence >= 0.60:
-            confidence_text = "moderate confidence"
-        else:
-            confidence_text = "low confidence"
-        
-        return (
-            f"We detected {detection_result.display_name} in your {detection_result.crop_type} "
-            f"with {confidence_text} ({confidence_pct}%). "
-            f"This is a {severity} severity disease. "
-            f"Please follow the treatment recommendations below to protect your crop."
-        )
-    
     # =========================================================================
     # TRANSLATION HELPERS
     # =========================================================================
     
     def _translate(self, text: str, language: str) -> str:
-        """Translate text to target language (single text fallback)."""
+        """Translate text to target language."""
         if not text or language == "en":
             return text
         
@@ -866,13 +600,8 @@ class DiagnosisGenerator:
             logger.warning(f"Translation failed: {e}")
             return text
     
-    def _translate_batch(self, texts: List[str], language: str) -> List[str]:
-        """
-        Translate multiple texts in a single batch call.
-        
-        This is the OPTIMIZED method - uses one model inference
-        instead of N separate calls.
-        """
+    def _translate_list(self, texts: List[str], language: str) -> List[str]:
+        """Translate a list of texts."""
         if not texts or language == "en":
             return texts
         
@@ -882,10 +611,6 @@ class DiagnosisGenerator:
             logger.warning(f"Batch translation failed: {e}")
             return texts
     
-    def _translate_list(self, texts: List[str], language: str) -> List[str]:
-        """Translate a list of texts (alias for _translate_batch)."""
-        return self._translate_batch(texts, language)
-    
     # =========================================================================
     # UTILITY METHODS
     # =========================================================================
@@ -996,7 +721,7 @@ def generate_diagnosis_with_image(
 
 if __name__ == "__main__":
     print("=" * 60)
-    print("Diagnosis Generator Service Test (OPTIMIZED)")
+    print("Diagnosis Generator Service Test")
     print("=" * 60)
     
     # Initialize generator
@@ -1036,13 +761,7 @@ if __name__ == "__main__":
     print(f"   Report ID: {test_report.report_id}")
     print(f"   Short Summary: {test_report.get_short_summary()}")
     
-    print("\n6. OPTIMIZATION INFO:")
-    print("   - Uses batch translation (1 call instead of 20+)")
-    print("   - Expected speedup: ~5x faster")
-    print("   - Old time: ~5 minutes")
-    print("   - New time: ~30-60 seconds")
-    
-    print("\n7. To generate actual diagnosis (requires models):")
+    print("\n6. To generate actual diagnosis (requires models):")
     print("   >>> report = generator.generate('/path/to/image.jpg', 'ha')")
     print("   >>> print(report.summary_message)")
     print("   >>> print(report.to_json())")