Kekik 1.7.5__tar.gz → 1.7.9__tar.gz

kekik-1.7.9/Kekik/Sifreleme/Packer.py

@@ -0,0 +1,199 @@
+# ! Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+import re
+
+class Packer:
+    """
+    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."""
+        source = re.sub(r'\\\\', r'\\', source)
+        source = source.replace("\\'", "'")
+        source = source.replace('\\"', '"')
+        return source
+
+    @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."""
+        # Ö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:
+            # 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.")
+
+        # 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 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
+
+        # 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]
+
+        try:
+            index = Packer.unbase(word, radix)
+            if 0 <= index < len(symtab):
+                replacement = symtab[index]
+                return replacement or word
+        except (ValueError, IndexError):
+            pass
+
+        return word
+
+    @staticmethod
+    def unpack(source: str) -> str:
+        """
+        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)
+
+        # Argümanları çıkar
+        try:
+            payload, symtab, radix, count = Packer.extract_arguments(source)
+
+            # 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.")
+
+            # 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 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-1.7.5 → kekik-1.7.9}/Kekik/cache.py

@@ -23,6 +23,10 @@ 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):
     """
     Cache key oluşturma amacıyla verilen değeri normalize eder.
@@ -49,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]
@@ -61,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)
@@ -73,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ı
@@ -96,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."""
@@ -144,12 +175,24 @@ 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()
 
@@ -158,8 +201,9 @@ 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):
+    def __init__(self, ttl=None, max_size=10000):
         self._ttl = ttl
+        self._max_size = max_size
 
         try:
             self.redis = redis.Redis(
@@ -170,25 +214,28 @@ class HybridSyncCache:
                 decode_responses = False
             )
             self.redis.ping()
-        except Exception:
+        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)
+        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:
+            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:
+                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.
@@ -200,8 +247,10 @@ class HybridSyncCache:
     def set(self, key, value):
         try:
             ser = pickle.dumps(value)
-        except Exception:
+        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
 
@@ -212,8 +261,9 @@ class HybridSyncCache:
                 else:
                     self.redis.set(key, ser)
                 return
-            except Exception:
+            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:
@@ -235,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:
@@ -257,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."""
@@ -294,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:
@@ -311,17 +369,30 @@ 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 = redisAsync.Redis(
@@ -331,10 +402,11 @@ class HybridAsyncCache:
                 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):
@@ -347,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
@@ -368,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
 
@@ -380,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:
@@ -436,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)
@@ -474,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 = HybridSyncCache(ttl) if use_redis else 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.5 → kekik-1.7.9}/Kekik.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: Kekik
-Version: 1.7.5
+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
@@ -35,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
@@ -316,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)**

{kekik-1.7.5 → kekik-1.7.9}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: Kekik
-Version: 1.7.5
+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
@@ -35,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
@@ -316,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)**

{kekik-1.7.5 → kekik-1.7.9}/README.md

@@ -275,6 +275,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)**

{kekik-1.7.5 → kekik-1.7.9}/setup.py

@@ -6,7 +6,7 @@ from io         import open
 setup(
     # ? Genel Bilgiler
     name         = "Kekik",
-    version      = "1.7.5",
+    version      = "1.7.9",
     url          = "https://github.com/keyiflerolsun/Kekik",
     description  = "İşlerimizi kolaylaştıracak fonksiyonların el altında durduğu kütüphane..",
     keywords     = ["Kekik", "KekikAkademi", "keyiflerolsun"],

kekik-1.7.5/Kekik/Sifreleme/Packer.py

@@ -1,62 +0,0 @@
-# ! Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
-
-import re
-
-class Packer:
-    """
-    P.A.C.K.E.R. sıkıştırma ve çözme işlemleri için bir sınıf.
-    ! » https://github.com/beautifier/js-beautify/blob/main/python/jsbeautifier/unpackers/packer.py
-    """
-    @staticmethod
-    def clean_escape_sequences(source: str) -> str:
-        """Kaçış dizilerini temizler."""
-        source = re.sub(r'\\\\', r'\\', source)
-        source = source.replace("\\'", "'")
-        source = source.replace('\\"', '"')
-        return source
-
-    @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)
-
-        if not match:
-            raise ValueError("Invalid P.A.C.K.E.R. source format.")
-
-        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"
-
-        return sum(alphabet.index(char) * (base**idx) for idx, char in enumerate(reversed(s)))
-
-    @staticmethod
-    def lookup_symbol(match: re.Match, symtab: list[str], radix: int) -> str:
-        """Sembolleri arar ve yerine koyar."""
-        word  = match[0]
-
-        return symtab[Packer.convert_base(word, radix)] or word
-
-    @staticmethod
-    def unpack(source: str) -> str:
-        """P.A.C.K.E.R. formatındaki sıkıştırılmış bir kaynağı çözer."""
-        source = Packer.clean_escape_sequences(source)
-
-        payload, symtab, radix, count = Packer.extract_arguments(source)
-
-        if count != len(symtab):
-            raise ValueError("Malformed P.A.C.K.E.R. symtab.")
-
-        return re.sub(r"\b\w+\b", lambda match: Packer.lookup_symbol(match, symtab, radix), payload)
-
-    @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.")