Initial Space deployment

.gitignore

@@ -0,0 +1,7 @@
+.env
+__pycache__/
+*.db
+in_*.jpg
+out_*.jpg
+in_*.mp4
+out_*.mp4

Dockerfile

@@ -0,0 +1,23 @@
+# Hugging Face Space (Docker) muhiti uchun
+# Asosiy Python imiji
+FROM python:3.10-slim
+
+# Tizim paketlarini yangilash va OpenCV hamda MoviePy uchun kerakli kutubxonalarni o'rnatish
+RUN apt-get update && apt-get install -y \
+    libgl1-mesa-glx \
+    libglib2.0-0 \
+    ffmpeg \
+    && rm -rf /var/lib/apt/lists/*
+
+# Ishchi katalogini yaratish
+WORKDIR /app
+
+# Talab qilinadigan paketlarni ko'chirib olish va o'rnatish
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Barcha bot fayllarini ko'chirib olish
+COPY . .
+
+# Botni ishga tushirish (main ismli faylingiz)
+CMD ["python", "main.py"]

database.py

@@ -0,0 +1,92 @@
+import sqlite3
+import os
+from datetime import datetime
+
+class Database:
+    def __init__(self, db_name="bot_database.db"):
+        self.db_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), db_name)
+        self.init_db()
+
+    def get_connection(self):
+        return sqlite3.connect(self.db_path)
+
+    def init_db(self):
+        """Ma'lumotlar bazasi jadvallarini yaratish."""
+        with self.get_connection() as conn:
+            cursor = conn.cursor()
+            
+            # Foydalanuvchilar jadvali
+            cursor.execute('''
+                CREATE TABLE IF NOT EXISTS users (
+                    user_id INTEGER PRIMARY KEY,
+                    username TEXT,
+                    first_name TEXT,
+                    joined_at DATETIME,
+                    default_filter TEXT DEFAULT 'retro'
+                )
+            ''')
+            
+            # Amallar tarixi jadvali
+            cursor.execute('''
+                CREATE TABLE IF NOT EXISTS history (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    user_id INTEGER,
+                    media_type TEXT,
+                    filter_type TEXT,
+                    processed_at DATETIME,
+                    file_id TEXT,
+                    FOREIGN KEY (user_id) REFERENCES users (user_id)
+                )
+            ''')
+            conn.commit()
+
+    def add_user(self, user_id, username, first_name):
+        """Yangi foydalanuvchini ro'yxatga olish yoki yangilash."""
+        with self.get_connection() as conn:
+            cursor = conn.cursor()
+            cursor.execute('''
+                INSERT OR REPLACE INTO users (user_id, username, first_name, joined_at)
+                VALUES (?, ?, ?, COALESCE((SELECT joined_at FROM users WHERE user_id = ?), ?))
+            ''', (user_id, username, first_name, user_id, datetime.now().isoformat()))
+            conn.commit()
+
+    def log_history(self, user_id, media_type, filter_type, file_id):
+        """Ishlov berish tarixini saqlash."""
+        with self.get_connection() as conn:
+            cursor = conn.cursor()
+            cursor.execute('''
+                INSERT INTO history (user_id, media_type, filter_type, processed_at, file_id)
+                VALUES (?, ?, ?, ?, ?)
+            ''', (user_id, media_type, filter_type, datetime.now().isoformat(), file_id))
+            conn.commit()
+
+    def get_user_history(self, user_id, limit=5):
+        """Foydalanuvchining oxirgi amallarini olish."""
+        with self.get_connection() as conn:
+            cursor = conn.cursor()
+            cursor.execute('''
+                SELECT media_type, filter_type, processed_at 
+                FROM history 
+                WHERE user_id = ? 
+                ORDER BY processed_at DESC 
+                LIMIT ?
+            ''', (user_id, limit))
+            return cursor.fetchall()
+
+    def set_default_filter(self, user_id, filter_type):
+        """Foydalanuvchi uchun standart filtrni o'rnatish."""
+        with self.get_connection() as conn:
+            cursor = conn.cursor()
+            cursor.execute('UPDATE users SET default_filter = ? WHERE user_id = ?', (filter_type, user_id))
+            conn.commit()
+
+    def get_user_settings(self, user_id):
+        """Foydalanuvchi sozlamalarini olish."""
+        with self.get_connection() as conn:
+            cursor = conn.cursor()
+            cursor.execute('SELECT default_filter FROM users WHERE user_id = ?', (user_id,))
+            result = cursor.fetchone()
+            return result[0] if result else 'retro'
+
+# Global DB instance
+db = Database()

filters.py

@@ -0,0 +1,763 @@
+import cv2
+import numpy as np
+from PIL import Image, ImageEnhance
+import os
+import logging
+
+# Loglarni filters.py uchun ham alohida sozlash
+logger = logging.getLogger(__name__)
+
+def apply_retro_filter(image_path, output_path):
+    """Rasmni retro uslubiga o'tkazadi (donadorlik, rang siljishi, vinyetka)."""
+    try:
+        image_path = os.path.abspath(image_path)
+        output_path = os.path.abspath(output_path)
+        
+        img = cv2.imread(image_path)
+        if img is None:
+            logger.error(f"Rasm o'qilmadi: {image_path}")
+            return None
+        
+        # Formatlarni BGR ga o'tkazish
+        if len(img.shape) == 2:
+            img = cv2.cvtColor(img, cv2.COLOR_GRAY2BGR)
+        elif img.shape[2] == 4:
+            img = cv2.cvtColor(img, cv2.COLOR_BGRA2BGR)
+
+        # 1. Sepia
+        sepia_filter = np.array([[0.272, 0.534, 0.131],
+                                 [0.349, 0.686, 0.168],
+                                 [0.393, 0.769, 0.189]])
+        img = cv2.transform(img, sepia_filter)
+        img = np.clip(img, 0, 255).astype(np.uint8)
+
+        # 2. Grain
+        noise = np.random.randint(0, 30, img.shape, dtype='uint8')
+        img = cv2.add(img, noise)
+
+        # 3. Vignette
+        rows, cols = img.shape[:2]
+        kernel_x = cv2.getGaussianKernel(cols, int(cols/1.5))
+        kernel_y = cv2.getGaussianKernel(rows, int(rows/1.5))
+        kernel = kernel_y * kernel_x.T
+        mask = 255 * kernel / np.max(kernel)
+        
+        vignette = img.astype(float)
+        for i in range(3):
+            vignette[:,:,i] = vignette[:,:,i] * mask / 255
+        
+        cv2.imwrite(output_path, vignette.astype(np.uint8))
+        if os.path.exists(output_path):
+            return output_path
+        return None
+    except Exception as e:
+        logger.error(f"Retro rasm xatosi: {e}")
+        return None
+
+def upscale_image(image_path, output_path, scale=2):
+    """Rasmni sifatini oshirish."""
+    try:
+        image_path = os.path.abspath(image_path)
+        output_path = os.path.abspath(output_path)
+        
+        img = cv2.imread(image_path)
+        if img is None: return None
+        
+        if len(img.shape) == 2:
+            img = cv2.cvtColor(img, cv2.COLOR_GRAY2BGR)
+        elif img.shape[2] == 4:
+            img = cv2.cvtColor(img, cv2.COLOR_BGRA2BGR)
+
+        height, width = img.shape[:2]
+        new_size = (width * scale, height * scale)
+        upscaled = cv2.resize(img, new_size, interpolation=cv2.INTER_LANCZOS4)
+        
+        pill_img = Image.fromarray(cv2.cvtColor(upscaled, cv2.COLOR_BGR2RGB))
+        
+        # O'tkirlikni ko'proq oshirish (2.5)
+        enhancer = ImageEnhance.Sharpness(pill_img)
+        pill_img = enhancer.enhance(2.5)
+        
+        # Kontrastni ham biroz oshirish
+        enhancer_c = ImageEnhance.Contrast(pill_img)
+        pill_img = enhancer_c.enhance(1.15)
+        
+        upscaled_final = cv2.cvtColor(np.array(pill_img), cv2.COLOR_RGB2BGR)
+        cv2.imwrite(output_path, upscaled_final)
+        return output_path
+    except Exception as e:
+        logger.error(f"Upscale rasm xatosi: {e}")
+        return None
+
+def process_video_retro(video_path, output_path, progress_callback=None):
+    """Videoga retro filtrini qo'llaydi."""
+    import moviepy.video.VideoClip as mp_video
+    from moviepy.video.io.VideoFileClip import VideoFileClip
+    
+    try:
+        video_path = os.path.abspath(video_path)
+        output_path = os.path.abspath(output_path)
+        
+        video = VideoFileClip(video_path)
+        total_frames = int(video.fps * video.duration)
+        current_frame = [0]
+
+        def filter_frame(frame):
+            current_frame[0] += 1
+            if progress_callback and current_frame[0] % 15 == 0:
+                percent = min(99, int((current_frame[0] / total_frames) * 100))
+                progress_callback(percent)
+
+            # Input frame is RGB
+            if frame.shape[2] == 4:
+                frame = frame[:, :, :3]
+            elif len(frame.shape) == 2:
+                frame = cv2.cvtColor(frame, cv2.COLOR_GRAY2RGB)
+                
+            bgr = cv2.cvtColor(frame, cv2.COLOR_RGB2BGR)
+            
+            sepia_filter = np.array([[0.272, 0.534, 0.131],
+                                     [0.349, 0.686, 0.168],
+                                     [0.393, 0.769, 0.189]])
+            bgr = cv2.transform(bgr, sepia_filter)
+            bgr = np.clip(bgr, 0, 255).astype(np.uint8)
+            
+            noise = np.random.randint(0, 15, bgr.shape, dtype='uint8')
+            bgr = cv2.add(bgr, noise)
+            
+            return cv2.cvtColor(bgr, cv2.COLOR_BGR2RGB)
+
+        processed_video = video.image_transform(filter_frame)
+
+        processed_video.write_videofile(
+            output_path, 
+            codec="libx264", 
+            audio_codec="aac", 
+            fps=video.fps or 24,
+            preset="ultrafast", # Tezroq bo'lishi uchun
+            threads=4,
+            logger=None
+        )
+        
+        video.close()
+        processed_video.close()
+        
+        if os.path.exists(output_path):
+            return output_path
+        return None
+    except Exception as e:
+        logger.error(f"Video process xatosi: {e}")
+        return None
+
+def process_video_upscale(video_path, output_path, progress_callback=None):
+    """Videoning sifatini (o'lcham va o'tkirlik) oshiradi."""
+    from moviepy.video.io.VideoFileClip import VideoFileClip
+    
+    try:
+        video_path = os.path.abspath(video_path)
+        output_path = os.path.abspath(output_path)
+        
+        video = VideoFileClip(video_path)
+        total_frames = int(video.fps * video.duration)
+        current_frame = [0]
+
+        def upscale_frame(frame):
+            current_frame[0] += 1
+            if progress_callback and current_frame[0] % 15 == 0:
+                percent = min(99, int((current_frame[0] / total_frames) * 100))
+                progress_callback(percent)
+
+            # RGB -> BGR
+            bgr = cv2.cvtColor(frame, cv2.COLOR_RGB2BGR)
+            
+            # 1.5x kattalashtirish
+            h, w = bgr.shape[:2]
+            upscaled = cv2.resize(bgr, (int(w*1.5), int(h*1.5)), interpolation=cv2.INTER_LANCZOS4)
+            
+            # Sharpness
+            gaussian_3 = cv2.GaussianBlur(upscaled, (0, 0), 2.0)
+            unsharp_image = cv2.addWeighted(upscaled, 1.5, gaussian_3, -0.5, 0)
+            
+            return cv2.cvtColor(unsharp_image, cv2.COLOR_BGR2RGB)
+
+        processed_video = video.image_transform(upscale_frame)
+
+        processed_video.write_videofile(
+            output_path, 
+            codec="libx264", 
+            audio_codec="aac", 
+            fps=video.fps or 24,
+            preset="ultrafast",
+            threads=4,
+            logger=None
+        )
+        
+        video.close()
+        processed_video.close()
+        return output_path if os.path.exists(output_path) else None
+    except Exception as e:
+        logger.error(f"Video upscale xatosi: {e}")
+        return None
+
+def apply_face_restore(image_path, output_path):
+    """Yuzlarni aniqlaydi va ularni tiniqlashtiradi (Face Fix)."""
+    try:
+        image_path = os.path.abspath(image_path)
+        output_path = os.path.abspath(output_path)
+        
+        img = cv2.imread(image_path)
+        if img is None: return None
+        
+        # Yuzni aniqlash uchun kaskad yuklanadi (yanada qat'iy parametrlar)
+        face_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + 'haarcascade_frontalface_default.xml')
+        gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
+        
+        # HistEq orqali qorong'u yuzlarni ham topish
+        gray = cv2.equalizeHist(gray)
+        faces = face_cascade.detectMultiScale(gray, scaleFactor=1.1, minNeighbors=5, minSize=(40, 40))
+        
+        for (x, y, w, h) in faces:
+            # Yuz qismini biroz kattaroq qilib ajratib olish (padding)
+            p = int(w * 0.15)
+            x1, y1 = max(0, x - p), max(0, y - p)
+            x2, y2 = min(img.shape[1], x + w + p), min(img.shape[0], y + h + p)
+            face_roi = img[y1:y2, x1:x2]
+            
+            # 1. Yuzni tekislash (skin smoothing - Bilateral + Median)
+            smoothed = cv2.bilateralFilter(face_roi, 9, 75, 75)
+            smoothed = cv2.medianBlur(smoothed, 3)
+            
+            # 2. Detallarni kuchli qaytarish (Unsharp Mask)
+            gaussian = cv2.GaussianBlur(smoothed, (0, 0), 2.5)
+            sharpened = cv2.addWeighted(smoothed, 2.0, gaussian, -1.0, 0)
+            
+            # 3. Sifatini oshirish (CLAHE orqali yorug'lik)
+            lab = cv2.cvtColor(sharpened, cv2.COLOR_BGR2LAB)
+            l, a, b = cv2.split(lab)
+            clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8,8))
+            cl = clahe.apply(l)
+            limg = cv2.merge((cl,a,b))
+            face_roi = cv2.cvtColor(limg, cv2.COLOR_LAB2BGR)
+            
+            # Asl rasmga qaytarish
+            img[y1:y2, x1:x2] = face_roi
+            
+        cv2.imwrite(output_path, img)
+        return output_path
+    except Exception as e:
+        logger.error(f"Face Restore xatosi: {e}")
+        return None
+
+def apply_auto_enhance(image_path, output_path):
+    """Ranglarni va yorug'likni avtomatik balanslaydi."""
+    try:
+        image_path = os.path.abspath(image_path)
+        output_path = os.path.abspath(output_path)
+        
+        img = cv2.imread(image_path)
+        if img is None: return None
+        
+        # CLAHE - Yorug'likni kuchliroq taqsimlash
+        lab = cv2.cvtColor(img, cv2.COLOR_BGR2LAB)
+        l, a, b = cv2.split(lab)
+        clahe = cv2.createCLAHE(clipLimit=3.0, tileGridSize=(8,8))
+        cl = clahe.apply(l)
+        limg = cv2.merge((cl,a,b))
+        enhanced = cv2.cvtColor(limg, cv2.COLOR_LAB2BGR)
+        
+        # Detallarni kuchaytirish (Unsharp Mask)
+        gaussian = cv2.GaussianBlur(enhanced, (0, 0), 2.0)
+        unsharp = cv2.addWeighted(enhanced, 1.5, gaussian, -0.5, 0)
+        
+        # Saturation (to'yinganlik) ni sezilarli oshirish
+        hsv = cv2.cvtColor(unsharp, cv2.COLOR_BGR2HSV)
+        h, s, v = cv2.split(hsv)
+        s = cv2.add(s, 25)
+        hsv = cv2.merge((h, s, v))
+        final = cv2.cvtColor(hsv, cv2.COLOR_HSV2BGR)
+        
+        cv2.imwrite(output_path, final)
+        return output_path
+    except Exception as e:
+        logger.error(f"Auto Enhance xatosi: {e}")
+        return None
+
+# ============================================================
+#  YANGI VIDEO FILTRLAR (Phase 6)
+# ============================================================
+
+def process_video_slowmo(video_path, output_path, progress_callback=None):
+    """Videoni 2x sekinlashtiradi (Slow Motion)."""
+    from moviepy.video.io.VideoFileClip import VideoFileClip
+    
+    try:
+        video_path = os.path.abspath(video_path)
+        output_path = os.path.abspath(output_path)
+        
+        video = VideoFileClip(video_path)
+        
+        # 2x sekinlashtirish (tezlikni 0.5 ga kamaytirish)
+        slow_video = video.with_speed_scaled(0.5)
+        
+        audio_params = {"audio_codec": "aac"} if video.audio else {"audio": False}
+        
+        slow_video.write_videofile(
+            output_path,
+            codec="libx264",
+            fps=video.fps or 24,
+            preset="ultrafast",
+            threads=4,
+            logger=None,
+            **audio_params
+        )
+        
+        video.close()
+        slow_video.close()
+        return output_path if os.path.exists(output_path) else None
+    except Exception as e:
+        logger.error(f"Slow Motion xatosi: {e}")
+        return None
+
+def process_video_bw(video_path, output_path, progress_callback=None):
+    """Videoni oq-qora (B&W) holatga o'tkazadi."""
+    from moviepy.video.io.VideoFileClip import VideoFileClip
+    
+    try:
+        video_path = os.path.abspath(video_path)
+        output_path = os.path.abspath(output_path)
+        
+        video = VideoFileClip(video_path)
+        total_frames = int(video.fps * video.duration)
+        current_frame = [0]
+
+        def bw_frame(frame):
+            current_frame[0] += 1
+            if progress_callback and current_frame[0] % 15 == 0:
+                percent = min(99, int((current_frame[0] / total_frames) * 100))
+                progress_callback(percent)
+            
+            gray = cv2.cvtColor(frame, cv2.COLOR_RGB2GRAY)
+            # Kontrastni biroz oshirish
+            clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8,8))
+            gray = clahe.apply(gray)
+            return cv2.cvtColor(gray, cv2.COLOR_GRAY2RGB)
+
+        processed = video.image_transform(bw_frame)
+        audio_params = {"audio_codec": "aac"} if video.audio else {"audio": False}
+        processed.write_videofile(
+            output_path,
+            codec="libx264",
+            fps=video.fps or 24,
+            preset="ultrafast",
+            threads=4,
+            logger=None,
+            **audio_params
+        )
+        
+        video.close()
+        processed.close()
+        return output_path if os.path.exists(output_path) else None
+    except Exception as e:
+        logger.error(f"B&W video xatosi: {e}")
+        return None
+
+def process_video_color_correct(video_path, output_path, progress_callback=None):
+    """Video ranglarini avtomatik korreksiya qiladi."""
+    from moviepy.video.io.VideoFileClip import VideoFileClip
+    
+    try:
+        video_path = os.path.abspath(video_path)
+        output_path = os.path.abspath(output_path)
+        
+        video = VideoFileClip(video_path)
+        total_frames = int(video.fps * video.duration)
+        current_frame = [0]
+
+        def color_frame(frame):
+            current_frame[0] += 1
+            if progress_callback and current_frame[0] % 15 == 0:
+                percent = min(99, int((current_frame[0] / total_frames) * 100))
+                progress_callback(percent)
+            
+            bgr = cv2.cvtColor(frame, cv2.COLOR_RGB2BGR)
+            
+            # CLAHE yorug'lik
+            lab = cv2.cvtColor(bgr, cv2.COLOR_BGR2LAB)
+            l, a, b = cv2.split(lab)
+            clahe = cv2.createCLAHE(clipLimit=3.0, tileGridSize=(8,8))
+            cl = clahe.apply(l)
+            lab = cv2.merge((cl, a, b))
+            bgr = cv2.cvtColor(lab, cv2.COLOR_LAB2BGR)
+            
+            # Unsharp mask
+            gaussian = cv2.GaussianBlur(bgr, (0, 0), 2.0)
+            bgr = cv2.addWeighted(bgr, 1.4, gaussian, -0.4, 0)
+            
+            # Saturation oshirish
+            hsv = cv2.cvtColor(bgr, cv2.COLOR_BGR2HSV)
+            h, s, v = cv2.split(hsv)
+            s = cv2.add(s, 20)
+            hsv = cv2.merge((h, s, v))
+            bgr = cv2.cvtColor(hsv, cv2.COLOR_HSV2BGR)
+            
+            return cv2.cvtColor(bgr, cv2.COLOR_BGR2RGB)
+
+        processed = video.image_transform(color_frame)
+        audio_params = {"audio_codec": "aac"} if video.audio else {"audio": False}
+        processed.write_videofile(
+            output_path,
+            codec="libx264",
+            fps=video.fps or 24,
+            preset="ultrafast",
+            threads=4,
+            logger=None,
+            **audio_params
+        )
+        
+        video.close()
+        processed.close()
+        return output_path if os.path.exists(output_path) else None
+    except Exception as e:
+        logger.error(f"Color Correct xatosi: {e}")
+        return None
+
+def process_video_remove_audio(video_path, output_path, progress_callback=None):
+    """Videodan ovozni olib tashlaydi."""
+    from moviepy.video.io.VideoFileClip import VideoFileClip
+    
+    try:
+        video_path = os.path.abspath(video_path)
+        output_path = os.path.abspath(output_path)
+        
+        video = VideoFileClip(video_path)
+        muted = video.without_audio()
+        
+        muted.write_videofile(
+            output_path,
+            codec="libx264",
+            fps=video.fps or 24,
+            preset="ultrafast",
+            threads=4,
+            logger=None
+        )
+        
+        video.close()
+        muted.close()
+        return output_path if os.path.exists(output_path) else None
+    except Exception as e:
+        logger.error(f"Remove audio xatosi: {e}")
+        return None
+
+def process_video_trim(video_path, output_path, progress_callback=None, max_duration=15):
+    """Videoning birinchi N soniyasini kesib oladi."""
+    from moviepy.video.io.VideoFileClip import VideoFileClip
+    
+    try:
+        video_path = os.path.abspath(video_path)
+        output_path = os.path.abspath(output_path)
+        
+        video = VideoFileClip(video_path)
+        
+        # Agar video allaqachon qisqa bo'lsa, barini olish
+        end_time = min(max_duration, video.duration)
+        trimmed = video.subclipped(0, end_time)
+        
+        audio_params = {"audio_codec": "aac"} if video.audio else {"audio": False}
+        trimmed.write_videofile(
+            output_path,
+            codec="libx264",
+            fps=video.fps or 24,
+            preset="ultrafast",
+            threads=4,
+            logger=None,
+            **audio_params
+        )
+        
+        video.close()
+        trimmed.close()
+        return output_path if os.path.exists(output_path) else None
+    except Exception as e:
+        logger.error(f"Video trim xatosi: {e}")
+        return None
+
+def process_video_face_fix(video_path, output_path, progress_callback=None):
+    """Video kadrlardagi yuzlarni aniqlaydi va tiniqlashtiradi."""
+    from moviepy.video.io.VideoFileClip import VideoFileClip
+    
+    try:
+        video_path = os.path.abspath(video_path)
+        output_path = os.path.abspath(output_path)
+        
+        video = VideoFileClip(video_path)
+        total_frames = int(video.fps * video.duration)
+        current_frame = [0]
+        face_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + 'haarcascade_frontalface_default.xml')
+
+        def face_frame(frame):
+            current_frame[0] += 1
+            if progress_callback and current_frame[0] % 15 == 0:
+                percent = min(99, int((current_frame[0] / total_frames) * 100))
+                progress_callback(percent)
+            
+            bgr = cv2.cvtColor(frame, cv2.COLOR_RGB2BGR)
+            gray = cv2.cvtColor(bgr, cv2.COLOR_BGR2GRAY)
+            # HistEq
+            gray = cv2.equalizeHist(gray)
+            faces = face_cascade.detectMultiScale(gray, scaleFactor=1.1, minNeighbors=5, minSize=(40, 40))
+            
+            for (x, y, w, h) in faces:
+                p = int(w * 0.1)
+                x1, y1 = max(0, x - p), max(0, y - p)
+                x2, y2 = min(bgr.shape[1], x + w + p), min(bgr.shape[0], y + h + p)
+                face_roi = bgr[y1:y2, x1:x2]
+                
+                # Bilateral + Median + Sharpen
+                smoothed = cv2.bilateralFilter(face_roi, 7, 50, 50)
+                smoothed = cv2.medianBlur(smoothed, 3)
+                gaussian = cv2.GaussianBlur(smoothed, (0, 0), 2.0)
+                sharpened = cv2.addWeighted(smoothed, 1.8, gaussian, -0.8, 0)
+                
+                # CLAHE
+                lab = cv2.cvtColor(sharpened, cv2.COLOR_BGR2LAB)
+                l, a, b = cv2.split(lab)
+                clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8,8))
+                cl = clahe.apply(l)
+                lab = cv2.merge((cl, a, b))
+                face_roi = cv2.cvtColor(lab, cv2.COLOR_LAB2BGR)
+                
+                bgr[y1:y2, x1:x2] = face_roi
+            
+            return cv2.cvtColor(bgr, cv2.COLOR_BGR2RGB)
+
+        processed = video.image_transform(face_frame)
+        audio_params = {"audio_codec": "aac"} if video.audio else {"audio": False}
+        
+        processed.write_videofile(
+            output_path,
+            codec="libx264",
+            fps=video.fps or 24,
+            preset="ultrafast",
+            threads=4,
+            logger=None,
+            **audio_params
+        )
+        
+        video.close()
+        processed.close()
+        return output_path if os.path.exists(output_path) else None
+    except Exception as e:
+        logger.error(f"Video Face Fix xatosi: {e}")
+        return None
+
+def process_video_auto_enhance(video_path, output_path, progress_callback=None):
+    """Video ranglarini va yorug'ligini avtomatik yaxshilaydi."""
+    from moviepy.video.io.VideoFileClip import VideoFileClip
+    
+    try:
+        video_path = os.path.abspath(video_path)
+        output_path = os.path.abspath(output_path)
+        
+        video = VideoFileClip(video_path)
+        total_frames = int(video.fps * video.duration)
+        current_frame = [0]
+
+        def enhance_frame(frame):
+            current_frame[0] += 1
+            if progress_callback and current_frame[0] % 15 == 0:
+                percent = min(99, int((current_frame[0] / total_frames) * 100))
+                progress_callback(percent)
+            
+            bgr = cv2.cvtColor(frame, cv2.COLOR_RGB2BGR)
+            
+            # CLAHE
+            lab = cv2.cvtColor(bgr, cv2.COLOR_BGR2LAB)
+            l, a, b = cv2.split(lab)
+            clahe = cv2.createCLAHE(clipLimit=2.5, tileGridSize=(8,8))
+            cl = clahe.apply(l)
+            lab = cv2.merge((cl, a, b))
+            enhanced = cv2.cvtColor(lab, cv2.COLOR_LAB2BGR)
+            
+            # Unsharp
+            gaussian = cv2.GaussianBlur(enhanced, (0, 0), 1.5)
+            enhanced = cv2.addWeighted(enhanced, 1.3, gaussian, -0.3, 0)
+            
+            # Saturation
+            hsv = cv2.cvtColor(enhanced, cv2.COLOR_BGR2HSV)
+            h, s, v = cv2.split(hsv)
+            s = cv2.add(s, 15)
+            hsv = cv2.merge((h, s, v))
+            enhanced = cv2.cvtColor(hsv, cv2.COLOR_HSV2BGR)
+            
+            return cv2.cvtColor(enhanced, cv2.COLOR_BGR2RGB)
+
+        processed = video.image_transform(enhance_frame)
+        audio_params = {"audio_codec": "aac"} if video.audio else {"audio": False}
+        
+        processed.write_videofile(
+            output_path,
+            codec="libx264",
+            fps=video.fps or 24,
+            preset="ultrafast",
+            threads=4,
+            logger=None,
+            **audio_params
+        )
+
+        video.close()
+        processed.close()
+        return output_path if os.path.exists(output_path) else None
+    except Exception as e:
+        logger.error(f"Video Auto Enhance xatosi: {e}")
+        return None
+
+def process_video_fps_boost(video_path, output_path, target_fps=60, progress_callback=None):
+    """Videoni Optical Flow orqali silliq FPS ga ko'taradi (frame interpolation).
+    
+    Kuchli bidirectional flow + sharpen + yuqori sifat codec.
+    """
+    try:
+        video_path = os.path.abspath(video_path)
+        output_path = os.path.abspath(output_path)
+        
+        cap = cv2.VideoCapture(video_path)
+        if not cap.isOpened():
+            logger.error(f"Video ochilmadi: {video_path}")
+            return None
+        
+        orig_fps = cap.get(cv2.CAP_PROP_FPS) or 24
+        width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+        height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+        total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+        
+        # Agar video allaqachon target_fps dan yuqori bo'lsa
+        if orig_fps >= target_fps:
+            cap.release()
+            from moviepy.video.io.VideoFileClip import VideoFileClip
+            video = VideoFileClip(video_path)
+            video.write_videofile(output_path, fps=target_fps, codec="libx264",
+                                 audio_codec="aac", preset="medium",
+                                 bitrate="8000k", threads=4, logger=None)
+            video.close()
+            return output_path if os.path.exists(output_path) else None
+        
+        # Nechta oraliq kadr qo'shish kerak
+        multiplier = max(2, round(target_fps / orig_fps))
+        actual_target_fps = orig_fps * multiplier
+        
+        logger.info(f"FPS Boost: {orig_fps} -> {actual_target_fps} (x{multiplier})")
+        
+        # Vaqtincha faylga yozish (audio'siz)
+        temp_video_path = output_path + "_temp.avi"
+        fourcc = cv2.VideoWriter_fourcc(*'MJPG')  # Yuqori sifat
+        writer = cv2.VideoWriter(temp_video_path, fourcc, actual_target_fps, (width, height))
+        
+        ret, prev_frame = cap.read()
+        if not ret:
+            cap.release()
+            return None
+        
+        frame_count = 0
+        
+        # Koordinata gridi (bir marta hisoblash)
+        h, w = prev_frame.shape[:2]
+        y_coords, x_coords = np.mgrid[0:h, 0:w].astype(np.float32)
+        
+        while True:
+            ret, next_frame = cap.read()
+            if not ret:
+                writer.write(prev_frame)
+                break
+            
+            frame_count += 1
+            if progress_callback and frame_count % 3 == 0:
+                percent = min(99, int((frame_count / total_frames) * 100))
+                progress_callback(percent)
+            
+            # Asl kadrni yozish
+            writer.write(prev_frame)
+            
+            # Ikki tomonlama Optical Flow (Bidirectional)
+            prev_gray = cv2.cvtColor(prev_frame, cv2.COLOR_BGR2GRAY)
+            next_gray = cv2.cvtColor(next_frame, cv2.COLOR_BGR2GRAY)
+            
+            # Oldinga oqim (prev -> next)
+            flow_forward = cv2.calcOpticalFlowFarneback(
+                prev_gray, next_gray, None,
+                pyr_scale=0.5, levels=5, winsize=21,
+                iterations=5, poly_n=7, poly_sigma=1.5,
+                flags=cv2.OPTFLOW_FARNEBACK_GAUSSIAN
+            )
+            
+            # Orqaga oqim (next -> prev)
+            flow_backward = cv2.calcOpticalFlowFarneback(
+                next_gray, prev_gray, None,
+                pyr_scale=0.5, levels=5, winsize=21,
+                iterations=5, poly_n=7, poly_sigma=1.5,
+                flags=cv2.OPTFLOW_FARNEBACK_GAUSSIAN
+            )
+            
+            # Oraliq kadrlarni yaratish
+            for i in range(1, multiplier):
+                alpha = i / multiplier
+                
+                # Prev -> oraliq pozitsiya (oldinga warp)
+                flow_f = flow_forward * alpha
+                map_x_f = (x_coords + flow_f[..., 0]).astype(np.float32)
+                map_y_f = (y_coords + flow_f[..., 1]).astype(np.float32)
+                warped_prev = cv2.remap(prev_frame, map_x_f, map_y_f,
+                                        cv2.INTER_CUBIC, borderMode=cv2.BORDER_REFLECT_101)
+                
+                # Next -> oraliq pozitsiya (orqaga warp)
+                flow_b = flow_backward * (1 - alpha)
+                map_x_b = (x_coords + flow_b[..., 0]).astype(np.float32)
+                map_y_b = (y_coords + flow_b[..., 1]).astype(np.float32)
+                warped_next = cv2.remap(next_frame, map_x_b, map_y_b,
+                                        cv2.INTER_CUBIC, borderMode=cv2.BORDER_REFLECT_101)
+                
+                # Ikki warp natijasini birlashtirish
+                interpolated = cv2.addWeighted(warped_prev, 1 - alpha, warped_next, alpha, 0)
+                
+                # Xiralashishga qarshi o'tkirlashtirish (Unsharp Mask)
+                gaussian = cv2.GaussianBlur(interpolated, (0, 0), 1.0)
+                interpolated = cv2.addWeighted(interpolated, 1.3, gaussian, -0.3, 0)
+                
+                writer.write(interpolated)
+            
+            prev_frame = next_frame
+        
+        cap.release()
+        writer.release()
+        
+        # Audio'ni biriktirish va yuqori sifatda saqlash
+        try:
+            from moviepy.video.io.VideoFileClip import VideoFileClip
+            original = VideoFileClip(video_path)
+            processed = VideoFileClip(temp_video_path)
+            
+            if original.audio is not None:
+                final = processed.with_audio(original.audio)
+                final.write_videofile(output_path, codec="libx264", audio_codec="aac",
+                                      preset="medium", bitrate="8000k",
+                                      threads=4, logger=None)
+                final.close()
+            else:
+                processed.write_videofile(output_path, codec="libx264",
+                                          preset="medium", bitrate="8000k",
+                                          threads=4, logger=None)
+            
+            original.close()
+            processed.close()
+        except Exception as audio_err:
+            logger.warning(f"Audio biriktirish xatosi: {audio_err}")
+            import shutil
+            shutil.move(temp_video_path, output_path)
+        
+        # Tozalash
+        if os.path.exists(temp_video_path):
+            try: os.remove(temp_video_path)
+            except: pass
+        
+        return output_path if os.path.exists(output_path) else None
+    except Exception as e:
+        logger.error(f"FPS Boost xatosi: {e}")
+        return None

main.py

@@ -0,0 +1,407 @@
+import os
+import logging
+import asyncio
+import collections
+import gc
+from datetime import datetime, timedelta
+from dotenv import load_dotenv
+
+from telegram import Update, InlineKeyboardButton, InlineKeyboardMarkup, constants
+from telegram.ext import (
+    ApplicationBuilder, 
+    CommandHandler, 
+    MessageHandler, 
+    filters, 
+    ContextTypes, 
+    CallbackQueryHandler
+)
+
+from filters import (
+    apply_retro_filter, 
+    upscale_image, 
+    process_video_retro, 
+    process_video_upscale, 
+    apply_face_restore, 
+    apply_auto_enhance,
+    process_video_slowmo,
+    process_video_bw,
+    process_video_color_correct,
+    process_video_remove_audio,
+    process_video_trim,
+    process_video_face_fix,
+    process_video_auto_enhance,
+    process_video_fps_boost
+)
+from database import db
+from concurrent.futures import ThreadPoolExecutor
+from apscheduler.schedulers.asyncio import AsyncIOScheduler
+
+# Muhit o'zgaruvchilarini yuklash
+load_dotenv()
+TOKEN = os.getenv("TELEGRAM_BOT_TOKEN")
+
+# Loglarni sozlash
+logging.basicConfig(
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    level=logging.INFO
+)
+logger = logging.getLogger(__name__)
+
+# Global media storage
+media_storage = {}
+processing_semaphore = asyncio.Semaphore(2) # Maksimal 2 ta parallel jarayon
+executor = ThreadPoolExecutor(max_workers=4)
+base_dir = os.path.dirname(os.path.abspath(__file__))
+
+# Scheduler for cleanup
+scheduler = AsyncIOScheduler()
+
+async def post_init(application):
+    """Bot ishga tushgandan so'ng bajariladigan amallar."""
+    scheduler.add_job(cleanup_old_files, 'interval', minutes=30)
+    scheduler.start()
+    logger.info("Scheduler va tozalash tizimi ishga tushdi.")
+
+async def cleanup_old_files():
+    """Eski fayllarni va xotirani tozalash."""
+    now = datetime.now()
+    to_delete = [k for k, v in media_storage.items() if (now - v.get('timestamp', now)) > timedelta(hours=1)]
+    for k in to_delete:
+        del media_storage[k]
+    
+    for f in os.listdir(base_dir):
+        if (f.startswith("in_") or f.startswith("out_")) and (now - datetime.fromtimestamp(os.path.getmtime(os.path.join(base_dir, f)))) > timedelta(hours=1):
+            try:
+                os.remove(os.path.join(base_dir, f))
+            except: pass
+
+# --- UI Helpers ---
+
+def get_main_menu_keyboard():
+    """Asosiy menyu tugmalari."""
+    keyboard = [
+        [
+            InlineKeyboardButton("📜 Tarix", callback_data="nav|history"),
+            InlineKeyboardButton("⚙️ Sozlamalar", callback_data="nav|settings")
+        ],
+        [
+            InlineKeyboardButton("ℹ️ Yordam", callback_data="nav|help")
+        ]
+    ]
+    return InlineKeyboardMarkup(keyboard)
+
+async def show_main_menu(update_or_query, context):
+    """Asosiy menyuni ko'rsatish."""
+    text = (
+        "✨ **Mukammal Filtr Botga xush kelibsiz!**\n\n"
+        "Menga rasm yoki video yuboring, so'ngra mo''jizani ko'ring. 🎨✨\n\n"
+        "💡 *Pastdagi tugmalar orqali botni boshqarishingiz mumkin:*"
+    )
+    
+    if isinstance(update_or_query, Update):
+        await update_or_query.message.reply_text(text, reply_markup=get_main_menu_keyboard(), parse_mode=constants.ParseMode.MARKDOWN)
+    else:
+        await update_or_query.edit_message_text(text, reply_markup=get_main_menu_keyboard(), parse_mode=constants.ParseMode.MARKDOWN)
+
+# --- Handlers ---
+
+async def settings_command(update_or_query, context: ContextTypes.DEFAULT_TYPE):
+    """Sozlamalar menyusi."""
+    if isinstance(update_or_query, Update):
+        user_id = update_or_query.effective_user.id
+    else:
+        user_id = update_or_query.from_user.id
+    
+    current_filter = db.get_user_settings(user_id)
+    
+    text = (
+        "\u2699\ufe0f **Sozlamalar**\n\n"
+        f"Joriy standart filtr: **{current_filter.upper()}**\n"
+        "Yangi standart filtrni tanlang:"
+    )
+    
+    keyboard = [
+        [
+            InlineKeyboardButton("\ud83c\udf9e Retro", callback_data="set|retro"),
+            InlineKeyboardButton("\ud83d\udc8e Ultra HD", callback_data="set|upscale")
+        ],
+        [
+            InlineKeyboardButton("\ud83e\udd16 Face Fix", callback_data="set|face_fix"),
+            InlineKeyboardButton("\u2728 Auto-Enhance", callback_data="set|auto_enhance")
+        ],
+        [InlineKeyboardButton("\ud83d\udd19 Orqaga", callback_data="nav|main")]
+    ]
+    
+    if isinstance(update_or_query, Update):
+        await update_or_query.message.reply_text(text, reply_markup=InlineKeyboardMarkup(keyboard), parse_mode=constants.ParseMode.MARKDOWN)
+    else:
+        await update_or_query.edit_message_text(text, reply_markup=InlineKeyboardMarkup(keyboard), parse_mode=constants.ParseMode.MARKDOWN)
+
+async def settings_callback_handler(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """Filtrni tanlash callbacki."""
+    query = update.callback_query
+    await query.answer()
+    
+    filter_type = query.data.split("|")[1]
+    db.set_default_filter(query.from_user.id, filter_type)
+    
+    name_map = {"retro": "RETRO", "upscale": "ULTRA HD", "face_fix": "FACE FIX", "auto_enhance": "AUTO-ENHANCE"}
+    display_name = name_map.get(filter_type, filter_type.upper())
+    
+    await query.edit_message_text(
+        f"\u2705 Standart filtr **{display_name}** ga o'zgartirildi!",
+        reply_markup=InlineKeyboardMarkup([[InlineKeyboardButton("\ud83d\udd19 Orqaga", callback_data="nav|settings")]]),
+        parse_mode=constants.ParseMode.MARKDOWN
+    )
+
+async def start(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """/start buyrug'i."""
+    user = update.effective_user
+    db.add_user(user.id, user.username, user.first_name)
+    await show_main_menu(update, context)
+
+async def handle_photo(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """Rasmlarni qabul qilish."""
+    try:
+        photo = update.message.photo[-1]
+        file_id = photo.file_id
+        short_id = str(update.message.message_id)
+        media_storage[short_id] = {"file_id": file_id, "type": "photo", "timestamp": datetime.now()}
+        
+        text = "🖼 **Rasm qabul qilindi!**\nQanday mo''jiza yaratamiz?"
+        if photo.file_size < 150000:
+            text = "🔍 **Tahlil:** Rasm biroz xira. 'Ultra HD' yoki 'Face Fix' tavsiya etiladi!\n\n" + text
+
+        keyboard = [
+            [
+                InlineKeyboardButton("🎞 Retro", callback_data=f"r|p|{short_id}"),
+                InlineKeyboardButton("💎 Ultra HD", callback_data=f"u|p|{short_id}")
+            ],
+            [
+                InlineKeyboardButton("🤖 Face Fix", callback_data=f"f|p|{short_id}"),
+                InlineKeyboardButton("✨ Auto-Enhance", callback_data=f"a|p|{short_id}")
+            ],
+            [
+                InlineKeyboardButton("🔙 Bekor qilish", callback_data="nav|main")
+            ]
+        ]
+        await update.message.reply_text(text, reply_markup=InlineKeyboardMarkup(keyboard), parse_mode=constants.ParseMode.MARKDOWN)
+    except Exception as e:
+        logger.error(f"Error in handle_photo: {e}")
+        await update.message.reply_text("❌ Xatolik yuz berdi.")
+
+async def handle_video(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """Videolarni qabul qilish."""
+    try:
+        message = update.message
+        video = message.video or message.animation or message.document
+        
+        if message.document and not (message.document.mime_type or "").startswith('video/'):
+            return
+
+        file_id = getattr(video, 'file_id', None)
+        if not file_id: return
+        
+        if getattr(video, 'file_size', 0) > 50 * 1024 * 1024:
+            await message.reply_text("⚠️ Video juda katta (max 50MB).")
+            return
+
+        short_id = str(message.message_id)
+        media_storage[short_id] = {"file_id": file_id, "type": "video", "timestamp": datetime.now()}
+        
+        keyboard = [
+            [
+                InlineKeyboardButton("🎞 Retro", callback_data=f"r|v|{short_id}"),
+                InlineKeyboardButton("💎 Ultra HD", callback_data=f"u|v|{short_id}")
+            ],
+            [
+                InlineKeyboardButton("🐢 Slow-Mo", callback_data=f"s|v|{short_id}"),
+                InlineKeyboardButton("⬛ Oq-Qora", callback_data=f"bw|v|{short_id}")
+            ],
+            [
+                InlineKeyboardButton("🌈 Rang Fix", callback_data=f"cc|v|{short_id}"),
+                InlineKeyboardButton("✨ Auto-Enhance", callback_data=f"va|v|{short_id}")
+            ],
+            [
+                InlineKeyboardButton("🤖 Face Fix", callback_data=f"vf|v|{short_id}"),
+                InlineKeyboardButton("🔇 Ovoz o'chirish", callback_data=f"ra|v|{short_id}")
+            ],
+            [
+                InlineKeyboardButton("✂️ Kesish (15s)", callback_data=f"t|v|{short_id}")
+            ],
+            [
+                InlineKeyboardButton("30 FPS", callback_data=f"fps30|v|{short_id}"),
+                InlineKeyboardButton("60 FPS", callback_data=f"fps60|v|{short_id}"),
+                InlineKeyboardButton("120 FPS", callback_data=f"fps120|v|{short_id}")
+            ],
+            [
+                InlineKeyboardButton("🔙 Bekor qilish", callback_data="nav|main")
+            ]
+        ]
+        await update.message.reply_text("🎥 **Video qabul qilindi!**\nQanday effekt beramiz?", reply_markup=InlineKeyboardMarkup(keyboard), parse_mode=constants.ParseMode.MARKDOWN)
+    except Exception as e:
+        logger.error(f"Error in handle_video: {e}")
+        await update.message.reply_text("❌ Xatolik yuz berdi.")
+
+async def navigation_handler(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """Navigatsiya tugmalari (Menu, History, Settings)."""
+    query = update.callback_query
+    await query.answer()
+    
+    data = query.data.split("|")[1]
+    
+    if data == "main":
+        await show_main_menu(query, context)
+    
+    elif data == "history":
+        history = db.get_user_history(query.from_user.id)
+        if not history:
+            text = "📭 Tarix bo'sh."
+        else:
+            text = "📜 **Sizning oxirgi 5 ta amalingiz:**\n\n"
+            for i, (m_type, f_type, dt) in enumerate(history, 1):
+                dt_obj = datetime.fromisoformat(dt).strftime("%H:%M %d.%m")
+                text += f"{i}. {'🖼' if m_type == 'photo' else '🎥'} {f_type.upper()} - {dt_obj}\n"
+        
+        keyboard = [[InlineKeyboardButton("🔙 Orqaga", callback_data="nav|main")]]
+        await query.edit_message_text(text, reply_markup=InlineKeyboardMarkup(keyboard), parse_mode=constants.ParseMode.MARKDOWN)
+    
+    elif data == "settings":
+        await settings_command(query, context)
+        
+    elif data == "help":
+        text = (
+            "ℹ️ **Yordam**\n\n"
+            "1. Rasm yoki Video yuboring.\n"
+            "2. Tugmalar orqali filtrni tanlang.\n"
+            "3. Progress bar orqali jarayonni kuzating.\n"
+            "4. Natijani yuklab oling!"
+        )
+        keyboard = [[InlineKeyboardButton("🔙 Orqaga", callback_data="nav|main")]]
+        await query.edit_message_text(text, reply_markup=InlineKeyboardMarkup(keyboard), parse_mode=constants.ParseMode.MARKDOWN)
+
+async def button_handler(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """Filtr tugmalari."""
+    query = update.callback_query
+    await query.answer()
+    
+    try:
+        data = query.data.split("|")
+        action, m_type, short_id = data[0], data[1], data[2]
+        
+        if short_id not in media_storage:
+            await query.edit_message_text("⚠️ Media ma'lumotlari topilmadi. Iltimos, qayta yuboring.")
+            return
+
+        async with processing_semaphore:
+            media_info = media_storage[short_id]
+            file_id = media_info["file_id"]
+            
+            msg = await query.edit_message_text("⏳ Jarayon boshlanmoqda...")
+            
+            file = await context.bot.get_file(file_id, read_timeout=60)
+            ext = "mp4" if m_type == "v" else "jpg"
+            input_path = os.path.join(base_dir, f"in_{short_id}.{ext}")
+            output_path = os.path.join(base_dir, f"out_{short_id}.{ext}")
+            await file.download_to_drive(input_path, read_timeout=60)
+
+            last_percent = [0]
+            async def progress(p):
+                # Faqat 10% dan oshganda xabarni yangilash (Telegram API ni qiynamaslik uchun)
+                if p - last_percent[0] >= 10 or p == 99:
+                    last_percent[0] = p
+                    bar = "█" * (p // 10) + "░" * (10 - p // 10)
+                    try: await query.edit_message_text(f"⚙️ Qayta ishlanmoqda...\n[{bar}] {p}%")
+                    except: pass
+
+            loop = asyncio.get_event_loop()
+            callback = lambda p: asyncio.run_coroutine_threadsafe(progress(p), loop)
+            success_path = None
+
+            logger.info(f"Processing started: {action} on {m_type} for {short_id}")
+
+            if m_type == "p":
+                func = {
+                    "r": apply_retro_filter, "u": upscale_image, 
+                    "f": apply_face_restore, "a": apply_auto_enhance
+                }.get(action)
+                if not func:
+                    logger.error(f"Unknown action: {action}")
+                    await context.bot.send_message(query.message.chat_id, "❌ Noma'lum amal.")
+                    return
+                success_path = await loop.run_in_executor(executor, func, input_path, output_path)
+            else:
+                # FPS Boost uchun alohida mantiq
+                if action in ("fps30", "fps60", "fps120"):
+                    fps_map = {"fps30": 30, "fps60": 60, "fps120": 120}
+                    target = fps_map[action]
+                    success_path = await loop.run_in_executor(
+                        executor, process_video_fps_boost, input_path, output_path, target, callback
+                    )
+                else:
+                    video_funcs = {
+                        "r": process_video_retro,
+                        "u": process_video_upscale,
+                        "s": process_video_slowmo,
+                        "bw": process_video_bw,
+                        "cc": process_video_color_correct,
+                        "ra": process_video_remove_audio,
+                        "t": process_video_trim,
+                        "vf": process_video_face_fix,
+                        "va": process_video_auto_enhance
+                    }
+                    func = video_funcs.get(action)
+                    if not func:
+                        logger.error(f"Unknown video action: {action}")
+                        await context.bot.send_message(query.message.chat_id, "❌ Noma'lum video amali.")
+                        return
+                    success_path = await loop.run_in_executor(executor, func, input_path, output_path, callback)
+
+            logger.info(f"Processing finished. Success path: {success_path}")
+
+            if success_path and os.path.exists(output_path):
+                # Save to history
+                f_name = {
+                    "r": "retro", "u": "4k", "f": "face fix", "a": "auto enhance",
+                    "s": "slow motion", "bw": "oq-qora", "cc": "rang fix",
+                    "ra": "ovoz olib tashlash", "t": "kesish", "vf": "video face fix",
+                    "va": "video auto enhance", "fps30": "30 FPS boost",
+                    "fps60": "60 FPS boost", "fps120": "120 FPS boost"
+                }.get(action, "filter")
+                db.log_history(query.from_user.id, "photo" if m_type == "p" else "video", f_name, file_id)
+                
+                with open(output_path, 'rb') as f:
+                    caption = f"✅ <b>{f_name.upper()}</b> muvaffaqiyatli qo'llanildi!"
+                    if m_type == "p":
+                        await context.bot.send_photo(query.message.chat_id, f, caption=caption, parse_mode=constants.ParseMode.HTML, read_timeout=60, write_timeout=60)
+                    else:
+                        await context.bot.send_video(query.message.chat_id, f, caption=caption, parse_mode=constants.ParseMode.HTML, read_timeout=120, write_timeout=120)
+            else:
+                logger.error(f"Processing failed for {short_id}. Action: {action}")
+                await context.bot.send_message(query.message.chat_id, "❌ Afsuski, ishlov berishda xatolik yuz berdi yoki natija topilmadi.")
+
+        await query.delete_message()
+    except Exception as e:
+        logger.error(f"Global button_handler error: {e}")
+        try: await context.bot.send_message(query.message.chat_id, f"❌ Tizimli xatolik: {e}")
+        except: pass
+    finally:
+        try:
+            if os.path.exists(input_path): os.remove(input_path)
+            if os.path.exists(output_path): os.remove(output_path)
+        except: pass
+        
+        # Xotirani majburiy tozalash (RAM to'lishini oldini oladi)
+        gc.collect()
+
+if __name__ == '__main__':
+    if TOKEN:
+        app = ApplicationBuilder().token(TOKEN).post_init(post_init).build()
+        app.add_handler(CommandHandler("start", start))
+        app.add_handler(CallbackQueryHandler(navigation_handler, pattern=r"^nav\|"))
+        app.add_handler(CallbackQueryHandler(settings_callback_handler, pattern=r"^set\|"))
+        app.add_handler(CallbackQueryHandler(button_handler))
+        app.add_handler(MessageHandler(filters.PHOTO, handle_photo))
+        app.add_handler(MessageHandler(filters.VIDEO | filters.ANIMATION | filters.Document.ALL, handle_video))
+        print("Bot ishga tushdi...")
+        app.run_polling()

requirements.txt

@@ -0,0 +1,9 @@
+python-telegram-bot[job-queue]
+opencv-python
+Pillow
+moviepy
+torch
+torchvision
+numpy
+python-dotenv
+apscheduler