🚀 Auto-deploy from GitHub

.gitignore

@@ -161,7 +161,7 @@ models/*/
 training/models/
 training/checkpoints/
 # training/outputs/ # Moved to logs/outputs as it's often mixed
-cardserver/models/lora-checkpoint/ # From user prompt
+/models/lora-checkpoint/
 # Common model file extensions
 *.bin
 *.safetensors

NOTES.md

@@ -0,0 +1,6 @@
+
+
+https://huggingface.co/docs/peft/en/task_guides/lora_based_methods
+https://chatgpt.com/share/6841f8f1-3164-800e-99ad-3ef13c4400e9
+
+https://git-lfs.com/

app/api/v1/endpoints/generate.py

@@ -3,17 +3,26 @@ from dotenv import load_dotenv
 from supabase import Client
 import uuid
 from ..schemas.card_schemas import CardGenerateRequest, CardGenerateResponse
-from ....core.generator import build_prompt, get_constellation
-from ....core.card_renderer import generate_card as render_card
-from ....utils.qr_utils import generate_qr_code
+from ....core.generator import build_prompt # get_constellation wird hier nicht direkt verwendet
+from ....core.card_renderer import generate_card as render_card_sync # Umbenennen für Klarheit
+from ....utils.qr_utils import generate_qr_code_sync # Umbenennen für Klarheit
 from ....services.database import get_supabase_client, save_card
 from ....core.config import settings
 from ....core.model_loader import get_generator
 from ....core.constraints import generate_with_retry, check_constraints
+from fastapi.concurrency import run_in_threadpool # Importieren
 
 load_dotenv()
 router = APIRouter()
 
+# Asynchrone Wrapper für blockierende Funktionen
+async def render_card_async(*args, **kwargs):
+    return await run_in_threadpool(render_card_sync, *args, **kwargs)
+
+async def generate_qr_code_async(*args, **kwargs):
+    return await run_in_threadpool(generate_qr_code_sync, *args, **kwargs)
+
+
 @router.post("/generate", response_model=CardGenerateResponse)
 async def generate_endpoint(
     request: CardGenerateRequest, 
@@ -23,13 +32,14 @@ async def generate_endpoint(
         lang = request.lang or "de"
         input_date_str = request.card_date.isoformat()
         
+        # build_prompt ist schnell und CPU-gebunden, kann synchron bleiben
         card_prompt = build_prompt(
             lang=lang,
             card_date=input_date_str,
             terms=request.terms
         )
 
-        llm_pipeline = get_generator()
+        llm_pipeline = get_generator() # Bleibt synchron, da es gecacht ist und schnell sein sollte nach dem ersten Mal
         
         generation_params = {
             "max_new_tokens": settings.GENERATION_MAX_NEW_TOKENS,
@@ -40,8 +50,8 @@ async def generate_endpoint(
             "return_full_text": False
         }
         
-        # Verwende generate_with_retry aus constraints.py
-        card_text = generate_with_retry(
+        # generate_with_retry ist jetzt asynchron
+        card_text = await generate_with_retry(
             prompt=card_prompt,
             generator=llm_pipeline,
             terms=request.terms,
@@ -55,22 +65,22 @@ async def generate_endpoint(
                 detail="Kartentext konnte nicht generiert werden oder erfüllt nicht die Bedingungen."
             )
 
-        # 4. QR-Code generieren
         card_id_for_url = str(uuid.uuid4())
         qr_content_url = f"{settings.FRONTEND_BASE_URL}/card/{card_id_for_url}"
         
-        qr_code_file_id = generate_qr_code(
+        # QR-Code Generierung asynchron
+        qr_code_file_id = await generate_qr_code_async(
             data=qr_content_url,
             output_path=settings.resolved_qr_code_path,
             size=settings.QR_CODE_SIZE
         )
         qr_code_url = f"{settings.API_PREFIX}/static/images/qr/{qr_code_file_id}.png"
 
-        # 5. Karte rendern
         card_design_id_to_render = request.card_design_id_override or 1 
         symbol_ids_to_render = request.symbol_ids_override or [1, 2]
 
-        card_file_id = render_card(
+        # Karten-Rendering asynchron
+        card_file_id = await render_card_async(
             card_design_id=card_design_id_to_render,
             symbol_ids=symbol_ids_to_render,
             text=card_text,
@@ -90,28 +100,27 @@ async def generate_endpoint(
             "session_id": uuid.UUID(card_id_for_url),
             "lang": lang,
             "prompt_text": card_prompt,
+            # llm_pipeline.model.config kann potenziell blockierend sein, wenn es I/O macht.
+            # Für den Moment belassen wir es, aber es könnte auch in einen Threadpool, falls nötig.
             "ml_model_info": llm_pipeline.model.config.to_dict() if hasattr(llm_pipeline, 'model') and hasattr(llm_pipeline.model, 'config') else {"name": str(type(llm_pipeline.model).__name__)},
             "generation_params": generation_params
         }
         
-        try:
-            db_response = await save_card(supabase, card_data_for_db)
-            db_id = None
-            if db_response and hasattr(db_response, 'data') and db_response.data and len(db_response.data) > 0:
-                db_id = str(db_response.data[0].get('id')) 
-            elif isinstance(db_response, list) and db_response and isinstance(db_response[0], dict): 
-                 db_id = str(db_response[0].get('id'))
-
-        except Exception as e:
-            print(f"Fehler beim Speichern der Karte in Supabase: {e}")
+        # save_card ist bereits asynchron (await)
+        db_response = await save_card(supabase, card_data_for_db)
+        db_id = None
+        # ... existing database response handling ...
+        if db_response and hasattr(db_response, 'data') and db_response.data and len(db_response.data) > 0:
+            db_id = str(db_response.data[0].get('id')) 
+        elif isinstance(db_response, list) and db_response and isinstance(db_response[0], dict): 
+             db_id = str(db_response[0].get('id'))
 
         return CardGenerateResponse(
-            message="Horoskopkarte erfolgreich generiert.",
-            # Der card_id in der Response sollte nun auch die neue UUID sein, wenn db_id nicht verfügbar ist
+            message="Karte erfolgreich generiert.",
             card_id=db_id if db_id else card_id_for_url, 
             qr_code_image_url=qr_code_url
         )
-
+    # ... existing error handling ...
     except FileNotFoundError as e:
         print(f"FileNotFoundError in generate_endpoint: {e}")
         raise HTTPException(status_code=500, detail=f"Ein benötigtes Template oder eine Datei wurde nicht gefunden: {e.filename}")

app/api/v1/schemas/card_schemas.py

@@ -79,7 +79,7 @@ class CardData(BaseModel):
     session_id: Optional[uuid.UUID] = Field(None, description="Session ID used for the request.")
     lang: Optional[str] = Field(None, description="Language used for generation.")
     prompt_text: Optional[str] = Field(None, description="The prompt text used for generation.")
-    model_info: Optional[dict] = Field(None, description="Information about the model used.")
+    ml_model_info: Optional[dict] = Field(None, description="Information about the model used.")
     generation_params: Optional[dict] = Field(None, description="Parameters used for text generation.")
 
 class CardDBSchema(BaseModel):
@@ -92,7 +92,7 @@ class CardDBSchema(BaseModel):
     session_id: UUID4  # Corresponds to uuid.UUID(card_id_for_url)
     lang: str
     prompt_text: str
-    model_info: Dict[str, Any]  # The field causing the warning
+    ml_model_info: Dict[str, Any]  # The field causing the warning
     generation_params: Dict[str, Any]
 
     # Add this model_config to resolve the warning

app/core/card_renderer.py

@@ -12,28 +12,28 @@ def generate_card(
     output_path: Path
 ) -> str:
     """
-    Generiert eine Horoskopkarte und speichert sie.
+    Generiert eine Karte und speichert sie.
     Verwendet jetzt übergebene Pfade für mehr Flexibilität und Testbarkeit.
     Gibt die UUID der generierten Datei (ohne Erweiterung) zurück.
     """
     try:
         # Basiskarte laden
-        base_image_file = base_images_path / f"{card_design_id}.png"
+        base_image_file = base_images_path / f"base{card_design_id}.png"
         if not base_image_file.exists():
-            raise FileNotFoundError(f"Basiskartenbild nicht gefunden: {base_image_file}")
+            raise FileNotFoundError(f"Basiskartenbild nicht gefunden: base{base_image_file}")
         card_design_img = Image.open(base_image_file).convert("RGBA")
 
         # Symbole hinzufügen
         # Die Positionierung hier ist ein Beispiel und muss ggf. angepasst werden
         symbol_x_start = 50
-        symbol_y_start = 400 # Beispiel Y-Position
-        symbol_spacing = 10 # Beispiel Abstand
+        symbol_y_start = 400
+        symbol_spacing = 10
         current_x = symbol_x_start
 
         for i, sid in enumerate(symbol_ids):
-            symbol_file = symbols_images_path / f"{sid}.png"
+            symbol_file = symbols_images_path / f"symbol{sid}.png"
             if not symbol_file.exists():
-                print(f"Warnung: Symbolbild nicht gefunden: {symbol_file}, wird übersprungen.")
+                print(f"Warnung: Symbolbild nicht gefunden: symbol{symbol_file}, wird übersprungen.")
                 continue
             symbol_img = Image.open(symbol_file).convert("RGBA")
             

app/core/config.py

@@ -1,7 +1,6 @@
 from pathlib import Path
 from pydantic_settings import BaseSettings, SettingsConfigDict
 from typing import ClassVar
-import os
 
 # Determine base directory based on environment
 current_file = Path(__file__).resolve()
@@ -19,6 +18,7 @@ class Settings(BaseSettings):
 
     MODEL_PATH: str = str(_CARDSERVER_DIR_CLS / "models" / "lora-checkpoint") 
     DEFAULT_MODEL_ID: str = "teknium/OpenHermes-2.5-Mistral-7B" 
+    MODEL_LOAD_IN_4BIT: bool = True  # Default to True for 4-bit loading
 
     GENERATED_PATH: str = str(_APP_DEFAULT_STATIC_DIR_CLS / "images" / "generated") 
     BASE_PATH: str = str(_APP_DEFAULT_STATIC_DIR_CLS / "images" / "base") 

app/core/constraints.py

@@ -1,34 +1,24 @@
 # constraints.py
 # Constraints: Begriffe prüfen, Filter
+from fastapi.concurrency import run_in_threadpool # Importieren
 
 def check_constraints(output: str, terms: list[str]) -> bool:
     if not terms: # Wenn keine Begriffe vorgegeben sind, ist die Bedingung immer erfüllt
         return True
     return all(term.lower() in output.lower() for term in terms)
 
-def generate_with_retry(prompt: str, generator, terms: list[str], max_retries: int = 3, generation_params: dict | None = None):
+async def generate_with_retry(prompt: str, generator, terms: list[str], max_retries: int = 3, generation_params: dict | None = None): # async def
     """
     Generiert Text mit Wiederholungsversuchen, bis die Bedingungen (Constraints) erfüllt sind.
-
-    Args:
-        prompt (str): Der Eingabe-Prompt für den Generator.
-        generator: Die Text-Generierungs-Pipeline oder -Funktion.
-        terms (list[str]): Eine Liste von Begriffen, die im generierten Text enthalten sein müssen.
-        max_retries (int): Maximale Anzahl von Wiederholungsversuchen.
-        generation_params (dict | None): Zusätzliche Parameter für den Generator.
-
-    Returns:
-        str: Der generierte Text, der die Bedingungen erfüllt, oder eine Fehlermeldung.
+    Führt die eigentliche Generierung in einem Threadpool aus.
     """
     if generation_params is None:
         generation_params = {}
         
     for attempt in range(max_retries):
         try:
-            # Stelle sicher, dass der Prompt als erster Parameter übergeben wird,
-            # und generation_params als Keyword-Argumente.
-            # Die meisten Hugging Face Pipelines erwarten den Prompt als positional argument.
-            responses = generator(prompt, **generation_params)
+            # Führe die blockierende Generator-Funktion im Threadpool aus
+            responses = await run_in_threadpool(generator, prompt, **generation_params)
             
             # Die Struktur der Antwort kann variieren. Üblich ist eine Liste von Diktionären.
             if responses and isinstance(responses, list) and responses[0].get("generated_text"):
@@ -44,6 +34,6 @@ def generate_with_retry(prompt: str, generator, terms: list[str], max_retries: i
             print(f"Fehler bei der Textgenerierung (Versuch {attempt + 1}/{max_retries}): {e}")
             # Optional: Kurze Pause vor dem nächsten Versuch
             # import time
-            # time.sleep(0.5)
+            # await asyncio.sleep(0.5) # Wenn async, dann asyncio.sleep
             
     return "Leider konnte kein gültiger Text erzeugt werden."

app/core/model_loader.py

@@ -6,20 +6,25 @@ from pathlib import Path
 import os
 from .config import settings
 from .hf_api import HuggingFaceWrapper
+from functools import lru_cache # Import lru_cache
 
 logger = logging.getLogger(__name__)
 
 
-def load_model():
+# Globale Variable für die Pipeline, um sie zwischenzuspeichern
+# _cached_generator_pipeline = None # Entfernt, da wir lru_cache verwenden
+
+def load_model_and_tokenizer(): # Umbenannt und gibt jetzt model und tokenizer zurück
     """
     Optimierter Model Loader mit LoRA-Support.
+    Lädt Basismodell und Tokenizer.
     Kann LoRA-Adapter von Hugging Face Hub herunterladen.
     Automatische Konfiguration basierend auf verfügbaren Ressourcen.
     """
     base_model_id = settings.DEFAULT_MODEL_ID
     hf_token = os.getenv("HF_API_KEY")
 
-    logger.info(f"Lade Basismodell: {base_model_id}")
+    logger.info(f"Lade Basismodell und Tokenizer: {base_model_id}")
 
     try:
         tokenizer = AutoTokenizer.from_pretrained(base_model_id, token=hf_token)
@@ -32,9 +37,9 @@ def load_model():
         tokenizer.pad_token = tokenizer.eos_token
 
     model_kwargs = {
-        "torch_dtype": torch.float16,  # Standardmäßig float16
+        "torch_dtype": torch.float16,
         "device_map": "auto",
-        "trust_remote_code": True,  # Notwendig für einige Modelle
+        "trust_remote_code": True,
         "token": hf_token
     }
 
@@ -120,15 +125,46 @@ def load_model():
     else:
         logger.info("Keine LoRA-Gewichte zum Laden spezifiziert oder gefunden. Verwende Basismodell.")
 
-    pipe = pipeline(
+    return model, tokenizer
+
+
+@lru_cache(maxsize=None) # Cache die Pipeline-Erstellung
+def get_generator():
+    """
+    Lädt das Modell und den Tokenizer (beim ersten Aufruf) 
+    und erstellt eine Textgenerierungs-Pipeline.
+    Die Pipeline wird gecacht.
+    """
+    # global _cached_generator_pipeline # Entfernt
+    # if _cached_generator_pipeline is None: # Entfernt
+    logger.info("Initialisiere Textgenerierungs-Pipeline...")
+    model, tokenizer = load_model_and_tokenizer() # Ruft die geänderte Funktion auf
+    
+    # Sicherstellen, dass pad_token_id gesetzt ist, wenn es im Tokenizer existiert
+    # Dies ist wichtig für einige Modelle, um Warnungen oder Fehler zu vermeiden
+    if tokenizer.pad_token_id is None and tokenizer.eos_token_id is not None:
+        logger.info(f"pad_token_id nicht im Tokenizer gefunden. Setze pad_token_id auf eos_token_id ({tokenizer.eos_token_id}).")
+        tokenizer.pad_token_id = tokenizer.eos_token_id
+        # Das Modell muss möglicherweise auch aktualisiert werden, wenn pad_token_id zur Laufzeit geändert wird
+        # Dies ist jedoch oft nicht notwendig, wenn das Modell bereits mit einem eos_token trainiert wurde.
+        # model.config.pad_token_id = tokenizer.pad_token_id
+
+    # Device für die Pipeline explizit setzen, falls nicht automatisch korrekt erkannt
+    # device = 0 if torch.cuda.is_available() else -1 # 0 für erste GPU, -1 für CPU
+    # Wenn device_map="auto" im Modell verwendet wird, sollte die Pipeline dies respektieren.
+    # Für explizite Kontrolle:
+    device = model.device # Das Gerät des Modells verwenden
+    
+    _cached_generator_pipeline = pipeline(
         "text-generation",
         model=model,
         tokenizer=tokenizer,
-        return_full_text=False
+        device=device # Gerät explizit übergeben
     )
-
-    logger.info("Text-Generierungs-Pipeline erfolgreich erstellt.")
-    return pipe
+    logger.info(f"Textgenerierungs-Pipeline erfolgreich initialisiert und auf Gerät {device} geladen.")
+    # else: # Entfernt
+        # logger.debug("Verwende gecachte Textgenerierungs-Pipeline.") # Entfernt
+    return _cached_generator_pipeline
 
 
 def get_model_info():
@@ -142,11 +178,8 @@ def get_model_info():
         "gpu_count": torch.cuda.device_count() if torch.cuda.is_available() else 0
     }
 
-_generator = None
-
-def get_generator():
-    """Thread-safe Generator abrufen"""
-    global _generator
-    if _generator is None:
-        _generator = load_model()
-    return _generator
+# Optional: Pre-load model at startup if desired (in main.py or similar)
+# def preload_model():
+#     logger.info("Starte Pre-Loading des Modells...")
+#     get_generator()
+#     logger.info("Modell erfolgreich vorab geladen.")

app/main.py

@@ -3,6 +3,7 @@ from fastapi.staticfiles import StaticFiles
 from fastapi.middleware.cors import CORSMiddleware
 from .api.v1.endpoints import generate, download, health
 from .core.config import settings
+from .core.model_loader import get_generator  # Import get_generator
 from contextlib import asynccontextmanager
 from pathlib import Path
 import logging
@@ -20,20 +21,21 @@ settings.resolved_qr_code_path.mkdir(parents=True, exist_ok=True)
 # Ensure the static mount directory exists
 settings.resolved_static_files_mount_dir.mkdir(parents=True, exist_ok=True)
 
+# Lifecycle management for the model
 @asynccontextmanager
 async def lifespan(app: FastAPI):
-    logger.info(f"{settings.PROJECT_NAME} Anwendung startet...")
-    logger.info(f"  Current working directory: {Path.cwd()}")
-    logger.info(f"  Config file location: {Path(__file__).resolve()}")
-    logger.info(f"  Model Path: {settings.resolved_model_path}")
-    logger.info(f"  Generated Images Path: {settings.resolved_generated_path}")
-    logger.info(f"  Base Images Path: {settings.resolved_base_path}")
-    logger.info(f"  Symbols Path: {settings.resolved_symbols_path}")
-    logger.info(f"  QR Codes Path: {settings.resolved_qr_code_path}")
-    logger.info(f"  Static Files Mount Dir: {settings.resolved_static_files_mount_dir}")
-    logger.info(f"  Default Font Path: {settings.resolved_default_font_path}")
+    # Startup: Preload the model
+    logger.info("Anwendung startet... Lade das LLM-Modell vorab.")
+    try:
+        get_generator()  # Calls get_generator to load and cache the model
+        logger.info("LLM-Modell erfolgreich vorab geladen und Pipeline initialisiert.")
+    except Exception as e:
+        logger.error(f"Fehler beim Vorabladen des LLM-Modells: {e}", exc_info=True)
+        # Decide whether to prevent the application from starting
+        # raise # Uncomment to prevent startup on error
     yield
-    logger.info(f"{settings.PROJECT_NAME} Anwendung wird heruntergefahren.")
+    # Shutdown: Cleanup actions could go here (not currently needed for the model)
+    logger.info("Anwendung wird heruntergefahren.")
 
 app = FastAPI(
     title=settings.PROJECT_NAME,  
@@ -48,7 +50,7 @@ try:
     logger.info(f"Attempting to mount static directory: {static_dir}")
     logger.info(f"Static directory exists: {static_dir.exists()}")
     if static_dir.exists():
-        app.mount("/static", StaticFiles(directory=static_dir), name="static")
+        app.mount(f"{settings.API_PREFIX}/static", StaticFiles(directory=static_dir), name="static")
         logger.info("Static files mounted successfully")
     else:
         logger.warning(f"Static directory does not exist: {static_dir}")
@@ -57,7 +59,7 @@ try:
         # Create basic subdirectories
         (static_dir / "images").mkdir(exist_ok=True)
         (static_dir / "fonts").mkdir(exist_ok=True)
-        app.mount("/static", StaticFiles(directory=static_dir), name="static")
+        app.mount(f"{settings.API_PREFIX}/static", StaticFiles(directory=static_dir), name="static")
         logger.info("Static files mounted with created directory")
 except Exception as e:
     logger.error(f"Failed to mount static files: {e}")

app/utils/qr_utils.py

@@ -1,8 +1,36 @@
 import qrcode
 from pathlib import Path
+import uuid # Import uuid
 
-def generate_qr_code(link: str, output_path: Path) -> Path:
-    qr = qrcode.make(link)
-    output_path.parent.mkdir(parents=True, exist_ok=True)
-    qr.save(output_path)
-    return output_path
+def generate_qr_code_sync(data: str, output_path: Path, size: int) -> str:
+    """
+    Generiert einen QR-Code und speichert ihn.
+    Gibt die UUID der generierten Datei (ohne Erweiterung) zurück.
+    Der Parameter 'size' wird hier nicht direkt von qrcode.make verwendet,
+    aber die Standardeinstellungen sind oft ausreichend. Für eine exakte Pixelgröße
+    müsste man qrcode.QRCode mit box_size und border verwenden.
+    """
+    qr = qrcode.QRCode(
+        version=1, # Standard
+        error_correction=qrcode.constants.ERROR_CORRECT_L, # Standard
+        # box_size steuert die Pixel pro "Box" des QR-Codes.
+        # Um die Gesamtgröße (size) zu erreichen, müsste man box_size berechnen.
+        # Beispiel: box_size=size // (anzahl_module + 2 * border_module)
+        # Für Einfachheit lassen wir es bei den Defaults oder einem festen Wert.
+        box_size=10, # Kann angepasst werden, um die 'size' besser zu treffen
+        border=4,    # Standard
+    )
+    qr.add_data(data)
+    qr.make(fit=True)
+
+    img = qr.make_image(fill_color="black", back_color="white")
+    
+    # Sicherstellen, dass das Ausgabeverzeichnis existiert
+    output_path.mkdir(parents=True, exist_ok=True)
+    
+    file_id = str(uuid.uuid4()) # Eindeutige ID für die Datei
+    file_path_with_id = output_path / f"{file_id}.png"
+    
+    img.save(file_path_with_id)
+    
+    return file_id # Gibt die UUID (ohne .png) zurück

scripts/quick_test.sh

@@ -1,58 +0,0 @@
-#!/bin/bash
-# Quick test script for Museum Sexoskop App
-
-BASE_URL="https://ch404-cardserver.hf.space"
-echo "🧪 Testing Museum Sexoskop App at: $BASE_URL"
-echo "=============================================="
-
-# Function to test an endpoint
-test_endpoint() {
-    local name="$1"
-    local url="$2"
-    local method="$3"
-    local data="$4"
-    
-    echo -e "\n🔍 Testing: $name"
-    echo "   URL: $url"
-    
-    if [ "$method" = "POST" ]; then
-        response=$(curl -s -w "\n%{http_code}" -X POST "$url" \
-                   -H "Content-Type: application/json" \
-                   -d "$data")
-    else
-        response=$(curl -s -w "\n%{http_code}" "$url")
-    fi
-    
-    # Split response and status code  
-    status_code=$(echo "$response" | tail -1)
-    body=$(echo "$response" | sed '$d')
-    
-    if [ "$status_code" = "200" ]; then
-        echo "   ✅ SUCCESS (200 OK)"
-        if command -v jq &> /dev/null; then
-            echo "$body" | jq . 2>/dev/null || echo "   📝 Response: $body"
-        else
-            echo "   📝 Response: $body"
-        fi
-    elif [ "$status_code" = "404" ]; then
-        echo "   ❌ NOT FOUND (404) - Space may not be running yet"
-    elif [ "$status_code" = "500" ]; then
-        echo "   ❌ SERVER ERROR (500) - Check space logs"
-    else
-        echo "   ⚠️  Status Code: $status_code"
-        echo "   📝 Response: $body"
-    fi
-}
-
-# Test endpoints
-test_endpoint "Health Check" "$BASE_URL/api/v1/health" "GET"
-
-test_endpoint "Root Endpoint" "$BASE_URL/" "GET"
-
-test_endpoint "Generate Horoscope" "$BASE_URL/api/v1/generate-horoscope" "POST" \
-    '{"terms": ["Test","Deploy","Success","Working","Happy"], "date_of_birth": "1990-01-01"}'
-
-echo -e "\n🏁 Testing complete!"
-echo "💡 If you see 404 errors, the space may still be deploying."
-echo "💡 If you see 500 errors, check the space logs on HuggingFace."
-echo "💡 Space URL: https://huggingface.co/spaces/ch404/cardserver"

scripts/start.sh

@@ -1,24 +0,0 @@
-#!/bin/bash
-# Startup script for debugging HF Space deployment
-
-echo "🔍 DEBUG: Starting Museum Sexoskop App"
-echo "📁 Current directory: $(pwd)"
-echo "📁 Directory contents:"
-ls -la
-
-echo "🐍 Python version: $(python --version)"
-echo "📦 Installed packages:"
-pip list | grep -E "(fastapi|uvicorn|pydantic|pillow|qrcode|transformers|torch)"
-
-echo "📁 App directory structure:"
-find /app -type d -name "app" -o -name "static" -o -name "templates" | head -20
-
-echo "🔧 Testing configuration..."
-if [ -f "/app/tests/test_config.py" ]; then
-    python tests/test_config.py
-else
-    echo "❌ tests/test_config.py not found"
-fi
-
-echo "🚀 Starting FastAPI server..."
-exec uvicorn app.main:app --host 0.0.0.0 --port 7860 --log-level debug

scripts/setup_training.sh → setup_training.sh

@@ -1,23 +1,33 @@
 #!/bin/bash
 # Schnelles Setup-Script für LORA-Training
 
+set -e # Exit immediately if a command exits with a non-zero status.
+
+# Determine the absolute path of the script (which is also the project root)
+PROJECT_ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+
 echo "🚀 Setup für kostengünstiges LORA-Training"
 echo "=========================================="
+echo "🔧 Script wird ausgeführt von: $PROJECT_ROOT"
+echo "📂 Projekt-Root-Verzeichnis: $PROJECT_ROOT"
 
 # 1. Virtuelle Umgebung erstellen (optional)
-echo "📦 Erstelle virtuelle Umgebung..."
-python3 -m venv venv_training
-source venv_training/bin/activate
+echo "📦 Erstelle virtuelle Umgebung in '$PROJECT_ROOT/venv_training'..."
+python3 -m venv "$PROJECT_ROOT/venv_training"
+echo "✨ Virtuelle Umgebung '$PROJECT_ROOT/venv_training' erstellt."
+echo "👉 Zum manuellen Aktivieren für spätere Sitzungen: source '$PROJECT_ROOT/venv_training/bin/activate'"
+source "$PROJECT_ROOT/venv_training/bin/activate"
+echo "✅ Virtuelle Umgebung für diese Skript-Sitzung aktiviert."
 
 # 2. Requirements installieren
 echo "📥 Installiere Training-Dependencies..."
-pip install -r training_requirements.txt
-pip install -r ../requirements.txt
+pip install -r "$PROJECT_ROOT/training/training_requirements.txt"
+pip install -r "$PROJECT_ROOT/requirements.txt" # General project requirements from root
 
 # 3. Training-Ordner vorbereiten
 echo "📁 Erstelle Training-Struktur..."
-mkdir -p ../models/lora-checkpoint
-mkdir -p data
+mkdir -p "$PROJECT_ROOT/models/lora-checkpoint"
+mkdir -p "$PROJECT_ROOT/training/data" # For training data
 
 # 4. GPU-Check
 echo "🔍 GPU-Verfügbarkeit prüfen..."
@@ -27,11 +37,18 @@ echo ""
 echo "✅ Setup abgeschlossen!"
 echo ""
 echo "🎯 Nächste Schritte:"
-echo "1. Trainingsdaten in data/ ablegen (JSON-Format)"
-echo "2. Training starten: python train_lora.py"
-echo "3. Geschätzter Speicherbedarf: ~8-12GB RAM + ~4GB VRAM"
+echo "1. Trainingsdaten in '$PROJECT_ROOT/training/data/' ablegen (JSON-Format, z.B. cards_training_data.json)."
+echo "2. Sicherstellen, dass die virtuelle Umgebung aktiv ist. Falls nicht, aktivieren mit:"
+echo "   source '$PROJECT_ROOT/venv_training/bin/activate'"
+echo "3. Zum Training-Verzeichnis wechseln und Training starten:"
+echo "   cd '$PROJECT_ROOT/training/'"
+echo "   python train_lora.py"
+echo "4. Geschätzter Speicherbedarf: ~8-12GB RAM + ~4GB VRAM"
 echo ""
 echo "💰 Kostenoptimierung:"
 echo "- Lokales Training: 0€ (nur Stromkosten)"
 echo "- Cloud-Alternative: Google Colab Pro (~10€/Monat)"
 echo "- Training-Zeit: ~2-4 Stunden je nach Datenmenge"
+echo ""
+echo "💡 Die virtuelle Umgebung '$PROJECT_ROOT/venv_training' ist derzeit in dieser Shell-Sitzung aktiv."
+echo "   Um sie zu verlassen (deaktivieren), tippe: deactivate"