UPDATE

2026-04-27 18:02:26 +03:30
parent 7c2ec2144d
commit 190a668355
19 changed files with 193 additions and 825 deletions
@@ -38,244 +38,24 @@ def _get_optimizer():
    return apps.get_app_config("crop_simulation").get_recommendation_optimizer()


-def _unique_items(items: list[str]) -> list[str]:
-    seen = set()
-    output = []
-    for item in items:
-        normalized = (item or "").strip()
-        if not normalized or normalized in seen:
-            continue
-        seen.add(normalized)
-        output.append(normalized)
-    return output
-
-
-def _find_section(sections: list[dict], section_type: str) -> dict | None:
-    for section in sections:
-        if isinstance(section, dict) and section.get("type") == section_type:
-            return section
-    return None
-
-
-def _field_sources(llm_section: dict, fallback_section: dict, merged_section: dict) -> dict[str, str]:
-    sources: dict[str, str] = {}
-    for key, value in merged_section.items():
-        if key == "provenance":
-            continue
-        llm_value = llm_section.get(key)
-        fallback_value = fallback_section.get(key)
-        if key in llm_section and value == llm_value and value != fallback_value:
-            sources[key] = "llm"
-        elif key in fallback_section and value == fallback_value and value != llm_value:
-            sources[key] = "fallback"
-        elif key in llm_section and key in fallback_section and llm_value == fallback_value == value:
-            sources[key] = "shared"
-        elif key in llm_section and key in fallback_section:
-            sources[key] = "merged"
-        else:
-            sources[key] = "fallback" if key in fallback_section else "llm"
-    return sources
-
-
-def _attach_provenance(section_type: str, llm_section: dict, fallback_section: dict, merged_section: dict) -> dict:
-    merged = dict(merged_section)
-    field_sources = _field_sources(llm_section, fallback_section, merged)
-    merged["provenance"] = {
-        "sectionType": section_type,
-        "llmProvided": bool(llm_section),
-        "fallbackUsed": any(source != "llm" for source in field_sources.values()),
-        "fieldSources": field_sources,
-    }
-    return merged
-
-
-def _fallback_with_provenance(fallback: dict, reason: str) -> dict:
-    sections = []
-    for section in fallback.get("sections", []):
-        section_with_provenance = dict(section)
-        section_with_provenance["provenance"] = {
-            "sectionType": section.get("type"),
-            "llmProvided": False,
-            "fallbackUsed": True,
-            "fieldSources": {
-                key: "fallback"
-                for key in section.keys()
-                if key != "provenance"
-            },
-        }
-        sections.append(section_with_provenance)
-    return {
-        "sections": sections,
-        "mergeMetadata": {
-            "source": "fallback_only",
-            "reason": reason,
-        },
-    }
-
-
-def _build_irrigation_fallback(
-    *,
-    optimized_result: dict | None,
-    daily_water_needs: list[dict],
-) -> dict:
-    if optimized_result:
-        recommended = optimized_result["recommended_strategy"]
-        content = (
-            f"{recommended['events']} نوبت آبیاری با حدود "
-            f"{recommended['amount_per_event_mm']} میلی متر در هر نوبت اجرا شود."
-        )
-        list_items = [
-            f"در بازه اعتبار حدود {recommended['total_irrigation_mm']} میلی متر آب توزیع شود.",
-            f"نوبت های پیشنهادی: {', '.join(recommended['event_dates']) or 'بر اساس پایش روزانه مزرعه'}",
-            f"رطوبت خاک نزدیک {recommended['moisture_target_percent']} درصد نگه داشته شود.",
-        ]
-        warning = optimized_result.get("alternatives", [])
-        warning_text = (
-            f"اگر شرایط مزرعه تغییر کرد، سناریوی جایگزین {warning[0]['label']} هم قابل بررسی است."
-            if warning
-            else "در صورت تغییر ناگهانی بارش یا باد، برنامه را دوباره ارزیابی کنید."
-        )
-        explanation = " ".join(recommended.get("reasoning", []))
-        return {
-            "sections": [
-                {
-                    "type": "recommendation",
-                    "title": "برنامه آبیاری بهینه",
-                    "icon": "droplet",
-                    "content": content,
-                    "frequency": f"{recommended['events']} نوبت در بازه اعتبار",
-                    "amount": (
-                        f"{recommended['amount_per_event_mm']} میلی متر در هر نوبت "
-                        f"(جمع کل {recommended['total_irrigation_mm']} میلی متر)"
-                    ),
-                    "timing": recommended["timing"],
-                    "validityPeriod": recommended["validity_period"],
-                    "expandableExplanation": explanation,
-                },
-                {
-                    "type": "list",
-                    "title": "اقدامات اجرایی",
-                    "icon": "list",
-                    "items": _unique_items(list_items),
-                },
-                {
-                    "type": "warning",
-                    "title": "هشدار آبیاری",
-                    "icon": "alert-triangle",
-                    "content": warning_text,
-                },
-            ]
-        }
-
-    total_mm = round(sum(float(item.get("gross_irrigation_mm", 0.0) or 0.0) for item in daily_water_needs), 2)
-    return {
-        "sections": [
-            {
-                "type": "recommendation",
-                "title": "برنامه آبیاری پیشنهادی",
-                "icon": "droplet",
-                "content": "پایش رطوبت خاک ادامه پیدا کند و برنامه آبیاری بر اساس نیاز روزانه تنظیم شود.",
-                "frequency": "بر اساس پایش روزانه",
-                "amount": f"جمع نیاز تخمینی این بازه حدود {total_mm} میلی متر است.",
-                "timing": "اوایل صبح یا نزدیک غروب",
-                "validityPeriod": "معتبر برای 3 روز آینده",
-                "expandableExplanation": "به دلیل محدود بودن داده ها، توصیه با اتکا به نیاز آبی روزانه ساخته شده است.",
-            },
-            {
-                "type": "list",
-                "title": "اقدامات اجرایی",
-                "icon": "list",
-                "items": [
-                    "قبل از هر نوبت آبیاری رطوبت خاک سطحی را دوباره بررسی کنید.",
-                    "اگر بارش موثر رخ داد، نوبت بعدی را به تعویق بیندازید.",
-                ],
-            },
-            {
-                "type": "warning",
-                "title": "هشدار آبیاری",
-                "icon": "alert-triangle",
-                "content": "با تغییر دما یا بارش پیش بینی شده، برنامه فعلی باید بازبینی شود.",
-            },
-        ]
-    }
-
-
-def _merge_irrigation_response(
-    *,
-    parsed_result: dict,
-    optimized_result: dict | None,
-    daily_water_needs: list[dict],
-) -> dict:
-    fallback = _build_irrigation_fallback(
-        optimized_result=optimized_result,
-        daily_water_needs=daily_water_needs,
-    )
+def _validate_irrigation_response(parsed_result: dict) -> dict:
    if not isinstance(parsed_result, dict):
-        return _fallback_with_provenance(fallback, "invalid_llm_payload")
+        raise ValueError("Irrigation recommendation response is not a JSON object.")

    sections = parsed_result.get("sections")
-    if not isinstance(sections, list):
-        return _fallback_with_provenance(fallback, "missing_sections")
+    if not isinstance(sections, list) or not sections:
+        raise ValueError("Irrigation recommendation response is missing sections.")

-    recommendation = _find_section(sections, "recommendation") or {}
-    list_section = _find_section(sections, "list") or {}
-    warning_section = _find_section(sections, "warning") or {}
+    for index, section in enumerate(sections):
+        if not isinstance(section, dict):
+            raise ValueError(f"Irrigation recommendation section {index} is invalid.")
+        missing = [key for key in ("type", "title", "icon") if key not in section]
+        if missing:
+            raise ValueError(
+                f"Irrigation recommendation section {index} is missing fields: {', '.join(missing)}"
+            )

-    fallback_recommendation = fallback["sections"][0]
-    fallback_list = fallback["sections"][1]
-    fallback_warning = fallback["sections"][2]
-
-    merged_recommendation = {**recommendation, **fallback_recommendation}
-    merged_recommendation["expandableExplanation"] = (
-        recommendation.get("expandableExplanation")
-        or fallback_recommendation["expandableExplanation"]
-    )
-    merged_recommendation["content"] = recommendation.get("content") or fallback_recommendation["content"]
-    merged_recommendation["title"] = recommendation.get("title") or fallback_recommendation["title"]
-
-    merged_list = {
-        **fallback_list,
-        **list_section,
-        "items": _unique_items(
-            list(list_section.get("items", [])) + list(fallback_list["items"])
-        )[:5],
-    }
-    merged_warning = {
-        **fallback_warning,
-        **warning_section,
-        "content": warning_section.get("content") or fallback_warning["content"],
-    }
-
-    merged_recommendation = _attach_provenance(
-        "recommendation",
-        recommendation,
-        fallback_recommendation,
-        merged_recommendation,
-    )
-    merged_list = _attach_provenance(
-        "list",
-        list_section,
-        fallback_list,
-        merged_list,
-    )
-    merged_warning = _attach_provenance(
-        "warning",
-        warning_section,
-        fallback_warning,
-        merged_warning,
-    )
-
-    return {
-        "sections": [merged_recommendation, merged_list, merged_warning],
-        "mergeMetadata": {
-            "source": "llm_with_fallback_merge",
-            "llmSectionsDetected": [section.get("type") for section in sections if isinstance(section, dict)],
-            "fallbackSectionsApplied": [
-                item["type"]
-                for item in (fallback_recommendation, fallback_list, fallback_warning)
-            ],
-        },
-    }
+    return parsed_result


 def _resolve_irrigation_method(
@@ -466,18 +246,10 @@ def get_irrigation_recommendation(
        raw = response.choices[0].message.content.strip()
    except Exception as exc:
        logger.error("Irrigation recommendation error for %s: %s", resolved_farm_uuid, exc)
-        result = _build_irrigation_fallback(
-            optimized_result=optimized_result,
-            daily_water_needs=daily_water_needs,
-        )
-        result["error"] = f"خطا در دریافت توصیه: {exc}"
-        result["raw_response"] = None
-        _fail_audit_log(
-            audit_log,
-            str(exc),
-            response_text=json.dumps(result, ensure_ascii=False, default=str),
-        )
-        return result
+        _fail_audit_log(audit_log, str(exc))
+        raise RuntimeError(
+            f"Irrigation recommendation failed for farm {resolved_farm_uuid}."
+        ) from exc

    try:
        cleaned = raw
@@ -487,11 +259,7 @@ def get_irrigation_recommendation(
    except (json.JSONDecodeError, ValueError):
        result = {}

-    result = _merge_irrigation_response(
-        parsed_result=result,
-        optimized_result=optimized_result,
-        daily_water_needs=daily_water_needs,
-    )
+    result = _validate_irrigation_response(result)
    result["raw_response"] = raw
    result["water_balance"] = {
        "daily": daily_water_needs,