Upload folder using huggingface_hub

modules/art_tools.py

@@ -0,0 +1,173 @@
+# modules/art_tools.py
+
+import os
+import math
+import numpy as np
+from PIL import Image, ImageDraw, ImageFont, ImageFilter, ImageOps
+import gradio as gr
+import io
+
+# --- ADOPTABLE GRID MAKER ---
+
+def hex_to_rgb(hex_color):
+    """Hex color kodunu (ör: #FF0000) (255, 0, 0) tuple'ına çevirir."""
+    hex_color = hex_color.lstrip('#')
+    return tuple(int(hex_color[i:i+2], 16) for i in (0, 2, 4)) + (255,) # Alpha ekle
+
+def create_grid_collage(files, columns, add_labels, label_type, start_number, bg_color_hex, title_text, banner_color_hex, title_color_hex):
+    """
+    Adoptable Style Grid Collage Maker
+    """
+    if not files:
+        return None, "⚠️ Lütfen resim dosyalarını seçin."
+    
+    try:
+        images = []
+        for file_obj in files:
+            try:
+                img = Image.open(file_obj.name).convert("RGBA")
+                images.append(img)
+            except:
+                continue
+                
+        if not images:
+            return None, "⚠️ Geçerli resim bulunamadı."
+
+
+        count = len(images)
+        cols = int(columns)
+        rows = math.ceil(count / cols)
+        
+        # 1. Boyut Standardizasyonu (İlk resme göre)
+        base_w, base_h = images[0].size
+        resized_images = []
+        for img in images:
+            if img.size != (base_w, base_h):
+                resized_images.append(img.resize((base_w, base_h), Image.Resampling.LANCZOS))
+            else:
+                resized_images.append(img)
+        
+        # Tasarım Parametreleri
+        padding = 40  # Resimler arası boşluk biraz arttı
+        frame_width = 15 # Çerçeve kalınlığı arttı
+
+        # Renkler
+        bg_color = hex_to_rgb(bg_color_hex)
+        banner_color = hex_to_rgb(banner_color_hex)
+        title_color = hex_to_rgb(title_color_hex)
+        frame_color = title_color # Çerçeve rengi başlık rengiyle aynı olsun
+
+        # Canvas Boyutu (Önce hesapla)
+        grid_w = (cols * base_w) + ((cols + 1) * padding)
+        
+        # Header Yüksekliği: Grid genişliğine orantılı olsun (Genişlik arttıkça yükseklik de artsın ki text büyüyebilsin)
+        # Min 250px, yoksa genişliğin %15'i
+        header_height = max(250, int(grid_w * 0.15))
+        
+        grid_h = header_height + (rows * base_h) + ((rows + 1) * padding)
+        
+        grid_img = Image.new("RGBA", (grid_w, grid_h), bg_color)
+        draw = ImageDraw.Draw(grid_img)
+        
+        # --- HEADER (BANNER) ÇİZİMİ ---
+        draw.rectangle([(0, 0), (grid_w, header_height)], fill=banner_color)
+        draw.rectangle([(0, header_height-15), (grid_w, header_height)], fill=frame_color)
+
+        # Başlangıç Font Boyutu (Çok daha büyük başlıyoruz - Grid genişliğine orantılı)
+        font_title_size = int(grid_w * 0.1) # Genişliğin %10'u ile başla
+        
+        # --- BAŞLIK FONTU BÜYÜKLÜĞÜNÜ AYARLA (Agresif Scaling) ---
+        target_width = grid_w * 0.95  # Banner genişliğinin %95'ini doldurmalı
+        max_height_text = header_height * 0.8 # Yüksekliğin %80'ini geçmesin (Hava kalsın)
+        
+        try:
+            font_path = "timesbd.ttf"
+            font_title = ImageFont.truetype(font_path, font_title_size)
+        except:
+             font_path = None
+             font_title = ImageFont.load_default()
+             
+        if font_path:
+            # İterasyonla en uygun boyutu bul
+            for _ in range(50): # Sonsuz döngüden kaçınmak için limitli
+                bbox_title = draw.textbbox((0, 0), title_text, font=font_title)
+                
+                w_total = (bbox_title[2] - bbox_title[0])
+                h_max = bbox_title[3] - bbox_title[1]
+
+                # Çok büyükse küçült
+                if w_total > target_width or h_max > max_height_text:
+                    font_title_size -= 5
+                    if font_title_size < 20: break
+                    font_title = ImageFont.truetype(font_path, font_title_size)
+                # Çok küçükse büyüt (Eğer dikeyde ve yatayda yer varsa)
+                elif w_total < target_width * 0.9 and h_max < max_height_text * 0.9:
+                     font_title_size += 5
+                     font_title = ImageFont.truetype(font_path, font_title_size)
+                else:
+                    break # Tamamdır
+        
+        # Son Ölçümler & Çizim
+        bbox_title = draw.textbbox((0, 0), title_text, font=font_title)
+        w_title = bbox_title[2] - bbox_title[0]
+        h_title = bbox_title[3] - bbox_title[1]
+        
+        start_x_text = (grid_w - w_title) // 2
+        bg_center_y = header_height // 2
+        
+        # Başlık çiz
+        draw.text((start_x_text, bg_center_y - h_title//2), title_text, font=font_title, fill=title_color, stroke_width=int(font_title_size*0.02), stroke_fill="black")
+
+        # --- RESİMLERİ YERLEŞTİR ---
+        # Numara Fontunu Resim Boyutuna Göre Ayarla (Çok Büyük)
+        try:
+            num_font_size = int(base_w * 0.25) # Resim genişliğinin %25'i kadar (Kocaman)
+            font_num = ImageFont.truetype("impact.ttf", num_font_size)
+        except:
+            font_num = ImageFont.load_default()
+
+        current_num = int(start_number)
+        
+        for i, img in enumerate(resized_images):
+            r = i // cols
+            c = i % cols
+            
+            x = padding + (c * (base_w + padding))
+            y = header_height + padding + (r * (base_h + padding))
+            
+            # Kalın Çerçeve
+            draw.rectangle(
+                [(x - frame_width, y - frame_width), 
+                 (x + base_w + frame_width, y + base_h + frame_width)], 
+                fill=None, outline=frame_color, width=frame_width
+            )
+
+            # Resim
+            grid_img.paste(img, (x, y), mask=img)
+            
+            # --- OVERLAY NUMARA (DEVASA) ---
+            if add_labels:
+                if str(label_type).startswith("Sadece"):
+                    num_str = f"{current_num}"
+                else:
+                    num_str = f"#{current_num}"
+                current_num += 1
+                
+                bbox_num = draw.textbbox((0, 0), num_str, font=font_num)
+                w_num = bbox_num[2] - bbox_num[0]
+                h_num = bbox_num[3] - bbox_num[1]
+                
+                # Ortala ve Biraz daha yukarı al (Resmin altından %10 yukarıda)
+                num_x = x + (base_w - w_num) // 2
+                num_y = y + base_h - h_num - int(base_h * 0.05) - 20
+                
+                # Çok Kalın Outline
+                outline_width = int(num_font_size * 0.08) # Font boyutuna göre outline kalınlığı
+                draw.text((num_x, num_y), num_str, font=font_num, fill="white", stroke_width=outline_width, stroke_fill="black")
+
+        return grid_img, "✅ Adoptable Grid oluşturuldu!"
+
+    except Exception as e:
+        import traceback
+        traceback.print_exc()
+        return None, f"❌ Hata: {str(e)}"

modules/cl_tagger_module.py

@@ -0,0 +1,297 @@
+# modules/cl_tagger_module.py
+
+import numpy as np
+from PIL import Image
+import json
+import os
+import onnxruntime as ort
+from huggingface_hub import hf_hub_download
+from dataclasses import dataclass
+from typing import Dict
+
+# --- Data Classes ---
+@dataclass
+class LabelData:
+    names: list[str]
+    rating: list[np.int64]
+    general: list[np.int64]
+    artist: list[np.int64]
+    character: list[np.int64]
+    copyright: list[np.int64]
+    meta: list[np.int64]
+    quality: list[np.int64]
+    model: list[np.int64]
+
+# --- Helper Functions ---
+def pil_ensure_rgb(image: Image.Image) -> Image.Image:
+    if image.mode not in ["RGB", "RGBA"]:
+        image = image.convert("RGBA") if "transparency" in image.info else image.convert("RGB")
+    if image.mode == "RGBA":
+        background = Image.new("RGB", image.size, (255, 255, 255))
+        background.paste(image, mask=image.split()[3])
+        image = background
+    return image
+
+def pil_pad_square(image: Image.Image) -> Image.Image:
+    width, height = image.size
+    if width == height: return image
+    new_size = max(width, height)
+    new_image = Image.new(image.mode, (new_size, new_size), (255, 255, 255))
+    paste_position = ((new_size - width) // 2, (new_size - height) // 2)
+    new_image.paste(image, paste_position)
+    return new_image
+
+def load_tag_mapping(mapping_path):
+    with open(mapping_path, 'r', encoding='utf-8') as f: tag_mapping_data = json.load(f)
+    if isinstance(tag_mapping_data, dict) and "idx_to_tag" in tag_mapping_data:
+        idx_to_tag = {int(k): v for k, v in tag_mapping_data["idx_to_tag"].items()}
+        tag_to_category = tag_mapping_data["tag_to_category"]
+    elif isinstance(tag_mapping_data, dict):
+        try:
+             tag_mapping_data_int_keys = {int(k): v for k, v in tag_mapping_data.items()}
+             idx_to_tag = {idx: data['tag'] for idx, data in tag_mapping_data_int_keys.items()}
+             tag_to_category = {data['tag']: data['category'] for data in tag_mapping_data_int_keys.values()}
+        except (KeyError, ValueError) as e:
+             raise ValueError(f"Unsupported tag mapping format (dict): {e}. Expected int keys with 'tag' and 'category'.")
+    else:
+        raise ValueError("Unsupported tag mapping format: Expected a dictionary.")
+
+    names = [None] * (max(idx_to_tag.keys()) + 1)
+    rating, general, artist, character, copyright, meta, quality, model_name = [], [], [], [], [], [], [], []
+    for idx, tag in idx_to_tag.items():
+        if idx >= len(names): names.extend([None] * (idx - len(names) + 1))
+        names[idx] = tag
+        category = tag_to_category.get(tag, 'Unknown')
+        idx_int = int(idx)
+        if category == 'Rating': rating.append(idx_int)
+        elif category == 'General': general.append(idx_int)
+        elif category == 'Artist': artist.append(idx_int)
+        elif category == 'Character': character.append(idx_int)
+        elif category == 'Copyright': copyright.append(idx_int)
+        elif category == 'Meta': meta.append(idx_int)
+        elif category == 'Quality': quality.append(idx_int)
+        elif category == 'Model': model_name.append(idx_int)
+
+    return LabelData(names=names, rating=np.array(rating, dtype=np.int64), general=np.array(general, dtype=np.int64), artist=np.array(artist, dtype=np.int64),
+                     character=np.array(character, dtype=np.int64), copyright=np.array(copyright, dtype=np.int64), meta=np.array(meta, dtype=np.int64), quality=np.array(quality, dtype=np.int64), model=np.array(model_name, dtype=np.int64)), idx_to_tag, tag_to_category
+
+def preprocess_image(image: Image.Image, target_size=(448, 448)):
+    image = pil_ensure_rgb(image)
+    image = pil_pad_square(image)
+    image_resized = image.resize(target_size, Image.BICUBIC)
+    img_array = np.array(image_resized, dtype=np.float32) / 255.0
+    img_array = img_array.transpose(2, 0, 1) # HWC -> CHW
+    img_array = img_array[::-1, :, :] # BGR conversion
+    mean = np.array([0.5, 0.5, 0.5], dtype=np.float32).reshape(3, 1, 1)
+    std = np.array([0.5, 0.5, 0.5], dtype=np.float32).reshape(3, 1, 1)
+    img_array = (img_array - mean) / std
+    img_array = np.expand_dims(img_array, axis=0) # Add batch dimension
+    return image, img_array
+
+def get_tags(probs, labels: LabelData, gen_threshold, char_threshold):
+    result = {
+        "rating": [], "general": [], "character": [], "copyright": [],
+        "artist": [], "meta": [], "quality": [], "model": []
+    }
+    
+    # Rating (select max)
+    if len(labels.rating) > 0:
+        valid_indices = labels.rating[labels.rating < len(probs)]
+        if len(valid_indices) > 0:
+            rating_probs = probs[valid_indices]
+            if len(rating_probs) > 0:
+                rating_idx_local = np.argmax(rating_probs)
+                rating_idx_global = valid_indices[rating_idx_local]
+                if rating_idx_global < len(labels.names) and labels.names[rating_idx_global] is not None:
+                    rating_name = labels.names[rating_idx_global]
+                    rating_conf = float(rating_probs[rating_idx_local])
+                    result["rating"].append((rating_name, rating_conf))
+
+    # Quality (select max)
+    if len(labels.quality) > 0:
+        valid_indices = labels.quality[labels.quality < len(probs)]
+        if len(valid_indices) > 0:
+            quality_probs = probs[valid_indices]
+            if len(quality_probs) > 0:
+                quality_idx_local = np.argmax(quality_probs)
+                quality_idx_global = valid_indices[quality_idx_local]
+                if quality_idx_global < len(labels.names) and labels.names[quality_idx_global] is not None:
+                    quality_name = labels.names[quality_idx_global]
+                    quality_conf = float(quality_probs[quality_idx_local])
+                    result["quality"].append((quality_name, quality_conf))
+
+    # Threshold-based categories
+    category_map = {
+        "general": (labels.general, gen_threshold),
+        "character": (labels.character, char_threshold),
+        "copyright": (labels.copyright, char_threshold),
+        "artist": (labels.artist, char_threshold),
+        "meta": (labels.meta, gen_threshold),
+        "model": (labels.model, gen_threshold)
+    }
+    for category, (indices, threshold) in category_map.items():
+        if len(indices) > 0:
+            valid_indices = indices[(indices < len(probs))]
+            if len(valid_indices) > 0:
+                category_probs = probs[valid_indices]
+                mask = category_probs >= threshold
+                selected_indices_local = np.where(mask)[0]
+                if len(selected_indices_local) > 0:
+                    selected_indices_global = valid_indices[selected_indices_local]
+                    selected_probs = category_probs[selected_indices_local]
+                    for idx_global, prob_val in zip(selected_indices_global, selected_probs):
+                        if idx_global < len(labels.names) and labels.names[idx_global] is not None:
+                             result[category].append((labels.names[idx_global], float(prob_val)))
+
+    for k in result:
+        result[k] = sorted(result[k], key=lambda x: x[1], reverse=True)
+    return result
+
+# --- Constants ---
+REPO_ID = "cella110n/cl_tagger"
+MODEL_OPTIONS = {
+    "cl_tagger_1_00": "cl_tagger_1_00/model_optimized.onnx"
+}
+DEFAULT_MODEL = "cl_tagger_1_00"
+CACHE_DIR = "./models/model_cache"
+
+class CLTagger:
+    def __init__(self):
+        self.onnx_model_path = None
+        self.tag_mapping_path = None
+        self.labels_data = None
+        self.idx_to_tag = None
+        self.tag_to_category = None
+        self.current_model = None
+        self.session = None
+        self.initialize_onnx_paths(DEFAULT_MODEL)
+
+    def initialize_onnx_paths(self, model_choice=DEFAULT_MODEL):
+        if not model_choice in MODEL_OPTIONS:
+            print(f"Invalid model choice: {model_choice}, falling back to default: {DEFAULT_MODEL}")
+            model_choice = DEFAULT_MODEL
+        
+        self.current_model = model_choice
+        model_dir = model_choice
+        onnx_filename = MODEL_OPTIONS[model_choice]
+        tag_mapping_filename = f"{model_dir}/tag_mapping.json"
+        
+        print(f"Initializing ONNX paths and labels for model: {model_choice}...")
+        hf_token = os.environ.get("HF_TOKEN")
+        
+        try:
+            print(f"Attempting to download ONNX model: {onnx_filename}")
+            self.onnx_model_path = hf_hub_download(
+                repo_id=REPO_ID,
+                filename=onnx_filename,
+                cache_dir=CACHE_DIR,
+                token=hf_token,
+                force_download=False
+            )
+            print(f"ONNX model path: {self.onnx_model_path}")
+
+            print(f"Attempting to download Tag mapping: {tag_mapping_filename}")
+            self.tag_mapping_path = hf_hub_download(
+                repo_id=REPO_ID,
+                filename=tag_mapping_filename,
+                cache_dir=CACHE_DIR,
+                token=hf_token,
+                force_download=False
+            )
+            print(f"Tag mapping path: {self.tag_mapping_path}")
+
+            print("Loading labels from mapping...")
+            self.labels_data, self.idx_to_tag, self.tag_to_category = load_tag_mapping(self.tag_mapping_path)
+            print(f"Labels loaded. Count: {len(self.labels_data.names)}")
+
+            print("Creating ONNX Runtime session (CPUExecutionProvider)...")
+            self.session = ort.InferenceSession(
+                self.onnx_model_path,
+                providers=["CPUExecutionProvider"]
+            )
+            print("ONNX Runtime session ready.")
+            return True
+
+        except Exception as e:
+            print(f"Error during initialization of CLTagger: {e}")
+            import traceback; traceback.print_exc()
+            self.onnx_model_path = None
+            self.tag_mapping_path = None
+            self.labels_data = None
+            self.idx_to_tag = None
+            self.tag_to_category = None
+            self.current_model = None
+            self.session = None
+            raise
+
+    def predict(self, image_input: Image.Image, gen_threshold: float, char_threshold: float) -> tuple[str, Image.Image | None, Dict]:
+        """
+        Tahmin işlemini gerçekleştirir.
+        :param image_input: Giriş PIL Image nesnesi.
+        :param gen_threshold: Genel/Meta/Model etiketleri için eşik değeri.
+        :param char_threshold: Karakter/Telif Hakkı/Sanatçı etiketleri için eşik değeri.
+        :return: (etiketler_string, None, ham_tahminler_sözlüğü)
+        """
+        
+        if self.onnx_model_path is None or self.labels_data is None or self.session is None:
+            message = "Error: CLTagger not initialized. Check startup logs."
+            print(message)
+            return message, None, {}
+
+        try:
+            original_pil_image, input_tensor = preprocess_image(image_input)
+            input_tensor = input_tensor.astype(np.float32)
+
+        except Exception as e:
+            message = f"Error processing input image in CLTagger: {e}"
+            print(message)
+            return message, None, {}
+
+        try:
+            input_name = self.session.get_inputs()[0].name
+            output_name = self.session.get_outputs()[0].name
+            outputs = self.session.run([output_name], {input_name: input_tensor})[0]
+
+            if np.isnan(outputs).any() or np.isinf(outputs).any():
+                outputs = np.nan_to_num(outputs, nan=0.0, posinf=1.0, neginf=0.0)
+
+            def stable_sigmoid(x):
+                return 1 / (1 + np.exp(-np.clip(x, -30, 30)))
+            probs = stable_sigmoid(outputs[0])
+
+        except Exception as e:
+            message = f"Error during ONNX inference in CLTagger: {e}"
+            print(message)
+            import traceback; traceback.print_exc()
+            return message, None, {}
+
+        try:
+            predictions = get_tags(probs, self.labels_data, gen_threshold, char_threshold)
+
+            output_tags = []
+            if predictions.get("rating"): output_tags.append(predictions["rating"][0][0].replace("_", " "))
+            if predictions.get("quality"): output_tags.append(predictions["quality"][0][0].replace("_", " "))
+            for category in ["artist", "character", "copyright", "general", "meta", "model"]:
+                tags_in_category = predictions.get(category, [])
+                for tag, prob in tags_in_category:
+                    if category == "meta" and any(p in tag.lower() for p in ['id', 'commentary', 'request', 'mismatch']):
+                        continue
+                    output_tags.append(tag.replace("_", " "))
+            output_text = ", ".join(output_tags)
+
+            # Visualization removed. Returning None for the image placeholder to maintain signature compatibility.
+            return output_text, None, predictions
+
+        except Exception as e:
+            message = f"Error during post-processing in CLTagger: {e}"
+            print(message)
+            import traceback; traceback.print_exc()
+            return message, None, {}
+
+# Module initialization
+if __name__ == "__main__":
+    try:
+        tagger_instance = CLTagger()
+        print("CLTagger module loaded successfully for testing.")
+    except Exception as e:
+        print(f"Failed to initialize CLTagger module: {e}")

modules/config_manager.py

@@ -0,0 +1,243 @@
+# modules/config_manager.py
+import os
+import json
+import gradio as gr
+
+# --- Yapılandırma ve Dosya Yolları ---
+CONFIG_FILE = "data/configs/config.json"
+TEMPLATES_FILE = "data/configs/renaming_templates.json" # Yeni Şablon Dosyası
+
+# --- ŞABLON YÖNETİMİ FONKSİYONLARI (YENİ) ---
+def load_renaming_templates():
+    default_templates = ["Adoptable {Number} (Female)", "{Number}", "Character_{Number}", "Design #{Number}"]
+    if os.path.exists(TEMPLATES_FILE):
+        try:
+            with open(TEMPLATES_FILE, "r", encoding="utf-8") as f:
+                loaded = json.load(f)
+                if isinstance(loaded, list) and loaded: return loaded
+        except: pass
+    return default_templates
+
+def save_renaming_templates_to_file(templates):
+    try:
+        os.makedirs(os.path.dirname(TEMPLATES_FILE), exist_ok=True)
+        with open(TEMPLATES_FILE, "w", encoding="utf-8") as f:
+            json.dump(templates, f, indent=4, ensure_ascii=False)
+    except Exception as e: print(f"Şablon kaydetme hatası: {e}")
+
+def add_renaming_template(new_template, current_list):
+    if not new_template: return gr.update(), current_list
+    if "{Number}" not in new_template:
+        return gr.update(value="❌ Şablon '{Number}' içermelidir!"), current_list
+    
+    if new_template not in current_list:
+        current_list.append(new_template)
+        save_renaming_templates_to_file(current_list)
+        # Dropdown'ı güncelle ve yeni ekleneni seçili yap
+        return gr.update(choices=current_list, value=new_template), current_list
+    return gr.update(value=new_template), current_list
+
+def delete_renaming_template(selected_template, current_list):
+    if selected_template in current_list:
+        current_list.remove(selected_template)
+        save_renaming_templates_to_file(current_list)
+        new_val = current_list[0] if current_list else ""
+        return gr.update(choices=current_list, value=new_val), current_list
+    return gr.update(), current_list
+
+# --- Yapılandırma Yönetimi Fonksiyonları ---
+
+def save_config(config_data):
+    """
+    Klasör yollarını ve tüm uygulama ayarlarını bir JSON dosyasına kaydeder.
+    """
+    try:
+        os.makedirs(os.path.dirname(CONFIG_FILE), exist_ok=True)
+        with open(CONFIG_FILE, "w", encoding="utf-8") as f:
+            json.dump(config_data, f, indent=4)
+    except IOError as e:
+        print(f"Yapılandırma dosyası yazma hatası: {e}")
+
+def load_config():
+    """
+    Tüm uygulama ayarlarını bir JSON dosyasından yükler veya varsayılan değerleri döndürür.
+    """
+    default_config = {
+        "folder_paths": [],
+        "general_settings": {
+            "device": "Auto",
+            "language": "tr",
+            "theme": "Default"
+        },
+        "global_tagger_settings": {
+            "use_joint": True,
+            "joint_thresh": 0.25,
+            "use_cl_tagger": True,
+            "cl_gen_thresh": 0.55,
+            "cl_char_thresh": 0.60,
+            "use_pixai_tagger": False,
+            "pixai_general_thresh": 0.30,
+            "pixai_char_thresh": 0.85,
+            "use_animetagger": False,
+            "animetagger_model": "MobileNet V4 (Hızlı)",
+            "animetagger_thresh": 0.35,
+            
+            # Gemini Ayarları
+            "use_gemini": False,
+            "gemini_api_key": "",
+            "gemini_mode": "Vision",
+            "gemini_model": "gemini-2.5-flash", 
+            "gemini_prompt_vision": "Describe this image in a detailed, natural language caption for an AI image generator dataset. Focus on the main subject, clothing, pose, and background. Do not use bullet points.",
+            "gemini_prompt_tags": "Create a fluent, natural language caption based on the provided tags. Focus on describing the scene vividly.",
+            "gemini_prompt_hybrid": "Describe this image using the visual details and refine the description with the provided tags for accuracy. Focus on a cohesive narrative.",
+            "gemini_system_instruction": "You are a helpful assistant that generates detailed and accurate image captions for AI image generation datasets.",
+            
+            # Kural Dosyaları
+            "replacement_file": "",
+            "synonym_file": "",
+            "addition_file": "",
+            "sort_order": "Alfabetik",
+            "context_weight": 0.0, 
+            
+            # Ayrı kategorizasyon ayarları
+            "tekil_enable_categorization": False,
+            "tekil_selected_categories": [],
+            "toplu_enable_categorization": False,
+            "toplu_selected_categories": [],
+            "dual1_enable_categorization": False,
+            "dual1_selected_categories": [],
+            "dual2_enable_categorization": False,
+            "dual2_selected_categories": []
+        },
+        "image_tools_settings": {
+            "folder_paths": [],
+            "scale_factor": 1.0,
+            "selected_renaming_file": "",
+            "renaming_type": "Rastgele",
+            "watermark_text": "Örnek Filigran", 
+            "watermark_opacity": 0.35, 
+            "watermark_font_ratio": 0.05, 
+            "watermark_angle": -45, 
+            "renaming_templates": [],
+            "brightness_level": 0,
+            "contrast_level": 0,    
+            "denoise_level": 0,     
+            "sharpen_amount": 0.0,
+            "sequential_pattern": "Adoptable #Number", 
+            "sequential_start_number": 1,
+            "sequential_digit_count": 4
+        },
+        "art_tools_settings": {
+            "grid_cols": 3,
+            "grid_bg_color": "#000000",
+            "grid_title_text": "ADOPTABLE SALE!",
+            "grid_banner_color": "#000000",
+            "grid_title_color": "#FFD700",
+            "grid_add_labels": True,
+            "grid_label_type": "Numara (#1, #2...)",
+            "grid_start_num": 1
+        }
+    }
+
+    try:
+        if os.path.exists(CONFIG_FILE):
+            with open(CONFIG_FILE, "r", encoding="utf-8") as f:
+                loaded_config = json.load(f)
+                def update_dict(d, u):
+                    for k, v in u.items():
+                        if isinstance(v, dict):
+                            # Eğer u[k] dict değilse (eski config uyumsuzluğu), d[k]'yı koru veya override et? 
+                            # Basitçe d[k] var ve dict ise recursive, değilse direk al.
+                            d[k] = update_dict(d.get(k, {}), v)
+                        else:
+                            d[k] = v
+                    return d
+                return update_dict(default_config.copy(), loaded_config)
+    except (IOError, json.JSONDecodeError) as e:
+        print(f"Yapılandırma dosyası okuma hatası veya dosya yok: {e}. Varsayılanlar yükleniyor.")
+    return default_config
+
+# --- Ayarları Kaydetme Fonksiyonları ---
+
+def save_global_tagger_settings(
+    device, language, theme,
+    use_joint, joint_thresh, 
+    use_cl_tagger, cl_gen_thresh, cl_char_thresh, 
+    use_pixai_tagger, pixai_general_thresh, pixai_char_thresh, 
+    use_animetagger, animetagger_model, animetagger_thresh,
+    # Gemini Parametreleri
+    use_gemini, gemini_api_key, gemini_mode, gemini_model,
+    gemini_prompt_vision, gemini_prompt_tags, gemini_prompt_hybrid,
+    gemini_system_instruction,
+    # Kural Dosyaları
+    replacement_file, synonym_file, addition_file,
+    sort_order,
+    context_weight, 
+    # Kategorizasyon
+    tekil_enable, tekil_cats,
+    toplu_enable, toplu_cats,
+    dual1_enable, dual1_cats,
+    dual2_enable, dual2_cats
+):
+    config_data = load_config()
+    config_data["general_settings"] = {"device": device, "language": language, "theme": theme}
+    config_data["global_tagger_settings"] = {
+        "use_joint": use_joint, "joint_thresh": joint_thresh,
+        "use_cl_tagger": use_cl_tagger, "cl_gen_thresh": cl_gen_thresh, "cl_char_thresh": cl_char_thresh,
+        "use_pixai_tagger": use_pixai_tagger, "pixai_general_thresh": pixai_general_thresh, "pixai_char_thresh": pixai_char_thresh,
+        "use_animetagger": use_animetagger, "animetagger_model": animetagger_model, "animetagger_thresh": animetagger_thresh,
+        
+        # Gemini
+        "use_gemini": use_gemini, "gemini_api_key": gemini_api_key, "gemini_mode": gemini_mode,
+        "gemini_model": gemini_model,
+        "gemini_prompt_vision": gemini_prompt_vision,
+        "gemini_prompt_tags": gemini_prompt_tags,
+        "gemini_prompt_hybrid": gemini_prompt_hybrid,
+        "gemini_system_instruction": gemini_system_instruction,
+        
+        # Dosyalar
+        "replacement_file": replacement_file, "synonym_file": synonym_file, "addition_file": addition_file, 
+        "sort_order": sort_order,
+        "context_weight": context_weight, 
+        
+        "tekil_enable_categorization": tekil_enable, "tekil_selected_categories": tekil_cats,
+        "toplu_enable_categorization": toplu_enable, "toplu_selected_categories": toplu_cats,
+        "dual1_enable_categorization": dual1_enable, "dual1_selected_categories": dual1_cats,
+        "dual2_enable_categorization": dual2_enable, "dual2_selected_categories": dual2_cats
+    }
+    save_config(config_data)
+    return gr.update(value="✅ Tüm genel ve özelleştirilmiş kategorizasyon ayarları kaydedildi.", visible=True)
+
+def save_image_tools_settings(folder_paths_str, scale_factor, watermark_text, watermark_opacity, watermark_font_ratio, watermark_angle, brightness_level, contrast_level, denoise_level, sharpen_amount):
+    config_data = load_config()
+    config_data["image_tools_settings"]["folder_paths"] = [path.strip() for path in folder_paths_str.split('\n') if path.strip()]
+    config_data["image_tools_settings"]["scale_factor"] = scale_factor
+    config_data["image_tools_settings"]["watermark_text"] = watermark_text
+    config_data["image_tools_settings"]["watermark_opacity"] = watermark_opacity
+    config_data["image_tools_settings"]["watermark_font_ratio"] = watermark_font_ratio
+    config_data["image_tools_settings"]["watermark_angle"] = watermark_angle
+    config_data["image_tools_settings"]["brightness_level"] = brightness_level
+    config_data["image_tools_settings"]["contrast_level"] = contrast_level
+    config_data["image_tools_settings"]["denoise_level"] = denoise_level
+    config_data["image_tools_settings"]["sharpen_amount"] = sharpen_amount
+    
+    save_config(config_data)
+    return gr.update(value="✅ Resim araçları ayarları kaydedildi.", visible=True)
+
+def save_art_tools_settings(grid_cols, grid_bg_color, grid_title_text, grid_banner_color, grid_title_color, grid_add_labels, grid_label_type, grid_start_num):
+    config_data = load_config()
+    # Eğer art_tools_settings keyi yoksa oluştur (eski configler için)
+    if "art_tools_settings" not in config_data:
+        config_data["art_tools_settings"] = {}
+
+    config_data["art_tools_settings"]["grid_cols"] = grid_cols
+    config_data["art_tools_settings"]["grid_bg_color"] = grid_bg_color
+    config_data["art_tools_settings"]["grid_title_text"] = grid_title_text
+    config_data["art_tools_settings"]["grid_banner_color"] = grid_banner_color
+    config_data["art_tools_settings"]["grid_title_color"] = grid_title_color
+    config_data["art_tools_settings"]["grid_add_labels"] = grid_add_labels
+    config_data["art_tools_settings"]["grid_label_type"] = grid_label_type
+    config_data["art_tools_settings"]["grid_start_num"] = grid_start_num
+    
+    save_config(config_data)
+    return gr.update(value="✅ Art Studio ayarları kaydedildi.", visible=True)

modules/hydra_layers.py

@@ -0,0 +1,191 @@
+# modules/hydra_layers.py
+
+import math
+import re
+from typing import Any
+import torch
+from torch import Tensor
+from torch.nn import (
+    Module, ModuleList, Parameter, Buffer,
+    Linear, LayerNorm, RMSNorm, Dropout, Flatten, Identity,
+    init
+)
+from torch.nn.functional import pad, scaled_dot_product_attention, silu, gelu
+from einops import rearrange
+
+# --- GLU.PY ---
+class GatedUnit(Module):
+    def __init__(self, dim: int = -1) -> None:
+        super().__init__()
+        self.dim = dim
+    def _activation(self, x: Tensor) -> Tensor:
+        raise NotImplementedError
+    def forward(self, x: Tensor) -> Tensor:
+        f, g = x.chunk(2, dim=self.dim)
+        return self._activation(f) * g
+
+class SwiGLU(GatedUnit):
+    def __init__(self, dim: int = -1) -> None:
+        super().__init__(dim)
+    def _activation(self, x: Tensor) -> Tensor:
+        return silu(x)
+
+# --- HYDRA_POOL.PY UTILS ---
+class IndexedAdd(Module):
+    def __init__(self, n_indices: int, dim: int, weight_shape: tuple[int, ...] | None = None, *, inplace: bool = False, device=None, dtype=None) -> None:
+        super().__init__()
+        self.dim = dim
+        self.inplace = inplace
+        self.index = Buffer(torch.empty(2, n_indices, device=device, dtype=torch.int32))
+        self.weight = Parameter(torch.ones(*(sz if sz != -1 else n_indices for sz in weight_shape), device=device, dtype=dtype)) if weight_shape is not None else None
+
+    def forward(self, dst: Tensor, src: Tensor) -> Tensor:
+        src = src.index_select(self.dim, self.index[0])
+        if self.weight is not None: src.mul_(self.weight)
+        return dst.index_add_(self.dim, self.index[1], src) if self.inplace else dst.index_add(self.dim, self.index[1], src)
+
+class BatchLinear(Module):
+    def __init__(self, batch_shape: tuple[int, ...] | int, in_features: int, out_features: int, *, bias: bool = False, flatten: bool = False, bias_inplace: bool = True, device=None, dtype=None) -> None:
+        super().__init__()
+        if isinstance(batch_shape, int): batch_shape = (batch_shape,)
+        self.flatten = -(len(batch_shape) + 1) if flatten else 0
+        self.weight = Parameter(torch.empty(*batch_shape, in_features, out_features, device=device, dtype=dtype))
+        bt = self.weight.flatten(end_dim=-3).mT
+        for idx in range(bt.size(0)): init.kaiming_uniform_(bt[idx], a=math.sqrt(5))
+        self.bias = Parameter(torch.zeros(*batch_shape, out_features, device=device, dtype=dtype)) if bias else None
+        self.bias_inplace = bias_inplace
+
+    def forward(self, x: Tensor) -> Tensor:
+        x = torch.matmul(x.unsqueeze(-2), self.weight).squeeze(-2)
+        if self.bias is not None:
+            if self.bias_inplace: x.add_(self.bias)
+            else: x = x + self.bias
+        if self.flatten: x = x.flatten(self.flatten)
+        return x
+
+class Mean(Module):
+    def __init__(self, dim: tuple[int, ...] | int = -1, *, keepdim: bool = False) -> None:
+        super().__init__()
+        self.dim = dim
+        self.keepdim = keepdim
+    def forward(self, x: Tensor) -> Tensor:
+        return x.mean(self.dim, self.keepdim)
+
+class _MidBlock(Module):
+    def __init__(self, attn_dim: int, head_dim: int, n_classes: int, *, ff_ratio: float, ff_dropout: float, q_cls_inplace: bool = True, device=None, dtype=None) -> None:
+        super().__init__()
+        self.head_dim = head_dim
+        self.q_cls_inplace = q_cls_inplace
+        hidden_dim = int(attn_dim * ff_ratio)
+        self.q_proj = Linear(attn_dim, attn_dim, bias=False, device=device, dtype=dtype)
+        self.q_cls = Parameter(torch.zeros(n_classes, attn_dim, device=device, dtype=dtype))
+        self.q_norm = RMSNorm(head_dim, eps=1e-5, elementwise_affine=False)
+        self.attn_out = Linear(attn_dim, attn_dim, bias=False, device=device, dtype=dtype)
+        self.ff_norm = LayerNorm(attn_dim, device=device, dtype=dtype)
+        self.ff_in = Linear(attn_dim, hidden_dim * 2, bias=False, device=device, dtype=dtype)
+        self.ff_act = SwiGLU()
+        self.ff_drop = Dropout(ff_dropout)
+        self.ff_out = Linear(hidden_dim, attn_dim, bias=False, device=device, dtype=dtype)
+
+    def _forward_q(self, x: Tensor) -> Tensor:
+        x = self.q_proj(x)
+        if self.q_cls_inplace: x.add_(self.q_cls)
+        else: x = x + self.q_cls
+        x = self.q_norm(x)
+        return rearrange(x, "... s (h e) -> ... h s e", e=self.head_dim)
+
+    def _forward_attn(self, x: Tensor, k: Tensor, v: Tensor, attn_mask: Tensor | None) -> Tensor:
+        a = scaled_dot_product_attention(self._forward_q(x), k, v, attn_mask=attn_mask)
+        a = rearrange(a, "... h s e -> ... s (h e)")
+        return x + self.attn_out(a)
+
+    def _forward_ff(self, x: Tensor) -> Tensor:
+        f = self.ff_out(self.ff_drop(self.ff_act(self.ff_in(self.ff_norm(x)))))
+        return x + f
+
+    def forward(self, x: Tensor, k: Tensor, v: Tensor, attn_mask: Tensor | None = None) -> Tensor:
+        return self._forward_ff(self._forward_attn(x, k, v, attn_mask))
+
+class HydraPool(Module):
+    def __init__(self, attn_dim: int, head_dim: int, n_classes: int, *, mid_blocks: int = 0, roots: tuple[int, int, int] = (0, 0, 0), ff_ratio: float = 3.0, ff_dropout: float = 0.0, input_dim: int = -1, output_dim: int = 1, device=None, dtype=None) -> None:
+        super().__init__()
+        if input_dim < 0: input_dim = attn_dim
+        self.n_classes = n_classes
+        self.head_dim = head_dim
+        self.output_dim = output_dim
+        self._has_roots = False
+        self._has_ff = False
+        self._q_normed = None
+
+        if roots != (0, 0, 0):
+            self._has_roots = True
+            n_roots, n_classroots, n_subclasses = roots
+            self.cls = Parameter(torch.randn(attn_dim // head_dim, n_classes, head_dim, device=device, dtype=dtype))
+            self.roots = Parameter(torch.randn(attn_dim // head_dim, n_roots, head_dim, device=device, dtype=dtype)) if n_roots > 0 else None
+            self.clsroots = IndexedAdd(n_classroots, dim=-2, weight_shape=(attn_dim // head_dim, -1, 1), device=device, dtype=dtype) if n_classroots > 0 else None
+            self.clscls = IndexedAdd(n_subclasses, dim=-2, weight_shape=(attn_dim // head_dim, -1, 1), inplace=True, device=device, dtype=dtype) if n_subclasses > 0 else None
+            self.q = Buffer(torch.empty(attn_dim // head_dim, n_classes, head_dim, device=device, dtype=dtype))
+        else:
+            self.q = Parameter(torch.randn(attn_dim // head_dim, n_classes, head_dim, device=device, dtype=dtype))
+            self._q_normed = False
+
+        self.kv = Linear(input_dim, attn_dim * 2, bias=False, device=device, dtype=dtype)
+        self.qk_norm = RMSNorm(head_dim, eps=1e-5, elementwise_affine=False)
+
+        if ff_ratio > 0.0:
+            self._has_ff = True
+            hidden_dim = int(attn_dim * ff_ratio)
+            self.ff_norm = LayerNorm(attn_dim, device=device, dtype=dtype)
+            self.ff_in = Linear(attn_dim, hidden_dim * 2, bias=False, device=device, dtype=dtype)
+            self.ff_act = SwiGLU()
+            self.ff_drop = Dropout(ff_dropout)
+            self.ff_out = Linear(hidden_dim, attn_dim, bias=False, device=device, dtype=dtype)
+
+        self.mid_blocks = ModuleList(_MidBlock(attn_dim, head_dim, n_classes, ff_ratio=ff_ratio, ff_dropout=ff_dropout, device=device, dtype=dtype) for _ in range(mid_blocks))
+        self.out_proj = BatchLinear(n_classes, attn_dim, output_dim * 2, device=device, dtype=dtype)
+        self.out_act = SwiGLU()
+
+    def create_head(self) -> Module:
+        return Flatten(-2) if self.output_dim == 1 else Mean(-1)
+
+    def _forward_q(self) -> Tensor:
+        if self._q_normed is None:
+            q = self.qk_norm(self.roots) if self.roots is not None else self.cls
+            if self.clsroots is not None: q = self.clsroots(self.cls, q)
+            if self.clscls is not None: q = self.clscls(q, q.detach())
+            return self.qk_norm(q)
+        elif self._q_normed is False: return self.qk_norm(self.q)
+        else: return self.q
+
+    def _forward_attn(self, x: Tensor, attn_mask: Tensor | None) -> tuple[Tensor, Tensor, Tensor]:
+        q = self._forward_q().expand(*x.shape[:-2], -1, -1, -1)
+        x = self.kv(x)
+        k, v = rearrange(x, "... s (n h e) -> n ... h s e", n=2, e=self.head_dim).unbind(0)
+        k = self.qk_norm(k)
+        x = scaled_dot_product_attention(q, k, v, attn_mask=attn_mask)
+        return rearrange(x, "... h s e -> ... s (h e)"), k, v
+
+    def _forward_ff(self, x: Tensor) -> Tensor:
+        if not self._has_ff: return x
+        return x + self.ff_out(self.ff_drop(self.ff_act(self.ff_in(self.ff_norm(x)))))
+
+    def forward(self, x: Tensor, attn_mask: Tensor | None = None) -> Tensor:
+        x, k, v = self._forward_attn(x, attn_mask)
+        x = self._forward_ff(x)
+        for block in self.mid_blocks: x = block(x, k, v, attn_mask)
+        return self.out_act(self.out_proj(x))
+
+    @staticmethod
+    def for_state(state_dict: dict[str, Any], prefix: str = "", *, ff_dropout: float = 0.0, device=None, dtype=None) -> "HydraPool":
+        n_heads, n_classes, head_dim = state_dict[f"{prefix}q"].shape
+        attn_dim = n_heads * head_dim
+        roots_t, clsroots_t, clscls_t = state_dict.get(f"{prefix}roots"), state_dict.get(f"{prefix}clsroots.index"), state_dict.get(f"{prefix}clscls.index")
+        roots = (roots_t.size(1) if roots_t is not None else 0, clsroots_t.size(1) if clsroots_t is not None else 0, clscls_t.size(1) if clscls_t is not None else 0)
+        input_dim = state_dict[f"{prefix}kv.weight"].size(1)
+        output_dim = state_dict[f"{prefix}out_proj.weight"].size(2) // 2
+        ffout_t = state_dict.get(f"{prefix}ff_out.weight")
+        hidden_dim = ffout_t.size(1) + 0.5 if ffout_t is not None else 0
+        ff_ratio = hidden_dim / attn_dim
+        pattern = re.compile(rf"^{re.escape(prefix)}mid_blocks\.([0-9]+)\.")
+        mid_blocks = max([-1, *(int(match[1]) for key in state_dict if (match := pattern.match(key)) is not None)]) + 1
+        return HydraPool(attn_dim, head_dim, n_classes, mid_blocks=mid_blocks, roots=roots, ff_ratio=ff_ratio, ff_dropout=ff_dropout, input_dim=input_dim, output_dim=output_dim, device=device, dtype=dtype)

modules/localization/languages.py

@@ -0,0 +1,611 @@
+
+# Dil seçeneğini ConfigManager'dan (circular import olmaması için) veya direkt dosyadan okuyabiliriz.
+# En sağlıklısı: Bir "current_language" global değişkeni tutmak ve bunu main.py veya config_manager update ettiğinde değiştirmek.
+# Ancak basit olması açısından burada dosyayı okuyalım (cache ile).
+
+import json
+import os
+
+_CACHED_LANG = None
+
+def get_db_lang():
+    global _CACHED_LANG
+    # Her çağrıda dosya okumak performansı düşürebilir, bu yüzden basit bir cache mekanizması ekleyelim.
+    # Ancak dil değiştiğinde uygulamanın yeniden başlatılması gerektiği için bu güvenlidir.
+    if _CACHED_LANG: return _CACHED_LANG
+    
+    config_path = "data/configs/config.json"
+    if os.path.exists(config_path):
+        try:
+            with open(config_path, "r", encoding="utf-8") as f:
+                data = json.load(f)
+                _CACHED_LANG = data.get("general_settings", {}).get("language", "tr")
+                return _CACHED_LANG
+        except: pass
+    return "tr"
+
+def get_str(key):
+    lang = get_db_lang()
+    
+    # 1. Hedef dil sözlüğünü al
+    target_dict = STRINGS.get(lang, STRINGS["tr"])
+    
+    # 2. Key varsa döndür
+    if key in target_dict:
+        return target_dict[key]
+    
+    # 3. Yedeğe (İngilizce'ye) bak (Eğer hedef dilde yoksa)
+    if lang != "en" and "en" in STRINGS and key in STRINGS["en"]:
+        return STRINGS["en"][key]
+        
+    # 4. Hiçbir yerde yoksa key'i olduğu gibi döndür
+    return key
+
+STRINGS = {
+    "tr": {
+        # Settings Tab
+        "tab_settings_title": "⚙️ Ayarlar",
+        "settings_header": "<h2 style='color:#2c3e50;'>Genel Yapılandırma ve Model Ayarları</h2>",
+        "save_settings_btn": "💾 Tüm Ayarları Kaydet",
+        "status_label": "Durum",
+        "device_section": "### 🖥️ Cihaz, Dil & Kural Dosyaları",
+        "device_label": "Çalıştırma Cihazı",
+        "device_info": "Modellerin hangi işlemcide çalışacağını belirler.",
+        "language_label": "Dil / Language",
+        "language_info": "Uygulama dilini değiştirir (Yeniden başlatma gerekir).",
+        "theme_label": "Arayüz Teması / UI Theme",
+        "theme_info": "Uygulama temasını değiştirir (Yeniden başlatma gerekir).",
+        "replacement_file_label": "Değiştirme Dosyası (Regex)",
+        "synonym_file_label": "Birleştirme Dosyası (Eşanlamlı)",
+        "addition_file_label": "Ekleme Dosyası (Sona Eklenecekler)",
+        "sort_order_label": "Etiket Sıralama Yöntemi",
+        "sort_alpha": "Alfabetik",
+        "sort_len": "Uzunluğa Göre",
+        "sort_random": "Rastgele",
+        "sort_orig": "Orijinal",
+        
+        "model_mobilenet": "MobileNet V4 (Hızlı)",
+        "model_convnext": "ConvNeXt V2 Huge (Pro)",
+        "model_caformer": "Caformer B36 (Yeni)",
+        "categorization_section": "### 🗂️ Mod Bazlı Kategorizasyon Ayarları",
+        "categorization_desc": "Aşağıdaki sekmelerden her bir mod için ayrı kategorizasyon ayarı yapabilirsiniz.",
+        "tab_single": "Tekil Mod",
+        "tab_batch": "Toplu Mod",
+        "tab_dual_left": "Dual Mod (Sol)",
+        "tab_dual_right": "Dual Mod (Sağ)",
+        "enable_cat_single": "Tekil Modda Kategorizasyonu Etkinleştir",
+        "cat_single_label": "Tekil Mod Kategorileri",
+        "enable_cat_batch": "Toplu Modda Kategorizasyonu Etkinleştir",
+        "cat_batch_label": "Toplu Mod Kategorileri",
+        "enable_cat_dual1": "Dual Mod Resim 1 (Sol) Kategorizasyon",
+        "cat_dual1_label": "Dual Resim 1 Kategorileri",
+        "enable_cat_dual2": "Dual Mod Resim 2 (Sağ) Kategorizasyon",
+        "cat_dual2_label": "Dual Resim 2 Kategorileri",
+        "model_sensitivity_section": "### 🤖 Model Hassasiyet Ayarları",
+        "context_weight_label": "Bağlam Ağırlığı (Context Weight)",
+        "context_weight_info": "Etiketleri rafine ederken veritabanında olmayan 'Unknown' etiketleri temizleme şiddeti.",
+        "joint_settings": "Joint Tagger Ayarları",
+        "use_joint": "Joint Etiketleyiciyi Kullan",
+        "joint_thresh": "Joint Eşiği",
+        "cl_settings": "CL Tagger Ayarları",
+        "use_cl": "CL Tagger'ı Kullan",
+        "cl_gen_thresh": "CL General/Meta/Model Eşiği",
+        "cl_char_thresh": "CL Character/Copyright/Artist Eşiği",
+        "pixai_settings": "PixAI Tagger Ayarları",
+        "use_pixai": "PixAI Tagger'ı Kullan",
+        "pixai_gen_thresh": "PixAI General Eşiği",
+        "pixai_char_thresh": "PixAI Character Eşiği",
+        "anime_settings": "Anime Tagger (MobileNet/ConvNeXt/Caformer)",
+        "use_anime": "Anime Tagger'ı Kullan",
+        "anime_model_label": "Model Seçimi",
+        "anime_thresh": "Etiket Eşiği",
+        "gemini_settings": "✨ Gemini Caption (Doğal Dil)",
+        "gemini_desc": "Görselleri etiket listesi yerine **doğal cümlelerle** betimler.",
+        "use_gemini": "Gemini Caption Kullan",
+        "gemini_api_key": "Google Gemini API Key",
+        "gemini_model": "Gemini Modeli",
+        "gemini_model_info": "Kullanılacak Gemini model versiyonunu seçin.",
+        "gemini_mode_label": "Gemini Modu",
+        "gemini_mode_info": "Vision: Sadece resme bakar. Tags: Sadece etiketleri kullanır. Vision + Tags: İkisini birleştirir.",
+        "gemini_system_instr": "Sistem Talimatı (System Instruction)",
+        "gemini_system_info": "Modelin genel davranışını ve kimliğini belirleyen ana talimat.",
+        "gemini_prompt_settings": "#### 📝 Mod Bazlı Prompt Ayarları",
+        "prompt_vision": "Vision Modu Prompt",
+        "prompt_tags": "Tags Modu Prompt",
+        "prompt_hybrid": "Vision + Tags Modu Prompt",
+        "save_success": "✅ Tüm genel ve özelleştirilmiş kategorizasyon ayarları kaydedildi. Dil değişikliğinin etkili olması için uygulamayı yeniden başlatın.",
+
+        # App Title
+        "app_title": "Ultra Pro Tagger V1",
+        "app_subtitle": "Yapay Zeka Destekli Otomatik Etiketleme ve Düzenleme Suiti",
+        
+        # Main UI
+        "btn_close_app": "Uygulamayı Kapat",
+        "btn_restart_app": "Uygulamayı Yeniden Başlat",
+
+        # Single Tab
+        "tab_single_title": "✨ Tekil Etiketleme",
+        "btn_process_single": "Görseli Etiketle (Genel Ayarlar ile)",
+        "label_image_upload": "Görsel Yükle",
+        "tab_raw_tags": "Has Etiketler",
+        "label_unique_tags": "Birleşik Benzersiz Etiketler",
+        "btn_send_to_cat": "Bu Etiketleri Kategorizasyona Gönder ➡️",
+        "tab_refined_tags": "Rafine Edilmiş",
+        "label_refined_tags": "Rafine Edilmiş (Temizlenmiş) Etiketler",
+        "tab_categorized_tags": "Kategorize Edilmiş",
+        "label_categorized_tags": "Kategorize Edilmiş Etiketler",
+        "header_wildcard": "### 📂 Wildcard Paketine Ekle",
+        "tab_gemini_caption": "Cümlelendirilmiş (GeminiCaption)",
+        "label_gemini_caption": "Gemini Betimlemesi",
+        "tab_combined_caption": "Kategorize + Cümlelendirilmiş (GeminiCaption)",
+        "label_combined_caption": "Kategorize ve Gemini Birleşimi",
+
+        # Batch Tab
+        "tab_batch_title": "📚 Toplu Etiketleme",
+        "btn_process_batch": "Resimleri İşle (Genel Ayarlar ile)",
+        "label_batch_input": "Resimleri Yükleyin (Çoklu Seçim)",
+        "tab_batch_original": "Orijinal Etiketler (Birleşik)",
+        "label_batch_original": "Tüm Resimlerden Orijinal Etiketler",
+        "tab_batch_refined": "Rafine Edilmiş (Birleşik)",
+        "label_batch_refined": "Tüm Resimlerden Rafine Edilmiş Etiketler",
+        "tab_batch_cat": "Kategorize Edilmiş (Satır Satır)",
+        "tab_batch_gemini": "Gemini Caption (Tümü)",
+        "label_batch_gemini": "Tüm Görsellerin Betimlemeleri",
+        "tab_batch_html": "Detaylı HTML Raporu",
+        "label_batch_html": "Detaylı Sonuçlar",
+        "btn_batch_download": "Tüm Sonuç Etiketleri İndir (.txt)",
+
+        # Dual Tab
+        "tab_dual_title": "↔️ Dual Etiketleme",
+        "dual_note": "<p style='color:#666; font-size:0.9em;'>Not: Dual modda her iki resim için 'Ayarlar' sekmesindeki ayrı kategorizasyon ayarları kullanılır.</p>",
+        "btn_process_dual": "Görselleri Karşılaştır ve Etiketle",
+        "label_img1": "Görsel 1",
+        "label_img2": "Görsel 2",
+        "tab_dual_combined": "Birleştirilmiş",
+        "label_dual_combined": "İki Resmin Birleşimi (Benzersiz)",
+        "label_dual_refined": "İki Resmin Birleşimi (Rafine)",
+        "label_dual_cat": "Birleşik Kategorize Edilmiş",
+        "label_gemini_img1": "Görsel 1 Gemini",
+        "label_gemini_img2": "Görsel 2 Gemini",
+
+        # Tools Tab
+        "tab_prompt_gen": "📝 Prompt Oluşturucu",
+        "tab_category_tools": "🏷️ Kategori Araçları",
+        "tab_rule_management": "🔁 Kural Yönetimi",
+        "tab_text_tools": "📝 Metin Araçları",
+        "tab_image_tools": "🖼️ Resim Araçları",
+        "tab_video_creator": "🎬 Video Oluşturucu",
+        "tab_art_studio": "🎨 Sanat Stüdyosu",
+        "label_tags_input": "Etiketleri girin (virgülle ayırın)",
+        "placeholder_tags_input": "örnek: 1kız, mavi saç, uzun saç, kedi kulakları...",
+
+        # Category Tools
+        "cat_live_tab_title": "Canlı Kategorizasyon",
+        "cat_live_header": "<h2 style='color:#2563eb'>Etiketleri Kategorilere Ayırın</h2>",
+        "cat_live_main_tab": "Ana Kategorizasyon",
+        "cat_live_main_select": "Gösterilecek Ana Kategorileri Seç",
+        "cat_live_main_btn": "Ana Kategorilere Ayır",
+        "cat_live_unmatched_btn": "⚠️ Eşleşmeyenleri Düzenleyiciye Aktar ve Düzenle ➡️",
+        "cat_live_main_output": "Ana Kategorize Edilmiş Etiketler",
+
+        "cat_manage_tab_title": "Kategori/Etiket Düzenleme",
+        "cat_manage_header": "<h3 style='color:#007bff;'>Kategori ve Etiket Dosyalarını Yönetin</h3>",
+        "cat_manage_main_accordion": "Ana Kategori Yönetimi",
+        "cat_manage_main_grid": "Tüm Kategoriler",
+        "cat_manage_main_refresh": "↻ Ana Kategorileri Yenile",
+        "cat_manage_main_select": "Kategori Seç",
+        "cat_manage_tags_input": "Etiketler (virgülle ayırın)",
+        "btn_add": "Ekle",
+        "btn_delete": "Sil",
+
+        # Category Redesign
+        "cat_redesign_live_tab": "Kategorilere Ayır",
+        "cat_redesign_main_tab": "📂 Kategori Yönetimi",
+
+
+
+        # Image Tools
+        "img_tools_header": "<h3 style='color:#0077b6;'>Toplu Resim İşleme</h3>",
+        "img_tools_paths_input": "Klasör Yolları (Her satıra bir yol)",
+        "img_tools_select_folder_btn": "📁 Klasör Seç",
+        "img_tools_clear_btn": "🗑️ Temizle",
+        "img_tools_save_settings_btn": "Yolu ve Araç Ayarlarını Kaydet",
+        "img_tools_res_accordion": "1. 📐 Çözünürlük",
+        "img_tools_scale_label": "Oran",
+        "btn_apply": "Uygula",
+        "img_tools_rename_accordion": "2. 📝 İsimlendirme (Şablonlu)",
+        "img_tools_rename_desc": "Dosyaları sırasıyla yeniden adlandırır. Şablonun içinde mutlaka **`{Number}`** olmalıdır.",
+        "img_tools_template_select": "Hazır Şablonlar",
+        "img_tools_delete_template_btn": "🗑️ Şablonu Sil",
+        "img_tools_new_template_input": "Yeni Şablon Ekle",
+        "img_tools_new_template_placeholder": "Örn: Adoptable {Number} (Elf)",
+        "img_tools_add_template_btn": "➕ Listeye Ekle",
+        "img_tools_start_num": "Başlangıç Numarası (Start)",
+        "img_tools_digit_count": "Basamak Sayısı (001 için 3)",
+        "img_tools_rename_btn": "Dosyaları Yeniden Adlandır",
+        "img_tools_watermark_accordion": "3. 🖋️ Filigran",
+        "img_tools_watermark_default": "Örnek Filigran",
+        "img_tools_watermark_text": "Metin",
+        "img_tools_watermark_opacity": "Opaklık",
+        "img_tools_watermark_size": "Font Boyutu",
+        "img_tools_watermark_angle": "Açı",
+        "img_tools_format_accordion": "4. 🖼️ Format",
+        "img_tools_format_label": "Format",
+        "btn_convert": "Dönüştür",
+        "img_tools_bc_accordion": "5. 🔅 Parlaklık/Kontrast",
+        "img_tools_brightness": "Parlaklık",
+        "img_tools_contrast": "Kontrast",
+        "img_tools_ds_accordion": "6. 🧼 Gürültü/Netlik",
+        "img_tools_denoise": "Gürültü Azaltma",
+        "img_tools_sharpen": "Netleştirme",
+
+        # Text Tools
+        "txt_tools_header": "<h3 style='color:#28a745;'>Manuel Metin Araçları</h3>",
+        "txt_tools_input": "İşlenecek Metin",
+        "txt_tools_tab_clean": "Temizleme",
+        "txt_tools_clean_btn": "Temizle ve Tekilleştir",
+        "label_result": "Sonuç",
+        "txt_tools_tab_format": "Format Değiştirme",
+        "txt_tools_lines_to_comma": "Satır -> Virgül",
+        "txt_tools_comma_to_lines": "Virgül -> Satır",
+        "txt_tools_tab_random": "Rastgele Seç",
+        "txt_tools_line_count": "Satır Sayısı",
+        "btn_select": "Seç",
+
+        "btn_filter": "Filtrele",
+
+        # Rule Tools
+        "rule_tools_intro": "Bu alanda etiketlerin nasıl değiştirileceğini, birleştirileceğini ve sonuçlara hangi etiketlerin ekleneceğini yönetebilirsiniz.",
+        "rule_rep_desc": "Etiketleri otomatik olarak başka etiketlerle değiştirir.",
+        "rule_rep_accordion": "Değiştirme Kuralları (Regex Destekli)",
+        "rule_active_file": "Aktif Dosya",
+        "rule_new_file_name": "Yeni Dosya Adı",
+        "rule_create_file_btn": "Yeni Dosya Oluştur",
+        "rule_tab_quick_add": "Hızlı Kural Ekle",
+        "rule_rep_old": "Eski Etiket (veya Regex)",
+        "rule_rep_new": "Yeni Etiket",
+        "rule_add_to_file_btn": "Kuralı Dosyaya Ekle",
+        "rule_tab_edit_file": "Dosyayı Düzenle",
+        "rule_file_content_manual": "Dosya İçeriği (Manuel Düzenleme)",
+        "rule_save_all_btn": "Tüm İçeriği Kaydet",
+        "rule_syn_accordion": "Birleştirme Kuralları (Eşanlamlı)",
+        "rule_syn_intro": "Birden fazla etiketi tek bir ana etikette birleştirir (Diğerlerini siler).",
+        "rule_syn_main": "Ana Etiket (Kalan)",
+        "rule_syn_remove": "Silinecek Eşanlamlılar (Virgülle ayırın)",
+        "rule_add_accordion": "Ekleme Kuralları (Sonuçlara Otomatik Eklenecekler)",
+        "rule_add_intro": "Bu bölümdeki etiketler, işlem bittikten sonra sonuç listesinin sonuna otomatik olarak eklenir.",
+        "rule_add_content_input": "Eklenecek Etiketler (Her satıra veya virgülle)",
+        "rule_add_save_btn": "Ekleme Kuralını Kaydet",
+
+        # Art Tools
+        "art_header": "### 🎨 Furry & Adoptable Araçları",
+        "art_desc": "Satış için grid oluşturma araçları.",
+        "art_tab_grid": "田 Adoptable Grid Oluşturucu",
+        "art_file_input": "Görselleri Seç (Çoklu)",
+        "art_grid_settings": "Grid Ayarları",
+        "art_cols": "Sütun Sayısı (Yan Yana Kaç Resim?)",
+        "art_bg_color": "Arkaplan Rengi",
+        "art_label_settings": "Etiket Ayarları",
+        "art_add_labels_check": "Resim Altına Yazı Ekle",
+        "art_label_type": "Yazı Tipi",
+        "art_start_num": "Başlangıç Numarası / Fiyatı",
+        "art_create_btn": "Grid Oluştur",
+        "art_output": "Grid Sonucu",
+
+        # Prompt Generator
+        "prompt_template_mgmt_header": "### 📝 Şablon Yönetimi",
+        "prompt_select_template": "Şablon Seçiniz",
+        "prompt_new_template_name": "Yeni Şablon Adı",
+        "prompt_template_content": "Şablon İçeriği",
+        "btn_update": "💾 Güncelle",
+        "btn_add_new": "➕ Yeni Ekle",
+        "prompt_generation_header": "### 🚀 Üretim",
+        "prompt_gen_btn": "SEÇİLİ ŞABLONU OLUŞTUR",
+        "prompt_gen_all_btn": "TÜM ŞABLONLARI OLUŞTUR",
+        "prompt_var_settings_accordion": "🛠️ Değişken Ayarları (Seçenek Ekle/Düzenle)",
+        "prompt_select_var": "Düzenlenecek Değişkeni Seç",
+        "prompt_var_label": "Etiket Adı",
+        "prompt_var_default": "Varsayılan Değer",
+        "prompt_var_options": "Seçenekler (Her satıra bir seçenek yazın)",
+        "prompt_update_var_btn": "Değişkeni Güncelle",
+
+        # Video Creator
+        "vid_header": "### 🎬 Pro Video Stüdyosu",
+        "vid_desc": "Görselleri ve müzikleri birleştirin, format seçin ve efekt ekleyin.",
+        "vid_img_input": "1. Görselleri Seçin (Slayt için çoklu)",
+        "vid_audio_input": "2. Müzikleri Seçin (Çoklu)",
+        "vid_resolution": "Video Formatı (Çözünürlük)",
+        "vid_speed": "İşleme Hızı",
+        "vid_text_overlay": "Video Üzerine Yazı Ekle (Opsiyonel)",
+        "vid_spectrum_check": "Ses Dalgası (Spectrum) Ekle (DİKKAT: Render süresini çok uzatır)",
+        "vid_create_btn": "VİDEOYU OLUŞTUR",
+        "vid_preview": "Önizleme",
+        "vid_status": "İşlem Durumu",
+    },
+    "en": {
+        # Settings Tab
+        "tab_settings_title": "⚙️ Tagger & Model Settings",
+        "settings_header": "<h2 style='color:#2c3e50;'>General Configuration and Model Settings</h2><p style='color:#666;'>Manage tagging modes, sensitivity, and language options here.</p>",
+        "save_settings_btn": "💾 Save All Settings",
+        "status_label": "Status",
+        "device_section": "### 🖥️ Device, Language & Rule Files",
+        "device_label": "Execution Device",
+        "device_info": "Determines which processor the models will run on.",
+        "language_label": "Dil / Language",
+        "language_info": "Changes application language (Requires restart).",
+        "theme_label": "UI Theme",
+        "theme_info": "Changes the application theme (Requires restart).",
+        "replacement_file_label": "Replacement File (Regex)",
+        "synonym_file_label": "Synonym File",
+        "addition_file_label": "Addition File (Append to End)",
+        "sort_order_label": "Tag Sorting Method",
+        "sort_alpha": "Alphabetical",
+        "sort_len": "By Length",
+        "sort_random": "Random",
+        "sort_orig": "Original",
+
+        "model_mobilenet": "MobileNet V4 (Fast)",
+        "model_convnext": "ConvNeXt V2 Huge (Pro)",
+        "model_caformer": "Caformer B36 (New)",
+        "categorization_section": "### 🗂️ Mode-Based Categorization Settings",
+        "categorization_desc": "Configure separate categorization settings for each mode below.",
+        "tab_single": "Single Mode",
+        "tab_batch": "Batch Mode",
+        "tab_dual_left": "Dual Mode (Left)",
+        "tab_dual_right": "Dual Mode (Right)",
+        "enable_cat_single": "Enable Categorization in Single Mode",
+        "cat_single_label": "Single Mode Categories",
+        "enable_cat_batch": "Enable Categorization in Batch Mode",
+        "cat_batch_label": "Batch Mode Categories",
+        "enable_cat_dual1": "Dual Mode Image 1 (Left) Categorization",
+        "cat_dual1_label": "Dual Image 1 Categories",
+        "enable_cat_dual2": "Dual Mode Image 2 (Right) Categorization",
+        "cat_dual2_label": "Dual Image 2 Categories",
+        "model_sensitivity_section": "### 🤖 Model Sensitivity Settings",
+        "context_weight_label": "Context Weight",
+        "context_weight_info": "Intensity of removing 'Unknown' tags not in database during refinement.",
+        "joint_settings": "Joint Tagger Settings",
+        "use_joint": "Use Joint Tagger",
+        "joint_thresh": "Joint Threshold",
+        "cl_settings": "CL Tagger Settings",
+        "use_cl": "Use CL Tagger",
+        "cl_gen_thresh": "CL General/Meta/Model Threshold",
+        "cl_char_thresh": "CL Character/Copyright/Artist Threshold",
+        "pixai_settings": "PixAI Tagger Settings",
+        "use_pixai": "Use PixAI Tagger",
+        "pixai_gen_thresh": "PixAI General Threshold",
+        "pixai_char_thresh": "PixAI Character Threshold",
+        "anime_settings": "Anime Tagger (MobileNet/ConvNeXt/Caformer)",
+        "use_anime": "Use Anime Tagger",
+        "anime_model_label": "Model Selection",
+        "anime_thresh": "Tag Threshold",
+        "gemini_settings": "✨ Gemini Caption (Natural Language)",
+        "gemini_desc": "Describes images with **natural sentences** instead of just tag lists.",
+        "use_gemini": "Use Gemini Caption",
+        "gemini_api_key": "Google Gemini API Key",
+        "gemini_model": "Gemini Model",
+        "gemini_model_info": "Select the Gemini model version to use.",
+        "gemini_mode_label": "Gemini Mode",
+        "gemini_mode_info": "Vision: Only looks at image. Tags: Only uses tags. Vision + Tags: Combines both.",
+        "gemini_system_instr": "System Instruction",
+        "gemini_system_info": "Main instruction defining the model's behavior and identity.",
+        "gemini_prompt_settings": "#### 📝 Mode-Based Prompt Settings",
+        "prompt_vision": "Vision Mode Prompt",
+        "prompt_tags": "Tags Mode Prompt",
+        "prompt_hybrid": "Vision + Tags Mode Prompt",
+        "save_success": "✅ All general and categorization settings saved. Please restart to apply language changes.",
+
+        # App Title
+        "app_title": "Ultra Pro Tagger V1",
+        "app_subtitle": "AI-Powered Automatic Tagging and Editing Suite",
+
+        # Main UI
+        "btn_close_app": "Close Application",
+        "btn_restart_app": "Restart Application",
+
+        # Single Tab
+        "tab_single_title": "✨ Single Tagging",
+        "btn_process_single": "Tag Image (With General Settings)",
+        "label_image_upload": "Upload Image",
+        "tab_raw_tags": "Raw Tags",
+        "label_unique_tags": "Merged Unique Tags",
+        "btn_send_to_cat": "Send These Tags to Categorization ➡️",
+        "tab_refined_tags": "Refined",
+        "label_refined_tags": "Refined (Cleaned) Tags",
+        "tab_categorized_tags": "Categorized",
+        "label_categorized_tags": "Categorized Tags",
+        "header_wildcard": "### 📂 Add to Wildcard Pack",
+        "tab_gemini_caption": "Captioned (GeminiCaption)",
+        "label_gemini_caption": "Gemini Caption",
+        "tab_combined_caption": "Categorized + Captioned (GeminiCaption)",
+        "label_combined_caption": "Categorized and Gemini Combination",
+
+        # Batch Tab
+        "tab_batch_title": "📚 Batch Tagging",
+        "btn_process_batch": "Process Images (With General Settings)",
+        "label_batch_input": "Upload Images (Multiple Selection)",
+        "tab_batch_original": "Original Tags (Combined)",
+        "label_batch_original": "Original Tags from All Images",
+        "tab_batch_refined": "Refined (Combined)",
+        "label_batch_refined": "Refined Tags from All Images",
+        "tab_batch_cat": "Categorized (Line by Line)",
+        "tab_batch_gemini": "Gemini Caption (All)",
+        "label_batch_gemini": "Captions for All Images",
+        "tab_batch_html": "Detailed HTML Report",
+        "label_batch_html": "Detailed Results",
+        "btn_batch_download": "Download All Result Tags (.txt)",
+
+        # Dual Tab
+        "tab_dual_title": "↔️ Dual Tagging",
+        "dual_note": "<p style='color:#666; font-size:0.9em;'>Note: Dual mode uses separate categorization settings for each image from the 'Settings' tab.</p>",
+        "btn_process_dual": "Compare and Tag Images",
+        "label_img1": "Image 1",
+        "label_img2": "Image 2",
+        "tab_dual_combined": "Combined",
+        "label_dual_combined": "Combined Unique Tags",
+        "label_dual_refined": "Combined Refined Tags",
+        "label_dual_cat": "Combined Categorized",
+        "label_gemini_img1": "Image 1 Gemini",
+        "label_gemini_img2": "Image 2 Gemini",
+
+        # Tools Tab
+        "tab_prompt_gen": "📝 Prompt Generator",
+        "tab_category_tools": "🏷️ Category Tools",
+        "tab_rule_management": "🔁 Rule Management",
+        "tab_text_tools": "📝 Text Tools",
+        "tab_image_tools": "🖼️ Image Tools",
+        "tab_video_creator": "🎬 Video Creator",
+        "tab_art_studio": "🎨 Art Studio",
+        "label_tags_input": "Enter Tags (comma separated)",
+        "placeholder_tags_input": "example: 1girl, blue hair, long hair, cat ears...",
+
+        # Category Tools
+        "cat_live_tab_title": "Live Categorization",
+        "cat_live_header": "<h2 style='color:#2563eb'>Categorize Tags</h2>",
+        "cat_live_main_tab": "Main Categorization",
+        "cat_live_main_select": "Select Main Categories to Show",
+        "cat_live_main_btn": "Categorize by Main",
+        "cat_live_unmatched_btn": "⚠️ Transfer Unmatched to Editor and Edit ➡️",
+        "cat_live_main_output": "Main Categorized Tags",
+        "cat_live_sub_tab": "Sub Categorization",
+        "cat_live_sub_select": "Select Sub Categories to Show",
+        "cat_live_sub_btn": "Categorize by Sub",
+        "cat_live_sub_output": "Sub Categorized Tags",
+        "cat_manage_tab_title": "Category/Tag Editing",
+        "cat_manage_header": "<h3 style='color:#007bff;'>Manage Category and Tag Files</h3>",
+        "cat_manage_main_accordion": "Main Category Management",
+        "cat_manage_main_grid": "All Categories",
+        "cat_manage_main_refresh": "↻ Refresh Main Categories",
+        "cat_manage_main_select": "Select Category",
+        "cat_manage_tags_input": "Tags (comma separated)",
+        "btn_add": "Add",
+        "btn_delete": "Delete",
+        "cat_manage_sub_accordion": "Sub Category Management",
+        "cat_manage_sub_grid": "All Sub Categories",
+        "cat_manage_sub_refresh": "↻ Refresh Sub Categories",
+        # Category Redesign
+        "cat_redesign_live_tab": "⚡ Live Test",
+        "cat_redesign_main_tab": "📂 Main Category Management",
+        "cat_redesign_sub_tab": "📁 Sub Category Management",
+        "cat_manage_sub_select": "Select Sub Category",
+
+        # Image Tools
+        "img_tools_header": "<h3 style='color:#0077b6;'>Batch Image Processing</h3>",
+        "img_tools_paths_input": "Folder Paths (One per line)",
+        "img_tools_select_folder_btn": "📁 Select Folder",
+        "img_tools_clear_btn": "🗑️ Clear",
+        "img_tools_save_settings_btn": "Save Path and Tool Settings",
+        "img_tools_res_accordion": "1. 📐 Resolution",
+        "img_tools_scale_label": "Scale",
+        "btn_apply": "Apply",
+        "img_tools_rename_accordion": "2. 📝 Renaming (Templated)",
+        "img_tools_rename_desc": "Renames files sequentially. Template must include **`{Number}`**.",
+        "img_tools_template_select": "Ready Templates",
+        "img_tools_delete_template_btn": "🗑️ Delete Template",
+        "img_tools_new_template_input": "Add New Template",
+        "img_tools_new_template_placeholder": "Ex: Adoptable {Number} (Elf)",
+        "img_tools_add_template_btn": "➕ Add to List",
+        "img_tools_start_num": "Start Number",
+        "img_tools_digit_count": "Digits (e.g. 3 for 001)",
+        "img_tools_rename_btn": "Rename Files",
+        "img_tools_watermark_accordion": "3. 🖋️ Watermark",
+        "img_tools_watermark_default": "Sample Watermark",
+        "img_tools_watermark_text": "Text",
+        "img_tools_watermark_opacity": "Opacity",
+        "img_tools_watermark_size": "Font Size",
+        "img_tools_watermark_angle": "Angle",
+        "img_tools_format_accordion": "4. 🖼️ Format",
+        "img_tools_format_label": "Format",
+        "btn_convert": "Convert",
+        "img_tools_bc_accordion": "5. 🔅 Brightness/Contrast",
+        "img_tools_brightness": "Brightness",
+        "img_tools_contrast": "Contrast",
+        "img_tools_ds_accordion": "6. 🧼 Denoise/Sharpen",
+        "img_tools_denoise": "Denoise",
+        "img_tools_sharpen": "Sharpen",
+
+        # Text Tools
+        "txt_tools_header": "<h3 style='color:#28a745;'>Manual Text Tools</h3>",
+        "txt_tools_input": "Text to Process",
+        "txt_tools_tab_clean": "Cleaning",
+        "txt_tools_clean_btn": "Clean and Uniquify",
+        "label_result": "Result",
+        "txt_tools_tab_format": "Change Format",
+        "txt_tools_lines_to_comma": "Lines -> Comma",
+        "txt_tools_comma_to_lines": "Comma -> Lines",
+        "txt_tools_tab_random": "Select Random",
+        "txt_tools_line_count": "Line Count",
+        "btn_select": "Select",
+        "txt_tools_tab_refine": "Refine",
+        "txt_tools_refine_desc": "Words to remove are read from **`{filename}`**.",
+        "btn_filter": "Filter",
+
+        # Rule Tools
+        "rule_tools_intro": "Manage how tags are replaced, merged, and appended to results in this area.",
+        "rule_rep_desc": "Automatically replaces tags with other tags.",
+        "rule_rep_accordion": "Replacement Rules (Regex Supported)",
+        "rule_active_file": "Active File",
+        "rule_new_file_name": "New File Name",
+        "rule_create_file_btn": "Create New File",
+        "rule_tab_quick_add": "Quick Add Rule",
+        "rule_rep_old": "Old Tag (or Regex)",
+        "rule_rep_new": "New Tag",
+        "rule_add_to_file_btn": "Add Rule to File",
+        "rule_tab_edit_file": "Edit File",
+        "rule_file_content_manual": "File Content (Manual Edit)",
+        "rule_save_all_btn": "Save All Content",
+        "rule_syn_accordion": "Merging Rules (Synonyms)",
+        "rule_syn_intro": "Merges multiple tags into one main tag (Deletes others).",
+        "rule_syn_main": "Main Tag (Kept)",
+        "rule_syn_remove": "Synonyms to Delete (Comma separated)",
+        "rule_add_accordion": "Addition Rules (Auto Append)",
+        "rule_add_intro": "Tags in this section are automatically appended to the end of the result list.",
+        "rule_add_content_input": "Tags to Add (Line by line or comma)",
+        "rule_add_save_btn": "Save Addition Rules",
+
+        # Art Tools
+        "art_header": "### 🎨 Furry & Adoptable Tools",
+        "art_desc": "Grid creation tools for sales.",
+        "art_tab_grid": "田 Adoptable Grid Creator",
+        "art_file_input": "Select Images (Multiple)",
+        "art_grid_settings": "Grid Settings",
+        "art_cols": "Columns (How many images side-by-side?)",
+        "art_bg_color": "Background Color",
+        "art_label_settings": "Label Settings",
+        "art_add_labels_check": "Add Text Below Image",
+        "art_label_type": "Label Type",
+        "art_start_num": "Start Number / Price",
+        "art_create_btn": "Create Grid",
+        "art_output": "Grid Result",
+
+        # Prompt Generator
+        "prompt_template_mgmt_header": "### 📝 Template Management",
+        "prompt_select_template": "Select Template",
+        "prompt_new_template_name": "New Template Name",
+        "prompt_template_content": "Template Content",
+        "btn_update": "💾 Update",
+        "btn_add_new": "➕ Add New",
+        "prompt_generation_header": "### 🚀 Generation",
+        "prompt_gen_btn": "GENERATE SELECTED TEMPLATE",
+        "prompt_gen_all_btn": "GENERATE ALL TEMPLATES",
+        "prompt_var_settings_accordion": "🛠️ Variable Settings (Add/Edit Options)",
+        "prompt_select_var": "Select Variable to Edit",
+        "prompt_var_label": "Label Name",
+        "prompt_var_default": "Default Value",
+        "prompt_var_options": "Options (One per line)",
+        "prompt_update_var_btn": "Update Variable",
+
+        # Video Creator
+        "vid_header": "### 🎬 Pro Video Studio",
+        "vid_desc": "Combine images and music, select format and add effects.",
+        "vid_img_input": "1. Select Images (Multiple for Slideshow)",
+        "vid_audio_input": "2. Select Music (Multiple)",
+        "vid_resolution": "Video Format (Resolution)",
+        "vid_speed": "Processing Speed",
+        "vid_text_overlay": "Add Text Over Video (Optional)",
+        "vid_spectrum_check": "Add Audio Spectrum (WARNING: Increases render time significantly)",
+        "vid_create_btn": "CREATE VIDEO",
+        "vid_preview": "Preview",
+        "vid_status": "Process Status",
+    },
+}

modules/managers/category_manager.py

@@ -0,0 +1,167 @@
+import os
+import functools
+import re
+import gradio as gr
+import random
+
+# --- Klasör Sabitleri ---
+KATEGORILER_KLASORU = "data/rules/kategoriler"
+ALT_KATEGORILER_KLASORU = "data/rules/alt_kategoriler"
+
+# --- KATEGORİZASYON ---
+
+@functools.lru_cache(maxsize=32)
+def kategori_sozlugu_yukle():
+    kategori_sozluk = {}
+    if not os.path.exists(KATEGORILER_KLASORU): os.makedirs(KATEGORILER_KLASORU, exist_ok=True); return {}
+    try:
+        for dosya in os.listdir(KATEGORILER_KLASORU):
+            if dosya.endswith(".txt"):
+                kat = dosya.replace(".txt", "").replace("_", " ")
+                with open(os.path.join(KATEGORILER_KLASORU, dosya), "r", encoding="utf-8") as f:
+                    kategori_sozluk[kat] = {s.strip().lower() for s in f if s.strip()}
+    except: pass
+    return kategori_sozluk
+
+
+
+def kategorizelendir_ileri(girdi_etiketleri_str, secilen_kategoriler_listesi, kategori_sozluk_ref):
+    if not girdi_etiketleri_str or not secilen_kategoriler_listesi: return ""
+    girdi = [t.strip().lower() for t in girdi_etiketleri_str.split(",") if t.strip()]
+    secilen = set(secilen_kategoriler_listesi)
+    sonuc = []
+    for t in girdi:
+        for k, v in kategori_sozluk_ref.items():
+            if k in secilen and t in v:
+                sonuc.append(t); break
+    return ", ".join(sorted(list(set(sonuc))))
+
+def kategori_html_ve_kopyala(kategori_adi, etiketler):
+    renk_map = {
+        0: ("#fef9c3", "#fde047", "🔶"), 1: ("#dbeafe", "#60a5fa", "🔷"),
+        2: ("#fee2e2", "#f87171", "🟥"), 3: ("#dcfce7", "#4ade80", "🟩"),
+        4: ("#f3e8ff", "#c084fc", "🟪"), "DİĞER / EŞLEŞMEYENLER": ("#f1f5f9", "#94a3b8", "🚫")
+    }
+    idx = 0
+    try: idx = int(kategori_adi.split()[0])
+    except: pass
+    
+    if kategori_adi.upper().startswith("DİĞER"): renk, border, ikon = renk_map["DİĞER / EŞLEŞMEYENLER"]
+    else: renk, border, ikon = renk_map.get(idx % 5, ("#f3f4f6", "#d1d5db", "🗂️"))
+
+    text_id = f"text_{random.randint(0,999999)}"
+    metin = ", ".join(etiketler)
+    chipler = "".join([f"<span style='background:rgba(255,255,255,0.6); padding:4px 8px; border-radius:6px; border:1px solid rgba(0,0,0,0.1); font-size:0.9em; color:#374151; display:inline-block;'>{e}</span>" for e in sorted(etiketler)])
+    
+    html = f"""
+    <div style="background:{renk}; border:2px solid {border}; border-radius:12px; padding:12px; margin-bottom:15px; display:flex; flex-direction:column; gap:10px; box-shadow: 0 2px 5px rgba(0,0,0,0.05);">
+        <div style="display:flex; justify-content:space-between; align-items:center; border-bottom:1px solid rgba(0,0,0,0.05); padding-bottom:8px;">
+            <div style="font-weight:bold; font-size:1.05em; color:#1f2937; display:flex; align-items:center; gap:6px;">
+                <span>{ikon}</span> <span>{kategori_adi.upper()}</span>
+                <span style="background:rgba(0,0,0,0.1); color:#4b5563; font-size:0.8em; padding:1px 6px; border-radius:10px;">{len(etiketler)}</span>
+            </div>
+            <button onclick="navigator.clipboard.writeText(document.getElementById('{text_id}').value); this.innerText='Kopyalandı!'" style="background:#2563eb; color:white; border:none; padding:4px 12px; border-radius:6px; cursor:pointer; font-size:0.85em; font-weight:500; transition: background 0.2s;">Kopyala</button>
+        </div>
+        <div style="display:flex; flex-wrap:wrap; gap:6px; max-height:150px; overflow-y:auto; padding-right:5px;">
+            {chipler if etiketler else "<span style='color:#6b7280; font-style:italic; font-size:0.9em;'>Bu kategoride etiket bulunamadı.</span>"}
+        </div>
+        <textarea id='{text_id}' style='display:none;'>{metin}</textarea>
+    </div>
+    """
+    return html
+
+def full_kategori_html_ve_kopyala(kategoriler, etiketler_list):
+    html = "<div style='margin-bottom:20px;'>"
+    for k, e in zip(kategoriler, etiketler_list): html += kategori_html_ve_kopyala(k, e)
+    return html + "</div>"
+
+def etiket_ekle(kategori, etiketler_str):
+    if not kategori: return gr.update(value="Kategori seçin")
+    yeni_etiketler = {e.strip().lower() for e in etiketler_str.split(",") if e.strip()}
+    if not yeni_etiketler: return gr.update(value="Eklenecek geçerli etiket yok.")
+    try:
+        if os.path.exists(KATEGORILER_KLASORU):
+            for dosya in os.listdir(KATEGORILER_KLASORU):
+                if dosya.endswith(".txt"):
+                    dosya_kategori_adi = dosya.replace(".txt", "").replace("_", " ")
+                    if dosya_kategori_adi == kategori: continue
+                    dosya_yolu = os.path.join(KATEGORILER_KLASORU, dosya)
+                    mevcut_diger = set()
+                    with open(dosya_yolu, "r", encoding="utf-8") as f: mevcut_diger = {l.strip().lower() for l in f if l.strip()}
+                    if not mevcut_diger.isdisjoint(yeni_etiketler):
+                        guncel_etiketler = mevcut_diger - yeni_etiketler
+                        with open(dosya_yolu, "w", encoding="utf-8") as f:
+                            for e in sorted(guncel_etiketler): f.write(e + "\n")
+        safe = re.sub(r'[^\w\.-]', '_', kategori)
+        path = os.path.join(KATEGORILER_KLASORU, f"{safe}.txt")
+        mevcut_hedef = set()
+        if os.path.exists(path):
+            with open(path, "r", encoding="utf-8") as f: mevcut_hedef = {l.strip().lower() for l in f if l.strip()}
+        with open(path, "w", encoding="utf-8") as f:
+            for e in sorted(mevcut_hedef | yeni_etiketler): f.write(e + "\n")
+        kategori_sozlugu_yukle.cache_clear()
+        return gr.update(value=f"✅ {len(yeni_etiketler)} etiket '{kategori}' kategorisine taşındı.", visible=True)
+    except Exception as e: return gr.update(value=f"❌ Hata: {e}")
+
+def etiket_sil(kategori, etiketler_str):
+    safe = re.sub(r'[^\w\.-]', '_', kategori)
+    path = os.path.join(KATEGORILER_KLASORU, f"{safe}.txt")
+    if not os.path.exists(path): return gr.update(value="Dosya yok")
+    sil = {e.strip().lower() for e in etiketler_str.split(",") if e.strip()}
+    try:
+        mevcut = {l.strip().lower() for l in open(path, encoding="utf-8") if l.strip()}
+        with open(path, "w", encoding="utf-8") as f:
+            for e in sorted(mevcut - sil): f.write(e + "\n")
+        kategori_sozlugu_yukle.cache_clear()
+        return gr.update(value=f"{len(sil & mevcut)} etiket silindi.", visible=True)
+    except Exception as e: return gr.update(value=f"Hata: {e}")
+
+def kategorileri_grid_html():
+    d = kategori_sozlugu_yukle()
+    html = "<div class='kategori-grid-app2'>"
+    for i, k in enumerate(sorted(d.keys())):
+        count = len(d[k])
+        # Kart yapısı
+        html += f"""
+        <div class='kategori-card-app2'>
+            <div class='kategori-title-app2'>{k.upper()}</div>
+            <div style='margin-top:auto; display:flex; justify-content:space-between; align-items:center;'>
+                <span style='font-size:0.85em; color:#64748b;'>Toplam Etiket</span>
+                <span style='background:#f1f5f9; color:#334151; padding:4px 12px; border-radius:20px; font-weight:bold; font-size:0.9em; border:1px solid #e2e8f0;'>{count}</span>
+            </div>
+        </div>
+        """
+    return html + "</div>"
+
+def grid_guncelle():
+    kategori_sozlugu_yukle.cache_clear()
+    return kategorileri_grid_html()
+
+
+
+
+
+def kategori_listesi(): return list(kategori_sozlugu_yukle().keys())
+
+
+def filter_and_display_main_categorized_tags(girdi_etiketleri_str, selected_main_categories):
+    ref = kategori_sozlugu_yukle()
+    girdi_etiketleri = {etiket.strip().lower() for etiket in girdi_etiketleri_str.split(",") if etiket.strip()}
+    sonuc = {k: [] for k in ref if k in (selected_main_categories if selected_main_categories else ref.keys())}
+    diger = set()
+    for etiket in girdi_etiketleri:
+        found = False
+        for kategori, kume in ref.items():
+            if etiket in kume and kategori in sonuc:
+                sonuc[kategori].append(etiket); found = True; break
+        if not found: diger.add(etiket)
+    cats, tags = [], []
+    if diger: cats.append("DİĞER / EŞLEŞMEYENLER"); tags.append(sorted(list(diger)))
+    for k in sorted(sonuc.keys()): cats.append(k); tags.append(sorted(sonuc[k]))
+    
+    html_output = full_kategori_html_ve_kopyala(cats, tags)
+    eslesmeyen_str = ", ".join(sorted(list(diger)))
+    return html_output, eslesmeyen_str
+
+
+

modules/managers/localization_manager.py

@@ -0,0 +1,31 @@
+
+from modules.config_manager import load_config
+from modules.localization.languages import STRINGS
+
+class LocalizationManager:
+    _instance = None
+
+    def __new__(cls):
+        if cls._instance is None:
+            cls._instance = super(LocalizationManager, cls).__new__(cls)
+            cls._instance.config = load_config()
+            cls._instance.language = cls._instance.config.get("general_settings", {}).get("language", "tr")
+            cls._instance.strings = STRINGS.get(cls._instance.language, STRINGS["tr"])
+        return cls._instance
+
+    def get(self, key):
+        """Returns the localized string for the given key."""
+        return self.strings.get(key, key)
+
+    def set_language(self, lang_code):
+        if lang_code in STRINGS:
+            self.language = lang_code
+            self.strings = STRINGS[lang_code]
+            return True
+        return False
+
+# Global instance
+loc = LocalizationManager()
+
+def get_str(key):
+    return loc.get(key)

modules/managers/rule_manager.py

@@ -0,0 +1,186 @@
+import os
+import functools
+import re
+import gradio as gr
+
+# --- Klasör Sabitleri ---
+REPLACEMENT_RULES_KLASORU = "data/rules/replacement_rules"
+SYNONYM_RULES_KLASORU = "data/rules/synonym_rules"
+ADDITION_RULES_KLASORU = "data/rules/addition_rules"
+
+# --- DEĞİŞTİRME KURALLARI (REPLACEMENT) ---
+
+@functools.lru_cache(maxsize=32)
+def get_replacement_files():
+    if not os.path.exists(REPLACEMENT_RULES_KLASORU): os.makedirs(REPLACEMENT_RULES_KLASORU); return []
+    return [os.path.join(REPLACEMENT_RULES_KLASORU, f) for f in os.listdir(REPLACEMENT_RULES_KLASORU) if f.endswith(".txt")]
+
+@functools.lru_cache(maxsize=32)
+def load_replacement_rules(file_path):
+    rules = {}
+    if not file_path or not os.path.exists(file_path): return rules
+    try:
+        with open(file_path, "r", encoding="utf-8") as f:
+            for line in f:
+                line = line.strip()
+                if not line or line.startswith('#'): continue
+                parts = line.split('->')
+                if len(parts) == 2:
+                    old_tag = parts[0].strip().lower().replace(r'\b', '')
+                    new_tag = parts[1].strip().lower()
+                    rules[old_tag] = new_tag
+        return rules
+    except: return {}
+
+def apply_replacements(tags_string, replacement_file_path):
+    if not tags_string or not replacement_file_path: return tags_string
+    rules = load_replacement_rules(replacement_file_path)
+    if not rules: return tags_string
+    tags = [t.strip().lower() for t in tags_string.split(",") if t.strip()]
+    processed_tags = []
+    for tag in tags:
+        if tag in rules: processed_tags.append(rules[tag])
+        else: processed_tags.append(tag)
+    return ", ".join(processed_tags)
+
+def create_replacement_file(file_name):
+    if not file_name.strip(): return "Hata"
+    path = os.path.join(REPLACEMENT_RULES_KLASORU, f"{re.sub(r'[^\w\.-]', '_', file_name)}.txt")
+    if not os.path.exists(REPLACEMENT_RULES_KLASORU): os.makedirs(REPLACEMENT_RULES_KLASORU)
+    with open(path, "w", encoding="utf-8") as f: 
+        f.write("# Eski Etiket -> Yeni Etiket\n")
+        f.write("# blue_hair -> cyan hair\n")
+        f.write("# Artık regex kullanmanıza gerek yoktur, tam eşleşme yapılır.\n")
+    get_replacement_files.cache_clear()
+    return f"Oluşturuldu: {path}"
+
+def read_replacement_file_content(file_path):
+    try: return open(file_path, "r", encoding="utf-8").read()
+    except: return ""
+
+def save_replacement_file_content(file_path, content):
+    try:
+        with open(file_path, "w", encoding="utf-8") as f: f.write(content)
+        load_replacement_rules.cache_clear()
+        return "Kaydedildi"
+    except: return "Hata"
+
+def append_replacement_rule_to_file(file_path, old_tag, new_tag):
+    if not file_path or not os.path.exists(file_path): return gr.update(value="❌ Geçerli bir dosya seçili değil.")
+    if not old_tag.strip(): return gr.update(value="❌ Eski etiket boş olamaz.")
+    clean_old = old_tag.strip()
+    clean_new = new_tag.strip()
+    rule_line = f"\n{clean_old} -> {clean_new}"
+    try:
+        with open(file_path, "a", encoding="utf-8") as f: f.write(rule_line)
+        load_replacement_rules.cache_clear()
+        return gr.update(value=f"✅ Kural eklendi: '{clean_old}' -> '{clean_new}'", visible=True)
+    except Exception as e: return gr.update(value=f"❌ Hata: {e}", visible=True)
+
+# --- BİRLEŞTİRME KURALLARI (SYNONYM) ---
+
+@functools.lru_cache(maxsize=32)
+def get_synonym_files():
+    if not os.path.exists(SYNONYM_RULES_KLASORU): os.makedirs(SYNONYM_RULES_KLASORU); return []
+    return [os.path.join(SYNONYM_RULES_KLASORU, f) for f in os.listdir(SYNONYM_RULES_KLASORU) if f.endswith(".txt")]
+
+@functools.lru_cache(maxsize=32)
+def load_synonym_rules(file_path):
+    rules = {}
+    if not file_path or not os.path.exists(file_path): return rules
+    try:
+        with open(file_path, "r", encoding="utf-8") as f:
+            for line in f:
+                if ':' in line and not line.strip().startswith('#'):
+                    p = line.split(':', 1)
+                    rules.setdefault(p[0].strip().lower(), set()).update({s.strip().lower() for s in p[1].split(',') if s.strip()})
+        return rules
+    except: return {}
+
+def apply_synonym_consolidation(tags_string, synonym_file_path):
+    if not tags_string or not synonym_file_path: return tags_string
+    rules = load_synonym_rules(synonym_file_path)
+    tag_set = {t.strip() for t in tags_string.split(',') if t.strip()}
+    remove = set()
+    for main, syns in rules.items():
+        if main in tag_set:
+            for s in syns:
+                if s in tag_set: remove.add(s)
+    return ", ".join(list(tag_set - remove))
+
+def create_synonym_file(file_name):
+    path = os.path.join(SYNONYM_RULES_KLASORU, f"{re.sub(r'[^\w\.-]', '_', file_name)}.txt")
+    if not os.path.exists(SYNONYM_RULES_KLASORU): os.makedirs(SYNONYM_RULES_KLASORU)
+    with open(path, "w", encoding="utf-8") as f: f.write("# main: s1, s2\n")
+    get_synonym_files.cache_clear()
+    return f"Oluşturuldu: {path}"
+
+def read_synonym_file_content(file_path):
+    try: return open(file_path, "r", encoding="utf-8").read()
+    except: return ""
+
+def save_synonym_file_content(file_path, content):
+    try:
+        with open(file_path, "w", encoding="utf-8") as f: f.write(content)
+        load_synonym_rules.cache_clear()
+        return "Kaydedildi"
+    except: return "Hata"
+
+def append_synonym_rule_to_file(file_path, main_tag, remove_tags_str):
+    if not file_path or not os.path.exists(file_path): return gr.update(value="❌ Geçerli bir dosya seçili değil.")
+    if not main_tag.strip() or not remove_tags_str.strip(): return gr.update(value="❌ Ana etiket veya silinecekler boş olamaz.")
+    rule_line = f"\n{main_tag.strip()}: {remove_tags_str.strip()}"
+    try:
+        with open(file_path, "a", encoding="utf-8") as f: f.write(rule_line)
+        load_synonym_rules.cache_clear()
+        return gr.update(value=f"✅ Kural eklendi: '{main_tag}' şunları silecek: {remove_tags_str}", visible=True)
+    except Exception as e: return gr.update(value=f"❌ Hata: {e}", visible=True)
+
+# --- EKLEME KURALLARI (ADDITION) ---
+
+@functools.lru_cache(maxsize=32)
+def get_addition_files():
+    if not os.path.exists(ADDITION_RULES_KLASORU): os.makedirs(ADDITION_RULES_KLASORU); return []
+    return [os.path.join(ADDITION_RULES_KLASORU, f) for f in os.listdir(ADDITION_RULES_KLASORU) if f.endswith(".txt")]
+
+@functools.lru_cache(maxsize=32)
+def load_addition_rules(file_path):
+    tags = []
+    if not file_path or not os.path.exists(file_path): return ""
+    try:
+        with open(file_path, "r", encoding="utf-8") as f:
+            for line in f:
+                line = line.strip()
+                if not line or line.startswith('#'): continue
+                parts = [t.strip() for t in line.split(',') if t.strip()]
+                tags.extend(parts)
+        return ", ".join(tags)
+    except: return ""
+
+def apply_additions(tags_string, addition_file_path):
+    if not addition_file_path: return tags_string
+    additional_tags = load_addition_rules(addition_file_path)
+    if not additional_tags: return tags_string
+    if not tags_string.strip(): return additional_tags
+    return f"{tags_string}, {additional_tags}"
+
+def create_addition_file(file_name):
+    if not file_name.strip(): return "Hata"
+    path = os.path.join(ADDITION_RULES_KLASORU, f"{re.sub(r'[^\w\.-]', '_', file_name)}.txt")
+    if not os.path.exists(ADDITION_RULES_KLASORU): os.makedirs(ADDITION_RULES_KLASORU)
+    with open(path, "w", encoding="utf-8") as f: 
+        f.write("# İşlem sonunda eklenecek etiketler (virgülle veya yeni satırla)\n")
+        f.write("# best quality, masterpiece\n")
+    get_addition_files.cache_clear()
+    return f"Oluşturuldu: {path}"
+
+def read_addition_file_content(file_path):
+    try: return open(file_path, "r", encoding="utf-8").read()
+    except: return ""
+
+def save_addition_file_content(file_path, content):
+    try:
+        with open(file_path, "w", encoding="utf-8") as f: f.write(content)
+        load_addition_rules.cache_clear()
+        return "Kaydedildi"
+    except: return "Hata"

modules/prompt_generator.py

@@ -0,0 +1,413 @@
+# modules/prompt_generator.py
+
+import gradio as gr
+import json
+import os
+import re
+import random
+from modules.localization.languages import get_str
+
+# --- Veriler ve Sabitler ---
+
+SABLON_DOSYA_YOLU = "data/configs/prompt_sablonlar.json"
+DEGISKENLER_DOSYA_YOLU = "data/configs/prompt_variables.json"
+
+# Varsayılan Veriler (İlk kurulum için)
+varsayilan_etiketler_ham = [
+    "Güzellik ve Makyaj", "Karakterin Yaşı", "Göz Rengi", "Saç Rengi ve Stili",
+    "Göğüs ve Göğüs Büyüklüğü", "Dönüşüm Öncesi Yüz İfadesi", "Dönüşüm Sırasındaki Yüz İfadesi",
+    "Dönüşüm Sonrası Yüz İfadesi", "Dönüşülen Hayvan", "Dönüşülen Hayvanın Fiziksel Özellikleri",
+    "Arkaplan/Mekan", "Dönüşüm Öncesi Poz", "Dönüşüm Esnası Poz 1", "Dönüşüm Esnası Poz 2",
+    "Dönüşüm Sonu Poz", "Dönüşüm Sonrası Poz 1 (Nude 1)", "Dönüşüm Sonrası Poz 2 (Nude 2)",
+    "Dönüşüm Sonrası Poz 3 (Blowjob)", "Dönüşüm Sonrası Poz 4 (Blowjob 2)", "Dönüşüm Sonrası Poz 5 (Missionary Sex)",
+    "Dönüşüm Sonrası Poz 6 (Cowgirl Position Sex)", "Dönüşüm Sonrası Poz 7 (Doggystyle Sex)",
+    "Dönüşüm Sonrası Poz 8 (Doggystyle Sex From Side)", "Dönüşüm Sonrası Poz 9 (Carrying Sex)",
+    "Dönüşüm Sonrası Poz 10 (On Side Sex)", "Dönüşüm Sonrası Poz 11 (Reverse Cowgirl Sex)",
+    "Dönüşüm Sonrası Poz 12 (After Sex Ejaculation)"
+]
+
+varsayilan_degerler_ham = [
+    "sexy", "25", "green eyes", "hair, red hair, long hair",
+    "breasts, fake tits, huge breasts", "seductive smile, closed mouth",
+    "(open mouth:1.1), (shocked, surprised expression:1.2), (wide-eyed:1.3), (screaming in pain:1.2), crying, gritting teeth, painful expression",
+    "(moaning, embarrassed:1.2)", "deer",
+    "animal ears, anthro, biped, black nose, brown body, brown fur, deer, deer ears, deer girl, deer tail, fur, furry, furry female, inner ear fluff, mammal, markings, multicolored body, multicolored fur, short tail, spikes, spots, spotted body, spotted fur, tail, tuft, white body, white fur, antlers, white antlers",
+    "blurry, blurry background, forest, nature, outdoors, outside, plant, tree",
+    "accessory, bare shoulders, blue ribbon, blush, bodily fluids, breasts, cleavage, cleavage cutout, closed mouth, clothed, clothing, clothing cutout, cowboy shot, dress, gloves, handwear, looking at viewer, ribbon, ribbons, sensitive, short dress, sleeveless, sleeveless dress, solo, sweat, white clothing, white dress, white gloves",
+    "all fours, blush, collarbone, genitals, kneeling, leaning, leaning backward, looking at viewer, nipples, nude, solo",
+    "all fours, blush, collarbone, genitals, kneeling, leaning, leaning backward, looking at viewer, nipples, nude, solo",
+    "all fours, blush, collarbone, kneeling, leaning, leaning backward, looking at viewer, nipples, nude, solo",
+    "anus, breasts with fur, clitoral hood, clitoris, completely nude, explicit, genitals, leg up, legs up, looking at viewer, looking up, lying, nipples, nude, on back, open mouth, paw pose, presenting, presenting pussy, pussy, solo, spread legs, spreading, teeth, tongue, tongue out, from above",
+    "all fours, anus, barefoot, bodily fluids, breasts with fur, completely nude, explicit, from behind, genitals, looking at viewer, looking back, nipples, nude, open mouth, presenting, pussy, solo, teeth, tongue, tongue out",
+    "all fours, anthro on human, anthro penetrated, ass up, balls, blush, bodily fluids, butt from the front, completely nude, deepthroat, duo, erection, explicit, faceless character, faceless male, fellatio, first person view, genitals, human male penetrating, human male penetrating anthro, human on anthro, human penetrating anthro, human pov, human/anthro, looking at viewer, lying, male, male on anthro, male pov, male/anthro, nude, oral, oral penetration, penetrating pov, penetration, penile, penile penetration, penis, penis in mouth, pov, saliva, saliva on penis, seductive, sex, solo focus, spread legs, spreading, sweat, sweaty butt, testicles, vein, wet",
+    "anthro penetrated, balls, breasts with fur, completely nude, duo, erection, explicit, faceless character, faceless human, faceless male, fellatio, from side, genitals, hetero, human male penetrating, human male penetrating anthro, human on anthro, human penetrating, human penetrating anthro, human/anthro, humanoid genitalia, humanoid penis, looking at another, male, male/anthro, nipples, nude, open mouth, oral, oral penetration, penetration, penile, penile penetration, penis, penis in mouth, pink nipples, sex, side view, solo focus, testicles",
+    "anthro penetrated, breasts with fur, cum, cum from pussy, cum in pussy, cum inside, cum on fur, duo, erection, explicit, faceless character, faceless male, first person view, from front position, genitals, human male penetrating, human male penetrating anthro, human penetrating, human penetrating anthro, human pov, human/anthro, humanoid penis, leaking cum, looking pleasured, lying anthro, male, male pov, male/anthro, missionary, missionary position, nipples, open mouth, orgasm, penetrating pov, penetration, penile, penile penetration, penis, penis in pussy, pov, pov crotch, pussy, saliva, sex, solo focus, spread legs, spreading, tongue, tongue out, vaginal, vaginal penetration, from above, male kneeling",
+    "anthro penetrated, arms behind back, breasts with fur, collarbone, completely nude, cowgirl position, duo, erection, explicit, first person view, from front position, genitals, anthro on top, hetero, human male penetrating, human male penetrating anthro, human on anthro, human penetrating, human penetrating anthro, human/anthro, looking at viewer, male, male on anthro, male on bottom, male pov, male/anthro, nipples, nude, on bottom, on top, open mouth, penetration, penile, penile penetration, penis, penis in pussy, pov, pussy, sex, solo focus, spread legs, straddling, sweat, vaginal, vaginal penetration, vein, veiny penis, male lying, anthro kneeling",
+    "ahegao, all fours, anthro penetrated, anus, back, back boob, balls, big penis, blush, bodily fluids, breasts with fur, deep penetration, doggystyle, duo, erection, explicit, first person view, from behind, from behind position, fucked silly, genital fluids, genitals, glistening, glistening butt, hetero, huge penis, human male penetrating, human male penetrating anthro, human on anthro, human penetrating, human penetrating anthro, human/anthro, humanoid genitalia, humanoid penis, large penis, looking at viewer, looking back, looking back at viewer, looking pleasured, male, male pov, male/anthro, open mouth, penetrating pov, penetration, penile, penile penetration, penis, penis in pussy, pov, pussy, pussy juice, rear view, sex, sex from behind, solo focus, sweat, sweaty butt, tongue, tongue out, trembling, vaginal, vaginal fluids, vaginal penetration, vein, veiny penis",
+    "all fours, ambiguous penetration, anthro penetrated, bodily fluids, breasts with fur, breath, butt grab, completely nude, cum, cum in pussy, cum inside, cum overflow, doggystyle, duo, explicit, faceless character, faceless male, from behind position, genital fluids, hand on butt, hetero, human male penetrating, human male penetrating anthro, human penetrated, human penetrating, human/anthro, looking pleasured, male, male/anthro, motion lines, nipples, nude, open mouth, penetration, penile, saliva, sex, sex from behind, solo focus, sweat, tongue, tongue out",
+    "anthro penetrated, balls, breasts with fur, clitoris, cum, cum in pussy, cum inside, duo, erection, explicit, folded, fucked silly, full nelson, genital fluids, human male penetrating, human male penetrating anthro, human on anthro, human penetrating, human penetrating anthro, human/anthro, humanoid penis, large penis, legs up, looking pleasured, male, male/anthro, nipples, nude, open mouth, penetration, penile, penile penetration, penis, penis in pussy, pussy, reverse suspended congress, saliva, sex, sex from behind, solo focus, spread legs, teeth, testicles, tongue, tongue out, butt fur, feet out of frame, male standing, anthro on lap, fur legs",
+    "anthro penetrated, breasts with fur, clitoral hood, clitoris, duo, erection, explicit, faceless character, faceless male, human male penetrating, human male penetrating anthro, human on anthro, human penetrating, human penetrating anthro, human/anthro, leg lift, looking at viewer, lying, male, male on anthro, male/anthro, nipples, nude, on side, open mouth, penetration, penile, penile penetration, penis, penis in mouth, pussy, pussy juice, raised leg, sex, anthro focus, spread legs, spreading, vein, veiny penis, fur legs, male kneeling, anthro lying, male grabbing",
+    "anthro penetrated, anus, back, balls, big penis, breasts with fur, duo, erection, explicit, eye roll, faceless character, faceless human, faceless male, anthro on top, first person view, from behind, fucked silly, genital fluids, genitals, happy, hetero, human male penetrating, human male penetrating anthro, human on anthro, human penetrating, human penetrating anthro, human/anthro, humanoid penis, looking back, looking pleasured, lying, male, male on anthro, male on bottom, male pov, male/anthro, nipples, nude, on bottom, on top, open mouth, penetration, penile, penile penetration, penis, penis in pussy, pov, puckered anus, pussy, reverse cowgirl position, sex, sex from behind, solo focus, straddling, toned, tongue, tongue out, vaginal, vaginal penetration, vein, veiny penis, male lying, from below",
+    "after sex, anus, balls, breasts with fur, completely nude, cum, cum from pussy, cum in pussy, cum inside, cum on fur, cum on penis, cumdrip, duo, erection, explicit, faceless character, faceless male, first person view, hetero, human on anthro, human pov, human/anthro, humanoid penis, leaking cum, looking at viewer, lying, male, male pov, male/anthro, nipples, nude, on back, on back, open mouth, penis, pov, pussy, solo focus, spread legs, spreading, sweat, teeth, from above, anthro lying, male kneeling"
+]
+
+VARSAYILAN_SABLONLAR = {
+    "Kalıp 1: Dönüşüm Öncesi": "{0}, {1}yo, {2}, {3}, {4}, {5}, {11}, {10}",
+    "Kalıp 2: Dönüşüm Esnası 1": "(mammal humanoid, {8} humanoid:1.1), transformation, species transformation, {9}, The scene features a {8} hybrid, {8} fur, {8} tail, {8} snout and ears, photomorph, {6}, {0}, {1}yo, {2}, {3}, {4}, {12}, {10}",
+    "Kalıp 3: Dönüşüm Esnası 2": "(mammal humanoid, {8} anthro:1.1), transformation, species transformation, {9}, The scene features a {8} hybrid, {8} fur, {8} tail, {8} snout and ears, photomorph, {6}, {0}, {1}yo, {2}, {3}, {4}, {12}, {10}",
+    "Kalıp 5: Dönüşüm Sonu": "(mammal anthro, {8} anthro:1.1), transformation, species transformation, {9}, The scene features a {8} anthro, {8} fur, {8} tail, {8} snout and ears, photomorph, {6}, {0}, {1}yo, {2}, {3}, {4}, {12}, {10}",
+}
+
+sablonlar = {}
+degiskenler = [] # Liste: [{'id': 0, 'label': '...', 'default': '...', 'options': [...]}]
+
+# --- Yardımcı Fonksiyonlar ---
+
+def sort_keys_naturally(keys):
+    def extract_number(key):
+        match = re.search(r'Kalıp (\d+):', key)
+        if match: return int(match.group(1))
+        return 9999
+    return sorted(keys, key=extract_number)
+
+def sablonlari_yukle():
+    global sablonlar
+    os.makedirs(os.path.dirname(SABLON_DOSYA_YOLU), exist_ok=True)
+    loaded_data = {}
+    if os.path.exists(SABLON_DOSYA_YOLU):
+        try:
+            with open(SABLON_DOSYA_YOLU, "r", encoding="utf-8") as f:
+                loaded_data = json.load(f)
+        except: loaded_data = {}
+    
+    for k, v in VARSAYILAN_SABLONLAR.items():
+        if k not in loaded_data: loaded_data[k] = v
+            
+    sorted_keys = sort_keys_naturally(list(loaded_data.keys()))
+    sablonlar = {k: loaded_data[k] for k in sorted_keys}
+    sablonlari_kaydet()
+
+def sablonlari_kaydet():
+    try:
+        with open(SABLON_DOSYA_YOLU, "w", encoding="utf-8") as f:
+            json.dump(sablonlar, f, ensure_ascii=False, indent=4)
+        return "Şablonlar başarıyla kaydedildi."
+    except Exception as e: return f"Kaydetme hatası: {e}"
+
+def degiskenleri_yukle():
+    """Değişkenleri JSON'dan yükler, yoksa varsayılan listelerden oluşturur."""
+    global degiskenler
+    os.makedirs(os.path.dirname(DEGISKENLER_DOSYA_YOLU), exist_ok=True)
+    
+    if os.path.exists(DEGISKENLER_DOSYA_YOLU):
+        try:
+            with open(DEGISKENLER_DOSYA_YOLU, "r", encoding="utf-8") as f:
+                degiskenler = json.load(f)
+        except:
+            degiskenler = []
+    
+    # Dosya yoksa veya boşsa varsayılanları yükle
+    if not degiskenler and varsayilan_etiketler_ham:
+        for i, (etiket, deger) in enumerate(zip(varsayilan_etiketler_ham, varsayilan_degerler_ham)):
+            degiskenler.append({
+                "id": i,
+                "label": etiket,
+                "default": deger,
+                "options": [deger]
+            })
+        degiskenleri_kaydet()
+
+def degiskenleri_kaydet():
+    try:
+        with open(DEGISKENLER_DOSYA_YOLU, "w", encoding="utf-8") as f:
+            json.dump(degiskenler, f, ensure_ascii=False, indent=4)
+        return "Değişkenler kaydedildi."
+    except Exception as e: return f"Hata: {e}"
+
+# Başlangıç Yüklemeleri
+sablonlari_yukle()
+degiskenleri_yukle()
+
+def metin_olusturucu(sablon_metni, *girdiler):
+    try:
+        clean_inputs = [str(g).strip() for g in girdiler]
+        sonuc_metni = sablon_metni.format(*clean_inputs)
+        return sonuc_metni.strip()
+    except IndexError: return "Hata: Şablondaki değişken sayısı, girilen değer sayısından fazla."
+    except Exception as e: return f"Bilinmeyen hata: {e}"
+
+def sablon_secim_degisti(secim):
+    return sablonlar.get(secim, "")
+
+def mevcut_sablonu_guncelle(secim_adi, yeni_icerik):
+    if not secim_adi: return "Lütfen bir şablon seçin."
+    sablonlar[secim_adi] = yeni_icerik
+    sonuc = sablonlari_kaydet()
+    return f"'{secim_adi}' güncellendi. {sonuc}"
+
+def yeni_sablon_ekle(yeni_ad, yeni_icerik):
+    if not yeni_ad: return "Hata: İsim boş.", gr.update(), gr.update(), gr.update()
+    if yeni_ad in sablonlar: return "Hata: İsim zaten var.", gr.update(), gr.update(), gr.update()
+    sablonlar[yeni_ad] = yeni_icerik
+    sorted_keys = sort_keys_naturally(list(sablonlar.keys()))
+    sablonlar = {k: sablonlar[k] for k in sorted_keys}
+    sablonlari_kaydet()
+    # Hem generatör hem manager dropdown'ını güncelle
+    update = gr.update(choices=list(sablonlar.keys()), value=yeni_ad)
+    return f"'{yeni_ad}' eklendi.", update, update, yeni_icerik
+
+def sablon_sil(secim_adi):
+    if not secim_adi: return "Hata: Seçim yok.", gr.update(), gr.update(), gr.update()
+    if secim_adi in sablonlar:
+        del sablonlar[secim_adi]
+        sablonlari_kaydet()
+        keys = list(sablonlar.keys())
+        val = keys[0] if keys else None
+        cont = sablonlar[val] if val else ""
+        update = gr.update(choices=keys, value=val)
+        return f"'{secim_adi}' silindi.", update, update, cont
+    return "Hata: Bulunamadı.", gr.update(), gr.update(), gr.update()
+
+def tum_metinleri_olustur(*girdiler):
+    tum_sonuclar = []
+    clean_inputs = [str(g).strip() for g in girdiler]
+    for ad, sablon in sablonlar.items():
+        try:
+            text = sablon.format(*clean_inputs)
+            # DÜZELTME: Artık başlıklar eklenmiyor, sadece metin ekleniyor.
+            tum_sonuclar.append(f"{text}")
+        except: pass
+    # Sonuçlar arasında 2 satır boşluk bırakılır.
+    return "\n\n".join(tum_sonuclar)
+
+# --- Değişken Seçenekleri Yönetim Fonksiyonları ---
+
+def get_degisken_bilgisi(label_with_id):
+    """Dropdown'dan seçilen etikete göre bilgileri getirir. Seçenekleri satır satır döndürür."""
+    try:
+        # "{0} - Göz Rengi" formatından ID'yi ayıkla
+        match = re.match(r"\{(\d+)\}", label_with_id)
+        if not match: return "", "", ""
+        
+        index = int(match.group(1))
+        
+        if 0 <= index < len(degiskenler):
+            d = degiskenler[index]
+            # Seçenekleri listesinden alıp satır satır string'e çevir
+            opts = "\n".join(d.get("options", []))
+            return d.get("label", ""), d.get("default", ""), opts
+    except:
+        pass
+    return "", "", ""
+
+def degisken_guncelle(label_with_id, label_new, default_val, options_text):
+    """Mevcut değişkenin etiketini ve seçeneklerini günceller. (Satır bazlı)"""
+    global degiskenler
+    
+    try:
+        match = re.match(r"\{(\d+)\}", label_with_id)
+        if not match: return "Hata: Geçersiz değişken seçimi.", gr.update(), gr.update(), gr.update()
+        
+        index = int(match.group(1))
+        
+        # Satır satır gelen metni listeye çevir
+        options_list = [line.strip() for line in options_text.split('\n') if line.strip()]
+        
+        # Seçenekler boşsa default değeri ekle
+        if not options_list and default_val:
+            options_list.append(default_val)
+        
+        # Default değer seçeneklerde yoksa en başa ekle (Kullanım kolaylığı için)
+        if default_val and default_val not in options_list:
+            options_list.insert(0, default_val)
+
+        if 0 <= index < len(degiskenler):
+            degiskenler[index]["label"] = label_new
+            degiskenler[index]["default"] = default_val
+            degiskenler[index]["options"] = options_list
+            
+            degiskenleri_kaydet()
+            
+            msg = f"Değişken {{{index}}} güncellendi."
+            # Seçenekler metin kutusuna geri satır satır yazılır
+            updated_options_text = "\n".join(options_list)
+            
+            return (
+                msg,
+                gr.update(choices=options_list, value=default_val, label=f"{{{index}}} - {label_new}"), # Ana UI kutusu
+                gr.update(choices=[f"{{{d['id']}}} - {d['label']}" for d in degiskenler], value=f"{{{index}}} - {label_new}"), # Yönetim listesi
+                gr.update(value=updated_options_text)
+            )
+        else:
+            return "Hata: Değişken bulunamadı.", gr.update(), gr.update(), gr.update()
+            
+    except Exception as e:
+        return f"Hata: {e}", gr.update(), gr.update(), gr.update()
+
+# --- UI ---
+
+def create_prompt_generator_ui():
+    degiskenleri_yukle() # UI oluşturulurken en güncel veriyi çek
+    
+    # Değişken listesini yönetim paneli için hazırla
+    degisken_secim_listesi = [f"{{{d['id']}}} - {d['label']}" for d in degiskenler]
+    
+    # Helper function for dropdown
+    def get_sablon_keys():
+        return list(sablonlar.keys())
+        
+    sablon_keys = get_sablon_keys()
+    
+    unsorted_inputs = [] # Generator inputs container
+    giris_kutulari = []  # Final sorted inputs
+
+    with gr.Tabs():
+        
+        # --- 1. SEKME: ÜRETİCİ (GENERATOR) ---
+        with gr.TabItem("🚀 Üretici"):
+            gr.Markdown("### 📝 Hızlı Prompt Oluştur")
+            
+            with gr.Row():
+                sablon_secici_generator = gr.Dropdown(choices=sablon_keys, label=get_str("prompt_select_template"), interactive=True, scale=3)
+                btn_olustur = gr.Button(get_str("prompt_gen_btn"), variant="primary", scale=1)
+                btn_tumu_olustur = gr.Button(get_str("prompt_gen_all_btn"), variant="secondary", scale=1)
+
+            cikti_alani = gr.Textbox(label=get_str("label_result"), lines=5, interactive=False, show_copy_button=True)
+            
+            with gr.Accordion("Gelişmiş Değişken Girdileri", open=True):
+                 # Dinamik Girdi Kutuları (Dropdown) - 3 Kolonlu düzen
+                with gr.Row():
+                    # Kolon 1
+                    with gr.Column():
+                        for i in range(0, len(degiskenler), 3):
+                            d = degiskenler[i]
+                            comp = gr.Dropdown(choices=d["options"], label=d["label"], value=d["default"], interactive=True)
+                            unsorted_inputs.append((i, comp))
+                    # Kolon 2
+                    with gr.Column():
+                        for i in range(1, len(degiskenler), 3):
+                            d = degiskenler[i]
+                            comp = gr.Dropdown(choices=d["options"], label=d["label"], value=d["default"], interactive=True)
+                            unsorted_inputs.append((i, comp))
+                    # Kolon 3
+                    with gr.Column():
+                        for i in range(2, len(degiskenler), 3):
+                            d = degiskenler[i]
+                            comp = gr.Dropdown(choices=d["options"], label=d["label"], value=d["default"], interactive=True)
+                            unsorted_inputs.append((i, comp))
+                
+                # Listeyi indekse göre sırala ve sadece componentleri al
+                unsorted_inputs.sort(key=lambda x: x[0])
+                giris_kutulari = [x[1] for x in unsorted_inputs]
+                
+        # --- 2. SEKME: ŞABLON YÖNETİCİSİ ---
+        with gr.TabItem("🛠️ Şablon Yöneticisi"):
+            gr.Markdown(get_str("prompt_template_mgmt_header"))
+            
+            with gr.Row():
+                sablon_secici_manager = gr.Dropdown(choices=sablon_keys, label="Düzenlenecek Şabloyu Seç", interactive=True, scale=2)
+                btn_sil = gr.Button("🗑️ Seçili Şablonu Sil", variant="stop", scale=1)
+
+            gr.Markdown("---")
+            gr.Markdown("#### Şablon Ekle / Düzenle")
+            
+            yeni_sablon_adi = gr.Textbox(label=get_str("prompt_new_template_name"), placeholder="Yeni şablon ise adını girin (Mevcut birini seçtiyseniz burası otomatik dolar)")
+            sablon_icerik = gr.Textbox(label=get_str("prompt_template_content"), lines=12, interactive=True, placeholder="Şablon içeriğini buraya yazın. Değişkenler için {0}, {1}... kullanın.")
+            
+            with gr.Row():
+                btn_guncelle = gr.Button(get_str("btn_update"), variant="primary")
+                btn_yeni_ekle = gr.Button(get_str("btn_add_new"), variant="secondary")
+                
+            status_msg = gr.Textbox(label=get_str("status_label"), interactive=False, visible=True)
+
+        # --- 3. SEKME: DEĞİŞKEN YÖNETİCİSİ ---
+        with gr.TabItem("🧩 Değişken Yöneticisi"):
+            gr.Markdown("### Değişkenleri Düzenle")
+            
+            yonetim_secim_dd = gr.Dropdown(
+                label=get_str("prompt_select_var"), 
+                choices=degisken_secim_listesi, 
+                value=degisken_secim_listesi[0] if degisken_secim_listesi else None,
+                interactive=True
+            )
+            
+            with gr.Row():
+                yonetim_label = gr.Textbox(label=get_str("prompt_var_label"), interactive=True)
+                yonetim_default = gr.Textbox(label=get_str("prompt_var_default"), interactive=True)
+            
+            yonetim_options = gr.Textbox(
+                label=get_str("prompt_var_options"), 
+                placeholder="Mavi Göz\nYeşil Göz\nEla Göz", 
+                lines=8,
+                interactive=True
+            )
+            
+            yonetim_kaydet_btn = gr.Button(get_str("prompt_update_var_btn"), variant="primary")
+            yonetim_durum = gr.Textbox(label=get_str("status_label"), visible=False)
+
+    # --- Event Bağlantıları ---
+    
+    # 1. Üretici (Generator) Eventleri
+    # Şablon seçildiğinde içeriği almamıza gerek yok, içerik backend'de tutuluyor. 
+    # Ama generate fonksiyonuna içeriği text olarak göndermek daha esnek.
+    # Bu yüzden generator'da gizli bir textbox tutabiliriz veya direk seçimi gönderebiliriz.
+    # Mevcut yapıda 'sablon_icerik' kullanılıyordu. Generator sekmesinde bunu gizli bir state veya textbox olarak tutalım.
+    gen_gizli_icerik = gr.State("") 
+    
+    sablon_secici_generator.change(fn=sablon_secim_degisti, inputs=sablon_secici_generator, outputs=gen_gizli_icerik)
+    
+    # Oluşturma
+    btn_olustur.click(fn=metin_olusturucu, inputs=[gen_gizli_icerik] + giris_kutulari, outputs=cikti_alani)
+    btn_tumu_olustur.click(fn=tum_metinleri_olustur, inputs=giris_kutulari, outputs=cikti_alani)
+
+    # 2. Şablon Yöneticisi Eventleri
+    
+    # Seçim değişince ismi ve içeriği doldur
+    def manager_select_change(secim):
+        content = sablon_secim_degisti(secim)
+        return secim, content # İsim kutusuna ve içerik kutusuna yaz
+
+    sablon_secici_manager.change(fn=manager_select_change, inputs=sablon_secici_manager, outputs=[yeni_sablon_adi, sablon_icerik])
+    
+    # Güncelle (Sadece içeriği güncelle, isim zaten seçili)
+    # create_prompt_generator_ui içinde helper
+    def manager_update_wrapper(name, content):
+        if not name: return "Lütfen bir şablon se��in veya adını yazın."
+        return mevcut_sablonu_guncelle(name, content)
+
+    btn_guncelle.click(fn=manager_update_wrapper, inputs=[yeni_sablon_adi, sablon_icerik], outputs=status_msg)
+    
+    # Yeni Ekle
+    # Çıktılar: status, gen_dropdown, man_dropdown, content_box (temizleme veya aynı kalma?)
+    btn_yeni_ekle.click(
+        fn=yeni_sablon_ekle, 
+        inputs=[yeni_sablon_adi, sablon_icerik], 
+        outputs=[status_msg, sablon_secici_generator, sablon_secici_manager, sablon_icerik]
+    )
+    
+    # Sil
+    btn_sil.click(
+        fn=sablon_sil,
+        inputs=[sablon_secici_manager],
+        outputs=[status_msg, sablon_secici_generator, sablon_secici_manager, sablon_icerik]
+    )
+
+    # 3. Değişken Yöneticisi Eventleri
+    yonetim_secim_dd.change(
+        fn=get_degisken_bilgisi,
+        inputs=[yonetim_secim_dd],
+        outputs=[yonetim_label, yonetim_default, yonetim_options]
+    )
+    
+    def yonetim_wrapper(dd_val, lbl, dflt, opts):
+        res = degisken_guncelle(dd_val, lbl, dflt, opts)
+        return res[0], res[2], res[3]
+
+    yonetim_kaydet_btn.click(
+        fn=yonetim_wrapper,
+        inputs=[yonetim_secim_dd, yonetim_label, yonetim_default, yonetim_options],
+        outputs=[yonetim_durum, yonetim_secim_dd, yonetim_options]
+    ).then(
+        fn=None,
+        _js="() => { alert('Değişken güncellendi! Seçeneklerin ana ekrana yansıması için lütfen sayfayı yenileyin veya uygulamayı yeniden başlatın.'); }"
+    )

modules/shared_state.py

@@ -0,0 +1,35 @@
+
+# modules/shared_state.py
+
+import time
+
+class SharedState:
+    def __init__(self):
+        self.web_image_data = None
+        self.last_update_time = 0
+        self.force_tab_switch = False
+        self.new_image_event = False
+
+shared_state = SharedState()
+
+def set_web_image(data):
+    """Web'den gelen resim verisini ayarlar (Base64 string)."""
+    shared_state.web_image_data = data
+    shared_state.last_update_time = time.time()
+    shared_state.force_tab_switch = True
+    shared_state.new_image_event = True
+
+def reset_image_event():
+    """Resim işlendiğinde event'i sıfırlar."""
+    shared_state.new_image_event = False
+
+def check_and_reset_tab_switch():
+    """Sekme değişikliği gerekiyorsa True döner ve flag'i sıfırlar."""
+    if shared_state.force_tab_switch:
+        shared_state.force_tab_switch = False
+        return True
+    return False
+
+def get_web_image():
+    """Web'den gelen son resim verisini ve zaman damgasını döndürür."""
+    return shared_state.web_image_data, shared_state.last_update_time

modules/tagger.py

@@ -0,0 +1,269 @@
+
+import os
+import tempfile
+import gradio as gr
+from PIL import Image
+
+# Import Tagger Processors
+from modules.taggers.joint import JointTaggerProcessor, run_joint_classifier
+from modules.taggers.cl import CLTaggerProcessor
+from modules.taggers.pixai import PixaiTaggerProcessor
+from modules.taggers.anime import AnimeTaggerProcessor
+from modules.taggers.gemini import GeminiTaggerProcessor
+
+# Import Managers and Utils
+from modules.managers.category_manager import kategori_sozlugu_yukle, kategorizelendir_ileri
+from modules.tagger_refinement import rafine_etiketler
+from modules.utils.tag_utils import unique_and_sort_tags
+from modules.managers.rule_manager import apply_additions
+
+# --- CL Tagger Modülünü İçe Aktarma ---
+try:
+    from modules.cl_tagger_module import CLTagger
+except ImportError:
+    try: from .cl_tagger_module import CLTagger # Fallback for relative import
+    except ImportError:
+        print("cl_tagger_module.py bulunamadı.")
+        CLTagger = None
+
+# Global Instance Variables
+cl_tagger_instance = None
+try:
+    if CLTagger:
+        cl_tagger_instance = CLTagger()
+        print("CL Tagger (ONNX) başarıyla yüklendi.")
+except Exception as e:
+    print(f"CL Tagger (ONNX) yüklenirken hata: {e}")
+    cl_tagger_instance = None
+
+# --- Ortak İşleme Fonksiyonu ---
+def _process_single_image(
+    image, 
+    joint_thresh, use_joint, 
+    cl_gen_thresh, cl_char_thresh, use_cl_tagger, 
+    pixai_general_thresh, pixai_char_thresh, use_pixai_tagger,
+    animetagger_model, animetagger_thresh, use_animetagger, 
+    use_gemini, gemini_api_key, gemini_mode, gemini_model_id, 
+    gemini_prompt_vision, gemini_prompt_tags, gemini_prompt_hybrid,
+    gemini_system_instruction,
+    replacement_file_path, synonym_file_path, addition_file_path,
+    sort_order="Alfabetik", 
+    device: str = "Auto",
+    context_weight: float = 0.0,
+    enable_cat_for_gemini=False, selected_cats_for_gemini=None 
+):
+    if image is None: return "", "", "", "⚠️ Resim yüklenmedi.", [] 
+    
+    alert_messages = []
+    all_tags = set()
+    all_raw_tags_for_original_sort = []
+    gemini_result_text = ""
+
+    current_joint_processor = JointTaggerProcessor(replacement_file_path, synonym_file_path, addition_file_path)
+    current_cl_tagger_processor = CLTaggerProcessor(cl_tagger_instance, replacement_file_path, synonym_file_path, addition_file_path)
+    current_pixai_processor = PixaiTaggerProcessor(replacement_file_path, synonym_file_path, addition_file_path)
+    current_animetagger_processor = AnimeTaggerProcessor(replacement_file_path, synonym_file_path, addition_file_path)
+    current_gemini_processor = GeminiTaggerProcessor()
+
+    if use_joint:
+        j_raw, j_alert, j_order = current_joint_processor.predict(image, joint_thresh, replacement_file_path, synonym_file_path, addition_file_path, sort_order, device)
+        if "Hata" not in j_raw and "❌" not in j_alert:
+            all_tags.update(t.strip() for t in j_raw.split(',') if t.strip())
+            all_raw_tags_for_original_sort.extend(j_order)
+        else: alert_messages.append(f"Joint: {j_alert}")
+
+    if use_cl_tagger:
+        cl_raw, cl_alert, cl_order = current_cl_tagger_processor.predict(image, cl_gen_thresh, cl_char_thresh, replacement_file_path, synonym_file_path, addition_file_path, sort_order) 
+        if "Hata" not in cl_raw and "❌" not in cl_alert:
+            all_tags.update(t.strip() for t in cl_raw.split(',') if t.strip())
+            all_raw_tags_for_original_sort.extend(cl_order)
+        else: alert_messages.append(f"CL: {cl_alert}")
+
+    if use_pixai_tagger:
+        p_raw, p_alert, p_order = current_pixai_processor.predict(image, pixai_general_thresh, pixai_char_thresh, replacement_file_path, synonym_file_path, addition_file_path, "Orijinal", device)
+        if "Hata" not in p_raw and "❌" not in p_alert:
+            all_tags.update(t.strip() for t in p_raw.split(',') if t.strip())
+            all_raw_tags_for_original_sort.extend(p_order)
+        else: alert_messages.append(f"PixAI: {p_alert}")
+
+    if use_animetagger:
+        a_raw, a_alert, a_order = current_animetagger_processor.predict(image, animetagger_model, animetagger_thresh, replacement_file_path, synonym_file_path, addition_file_path, "Orijinal", device)
+        if "Hata" not in a_raw and "❌" not in a_alert:
+            all_tags.update(t.strip() for t in a_raw.split(',') if t.strip())
+            all_raw_tags_for_original_sort.extend(a_order)
+        else: alert_messages.append(f"AnimeTagger: {a_alert}")
+
+    combined_final_tags_string = unique_and_sort_tags(", ".join(list(all_tags)), sort_order, original_order_ref=all_raw_tags_for_original_sort)
+    
+    refined_final_tags_string = rafine_etiketler(combined_final_tags_string, context_weight)
+    
+    refined_final_tags_string = apply_additions(refined_final_tags_string, addition_file_path)
+
+    if use_gemini:
+        active_prompt = gemini_prompt_vision
+        if gemini_mode == "Tags": active_prompt = gemini_prompt_tags
+        elif gemini_mode == "Vision + Tags": active_prompt = gemini_prompt_hybrid
+            
+        tags_content_for_gemini = ""
+        if gemini_mode in ["Tags", "Vision + Tags"]:
+            source_tags = refined_final_tags_string if refined_final_tags_string else combined_final_tags_string
+            if enable_cat_for_gemini and selected_cats_for_gemini:
+                tags_content_for_gemini = kategorizelendir_ileri(source_tags, selected_cats_for_gemini, kategori_sozlugu_yukle())
+            else:
+                tags_content_for_gemini = source_tags
+        
+        g_text, g_alert = current_gemini_processor.predict(
+            image, gemini_api_key, active_prompt, gemini_mode, 
+            tags_content_for_gemini, gemini_model_id, 
+            gemini_system_instruction
+        )
+        if "❌" in g_alert or "⚠️" in g_alert: alert_messages.append(f"Gemini: {g_alert}")
+        else: gemini_result_text = g_text
+            
+    final_alert = "✅ İşlem tamamlandı!" if not alert_messages else "❌ Hatalar: " + "; ".join(alert_messages)
+
+    return combined_final_tags_string, refined_final_tags_string, gemini_result_text, final_alert, all_raw_tags_for_original_sort
+
+# --- Ana Etiketleme Fonksiyonları ---
+
+def toplu_islem(
+    image, 
+    joint_thresh, use_joint, 
+    cl_gen_thresh, cl_char_thresh, use_cl_tagger, 
+    pixai_general_thresh, pixai_char_thresh, use_pixai_tagger, 
+    animetagger_model, animetagger_thresh, use_animetagger, 
+    use_gemini, gemini_api_key, gemini_mode, gemini_model_id,
+    gemini_prompt_vision, gemini_prompt_tags, gemini_prompt_hybrid,
+    gemini_system_instruction,
+    replacement_file_path, synonym_file_path, addition_file_path,
+    enable_categorization, selected_categories, sort_order="Alfabetik", device: str = "Auto", context_weight: float = 0.0
+):
+    final_tags_string, refined_tags_string, gemini_out, alert_message, _ = _process_single_image(
+        image, 
+        joint_thresh, use_joint, 
+        cl_gen_thresh, cl_char_thresh, use_cl_tagger, 
+        pixai_general_thresh, pixai_char_thresh, use_pixai_tagger, 
+        animetagger_model, animetagger_thresh, use_animetagger, 
+        use_gemini, gemini_api_key, gemini_mode, gemini_model_id,
+        gemini_prompt_vision, gemini_prompt_tags, gemini_prompt_hybrid,
+        gemini_system_instruction,
+        replacement_file_path, synonym_file_path, addition_file_path,
+        sort_order, device, context_weight,
+        enable_cat_for_gemini=enable_categorization, selected_cats_for_gemini=selected_categories
+    )
+    
+    source_for_cat = refined_tags_string if refined_tags_string else final_tags_string
+    categorized_tags_output = kategorizelendir_ileri(source_for_cat, selected_categories, kategori_sozlugu_yukle()) if (enable_categorization and selected_categories) else ""
+    
+    parts = []
+    if categorized_tags_output: parts.append(categorized_tags_output)
+    if gemini_out: parts.append(gemini_out)
+    combined_cat_gem = ", ".join(parts)
+    
+    return alert_message, final_tags_string, refined_tags_string, categorized_tags_output, gemini_out, combined_cat_gem
+
+def toplu_islem_batch(
+    progress=gr.Progress(), images=None, 
+    joint_thresh=0.25, use_joint=True, 
+    cl_gen_thresh=0.55, cl_char_thresh=0.60, use_cl_tagger=True, 
+    pixai_general_thresh=0.30, pixai_char_thresh=0.85, use_pixai_tagger=False, 
+    animetagger_model="MobileNet V4 (Hızlı)", animetagger_thresh=0.35, use_animetagger=False, 
+    use_gemini=False, gemini_api_key="", gemini_mode="Vision", gemini_model_id="gemini-2.5-flash",
+    gemini_prompt_vision="", gemini_prompt_tags="", gemini_prompt_hybrid="",
+    gemini_system_instruction="",
+    replacement_file_path="", synonym_file_path="", addition_file_path="",
+    enable_categorization=False, selected_categories=None, sort_order="Alfabetik", device: str = "Auto", context_weight: float = 0.0
+):
+    if not images: return "⚠️ Resim yüklenmedi.", "", None, "", "", "", ""
+    all_final, all_refined, all_cat, all_orig, all_gemini, results_html, alerts = [], [], [], [], [], [], []
+    total = len(images)
+
+    for i, img_obj in enumerate(images):
+        progress(i / total, desc=f"İşleniyor: {os.path.basename(img_obj.name)} ({i+1}/{total})")
+        try: image = Image.open(img_obj.name)
+        except Exception as e: alerts.append(f"{img_obj.name}: Okuma hatası: {e}"); continue
+
+        comb, ref, gem_out, alert, orig = _process_single_image(
+            image, 
+            joint_thresh, use_joint, 
+            cl_gen_thresh, cl_char_thresh, use_cl_tagger, 
+            pixai_general_thresh, pixai_char_thresh, use_pixai_tagger, 
+            animetagger_model, animetagger_thresh, use_animetagger, 
+            use_gemini, gemini_api_key, gemini_mode, gemini_model_id,
+            gemini_prompt_vision, gemini_prompt_tags, gemini_prompt_hybrid,
+            gemini_system_instruction,
+            replacement_file_path, synonym_file_path, addition_file_path,
+            sort_order, device, context_weight,
+            enable_cat_for_gemini=enable_categorization, selected_cats_for_gemini=selected_categories
+        )
+        
+        if "❌" in alert or "⚠️" in alert: alerts.append(f"{img_obj.name}: {alert}")
+        else:
+            all_final.append(comb); all_refined.append(ref); all_orig.extend(orig)
+            if gem_out: all_gemini.append(f"--- {os.path.basename(img_obj.name)} ---\n{gem_out}")
+            
+            source = ref if ref else comb
+            cat_out = kategorizelendir_ileri(source, selected_categories, kategori_sozlugu_yukle()) if (enable_categorization and selected_categories) else ""
+            if cat_out: all_cat.append(cat_out)
+            
+            html_part = f"<div style='border:1px solid #ddd; padding:10px; margin:5px;'><b>{os.path.basename(img_obj.name)}</b><br>Tags: {ref}"
+            if gem_out: html_part += f"<br><i>Gemini: {gem_out}</i>"
+            html_part += "</div>"
+            results_html.append(html_part)
+
+    progress(1.0, desc="✅ Bitti.")
+    final_alert = "✅ Başarılı!" if not alerts else "⚠️ Hatalar:\n" + "\n".join(alerts)
+    out_file = None
+    if all_final:
+        with tempfile.NamedTemporaryFile(mode='w+', encoding='utf-8', delete=False, suffix=".txt") as tf:
+            tf.write("\n".join(all_final)); out_file = tf.name
+            
+    gemini_combined_str = "\n\n".join(all_gemini)
+    return final_alert, "<br>".join(results_html), out_file, "\n".join(all_cat), unique_and_sort_tags(", ".join(list(set(all_orig))), "Alfabetik"), unique_and_sort_tags(", ".join(all_refined), "Alfabetik"), gemini_combined_str
+
+def process_dual_images(image1, image2, joint_thresh1, use_joint1, joint_thresh2, use_joint2, cl_gen_thresh1, cl_char_thresh1, use_cl_tagger1, cl_gen_thresh2, cl_char_thresh2, use_cl_tagger2, pixai_general_thresh1, pixai_char_thresh1, use_pixai_tagger1, pixai_general_thresh2, pixai_char_thresh2, use_pixai_tagger2, animetagger_model1, animetagger_thresh1, use_animetagger1, animetagger_model2, animetagger_thresh2, use_animetagger2, 
+                        use_gemini, gemini_api_key, gemini_mode, gemini_model_id,
+                        gemini_prompt_vision, gemini_prompt_tags, gemini_prompt_hybrid,
+                        gemini_system_instruction,
+                        replacement_file_path, synonym_file_path, addition_file_path,
+                        enable_categorization_img1, selected_categories_img1, enable_categorization_img2, selected_categories_img2, sort_order="Alfabetik", device: str = "Auto", context_weight: float = 0.0):
+    images_settings = [
+        (image1, use_joint1, joint_thresh1, cl_gen_thresh1, cl_char_thresh1, use_cl_tagger1, pixai_general_thresh1, pixai_char_thresh1, use_pixai_tagger1, animetagger_model1, animetagger_thresh1, use_animetagger1, enable_categorization_img1, selected_categories_img1),
+        (image2, use_joint2, joint_thresh2, cl_gen_thresh2, cl_char_thresh2, use_cl_tagger2, pixai_general_thresh2, pixai_char_thresh2, use_pixai_tagger2, animetagger_model2, animetagger_thresh2, use_animetagger2, enable_categorization_img2, selected_categories_img2)
+    ]
+    alerts, cats, all_tags_sets, refined_sets, orig_tags, gemini_results = [], [], [], [], [], []
+    
+    for img, uj, jt, cg, cc, uc, pg, pc, up, am, at, ua, enc, selc in images_settings:
+        comb, ref, gem_out, alert, orig = _process_single_image(
+            img, jt, uj, cg, cc, uc, pg, pc, up, am, at, ua, 
+            use_gemini, gemini_api_key, gemini_mode, gemini_model_id,
+            gemini_prompt_vision, gemini_prompt_tags, gemini_prompt_hybrid,
+            gemini_system_instruction,
+            replacement_file_path, synonym_file_path, addition_file_path,
+            sort_order, device, context_weight,
+            enable_cat_for_gemini=enc, selected_cats_for_gemini=selc
+        )
+        if "❌" in alert: alerts.append(alert)
+        all_tags_sets.append(set(comb.split(', '))); refined_sets.append(set(ref.split(', '))); orig_tags.extend(orig)
+        gemini_results.append(gem_out)
+        src = ref if ref else comb
+        cats.append(kategorizelendir_ileri(src, selc, kategori_sozlugu_yukle()) if (enc and selc) else "")
+
+    combined_all = unique_and_sort_tags(", ".join(list(set().union(*all_tags_sets))), sort_order, orig_tags)
+    combined_ref = unique_and_sort_tags(", ".join(list(set().union(*refined_sets))), sort_order, orig_tags)
+    
+    combined_all = apply_additions(combined_all, addition_file_path)
+    combined_ref = apply_additions(combined_ref, addition_file_path)
+    
+    combined_cat = unique_and_sort_tags(", ".join([c for c in cats if c]), sort_order, orig_tags)
+    
+    valid_captions = [g.strip() for g in gemini_results if g and g.strip()]
+    gemini_combined_text = " ".join(valid_captions)
+
+    parts = []
+    if combined_cat: parts.append(combined_cat)
+    if gemini_combined_text: parts.append(gemini_combined_text)
+    
+    combined_cat_plus_gem = ", ".join(parts)
+    
+    return alerts, combined_all, combined_ref, combined_cat, gemini_combined_text, combined_cat_plus_gem

modules/tagger_refinement.py

@@ -0,0 +1,270 @@
+
+# modules/tagger_refinement.py
+
+import os
+import re
+import csv
+import joblib
+import numpy as np
+import pathlib
+import logging
+from collections import Counter, OrderedDict
+from lark import Lark, Token
+from lark.exceptions import ParseError
+import hnswlib
+import compress_fasttext
+from scipy.sparse import csr_matrix
+
+# --- LOGGING SETUP (Sessizleştirme) ---
+logging.basicConfig(level=logging.WARNING)
+for _name in ("gensim", "hnswlib"):
+    logging.getLogger(_name).setLevel(logging.ERROR)
+
+# --- Dosya Yolları Sabitleri (Veri ve Modeller) ---
+PATH_TF_IDF = "models/binaries/tf_idf_files_420.joblib"
+PATH_HNSW_TAGS = "models/binaries/tfidf_hnsw_tags.bin"
+PATH_FASTTEXT = "models/binaries/e621FastTextModel010Replacement_small.bin"
+PATH_DB_RATING = "data/databases/word_rating_probabilities.csv"
+PATH_DB_FLUFFYROCK = "data/databases/fluffyrock_3m.csv"
+
+# --- GLOBAL MODEL DEĞİŞKENLERİ ---
+_HNSW_TAG = None
+_HNSW_DIM = None
+_HNSW_N_TAG = None
+_TF_IDF_COMPONENTS = None
+_FASTTEXT_MODEL = None
+_TAG_DATA_CACHE = None 
+_NSFW_TAGS = None
+_ARTIST_SET = None
+
+# --- PARSER (Lark Grammar) ---
+grammar = r"""
+!start: (prompt | /[][():]/+)*
+prompt: (emphasized | plain | comma | WHITESPACE)*
+!emphasized: "(" prompt ")"
+        | "(" prompt ":" [WHITESPACE] NUMBER [WHITESPACE] ")"
+comma: ","
+WHITESPACE: /\s+/
+plain: /([^,\\\[\]():|]|\\.)+/
+%import common.SIGNED_NUMBER -> NUMBER
+"""
+parser = Lark(grammar, start='start')
+
+def load_tf_idf_components():
+    global _TF_IDF_COMPONENTS, _NSFW_TAGS, _ARTIST_SET
+    
+    if _TF_IDF_COMPONENTS is None:
+        fname = PATH_TF_IDF
+        if os.path.exists(fname):
+            try:
+                _TF_IDF_COMPONENTS = joblib.load(fname)
+                if 'tag_to_row_index' in _TF_IDF_COMPONENTS:
+                    _TF_IDF_COMPONENTS['row_to_tag'] = {idx: tag for tag, idx in _TF_IDF_COMPONENTS['tag_to_row_index'].items()}
+                idf = _TF_IDF_COMPONENTS['idf']
+                if isinstance(idf, dict):
+                    t2c = _TF_IDF_COMPONENTS['tag_to_column_index']
+                    n_cols = max(t2c.values()) + 1
+                    idf_by_col = np.ones(n_cols, dtype=np.float32)
+                    for term, col in t2c.items(): idf_by_col[col] = float(idf.get(term, 1.0))
+                    _TF_IDF_COMPONENTS['idf'] = idf_by_col
+            except Exception:
+                _TF_IDF_COMPONENTS = {}
+        else:
+            _TF_IDF_COMPONENTS = {}
+
+    if _NSFW_TAGS is None:
+        _NSFW_TAGS = set()
+        if os.path.exists(PATH_DB_RATING):
+            with open(PATH_DB_RATING, 'r', newline='', encoding='utf-8') as csvfile:
+                reader = csv.reader(csvfile); next(reader, None)
+                for row in reader:
+                    if float(row[1]) >= 0.95: _NSFW_TAGS.add(row[0])
+
+    if _ARTIST_SET is None:
+        _ARTIST_SET = set()
+        if os.path.exists(PATH_DB_FLUFFYROCK):
+            with open(PATH_DB_FLUFFYROCK, 'r', newline='', encoding='utf-8') as csvfile:
+                reader = csv.reader(csvfile)
+                for row in reader:
+                    if row[0].startswith('by_'): _ARTIST_SET.add(row[0][3:])
+
+def get_tag_data_cache():
+    global _TAG_DATA_CACHE
+    if _TAG_DATA_CACHE is None:
+        if not os.path.exists(PATH_DB_FLUFFYROCK): return None
+        def build_aliases(rev=False):
+            d = {}
+            with open(PATH_DB_FLUFFYROCK, 'r', newline='', encoding='utf-8') as f:
+                r = csv.reader(f)
+                for row in r:
+                    tag = ''.join(c for c in row[0] if ord(c)<128)
+                    alist = [] if row[3] == "null" else [''.join(c for c in alias if ord(c)<128) for alias in row[3].split(',')]
+                    if rev:
+                        for a in alist: d.setdefault(a, []).append(tag)
+                    else: d[tag] = alist
+            return d
+        def build_counts():
+            d = {}
+            with open(PATH_DB_FLUFFYROCK, 'r', newline='', encoding='utf-8') as f:
+                r = csv.reader(f)
+                for row in r:
+                    if row[2].isdigit(): d[row[0]] = int(row[2])
+            return d
+        _TAG_DATA_CACHE = {'tag2aliases': build_aliases(), 'alias2tags': build_aliases(rev=True), 'tag2count': build_counts()}
+    return _TAG_DATA_CACHE
+
+def is_artist(name):
+    load_tf_idf_components()
+    return name in _ARTIST_SET
+
+def _l2_normalize_rows(mat):
+    mat = np.asarray(mat, dtype=np.float32)
+    norms = np.linalg.norm(mat, axis=1, keepdims=True)
+    norms[norms == 0.0] = 1.0
+    return mat / norms
+
+def _ensure_hnsw_indexes():
+    global _HNSW_TAG, _HNSW_DIM, _HNSW_N_TAG
+    if _HNSW_TAG is not None: return
+    load_tf_idf_components()
+    if not _TF_IDF_COMPONENTS: return
+    reduced_matrix = _TF_IDF_COMPONENTS.get('reduced_matrix')
+    row_to_tag = _TF_IDF_COMPONENTS.get('row_to_tag')
+    if reduced_matrix is None: return
+    rm = _l2_normalize_rows(reduced_matrix).astype(np.float32)
+    n_items, dim = rm.shape
+    _HNSW_DIM = dim
+    tag_rows = []
+    for i in range(n_items):
+        tag = row_to_tag.get(i, "")
+        base = tag[3:] if tag.startswith("by_") else tag
+        if tag in {"by_unknown_artist", "by_conditional_dnp"}: tag_rows.append(i); continue
+        if not is_artist(base): tag_rows.append(i)
+    
+    tag_path = pathlib.Path(PATH_HNSW_TAGS)
+    idx = hnswlib.Index(space='cosine', dim=dim)
+    if tag_path.exists():
+        try:
+            idx.load_index(str(tag_path), max_elements=max(1, len(tag_rows)))
+            idx.set_ef(200)
+            _HNSW_TAG = idx
+            _HNSW_N_TAG = len(tag_rows)
+        except Exception: pass
+
+def _hnsw_query(vec, k=2000):
+    _ensure_hnsw_indexes()
+    if _HNSW_TAG is None: return [], []
+    q = np.asarray(vec, dtype=np.float32).reshape(-1)
+    q_norm = np.linalg.norm(q)
+    if q_norm > 0: q = q / q_norm
+    labels, dists = _HNSW_TAG.knn_query(q, k=min(k, _HNSW_N_TAG))
+    return labels[0], 1.0 - dists[0]
+
+special_tags = ["score:0", "score:1", "score:2", "score:3", "score:4", "score:5", "score:6", "score:7", "score:8", "score:9", "rating:s", "rating:q", "rating:e"]
+MODEL_SPECIFIC_TAGS = {"masterpiece", "best quality", "good quality", "normal quality", "low quality", "worst quality", "highres", "lowres", "absurdres", "source_pony", "source_furry", "rating_safe", "rating_explicit", "rating_questionable"}
+
+def remove_special_tags(original_string):
+    tags = [tag.strip() for tag in original_string.split(",")]
+    remaining = [t for t in tags if t not in special_tags]
+    return ", ".join(remaining)
+
+def extract_tags(tree):
+    tags_with_positions = []
+    def _traverse(node):
+        if isinstance(node, Token) and node.type == '__ANON_1': tags_with_positions.append((node.value, node.start_pos))
+        elif not isinstance(node, Token):
+            for child in node.children: _traverse(child)
+    _traverse(tree)
+    return tags_with_positions
+
+def construct_pseudo_vector(pseudo_doc_terms):
+    load_tf_idf_components()
+    if not _TF_IDF_COMPONENTS: return None
+    idf = _TF_IDF_COMPONENTS['idf']
+    t2c = _TF_IDF_COMPONENTS['tag_to_column_index']
+    cols, data = [], []
+    for term, w in pseudo_doc_terms.items():
+        j = t2c.get(term)
+        if j is None: continue
+        cols.append(j); data.append(w * idf[j])
+    return csr_matrix((data, cols, [0, len(cols)]), shape=(1, len(idf)), dtype=np.float32)
+
+def get_similar_tags_tfidf(pseudo_doc_terms):
+    load_tf_idf_components()
+    if not _TF_IDF_COMPONENTS: return {}
+    pseudo = construct_pseudo_vector(pseudo_doc_terms)
+    if pseudo is None: return {}
+    svd = _TF_IDF_COMPONENTS['svd_model']
+    reduced = svd.transform(pseudo)
+    top_inds, top_sims = _hnsw_query(reduced)
+    row_to_tag = _TF_IDF_COMPONENTS['row_to_tag']
+    sim_dict = {}
+    for i, sim in zip(top_inds, top_sims):
+        tag = row_to_tag.get(int(i))
+        if tag and tag not in _NSFW_TAGS: sim_dict[tag] = float(sim)
+    sorted_sim = OrderedDict(sorted(sim_dict.items(), key=lambda x: x[1], reverse=True))
+    return OrderedDict((k.replace('_', ' ').replace('(', '\\(').replace(')', '\\)'), v) for k, v in sorted_sim.items())
+
+def rafine_etiketler(tags_string, context_weight=0.5):
+    global _FASTTEXT_MODEL
+    if not tags_string or not tags_string.strip(): return ""
+    load_tf_idf_components()
+    data_cache = get_tag_data_cache()
+    if _FASTTEXT_MODEL is None and os.path.exists(PATH_FASTTEXT):
+        try: _FASTTEXT_MODEL = compress_fasttext.models.CompressedFastTextKeyedVectors.load(PATH_FASTTEXT)
+        except: pass
+    if (not _FASTTEXT_MODEL or not data_cache or not _TF_IDF_COMPONENTS) and context_weight < 0.01: return tags_string 
+
+    try:
+        input_str = remove_special_tags(tags_string.lower())
+        try: parsed = parser.parse(input_str)
+        except ParseError: return tags_string
+        raw_tags = extract_tags(parsed)
+        tag_data = []
+        for tag_text, start_pos in raw_tags:
+            mod_tag = tag_text.replace('_', ' ').replace('\\(', '(').replace('\\)', ')').strip()
+            tf_idf_tag = re.sub(r'\\([()])', r'\1', re.sub(r' ', '_', tag_text.strip().removeprefix('by ').removeprefix('by_')))
+            tag_data.append({"original_tag": tag_text, "modified_tag": mod_tag, "tf_idf_matrix_tag": tf_idf_tag})
+        
+        terms = [t["tf_idf_matrix_tag"] for t in tag_data]
+        suggested_context = {}
+        if _TF_IDF_COMPONENTS and _HNSW_TAG: suggested_context = get_similar_tags_tfidf(dict(Counter(terms)))
+        
+        valid_tags = []
+        for item in tag_data:
+            orig, mod = item["original_tag"], item["modified_tag"]
+            search = mod.replace(' ', '_')
+            if mod in special_tags or orig in MODEL_SPECIFIC_TAGS: continue 
+            if not data_cache:
+                valid_tags.append(orig); continue
+            if is_artist(search.lower().removeprefix('by_')):
+                valid_tags.append(orig); continue
+            if search in data_cache['tag2count'] or search in data_cache['tag2aliases']:
+                valid_tags.append(orig); continue
+            if not _FASTTEXT_MODEL:
+                if context_weight < 0.5: valid_tags.append(orig)
+                continue
+
+            similar_words = _FASTTEXT_MODEL.most_similar(search, topn=20)
+            candidates = []
+            seen_cand = set()
+            for sim_word, sim in similar_words:
+                 if sim_word in seen_cand: continue
+                 if sim_word in data_cache['tag2aliases']:
+                     candidates.append((sim_word.replace('_', ' '), sim)); seen_cand.add(sim_word)
+                 else:
+                     targets = data_cache['alias2tags'].get(sim_word, [])
+                     for t in targets:
+                         if t not in seen_cand: candidates.append((t.replace('_', ' '), sim)); seen_cand.add(t)
+
+            scored_candidates = []
+            for word, sim in candidates:
+                ctx_score = float(suggested_context.get(word) or suggested_context.get(word.replace('(', '\\(').replace(')', '\\)')) or 0.0)
+                final_score = (1.0 - context_weight) * sim + (context_weight * ctx_score)
+                scored_candidates.append((word, final_score))
+            scored_candidates.sort(key=lambda x: x[1], reverse=True)
+            if scored_candidates:
+                best_candidate, best_score = scored_candidates[0]
+                if best_score > 0.6: valid_tags.append(best_candidate)
+        return ", ".join(valid_tags)
+    except Exception: return tags_string

modules/taggers/anime.py

@@ -0,0 +1,91 @@
+
+import os
+import gc
+import pandas as pd
+import timm
+import torch
+from safetensors.torch import load_file
+from modules.taggers.base import TaggerProcessor
+from modules.taggers.joint import get_torch_device
+
+# --- ANIME TAGGER Global Durum ---
+ANIMETAGGER_MODEL_MAP = {
+    "mobilenetv4": {"folder": "models/anime_taggers/mobilenetv4_conv_aa_large.dbv4-full", "arch": "mobilenetv4_conv_aa_large"},
+    "convnextv2": {"folder": "models/anime_taggers/convnextv2_huge.dbv4-full", "arch": "convnextv2_huge"},
+    "caformer": {"folder": "models/anime_taggers/caformer_s36.dbv4-full", "arch": "caformer_s36"},
+    # Legacy Support
+    "MobileNet V4 (Hızlı)": {"folder": "models/anime_taggers/mobilenetv4_conv_aa_large.dbv4-full", "arch": "mobilenetv4_conv_aa_large"},
+    "ConvNeXt V2 Huge (Pro)": {"folder": "models/anime_taggers/convnextv2_huge.dbv4-full", "arch": "convnextv2_huge"},
+    "Caformer B36 (Yeni)": {"folder": "models/anime_taggers/caformer_s36.dbv4-full", "arch": "caformer_s36"},
+}
+CURRENT_ANIMETAGGER_MODEL = None
+CURRENT_ANIMETAGGER_TRANSFORM = None
+CURRENT_ANIMETAGGER_TAGS = []
+LOADED_ANIMETAGGER_KEY = None
+
+def load_animetagger_model(selection_key, device_pref: str):
+    global CURRENT_ANIMETAGGER_MODEL, CURRENT_ANIMETAGGER_TRANSFORM, CURRENT_ANIMETAGGER_TAGS, LOADED_ANIMETAGGER_KEY
+    target_device = get_torch_device(device_pref)
+    if LOADED_ANIMETAGGER_KEY == selection_key and CURRENT_ANIMETAGGER_MODEL is not None:
+        if next(CURRENT_ANIMETAGGER_MODEL.parameters()).device.type != target_device:
+            CURRENT_ANIMETAGGER_MODEL.to(target_device)
+        return True
+
+    print(f"\n--- ANIME TAGGER YÜKLENİYOR: {selection_key} ---")
+    if CURRENT_ANIMETAGGER_MODEL is not None:
+        del CURRENT_ANIMETAGGER_MODEL
+        CURRENT_ANIMETAGGER_MODEL = None
+        gc.collect()
+        if torch.cuda.is_available(): torch.cuda.empty_cache()
+
+    config = ANIMETAGGER_MODEL_MAP.get(selection_key)
+    if not config: return False
+    folder_path = config["folder"]
+    model_path = os.path.join(folder_path, "model.safetensors")
+    tags_path = os.path.join(folder_path, "selected_tags.csv")
+    if not os.path.exists(model_path) or not os.path.exists(tags_path): return False
+
+    try:
+        df = pd.read_csv(tags_path)
+        CURRENT_ANIMETAGGER_TAGS = df['name'].tolist() if 'name' in df.columns else df.iloc[:, 0].tolist()
+        model = timm.create_model(config['arch'], pretrained=False, num_classes=len(CURRENT_ANIMETAGGER_TAGS))
+        model.load_state_dict(load_file(model_path))
+        model.to(target_device).eval()
+        CURRENT_ANIMETAGGER_MODEL = model
+    except Exception as e:
+        print(f"Model yükleme hatası ({selection_key}): {e}")
+        return False
+    
+    from timm.data import resolve_data_config
+    from timm.data.transforms_factory import create_transform
+    data_config = resolve_data_config({}, model=CURRENT_ANIMETAGGER_MODEL)
+    CURRENT_ANIMETAGGER_TRANSFORM = create_transform(**data_config)
+    LOADED_ANIMETAGGER_KEY = selection_key
+    return True
+
+
+class AnimeTaggerProcessor(TaggerProcessor):
+    def predict(self, image, model_key, threshold, replacement_file_path, synonym_file_path, addition_file_path, sort_order="Alfabetik", device_pref: str = "Auto"):
+        self.replacement_file = replacement_file_path
+        self.synonym_file = synonym_file_path
+        self.addition_file = addition_file_path
+        
+        if image is None: return "", "⚠️ Resim yüklenmedi.", []
+        try:
+            if not load_animetagger_model(model_key, device_pref):
+                return "", f"❌ Anime Tagger modeli yüklenemedi: {model_key}.", []
+            target_device = get_torch_device(device_pref)
+            img = image.convert("RGB") if image.mode != "RGB" else image
+            tensor = CURRENT_ANIMETAGGER_TRANSFORM(img).unsqueeze(0).to(target_device)
+            with torch.no_grad():
+                output = CURRENT_ANIMETAGGER_MODEL(tensor)
+                probs = torch.sigmoid(output)[0].cpu().numpy()
+            results = dict(zip(CURRENT_ANIMETAGGER_TAGS, probs))
+            filtered_results = {tag: float(score) for tag, score in results.items() if score > threshold}
+            sorted_items = sorted(filtered_results.items(), key=lambda x: x[1], reverse=True)
+            original_order_for_anime = [tag.replace("_", " ") for tag, score in sorted_items]
+            raw_tags_string = ", ".join(original_order_for_anime)
+            final_tags = self.process_tags(raw_tags_string, sort_order, original_order_for_anime)
+            return final_tags, "✅ Anime Tagger işlemi tamamlandı!", original_order_for_anime
+        except Exception as e:
+            return f"Hata: {e}", f"❌ Anime Tagger hata: {e}", []

modules/taggers/base.py

@@ -0,0 +1,18 @@
+
+from modules.utils.tag_utils import clean_tags_underscore, unique_and_sort_tags
+from modules.managers.rule_manager import apply_replacements, apply_synonym_consolidation, apply_additions
+
+class TaggerProcessor:
+    def __init__(self, replacement_file_path, synonym_file_path, addition_file_path):
+        self.replacement_file = replacement_file_path
+        self.synonym_file = synonym_file_path
+        self.addition_file = addition_file_path
+        
+    def process_tags(self, raw_tags_string, sort_order="Alfabetik", original_order_ref=None):
+        cleaned = clean_tags_underscore(raw_tags_string)
+        replaced = apply_replacements(cleaned, self.replacement_file)
+        consolidated = apply_synonym_consolidation(replaced, self.synonym_file)
+        final_tags = unique_and_sort_tags(consolidated, sort_order, original_order_ref)
+        # Ekleme Kurallarını en son uygula (Listenin sonuna ekler)
+        final_tags_with_additions = apply_additions(final_tags, self.addition_file)
+        return final_tags_with_additions

modules/taggers/cl.py

@@ -0,0 +1,27 @@
+
+from modules.taggers.base import TaggerProcessor
+
+class CLTaggerProcessor(TaggerProcessor):
+    def __init__(self, cl_tagger_instance_ref, replacement_file_path, synonym_file_path, addition_file_path):
+        super().__init__(replacement_file_path, synonym_file_path, addition_file_path)
+        self.cl_tagger_ref = cl_tagger_instance_ref
+    
+    def predict(self, image, gen_threshold, char_threshold, replacement_file_path, synonym_file_path, addition_file_path, sort_order="Alfabetik", device_pref: str = "Auto"):
+        self.replacement_file = replacement_file_path
+        self.synonym_file = synonym_file_path
+        self.addition_file = addition_file_path
+        
+        if self.cl_tagger_ref is None or self.cl_tagger_ref.session is None:
+            return "", "❌ CL Tagger modülü yüklenemedi.", []
+        if image is None: return "", "⚠️ Resim yüklenmedi.", []
+        try:
+            ai_tags_string_raw, _, raw_predictions_dict = self.cl_tagger_ref.predict(image, gen_threshold, char_threshold)
+            all_raw_tags_with_probs = []
+            for category_key in ["rating", "quality", "artist", "character", "copyright", "general", "meta", "model"]:
+                all_raw_tags_with_probs.extend(raw_predictions_dict.get(category_key, []))
+            all_raw_tags_with_probs_sorted = sorted(all_raw_tags_with_probs, key=lambda x: x[1], reverse=True)
+            original_order_for_cl = [tag_name.replace("_", " ") for tag_name, _ in all_raw_tags_with_probs_sorted]
+            final_tags = self.process_tags(ai_tags_string_raw, sort_order, original_order_for_cl)
+            return final_tags, "✅ CL Tagger işlemi tamamlandı!", original_order_for_cl
+        except Exception as e:
+            return f"Hata: {e}", f"❌ CL Tagger hata: {e}", []

modules/taggers/gemini.py

@@ -0,0 +1,30 @@
+
+try:
+    import google.generativeai as genai
+    GEMINI_AVAILABLE = True
+except ImportError:
+    GEMINI_AVAILABLE = False
+
+class GeminiTaggerProcessor:
+    def predict(self, image, api_key, prompt, mode="Vision", tags_text="", model_id="gemini-2.5-flash", system_instruction=None):
+        if not GEMINI_AVAILABLE: return "Kütüphane eksik: pip install google-generativeai", "⚠️ Kütüphane eksik."
+        if not api_key: return "API Key Eksik", "⚠️ Gemini API Key girilmedi."
+        try:
+            genai.configure(api_key=api_key)
+            model = genai.GenerativeModel(
+                model_id,
+                system_instruction=system_instruction if system_instruction and system_instruction.strip() else None
+            ) 
+            
+            if mode == "Tags":
+                full_prompt = f"{prompt}\n\nEtiketler:\n{tags_text}"
+                response = model.generate_content(full_prompt)
+            elif mode == "Vision + Tags":
+                full_prompt = f"{prompt}\n\nTespit Edilen Etiketler:\n{tags_text}"
+                response = model.generate_content([full_prompt, image])
+            else:
+                response = model.generate_content([prompt, image])
+                
+            return response.text.strip(), "✅ Gemini işlemi tamamlandı!"
+        except Exception as e:
+            return f"Hata: {str(e)}", f"❌ Gemini Hatası: {str(e)}"

modules/taggers/image_utils.py

@@ -0,0 +1,126 @@
+
+import math
+import numpy as np
+import torch
+from torch import Tensor
+from einops import rearrange
+from PIL import Image, ImageCms
+from PIL.Image import Resampling
+from PIL.ImageCms import (
+    Direction, Intent, ImageCmsProfile, createProfile, getDefaultIntent, 
+    isIntentSupported, profileToProfile
+)
+from PIL.ImageOps import exif_transpose
+import timm
+
+_SRGB = createProfile(colorSpace='sRGB')
+_INTENT_FLAGS = {
+    Intent.PERCEPTUAL: ImageCms.FLAGS["HIGHRESPRECALC"],
+    Intent.RELATIVE_COLORIMETRIC: (ImageCms.FLAGS["HIGHRESPRECALC"] | ImageCms.FLAGS["BLACKPOINTCOMPENSATION"]),
+    Intent.ABSOLUTE_COLORIMETRIC: ImageCms.FLAGS["HIGHRESPRECALC"]
+}
+
+def _coalesce_intent(intent: Intent | int) -> Intent:
+    if isinstance(intent, Intent): return intent
+    mapping = {0: Intent.PERCEPTUAL, 1: Intent.RELATIVE_COLORIMETRIC, 2: Intent.SATURATION, 3: Intent.ABSOLUTE_COLORIMETRIC}
+    if intent in mapping: return mapping[intent]
+    raise ValueError("invalid intent")
+
+def process_srgb(img: Image, *, resize=None, crop=None, expect: tuple = None) -> Image:
+    img.load()
+    try: exif_transpose(img, in_place=True)
+    except Exception: pass
+    size = (img.width, img.height)
+    if expect is not None and size != expect: raise RuntimeError(f"Image size mismatch.")
+
+    if (icc_raw := img.info.get("icc_profile")) is not None:
+        try:
+            profile = ImageCmsProfile(torch.io.BytesIO(icc_raw))
+            working_mode = img.mode
+            if img.mode.startswith(("RGB", "BGR", "P")): working_mode = "RGBA" if img.has_transparency_data else "RGB"
+            elif img.mode.startswith(("L", "I", "F")) or img.mode == "1": working_mode = "LA" if img.has_transparency_data else "L"
+            if img.mode != working_mode: img = img.convert(working_mode)
+            mode = "RGBA" if img.has_transparency_data else "RGB"
+            intent = Intent.RELATIVE_COLORIMETRIC
+            if isIntentSupported(profile, intent, Direction.INPUT) != 1: intent = _coalesce_intent(getDefaultIntent(profile))
+            if (flags := _INTENT_FLAGS.get(intent)) is None: raise RuntimeError("Unsupported intent")
+            
+            if img.mode == mode: profileToProfile(img, profile, _SRGB, renderingIntent=intent, inPlace=True, flags=flags)
+            else: img = cast(Image, profileToProfile(img, profile, _SRGB, renderingIntent=intent, outputMode=mode, flags=flags))
+        except Exception: pass
+
+    if img.has_transparency_data:
+        if img.mode != "RGBa":
+            try: img = img.convert("RGBa")
+            except ValueError: img = img.convert("RGBA").convert("RGBa")
+    elif img.mode != "RGB": img = img.convert("RGB")
+
+    if crop is not None:
+        if not isinstance(crop, tuple): crop = crop(size)
+        img = img.crop(crop)
+        size = (img.width, img.height)
+
+    if resize is not None:
+        if not isinstance(resize, tuple): resize = resize(size)
+        if size != resize:
+            img = img.resize(resize, Resampling.LANCZOS, box=None, reducing_gap=3.0)
+
+    return img
+
+def put_srgb_patch(img: Image, patch_data: Tensor, patch_coord: Tensor, patch_valid: Tensor, patch_size: int) -> None:
+    if img.mode not in ("RGB", "RGBA", "RGBa"): raise ValueError(f"Image has non-RGB mode {img.mode}.")
+    patches = rearrange(np.asarray(img)[:, :, :3], "(h p1) (w p2) c -> h w (p1 p2 c)", p1=patch_size, p2=patch_size)
+    coords = np.stack(np.meshgrid(np.arange(patches.shape[0], dtype=np.int16), np.arange(patches.shape[1], dtype=np.int16), indexing="ij"), axis=-1)
+    coords = rearrange(coords, "h w c -> (h w) c")
+    patches = rearrange(patches, "h w p -> (h w) p")
+    n = patches.shape[0]
+    np.copyto(patch_data[:n].numpy(), patches, casting="no")
+    np.copyto(patch_coord[:n].numpy(), coords, casting="no")
+    patch_valid[:n] = True
+
+def sdpa_attn_mask(patch_valid: Tensor, num_prefix_tokens: int = 0, symmetric: bool = True, q_len: int | None = None, dtype: torch.dtype | None = None) -> Tensor:
+    mask = patch_valid.unflatten(-1, (1, 1, -1))
+    if num_prefix_tokens:
+        mask = torch.cat((torch.ones(*mask.shape[:-1], num_prefix_tokens, device=patch_valid.device, dtype=torch.bool), mask), dim=-1)
+    return mask
+
+# Monkey Patching Timm for NaFlexVit
+try:
+    timm.models.naflexvit.create_attention_mask = sdpa_attn_mask
+except AttributeError:
+    pass
+
+def get_image_size_for_seq(image_hw, patch_size: int = 16, max_seq_len: int = 1024, max_ratio: float = 1.0, eps: float = 1e-5) -> tuple[int, int]:
+    h, w = image_hw
+    max_py = int(max((h * max_ratio) // patch_size, 1))
+    max_px = int(max((w * max_ratio) // patch_size, 1))
+    if (max_py * max_px) <= max_seq_len: return max_py * patch_size, max_px * patch_size
+    
+    def patchify(ratio: float) -> tuple[int, int]:
+        return (min(int(math.ceil((h * ratio) / patch_size)), max_py), min(int(math.ceil((w * ratio) / patch_size)), max_px))
+
+    py, px = patchify(eps)
+    if (py * px) > max_seq_len: raise ValueError(f"Image too large.")
+    ratio = eps
+    while (max_ratio - ratio) >= eps:
+        mid = (ratio + max_ratio) / 2.0
+        mpy, mpx = patchify(mid)
+        if (mpy * mpx) > max_seq_len: max_ratio = mid
+        else:
+            ratio = mid
+            py, px = mpy, mpx
+            if (py * px) == max_seq_len: break
+    return py * patch_size, px * patch_size
+
+def process_image_jtp(img: Image, patch_size: int, max_seq_len: int) -> Image:
+    def compute_resize(wh):
+        h, w = get_image_size_for_seq((wh[1], wh[0]), patch_size, max_seq_len)
+        return w, h
+    return process_srgb(img, resize=compute_resize)
+
+def patchify_image(img: Image, patch_size: int, max_seq_len: int) -> tuple[Tensor, Tensor, Tensor]:
+    patches = torch.zeros(max_seq_len, patch_size * patch_size * 3, device="cpu", dtype=torch.uint8)
+    patch_coords = torch.zeros(max_seq_len, 2, device="cpu", dtype=torch.int16)
+    patch_valid = torch.zeros(max_seq_len, device="cpu", dtype=torch.bool)
+    put_srgb_patch(img, patches, patch_coords, patch_valid, patch_size)
+    return patches, patch_coords, patch_valid

modules/taggers/joint.py

@@ -0,0 +1,121 @@
+
+import os
+import timm
+import torch
+import huggingface_hub
+from safetensors import safe_open
+from PIL import Image
+
+from modules.hydra_layers import HydraPool
+from modules.taggers.image_utils import process_image_jtp, patchify_image
+from modules.taggers.base import TaggerProcessor
+
+# Global State
+INITIAL_TORCH_DEVICE = ["cpu", "cuda"][torch.cuda.is_available()]
+JOINT_MODEL = None
+JOINT_TAGS = []
+PATCH_SIZE = 16
+MAX_SEQ_LEN = 1024
+
+def get_torch_device(device_pref: str) -> str:
+    if device_pref == "CUDA" and torch.cuda.is_available(): return "cuda"
+    elif device_pref == "Auto" and torch.cuda.is_available(): return "cuda"
+    return "cpu"
+
+run_joint_classifier = None
+
+# Initialize Model Loading on Import (or lazily)
+# To preserve behavior, we'll try to load it immediately but wrap in try/except
+try:
+    print("Joint Tagger (JTP-3 Hydra) Yükleniyor...")
+    jtp3_path = huggingface_hub.hf_hub_download(repo_id="RedRocket/JTP-3", filename="models/jtp-3-hydra.safetensors")
+    
+    with safe_open(jtp3_path, framework="pt", device="cpu") as f:
+        metadata = f.metadata()
+        state_dict = {key: f.get_tensor(key) for key in f.keys()}
+        
+    tags = metadata["classifier.labels"].split("\n")
+    JOINT_TAGS = [t.replace("_", " ").replace("vulva", "pussy") for t in tags] 
+    
+    joint_model = timm.create_model(
+        'naflexvit_so400m_patch16_siglip',
+        pretrained=False, num_classes=0,
+        pos_embed_interp_mode="bilinear",
+        weight_init="skip", fix_init=False,
+        device="cpu", dtype=torch.bfloat16
+    )
+    
+    joint_model.attn_pool = HydraPool.for_state(state_dict, "attn_pool.", device="cpu", dtype=torch.bfloat16)
+    joint_model.head = joint_model.attn_pool.create_head()
+    joint_model.num_classes = len(tags)
+    
+    joint_model.load_state_dict(state_dict, strict=False)
+    joint_model.attn_pool._q_normed = True
+    
+    joint_model.eval().to(dtype=torch.bfloat16)
+    joint_model.to(INITIAL_TORCH_DEVICE) 
+    JOINT_MODEL = joint_model
+    
+    def run_joint_classifier_func(image: Image, threshold, execution_device: str):
+        device_for_tensor = get_torch_device(execution_device)
+        processed_img = process_image_jtp(image, PATCH_SIZE, MAX_SEQ_LEN)
+        patches, patch_coords, patch_valid = patchify_image(processed_img, PATCH_SIZE, MAX_SEQ_LEN)
+        
+        patches = patches.unsqueeze(0).to(device=device_for_tensor, non_blocking=True)
+        patch_coords = patch_coords.unsqueeze(0).to(device=device_for_tensor, non_blocking=True)
+        patch_valid = patch_valid.unsqueeze(0).to(device=device_for_tensor, non_blocking=True)
+        
+        patches = patches.to(dtype=torch.bfloat16).div_(127.5).sub_(1.0)
+        patch_coords = patch_coords.to(dtype=torch.int32)
+        
+        if next(JOINT_MODEL.parameters()).device.type != device_for_tensor:
+            JOINT_MODEL.to(device_for_tensor)
+
+        with torch.no_grad():
+            features = JOINT_MODEL.forward_intermediates(
+                patches,
+                patch_coord=patch_coords,
+                patch_valid=patch_valid,
+                output_dict=True,
+                output_fmt='NLC'
+            )
+            logits = JOINT_MODEL.forward_head(features["image_features"], patch_valid=patch_valid)
+            
+        probits = logits[0].float().sigmoid_().mul_(2.0).sub_(1.0)
+        
+        values, indices = probits.cpu().topk(len(JOINT_TAGS)) 
+        
+        raw_results = []
+        for idx, val in zip(indices, values):
+            score = val.item()
+            if score >= threshold:
+                raw_results.append((JOINT_TAGS[idx.item()], score))
+        
+        text_no_impl = ", ".join([t[0] for t in raw_results])
+        sorted_tag_score = dict(raw_results)
+        
+        return text_no_impl, sorted_tag_score
+
+    run_joint_classifier = run_joint_classifier_func
+    print(f"JTP-3 Hydra Modeli Başarıyla Yüklendi ({INITIAL_TORCH_DEVICE})")
+
+except Exception as e:
+    print(f"Joint Tagger (JTP-3) yüklenirken hata: {e}")
+    run_joint_classifier = None
+
+
+class JointTaggerProcessor(TaggerProcessor):
+    def predict(self, image, threshold, replacement_file_path, synonym_file_path, addition_file_path, sort_order="Alfabetik", device_pref: str = "Auto"):
+        self.replacement_file = replacement_file_path
+        self.synonym_file = synonym_file_path
+        self.addition_file = addition_file_path
+        
+        if run_joint_classifier is None: return "", "❌ Joint Tagger (JTP-3) yüklenemedi.", []
+        if image is None: return "", "⚠️ Resim yüklenmedi.", []
+        try:
+            ai_tags_string_raw, raw_tags_sorted_by_confidence = run_joint_classifier(image, threshold, device_pref)
+            original_order_for_joint = list(raw_tags_sorted_by_confidence.keys())
+            final_tags = self.process_tags(ai_tags_string_raw, sort_order, original_order_for_joint)
+            return final_tags, "✅ Joint (JTP-3) işlemi tamamlandı!", original_order_for_joint
+        except Exception as e:
+            return f"Hata: {e}", f"❌ Joint hata: {e}", []

modules/taggers/pixai.py

@@ -0,0 +1,104 @@
+
+import os
+import json
+import pandas as pd
+import numpy as np
+import onnxruntime as ort
+import huggingface_hub
+from PIL import Image
+from PIL.Image import Resampling
+from modules.taggers.base import TaggerProcessor
+
+# --- PIXAI Tagger Global Durum ---
+PIXAI_MODEL = None
+PIXAI_MODEL_NAME = None
+PIXAI_TAGS_DF = None
+PIXAI_D_IPS = None
+PIXAI_PREPROCESS_FUNC = None
+PIXAI_THRESHOLDS = None
+PIXAI_CATEGORY_NAMES = None
+
+def _download_pixai_files(model_name: str):
+    repo_id = model_name if '/' in model_name else f'deepghs/pixai-tagger-{model_name}-onnx'
+    return (
+        huggingface_hub.hf_hub_download(repo_id=repo_id, filename='model.onnx', library_name="pixai-tagger"),
+        huggingface_hub.hf_hub_download(repo_id=repo_id, filename='selected_tags.csv', library_name="pixai-tagger"),
+        huggingface_hub.hf_hub_download(repo_id=repo_id, filename='preprocess.json', library_name="pixai-tagger"),
+        huggingface_hub.hf_hub_download(repo_id=repo_id, filename='thresholds.csv', library_name="pixai-tagger")
+    )
+
+def _load_pixai_model_components(device_pref: str):
+    global PIXAI_MODEL, PIXAI_MODEL_NAME, PIXAI_TAGS_DF, PIXAI_D_IPS, PIXAI_PREPROCESS_FUNC, PIXAI_THRESHOLDS, PIXAI_CATEGORY_NAMES
+    model_name = 'deepghs/pixai-tagger-v0.9-onnx'
+    if PIXAI_MODEL_NAME != model_name:
+        try:
+            m_path, t_path, p_path, th_path = _download_pixai_files(model_name)
+            providers = ['CUDAExecutionProvider', 'CPUExecutionProvider'] if device_pref == "CUDA" else ['CPUExecutionProvider']
+            PIXAI_MODEL = ort.InferenceSession(m_path, providers=providers)
+            PIXAI_TAGS_DF = pd.read_csv(t_path)
+            PIXAI_D_IPS = {}
+            if 'ips' in PIXAI_TAGS_DF.columns:
+                 PIXAI_TAGS_DF['ips'] = PIXAI_TAGS_DF['ips'].apply(lambda x: json.loads(x) if pd.notna(x) and x != '{}' else {})
+            
+            def transform(img):
+                if img.mode != 'RGB': img = img.convert('RGB')
+                img = img.resize((448, 448), Resampling.LANCZOS)
+                img_array = np.array(img).astype(np.float32) / 255.0
+                mean = np.array([0.48145466, 0.4578275, 0.40821073]).astype(np.float32)
+                std = np.array([0.26862954, 0.26130258, 0.27577711]).astype(np.float32)
+                img_array = (img_array - mean) / std
+                return np.transpose(img_array, (2, 0, 1))
+
+            PIXAI_PREPROCESS_FUNC = transform
+            if th_path and os.path.exists(th_path):
+                df_th = pd.read_csv(th_path)
+                PIXAI_THRESHOLDS = {row['category']: row['threshold'] for _, row in df_th.iterrows()}
+                PIXAI_CATEGORY_NAMES = {row['category']: row['name'] for _, row in df_th.iterrows()}
+            else:
+                PIXAI_THRESHOLDS = {0: 0.3, 4: 0.85, 9: 0.85}
+                PIXAI_CATEGORY_NAMES = {0: 'general', 4: 'character', 9: 'rating'}
+            PIXAI_MODEL_NAME = model_name
+        except Exception as e: print(f"PixAI yükleme hatası: {e}"); raise
+    return PIXAI_MODEL, PIXAI_TAGS_DF, PIXAI_D_IPS, PIXAI_PREPROCESS_FUNC, PIXAI_THRESHOLDS, PIXAI_CATEGORY_NAMES
+
+def get_pixai_tags(image: Image, thresholds: dict, device_pref: str):
+    model, df_tags, _, preprocess, default_thresh, cat_names = _load_pixai_model_components(device_pref)
+    input_tensor = preprocess(image)
+    if len(input_tensor.shape) == 3: input_tensor = np.expand_dims(input_tensor, axis=0)
+    
+    out = model.run(None, {'input': input_tensor.astype(np.float32)})[0][0]
+    
+    mapped_thresh = {}
+    for cat_id, cat_name in cat_names.items():
+        if cat_name == 'general': mapped_thresh[cat_id] = thresholds.get('pixai_general_thresh', default_thresh.get(cat_id, 0.3))
+        elif cat_name in ['character', 'copyright', 'artist']: mapped_thresh[cat_id] = thresholds.get('pixai_char_thresh', default_thresh.get(cat_id, 0.85))
+        else: mapped_thresh[cat_id] = default_thresh.get(cat_id, 0.85)
+        
+    all_tags = []
+    for cat in sorted(set(df_tags['category'])):
+        mask = df_tags['category'] == cat
+        names = df_tags.loc[mask, 'name']
+        preds = out[mask]
+        thresh = mapped_thresh.get(cat, 0.85)
+        sel_mask = preds >= thresh
+        for n, s in zip(names[sel_mask], preds[sel_mask]): all_tags.append((n, float(s)))
+            
+    return ", ".join([t[0] for t in all_tags]), [t[0].replace("_", " ") for t in sorted(all_tags, key=lambda x: x[1], reverse=True)]
+
+class PixaiTaggerProcessor(TaggerProcessor):
+    def predict(self, image, pixai_general_thresh, pixai_char_thresh, replacement_file_path, synonym_file_path, addition_file_path, sort_order="Alfabetik", device_pref: str = "Auto"):
+        self.replacement_file = replacement_file_path
+        self.synonym_file = synonym_file_path
+        self.addition_file = addition_file_path
+        
+        if PIXAI_MODEL is None:
+            try: _load_pixai_model_components(device_pref)
+            except Exception as e: return "", f"❌ PixAI Tagger modülü yüklenemedi: {e}", []
+        if image is None: return "", "⚠️ Resim yüklenmedi.", []
+        try:
+            thresholds = {'pixai_general_thresh': pixai_general_thresh, 'pixai_char_thresh': pixai_char_thresh}
+            ai_tags_string_raw, original_order_for_pixai = get_pixai_tags(image, thresholds, device_pref)
+            final_tags = self.process_tags(ai_tags_string_raw, sort_order, original_order_for_pixai)
+            return final_tags, "✅ PixAI işlemi tamamlandı!", original_order_for_pixai
+        except Exception as e:
+            return f"Hata: {e}", f"❌ PixAI hata: {e}", []

modules/tools.py

@@ -0,0 +1,33 @@
+
+from modules.tools_text import (
+    clean_and_uniquify_text_simple, 
+    convert_lines_to_comma, 
+    convert_comma_to_lines, 
+    select_and_copy_random_lines, 
+    refine_text_by_file, 
+    append_text_to_wildcard_file,
+    REFINELIST_FILENAME
+)
+
+from modules.tools_image import (
+    process_brightness_contrast, 
+    process_denoise_sharpen, 
+    process_resolution_change, 
+    process_text_watermark, 
+    process_format_change
+)
+
+from modules.tools_renaming import (
+    apply_renaming_from_configlist, 
+    apply_custom_renaming
+)
+from modules.utils.file_utils import get_configlist_files
+
+# Export Everything
+__all__ = [
+    'clean_and_uniquify_text_simple', 'convert_lines_to_comma', 'convert_comma_to_lines',
+    'select_and_copy_random_lines', 'refine_text_by_file', 'process_resolution_change',
+    'apply_renaming_from_configlist', 'apply_custom_renaming', 'get_configlist_files',
+    'process_text_watermark', 'process_format_change', 'process_brightness_contrast',
+    'process_denoise_sharpen', 'append_text_to_wildcard_file', 'REFINELIST_FILENAME'
+]

modules/tools_image.py

@@ -0,0 +1,193 @@
+
+import os
+import gradio as gr
+from PIL import Image, ImageEnhance, ImageFilter, ImageDraw, ImageFont
+from modules.utils.file_utils import _get_all_image_paths
+
+def _apply_pil_enhancement(img: Image.Image, enhancer_type: ImageEnhance, level: int) -> Image.Image:
+    """PIL ImageEnhance kullanarak parlaklık veya kontrast ayarı yapar."""
+    # Level: -100'den 100'e. Factor: 0.0'dan 2.0'a (1.0 orijinal)
+    factor = (level / 100.0) + 1.0
+    factor = max(0.0, factor) 
+    enhancer = enhancer_type(img)
+    return enhancer.enhance(factor)
+
+def process_brightness_contrast(progress=gr.Progress(), folder_paths_str: str="", brightness_level: int=0, contrast_level: int=0):
+    folder_paths = [p.strip() for p in folder_paths_str.split('\n') if p.strip()]
+    if not folder_paths: return "⚠️ Klasör yolu girin.", gr.update(value="⚠️ İptal.", visible=True)
+    if brightness_level == 0 and contrast_level == 0: return "⚠️ Değişiklik yok.", gr.update(value="⚠️ İptal.", visible=True)
+
+    processed_count = 0
+    output_messages = [f"ℹ️ Parlaklık/Kontrast işlemi (P: {brightness_level}, K: {contrast_level})."]
+    all_image_paths = _get_all_image_paths(folder_paths)
+    total = len(all_image_paths)
+    
+    if total == 0: return "⚠️ Resim bulunamadı.", gr.update(value="⚠️ Resim Yok.", visible=True)
+    
+    for i, file_path in enumerate(all_image_paths):
+        filename = os.path.basename(file_path)
+        progress((i / total), desc=f"İşleniyor: {filename}")
+        try:
+            with Image.open(file_path) as img:
+                orig_mode = img.mode
+                if brightness_level != 0: img = _apply_pil_enhancement(img, ImageEnhance.Brightness, brightness_level)
+                if contrast_level != 0: img = _apply_pil_enhancement(img, ImageEnhance.Contrast, contrast_level)
+                
+                ext = os.path.splitext(filename)[1].lower()
+                if ext in ('.jpg', '.jpeg'): img.convert("RGB").save(file_path, "JPEG", quality=95)
+                elif ext == '.webp': img.save(file_path, "WEBP", lossless=True)
+                else: 
+                    if orig_mode in ('RGBA', 'P'): img.save(file_path)
+                    else: img.convert(orig_mode).save(file_path)
+                processed_count += 1
+        except Exception as e: output_messages.append(f"❌ Hata ({filename}): {e}")
+            
+    return "\n".join(output_messages), gr.update(value=f"✅ {processed_count} resim işlendi.", visible=True)
+
+def process_denoise_sharpen(progress=gr.Progress(), folder_paths_str: str="", denoise_level: int=0, sharpen_amount: float=0.0):
+    folder_paths = [p.strip() for p in folder_paths_str.split('\n') if p.strip()]
+    if not folder_paths: return "⚠️ Klasör yolu girin.", gr.update(value="⚠️ İptal.", visible=True)
+    if denoise_level == 0 and sharpen_amount == 0.0: return "⚠️ Değişiklik yok.", gr.update(value="⚠️ İptal.", visible=True)
+
+    processed_count = 0
+    output_messages = [f"ℹ️ Gürültü/Netlik işlemi (G: {denoise_level}, N: {sharpen_amount})."]
+    all_image_paths = _get_all_image_paths(folder_paths)
+    total = len(all_image_paths)
+    
+    if total == 0: return "⚠️ Resim bulunamadı.", gr.update(value="⚠️ Resim Yok.", visible=True)
+
+    for i, file_path in enumerate(all_image_paths):
+        filename = os.path.basename(file_path)
+        progress((i / total), desc=f"İşleniyor: {filename}")
+        try:
+            with Image.open(file_path) as img:
+                orig_mode = img.mode
+                if denoise_level > 0: img = img.filter(ImageFilter.MedianFilter(size=denoise_level * 2 + 1))
+                if sharpen_amount > 0.0: img = ImageEnhance.Sharpness(img).enhance(sharpen_amount)
+                
+                ext = os.path.splitext(filename)[1].lower()
+                if ext in ('.jpg', '.jpeg'): img.convert("RGB").save(file_path, "JPEG", quality=95)
+                elif ext == '.webp': img.save(file_path, "WEBP", lossless=True)
+                else: 
+                    if orig_mode in ('RGBA', 'P'): img.save(file_path)
+                    else: img.convert(orig_mode).save(file_path)
+                processed_count += 1
+        except Exception as e: output_messages.append(f"❌ Hata ({filename}): {e}")
+            
+    return "\n".join(output_messages), gr.update(value=f"✅ {processed_count} resim işlendi.", visible=True)
+
+def process_resolution_change(progress=gr.Progress(), folder_paths_str="", scale_factor=1.0):
+    folder_paths = [p.strip() for p in folder_paths_str.split('\n') if p.strip()]
+    if not folder_paths: return "⚠️ Klasör yolu girin.", gr.update(value="⚠️ İptal.", visible=True)
+    
+    scale = float(scale_factor)
+    processed_count = 0
+    output_messages = ["ℹ️ Çözünürlük değiştirme işlemi başladı."]
+    all_image_paths = _get_all_image_paths(folder_paths)
+    total = len(all_image_paths)
+    
+    if total == 0: return "⚠️ Resim bulunamadı.", gr.update(value="⚠️ Resim Yok.", visible=True)
+
+    for i, file_path in enumerate(all_image_paths):
+        filename = os.path.basename(file_path)
+        progress((i / total), desc=f"İşleniyor: {filename}")
+        try:
+            with Image.open(file_path) as img:
+                nw = int(img.width * scale)
+                nh = int(img.height * scale)
+                if abs(nw - img.width) < 1 and abs(nh - img.height) < 1: continue
+                img.resize((nw, nh), Image.Resampling.LANCZOS).save(file_path)
+                processed_count += 1
+        except Exception as e: output_messages.append(f"❌ Hata ({filename}): {e}")
+            
+    return "\n".join(output_messages), gr.update(value=f"✅ {processed_count} resim yeniden boyutlandırıldı.", visible=True)
+
+def process_text_watermark(progress=gr.Progress(), folder_paths_str="", watermark_text="", opacity=0.35, font_size_ratio=0.05, rotation_angle=-45):
+    folder_paths = [p.strip() for p in folder_paths_str.split('\n') if p.strip()]
+    if not folder_paths or not watermark_text: return "⚠️ Yol veya metin eksik.", gr.update(value="⚠️ İptal.", visible=True)
+
+    processed = 0
+    all_paths = _get_all_image_paths(folder_paths)
+    total = len(all_paths)
+    if total == 0: return "⚠️ Resim yok.", gr.update(value="⚠️ İptal.", visible=True)
+
+    font_path = "arial.ttf"
+    try: ImageFont.truetype(font_path, 10)
+    except: font_path = None # Default kullan
+
+    for i, path in enumerate(all_paths):
+        progress(i/total, desc=f"Filigran: {os.path.basename(path)}")
+        try:
+            with Image.open(path).convert("RGBA") as base:
+                W, H = base.size
+                fs = max(10, int(W * font_size_ratio))
+                font = ImageFont.truetype(font_path, fs) if font_path else ImageFont.load_default()
+                
+                # Layer oluştur
+                txt_layer = Image.new('RGBA', (W*2, H*2), (0,0,0,0))
+                draw = ImageDraw.Draw(txt_layer)
+                fill = (255, 255, 255, int(255 * opacity))
+                
+                # Metin boyutu
+                bbox = draw.textbbox((0,0), watermark_text, font=font)
+                tw, th = bbox[2]-bbox[0], bbox[3]-bbox[1]
+                
+                # Döşeme (Tiling)
+                xspace, yspace = max(50, tw*2), max(50, th*4)
+                for y in range(0, H*2, yspace):
+                    for x in range(0, W*2, xspace):
+                        draw.text((x + (y//yspace % 2)*(xspace//2), y), watermark_text, font=font, fill=fill)
+                
+                # Döndür ve Kırp
+                if rotation_angle != 0:
+                    txt_layer = txt_layer.rotate(rotation_angle, resample=Image.BICUBIC)
+                
+                cx, cy = txt_layer.width//2, txt_layer.height//2
+                final_layer = txt_layer.crop((cx - W//2, cy - H//2, cx + W//2, cy + H//2))
+                
+                base.alpha_composite(final_layer)
+                
+                ext = os.path.splitext(path)[1].lower()
+                if ext in ('.jpg', '.jpeg'): base.convert("RGB").save(path, "JPEG", quality=95)
+                else: base.save(path)
+                processed += 1
+        except Exception as e: print(f"Hata: {e}")
+
+    return "İşlem tamam.", gr.update(value=f"✅ {processed} resme filigran eklendi.", visible=True)
+
+def process_format_change(progress=gr.Progress(), folder_paths_str="", target_format=""):
+    folder_paths = [p.strip() for p in folder_paths_str.split('\n') if p.strip()]
+    if not folder_paths: return "⚠️ Yol girin.", gr.update(value="⚠️ İptal.", visible=True)
+    
+    fmt = target_format.strip().lower()
+    if fmt == '.svg': return "❌ SVG desteklenmez.", gr.update(value="❌ Hata.", visible=True)
+    
+    processed = 0
+    all_paths = _get_all_image_paths(folder_paths)
+    total = len(all_paths)
+    
+    for i, path in enumerate(all_paths):
+        progress(i/total, desc=f"Dönüştürülüyor: {os.path.basename(path)}")
+        name, ext = os.path.splitext(path)
+        if ext.lower() == fmt: continue 
+        
+        try:
+            with Image.open(path) as img:
+                new_path = f"{name}{fmt}"
+                save_fmt = "JPEG" if fmt in ('.jpg', '.jpeg') else fmt.replace('.', '').upper()
+                
+                if img.mode == 'RGBA' and save_fmt == 'JPEG':
+                    bg = Image.new('RGB', img.size, (255,255,255))
+                    bg.paste(img, mask=img.split()[3])
+                    bg.save(new_path, quality=95)
+                elif save_fmt == 'PNG':
+                    img.save(new_path) # RGBA korur
+                else:
+                    img.convert('RGB').save(new_path)
+                
+                # Eskiyi sil
+                if os.path.exists(new_path): os.remove(path)
+                processed += 1
+        except Exception as e: print(f"Hata: {e}")
+
+    return "İşlem tamam.", gr.update(value=f"✅ {processed} resim dönüştürüldü.", visible=True)

modules/tools_renaming.py

@@ -0,0 +1,94 @@
+
+import os
+import shutil
+import random
+import gradio as gr
+from modules.utils.file_utils import _get_all_image_paths
+
+def apply_renaming_from_configlist(progress=gr.Progress(), folder_paths_str="", configlist_file="", renaming_type="Rastgele"):
+    """Liste dosyasından rastgele isim seçip dosyaları adlandırır."""
+    folder_paths = [p.strip() for p in folder_paths_str.split('\n') if p.strip()]
+    if not folder_paths: return "⚠️ Klasör yolu girin.", gr.update(value="⚠️ İptal.", visible=True)
+    if not configlist_file or not os.path.exists(configlist_file): return "❌ Liste dosyası seçilmedi.", gr.update(value="❌ Hata.", visible=True)
+
+    try:
+        with open(configlist_file, 'r', encoding='utf-8') as f: name_list = [line.strip() for line in f if line.strip()]
+    except Exception as e: return f"❌ Dosya okuma hatası: {e}", gr.update(value="❌ Hata.", visible=True)
+
+    if not name_list: return "⚠️ Liste boş.", gr.update(value="⚠️ İptal.", visible=True)
+
+    output_messages = ["ℹ️ Liste bazlı adlandırma başladı."]
+    renamed_count = 0
+    all_image_paths = _get_all_image_paths(folder_paths)
+    total = len(all_image_paths)
+    
+    if total == 0: return "⚠️ Resim bulunamadı.", gr.update(value="⚠️ Resim Yok.", visible=True)
+
+    # İsim listesini karıştır (Rastgele mod ise)
+    if renaming_type == "Rastgele": random.shuffle(name_list)
+    
+    # Yeterli isim var mı?
+    if len(name_list) < total: output_messages.append("⚠️ Uyarı: İsim listesi dosya sayısından az, bazıları tekrar edebilir veya işlenmeyebilir.")
+
+    for i, file_path in enumerate(all_image_paths):
+        if i >= len(name_list): break # İsim bitti
+        filename = os.path.basename(file_path)
+        progress((i / total), desc=f"Adlandırılıyor: {filename}")
+        
+        ext = os.path.splitext(filename)[1]
+        new_base = name_list[i].replace(' ', '_').replace(',', '_')
+        new_name = f"{new_base}{ext}"
+        new_path = os.path.join(os.path.dirname(file_path), new_name)
+        
+        if file_path != new_path:
+            try:
+                shutil.move(file_path, new_path)
+                renamed_count += 1
+            except Exception as e: output_messages.append(f"❌ Hata ({filename}): {e}")
+
+    return "\n".join(output_messages), gr.update(value=f"✅ {renamed_count} dosya adlandırıldı.", visible=True)
+
+def apply_custom_renaming(progress=gr.Progress(), folder_paths_str: str="", pattern: str="", start_number: int=1, digit_count: int=3):
+    """
+    Dosyaları şablon + numara mantığıyla adlandırır.
+    Pattern içinde {Number} olmalıdır. Örn: "Adoptable {Number}"
+    """
+    folder_paths = [p.strip() for p in folder_paths_str.split('\n') if p.strip()]
+    if not folder_paths: return "⚠️ Klasör yolu girin.", gr.update(value="⚠️ İptal.", visible=True)
+    if not pattern or "{Number}" not in pattern: return "❌ Şablon '{Number}' içermelidir!", gr.update(value="❌ Hatalı Şablon.", visible=True)
+
+    renamed_count = 0
+    curr_num = int(start_number)
+    output_messages = [f"ℹ️ Şablonlu adlandırma: '{pattern}', Başlangıç: {curr_num}"]
+    
+    # Her klasör için ayrı işlem (Sıralamayı korumak için)
+    for folder in folder_paths:
+        if not os.path.isdir(folder): continue
+        images = [f for f in os.listdir(folder) if f.lower().endswith(('.png', '.jpg', '.jpeg', '.webp'))]
+        images.sort() # İsme göre sırala
+        
+        if not images: continue
+        
+        for i, img_name in enumerate(images):
+            progress(0, desc=f"Adlandırılıyor: {img_name}") # Basit progress
+            
+            ext = os.path.splitext(img_name)[1]
+            num_str = str(curr_num).zfill(int(digit_count))
+            new_base = pattern.replace("{Number}", num_str).strip()
+            new_name = f"{new_base}{ext}"
+            
+            old_path = os.path.join(folder, img_name)
+            new_path = os.path.join(folder, new_name)
+            
+            if old_path != new_path:
+                try:
+                    if os.path.exists(new_path) and old_path.lower() != new_path.lower():
+                        output_messages.append(f"⚠️ Çakışma: '{new_name}' zaten var. Atlandı.")
+                    else:
+                        shutil.move(old_path, new_path)
+                        renamed_count += 1
+                except Exception as e: output_messages.append(f"❌ Hata ({img_name}): {e}")
+            
+            curr_num += 1
+
+    return "\n".join(output_messages), gr.update(value=f"✅ {renamed_count} dosya adlandırıldı. Son No: {curr_num-1}", visible=True)

modules/tools_text.py

@@ -0,0 +1,98 @@
+
+import os
+import re
+import random
+import gradio as gr
+
+REFINELIST_PATH = "data/text_lists/RafineListesi.txt"
+REFINELIST_FILENAME = "RafineListesi.txt"
+
+def clean_and_uniquify_text_simple(text):
+    """Metni temizler, alt çizgileri boşluğa çevirir ve etiketleri tekilleştirir."""
+    if not text: return ""
+    cleaned = re.sub(r'[\s_]+', ' ', text).strip()
+    tags = {t.strip() for t in cleaned.split(',') if t.strip()}
+    return ", ".join(sorted(tags))
+
+def convert_lines_to_comma(text):
+    """Satırları virgülle ayrılmış metne çevirir."""
+    lines = [line.strip() for line in text.split('\n') if line.strip()]
+    if not lines: return "", gr.update(value="⚠️ Girişte geçerli metin bulunamadı.", visible=True)
+    return ", ".join(lines), gr.update(value="✅ Satırlar virgüllü metne çevrildi.", visible=True)
+
+def convert_comma_to_lines(text):
+     """Virgülle ayrılmış metni satırlara çevirir."""
+     lines = [line.strip() for line in text.split(',') if line.strip()]
+     if not lines: return "", gr.update(value="⚠️ Girişte geçerli metin bulunamadı.", visible=True)
+     return "\n".join(lines), gr.update(value="✅ Virgüllü metin satırlara çevrildi.", visible=True)
+
+def select_and_copy_random_lines(text_input_raw, num_lines_to_copy_slider):
+     """Metinden rastgele satırları seçer."""
+     lines = [line.strip() for line in text_input_raw.split('\n') if line.strip()]
+     num_lines = int(num_lines_to_copy_slider)
+     if not lines: return "", gr.update(value="⚠️ Girişte geçerli metin bulunamadı.", visible=True)
+     if num_lines > len(lines):
+         return "", gr.update(value=f"⚠️ {len(lines)} satır var, ancak {num_lines} satır istendi. İşlem iptal edildi.", visible=True)
+     selected = random.sample(lines, num_lines)
+     return "\n".join(selected), gr.update(value=f"✅ {num_lines} adet rastgele satır seçildi.", visible=True)
+
+def refine_text_by_file(input_text: str):
+    """Kullanıcı metnini RafineListesi.txt dosyasındaki anahtar kelimelere göre filtreler."""
+    if not input_text.strip():
+        return "", gr.update(value="⚠️ Girişte geçerli metin bulunamadı.", visible=True)
+    
+    target_path = REFINELIST_PATH 
+    try:
+        if not os.path.exists(target_path):
+            os.makedirs(os.path.dirname(target_path), exist_ok=True)
+            with open(target_path, "w", encoding="utf-8") as f: f.write("")
+            return input_text, gr.update(value=f"⚠️ Uyarı: '{target_path}' dosyası bulunamadı, boş bir dosya oluşturuldu.", visible=True)
+            
+        with open(target_path, 'r', encoding='utf-8') as f:
+            kaldirilacak_kelimeler = [satir.strip().lower() for satir in f if satir.strip()]
+            
+        if not kaldirilacak_kelimeler:
+            return input_text, gr.update(value="⚠️ Kaldırılacak kelime listesi boş.", visible=True)
+    except Exception as e:
+        return input_text, gr.update(value=f"❌ Dosya okuma hatası: {e}", visible=True)
+
+    bolumler = [b.strip() for b in re.split(r'[, \n]+', input_text) if b.strip()]
+    temiz_bolumler = []
+    kaldirilan_sayisi = 0
+
+    for bolum in bolumler:
+        bolum_kucuk_harf = bolum.lower()
+        gecerli_kalacak_mi = True
+        for kelime in kaldirilacak_kelimeler:
+            if kelime in bolum_kucuk_harf: 
+                gecerli_kalacak_mi = False; break
+        if gecerli_kalacak_mi: temiz_bolumler.append(bolum)
+        else: kaldirilan_sayisi += 1
+
+    temiz_bolumler_set = sorted(list(set(temiz_bolumler)))
+    return ', '.join(temiz_bolumler_set), gr.update(value=f"✅ {len(temiz_bolumler_set)} etiket kaldı, {kaldirilan_sayisi} etiket kaldırıldı.", visible=True)
+
+def append_text_to_wildcard_file(text, filename):
+    if not text.strip(): return gr.update(value="⚠️ Metin boş.")
+    folder = "data/wildcards"
+    os.makedirs(folder, exist_ok=True)
+    filepath = os.path.join(folder, f"{filename}.txt")
+    
+    try:
+        # Mevcut içeriği oku ve duplicate kontrolü yap
+        existing_lines = set()
+        if os.path.exists(filepath):
+            with open(filepath, "r", encoding="utf-8") as f:
+                existing_lines = {line.strip() for line in f if line.strip()}
+        
+        new_text = text.strip()
+        
+        # Eğer bu etiket listesi zaten eklenmişse uyarı ver
+        if new_text in existing_lines:
+            return gr.update(value=f"⚠️ Bu etiket listesi '{filename}' paketine zaten eklenmiş!", visible=True)
+        
+        # Eklenmemişse dosyaya ekle
+        with open(filepath, "a", encoding="utf-8") as f:
+            f.write(new_text + "\n")
+        return gr.update(value=f"✅ '{filename}' paketine eklendi.", visible=True)
+    except Exception as e: return gr.update(value=f"❌ Hata: {e}", visible=True)

modules/ui/common.py

@@ -0,0 +1,96 @@
+# modules/ui/common.py
+
+CSS_STYLES = """
+body { font-family: 'Inter', 'Segoe UI', Arial, sans-serif; background: #f0f2f5; color: #333; }
+.gradio-container { box-shadow: 0 8px 25px rgba(0, 0, 0, 0.07); border-radius: 12px; overflow: hidden; background: #ffffff; max-width: 96% !important; }
+h1, h2, h3, h4, h5, h6 { color: #2c3e50; font-weight: 600; }
+
+.tab-nav { display: flex; justify-content: center; width: 100%; }
+.gr-tab-item { padding: 15px 25px; font-size: 1.1em; font-weight: 500; }
+.gr-tab-item.selected { background: linear-gradient(45deg, #6a11cb 0%, #2575fc 100%); color: white; border-radius: 8px 8px 0 0; }
+.gr-button { border-radius: 8px; font-weight: 600; transition: all 0.3s ease; }
+.gr-button.primary { background: linear-gradient(45deg, #6a11cb 0%, #2575fc 100%); color: white; border: none; }
+.gr-button.primary:hover { opacity: 0.9; transform: translateY(-1px); }
+.gr-button.stop { background: linear-gradient(45deg, #ff4e50 0%, #f9d423 100%); color: white; border: none; }
+.gr-button.stop:hover { opacity: 0.9; transform: translateY(-1px); }
+.gr-textbox, .gr-dropdown, .gr-slider { border-radius: 8px; border: 1px solid #e0e0e0; box-shadow: inset 0 1px 3px rgba(0,0,0,0.05); }
+.gr-image, .gr-dataframe { border-radius: 8px; box-shadow: 0 4px 12px rgba(0, 0, 0, 0.06); }
+.kategori-grid-app2 { display: grid; grid-template-columns: repeat(auto-fill, minmax(280px, 1fr)); gap: 20px; padding: 10px; }
+.kategori-card-app2 { background: #ffffff; border: 1px solid #e2e8f0; border-radius: 16px; padding: 20px; box-shadow: 0 4px 6px -1px rgba(0, 0, 0, 0.1), 0 2px 4px -1px rgba(0, 0, 0, 0.06); transition: all 0.3s ease; display: flex; flex-direction: column; }
+.kategori-card-app2:hover { transform: translateY(-4px); box-shadow: 0 10px 15px -3px rgba(0, 0, 0, 0.1), 0 4px 6px -2px rgba(0, 0, 0, 0.05); border-color: #cbd5e1; }
+.kategori-title-app2 { font-size: 1.25rem; font-weight: 700; color: #1e293b; margin-bottom: 12px; border-bottom: 2px solid #f1f5f9; padding-bottom: 8px; letter-spacing: -0.025em; }
+.kategori-tags-app2 { font-size: 0.95rem; color: #475569; line-height: 1.6; font-family: 'Consolas', 'Monaco', monospace; background: #f8fafc; padding: 10px; border-radius: 8px; border: 1px solid #e2e8f0; flex-grow: 1; }
+.grid-tag { background:#fff3; display:inline-block; margin:2px 6px 2px 0; padding:5px 10px; border-radius:12px; border:1px solid #cbd5e1; font-size:14px; color:#334155; }
+#alert-box { margin-top: 15px; padding: 12px 18px; border-radius: 8px; font-weight: 600; text-align: center; }
+#alert-box[value^="✅"] { background-color: #d4edda; color: #155724; border: 1px solid #c3e6cb; }
+#alert-box[value^="⚠️"] { background-color: #fff3cd; color: #856404; border: 1px solid #ffeeba; }
+#alert-box[value^="❌"] { background-color: #f8d7da; color: #721c24; border: 1px solid #f5c6cb; }
+#alert-box[value^="🗑️"] { background-color: #e2e3e5; color: #383d41; border: 1px solid #d6d8db; }
+#renaming-alert-box { margin-top: 15px; padding: 12px 18px; border-radius: 8px; font-weight: 600; text-align: left; white-space: pre-wrap; }
+#renaming-alert-box[value^="✅"] { background-color: #d4edda; color: #155724; border: 1px solid #c3e6cb; }
+#renaming-alert-box[value^="⚠️"] { background-color: #fff3cd; color: #856404; border: 1px solid #ffeeba; }
+#renaming-alert-box[value^="❌"] { background-color: #f8d7da; color: #721c24; border: 1px solid #f5c6cb; }
+#renaming-alert-box[value^="ℹ️"] { background-color: #cce5ff; color: #004085; border: 1px solid #b8daff; }
+.gr-box { border: 1px solid #e0e0e0 !important; border-radius: 12px !important; box-shadow: 0 2px 8px rgba(0, 0, 0, 0.05) !important; }
+.gr-row, .gr-column { padding: 10px; }
+.copy-output-btn { margin-top: 10px; padding: 8px 12px; border-radius: 6px; background-color: #f0f0f0; border: 1px solid #ccc; cursor: pointer; font-weight: 500; transition: all 0.2s ease; width: 100%; }
+.copy-output-btn:hover { background-color: #e0e0e0; }
+.vertical-divider { border-left: 2px solid #e0e0e0; height: auto; margin: 0 20px; }
+
+/* --- Tab Styling Improvements --- */
+.gradio-container .tabs > .tab-nav {
+    border-bottom: 2px solid #e5e7eb;
+    margin-bottom: 20px;
+    background-color: #f8fafc;
+    border-radius: 12px 12px 0 0;
+    padding: 10px 10px 0 10px;
+    
+    /* Force single line */
+    display: flex;
+    justify-content: center; /* Or center, depending on preference */
+    flex-wrap: nowrap;
+    overflow-x: auto; /* Allow scrolling if it really doesn't fit */
+    white-space: nowrap;
+}
+
+.gradio-container .tabs > .tab-nav > button {
+    display: inline-flex;
+    justify-content: center;
+    align-items: center;
+    padding: 5px 8px; /* Reduced padding further */
+    font-size: 0.9em; /* Reduced font size further */
+    font-weight: 700 !important;
+    color: #64748b;
+    border: none;
+    background: transparent;
+    cursor: pointer;
+    transition: all 0.2s ease;
+    border-radius: 8px 8px 0 0;
+    margin-right: 2px;
+    font-family: 'Segoe UI', sans-serif;
+    letter-spacing: 0.01em;
+    flex-shrink: 0; /* Prevent squishing too much */
+}
+
+.gradio-container .tabs > .tab-nav > button:hover {
+    color: #3b82f6;
+    background-color: #e2e8f0;
+}
+
+.gradio-container .tabs > .tab-nav > button.selected {
+    color: #2563eb;
+    background-color: #ffffff;
+    border-bottom: 3px solid #2563eb;
+    box-shadow: 0 -2px 4px -1px rgba(0, 0, 0, 0.05);
+    font-size: 0.95em; /* Slightly larger than normal but smaller than before */
+    z-index: 10;
+}
+
+
+
+
+.footer-content { display: flex; justify-content: space-between; align-items: center; width: 100%; margin-top: 15px; }
+
+/* Hidden Timer Buttons */
+#timer_btn, #main_loop_btn { display: none !important; }
+"""

modules/ui/tab_batch.py

@@ -0,0 +1,87 @@
+
+# modules/ui/tab_batch.py
+
+import gradio as gr
+from modules.tagger import toplu_islem_batch
+from modules.tools import append_text_to_wildcard_file
+from modules.managers.localization_manager import get_str
+
+def create_batch_tab(settings_inputs):
+    """
+    Toplu etiketleme sekmesini oluşturur.
+    settings_inputs: create_settings_tab fonksiyonundan dönen sözlük.
+    """
+    with gr.TabItem(get_str("tab_batch_title")):
+        with gr.Row():
+            toplu_batch_process_button = gr.Button(get_str("btn_process_batch"), variant="primary", size="lg")
+
+        with gr.Row():
+            with gr.Column(scale=3):
+                toplu_batch_image_input = gr.File(label=get_str("label_batch_input"), file_count="multiple", file_types=["image"], interactive=True)
+            
+            with gr.Column(scale=7):
+                toplu_batch_alert = gr.Textbox(label=get_str("status_label"), elem_id="alert-box", interactive=False)
+                with gr.Tab(get_str("tab_batch_original")):
+                        toplu_batch_combined_original_tags = gr.Textbox(label=get_str("label_batch_original"), interactive=False, lines=15, show_copy_button=True)
+                        # --- BUTON EKLENDİ ---
+                        btn_send_toplu = gr.Button(get_str("btn_send_to_cat"), variant="secondary")
+
+                with gr.Tab(get_str("tab_batch_refined")):
+                        toplu_batch_refined_tags = gr.Textbox(label=get_str("label_batch_refined"), interactive=False, lines=15, show_copy_button=True)
+                with gr.Tab(get_str("tab_batch_cat")):
+                        toplu_batch_categorized_output = gr.Textbox(label=get_str("label_categorized_tags"), interactive=False, lines=15, show_copy_button=True)
+                        # --- WILDCARD BUTONLARI (TOPLU) ---
+                        gr.Markdown(get_str("header_wildcard"))
+                        with gr.Row():
+                            btn_female_sfw_toplu = gr.Button("FEMALE SFWPACK", size="sm")
+                            btn_female_nsfw_toplu = gr.Button("FEMALE NSFWPACK", size="sm")
+                            btn_female_nude_toplu = gr.Button("FEMALE NUDEPACK", size="sm")
+                        with gr.Row():
+                            btn_futa_sfw_toplu = gr.Button("FUTANARI SFWPACK", size="sm")
+                            btn_futa_nsfw_toplu = gr.Button("FUTANARI NSFWPACK", size="sm")
+                            btn_futa_nude_toplu = gr.Button("FUTANARI NUDEPACK", size="sm")
+                        with gr.Row():
+                            btn_furry_toplu = gr.Button("FURRY-ANTHRO", size="sm")
+                            btn_hair_toplu = gr.Button("HAIR-EYE", size="sm")
+
+                with gr.Tab(get_str("tab_batch_gemini")):
+                        toplu_batch_gemini_output = gr.Textbox(label=get_str("label_batch_gemini"), interactive=False, lines=15, show_copy_button=True)
+                with gr.Tab(get_str("tab_batch_html")):
+                    toplu_batch_results_html = gr.HTML(label=get_str("label_batch_html"))
+                
+                toplu_batch_download_button = gr.File(label=get_str("btn_batch_download"), visible=False, interactive=False)
+
+        batch_inputs = [
+            toplu_batch_image_input, 
+            settings_inputs["set_joint_thresh"], settings_inputs["set_use_joint"],
+            settings_inputs["set_cl_gen_thresh"], settings_inputs["set_cl_char_thresh"], settings_inputs["set_use_cl_tagger"],
+            settings_inputs["set_pixai_gen_thresh"], settings_inputs["set_pixai_char_thresh"], settings_inputs["set_use_pixai_tagger"],
+            settings_inputs["set_animetagger_model"], settings_inputs["set_animetagger_thresh"], settings_inputs["set_use_animetagger"],
+            # Gemini
+            settings_inputs["set_use_gemini"], settings_inputs["set_gemini_api_key"], settings_inputs["set_gemini_mode"], settings_inputs["set_gemini_model"],
+            settings_inputs["set_gemini_prompt_vision"], settings_inputs["set_gemini_prompt_tags"], settings_inputs["set_gemini_prompt_hybrid"],
+            settings_inputs["set_gemini_system_instruction"],
+            # Dosyalar
+            settings_inputs["set_replacement_file"], settings_inputs["set_synonym_file"], settings_inputs["set_addition_file"],
+            settings_inputs["set_toplu_enable_categorization"], settings_inputs["set_toplu_selected_categories"],
+            settings_inputs["set_sort_order"], settings_inputs["set_device"], settings_inputs["set_context_weight"]
+        ]
+        batch_outputs = [toplu_batch_alert, toplu_batch_results_html, toplu_batch_download_button, toplu_batch_categorized_output, toplu_batch_combined_original_tags, toplu_batch_refined_tags, toplu_batch_gemini_output]
+        toplu_batch_process_button.click(fn=toplu_islem_batch, inputs=batch_inputs, outputs=batch_outputs).then(lambda file_output: gr.update(visible=file_output is not None), inputs=[toplu_batch_download_button], outputs=[toplu_batch_download_button])
+
+        # WILDCARD EVENTLERI (TOPLU)
+        btn_female_sfw_toplu.click(fn=lambda x: append_text_to_wildcard_file(x, "FEMALE SFWPACK"), inputs=[toplu_batch_categorized_output], outputs=[toplu_batch_alert])
+        btn_female_nsfw_toplu.click(fn=lambda x: append_text_to_wildcard_file(x, "FEMALE NSFWPACK"), inputs=[toplu_batch_categorized_output], outputs=[toplu_batch_alert])
+        btn_female_nude_toplu.click(fn=lambda x: append_text_to_wildcard_file(x, "FEMALE NUDEPACK"), inputs=[toplu_batch_categorized_output], outputs=[toplu_batch_alert])
+        
+        btn_futa_sfw_toplu.click(fn=lambda x: append_text_to_wildcard_file(x, "FUTANARI SFWPACK"), inputs=[toplu_batch_categorized_output], outputs=[toplu_batch_alert])
+        btn_futa_nsfw_toplu.click(fn=lambda x: append_text_to_wildcard_file(x, "FUTANARI NSFWPACK"), inputs=[toplu_batch_categorized_output], outputs=[toplu_batch_alert])
+        btn_futa_nude_toplu.click(fn=lambda x: append_text_to_wildcard_file(x, "FUTANARI NUDEPACK"), inputs=[toplu_batch_categorized_output], outputs=[toplu_batch_alert])
+
+        btn_furry_toplu.click(fn=lambda x: append_text_to_wildcard_file(x, "FURRY-ANTHRO"), inputs=[toplu_batch_categorized_output], outputs=[toplu_batch_alert])
+        btn_hair_toplu.click(fn=lambda x: append_text_to_wildcard_file(x, "HAIR-EYE"), inputs=[toplu_batch_categorized_output], outputs=[toplu_batch_alert])
+
+        return {
+             "btn_send_toplu": btn_send_toplu,
+             "toplu_batch_combined_original_tags": toplu_batch_combined_original_tags
+        }

modules/ui/tab_dual.py

@@ -0,0 +1,97 @@
+
+# modules/ui/tab_dual.py
+
+import gradio as gr
+from modules.tagger import process_dual_images
+from modules.tools import append_text_to_wildcard_file
+from modules.managers.localization_manager import get_str
+
+def create_dual_tab(settings_inputs):
+    """
+    Dual (ikili) etiketleme sekmesini oluşturur.
+    settings_inputs: create_settings_tab fonksiyonundan dönen sözlük.
+    """
+    with gr.TabItem(get_str("tab_dual_title")):
+        gr.Markdown(get_str("dual_note"))
+        with gr.Row():
+            dual_process_button_top = gr.Button(get_str("btn_process_dual"), variant="primary", size="lg", visible=False)
+        
+        with gr.Row():
+            with gr.Column(scale=3):
+                dual_image_input1 = gr.Image(type="pil", label=get_str("label_img1"), width=300, height=300)
+                dual_image_input2 = gr.Image(type="pil", label=get_str("label_img2"), width=300, height=300)
+            
+            with gr.Column(scale=7):
+                dual_alert = gr.Textbox(label=get_str("status_label"), elem_id="alert-box", visible=False, interactive=False)
+                with gr.Tab(get_str("tab_dual_combined")):
+                    dual_combined_all_tags = gr.Textbox(label=get_str("label_dual_combined"), interactive=True, lines=8, show_copy_button=True)
+                    # --- BUTON EKLENDİ ---
+                    btn_send_dual = gr.Button(get_str("btn_send_to_cat"), variant="secondary")
+
+                with gr.Tab(get_str("tab_refined_tags")):
+                    dual_combined_refined_tags = gr.Textbox(label=get_str("label_dual_refined"), interactive=True, lines=8, show_copy_button=True)
+                with gr.Tab(get_str("tab_categorized_tags")):
+                    dual_combined_categorized_output = gr.Textbox(label=get_str("label_dual_cat"), interactive=True, lines=8, show_copy_button=True)
+                    # --- WILDCARD BUTONLARI (DUAL) ---
+                    gr.Markdown(get_str("header_wildcard"))
+                    with gr.Row():
+                        btn_female_sfw_dual = gr.Button("FEMALE SFWPACK", size="sm")
+                        btn_female_nsfw_dual = gr.Button("FEMALE NSFWPACK", size="sm")
+                        btn_female_nude_dual = gr.Button("FEMALE NUDEPACK", size="sm")
+                    with gr.Row():
+                        btn_futa_sfw_dual = gr.Button("FUTANARI SFWPACK", size="sm")
+                        btn_futa_nsfw_dual = gr.Button("FUTANARI NSFWPACK", size="sm")
+                        btn_futa_nude_dual = gr.Button("FUTANARI NUDEPACK", size="sm")
+                    with gr.Row():
+                        btn_furry_dual = gr.Button("FURRY-ANTHRO", size="sm")
+                        btn_hair_dual = gr.Button("HAIR-EYE", size="sm")
+
+                with gr.Tab(get_str("tab_gemini_caption")):
+                    with gr.Row():
+                        dual_gemini_output_img1 = gr.Textbox(label=get_str("label_gemini_img1"), interactive=True, lines=5, show_copy_button=True)
+                        dual_gemini_output_img2 = gr.Textbox(label=get_str("label_gemini_img2"), interactive=True, lines=5, show_copy_button=True)
+                with gr.Tab(get_str("tab_combined_caption")):
+                        dual_combined_cat_gem_output = gr.Textbox(label=get_str("label_combined_caption"), interactive=True, lines=10, show_copy_button=True)
+
+        dual_inputs = [
+            dual_image_input1, dual_image_input2,
+            settings_inputs["set_joint_thresh"], settings_inputs["set_use_joint"], settings_inputs["set_joint_thresh"], settings_inputs["set_use_joint"],
+            settings_inputs["set_cl_gen_thresh"], settings_inputs["set_cl_char_thresh"], settings_inputs["set_use_cl_tagger"], settings_inputs["set_cl_gen_thresh"], settings_inputs["set_cl_char_thresh"], settings_inputs["set_use_cl_tagger"],
+            settings_inputs["set_pixai_gen_thresh"], settings_inputs["set_pixai_char_thresh"], settings_inputs["set_use_pixai_tagger"], settings_inputs["set_pixai_gen_thresh"], settings_inputs["set_pixai_char_thresh"], settings_inputs["set_use_pixai_tagger"],
+            settings_inputs["set_animetagger_model"], settings_inputs["set_animetagger_thresh"], settings_inputs["set_use_animetagger"], settings_inputs["set_animetagger_model"], settings_inputs["set_animetagger_thresh"], settings_inputs["set_use_animetagger"],
+            # Gemini
+            settings_inputs["set_use_gemini"], settings_inputs["set_gemini_api_key"], settings_inputs["set_gemini_mode"], settings_inputs["set_gemini_model"],
+            settings_inputs["set_gemini_prompt_vision"], settings_inputs["set_gemini_prompt_tags"], settings_inputs["set_gemini_prompt_hybrid"],
+            settings_inputs["set_gemini_system_instruction"],
+            # Dosyalar
+            settings_inputs["set_replacement_file"], settings_inputs["set_synonym_file"], settings_inputs["set_addition_file"],
+            settings_inputs["set_dual1_enable_categorization"], settings_inputs["set_dual1_selected_categories"],
+            settings_inputs["set_dual2_enable_categorization"], settings_inputs["set_dual2_selected_categories"],
+            settings_inputs["set_sort_order"], settings_inputs["set_device"], settings_inputs["set_context_weight"] 
+        ]
+        def update_dual_outputs_wrapper(*args):
+            final_overall_alert, all_tags_str, refined_tags_str, combined_cat_tags_str, gemini_out1, gemini_out2, combined_cat_gem = process_dual_images(*args)
+            return (gr.update(value=final_overall_alert, visible=True), all_tags_str, refined_tags_str, combined_cat_tags_str, gemini_out1, gemini_out2, combined_cat_gem)
+
+        dual_process_button_top.click(fn=update_dual_outputs_wrapper, inputs=dual_inputs, outputs=[dual_alert, dual_combined_all_tags, dual_combined_refined_tags, dual_combined_categorized_output, dual_gemini_output_img1, dual_gemini_output_img2, dual_combined_cat_gem_output])
+        
+        # --- OTOMATİK TETİKLEME (RESİM DEĞİŞİNCE) ---
+        dual_image_input1.change(fn=update_dual_outputs_wrapper, inputs=dual_inputs, outputs=[dual_alert, dual_combined_all_tags, dual_combined_refined_tags, dual_combined_categorized_output, dual_gemini_output_img1, dual_gemini_output_img2, dual_combined_cat_gem_output])
+        dual_image_input2.change(fn=update_dual_outputs_wrapper, inputs=dual_inputs, outputs=[dual_alert, dual_combined_all_tags, dual_combined_refined_tags, dual_combined_categorized_output, dual_gemini_output_img1, dual_gemini_output_img2, dual_combined_cat_gem_output])
+
+        # WILDCARD EVENTLERI (DUAL)
+        btn_female_sfw_dual.click(fn=lambda x: append_text_to_wildcard_file(x, "FEMALE SFWPACK"), inputs=[dual_combined_categorized_output], outputs=[dual_alert])
+        btn_female_nsfw_dual.click(fn=lambda x: append_text_to_wildcard_file(x, "FEMALE NSFWPACK"), inputs=[dual_combined_categorized_output], outputs=[dual_alert])
+        btn_female_nude_dual.click(fn=lambda x: append_text_to_wildcard_file(x, "FEMALE NUDEPACK"), inputs=[dual_combined_categorized_output], outputs=[dual_alert])
+        
+        btn_futa_sfw_dual.click(fn=lambda x: append_text_to_wildcard_file(x, "FUTANARI SFWPACK"), inputs=[dual_combined_categorized_output], outputs=[dual_alert])
+        btn_futa_nsfw_dual.click(fn=lambda x: append_text_to_wildcard_file(x, "FUTANARI NSFWPACK"), inputs=[dual_combined_categorized_output], outputs=[dual_alert])
+        btn_futa_nude_dual.click(fn=lambda x: append_text_to_wildcard_file(x, "FUTANARI NUDEPACK"), inputs=[dual_combined_categorized_output], outputs=[dual_alert])
+
+        btn_furry_dual.click(fn=lambda x: append_text_to_wildcard_file(x, "FURRY-ANTHRO"), inputs=[dual_combined_categorized_output], outputs=[dual_alert])
+        btn_hair_dual.click(fn=lambda x: append_text_to_wildcard_file(x, "HAIR-EYE"), inputs=[dual_combined_categorized_output], outputs=[dual_alert])
+
+        return {
+             "btn_send_dual": btn_send_dual,
+             "dual_combined_all_tags": dual_combined_all_tags
+        }

modules/ui/tab_settings.py

@@ -0,0 +1,269 @@
+
+# modules/ui/tab_settings.py
+
+import os
+import gradio as gr
+from modules.config_manager import save_global_tagger_settings
+from modules.managers.rule_manager import (
+    get_replacement_files,
+    get_synonym_files,
+    get_addition_files
+)
+from modules.managers.category_manager import kategori_listesi
+from modules.managers.localization_manager import get_str # Localization import
+# cl_tagger_instance'ı kontrol etmek için (opsiyonel, main'den de geçilebilir ama import etmek daha kolay)
+from modules.tagger import cl_tagger_instance
+
+REPLACEMENT_RULES_KLASORU = "data/rules/replacement_rules"
+SYNONYM_RULES_KLASORU = "data/rules/synonym_rules"
+ADDITION_RULES_KLASORU = "data/rules/addition_rules"
+
+def create_settings_tab(app_config):
+    initial_global_settings = app_config.get("global_tagger_settings", {})
+    initial_general_settings = app_config.get("general_settings", {"device": "Auto", "language": "tr"})
+    
+    # Normalizasyon Haritaları (Legacy -> New Key)
+    sort_normalization = {
+        "Alfabetik": "alpha",
+        "Uzunluğa Göre": "length",
+        "Rastgele": "random",
+        "Orijinal": "original"
+    }
+    
+    anime_normalization = {
+        "MobileNet V4 (Hızlı)": "mobilenetv4",
+        "ConvNeXt V2 Huge (Pro)": "convnextv2",
+        "Caformer B36 (Yeni)": "caformer"
+    }
+
+    # config'den gelen değerleri normalize et
+    current_sort = initial_global_settings.get("sort_order", "alpha")
+    current_sort = sort_normalization.get(current_sort, current_sort) # Eğer map'te varsa değiştir, yoksa olduğu gibi bırak (zaten key ise)
+
+    current_anime = initial_global_settings.get("animetagger_model", "mobilenetv4")
+    current_anime = anime_normalization.get(current_anime, current_anime)
+
+    default_synonym_file = os.path.join(SYNONYM_RULES_KLASORU, "varsayilan_birlesimler.txt")
+    default_replacement_file = os.path.join(REPLACEMENT_RULES_KLASORU, "varsayilan_degisiklikler.txt")
+    default_addition_file = os.path.join(ADDITION_RULES_KLASORU, "varsayilan_eklemeler.txt")
+
+    with gr.TabItem(get_str("tab_settings_title")):
+        gr.Markdown(get_str("settings_header"))
+        
+        with gr.Row():
+            save_global_btn = gr.Button(get_str("save_settings_btn"), variant="primary", size="lg")
+            global_settings_alert = gr.Textbox(label=get_str("status_label"), elem_id="alert-box", visible=False, interactive=False)
+
+        # 1. Çalıştırma Cihazı Ayarı
+        with gr.Accordion("🖥️ Çalıştırma Cihazı Ayarı", open=False):
+            set_device = gr.Radio(["Auto", "CPU", "CUDA"], value=initial_general_settings.get("device", "Auto"), label=get_str("device_label"), info=get_str("device_info"))
+
+        # 2. Dil ve Tema Ayarı
+        with gr.Accordion("🌐 Dil ve Tema Ayarı", open=False):
+            with gr.Row():
+                set_language = gr.Dropdown(
+                    label=get_str("language_label"), 
+                    choices=[("Türkçe", "tr"), ("English", "en")], 
+                    value=initial_general_settings.get("language", "tr"),
+                    interactive=True,
+                    info=get_str("language_info")
+                )
+                set_theme = gr.Dropdown(
+                    label=get_str("theme_label"),
+                    choices=["Default", "Soft", "Glass", "Monochrome"],
+                    value=initial_general_settings.get("theme", "Default"),
+                    interactive=True,
+                    info=get_str("theme_info")
+                )
+
+        # 3. Kural Yönetimi Ayarları
+        with gr.Accordion("📜 Kural Yönetimi Ayarları", open=False):
+            set_replacement_file = gr.Dropdown(label=get_str("replacement_file_label"), choices=get_replacement_files(), value=initial_global_settings.get("replacement_file") if initial_global_settings.get("replacement_file") in get_replacement_files() else (default_replacement_file if os.path.exists(default_replacement_file) else None), interactive=True)
+            set_synonym_file = gr.Dropdown(label=get_str("synonym_file_label"), choices=get_synonym_files(), value=initial_global_settings.get("synonym_file") if initial_global_settings.get("synonym_file") in get_synonym_files() else (default_synonym_file if os.path.exists(default_synonym_file) else None), interactive=True)
+            set_addition_file = gr.Dropdown(label=get_str("addition_file_label"), choices=get_addition_files(), value=initial_global_settings.get("addition_file") if initial_global_settings.get("addition_file") in get_addition_files() else (default_addition_file if os.path.exists(default_addition_file) else None), interactive=True)
+
+        # 4. Etiket Sıralama Ayarı
+        with gr.Accordion("🔡 Etiket Sıralama Ayarı", open=False):
+            set_sort_order = gr.Radio(
+                label=get_str("sort_order_label"),
+                choices=[
+                    (get_str("sort_alpha"), "alpha"),
+                    (get_str("sort_len"), "length"),
+                    (get_str("sort_random"), "random"),
+                    (get_str("sort_orig"), "original")
+                ],
+                value=current_sort
+            )
+
+        # 5. Rafine Bağlam Ağırlığı Ayarı
+        with gr.Accordion("⚖️ Rafine Bağlam Ağırlığı Ayarı", open=False):
+            set_context_weight = gr.Slider(minimum=0.0, maximum=1.0, value=initial_global_settings.get("context_weight", 0.0), step=0.05, label=get_str("context_weight_label"), info=get_str("context_weight_info"))
+
+        # 6. Kategorizasyon Ayarları
+        with gr.Accordion("📂 Kategorizasyon Ayarları", open=False):
+            
+            with gr.Tabs():
+                with gr.TabItem(get_str("tab_single")):
+                    set_tekil_enable_categorization = gr.Checkbox(label=get_str("enable_cat_single"), value=initial_global_settings.get("tekil_enable_categorization", False))
+                    set_tekil_selected_categories = gr.Dropdown(label=get_str("cat_single_label"), choices=kategori_listesi(), multiselect=True, interactive=True, value=initial_global_settings.get("tekil_selected_categories"), visible=initial_global_settings.get("tekil_enable_categorization", False))
+                
+                with gr.TabItem(get_str("tab_batch")):
+                    set_toplu_enable_categorization = gr.Checkbox(label=get_str("enable_cat_batch"), value=initial_global_settings.get("toplu_enable_categorization", False))
+                    set_toplu_selected_categories = gr.Dropdown(label=get_str("cat_batch_label"), choices=kategori_listesi(), multiselect=True, interactive=True, value=initial_global_settings.get("toplu_selected_categories"), visible=initial_global_settings.get("toplu_enable_categorization", False))
+                
+                with gr.TabItem(get_str("tab_dual_left")):
+                    set_dual1_enable_categorization = gr.Checkbox(label=get_str("enable_cat_dual1"), value=initial_global_settings.get("dual1_enable_categorization", False))
+                    set_dual1_selected_categories = gr.Dropdown(label=get_str("cat_dual1_label"), choices=kategori_listesi(), multiselect=True, interactive=True, value=initial_global_settings.get("dual1_selected_categories"), visible=initial_global_settings.get("dual1_enable_categorization", False))
+                
+                with gr.TabItem(get_str("tab_dual_right")):
+                    set_dual2_enable_categorization = gr.Checkbox(label=get_str("enable_cat_dual2"), value=initial_global_settings.get("dual2_enable_categorization", False))
+                    set_dual2_selected_categories = gr.Dropdown(label=get_str("cat_dual2_label"), choices=kategori_listesi(), multiselect=True, interactive=True, value=initial_global_settings.get("dual2_selected_categories"), visible=initial_global_settings.get("dual2_enable_categorization", False))
+
+            set_tekil_enable_categorization.change(lambda value: gr.update(visible=value), inputs=[set_tekil_enable_categorization], outputs=[set_tekil_selected_categories])
+            set_toplu_enable_categorization.change(lambda value: gr.update(visible=value), inputs=[set_toplu_enable_categorization], outputs=[set_toplu_selected_categories])
+            set_dual1_enable_categorization.change(lambda value: gr.update(visible=value), inputs=[set_dual1_enable_categorization], outputs=[set_dual1_selected_categories])
+            set_dual2_enable_categorization.change(lambda value: gr.update(visible=value), inputs=[set_dual2_enable_categorization], outputs=[set_dual2_selected_categories])
+
+        # 7. Tagger Ayarları
+        with gr.Accordion("🤖 Tagger Ayarları", open=False):
+            with gr.Tabs():
+                with gr.TabItem("Joint Tagger"):
+                    with gr.Row():
+                        set_use_joint = gr.Checkbox(label=get_str("use_joint"), value=initial_global_settings.get("use_joint", True))
+                        set_joint_thresh = gr.Slider(minimum=0.01, maximum=1.0, value=initial_global_settings.get("joint_thresh", 0.25), step=0.01, label=get_str("joint_thresh"))
+                
+                with gr.TabItem("CL Tagger"):
+                    with gr.Row():
+                        set_use_cl_tagger = gr.Checkbox(label=get_str("use_cl"), value=initial_global_settings.get("use_cl_tagger", True), interactive=(cl_tagger_instance is not None))
+                    with gr.Row():
+                        set_cl_gen_thresh = gr.Slider(minimum=0.0, maximum=1.0, step=0.05, value=initial_global_settings.get("cl_gen_thresh", 0.55), label=get_str("cl_gen_thresh"))
+                        set_cl_char_thresh = gr.Slider(minimum=0.0, maximum=1.0, step=0.05, value=initial_global_settings.get("cl_char_thresh", 0.60), label=get_str("cl_char_thresh"))
+                
+                with gr.TabItem("PixAI Tagger"):
+                    with gr.Row():
+                        set_use_pixai_tagger = gr.Checkbox(label=get_str("use_pixai"), value=initial_global_settings.get("use_pixai_tagger", False))
+                    with gr.Row():
+                        set_pixai_gen_thresh = gr.Slider(minimum=0.0, maximum=1.0, step=0.05, value=initial_global_settings.get("pixai_general_thresh", 0.30), label=get_str("pixai_gen_thresh"))
+                        set_pixai_char_thresh = gr.Slider(minimum=0.0, maximum=1.0, step=0.05, value=initial_global_settings.get("pixai_char_thresh", 0.85), label=get_str("pixai_char_thresh"))
+
+                with gr.TabItem("Anime Tagger"):
+                    with gr.Row():
+                        set_use_animetagger = gr.Checkbox(label=get_str("use_anime"), value=initial_global_settings.get("use_animetagger", False))
+                        set_animetagger_model = gr.Dropdown(
+                            label=get_str("anime_model_label"), 
+                            choices=[
+                                (get_str("model_mobilenet"), "mobilenetv4"),
+                                (get_str("model_convnext"), "convnextv2"),
+                                (get_str("model_caformer"), "caformer")
+                            ], 
+                            value=current_anime,
+                            interactive=True
+                        )
+                    set_animetagger_thresh = gr.Slider(minimum=0.01, maximum=1.0, value=initial_global_settings.get("animetagger_thresh", 0.35), step=0.01, label=get_str("anime_thresh"))
+
+                with gr.TabItem("Gemini Caption"):
+                    gr.Markdown(get_str("gemini_desc"))
+                    set_use_gemini = gr.Checkbox(label=get_str("use_gemini"), value=initial_global_settings.get("use_gemini", False))
+                    set_gemini_api_key = gr.Textbox(label=get_str("gemini_api_key"), placeholder="AIzaSy...", type="password", value=initial_global_settings.get("gemini_api_key", ""))
+                    
+                    set_gemini_model = gr.Dropdown(
+                        label=get_str("gemini_model"),
+                        choices=["gemini-2.5-flash", "gemini-2.5-pro", "gemini-2.0-flash", "gemini-1.5-pro", "gemini-1.5-flash"],
+                        value=initial_global_settings.get("gemini_model", "gemini-2.5-flash"),
+                        interactive=True,
+                        info=get_str("gemini_model_info")
+                    )
+
+                    set_gemini_mode = gr.Radio(
+                        label=get_str("gemini_mode_label"), 
+                        choices=["Vision", "Tags", "Vision + Tags"], 
+                        value=initial_global_settings.get("gemini_mode", "Vision"), 
+                        info=get_str("gemini_mode_info")
+                    )
+                    
+                    set_gemini_system_instruction = gr.Textbox(
+                        label=get_str("gemini_system_instr"), 
+                        value=initial_global_settings.get("gemini_system_instruction", "You are a helpful assistant that generates detailed and accurate image captions for AI image generation datasets."),
+                        lines=2,
+                        placeholder="Örn: You are an expert photographer describing images...",
+                        info=get_str("gemini_system_info")
+                    )
+                    
+                    gr.Markdown(get_str("gemini_prompt_settings"))
+                    with gr.Tabs():
+                        with gr.TabItem(get_str("prompt_vision")):
+                            set_gemini_prompt_vision = gr.Textbox(
+                                label=get_str("prompt_vision"), 
+                                value=initial_global_settings.get("gemini_prompt_vision", "Describe this image in a detailed, natural language caption for an AI image generator dataset. Focus on the main subject, clothing, pose, and background. Do not use bullet points."), 
+                                lines=3
+                            )
+                        with gr.TabItem(get_str("prompt_tags")):
+                            set_gemini_prompt_tags = gr.Textbox(
+                                label=get_str("prompt_tags"), 
+                                value=initial_global_settings.get("gemini_prompt_tags", "Create a fluent, natural language caption based on the provided tags. Focus on describing the scene vividly."), 
+                                lines=3
+                            )
+                        with gr.TabItem(get_str("prompt_hybrid")):
+                            set_gemini_prompt_hybrid = gr.Textbox(
+                                label=get_str("prompt_hybrid"), 
+                                value=initial_global_settings.get("gemini_prompt_hybrid", "Describe this image using the visual details and refine the description with the provided tags for accuracy. Focus on a cohesive narrative."), 
+                                lines=3
+                            )
+
+        save_global_btn.click(fn=save_global_tagger_settings, inputs=[
+            set_device, set_language, set_theme,
+            set_use_joint, set_joint_thresh,
+            set_use_cl_tagger, set_cl_gen_thresh, set_cl_char_thresh,
+            set_use_pixai_tagger, set_pixai_gen_thresh, set_pixai_char_thresh,
+            set_use_animetagger, set_animetagger_model, set_animetagger_thresh,
+            # Gemini
+            set_use_gemini, set_gemini_api_key, set_gemini_mode, set_gemini_model,
+            set_gemini_prompt_vision, set_gemini_prompt_tags, set_gemini_prompt_hybrid,
+            set_gemini_system_instruction,
+            # Dosyalar
+            set_replacement_file, set_synonym_file, set_addition_file,
+            set_sort_order,
+            set_context_weight,
+            # Kategorizasyon
+            set_tekil_enable_categorization, set_tekil_selected_categories,
+            set_toplu_enable_categorization, set_toplu_selected_categories,
+            set_dual1_enable_categorization, set_dual1_selected_categories,
+            set_dual2_enable_categorization, set_dual2_selected_categories
+        ], outputs=global_settings_alert)
+
+        # Diğer modüllerde (tab_single, tab_batch, vb.) kullanılmak üzere bu ayarları döndürüyoruz
+        return {
+            "set_device": set_device,
+            "set_use_joint": set_use_joint,
+            "set_joint_thresh": set_joint_thresh,
+            "set_use_cl_tagger": set_use_cl_tagger,
+            "set_cl_gen_thresh": set_cl_gen_thresh,
+            "set_cl_char_thresh": set_cl_char_thresh,
+            "set_use_pixai_tagger": set_use_pixai_tagger,
+            "set_pixai_gen_thresh": set_pixai_gen_thresh,
+            "set_pixai_char_thresh": set_pixai_char_thresh,
+            "set_use_animetagger": set_use_animetagger,
+            "set_animetagger_model": set_animetagger_model,
+            "set_animetagger_thresh": set_animetagger_thresh,
+            "set_use_gemini": set_use_gemini,
+            "set_gemini_api_key": set_gemini_api_key,
+            "set_gemini_mode": set_gemini_mode,
+            "set_gemini_model": set_gemini_model,
+            "set_gemini_prompt_vision": set_gemini_prompt_vision,
+            "set_gemini_prompt_tags": set_gemini_prompt_tags,
+            "set_gemini_prompt_hybrid": set_gemini_prompt_hybrid,
+            "set_gemini_system_instruction": set_gemini_system_instruction,
+            "set_replacement_file": set_replacement_file,
+            "set_synonym_file": set_synonym_file,
+            "set_addition_file": set_addition_file,
+            "set_sort_order": set_sort_order,
+            "set_context_weight": set_context_weight,
+            "set_tekil_enable_categorization": set_tekil_enable_categorization,
+            "set_tekil_selected_categories": set_tekil_selected_categories,
+            "set_toplu_enable_categorization": set_toplu_enable_categorization,
+            "set_toplu_selected_categories": set_toplu_selected_categories,
+            "set_dual1_enable_categorization": set_dual1_enable_categorization,
+            "set_dual1_selected_categories": set_dual1_selected_categories,
+            "set_dual2_enable_categorization": set_dual2_enable_categorization,
+            "set_dual2_selected_categories": set_dual2_selected_categories
+        }

modules/ui/tab_single.py

@@ -0,0 +1,148 @@
+
+# modules/ui/tab_single.py
+
+import gradio as gr
+from modules.tagger import toplu_islem
+from modules.managers.localization_manager import get_str
+from modules.tools import append_text_to_wildcard_file
+
+
+# JS Timer main.py üzerinden yönetiliyor
+
+
+import base64
+import io
+from PIL import Image
+from modules.shared_state import get_web_image, reset_image_event
+
+
+def fetch_web_image(last_known_ts):
+    """Shared state'den son gelen web resmini kontrol eder. Yeni ise döndürür."""
+    data, timestamp = get_web_image()
+    
+    # Henüz veri yoksa veya veri eskiyse (zaten işlendiyse) işlem yapma
+    if not data or timestamp == last_known_ts:
+        return gr.update(), gr.update(), last_known_ts
+
+    try:
+        if "," in data: data = data.split(",")[1]
+        
+        image_data = base64.b64decode(data)
+        image = Image.open(io.BytesIO(image_data))
+        
+        # Resmi başarılı şekilde aldık, yeni timestamp'i döndür
+        reset_image_event() # Flag'i sıfırla ki JS tekrar basmasın
+        return image, "✅ Web'den yeni resim alındı!", timestamp
+    except Exception as e:
+        return gr.update(), f"❌ Hata: {str(e)}", last_known_ts
+
+def create_single_tab(settings_inputs):
+    """
+    Tekil etiketleme sekmesini oluşturur.
+    settings_inputs: create_settings_tab fonksiyonundan dönen sözlük.
+    """
+    with gr.TabItem(get_str("tab_single_title"), id="tab_single"):
+        with gr.Row():
+            tekil_process_button_top = gr.Button(get_str("btn_process_single"), variant="primary", size="lg", visible=False)
+        
+        with gr.Row():
+            with gr.Column(scale=3):
+                # Manuel buton artık gereksiz olduğu için gizlendi (Otomatik çalışıyor)
+                btn_get_from_web = gr.Button("🌐 Web'den Yapıştır (Eklenti)", variant="secondary", size="sm", visible=False)
+                toplu_image_input = gr.Image(type="pil", label=get_str("label_image_upload"), width=512, height=512)
+            
+            with gr.Column(scale=7):
+                toplu_alert = gr.Textbox(label=get_str("status_label"), elem_id="alert-box", visible=False, interactive=False)
+                
+                with gr.Tab(get_str("tab_raw_tags")):
+                    toplu_filtered_output = gr.Textbox(label=get_str("label_unique_tags"), interactive=True, lines=10, show_copy_button=True)
+                    # --- BUTON EKLENDİ ---
+                    btn_send_tekil = gr.Button(get_str("btn_send_to_cat"), variant="secondary")
+
+
+                with gr.Tab(get_str("tab_refined_tags")): 
+                    tekil_refined_output = gr.Textbox(label=get_str("label_refined_tags"), interactive=True, lines=10, show_copy_button=True)
+                with gr.Tab(get_str("tab_categorized_tags")):
+                    tekil_categorized_output = gr.Textbox(label=get_str("label_categorized_tags"), interactive=False, lines=10, show_copy_button=True)
+                    # --- WILDCARD BUTONLARI (TEKİL) ---
+                    gr.Markdown(get_str("header_wildcard"))
+                    with gr.Row():
+                        btn_female_sfw_tekil = gr.Button("FEMALE SFWPACK", size="sm")
+                        btn_female_nsfw_tekil = gr.Button("FEMALE NSFWPACK", size="sm")
+                        btn_female_nude_tekil = gr.Button("FEMALE NUDEPACK", size="sm")
+                    with gr.Row():
+                        btn_futa_sfw_tekil = gr.Button("FUTANARI SFWPACK", size="sm")
+                        btn_futa_nsfw_tekil = gr.Button("FUTANARI NSFWPACK", size="sm")
+                        btn_futa_nude_tekil = gr.Button("FUTANARI NUDEPACK", size="sm")
+                    with gr.Row():
+                        btn_furry_tekil = gr.Button("FURRY-ANTHRO", size="sm")
+                        btn_hair_tekil = gr.Button("HAIR-EYE", size="sm")
+
+                with gr.Tab(get_str("tab_gemini_caption")):
+                        tekil_gemini_output = gr.Textbox(label=get_str("label_gemini_caption"), interactive=True, lines=5, show_copy_button=True)
+                with gr.Tab(get_str("tab_combined_caption")):
+                        tekil_combined_cat_gem_output = gr.Textbox(label=get_str("label_combined_caption"), interactive=True, lines=10, show_copy_button=True)
+        
+        # --- OTOMATİK KONTROL İÇİN STATE VE TIMER BUTTON ---
+        ts_state = gr.State(value=0) # Son işlenen resmin zaman damgası
+        
+        # Gradio 3.x uyumlu Timer alternatifi: JS ile tıklanan buton
+        # Butonu visible=True yapıp style ile gizliyoruz ki JS bulabilsin
+        timer_btn = gr.Button("Timer", elem_id="timer_btn", visible=True) 
+        # CSS ile gizle: #timer_btn { display: none !important; } (Bunu common.py'ye veya inline css'e ekleyeceğiz)
+
+        
+        inputs_for_tekil = [
+            toplu_image_input, 
+            settings_inputs["set_joint_thresh"], settings_inputs["set_use_joint"],
+            settings_inputs["set_cl_gen_thresh"], settings_inputs["set_cl_char_thresh"], settings_inputs["set_use_cl_tagger"],
+            settings_inputs["set_pixai_gen_thresh"], settings_inputs["set_pixai_char_thresh"], settings_inputs["set_use_pixai_tagger"],
+            settings_inputs["set_animetagger_model"], settings_inputs["set_animetagger_thresh"], settings_inputs["set_use_animetagger"], 
+            # Gemini
+            settings_inputs["set_use_gemini"], settings_inputs["set_gemini_api_key"], settings_inputs["set_gemini_mode"], settings_inputs["set_gemini_model"],
+            settings_inputs["set_gemini_prompt_vision"], settings_inputs["set_gemini_prompt_tags"], settings_inputs["set_gemini_prompt_hybrid"],
+            settings_inputs["set_gemini_system_instruction"],
+            # Dosyalar
+            settings_inputs["set_replacement_file"], settings_inputs["set_synonym_file"], settings_inputs["set_addition_file"],
+            settings_inputs["set_tekil_enable_categorization"], settings_inputs["set_tekil_selected_categories"],
+            settings_inputs["set_sort_order"], settings_inputs["set_device"], settings_inputs["set_context_weight"] 
+        ]
+        outputs_for_tekil = [toplu_alert, toplu_filtered_output, tekil_refined_output, tekil_categorized_output, tekil_gemini_output, tekil_combined_cat_gem_output]
+        # Button click event'i (Artık gizli ama kod yapısı bozulmasın diye tutuyoruz)
+        tekil_process_button_top.click(fn=toplu_islem, inputs=inputs_for_tekil, outputs=outputs_for_tekil)
+        
+        # --- OTOMATİK TETİKLEME (RESİM DEĞİŞİNCE) ---
+        toplu_image_input.change(fn=toplu_islem, inputs=inputs_for_tekil, outputs=outputs_for_tekil)
+
+        
+        # Web'den resim alma eventi (JS Tetiklemeli)
+        timer_btn.click(
+            fn=fetch_web_image,
+            inputs=[ts_state],
+            outputs=[toplu_image_input, toplu_alert, ts_state],
+            show_progress="hidden" # Yükleniyor animasyonu gizlendi
+        )
+
+        # MANUEL BUTON
+        btn_get_from_web.click(
+            fn=fetch_web_image,
+            inputs=[ts_state],
+            outputs=[toplu_image_input, toplu_alert, ts_state]
+        )
+
+        # WILDCARD EVENTLERI (TEKİL)
+        btn_female_sfw_tekil.click(fn=lambda x: append_text_to_wildcard_file(x, "FEMALE SFWPACK"), inputs=[tekil_categorized_output], outputs=[toplu_alert])
+        btn_female_nsfw_tekil.click(fn=lambda x: append_text_to_wildcard_file(x, "FEMALE NSFWPACK"), inputs=[tekil_categorized_output], outputs=[toplu_alert])
+        btn_female_nude_tekil.click(fn=lambda x: append_text_to_wildcard_file(x, "FEMALE NUDEPACK"), inputs=[tekil_categorized_output], outputs=[toplu_alert])
+        
+        btn_futa_sfw_tekil.click(fn=lambda x: append_text_to_wildcard_file(x, "FUTANARI SFWPACK"), inputs=[tekil_categorized_output], outputs=[toplu_alert])
+        btn_futa_nsfw_tekil.click(fn=lambda x: append_text_to_wildcard_file(x, "FUTANARI NSFWPACK"), inputs=[tekil_categorized_output], outputs=[toplu_alert])
+        btn_futa_nude_tekil.click(fn=lambda x: append_text_to_wildcard_file(x, "FUTANARI NUDEPACK"), inputs=[tekil_categorized_output], outputs=[toplu_alert])
+
+        btn_furry_tekil.click(fn=lambda x: append_text_to_wildcard_file(x, "FURRY-ANTHRO"), inputs=[tekil_categorized_output], outputs=[toplu_alert])
+        btn_hair_tekil.click(fn=lambda x: append_text_to_wildcard_file(x, "HAIR-EYE"), inputs=[tekil_categorized_output], outputs=[toplu_alert])
+
+        return {
+            "btn_send_tekil": btn_send_tekil,
+            "toplu_filtered_output": toplu_filtered_output
+        }

modules/ui/tab_tools.py

@@ -0,0 +1,69 @@
+
+# modules/ui/tab_tools.py
+
+import os
+import gradio as gr
+from modules.prompt_generator import create_prompt_generator_ui
+from modules.video_creator import create_video_ui
+
+# New Component Imports
+from modules.ui.tools.category_ui import create_category_ui
+from modules.ui.tools.rule_ui import create_rule_ui
+from modules.ui.tools.text_ui import create_text_ui
+from modules.ui.tools.image_ui import create_image_ui
+from modules.ui.tools.art_ui import create_art_ui
+from modules.localization.languages import get_str
+
+REPLACEMENT_RULES_KLASORU = "data/rules/replacement_rules"
+SYNONYM_RULES_KLASORU = "data/rules/synonym_rules"
+ADDITION_RULES_KLASORU = "data/rules/addition_rules"
+
+def create_tools_tab(app_config):
+    initial_image_tools_settings = app_config.get("image_tools_settings", {})
+    initial_global_settings = app_config.get("global_tagger_settings", {})
+
+    default_synonym_file = os.path.join(SYNONYM_RULES_KLASORU, "varsayilan_birlesimler.txt")
+    default_replacement_file = os.path.join(REPLACEMENT_RULES_KLASORU, "varsayilan_degisiklikler.txt")
+    default_addition_file = os.path.join(ADDITION_RULES_KLASORU, "varsayilan_eklemeler.txt")
+
+    # --- 1. KATEGORİ ARAÇLARI ---
+    with gr.TabItem(get_str("tab_category_tools"), id="tab_kategori_araclari"):
+        with gr.Tabs() as tabs_kategori_ic:
+            # Common input is now created inside create_category_ui
+            etiket_input_common = create_category_ui(tabs_kategori_ic)
+
+    # --- 2. RESİM ARAÇLARI ---
+    with gr.TabItem(get_str("tab_image_tools")):
+        create_image_ui(initial_image_tools_settings)
+
+    # --- 3. METİN ARAÇLARI ---
+    with gr.TabItem(get_str("tab_text_tools")):
+        create_text_ui()
+
+    # --- 4. PROMPT OLUŞTURUCU ---
+    with gr.TabItem(get_str("tab_prompt_gen")):
+        create_prompt_generator_ui()
+
+    # --- 5. VIDEO CREATOR ---
+    with gr.TabItem(get_str("tab_video_creator")):
+        create_video_ui()
+
+    # --- 6. SANAT STÜDYOSU ---
+    with gr.TabItem(get_str("tab_art_studio")):
+        create_art_ui()
+
+    # --- 7. KURAL YÖNETİMİ ---
+    with gr.TabItem(get_str("tab_rule_management")):
+        replacement_file_content, synonym_file_content, addition_file_content = create_rule_ui(
+            initial_global_settings, 
+            default_replacement_file, 
+            default_synonym_file, 
+            default_addition_file
+        )
+
+    return {
+        "etiket_input_common": etiket_input_common,
+        "replacement_file_content": replacement_file_content,
+        "synonym_file_content": synonym_file_content,
+        "addition_file_content": addition_file_content
+    }

modules/ui/tools/art_ui.py

@@ -0,0 +1,50 @@
+import gradio as gr
+from modules.art_tools import create_grid_collage
+from modules.localization.languages import get_str
+from modules.config_manager import save_art_tools_settings, load_config
+
+def create_art_ui():
+    # Ayarları Yükle
+    config = load_config()
+    art_settings = config.get("art_tools_settings", {})
+
+    with gr.Tabs():
+        with gr.TabItem(get_str("art_tab_grid")):
+            with gr.Row():
+                with gr.Column():
+                    grid_files = gr.File(label=get_str("art_file_input"), file_count="multiple", file_types=["image"])
+                    with gr.Accordion(get_str("art_grid_settings"), open=True):
+                        grid_cols = gr.Slider(minimum=1, maximum=5, value=art_settings.get("grid_cols", 3), step=1, label=get_str("art_cols"))
+                        grid_bg_color = gr.ColorPicker(value=art_settings.get("grid_bg_color", "#000000"), label="Arka Plan Rengi")
+
+                    with gr.Accordion("Banner & Yazı Ayarları", open=True):
+                        with gr.Row():
+                            grid_title_text = gr.Textbox(value=art_settings.get("grid_title_text", "ADOPTABLE SALE!"), label="Banner Başlığı")
+                        with gr.Row():
+                            grid_banner_color = gr.ColorPicker(value=art_settings.get("grid_banner_color", "#000000"), label="Banner Arka Planı")
+                            grid_title_color = gr.ColorPicker(value=art_settings.get("grid_title_color", "#FFD700"), label="Başlık Rengi (Gold)")
+                    
+                    with gr.Accordion(get_str("art_label_settings"), open=True):
+                        grid_add_labels = gr.Checkbox(label=get_str("art_add_labels_check"), value=art_settings.get("grid_add_labels", True))
+                        grid_label_type = gr.Dropdown(["Numara (#1, #2...)", "Sadece Numaralar"], value=art_settings.get("grid_label_type", "Numara (#1, #2...)"), label=get_str("art_label_type"))
+                        grid_start_num = gr.Number(value=art_settings.get("grid_start_num", 1), label=get_str("art_start_num"), precision=0)
+                    
+                    with gr.Row():
+                        grid_btn = gr.Button(get_str("art_create_btn"), variant="primary", scale=2)
+                        save_art_btn = gr.Button("💾 Ayarları Kaydet", variant="secondary", scale=1)
+                
+                with gr.Column():
+                    grid_output = gr.Image(type="pil", label=get_str("art_output"))
+                    grid_status = gr.Textbox(label=get_str("status_label"), interactive=False)
+            
+            grid_btn.click(
+                fn=create_grid_collage,
+                inputs=[grid_files, grid_cols, grid_add_labels, grid_label_type, grid_start_num, grid_bg_color, grid_title_text, grid_banner_color, grid_title_color],
+                outputs=[grid_output, grid_status]
+            )
+            
+            save_art_btn.click(
+                fn=save_art_tools_settings,
+                inputs=[grid_cols, grid_bg_color, grid_title_text, grid_banner_color, grid_title_color, grid_add_labels, grid_label_type, grid_start_num],
+                outputs=[grid_status]
+            )

modules/ui/tools/category_ui.py

@@ -0,0 +1,82 @@
+import gradio as gr
+from modules.managers.category_manager import (
+    kategori_listesi,
+    filter_and_display_main_categorized_tags,
+    kategorileri_grid_html,
+    grid_guncelle,
+    etiket_ekle,
+    etiket_sil
+)
+from modules.localization.languages import get_str
+
+def create_category_ui(tabs_kategori_ic):
+    
+    # --- 1. SEKME: CANLI TEST (LIVE TEST) ---
+    with gr.TabItem(get_str("cat_redesign_live_tab"), id="tab_cat_live"):
+        
+        # Giriş Alanı (Buraya taşındı, sadece bu sekmede görünsün diye)
+        etiket_input_common = gr.Textbox(lines=5, label=get_str("label_tags_input"), interactive=True, placeholder=get_str("placeholder_tags_input"))
+
+        # Butonlar (Yan Yana)
+        with gr.Row():
+            main_cat_button = gr.Button(get_str("cat_live_main_btn"), variant="primary", scale=1) # Ana Kategoriye Göre
+        
+        # Transfer Butonu (Sonuçların üstünde)
+        btn_transfer_unmatched = gr.Button(get_str("cat_live_unmatched_btn"), variant="stop", visible=False)
+        hidden_unmatched_tags = gr.Textbox(visible=False)
+        
+        gr.Markdown("<h3 style='text-align: center; margin-bottom: 20px;'>🔍 Sonuçlar</h3>")
+        main_html_output = gr.HTML(label=get_str("cat_live_main_output"), min_height=200)
+
+        # Event Bağlantıları (Canlı Test)
+        def kategorize_ve_buton_kontrol(tags):
+            html, unmatched = filter_and_display_main_categorized_tags(tags, None) 
+            return html, unmatched, gr.update(visible=bool(unmatched)), gr.update(visible=True)
+
+        main_cat_button.click(
+            fn=kategorize_ve_buton_kontrol, 
+            inputs=[etiket_input_common], 
+            outputs=[main_html_output, hidden_unmatched_tags, btn_transfer_unmatched, main_html_output]
+        )
+
+        def transfer_et_ve_gec(unmatched_text):
+            # Ana Yönetim sekmesine geçiş yap ve input kutusunu doldur
+            return (
+                unmatched_text,                          
+                gr.Tabs(selected="tab_cat_main"), 
+            )
+
+    # --- 2. SEKME: ANA KATEGORİ YÖNETİMİ ---
+    with gr.TabItem(get_str("cat_redesign_main_tab"), id="tab_cat_main"):
+        
+        # Üst Panel: Yönetim
+        with gr.Group():
+            with gr.Row(variant="panel"):
+                with gr.Column(scale=1):
+                    kategori_dd = gr.Dropdown(choices=kategori_listesi(), label="Kategori Seç / Select Category", interactive=True)
+                with gr.Column(scale=3):
+                    with gr.Row():
+                        etik_giris = gr.Textbox(label="Etiket Ekle/Sil (Virgül ile ayırın)", interactive=True, scale=3)
+                        with gr.Column(scale=1, min_width=150):
+                            btn_etik_ekle = gr.Button(get_str("btn_add"), variant="primary", scale=1)
+                            btn_etik_sil = gr.Button(get_str("btn_delete"), variant="stop", scale=1)
+                
+            alert = gr.Textbox(label=get_str("status_label"), elem_id="alert-box", visible=False)
+
+        # Alt Panel: Grid Görünümü
+        gr.Markdown("<h3 style='text-align: center; margin-bottom: 20px;'>📂 Tüm Kategoriler</h3>")
+        
+        grid_out = gr.HTML(value=kategorileri_grid_html())
+
+        # Event Bağlantıları (Ana Yönetim)
+        btn_etik_ekle.click(fn=etiket_ekle, inputs=[kategori_dd, etik_giris], outputs=alert).then(grid_guncelle, outputs=grid_out)
+        btn_etik_sil.click(fn=etiket_sil, inputs=[kategori_dd, etik_giris], outputs=alert).then(grid_guncelle, outputs=grid_out)
+
+    # --- Geç Bağlantılar (Cross-Tab Events) ---
+    btn_transfer_unmatched.click(
+        fn=transfer_et_ve_gec,
+        inputs=[hidden_unmatched_tags],
+        outputs=[etik_giris, tabs_kategori_ic] # tabs_kategori_ic ana tab objesi
+    )
+    
+    return etiket_input_common

modules/ui/tools/image_ui.py

@@ -0,0 +1,123 @@
+
+import gradio as gr
+import tkinter as tk
+from tkinter import filedialog
+from modules.config_manager import (
+    save_image_tools_settings, 
+    load_renaming_templates, 
+    add_renaming_template, 
+    delete_renaming_template
+)
+from modules.localization.languages import get_str
+from modules.tools import (
+    apply_custom_renaming,
+    process_resolution_change,
+    process_text_watermark,
+    process_format_change,
+    process_brightness_contrast,
+    process_denoise_sharpen
+)
+
+def create_image_ui(initial_image_tools_settings):
+    initial_folder_paths_str = "\n".join(initial_image_tools_settings.get("folder_paths", []))
+    
+    initial_watermark_text = initial_image_tools_settings.get("watermark_text", get_str("img_tools_watermark_default"))
+    initial_watermark_opacity = initial_image_tools_settings.get("watermark_opacity", 0.35)
+    initial_watermark_font_ratio = initial_image_tools_settings.get("watermark_font_ratio", 0.05)
+    initial_watermark_angle = initial_image_tools_settings.get("watermark_angle", -45)
+
+    initial_brightness_level = initial_image_tools_settings.get("brightness_level", 0)
+    initial_contrast_level = initial_image_tools_settings.get("contrast_level", 0)
+    initial_denoise_level = initial_image_tools_settings.get("denoise_level", 0)
+    initial_sharpen_amount = initial_image_tools_settings.get("sharpen_amount", 0.0)
+
+    current_templates = load_renaming_templates()
+    state_templates = gr.State(current_templates)
+
+    gr.Markdown(get_str("img_tools_header"))
+    
+    def select_folder_dialog(current_paths):
+        try:
+            root = tk.Tk()
+            root.withdraw()
+            root.attributes('-topmost', True)
+            folder_path = filedialog.askdirectory(title=get_str("img_tools_select_folder_btn")) # Using button text as title, simpler
+            root.destroy()
+            if folder_path:
+                existing_paths = current_paths.strip() if current_paths else ""
+                if existing_paths: return f"{existing_paths}\n{folder_path}"
+                else: return folder_path
+            return current_paths
+        except Exception as e:
+            print(f"Klasör seçme hatası: {e}")
+            return current_paths
+    
+    with gr.Row():
+        with gr.Column(scale=1):
+            folder_path_input = gr.Textbox(label=get_str("img_tools_paths_input"), value=initial_folder_paths_str, lines=5)
+            with gr.Row():
+                select_folder_btn = gr.Button(get_str("img_tools_select_folder_btn"), variant="secondary", size="sm")
+                clear_paths_btn = gr.Button(get_str("img_tools_clear_btn"), variant="stop", size="sm")
+            save_paths_button = gr.Button(get_str("img_tools_save_settings_btn"), variant="secondary")
+            image_tools_alert = gr.Textbox(label=get_str("status_label"), elem_id="renaming-alert-box", interactive=False, lines=5)
+            
+            select_folder_btn.click(fn=select_folder_dialog, inputs=[folder_path_input], outputs=[folder_path_input])
+            clear_paths_btn.click(fn=lambda: "", inputs=[], outputs=[folder_path_input])
+        
+        with gr.Column(scale=3):
+            with gr.Accordion(get_str("img_tools_res_accordion"), open=False):
+                scale_factor_dropdown = gr.Dropdown(label=get_str("img_tools_scale_label"), choices=[1.001, 1.01, 1.1, 1.25, 1.5, 2.0, 4.0], value=1.0, interactive=True)
+                process_resolution_button = gr.Button(get_str("btn_apply"), variant="primary")
+            
+            with gr.Accordion(get_str("img_tools_rename_accordion"), open=True):
+                gr.Markdown(get_str("img_tools_rename_desc"))
+                with gr.Row():
+                    template_dropdown = gr.Dropdown(label=get_str("img_tools_template_select"), choices=current_templates, value=current_templates[0] if current_templates else "", interactive=True, allow_custom_value=True)
+                    btn_del_template = gr.Button(get_str("img_tools_delete_template_btn"), variant="stop")
+                
+                with gr.Row():
+                    new_template_input = gr.Textbox(label=get_str("img_tools_new_template_input"), placeholder=get_str("img_tools_new_template_placeholder"))
+                    btn_add_template = gr.Button(get_str("img_tools_add_template_btn"), variant="secondary")
+
+                with gr.Row():
+                    start_num_input = gr.Number(label=get_str("img_tools_start_num"), value=1, precision=0)
+                    digit_count_slider = gr.Slider(label=get_str("img_tools_digit_count"), value=3, minimum=1, maximum=10, step=1)
+                
+                apply_renaming_btn = gr.Button(get_str("img_tools_rename_btn"), variant="primary")
+
+            btn_add_template.click(fn=add_renaming_template, inputs=[new_template_input, state_templates], outputs=[template_dropdown, state_templates])
+            btn_del_template.click(fn=delete_renaming_template, inputs=[template_dropdown, state_templates], outputs=[template_dropdown, state_templates])
+            apply_renaming_btn.click(fn=apply_custom_renaming, inputs=[folder_path_input, template_dropdown, start_num_input, digit_count_slider], outputs=[image_tools_alert, image_tools_alert])
+
+            with gr.Accordion(get_str("img_tools_watermark_accordion"), open=False):
+                watermark_text_input = gr.Textbox(label=get_str("img_tools_watermark_text"), value=initial_watermark_text)
+                watermark_opacity_slider = gr.Slider(minimum=0.05, maximum=1.0, value=initial_watermark_opacity, label=get_str("img_tools_watermark_opacity"))
+                watermark_font_ratio = gr.Slider(minimum=0.01, maximum=0.2, value=initial_watermark_font_ratio, label=get_str("img_tools_watermark_size"))
+                watermark_angle_slider = gr.Slider(minimum=-90, maximum=90, value=initial_watermark_angle, label=get_str("img_tools_watermark_angle"))
+                process_watermark_button = gr.Button(get_str("btn_add"), variant="primary")
+            
+            with gr.Accordion(get_str("img_tools_format_accordion"), open=False):
+                format_dropdown = gr.Dropdown(label=get_str("img_tools_format_label"), choices=[".png", ".jpeg", ".webp"], value=".png")
+                process_format_button = gr.Button(get_str("btn_convert"), variant="primary")
+            
+            with gr.Accordion(get_str("img_tools_bc_accordion"), open=False):
+                brightness_level = gr.Slider(minimum=-100, maximum=100, step=5, value=initial_brightness_level, label=get_str("img_tools_brightness"))
+                contrast_level = gr.Slider(minimum=-100, maximum=100, step=5, value=initial_contrast_level, label=get_str("img_tools_contrast"))
+                process_brightness_contrast_button = gr.Button(get_str("btn_apply"), variant="primary")
+            
+            with gr.Accordion(get_str("img_tools_ds_accordion"), open=False):
+                denoise_level = gr.Slider(minimum=0, maximum=5, step=1, value=initial_denoise_level, label=get_str("img_tools_denoise"))
+                sharpen_amount = gr.Slider(minimum=0.0, maximum=3.0, step=0.1, value=initial_sharpen_amount, label=get_str("img_tools_sharpen"))
+                process_denoise_sharpen_button = gr.Button(get_str("btn_apply"), variant="primary")
+
+    process_resolution_button.click(fn=process_resolution_change, inputs=[folder_path_input, scale_factor_dropdown], outputs=[image_tools_alert])
+    process_watermark_button.click(fn=process_text_watermark, inputs=[folder_path_input, watermark_text_input, watermark_opacity_slider, watermark_font_ratio, watermark_angle_slider], outputs=[image_tools_alert])
+    process_format_button.click(fn=process_format_change, inputs=[folder_path_input, format_dropdown], outputs=[image_tools_alert])
+    process_brightness_contrast_button.click(fn=process_brightness_contrast, inputs=[folder_path_input, brightness_level, contrast_level], outputs=[image_tools_alert])
+    process_denoise_sharpen_button.click(fn=process_denoise_sharpen, inputs=[folder_path_input, denoise_level, sharpen_amount], outputs=[image_tools_alert])
+    
+    save_paths_button.click(fn=save_image_tools_settings, inputs=[
+        folder_path_input, scale_factor_dropdown,
+        watermark_text_input, watermark_opacity_slider, watermark_font_ratio, watermark_angle_slider,
+        brightness_level, contrast_level, denoise_level, sharpen_amount
+    ], outputs=[image_tools_alert])

modules/ui/tools/rule_ui.py

@@ -0,0 +1,132 @@
+
+import os
+import gradio as gr
+from modules.managers.rule_manager import (
+    get_replacement_files,
+    get_synonym_files,
+    get_addition_files,
+    create_replacement_file,
+    read_replacement_file_content,
+    save_replacement_file_content,
+    append_replacement_rule_to_file,
+    create_synonym_file,
+    read_synonym_file_content,
+    save_synonym_file_content,
+    append_synonym_rule_to_file,
+    create_addition_file,
+    read_addition_file_content,
+    save_addition_file_content
+)
+
+from modules.localization.languages import get_str
+
+def create_rule_ui(initial_global_settings, default_replacement_file, default_synonym_file, default_addition_file):
+    
+    gr.Markdown(get_str("rule_tools_intro"))
+    
+    replacement_file_content = gr.Textbox(label=get_str("rule_file_content_manual"), visible=False)
+    synonym_file_content = gr.Textbox(label=get_str("rule_file_content_manual"), visible=False)
+    addition_file_content = gr.Textbox(label=get_str("rule_file_content_manual"), visible=False)
+
+    # --- 1. DEĞİŞTİRME KURALLARI ---
+    with gr.Accordion(get_str("rule_rep_accordion"), open=True):
+        gr.Markdown(get_str("rule_rep_desc"))
+        with gr.Row():
+                with gr.Column(scale=1):
+                    # initial value logic is complex, simplify
+                    rep_val = initial_global_settings.get("replacement_file")
+                    if rep_val not in get_replacement_files():
+                         rep_val = default_replacement_file if os.path.exists(default_replacement_file) else None
+                    
+                    replacement_file_selector = gr.Dropdown(label=get_str("rule_active_file"), choices=get_replacement_files(), value=rep_val, interactive=True)
+                    replacement_file_alert = gr.Textbox(label=get_str("status_label"), elem_id="alert-box", visible=False)
+                
+                with gr.Column(scale=1):
+                    new_replacement_file_name = gr.Textbox(label=get_str("rule_new_file_name"), placeholder="ozel_degisimler")
+                    create_replacement_btn = gr.Button(get_str("rule_create_file_btn"))
+
+        with gr.Tabs():
+                with gr.TabItem(get_str("rule_tab_quick_add")):
+                    with gr.Row():
+                        txt_rep_old = gr.Textbox(label=get_str("rule_rep_old"), placeholder="örn: blue_hair")
+                        txt_rep_new = gr.Textbox(label=get_str("rule_rep_new"), placeholder="örn: cyan hair")
+                    btn_add_rep = gr.Button(get_str("rule_add_to_file_btn"), variant="primary")
+                    
+                with gr.TabItem(get_str("rule_tab_edit_file")):
+                    replacement_file_content = gr.Textbox(label=get_str("rule_file_content_manual"), interactive=True, lines=10)
+                    save_replacement_rules_btn = gr.Button(get_str("rule_save_all_btn"), variant="secondary")
+
+    # --- 2. BİRLEŞTİRME KURALLARI ---
+    with gr.Accordion(get_str("rule_syn_accordion"), open=False):
+        gr.Markdown(get_str("rule_syn_intro"))
+        with gr.Row():
+                with gr.Column(scale=1):
+                    syn_val = initial_global_settings.get("synonym_file")
+                    if syn_val not in get_synonym_files():
+                         syn_val = default_synonym_file if os.path.exists(default_synonym_file) else None
+
+                    synonym_file_selector = gr.Dropdown(label=get_str("rule_active_file"), choices=get_synonym_files(), value=syn_val, interactive=True)
+                    synonym_file_alert = gr.Textbox(label=get_str("status_label"), elem_id="alert-box", visible=False)
+                with gr.Column(scale=1):
+                    new_synonym_file_name = gr.Textbox(label=get_str("rule_new_file_name"), placeholder="ozel_birlesimler")
+                    create_synonym_btn = gr.Button(get_str("rule_create_file_btn"))
+
+        with gr.Tabs():
+                with gr.TabItem(get_str("rule_tab_quick_add")):
+                    with gr.Row():
+                        txt_syn_main = gr.Textbox(label=get_str("rule_syn_main"), placeholder="örn: underwear")
+                        txt_syn_remove = gr.Textbox(label=get_str("rule_syn_remove"), placeholder="örn: panties, briefs")
+                    btn_add_syn = gr.Button(get_str("rule_add_to_file_btn"), variant="primary")
+                    
+                with gr.TabItem(get_str("rule_tab_edit_file")):
+                    synonym_file_content = gr.Textbox(label=get_str("rule_file_content_manual"), interactive=True, lines=10)
+                    save_synonym_rules_btn = gr.Button(get_str("rule_save_all_btn"), variant="secondary")
+    
+    # --- 3. EKLEME KURALLARI ---
+    with gr.Accordion(get_str("rule_add_accordion"), open=False):
+        gr.Markdown(get_str("rule_add_intro"))
+        with gr.Row():
+                with gr.Column(scale=1):
+                    add_val = initial_global_settings.get("addition_file")
+                    if add_val not in get_addition_files():
+                         add_val = default_addition_file if os.path.exists(default_addition_file) else None
+
+                    addition_file_selector = gr.Dropdown(label=get_str("rule_active_file"), choices=get_addition_files(), value=add_val, interactive=True)
+                    addition_file_alert = gr.Textbox(label=get_str("status_label"), elem_id="alert-box", visible=False)
+                with gr.Column(scale=1):
+                    new_addition_file_name = gr.Textbox(label=get_str("rule_new_file_name"), placeholder="imza_etiketlerim")
+                    create_addition_btn = gr.Button(get_str("rule_create_file_btn"))
+
+        addition_file_content = gr.Textbox(label=get_str("rule_add_content_input"), interactive=True, lines=10, placeholder="best quality, masterpiece\nsigned by artist")
+        save_addition_rules_btn = gr.Button(get_str("rule_add_save_btn"), variant="primary")
+
+
+    # --- EVENT HANDLERS ---
+    def update_dropdowns(val1, val2, val3):
+        files_rep = get_replacement_files()
+        files_syn = get_synonym_files()
+        files_add = get_addition_files()
+        return (
+            gr.update(choices=files_rep, value=val1 if val1 in files_rep else None),
+            gr.update(choices=files_syn, value=val2 if val2 in files_syn else None),
+            gr.update(choices=files_add, value=val3 if val3 in files_add else None)
+        )
+
+    # Replacement Events
+    create_replacement_btn.click(fn=create_replacement_file, inputs=[new_replacement_file_name], outputs=[replacement_file_alert]).then(fn=lambda: update_dropdowns(None, None, None)[0], outputs=[replacement_file_selector])
+    replacement_file_selector.change(fn=read_replacement_file_content, inputs=[replacement_file_selector], outputs=[replacement_file_content])
+    save_replacement_rules_btn.click(fn=save_replacement_file_content, inputs=[replacement_file_selector, replacement_file_content], outputs=[replacement_file_alert])
+    btn_add_rep.click(fn=append_replacement_rule_to_file, inputs=[replacement_file_selector, txt_rep_old, txt_rep_new], outputs=[replacement_file_alert]).then(fn=read_replacement_file_content, inputs=[replacement_file_selector], outputs=[replacement_file_content])
+
+    # Synonym Events
+    create_synonym_btn.click(fn=create_synonym_file, inputs=[new_synonym_file_name], outputs=[synonym_file_alert]).then(fn=lambda: update_dropdowns(None, None, None)[1], outputs=[synonym_file_selector])
+    synonym_file_selector.change(fn=read_synonym_file_content, inputs=[synonym_file_selector], outputs=[synonym_file_content])
+    save_synonym_rules_btn.click(fn=save_synonym_file_content, inputs=[synonym_file_selector, synonym_file_content], outputs=[synonym_file_alert])
+    btn_add_syn.click(fn=append_synonym_rule_to_file, inputs=[synonym_file_selector, txt_syn_main, txt_syn_remove], outputs=[synonym_file_alert]).then(fn=read_synonym_file_content, inputs=[synonym_file_selector], outputs=[synonym_file_content])
+
+    # Addition Events
+    create_addition_btn.click(fn=create_addition_file, inputs=[new_addition_file_name], outputs=[addition_file_alert]).then(fn=lambda: update_dropdowns(None, None, None)[2], outputs=[addition_file_selector])
+    addition_file_selector.change(fn=read_addition_file_content, inputs=[addition_file_selector], outputs=[addition_file_content])
+    save_addition_rules_btn.click(fn=save_addition_file_content, inputs=[addition_file_selector, addition_file_content], outputs=[addition_file_alert])
+
+    return replacement_file_content, synonym_file_content, addition_file_content

modules/ui/tools/text_ui.py

@@ -0,0 +1,34 @@
+
+import gradio as gr
+from modules.localization.languages import get_str
+from modules.tools import (
+    clean_and_uniquify_text_simple,
+    convert_lines_to_comma,
+    convert_comma_to_lines,
+    select_and_copy_random_lines
+)
+
+def create_text_ui():
+    with gr.Row():
+        with gr.Column():
+            gr.Markdown(get_str("txt_tools_header"))
+            text_input_raw = gr.Textbox(label=get_str("txt_tools_input"), lines=5, placeholder="örnek: \nred_hair\nlong__hair\nblue_eyes")
+            text_cleaner_alert = gr.Textbox(label=get_str("status_label"), elem_id="alert-box", visible=False)
+            
+            with gr.Tabs():
+                with gr.Tab(get_str("txt_tools_tab_clean")):
+                    text_cleaner_process_button = gr.Button(get_str("txt_tools_clean_btn"), variant="primary")
+                    text_cleaner_output = gr.Textbox(label=get_str("label_result"), lines=5, interactive=False, show_copy_button=True)
+                with gr.Tab(get_str("txt_tools_tab_format")):
+                    format_output = gr.Textbox(label=get_str("label_result"), lines=5, interactive=False, show_copy_button=True)
+                    with gr.Row():
+                        lines_to_comma_btn = gr.Button(get_str("txt_tools_lines_to_comma"), variant="primary")
+                        comma_to_lines_btn = gr.Button(get_str("txt_tools_comma_to_lines"), variant="primary")
+                with gr.Tab(get_str("txt_tools_tab_random")):
+                    num_lines_to_copy_slider = gr.Slider(minimum=1, maximum=300, value=1, step=1, label=get_str("txt_tools_line_count"))
+                    select_random_lines_button = gr.Button(get_str("btn_select"), variant="primary")
+                    random_lines_output = gr.Textbox(label=get_str("label_result"), lines=5, interactive=False, show_copy_button=True)
+    text_cleaner_process_button.click(fn=lambda text: (clean_and_uniquify_text_simple(text), gr.update(value="✅ Metin temizlendi.", visible=True)), inputs=[text_input_raw], outputs=[text_cleaner_output, text_cleaner_alert])
+    lines_to_comma_btn.click(fn=convert_lines_to_comma, inputs=[text_input_raw], outputs=[format_output, text_cleaner_alert])
+    comma_to_lines_btn.click(fn=convert_comma_to_lines, inputs=[text_input_raw], outputs=[format_output, text_cleaner_alert])
+    select_random_lines_button.click(fn=select_and_copy_random_lines, inputs=[text_input_raw, num_lines_to_copy_slider], outputs=[random_lines_output, text_cleaner_alert])

modules/utils/file_utils.py

@@ -0,0 +1,22 @@
+
+import os
+from typing import List
+
+CONFIGLIST_KLASORU = "data/rules/configlist"
+
+def get_configlist_files():
+    """Configlist klasöründeki tüm txt dosyalarını döndürür."""
+    if os.path.exists(CONFIGLIST_KLASORU):
+        return [os.path.join(CONFIGLIST_KLASORU, f) for f in os.listdir(CONFIGLIST_KLASORU) if f.endswith(".txt")]
+    return []
+
+def _get_all_image_paths(folder_paths: List[str]) -> List[str]:
+    """Tüm klasörlerdeki resim dosyalarının yollarını toplar."""
+    image_extensions = (('.png', '.jpg', '.jpeg', '.webp'))
+    all_paths = []
+    for folder_path in folder_paths:
+        if os.path.isdir(folder_path):
+            for filename in os.listdir(folder_path):
+                if filename.lower().endswith(image_extensions):
+                    all_paths.append(os.path.join(folder_path, filename))
+    return all_paths

modules/utils/tag_utils.py

@@ -0,0 +1,30 @@
+
+import re
+import random
+
+def clean_tags_underscore(tags_string):
+    if not tags_string: return ""
+    cleaned = re.sub(r'\_+', ' ', tags_string).strip()
+    return re.sub(r'\s+', ' ', cleaned)
+
+def unique_and_sort_tags(tags_string, sort_order="alpha", original_order_ref=None):
+    if not tags_string:
+        return ""
+    
+    tags = [t.strip() for t in tags_string.split(',') if t.strip()]
+    unique_tags = []
+    [unique_tags.append(t) for t in tags if t not in unique_tags]
+    
+    if sort_order == "alpha" or sort_order == "Alfabetik": 
+        return ", ".join(sorted(unique_tags))
+    elif sort_order == "length" or sort_order == "Uzunluğa Göre":
+        return ", ".join(sorted(unique_tags, key=len))
+    elif sort_order == "random" or sort_order == "Rastgele":
+        # random is already imported at the top, no need to re-import
+        random.shuffle(unique_tags)
+        return ", ".join(unique_tags)
+    elif sort_order == "original" or sort_order == "Orijinal":
+        return ", ".join(unique_tags) # Zaten unique yaparken sıra korundu
+    
+    # Default case if sort_order is not recognized, or if original_order_ref was intended for a different sort
+    return ", ".join(unique_tags)

modules/video_creator.py

@@ -0,0 +1,263 @@
+# modules/video_creator.py
+
+import os
+import time
+import numpy as np
+import gradio as gr
+from PIL import Image, ImageFilter, ImageDraw, ImageFont
+import matplotlib.pyplot as plt
+import io
+
+# MoviePy Kütüphanesi (v2.0+ Uyumlu)
+from moviepy import (
+    ImageClip, AudioFileClip, concatenate_audioclips, 
+    concatenate_videoclips, CompositeVideoClip, VideoClip, ColorClip, TextClip
+)
+
+# Çıktı klasörü
+OUTPUT_DIR = "outputs"
+
+# Çözünürlük Ayarları
+RESOLUTIONS = {
+    "YouTube (16:9)": (1920, 1080),
+    "Shorts/Reels (9:16)": (1080, 1920),
+    "Kare (1:1)": (1080, 1080)
+}
+
+def create_blurred_background(pil_img, target_size):
+    """Resmi bulanıklaştırıp arka plana yayar, orijinali ortada tutar."""
+    target_w, target_h = target_size
+    img_w, img_h = pil_img.size
+    
+    # 1. Arka planı oluştur (Resmi kaplayacak şekilde büyüt ve bulanıklaştır)
+    bg_ratio = max(target_w / img_w, target_h / img_h)
+    bg_new_size = (int(img_w * bg_ratio), int(img_h * bg_ratio))
+    background = pil_img.resize(bg_new_size, Image.Resampling.LANCZOS)
+    
+    # Ortalamak için kırp
+    left = (bg_new_size[0] - target_w) / 2
+    top = (bg_new_size[1] - target_h) / 2
+    background = background.crop((left, top, left + target_w, top + target_h))
+    
+    # Bulanıklaştır
+    background = background.filter(ImageFilter.GaussianBlur(radius=20))
+    
+    # 2. Ön planı oluştur (Sığacak şekilde ayarla)
+    fg_ratio = min(target_w / img_w, target_h / img_h)
+    fg_new_size = (int(img_w * fg_ratio), int(img_h * fg_ratio))
+    foreground = pil_img.resize(fg_new_size, Image.Resampling.LANCZOS)
+    
+    # 3. Birleştir
+    final_img = background.copy()
+    fg_x = (target_w - fg_new_size[0]) // 2
+    fg_y = (target_h - fg_new_size[1]) // 2
+    final_img.paste(foreground, (fg_x, fg_y))
+    
+    return final_img
+
+def create_text_overlay(txt, target_size, duration):
+    """Basit metin görseli oluşturur (PIL kullanarak)"""
+    w, h = target_size
+    # Şeffaf katman
+    img = Image.new('RGBA', target_size, (255, 255, 255, 0))
+    draw = ImageDraw.Draw(img)
+    
+    # Font boyutu ve ayarı
+    font_size = int(h * 0.05) # Yüksekliğin %5'i
+    try:
+        font = ImageFont.truetype("arial.ttf", font_size)
+    except:
+        font = ImageFont.load_default()
+    
+    # Metin boyutunu hesapla
+    bbox = draw.textbbox((0, 0), txt, font=font)
+    text_w = bbox[2] - bbox[0]
+    text_h = bbox[3] - bbox[1]
+    
+    # Alt ortaya yerleştir (biraz yukarıda)
+    x = (w - text_w) / 2
+    y = h - (text_h * 2.5)
+    
+    # Arka plan kutusu (Siyah, yarı saydam)
+    padding = 10
+    draw.rectangle(
+        [x - padding, y - padding, x + text_w + padding, y + text_h + padding], 
+        fill=(0, 0, 0, 160)
+    )
+    # Metni yaz
+    draw.text((x, y), txt, font=font, fill="white")
+    
+    return ImageClip(np.array(img)).with_duration(duration)
+
+def make_audio_spectrum_clip(audio_clip, target_size, duration):
+    """Ses dalgası animasyonu oluşturur (Matplotlib ile)"""
+    w, h = target_size
+    fps = 10 
+    
+    audio_array = audio_clip.to_soundarray(fps=fps)
+    if audio_array.ndim > 1:
+        audio_array = audio_array.mean(axis=1)
+        
+    audio_array = audio_array / np.max(np.abs(audio_array) + 0.0001)
+
+    def make_frame(t):
+        index = int(t * fps)
+        if index >= len(audio_array):
+            index = len(audio_array) - 1
+            
+        val = abs(audio_array[index])
+        
+        fig, ax = plt.subplots(figsize=(w/100, h/400), dpi=72)
+        fig.patch.set_alpha(0) 
+        ax.axis('off')
+        
+        bar_height = val
+        ax.barh([0], [bar_height], color='cyan', height=0.5, alpha=0.8)
+        ax.set_xlim(0, 1)
+        ax.set_ylim(-0.5, 0.5)
+        
+        buf = io.BytesIO()
+        fig.savefig(buf, format='png', bbox_inches='tight', pad_inches=0, transparent=True)
+        buf.seek(0)
+        plt.close(fig) 
+        
+        img = Image.open(buf).convert("RGBA")
+        img = img.resize((w, int(h*0.2))) 
+        
+        full_frame = Image.new('RGBA', (w, h), (0,0,0,0))
+        full_frame.paste(img, (0, int(h * 0.8))) 
+        
+        return np.array(full_frame)
+
+    clip = VideoClip(make_frame, duration=duration)
+    mask = VideoClip(make_frame, duration=duration).to_mask()
+    return clip.with_mask(mask)
+
+
+def create_video_logic(
+    image_files, audio_files, 
+    resolution_key, 
+    custom_text, 
+    enable_spectrum,
+    video_preset, # YENİ PARAMETRE
+    progress=gr.Progress()
+):
+    if not image_files: return None, "⚠️ Lütfen en az bir resim seçin."
+    if not audio_files: return None, "⚠️ Lütfen en az bir ses dosyası seçin."
+
+    os.makedirs(OUTPUT_DIR, exist_ok=True)
+    output_filename = f"pro_video_{int(time.time())}.mp4"
+    output_path = os.path.join(OUTPUT_DIR, output_filename)
+    
+    target_size = RESOLUTIONS.get(resolution_key, (1920, 1080))
+
+    try:
+        progress(0.1, desc="Sesler işleniyor...")
+        audio_clips = [AudioFileClip(f.name if hasattr(f, 'name') else f) for f in audio_files]
+        final_audio = concatenate_audioclips(audio_clips)
+        total_duration = final_audio.duration
+        
+        progress(0.2, desc="Görseller hazırlanıyor (Slayt Modu)...")
+        
+        img_duration = total_duration / len(image_files)
+        video_clips = []
+        
+        for img_file in image_files:
+            img_path = img_file.name if hasattr(img_file, 'name') else img_file
+            
+            with Image.open(img_path) as pil_img:
+                processed_img = create_blurred_background(pil_img, target_size)
+            
+            clip = ImageClip(np.array(processed_img)).with_duration(img_duration)
+            video_clips.append(clip)
+            
+        base_video = concatenate_videoclips(video_clips, method="compose")
+        base_video = base_video.with_audio(final_audio)
+        
+        final_layers = [base_video]
+        
+        if custom_text and custom_text.strip():
+            progress(0.4, desc="Metin katmanı oluşturuluyor...")
+            txt_clip = create_text_overlay(custom_text, target_size, total_duration)
+            final_layers.append(txt_clip)
+            
+        if enable_spectrum:
+            progress(0.5, desc="Ses dalgası grafiği oluşturuluyor (Bu işlem ÇOK yavaş olabilir)...")
+            try:
+                spectrum_clip = make_audio_spectrum_clip(final_audio, target_size, total_duration)
+                final_layers.append(spectrum_clip)
+            except Exception as e:
+                print(f"Spectrum hatası: {e}")
+
+        final_video = CompositeVideoClip(final_layers, size=target_size)
+        
+        progress(0.7, desc=f"Video render ediliyor ({video_preset})... Bu işlem uzun sürebilir, lütfen bekleyin.")
+        
+        # Render işlemi - logger='bar' konsola ilerleme yazar
+        final_video.write_videofile(
+            output_path, 
+            fps=24, 
+            codec='libx264',
+            audio_codec='aac',
+            preset=video_preset,
+            threads=os.cpu_count() or 4,  # CPU sayısına göre otomatik
+            logger='bar'  # Konsola ilerleme yazsın
+        )
+        
+        # Bellek temizliği
+        final_video.close()
+        for clip in video_clips:
+            clip.close()
+        for ac in audio_clips:
+            ac.close()
+        final_audio.close()
+        
+        progress(1.0, desc="✅ İşlem Tamamlandı!") 
+        
+        return output_path, f"✅ Pro Video Hazır! ({resolution_key})"
+
+    except Exception as e:
+        import traceback
+        traceback.print_exc()
+        return None, f"⛔ Hata: {str(e)}"
+
+# --- UI ---
+
+import gradio as gr
+from modules.localization.languages import get_str
+
+def create_video_ui():
+    gr.Markdown(get_str("vid_header"))
+    gr.Markdown(get_str("vid_desc"))
+    
+    with gr.Row():
+        with gr.Column():
+            image_input = gr.File(label=get_str("vid_img_input"), file_count="multiple", file_types=["image"])
+            audio_input = gr.File(label=get_str("vid_audio_input"), file_count="multiple", file_types=["audio"])
+            
+            with gr.Row():
+                resolution_dropdown = gr.Dropdown(
+                    choices=["1920x1080", "1280x720", "1080x1920", "720x1280", "1080x1080"],
+                    value="1920x1080",
+                    label=get_str("vid_resolution")
+                )
+                preset_radio = gr.Radio(
+                    choices=["ultrafast", "superfast", "veryfast", "faster", "fast", "medium"],
+                    value="medium",
+                    label=get_str("vid_speed")
+                )
+
+            text_overlay = gr.Textbox(label=get_str("vid_text_overlay"), placeholder="Örn: My Artworks 2024")
+            spectrum_check = gr.Checkbox(label=get_str("vid_spectrum_check"), value=False)
+            
+            create_btn = gr.Button(get_str("vid_create_btn"), variant="primary")
+        
+        with gr.Column():
+            video_output = gr.Video(label=get_str("vid_preview"))
+            status_output = gr.Textbox(label=get_str("vid_status"), interactive=False)
+
+    create_btn.click(
+        fn=create_video_logic,
+        inputs=[image_input, audio_input, resolution_dropdown, text_overlay, spectrum_check, preset_radio],
+        outputs=[video_output, status_output]
+    )