🚀 Auto-deploy from GitHub

app/api/__init__.py

@@ -0,0 +1 @@
+# API package

app/api/v1/__init__.py

@@ -0,0 +1 @@
+# API v1 package

app/api/v1/endpoints/__init__.py

@@ -0,0 +1,4 @@
+# API v1 endpoints package
+from . import health, generate, download
+
+__all__ = ["health", "generate", "download"]

app/api/v1/endpoints/download.py

@@ -0,0 +1,53 @@
+from fastapi import APIRouter, HTTPException, Depends
+from fastapi.responses import FileResponse
+from pathlib import Path
+from ....services.database import get_supabase_client # Corrected import
+from ....core.config import settings # Import settings
+from supabase import Client
+
+router = APIRouter()
+
+@router.get("/download/image/{card_id}") # Changed to path parameter
+async def download_generated_image(
+    card_id: str, # card_id from path
+    supabase: Client = Depends(get_supabase_client)
+):
+    """
+    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()
+        
+        if not response.data:
+            raise HTTPException(status_code=404, detail="Card not found in database")
+        
+        card_data = response.data[0]
+        image_filename = card_data.get("image_path") # Assuming image_path stores the filename
+        
+        if not image_filename:
+            raise HTTPException(status_code=404, detail="Image filename not found for this card")
+        
+        # Construct the full file path using settings
+        # image_filename is expected to be just the name of the file, e.g., "some_uuid.png"
+        full_path = settings.resolved_generated_path / image_filename
+        
+        # Check if file exists
+        if not full_path.exists() or not full_path.is_file():
+            # Log this issue, as it indicates a discrepancy between DB and filesystem
+            print(f"Error: File not found on server at path: {full_path}")
+            raise HTTPException(status_code=404, detail="Image file not found on server")
+        
+        return FileResponse(
+            path=str(full_path), # Ensure path is a string
+            filename=image_filename, # Use the filename from the database
+            media_type="image/png"  # Assuming PNG, adjust if necessary
+        )
+        
+    except HTTPException as http_exc: # Re-raise HTTPExceptions
+        raise http_exc
+    except Exception as e:
+        # Log the exception for debugging
+        print(f"An unexpected error occurred: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"Error retrieving image: {str(e)}")

app/api/v1/endpoints/generate.py

@@ -0,0 +1,200 @@
+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
+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
+
+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, 
+    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()
+        
+        horoscope_prompt = build_prompt(
+            lang=lang,
+            birthdate=birthdate_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)
+        generation_params = {
+            "max_length": 200, # Beispielwert
+            "temperature": 0.75, # Beispielwert
+            "do_sample": True,
+            "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
+
+
+        # 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
+        
+        # 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
+            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}"
+        
+        return HoroscopeGenerateResponse(
+            card_id=card_file_id,
+            qr_code_image_url=qr_code_image_url,
+            message="Horoskopkarte erfolgreich generiert."
+        )
+
+    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)}")
+    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
+        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

app/api/v1/endpoints/health.py

@@ -0,0 +1,49 @@
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel
+import httpx
+import asyncio
+from typing import Optional
+import os
+from dotenv import load_dotenv
+
+load_dotenv()
+
+router = APIRouter()
+
+class HealthResponse(BaseModel):
+    status: str
+    server: str
+    huggingface_space: Optional[str] = None
+    huggingface_space_url: Optional[str] = None
+
+HF_SPACE_URL = os.getenv("HF_SPACE_URL", None)
+
+async def check_huggingface_space():
+    """Check if HuggingFace space is available"""
+    if not HF_SPACE_URL:
+        return None
+    
+    try:
+        async with httpx.AsyncClient(timeout=5.0) as client:
+            response = await client.get(HF_SPACE_URL)
+            return "healthy" if response.status_code == 200 else "unhealthy"
+    except Exception:
+        return "unreachable"
+
+@router.get("/health", response_model=HealthResponse)
+async def health_check():
+    """
+    Health check endpoint that verifies server status and HuggingFace space availability
+    """
+    try:
+        # Check HuggingFace space if configured
+        hf_status = await check_huggingface_space()
+        
+        return HealthResponse(
+            status="healthy",
+            server="running",
+            huggingface_space=hf_status,
+            huggingface_space_url=HF_SPACE_URL
+        )
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Health check failed: {str(e)}")

app/api/v1/schemas/__init__.py

@@ -0,0 +1 @@
+# API v1 schemas package

app/api/v1/schemas/horoscope_schemas.py

@@ -0,0 +1,61 @@
+# app/schemas/horoscope_schemas.py
+
+from pydantic import BaseModel, Field
+from datetime import date
+from typing import List, Optional
+import uuid
+
+# --- Request Models ---
+
+class HoroscopeGenerateRequest(BaseModel):
+    """
+    Schema für die Anfrage zur Generierung einer personalisierten Horoskopkarte.
+    """
+    terms: List[str] = Field(
+        ...,
+        min_length=5,
+        max_length=5,
+        description="Fünf Schlüsselbegriffe oder Konzepte für das Horoskop.",
+        example=["Liebe", "Erfolg", "Glück", "Herausforderung", "Wachstum"]
+    )
+    date_of_birth: date = Field(
+        ...,
+        description="Das Geburtsdatum des Nutzers im Format JJJJ-MM-TT.",
+        example="1990-05-15"
+    )
+
+# --- Response Models ---
+
+class HoroscopeGenerateResponse(BaseModel):
+    """
+    Schema für die Antwort nach erfolgreicher Anfrage zur Horoskopgenerierung.
+    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.",
+        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.",
+        example="http://localhost:8000/static/qr_codes/qr_code_a1b2c3d4-e5f6-7890-1234-567890abcdef.png"
+    )
+    message: str = Field(
+        "Horoskopkarten-Generierung erfolgreich initiiert. QR-Code ist verfügbar.",
+        description="Eine Bestätigungsnachricht."
+    )
+
+class HoroscopeCardData(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.
+    """
+    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.")

app/card_renderer.py

@@ -1,26 +0,0 @@
-from PIL import Image, ImageDraw, ImageFont
-import uuid
-from pathlib import Path
-
-def generate_card(tarot_id: int, symbol_ids: list[int], text: str) -> str:
-    base_path = Path(__file__).parent
-    tarot_img = Image.open(base_path / f"assets/images/base/{tarot_id}.png").convert("RGBA")
-
-    # Symbole hinzufügen
-    for sid in symbol_ids:
-        symbol = Image.open(base_path / f"assets/images/symbols/{sid}.png").convert("RGBA")
-        tarot_img.paste(symbol, (50 + sid*10, 400), symbol)  # Positionierung frei wählbar
-
-    # Text hinzufügen
-    draw = ImageDraw.Draw(tarot_img)
-    font = ImageFont.truetype(str(base_path / "assets/fonts/hand.ttf"), 20)
-    draw.text((50, tarot_img.height - 150), text, font=font, fill="black")
-
-    # Speichern
-    output_dir = base_path / "assets/images/generated"
-    output_dir.mkdir(exist_ok=True)
-    file_id = str(uuid.uuid4())
-    output_path = output_dir / f"{file_id}.png"
-    tarot_img.save(output_path)
-
-    return file_id  # nur ID zurückgeben

app/core/card_renderer.py

@@ -0,0 +1,107 @@
+from PIL import Image, ImageDraw, ImageFont
+import uuid
+from pathlib import Path
+
+def generate_card(
+    tarot_id: int, 
+    symbol_ids: list[int], 
+    text: str,
+    base_images_path: Path,
+    symbols_images_path: Path,
+    font_path: Path,
+    output_path: Path
+) -> str:
+    """
+    Generiert eine Horoskopkarte 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"{tarot_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")
+
+        # 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
+        current_x = symbol_x_start
+
+        for i, sid in enumerate(symbol_ids):
+            symbol_file = symbols_images_path / f"{sid}.png"
+            if not symbol_file.exists():
+                print(f"Warnung: Symbolbild nicht gefunden: {symbol_file}, wird übersprungen.")
+                continue
+            symbol_img = Image.open(symbol_file).convert("RGBA")
+            
+            # 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) 
+            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)
+        try:
+            font_size = 20 # Beispiel
+            font = ImageFont.truetype(str(font_path), font_size)
+        except IOError:
+            print(f"Warnung: Konnte Schriftart {font_path} nicht laden. Fallback auf Standard-Schriftart (falls verfügbar).")
+            font = ImageFont.load_default() # Fallback
+        
+        # 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
+        # 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
+        lines = []
+        words = text.split()
+        current_line = ""
+        for word in words:
+            # Teste, ob das Wort auf die aktuelle Zeile passt
+            # Die Methode textbbox ist ab Pillow 8.0.0 verfügbar, textsize ist älter
+            if hasattr(draw, 'textbbox'):
+                bbox = draw.textbbox((0,0), current_line + word + " ", font=font)
+                line_width = bbox[2] - bbox[0]
+            else:
+                line_width, _ = draw.textsize(current_line + word + " ", font=font)
+
+            if line_width <= max_width:
+                current_line += word + " "
+            else:
+                lines.append(current_line.strip())
+                current_line = word + " "
+        lines.append(current_line.strip()) # Letzte Zeile hinzufügen
+
+        line_height = font.getbbox("A")[3] - font.getbbox("A")[1] if hasattr(font, 'getbbox') else font.getsize("A")[1]
+        for i, line in enumerate(lines):
+            draw.text((text_x, text_y + (i * (line_height + 5))), line, font=font, fill=(0, 0, 0, 255))
+
+
+        # Speichern der generierten Karte
+        output_path.mkdir(parents=True, exist_ok=True)
+        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)
+        
+        return file_id  # Gibt die UUID (ohne .png) zurück
+
+    except FileNotFoundError as e:
+        # Fehler weiterleiten, damit der aufrufende Endpunkt ihn behandeln kann
+        raise e 
+    except Exception as e:
+        # Allgemeiner Fehler beim Rendern
+        print(f"Fehler in generate_card: {type(e).__name__} - {str(e)}")
+        import traceback
+        traceback.print_exc()
+        raise RuntimeError(f"Fehler beim Rendern der Horoskopkarte: {str(e)}")

app/core/config.py

@@ -0,0 +1,61 @@
+from pathlib import Path
+from pydantic_settings import BaseSettings, SettingsConfigDict
+from typing import ClassVar
+
+class Settings(BaseSettings):
+    _PROJECT_ROOT_DIR_CLS: ClassVar[Path] = Path(__file__).resolve().parent.parent.parent.parent
+    _CARDSERVER_DIR_CLS: ClassVar[Path] = _PROJECT_ROOT_DIR_CLS / "cardserver"
+    _APP_DEFAULT_STATIC_DIR_CLS: ClassVar[Path] = _CARDSERVER_DIR_CLS / "static"
+
+    MODEL_PATH: str = str(_CARDSERVER_DIR_CLS / "models" / "lora-checkpoint") 
+    DEFAULT_MODEL_ID: str = "teknium/OpenHermes-2.5-Mistral-7B" 
+
+    GENERATED_PATH: str = str(_APP_DEFAULT_STATIC_DIR_CLS / "images" / "generated") 
+    BASE_PATH: str = str(_APP_DEFAULT_STATIC_DIR_CLS / "images" / "base") 
+    SYMBOLS_PATH: str = str(_APP_DEFAULT_STATIC_DIR_CLS / "images" / "symbols") 
+    QR_CODE_PATH: str = str(_APP_DEFAULT_STATIC_DIR_CLS / "images" / "qr") 
+    
+    STATIC_FILES_MOUNT_DIR: str = str(_APP_DEFAULT_STATIC_DIR_CLS) 
+    
+    FONTS_SUBDIR: str = "fonts" 
+
+    API_PREFIX: str = "/api/v1"
+    PROJECT_NAME: str = "Horoskopkarten-Generator"
+    APP_VERSION: str = "1.0.0"
+
+    @property
+    def resolved_model_path(self) -> Path:
+        return Path(self.MODEL_PATH)
+
+    @property
+    def resolved_generated_path(self) -> Path:
+        return Path(self.GENERATED_PATH)
+
+    @property
+    def resolved_base_path(self) -> Path:
+        return Path(self.BASE_PATH)
+
+    @property
+    def resolved_symbols_path(self) -> Path:
+        return Path(self.SYMBOLS_PATH)
+
+    @property
+    def resolved_qr_code_path(self) -> Path:
+        return Path(self.QR_CODE_PATH)
+    
+    @property
+    def resolved_static_files_mount_dir(self) -> Path:
+        return Path(self.STATIC_FILES_MOUNT_DIR)
+
+    @property
+    def resolved_default_font_path(self) -> Path:
+        return self.resolved_static_files_mount_dir / self.FONTS_SUBDIR / "hand.ttf"
+
+    model_config = SettingsConfigDict(
+        env_file=".env", 
+        env_file_encoding='utf-8',
+        extra='ignore', 
+        case_sensitive=False 
+    )
+
+settings = Settings()

app/{generator.py → core/generator.py}

@@ -1,7 +1,3 @@
-
-
-
-
 from jinja2 import Template
 from pathlib import Path
 import datetime
@@ -26,7 +22,7 @@ def get_zodiac(birthdate: str) -> str:
     return "Steinbock"
 
 def build_prompt(lang: str, birthdate: str, terms: list[str]) -> str:
-    template_path = Path(__file__).parent / "templates" / lang / "base.txt"
+    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}")
     

app/core/model_loader.py

@@ -0,0 +1,21 @@
+from transformers import AutoTokenizer, AutoModelForCausalLM, pipeline
+from peft import PeftModel
+
+
+
+def load_model():
+    base_model_id = "teknium/OpenHermes-2.5-Mistral-7B"
+    lora_path = "./models/lora-checkpoint"  # oder None, falls nicht getunt
+
+    tokenizer = AutoTokenizer.from_pretrained(base_model_id)
+    model = AutoModelForCausalLM.from_pretrained(base_model_id, load_in_4bit=True, device_map="auto")
+
+    try:
+        model = PeftModel.from_pretrained(model, lora_path)
+    except:
+        pass  # fallback ohne LoRA
+
+    pipe = pipeline("text-generation", model=model, tokenizer=tokenizer)
+    return pipe
+
+generator = load_model()

app/main.py

@@ -1,19 +1,61 @@
-import os
-from fastapi import FastAPI, Request
-from pydantic import BaseModel
-from generator import build_prompt, generate_with_retry
-from model_loader import generator
+from fastapi import FastAPI
+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 contextlib import asynccontextmanager
+import logging
 
-SECRET_KEY = os.getenv("SECRET_KEY")
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
 
-app = FastAPI()
+settings.resolved_generated_path.mkdir(parents=True, exist_ok=True)
+settings.resolved_base_path.mkdir(parents=True, exist_ok=True)
+settings.resolved_symbols_path.mkdir(parents=True, exist_ok=True)
+settings.resolved_qr_code_path.mkdir(parents=True, exist_ok=True)
 
-class GenRequest(BaseModel):
-    birthdate: str
-    terms: list[str]
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    logger.info(f"{settings.PROJECT_NAME} Anwendung startet...")
+    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}")
+    yield
+    logger.info(f"{settings.PROJECT_NAME} Anwendung wird heruntergefahren.")
 
-@app.post("/generate")
-def generate_text(req: GenRequest):
-    prompt = build_prompt(req.birthdate, req.terms)
-    output = generate_with_retry(prompt, generator, req.terms)
-    return {"output": output}
+app = FastAPI(
+    title=settings.PROJECT_NAME,  
+    description="Ein Service zur Generierung personalisierter Horoskopkarten mit LoRa und FastAPI.",
+    version=settings.APP_VERSION, 
+    lifespan=lifespan
+)
+
+app.mount("/static", StaticFiles(directory=settings.resolved_static_files_mount_dir), name="static")
+
+
+origins = [
+    "http://localhost",
+    "http://localhost:3000",  
+    # TODO: Optional Füge hier deine Frontend-URL(s) hinzu
+]
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=origins,
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+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(download.router, prefix=settings.API_PREFIX, tags=["Download Card"])
+
+@app.get("/")
+async def root():
+    return {"message": f"Welcome to the {settings.PROJECT_NAME} API."}

app/model_loader.py

@@ -1,2 +0,0 @@
-# model_loader.py
-# LLM laden (lokal oder remote)

app/services/database.py

@@ -0,0 +1,39 @@
+import os
+from supabase import create_client
+from dotenv import load_dotenv
+
+load_dotenv()
+
+SUPABASE_URL = os.getenv("SUPABASE_URL")
+SUPABASE_KEY = os.getenv("SUPABASE_KEY")
+supabase = create_client(SUPABASE_URL, SUPABASE_KEY)
+
+def get_supabase_client():
+    return supabase
+
+def save_horoscope_card(
+    card_id: str,
+    terms: list[str],
+    date_of_birth: str, # Pydantic date wird hier als str erwartet für Supabase
+    horoscope_text: str,
+    image_filename: str, # Nur der Dateiname, Pfad wird serverseitig verwaltet
+    qr_code_filename: str, # Nur der Dateiname
+    qr_code_link: str
+):
+    """Speichert die Daten der generierten Horoskopkarte in Supabase."""
+    try:
+        response = supabase.table("horoscope_cards").insert({
+            "id": card_id,
+            "terms": terms,
+            "date_of_birth": date_of_birth,
+            "horoscope_text": horoscope_text,
+            "image_filename": image_filename,
+            "qr_code_filename": qr_code_filename,
+            "qr_code_link": qr_code_link
+            # created_at wird von Supabase automatisch gesetzt, wenn entsprechend konfiguriert
+        }).execute()
+        return response
+    except Exception as e:
+        # Hier wäre ein besseres Logging/Fehlerhandling gut
+        print(f"Error saving to Supabase: {e}")
+        raise

app/utils/file_utils.py

@@ -0,0 +1,18 @@
+import uuid, os
+from pathlib import Path
+from dotenv import load_dotenv
+
+load_dotenv()
+GENERATED_DIR = Path(os.getenv("GENERATED_PATH", "media"))
+HOST_URL = os.getenv("HOST_URL", "http://localhost:8000")
+
+def save_card_image(image_bytes: bytes, extension="png") -> Path:
+    filename = f"{uuid.uuid4()}.{extension}"
+    filepath = GENERATED_DIR / filename
+    filepath.parent.mkdir(parents=True, exist_ok=True)
+    with open(filepath, "wb") as f:
+        f.write(image_bytes)
+    return filepath
+
+def get_card_url(filename: str, base_url: str = "https://yourdomain.com/media") -> str:
+    return f"{base_url}/{filename}"

app/utils/qr_utils.py

@@ -0,0 +1,8 @@
+import qrcode
+from pathlib import Path
+
+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

requirements.txt

@@ -1,7 +1,12 @@
 fastapi
 uvicorn[standard]
-jinja2
+pydantic
 qrcode
 pillow
+peft
+torch
+accelerate    
 transformers
-peft
+numpy 
+supabase
+jinja2