Phase 11: DRY refactoring, NudeNet frame skip, Rate Limit, GC yaxshilash

filters.py

@@ -3,6 +3,12 @@ import numpy as np
 from PIL import Image, ImageEnhance
 import os
 import logging
+from moviepy.video.io.VideoFileClip import VideoFileClip
+
+try:
+    from nudenet import NudeDetector
+except ImportError:
+    NudeDetector = None
 
 # Loglarni filters.py uchun ham alohida sozlash
 logger = logging.getLogger(__name__)
@@ -89,115 +95,77 @@ def upscale_image(image_path, output_path, scale=2):
         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
-    
+def _apply_video_transform(video_path, output_path, transform_func, progress_callback=None, fps_override=None):
+    """Barcha video filtrlar uchun umumiy ishlov beruvchi (DRY qoidasi uchun)."""
     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)
+        total_frames = int((fps_override or video.fps) * video.duration)
         current_frame = [0]
 
-        def filter_frame(frame):
+        def wrapped_transform(frame):
             current_frame[0] += 1
             if progress_callback and current_frame[0] % 15 == 0:
-                percent = min(99, int((current_frame[0] / total_frames) * 100))
+                percent = min(99, int((current_frame[0] / max(1, total_frames)) * 100))
                 progress_callback(percent)
+            return transform_func(frame)
 
-            # 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 = video.image_transform(wrapped_transform)
+        audio_params = {"audio_codec": "aac"} if video.audio else {"audio": False}
+        
         processed_video.write_videofile(
             output_path, 
             codec="libx264", 
-            audio_codec="aac", 
-            fps=video.fps or 24,
-            preset="ultrafast", # Tezroq bo'lishi uchun
+            fps=fps_override or video.fps or 24,
+            preset="ultrafast",
             threads=4,
-            logger=None
+            logger=None,
+            **audio_params
         )
         
         video.close()
         processed_video.close()
-        
-        if os.path.exists(output_path):
-            return output_path
-        return None
+        return output_path if os.path.exists(output_path) else None
     except Exception as e:
-        logger.error(f"Video process xatosi: {e}")
+        logger.error(f"Video transform 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)
+def process_video_retro(video_path, output_path, progress_callback=None):
+    """Videoga retro filtrini qo'llaydi."""
+    def filter_frame(frame):
+        if frame.shape[2] == 4:
+            frame = frame[:, :, :3]
+        elif len(frame.shape) == 2:
+            frame = cv2.cvtColor(frame, cv2.COLOR_GRAY2RGB)
             
-            return cv2.cvtColor(unsharp_image, cv2.COLOR_BGR2RGB)
+        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)
+        
+    return _apply_video_transform(video_path, output_path, filter_frame, progress_callback)
 
-        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
-        )
+def process_video_upscale(video_path, output_path, progress_callback=None):
+    """Videoning sifatini (o'lcham va o'tkirlik) oshiradi."""
+    def upscale_frame(frame):
+        bgr = cv2.cvtColor(frame, cv2.COLOR_RGB2BGR)
+        h, w = bgr.shape[:2]
+        upscaled = cv2.resize(bgr, (int(w*1.5), int(h*1.5)), interpolation=cv2.INTER_LANCZOS4)
         
-        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
+        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)
+        
+    return _apply_video_transform(video_path, output_path, upscale_frame, progress_callback)
 
 def apply_face_restore(image_path, output_path):
     """Yuzlarni aniqlaydi va ularni tiniqlashtiradi (Face Fix)."""
@@ -288,29 +256,17 @@ def apply_auto_enhance(image_path, output_path):
 
 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
+            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
@@ -320,127 +276,51 @@ def process_video_slowmo(video_path, output_path, progress_callback=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)
+    def bw_frame(frame):
+        gray = cv2.cvtColor(frame, cv2.COLOR_RGB2GRAY)
+        clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8,8))
+        gray = clahe.apply(gray)
+        return cv2.cvtColor(gray, cv2.COLOR_GRAY2RGB)
         
-        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
+    return _apply_video_transform(video_path, output_path, bw_frame, progress_callback)
 
 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)
+    def color_frame(frame):
+        bgr = cv2.cvtColor(frame, cv2.COLOR_RGB2BGR)
         
-        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
-        )
+        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)
         
-        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
+        gaussian = cv2.GaussianBlur(bgr, (0, 0), 2.0)
+        bgr = cv2.addWeighted(bgr, 1.4, gaussian, -0.4, 0)
+        
+        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)
+        
+    return _apply_video_transform(video_path, output_path, color_frame, progress_callback)
 
 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
+            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
@@ -450,29 +330,18 @@ def process_video_remove_audio(video_path, output_path, progress_callback=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
+            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
@@ -482,133 +351,62 @@ def process_video_trim(video_path, output_path, progress_callback=None, max_dura
 
 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
+    face_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + 'haarcascade_frontalface_default.xml')
     
-    try:
-        video_path = os.path.abspath(video_path)
-        output_path = os.path.abspath(output_path)
+    def face_frame(frame):
+        bgr = cv2.cvtColor(frame, cv2.COLOR_RGB2BGR)
+        gray = cv2.cvtColor(bgr, cv2.COLOR_BGR2GRAY)
+        gray = cv2.equalizeHist(gray)
+        faces = face_cascade.detectMultiScale(gray, scaleFactor=1.1, minNeighbors=5, minSize=(40, 40))
         
-        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)
+        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]
             
-            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))
+            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)
             
-            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
+            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)
             
-            return cv2.cvtColor(bgr, cv2.COLOR_BGR2RGB)
-
-        processed = video.image_transform(face_frame)
-        audio_params = {"audio_codec": "aac"} if video.audio else {"audio": False}
+            bgr[y1:y2, x1:x2] = face_roi
         
-        processed.write_videofile(
-            output_path,
-            codec="libx264",
-            fps=video.fps or 24,
-            preset="ultrafast",
-            threads=4,
-            logger=None,
-            **audio_params
-        )
+        return cv2.cvtColor(bgr, cv2.COLOR_BGR2RGB)
         
-        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
+    return _apply_video_transform(video_path, output_path, face_frame, progress_callback)
 
 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)
+    def enhance_frame(frame):
+        bgr = cv2.cvtColor(frame, cv2.COLOR_RGB2BGR)
         
-        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}
+        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)
         
-        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
+        gaussian = cv2.GaussianBlur(enhanced, (0, 0), 1.5)
+        enhanced = cv2.addWeighted(enhanced, 1.3, gaussian, -0.3, 0)
+        
+        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)
+        
+    return _apply_video_transform(video_path, output_path, enhance_frame, progress_callback)
 
 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).
@@ -632,7 +430,6 @@ def process_video_fps_boost(video_path, output_path, target_fps=60, progress_cal
         # 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",
@@ -730,7 +527,6 @@ def process_video_fps_boost(video_path, output_path, target_fps=60, progress_cal
         
         # Audio'ni biriktirish va yuqori sifatda saqlash
         try:
-            from moviepy.video.io.VideoFileClip import VideoFileClip
             original = VideoFileClip(video_path)
             processed = VideoFileClip(temp_video_path)
             
@@ -769,47 +565,51 @@ def process_video_fps_boost(video_path, output_path, target_fps=60, progress_cal
 _nude_detector = None
 
 def get_nude_detector():
-    """Nudity detektorini lazily (kerak bo'lganda) yuklash."""
+    """Nudity detektorini faqat kerak bo'lganda yuklaydi."""
     global _nude_detector
     if _nude_detector is None:
         try:
-            from nudenet import NudeDetector
+            if NudeDetector is None:
+                logger.error("NudeNet kutubxonasi o'rnatilmagan.")
+                return None
             _nude_detector = NudeDetector()
             logger.info("NudeNet modeli muvaffaqiyatli yuklandi.")
         except Exception as e:
-            logger.error(f"NudeNet yuklashda xato: {e}")
+            logger.error(f"NudeNetni yuklashda xatolik: {e}")
+            return None
     return _nude_detector
 
 def apply_nudenet_filter(image_path, output_path):
-    """Rasmda NSFW hududlarni aniqlaydi va ularni xiralashtiradi."""
+    """Rasmda NSFW hududlarni aniqlaydi va blur (xiralashish) qo'llaydi."""
     try:
         detector = get_nude_detector()
         if not detector: return None
-
-        # Deteksiya qilish
-        detections = detector.detect(image_path)
         
+        image_path = os.path.abspath(image_path)
+        output_path = os.path.abspath(output_path)
+        
+        detections = detector.detect(image_path)
+        if not detections:
+            return image_path
+            
         img = cv2.imread(image_path)
-        if img is None: return None
-
-        # NSFW hududlarni blur qilish
         h, w = img.shape[:2]
+        
         for detection in detections:
-            box = detection['box']
-            label = detection['label']
-            score = detection['score']
+            score = detection.get('score', 0)
+            label = detection.get('class', '')
             
-            if score > 0.4: # Ishonchliligi 40% dan yuqori bo'lsa
-                x1, y1, x2, y2 = map(int, box)
-                x1, y1 = max(0, y1), max(0, x1) # NudeNet box [y1, x1, y2, x2]? Yo'q, odatda [x, y, x+w, y+h]
-                # NudeNet 3.0 box: [left, top, right, bottom] -> [x1, y1, x2, y2]
-                x1, y1 = max(0, x1), max(0, y1)
-                x2, y2 = min(w, x2), min(h, y2)
-                
-                roi = img[y1:y2, x1:x2]
-                if roi.size > 0:
-                    img[y1:y2, x1:x2] = cv2.GaussianBlur(roi, (51, 51), 30)
-                    logger.info(f"NSFW aniqlandi ({label}) va xiralashtirildi.")
+            if score > 0.4:
+                box = detection.get('box', [])
+                if len(box) == 4:
+                    x1, y1, x2, y2 = map(int, box)
+                    x1, y1 = max(0, x1), max(0, y1)
+                    x2, y2 = min(w, x2), min(h, y2)
+                    
+                    roi = img[y1:y2, x1:x2]
+                    if roi.size > 0:
+                        img[y1:y2, x1:x2] = cv2.GaussianBlur(roi, (51, 51), 30)
+                        logger.info(f"NSFW aniqlandi ({label}) va xiralashtirildi.")
 
         cv2.imwrite(output_path, img)
         return output_path if os.path.exists(output_path) else None
@@ -819,66 +619,50 @@ def apply_nudenet_filter(image_path, output_path):
 
 def process_video_nnsfw(video_path, output_path, progress_callback=None):
     """Videoda kadrbay-kadr NSFW senzurasini amalga oshiradi."""
-    from moviepy.video.io.VideoFileClip import VideoFileClip
-    
     try:
         detector = get_nude_detector()
-        if not detector: return None
+        if detector is None:
+            return None
 
-        video = VideoFileClip(video_path)
-        total_frames = int(video.fps * video.duration)
+        skip_frames = 12  # Har 12 kadrda 1 marta tekshiriladi
         current_frame = [0]
+        current_detections = [[]]
 
         def censor_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)
             h, w = bgr.shape[:2]
             
-            # Har bir kadrni diskka yozish juda sekin.
-            # NudeNet 3.0 detector.detect() faqat path qabul qiladi.
-            # Optimizatsiya: kadrni xotirada saqlab, vaqtinchalik fayl qilib yuboramiz.
-            # Diqqat: Bu jarayon juda sekin bo'lishi mumkin!
-            
-            temp_path = f"tmp_f_{os.getpid()}.jpg"
-            cv2.imwrite(temp_path, bgr)
-            detections = detector.detect(temp_path)
-            
-            for d in detections:
-                if d['score'] > 0.4:
-                    x1, y1, x2, y2 = map(int, d['box'])
-                    x1, y1 = max(0, x1), max(0, y1)
-                    x2, y2 = min(w, x2), min(h, y2)
-                    roi = bgr[y1:y2, x1:x2]
-                    if roi.size > 0:
-                        bgr[y1:y2, x1:x2] = cv2.GaussianBlur(roi, (51, 51), 30)
-            
-            if os.path.exists(temp_path):
-                try: os.remove(temp_path)
-                except: pass
+            # Faqat ma'lum kadrlarda nudenet ni chaqirish
+            if current_frame[0] % skip_frames == 1:
+                temp_path = f"tmp_f_{os.getpid()}_{current_frame[0]}.jpg"
+                cv2.imwrite(temp_path, bgr)
+                try:
+                    detections = detector.detect(temp_path) if detector else []
+                    current_detections[0] = detections if isinstance(detections, list) else []
+                except Exception as e:
+                    logger.warning(f"NudeNet detect xatosi: {e}")
+                    current_detections[0] = []
+                
+                if os.path.exists(temp_path):
+                    try: os.remove(temp_path)
+                    except: pass
+            
+            # Keshdagi oxirgi topilmalar bo'yicha blur qo'llash
+            for d in current_detections[0]:
+                if isinstance(d, dict) and d.get('score', 0) > 0.4:
+                    box = d.get('box')
+                    if isinstance(box, list) and len(box) == 4:
+                        x1, y1, x2, y2 = map(int, box)
+                        x1, y1 = max(0, x1), max(0, y1)
+                        x2, y2 = min(w, x2), min(h, y2)
+                        roi = bgr[y1:y2, x1:x2]
+                        if roi.size > 0:
+                            bgr[y1:y2, x1:x2] = cv2.GaussianBlur(roi, (51, 51), 30)
 
             return cv2.cvtColor(bgr, cv2.COLOR_BGR2RGB)
 
-        processed = video.image_transform(censor_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
+        return _apply_video_transform(video_path, output_path, censor_frame, progress_callback)
     except Exception as e:
         logger.error(f"Video NSFW xatosi: {e}")
         return None

main.py

@@ -76,6 +76,19 @@ processing_semaphore = asyncio.Semaphore(2)
 executor = ThreadPoolExecutor(max_workers=4)
 base_dir = os.path.dirname(os.path.abspath(__file__))
 
+# Rate Limit (Spam himoyasi)
+user_active_tasks = {}  # {user_id: timestamp}
+RATE_LIMIT_SECONDS = 5  # Minimum kutish vaqti (soniya)
+
+def check_rate_limit(user_id):
+    """Foydalanuvchi spam qilayotganini tekshiradi. True = ruxsat, False = bloklangan."""
+    now = time.time()
+    last_time = user_active_tasks.get(user_id)
+    if last_time and (now - last_time) < RATE_LIMIT_SECONDS:
+        return False
+    user_active_tasks[user_id] = now
+    return True
+
 # Scheduler for cleanup
 scheduler = AsyncIOScheduler()
 
@@ -86,17 +99,32 @@ async def post_init(application):
     logger.info("Scheduler va tozalash tizimi ishga tushdi.")
 
 async def cleanup_old_files():
-    """Eski fayllarni va xotirani tozalash."""
+    """Eski fayllarni, vaqtinchalik fayllarni va xotirani tozalash."""
     now = datetime.now()
+    
+    # 1. Eskirgan media_storage yozuvlarini tozalash
     to_delete = [k for k, v in media_storage.items() if (now - v.get('timestamp', now)) > timedelta(hours=1)]
     for k in to_delete:
-        media_storage.pop(k, None) # Lint fix
+        media_storage.pop(k, None)
     
+    # 2. Eskirgan user_active_tasks ni tozalash
+    stale_users = [uid for uid, ts in user_active_tasks.items() if (time.time() - ts) > 300]
+    for uid in stale_users:
+        user_active_tasks.pop(uid, None)
+    
+    # 3. in_/out_/tmp_ fayllarni tozalash
     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):
+        fpath = os.path.join(base_dir, f)
+        if (f.startswith("in_") or f.startswith("out_") or f.startswith("tmp_")):
             try:
-                os.remove(os.path.join(base_dir, f))
+                file_age = now - datetime.fromtimestamp(os.path.getmtime(fpath))
+                if file_age > timedelta(minutes=30):
+                    os.remove(fpath)
+                    logger.info(f"Tozalandi: {f}")
             except: pass
+    
+    gc.collect()
+    logger.info(f"Tozalash yakunlandi. media_storage: {len(media_storage)}, active_tasks: {len(user_active_tasks)}")
 
 # --- UI Helpers ---
 
@@ -322,6 +350,12 @@ async def button_handler(update: Update, context: ContextTypes.DEFAULT_TYPE):
             await query.edit_message_text("⚠️ Media ma'lumotlari topilmadi. Iltimos, qayta yuboring.")
             return
 
+        # Spam himoyasi: foydalanuvchi juda tez-tez so'rov yuborsa bloklash
+        user_id = query.from_user.id
+        if not check_rate_limit(user_id):
+            await query.edit_message_text("⏳ Sizda tugallanmagan jarayon bor yoki juda tez so'rov yuboryapsiz. Biroz kuting!")
+            return
+
         async with processing_semaphore:
             media_info = media_storage[short_id]
             file_id = media_info["file_id"]
@@ -418,11 +452,21 @@ async def button_handler(update: Update, context: ContextTypes.DEFAULT_TYPE):
         try: await context.bot.send_message(query.message.chat_id, f"❌ Tizimli xatolik: {e}")
         except: pass
     finally:
+        # Rate limit tozalash
         try:
-            if os.path.exists(input_path): os.remove(input_path)
-            if os.path.exists(output_path): os.remove(output_path)
+            user_active_tasks.pop(query.from_user.id, None)
         except: pass
         
+        # Fayllarni tozalash
+        for cleanup_path in [locals().get('input_path'), locals().get('output_path')]:
+            if cleanup_path and os.path.exists(cleanup_path):
+                try: os.remove(cleanup_path)
+                except: pass
+        
+        # media_storage dan eskirgan yozuvlarni tozalash
+        if short_id in media_storage:
+            media_storage.pop(short_id, None)
+        
         # Xotirani majburiy tozalash (RAM to'lishini oldini oladi)
         gc.collect()