local-triage 0.0.0-stage → 0.10.0-dev.32
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/LICENSE +21 -0
- package/README.md +90 -2
- package/THIRD-PARTY-NOTICES.md +48 -0
- package/app/__init__.py +3 -0
- package/app/affiliation.py +137 -0
- package/app/ask.py +300 -0
- package/app/build_info.py +98 -0
- package/app/capec.py +168 -0
- package/app/capec_view.py +27 -0
- package/app/codecmp.py +59 -0
- package/app/config.py +411 -0
- package/app/context.py +1451 -0
- package/app/cvss.py +357 -0
- package/app/db.py +6234 -0
- package/app/defect.py +670 -0
- package/app/defect_check.py +323 -0
- package/app/defect_drafts.py +612 -0
- package/app/defect_dto.py +149 -0
- package/app/defect_fields.py +248 -0
- package/app/defect_form.py +124 -0
- package/app/defect_links.py +107 -0
- package/app/defect_local_text.py +103 -0
- package/app/defect_references.py +164 -0
- package/app/defect_where.py +147 -0
- package/app/ecosystem.py +51 -0
- package/app/executors.py +660 -0
- package/app/feeds.py +1231 -0
- package/app/guard.py +164 -0
- package/app/hub_block_builder.py +200 -0
- package/app/hub_block_version.py +220 -0
- package/app/hub_defects.py +4469 -0
- package/app/hub_effects.py +421 -0
- package/app/hub_entity_versions.py +108 -0
- package/app/hub_import.py +2054 -0
- package/app/hub_onboarding.py +114 -0
- package/app/hub_ops.py +330 -0
- package/app/hub_pull.py +1195 -0
- package/app/hub_state.py +255 -0
- package/app/hub_status.py +237 -0
- package/app/hub_sync.py +619 -0
- package/app/hub_sync_api.py +241 -0
- package/app/hub_sync_compare.py +1054 -0
- package/app/hub_sync_contract.py +75 -0
- package/app/hub_template_model.py +74 -0
- package/app/hub_text_scale.py +159 -0
- package/app/journal.py +250 -0
- package/app/llm.py +850 -0
- package/app/llm_chat.py +596 -0
- package/app/llm_http.py +319 -0
- package/app/llm_messages.py +401 -0
- package/app/llm_net.py +764 -0
- package/app/llm_ollama.py +571 -0
- package/app/lockfile.py +505 -0
- package/app/logsafe.py +54 -0
- package/app/main.py +367 -0
- package/app/mask_display.py +132 -0
- package/app/masking.py +814 -0
- package/app/metrics.py +194 -0
- package/app/model_traffic.py +519 -0
- package/app/models.py +483 -0
- package/app/navigation.py +121 -0
- package/app/osv.py +279 -0
- package/app/package_identity.py +189 -0
- package/app/package_transition.py +824 -0
- package/app/profile_gate.py +71 -0
- package/app/prompts.py +1108 -0
- package/app/provider_keys.py +189 -0
- package/app/providers.py +511 -0
- package/app/routes/__init__.py +10 -0
- package/app/routes/api.py +153 -0
- package/app/routes/capec.py +186 -0
- package/app/routes/common.py +407 -0
- package/app/routes/components.py +1499 -0
- package/app/routes/cwe.py +168 -0
- package/app/routes/decision_selected.py +153 -0
- package/app/routes/defect_add.py +223 -0
- package/app/routes/defect_card_routes.py +363 -0
- package/app/routes/defect_selected.py +342 -0
- package/app/routes/feeds.py +155 -0
- package/app/routes/findings.py +2736 -0
- package/app/routes/hub.py +402 -0
- package/app/routes/hub_bulk.py +288 -0
- package/app/routes/hub_defect_routes.py +1945 -0
- package/app/routes/hub_status_routes.py +1132 -0
- package/app/routes/hub_sync_routes.py +463 -0
- package/app/routes/journal.py +132 -0
- package/app/routes/projects.py +1601 -0
- package/app/routes/providers.py +336 -0
- package/app/routes/references.py +26 -0
- package/app/routes/runs.py +219 -0
- package/app/routes/sca.py +2722 -0
- package/app/routes/settings.py +163 -0
- package/app/run_errors.py +151 -0
- package/app/sca.py +1662 -0
- package/app/sca_contract.py +1289 -0
- package/app/sca_research.py +1089 -0
- package/app/sca_research_net.py +1007 -0
- package/app/sca_text.py +965 -0
- package/app/serve.py +70 -0
- package/app/settings_store.py +262 -0
- package/app/static/app.css +2802 -0
- package/app/static/app.js +3772 -0
- package/app/static/capec-license.txt +9 -0
- package/app/static/favicon.svg +1 -0
- package/app/static/fonts/Golos-Text_DemiBold.woff2 +0 -0
- package/app/static/fonts/Golos-Text_Regular.woff2 +0 -0
- package/app/static/fonts/OFL.txt +90 -0
- package/app/static/navigation.js +234 -0
- package/app/static/observability.js +121 -0
- package/app/static/theme.js +49 -0
- package/app/storage/__init__.py +16 -0
- package/app/storage/local_state.py +246 -0
- package/app/storage/migrate.py +110 -0
- package/app/storage/migrations/postgresql/0001_baseline.sql +896 -0
- package/app/storage/migrations/postgresql/0002_feeds_and_secrets.sql +55 -0
- package/app/storage/migrations/postgresql/0003_project_mask_display.sql +5 -0
- package/app/storage/migrations/postgresql/0004_package_identity.sql +36 -0
- package/app/storage/postgresql.py +573 -0
- package/app/storage/schema.py +619 -0
- package/app/storage/sql.py +57 -0
- package/app/storage/tools.py +254 -0
- package/app/telemetry.py +307 -0
- package/app/templates/base.html +91 -0
- package/app/templates/capec/context.html +3 -0
- package/app/templates/capec/detail.html +27 -0
- package/app/templates/capec/index.html +128 -0
- package/app/templates/components/_archive.html +11 -0
- package/app/templates/components/archived.html +19 -0
- package/app/templates/components/batch.html +35 -0
- package/app/templates/components/detail.html +332 -0
- package/app/templates/components/index.html +338 -0
- package/app/templates/components/research_preview.html +80 -0
- package/app/templates/components/research_run.html +54 -0
- package/app/templates/cwe/bdu.html +56 -0
- package/app/templates/cwe/detail.html +233 -0
- package/app/templates/cwe/index.html +97 -0
- package/app/templates/error.html +8 -0
- package/app/templates/feeds/index.html +65 -0
- package/app/templates/findings/card.html +639 -0
- package/app/templates/findings/decision_selected.html +41 -0
- package/app/templates/findings/defect_add.html +46 -0
- package/app/templates/findings/defect_selected.html +47 -0
- package/app/templates/findings/list.html +153 -0
- package/app/templates/findings/send_selected.html +53 -0
- package/app/templates/findings/trace.html +72 -0
- package/app/templates/journal/detail.html +19 -0
- package/app/templates/journal/index.html +19 -0
- package/app/templates/macros.html +440 -0
- package/app/templates/navigation-fields.html +1 -0
- package/app/templates/navigation.html +11 -0
- package/app/templates/projects/_identity_summary.html +42 -0
- package/app/templates/projects/defect_card.html +153 -0
- package/app/templates/projects/defect_create_preview.html +17 -0
- package/app/templates/projects/defect_fields_diff.html +6 -0
- package/app/templates/projects/defect_fields_form.html +40 -0
- package/app/templates/projects/defect_references.html +17 -0
- package/app/templates/projects/defect_sync_preview.html +28 -0
- package/app/templates/projects/defect_update_actions.html +6 -0
- package/app/templates/projects/defect_update_preview.html +24 -0
- package/app/templates/projects/defects.html +126 -0
- package/app/templates/projects/delete.html +31 -0
- package/app/templates/projects/external.html +61 -0
- package/app/templates/projects/folders.html +64 -0
- package/app/templates/projects/hub_accepted.html +10 -0
- package/app/templates/projects/hub_assignment.html +50 -0
- package/app/templates/projects/hub_pending.html +20 -0
- package/app/templates/projects/hub_pending_list.html +17 -0
- package/app/templates/projects/hub_state_note.html +23 -0
- package/app/templates/projects/hub_step_note.html +5 -0
- package/app/templates/projects/hub_sync.html +105 -0
- package/app/templates/projects/hub_sync_confirm.html +32 -0
- package/app/templates/projects/hub_sync_worker.html +5 -0
- package/app/templates/projects/hub_text_rules.html +64 -0
- package/app/templates/projects/identity_report.html +74 -0
- package/app/templates/projects/list.html +90 -0
- package/app/templates/projects/project.html +433 -0
- package/app/templates/reference-missing.html +14 -0
- package/app/templates/runs/run.html +166 -0
- package/app/templates/sca/card.html +476 -0
- package/app/templates/sca/index.html +321 -0
- package/app/templates/settings/hub_url.html +31 -0
- package/app/templates/settings/index.html +216 -0
- package/app/templates/settings/provider.html +229 -0
- package/app/templates/settings/providers.html +37 -0
- package/app/templates/worklists.html +52 -0
- package/app/textsafe.py +117 -0
- package/app/timing.py +245 -0
- package/app/triage.py +1743 -0
- package/app/view.py +430 -0
- package/app/worklists.py +204 -0
- package/examples/demo/demo-hub-report-v2.xlsx +0 -0
- package/examples/demo/demo-hub-report.xlsx +0 -0
- package/examples/demo/repos/billing-core/pom.xml +30 -0
- package/examples/demo/repos/billing-core/src/main/java/org/example/billing/Invoice.java +9 -0
- package/examples/demo/repos/billing-core/src/main/java/org/example/billing/InvoiceRepository.java +51 -0
- package/examples/demo/repos/billing-core/src/main/java/org/example/billing/InvoiceStatus.java +11 -0
- package/examples/demo/repos/billing-core/src/main/java/org/example/billing/config/DatabaseSettings.java +18 -0
- package/examples/demo/repos/billing-core/src/main/java/org/example/billing/payment/PaymentTokenService.java +35 -0
- package/examples/demo/repos/billing-core/src/main/java/org/example/billing/web/InvoiceExportController.java +57 -0
- package/examples/demo/repos/catalog-api/catalog_api/__init__.py +1 -0
- package/examples/demo/repos/catalog-api/catalog_api/products.py +24 -0
- package/examples/demo/repos/catalog-api/catalog_api/tasks.py +24 -0
- package/examples/demo/repos/catalog-api/catalog_api/views.py +17 -0
- package/examples/demo/repos/catalog-api/requirements.txt +3 -0
- package/npm/build.json +5 -0
- package/npm/cli.js +346 -0
- package/npm/files.manifest +224 -0
- package/npm/lib/binding.js +64 -0
- package/npm/lib/cluster.js +330 -0
- package/npm/lib/env.js +88 -0
- package/npm/lib/fsx.js +125 -0
- package/npm/lib/http.js +53 -0
- package/npm/lib/metrics.js +73 -0
- package/npm/lib/paths.js +150 -0
- package/npm/lib/pg.js +351 -0
- package/npm/lib/proc.js +101 -0
- package/npm/lib/python.js +133 -0
- package/npm/lib/stand.js +46 -0
- package/npm/lib/supervisor.js +1141 -0
- package/npm/lib/version.js +21 -0
- package/npm/requirements.txt +476 -0
- package/npm-shrinkwrap.json +111 -0
- package/package.json +37 -4
package/app/triage.py
ADDED
|
@@ -0,0 +1,1743 @@
|
|
|
1
|
+
"""Очередь триажа SAST: фоновый поток разбирает находки по одной.
|
|
2
|
+
|
|
3
|
+
Для каждой находки: кодовая база → папка с клоном, срез кода (build_context, секреты и ПДн маскируются),
|
|
4
|
+
отпечаток случая (case_hash), готовый вердикт из кэша или вызов модели, сохранение. Между находками поток
|
|
5
|
+
выполняет принятые команды «пауза» и «стоп». Прогоны выполняются по одному: видеокарта одна.
|
|
6
|
+
|
|
7
|
+
Порядок разбора задаётся при загрузке выгрузки (order_findings): срочные, затем по критичности, дубли (один ключ
|
|
8
|
+
группы) рядом – дубль с тем же отпечатком берёт уже готовый вердикт.
|
|
9
|
+
|
|
10
|
+
Команды и переходы состояний идущего прогона выполняются под общей блокировкой, поэтому принятая команда
|
|
11
|
+
не теряется: стоп важнее паузы, а после стопа прогон не уходит на паузу даже при сбое Ollama. Принятая команда
|
|
12
|
+
хранится и в базе (runs.control): «Стоп», принятый перед перезапуском приложения, при запуске останавливает прогон.
|
|
13
|
+
|
|
14
|
+
Настройки работы (адрес Ollama) берутся из базы поверх переменных окружения в начале каждого прогона
|
|
15
|
+
(current_settings): их меняют на странице «Настройки».
|
|
16
|
+
"""
|
|
17
|
+
|
|
18
|
+
from __future__ import annotations
|
|
19
|
+
|
|
20
|
+
import hashlib
|
|
21
|
+
import json
|
|
22
|
+
import logging
|
|
23
|
+
import os
|
|
24
|
+
import statistics
|
|
25
|
+
import threading
|
|
26
|
+
import time
|
|
27
|
+
from collections.abc import Callable, Iterable, Mapping
|
|
28
|
+
import dataclasses
|
|
29
|
+
from dataclasses import dataclass, field
|
|
30
|
+
from pathlib import Path
|
|
31
|
+
from typing import Any
|
|
32
|
+
|
|
33
|
+
from app import model_traffic
|
|
34
|
+
from app.config import Settings
|
|
35
|
+
from app.context import build_context, clone_revision, export_fragment_view, file_presence, norm_path, resolve_repo
|
|
36
|
+
from app.db import (ACTIVE_RUN_STATES, FINAL_RUN_STATES, UNKNOWN_RESULT_NOTE, Database, DatabaseBusy,
|
|
37
|
+
EmptyQueue, ProfileChanged)
|
|
38
|
+
from app.hub_import import group_key, group_key2, is_urgent, near_columns2
|
|
39
|
+
from app.executors import (DROP_PAUSE_NOTE, DROP_SHARE_PAUSE, DROP_STREAK_PAUSE, REMOTE_KINDS, ProfileError,
|
|
40
|
+
SendNotAllowed, applied_think, choose_profile, client_for, drop_retry_allowed,
|
|
41
|
+
execution_values, fit_options, fit_thinking, host_metrics_of, json_overhead, planned_think,
|
|
42
|
+
prompt_size, provider_key, same_model, send_guard, snapshot_mismatch, snapshot_options, thinking_limit,
|
|
43
|
+
unload_allowed_of)
|
|
44
|
+
from app.llm import (DEFAULT_OPTIONS, LlmError, PromptOverflowError, estimate_tokens, gate_for,
|
|
45
|
+
model_answered, norm_model_name, outcome_unknown, prompt_budget, prompt_fits, prompt_tokens)
|
|
46
|
+
from app.llm_ollama import OllamaClient
|
|
47
|
+
from app.lockfile import LockUnsure
|
|
48
|
+
from app.storage import CommitUnknown
|
|
49
|
+
from app.logsafe import failure_text, log_failure
|
|
50
|
+
from app.masking import mask_text
|
|
51
|
+
from app.models import CodeContext, Finding, LlmStats
|
|
52
|
+
from app.prompts import (PROMPT_VERSION, VERDICT_ENUMS, VERDICT_FIELDS, VERDICT_REQUIRED, VERDICT_TYPES,
|
|
53
|
+
build_sast_messages, check_verdict_answer, parse_verdict, request_key, steering_fields,
|
|
54
|
+
steering_lines)
|
|
55
|
+
|
|
56
|
+
log = logging.getLogger("local_triage.triage")
|
|
57
|
+
|
|
58
|
+
SCOPES = ("live", "all", "urgent", "selected") # live – по умолчанию (бэклог 104)
|
|
59
|
+
SEVERITY_RANK = {"critical": 0, "high": 1, "medium": 2, "low": 3, "info": 4}
|
|
60
|
+
KIND_RANK = {"SAST": 0, "SCA": 1, "SCA-license": 2, "DAST": 3}
|
|
61
|
+
FEED_SIZE = 12 # сколько последних находок показывать в ленте прогона
|
|
62
|
+
WORKER_POLL_S = 1.0 # как часто поток проверяет очередь, если его не разбудили
|
|
63
|
+
CONTEXT_CHARS = 14000 # срез кода для модели, знаков; не помещается в окно контекста – сокращается
|
|
64
|
+
MIN_CONTEXT_CHARS = 1000 # …но не меньше: дальше промпт отклоняется с понятной ошибкой
|
|
65
|
+
CLONE_GONE_NOTE = ("Код находки в клоне сейчас не прочитать: файл пропал во время разбора или не найден однозначно. "
|
|
66
|
+
"Сохранённый срез не изменён. Проверьте клон или удалите его – тогда модель получит срез из базы.")
|
|
67
|
+
FIT_ATTEMPTS = 3 # сколько раз сокращать срез
|
|
68
|
+
CHANGED_NOTE = ("Находка или папка с клоном изменились, пока шёл разбор (новая выгрузка или другое соответствие "
|
|
69
|
+
"папок): результат не привязан, запустите прогон для неё заново.")
|
|
70
|
+
CODE_CHANGED_NOTE = ("Код в клоне изменился, пока отвечала модель: ответ относится к прежнему коду и к находке "
|
|
71
|
+
"не привязан. Запустите разбор этой находки заново.")
|
|
72
|
+
PARTIAL_NOTE = " Замеры скорости по этой находке неполные: ответа модели целиком нет."
|
|
73
|
+
# Занятая база или нечитаемый замок папки данных при записи результата находки (Э2): это не ошибка находки –
|
|
74
|
+
# запись повторяется, затем прогон встаёт на паузу, а находка остаётся в очереди
|
|
75
|
+
# Неизвестный исход COMMIT в прогоне – как занятая база: повтор и пауза, находка не считается ошибкой. Все записи под retry_busy
|
|
76
|
+
# безопасно повторить: вердикт с заранее полученным номером, срез, завершение находки только из pending, состояние прогона
|
|
77
|
+
# (ADR-0128, п. 6.4). Прямые записи без повтора при таком исходе дают паузу; «Продолжить» берёт следующую незавершённую находку.
|
|
78
|
+
BUSY_ERRORS = (DatabaseBusy, LockUnsure, CommitUnknown)
|
|
79
|
+
DB_UNKNOWN_PAUSE = ("Связь с базой оборвалась во время подтверждения записи, записалась ли она, неизвестно. Прогон на паузе. "
|
|
80
|
+
"Нажмите «Продолжить», когда база снова доступна: завершённые находки повторно не разбираются, а незавершённая "
|
|
81
|
+
"может быть разобрана заново.")
|
|
82
|
+
DB_RUN_PAUSE = ("База данных занята или недоступна либо не читается файл замка папки данных, и состояние прогона записать не "
|
|
83
|
+
"удалось. Прогон на паузе, разобранные находки сохранены. Нажмите «Продолжить», когда это пройдёт.")
|
|
84
|
+
DB_WRITE_RETRIES = 3
|
|
85
|
+
DB_RETRY_WAIT_S = 2.0
|
|
86
|
+
DB_BUSY_PAUSE = ("База данных занята (её держит другой запрос) или файл замка папки данных не прочитался: результат "
|
|
87
|
+
"находки не записан. Прогон на паузе, находка осталась в очереди. Нажмите «Продолжить», когда база "
|
|
88
|
+
"освободится: модель может разобрать эту находку заново.")
|
|
89
|
+
# Прогон без снимка исполнителя (начат до 0.9.12) и прогон с выключенным профилем (ADR-0102): исполнителя не
|
|
90
|
+
# подменяем – «Продолжить» создаёт новый прогон на действующем профиле проекта (TriageRunner.continue_as_new)
|
|
91
|
+
LEGACY_RUN_NOTE = ("Прогон начат до 0.9.12: сервер модели, на котором он шёл, не записан. Нажмите «Продолжить» – "
|
|
92
|
+
"неразобранные находки пойдут новым прогоном на профиле модели проекта.")
|
|
93
|
+
DISABLED_PROFILE_NOTE = ("Прогон на паузе. Включите профиль на странице «Настройки» или нажмите «Продолжить» – "
|
|
94
|
+
"неразобранные находки пойдут новым прогоном на действующем профиле проекта.")
|
|
95
|
+
PAUSE_OLLAMA_NOTE = "Прогон на паузе: проверьте Ollama и нажмите «Продолжить»."
|
|
96
|
+
PAUSE_PROVIDER_NOTE = "Прогон на паузе: устраните причину у провайдера и нажмите «Продолжить»."
|
|
97
|
+
PAYMENT_NOTE = "Провайдер ответил 402: нужна оплата (пополните баланс в личном кабинете провайдера)."
|
|
98
|
+
|
|
99
|
+
|
|
100
|
+
def pause_note(execution: Mapping[str, Any] | None) -> str:
|
|
101
|
+
"""Подсказка паузы по классу исполнителя: Ollama своего контура или внешний провайдер."""
|
|
102
|
+
return PAUSE_PROVIDER_NOTE if str((execution or {}).get("trust") or "") == "external" else PAUSE_OLLAMA_NOTE
|
|
103
|
+
|
|
104
|
+
|
|
105
|
+
def pause_text(error: Exception) -> str:
|
|
106
|
+
"""Текст паузы прогона при отказе перед отправкой: причина и что делать (SendNotAllowed.note; по умолчанию – о
|
|
107
|
+
выключенном профиле)."""
|
|
108
|
+
return f"{error} {getattr(error, 'note', '') or DISABLED_PROFILE_NOTE}"
|
|
109
|
+
|
|
110
|
+
|
|
111
|
+
def retry_busy(write: Callable[[], Any]) -> Any:
|
|
112
|
+
"""Запись при занятой базе: несколько попыток с паузой; не вышло – исключение BUSY_ERRORS дальше."""
|
|
113
|
+
unknown = None
|
|
114
|
+
for attempt in range(DB_WRITE_RETRIES):
|
|
115
|
+
try:
|
|
116
|
+
return write()
|
|
117
|
+
except BUSY_ERRORS as e:
|
|
118
|
+
if isinstance(e, CommitUnknown):
|
|
119
|
+
unknown = e # следующая ошибка не снимает неопределённость: запись могла подтвердиться
|
|
120
|
+
if attempt + 1 == DB_WRITE_RETRIES:
|
|
121
|
+
if unknown is not None and unknown is not e:
|
|
122
|
+
raise unknown from e
|
|
123
|
+
raise
|
|
124
|
+
time.sleep(DB_RETRY_WAIT_S)
|
|
125
|
+
except Exception as e: # другая ошибка повтора тоже не значит, что прежняя запись не подтвердилась
|
|
126
|
+
if unknown is not None:
|
|
127
|
+
log_failure(log, "повтор записи после неизвестного исхода COMMIT не прошёл", e) # журнал покажет место этой ошибки
|
|
128
|
+
raise unknown from e
|
|
129
|
+
raise
|
|
130
|
+
return None
|
|
131
|
+
PROMPT_DOUBT_NOTE = ("Промпт, по счёту модели, не поместился в окно контекста вместе с ответом: начало могло быть "
|
|
132
|
+
"обрезано, ответ не принят. Увеличьте окно контекста (MODEL_NUM_CTX) и разберите находку ещё раз.")
|
|
133
|
+
# удалённый API: запрос не поместился в окно профиля даже с наименьшим срезом – совет про профиль, не про Ollama
|
|
134
|
+
REMOTE_WINDOW_NOTE = ("Увеличьте «Окно контекста модели» или уменьшите «Предел ответа» в профиле провайдера и "
|
|
135
|
+
"разберите находку ещё раз.")
|
|
136
|
+
|
|
137
|
+
# Медленный режим модели. Причина такого режима не доказана: у процесса модели часть памяти может оказаться
|
|
138
|
+
# в общей памяти Windows, и генерация идёт в несколько раз медленнее. Приложение только замечает замедление
|
|
139
|
+
# и перезагружает модель между находками; причину в интерфейсе не утверждает.
|
|
140
|
+
SLOW_TPS_SHARE = 0.35 # медленно – ниже этой доли обычной скорости (медианы последних ответов)
|
|
141
|
+
SLOW_TPS_ABSOLUTE = 30.0 # без ориентира: абсолютный порог ток/с для первых двух ответов подряд
|
|
142
|
+
SLOW_TPS_KNOWN_FAST = 80.0 # быстрая модель: раньше давала больше этого, иначе абсолютный порог не применяется
|
|
143
|
+
SLOW_STREAK = 2 # сколько медленных ответов подряд нужно, чтобы считать режим медленным
|
|
144
|
+
SLOW_MAX_RELOADS = 2 # не больше двух попыток перезагрузки за прогон, включая неудачные
|
|
145
|
+
SLOW_BASELINE_MIN = 3 # ориентир – медиана, для неё нужно не меньше трёх успешных ответов
|
|
146
|
+
SLOW_BASELINE_WINDOW = 20 # сколько последних ответов прогона берётся для ориентира
|
|
147
|
+
SLOW_HISTORY_WINDOW = 200 # сколько ответов прошлых прогонов той же модели смотреть
|
|
148
|
+
SLOW_RELOAD_WAIT_S = 15.0 # сколько ждать, пока /api/ps покажет модель выгруженной
|
|
149
|
+
SLOW_RELOAD_POLL_S = 0.2 # как часто спрашивать /api/ps во время ожидания
|
|
150
|
+
|
|
151
|
+
|
|
152
|
+
def slow_model_status_text(tps: float, baseline: float, reloaded: bool) -> str:
|
|
153
|
+
"""Строка оператору о медленном режиме. Причина не называется: она не доказана."""
|
|
154
|
+
measured = f"{_tps_number(tps)} ток/с при обычных {_tps_number(baseline)}"
|
|
155
|
+
if reloaded:
|
|
156
|
+
return f"Модель работала медленно ({measured}) – перезагружена"
|
|
157
|
+
return (f"Модель работала медленно ({measured}) – перезагрузка не помогла: закройте программы, "
|
|
158
|
+
"использующие видеокарту, и нажмите «Пауза» → «Продолжить»")
|
|
159
|
+
|
|
160
|
+
|
|
161
|
+
def _tps_number(value: float) -> str:
|
|
162
|
+
"""Ток/с в строке оператору: целое, если оно не меньше 10, иначе один знак после запятой."""
|
|
163
|
+
return f"{value:.0f}" if abs(value) >= 10 else f"{value:.1f}"
|
|
164
|
+
|
|
165
|
+
|
|
166
|
+
def _median(values: Iterable[float]) -> float | None:
|
|
167
|
+
items = list(values)
|
|
168
|
+
return float(statistics.median(items)) if items else None
|
|
169
|
+
|
|
170
|
+
|
|
171
|
+
@dataclass
|
|
172
|
+
class _SlowState:
|
|
173
|
+
"""Замедление одного прогона: последние скорости, серия медленных ответов, перезагрузки и строка оператору."""
|
|
174
|
+
|
|
175
|
+
samples: list[float] = field(default_factory=list)
|
|
176
|
+
history_median: float | None = None # ориентир: медиана прошлых прогонов, только если замеров хватает
|
|
177
|
+
history_typical: float | None = None # та же медиана для строки оператору, даже по одному-двум замерам
|
|
178
|
+
history_fast: bool = False
|
|
179
|
+
streak: int = 0
|
|
180
|
+
reloads: int = 0
|
|
181
|
+
reload_pending: bool = False
|
|
182
|
+
unload_allowed: bool = True # снимок исполнителя разрешает выгрузку модели (профиль lan – только по разрешению)
|
|
183
|
+
after_reload: bool = False
|
|
184
|
+
pending_tps: float = 0.0
|
|
185
|
+
pending_baseline: float = 0.0
|
|
186
|
+
text: str = ""
|
|
187
|
+
warning: bool = False
|
|
188
|
+
|
|
189
|
+
|
|
190
|
+
class TriageError(Exception):
|
|
191
|
+
"""Прогон не запустить или не изменить. Текст – по-русски, для показа в интерфейсе."""
|
|
192
|
+
|
|
193
|
+
|
|
194
|
+
# ============================================================================ порядок разбора
|
|
195
|
+
|
|
196
|
+
def severity_rank(f: Finding) -> int:
|
|
197
|
+
"""Ранг критичности: 0 – критическая. У SCA отчёта Hub критичности нет – ранг по полосам CVSS v3."""
|
|
198
|
+
if f.severity in SEVERITY_RANK:
|
|
199
|
+
return SEVERITY_RANK[f.severity]
|
|
200
|
+
if f.cvss is not None:
|
|
201
|
+
if f.cvss >= 9.0:
|
|
202
|
+
return 0
|
|
203
|
+
if f.cvss >= 7.0:
|
|
204
|
+
return 1
|
|
205
|
+
if f.cvss >= 4.0:
|
|
206
|
+
return 2
|
|
207
|
+
return 3 if f.cvss > 0 else 4
|
|
208
|
+
return 5
|
|
209
|
+
|
|
210
|
+
|
|
211
|
+
def order_findings(findings: Iterable[Finding], sca_cvss: float = 9.0) -> list[dict]:
|
|
212
|
+
"""Находки → строки для Database.save_import (и reorder_findings) в порядке разбора.
|
|
213
|
+
|
|
214
|
+
SAST впереди остальных видов; внутри вида – срочные, затем по критичности, затем по порядку выгрузки.
|
|
215
|
+
Находки с одним ключом группы (дубли) идут подряд, на месте самой срочной из них.
|
|
216
|
+
"""
|
|
217
|
+
items = []
|
|
218
|
+
for index, f in enumerate(findings):
|
|
219
|
+
urgent = bool(is_urgent(f, sca_cvss=sca_cvss))
|
|
220
|
+
gk = group_key2(f) # дубли идут подряд по ключу второй редакции (ADR-0095)
|
|
221
|
+
key = (KIND_RANK.get(f.kind, 9), 0 if urgent else 1, severity_rank(f), index)
|
|
222
|
+
items.append((f, urgent, gk, key, (f.kind, gk or f"id:{f.hub_id}")))
|
|
223
|
+
best: dict[tuple[str, str], tuple] = {}
|
|
224
|
+
for _, _, _, key, group in items:
|
|
225
|
+
if group not in best or key < best[group]:
|
|
226
|
+
best[group] = key
|
|
227
|
+
items.sort(key=lambda item: (best[item[4]], item[3]))
|
|
228
|
+
rows = []
|
|
229
|
+
for pos, (f, urgent, gk, _, _) in enumerate(items):
|
|
230
|
+
cat, file2, line = near_columns2(f)
|
|
231
|
+
rows.append({"hub_id": f.hub_id, "pos": pos, "kind": f.kind, "severity": f.severity, "cvss": f.cvss,
|
|
232
|
+
"urgent": urgent, "codebase": f.codebase, "group_key": group_key(f), "group_key2": gk,
|
|
233
|
+
"g2_cat": cat, "g2_file": file2, "g2_line": line, "data": f.to_dict()})
|
|
234
|
+
return rows
|
|
235
|
+
|
|
236
|
+
|
|
237
|
+
def reorder_project(db: Database, project_id: int, sca_cvss: float) -> int:
|
|
238
|
+
"""Заново упорядочить находки проекта и пересчитать срочность (например, после смены порога срочности SCA
|
|
239
|
+
на странице «Настройки»). Порядок выгрузки восстанавливается по листу и строке. Возвращает, у скольких находок
|
|
240
|
+
изменились порядок или срочность."""
|
|
241
|
+
findings = [Finding.from_dict(row["data"]) for row in db.findings_data(project_id)]
|
|
242
|
+
findings.sort(key=lambda f: (KIND_RANK.get(f.kind, 9), f.sheet, f.row))
|
|
243
|
+
return db.reorder_findings(project_id, order_findings(findings, sca_cvss))
|
|
244
|
+
|
|
245
|
+
|
|
246
|
+
# ============================================================================ случай для модели
|
|
247
|
+
|
|
248
|
+
def repo_dir_for(settings: Settings, project: dict, codebase_map: dict[str, dict],
|
|
249
|
+
f: Finding) -> tuple[Path | None, str]:
|
|
250
|
+
"""Папка клона кодовой базы находки: (путь, "") или (None, причина). Отвязанный клон (detached, ADR-0072) не
|
|
251
|
+
читается, даже если папка на месте: код кодовой базы – срезы в базе."""
|
|
252
|
+
entry = codebase_map.get(f.codebase) or {}
|
|
253
|
+
folder = str(entry.get("folder") or "").strip()
|
|
254
|
+
if not folder:
|
|
255
|
+
return None, "кодовая база не сопоставлена с папкой"
|
|
256
|
+
if entry.get("detached"):
|
|
257
|
+
return None, "клон отвязан: код берётся из срезов в базе"
|
|
258
|
+
rel = "/".join(part for part in (str(project.get("repos_dir") or "").strip("/"), folder) if part)
|
|
259
|
+
try:
|
|
260
|
+
path = resolve_repo(settings.repos_root, rel)
|
|
261
|
+
except ValueError as e:
|
|
262
|
+
return None, str(e)
|
|
263
|
+
if not path.is_dir():
|
|
264
|
+
return None, "папка с клоном не найдена"
|
|
265
|
+
if empty_dir(path):
|
|
266
|
+
# Пустая папка на месте удалённого клона – тоже клона нет: иначе сверка ревизий сочла бы её другим
|
|
267
|
+
# кодом и сбросила сохранённые срезы (ADR-0072)
|
|
268
|
+
return None, "папка с клоном пуста"
|
|
269
|
+
return path, ""
|
|
270
|
+
|
|
271
|
+
|
|
272
|
+
def empty_dir(path: Path) -> bool:
|
|
273
|
+
"""В папке нет ни одной записи. Не удалось прочитать – не пустая: решает обычная проверка файла."""
|
|
274
|
+
try:
|
|
275
|
+
with os.scandir(path) as entries:
|
|
276
|
+
return next(entries, None) is None
|
|
277
|
+
except OSError:
|
|
278
|
+
return False
|
|
279
|
+
|
|
280
|
+
|
|
281
|
+
def stored_code(case: dict | None) -> CodeContext | None:
|
|
282
|
+
"""Сохранённый в базе срез находки (cases.context_json) или None, если среза нет. Срез с кодом из файла клона –
|
|
283
|
+
статус «ok»; срез из одной строки выгрузки (файла в клоне не было) и срез без строк тоже возвращаются: без
|
|
284
|
+
клона каждый остаётся тем, что видела модель, и отпечаток решения по нему не меняется."""
|
|
285
|
+
context = (case or {}).get("context") or {}
|
|
286
|
+
if not context.get("status"):
|
|
287
|
+
return None
|
|
288
|
+
try:
|
|
289
|
+
return CodeContext.from_dict(context)
|
|
290
|
+
except (TypeError, ValueError, KeyError):
|
|
291
|
+
return None
|
|
292
|
+
|
|
293
|
+
|
|
294
|
+
def snapshot_code(settings: Settings, source: dict, case: dict | None) -> tuple[CodeContext, str] | None:
|
|
295
|
+
"""Код находки из базы вместо клона (ADR-0072): папки клона её кодовой базы нет (удалена, пуста, другой корень
|
|
296
|
+
папок с клонами) или в клоне нет файла находки, а срез сохранён при разборе или кнопкой «Сохранить срезы кода» –
|
|
297
|
+
(срез, отпечаток). Файл в клоне на месте или среза нет – None: код читается из клона, как раньше. Код проекта
|
|
298
|
+
после выгрузки не меняется, поэтому сохранённый срез без клона считается текущим кодом: он не перезаписывается
|
|
299
|
+
и не сверяется."""
|
|
300
|
+
ctx = stored_code(case)
|
|
301
|
+
if ctx is None:
|
|
302
|
+
return None
|
|
303
|
+
f = Finding.from_dict(source["data"])
|
|
304
|
+
repo_dir, _ = repo_dir_for(settings, {"repos_dir": source["repos_dir"]}, source_codebases(source, f), f)
|
|
305
|
+
if repo_dir is not None and _code_file_present(repo_dir, f, ctx.file):
|
|
306
|
+
return None
|
|
307
|
+
return ctx, case_hash(f, ctx)
|
|
308
|
+
|
|
309
|
+
|
|
310
|
+
def degrades(case: dict | None, ctx: CodeContext) -> bool:
|
|
311
|
+
"""Новый срез хуже сохранённого: в базе код из файла (статус «ok»), а сейчас – только строка выгрузки или ничего.
|
|
312
|
+
Такой срез автоматически не записывается (ADR-0072): файл пропал во время разбора или не найден однозначно,
|
|
313
|
+
а полноценный срез в базе – единственная копия кода, если клон потом удалят."""
|
|
314
|
+
return ((case or {}).get("context") or {}).get("status") == "ok" and ctx.status != "ok"
|
|
315
|
+
|
|
316
|
+
|
|
317
|
+
def source_codebases(source: dict, f: Finding) -> dict[str, dict]:
|
|
318
|
+
"""Сопоставление кодовой базы находки по снимку Database.case_input() – для repo_dir_for."""
|
|
319
|
+
return {f.codebase: {"folder": source["folder"], "detached": bool(source.get("detached"))}}
|
|
320
|
+
|
|
321
|
+
|
|
322
|
+
def _code_file_present(repo_dir: Path, f: Finding, stored_file: str = "") -> bool:
|
|
323
|
+
"""Файл находки есть в клоне или это не определить (файл не читается). Нет только тогда, когда это доказано:
|
|
324
|
+
клон удалён не целиком – осталась .git или часть папок – и файла нет ни по пути сохранённого среза, ни по пути
|
|
325
|
+
из выгрузки. Несколько подходящих файлов или неполный обход клона – файл считается на месте: код читается из
|
|
326
|
+
клона, и его изменения видны, как раньше."""
|
|
327
|
+
try:
|
|
328
|
+
for rel in dict.fromkeys(r for r in (norm_path(stored_file), norm_path(f.file)) if r):
|
|
329
|
+
if file_presence(repo_dir, rel) != "missing":
|
|
330
|
+
return True
|
|
331
|
+
except (OSError, ValueError):
|
|
332
|
+
return True
|
|
333
|
+
return False
|
|
334
|
+
|
|
335
|
+
|
|
336
|
+
def observed_revisions(settings: Settings, project: dict, codebase_map: dict[str, dict]) -> dict[str, str]:
|
|
337
|
+
"""Ревизии клонов кодовых баз проекта, папка которых сейчас на месте: {кодовая база: ревизия}; "" – папка
|
|
338
|
+
не клон git. Кодовые базы без папки или с пропавшей папкой не входят: о них ничего не известно."""
|
|
339
|
+
result = {}
|
|
340
|
+
for codebase, entry in codebase_map.items():
|
|
341
|
+
if not str((entry or {}).get("folder") or "").strip():
|
|
342
|
+
continue
|
|
343
|
+
repo_dir, _ = repo_dir_for(settings, project, codebase_map, Finding(hub_id="", kind="SAST", codebase=codebase))
|
|
344
|
+
if repo_dir is not None:
|
|
345
|
+
result[codebase] = clone_revision(repo_dir)
|
|
346
|
+
return result
|
|
347
|
+
|
|
348
|
+
|
|
349
|
+
def sync_revisions(db: Database, settings: Settings, project: dict) -> dict:
|
|
350
|
+
"""Сверка ревизий клонов проекта с запомненными (Database.sync_revisions): при смене ревизии срезы находок
|
|
351
|
+
этой кодовой базы сбрасываются, а отметки «проверено» снимаются. Перед сверкой удалённые клоны с полными срезами
|
|
352
|
+
отвязываются (detach_removed_clones): клон другой выгрузки, положенный потом на то же место, срезы не сбросит."""
|
|
353
|
+
detach_removed_clones(db, settings, project)
|
|
354
|
+
return db.sync_revisions(project["id"], observed_revisions(settings, project,
|
|
355
|
+
db.get_codebase_map(project["id"], with_detached=True)))
|
|
356
|
+
|
|
357
|
+
|
|
358
|
+
def detach_removed_clones(db: Database, settings: Settings, project: dict) -> list[str]:
|
|
359
|
+
"""Отвязать клоны, которые удалили после разбора (ADR-0072): у кодовой базы выбрана папка, клона нет (папка
|
|
360
|
+
удалена, пуста или вне корня), срез полон у каждой её находки SAST и хотя бы в одном срезе код из файла
|
|
361
|
+
(клон был: кодовую базу, которую разбирали без клона, не отвязываем). Отвязанный клон больше не читается,
|
|
362
|
+
пока человек не подключит клоны снова (Database.clear_detached) или не выберет другую папку. Возвращает
|
|
363
|
+
отвязанные сейчас кодовые базы."""
|
|
364
|
+
pid = int(project["id"])
|
|
365
|
+
if not settings.repos_root.is_dir():
|
|
366
|
+
return [] # корень папок с клонами не подключён: это не удаление клонов, отвязывать нельзя
|
|
367
|
+
counts = db.snapshot_counts(pid)
|
|
368
|
+
cmap = db.get_codebase_map(pid, with_detached=True)
|
|
369
|
+
removed = []
|
|
370
|
+
for codebase, entry in cmap.items():
|
|
371
|
+
n = counts.get(codebase) or {}
|
|
372
|
+
if (not str(entry.get("folder") or "").strip() or entry.get("detached") or not n.get("sast")
|
|
373
|
+
or n.get("none") or n.get("incomplete") or not n.get("code")):
|
|
374
|
+
continue
|
|
375
|
+
repo_dir, _ = repo_dir_for(settings, project, cmap, Finding(hub_id="", kind="SAST", codebase=codebase))
|
|
376
|
+
if repo_dir is None:
|
|
377
|
+
removed.append(codebase)
|
|
378
|
+
if removed:
|
|
379
|
+
db.set_detached(pid, removed)
|
|
380
|
+
return removed
|
|
381
|
+
|
|
382
|
+
|
|
383
|
+
def save_snapshots(db: Database, settings: Settings, project: dict, mask_key: bytes) -> dict:
|
|
384
|
+
"""«Сохранить срезы кода» (ADR-0072): находкам SAST текущей выгрузки без сохранённого среза, у которых клон на
|
|
385
|
+
месте, строится и записывается срез – так же, как его строит прогон (маскирование, CONTEXT_CHARS), но без
|
|
386
|
+
модели. Удалять клоны можно после проверки полноты срезов. Срез без вердикта с причиной missing, unreadable
|
|
387
|
+
или неизвестной причиной, а также no_repo сопоставленного неотвязанного клона заменяется, только если файл
|
|
388
|
+
теперь доступен и прочитан; прежний вердикт по no_repo к новому коду не привязывается.
|
|
389
|
+
Возвращает {"saved": сколько записано, "skipped": {причина: сколько}}."""
|
|
390
|
+
pid = int(project["id"])
|
|
391
|
+
saved, skipped = 0, {}
|
|
392
|
+
for hub_id, upgrade in db.snapshot_candidates(pid):
|
|
393
|
+
source = db.case_input(pid, hub_id)
|
|
394
|
+
if source is None or source.get("missing"):
|
|
395
|
+
continue
|
|
396
|
+
f = Finding.from_dict(source["data"])
|
|
397
|
+
repo_dir, why = repo_dir_for(settings, {"repos_dir": source["repos_dir"]}, source_codebases(source, f), f)
|
|
398
|
+
if repo_dir is None:
|
|
399
|
+
skipped[why] = skipped.get(why, 0) + 1
|
|
400
|
+
continue
|
|
401
|
+
if upgrade and file_presence(repo_dir, f.file) != "found":
|
|
402
|
+
continue
|
|
403
|
+
# срез без строк тоже сохраняется – как в прогоне («Нет кода для разбора»): без клона он останется тем же
|
|
404
|
+
ctx = build_context(repo_dir, f, max_chars=CONTEXT_CHARS, mask_key=mask_key, no_repo_note=why)
|
|
405
|
+
if upgrade and ctx.status != "ok":
|
|
406
|
+
continue # полноценный срез не получен: прежний срез остаётся
|
|
407
|
+
if db.save_case(pid, hub_id, case_hash(f, ctx), {**case_context(f, ctx), "max_chars": CONTEXT_CHARS},
|
|
408
|
+
None, source, only_new=not upgrade, replace_line_only=upgrade):
|
|
409
|
+
saved += 1
|
|
410
|
+
return {"saved": saved, "skipped": skipped}
|
|
411
|
+
|
|
412
|
+
|
|
413
|
+
def case_hash(f: Finding, ctx: CodeContext) -> str:
|
|
414
|
+
"""Отпечаток случая – всё, что модель видит в сведениях о находке и в коде: правило, место, маскированный срез
|
|
415
|
+
кода и сведения о нём. ID находки, имя кодовой базы, анализатор и критичность в промпт не входят (prompts.py),
|
|
416
|
+
поэтому нет их и здесь: дубль от другого анализатора или с другой критичностью получает тот же вердикт.
|
|
417
|
+
Шаблон промпта учитывает PROMPT_VERSION в ключе кэша, параметры генерации – константы (окно контекста на вход
|
|
418
|
+
не влияет: промпт, который в него не помещается, не отправляется)."""
|
|
419
|
+
payload = {
|
|
420
|
+
"kind": f.kind, "rule": f.rule, "cwe": list(f.cwe), "file": f.file, "line": f.line,
|
|
421
|
+
"language": f.language, "snippet": " ".join(str(f.snippet or "").split()),
|
|
422
|
+
"ctx": {"status": ctx.status, "file": ctx.file, "language": ctx.language, "start": ctx.start_line,
|
|
423
|
+
"target": ctx.target_line, "lines": list(ctx.lines), "enclosing": ctx.enclosing,
|
|
424
|
+
"export_line_check": ctx.export_line_check, "note": ctx.note},
|
|
425
|
+
}
|
|
426
|
+
if ctx.export_line_check_version >= 2:
|
|
427
|
+
# ADR-0082: в отпечатке – сверка версии 1 по тому же коду, чтобы уточнённая сверка не меняла отпечаток
|
|
428
|
+
# неизменного кода (иначе карточка сочла бы код изменившимся и решение потеряло бы «Проверено»)
|
|
429
|
+
payload["ctx"]["export_line_check"] = ctx.hash_check
|
|
430
|
+
payload["ctx"]["export_line_at"] = ctx.hash_check_at
|
|
431
|
+
elif ctx.export_line_check_version >= 1:
|
|
432
|
+
payload["ctx"]["export_line_at"] = ctx.export_line_at # новые срезы; старые отпечатки остаются прежними
|
|
433
|
+
text = json.dumps(payload, ensure_ascii=False, sort_keys=True)
|
|
434
|
+
return hashlib.sha256(text.encode("utf-8")).hexdigest()
|
|
435
|
+
|
|
436
|
+
|
|
437
|
+
def think_for(model: str) -> str | None:
|
|
438
|
+
"""Режим рассуждений передаётся только моделям gpt-oss."""
|
|
439
|
+
return "low" if "gpt-oss" in model.casefold() else None
|
|
440
|
+
|
|
441
|
+
|
|
442
|
+
def model_options(num_ctx: int) -> dict[str, int]:
|
|
443
|
+
"""Параметры генерации прогона: окно контекста из настроек; предел длины ответа – не больше четверти окна,
|
|
444
|
+
чтобы в маленьком окне оставалось место под промпт."""
|
|
445
|
+
return {"num_ctx": int(num_ctx), "num_predict": min(int(DEFAULT_OPTIONS["num_predict"]), int(num_ctx) // 4)}
|
|
446
|
+
|
|
447
|
+
|
|
448
|
+
def case_context(f: Finding, ctx: CodeContext) -> dict[str, Any]:
|
|
449
|
+
"""Срез для хранения (cases.context_json): CodeContext и признаки попытки повлиять на разбор – номера строк
|
|
450
|
+
кода и названия полей находки с текстом, похожим на указания для модели. Карточка и список показывают их
|
|
451
|
+
человеку: вердикт, полученный под влиянием таких указаний, не должен выглядеть как обычный."""
|
|
452
|
+
return {**ctx.to_dict(), "steering_lines": steering_lines(ctx), "steering_fields": steering_fields(f, ctx)}
|
|
453
|
+
|
|
454
|
+
|
|
455
|
+
def current_code(settings: Settings, source: dict, mask_key: bytes, max_chars: int = CONTEXT_CHARS,
|
|
456
|
+
case: dict | None = None) -> tuple[Finding, CodeContext, str]:
|
|
457
|
+
"""Срез текущего кода находки по снимку Database.case_input() – так же, как его строит прогон: (находка,
|
|
458
|
+
срез, отпечаток case_hash). Отпечаток сравнивается с тем, что видела модель (cases.case_hash) или человек
|
|
459
|
+
(reviews.code_hash): изменился – код в клоне другой. max_chars – размер среза, с которым считался отпечаток,
|
|
460
|
+
с которым идёт сравнение. case – сохранённый срез находки: если клона нет, текущий код – он (snapshot_code).
|
|
461
|
+
Без клона срез другого размера не построить: возвращается отпечаток сохранённого среза, и решение, принятое при
|
|
462
|
+
другом размере, не совпадёт – его актуальность не доказана (code_changed), решение сохраняют заново."""
|
|
463
|
+
f, ctx, chash, _ = current_code_origin(settings, source, mask_key, max_chars, case)
|
|
464
|
+
return f, ctx, chash
|
|
465
|
+
|
|
466
|
+
|
|
467
|
+
def current_code_origin(settings: Settings, source: dict, mask_key: bytes, max_chars: int = CONTEXT_CHARS,
|
|
468
|
+
case: dict | None = None) -> tuple[Finding, CodeContext, str, bool]:
|
|
469
|
+
"""То же, что current_code, и признак: срез подставлен из базы (клона или файла находки нет, snapshot_code).
|
|
470
|
+
Признак – у того же чтения: повторная проверка клона позже может увидеть уже вернувшийся файл, код которого
|
|
471
|
+
никто не читал (ревью Codex ветки долга, круг 5)."""
|
|
472
|
+
f = Finding.from_dict(source["data"])
|
|
473
|
+
snapshot = snapshot_code(settings, source, case)
|
|
474
|
+
if snapshot is not None:
|
|
475
|
+
return f, snapshot[0], snapshot[1], True
|
|
476
|
+
repo_dir, why = repo_dir_for(settings, {"repos_dir": source["repos_dir"]}, source_codebases(source, f), f)
|
|
477
|
+
ctx = build_context(repo_dir, f, max_chars=max_chars, mask_key=mask_key, no_repo_note=why)
|
|
478
|
+
return f, ctx, case_hash(f, ctx), False
|
|
479
|
+
|
|
480
|
+
|
|
481
|
+
def _merged_stats(first: LlmStats | None, second: LlmStats | None) -> LlmStats | None:
|
|
482
|
+
"""Замеры двух обращений одной находки (оборванное и автоматический повтор, ADR-0107): токены, попытки и время
|
|
483
|
+
складываются, скорость – последнего ответа."""
|
|
484
|
+
if first is None or second is None:
|
|
485
|
+
return second if second is not None else first
|
|
486
|
+
return dataclasses.replace(
|
|
487
|
+
second, prompt_tokens=first.prompt_tokens + second.prompt_tokens,
|
|
488
|
+
output_tokens=first.output_tokens + second.output_tokens, attempts=first.attempts + second.attempts,
|
|
489
|
+
total_s=round(first.total_s + second.total_s, 3), load_s=first.load_s + second.load_s,
|
|
490
|
+
reasoning_tokens=first.reasoning_tokens + second.reasoning_tokens,
|
|
491
|
+
cache_hit_tokens=first.cache_hit_tokens + second.cache_hit_tokens,
|
|
492
|
+
think=",".join(p for p in (first.think, second.think) if p))
|
|
493
|
+
|
|
494
|
+
|
|
495
|
+
def _after_drop(drop_error: LlmError, retry_error: Exception) -> LlmError:
|
|
496
|
+
"""Обрыв без ответа, после которого повтор не получил ответа модели (не ушёл, 402, ошибка сервера): находка –
|
|
497
|
+
«результат неизвестен» первого запроса, причина повтора – в тексте (ревью Codex, круг 18)."""
|
|
498
|
+
drop_error.drop_retries = 1 # type: ignore[attr-defined]
|
|
499
|
+
drop_error.retry_error = str(retry_error) # type: ignore[attr-defined]
|
|
500
|
+
# 402 повтора – провайдер просит оплату: прогон встаёт на паузу по оплате (ревью Codex, круг 19)
|
|
501
|
+
drop_error.retry_status = getattr(retry_error, "status", None) # type: ignore[attr-defined]
|
|
502
|
+
drop_error.stats = _merged_stats(drop_error.stats, getattr(retry_error, "stats", None))
|
|
503
|
+
return drop_error
|
|
504
|
+
|
|
505
|
+
|
|
506
|
+
def _stats_partial(error: LlmError) -> bool:
|
|
507
|
+
"""Замеры неудачного ответа неполные: попытку прервал сбой связи или сервера, и что модель успела
|
|
508
|
+
сгенерировать в ней, неизвестно (ответ не по формату, оборванный по длине ответ – замерены полностью).
|
|
509
|
+
Признак – ответа модели в ошибке нет (raw пуст), хотя попытка была; если клиент сам сообщает признак
|
|
510
|
+
(stats_partial), берётся он."""
|
|
511
|
+
explicit = getattr(error, "stats_partial", None)
|
|
512
|
+
if explicit is not None:
|
|
513
|
+
return bool(explicit)
|
|
514
|
+
if getattr(error, "drop_retries", 0):
|
|
515
|
+
# одна из попыток оборвалась без ответа: её расход неизвестен, как бы ни закончился повтор (ревью Codex, круг 19)
|
|
516
|
+
return True
|
|
517
|
+
if getattr(error, "reason", None):
|
|
518
|
+
# известный исход (LlmError.reason, ADR-0106 п. 8): ответ получен целиком, его расход в stats – замеры полные,
|
|
519
|
+
# даже если текста ответа нет (отказ модели, неизвестная причина остановки, ответ не по протоколу; KIMI-05)
|
|
520
|
+
return False
|
|
521
|
+
return error.stats is not None and error.stats.attempts > 0 and not error.raw
|
|
522
|
+
|
|
523
|
+
|
|
524
|
+
# ============================================================================ очередь
|
|
525
|
+
|
|
526
|
+
class TriageRunner:
|
|
527
|
+
"""Фоновый поток триажа. Состояние прогонов – в базе; принятые команды паузы и стопа – в памяти процесса
|
|
528
|
+
и в базе (runs.control), чтобы принятый «Стоп» пережил перезапуск."""
|
|
529
|
+
|
|
530
|
+
def __init__(self, db: Database, settings: Settings,
|
|
531
|
+
client_factory: Callable[[str], OllamaClient] | None = None,
|
|
532
|
+
mask_key: bytes | None = None) -> None:
|
|
533
|
+
self.db = db
|
|
534
|
+
self.settings = settings
|
|
535
|
+
self._client_factory = client_factory or OllamaClient
|
|
536
|
+
self._mask_key = mask_key if mask_key is not None else db.mask_key()
|
|
537
|
+
self._lock = threading.Lock() # команды, переходы состояний идущего прогона, текущая находка
|
|
538
|
+
self._life = threading.Lock() # запуск и остановка потока
|
|
539
|
+
self._controls: dict[int, str] = {} # run_id -> 'pause' | 'stop'
|
|
540
|
+
self._live: dict[int, dict[str, Any]] = {} # run_id -> текущая находка и этап
|
|
541
|
+
self._slow: dict[int, _SlowState] = {} # run_id -> замедление и перезагрузки модели
|
|
542
|
+
self._unsaved_errors: dict[int, str] = {} # прогоны, чьё состояние «ошибка» не удалось записать
|
|
543
|
+
# прогоны, чью паузу из-за занятой базы не удалось записать (Э2): причина – запишется позже
|
|
544
|
+
self._unsaved_pauses: dict[int, str] = {}
|
|
545
|
+
# обрывы без ответа у внешнего провайдера по прогону: {run_id: {"drops", "streak", "done"}}; каскад – пауза
|
|
546
|
+
# прогона после находки (DROP_STREAK_PAUSE, DROP_SHARE_PAUSE); счёт заново после «Продолжить»
|
|
547
|
+
self._drops: dict[int, dict[str, int]] = {}
|
|
548
|
+
self._drop_pause: dict[int, str] = {}
|
|
549
|
+
self._wake = threading.Event()
|
|
550
|
+
self._halt = threading.Event()
|
|
551
|
+
self._thread: threading.Thread | None = None
|
|
552
|
+
|
|
553
|
+
def current_settings(self) -> Settings:
|
|
554
|
+
"""Действующие настройки: сохранённые в интерфейсе (таблица settings) поверх переменных окружения."""
|
|
555
|
+
return self.settings.with_stored(self.db.get_settings())
|
|
556
|
+
|
|
557
|
+
# ---------------------------------------------------------------- жизненный цикл
|
|
558
|
+
|
|
559
|
+
def start(self) -> None:
|
|
560
|
+
"""Запускает поток. Прогоны, прерванные перезапуском, ставятся на паузу. Повторный вызов при живом
|
|
561
|
+
потоке ничего не делает; после shutdown() ждёт, пока прежний поток доработает находку."""
|
|
562
|
+
with self._life:
|
|
563
|
+
if self._thread is not None and self._thread.is_alive():
|
|
564
|
+
if not self._halt.is_set():
|
|
565
|
+
return
|
|
566
|
+
self._thread.join()
|
|
567
|
+
self.db.recover_interrupted()
|
|
568
|
+
self._halt = threading.Event()
|
|
569
|
+
thread = threading.Thread(target=self._loop, args=(self._halt,), name="triage-worker", daemon=True)
|
|
570
|
+
thread.start() # не запустился – прежнее состояние, shutdown() не ждёт незапущенный поток
|
|
571
|
+
self._thread = thread
|
|
572
|
+
|
|
573
|
+
def shutdown(self, timeout: float = 5.0) -> bool:
|
|
574
|
+
"""Останавливает поток после текущей находки. True – поток завершился за timeout секунд
|
|
575
|
+
(только тогда базу можно закрывать)."""
|
|
576
|
+
with self._life:
|
|
577
|
+
self._halt.set()
|
|
578
|
+
self._wake.set()
|
|
579
|
+
thread = self._thread
|
|
580
|
+
if thread is None or thread.ident is None:
|
|
581
|
+
return True
|
|
582
|
+
thread.join(timeout)
|
|
583
|
+
return not thread.is_alive()
|
|
584
|
+
|
|
585
|
+
# ---------------------------------------------------------------- команды
|
|
586
|
+
|
|
587
|
+
def enqueue(self, project_id: int, model: str, scope: str, hub_ids: Iterable[str] = (),
|
|
588
|
+
fresh: bool = False, origin: str = "", provider_id: int | None = None) -> int:
|
|
589
|
+
"""Ставит прогон в очередь; возвращает его номер. fresh – не брать готовые вердикты из кэша. Профиль –
|
|
590
|
+
provider_id или профиль проекта, или профиль приложения (ADR-0102); снимок исполнителя пишется вместе с
|
|
591
|
+
прогоном: окно, предел ответа, срок и режим схемы замораживаются при постановке."""
|
|
592
|
+
model = str(model or "").strip()
|
|
593
|
+
if scope not in SCOPES:
|
|
594
|
+
raise TriageError("Неизвестный охват прогона.")
|
|
595
|
+
if not model:
|
|
596
|
+
raise TriageError("Не выбрана модель.")
|
|
597
|
+
settings = self.current_settings()
|
|
598
|
+
try:
|
|
599
|
+
profile = choose_profile(self.db, settings, self.db.get_project(project_id), provider_id)
|
|
600
|
+
except ProfileError as e:
|
|
601
|
+
raise TriageError(str(e)) from None
|
|
602
|
+
execution = execution_values(profile, model, "triage", settings.num_ctx, settings.model_json_schema)
|
|
603
|
+
with self._lock:
|
|
604
|
+
active = self.db.active_runs(project_id)
|
|
605
|
+
if active:
|
|
606
|
+
if origin == "card" and active[0].get("state") != "paused": # разборы идут по одному, очереди нет – сказать, что делать
|
|
607
|
+
raise TriageError(f"Сейчас идёт другой разбор (прогон №{active[0]['id']}). Разборы проекта идут по одному: "
|
|
608
|
+
"дождитесь его конца и нажмите «Разобрать» снова. Ход прогона – на странице проекта.")
|
|
609
|
+
raise TriageError(f"У проекта есть незавершённый прогон №{active[0]['id']}: продолжите или "
|
|
610
|
+
"остановите его.")
|
|
611
|
+
try: # состав очереди и паспорт – одним чтением в транзакции создания прогона (бэклог 104)
|
|
612
|
+
run_id = self.db.create_run(project_id, model, scope, PROMPT_VERSION, list(hub_ids), fresh=fresh,
|
|
613
|
+
origin=origin, execution=execution, queue_scope=scope)
|
|
614
|
+
except EmptyQueue:
|
|
615
|
+
raise TriageError("Нет находок SAST для выбранного охвата.") from None
|
|
616
|
+
except ProfileChanged as e:
|
|
617
|
+
raise TriageError(f"{e} Выберите для проекта действующий профиль.") from None
|
|
618
|
+
self._wake.set()
|
|
619
|
+
return run_id
|
|
620
|
+
|
|
621
|
+
def continuation_reason(self, run: dict) -> str:
|
|
622
|
+
"""Почему прогон нельзя продолжить им самим ("" – можно): у него нет снимка исполнителя (начат до 0.9.12) или
|
|
623
|
+
профиль снимка выключен. Тогда «Продолжить» – новый прогон на действующем профиле проекта (П22)."""
|
|
624
|
+
execution = self.db.get_execution(run.get("execution_id"))
|
|
625
|
+
if execution is None:
|
|
626
|
+
return "Прогон начат до 0.9.12: адрес исполнителя у него не записан."
|
|
627
|
+
profile = self.db.get_provider(execution["provider_id"]) if execution.get("provider_id") else None
|
|
628
|
+
return snapshot_mismatch(profile, execution)
|
|
629
|
+
|
|
630
|
+
def continue_as_new(self, run_id: int, hub_ids: Iterable[str] | None = None, origin: str | None = None,
|
|
631
|
+
fresh: bool | None = None, execution_id: int | None = None) -> int:
|
|
632
|
+
"""Новый прогон вместо прежнего (ADR-0102 п. 4–5, П22): «Продолжить» у прогона без снимка или с выключенным
|
|
633
|
+
профилем, «Повторить ошибочные». Новый прогон – с parent_run_id и собственным снимком на действующем профиле
|
|
634
|
+
проекта (или с перенесённым снимком execution_id); прежний, если он в очереди или на паузе, останавливается в
|
|
635
|
+
той же транзакции с отметкой, каким прогоном продолжен. Все проверки – до записи: отказ прежний прогон не
|
|
636
|
+
трогает. hub_ids – находки (по умолчанию – неразобранные)."""
|
|
637
|
+
with self._lock:
|
|
638
|
+
run = self.db.get_run(run_id)
|
|
639
|
+
if run is None:
|
|
640
|
+
raise TriageError("Прогон не найден.")
|
|
641
|
+
if run["state"] == "running":
|
|
642
|
+
raise TriageError("Прогон ещё идёт: сначала поставьте его на паузу.")
|
|
643
|
+
self.db.settle_sending_items(run_id) # К11: находки с меткой без результата новым прогоном не берутся
|
|
644
|
+
ids = list(hub_ids) if hub_ids is not None else self.db.pending_hub_ids(run_id)
|
|
645
|
+
if not ids:
|
|
646
|
+
raise TriageError("Продолжать нечего: все находки прогона уже разобраны.")
|
|
647
|
+
execution = None
|
|
648
|
+
if execution_id is None:
|
|
649
|
+
settings = self.current_settings()
|
|
650
|
+
try:
|
|
651
|
+
profile = choose_profile(self.db, settings, self.db.get_project(run["project_id"]))
|
|
652
|
+
except ProfileError as e:
|
|
653
|
+
raise TriageError(str(e)) from None
|
|
654
|
+
execution = execution_values(profile, run["model"], "triage", settings.num_ctx,
|
|
655
|
+
settings.model_json_schema)
|
|
656
|
+
others = [r for r in self.db.active_runs(run["project_id"]) if r["id"] != run_id]
|
|
657
|
+
if others:
|
|
658
|
+
raise TriageError(f"У проекта есть незавершённый прогон №{others[0]['id']}: продолжите или "
|
|
659
|
+
"остановите его.")
|
|
660
|
+
try:
|
|
661
|
+
new_id = self.db.create_run(run["project_id"], run["model"], "selected", PROMPT_VERSION, ids,
|
|
662
|
+
fresh=bool(run["fresh"]) if fresh is None else fresh,
|
|
663
|
+
origin=run.get("origin") or "" if origin is None else origin,
|
|
664
|
+
execution=execution, execution_id=execution_id, parent_run_id=run_id)
|
|
665
|
+
except ProfileChanged as e: # профиль выключили или сменили адрес только что: прежний прогон не тронут
|
|
666
|
+
raise TriageError(f"{e} Запустите новый прогон на действующем профиле проекта.") from None
|
|
667
|
+
except RuntimeError:
|
|
668
|
+
raise TriageError("Прогон успел измениться: обновите страницу.") from None
|
|
669
|
+
self._wake.set()
|
|
670
|
+
return new_id
|
|
671
|
+
|
|
672
|
+
def retry_errors(self, run_id: int, hub_ids: Iterable[str]) -> int:
|
|
673
|
+
"""«Повторить ошибочные» (ADR-0102 п. 5): снимок прежнего прогона переносится, если его профиль включён и адрес
|
|
674
|
+
профиля не менялся; профиль выключен или адрес изменился – отказ с причиной (прежний прогон не трогается);
|
|
675
|
+
прогон без снимка (до 0.9.12) – новый прогон на действующем профиле проекта с собственным снимком."""
|
|
676
|
+
run = self.db.get_run(run_id)
|
|
677
|
+
if run is None:
|
|
678
|
+
raise TriageError("Прогон не найден.")
|
|
679
|
+
execution = self.db.get_execution(run.get("execution_id"))
|
|
680
|
+
if execution is None:
|
|
681
|
+
return self.continue_as_new(run_id, hub_ids, origin="retry", fresh=True)
|
|
682
|
+
profile = self.db.get_provider(execution["provider_id"]) if execution.get("provider_id") else None
|
|
683
|
+
reason = snapshot_mismatch(profile, execution)
|
|
684
|
+
if reason:
|
|
685
|
+
raise TriageError(f"{reason} Запустите новый прогон ошибочных находок на действующем профиле проекта.")
|
|
686
|
+
return self.continue_as_new(run_id, hub_ids, origin="retry", fresh=True, execution_id=int(execution["id"]))
|
|
687
|
+
|
|
688
|
+
def pause(self, run_id: int) -> bool:
|
|
689
|
+
"""Пауза: прогон в очереди – сразу, идущий – после текущей находки. Принятый стоп важнее."""
|
|
690
|
+
with self._lock:
|
|
691
|
+
run = self.db.get_run(run_id)
|
|
692
|
+
if run is None:
|
|
693
|
+
return False
|
|
694
|
+
if run["state"] == "queued" and self.db.set_run_state(run_id, "paused", last_error="",
|
|
695
|
+
only_from=("queued",)):
|
|
696
|
+
return True
|
|
697
|
+
run = self.db.get_run(run_id) # поток мог успеть взять прогон в работу
|
|
698
|
+
if (run is not None and run["state"] == "running" and self._controls.get(run_id) != "stop"
|
|
699
|
+
and run.get("control") != "stop"):
|
|
700
|
+
try:
|
|
701
|
+
accepted = self.db.set_run_control(run_id, "pause")
|
|
702
|
+
except CommitUnknown:
|
|
703
|
+
self._controls[run_id] = "pause" # запись могла подтвердиться, а команду оператор дал
|
|
704
|
+
raise
|
|
705
|
+
if not accepted:
|
|
706
|
+
return False
|
|
707
|
+
self._controls[run_id] = "pause"
|
|
708
|
+
return True
|
|
709
|
+
return False
|
|
710
|
+
|
|
711
|
+
def resume(self, run_id: int) -> bool:
|
|
712
|
+
"""Продолжить: прогон на паузе возвращается в очередь; у идущего снимается принятая пауза."""
|
|
713
|
+
with self._lock:
|
|
714
|
+
run = self.db.get_run(run_id)
|
|
715
|
+
if run is None:
|
|
716
|
+
return False
|
|
717
|
+
# пауза, у которой не записался итог: обработчик уже вышел, а в базе прогон ещё идёт – он тоже возвращается в очередь
|
|
718
|
+
stopping = self._controls.get(run_id) == "stop" or run.get("control") == "stop" # принятый «Стоп» важнее
|
|
719
|
+
if run["state"] == "paused" or (run["state"] == "running" and run_id in self._unsaved_pauses and not stopping):
|
|
720
|
+
# К11: находки с меткой отправки без результата – «результат неизвестен», снова не отправляются
|
|
721
|
+
self.db.settle_sending_items(run_id)
|
|
722
|
+
if run["state"] == "paused": # пауза уже в базе; записать её заново после этого «Продолжить» нельзя и при обрыве
|
|
723
|
+
self._unsaved_pauses.pop(run_id, None)
|
|
724
|
+
ok = self.db.set_run_state(run_id, "queued", last_error="", only_from=(run["state"],))
|
|
725
|
+
if ok:
|
|
726
|
+
# отложенная пауза не должна отменить это «Продолжить»
|
|
727
|
+
self._unsaved_pauses.pop(run_id, None)
|
|
728
|
+
self._controls.pop(run_id, None)
|
|
729
|
+
self._wake.set()
|
|
730
|
+
return ok
|
|
731
|
+
if run["state"] == "running" and self._controls.get(run_id) == "pause":
|
|
732
|
+
self.db.set_run_control(run_id, "")
|
|
733
|
+
del self._controls[run_id]
|
|
734
|
+
return True
|
|
735
|
+
return False
|
|
736
|
+
|
|
737
|
+
def stop(self, run_id: int) -> bool:
|
|
738
|
+
"""Стоп: прогон в очереди или на паузе – сразу, идущий – после текущей находки. Принятая команда идущего
|
|
739
|
+
прогона сначала записывается в базу: если приложение перезапустится раньше, чем закончится текущая
|
|
740
|
+
находка, прогон при запуске будет остановлен, а не поставлен на паузу."""
|
|
741
|
+
with self._lock:
|
|
742
|
+
run = self.db.get_run(run_id)
|
|
743
|
+
if run is None:
|
|
744
|
+
return False
|
|
745
|
+
if run["state"] in ("queued", "paused") and self.db.set_run_state(
|
|
746
|
+
run_id, "stopped", only_from=("queued", "paused")):
|
|
747
|
+
return True
|
|
748
|
+
run = self.db.get_run(run_id)
|
|
749
|
+
if run is not None and run["state"] == "running":
|
|
750
|
+
try:
|
|
751
|
+
accepted = self.db.set_run_control(run_id, "stop")
|
|
752
|
+
except CommitUnknown:
|
|
753
|
+
self._controls[run_id] = "stop" # запись могла подтвердиться, а команду оператор дал: прогон остановится
|
|
754
|
+
raise
|
|
755
|
+
if accepted:
|
|
756
|
+
self._controls[run_id] = "stop"
|
|
757
|
+
return True
|
|
758
|
+
return False
|
|
759
|
+
|
|
760
|
+
def _apply_control(self, run_id: int) -> bool:
|
|
761
|
+
"""Между находками: выполнить принятую команду. True – прогон остановлен или поставлен на паузу."""
|
|
762
|
+
with self._lock:
|
|
763
|
+
control = self._controls.get(run_id)
|
|
764
|
+
if control is None:
|
|
765
|
+
return False
|
|
766
|
+
self.db.set_run_state(run_id, "stopped" if control == "stop" else "paused", only_from=("running",))
|
|
767
|
+
self._controls.pop(run_id, None) # после записи: занятая база при повторе не потеряет команду
|
|
768
|
+
if control == "stop":
|
|
769
|
+
self._slow.pop(run_id, None)
|
|
770
|
+
return True
|
|
771
|
+
|
|
772
|
+
def _finish(self, run_id: int, state: str, last_error: str | None = None) -> None:
|
|
773
|
+
"""Перевести идущий прогон в state. Если принят стоп, вместо паузы прогон останавливается."""
|
|
774
|
+
with self._lock:
|
|
775
|
+
control = self._controls.get(run_id)
|
|
776
|
+
if control == "stop" and state == "paused":
|
|
777
|
+
state = "stopped"
|
|
778
|
+
self.db.set_run_state(run_id, state, last_error=last_error, only_from=("running",))
|
|
779
|
+
self._controls.pop(run_id, None) # после записи: занятая база при повторе не потеряет принятый стоп
|
|
780
|
+
if state in FINAL_RUN_STATES:
|
|
781
|
+
self._slow.pop(run_id, None)
|
|
782
|
+
|
|
783
|
+
def _set_live(self, run_id: int, **values: Any) -> None:
|
|
784
|
+
with self._lock:
|
|
785
|
+
if 'since' in values:
|
|
786
|
+
values['since_monotonic'] = time.monotonic() if values['since'] is not None else None
|
|
787
|
+
if values.get('phase') and values.get('phase') != self._live.get(run_id,{}).get('phase'):
|
|
788
|
+
values['phase_since'] = time.time()
|
|
789
|
+
self._live.setdefault(run_id, {}).update(values)
|
|
790
|
+
|
|
791
|
+
# ---------------------------------------------------------------- состояние для страницы прогона
|
|
792
|
+
|
|
793
|
+
def run_status(self, run_id: int) -> dict | None:
|
|
794
|
+
"""Состояние прогона: счётчики, скорость, оценка оставшегося времени, текущая находка, лента."""
|
|
795
|
+
run = self.db.get_run(run_id)
|
|
796
|
+
if run is None:
|
|
797
|
+
return None
|
|
798
|
+
with self._lock:
|
|
799
|
+
live = dict(self._live.get(run_id) or {})
|
|
800
|
+
control = self._controls.get(run_id)
|
|
801
|
+
active = run["state"] in ACTIVE_RUN_STATES
|
|
802
|
+
pending, calls = self.db.pending_model_groups(run_id) if active else (0, 0)
|
|
803
|
+
# среднее время ответа модели – без загрузки модели в память (её время – только у первой находки)
|
|
804
|
+
avg_call = run["model_seconds"] / run["model_calls"] if run["model_calls"] else None
|
|
805
|
+
from app.journal import eta_average
|
|
806
|
+
estimate = eta_average(self.db, run_id)
|
|
807
|
+
eta = round(calls * estimate) if run['state'] == 'running' and estimate is not None else None
|
|
808
|
+
tps_avg = run["output_tokens"] / run["eval_seconds"] if run["eval_seconds"] > 0 else None
|
|
809
|
+
# удалённый API: видеокарта и память этого компьютера к прогону не относятся, скорость генерации сервер не
|
|
810
|
+
# сообщает – скорость ответа считается по времени модели (с ожиданием сервера)
|
|
811
|
+
execution = self.db.get_execution(run.get("execution_id")) if run.get("execution_id") else None
|
|
812
|
+
remote = str((execution or {}).get("kind") or "ollama") in REMOTE_KINDS
|
|
813
|
+
if remote and tps_avg is None and run["model_seconds"] > 0 and run["output_tokens"]:
|
|
814
|
+
tps_avg = run["output_tokens"] / run["model_seconds"]
|
|
815
|
+
# длительность – время работы над находками: паузы и простой после перезапуска не входят
|
|
816
|
+
elapsed = None
|
|
817
|
+
if run["started_at"]:
|
|
818
|
+
working = self.db.run_work_seconds(run_id)
|
|
819
|
+
if run["state"] == "running" and live.get("since"):
|
|
820
|
+
working += max(0.0, time.monotonic() - live.get('since_monotonic', time.monotonic()))
|
|
821
|
+
elapsed = round(working)
|
|
822
|
+
current = None
|
|
823
|
+
if run["state"] == "running" and live.get("hub_id") and live.get("since"):
|
|
824
|
+
current = {"hub_id": live.get("hub_id"), "finding_id": live.get("finding_id"),
|
|
825
|
+
"phase": live.get("phase", ""), "seconds": round(max(0, time.monotonic() - live.get('since_monotonic', time.monotonic()))),
|
|
826
|
+
**{k:live.get(k) for k in ('phase_since','request_started_at','last_model_event_at','attempt')}}
|
|
827
|
+
total = int(run["total"] or 0)
|
|
828
|
+
new_verdicts = run["done"] - run["cached"] - run["skipped"] - run["failed"]
|
|
829
|
+
feed = self.db.recent_items(run_id, FEED_SIZE)
|
|
830
|
+
from app import journal
|
|
831
|
+
slow = journal.slow_model_state(self.db, run_id)
|
|
832
|
+
return {
|
|
833
|
+
"run": {key: run[key] for key in ("id", "project_id", "state", "scope", "model", "prompt_version",
|
|
834
|
+
"fresh", "total", "done", "failed", "cached", "skipped",
|
|
835
|
+
"model_calls", "last_error", "created_at", "started_at",
|
|
836
|
+
"finished_at", "partial_stats")},
|
|
837
|
+
"new_verdicts": max(0, new_verdicts),
|
|
838
|
+
"progress": round(100.0 * run["done"] / total, 1) if total else 100.0,
|
|
839
|
+
"pending": pending,
|
|
840
|
+
"eta_s": eta,
|
|
841
|
+
"avg_call_s": round(avg_call, 1) if avg_call is not None else None,
|
|
842
|
+
"elapsed_s": elapsed,
|
|
843
|
+
# у удалённого API последней скорости генерации нет – на её месте средняя скорость ответа
|
|
844
|
+
"tps_last": (round(tps_avg, 1) if remote and tps_avg else
|
|
845
|
+
round(run["last_tps"], 1) if run["last_tps"] else None),
|
|
846
|
+
"tps_avg": round(tps_avg, 1) if tps_avg else None,
|
|
847
|
+
"remote_executor": remote,
|
|
848
|
+
"remote_where": {"external": "у внешнего провайдера (интернет)", "lan": "на сервере в сети организации"}.get(
|
|
849
|
+
str((execution or {}).get("trust") or ""), "на сервере провайдера") if remote else "",
|
|
850
|
+
"control": control,
|
|
851
|
+
"current": current,
|
|
852
|
+
"feed": feed,
|
|
853
|
+
"last_result_at": feed[0]['finished_at'] if feed else None,
|
|
854
|
+
"slow_model": ({key: slow.get(key) for key in ("tps", "baseline", "reloads", "text", "warning")}
|
|
855
|
+
if slow.get("text") else None),
|
|
856
|
+
"journal_warning": model_traffic.failure_text(run_id),
|
|
857
|
+
}
|
|
858
|
+
|
|
859
|
+
# ---------------------------------------------------------------- поток
|
|
860
|
+
|
|
861
|
+
def _loop(self, halt: threading.Event) -> None:
|
|
862
|
+
"""Диспетчер очереди. Не завершается от ошибок: сбой базы – подождать и попробовать снова."""
|
|
863
|
+
while not halt.is_set():
|
|
864
|
+
try:
|
|
865
|
+
self._save_pending_errors()
|
|
866
|
+
run = self.db.next_queued_run()
|
|
867
|
+
except Exception as e:
|
|
868
|
+
log_failure(log, "очередь прогонов недоступна", e)
|
|
869
|
+
halt.wait(WORKER_POLL_S)
|
|
870
|
+
continue
|
|
871
|
+
if run is None:
|
|
872
|
+
self._wake.wait(WORKER_POLL_S)
|
|
873
|
+
self._wake.clear()
|
|
874
|
+
continue
|
|
875
|
+
run_id = int(run["id"])
|
|
876
|
+
try:
|
|
877
|
+
with model_traffic.context(run_id=run_id): # сбой журнала при любом обращении прогона – в его учёт
|
|
878
|
+
self._process_run(run_id, halt)
|
|
879
|
+
except BUSY_ERRORS as e: # база занята, недоступна или исход записи неизвестен: данные целы, это не ошибка прогона
|
|
880
|
+
log_failure(log, "прогон %s на паузе: база занята или исход записи неизвестен", e, run_id)
|
|
881
|
+
self._pause_after_db_failure(run_id, DB_UNKNOWN_PAUSE if isinstance(e, CommitUnknown) else DB_RUN_PAUSE)
|
|
882
|
+
except Exception as e: # прогон не должен оставаться «идёт» после сбоя
|
|
883
|
+
eid = log_failure(log, "прогон %s прерван внутренней ошибкой", e, run_id)
|
|
884
|
+
self._mark_error(run_id, f"Внутренняя ошибка {type(e).__name__} (ошибка {eid}). Подробности – "
|
|
885
|
+
"в журнале контейнера.")
|
|
886
|
+
finally:
|
|
887
|
+
with self._lock:
|
|
888
|
+
# отложенной паузе нужен принятый «Стоп»: он мог остаться только в памяти
|
|
889
|
+
if run_id not in self._unsaved_pauses or self._controls.get(run_id) != "stop":
|
|
890
|
+
self._controls.pop(run_id, None)
|
|
891
|
+
self._live.pop(run_id, None)
|
|
892
|
+
|
|
893
|
+
def _pause_after_db_failure(self, run_id: int, note: str) -> None:
|
|
894
|
+
"""Пауза прогона после сбоя записи вне обработки находки. Оставшийся в очереди тоже: иначе поток брал бы его снова и снова,
|
|
895
|
+
а следующие прогоны ждали бы. Завершённый не меняется; принятый «Стоп» (в памяти или в базе) важнее паузы. Сбой этой записи
|
|
896
|
+
не останавливает поток очереди: она повторится, когда база освободится (_save_pending_errors)."""
|
|
897
|
+
failure = None
|
|
898
|
+
with self._lock: # и запись, и её откладывание под одним замком: «Продолжить» не вклинится между ними
|
|
899
|
+
try:
|
|
900
|
+
run = self.db.get_run(run_id) or {}
|
|
901
|
+
stop = self._controls.get(run_id) == "stop" or run.get("control") == "stop"
|
|
902
|
+
self.db.set_run_state(run_id, "stopped" if stop else "paused", last_error=note, only_from=("running", "queued"))
|
|
903
|
+
self._controls.pop(run_id, None)
|
|
904
|
+
if (self.db.get_run(run_id) or {}).get("state") in FINAL_RUN_STATES:
|
|
905
|
+
self._slow.pop(run_id, None)
|
|
906
|
+
except Exception as e:
|
|
907
|
+
failure = e
|
|
908
|
+
self._unsaved_pauses[run_id] = note
|
|
909
|
+
if failure is not None:
|
|
910
|
+
log_failure(log, "пауза прогона %s не записана, повторю позже", failure, run_id)
|
|
911
|
+
|
|
912
|
+
def _mark_error(self, run_id: int, text: str) -> None:
|
|
913
|
+
try:
|
|
914
|
+
self.db.set_run_state(run_id, "error", last_error=text, only_from=("running", "queued"))
|
|
915
|
+
with self._lock:
|
|
916
|
+
self._slow.pop(run_id, None)
|
|
917
|
+
except Exception as e:
|
|
918
|
+
log_failure(log, "состояние прогона %s не записано, повторю позже", e, run_id)
|
|
919
|
+
with self._lock:
|
|
920
|
+
self._unsaved_errors[run_id] = text
|
|
921
|
+
|
|
922
|
+
def _save_pending_errors(self) -> None:
|
|
923
|
+
with self._lock:
|
|
924
|
+
pauses = dict(self._unsaved_pauses)
|
|
925
|
+
for run_id, text in pauses.items():
|
|
926
|
+
with self._lock: # как _finish: принятый «Стоп» (в памяти или в базе) важнее паузы, снимается после записи
|
|
927
|
+
if run_id not in self._unsaved_pauses: # пока шёл обход, оператор нажал «Продолжить»
|
|
928
|
+
continue
|
|
929
|
+
run = self.db.get_run(run_id) or {}
|
|
930
|
+
stop = self._controls.get(run_id) == "stop" or run.get("control") == "stop"
|
|
931
|
+
self.db.set_run_state(run_id, "stopped" if stop else "paused", last_error=text, only_from=("running", "queued"))
|
|
932
|
+
self._unsaved_pauses.pop(run_id, None)
|
|
933
|
+
self._controls.pop(run_id, None)
|
|
934
|
+
if (self.db.get_run(run_id) or {}).get("state") in FINAL_RUN_STATES:
|
|
935
|
+
self._slow.pop(run_id, None)
|
|
936
|
+
with self._lock:
|
|
937
|
+
pending = dict(self._unsaved_errors)
|
|
938
|
+
for run_id, text in pending.items():
|
|
939
|
+
self.db.set_run_state(run_id, "error", last_error=text, only_from=("running", "queued"))
|
|
940
|
+
with self._lock:
|
|
941
|
+
self._unsaved_errors.pop(run_id, None)
|
|
942
|
+
self._slow.pop(run_id, None)
|
|
943
|
+
|
|
944
|
+
def _process_run(self, run_id: int, halt: threading.Event) -> None:
|
|
945
|
+
if not self.db.set_run_state(run_id, "running", last_error="", only_from=("queued",)):
|
|
946
|
+
return # прогон успели поставить на паузу или остановить
|
|
947
|
+
run = self.db.get_run(run_id)
|
|
948
|
+
project = self.db.get_project(run["project_id"]) if run is not None else None
|
|
949
|
+
if run is None or project is None:
|
|
950
|
+
self._finish(run_id, "error", "Проект прогона не найден.")
|
|
951
|
+
return
|
|
952
|
+
if run["prompt_version"] != PROMPT_VERSION:
|
|
953
|
+
self._finish(run_id, "error", f"Прогон начат с промптом {run['prompt_version']}, а приложение уже "
|
|
954
|
+
f"работает с {PROMPT_VERSION}: запустите новый прогон.")
|
|
955
|
+
return
|
|
956
|
+
settings = self.current_settings() # папки клонов; адрес, модель и параметры – из снимка исполнителя
|
|
957
|
+
execution = self.db.get_execution(run.get("execution_id"))
|
|
958
|
+
if execution is None: # прогон до 0.9.12 (остался в очереди после обновления): исполнителя не подменяем
|
|
959
|
+
self._finish(run_id, "paused", LEGACY_RUN_NOTE)
|
|
960
|
+
return
|
|
961
|
+
guard = send_guard(self.db, execution, project_id=run["project_id"])
|
|
962
|
+
try:
|
|
963
|
+
guard()
|
|
964
|
+
except SendNotAllowed as e:
|
|
965
|
+
self._finish(run_id, "paused", pause_text(e))
|
|
966
|
+
return
|
|
967
|
+
try: # клон могли обновить (git pull) после прошлой сверки: срезы по прежнему коду не берутся
|
|
968
|
+
changed = sync_revisions(self.db, settings, project)["changed"]
|
|
969
|
+
if changed: # имена кодовых баз в журнал не пишутся: журнал пересылают при сбоях
|
|
970
|
+
log.info("прогон %s: сменилась ревизия клонов у %d кодовых баз", run_id, len(changed))
|
|
971
|
+
except Exception as e:
|
|
972
|
+
log_failure(log, "ревизии клонов не сверены (прогон %s)", e, run_id)
|
|
973
|
+
client = client_for(self._client_factory, execution, guard, db=self.db,
|
|
974
|
+
project_id=run["project_id"])
|
|
975
|
+
options, _, think_rule = snapshot_options(execution)
|
|
976
|
+
gate = gate_for(execution) # группа права на генерацию – из снимка прогона (ADR-0104 п. 6), не пересчитывается
|
|
977
|
+
try:
|
|
978
|
+
client.check_url()
|
|
979
|
+
except LlmError as e: # адрес не из разрешённых: продолжать бессмысленно, пока адрес не исправлен
|
|
980
|
+
self._refresh_contexts(run, halt)
|
|
981
|
+
refused = self._refused(guard) # профиль выключили – пауза, а не ошибка адреса
|
|
982
|
+
self._finish(run_id, "paused" if refused else "error", refused or str(e))
|
|
983
|
+
return
|
|
984
|
+
# счёт обрывов без ответа – заново на каждый запуск и после «Продолжить» (каскад – пауза, _count_drop)
|
|
985
|
+
self._drops.pop(run_id, None)
|
|
986
|
+
self._drop_pause.pop(run_id, None)
|
|
987
|
+
# удалённые API – точное имя модели, Ollama – без регистра и «:latest» (ADR-0106 п. 7)
|
|
988
|
+
name_of = same_model(str(execution.get("kind") or "ollama"))
|
|
989
|
+
remote = str(execution.get("kind") or "ollama") in REMOTE_KINDS
|
|
990
|
+
try:
|
|
991
|
+
model_list = client.list_models()
|
|
992
|
+
names = {name_of(m.get("name", "")) for m in model_list}
|
|
993
|
+
except LlmError as e:
|
|
994
|
+
self._refresh_contexts(run, halt)
|
|
995
|
+
# отказ допуска (адрес не подтверждён, ключ задан для другого адреса) – со своей причиной и подсказкой
|
|
996
|
+
self._finish(run_id, "paused", self._refused(guard) or (
|
|
997
|
+
pause_text(e) if isinstance(e, SendNotAllowed) else f"{e} {pause_note(execution)}"))
|
|
998
|
+
return
|
|
999
|
+
if name_of(run["model"]) not in names:
|
|
1000
|
+
self._refresh_contexts(run, halt)
|
|
1001
|
+
refused = self._refused(guard) # модель пропала, а профиль за это время выключили: причина – профиль
|
|
1002
|
+
if refused:
|
|
1003
|
+
self._finish(run_id, "paused", refused)
|
|
1004
|
+
return
|
|
1005
|
+
self._finish(run_id, "error", (
|
|
1006
|
+
f"Модели «{run['model']}» нет в списке моделей сервера профиля: проверьте имя модели (оно "
|
|
1007
|
+
"сравнивается точно, с учётом регистра) в профиле или в параметрах проекта." if remote else
|
|
1008
|
+
f"Модели «{run['model']}» нет в Ollama. Загрузите её командой: ollama pull {run['model']}"))
|
|
1009
|
+
return
|
|
1010
|
+
# Паспорт окружения сохраняется при каждом продолжении, без зависимости от браузера.
|
|
1011
|
+
from app import __version__
|
|
1012
|
+
from app.journal import environment
|
|
1013
|
+
from app.metrics import gpu_stats
|
|
1014
|
+
from app.telemetry import host_snapshot
|
|
1015
|
+
selected_model = next((m for m in model_list if name_of(m.get('name', '')) == name_of(run['model'])), {})
|
|
1016
|
+
# видеокарта, память и процессор этого компьютера – только когда модель на нём (профиль local, ADR-0102 п. 9)
|
|
1017
|
+
local_host = host_metrics_of(execution)
|
|
1018
|
+
host = host_snapshot(settings.data_dir / 'telemetry' / 'host.json') if local_host else {'status': 'remote'}
|
|
1019
|
+
try:
|
|
1020
|
+
gpu = gpu_stats() if local_host else None
|
|
1021
|
+
except Exception:
|
|
1022
|
+
gpu = None # Необязательная метрика не останавливает разбор находок.
|
|
1023
|
+
hardware = ({'name': gpu.get('name'), 'memory_total_mb': gpu.get('memory_total_mb'),
|
|
1024
|
+
'gpus': [{'name': g.get('name'), 'memory_total_mb': g.get('memory_total_mb')} for g in gpu.get('gpus', [])]} if gpu else None)
|
|
1025
|
+
environment(self.db, run_id, {
|
|
1026
|
+
'app_version': __version__, 'prompt_version': run['prompt_version'],
|
|
1027
|
+
'model': {key: selected_model.get(key) for key in ('name', 'digest', 'size', 'params', 'quant', 'family', 'context_length')},
|
|
1028
|
+
# параметры и уровень рассуждения – из снимка исполнителя (ADR-0102), а не из текущих настроек
|
|
1029
|
+
'execution_id': execution['id'], 'provider_id': execution.get('provider_id'),
|
|
1030
|
+
'options': {**DEFAULT_OPTIONS, **options},
|
|
1031
|
+
# по сведениям сервера (семейство и возможности модели); у рассуждающей – предел по остатку окна
|
|
1032
|
+
'think': applied_think(think_rule, run['model'], {'details': {'family': selected_model.get('family') or ''},
|
|
1033
|
+
'capabilities': selected_model.get('capabilities')}),
|
|
1034
|
+
'think_limit': thinking_limit(execution, applied_think(
|
|
1035
|
+
think_rule, run['model'], {'details': {'family': selected_model.get('family') or ''},
|
|
1036
|
+
'capabilities': selected_model.get('capabilities')}))[0],
|
|
1037
|
+
'gpu': hardware, 'host_memory_total': (host.get('memory') or {}).get('total_bytes') if host.get('status') == 'fresh' else None,
|
|
1038
|
+
'host_status': host.get('status'),
|
|
1039
|
+
'code_revisions': self.db.revisions(project['id']),
|
|
1040
|
+
})
|
|
1041
|
+
slow_state = self._slow_state(run, execution) # ориентир: ответы прогона и прошлых прогонов того же исполнителя
|
|
1042
|
+
|
|
1043
|
+
def waiting_cancelled() -> bool: # ожидание права на генерацию прерывают остановка, «Пауза» и «Стоп»
|
|
1044
|
+
with self._lock:
|
|
1045
|
+
return halt.is_set() or run_id in self._controls
|
|
1046
|
+
|
|
1047
|
+
while True:
|
|
1048
|
+
if self._apply_control(run_id):
|
|
1049
|
+
return
|
|
1050
|
+
if halt.is_set():
|
|
1051
|
+
self._finish(run_id, "paused", "Приложение остановлено, прогон на паузе.")
|
|
1052
|
+
return
|
|
1053
|
+
item = self.db.next_pending_item(run_id)
|
|
1054
|
+
if item is None:
|
|
1055
|
+
self._finish(run_id, "done")
|
|
1056
|
+
return
|
|
1057
|
+
# право на генерацию – на всю находку (ADR-0099): вопрос к модели в это время получает отказ, а начатый
|
|
1058
|
+
# вопрос находка дожидается
|
|
1059
|
+
if not gate.acquire("triage", waiting_cancelled):
|
|
1060
|
+
if self._apply_control(run_id):
|
|
1061
|
+
return
|
|
1062
|
+
if halt.is_set():
|
|
1063
|
+
self._finish(run_id, "paused", "Приложение остановлено, прогон на паузе.")
|
|
1064
|
+
return
|
|
1065
|
+
continue # команду успели отменить («Продолжить» после «Пауза») – ждать права снова
|
|
1066
|
+
refused, busy_note = "", DB_BUSY_PAUSE
|
|
1067
|
+
try:
|
|
1068
|
+
problem = self._process_item(run, client, item, settings, execution)
|
|
1069
|
+
except BUSY_ERRORS as e:
|
|
1070
|
+
if isinstance(e, CommitUnknown):
|
|
1071
|
+
busy_note = DB_UNKNOWN_PAUSE
|
|
1072
|
+
log_failure(log, "результат находки неизвестен: связь с базой оборвалась (прогон %s)", e, run_id)
|
|
1073
|
+
else:
|
|
1074
|
+
log_failure(log, "результат находки не записан: база занята (прогон %s)", e, run_id)
|
|
1075
|
+
busy = True
|
|
1076
|
+
except SendNotAllowed as e: # профиль выключили во время прогона: запрос не ушёл, находка в очереди
|
|
1077
|
+
busy, problem, refused = False, "", pause_text(e)
|
|
1078
|
+
else:
|
|
1079
|
+
busy = False
|
|
1080
|
+
finally:
|
|
1081
|
+
gate.release()
|
|
1082
|
+
if refused:
|
|
1083
|
+
self._set_live(run_id, since=None)
|
|
1084
|
+
self._finish(run_id, "paused", refused)
|
|
1085
|
+
return
|
|
1086
|
+
if busy: # незавершённую находку «Продолжить» возьмёт снова, завершённую при потерянном ответе – нет
|
|
1087
|
+
self._set_live(run_id, since=None)
|
|
1088
|
+
self._pause_after_db_failure(run_id, busy_note)
|
|
1089
|
+
return
|
|
1090
|
+
self._set_live(run_id, since=None) # время находки уже учтено в длительности прогона
|
|
1091
|
+
if problem: # сервер не отвечает (или 402 у провайдера): находка остаётся в очереди, стоп важнее паузы
|
|
1092
|
+
self._finish(run_id, "paused", f"{problem} {pause_note(execution)}")
|
|
1093
|
+
return
|
|
1094
|
+
drop_note = self._drop_pause.pop(run_id, "")
|
|
1095
|
+
if drop_note: # каскад обрывов у провайдера: находка записана, дальше – пауза, а не новые запросы
|
|
1096
|
+
self._drops.pop(run_id, None)
|
|
1097
|
+
self._finish(run_id, "paused", drop_note)
|
|
1098
|
+
return
|
|
1099
|
+
if self._apply_control(run_id):
|
|
1100
|
+
return
|
|
1101
|
+
if slow_state.reload_pending and not halt.is_set():
|
|
1102
|
+
# Выгрузка – между находками: запрос к модели уже закончен, следующий загрузит её заново; выгрузка –
|
|
1103
|
+
# тоже обращение к модели и не должна прийтись на ответ на вопрос
|
|
1104
|
+
if gate.acquire("triage", waiting_cancelled):
|
|
1105
|
+
try:
|
|
1106
|
+
self._reload_slow_model(run, client, slow_state, halt)
|
|
1107
|
+
finally:
|
|
1108
|
+
gate.release()
|
|
1109
|
+
if self._apply_control(run_id):
|
|
1110
|
+
return
|
|
1111
|
+
|
|
1112
|
+
def _count_drop(self, run: Mapping[str, Any], dropped: bool) -> None:
|
|
1113
|
+
"""Учёт обрывов без ответа у внешнего провайдера: находка с обрывом (даже если повтор ответил) продолжает
|
|
1114
|
+
серию, находка с ответом её прерывает. Серия DROP_STREAK_PAUSE подряд или больше DROP_SHARE_PAUSE прогона
|
|
1115
|
+
(но не меньше DROP_STREAK_PAUSE обрывов) – прогон встанет на паузу после этой находки (повтор не должен
|
|
1116
|
+
становиться бесконечным)."""
|
|
1117
|
+
run_id = int(run["id"])
|
|
1118
|
+
counts = self._drops.setdefault(run_id, {"drops": 0, "streak": 0, "done": 0})
|
|
1119
|
+
counts["done"] += 1
|
|
1120
|
+
if not dropped:
|
|
1121
|
+
counts["streak"] = 0
|
|
1122
|
+
return
|
|
1123
|
+
counts["drops"] += 1
|
|
1124
|
+
counts["streak"] += 1
|
|
1125
|
+
share = counts["drops"] > DROP_SHARE_PAUSE * max(1, int(run.get("total") or 0))
|
|
1126
|
+
if counts["streak"] >= DROP_STREAK_PAUSE or (counts["drops"] >= DROP_STREAK_PAUSE and share):
|
|
1127
|
+
self._drop_pause[run_id] = DROP_PAUSE_NOTE.format(drops=counts["drops"], done=counts["done"],
|
|
1128
|
+
streak=counts["streak"])
|
|
1129
|
+
|
|
1130
|
+
@staticmethod
|
|
1131
|
+
def _model_entry(client: OllamaClient, model: str) -> dict[str, Any]:
|
|
1132
|
+
"""Запись /api/tags о модели, которая сейчас лежит на сервере под этим именем: digest весов (ADR-0084) и
|
|
1133
|
+
семейство (уровень рассуждения, ADR-0102); сведения недоступны – {}."""
|
|
1134
|
+
try:
|
|
1135
|
+
return dict(client.model_info(model))
|
|
1136
|
+
except LlmError:
|
|
1137
|
+
return {}
|
|
1138
|
+
|
|
1139
|
+
@staticmethod
|
|
1140
|
+
def _model_digest(client: OllamaClient, model: str, run: dict) -> str:
|
|
1141
|
+
"""Digest весов модели, которые сейчас лежат в Ollama под этим именем (ADR-0084); сведения недоступны –
|
|
1142
|
+
пусто: ключ кэша тогда без digest, отправка всё равно проверит модель перед запросом."""
|
|
1143
|
+
try:
|
|
1144
|
+
return str(client.model_info(model).get("digest") or "")
|
|
1145
|
+
except LlmError:
|
|
1146
|
+
return ""
|
|
1147
|
+
|
|
1148
|
+
def _process_item(self, run: dict, client: OllamaClient, item: dict, settings: Settings | None = None,
|
|
1149
|
+
execution: Mapping[str, Any] | None = None) -> str:
|
|
1150
|
+
"""Одна находка прогона. Возвращает текст ошибки, если Ollama перестала отвечать, иначе "".
|
|
1151
|
+
settings – действующие настройки прогона (папки клонов); execution – снимок исполнителя (ADR-0102): параметры
|
|
1152
|
+
генерации, правило уровня рассуждения и режим схемы ответа. SendNotAllowed (профиль выключен перед
|
|
1153
|
+
отправкой) поднимается выше: прогон встаёт на паузу."""
|
|
1154
|
+
settings = settings or self.settings
|
|
1155
|
+
if execution is None:
|
|
1156
|
+
execution = self.db.get_execution(run.get("execution_id"))
|
|
1157
|
+
if execution is None:
|
|
1158
|
+
raise SendNotAllowed("У прогона нет снимка исполнителя: запрос к модели не отправлен.")
|
|
1159
|
+
run_id, item_id, hub_id = int(run["id"]), int(item["id"]), str(item["hub_id"])
|
|
1160
|
+
project_id = int(run["project_id"])
|
|
1161
|
+
started = time.monotonic()
|
|
1162
|
+
# Находка, папка проекта и папка клона – одним снимком на каждую находку: их могли поменять во время
|
|
1163
|
+
# прогона. Результат привязывается, только если снимок к моменту сохранения не устарел (save_case).
|
|
1164
|
+
source = self.db.case_input(project_id, hub_id)
|
|
1165
|
+
if source is None or source.get("missing"):
|
|
1166
|
+
self.db.finish_item(run_id, item_id, "skipped", error="Находки нет в текущей выгрузке.")
|
|
1167
|
+
return ""
|
|
1168
|
+
f = Finding.from_dict(source["data"])
|
|
1169
|
+
self._set_live(run_id, hub_id=hub_id, finding_id=source["finding_id"], phase="context", since=time.time(),
|
|
1170
|
+
request_started_at=None,last_model_event_at=None,attempt=None)
|
|
1171
|
+
model = str(run["model"])
|
|
1172
|
+
options, _, think_rule = snapshot_options(execution)
|
|
1173
|
+
schema_mode = str(execution.get("schema_mode") or settings.model_json_schema)
|
|
1174
|
+
try:
|
|
1175
|
+
repo_dir, why = repo_dir_for(settings, {"repos_dir": source["repos_dir"]}, source_codebases(source, f), f)
|
|
1176
|
+
max_chars = CONTEXT_CHARS
|
|
1177
|
+
# Клона нет (или в нём нет файла находки), а срез с кодом сохранён – модель разбирает его (ADR-0072):
|
|
1178
|
+
# срез из одной строки выгрузки не должен затереть код, который уже в базе
|
|
1179
|
+
stored = self.db.get_case(project_id, hub_id)
|
|
1180
|
+
snapshot = snapshot_code(settings, source, stored)
|
|
1181
|
+
if snapshot is not None:
|
|
1182
|
+
ctx = snapshot[0]
|
|
1183
|
+
max_chars = int((stored or {}).get("context", {}).get("max_chars") or CONTEXT_CHARS)
|
|
1184
|
+
else:
|
|
1185
|
+
ctx = build_context(repo_dir, f, max_chars=max_chars, mask_key=self._mask_key, no_repo_note=why)
|
|
1186
|
+
except BUSY_ERRORS:
|
|
1187
|
+
raise
|
|
1188
|
+
except Exception as e:
|
|
1189
|
+
eid = log_failure(log, "контекст находки не собран (прогон %s)", e, run_id)
|
|
1190
|
+
self.db.finish_item(run_id, item_id, "error", error=failure_text("Не удалось собрать контекст", e, eid))
|
|
1191
|
+
return ""
|
|
1192
|
+
if snapshot is None and degrades(stored, ctx):
|
|
1193
|
+
# Полноценный срез в базе не заменяется строкой выгрузки (ADR-0072): ни срезом, ни кэшем, ни ответом
|
|
1194
|
+
self._keep_slice(settings, source, stored, project_id, hub_id)
|
|
1195
|
+
self.db.finish_item(run_id, item_id, "skipped", error=CLONE_GONE_NOTE)
|
|
1196
|
+
return ""
|
|
1197
|
+
|
|
1198
|
+
def store(chash: str, verdict_id: int | None, from_saved: bool = False, **measures: Any) -> bool | None:
|
|
1199
|
+
"""Срез и привязка к вердикту; сбой записи – ошибка этой находки, а не прогона (None). max_chars –
|
|
1200
|
+
размер среза: карточка соберёт текущий код так же и сравнит с тем, что видела модель."""
|
|
1201
|
+
try:
|
|
1202
|
+
return retry_busy(lambda: self.db.save_case(project_id, hub_id, chash,
|
|
1203
|
+
{**case_context(f, ctx), "max_chars": max_chars},
|
|
1204
|
+
verdict_id, source, no_downgrade=True,
|
|
1205
|
+
from_snapshot=snapshot is not None or from_saved))
|
|
1206
|
+
except BUSY_ERRORS:
|
|
1207
|
+
raise
|
|
1208
|
+
except Exception as e:
|
|
1209
|
+
eid = log_failure(log, "срез находки не сохранён (прогон %s)", e, run_id)
|
|
1210
|
+
self.db.finish_item(run_id, item_id, "error", case_hash=chash,
|
|
1211
|
+
error=failure_text("Не удалось сохранить срез", e, eid), **measures)
|
|
1212
|
+
return None
|
|
1213
|
+
|
|
1214
|
+
for attempt in range(FIT_ATTEMPTS + 1):
|
|
1215
|
+
chash = case_hash(f, ctx)
|
|
1216
|
+
if not ctx.lines:
|
|
1217
|
+
linked = store(chash, None)
|
|
1218
|
+
if linked is not None:
|
|
1219
|
+
self.db.finish_item(run_id, item_id, "skipped", case_hash=chash,
|
|
1220
|
+
error=f"Нет кода для разбора: {ctx.note or ctx.status}." if linked
|
|
1221
|
+
else CHANGED_NOTE)
|
|
1222
|
+
return ""
|
|
1223
|
+
current = (stored or {}).get("verdict") or {}
|
|
1224
|
+
if (not run["fresh"] and stored and stored.get("verdict_id") and stored.get("case_hash") == chash
|
|
1225
|
+
and current.get("prompt_version") == PROMPT_VERSION):
|
|
1226
|
+
# У находки уже есть вердикт по этому же коду (в том числе «второе мнение» другой модели): обычный
|
|
1227
|
+
# прогон его не заменяет ответом из кэша – иначе решение по нему потеряло бы «Проверено». Решение
|
|
1228
|
+
# принято по другому коду (код вернулся к срезу модели, бэклог 114) – отметка снимается; только когда
|
|
1229
|
+
# срез построен по клону: подставленный сохранённый срез (клона нет) не доказывает смену кода (ADR-0072)
|
|
1230
|
+
if snapshot is None:
|
|
1231
|
+
retry_busy(lambda h=chash, n=max_chars: self.db.reopen_for_decision_code(project_id, hub_id, h, n,
|
|
1232
|
+
source))
|
|
1233
|
+
self.db.finish_item(run_id, item_id, "cached", case_hash=chash, verdict_id=stored["verdict_id"],
|
|
1234
|
+
seconds=time.monotonic() - started)
|
|
1235
|
+
return ""
|
|
1236
|
+
try:
|
|
1237
|
+
# mask_key: строка срабатывания из выгрузки попадает в промпт только маскированной
|
|
1238
|
+
messages = self._masked(build_sast_messages(f, ctx, mask_key=self._mask_key))
|
|
1239
|
+
except Exception as e:
|
|
1240
|
+
eid = log_failure(log, "промпт не собран (прогон %s)", e, run_id)
|
|
1241
|
+
# срез всё равно сохраняется: если код изменился, прежний вердикт к нему уже не относится
|
|
1242
|
+
if store(chash, None) is not None:
|
|
1243
|
+
self.db.finish_item(run_id, item_id, "error", case_hash=chash,
|
|
1244
|
+
error=failure_text("Не удалось собрать промпт", e, eid))
|
|
1245
|
+
return ""
|
|
1246
|
+
# Кэш по запросу целиком (ADR-0027, ADR-0084): сообщения, параметры генерации, режим схемы и digest
|
|
1247
|
+
# весов модели, который сейчас лежит в Ollama под этим именем. Ответ на другой запрос или от других
|
|
1248
|
+
# весов не подставляется; в прогоне «заново» – только ответ на этот же запрос, полученный в нём же.
|
|
1249
|
+
# удалённый API отпечатка весов и сведений о рассуждении не отдаёт: запись модели не запрашивается – иначе
|
|
1250
|
+
# перед каждой находкой уходил лишний GET /models провайдеру; кэш по запросу у
|
|
1251
|
+
# внешнего провайдера и так не читается (нет digest), рассуждение gpt-oss определяется по имени
|
|
1252
|
+
remote = str((execution or {}).get("kind") or "ollama") in REMOTE_KINDS
|
|
1253
|
+
entry = {} if remote else self._model_entry(client, model)
|
|
1254
|
+
digest = str(entry.get("digest") or "")
|
|
1255
|
+
# уровень рассуждения – по модели, которая сейчас лежит на сервере под этим именем (ADR-0102): одно и то же
|
|
1256
|
+
# значение уходит в ключ кэша и в тело запроса
|
|
1257
|
+
think = applied_think(think_rule, model, entry or None)
|
|
1258
|
+
# на каждую отправку – то же значение (по нему предел, срок и ключ); изменилось – отказ без запроса
|
|
1259
|
+
think_per_send = planned_think(think_rule, model, think)
|
|
1260
|
+
# рассуждающий запрос (think true) – свой срок и предел ответа: остаток окна после промпта, не больше
|
|
1261
|
+
# предела рассуждения (срез подбирается под обычный предел – код у модели рассуждение не отнимает)
|
|
1262
|
+
think_limit, call_timeout = thinking_limit(execution, think)
|
|
1263
|
+
sent_options = fit_thinking(options, think_limit, messages) if think_limit else options
|
|
1264
|
+
rkey = request_key(model, messages, sent_options, think, PROMPT_VERSION, model_digest=digest,
|
|
1265
|
+
json_schema=schema_mode, provider=provider_key(execution))
|
|
1266
|
+
# веса не удалось определить – кэш по запросу не читается и не пополняется: неизвестные веса не
|
|
1267
|
+
# считаются совпавшими; у внешнего провайдера отпечатка весов нет никогда – кэша по ключу нет (П4),
|
|
1268
|
+
# каждый разбор – новый запрос
|
|
1269
|
+
external = str(execution.get("trust") or "") == "external"
|
|
1270
|
+
if not digest or external:
|
|
1271
|
+
cached = None
|
|
1272
|
+
elif run["fresh"]:
|
|
1273
|
+
cached = self.db.verdict_by_request_in_run(run_id, rkey)
|
|
1274
|
+
else:
|
|
1275
|
+
cached = self.db.find_verdict_by_request(rkey)
|
|
1276
|
+
if cached is not None:
|
|
1277
|
+
seconds = time.monotonic() - started
|
|
1278
|
+
linked = store(chash, cached["id"], seconds=seconds)
|
|
1279
|
+
if linked is not None:
|
|
1280
|
+
self.db.finish_item(run_id, item_id, "cached" if linked else "skipped", case_hash=chash,
|
|
1281
|
+
verdict_id=cached["id"] if linked else None,
|
|
1282
|
+
error="" if linked else CHANGED_NOTE, seconds=seconds)
|
|
1283
|
+
return ""
|
|
1284
|
+
# окно и предел ответа – того сервера, куда уйдёт запрос (у удалённого API – из профиля за вычетом схемы
|
|
1285
|
+
# ответа, которую клиент добавит к сообщениям; KIMI-01)
|
|
1286
|
+
fit = fit_options(execution, options, json_overhead(client, VERDICT_FIELDS, VERDICT_REQUIRED,
|
|
1287
|
+
VERDICT_ENUMS, VERDICT_TYPES))
|
|
1288
|
+
size = prompt_size(execution) # оценка длины – та же, что у клиента перед отправкой
|
|
1289
|
+
if attempt == FIT_ATTEMPTS or prompt_fits(messages, fit, size):
|
|
1290
|
+
break
|
|
1291
|
+
# Плотный код (знаки вне ASCII и кириллицы) не помещается в окно контекста: срез сокращается на нужную
|
|
1292
|
+
# долю с запасом, иначе Ollama обрезала бы начало промпта вместе с системным сообщением. Совсем
|
|
1293
|
+
# маленький срез не нужен: такой промпт chat_json отклонит с понятной ошибкой.
|
|
1294
|
+
excess = (size or prompt_tokens)(messages) - (prompt_budget(fit) or 0)
|
|
1295
|
+
code = "\n".join(ctx.lines)
|
|
1296
|
+
keep = max(0.0, 1.0 - excess / max(1, estimate_tokens(code))) * 0.9
|
|
1297
|
+
smaller = int((len(code) + 10 * len(ctx.lines)) * keep)
|
|
1298
|
+
if snapshot is not None:
|
|
1299
|
+
break # срез из базы без клона не пересобрать: если не помещается, ответит проверка длины промпта
|
|
1300
|
+
if smaller < MIN_CONTEXT_CHARS:
|
|
1301
|
+
if max_chars <= MIN_CONTEXT_CHARS:
|
|
1302
|
+
break # max_chars остаётся размером того среза, который уйдёт модели
|
|
1303
|
+
smaller = MIN_CONTEXT_CHARS # меньше не сокращаем, но и наименьший срез пробуем
|
|
1304
|
+
max_chars = smaller
|
|
1305
|
+
try:
|
|
1306
|
+
ctx = build_context(repo_dir, f, max_chars=max_chars, mask_key=self._mask_key, no_repo_note=why)
|
|
1307
|
+
except Exception as e:
|
|
1308
|
+
eid = log_failure(log, "контекст находки не собран (прогон %s)", e, run_id)
|
|
1309
|
+
self.db.finish_item(run_id, item_id, "error",
|
|
1310
|
+
error=failure_text("Не удалось собрать контекст", e, eid))
|
|
1311
|
+
return ""
|
|
1312
|
+
if degrades(stored, ctx): # файл пропал, пока срез сокращался
|
|
1313
|
+
self._keep_slice(settings, source, stored, project_id, hub_id)
|
|
1314
|
+
self.db.finish_item(run_id, item_id, "skipped", error=CLONE_GONE_NOTE)
|
|
1315
|
+
return ""
|
|
1316
|
+
# Новый срез – до обращения к модели: если код изменился, прежний вердикт к нему уже не относится
|
|
1317
|
+
# (save_case отвязывает его и снимает отметку «проверено»), даже если модель ответит ошибкой.
|
|
1318
|
+
linked = store(chash, None)
|
|
1319
|
+
if linked is None:
|
|
1320
|
+
return ""
|
|
1321
|
+
if not linked:
|
|
1322
|
+
self.db.finish_item(run_id, item_id, "skipped", case_hash=chash, error=CHANGED_NOTE)
|
|
1323
|
+
return ""
|
|
1324
|
+
self._set_live(run_id, phase="model")
|
|
1325
|
+
last_progress = [0.0]
|
|
1326
|
+
def progress(event):
|
|
1327
|
+
now=time.monotonic()
|
|
1328
|
+
if event['event']=='fragment':
|
|
1329
|
+
if now-last_progress[0]>=1:
|
|
1330
|
+
self._set_live(run_id,phase='generating',last_model_event_at=time.time())
|
|
1331
|
+
last_progress[0]=now
|
|
1332
|
+
elif event['event']=='request_started':
|
|
1333
|
+
last_progress[0]=0
|
|
1334
|
+
self._set_live(run_id,phase='waiting',request_started_at=time.time(),last_model_event_at=None,attempt=event['attempt'])
|
|
1335
|
+
elif event['event']=='response_done':self._set_live(run_id,phase='validating',last_model_event_at=time.time())
|
|
1336
|
+
if external:
|
|
1337
|
+
# К11: метка отправки – до сетевого вызова; перезапуск с меткой – «результат неизвестен», повтора нет
|
|
1338
|
+
self.db.mark_item_sending(run_id, item_id)
|
|
1339
|
+
try:
|
|
1340
|
+
# validate – проверка ответа по существу (пустой fix у истинной, комментарий для Hub без текста):
|
|
1341
|
+
# замечания ведут к повтору, как ответ не по формату. Контекст журнала обмена с моделью: обращения
|
|
1342
|
+
# внутри вызова (в том числе /api/tags перед отправкой кода) помечаются прогоном и находкой.
|
|
1343
|
+
with model_traffic.context(purpose="triage", run_id=run_id, hub_id=hub_id, project_id=project_id):
|
|
1344
|
+
client.timeout = call_timeout # срок одного обращения: у рассуждающего запроса – свой
|
|
1345
|
+
drop_error: LlmError | None = None
|
|
1346
|
+
while True:
|
|
1347
|
+
try:
|
|
1348
|
+
obj, stats = client.chat_json(model, messages, VERDICT_FIELDS, VERDICT_REQUIRED, VERDICT_ENUMS,
|
|
1349
|
+
options=sent_options, think=think_per_send, types=VERDICT_TYPES,
|
|
1350
|
+
validate=check_verdict_answer, progress=progress,
|
|
1351
|
+
json_schema=schema_mode)
|
|
1352
|
+
break
|
|
1353
|
+
except (SendNotAllowed, PromptOverflowError) as e:
|
|
1354
|
+
if drop_error is not None:
|
|
1355
|
+
# первый запрос оборвался (исход неизвестен), а повтор не ушёл: профиль выключен, отметка
|
|
1356
|
+
# снята, окно – находка остаётся «результат неизвестен», а не возвращается в очередь,
|
|
1357
|
+
# иначе «Продолжить» отправил бы её снова (ревью Codex, круг 18, блокирующее)
|
|
1358
|
+
raise _after_drop(drop_error, e) from e
|
|
1359
|
+
raise
|
|
1360
|
+
except LlmError as e:
|
|
1361
|
+
# обрыв без ответа у внешнего провайдера с отметкой профиля «Повторять после обрыва» – один
|
|
1362
|
+
# повтор на находку (ADR-0107); второй обрыв – «результат
|
|
1363
|
+
# неизвестен»; метка отправки стоит до конца: перезапуск между попытками – тоже «неизвестен»
|
|
1364
|
+
if (drop_error is None and external and outcome_unknown(e) and not getattr(e, "reason", None)
|
|
1365
|
+
and drop_retry_allowed(execution)):
|
|
1366
|
+
drop_error = e
|
|
1367
|
+
log.info("обрыв без ответа – автоматический повтор (прогон %s, находка %s)", run_id, hub_id)
|
|
1368
|
+
continue
|
|
1369
|
+
if drop_error is not None:
|
|
1370
|
+
if not model_answered(e) and not outcome_unknown(e):
|
|
1371
|
+
# повтор без ответа модели (402, ошибка сервера, сбой до отправки, кончились срок или
|
|
1372
|
+
# предел отправок – запрос не ушёл) – исход первого запроса по-прежнему неизвестен
|
|
1373
|
+
raise _after_drop(drop_error, e) from e
|
|
1374
|
+
e.drop_retries = 1 # type: ignore[attr-defined]
|
|
1375
|
+
e.stats = _merged_stats(drop_error.stats, e.stats)
|
|
1376
|
+
raise
|
|
1377
|
+
if drop_error is not None:
|
|
1378
|
+
# расход оборванной попытки – вместе с ответом повтора (ревью Codex, круг 18)
|
|
1379
|
+
stats = _merged_stats(drop_error.stats, stats)
|
|
1380
|
+
stats.drop_retries = 1
|
|
1381
|
+
if external:
|
|
1382
|
+
self._count_drop(run, drop_error is not None)
|
|
1383
|
+
except SendNotAllowed:
|
|
1384
|
+
# профиль выключен или отметка проекта снята перед отправкой (в том числе перед повтором – исход прежней
|
|
1385
|
+
# попытки известен): запрос не ушёл – метка снимается, находка остаётся в очереди, прогон – на паузу
|
|
1386
|
+
if external:
|
|
1387
|
+
self.db.mark_item_sending(run_id, item_id, sending=False)
|
|
1388
|
+
raise
|
|
1389
|
+
except PromptOverflowError as e:
|
|
1390
|
+
# Оценка длины промпта – эвристика с запасом (llm.estimate_tokens, llm.PROMPT_SAFETY_SHARE). Если сама
|
|
1391
|
+
# Ollama насчитала в промпте любой из попыток больше, чем помещается в окно вместе с ответом, начало
|
|
1392
|
+
# промпта могло быть обрезано вместе с системным сообщением: такому ответу не доверяем (chat_json).
|
|
1393
|
+
measures = self._measures(e.stats, time.monotonic() - started)
|
|
1394
|
+
# у удалённого API это отказ его клиента до отправки по окну профиля (запрос не ушёл, не оплачен): совет
|
|
1395
|
+
# про MODEL_NUM_CTX Ollama здесь ложный – текст клиента и совет про профиль
|
|
1396
|
+
remote_kind = str((execution or {}).get("kind") or "ollama") in REMOTE_KINDS
|
|
1397
|
+
text = f"{e} {REMOTE_WINDOW_NOTE}" if remote_kind and not getattr(e, "sent", False) else PROMPT_DOUBT_NOTE
|
|
1398
|
+
self.db.finish_item(run_id, item_id, "error", case_hash=chash, error=text, **measures)
|
|
1399
|
+
return ""
|
|
1400
|
+
except LlmError as e:
|
|
1401
|
+
partial = _stats_partial(e)
|
|
1402
|
+
if external and outcome_unknown(e):
|
|
1403
|
+
# К11: байты ушли, ответа нет (или он от посредника) – «результат неизвестен»: ошибка этой находки,
|
|
1404
|
+
# больше не отправляется (автоповтор после обрыва, если включён в профиле, уже был); метка снимается
|
|
1405
|
+
# вместе с записью результата
|
|
1406
|
+
measures = self._measures(e.stats, time.monotonic() - started)
|
|
1407
|
+
retry_error = str(getattr(e, "retry_error", "") or "")
|
|
1408
|
+
again = (f" Автоматический повтор после обрыва не получил ответа модели: {retry_error}" if retry_error
|
|
1409
|
+
else " Автоматический повтор после обрыва тоже остался без ответа."
|
|
1410
|
+
if getattr(e, "drop_retries", 0) else "")
|
|
1411
|
+
self.db.finish_item(run_id, item_id, "error", case_hash=chash,
|
|
1412
|
+
error=f"{UNKNOWN_RESULT_NOTE} {e}{again}", stats_partial=partial, **measures)
|
|
1413
|
+
self._count_drop(run, True)
|
|
1414
|
+
# повтор после обрыва получил 402: следующие находки тоже не примут – пауза по оплате, как без обрыва
|
|
1415
|
+
return PAYMENT_NOTE if getattr(e, "retry_status", None) == 402 else ""
|
|
1416
|
+
if external and getattr(e, "reason", None):
|
|
1417
|
+
# ответ получен: серия обрывов прервана, если обрыва не было; обрыв, после которого повтор получил
|
|
1418
|
+
# известный отказ, – тоже обрыв (ревью Codex, круг 18)
|
|
1419
|
+
self._count_drop(run, bool(getattr(e, "drop_retries", 0)))
|
|
1420
|
+
if getattr(e, "reason", None):
|
|
1421
|
+
# известный окончательный исход (ответ получен и разобран, ADR-0106): находка – ошибка сразу, с
|
|
1422
|
+
# расходом ответа; служебный опрос сервера не нужен – его сбой не оставит находку в очереди и не
|
|
1423
|
+
# отправит её заново после «Продолжить» (ревью круг 15, находка 1); метка отправки снимается записью
|
|
1424
|
+
measures = self._measures(e.stats, time.monotonic() - started)
|
|
1425
|
+
self.db.finish_item(run_id, item_id, "error", case_hash=chash,
|
|
1426
|
+
error=str(e) + (PARTIAL_NOTE if partial else ""), stats_partial=partial, **measures)
|
|
1427
|
+
return ""
|
|
1428
|
+
if external and getattr(e, "status", None) == 402:
|
|
1429
|
+
# нужна оплата: запрос провайдер не принял – метка снимается, находка остаётся в очереди, прогон –
|
|
1430
|
+
# на паузу с причиной
|
|
1431
|
+
self.db.mark_item_sending(run_id, item_id, sending=False)
|
|
1432
|
+
return PAYMENT_NOTE
|
|
1433
|
+
if not self._server_alive(client):
|
|
1434
|
+
if external: # ответ сервера был (или запрос не ушёл) – исход известен, метка снимается
|
|
1435
|
+
self.db.mark_item_sending(run_id, item_id, sending=False)
|
|
1436
|
+
return str(e)
|
|
1437
|
+
# Модель могла сгенерировать ответ не по формату: её токены и время входят в среднюю скорость
|
|
1438
|
+
# прогона; после сбоя связи замеры прерванной попытки неизвестны – находка помечается
|
|
1439
|
+
measures = self._measures(e.stats, time.monotonic() - started)
|
|
1440
|
+
self.db.finish_item(run_id, item_id, "error", case_hash=chash,
|
|
1441
|
+
error=str(e) + (PARTIAL_NOTE if partial else ""), stats_partial=partial, **measures)
|
|
1442
|
+
return ""
|
|
1443
|
+
eta_sample = self._observe_speed(run, stats)
|
|
1444
|
+
self._set_live(run_id, phase='saving')
|
|
1445
|
+
seconds = time.monotonic() - started
|
|
1446
|
+
measures = self._measures(stats, seconds)
|
|
1447
|
+
try:
|
|
1448
|
+
# срез, который видела модель (в том же представлении, что в промпте): номера строк-доказательств вне
|
|
1449
|
+
# него отбрасываются, при сверке differs уверенность ограничена (ADR-0080)
|
|
1450
|
+
verdict = parse_verdict(obj, export_fragment_view(f, ctx))
|
|
1451
|
+
except Exception as e: # неожиданный сбой разбора ответа – ошибка этой находки, прогон идёт дальше
|
|
1452
|
+
eid = log_failure(log, "ответ модели не разобран (прогон %s)", e, run_id)
|
|
1453
|
+
self.db.finish_item(run_id, item_id, "error", case_hash=chash,
|
|
1454
|
+
error=failure_text("Ответ модели не разобран", e, eid), **measures)
|
|
1455
|
+
return ""
|
|
1456
|
+
# последняя проверка перед сохранением – после всей нормализации вердикта (сервер с ключом мог вернуть его)
|
|
1457
|
+
if model_traffic.shows_secret([verdict.to_dict(), stats.to_dict()], getattr(client, "secrets", ())):
|
|
1458
|
+
self.db.finish_item(run_id, item_id, "error", case_hash=chash, error=model_traffic.KEY_IN_ANSWER,
|
|
1459
|
+
**measures)
|
|
1460
|
+
return ""
|
|
1461
|
+
try:
|
|
1462
|
+
# веса под этим именем сменились, пока модель отвечала, – ответ не кладётся под ключ прежних весов;
|
|
1463
|
+
# ответ на повтор (замечание о формате, другой seed) – ответ на другой запрос, под ключ первого не кладётся;
|
|
1464
|
+
# сервер отверг схему ответа – запрос ушёл без неё, под ключ со схемой тоже не кладётся
|
|
1465
|
+
dropped = getattr(client, "schema_dropped", None)
|
|
1466
|
+
saved_key = rkey if (digest and stats.attempts == 1 and not (callable(dropped) and dropped())
|
|
1467
|
+
and self._model_digest(client, model, run) == digest) else ""
|
|
1468
|
+
reserved = retry_busy(self.db.reserve_verdict_id)
|
|
1469
|
+
verdict_id = retry_busy(lambda: self.db.save_verdict(chash, model, PROMPT_VERSION, verdict.to_dict(),
|
|
1470
|
+
stats.to_dict(), request_key=saved_key,
|
|
1471
|
+
execution_id=int(execution["id"]),
|
|
1472
|
+
verdict_id=reserved))
|
|
1473
|
+
except BUSY_ERRORS:
|
|
1474
|
+
raise # занятая база – пауза прогона, находка остаётся в очереди (Э2)
|
|
1475
|
+
except Exception as e: # сбой записи – ошибка этой находки, а не всего прогона
|
|
1476
|
+
eid = log_failure(log, "вердикт не сохранён (прогон %s)", e, run_id)
|
|
1477
|
+
self.db.finish_item(run_id, item_id, "error", case_hash=chash,
|
|
1478
|
+
error=failure_text("Не удалось сохранить вердикт", e, eid), **measures)
|
|
1479
|
+
return ""
|
|
1480
|
+
# Пока модель отвечала, код в клоне могли поменять (правки в рабочей копии, git pull): ответ сохранён в кэше
|
|
1481
|
+
# для того кода, который она видела, но к находке не привязывается – иначе он выглядел бы действующим.
|
|
1482
|
+
# клон удалили, пока модель отвечала: поздняя сверка берёт сохранённый срез – и сохранение знает об этом,
|
|
1483
|
+
# подставленный срез сменой кода не считается (ADR-0072, ревью Codex ветки долга, круг 4)
|
|
1484
|
+
late_saved = {"used": False}
|
|
1485
|
+
|
|
1486
|
+
def late_snapshot():
|
|
1487
|
+
got = snapshot_code(settings, source, self.db.get_case(project_id, hub_id))
|
|
1488
|
+
late_saved["used"] = got is not None
|
|
1489
|
+
return got
|
|
1490
|
+
|
|
1491
|
+
if snapshot is None and self._code_changed(f, repo_dir, max_chars, chash, late_snapshot):
|
|
1492
|
+
self.db.finish_item(run_id, item_id, "skipped", case_hash=chash, error=CODE_CHANGED_NOTE, **measures)
|
|
1493
|
+
return ""
|
|
1494
|
+
linked = store(chash, verdict_id, from_saved=late_saved["used"], **measures)
|
|
1495
|
+
if linked is None:
|
|
1496
|
+
return ""
|
|
1497
|
+
if linked:
|
|
1498
|
+
# после обрыва замеры неполные: что модель успела сгенерировать в оборванной попытке, неизвестно; время
|
|
1499
|
+
# находки с повтором – не образец для оценки оставшегося
|
|
1500
|
+
retry_busy(lambda: self.db.finish_item(run_id, item_id, "done", case_hash=chash, verdict_id=verdict_id,
|
|
1501
|
+
eta_sample=eta_sample and not stats.drop_retries,
|
|
1502
|
+
stats_partial=bool(stats.drop_retries), **measures))
|
|
1503
|
+
else:
|
|
1504
|
+
retry_busy(lambda: self.db.finish_item(run_id, item_id, "skipped", case_hash=chash, error=CHANGED_NOTE,
|
|
1505
|
+
**measures))
|
|
1506
|
+
return ""
|
|
1507
|
+
|
|
1508
|
+
# ---------------------------------------------------------------- медленный режим модели
|
|
1509
|
+
|
|
1510
|
+
@staticmethod
|
|
1511
|
+
def _refused(guard: Callable[[], None]) -> str:
|
|
1512
|
+
"""Текст паузы, если допуск профиля снимка уже не действует ("" – действует): сбой перед первой отправкой
|
|
1513
|
+
сначала сверяется с допуском (ADR-0102), чтобы выключенный профиль давал паузу, а не ошибку."""
|
|
1514
|
+
try:
|
|
1515
|
+
guard()
|
|
1516
|
+
except SendNotAllowed as e:
|
|
1517
|
+
return pause_text(e)
|
|
1518
|
+
return ""
|
|
1519
|
+
|
|
1520
|
+
def _slow_state(self, run: dict, execution: Mapping[str, Any] | None = None) -> _SlowState:
|
|
1521
|
+
"""Состояние замедления прогона: ответы текущего прогона из базы, медиана прошлых прогонов той же конфигурации
|
|
1522
|
+
исполнителя (протокол, адрес, модель – ADR-0102, П24) и записанные в журнал перезагрузки. Читается один раз
|
|
1523
|
+
за прогон; продолжение после паузы берёт готовое. Выгружать модель можно, только если снимок это разрешает."""
|
|
1524
|
+
run_id = int(run["id"])
|
|
1525
|
+
state = self._slow.get(run_id)
|
|
1526
|
+
if state is not None:
|
|
1527
|
+
return state
|
|
1528
|
+
state = _SlowState()
|
|
1529
|
+
if execution is None:
|
|
1530
|
+
execution = self.db.get_execution(run.get("execution_id"))
|
|
1531
|
+
state.unload_allowed = unload_allowed_of(execution)
|
|
1532
|
+
executor = (str(execution["kind"]), str(execution["base_url"])) if execution else None
|
|
1533
|
+
try:
|
|
1534
|
+
state.samples = self.db.run_tps_samples(run_id, SLOW_BASELINE_WINDOW)
|
|
1535
|
+
history = self.db.model_tps_samples(str(run["model"]), exclude_run_id=run_id, limit=SLOW_HISTORY_WINDOW,
|
|
1536
|
+
executor=executor)
|
|
1537
|
+
state.history_median = _median(history) if len(history) >= SLOW_BASELINE_MIN else None
|
|
1538
|
+
state.history_typical = _median(history)
|
|
1539
|
+
state.history_fast = any(value > SLOW_TPS_KNOWN_FAST for value in history)
|
|
1540
|
+
from app import journal
|
|
1541
|
+
saved = journal.slow_model_state(self.db, run_id)
|
|
1542
|
+
state.reloads = int(saved.get("reloads") or 0)
|
|
1543
|
+
state.text = str(saved.get("text") or "")
|
|
1544
|
+
state.warning = bool(saved.get("warning"))
|
|
1545
|
+
except Exception as e:
|
|
1546
|
+
log_failure(log, "состояние медленного режима не прочитано (прогон %s)", e, run_id)
|
|
1547
|
+
self._slow[run_id] = state
|
|
1548
|
+
return state
|
|
1549
|
+
|
|
1550
|
+
def _observe_speed(self, run: dict, stats: Any) -> bool:
|
|
1551
|
+
"""Учесть скорость законченного ответа. True – ответ годится для оценки оставшегося времени, False –
|
|
1552
|
+
медленный ответ (до перезагрузки) или первый ответ после загрузки модели. При медленном режиме
|
|
1553
|
+
помечает перезагрузку (её выполнит _reload_slow_model между находками) или записывает предупреждение.
|
|
1554
|
+
"""
|
|
1555
|
+
tps = float(getattr(stats, "eval_tps", 0) or 0)
|
|
1556
|
+
if tps <= 0:
|
|
1557
|
+
return True
|
|
1558
|
+
state = self._slow_state(run)
|
|
1559
|
+
previous = state.samples[-SLOW_BASELINE_WINDOW:]
|
|
1560
|
+
reference = _median(previous) if len(previous) >= SLOW_BASELINE_MIN else state.history_median
|
|
1561
|
+
baseline = reference if reference is not None else (state.history_typical or tps)
|
|
1562
|
+
first_after_reload = state.after_reload
|
|
1563
|
+
state.after_reload = False
|
|
1564
|
+
if first_after_reload: # загрузка модели после перезагрузки: ответ не показатель режима
|
|
1565
|
+
state.streak = 0
|
|
1566
|
+
return False
|
|
1567
|
+
if reference is not None and reference > 0:
|
|
1568
|
+
slow = tps < reference * SLOW_TPS_SHARE
|
|
1569
|
+
elif state.history_fast:
|
|
1570
|
+
# Ориентира ещё нет: у моделей, которые раньше давали больше SLOW_TPS_KNOWN_FAST, два ответа
|
|
1571
|
+
# подряд ниже абсолютного порога уже говорят о медленном режиме.
|
|
1572
|
+
slow = tps < SLOW_TPS_ABSOLUTE
|
|
1573
|
+
else:
|
|
1574
|
+
slow = False
|
|
1575
|
+
if not slow:
|
|
1576
|
+
# Ориентир – медиана успешных ответов обычной скорости: медленные ответы её не сдвигают вниз,
|
|
1577
|
+
# иначе после первой же перезагрузки стало бы «нормально» медленно.
|
|
1578
|
+
state.samples.append(tps)
|
|
1579
|
+
state.samples = state.samples[-SLOW_BASELINE_WINDOW:]
|
|
1580
|
+
state.streak = 0
|
|
1581
|
+
return True
|
|
1582
|
+
state.streak += 1
|
|
1583
|
+
if state.streak < SLOW_STREAK:
|
|
1584
|
+
return False # медленный, но серия ещё не набрана: в оценку времени всё равно не берём
|
|
1585
|
+
state.streak = 0
|
|
1586
|
+
if state.reloads < SLOW_MAX_RELOADS and state.unload_allowed:
|
|
1587
|
+
state.reload_pending = True
|
|
1588
|
+
state.pending_tps = tps
|
|
1589
|
+
state.pending_baseline = baseline
|
|
1590
|
+
elif not state.warning:
|
|
1591
|
+
state.warning = True
|
|
1592
|
+
state.text = slow_model_status_text(tps, baseline, reloaded=False)
|
|
1593
|
+
if not state.unload_allowed: # общий сервер: выгружать модель профиль не разрешает (ADR-0102 п. 9)
|
|
1594
|
+
state.text += " Выгрузка модели на этом сервере не разрешена профилем."
|
|
1595
|
+
self._record_slow_event(run, "warning", tps, baseline, state)
|
|
1596
|
+
log.info("прогон %s: медленный режим модели не исправлен двумя перезагрузками (%s ток/с при обычных %s)",
|
|
1597
|
+
int(run["id"]), _tps_number(tps), _tps_number(baseline))
|
|
1598
|
+
return False
|
|
1599
|
+
|
|
1600
|
+
def _reload_slow_model(self, run: dict, client: OllamaClient, state: _SlowState,
|
|
1601
|
+
halt: threading.Event) -> None:
|
|
1602
|
+
"""Выгрузить модель (keep_alive 0) и дождаться, что /api/ps её больше не показывает. Следующий запрос
|
|
1603
|
+
загрузит модель заново. Сбой выгрузки не останавливает прогон: предупреждение остаётся оператору."""
|
|
1604
|
+
run_id, project_id, model = int(run["id"]), int(run["project_id"]), str(run["model"])
|
|
1605
|
+
|
|
1606
|
+
def interrupted() -> bool:
|
|
1607
|
+
with self._lock:
|
|
1608
|
+
return halt.is_set() or run_id in self._controls
|
|
1609
|
+
|
|
1610
|
+
if not state.reload_pending or state.reloads >= SLOW_MAX_RELOADS or interrupted():
|
|
1611
|
+
return
|
|
1612
|
+
state.reload_pending = False
|
|
1613
|
+
tps, baseline = state.pending_tps, state.pending_baseline
|
|
1614
|
+
state.reloads += 1 # ошибка и прерванное ожидание тоже расходуют попытку
|
|
1615
|
+
try:
|
|
1616
|
+
with model_traffic.context(purpose="reload", run_id=run_id, project_id=project_id):
|
|
1617
|
+
client.unload_model(model)
|
|
1618
|
+
self._wait_unloaded(client, model, interrupted)
|
|
1619
|
+
except LlmError as e:
|
|
1620
|
+
state.warning = True
|
|
1621
|
+
state.text = f"Модель работала медленно – перезагрузить модель не удалось: {e}"
|
|
1622
|
+
self._record_slow_event(run, "warning", tps, baseline, state)
|
|
1623
|
+
log_failure(log, "модель не выгружена для перезагрузки (прогон %s)", e, run_id)
|
|
1624
|
+
return
|
|
1625
|
+
state.after_reload = True
|
|
1626
|
+
state.streak = 0
|
|
1627
|
+
state.warning = False
|
|
1628
|
+
state.text = slow_model_status_text(tps, baseline, reloaded=True)
|
|
1629
|
+
self._record_slow_event(run, "reload", tps, baseline, state)
|
|
1630
|
+
log.info("прогон %s: медленный режим модели (%s ток/с при обычных %s), модель выгружена",
|
|
1631
|
+
run_id, _tps_number(tps), _tps_number(baseline))
|
|
1632
|
+
|
|
1633
|
+
def _record_slow_event(self, run: dict, action: str, tps: float, baseline: float, state: _SlowState) -> None:
|
|
1634
|
+
"""Событие медленного режима – в журнал прогона (страница «Журнал»). Сбой записи не мешает разбору."""
|
|
1635
|
+
try:
|
|
1636
|
+
from app import journal
|
|
1637
|
+
journal.slow_model_event(self.db, int(run["id"]), action=action, tps=tps, baseline=baseline,
|
|
1638
|
+
text=state.text, reloads=state.reloads)
|
|
1639
|
+
except Exception as e:
|
|
1640
|
+
log_failure(log, "событие медленного режима не записано (прогон %s)", e, int(run["id"]))
|
|
1641
|
+
|
|
1642
|
+
@staticmethod
|
|
1643
|
+
def _wait_unloaded(client: OllamaClient, model: str, interrupted: Callable[[], bool]) -> None:
|
|
1644
|
+
"""Подтвердить выгрузку через /api/ps. Ошибка, истёкший срок и команда управления – не успех.
|
|
1645
|
+
Команды проверяются между опросами и сразу после ответа сервера."""
|
|
1646
|
+
wanted = norm_model_name(model)
|
|
1647
|
+
deadline = time.monotonic() + SLOW_RELOAD_WAIT_S
|
|
1648
|
+
while True:
|
|
1649
|
+
if interrupted():
|
|
1650
|
+
raise LlmError("ожидание выгрузки прервано командой управления.")
|
|
1651
|
+
if time.monotonic() >= deadline:
|
|
1652
|
+
raise LlmError(f"Ollama не подтвердила выгрузку за {SLOW_RELOAD_WAIT_S:g} с.")
|
|
1653
|
+
loaded = {norm_model_name(str(entry.get("name") or "")) for entry in client.ps()}
|
|
1654
|
+
if interrupted():
|
|
1655
|
+
raise LlmError("ожидание выгрузки прервано командой управления.")
|
|
1656
|
+
if time.monotonic() >= deadline:
|
|
1657
|
+
raise LlmError(f"Ollama не подтвердила выгрузку за {SLOW_RELOAD_WAIT_S:g} с.")
|
|
1658
|
+
if wanted not in loaded:
|
|
1659
|
+
return
|
|
1660
|
+
time.sleep(min(SLOW_RELOAD_POLL_S, max(0.0, deadline - time.monotonic())))
|
|
1661
|
+
|
|
1662
|
+
@staticmethod
|
|
1663
|
+
def _measures(stats: Any, seconds: float) -> dict[str, Any]:
|
|
1664
|
+
"""Замеры ответа модели для finish_item; stats – LlmStats или None (сбой до первого ответа)."""
|
|
1665
|
+
measures: dict[str, Any] = {"seconds": seconds, "model_call": True}
|
|
1666
|
+
if stats is None:
|
|
1667
|
+
return measures
|
|
1668
|
+
measures.update(eval_tps=stats.eval_tps or None, output_tokens=stats.output_tokens,
|
|
1669
|
+
model_seconds=max(0.0, seconds - stats.load_s),
|
|
1670
|
+
eval_seconds=stats.output_tokens / stats.eval_tps if stats.eval_tps > 0 else 0.0)
|
|
1671
|
+
return measures
|
|
1672
|
+
|
|
1673
|
+
def _code_changed(self, f: Finding, repo_dir: Path | None, max_chars: int, chash: str,
|
|
1674
|
+
snapshot: Any = None) -> bool:
|
|
1675
|
+
"""Код находки сейчас другой, чем в срезе с отпечатком chash. Не удалось прочитать – считается изменившимся:
|
|
1676
|
+
ответ про код, которого не видно, привязывать нельзя. snapshot() – срез из базы, если клон удалили, пока
|
|
1677
|
+
модель отвечала (snapshot_code): тогда сравнивается он, а не строка выгрузки (ADR-0072)."""
|
|
1678
|
+
try:
|
|
1679
|
+
late = snapshot() if snapshot is not None else None
|
|
1680
|
+
if late is not None:
|
|
1681
|
+
return late[1] != chash
|
|
1682
|
+
return case_hash(f, build_context(repo_dir, f, max_chars=max_chars, mask_key=self._mask_key)) != chash
|
|
1683
|
+
except BUSY_ERRORS:
|
|
1684
|
+
raise # занятая база – пауза прогона, а не «код изменился» (Э2)
|
|
1685
|
+
except Exception as e:
|
|
1686
|
+
log_failure(log, "срез находки не перечитан после ответа модели", e)
|
|
1687
|
+
return True
|
|
1688
|
+
|
|
1689
|
+
def _refresh_contexts(self, run: dict, halt: threading.Event) -> None:
|
|
1690
|
+
"""Модель недоступна (Ollama не отвечает, модели нет, адрес не из разрешённых), а срезы находок прогона
|
|
1691
|
+
всё равно сверяются с текущим кодом: если код изменился (правки без смены ревизии, папка без .git),
|
|
1692
|
+
прежний вердикт отвязывается и отметка «проверено» снимается (save_case) – решение по прежнему коду
|
|
1693
|
+
не остаётся «проверенным» из-за того, что модель не ответила. Очередь прогона не меняется."""
|
|
1694
|
+
run_id, project_id = int(run["id"]), int(run["project_id"])
|
|
1695
|
+
for hub_id in self.db.pending_hub_ids(run_id):
|
|
1696
|
+
if halt.is_set():
|
|
1697
|
+
return
|
|
1698
|
+
try:
|
|
1699
|
+
stored = self.db.get_case(project_id, hub_id)
|
|
1700
|
+
source = self.db.case_input(project_id, hub_id)
|
|
1701
|
+
if stored is None or source is None:
|
|
1702
|
+
continue # среза нет – отвязывать нечего
|
|
1703
|
+
max_chars = int(stored["context"].get("max_chars") or CONTEXT_CHARS)
|
|
1704
|
+
f, ctx, chash, saved = current_code_origin(self.settings, source, self._mask_key, max_chars,
|
|
1705
|
+
case=stored)
|
|
1706
|
+
if chash == stored["case_hash"]:
|
|
1707
|
+
# срез тот же, а решение принято по другому коду (бэклог 114) – отметка снимается; если клона нет
|
|
1708
|
+
# и текущий код – сам сохранённый срез, сверять нечего (ADR-0072). Признак – у того же чтения:
|
|
1709
|
+
# файл мог вернуться в клон после него (ревью Codex ветки долга, круг 5)
|
|
1710
|
+
if not saved:
|
|
1711
|
+
self.db.reopen_for_decision_code(project_id, hub_id, chash, max_chars, source)
|
|
1712
|
+
continue
|
|
1713
|
+
if degrades(stored, ctx): # полноценный срез не ухудшается
|
|
1714
|
+
self._keep_slice(self.settings, source, stored, project_id, hub_id)
|
|
1715
|
+
continue
|
|
1716
|
+
self.db.save_case(project_id, hub_id, chash, {**case_context(f, ctx), "max_chars": max_chars},
|
|
1717
|
+
None, source, no_downgrade=True)
|
|
1718
|
+
except Exception as e:
|
|
1719
|
+
log_failure(log, "срез находки не сверен (прогон %s)", e, run_id)
|
|
1720
|
+
|
|
1721
|
+
def _keep_slice(self, settings: Settings, source: dict, stored: dict | None, project_id: int, hub_id: str) -> None:
|
|
1722
|
+
"""Новый срез хуже сохранённого и не записывается (degrades). Если файл находки по-прежнему в клоне (его
|
|
1723
|
+
укоротили, путь стал неоднозначным), код под решением уже другой: отметка «проверено» снимается, срез
|
|
1724
|
+
остаётся. Если файл пропал (клон удаляют), код тот же – отметка остаётся."""
|
|
1725
|
+
if snapshot_code(settings, source, stored) is None:
|
|
1726
|
+
self.db.reopen_for_code_change(project_id, hub_id, source)
|
|
1727
|
+
|
|
1728
|
+
def _masked(self, messages: list[dict]) -> list[dict]:
|
|
1729
|
+
"""Последняя сетка перед отправкой: маскирование всего текста сообщений с данными находки (путь файла,
|
|
1730
|
+
правило, заметки). Повторное маскирование уже замаскированного текста его не меняет.
|
|
1731
|
+
|
|
1732
|
+
env_style=False – как у среза кода в build_context: строка кода «КЛЮЧ=значение» не скрывается целиком,
|
|
1733
|
+
и модель видит тот же код, что человек в карточке. Поля находки prompts.py уже маскирует как текст."""
|
|
1734
|
+
return [{**m, "content": mask_text(str(m.get("content") or ""), self._mask_key, env_style=False)[0]}
|
|
1735
|
+
if m.get("role") == "user" else m for m in messages]
|
|
1736
|
+
|
|
1737
|
+
@staticmethod
|
|
1738
|
+
def _server_alive(client: OllamaClient) -> bool:
|
|
1739
|
+
try:
|
|
1740
|
+
client.version()
|
|
1741
|
+
except LlmError:
|
|
1742
|
+
return False
|
|
1743
|
+
return True
|