nowy model

backend/app/api/routes.py

@@ -5,6 +5,7 @@ from app.models.schemas import (
     AnalysisRequest,
     AnalysisResponse,
     ErrorResponse,
+    GuildConfigSchema,
     HealthResponse,
     TextAnalysisRequest,
     ImageAnalysisRequest,
@@ -13,8 +14,9 @@ from app.services.download import download_file
 from app.services.text_analyzer import analyze_text
 from app.services.image_analyzer import analyze_image
 from app.core.config import get_settings
-from app.utils.exceptions import DeepfakeDetectionError
+from app.utils.exceptions import DeepfakeDetectionError, SetupRequiredError
 from app.core.limiter import limiter
+from app.config_manager import save_guild_config
 
 logger = logging.getLogger(__name__)
 
@@ -56,8 +58,35 @@ async def health_check() -> HealthResponse:
         version=settings.APP_VERSION,
         available_models=settings.AVAILABLE_MODELS,
         supported_types=list(settings.AVAILABLE_MODELS.keys()),
+        models_status=models_status,
     )
 
+# Endpoint do zapisywania konfiguracji (wywoływany przez bota)
+@router.post("/guilds/{guild_id}/setup", tags=["Setup"])
+async def save_discord_guild_setup(guild_id: str, payload: GuildConfigSchema):
+    # Walidacja modeli z pliku ustawień
+    settings = get_settings()
+    allowed_text_models = settings.AVAILABLE_MODELS.get("text", [])
+    
+    # Walidujemy tylko wtedy, gdy model nie jest ustawiony na "none"
+    if payload.active_text_model and payload.active_text_model.lower() != "none":
+        if payload.active_text_model not in allowed_text_models:
+            raise HTTPException(
+                status_code=400,
+                detail=f"Model '{payload.active_text_model}' nie jest dozwolony. Wybierz z: {allowed_text_models}"
+            )
+            
+    # Zapis konfiguracji przez config_manager
+    config_dict = payload.dict()
+    save_guild_config(guild_id, config_dict)
+    
+    logger.info(f"Zapisano nową konfigurację dla serwera Discord {guild_id}")
+    return {
+        "status": "success",
+        "message": f"Konfiguracja dla serwera {guild_id} została zapisana.",
+        "config": config_dict
+    }
+
 @router.post(
     "/analyze",
     response_model=AnalysisResponse,

backend/app/config_manager.py

@@ -0,0 +1,44 @@
+import json
+import os
+import logging
+from typing import Dict, Any, Optional
+
+logger = logging.getLogger(__name__)
+CONFIG_FILE = "guild_configs.json"
+
+def _load_all_configs() -> Dict[str, Dict[str, Any]]:
+    """Odczytuje konfiguracje wszystkich serwerów z pliku."""
+    if os.path.exists(CONFIG_FILE):
+        try:
+            with open(CONFIG_FILE, "r", encoding="utf-8") as f:
+                return json.load(f)
+        except Exception as e:
+            logger.error(f"Błąd podczas odczytu pliku konfiguracji: {e}")
+    return {}
+
+def _save_all_configs(configs: Dict[str, Dict[str, Any]]):
+    """Zapisuje konfiguracje na dysk."""
+    try:
+        with open(CONFIG_FILE, "w", encoding="utf-8") as f:
+            json.dump(configs, f, indent=4, ensure_ascii=False)
+    except Exception as e:
+        logger.error(f"Błąd podczas zapisu pliku konfiguracji: {e}")
+
+def save_guild_config(guild_id: str, config_data: Dict[str, Any]):
+    """Zapisuje kompletną konfigurację dla danego serwera Discord."""
+    configs = _load_all_configs()
+    configs[guild_id] = config_data
+    _save_all_configs(configs)
+
+def get_active_text_model(guild_id: str) -> Optional[str]:
+    """
+    Zwraca wybrany model dla serwera. 
+    Zwraca None, jeśli konfiguracja nie istnieje lub model jest ustawiony na 'none'.
+    """
+    configs = _load_all_configs()
+    guild_config = configs.get(guild_id, {})
+    model = guild_config.get("active_text_model", "none")
+    
+    if not model or model.lower() == "none":
+        return None
+    return model

backend/app/core/config.py

@@ -29,7 +29,8 @@ class Settings:
     LOG_FILE: Optional[str] = os.getenv("LOG_FILE", None)
     
     AVAILABLE_MODELS = {
-        "text": ["yaya36095/xlm-roberta-text-detector"],
+        "text": ["yaya36095/xlm-roberta-text-detector",
+                 "almanach/xlmr-chatgptdetect-noisy"],
         "image": ["capcheck/ai-image-detection"],
     }
 

backend/app/models/schemas.py

@@ -1,5 +1,5 @@
 from pydantic import BaseModel, HttpUrl, Field
-from typing import Union, Literal, Optional
+from typing import Union, Literal, Optional, Dict, List
 
 
 class TextAnalysisRequest(BaseModel):
@@ -100,5 +100,17 @@ class HealthResponse(BaseModel):
     status: str = Field(..., description="Service status")
     service: str = Field(..., description="Service name")
     version: str = Field(..., description="Service version")
-    available_models: dict = Field(..., description="Available detector models per content type")
-    supported_types: list = Field(..., description="Supported content types")
+    available_models: Dict[str, List[str]] = Field(
+        ..., description="Lista dostępnych modeli pogrupowana według typów"
+    )
+    supported_types: List[str] = Field(
+        ..., description="Obsługiwane typy danych"
+    )
+    models_status: Dict[str, str] = Field(
+        ..., description="Status gotowości handlerów dla poszczególnych typów"
+    )
+    
+class GuildConfigSchema(BaseModel):
+    active_text_model: Optional[str] = "none"
+    # Tutaj możesz dodać inne parametry, które bot zbiera w sesji setup (np. log_channel_id)
+    log_channel_id: Optional[str] = None

backend/app/services/text_analyzer.py

@@ -1,45 +1,76 @@
 import logging
 import time
+import gc
 from typing import Dict, Any
+
+from app.config_manager import get_active_text_model
+from app.utils.exceptions import SetupRequiredError
 from transformers import pipeline
+# Importujesz helpery z Kroku 2:
+# from config_manager import get_active_text_model 
 
 logger = logging.getLogger(__name__)
 
+# Przechowujemy nazwę aktualnie załadowanego modelu oraz sam obiekt klasyfikatora
+_loaded_model_name = None
 _text_classifier = None
 
-def _load_model():
-    global _text_classifier
-    if _text_classifier is None:
-        logger.info("Loading XLM-RoBERTa text detector model...")
-        _text_classifier = pipeline(
-            "text-classification",
-            model="yaya36095/xlm-roberta-text-detector",
-            device=-1
-        )
-        logger.info("Text detector model loaded successfully")
+def _load_model(target_model_name: str):
+    global _text_classifier, _loaded_model_name
+    
+    # Jeśli model w pamięci jest tym, którego potrzebujemy, po prostu go zwracamy
+    if _text_classifier is not None and _loaded_model_name == target_model_name:
+        return _text_classifier
+        
+    logger.info(f"Wymagana zmiana modelu. Obecny w RAM: {_loaded_model_name}, Nowy: {target_model_name}")
+    
+    # Zwalnianie pamięci po poprzednim modelu
+    _text_classifier = None
+    gc.collect()
+    
+    logger.info(f"Ładowanie modelu text detector: {target_model_name}...")
+    _text_classifier = pipeline(
+        "text-classification",
+        model=target_model_name,
+        device=-1  # -1 oznacza CPU, jeśli masz GPU ustaw np. 0
+    )
+    _loaded_model_name = target_model_name
+    logger.info(f"Model {target_model_name} został pomyślnie załadowany.")
+    
     return _text_classifier
 
-async def analyze_text(text: str) -> Dict[str, Any]:
+async def analyze_text(text: str, guild_id: str) -> Dict[str, Any]:
     start_time = time.time()
     
-    logger.info(f"Starting text analysis, length: {len(text)} chars")
+    # Pobranie aktywnego modelu dla danej gildii
+    active_model = get_active_text_model(guild_id)
     
-    classifier = _load_model()
+    # BLOKADA: Jeżeli model to 'none' lub brak konfiguracji, natychmiast wyrzucamy błąd
+    if not active_model:
+        logger.warning(f"Zablokowano zapytanie! Serwer {guild_id} nie ma skonfigurowanego modelu.")
+        raise SetupRequiredError(
+            f"Serwer o ID '{guild_id}' nie został jeszcze skonfigurowany. "
+            "Użyj komendy setup na Discordzie przed wykonaniem analizy."
+        )
+
+    logger.info(f"Rozpoczęcie analizy tekstu dla serwera {guild_id} przy użyciu modelu: {active_model}")
+    
+    classifier = _load_model(active_model)
     result = classifier(text)
     
     label = result[0]["label"]
     score = result[0]["score"]
     
-    is_deepfake = label.lower() == "fake"
+    is_deepfake = label.lower() in ["fake", "ai", "chatgpt", "label_1", "machine-generated"]
     confidence = score
-    
     analysis_time = time.time() - start_time
     
     response = {
         "is_deepfake": is_deepfake,
         "confidence": round(confidence, 3),
         "analysis_time": round(analysis_time, 3),
+        "used_model": active_model,
     }
     
-    logger.info(f"Text analysis completed. Result: {response}")
-    return response
+    logger.info(f"Analiza zakończona sukcesem dla serwera {guild_id}.")
+    return response

backend/app/utils/exceptions.py

@@ -51,3 +51,9 @@ class UnsupportedModelError(DeepfakeDetectionError):
     def __init__(self, model_name: str):
         message = f"Detector model '{model_name}' is not supported"
         super().__init__(message, 400)
+        
+class SetupRequiredError(Exception):
+    """Wyjątek zgłaszany, gdy bot nie został jeszcze skonfigurowany na danym serwerze."""
+    
+    def __init__(self, message: str = "Setup required"):
+        super().__init__(message, 500)