209 lines
7.4 KiB
Python
209 lines
7.4 KiB
Python
"""
|
|
teach.py — Isolated teaching/feedback page.
|
|
|
|
This blueprint is intentionally separate from the working compare pipeline.
|
|
It renders a standalone UI and stores feedback only in the feedback table.
|
|
"""
|
|
|
|
import json
|
|
import os
|
|
|
|
from flask import Blueprint, jsonify, render_template, request
|
|
|
|
import db
|
|
|
|
teach_bp = Blueprint("teach", __name__)
|
|
|
|
|
|
@teach_bp.route("/teach/api/meta", methods=["GET"])
|
|
def teach_meta_api():
|
|
"""Return default metadata for the isolated teaching page."""
|
|
return jsonify({
|
|
"ok": True,
|
|
"prompt_version": os.getenv("TEACH_PROMPT_VERSION", "vm-teach-v1"),
|
|
"model_name": os.getenv("TEACH_MODEL_NAME", "gpt-oss-120b"),
|
|
})
|
|
|
|
|
|
@teach_bp.route("/teach", methods=["GET"])
|
|
def teach_page():
|
|
"""Standalone feedback page for reviewing comparison output."""
|
|
return render_template("teach.html")
|
|
|
|
|
|
@teach_bp.route("/teach/api/contracts", methods=["GET"])
|
|
def teach_contracts_api():
|
|
"""List contracts and supplements for the teaching page."""
|
|
result, err = db.query(
|
|
"SELECT c.id AS contract_id, c.number AS contract_number, c.client, c.date_signed, "
|
|
"s.id AS supplement_id, s.number AS supplement_number, s.date_signed AS supplement_date, "
|
|
"s.type AS supplement_type, s.document_id, d.filename AS document_filename "
|
|
"FROM contracts c "
|
|
"LEFT JOIN supplements s ON s.contract_id = c.id "
|
|
"LEFT JOIN documents d ON d.id = s.document_id "
|
|
"ORDER BY c.created_at DESC, s.date_signed DESC NULLS LAST, s.created_at DESC"
|
|
)
|
|
if err:
|
|
return jsonify({"ok": False, "error": err}), 500
|
|
|
|
contracts = {}
|
|
for row in result["rows"]:
|
|
item = dict(zip(result["columns"], row))
|
|
cid = str(item["contract_id"])
|
|
if cid not in contracts:
|
|
contracts[cid] = {
|
|
"contract_id": cid,
|
|
"contract_number": item.get("contract_number"),
|
|
"client": item.get("client"),
|
|
"date_signed": item.get("date_signed"),
|
|
"supplements": [],
|
|
}
|
|
if item.get("supplement_id"):
|
|
contracts[cid]["supplements"].append({
|
|
"supplement_id": str(item["supplement_id"]),
|
|
"supplement_number": item.get("supplement_number"),
|
|
"supplement_date": item.get("supplement_date"),
|
|
"supplement_type": item.get("supplement_type"),
|
|
"document_id": str(item["document_id"]) if item.get("document_id") else None,
|
|
"document_filename": item.get("document_filename"),
|
|
})
|
|
|
|
return jsonify({"ok": True, "contracts": list(contracts.values())})
|
|
|
|
|
|
@teach_bp.route("/teach/api/context", methods=["GET"])
|
|
def teach_context_api():
|
|
"""Load rows and history for a chosen supplement."""
|
|
supplement_id = request.args.get("supplement_id")
|
|
if not supplement_id:
|
|
return jsonify({"ok": False, "error": "supplement_id required"}), 400
|
|
|
|
supp, err = db.query_one(
|
|
"SELECT s.id AS supplement_id, s.contract_id, s.number, s.date_signed, s.type, "
|
|
"c.number AS contract_number, c.client, d.filename AS document_filename "
|
|
"FROM supplements s "
|
|
"JOIN contracts c ON c.id = s.contract_id "
|
|
"LEFT JOIN documents d ON d.id = s.document_id "
|
|
"WHERE s.id = %s",
|
|
(supplement_id,),
|
|
)
|
|
if err:
|
|
return jsonify({"ok": False, "error": err}), 500
|
|
if not supp:
|
|
return jsonify({"ok": False, "error": "not found"}), 404
|
|
|
|
rows_result, err = db.query(
|
|
"SELECT id, row_num, name, price, qty, sum, date_start, date_end, created_at "
|
|
"FROM spec_rows WHERE supplement_id = %s ORDER BY row_num",
|
|
(supplement_id,),
|
|
)
|
|
if err:
|
|
return jsonify({"ok": False, "error": err}), 500
|
|
|
|
prev_rows_result, err = db.query(
|
|
"SELECT sr.row_num, sr.name, sr.price, sr.qty, sr.sum, sr.date_start "
|
|
"FROM spec_rows sr "
|
|
"JOIN supplements s ON s.id = sr.supplement_id "
|
|
"WHERE s.contract_id = %s AND s.id <> %s "
|
|
"ORDER BY s.date_signed DESC NULLS LAST, sr.row_num",
|
|
(supp["contract_id"], supplement_id),
|
|
)
|
|
if err:
|
|
return jsonify({"ok": False, "error": err}), 500
|
|
|
|
rows = [dict(zip(rows_result["columns"], row)) for row in rows_result["rows"]]
|
|
prev_rows = [dict(zip(prev_rows_result["columns"], row)) for row in prev_rows_result["rows"]]
|
|
|
|
return jsonify({
|
|
"ok": True,
|
|
"supplement": supp,
|
|
"current_rows": rows,
|
|
"previous_rows": prev_rows,
|
|
})
|
|
|
|
|
|
@teach_bp.route("/teach/api/feedback", methods=["GET", "POST"])
|
|
def teach_feedback_api():
|
|
"""Read or append isolated feedback records."""
|
|
if request.method == "GET":
|
|
contract_id = request.args.get("contract_id")
|
|
supplement_id = request.args.get("supplement_id")
|
|
sql = (
|
|
"SELECT id, created_at, contract_id, supplement_id, event_seq, scope, verdict, "
|
|
"error_type, field, service_name, llm_value, correct_value, prompt_version, model_name, doc_mode, comment "
|
|
"FROM feedback"
|
|
)
|
|
params = []
|
|
where = []
|
|
if contract_id:
|
|
where.append("contract_id = %s")
|
|
params.append(contract_id)
|
|
if supplement_id:
|
|
where.append("supplement_id = %s")
|
|
params.append(supplement_id)
|
|
if where:
|
|
sql += " WHERE " + " AND ".join(where)
|
|
sql += " ORDER BY created_at DESC LIMIT 200"
|
|
result, err = db.query(sql, tuple(params) if params else None)
|
|
if err:
|
|
return jsonify({"ok": False, "error": err}), 500
|
|
rows = [dict(zip(result["columns"], row)) for row in result["rows"]]
|
|
return jsonify({"ok": True, "rows": rows, "count": len(rows)})
|
|
|
|
data = request.get_json(silent=True) or {}
|
|
|
|
required = ["scope", "verdict"]
|
|
for key in required:
|
|
if not data.get(key):
|
|
return jsonify({"ok": False, "error": f"{key} is required"}), 400
|
|
|
|
sql = (
|
|
"INSERT INTO feedback (contract_id, supplement_id, event_seq, scope, verdict, error_type, field, "
|
|
"service_name, llm_value, correct_value, prompt_version, model_name, doc_mode, comment) "
|
|
"VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s::jsonb, %s::jsonb, %s, %s, %s, %s) RETURNING id"
|
|
)
|
|
|
|
params = (
|
|
data.get("contract_id"),
|
|
data.get("supplement_id"),
|
|
data.get("event_seq"),
|
|
data.get("scope"),
|
|
data.get("verdict"),
|
|
data.get("error_type"),
|
|
data.get("field"),
|
|
data.get("service_name"),
|
|
_json_or_none(data.get("llm_value")),
|
|
_json_or_none(data.get("correct_value")),
|
|
data.get("prompt_version"),
|
|
data.get("model_name"),
|
|
data.get("doc_mode"),
|
|
data.get("comment"),
|
|
)
|
|
|
|
conn, err = db.connect()
|
|
if err:
|
|
return jsonify({"ok": False, "error": err}), 500
|
|
|
|
try:
|
|
cur = conn.cursor()
|
|
cur.execute(sql, params)
|
|
row = cur.fetchone()
|
|
conn.commit()
|
|
cur.close()
|
|
return jsonify({"ok": True, "id": str(row[0]) if row else None})
|
|
except Exception as exc:
|
|
try:
|
|
conn.rollback()
|
|
except Exception:
|
|
pass
|
|
return jsonify({"ok": False, "error": str(exc)}), 500
|
|
finally:
|
|
db.put_conn(conn)
|
|
|
|
|
|
def _json_or_none(value):
|
|
"""Prepare JSONB payload for psycopg2."""
|
|
if value is None or value == "":
|
|
return None
|
|
return json.dumps(value, ensure_ascii=False)
|