🚀 Auto-deploy from GitHub

.gitignore

@@ -1,21 +1,199 @@
 .git
 __pycache__
 __pycache__/
-*.pyc
-*.pyo
-*.pyd
-*.egg-info/
+*.py[cod]
+*$py.class
+*.pyd # Added from user prompt
+
+# C extensions
+*.so
+
+# Distribution / packaging
 .Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+pip-wheel-metadata/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+node_modules/ # Added from existing, good to keep
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache # Moved from ML section, as it's general
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover # Corrected from *.py,cover
+.hypothesis/
+.pytest_cache/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+# *.log # Moved to general logs
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints/
+*.ipynb # Moved from ML section
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+.python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don\'t work, or not
+#   install all needed dependencies.
+Pipfile.lock
+
+# poetry
+#poetry.lock
+
+# pdm
+#pdm.lock
+#pd.toml
+
+# PEP 582; __pypackages__ directory
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
 env/
 venv/
-.venv/
-.vscode/
+ENV/
+env.bak/
+venv.bak/
+# Specific training venvs from existing .gitignore
+training/env/
+training/.venv/
+**/venv_training/ # This covers training/venv_training/ from user prompt as well
+
+# IDE specific
+.vscode/ # Covers .vscode/settings.json
 .idea/
 *.swp
 *.swo
+*~
+
+# OS Specific
 .DS_Store
+.DS_Store? # From existing
+._* # From existing
+.Spotlight-V100 # From existing
+.Trashes # From existing
 Thumbs.db
-*.env
-secrets.txt
-*.log
-local_settings.py
+ehthumbs.db # From existing
+
+# Secrets / Sensitive Config
+secrets.txt # From existing
+*.env # From existing, consolidated here
+
+# Log files
+*.log # Consolidated from Django and general
+
+# Temporary files
+*.tmp
+temp/
+tmp/
+
+# ================================
+# ML & Training specific ignores
+# ================================
+
+# Virtual environments (training) - Covered by general Environments and **/venv_training/
+# training/venv_training/ # Redundant
+
+# Model files & checkpoints (sehr groß!)
+models/*/
+training/models/
+training/checkpoints/
+# training/outputs/ # Moved to logs/outputs as it's often mixed
+cardserver/models/lora-checkpoint/ # From user prompt
+# Common model file extensions
+*.bin
+*.safetensors
+*.ckpt
+*.pt
+*.pth
+*.h5
+*.hdf5
+
+# PyTorch & CUDA cache
+.torch/
+.torchvision/
+.triton/
+# .cache/ # Moved to unit test/coverage reports as it's more general
+
+# Training logs & outputs
+training/logs/
+training/runs/
+training/wandb/ # Covers wandb/ from existing
+training/outputs/ # Consolidated from existing
+tensorboard_logs/
+mlruns/
+
+# Datasets (können groß sein)
+training/data/large_datasets/
+training/data/*.parquet
+training/data/*.arrow
+training/data/*.csv
+training/data/*.json.gz
+training/data/*.jsonl
+
+# Dependencies that should be reinstalled (already covered by build/, dist/, etc.)
+# node_modules/ # Covered
+# dist/ # Covered
+# build/ # Covered

Dockerfile

@@ -19,3 +19,4 @@ RUN chmod +x start.sh
 
 # Start FastAPI with debug startup script
 CMD ["./start.sh"]
+

app/api/v1/endpoints/download.py

@@ -16,9 +16,7 @@ async def download_generated_image(
     Download a custom generated image using the card_id to find the image path from Supabase.
     """
     try:
-        # Query Supabase for the image record using card_id
-        # Assuming your table is named 'horoscope_cards' and has 'id' and 'image_path'
-        response = supabase.table("horoscope_cards").select("image_path").eq("id", card_id).execute()
+        response = supabase.table("cards").select("image_path").eq("id", card_id).execute()
         
         if not response.data:
             raise HTTPException(status_code=404, detail="Card not found in database")

app/api/v1/endpoints/generate.py

@@ -1,200 +1,124 @@
 from fastapi import APIRouter, HTTPException, Depends
-import os
 from dotenv import load_dotenv
-
-# Supabase Client importieren
 from supabase import Client
-
-# Eigene Modulimporte
-from ..schemas.horoscope_schemas import HoroscopeGenerateRequest, HoroscopeGenerateResponse
-from ....core.generator import build_prompt, get_zodiac
-from ....core.card_renderer import generate_card as render_horoscope_card # Umbenannt für Klarheit
+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 ....services.database import get_supabase_client, save_horoscope_card
-from ....core.config import settings # Für Pfade und URLs
-
-# Model-Ladefunktionen (angenommen, diese bleiben ähnlich, aber ggf. anpassen)
-from transformers import AutoTokenizer, AutoModelForCausalLM, pipeline
-from peft import PeftModel
+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
 
 load_dotenv()
 router = APIRouter()
 
-# --- Globale Variablen und Modell-Ladefunktion ---
-MODEL_PATH = os.getenv("MODEL_PATH", settings.MODEL_PATH) # Aus settings holen
-DEFAULT_MODEL_ID = os.getenv("DEFAULT_MODEL_ID", settings.DEFAULT_MODEL_ID) # Aus settings holen
-text_generator_pipeline = None
-
-def load_language_model():
-    global text_generator_pipeline
-    if text_generator_pipeline is not None:
-        return text_generator_pipeline
-    
-    try:
-        tokenizer = AutoTokenizer.from_pretrained(DEFAULT_MODEL_ID)
-        model = AutoModelForCausalLM.from_pretrained(
-            DEFAULT_MODEL_ID, 
-            load_in_4bit=True, 
-            device_map="auto" # "auto" für GPU-Nutzung falls verfügbar
-        )
-        # Versuche, LoRA-Gewichte zu laden
-        if settings.resolved_model_path.exists(): # Prüfen ob der Pfad existiert
-            try:
-                model = PeftModel.from_pretrained(model, str(settings.resolved_model_path))
-            except Exception as e:
-                print(f"Konnte LoRA-Modell nicht laden von {settings.resolved_model_path}: {e}. Fallback auf Basismodell.")
-                # Hier könnte man entscheiden, ob man einen Fehler wirft oder mit dem Basismodell weitermacht
-        else:
-            print(f"LoRA-Modellpfad {settings.resolved_model_path} nicht gefunden. Verwende Basismodell.")
-
-        text_generator_pipeline = pipeline(
-            "text-generation", 
-            model=model, 
-            tokenizer=tokenizer,
-            # Ggf. weitere Pipeline-Parameter hier
-        )
-        return text_generator_pipeline
-    except Exception as e:
-        # Loggen des Fehlers wäre hier gut
-        raise HTTPException(status_code=500, detail=f"Fehler beim Laden des Sprachmodells: {str(e)}")
-
-# Sicherstellen, dass das Modell beim Start geladen wird (optional, kann auch lazy loading sein)
-# load_language_model()
-
-
-@router.post("/generate-horoscope", response_model=HoroscopeGenerateResponse)
-async def generate_horoscope_endpoint(
-    request: HoroscopeGenerateRequest, 
+@router.post("/generate", response_model=CardGenerateResponse)
+async def generate_endpoint(
+    request: CardGenerateRequest, 
     supabase: Client = Depends(get_supabase_client)
 ):
     try:
-        # 1. Prompt erstellen
-        # Annahme: 'lang' ist fest auf 'de' gesetzt oder kommt aus der Anfrage/Config
-        lang = "de" 
-        birthdate_str = request.date_of_birth.isoformat()
+        lang = request.lang or "de"
+        input_date_str = request.card_date.isoformat()
         
-        horoscope_prompt = build_prompt(
+        card_prompt = build_prompt(
             lang=lang,
-            birthdate=birthdate_str,
+            card_date=input_date_str,
             terms=request.terms
         )
 
-        # 2. Horoskoptext generieren
-        llm_pipeline = load_language_model()
-        # Parameter für die Textgenerierung (könnten auch aus request oder config kommen)
+        llm_pipeline = get_generator()
+        
         generation_params = {
-            "max_length": 200, # Beispielwert
-            "temperature": 0.75, # Beispielwert
-            "do_sample": True,
-            "return_full_text": False 
+            "max_new_tokens": settings.GENERATION_MAX_NEW_TOKENS,
+            "temperature": settings.GENERATION_TEMPERATURE,
+            "do_sample": settings.GENERATION_DO_SAMPLE,
+            "top_k": settings.GENERATION_TOP_K,
+            "top_p": settings.GENERATION_TOP_P,
+            "return_full_text": False
         }
         
-        # Der Prompt selbst ist der Input für die Pipeline
-        # Die Hugging Face Pipeline erwartet den Prompt als ersten Parameter
-        # und die anderen Parameter als kwargs.
-        # Der 'prompt' im request.prompt von vorher ist jetzt 'horoscope_prompt'
-        generated_outputs = llm_pipeline(horoscope_prompt, **generation_params)
-        
-        if not generated_outputs or not generated_outputs[0]["generated_text"]:
-            raise HTTPException(status_code=500, detail="Textgenerierung fehlgeschlagen oder leerer Text.")
-        
-        horoscope_text = generated_outputs[0]["generated_text"].strip()
-        
-        # (Optional) Constraints prüfen, falls implementiert in app.core.constraints
-        # from app.core.constraints import check_constraints, generate_with_retry
-        # if not check_constraints(horoscope_text, request.terms):
-        #     # Hier könnte eine Retry-Logik oder Fehlerbehandlung erfolgen
-        #     pass
+        # Verwende generate_with_retry aus constraints.py
+        card_text = generate_with_retry(
+            prompt=card_prompt,
+            generator=llm_pipeline,
+            terms=request.terms,
+            max_retries=settings.GENERATION_MAX_RETRIES,
+            generation_params=generation_params
+        )
 
+        if card_text == "Leider konnte kein gültiger Text erzeugt werden." or not check_constraints(card_text, request.terms):
+            raise HTTPException(
+                status_code=500, 
+                detail="Kartentext konnte nicht generiert werden oder erfüllt nicht die Bedingungen."
+            )
 
-        # 3. Horoskopkarte rendern
-        # Annahmen für tarot_id und symbol_ids - diese müssten dynamisch werden
-        tarot_id = 1 # Beispiel
-        symbol_ids = [1, 2, 3, 4] # Beispiel
+        # 4. QR-Code generieren
+        card_id_for_url = str(uuid.uuid4())
+        qr_content_url = f"{settings.FRONTEND_BASE_URL}/card/{card_id_for_url}"
         
-        # card_renderer.generate_card speichert die Karte und gibt eine file_id (UUID) zurück
-        # Der Pfad wird in config.py über settings.resolved_generated_path definiert
-        # und card_renderer sollte diesen verwenden oder einen relativen Pfad dazu.
-        # Für generate_card:
-        # base_path = settings.resolved_base_path
-        # symbols_path = settings.resolved_symbols_path
-        # font_path = settings.resolved_default_font_path
-        # output_dir = settings.resolved_generated_path
-        # Diese Pfade müssen in card_renderer.py korrekt verwendet werden.
-        
-        # Temporäre Annahme: generate_card gibt den Dateinamen (inkl. Erweiterung) zurück
-        # und speichert im korrekten `settings.resolved_generated_path`
-        card_file_id = render_horoscope_card(
-            tarot_id=tarot_id, 
-            symbol_ids=symbol_ids, 
-            text=horoscope_text,
-            # Übergabe der Pfade an card_renderer, falls es diese nicht selbst aus settings holt
+        qr_code_file_id = generate_qr_code(
+            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(
+            card_design_id=card_design_id_to_render,
+            symbol_ids=symbol_ids_to_render,
+            text=card_text,
             base_images_path=settings.resolved_base_path,
             symbols_images_path=settings.resolved_symbols_path,
             font_path=settings.resolved_default_font_path,
             output_path=settings.resolved_generated_path
         )
-        card_image_filename = f"{card_file_id}.png" # Annahme, dass generate_card die ID ohne Extension zurückgibt
-
-        # 4. QR-Code erstellen
-        # Der Link im QR-Code sollte auf den Download-Endpunkt für das Bild zeigen
-        # z.B. HOST_URL/api/v1/download/image?image_id=<card_file_id>
-        # Die HOST_URL sollte aus den Settings kommen (ggf. anpassen in config.py)
-        host_url = os.getenv("HOST_URL", "http://localhost:8000") # Fallback, besser aus settings
-        
-        # Der image_id Parameter für den Download-Endpunkt ist die card_file_id (UUID)
-        qr_code_content_link = f"{host_url}{settings.API_PREFIX}/download/image/{card_file_id}"
-        
-        qr_code_filename_base = f"qr_{card_file_id}.png"
-        qr_code_save_path = settings.resolved_qr_code_path / qr_code_filename_base
-        
-        generate_qr_code(link=qr_code_content_link, output_path=qr_code_save_path)
-
-        # 5. Daten in Supabase speichern
-        # Die Tabelle sollte 'horoscope_cards' heißen und Spalten gemäß HoroscopeCardData haben
-        # (id, terms, date_of_birth, horoscope_text, image_filename, qr_code_filename, qr_code_link)
-        save_horoscope_card(
-            supabase_client=supabase, # Übergeben des Supabase Clients
-            card_id=card_file_id, # UUID als String
-            terms=request.terms,
-            date_of_birth=birthdate_str,
-            horoscope_text=horoscope_text,
-            image_filename=card_image_filename,
-            qr_code_filename=qr_code_filename_base,
-            qr_code_link=qr_code_content_link
-        )
 
-        # 6. Antwort an Frontend
-        # Die URL zum QR-Code-Bild, das direkt im Frontend angezeigt werden kann
-        # z.B. HOST_URL/static/images/qr/qr_<card_file_id>.png
-        # Der /static Pfad wird in main.py gemountet
-        qr_code_image_url = f"{host_url}/static/images/qr/{qr_code_filename_base}"
+        card_data_for_db = {
+            "terms": request.terms,
+            "card_date": input_date_str, 
+            "card_text": card_text,
+            "image_filename": f"{card_file_id}.png",
+            "qr_code_filename": f"{qr_code_file_id}.png",
+            "qr_code_link": qr_content_url,
+            "session_id": uuid.UUID(card_id_for_url),
+            "lang": lang,
+            "prompt_text": card_prompt,
+            "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
+        }
         
-        return HoroscopeGenerateResponse(
-            card_id=card_file_id,
-            qr_code_image_url=qr_code_image_url,
-            message="Horoskopkarte erfolgreich generiert."
+        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}")
+
+        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
+            card_id=db_id if db_id else card_id_for_url, 
+            qr_code_image_url=qr_code_url
         )
 
     except FileNotFoundError as e:
-        # Speziell für Template-Fehler
-        raise HTTPException(status_code=500, detail=f"Eine benötigte Datei wurde nicht gefunden: {str(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}")
     except HTTPException as e:
-        # Weiterleiten von HTTPExceptions (z.B. vom Modell-Laden)
         raise e
     except Exception as e:
-        # Allgemeiner Fehler, hier wäre besseres Logging wichtig
-        print(f"Unerwarteter Fehler im generate_horoscope_endpoint: {type(e).__name__} - {str(e)}")
-        # Stacktrace loggen für Debugging:
         import traceback
+        print(f"Unerwarteter Fehler in generate_endpoint: {type(e).__name__} - {str(e)}")
         traceback.print_exc()
-        raise HTTPException(status_code=500, detail=f"Interne Serverfehler bei der Horoskopgenerierung: {str(e)}")
-
-# Alte Endpunkt-Definition entfernen oder anpassen, falls der Pfad gleich bleiben soll
-# Der Pfad wurde zu "/generate-horoscope" geändert, um Konflikte zu vermeiden,
-# und das Request/Response-Modell wurde angepasst.
-
-# @router.post("/generate", response_model=GenerateResponse)
-# async def generate_text(request: GenerateRequest):
-#     # ... alter Code ...
-#     pass
+        raise HTTPException(status_code=500, detail=f"Ein interner Fehler ist aufgetreten: {str(e)}")

app/api/v1/schemas/{horoscope_schemas.py → card_schemas.py}

@@ -1,5 +1,3 @@
-# app/schemas/horoscope_schemas.py
-
 from pydantic import BaseModel, Field
 from datetime import date
 from typing import List, Optional
@@ -7,38 +5,57 @@ import uuid
 
 # --- Request Models ---
 
-class HoroscopeGenerateRequest(BaseModel):
+class CardGenerateRequest(BaseModel):
     """
-    Schema für die Anfrage zur Generierung einer personalisierten Horoskopkarte.
+    Schema für die Anfrage zur Generierung einer personalisierten Karte.
     """
     terms: List[str] = Field(
         ...,
         min_length=5,
         max_length=5,
-        description="Fünf Schlüsselbegriffe oder Konzepte für das Horoskop.",
+        description="Fünf Schlüsselbegriffe oder Konzepte für die Karte.",
         example=["Liebe", "Erfolg", "Glück", "Herausforderung", "Wachstum"]
     )
-    date_of_birth: date = Field(
+    card_date: date = Field(
         ...,
-        description="Das Geburtsdatum des Nutzers im Format JJJJ-MM-TT.",
+        description="Das Datum für die Karte im Format JJJJ-MM-TT (z.B. Geburtsdatum oder ein anderes relevantes Datum).",
         example="1990-05-15"
     )
+    lang: Optional[str] = Field(
+        "de",
+        description="Sprache für den Kartentext, Standardwert ist 'de'.",
+        example="en"
+    )
+    session_id: uuid.UUID = Field(
+        default_factory=uuid.uuid4,
+        description="Session-ID zur Verfolgung der Anfrage, Standardwert ist eine neue UUID."
+    )
+    card_design_id_override: Optional[int] = Field(
+        None,
+        description="Überschreibung der Karten-Design-ID. Beispiel: 1",
+        example=1
+    )
+    symbol_ids_override: Optional[List[int]] = Field(
+        None,
+        description="Überschreibung der Symbol-IDs. Beispiel: [1, 2, 3]",
+        example=[1, 2]
+    )
 
 # --- Response Models ---
 
-class HoroscopeGenerateResponse(BaseModel):
+class CardGenerateResponse(BaseModel):
     """
-    Schema für die Antwort nach erfolgreicher Anfrage zur Horoskopgenerierung.
+    Schema für die Antwort nach erfolgreicher Anfrage zur Kartengenerierung.
     Enthält den Link zum QR-Code und die ID der generierten Karte.
     """
     card_id: str = Field(
         ...,
-        description="Die eindeutige ID der generierten Horoskopkarte. Wird für den Download benötigt.",
+        description="Die eindeutige ID der generierten Karte. Wird für den Download benötigt.",
         example="a1b2c3d4-e5f6-7890-1234-567890abcdef"
     )
     qr_code_image_url: str = Field(
         ...,
-        description="Die URL, unter der das QR-Code-Bild (das den Download-Link zur Horoskopkarte enthält) direkt abrufbar ist.",
+        description="Die URL, unter der das QR-Code-Bild (das den Download-Link zur Karte enthält) direkt abrufbar ist.",
         example="http://localhost:8000/static/qr_codes/qr_code_a1b2c3d4-e5f6-7890-1234-567890abcdef.png"
     )
     message: str = Field(
@@ -46,16 +63,21 @@ class HoroscopeGenerateResponse(BaseModel):
         description="Eine Bestätigungsnachricht."
     )
 
-class HoroscopeCardData(BaseModel):
+class CardData(BaseModel):
     """
-    Schema für die internen Daten einer gespeicherten Horoskopkarte (z.B. aus Supabase).
-    Dies ist kein API-Response-Modell, sondern eher ein Datenmodell für Services/Datenbank.
+    Schema für die internen Daten einer gespeicherten Karte (z.B. aus Supabase),
+    basierend auf der Tabelle 'cards'.
     """
-    id: uuid.UUID = Field(..., description="Eindeutige ID der Horoskopkarte.")
-    terms: List[str] = Field(..., description="Die ursprünglichen fünf Schlüsselbegriffe.")
-    date_of_birth: date = Field(..., description="Das Geburtsdatum des Nutzers.")
-    horoscope_text: str = Field(..., description="Der generierte Horoskoptext.")
-    image_path: str = Field(..., description="Dateisystempfad zum generierten Horoskopbild.")
-    qr_code_path: str = Field(..., description="Dateisystempfad zum generierten QR-Code-Bild.")
-    qr_code_link: str = Field(..., description="Der URL, der im QR-Code kodiert ist.")
-    created_at: Optional[date] = Field(None, description="Zeitpunkt der Erstellung des Eintrags.")
+    id: int = Field(..., description="Eindeutige ID der Karte (bigint).")
+    terms: List[str] = Field(..., description="Die ursprünglichen fünf Schlüsselbegriffe (text[]).")
+    card_date: date = Field(..., description="Das Geburtsdatum des Nutzers (timestamp with time zone, Pydantic uses date for simplicity here, conversion might be needed).")
+    card_text: str = Field(..., description="Der generierte Kartentext (text).")
+    image_filename: str = Field(..., description="Dateiname des generierten Kartenbildes (text).")
+    qr_code_filename: str = Field(..., description="Dateiname des generierten QR-Code-Bildes (text).")
+    qr_code_link: str = Field(..., description="Der URL, der im QR-Code kodiert ist (text).")
+    created_at: date = Field(..., description="Zeitpunkt der Erstellung des Eintrags (timestamp with time zone, Pydantic uses date).")
+    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.")
+    generation_params: Optional[dict] = Field(None, description="Parameters used for text generation.")

app/core/card_renderer.py

@@ -3,7 +3,7 @@ import uuid
 from pathlib import Path
 
 def generate_card(
-    tarot_id: int, 
+    card_design_id: int, 
     symbol_ids: list[int], 
     text: str,
     base_images_path: Path,
@@ -18,10 +18,10 @@ def generate_card(
     """
     try:
         # Basiskarte laden
-        base_image_file = base_images_path / f"{tarot_id}.png"
+        base_image_file = base_images_path / f"{card_design_id}.png"
         if not base_image_file.exists():
             raise FileNotFoundError(f"Basiskartenbild nicht gefunden: {base_image_file}")
-        tarot_img = Image.open(base_image_file).convert("RGBA")
+        card_design_img = Image.open(base_image_file).convert("RGBA")
 
         # Symbole hinzufügen
         # Die Positionierung hier ist ein Beispiel und muss ggf. angepasst werden
@@ -40,14 +40,14 @@ def generate_card(
             # Beispielhafte Positionierung - muss ggf. verfeinert werden
             # Annahme: Symbole werden nebeneinander platziert
             position = (current_x, symbol_y_start) 
-            tarot_img.paste(symbol_img, position, symbol_img) 
+            card_design_img.paste(symbol_img, position, symbol_img) 
             current_x += symbol_img.width + symbol_spacing
 
         # Text hinzufügen
         if not font_path.exists():
             raise FileNotFoundError(f"Schriftart nicht gefunden: {font_path}")
         
-        draw = ImageDraw.Draw(tarot_img)
+        draw = ImageDraw.Draw(card_design_img)
         try:
             font_size = 20 # Beispiel
             font = ImageFont.truetype(str(font_path), font_size)
@@ -58,11 +58,11 @@ def generate_card(
         # Textpositionierung und -umbruch (vereinfacht)
         # Für besseren Textumbruch wären komplexere Logiken nötig (z.B. textwrap Modul)
         text_x = 50
-        text_y = tarot_img.height - 150 # Beispiel Y-Position von unten
+        text_y = card_design_img.height - 150 # Beispiel Y-Position von unten
         # draw.text((text_x, text_y), text, font=font, fill=(0, 0, 0, 255)) # Schwarz, voll opak
         
         # Einfacher Textumbruch
-        max_width = tarot_img.width - (2 * text_x) # Maximale Breite für Text
+        max_width = card_design_img.width - (2 * text_x) # Maximale Breite für Text
         lines = []
         words = text.split()
         current_line = ""
@@ -92,7 +92,7 @@ def generate_card(
         file_id = str(uuid.uuid4()) # Eindeutige ID für die Datei
         output_file_path = output_path / f"{file_id}.png"
         
-        tarot_img.save(output_file_path)
+        card_design_img.save(output_file_path)
         
         return file_id  # Gibt die UUID (ohne .png) zurück
 

app/core/config.py

@@ -33,6 +33,23 @@ class Settings(BaseSettings):
     PROJECT_NAME: str = "Horoskopkarten-Generator"
     APP_VERSION: str = "1.0.0"
 
+    # Generation parameters
+    GENERATION_MAX_NEW_TOKENS: int = 250
+    GENERATION_TEMPERATURE: float = 0.75
+    GENERATION_DO_SAMPLE: bool = True
+    GENERATION_TOP_K: int = 50
+    GENERATION_TOP_P: float = 0.95
+    GENERATION_MAX_RETRIES: int = 3
+
+    # QR Code settings
+    FRONTEND_BASE_URL: str = "http://localhost:3000" # Beispiel, anpassen!
+    QR_CODE_SIZE: int = 200 # Größe des QR-Codes in Pixeln
+
+    # Model and Tokenizer settings
+    # HUGGING_FACE_HUB_TOKEN: str | None = os.getenv("HUGGING_FACE_HUB_TOKEN") # Handled by HF libs
+    LORA_MODEL_REPO_ID: str | None = None # Beispiel: "your-username/your-lora-model-repo"
+    # LORA_MODEL_REVISION: str = "main" # Beispiel: "main" oder ein spezifischer Commit/Tag
+
     @property
     def resolved_model_path(self) -> Path:
         return Path(self.MODEL_PATH)

app/core/constraints.py

@@ -2,11 +2,48 @@
 # Constraints: Begriffe prüfen, Filter
 
 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, generator, terms, max_retries=3):
-    for _ in range(max_retries):
-        response = generator(prompt)[0]["generated_text"]
-        if check_constraints(response, terms):
-            return response
+def generate_with_retry(prompt: str, generator, terms: list[str], max_retries: int = 3, generation_params: dict | None = None):
+    """
+    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.
+    """
+    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)
+            
+            # 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"):
+                generated_text = responses[0]["generated_text"].strip()
+                if check_constraints(generated_text, terms):
+                    return generated_text
+            else:
+                # Fallback, falls die Antwortstruktur unerwartet ist oder kein Text generiert wurde
+                print(f"Unerwartete Antwortstruktur vom Generator bei Versuch {attempt + 1}: {responses}")
+                generated_text = "" # oder None, je nachdem wie der Rest des Codes damit umgeht
+
+        except Exception as e:
+            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)
+            
     return "Leider konnte kein gültiger Text erzeugt werden."

app/core/generator.py

@@ -7,31 +7,39 @@ import datetime
 218 = 02.18. → Ende Wassermann
 """
 
-def get_zodiac(birthdate: str) -> str:
+def get_constellation(birthdate: str) -> str:
     """Leitet das Sternzeichen aus dem Geburtsdatum ab."""
     date = datetime.datetime.strptime(birthdate, "%Y-%m-%d").date()
-    zodiacs = [
+    constellations = [
         (120, "Steinbock"), (218, "Wassermann"), (320, "Fische"), (420, "Widder"),
         (521, "Stier"), (621, "Zwillinge"), (722, "Krebs"), (823, "Löwe"),
         (923, "Jungfrau"), (1023, "Waage"), (1122, "Skorpion"), (1222, "Schütze"), (1231, "Steinbock")
     ]
     date_as_number = int(f"{date.month:02d}{date.day:02d}")
-    for boundary, sign in zodiacs:
+    for boundary, sign in constellations:
         if date_as_number <= boundary:
             return sign
     return "Steinbock"
 
-def build_prompt(lang: str, birthdate: str, terms: list[str]) -> str:
-    template_path = Path(__file__).resolve().parent.parent.parent / "templates" / lang / "base.txt"
-    if not template_path.exists():
-        raise FileNotFoundError(f"Template nicht gefunden: {template_path}")
-    
-    template = Template(template_path.read_text(encoding="utf-8"))
-    sternzeichen = get_zodiac(birthdate)
+PROMPT_TEMPLATE = Template("""
+Du bist ein Sexoskop-Orakel. Erstelle einen kurzen, prägnanten Horoskoptext (maximal 1-2 Sätze) für eine Person, basierend auf folgenden Informationen:
 
-    prompt = template.render(
-        birthdate=birthdate,
-        terms=', '.join(terms),
-        sternzeichen=sternzeichen
-        )
-    return prompt
+Sprache: {{ lang }}
+Datum: {{ card_date }} {# Geändert von birthdate #}
+Sternzeichen: {{ constellation }}
+Schlüsselbegriffe: {{ terms_str }}
+
+Der Text soll die Schlüsselbegriffe kreativ und subtil einbinden und zum angegebenen Datum passen.
+Antworte nur mit dem Horoskoptext.
+""")
+
+def build_prompt(lang: str, card_date: str, terms: list[str]) -> str:
+    """Baut den Prompt für das LLM basierend auf Geburtsdatum und Begriffen."""
+    constellation = get_constellation(card_date)
+    terms_str = ", ".join(terms)
+    return PROMPT_TEMPLATE.render(
+        lang=lang, 
+        card_date=card_date, 
+        constellation=constellation, 
+        terms_str=terms_str
+    )

app/core/hf_api.py

@@ -0,0 +1,367 @@
+import os
+from huggingface_hub import HfApi, HfFolder, Repository, create_repo, get_full_repo_name
+from huggingface_hub.utils import HfHubHTTPError
+import logging
+from pathlib import Path
+import json # Added for example usage
+
+logger = logging.getLogger(__name__)
+
+class HuggingFaceWrapper:
+    """
+    A wrapper for interacting with the Hugging Face Hub API.
+    Handles authentication, model and dataset uploads/downloads,
+    and repository creation.
+    """
+    def __init__(self, token: str | None = None, default_repo_prefix: str = "museum-sexoskop"):
+        """
+        Initializes the HuggingFaceWrapper.
+
+        Args:
+            token: Your Hugging Face API token. If None, it will try to use
+                   a token saved locally via `huggingface-cli login`.
+            default_repo_prefix: A default prefix for repository names.
+        """
+        self.api = HfApi()
+        if token:
+            self.token = token
+            # Note: HfApi uses the token from HfFolder by default if logged in.
+            # To explicitly use a provided token for all operations,
+            # some HfApi methods accept it directly.
+            # For operations like Repository, ensure the environment or HfFolder is set.
+            HfFolder.save_token(token)
+            logger.info("Hugging Face token saved for the session.")
+        else:
+            self.token = HfFolder.get_token()
+            if not self.token:
+                logger.warning("No Hugging Face token provided or found locally. "
+                               "Please login using `huggingface-cli login` or provide a token.")
+            else:
+                logger.info("Using locally saved Hugging Face token.")
+        
+        self.default_repo_prefix = default_repo_prefix
+
+    def _get_full_repo_id(self, repo_name: str, repo_type: str | None = None) -> str:
+        """Helper to construct full repo ID, ensuring it includes the username/org."""
+        # If repo_name already contains a slash, it's likely a full ID (user/repo or org/repo)
+        if "/" in repo_name:
+            # Further check: if it doesn't have the prefix and prefix is defined,
+            # this might be an attempt to use a non-prefixed name directly.
+            # For simplicity, we assume if '/' is present, it's a deliberate full ID.
+            return repo_name
+
+        user_or_org = self.api.whoami(token=self.token).get("name") if self.token else None
+        if not user_or_org:
+            raise ValueError("Could not determine Hugging Face username/org. Ensure you are logged in or token is valid.")
+        
+        effective_repo_name = repo_name
+        if self.default_repo_prefix and not repo_name.startswith(self.default_repo_prefix):
+            effective_repo_name = f"{self.default_repo_prefix}-{repo_name}"
+            
+        return f"{user_or_org}/{effective_repo_name}"
+
+    def create_repository(self, repo_name: str, repo_type: str | None = None, private: bool = True, organization: str | None = None) -> str:
+        """
+        Creates a new repository on the Hugging Face Hub.
+        If organization is provided, repo_name should be the base name.
+        If organization is None, repo_name can be a base name (username will be prepended) 
+        or a full name like 'username/repo_name'.
+
+        Args:
+            repo_name: The name of the repository. Can be 'my-repo' or 'username/my-repo'.
+            repo_type: Type of the repository ('model', 'dataset', 'space').
+            private: Whether the repository should be private.
+            organization: Optional organization name to create the repo under. If provided,
+                          repo_name should be the base name for the repo within that org.
+
+        Returns:
+            The full repository ID (e.g., "username/repo_name" or "orgname/repo_name").
+        """
+        if organization:
+            # If org is specified, repo_name must be the base name for that org
+            if "/" in repo_name:
+                raise ValueError("When organization is specified, repo_name should be a base name, not 'org/repo'.")
+            full_repo_id = f"{organization}/{repo_name}"
+        elif "/" in repo_name:
+            # User provided a full name like "username/repo_name"
+            full_repo_id = repo_name
+        else:
+            # User provided a base name, prepend current user
+            user = self.api.whoami(token=self.token).get("name")
+            if not user:
+                raise ConnectionError("Could not determine Hugging Face username. Ensure token is valid and you are logged in.")
+            full_repo_id = f"{user}/{repo_name}"
+        
+        try:
+            url = create_repo(repo_id=full_repo_id, token=self.token, private=private, repo_type=repo_type, exist_ok=True)
+            logger.info(f"Repository '{full_repo_id}' ensured to exist. URL: {url}")
+            return full_repo_id
+        except HfHubHTTPError as e:
+            logger.error(f"Error creating repository '{full_repo_id}': {e}")
+            # If error indicates it's because it's a user repo and trying to use org logic or vice-versa
+            # it might be complex to auto-fix, so better to raise.
+            raise
+
+    def upload_file_or_folder(self, local_path: str | Path, repo_id: str, path_in_repo: str | None = None, repo_type: str | None = None, commit_message: str = "Upload content"):
+        """Helper to upload a single file or an entire folder."""
+        local_path_obj = Path(local_path)
+        
+        if not path_in_repo and local_path_obj.is_file():
+            path_in_repo = local_path_obj.name
+        elif not path_in_repo and local_path_obj.is_dir():
+             # For folders, path_in_repo is relative to the repo root.
+             # If None, files will be uploaded to the root.
+             # If you want to upload contents of 'my_folder' into 'target_folder_in_repo/',
+             # then path_in_repo should be 'target_folder_in_repo'
+             # For simplicity here, if path_in_repo is None for a folder, we upload its contents to the root.
+             pass
+
+
+        if local_path_obj.is_file():
+            self.api.upload_file(
+                path_or_fileobj=str(local_path_obj),
+                path_in_repo=path_in_repo if path_in_repo else local_path_obj.name,
+                repo_id=repo_id,
+                repo_type=repo_type,
+                token=self.token,
+                commit_message=commit_message,
+            )
+            logger.info(f"File '{local_path_obj}' uploaded to '{repo_id}/{path_in_repo if path_in_repo else local_path_obj.name}'.")
+        elif local_path_obj.is_dir():
+            # upload_folder uploads the *contents* of folder_path into the repo_id,
+            # optionally under a path_in_repo.
+            self.api.upload_folder(
+                folder_path=str(local_path_obj),
+                path_in_repo=path_in_repo if path_in_repo else ".", # Upload to root if no path_in_repo
+                repo_id=repo_id,
+                repo_type=repo_type,
+                token=self.token,
+                commit_message=commit_message,
+                ignore_patterns=["*.git*", ".gitattributes"],
+            )
+            logger.info(f"Folder '{local_path_obj}' contents uploaded to '{repo_id}{'/' + path_in_repo if path_in_repo and path_in_repo != '.' else ''}'.")
+        else:
+            raise FileNotFoundError(f"Local path '{local_path}' not found or is not a file/directory.")
+
+    def upload_model(self, model_path: str | Path, repo_name: str, private: bool = True, commit_message: str = "Upload model", organization: str | None = None) -> str:
+        """
+        Uploads a model to the Hugging Face Hub.
+
+        Args:
+            model_path: Path to the local model directory or file.
+            repo_name: Base name of the repository (e.g., "my-lora-model").
+                       The prefix from __init__ and username/org will be added.
+            private: Whether the repository should be private.
+            commit_message: Commit message for the upload.
+            organization: Optional organization to host this model. If None, uses the logged-in user.
+
+
+        Returns:
+            The URL of the uploaded model repository.
+        """
+        # Construct the effective repo name, possibly prefixed
+        effective_repo_name = repo_name
+        if self.default_repo_prefix and not repo_name.startswith(self.default_repo_prefix):
+             effective_repo_name = f"{self.default_repo_prefix}-{repo_name}"
+
+        # Create the repository
+        target_repo_id = self.create_repository(repo_name=effective_repo_name, repo_type="model", private=private, organization=organization)
+        
+        logger.info(f"Uploading model from '{model_path}' to '{target_repo_id}'...")
+        self.upload_file_or_folder(local_path=model_path, repo_id=target_repo_id, repo_type="model", commit_message=commit_message)
+            
+        repo_url = f"https://huggingface.co/{target_repo_id}"
+        logger.info(f"Model uploaded to {repo_url}")
+        return repo_url
+
+    def download_model(self, repo_name: str, local_dir: str | Path, revision: str | None = None, organization: str | None = None) -> str:
+        """
+        Downloads a model from the Hugging Face Hub.
+
+        Args:
+            repo_name: Name of the repository. Can be a base name (e.g., "my-lora-model")
+                       or a full ID (e.g., "username/my-lora-model").
+                       If base name and no organization, prefix and username are added.
+                       If base name and organization, prefix is added.
+            local_dir: Local directory to save the model.
+            revision: Optional model revision (branch, tag, commit hash).
+            organization: Optional organization if repo_name is a base name under an org.
+
+        Returns:
+            Path to the downloaded model.
+        """
+        if "/" in repo_name: # User provided full ID like "user/repo" or "org/repo"
+            target_repo_id = repo_name
+        else: # User provided base name
+            effective_repo_name = repo_name
+            if self.default_repo_prefix and not repo_name.startswith(self.default_repo_prefix):
+                effective_repo_name = f"{self.default_repo_prefix}-{repo_name}"
+            
+            if organization:
+                target_repo_id = f"{organization}/{effective_repo_name}"
+            else:
+                user = self.api.whoami(token=self.token).get("name")
+                if not user:
+                    raise ConnectionError("Could not determine Hugging Face username for downloading.")
+                target_repo_id = f"{user}/{effective_repo_name}"
+
+        logger.info(f"Downloading model '{target_repo_id}' to '{local_dir}'...")
+        
+        downloaded_path = self.api.snapshot_download(
+            repo_id=target_repo_id,
+            repo_type="model", # Can be omitted, snapshot_download infers if possible
+            local_dir=str(local_dir),
+            token=self.token,
+            revision=revision,
+        )
+        logger.info(f"Model '{target_repo_id}' downloaded to '{downloaded_path}'.")
+        return downloaded_path
+
+    def upload_dataset(self, dataset_path: str | Path, repo_name: str, private: bool = True, commit_message: str = "Upload dataset", organization: str | None = None) -> str:
+        """
+        Uploads a dataset to the Hugging Face Hub. (Similar to upload_model)
+        """
+        effective_repo_name = repo_name
+        if self.default_repo_prefix and not repo_name.startswith(self.default_repo_prefix):
+             effective_repo_name = f"{self.default_repo_prefix}-{repo_name}"
+
+        target_repo_id = self.create_repository(repo_name=effective_repo_name, repo_type="dataset", private=private, organization=organization)
+
+        logger.info(f"Uploading dataset from '{dataset_path}' to '{target_repo_id}'...")
+        self.upload_file_or_folder(local_path=dataset_path, repo_id=target_repo_id, repo_type="dataset", commit_message=commit_message)
+
+        repo_url = f"https://huggingface.co/{target_repo_id}"
+        logger.info(f"Dataset uploaded to {repo_url}")
+        return repo_url
+
+    def download_dataset(self, repo_name: str, local_dir: str | Path, revision: str | None = None, organization: str | None = None) -> str:
+        """
+        Downloads a dataset from the Hugging Face Hub. (Similar to download_model)
+        """
+        if "/" in repo_name:
+            target_repo_id = repo_name
+        else:
+            effective_repo_name = repo_name
+            if self.default_repo_prefix and not repo_name.startswith(self.default_repo_prefix):
+                effective_repo_name = f"{self.default_repo_prefix}-{repo_name}"
+            if organization:
+                target_repo_id = f"{organization}/{effective_repo_name}"
+            else:
+                user = self.api.whoami(token=self.token).get("name")
+                if not user:
+                    raise ConnectionError("Could not determine Hugging Face username for downloading.")
+                target_repo_id = f"{user}/{effective_repo_name}"
+                
+        logger.info(f"Downloading dataset '{target_repo_id}' to '{local_dir}'...")
+        
+        downloaded_path = self.api.snapshot_download(
+            repo_id=target_repo_id,
+            repo_type="dataset", # Can be omitted
+            local_dir=str(local_dir),
+            token=self.token,
+            revision=revision,
+        )
+        logger.info(f"Dataset '{target_repo_id}' downloaded to '{downloaded_path}'.")
+        return downloaded_path
+
+    def initiate_training(self, model_repo_id: str, dataset_repo_id: str, training_params: dict):
+        logger.warning("initiate_training is a placeholder and not fully implemented.")
+        logger.info(f"Would attempt to train model {model_repo_id} with dataset {dataset_repo_id} using params: {training_params}")
+        pass
+
+# Example Usage
+if __name__ == "__main__":
+    logging.basicConfig(level=logging.INFO)
+    
+    hf_token = os.environ.get("HF_TOKEN") 
+    if not hf_token:
+        logger.warning("HF_TOKEN environment variable not set. Please set it or log in via huggingface-cli.")
+        logger.warning("Skipping example usage.")
+    else:
+        # Use a different prefix for examples to avoid conflict with actual app prefix
+        hf_wrapper = HuggingFaceWrapper(token=hf_token, default_repo_prefix="hf-wrapper-test")
+        
+        # Determine current Hugging Face username for constructing repo IDs in tests
+        try:
+            current_hf_user = hf_wrapper.api.whoami(token=hf_wrapper.token).get("name")
+            if not current_hf_user:
+                raise ValueError("Could not retrieve HuggingFace username.")
+        except Exception as e:
+            logger.error(f"Failed to get HuggingFace username for tests: {e}. Skipping examples.")
+            current_hf_user = None
+
+        if current_hf_user:
+            # --- Test Repository Creation ---
+            test_model_repo_basename = "my-test-model"
+            test_dataset_repo_basename = "my-test-dataset"
+            
+            # These will be prefixed like "hf-wrapper-test-my-test-model"
+            # And the full ID will be "username/hf-wrapper-test-my-test-model"
+            
+            try:
+                logger.info("\\n--- Testing Model Repository Creation ---")
+                model_repo_id = hf_wrapper.create_repository(repo_name=test_model_repo_basename, repo_type="model", private=True)
+                logger.info(f"Model repository created/ensured: {model_repo_id}")
+
+                logger.info("\\n--- Testing Dataset Repository Creation ---")
+                dataset_repo_id = hf_wrapper.create_repository(repo_name=test_dataset_repo_basename, repo_type="dataset", private=True)
+                logger.info(f"Dataset repository created/ensured: {dataset_repo_id}")
+                
+                # --- Test File/Folder Upload & Download ---
+                dummy_model_dir = Path("dummy_model_for_hf_upload")
+                dummy_model_dir.mkdir(exist_ok=True)
+                dummy_dataset_file = Path("dummy_dataset_for_hf_upload.jsonl")
+
+                with open(dummy_model_dir / "config.json", "w") as f:
+                    json.dump({"model_type": "dummy", "_comment": "Test model config"}, f, indent=2)
+                with open(dummy_model_dir / "model.safetensors", "w") as f:
+                    f.write("This is a dummy safetensors file content.")
+                
+                with open(dummy_dataset_file, "w") as f:
+                    f.write(json.dumps({"text": "example line 1 for hf dataset"}) + "\\n")
+                    f.write(json.dumps({"text": "example line 2 for hf dataset"}) + "\\n")
+
+                logger.info(f"\\n--- Testing Model Upload (folder to {test_model_repo_basename}) ---")
+                # upload_model uses the base name, prefixing and user/org is handled internally
+                hf_wrapper.upload_model(model_path=dummy_model_dir, repo_name=test_model_repo_basename, private=True)
+                
+                logger.info(f"\\n--- Testing Dataset Upload (file to {test_dataset_repo_basename}) ---")
+                hf_wrapper.upload_dataset(dataset_path=dummy_dataset_file, repo_name=test_dataset_repo_basename, private=True)
+
+                # For download, construct the full repo ID as it would be on the Hub
+                # The upload methods return the Hub URL, but download needs repo_id.
+                # The create_repository returned the full ID, e.g. current_hf_user/hf-wrapper-test-my-test-model
+                
+                downloaded_model_path_base = Path("downloaded_hf_models")
+                downloaded_model_path_base.mkdir(exist_ok=True)
+                # model_repo_id is already the full ID from create_repository
+                # e.g. "username/hf-wrapper-test-my-test-model"
+                
+                logger.info(f"\\n--- Testing Model Download (from {model_repo_id}) ---")
+                # Use the repo_id returned by create_repository or constructed with _get_full_repo_id
+                # For download, repo_name can be the full ID.
+                hf_wrapper.download_model(repo_name=model_repo_id, local_dir=downloaded_model_path_base / test_model_repo_basename)
+                logger.info(f"Model downloaded to: {downloaded_model_path_base / test_model_repo_basename}")
+
+                downloaded_dataset_path_base = Path("downloaded_hf_datasets")
+                downloaded_dataset_path_base.mkdir(exist_ok=True)
+                # dataset_repo_id is e.g. "username/hf-wrapper-test-my-test-dataset"
+                
+                logger.info(f"\\n--- Testing Dataset Download (from {dataset_repo_id}) ---")
+                hf_wrapper.download_dataset(repo_name=dataset_repo_id, local_dir=downloaded_dataset_path_base / test_dataset_repo_basename)
+                logger.info(f"Dataset downloaded to: {downloaded_dataset_path_base / test_dataset_repo_basename}")
+
+                logger.info("\\nExample usage complete. Check your Hugging Face account for new repositories.")
+                logger.info(f"Consider deleting test repositories: {model_repo_id}, {dataset_repo_id}")
+                
+                # Clean up local dummy files/folders
+                import shutil
+                shutil.rmtree(dummy_model_dir)
+                dummy_dataset_file.unlink()
+                # You might want to manually inspect downloaded folders before deleting
+                # shutil.rmtree(downloaded_model_path_base)
+                # shutil.rmtree(downloaded_dataset_path_base)
+                logger.info("Local dummy files and folders cleaned up. Downloaded content remains for inspection.")
+
+            except Exception as e:
+                logger.error(f"An error occurred during example usage: {e}", exc_info=True)

app/core/lora_config.py

@@ -1,2 +1,86 @@
 # lora_config.py
-# LoRA-Config (separat gehalten für Training)
+# LoRA-Config für effizienten Training und Inference
+
+from peft import LoraConfig, TaskType
+from pathlib import Path
+
+class LoRAConfiguration:
+    """Zentralisierte LoRA-Konfiguration für Training und Inference"""
+    
+    # Training-optimierte Konfiguration (lokales Training)
+    TRAINING_CONFIG = LoraConfig(
+        task_type=TaskType.CAUSAL_LM,
+        r=16,  # Rank - Balance zwischen Qualität und Effizienz
+        lora_alpha=32,  # Skalierung für LoRA-Gewichte
+        lora_dropout=0.1,  # Regularisierung
+        target_modules=["q_proj", "v_proj", "k_proj", "o_proj"],  # Attention-Module
+        bias="none",  # Keine Bias-Parameter trainieren
+        inference_mode=False
+    )
+    
+    # Inference-optimierte Konfiguration (HuggingFace Space)
+    INFERENCE_CONFIG = LoraConfig(
+        task_type=TaskType.CAUSAL_LM,
+        r=16,
+        lora_alpha=32,
+        lora_dropout=0.1,
+        target_modules=["q_proj", "v_proj", "k_proj", "o_proj"],
+        bias="none",
+        inference_mode=True  # Optimiert für Inference
+    )
+    
+    # Kostengünstige Konfiguration (niedrigere Qualität, aber sehr effizient)
+    BUDGET_CONFIG = LoraConfig(
+        task_type=TaskType.CAUSAL_LM,
+        r=8,  # Niedrigerer Rank
+        lora_alpha=16,
+        lora_dropout=0.05,
+        target_modules=["q_proj", "v_proj"],  # Nur wichtigste Module
+        bias="none",
+        inference_mode=False
+    )
+    
+    @staticmethod
+    def get_config(mode="inference"):
+        """
+        Konfiguration basierend auf Verwendungszweck abrufen
+        
+        Args:
+            mode: "training", "inference", oder "budget"
+        """
+        if mode == "training":
+            return LoRAConfiguration.TRAINING_CONFIG
+        elif mode == "budget":
+            return LoRAConfiguration.BUDGET_CONFIG
+        else:
+            return LoRAConfiguration.INFERENCE_CONFIG
+    
+    @staticmethod
+    def estimate_parameters(r=16, target_modules=4):
+        """
+        Geschätzte Anzahl trainierbarer Parameter
+        Für Kostenabschätzung
+        """
+        # Grobe Schätzung basierend auf Mistral-7B
+        base_params = 7_000_000_000
+        lora_params = r * 2 * 4096 * target_modules  # Vereinfachte Berechnung
+        trainable_ratio = lora_params / base_params
+        
+        return {
+            "base_parameters": base_params,
+            "lora_parameters": lora_params,
+            "trainable_ratio": f"{trainable_ratio*100:.3f}%",
+            "memory_estimate_gb": (lora_params * 4) / (1024**3)  # 4 bytes per param
+        }
+
+# Verwendung in der Anwendung
+def get_lora_config_for_environment():
+    """Automatische Konfiguration basierend auf Umgebung"""
+    try:
+        import torch
+        if torch.cuda.is_available():
+            return LoRAConfiguration.get_config("inference")
+        else:
+            return LoRAConfiguration.get_config("budget")
+    except ImportError:
+        return LoRAConfiguration.get_config("budget")

app/core/model_loader.py

@@ -1,21 +1,152 @@
 from transformers import AutoTokenizer, AutoModelForCausalLM, pipeline
 from peft import PeftModel
+import torch
+import logging
+from pathlib import Path
+import os
+from .config import settings
+from .hf_api import HuggingFaceWrapper
 
+logger = logging.getLogger(__name__)
 
 
 def load_model():
-    base_model_id = "teknium/OpenHermes-2.5-Mistral-7B"
-    lora_path = "./models/lora-checkpoint"  # oder None, falls nicht getunt
+    """
+    Optimierter Model Loader mit LoRA-Support.
+    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")
 
-    tokenizer = AutoTokenizer.from_pretrained(base_model_id)
-    model = AutoModelForCausalLM.from_pretrained(base_model_id, load_in_4bit=True, device_map="auto")
+    logger.info(f"Lade Basismodell: {base_model_id}")
 
     try:
-        model = PeftModel.from_pretrained(model, lora_path)
-    except:
-        pass  # fallback ohne LoRA
+        tokenizer = AutoTokenizer.from_pretrained(base_model_id, token=hf_token)
+    except Exception as e:
+        logger.error(f"Fehler beim Laden des Tokenizers für {base_model_id}: {e}")
+        raise
 
-    pipe = pipeline("text-generation", model=model, tokenizer=tokenizer)
+    if tokenizer.pad_token is None:
+        logger.info("Tokenizer hat kein pad_token. Setze pad_token = eos_token.")
+        tokenizer.pad_token = tokenizer.eos_token
+
+    model_kwargs = {
+        "torch_dtype": torch.float16,  # Standardmäßig float16
+        "device_map": "auto",
+        "trust_remote_code": True,  # Notwendig für einige Modelle
+        "token": hf_token
+    }
+
+    if settings.MODEL_LOAD_IN_4BIT is not False:  # Annahme: settings.MODEL_LOAD_IN_4BIT existiert
+        try:
+            model_kwargs["load_in_4bit"] = True
+            # Ggf. BitsAndBytesConfig hier, falls benötigt
+            # from transformers import BitsAndBytesConfig
+            # model_kwargs["quantization_config"] = BitsAndBytesConfig(...)
+            logger.info("Versuche, Modell mit 4-bit Quantisierung zu laden.")
+            model = AutoModelForCausalLM.from_pretrained(base_model_id, **model_kwargs)
+            logger.info("Modell erfolgreich mit 4-bit Quantisierung geladen.")
+        except Exception as e:
+            logger.warning(f"4-bit Laden fehlgeschlagen: {e}. Fallback auf Standard-Laden (FP16).")
+            del model_kwargs["load_in_4bit"]
+            if "quantization_config" in model_kwargs: del model_kwargs["quantization_config"]
+            model = AutoModelForCausalLM.from_pretrained(base_model_id, **model_kwargs)
+    else:
+        logger.info("4-bit Quantisierung ist deaktiviert. Lade Modell in FP16.")
+        model = AutoModelForCausalLM.from_pretrained(base_model_id, **model_kwargs)
+
+    # LoRA-Gewichte laden
+    lora_path_to_load = None
+    if settings.LORA_MODEL_REPO_ID:
+        logger.info(f"LoRA Adapter soll von Hugging Face Hub geladen werden: {settings.LORA_MODEL_REPO_ID}")
+        hf_wrapper = HuggingFaceWrapper(token=hf_token)  # Token wird intern vom Wrapper geholt, falls nicht explizit übergeben
+
+        # Zielverzeichnis für heruntergeladene LoRA-Adapter
+        # Basierend auf MODEL_PATH aus settings, um Konsistenz zu wahren
+        # Beispiel: cardserver/models/lora-checkpoint/downloaded_adapters/your-lora-model-repo
+        local_lora_download_dir_base = settings.resolved_model_path.parent / "downloaded_adapters"
+        lora_adapter_name = settings.LORA_MODEL_REPO_ID.split("/")[-1]  # z.B. "your-lora-model-repo"
+        local_lora_dir = local_lora_download_dir_base / lora_adapter_name
+
+        # Prüfen, ob der Adapter bereits heruntergeladen wurde (einfache Prüfung)
+        # Eine robustere Prüfung könnte Versions-Hashes oder Modifikationszeiten beinhalten.
+        adapter_config_file = local_lora_dir / "adapter_config.json"
+
+        if not adapter_config_file.exists() or getattr(settings, "LORA_FORCE_DOWNLOAD", False):
+            if adapter_config_file.exists():
+                logger.info(f"LORA_FORCE_DOWNLOAD ist aktiv. LoRA-Adapter wird erneut heruntergeladen: {settings.LORA_MODEL_REPO_ID}")
+            else:
+                logger.info(f"LoRA-Adapter nicht lokal gefunden unter {local_lora_dir}. Wird heruntergeladen...")
+
+            local_lora_dir.mkdir(parents=True, exist_ok=True)  # Sicherstellen, dass das Verzeichnis existiert
+            try:
+                downloaded_path_str = hf_wrapper.download_model(
+                    repo_name=settings.LORA_MODEL_REPO_ID,
+                    local_dir=str(local_lora_dir),  # Muss ein String sein
+                    # revision=settings.LORA_MODEL_REVISION # Falls eine spezifische Version benötigt wird
+                )
+                lora_path_to_load = Path(downloaded_path_str)  # Der Rückgabewert ist der Pfad
+                logger.info(f"LoRA-Adapter erfolgreich von {settings.LORA_MODEL_REPO_ID} nach {lora_path_to_load} heruntergeladen.")
+            except Exception as e:
+                logger.error(f"Fehler beim Herunterladen des LoRA-Adapters von {settings.LORA_MODEL_REPO_ID}: {e}")
+                logger.info("Versuche, Fallback auf lokalen Pfad (falls konfiguriert) oder verwende Basismodell.")
+                # Fallback auf settings.resolved_model_path, falls LORA_MODEL_REPO_ID fehlschlägt
+                if settings.resolved_model_path.exists() and (settings.resolved_model_path / "adapter_config.json").exists():
+                    lora_path_to_load = settings.resolved_model_path
+                    logger.info(f"Fallback auf lokalen LoRA-Pfad: {lora_path_to_load}")
+                else:
+                    lora_path_to_load = None  # Kein LoRA verwenden
+        else:
+            lora_path_to_load = local_lora_dir
+            logger.info(f"LoRA-Adapter {settings.LORA_MODEL_REPO_ID} bereits lokal vorhanden unter: {lora_path_to_load}")
+
+    elif settings.resolved_model_path.exists() and (settings.resolved_model_path / "adapter_config.json").exists():
+        # Fallback: Wenn LORA_MODEL_REPO_ID nicht gesetzt ist, aber ein lokaler Pfad existiert
+        lora_path_to_load = settings.resolved_model_path
+        logger.info(f"Verwende lokalen LoRA-Pfad: {lora_path_to_load} (da LORA_MODEL_REPO_ID nicht gesetzt).")
+    else:
+        logger.info("Kein LORA_MODEL_REPO_ID in den Settings und kein gültiger lokaler LoRA-Pfad gefunden.")
+        lora_path_to_load = None
+
+    if lora_path_to_load:
+        try:
+            logger.info(f"Versuche, LoRA-Gewichte von Pfad zu laden: {lora_path_to_load}")
+            model = PeftModel.from_pretrained(model, str(lora_path_to_load))
+            logger.info("✅ LoRA-Modell erfolgreich auf Basismodell angewendet.")
+        except Exception as e:
+            logger.error(f"❌ LoRA-Loading von {lora_path_to_load} fehlgeschlagen: {e}")
+            logger.info("Verwende Basismodell ohne LoRA-Adapter.")
+    else:
+        logger.info("Keine LoRA-Gewichte zum Laden spezifiziert oder gefunden. Verwende Basismodell.")
+
+    pipe = pipeline(
+        "text-generation",
+        model=model,
+        tokenizer=tokenizer,
+        return_full_text=False
+    )
+
+    logger.info("Text-Generierungs-Pipeline erfolgreich erstellt.")
     return pipe
 
-generator = load_model()
+
+def get_model_info():
+    """Informationen über das geladene Modell"""
+    lora_path = settings.resolved_model_path
+    return {
+        "base_model": settings.DEFAULT_MODEL_ID,
+        "lora_enabled": lora_path.exists(),
+        "lora_path": str(lora_path) if lora_path.exists() else None,
+        "gpu_available": torch.cuda.is_available(),
+        "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

app/hf_api.py

@@ -1,2 +0,0 @@
-# hf_api.py
-# Optional: HuggingFace API-Wrapper

app/main.py

@@ -79,7 +79,7 @@ app.add_middleware(
 )
 
 app.include_router(health.router, prefix=settings.API_PREFIX, tags=["Health"])
-app.include_router(generate.router, prefix=settings.API_PREFIX, tags=["Generate Horoscope"])
+app.include_router(generate.router, prefix=settings.API_PREFIX, tags=["Generate Card"])
 app.include_router(download.router, prefix=settings.API_PREFIX, tags=["Download Card"])
 
 @app.get("/")

app/services/database.py

@@ -11,11 +11,11 @@ supabase = create_client(SUPABASE_URL, SUPABASE_KEY)
 def get_supabase_client():
     return supabase
 
-def save_horoscope_card(
+def save_card(
     card_id: str,
     terms: list[str],
-    date_of_birth: str, # Pydantic date wird hier als str erwartet für Supabase
-    horoscope_text: str,
+    card_date: str, # Pydantic date wird hier als str erwartet für Supabase
+    card_text: str,
     image_filename: str, # Nur der Dateiname, Pfad wird serverseitig verwaltet
     qr_code_filename: str, # Nur der Dateiname
     qr_code_link: str
@@ -25,8 +25,8 @@ def save_horoscope_card(
         response = supabase.table("horoscope_cards").insert({
             "id": card_id,
             "terms": terms,
-            "date_of_birth": date_of_birth,
-            "horoscope_text": horoscope_text,
+            "card_date": card_date,
+            "card_text": card_text,
             "image_filename": image_filename,
             "qr_code_filename": qr_code_filename,
             "qr_code_link": qr_code_link

requirements.txt

@@ -1,13 +1,26 @@
-fastapi
-uvicorn[standard]
-pydantic
-pydantic-settings
-qrcode
-pillow
-peft
-torch
-accelerate    
-transformers
-numpy 
-supabase
-jinja2
+# Core Production Dependencies
+# Für FastAPI Server und Inference
+
+# FastAPI Framework
+fastapi>=0.110.0
+uvicorn[standard]>=0.30.0
+
+# Data Validation
+pydantic>=2.8.0
+pydantic-settings>=2.6.0
+
+# Image Processing
+pillow>=10.0.0
+qrcode>=7.4.0
+
+# ML Inference (minimale Versionen für Produktion)
+torch>=2.4.0
+transformers>=4.52.0
+peft>=0.15.0
+accelerate>=1.7.0
+numpy>=1.26.0
+bitsandbytes>=0.41.0 # For 4-bit/8-bit loading
+
+# Database & Templates
+supabase>=2.7.0
+jinja2>=3.1.0

scripts/setup_training.sh

@@ -0,0 +1,37 @@
+#!/bin/bash
+# Schnelles Setup-Script für LORA-Training
+
+echo "🚀 Setup für kostengünstiges LORA-Training"
+echo "=========================================="
+
+# 1. Virtuelle Umgebung erstellen (optional)
+echo "📦 Erstelle virtuelle Umgebung..."
+python3 -m venv venv_training
+source venv_training/bin/activate
+
+# 2. Requirements installieren
+echo "📥 Installiere Training-Dependencies..."
+pip install -r training_requirements.txt
+pip install -r ../requirements.txt
+
+# 3. Training-Ordner vorbereiten
+echo "📁 Erstelle Training-Struktur..."
+mkdir -p ../models/lora-checkpoint
+mkdir -p data
+
+# 4. GPU-Check
+echo "🔍 GPU-Verfügbarkeit prüfen..."
+python -c "import torch; print(f'CUDA verfügbar: {torch.cuda.is_available()}'); print(f'GPU-Anzahl: {torch.cuda.device_count()}')"
+
+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 ""
+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"

scripts/start.sh

@@ -0,0 +1,24 @@
+#!/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

tests/MANUAL_VERIFICATION.md

@@ -1,149 +0,0 @@
-# Manual Deployment Verification Guide
-
-## 🔍 Step-by-Step Verification Process
-
-Since automated monitoring may have limitations, here's how to manually verify the deployment:
-
-### 1. **Check HF Space Status**
-
-Visit these URLs in your browser:
-- **Space Page**: https://huggingface.co/spaces/ch404/cardserver
-- **Direct App**: https://ch404-cardserver.hf.space/
-- **Alternative**: https://huggingface.co/spaces/ch404/cardserver
-
-**What to look for**:
-- ✅ Space shows "Running" status (green indicator)
-- ✅ No error messages in the space logs
-- ✅ App loads without 500 errors
-
-### 2. **Test API Endpoints Manually**
-
-#### A. Health Check (Should work first)
-```bash
-curl "https://ch404-cardserver.hf.space/api/v1/health"
-```
-**Expected**: `{"status": "healthy", "server": "running", ...}`
-
-#### B. Root Endpoint
-```bash
-curl "https://ch404-cardserver.hf.space/"
-```
-**Expected**: `{"message": "Welcome to the Horoskopkarten-Generator API."}`
-
-#### C. Generate Horoscope (Full functionality test)
-```bash
-curl -X POST "https://ch404-cardserver.hf.space/api/v1/generate-horoscope" \
-     -H "Content-Type: application/json" \
-     -d '{
-       "terms": ["Erfolg", "Liebe", "Glück", "Abenteuer", "Weisheit"],
-       "date_of_birth": "1990-06-13"
-     }'
-```
-**Expected**: Returns `card_id` and `qr_code_image_url`
-
-### 3. **Troubleshooting Common Issues**
-
-#### **Issue: 404 Errors**
-- **Cause**: Space is not running or still deploying
-- **Solution**: Wait 2-5 minutes, then retry
-- **Check**: Space logs in HF interface
-
-#### **Issue: 500 Internal Server Error**
-- **Cause**: Our original static directory error
-- **Solution**: Check if our fixes were applied
-- **Verify**: Look for deployment commit in GitHub
-
-#### **Issue: Space Shows "Building"**
-- **Cause**: Deployment in progress
-- **Solution**: Wait for completion (can take 5-10 minutes)
-- **Monitor**: Refresh space page periodically
-
-#### **Issue: Authentication Errors (401)**
-- **Cause**: Space might be private
-- **Solution**: Make space public in HF settings
-- **Check**: Space visibility settings
-
-### 4. **Expected Behavior After Fix**
-
-#### **Before Fix**:
-```
-RuntimeError: Directory '/cardserver/static' does not exist
-```
-
-#### **After Fix**:
-```
-✅ INFO: Attempting to mount static directory: /app/static
-✅ INFO: Static directory exists: True  
-✅ INFO: Static files mounted successfully
-✅ FastAPI app starts normally
-```
-
-### 5. **Manual Testing Workflow**
-
-1. **Wait for Deployment** (5-10 minutes after push)
-2. **Check Space Status** (visit HF space page)
-3. **Test Health Endpoint** (basic connectivity)
-4. **Test Root Endpoint** (app is running)
-5. **Test Generation** (full functionality)
-6. **Test Download** (using card_id from step 5)
-
-### 6. **Success Indicators**
-
-✅ **Space shows "Running" status**  
-✅ **Health endpoint returns 200 OK**  
-✅ **Generate endpoint returns card_id**  
-✅ **QR code URL is accessible**  
-✅ **Download endpoint serves PNG files**  
-
-### 7. **If Still Having Issues**
-
-#### **Check HF Space Logs**:
-1. Go to https://huggingface.co/spaces/ch404/cardserver
-2. Click on "Logs" tab
-3. Look for our debug output from `start.sh`
-4. Check for any error messages
-
-#### **Verify GitHub Deployment**:
-1. Check if GitHub Actions completed successfully
-2. Verify our commits were pushed to the space
-3. Look for any deployment failures
-
-#### **Alternative Testing**:
-If the space URL doesn't work, try:
-- Different browsers
-- Incognito/private mode
-- Direct IP (if available in logs)
-
-### 8. **Quick Test Script**
-
-Save this as `quick_test.sh` and run it:
-```bash
-#!/bin/bash
-BASE_URL="https://ch404-cardserver.hf.space"
-
-echo "Testing Museum Sexoskop App..."
-echo "================================"
-
-echo "1. Testing health endpoint..."
-curl -s "$BASE_URL/api/v1/health" | jq . || echo "Failed or not JSON"
-
-echo -e "\n2. Testing root endpoint..."
-curl -s "$BASE_URL/" | jq . || echo "Failed or not JSON"
-
-echo -e "\n3. Testing generate endpoint..."
-curl -s -X POST "$BASE_URL/api/v1/generate-horoscope" \
-     -H "Content-Type: application/json" \
-     -d '{"terms": ["Test","Deploy","Success","Working","Happy"], "date_of_birth": "1990-01-01"}' \
-     | jq . || echo "Failed or not JSON"
-
-echo -e "\nDone!"
-```
-
-### 9. **Final Notes**
-
-- **Patience**: HF Spaces can take time to deploy and start
-- **Dependencies**: ML model loading adds startup time
-- **Resources**: Free HF Spaces have limitations
-- **Persistence**: Spaces may sleep after inactivity
-
-The fixes we implemented should resolve the static directory error. If you see different errors now, they're likely related to dependencies or model loading, which is progress!

training/data/cards_training_data.json

@@ -0,0 +1,38 @@
+[
+  {
+    "sign": "Widder",
+    "date": "heute",
+    "context": "Liebe und Beziehungen",
+    "text": "Die Energie des Mars verleiht Ihnen heute besondere Anziehungskraft. Ihr Charisma wirkt magnetisch auf andere. In bestehenden Beziehungen können wichtige Gespräche zu mehr Intimität führen. Singles sollten aufmerksam sein - eine besondere Begegnung könnte heute stattfinden."
+  },
+  {
+    "sign": "Stier",
+    "date": "morgen",
+    "context": "Beruf und Karriere", 
+    "text": "Venus bringt harmonische Schwingungen in Ihr Berufsleben. Kreative Projekte stehen unter einem besonders guten Stern. Nutzen Sie Ihre diplomatischen Fähigkeiten für wichtige Verhandlungen. Finanzielle Entscheidungen sollten gut durchdacht werden."
+  },
+  {
+    "sign": "Zwillinge",
+    "date": "diese Woche",
+    "context": "Gesundheit und Wohlbefinden",
+    "text": "Merkur aktiviert Ihre mentale Energie - perfekt für neue Lernprojekte. Achten Sie auf ausreichend Bewegung und frische Luft. Ihr Kommunikationsbedürfnis ist erhöht, nutzen Sie dies für wichtige Gespräche mit Familie und Freunden."
+  },
+  {
+    "sign": "Krebs",
+    "date": "heute",
+    "context": "Familie und Zuhause",
+    "text": "Der Mond verstärkt Ihre emotionale Intuition erheblich. In familiären Angelegenheiten können Sie als Vermittler fungieren. Ihr Zuhause wird zum Kraftort - schaffen Sie eine gemütliche Atmosphäre. Kochexperimente sind heute besonders erfolgreich."
+  },
+  {
+    "sign": "Löwe",
+    "date": "dieses Wochenende", 
+    "context": "Kreativität und Selbstausdruck",
+    "text": "Die Sonne entfacht Ihre kreative Flamme! Künstlerische Projekte erleben einen Durchbruch. Ihre natürliche Ausstrahlung zieht Bewunderung an. Bühnenmomente und öffentliche Auftritte stehen unter einem glücklichen Stern. Zeigen Sie, was in Ihnen steckt!"
+  },
+  {
+    "sign": "Jungfrau",
+    "date": "nächste Woche",
+    "context": "Organisation und Effizienz",
+    "text": "Ihre analytischen Fähigkeiten sind geschärft wie selten zuvor. Komplexe Probleme lösen Sie mit Leichtigkeit. Gesundheitliche Präventionsmaßnahmen zeigen positive Wirkung. Ordnung in Ihrem Umfeld bringt auch mentale Klarheit. Details werden zu Ihrem Vorteil."
+  }
+]

training/deploy_lora.py

@@ -0,0 +1,221 @@
+#!/usr/bin/env python3
+"""
+Deployment-Script für trainierte LoRA-Modelle
+Automatisiert den Upload zu Hugging Face Hub
+"""
+
+import os
+import shutil
+from pathlib import Path
+import subprocess
+import json
+import logging
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+class LoRADeployer:
+    def __init__(self, model_path="../models/lora-checkpoint"):
+        self.model_path = Path(model_path)
+        self.hf_username = None  # Wird aus HF_USERNAME env var gelesen
+        
+    def verify_model(self):
+        """Prüft ob trainiertes LoRA-Modell vollständig ist"""
+        required_files = [
+            "adapter_config.json",
+            "adapter_model.bin",  # oder adapter_model.safetensors
+            "README.md"
+        ]
+        
+        missing_files = []
+        for file in required_files:
+            if not (self.model_path / file).exists():
+                missing_files.append(file)
+                
+        if missing_files:
+            logger.error(f"Fehlende Dateien: {missing_files}")
+            return False
+            
+        logger.info("✅ LoRA-Modell vollständig")
+        return True
+        
+    def create_model_card(self):
+        """Erstellt eine Model Card für Hugging Face"""
+        model_card = f"""---
+library_name: peft
+base_model: teknium/OpenHermes-2.5-Mistral-7B
+tags:
+- generated_from_trainer
+- horoscope
+- astrology
+- german
+- lora
+language:
+- de
+- en
+license: apache-2.0
+---
+
+# LoRA Adapter für Horoskop-Generierung
+
+Dieses LoRA-Adapter wurde für die Generierung von personalisierten Horoskopen trainiert.
+
+## Basis-Modell
+- **Model**: teknium/OpenHermes-2.5-Mistral-7B
+- **LoRA Rank**: 16
+- **Target Modules**: q_proj, v_proj, k_proj, o_proj
+
+## Verwendung
+
+```python
+from transformers import AutoTokenizer, AutoModelForCausalLM
+from peft import PeftModel
+
+base_model = "teknium/OpenHermes-2.5-Mistral-7B"
+tokenizer = AutoTokenizer.from_pretrained(base_model)
+model = AutoModelForCausalLM.from_pretrained(base_model, load_in_4bit=True)
+model = PeftModel.from_pretrained(model, "IHR_USERNAME/horoskop-lora")
+
+# Beispiel-Prompt
+prompt = "<|im_start|>system\\nDu bist ein erfahrener Astrologe.<|im_end|>\\n<|im_start|>user\\nErstelle ein Horoskop für Widder heute.<|im_end|>\\n<|im_start|>assistant\\n"
+```
+
+## Training Details
+- **Training Duration**: {self.get_training_info().get('duration', 'N/A')}
+- **Dataset Size**: {self.get_training_info().get('dataset_size', 'N/A')}
+- **Epochs**: {self.get_training_info().get('epochs', 'N/A')}
+"""
+        
+        readme_path = self.model_path / "README.md"
+        with open(readme_path, 'w', encoding='utf-8') as f:
+            f.write(model_card)
+            
+        logger.info(f"Model Card erstellt: {readme_path}")
+        
+    def get_training_info(self):
+        """Liest Training-Informationen aus logs oder config"""
+        # Placeholder - könnte aus Training-Logs gelesen werden
+        return {
+            "duration": "2-4 Stunden",
+            "dataset_size": "500+ Horoskop-Beispiele", 
+            "epochs": "3"
+        }
+        
+    def upload_to_hf(self, repo_name="horoskop-lora"):
+        """Upload zu Hugging Face Hub"""
+        
+        # Hugging Face Username prüfen
+        hf_username = os.getenv("HF_USERNAME")
+        if not hf_username:
+            logger.error("HF_USERNAME environment variable nicht gesetzt")
+            logger.info("Setzen Sie: export HF_USERNAME=ihr_username")
+            return False
+            
+        # Hugging Face CLI prüfen
+        try:
+            subprocess.run(["huggingface-cli", "--version"], check=True, capture_output=True)
+        except subprocess.CalledProcessError:
+            logger.error("Hugging Face CLI nicht installiert")
+            logger.info("Installieren Sie: pip install huggingface_hub")
+            return False
+            
+        # Repository erstellen
+        repo_id = f"{hf_username}/{repo_name}"
+        logger.info(f"Erstelle Repository: {repo_id}")
+        
+        try:
+            # Repository auf HF erstellen
+            cmd = [
+                "huggingface-cli", "repo", "create", 
+                repo_id, "--type", "model", "--private"
+            ]
+            subprocess.run(cmd, check=True)
+            logger.info(f"✅ Repository erstellt: {repo_id}")
+            
+        except subprocess.CalledProcessError as e:
+            if "already exists" in str(e):
+                logger.info(f"Repository existiert bereits: {repo_id}")
+            else:
+                logger.error(f"Repository-Erstellung fehlgeschlagen: {e}")
+                return False
+                
+        # Dateien hochladen
+        try:
+            cmd = [
+                "huggingface-cli", "upload", repo_id,
+                str(self.model_path), ".", "--recursive"
+            ]
+            subprocess.run(cmd, check=True)
+            logger.info(f"✅ Upload erfolgreich: https://huggingface.co/{repo_id}")
+            return True
+            
+        except subprocess.CalledProcessError as e:
+            logger.error(f"Upload fehlgeschlagen: {e}")
+            return False
+            
+    def prepare_for_space(self):
+        """Bereitet Modell für Hugging Face Space vor"""
+        space_model_path = Path("../models/lora-checkpoint-deployed")
+        space_model_path.mkdir(exist_ok=True)
+        
+        # Kopiere nur notwendige Dateien
+        essential_files = [
+            "adapter_config.json",
+            "adapter_model.bin",
+            "adapter_model.safetensors"
+        ]
+        
+        for file in essential_files:
+            src = self.model_path / file
+            if src.exists():
+                dst = space_model_path / file
+                shutil.copy2(src, dst)
+                logger.info(f"Kopiert: {file}")
+                
+        logger.info(f"✅ Space-ready Modell in: {space_model_path}")
+        return space_model_path
+
+def main():
+    """Hauptfunktion für Deployment"""
+    deployer = LoRADeployer()
+    
+    print("🚀 LoRA-Modell Deployment")
+    print("========================")
+    
+    # 1. Modell verifizieren
+    if not deployer.verify_model():
+        print("❌ Modell-Verifikation fehlgeschlagen")
+        return
+        
+    # 2. Model Card erstellen
+    deployer.create_model_card()
+    
+    # 3. User-Input für Deployment-Optionen
+    print("\n📤 Deployment-Optionen:")
+    print("1. Für Hugging Face Space vorbereiten")
+    print("2. Zu Hugging Face Hub hochladen")
+    print("3. Beides")
+    
+    choice = input("Wählen Sie (1-3): ").strip()
+    
+    if choice in ["1", "3"]:
+        space_path = deployer.prepare_for_space()
+        print(f"✅ Space-ready: {space_path}")
+        
+    if choice in ["2", "3"]:
+        repo_name = input("Repository-Name (Standard: horoskop-lora): ").strip()
+        if not repo_name:
+            repo_name = "horoskop-lora"
+            
+        if deployer.upload_to_hf(repo_name):
+            print("✅ Upload zu Hugging Face erfolgreich!")
+        else:
+            print("❌ Upload fehlgeschlagen")
+            
+    print("\n🎯 Nächste Schritte:")
+    print("1. Aktualisieren Sie config.py mit dem neuen Modell-Pfad")
+    print("2. Testen Sie das Modell lokal")
+    print("3. Deployen Sie zu Hugging Face Space")
+
+if __name__ == "__main__":
+    main()

training/test_setup.py

@@ -0,0 +1,27 @@
+#!/usr/bin/env python3
+import torch
+import transformers
+import peft
+import datasets
+import evaluate
+import sklearn
+import wandb
+import tensorboard
+
+print('✅ Alle Training-Pakete erfolgreich importiert!')
+print(f'🚀 PyTorch Version: {torch.__version__}')
+print(f'🤖 Transformers Version: {transformers.__version__}')
+print(f'🔧 PEFT Version: {peft.__version__}')
+print(f'📊 Datasets Version: {datasets.__version__}')
+print(f'🎯 CUDA verfügbar: {torch.cuda.is_available()}')
+
+if torch.cuda.is_available():
+    print(f'📱 GPU: {torch.cuda.get_device_name(0)}')
+    print(f'💾 VRAM: {torch.cuda.get_device_properties(0).total_memory / 1024**3:.1f} GB')
+else:
+    print('💻 CPU-Modus (kein CUDA)')
+
+print('\n🎯 Hardware-Empfehlungen für LoRA-Training:')
+print('• Minimum: 8GB RAM + 4GB VRAM')
+print('• Empfohlen: 16GB RAM + 8GB VRAM') 
+print('• Optimal: 32GB RAM + 16GB+ VRAM')

training/train_lora.py

@@ -0,0 +1,175 @@
+#!/usr/bin/env python3
+"""
+Kostengünstiges LORA-Training für OpenHermes-2.5-Mistral-7B
+Optimiert für lokale Ausführung mit effizienter Speichernutzung
+"""
+
+import torch
+from transformers import (
+    AutoTokenizer, AutoModelForCausalLM, 
+    TrainingArguments, Trainer, DataCollatorForLanguageModeling
+)
+from peft import LoraConfig, get_peft_model, TaskType
+from datasets import Dataset
+import json
+from pathlib import Path
+import logging
+
+# Setup logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+class LoRATrainer:
+    def __init__(self, base_model_id="teknium/OpenHermes-2.5-Mistral-7B"):
+        self.base_model_id = base_model_id
+        self.output_dir = Path("../models/lora-checkpoint")
+        self.output_dir.mkdir(parents=True, exist_ok=True)
+        
+    def setup_model_and_tokenizer(self):
+        """Modell und Tokenizer mit optimalen Einstellungen laden"""
+        logger.info(f"Lade Modell: {self.base_model_id}")
+        
+        # Tokenizer
+        self.tokenizer = AutoTokenizer.from_pretrained(self.base_model_id)
+        if self.tokenizer.pad_token is None:
+            self.tokenizer.pad_token = self.tokenizer.eos_token
+            
+        # Modell mit 4-bit Quantisierung für Speichereffizienz
+        self.model = AutoModelForCausalLM.from_pretrained(
+            self.base_model_id,
+            load_in_4bit=True,
+            torch_dtype=torch.float16,
+            device_map="auto",
+            trust_remote_code=True
+        )
+        
+        # LoRA Konfiguration - kostengünstig optimiert
+        lora_config = LoraConfig(
+            task_type=TaskType.CAUSAL_LM,
+            r=16,  # Rank - niedrig für Effizienz
+            lora_alpha=32,  # Skalierungsfaktor
+            lora_dropout=0.1,
+            target_modules=["q_proj", "v_proj", "k_proj", "o_proj"],  # Nur wichtige Module
+            bias="none"
+        )
+        
+        # PEFT Modell erstellen
+        self.model = get_peft_model(self.model, lora_config)
+        self.model.print_trainable_parameters()
+        
+    def prepare_dataset(self, data_path="training_data.json"):
+        """Trainingsdaten vorbereiten"""
+        logger.info(f"Lade Trainingsdaten: {data_path}")
+        
+        # Beispiel-Datenformat für Horoskop-Generierung
+        if not Path(data_path).exists():
+            self.create_sample_data(data_path)
+            
+        with open(data_path, 'r', encoding='utf-8') as f:
+            data = json.load(f)
+            
+        def tokenize_function(examples):
+            # Prompt-Template für Horoskop-Generierung
+            texts = []
+            for item in examples:
+                prompt = f"<|im_start|>system\nDu bist ein erfahrener Astrologe. Erstelle ein präzises und einfühlsames Horoskop.<|im_end|>\n<|im_start|>user\nErstelle ein Horoskop für {item['sign']} am {item['date']}.<|im_end|>\n<|im_start|>assistant\n{item['horoscope']}<|im_end|>"
+                texts.append(prompt)
+                
+            tokenized = self.tokenizer(
+                texts,
+                truncation=True,
+                padding="max_length",
+                max_length=512,
+                return_tensors="pt"
+            )
+            tokenized["labels"] = tokenized["input_ids"].clone()
+            return tokenized
+            
+        dataset = Dataset.from_list(data)
+        tokenized_dataset = dataset.map(tokenize_function, batched=False)
+        return tokenized_dataset
+        
+    def create_sample_data(self, data_path):
+        """Beispiel-Trainingsdaten erstellen"""
+        sample_data = [
+            {
+                "sign": "Widder",
+                "date": "heute",
+                "horoscope": "Die Energie des Mars verleiht Ihnen heute besondere Kraft. Nutzen Sie diese für wichtige Entscheidungen in der Liebe."
+            },
+            {
+                "sign": "Stier",
+                "date": "morgen", 
+                "horoscope": "Venus bringt harmonische Schwingungen in Ihr Leben. Ein perfekter Tag für romantische Begegnungen."
+            },
+            # Weitere Beispiele...
+        ]
+        
+        with open(data_path, 'w', encoding='utf-8') as f:
+            json.dump(sample_data, f, ensure_ascii=False, indent=2)
+        logger.info(f"Beispiel-Trainingsdaten erstellt: {data_path}")
+        
+    def train(self, dataset, num_epochs=3):
+        """Training starten - kostengünstig optimiert"""
+        logger.info("Starte Training...")
+        
+        training_args = TrainingArguments(
+            output_dir=str(self.output_dir),
+            num_train_epochs=num_epochs,
+            per_device_train_batch_size=1,  # Kleine Batch-Size für wenig RAM
+            gradient_accumulation_steps=4,  # Simuliert größere Batches
+            warmup_steps=100,
+            logging_steps=10,
+            save_steps=500,
+            evaluation_strategy="no",  # Keine Evaluation für Effizienz
+            save_strategy="epoch",
+            load_best_model_at_end=False,
+            remove_unused_columns=False,
+            dataloader_pin_memory=False,
+            gradient_checkpointing=True,  # Speicher sparen
+            optim="adamw_torch",
+            learning_rate=5e-5,
+            weight_decay=0.01,
+            lr_scheduler_type="cosine",
+            report_to=None,  # Kein Wandb etc. für Kosten
+        )
+        
+        data_collator = DataCollatorForLanguageModeling(
+            tokenizer=self.tokenizer,
+            mlm=False
+        )
+        
+        trainer = Trainer(
+            model=self.model,
+            args=training_args,
+            train_dataset=dataset,
+            data_collator=data_collator,
+        )
+        
+        # Training starten
+        trainer.train()
+        
+        # Modell speichern
+        trainer.save_model()
+        self.tokenizer.save_pretrained(str(self.output_dir))
+        logger.info(f"Training abgeschlossen. Modell gespeichert in: {self.output_dir}")
+
+def main():
+    """Hauptfunktion für Training"""
+    trainer = LoRATrainer()
+    
+    # 1. Modell und Tokenizer setup
+    trainer.setup_model_and_tokenizer()
+    
+    # 2. Dataset vorbereiten
+    dataset = trainer.prepare_dataset()
+    
+    # 3. Training starten
+    trainer.train(dataset, num_epochs=3)
+    
+    print("✅ LORA-Training erfolgreich abgeschlossen!")
+    print(f"📁 Modell gespeichert in: {trainer.output_dir}")
+    print("🚀 Jetzt können Sie das trainierte Modell in Ihrem FastAPI-Server verwenden.")
+
+if __name__ == "__main__":
+    main()

training/training_requirements.txt

@@ -0,0 +1,25 @@
+# Training-Specific Dependencies
+# Nur für lokales Training benötigt - NICHT für Produktion
+
+# Dataset Handling & Evaluation
+datasets>=2.14.0
+evaluate>=0.4.0
+
+# ML Training & Analysis
+scikit-learn>=1.3.0
+
+# Training Monitoring (Optional)
+wandb>=0.20.0  # Experiment tracking
+tensorboard>=2.19.0  # Loss visualization
+
+# Training Utilities
+tqdm>=4.66.0  # Progress bars
+matplotlib>=3.8.0  # Plotting
+seaborn>=0.13.0  # Better plots
+
+# Development Tools (Optional)
+jupyter>=1.0.0  # Notebooks for analysis
+ipywidgets>=8.0.0  # Interactive widgets
+
+# Basis-Requirements werden automatisch über requirements.txt geladen:
+# torch, transformers, peft, accelerate, numpy