Kekik 1.7.2__py3-none-any.whl → 1.7.9__py3-none-any.whl

Kekik/Sifreleme/Packer.py

@@ -4,9 +4,49 @@ import re
 
 class Packer:
     """
-    P.A.C.K.E.R. sıkıştırma ve çözme işlemleri için bir sınıf.
+    P.A.C.K.E.R. sıkıştırma ve çözme işlemleri için kapsamlı bir sınıf.
     ! » https://github.com/beautifier/js-beautify/blob/main/python/jsbeautifier/unpackers/packer.py
     """
+
+    # Regex kalıpları - daha gevşek, farklı varyasyonları yakalayabilecek şekilde
+    PACKED_PATTERN = re.compile(
+        r"\}\s*\(\s*['\"](.*?)['\"],\s*(\d+),\s*(\d+),\s*['\"](.+?)['\"]\.split\(['\"]\\?\|['\"]\)",
+        re.IGNORECASE | re.MULTILINE | re.DOTALL
+    )
+
+    # Alternatif regex pattern, farklı formatlarda paketlenmiş kodu yakalamak için
+    ALTERNATIVE_PATTERNS = [
+        # Standart pattern
+        re.compile(
+            r"\}\('(.*)',\s*(\d+),\s*(\d+),\s*'(.*?)'\.split\('\|'\)",
+            re.IGNORECASE | re.MULTILINE | re.DOTALL
+        ),
+        # Daha gevşek pattern
+        re.compile(
+            r"\}\s*\(\s*['\"](.*?)['\"],\s*(\d+),\s*(\d+),\s*['\"](.+?)['\"]\.split\(['\"]\\?\|['\"]\)",
+            re.IGNORECASE | re.MULTILINE | re.DOTALL
+        ),
+        # Eval formatı
+        re.compile(
+            r"eval\(function\(p,a,c,k,e,(?:r|d|)\)\{.*?return p\}(.*?\.split\('\|'\))",
+            re.IGNORECASE | re.MULTILINE | re.DOTALL
+        )
+    ]
+
+    # Kelime değiştirme deseni
+    REPLACE_PATTERN = re.compile(
+        r"\b\w+\b",
+        re.IGNORECASE | re.MULTILINE
+    )
+
+    # Alfabeler
+    ALPHABET = {
+        52: "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOP",
+        54: "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQR",
+        62: "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ",
+        95: " !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~"
+    }
+
     @staticmethod
     def clean_escape_sequences(source: str) -> str:
         """Kaçış dizilerini temizler."""
@@ -18,45 +58,142 @@ class Packer:
     @staticmethod
     def extract_arguments(source: str) -> tuple[str, list[str], int, int]:
         """P.A.C.K.E.R. formatındaki kaynak koddan argümanları çıkarır."""
-        match = re.search(r"}\('(.*)',(\d+),(\d+),'(.*)'\.split\('\|'\)", source, re.DOTALL)
+        # Önce standart pattern ile dene
+        match = Packer.PACKED_PATTERN.search(source)
+
+        # Eğer bulunamazsa, alternatif pattern'leri dene
+        if not match:
+            for pattern in Packer.ALTERNATIVE_PATTERNS:
+                match = pattern.search(source)
+                if match:
+                    break
 
         if not match:
-            raise ValueError("Invalid P.A.C.K.E.R. source format.")
+            # Son çare: daha serbest bir string arama 
+            if "'.split('|')" in source or '".split("|")' in source:
+                # Manuel olarak parçalama işlemi yap
+                try:
+                    # Basit bir yaklaşım, çoğu vakada çalışır
+                    parts = re.findall(r"\((['\"](.*?)['\"],\s*(\d+),\s*(\d+),\s*['\"](.*?)['\"]\.split", source)
+                    if parts:
+                        payload, radix, count, symtab = parts[0][1:]
+                        return payload, symtab.split("|"), int(radix), int(count)
+                except Exception:
+                    pass
+
+            raise ValueError("Invalid P.A.C.K.E.R. source format. Pattern not found.")
 
-        payload, radix, count, symtab = match.groups()
+        # Eval formatını işle
+        if len(match.groups()) == 1:
+            # Eval formatı yakalandı, içeriği çıkar
+            eval_content = match.group(1)
+            if inner_match := re.search(r"\('(.*)',(\d+),(\d+),'(.*)'\)", eval_content):
+                payload, radix, count, symtab = inner_match.groups()
+            else:
+                raise ValueError("Cannot extract arguments from eval pattern")
+        else:
+            # Standart format yakalandı
+            payload, radix, count, symtab = match.groups()
 
         return payload, symtab.split("|"), int(radix), int(count)
 
     @staticmethod
-    def convert_base(s: str, base: int) -> int:
-        """Bir sayıyı belirli bir tabandan ondalık tabana çevirir."""
-        alphabet = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
+    def unbase(value: str, base: int) -> int:
+        """
+        Verilen değeri belirtilen tabandan ondalık sayıya dönüştürür.
+        Geniş taban desteği (2-95 arası) sağlar.
+        """
+        # Standart Python taban dönüşümü (2-36 arası)
+        if 2 <= base <= 36:
+            try:
+                return int(value, base)
+            except ValueError:
+                return 0
 
-        return sum(alphabet.index(char) * (base**idx) for idx, char in enumerate(reversed(s)))
+        # Geniş taban desteği (37-95 arası)
+        if base > 95:
+            raise ValueError(f"Desteklenmeyen taban: {base}")
 
+        # Uygun alfabeyi seç
+        if base > 62:
+            selector = 95
+        elif base > 54:
+            selector = 62
+        elif base > 52:
+            selector = 54
+        else:
+            selector = 52
+
+        # Alfabeden karakter-indeks sözlüğü oluştur
+        char_dict = {char: idx for idx, char in enumerate(Packer.ALPHABET[selector])}
+
+        # Değeri dönüştür
+        result = 0
+        for index, char in enumerate(reversed(value)):
+            digit = char_dict.get(char, 0)
+            result += digit * (base ** index)
+
+        return result
+    
     @staticmethod
     def lookup_symbol(match: re.Match, symtab: list[str], radix: int) -> str:
         """Sembolleri arar ve yerine koyar."""
-        word  = match[0]
+        word = match[0]
+
+        try:
+            index = Packer.unbase(word, radix)
+            if 0 <= index < len(symtab):
+                replacement = symtab[index]
+                return replacement or word
+        except (ValueError, IndexError):
+            pass
 
-        return symtab[Packer.convert_base(word, radix)] or word
+        return word
 
     @staticmethod
     def unpack(source: str) -> str:
-        """P.A.C.K.E.R. formatındaki sıkıştırılmış bir kaynağı çözer."""
+        """
+        P.A.C.K.E.R. formatındaki sıkıştırılmış bir JavaScript kodunu çözer.
+        Birden fazla format ve varyasyonu destekler.
+        """
+        # Kaçış dizilerini temizle
         source = Packer.clean_escape_sequences(source)
 
-        payload, symtab, radix, count = Packer.extract_arguments(source)
+        # Argümanları çıkar
+        try:
+            payload, symtab, radix, count = Packer.extract_arguments(source)
 
-        if count != len(symtab):
-            raise ValueError("Malformed P.A.C.K.E.R. symtab.")
+            # Sembol tablosunun doğruluğunu kontrol et (ancak sıkı değil)
+            if len(symtab) != count:
+                print(f"Uyarı: Sembol tablosu sayısı ({len(symtab)}) ile belirtilen sayı ({count}) eşleşmiyor, ancak devam ediliyor.")
 
-        return re.sub(r"\b\w+\b", lambda match: Packer.lookup_symbol(match, symtab, radix), payload)
+            # Kelimeleri değiştir ve sonucu döndür
+            return Packer.REPLACE_PATTERN.sub(
+                lambda match: Packer.lookup_symbol(match, symtab, radix), 
+                payload
+            )
+        except Exception as e:
+            # Detaylı hata mesajı
+            raise ValueError(f"Unpacking failed: {str(e)}\nSource preview: {source[:100]}...")
 
     @staticmethod
-    def pack(source: str, radix: int = 62) -> str:
-        """Bir metni P.A.C.K.E.R. formatında sıkıştırır."""
-        # Bu işlev, simgeleri ve sıkıştırılmış metni yeniden oluşturmak için bir yol sağlar.
-        # Ancak bu, belirli bir algoritma veya sıkıştırma tekniğine bağlıdır.
-        # Gerçekleştirilmesi zor olabilir çünkü P.A.C.K.E.R.'ın spesifik sıkıştırma mantığını takip etmek gerekir.
-        raise NotImplementedError("Packing function is not implemented.")
+    def detect_packed(source: str) -> bool:
+        """Verilen kodun P.A.C.K.E.R. formatında sıkıştırılmış olup olmadığını kontrol eder."""
+        # Standart pattern'i kontrol et
+        if Packer.PACKED_PATTERN.search(source):
+            return True
+
+        # Alternatif pattern'leri kontrol et
+        for pattern in Packer.ALTERNATIVE_PATTERNS:
+            if pattern.search(source):
+                return True
+
+        # Yaygın belirteçleri kontrol et
+        indicators = [
+            ".split('|')",
+            '.split("|")',
+            "function(p,a,c,k,e,",
+            "function(p, a, c, k, e, "
+        ]
+
+        return any(indicator in source for indicator in indicators)

Kekik/cache.py

@@ -9,13 +9,23 @@ import threading
 import asyncio
 import pickle
 
-# Redis için asenkron client (Redis yoksa fallback yapılacak)
-import redis.asyncio as redis
+# Redis client (Redis yoksa fallback yapılacak)
+import redis.asyncio as redisAsync
+import redis         as redis
 
 # -----------------------------------------------------
 # Sabitler ve Yardımcı Fonksiyonlar
 # -----------------------------------------------------
-UNLIMITED = None
+UNLIMITED  = None
+
+REDIS_HOST = "127.0.0.1"
+REDIS_PORT = 6379
+REDIS_DB   = 0
+REDIS_PASS = None
+
+# FastAPI için cache'ten hariç tutulacak parametreler ve HTTP status kodları
+CACHE_IGNORE_PARAMS       = {"kurek", "debug", "_", "t", "timestamp"}
+CACHE_IGNORE_STATUS_CODES = {400, 401, 403, 404, 500, 501, 502, 503}
 
 def normalize_for_key(value):
     """
@@ -43,6 +53,7 @@ def simple_cache_key(func, args, kwargs) -> str:
     Oluşturulan stringin sonuna MD5 hash eklenebilir.
     """
     base_key = f"{func.__module__}.{func.__qualname__}"
+    base_key = "|".join(base_key.split("."))
 
     if args:
         norm_args = [normalize_for_key(arg) for arg in args]
@@ -55,11 +66,12 @@ def simple_cache_key(func, args, kwargs) -> str:
     hashed = md5(base_key.encode('utf-8')).hexdigest()
     return f"{base_key}"  # |{hashed}
 
-async def make_cache_key(func, args, kwargs, is_fastapi=False) -> str:
+async def make_cache_key(func, args, kwargs, is_fastapi=False, include_auth=False) -> str:
     """
     Cache key'ini oluşturur.
     - is_fastapi=False ise simple_cache_key() kullanılır.
     - True ise FastAPI Request nesnesine göre özel key oluşturulur.
+    - include_auth=True ise authorization header'ı key'e dahil edilir.
     """
     if not is_fastapi:
         return simple_cache_key(func, args, kwargs)
@@ -67,21 +79,40 @@ async def make_cache_key(func, args, kwargs, is_fastapi=False) -> str:
     # FastAPI: request ilk argümandan ya da kwargs'dan alınır.
     request = args[0] if args else kwargs.get("request")
 
-    if request.method == "GET":
-        # Eğer query_params boşsa {} olarak ayarla
-        veri = dict(request.query_params) if request.query_params else {}
-    else:
-        try:
-            veri = await request.json()
-        except Exception:
-            form_data = await request.form()
-            veri = dict(form_data.items())
-
-    # Eğer "kurek" gibi özel parametreler varsa temizleyebilirsiniz:
-    veri.pop("kurek", None)
+    # Request bulunamamışsa fallback
+    if request is None or not hasattr(request, 'method'):
+        return simple_cache_key(func, args, kwargs)
 
-    args_hash = md5(urlencode(veri).encode()).hexdigest() if veri else ""
-    return f"{request.url.path}?{veri}"
+    try:
+        if request.method == "GET":
+            # Eğer query_params boşsa {} olarak ayarla
+            veri = dict(request.query_params) if request.query_params else {}
+        else:
+            try:
+                content_type = request.headers.get("content-type", "")
+                if "application/json" in content_type:
+                    veri = await request.json()
+                else:
+                    form_data = await request.form()
+                    veri = dict(form_data.items())
+            except Exception:
+                veri = {}
+
+        # Sistem parametrelerini temizle
+        for param in CACHE_IGNORE_PARAMS:
+            veri.pop(param, None)
+
+        # Authorization header'ı dahil et (user-specific cache için)
+        if include_auth and "authorization" in request.headers:
+            auth_hash = md5(request.headers["authorization"].encode()).hexdigest()
+            veri[f"_auth_hash"] = auth_hash
+
+        args_hash = md5(urlencode(veri).encode()).hexdigest() if veri else ""
+        return f"{request.url.path}|{veri}" if veri else f"{request.url.path}"
+    except Exception as e:
+        # Herhangi bir hata durumunda fallback
+        konsol.log(f"[yellow]FastAPI cache key oluşturma hatası: {e}, basit key kullanılıyor")
+        return simple_cache_key(func, args, kwargs)
 
 # -----------------------------------------------------
 # Senkron Cache (RAM) Sınıfı
@@ -90,29 +121,35 @@ async def make_cache_key(func, args, kwargs, is_fastapi=False) -> str:
 class SyncCache:
     """
     Senkron fonksiyonlar için basit in-memory cache.
-    TTL süresi dolan veriler periyodik olarak arka plan thread’iyle temizlenir.
+    TTL süresi dolan veriler periyodik olarak arka plan thread'iyle temizlenir.
     """
-    def __init__(self, ttl=UNLIMITED, cleanup_interval=60 * 60):
-        self._ttl   = ttl
-        self._data  = {}
-        self._times = {}
+    def __init__(self, ttl=UNLIMITED, cleanup_interval=60 * 60, max_size=10000):
+        self._ttl           = ttl
+        self._data          = {}
+        self._times         = {}
+        self._access_counts = {}  # LRU tracker
+        self._max_size      = max_size
 
-        # TTL sınırsız değilse, cleanup_interval ile ttl'den büyük olanı kullanıyoruz.
-        self._cleanup_interval = max(ttl, cleanup_interval) if ttl is not UNLIMITED else cleanup_interval
+        # TTL sınırsız değilse, cleanup_interval kullanıyoruz.
+        self._cleanup_interval = cleanup_interval if ttl is UNLIMITED else min(ttl, cleanup_interval)
 
         # Arka planda çalışan ve periyodik olarak expired entry'leri temizleyen thread başlatılıyor.
-        self._lock           = threading.RLock()
-        self._cleanup_thread = threading.Thread(target=self._auto_cleanup, daemon=True)
+        self._lock                  = threading.RLock()
+        self._cleanup_thread        = threading.Thread(target=self._auto_cleanup, daemon=True)
+        self._cleanup_thread.daemon = True
         self._cleanup_thread.start()
 
     def _auto_cleanup(self):
         """Belirlenen aralıklarla cache içerisindeki süresi dolmuş entry'leri temizler."""
         while True:
-            time.sleep(self._cleanup_interval)
-            with self._lock:
-                keys = list(self._data.keys())
-                for key in keys:
-                    self.remove_if_expired(key)
+            try:
+                time.sleep(self._cleanup_interval)
+                with self._lock:
+                    keys = list(self._data.keys())
+                    for key in keys:
+                        self.remove_if_expired(key)
+            except Exception as e:
+                konsol.log(f"[red]Cache cleanup hatası: {e}")
 
     def _is_expired(self, key):
         """Belirtilen key'in süresi dolmuşsa True döner."""
@@ -138,15 +175,108 @@ class SyncCache:
         with self._lock:
             self.remove_if_expired(key)
             veri = self._data[key]
+            # LRU tracker'ı güncelle
+            self._access_counts[key] = self._access_counts.get(key, 0) + 1
             # konsol.log(f"[yellow][~] {key}")
             return veri
 
     def __setitem__(self, key, value):
         with self._lock:
-            self._data[key] = value
+            # Kapasite kontrolü - LRU temizlemesi
+            if len(self._data) >= self._max_size and key not in self._data:
+                # En az kullanılan key'i bul ve sil
+                lru_key = min(self._access_counts, key=self._access_counts.get)
+                self._data.pop(lru_key, None)
+                self._times.pop(lru_key, None)
+                self._access_counts.pop(lru_key, None)
+                # konsol.log(f"[red][-] LRU eviction: {lru_key}")
+
+            self._data[key]          = value
+            self._access_counts[key] = 0
             if self._ttl is not UNLIMITED:
                 self._times[key] = time.time()
 
+class HybridSyncCache:
+    """
+    Senkron işlemler için, öncelikle Redis cache kullanılmaya çalışılır.
+    Redis'ten veri alınamazsa ya da hata oluşursa, SyncCache (in-memory) fallback uygulanır.
+    """
+    def __init__(self, ttl=None, max_size=10000):
+        self._ttl = ttl
+        self._max_size = max_size
+
+        try:
+            self.redis = redis.Redis(
+                host             = REDIS_HOST,
+                port             = REDIS_PORT,
+                db               = REDIS_DB,
+                password         = REDIS_PASS,
+                decode_responses = False
+            )
+            self.redis.ping()
+        except Exception as e:
+            konsol.log(f"[yellow]Redis bağlantısı başarısız, in-memory cache kullanılıyor: {e}")
+            self.redis = None
+
+        self.memory = SyncCache(ttl, max_size=max_size)
+
+    def get(self, key):
+        # Önce Redis ile deniyoruz:
+        if self.redis:
+            try:
+                data = self.redis.get(key)
+            except Exception as e:
+                # konsol.log(f"[yellow]Redis get hatası: {e}")
+                data = None
+            if data is not None:
+                try:
+                    result = pickle.loads(data)
+                    # konsol.log(f"[yellow][~] {key}")
+                    return result
+                except Exception as e:
+                    # Deserialize hatası durumunda fallback'e geç
+                    # konsol.log(f"[yellow]Pickle deserialize hatası: {e}")
+                    pass
+
+        # Redis'te veri yoksa, yerel cache'ten alıyoruz.
+        try:
+            return self.memory[key]
+        except KeyError:
+            raise KeyError(key)
+
+    def set(self, key, value):
+        try:
+            ser = pickle.dumps(value)
+        except Exception as e:
+            # Serialization hatası durumunda yerel cache'e yazalım.
+            # (TemplateResponse, FileResponse gibi pickle'lanamayan objeler için)
+            # konsol.log(f"[yellow]Pickle serialize hatası: {e}, in-memory cache kullanılıyor")
+            self.memory[key] = value
+            return
+
+        if self.redis:
+            try:
+                if self._ttl is not None:
+                    self.redis.set(key, ser, ex=self._ttl)
+                else:
+                    self.redis.set(key, ser)
+                return
+            except Exception as e:
+                # Redis'e yazılamazsa yerel cache'e geçelim.
+                # konsol.log(f"[yellow]Redis set hatası: {e}, in-memory cache kullanılıyor")
+                self.memory[key] = value
+                return
+        else:
+            # Redis kullanılmıyorsa direkt yerel cache'e yaz.
+            self.memory[key] = value
+
+    # HybridSyncCache'in subscriptable olması için:
+    def __getitem__(self, key):
+        return self.get(key)
+
+    def __setitem__(self, key, value):
+        self.set(key, value)
+
 # -----------------------------------------------------
 # Asenkron Cache (In-Memory) ve Redis Hybrid Cache
 # -----------------------------------------------------
@@ -155,18 +285,21 @@ class AsyncCache:
     """
     Temel in-memory asenkron cache.
     """
-    def __init__(self, ttl=UNLIMITED, cleanup_interval=60 * 60):
+    def __init__(self, ttl=UNLIMITED, cleanup_interval=60 * 60, max_size=10000):
         """
         :param ttl: Her entry için geçerli süre (saniye). Örneğin 3600 saniye 1 saattir.
         :param cleanup_interval: Otomatik temizleme görevinin kaç saniyede bir çalışacağını belirler.
+        :param max_size: Maksimum cache boyutu (en eski entry'ler silinir).
         """
-        self._ttl    = ttl
-        self._data   = {}
-        self._times  = {}
-        self.futures = {}
+        self._ttl           = ttl
+        self._data          = {}
+        self._times         = {}
+        self._access_counts = {}  # LRU tracker
+        self.futures        = {}
+        self._max_size      = max_size
 
-        # TTL sınırsız değilse, cleanup_interval ile ttl'den büyük olanı kullanıyoruz.
-        self._cleanup_interval = max(ttl, cleanup_interval) if ttl is not UNLIMITED else cleanup_interval
+        # TTL sınırsız değilse, cleanup_interval kullanıyoruz.
+        self._cleanup_interval = cleanup_interval if ttl is UNLIMITED else min(ttl, cleanup_interval)
 
         # Aktif bir event loop varsa otomatik temizlik görevini başlatıyoruz.
         try:
@@ -177,9 +310,12 @@ class AsyncCache:
     async def _auto_cleanup(self):
         """Belirlenen aralıklarla cache içerisindeki süresi dolmuş entry'leri temizler."""
         while True:
-            await asyncio.sleep(self._cleanup_interval)
-            for key in list(self._data.keys()):
-                self.remove_if_expired(key)
+            try:
+                await asyncio.sleep(self._cleanup_interval)
+                for key in list(self._data.keys()):
+                    self.remove_if_expired(key)
+            except Exception as e:
+                konsol.log(f"[red]Async cache cleanup hatası: {e}")
 
     def ensure_cleanup_task(self):
         """Event loop mevcutsa, cleanup task henüz başlatılmadıysa oluştur."""
@@ -214,6 +350,8 @@ class AsyncCache:
         try:
             # Cache içerisinde key varsa direkt değeri döndür.
             value = self._data[key]
+            # LRU tracker'ı güncelle
+            self._access_counts[key] = self._access_counts.get(key, 0) + 1
             # konsol.log(f"[yellow][~] {key}")
             return value
         except KeyError:
@@ -231,28 +369,44 @@ class AsyncCache:
     async def set(self, key, value):
         """Belirtilen key için cache'e değer ekler."""
         self.ensure_cleanup_task()
-        self._data[key] = value
+
+        # Kapasite kontrolü - LRU temizlemesi
+        if len(self._data) >= self._max_size and key not in self._data:
+            # En az kullanılan key'i bul ve sil
+            lru_key = min(self._access_counts, key=self._access_counts.get)
+            self._data.pop(lru_key, None)
+            self._times.pop(lru_key, None)
+            self._access_counts.pop(lru_key, None)
+            self.futures.pop(lru_key, None)
+            # konsol.log(f"[red][-] Async LRU eviction: {lru_key}")
+
+        self._data[key]          = value
+        self._access_counts[key] = 0
         if self._ttl is not UNLIMITED:
             self._times[key] = time.time()
 
 class HybridAsyncCache:
     """
     Öncelikle Redis cache kullanılmaya çalışılır.
-    Hata durumunda veya Redis erişilemiyorsa in-memory AsyncCache’e geçilir.
+    Hata durumunda veya Redis erişilemiyorsa in-memory AsyncCache'e geçilir.
     """
-    def __init__(self, ttl=UNLIMITED):
+    def __init__(self, ttl=UNLIMITED, max_size=10000):
         self._ttl = ttl
+        self._max_size = max_size
 
         try:
-            self.redis = redis.Redis(
-                host             = "127.0.0.1",
-                port             = 6379,
+            self.redis = redisAsync.Redis(
+                host             = REDIS_HOST,
+                port             = REDIS_PORT,
+                db               = REDIS_DB,
+                password         = REDIS_PASS,
                 decode_responses = False
             )
-        except Exception:
+        except Exception as e:
+            konsol.log(f"[yellow]Async Redis bağlantısı başarısız, in-memory cache kullanılıyor: {e}")
             self.redis = None
 
-        self.memory  = AsyncCache(ttl)
+        self.memory  = AsyncCache(ttl, max_size=max_size)
         self.futures = {}
 
     async def get(self, key):
@@ -265,15 +419,17 @@ class HybridAsyncCache:
         if self.redis:
             try:
                 data = await self.redis.get(key)
-            except Exception:
+            except Exception as e:
+                konsol.log(f"[yellow]Async Redis get hatası: {e}")
                 return await self.memory.get(key)
             if data is not None:
                 try:
                     result = pickle.loads(data)
                     # konsol.log(f"[yellow][~] {key}")
                     return result
-                except Exception:
+                except Exception as e:
                     # Deserialize hatası durumunda in-memory cache'ten dene
+                    konsol.log(f"[yellow]Async pickle deserialize hatası: {e}")
                     return await self.memory.get(key)
             else:
                 # Redis'te veri yoksa, in-memory cache'e bak
@@ -286,8 +442,10 @@ class HybridAsyncCache:
         # Önce veriyi pickle etmeyi deniyoruz.
         try:
             ser = pickle.dumps(value)
-        except Exception:
+        except Exception as e:
             # Serialization hatası durumunda sadece in-memory cache'e yaz
+            # (TemplateResponse, FileResponse gibi pickle'lanamayan objeler için)
+            # konsol.log(f"[yellow]Async pickle serialize hatası: {e}, in-memory cache kullanılıyor")
             await self.memory.set(key, value)
             return
 
@@ -298,8 +456,9 @@ class HybridAsyncCache:
                 else:
                     await self.redis.set(key, ser)
                 return
-            except Exception:
+            except Exception as e:
                 # Redis yazma hatası durumunda in-memory fallback
+                # konsol.log(f"[yellow]Async Redis set hatası: {e}, in-memory cache kullanılıyor")
                 await self.memory.set(key, value)
                 return
         else:
@@ -354,35 +513,61 @@ async def _async_compute_and_cache(func, key, unless, *args, **kwargs):
 # kekik_cache Dekoratörü (Senkrondan Asenkrona)
 # -----------------------------------------------------
 
-def kekik_cache(ttl=UNLIMITED, unless=None, is_fastapi=False, use_redis=True):
+def kekik_cache(ttl=UNLIMITED, unless=None, use_redis=True, max_size=10000, is_fastapi=None, include_auth=False):
     """
     Bir fonksiyonun (senkron/asenkron) sonucunu cache'ler.
+    FastAPI endpoint'leri otomatik detekt edilir (is_fastapi=None ise) veya manuel olarak belirtilebilir.
     
     Parametreler:
       - ttl: Cache'in geçerlilik süresi (saniye). UNLIMITED ise süresizdir.
       - unless: Sonuç alınmadan önce çağrılan, True dönerse cache'e alınmaz.
-      - is_fastapi: True ise, FastAPI Request nesnesine göre key oluşturur.
+      - is_fastapi: True/False ile açıkça belirt, None ise otomatik detekt (Request nesnesine bakarak).
       - use_redis: Asenkron fonksiyonlarda Redis kullanımı (Hybrid cache) için True verilebilir.
+      - max_size: Cache'in maksimum boyutu. Kapasiteyi aşarsa LRU temizlemesi yapılır.
+      - include_auth: Authorization header'ını key'e dahil et (user-specific cache).
     
     Örnek Kullanım:
     
-        @kekik_cache(ttl=15, unless=lambda sonuc: sonuc is None)
-        async def bakalim(param):
-            return param
+        # Basit fonksiyon
+        @kekik_cache(ttl=300)
+        async def hesapla(param):
+            return param * 2
+        
+        # FastAPI endpoint (otomatik detekt)
+        @app.get("/users/{user_id}")
+        @kekik_cache(ttl=300, include_auth=True)
+        async def get_user(user_id: int, request: Request):
+            return {"id": user_id, "name": "..."}
+        
+        # FastAPI endpoint (manuel belirtim)
+        @app.get("/data")
+        @kekik_cache(ttl=600, is_fastapi=True)
+        async def get_data(request: Request):
+            return {"data": "..."}
+        
+        # Hata response'larını cache'leme
+        @app.get("/data")
+        @kekik_cache(ttl=300, unless=lambda r: r.status_code >= 400)
+        async def get_data(request: Request):
+            return {}
     """
     # Parametresiz kullanım durumunda
     if callable(ttl):
-        return kekik_cache(UNLIMITED, unless=unless, is_fastapi=is_fastapi, use_redis=use_redis)(ttl)
+        return kekik_cache(UNLIMITED, unless=unless, use_redis=use_redis, max_size=max_size, is_fastapi=is_fastapi, include_auth=include_auth)(ttl)
 
     def decorator(func):
         if asyncio.iscoroutinefunction(func):
             # Asenkron fonksiyonlar için cache türünü seçelim:
-
-            func.__cache = HybridAsyncCache(ttl) if use_redis else AsyncCache(ttl)
+            func.__cache = HybridAsyncCache(ttl, max_size=max_size) if use_redis else AsyncCache(ttl, max_size=max_size)
 
             @wraps(func)
             async def async_wrapper(*args, **kwargs):
-                key = await make_cache_key(func, args, kwargs, is_fastapi)
+                # is_fastapi otomatik deteksiyon (None ise) ya da manuel belirtim
+                detect_fastapi = is_fastapi
+                if detect_fastapi is None:
+                    detect_fastapi = args and hasattr(args[0], "url") and hasattr(args[0], "method")
+
+                key = await make_cache_key(func, args, kwargs, detect_fastapi, include_auth=include_auth)
 
                 try:
                     return await func.__cache.get(key)
@@ -392,7 +577,7 @@ def kekik_cache(ttl=UNLIMITED, unless=None, is_fastapi=False, use_redis=True):
             return async_wrapper
         else:
             # Senkron fonksiyonlar için
-            func.__cache = SyncCache(ttl)
+            func.__cache = HybridSyncCache(ttl, max_size=max_size) if use_redis else SyncCache(ttl, max_size=max_size)
 
             @wraps(func)
             def sync_wrapper(*args, **kwargs):

{Kekik-1.7.2.dist-info → kekik-1.7.9.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: Kekik
-Version: 1.7.2
+Version: 1.7.9
 Summary: İşlerimizi kolaylaştıracak fonksiyonların el altında durduğu kütüphane..
 Home-page: https://github.com/keyiflerolsun/Kekik
 Author: keyiflerolsun
@@ -26,6 +26,7 @@ Requires-Dist: simplejson
 Requires-Dist: rich
 Requires-Dist: tabulate
 Requires-Dist: pycryptodome
+Requires-Dist: redis
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier
@@ -34,6 +35,7 @@ Dynamic: description-content-type
 Dynamic: home-page
 Dynamic: keywords
 Dynamic: license
+Dynamic: license-file
 Dynamic: requires-dist
 Dynamic: requires-python
 Dynamic: summary
@@ -315,6 +317,11 @@ var played = 0;
 eval_jwSetup = re.compile(r'\};\s*(eval\(function[\s\S]*?)var played = \d+;').findall(veri)[0]
 print(Packer.unpack(Packer.unpack(eval_jwSetup)))
 # jwSetup.sources=[{"default":true,"file":"\x68\x74\x74\x70\x73\x3a\x2f\x2f\x64\x32\x2e\x69\x6d\x61\x67\x65\x73\x70\x6f\x74\x2e\x62\x75\x7a\x7a\x2f\x66\x32\x2f\x4e\x74\x4f\x31\x4e\x51\x5a\x6a\x44\x51\x41\x6b\x78\x6c\x58\x45\x47\x33\x6c\x62\x66\x62\x30\x31\x79\x74\x70\x57\x66\x4e\x30\x66\x62\x66\x50\x58\x5a\x55\x31\x6a\x50\x77\x5a\x6d\x48\x71\x58\x41\x37\x6c\x6d\x6d\x4b\x67\x47\x59\x31\x66\x47\x42\x6d\x6c\x38\x68\x32\x7a\x33\x4f\x5a\x69\x4f\x63\x4c\x6b\x51\x70\x7a\x57\x78\x4b\x45\x4c\x57\x42\x63\x79\x4d\x74\x75\x55\x44\x57\x46\x4e\x6c\x69\x64\x70\x46\x46\x65\x6e\x65\x64\x66\x48\x30\x69\x74\x66\x59\x67\x38\x52\x47\x41\x6b\x38\x6c\x76\x72\x31","label":"0","type":"hls","preload":"none"}];var mu=getLocation(jwSetup.sources[0].file);
+
+# ! Veya
+
+while Packer.detect_packed(veri):
+    veri = Packer.unpack(veri)
 ```
 
 ### **[CryptoJS](https://github.com/keyiflerolsun/Kekik/blob/main/Kekik/Sifreleme/CryptoJS.py)**
@@ -367,6 +374,26 @@ print(NaysHash().generate_xtoken(
 # EygcmEIe3aU0TWIubaQTuBwbrqpY7HFcNDajlSKCT5c=
 ```
 
+### **[kekik_cache](https://github.com/keyiflerolsun/Kekik/blob/main/Kekik/cache.py)**
+```python
+import Kekik.cache as cache
+cache.REDIS_HOST = "127.0.0.1"
+cache.REDIS_PORT = 6379
+cache.REDIS_DB   = 0
+cache.REDIS_PASS = None
+kekik_cache      = cache.kekik_cache
+
+@kekik_cache(ttl=5)
+def sync_func(x, y):
+    time.sleep(1)
+    return x + y
+
+@kekik_cache(ttl=5)
+async def async_func(x, y):
+    await asyncio.sleep(1)
+    return x * y
+```
+
 ### **[dict2json](https://github.com/keyiflerolsun/Kekik/blob/main/Kekik/dict2json.py)**
 ### **[dosya_indir](https://github.com/keyiflerolsun/Kekik/blob/main/Kekik/dosya_indir.py)**
 ### **[benim_hwid](https://github.com/keyiflerolsun/Kekik/blob/main/Kekik/hwid_kontrol.py)**

{Kekik-1.7.2.dist-info → kekik-1.7.9.dist-info}/RECORD

@@ -2,7 +2,7 @@ Kekik/BIST.py,sha256=gFvEFdLGgsxUq33AkqOr5pVGsSm9jR0v6DVwoSzhX7w,1375
 Kekik/Domain2IP.py,sha256=dMDatPElTMfLORzC_QN9znex8Se1eid3EPsxAe5S1aQ,4851
 Kekik/Nesne.py,sha256=33pp49cZkRCoa0aUFfzVMpx5FSJchSdiKhm97Nkol1Q,7020
 Kekik/__init__.py,sha256=Iy-O4c_DuY2ttQJv6j7xoVk3IS9EcC0Aqx3vhFvCgd8,1057
-Kekik/cache.py,sha256=vJ9b7eAyKH0Z2JCW5JIDsyLkNwXvWkS3vnJpv_mj0Us,14892
+Kekik/cache.py,sha256=to3ihJyxPasQDr5QO1hJPRVDbidBSILK2kGKUfPZ2wE,23308
 Kekik/cli.py,sha256=I--MV8-okBSUYAaV4fRsMeB2n57OJITrgbEnK1OdTPY,3648
 Kekik/csv2dict.py,sha256=HO0AgREXE0yM7cL4OwqpkCGm2pz31RTb0mhnTg6gdwo,423
 Kekik/dict2csv.py,sha256=AcGvEg9i5MXtwMwg7WiDxOj8h9LldNjjcRiWFwA9XJU,560
@@ -27,16 +27,16 @@ Kekik/Sifreleme/AESManager.py,sha256=eYgbHANtYrWFJgLeUuj63tlL0Yn8gyPCJYbXfWlpNbo
 Kekik/Sifreleme/CryptoJS.py,sha256=qDlgTaSXcs5jF4DNmjuwK5CL3VL1P7xyJzDTof1--As,3126
 Kekik/Sifreleme/HexCodec.py,sha256=fB1ZGBYCQLUUiZNXqn0sxYhEMhxPoyC1BPYkRJ5G7hY,900
 Kekik/Sifreleme/NaysHash.py,sha256=CJVlyHCXSv8JN8fitF2LQHLcd-opY6zergcgmX3pj_Y,2234
-Kekik/Sifreleme/Packer.py,sha256=4DWFMyhqsZvVKIUjZNruR8RwHSjuPKJi8WDCUTBGWCQ,2600
+Kekik/Sifreleme/Packer.py,sha256=o4jkoKdI0UOg9jqGsCg2H82vLbfsuYQnWFYS1DzRWrU,7290
 Kekik/Sifreleme/StringCodec.py,sha256=5kmFLN7g2c_ENxD491lAlH0AGtW7tIy5h5KPHEuTzyM,1426
 Kekik/Sifreleme/__init__.py,sha256=IDSVFP4xshnpPLyCX2ndY_N9cYIzikqu5LFi_E-3-5Q,284
 Kekik/kisi_ver/__init__.py,sha256=gH613YZC3ziE7f67dViefRSuwDwsHyVvXHpM5CzZ2q4,1386
 Kekik/kisi_ver/biyografiler.py,sha256=5Xv1ixaDGHGtl5Nf92jo9dPgF3jDXOGEPmWgoEsn9j8,189486
 Kekik/kisi_ver/isimler.py,sha256=zHVimWL_4TvoLE3qzWQslDBc8-IJZSB02s0vRwsVM1g,88066
 Kekik/kisi_ver/soyisimler.py,sha256=YQJYp2SjENgwOaCa9mmShxPYeeUll2cq8Vox-d8_kB8,78485
-Kekik-1.7.2.dist-info/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-Kekik-1.7.2.dist-info/METADATA,sha256=7RQJjD9uh3TDqIPkeRQ8bszs0gVcZJlFf8BMaP31r2U,43959
-Kekik-1.7.2.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-Kekik-1.7.2.dist-info/entry_points.txt,sha256=yjBifxtRlqfg8lPkH4Bu-urSa5ecptCHsuth-DcyWcg,59
-Kekik-1.7.2.dist-info/top_level.txt,sha256=NotddscfgxawvuRyAa7xkgnMhyteFDcBxb5aU5GY3BM,6
-Kekik-1.7.2.dist-info/RECORD,,
+kekik-1.7.9.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+kekik-1.7.9.dist-info/METADATA,sha256=z_24aSaYTNhm4UWDjgfeC5dk4EiHs7SRm_Uys-6Nn54,44515
+kekik-1.7.9.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+kekik-1.7.9.dist-info/entry_points.txt,sha256=yjBifxtRlqfg8lPkH4Bu-urSa5ecptCHsuth-DcyWcg,59
+kekik-1.7.9.dist-info/top_level.txt,sha256=NotddscfgxawvuRyAa7xkgnMhyteFDcBxb5aU5GY3BM,6
+kekik-1.7.9.dist-info/RECORD,,

{Kekik-1.7.2.dist-info → kekik-1.7.9.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.8.0)
+Generator: setuptools (80.9.0)
 Root-Is-Purelib: true
 Tag: py3-none-any