Restructure: Move grid_* + vocab_* into packages (klausur-service)

grid/ package (16 files):
  grid/build/   — core, zones, cleanup, text_ops, cell_ops, finalize
  grid/editor/  — api, helpers, columns, filters, headers, zones

vocab/ package (10 files):
  vocab/worksheet/ — api, models, extraction, generation, ocr, upload, analysis, compare
  vocab/           — session_store, learn_bridge

26 backward-compat shims. Internal imports relative. RAG untouched.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

klausur-service/backend/vocab_learn_bridge.py

@@ -1,196 +1,4 @@
-"""
-Vocab Learn Bridge — Converts vocabulary session data into Learning Units.
-
-Bridges klausur-service (vocab extraction) with backend-lehrer (learning units + generators).
-Creates a Learning Unit in backend-lehrer, then triggers MC/Cloze/QA generation.
-
-DATENSCHUTZ: All communication stays within Docker network (breakpilot-network).
-"""
-
-import os
-import json
-import logging
-import httpx
-from typing import List, Dict, Any, Optional
-
-logger = logging.getLogger(__name__)
-
-BACKEND_LEHRER_URL = os.getenv("BACKEND_LEHRER_URL", "http://backend-lehrer:8001")
-
-
-def vocab_to_analysis_data(session_name: str, vocabulary: List[Dict[str, Any]]) -> Dict[str, Any]:
-    """
-    Convert vocabulary entries from a vocab session into the analysis_data format
-    expected by backend-lehrer generators (MC, Cloze, QA).
-
-    The generators consume:
-    - title: Display name
-    - subject: Subject area
-    - grade_level: Target grade
-    - canonical_text: Full text representation
-    - printed_blocks: Individual text blocks
-    - vocabulary: Original vocab data (for vocab-specific modules)
-    """
-    canonical_lines = []
-    printed_blocks = []
-
-    for v in vocabulary:
-        en = v.get("english", "").strip()
-        de = v.get("german", "").strip()
-        example = v.get("example_sentence", "").strip()
-
-        if not en and not de:
-            continue
-
-        line = f"{en} = {de}"
-        if example:
-            line += f" ({example})"
-        canonical_lines.append(line)
-
-        block_text = f"{en} — {de}"
-        if example:
-            block_text += f" | {example}"
-        printed_blocks.append({"text": block_text})
-
-    return {
-        "title": session_name,
-        "subject": "English Vocabulary",
-        "grade_level": "5-8",
-        "canonical_text": "\n".join(canonical_lines),
-        "printed_blocks": printed_blocks,
-        "vocabulary": vocabulary,
-    }
-
-
-async def create_learning_unit(
-    session_name: str,
-    vocabulary: List[Dict[str, Any]],
-    grade: Optional[str] = None,
-) -> Dict[str, Any]:
-    """
-    Create a Learning Unit in backend-lehrer from vocabulary data.
-
-    Steps:
-    1. Create unit via POST /api/learning-units/
-    2. Return the created unit info
-
-    Returns dict with unit_id, status, vocabulary_count.
-    """
-    if not vocabulary:
-        raise ValueError("No vocabulary entries provided")
-
-    analysis_data = vocab_to_analysis_data(session_name, vocabulary)
-
-    async with httpx.AsyncClient(timeout=30.0) as client:
-        # 1. Create Learning Unit
-        create_payload = {
-            "title": session_name,
-            "subject": "Englisch",
-            "grade": grade or "5-8",
-        }
-
-        try:
-            resp = await client.post(
-                f"{BACKEND_LEHRER_URL}/api/learning-units/",
-                json=create_payload,
-            )
-            resp.raise_for_status()
-            unit = resp.json()
-        except httpx.HTTPError as e:
-            logger.error(f"Failed to create learning unit: {e}")
-            raise RuntimeError(f"Backend-Lehrer nicht erreichbar: {e}")
-
-        unit_id = unit.get("id")
-        if not unit_id:
-            raise RuntimeError("Learning Unit created but no ID returned")
-
-        logger.info(f"Created learning unit {unit_id} with {len(vocabulary)} vocabulary entries")
-
-        # 2. Save analysis_data as JSON file for generators
-        analysis_dir = os.path.expanduser("~/Arbeitsblaetter/Lerneinheiten")
-        os.makedirs(analysis_dir, exist_ok=True)
-        analysis_path = os.path.join(analysis_dir, f"{unit_id}_analyse.json")
-
-        with open(analysis_path, "w", encoding="utf-8") as f:
-            json.dump(analysis_data, f, ensure_ascii=False, indent=2)
-
-        logger.info(f"Saved analysis data to {analysis_path}")
-
-        return {
-            "unit_id": unit_id,
-            "unit": unit,
-            "analysis_path": analysis_path,
-            "vocabulary_count": len(vocabulary),
-            "status": "created",
-        }
-
-
-async def generate_learning_modules(
-    unit_id: str,
-    analysis_path: str,
-) -> Dict[str, Any]:
-    """
-    Trigger MC, Cloze, and QA generation from analysis data.
-
-    Imports generators directly (they run in-process for klausur-service)
-    or calls backend-lehrer API if generators aren't available locally.
-
-    Returns dict with generation results.
-    """
-    results = {
-        "unit_id": unit_id,
-        "mc": {"status": "pending"},
-        "cloze": {"status": "pending"},
-        "qa": {"status": "pending"},
-    }
-
-    # Load analysis data
-    with open(analysis_path, "r", encoding="utf-8") as f:
-        analysis_data = json.load(f)
-
-    # Try to generate via backend-lehrer API
-    async with httpx.AsyncClient(timeout=120.0) as client:
-        # Generate QA (includes Leitner fields)
-        try:
-            resp = await client.post(
-                f"{BACKEND_LEHRER_URL}/api/learning-units/{unit_id}/generate-qa",
-                json={"analysis_data": analysis_data, "num_questions": min(len(analysis_data.get("vocabulary", [])), 20)},
-            )
-            if resp.status_code == 200:
-                results["qa"] = {"status": "generated", "data": resp.json()}
-            else:
-                logger.warning(f"QA generation returned {resp.status_code}")
-                results["qa"] = {"status": "skipped", "reason": f"HTTP {resp.status_code}"}
-        except Exception as e:
-            logger.warning(f"QA generation failed: {e}")
-            results["qa"] = {"status": "error", "reason": str(e)}
-
-        # Generate MC
-        try:
-            resp = await client.post(
-                f"{BACKEND_LEHRER_URL}/api/learning-units/{unit_id}/generate-mc",
-                json={"analysis_data": analysis_data, "num_questions": min(len(analysis_data.get("vocabulary", [])), 10)},
-            )
-            if resp.status_code == 200:
-                results["mc"] = {"status": "generated", "data": resp.json()}
-            else:
-                results["mc"] = {"status": "skipped", "reason": f"HTTP {resp.status_code}"}
-        except Exception as e:
-            logger.warning(f"MC generation failed: {e}")
-            results["mc"] = {"status": "error", "reason": str(e)}
-
-        # Generate Cloze
-        try:
-            resp = await client.post(
-                f"{BACKEND_LEHRER_URL}/api/learning-units/{unit_id}/generate-cloze",
-                json={"analysis_data": analysis_data},
-            )
-            if resp.status_code == 200:
-                results["cloze"] = {"status": "generated", "data": resp.json()}
-            else:
-                results["cloze"] = {"status": "skipped", "reason": f"HTTP {resp.status_code}"}
-        except Exception as e:
-            logger.warning(f"Cloze generation failed: {e}")
-            results["cloze"] = {"status": "error", "reason": str(e)}
-
-    return results
+# Backward-compat shim -- module moved to vocab/learn_bridge.py
+import importlib as _importlib
+import sys as _sys
+_sys.modules[__name__] = _importlib.import_module("vocab.learn_bridge")