Merge branch 'main' into hackaton-delenda-est

backend/app/api/routes.py

@@ -16,7 +16,7 @@ from app.services.image_analyzer import analyze_image
 from app.core.config import get_settings
 from app.utils.exceptions import DeepfakeDetectionError, SetupRequiredError
 from app.core.limiter import limiter
-from app.config_manager import save_guild_config
+from app.config_manager import _load_all_configs, save_guild_config
 
 logger = logging.getLogger(__name__)
 
@@ -67,6 +67,7 @@ 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", [])
+    allowed_image_models = settings.AVAILABLE_MODELS.get("image", [])
     
     # Walidujemy tylko wtedy, gdy model nie jest ustawiony na "none"
     if payload.active_text_model and payload.active_text_model.lower() != "none":
@@ -76,6 +77,13 @@ async def save_discord_guild_setup(guild_id: str, payload: GuildConfigSchema):
                 detail=f"Model '{payload.active_text_model}' nie jest dozwolony. Wybierz z: {allowed_text_models}"
             )
             
+    if payload.active_image_model and payload.active_image_model.lower() != "none":
+        if payload.active_image_model not in allowed_image_models:
+            raise HTTPException(
+                status_code=400,
+                detail=f"Model '{payload.active_image_model}' nie jest dozwolony. Wybierz z: {allowed_image_models}"
+            )
+            
     # Zapis konfiguracji przez config_manager
     config_dict = payload.dict()
     save_guild_config(guild_id, config_dict)
@@ -87,6 +95,18 @@ async def save_discord_guild_setup(guild_id: str, payload: GuildConfigSchema):
         "config": config_dict
     }
 
+@router.get("/guilds/{guild_id}/config", tags=["Setup"])
+async def get_discord_guild_config(guild_id: str):
+    """Zwraca zapisaną konfigurację dla konkretnego serwera Discord."""
+    configs = _load_all_configs()
+    guild_config = configs.get(guild_id, {})
+    
+    return {
+        "active_text_model": guild_config.get("active_text_model", "none"),
+        "active_image_model": guild_config.get("active_image_model", "none"),
+        "log_channel_id": guild_config.get("log_channel_id", None)
+    }
+
 @router.post(
     "/analyze",
     response_model=AnalysisResponse,
@@ -102,6 +122,8 @@ async def save_discord_guild_setup(guild_id: str, payload: GuildConfigSchema):
 )
 @limiter.limit("1/5seconds")
 async def analyze(request: Request, payload: AnalysisRequest) -> AnalysisResponse:
+    guild_id = payload.guild_id
+    
     if isinstance(payload, TextAnalysisRequest):
         content_type = "text"
     elif isinstance(payload, ImageAnalysisRequest):
@@ -113,12 +135,6 @@ async def analyze(request: Request, payload: AnalysisRequest) -> AnalysisRespons
         )
 
     settings = get_settings()
-    models = settings.AVAILABLE_MODELS.get(content_type)
-    if not models:
-        raise HTTPException(status_code=400, detail=f"No model available for {content_type} analysis")
-    
-    model = models[0]
-    logger.info(f"Received {content_type} analysis request, model: {model}")
 
     try:
         if content_type == "text":
@@ -127,7 +143,7 @@ async def analyze(request: Request, payload: AnalysisRequest) -> AnalysisRespons
             if len(payload.text) < 50:
                 raise ValueError("Text content must be at least 50 characters")
             
-            analysis_result = await analyze_text(payload.text)
+            analysis_result = await analyze_text(payload.text, guild_id)
 
         elif content_type == "image":
             image_bytes = await download_file(str(payload.image_url))
@@ -136,10 +152,12 @@ async def analyze(request: Request, payload: AnalysisRequest) -> AnalysisRespons
             if len(image_bytes) > settings.MAX_CONTENT_SIZES["image"]:
                 raise ValueError(f"Image size exceeds maximum of {settings.MAX_CONTENT_SIZES['image']} bytes")
             
-            analysis_result = await analyze_image(image_bytes)
+            analysis_result = await analyze_image(image_bytes, guild_id)
 
     except ValueError as e:
         raise HTTPException(status_code=400, detail=str(e))
+    except SetupRequiredError as e:
+        raise HTTPException(status_code=400, detail=str(e))
     except DeepfakeDetectionError as e:
         raise HTTPException(status_code=e.status_code, detail=e.message)
     except Exception as e:
@@ -147,12 +165,13 @@ async def analyze(request: Request, payload: AnalysisRequest) -> AnalysisRespons
         raise HTTPException(status_code=500, detail=f"Failed to analyze {content_type}")
 
     logger.info(f"{content_type.capitalize()} analysis completed. Result: {analysis_result}")
+    used_model = analysis_result.get("used_model", settings.AVAILABLE_MODELS.get(content_type)[0])
     
     return AnalysisResponse(
         is_deepfake=analysis_result["is_deepfake"],
         confidence=analysis_result["confidence"],
         analysis_time=analysis_result["analysis_time"],
-        used_model=model,
+        used_model=used_model,
         content_type=content_type,
     )
 

backend/app/config_manager.py

@@ -39,6 +39,16 @@ def get_active_text_model(guild_id: str) -> Optional[str]:
     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
+
+def get_active_image_model(guild_id: str) -> Optional[str]:
+    """Zwraca aktywny model obrazu dla serwera. Jeśli brak konfiguracji, zwraca None."""
+    configs = _load_all_configs()
+    guild_config = configs.get(guild_id, {})
+    model = guild_config.get("active_image_model", "none")
+    
     if not model or model.lower() == "none":
         return None
     return model

backend/app/models/schemas.py

@@ -5,6 +5,7 @@ from typing import Union, Literal, Optional, Dict, List
 class TextAnalysisRequest(BaseModel):
     content_type: Literal["text"]
     text: str = Field(..., description="Text content to analyze for deepfake detection")
+    guild_id: str = Field(..., description="ID serwera Discord, z którego pochodzi żądanie")
     
     class Config:
         json_schema_extra = {
@@ -18,6 +19,7 @@ class TextAnalysisRequest(BaseModel):
 class ImageAnalysisRequest(BaseModel):
     content_type: Literal["image"]
     image_url: HttpUrl = Field(..., description="URL of the image to analyze")
+    guild_id: str = Field(..., description="ID serwera Discord, z którego pochodzi żądanie")
     
     class Config:
         json_schema_extra = {
@@ -28,37 +30,10 @@ class ImageAnalysisRequest(BaseModel):
         }
 
 
-class VideoAnalysisRequest(BaseModel):
-    content_type: Literal["video"]
-    video_url: HttpUrl = Field(..., description="URL of the video to analyze")
-    
-    class Config:
-        json_schema_extra = {
-            "example": {
-                "content_type": "video",
-                "video_url": "https://example.com/video.mp4"
-            }
-        }
-
-
-class FileAnalysisRequest(BaseModel):
-    content_type: Literal["file"]
-    file_url: HttpUrl = Field(..., description="URL of the file to analyze")
-    
-    class Config:
-        json_schema_extra = {
-            "example": {
-                "content_type": "file",
-                "file_url": "https://example.com/video.mp4"
-            }
-        }
-
 
 AnalysisRequest = Union[
     TextAnalysisRequest,
-    ImageAnalysisRequest,
-    VideoAnalysisRequest,
-    FileAnalysisRequest,
+    ImageAnalysisRequest
 ]
 
 
@@ -112,5 +87,5 @@ class HealthResponse(BaseModel):
     
 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)
+    active_image_model: Optional[str] = "none"
     log_channel_id: Optional[str] = None

backend/app/services/image_analyzer.py

@@ -1,30 +1,60 @@
 import io
 import logging
 import time
+import gc
 from typing import Dict, Any
 from PIL import Image
 from transformers import pipeline
 
+# Importujemy helper do konfiguracji oraz wyjątek braku konfiguracji
+from app.config_manager import get_active_image_model
+from app.utils.exceptions import SetupRequiredError
+
 logger = logging.getLogger(__name__)
 
+# Przechowujemy referencje do aktualnie załadowanego modelu obrazów
+_loaded_model_name = None
 _image_classifier = None
 
-def _load_model():
-    global _image_classifier
-    if _image_classifier is None:
-        logger.info("Loading capcheck/ai-image-detection model...")
-        _image_classifier = pipeline(
-            "image-classification",
-            model="capcheck/ai-image-detection",
-            device=-1 
-        )
-        logger.info("Image detector model loaded successfully")
+def _load_model(target_model_name: str):
+    global _image_classifier, _loaded_model_name
+    
+    # Jeśli model o tej nazwie jest już załadowany w pamięci, używamy go ponownie
+    if _image_classifier is not None and _loaded_model_name == target_model_name:
+        return _image_classifier
+        
+    logger.info(f"Wymagana zmiana modelu obrazu. Obecny w RAM: {_loaded_model_name}, Nowy: {target_model_name}")
+    
+    # Czyszczenie pamięci po poprzednim modelu obrazów
+    _image_classifier = None
+    gc.collect()
+    
+    logger.info(f"Ładowanie modelu image detector: {target_model_name}...")
+    _image_classifier = pipeline(
+        "image-classification",
+        model=target_model_name,
+        device=-1  # -1 oznacza CPU
+    )
+    _loaded_model_name = target_model_name
+    logger.info(f"Model {target_model_name} został pomyślnie załadowany.")
+    
     return _image_classifier
 
-async def analyze_image(image_bytes: bytes) -> Dict[str, Any]:
+async def analyze_image(image_bytes: bytes, guild_id: str) -> Dict[str, Any]:
     start_time = time.time()
     
-    logger.info(f"Starting image analysis, size: {len(image_bytes)} bytes")
+    # 1. Sprawdzamy konfigurację modelu dla danego serwera Discord
+    active_model = get_active_image_model(guild_id)
+    
+    # BLOKADA: Jeżeli model to 'none' lub brak konfiguracji, natychmiast przerywamy i zgłaszamy błąd
+    if not active_model:
+        logger.warning(f"Zablokowano zapytanie! Serwer {guild_id} nie ma skonfigurowanego modelu dla obrazów.")
+        raise SetupRequiredError(
+            f"Serwer o ID '{guild_id}' nie został jeszcze skonfigurowany pod kątem analizy obrazów. "
+            "Użyj komendy setup na Discordzie przed wykonaniem analizy."
+        )
+
+    logger.info(f"Starting image analysis for guild: {guild_id}, model: {active_model}, size: {len(image_bytes)} bytes")
     
     try:
         image = Image.open(io.BytesIO(image_bytes)).convert("RGB")
@@ -32,14 +62,15 @@ async def analyze_image(image_bytes: bytes) -> Dict[str, Any]:
         logger.error(f"Failed to parse image bytes: {str(e)}")
         raise ValueError("Invalid image format or corrupted bytes") from e
     
-    classifier = _load_model()
-    
+    # 2. Dynamicznie pobieramy/ładujemy wskazany model
+    classifier = _load_model(active_model)
     result = classifier(image)
     
     label = result[0]["label"]
     score = result[0]["score"]
     
-    is_deepfake = label.lower() == "fake"
+    # Dostosowanie do najczęstszych etykiet fałszywych obrazów (np. "fake", "ai", "synthetic")
+    is_deepfake = label.lower() in ["fake", "ai", "synthetic", "label_1"]
     confidence = score
     
     analysis_time = time.time() - start_time
@@ -48,6 +79,7 @@ async def analyze_image(image_bytes: bytes) -> Dict[str, Any]:
         "is_deepfake": is_deepfake,
         "confidence": round(confidence, 3),
         "analysis_time": round(analysis_time, 3),
+        "used_model": active_model,
     }
     
     logger.info(f"Image analysis completed. Result: {response}")

backend/guild_configs.json

@@ -0,0 +1,7 @@
+{
+    "1515307986963267595": {
+        "active_text_model": "almanach/xlmr-chatgptdetect-noisy",
+        "active_image_model": "capcheck/ai-image-detection",
+        "log_channel_id": "1515373138937123007"
+    }
+}

configManager.js

@@ -1,44 +0,0 @@
-import fs from "fs";
-import path from "path";
-
-const filePath = path.resolve("./guildConfigs.json");
-
-// Domyślne ustawienia (teraz modele są zapisywane dynamicznie w obiekcie)
-export const DEFAULT_CONFIG = {
-	logChannelId: null,
-	models: {} 
-};
-
-export function loadConfig(guildId) {
-	if (!fs.existsSync(filePath)) {
-		fs.writeFileSync(filePath, JSON.stringify({}));
-	}
-	try {
-		const data = JSON.parse(fs.readFileSync(filePath, "utf-8"));
-		const config = data[guildId] || { ...DEFAULT_CONFIG };
-		
-		// Upewniamy się, że obiekt "models" zawsze istnieje
-		if (!config.models) {
-			config.models = {};
-		}
-		return config;
-	} catch (err) {
-		console.error("Błąd podczas odczytu konfiguracji:", err);
-		return { ...DEFAULT_CONFIG };
-	}
-}
-
-export function saveConfig(guildId, newConfig) {
-	if (!fs.existsSync(filePath)) {
-		fs.writeFileSync(filePath, JSON.stringify({}));
-	}
-	try {
-		const data = JSON.parse(fs.readFileSync(filePath, "utf-8"));
-		data[guildId] = { ...DEFAULT_CONFIG, ...data[guildId], ...newConfig };
-		fs.writeFileSync(filePath, JSON.stringify(data, null, 2));
-		return true;
-	} catch (err) {
-		console.error("Błąd podczas zapisu konfiguracji:", err);
-		return false;
-	}
-}

index.js

@@ -20,8 +20,6 @@ import {
   ChannelType
 } from "discord.js";
 
-import { loadConfig, saveConfig } from "./configManager.js";
-
 const client = new Client({
 	intents: [
 		GatewayIntentBits.Guilds,
@@ -81,6 +79,28 @@ async function fetchAvailableModels() {
 	return null;
 }
 
+async function fetchGuildConfig(guildId) {
+	try {
+		const response = await fetch(`${API_URL}/guilds/${guildId}/config`);
+		if (response.ok) {
+			const data = await response.json();
+			return {
+				logChannelId: data.log_channel_id,
+				models: {
+					text: data.active_text_model || "none",
+					image: data.active_image_model || "none"
+				}
+			};
+		}
+	} catch (err) {
+		console.error(`[CONFIG ERROR] Błąd pobierania konfiguracji dla gildii ${guildId}:`, err.message);
+	}
+	return {
+		logChannelId: null,
+		models: {}
+	};
+}
+
 function preparePayload(input, explicitContentType = null) {
 	const trimmed = input.trim();
 
@@ -198,7 +218,7 @@ function generateSetupView(tempConfig, availableModels) {
 }
 
 async function sendLogToDiscord(guild, embedToSend) {
-	const config = loadConfig(guild.id);
+	const config = await fetchGuildConfig(guild.id);
 	if (!config.logChannelId) return;
 
 	try {
@@ -214,16 +234,9 @@ async function sendLogToDiscord(guild, embedToSend) {
 async function handleAnalysis(interaction, userContent, targetMessage = null, explicitContentType = null) {
 	await interaction.deferReply({ flags: [MessageFlags.Ephemeral] });
 
-	const serverConfig = loadConfig(interaction.guildId);
-
 	try {
 		const { type, payload } = preparePayload(userContent, explicitContentType);
-		
-		// DYNAMICZNE POBIERANIE MODELU Z PLIKU KONFIGURACYJNEGO DLA DANEGO FORMATU (np. text, image, video)
-		const chosenModel = serverConfig.models[type];
-		if (chosenModel) {
-			payload.model = chosenModel;
-		}
+		payload.guild_id = interaction.guildId;
 
 		console.log(`Wysyłanie zapytania typu: ${type} do API z modelem: ${payload.model || "domyślny"}...`);
 
@@ -335,28 +348,25 @@ client.on(Events.InteractionCreate, async (interaction) => {
 
 		if (interaction.commandName === "setup") {
 			const guildId = interaction.guildId;
-			const currentConfig = loadConfig(guildId);
-
+            
 			await interaction.deferReply({ flags: [MessageFlags.Ephemeral] });
 
-			// Pobieramy aktywne modele bezpośrednio z FastAPI
+			// Pobieramy konfigurację bezpośrednio z FastAPI
+			const currentConfig = await fetchGuildConfig(guildId);
 			const availableModels = await fetchAvailableModels();
 
-			// Jeśli backend nie działa, natychmiast przerywamy i wyświetlamy błąd
 			if (!availableModels || Object.keys(availableModels).length === 0) {
 				return interaction.editReply({
 					content: "❌ **Błąd konfiguracji:** Nie udało się nawiązać połączenia z backendem (FastAPI). Uruchom swój backend w Pythonie i spróbuj ponownie!"
 				});
 			}
 
-			// Inicjalizujemy domyślne modele w konfiguracji, jeśli nie były wcześniej ustawione
 			for (const [contentType, models] of Object.entries(availableModels)) {
 				if (!currentConfig.models[contentType] && models.length > 0) {
 					currentConfig.models[contentType] = models[0];
 				}
 			}
 
-			// Zapisujemy sesję z konfiguracją oraz pobranymi modelami
 			activeSetupSessions.set(guildId, { 
 				config: { ...currentConfig }, 
 				availableModels 
@@ -447,14 +457,15 @@ client.on(Events.InteractionCreate, async (interaction) => {
 			const tempSession = activeSetupSessions.get(guildId);
 			if (tempSession) {
 				try {
-					const response = await fetch(`http://backend-api-url/guilds/${guildId}/setup`, {
+					const response = await fetch(`${API_URL}/guilds/${guildId}/setup`, {
 						method: "POST",
 						headers: {
 							"Content-Type": "application/json"
 						},
 						body: JSON.stringify({
-							active_text_model: tempSession.config.active_text_model || "none",
-							log_channel_id: tempSession.config.log_channel_id || null
+							active_text_model: tempSession.config.models?.text || "none",
+							active_image_model: tempSession.config.models?.image || "none",
+							log_channel_id: tempSession.config.logChannelId || null
 						})
 					});