Update app.py

app.py

@@ -12,17 +12,12 @@ from huggingface_hub import InferenceClient
 
 # ============================================================
 # ENV
-# HF_TOKEN НЕ обязателен.
-# Если он есть — используем.
-# Если нет — пытаемся работать без него.
+# HF_TOKEN необязателен
 # ============================================================
 HF_TOKEN = os.getenv("HF_TOKEN", "").strip()
 
 # ============================================================
-# FREE / OPEN MODELS ON HUGGING FACE
-# Можно менять список под эксперимент.
-# Важно: доступность конкретной модели в serverless inference
-# на Hugging Face может меняться.
+# OPEN / FREE MODELS
 # ============================================================
 HF_MODELS = {
     "Qwen2.5-72B-Instruct": "Qwen/Qwen2.5-72B-Instruct",
@@ -45,6 +40,7 @@ class RequirementResult:
     status: str
     latency_sec: float
     issues: List[str]
+    issues_count: int
     refactored_requirement: str
     scores: Dict[str, Any]
     overall_score: Optional[float]
@@ -57,17 +53,28 @@ class RequirementResult:
 # PROMPTS
 # ============================================================
 SYSTEM_PROMPT = """
-You are an expert requirements engineer and business/system analyst.
-
-Your task:
-1. Analyze a software requirement.
-2. Detect quality issues.
-3. Refactor the requirement to improve clarity and testability.
-4. Score the requirement quality.
-
-Return ONLY valid JSON with this exact schema:
+Ты — эксперт по системному анализу и инженерии требований.
+
+Твоя задача:
+1. Проанализировать программное требование.
+2. Выявить ошибки, недостатки и проблемы качества требования.
+3. Выполнить рефакторинг требования, сделав его более понятным, однозначным и тестируемым.
+4. Оценить качество требования по заданным критериям.
+
+ВАЖНО:
+- Отвечай ТОЛЬКО на русском языке.
+- Все поля JSON должны быть заполнены на русском языке.
+- Поле refactored_requirement должно содержать улучшенную формулировку требования на русском языке.
+- Поле issues должно содержать список найденных проблем на русском языке.
+- Поле explanation должно содержать краткое объяснение на русском языке.
+- Не добавляй никаких комментариев вне JSON.
+- Не используй markdown.
+- Верни только валидный JSON.
+
+Верни JSON строго в таком формате:
 {
   "issues": ["..."],
+  "issues_count": 0,
   "refactored_requirement": "...",
   "scores": {
     "clarity": 0,
@@ -80,22 +87,21 @@ Return ONLY valid JSON with this exact schema:
   "explanation": "..."
 }
 
-Rules:
-- Each criterion must be an integer from 1 to 10.
-- overall_score must be a number from 1 to 10.
-- Keep issues concise.
-- refactored_requirement must be a single improved requirement in the same language as input.
-- explanation should briefly justify the result.
-- Output ONLY JSON. No markdown fences. No extra commentary.
+Правила:
+- issues_count должно быть равно количеству элементов в массиве issues.
+- Каждая оценка в scores — целое число от 1 до 10.
+- overall_score — число от 1 до 10.
+- issues должны быть краткими и содержательными.
+- refactored_requirement должен содержать одну улучшенную формулировку требования.
 """.strip()
 
 
 def build_user_prompt(requirement: str, project_context: str = "") -> str:
-    ctx = f"\nProject context:\n{project_context}\n" if project_context.strip() else ""
+    ctx = f"\nКонтекст проекта:\n{project_context}\n" if project_context.strip() else ""
     return f"""
-Analyze and refactor the following requirement.{ctx}
+Проанализируй и отрефактори следующее требование.{ctx}
 
-Requirement:
+Требование:
 {requirement}
 """.strip()
 
@@ -122,7 +128,7 @@ def safe_json_extract(text: str) -> Dict[str, Any]:
         except Exception:
             pass
 
-    raise ValueError("Model did not return valid JSON")
+    raise ValueError("Модель не вернула корректный JSON")
 
 
 def to_int_score(value: Any) -> Optional[int]:
@@ -138,6 +144,14 @@ def normalize_result_json(data: Dict[str, Any]) -> Dict[str, Any]:
     if not isinstance(issues, list):
         issues = [str(issues)]
 
+    issues = [str(x).strip() for x in issues if str(x).strip()]
+    issues_count = data.get("issues_count")
+
+    try:
+        issues_count = int(issues_count)
+    except Exception:
+        issues_count = len(issues)
+
     scores = data.get("scores", {})
     if not isinstance(scores, dict):
         scores = {}
@@ -149,7 +163,8 @@ def normalize_result_json(data: Dict[str, Any]) -> Dict[str, Any]:
         overall_score = None
 
     return {
-        "issues": [str(x).strip() for x in issues if str(x).strip()],
+        "issues": issues,
+        "issues_count": len(issues),
         "refactored_requirement": str(data.get("refactored_requirement", "")).strip(),
         "scores": {
             "clarity": to_int_score(scores.get("clarity")),
@@ -212,7 +227,7 @@ def load_requirements_from_file(file_obj) -> List[str]:
                 if key in data and isinstance(data[key], list):
                     return [str(x).strip() for x in data[key] if str(x).strip()]
 
-        raise ValueError("JSON file must contain an array or object with 'requirements' array")
+        raise ValueError("JSON-файл должен содержать массив или объект с массивом 'requirements'")
 
     if ext == ".csv":
         df = pd.read_csv(path)
@@ -224,7 +239,7 @@ def load_requirements_from_file(file_obj) -> List[str]:
         first_col = df.columns[0]
         return [str(x).strip() for x in df[first_col].dropna().tolist() if str(x).strip()]
 
-    raise ValueError("Supported formats: .txt, .csv, .json")
+    raise ValueError("Поддерживаются только форматы .txt, .csv, .json")
 
 
 # ============================================================
@@ -275,7 +290,7 @@ def run_single_model(
 
     try:
         if model_label not in HF_MODELS:
-            raise RuntimeError(f"Unknown model: {model_label}")
+            raise RuntimeError(f"Неизвестная модель: {model_label}")
 
         raw_text, parsed = call_hf_model(
             HF_MODELS[model_label],
@@ -295,6 +310,7 @@ def run_single_model(
             status="ok",
             latency_sec=latency,
             issues=parsed["issues"],
+            issues_count=parsed["issues_count"],
             refactored_requirement=parsed["refactored_requirement"],
             scores=parsed["scores"],
             overall_score=parsed["overall_score"],
@@ -313,6 +329,7 @@ def run_single_model(
             status=f"error: {str(e)}",
             latency_sec=latency,
             issues=[],
+            issues_count=0,
             refactored_requirement="",
             scores={},
             overall_score=None,
@@ -395,22 +412,22 @@ def build_summary_dataframe(results: List[RequirementResult]) -> pd.DataFrame:
     rows = []
     for r in results:
         rows.append({
-            "requirement_id": r.requirement_id,
-            "model": r.model_name,
-            "provider": r.provider,
-            "status": r.status,
-            "latency_sec": r.latency_sec,
-            "overall_score": r.overall_score,
-            "clarity": r.scores.get("clarity"),
-            "unambiguity": r.scores.get("unambiguity"),
-            "completeness": r.scores.get("completeness"),
-            "consistency": r.scores.get("consistency"),
-            "testability": r.scores.get("testability"),
-            "issues_count": len(r.issues),
-            "source_requirement": r.source_requirement,
-            "refactored_requirement": r.refactored_requirement,
-            "issues": "; ".join(r.issues),
-            "explanation": r.explanation,
+            "ID требования": r.requirement_id,
+            "Модель": r.model_name,
+            "Провайдер": r.provider,
+            "Статус": r.status,
+            "Время ответа (сек)": r.latency_sec,
+            "Общая оценка": r.overall_score,
+            "Ясность": r.scores.get("clarity"),
+            "Однозначность": r.scores.get("unambiguity"),
+            "Полнота": r.scores.get("completeness"),
+            "Согласованность": r.scores.get("consistency"),
+            "Тестируемость": r.scores.get("testability"),
+            "Количество ошибок": r.issues_count,
+            "Исходное требование": r.source_requirement,
+            "Отрефакторенное требование": r.refactored_requirement,
+            "Найденные ошибки": "; ".join(r.issues),
+            "Пояснение": r.explanation,
         })
     return pd.DataFrame(rows)
 
@@ -420,8 +437,14 @@ def build_best_results_dataframe(results: List[RequirementResult]) -> pd.DataFra
 
     if not valid:
         return pd.DataFrame(columns=[
-            "requirement_id", "best_model", "overall_score",
-            "source_requirement", "refactored_requirement", "issues", "explanation"
+            "ID требования",
+            "Лучшая модель",
+            "Общая оценка",
+            "Количество ошибок",
+            "Исходное требование",
+            "��трефакторенное требование",
+            "Найденные ошибки",
+            "Пояснение"
         ])
 
     best_by_req = {}
@@ -434,47 +457,57 @@ def build_best_results_dataframe(results: List[RequirementResult]) -> pd.DataFra
     for req_id in sorted(best_by_req.keys()):
         r = best_by_req[req_id]
         rows.append({
-            "requirement_id": r.requirement_id,
-            "best_model": r.model_name,
-            "overall_score": r.overall_score,
-            "source_requirement": r.source_requirement,
-            "refactored_requirement": r.refactored_requirement,
-            "issues": "; ".join(r.issues),
-            "explanation": r.explanation,
+            "ID требования": r.requirement_id,
+            "Лучшая модель": r.model_name,
+            "Общая оценка": r.overall_score,
+            "Количество ошибок": r.issues_count,
+            "Исходное требование": r.source_requirement,
+            "Отрефакторенное требование": r.refactored_requirement,
+            "Найденные ошибки": "; ".join(r.issues),
+            "Пояснение": r.explanation,
         })
 
     return pd.DataFrame(rows)
 
 
 def build_stats_markdown(requirements: List[str], selected_models: List[str], results: List[RequirementResult]) -> str:
-    total = len(results)
-    ok = sum(1 for r in results if r.status == "ok")
-    failed = total - ok
+    total_runs = len(results)
+    ok_runs = sum(1 for r in results if r.status == "ok")
+    failed_runs = total_runs - ok_runs
 
-    avg_latency = round(sum(r.latency_sec for r in results) / total, 3) if total else 0
+    avg_latency = round(sum(r.latency_sec for r in results) / total_runs, 3) if total_runs else 0
 
     valid_scores = [r.overall_score for r in results if r.overall_score is not None]
     avg_score = round(sum(valid_scores) / len(valid_scores), 2) if valid_scores else None
 
+    total_issues = sum(r.issues_count for r in results if r.status == "ok")
+    avg_issues = round(total_issues / ok_runs, 2) if ok_runs else 0
+
     by_model = {}
     for r in results:
-        by_model.setdefault(r.model_name, {"count": 0, "ok": 0, "scores": [], "latency": []})
+        by_model.setdefault(
+            r.model_name,
+            {"count": 0, "ok": 0, "scores": [], "latency": [], "issues": []}
+        )
         by_model[r.model_name]["count"] += 1
         if r.status == "ok":
             by_model[r.model_name]["ok"] += 1
+            by_model[r.model_name]["issues"].append(r.issues_count)
         if r.overall_score is not None:
             by_model[r.model_name]["scores"].append(r.overall_score)
         by_model[r.model_name]["latency"].append(r.latency_sec)
 
     lines = [
         "## Результаты запуска",
-        f"- Требований: **{len(requirements)}**",
-        f"- Моделей: **{len(selected_models)}**",
-        f"- Всего прогонов: **{total}**",
-        f"- Успешных: **{ok}**",
-        f"- Ошибок: **{failed}**",
-        f"- Средняя задержка: **{avg_latency} сек**",
-        f"- Средний overall score: **{avg_score if avg_score is not None else 'n/a'}**",
+        f"- Количество требований: **{len(requirements)}**",
+        f"- Количество моделей: **{len(selected_models)}**",
+        f"- Всего прогонов: **{total_runs}**",
+        f"- Успешных прогонов: **{ok_runs}**",
+        f"- Ошибок выполнения: **{failed_runs}**",
+        f"- Среднее время ответа: **{avg_latency} сек**",
+        f"- Средняя общая оценка: **{avg_score if avg_score is not None else 'n/a'}**",
+        f"- Общее количество найденных ошибок в требованиях: **{total_issues}**",
+        f"- Среднее количество найденных ошибок на один успешный прогон: **{avg_issues}**",
         "",
         "### Средние показатели по моделям",
     ]
@@ -482,10 +515,14 @@ def build_stats_markdown(requirements: List[str], selected_models: List[str], re
     for model_name, item in by_model.items():
         avg_model_score = round(sum(item["scores"]) / len(item["scores"]), 2) if item["scores"] else None
         avg_model_latency = round(sum(item["latency"]) / len(item["latency"]), 2) if item["latency"] else None
+        avg_model_issues = round(sum(item["issues"]) / len(item["issues"]), 2) if item["issues"] else 0
+
         lines.append(
-            f"- **{model_name}**: success={item['ok']}/{item['count']}, "
-            f"avg_score={avg_model_score if avg_model_score is not None else 'n/a'}, "
-            f"avg_latency={avg_model_latency if avg_model_latency is not None else 'n/a'} sec"
+            f"- **{model_name}**: "
+            f"успешно {item['ok']}/{item['count']}, "
+            f"средняя оцен��а = {avg_model_score if avg_model_score is not None else 'n/a'}, "
+            f"среднее время = {avg_model_latency if avg_model_latency is not None else 'n/a'} сек, "
+            f"среднее количество ошибок = {avg_model_issues}"
         )
 
     return "\n".join(lines)
@@ -537,7 +574,7 @@ def preview_loaded_requirements(raw_requirements: str, uploaded_file):
 # ============================================================
 # UI
 # ============================================================
-with gr.Blocks(title="LLM Requirement Refactoring Benchmark") as demo:
+with gr.Blocks(title="Сравнение LLM для рефакторинга требований") as demo:
     gr.Markdown(
         """
 # Сравнение бесплатных LLM для рефакторинга требований
@@ -545,9 +582,10 @@ with gr.Blocks(title="LLM Requirement Refactoring Benchmark") as demo:
 Приложение позволяет:
 - загрузить набор требований;
 - прогнать их через несколько open/free моделей;
-- получить анализ проблем;
-- получить рефакторинг требования;
-- сравнить результаты в таблице.
+- получить анализ ошибок и проблем;
+- получить улучшенную формулировку требования;
+- сравнить результаты в таблице;
+- увидеть количество найденных ошибок.
 """
     )
 
@@ -586,12 +624,12 @@ with gr.Blocks(title="LLM Requirement Refactoring Benchmark") as demo:
 
             temperature = gr.Slider(
                 minimum=0.0, maximum=1.0, value=0.2, step=0.1,
-                label="Temperature"
+                label="Температура"
             )
 
             max_tokens = gr.Slider(
                 minimum=256, maximum=2048, value=1024, step=128,
-                label="Max output tokens"
+                label="Максимум токенов в ответе"
             )
 
             max_parallel_calls = gr.Slider(
@@ -619,8 +657,8 @@ with gr.Blocks(title="LLM Requirement Refactoring Benchmark") as demo:
     raw_json = gr.Code(label="Полные ответы моделей (JSON)", language="json")
 
     with gr.Row():
-        csv_file = gr.File(label="Скачать summary CSV")
-        json_file = gr.File(label="Скачать full JSON")
+        csv_file = gr.File(label="Скачать CSV-результаты")
+        json_file = gr.File(label="Скачать полный JSON")
 
     run_btn.click(
         fn=compare_models,