Константин Лебединский
660 lines
31 KiB
Python
660 lines
31 KiB
Python
"""AI-генерация теста/вопроса в редакторе (порт `services/aiEditorService.js`)."""
|
|
from __future__ import annotations
|
|
|
|
from typing import Any
|
|
|
|
from .draft_validator import (
|
|
assert_draft_matches_shape,
|
|
parse_json_from_llm_text,
|
|
shuffle_options_in_questions,
|
|
validate_and_normalize_draft,
|
|
)
|
|
from .llm_client import LlmError, chat_completion_text_content, get_llm_config
|
|
|
|
|
|
class HttpError(Exception):
|
|
def __init__(self, status: int, message: str):
|
|
super().__init__(message)
|
|
self.status = status
|
|
self.message = message
|
|
|
|
|
|
def parse_and_validate_shape(s: Any) -> list[dict]:
|
|
if not isinstance(s, list) or not s:
|
|
raise HttpError(400, 'Передайте непустой массив shape: [{ optionsCount, hasMultipleAnswers }, ...].')
|
|
if len(s) > 40:
|
|
raise HttpError(400, 'Не более 40 вопросов за раз.')
|
|
out = []
|
|
for i, row in enumerate(s):
|
|
if not isinstance(row, dict):
|
|
raise HttpError(400, f'shape[{i}]: ожидается объект.')
|
|
try:
|
|
n = int(float(row.get('optionsCount')))
|
|
except (TypeError, ValueError):
|
|
raise HttpError(400, f'shape[{i}]: optionsCount от 2 до 12.')
|
|
if n < 2 or n > 12:
|
|
raise HttpError(400, f'shape[{i}]: optionsCount от 2 до 12.')
|
|
has_multi = bool(row.get('hasMultipleAnswers'))
|
|
raw_min = row.get('minCorrect', 1)
|
|
raw_max = row.get('maxCorrect', n if has_multi else 1)
|
|
try:
|
|
min_c = int(float(raw_min))
|
|
max_c = int(float(raw_max))
|
|
except (TypeError, ValueError):
|
|
raise HttpError(400, f'shape[{i}]: minCorrect/maxCorrect должны быть числами.')
|
|
if not has_multi:
|
|
min_c = 1
|
|
max_c = 1
|
|
if min_c < 1 or max_c < 1 or min_c > max_c or max_c > n:
|
|
raise HttpError(
|
|
400,
|
|
f'shape[{i}]: корректный диапазон правильных ответов — от 1 до {n}, min<=max.',
|
|
)
|
|
out.append(
|
|
{
|
|
'optionsCount': n,
|
|
'hasMultipleAnswers': has_multi,
|
|
'minCorrect': min_c,
|
|
'maxCorrect': max_c,
|
|
}
|
|
)
|
|
return out
|
|
|
|
|
|
def _require_cfg():
|
|
cfg = get_llm_config()
|
|
if cfg is None:
|
|
raise HttpError(503, 'Задайте DEEPSEEK_API_KEY или OPENAI_API_KEY на сервере.')
|
|
return cfg
|
|
|
|
|
|
def generate_full_test_by_shape(test_title: str, test_description: str, shape: list[dict]) -> dict:
|
|
cfg = _require_cfg()
|
|
title = (test_title or '').strip() or 'Тест'
|
|
desc = (test_description or '').strip()
|
|
lines = []
|
|
for i, sh in enumerate(shape):
|
|
if sh['hasMultipleAnswers']:
|
|
tail = (
|
|
'несколько вариантов помечены как верные (hasMultipleAnswers: true), '
|
|
f'число правильных от {sh["minCorrect"]} до {sh["maxCorrect"]}.'
|
|
)
|
|
else:
|
|
tail = 'ровно один верный вариант (hasMultipleAnswers: false).'
|
|
lines.append(f'Вопрос {i + 1}: ровно {sh["optionsCount"]} вариантов ответа; {tail}')
|
|
|
|
system = (
|
|
'Ты составитель учебных тестов. Отвечай ТОЛЬКО одним JSON-объектом на русском. '
|
|
'Схема: {"title": string, "description": string (может быть пустой строкой), '
|
|
'"questions": array}. Каждый вопрос: {"text", "hasMultipleAnswers", '
|
|
'"options": [{ "text", "isCorrect" }]}.'
|
|
)
|
|
user = (
|
|
'Составь тест по теме.\n\n'
|
|
f'Название (можно уточнить, но смысл сохранить): {title}\n'
|
|
f'Краткое описание / контекст темы: '
|
|
f'{desc or "не указано; придумай согласованную тему с названием."}\n\n'
|
|
f'Соблюди СТРОГО число вопросов и вариантов (не больше и не меньше):\n'
|
|
+ '\n'.join(lines)
|
|
+ '\n\nПравила: варианты — осмысленные, по теме; отметь isCorrect согласно '
|
|
'hasMultipleAnswers; для одного правильного — ровна одна true.'
|
|
)
|
|
|
|
raw = chat_completion_text_content(cfg, system, user, 0.35)
|
|
parsed = parse_json_from_llm_text(raw)
|
|
draft = validate_and_normalize_draft(parsed)
|
|
assert_draft_matches_shape({'questions': draft['questions']}, shape)
|
|
shuffle_options_in_questions(draft['questions'])
|
|
return {
|
|
'title': draft['title'],
|
|
'description': draft['description'],
|
|
'questions': draft['questions'],
|
|
}
|
|
|
|
|
|
# ─── E1.8: AI v2 ──────────────────────────────────────────────────────
|
|
|
|
|
|
def generate_test_by_title(
|
|
test_title: str,
|
|
test_description: str = '',
|
|
questions_count: int = 10,
|
|
options_count: int = 4,
|
|
has_multiple_answers: bool = False,
|
|
) -> dict:
|
|
"""Генерация теста ТОЛЬКО по названию: AI сам предлагает вопросы.
|
|
|
|
Сетка не задаётся жёстко: пользователю даётся подсказка о желаемом числе
|
|
вопросов и вариантов, но мы валидируем мягко (не assert_draft_matches_shape).
|
|
"""
|
|
cfg = _require_cfg()
|
|
title = (test_title or '').strip()
|
|
if not title:
|
|
raise HttpError(400, 'Укажите название теста.')
|
|
desc = (test_description or '').strip()
|
|
n_q = max(3, min(40, int(questions_count or 10)))
|
|
n_opt = max(2, min(12, int(options_count or 4)))
|
|
|
|
system = (
|
|
'Ты опытный методист, составляешь учебные тесты. Отвечай ТОЛЬКО одним '
|
|
'JSON-объектом на русском. Схема: {"title", "description", "questions": ['
|
|
'{"text", "hasMultipleAnswers": boolean, "options": [{"text", "isCorrect"}]}'
|
|
']}. Минимум 2 варианта, отметь хотя бы один isCorrect: true.'
|
|
)
|
|
user = (
|
|
'Составь учебный тест по этой теме.\n\n'
|
|
f'Название теста: {title}\n'
|
|
f'Описание/контекст: {desc or "не указано — определи по названию."}\n\n'
|
|
f'Подсказка по сетке: примерно {n_q} вопросов, в каждом по {n_opt} вариантов '
|
|
f'ответа; '
|
|
f'тип ответа — {"несколько правильных" if has_multiple_answers else "один правильный"} '
|
|
f'(но если по смыслу нужно отступить — отступи). '
|
|
'Покрой ключевые подтемы. Дистракторы делай правдоподобными, не очевидно '
|
|
'неверными. Текст — короткий, понятный.'
|
|
)
|
|
raw = chat_completion_text_content(cfg, system, user, 0.45)
|
|
parsed = parse_json_from_llm_text(raw)
|
|
draft = validate_and_normalize_draft(parsed)
|
|
shuffle_options_in_questions(draft['questions'])
|
|
return {
|
|
'title': draft['title'],
|
|
'description': draft['description'],
|
|
'questions': draft['questions'],
|
|
}
|
|
|
|
|
|
def check_test_quality(test_title: str, test_description: str, questions: list[dict]) -> dict:
|
|
"""AI-рецензия теста: общий вердикт + список рекомендаций по разделам."""
|
|
cfg = _require_cfg()
|
|
title = (test_title or '').strip() or 'Тест'
|
|
desc = (test_description or '').strip()
|
|
qs = questions or []
|
|
if not qs:
|
|
raise HttpError(400, 'В тесте нет вопросов — нечего проверять.')
|
|
|
|
system = (
|
|
'Ты ревьюер учебных тестов. Отвечай ТОЛЬКО JSON: {"verdict": "ok"|"warn"|"bad", '
|
|
'"summary": string (1-2 предложения), '
|
|
'"sections": [{"title": string, "items": [string, ...]}]}. '
|
|
'Разделы рекомендаций: «Чёткость формулировок», «Качество дистракторов», '
|
|
'"Охват темы», «Сбалансированность сложности». Пропусти раздел, если '
|
|
'претензий нет. Вердикт: ok — годен; warn — есть замечания; bad — серьёзные '
|
|
'проблемы. Все тексты — на русском, короткие и предметные.'
|
|
)
|
|
test_dump = {
|
|
'title': title,
|
|
'description': desc,
|
|
'questions': [
|
|
{
|
|
'text': q.get('text', ''),
|
|
'hasMultipleAnswers': bool(q.get('hasMultipleAnswers')),
|
|
'options': [
|
|
{'text': o.get('text', ''), 'isCorrect': bool(o.get('isCorrect'))}
|
|
for o in (q.get('options') or [])
|
|
],
|
|
}
|
|
for q in qs
|
|
],
|
|
}
|
|
import json as _json
|
|
|
|
user = 'Проверь качество теста и дай рекомендации:\n\n' + _json.dumps(
|
|
test_dump, ensure_ascii=False
|
|
)
|
|
raw = chat_completion_text_content(cfg, system, user, 0.25)
|
|
parsed = parse_json_from_llm_text(raw)
|
|
if not isinstance(parsed, dict):
|
|
raise LlmError('Неверный формат ответа модели.', code='llm_shape')
|
|
verdict = str(parsed.get('verdict') or '').strip().lower()
|
|
if verdict not in ('ok', 'warn', 'bad'):
|
|
verdict = 'warn'
|
|
summary = str(parsed.get('summary') or '').strip()
|
|
raw_sections = parsed.get('sections') or []
|
|
sections: list[dict] = []
|
|
if isinstance(raw_sections, list):
|
|
for s in raw_sections:
|
|
if not isinstance(s, dict):
|
|
continue
|
|
t = str(s.get('title') or '').strip()
|
|
items = s.get('items') or []
|
|
if not t or not isinstance(items, list) or not items:
|
|
continue
|
|
clean_items = [str(x).strip() for x in items if str(x).strip()]
|
|
if clean_items:
|
|
sections.append({'title': t, 'items': clean_items})
|
|
return {'verdict': verdict, 'summary': summary, 'sections': sections}
|
|
|
|
|
|
def _merge_suggested_by_focus(
|
|
focus: str,
|
|
orig: dict,
|
|
sug: dict,
|
|
) -> dict:
|
|
"""Сужает предложение модели под выбранную область правки."""
|
|
orig_opts = [
|
|
{'text': str(o.get('text', '')).strip(), 'isCorrect': bool(o.get('isCorrect'))}
|
|
for o in (orig.get('options') or [])
|
|
]
|
|
sug_opts = sug.get('options') or []
|
|
hm = bool(orig.get('hasMultipleAnswers'))
|
|
ot = str(orig.get('text', '')).strip()
|
|
|
|
if focus == 'questions':
|
|
return {
|
|
'text': str(sug.get('text', '')).strip(),
|
|
'hasMultipleAnswers': hm,
|
|
'options': [dict(o) for o in orig_opts],
|
|
}
|
|
if focus == 'distractors':
|
|
merged = []
|
|
for j, oo in enumerate(orig_opts):
|
|
so = sug_opts[j] if j < len(sug_opts) else oo
|
|
if oo['isCorrect']:
|
|
merged.append(dict(oo))
|
|
else:
|
|
merged.append(
|
|
{'text': str(so.get('text', '')).strip(), 'isCorrect': False}
|
|
)
|
|
return {'text': ot, 'hasMultipleAnswers': hm, 'options': merged}
|
|
if focus == 'options':
|
|
merged = []
|
|
for j, oo in enumerate(orig_opts):
|
|
so = sug_opts[j] if j < len(sug_opts) else oo
|
|
merged.append(
|
|
{
|
|
'text': str(so.get('text', '')).strip(),
|
|
'isCorrect': oo['isCorrect'],
|
|
}
|
|
)
|
|
return {'text': ot, 'hasMultipleAnswers': hm, 'options': merged}
|
|
return {
|
|
'text': str(sug.get('text', '')).strip(),
|
|
'hasMultipleAnswers': bool(sug.get('hasMultipleAnswers')),
|
|
'options': [
|
|
{'text': str(o.get('text', '')).strip(), 'isCorrect': bool(o.get('isCorrect'))}
|
|
for o in sug_opts
|
|
],
|
|
}
|
|
|
|
|
|
def improve_test_full(
|
|
test_title: str, test_description: str, questions: list[dict], focus: str = 'all'
|
|
) -> dict:
|
|
"""AI-улучшение всего теста. Возвращает 'было → стало' для каждого вопроса.
|
|
|
|
focus: all | questions | distractors | options
|
|
"""
|
|
cfg = _require_cfg()
|
|
title = (test_title or '').strip() or 'Тест'
|
|
desc = (test_description or '').strip()
|
|
qs = questions or []
|
|
if not qs:
|
|
raise HttpError(400, 'В тесте нет вопросов — нечего улучшать.')
|
|
|
|
focus = (focus or 'all').strip().lower()
|
|
if focus not in ('all', 'questions', 'distractors', 'options'):
|
|
focus = 'all'
|
|
|
|
system_by_focus = {
|
|
'all': (
|
|
'Ты редактор учебных тестов. Получаешь массив вопросов и предлагаешь '
|
|
'улучшения: чёткие формулировки, лучшие дистракторы, корректную разметку '
|
|
'isCorrect. Сохраняй исходную сетку: число вопросов, число вариантов и '
|
|
'значение hasMultipleAnswers НЕ меняй — иначе клиент отклонит ответ. '
|
|
'Отвечай ТОЛЬКО JSON: {"questions": [{"text", "hasMultipleAnswers", '
|
|
'"options": [{"text", "isCorrect"}]}, ...]}. Тексты — на русском, короткие.'
|
|
),
|
|
'questions': (
|
|
'Ты редактор учебных тестов. Улучши ТОЛЬКО формулировки вопросов (поле text). '
|
|
'В ответе для каждого вопроса верни options ДОСЛОВНО как во входе '
|
|
'(те же тексты и те же isCorrect), без правок. '
|
|
'Сетку не меняй. Отвечай ТОЛЬКО JSON: {"questions": [{"text", "hasMultipleAnswers", '
|
|
'"options": [{"text", "isCorrect"}]}, ...]}.'
|
|
),
|
|
'distractors': (
|
|
'Ты редактор учебных тестов. Улучши ТОЛЬКО неверные варианты (дистракторы), '
|
|
'где isCorrect: false. Верные варианты (isCorrect: true) верни ДОСЛОВНО как во входе. '
|
|
'Текст вопроса (text) не меняй — верни как во входе. hasMultipleAnswers не меняй. '
|
|
'Отвечай ТОЛЬКО JSON: {"questions": [{"text", "hasMultipleAnswers", '
|
|
'"options": [{"text", "isCorrect"}]}, ...]}.'
|
|
),
|
|
'options': (
|
|
'Ты редактор учебных тестов. Улучши формулировки всех вариантов ответа; '
|
|
'какой вариант верный, не меняй — isCorrect копируй из входа для каждого индекса. '
|
|
'Текст вопроса не меняй — верни как во входе. hasMultipleAnswers не меняй. '
|
|
'Отвечай ТОЛЬКО JSON: {"questions": [{"text", "hasMultipleAnswers", '
|
|
'"options": [{"text", "isCorrect"}]}, ...]}.'
|
|
),
|
|
}
|
|
system = system_by_focus[focus]
|
|
|
|
test_dump = {
|
|
'title': title,
|
|
'description': desc,
|
|
'questions': [
|
|
{
|
|
'text': q.get('text', ''),
|
|
'hasMultipleAnswers': bool(q.get('hasMultipleAnswers')),
|
|
'options': [
|
|
{'text': o.get('text', ''), 'isCorrect': bool(o.get('isCorrect'))}
|
|
for o in (q.get('options') or [])
|
|
],
|
|
}
|
|
for q in qs
|
|
],
|
|
}
|
|
import json as _json
|
|
|
|
user = 'Улучши тест без изменения сетки:\n\n' + _json.dumps(
|
|
test_dump, ensure_ascii=False
|
|
)
|
|
raw = chat_completion_text_content(cfg, system, user, 0.3)
|
|
parsed = parse_json_from_llm_text(raw)
|
|
|
|
shape = [
|
|
{
|
|
'optionsCount': len(q.get('options') or []),
|
|
'hasMultipleAnswers': bool(q.get('hasMultipleAnswers')),
|
|
}
|
|
for q in qs
|
|
]
|
|
assert_draft_matches_shape(parsed, shape)
|
|
draft = validate_and_normalize_draft(
|
|
{'title': title, 'questions': parsed.get('questions') or []}
|
|
)
|
|
raw_suggested = draft['questions']
|
|
|
|
suggested_qs = [_merge_suggested_by_focus(focus, o, s) for o, s in zip(qs, raw_suggested)]
|
|
|
|
items = []
|
|
for i, (orig, sug) in enumerate(zip(qs, suggested_qs)):
|
|
orig_opts = [
|
|
{'text': str(o.get('text', '')).strip(), 'isCorrect': bool(o.get('isCorrect'))}
|
|
for o in (orig.get('options') or [])
|
|
]
|
|
sug_opts = sug['options']
|
|
text_changed = (str(orig.get('text', '')).strip() != sug['text'])
|
|
options_changed = (
|
|
len(orig_opts) != len(sug_opts)
|
|
or any(
|
|
a['text'] != b['text'] or a['isCorrect'] != b['isCorrect']
|
|
for a, b in zip(orig_opts, sug_opts)
|
|
)
|
|
)
|
|
items.append(
|
|
{
|
|
'index': i,
|
|
'original': {
|
|
'text': str(orig.get('text', '')).strip(),
|
|
'hasMultipleAnswers': bool(orig.get('hasMultipleAnswers')),
|
|
'options': orig_opts,
|
|
},
|
|
'suggested': {
|
|
'text': sug['text'],
|
|
'hasMultipleAnswers': sug['hasMultipleAnswers'],
|
|
'options': sug_opts,
|
|
},
|
|
'textChanged': text_changed,
|
|
'optionsChanged': options_changed,
|
|
'changed': text_changed or options_changed,
|
|
}
|
|
)
|
|
|
|
return {'items': items, 'focus': focus}
|
|
|
|
|
|
def improve_single_option_text(
|
|
test_title: str,
|
|
test_description: str,
|
|
question_text: str,
|
|
options: list[dict],
|
|
option_index: int,
|
|
) -> dict:
|
|
"""Улучшает формулировку одного варианта ответа, не меняя роль (верный/неверный)."""
|
|
cfg = _require_cfg()
|
|
opts = options or []
|
|
try:
|
|
idx = int(option_index)
|
|
except (TypeError, ValueError):
|
|
raise HttpError(400, 'Укажите целочисленный optionIndex.')
|
|
if idx < 0 or idx >= len(opts):
|
|
raise HttpError(400, 'Некорректный индекс варианта.')
|
|
|
|
topic = (((test_title or '').strip() or 'Тест') + '. ' + (test_description or '').strip()).strip()
|
|
qt = (question_text or '').strip()
|
|
lines = []
|
|
for j, o in enumerate(opts):
|
|
mark = ' ← улучшить этот вариант' if j == idx else ''
|
|
oc = 'верный' if o.get('isCorrect') else 'неверный'
|
|
lines.append(f'{j + 1}. ({oc}) {o.get("text", "")}{mark}')
|
|
|
|
system = (
|
|
'Ты редактор учебных тестов. Отвечай ТОЛЬКО JSON: {"text": string} — '
|
|
'улучшенная формулировка ОДНОГО варианта ответа. Не меняй статус верности: '
|
|
'если вариант был верным, формулировка остаётся верным ответом по смыслу; '
|
|
'если неверным — остаётся неверным дистрактором. Без лишних слов.'
|
|
)
|
|
user = (
|
|
f'Тема теста: {topic}\n\n'
|
|
f'Вопрос: {qt or "—"}\n\n'
|
|
'Варианты:\n'
|
|
+ '\n'.join(lines)
|
|
+ f'\n\nПерепиши только вариант №{idx + 1}, короче и яснее, на русском.'
|
|
)
|
|
raw = chat_completion_text_content(cfg, system, user, 0.25)
|
|
parsed = parse_json_from_llm_text(raw)
|
|
text = str((parsed or {}).get('text') or '').strip()
|
|
if not text:
|
|
raise LlmError('Пустой text в ответе модели.', code='llm_shape')
|
|
return {'optionIndex': idx, 'text': text}
|
|
|
|
|
|
def generate_question_hint(
|
|
*,
|
|
question_text: str,
|
|
options: list[dict],
|
|
) -> str:
|
|
"""Универсальная подсказка к вопросу: 2–4 предложения, объясняет правильный ответ."""
|
|
cfg = get_llm_config()
|
|
if cfg is None:
|
|
return ''
|
|
correct_list = '; '.join(o['text'] for o in options if o.get('isCorrect'))
|
|
all_list = '; '.join(o['text'] for o in options)
|
|
system = (
|
|
'Ты опытный преподаватель. Отвечай по-русски, кратко (2–4 предложения), '
|
|
'без markdown и без вступлений. Объясни почему правильный вариант — правильный.'
|
|
)
|
|
user = (
|
|
f'Вопрос: {question_text}\n'
|
|
f'Варианты: {all_list}\n'
|
|
f'Правильный ответ: {correct_list or "—"}\n\n'
|
|
'Дай краткое объяснение для подсказки во всплывающем окне.'
|
|
)
|
|
try:
|
|
raw = chat_completion_text_content(cfg, system, user, 0.3, as_json=False)
|
|
return (raw or '').strip()
|
|
except Exception as e:
|
|
import logging
|
|
logging.getLogger(__name__).warning('generate_question_hint failed: %s', e)
|
|
return ''
|
|
|
|
|
|
def explain_answer(
|
|
*,
|
|
question_text: str,
|
|
options: list[dict],
|
|
selected_texts: list[str],
|
|
is_correct: bool,
|
|
) -> str:
|
|
"""Генерирует короткое объяснение результата ответа на вопрос (для попапа подсказки)."""
|
|
cfg = get_llm_config()
|
|
if cfg is None:
|
|
return ''
|
|
correct_list = '; '.join(o['text'] for o in options if o.get('isCorrect'))
|
|
sel_list = '; '.join(selected_texts) if selected_texts else '(ничего не выбрано)'
|
|
verdict = 'верно' if is_correct else 'неверно'
|
|
system = (
|
|
'Ты опытный преподаватель. Отвечай по-русски, кратко (2–4 предложения). '
|
|
'Объясни почему правильный ответ именно такой, без лишней воды и без markdown.'
|
|
)
|
|
user = (
|
|
f'Вопрос: {question_text}\n'
|
|
f'Правильный ответ: {correct_list or "—"}\n'
|
|
f'Ответ ученика ({verdict}): {sel_list}\n\n'
|
|
'Дай краткое объяснение для подсказки во всплывающем окне.'
|
|
)
|
|
try:
|
|
raw = chat_completion_text_content(cfg, system, user, 0.3, as_json=False)
|
|
return (raw or '').strip()
|
|
except Exception as e:
|
|
import logging
|
|
logging.getLogger(__name__).warning('explain_answer failed: %s', e)
|
|
return ''
|
|
|
|
|
|
def generate_or_rephrase_question(
|
|
test_title: str,
|
|
test_description: str,
|
|
question_text: str,
|
|
options_count: Any,
|
|
has_multiple_answers: bool,
|
|
mode: str | None = None,
|
|
existing_options: list[dict] | None = None,
|
|
) -> dict:
|
|
import json as _json
|
|
|
|
cfg = _require_cfg()
|
|
try:
|
|
n = int(float(options_count))
|
|
except (TypeError, ValueError):
|
|
raise HttpError(400, 'optionsCount: от 2 до 12.')
|
|
if n < 2 or n > 12:
|
|
raise HttpError(400, 'optionsCount: от 2 до 12.')
|
|
|
|
topic = (((test_title or '').strip() or 'Тест') + '. ' + (test_description or '').strip()).strip()
|
|
qt = (question_text or '').strip()
|
|
mode = (mode or '').strip() if mode else ''
|
|
|
|
# ── Режим дистракторов: есть вопрос + часть вариантов пуста ─────────────
|
|
if qt and mode == 'distractors' and existing_options:
|
|
filled = [o for o in existing_options if (o.get('text') or '').strip()]
|
|
empty_count = len([o for o in existing_options if not (o.get('text') or '').strip()])
|
|
if empty_count <= 0:
|
|
raise HttpError(400, 'Нет пустых полей для дистракторов — добавьте пустые варианты или выберите другой режим.')
|
|
filled_lines = '\n'.join(
|
|
f'- {"✓" if o.get("isCorrect") else "✗"} {o["text"]}'
|
|
for o in filled
|
|
) or '(нет)'
|
|
system = (
|
|
'Ты составитель учебных тестов. Отвечай ТОЛЬКО JSON: '
|
|
f'{{"options": [{{"text": string, "isCorrect": false}}, ...]}} — '
|
|
f'ровно {empty_count} объекта в массиве. '
|
|
'Все тексты на русском, без нумерации, без кавычек.'
|
|
)
|
|
user = (
|
|
f'Тема теста: {topic}\n\n'
|
|
f'Вопрос: {qt}\n\n'
|
|
f'Уже заполненные варианты:\n{filled_lines}\n\n'
|
|
f'Придумай ровно {empty_count} правдоподобных, но НЕВЕРНЫХ дистракторов '
|
|
f'(isCorrect: false), которые не повторяют уже существующие варианты '
|
|
f'и выглядят похоже на реальные ответы.'
|
|
)
|
|
raw = chat_completion_text_content(cfg, system, user, 0.45)
|
|
parsed = parse_json_from_llm_text(raw)
|
|
opts = []
|
|
if isinstance(parsed, dict):
|
|
opts = parsed.get('options') or []
|
|
elif isinstance(parsed, list):
|
|
opts = parsed
|
|
opts = [
|
|
{'text': str(o.get('text') or '').strip(), 'isCorrect': False}
|
|
for o in opts if (o.get('text') or '').strip()
|
|
][:empty_count]
|
|
return {'mode': 'distractors', 'text': qt, 'options': opts}
|
|
|
|
# ── Улучшить только формулировки вариантов (без смены верности) ──────────
|
|
if qt and mode == 'improve_options' and existing_options:
|
|
n_opts = len(existing_options)
|
|
if n_opts < 2:
|
|
raise HttpError(400, 'Нужно минимум два варианта ответа.')
|
|
dump_opts = [
|
|
{'text': str(o.get('text', '')), 'isCorrect': bool(o.get('isCorrect'))}
|
|
for o in existing_options
|
|
]
|
|
system = (
|
|
'Ты редактор учебных тестов. Отвечай ТОЛЬКО JSON: '
|
|
'{"options": [{"text": string, "isCorrect": boolean}, ...]}. '
|
|
'Число элементов и значение isCorrect на каждом индексе должны совпадать с входом; '
|
|
'улучши только формулировки text — короче и яснее, на русском.'
|
|
)
|
|
user = (
|
|
f'Тема теста: {topic}\n\n'
|
|
f'Вопрос:\n{qt}\n\n'
|
|
f'Варианты (улучши только тексты, isCorrect не меняй):\n{_json.dumps(dump_opts, ensure_ascii=False)}'
|
|
)
|
|
raw = chat_completion_text_content(cfg, system, user, 0.3)
|
|
parsed = parse_json_from_llm_text(raw)
|
|
raw_list = parsed.get('options') if isinstance(parsed, dict) else None
|
|
if not isinstance(raw_list, list) or len(raw_list) != n_opts:
|
|
raise LlmError('Неверный формат: ожидается options той же длины.', code='llm_shape')
|
|
out_opts = []
|
|
for i in range(n_opts):
|
|
ro = raw_list[i] if i < len(raw_list) else {}
|
|
orig_t = dump_opts[i]['text'].strip()
|
|
t = str((ro or {}).get('text') or '').strip() or orig_t
|
|
out_opts.append({'text': t, 'isCorrect': dump_opts[i]['isCorrect']})
|
|
return {'mode': 'improve_options', 'text': qt, 'options': out_opts}
|
|
|
|
# ── Только переформулировать текст вопроса ────────────────────────────────
|
|
if qt and mode == 'rephrase':
|
|
system = (
|
|
'Ты редактор учебных материалов. Отвечай ТОЛЬКО JSON: {"text": string} — '
|
|
'чёткая формулировка вопроса на русском, 1–3 полных предложения в зависимости '
|
|
'от сложности исходного черновика, без вариантов ответа.'
|
|
)
|
|
user = (
|
|
f'Тема теста: {topic}\n\n'
|
|
f'Исходный черновик вопроса (улучши формулировку, не меняй смысл без нужды):\n{qt}'
|
|
)
|
|
raw = chat_completion_text_content(cfg, system, user, 0.3)
|
|
parsed = parse_json_from_llm_text(raw)
|
|
text = str((parsed or {}).get('text') or '').strip()
|
|
if not text:
|
|
raise LlmError('Пустой text в ответе модели.', code='llm_shape')
|
|
return {'mode': 'rephrase', 'text': text}
|
|
|
|
if qt:
|
|
raise HttpError(
|
|
400,
|
|
'Укажите режим: distractors, improve_options или rephrase — или очистите текст вопроса для полной генерации.',
|
|
)
|
|
|
|
# ── Полная генерация: вопрос пуст ────────────────────────────────────────
|
|
system = (
|
|
'Ты составитель тестов. Отвечай ТОЛЬКО JSON: {"text", "hasMultipleAnswers", '
|
|
'"options": [{ "text", "isCorrect" }]}. Все на русском.'
|
|
)
|
|
multi_clause = (
|
|
'true (несколько верных, минимум 2 isCorrect: true, остальные false).'
|
|
if has_multiple_answers
|
|
else 'false (ровно один isCorrect: true).'
|
|
)
|
|
user = (
|
|
f'Тема теста: {topic}\n\n'
|
|
f'Сформулируй ОДИН вопрос по этой теме с ровно {n} вариантами ответа. '
|
|
f'hasMultipleAnswers = {multi_clause}'
|
|
)
|
|
raw = chat_completion_text_content(cfg, system, user, 0.35)
|
|
parsed = parse_json_from_llm_text(raw)
|
|
shape = [{'optionsCount': n, 'hasMultipleAnswers': bool(has_multiple_answers)}]
|
|
assert_draft_matches_shape({'questions': [parsed]}, shape)
|
|
draft = validate_and_normalize_draft({'title': 'временно', 'questions': [parsed]})
|
|
q0 = draft['questions'][0]
|
|
shuffle_options_in_questions([q0])
|
|
return {
|
|
'mode': 'full',
|
|
'text': q0['text'],
|
|
'hasMultipleAnswers': q0['hasMultipleAnswers'],
|
|
'options': q0['options'],
|
|
}
|