Kekik 1.6.7__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

@@ -1,65 +1,306 @@
-# ! https://github.com/Fatal1ty/aiocached
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
 
-import asyncio
+from .cli         import konsol
 from functools    import wraps
-from time         import time
 from hashlib      import md5
 from urllib.parse import urlencode
+import time
+import threading
+import asyncio
+import pickle
+
+# 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
 
-class Cache:
+# 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):
     """
-    Basit in-memory cache yapısı.
-    TTL (time-to-live) süresi dolan veriler otomatik olarak temizlenir (get/erişim anında kontrol edilir).
+    Cache key oluşturma amacıyla verilen değeri normalize eder.
+    - Basit tipler (int, float, str, bool, None) doğrudan kullanılır.
+    - dict: Anahtarları sıralı olarak normalize eder.
+    - list/tuple: Elemanları normalize eder.
+    - Diğer: Sadece sınıf ismi kullanılır.
     """
-    def __init__(self, ttl=UNLIMITED):
-        self._data  = {}
-        self._ttl   = ttl
-        self._times = {}
+    if isinstance(value, (int, float, str, bool, type(None))):
+        return value
+
+    elif isinstance(value, dict):
+        return {k: normalize_for_key(value[k]) for k in sorted(value)}
+
+    elif isinstance(value, (list, tuple)):
+        return [normalize_for_key(item) for item in value]
+
+    else:
+        return value.__class__.__name__
+
+def simple_cache_key(func, args, kwargs) -> str:
+    """
+    Fonksiyonun tam adı ve parametrelerini kullanarak bir cache key oluşturur.
+    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]
+        base_key += f"|{norm_args}"
+
+    if kwargs:
+        norm_kwargs = {k: normalize_for_key(v) for k, v in kwargs.items()}
+        base_key   += f"|{str(sorted(norm_kwargs.items()))}"
+
+    hashed = md5(base_key.encode('utf-8')).hexdigest()
+    return f"{base_key}"  # |{hashed}
+
+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)
+
+    # FastAPI: request ilk argümandan ya da kwargs'dan alınır.
+    request = args[0] if args else kwargs.get("request")
+
+    # Request bulunamamışsa fallback
+    if request is None or not hasattr(request, 'method'):
+        return simple_cache_key(func, args, kwargs)
+
+    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ı
+# -----------------------------------------------------
+
+class SyncCache:
+    """
+    Senkron fonksiyonlar için basit in-memory cache.
+    TTL süresi dolan veriler periyodik olarak arka plan thread'iyle temizlenir.
+    """
+    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 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._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:
+            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 dolduysa True döner."""
+        """Belirtilen key'in süresi dolmuşsa True döner."""
         if self._ttl is UNLIMITED:
             return False
 
         timestamp = self._times.get(key)
 
-        return timestamp is not None and (time() - timestamp > self._ttl)
+        return timestamp is not None and (time.time() - timestamp > self._ttl)
 
     def remove_if_expired(self, key):
         """
         Eğer key'in cache süresi dolmuşsa, ilgili entry'yi temizler.
+        Thread güvenliği sağlamak için lock kullanılır.
         """
-        if self._is_expired(key):
-            self._data.pop(key, None)
-            self._times.pop(key, None)
+        with self._lock:
+            if self._is_expired(key):
+                self._data.pop(key, None)
+                self._times.pop(key, None)
+                # konsol.log(f"[red][-] {key}")
 
     def __getitem__(self, key):
-        self.remove_if_expired(key)
-        return self._data[key]
+        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):
-        self._data[key] = value
-        if self._ttl is not UNLIMITED:
-            self._times[key] = time()
+        with self._lock:
+            # 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)
 
-class AsyncCache(Cache):
+# -----------------------------------------------------
+# Asenkron Cache (In-Memory) ve Redis Hybrid Cache
+# -----------------------------------------------------
+
+class AsyncCache:
     """
-    Asenkron işlemleri destekleyen cache yapısı.
-    Aynı key için gelen eşzamanlı çağrılar, futures kullanılarak tek sonuç üzerinden paylaşılır.
-    Ek olarak, belirli aralıklarla cache’i kontrol edip, süresi dolmuş verileri temizleyen otomatik temizleme görevi çalışır.
+    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).
         """
-        super().__init__(ttl)
-        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 kullanıyoruz.
+        self._cleanup_interval = cleanup_interval if ttl is UNLIMITED else min(ttl, cleanup_interval)
 
-        self._cleanup_interval = max(ttl, cleanup_interval) if ttl is not UNLIMITED else cleanup_interval
         # Aktif bir event loop varsa otomatik temizlik görevini başlatıyoruz.
         try:
             self._cleanup_task = asyncio.get_running_loop().create_task(self._auto_cleanup())
@@ -69,50 +310,175 @@ class AsyncCache(Cache):
     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)
-            # _data kopyasını almak, üzerinde dönüp silme yaparken hata almamak için.
-            keys = list(self._data.keys())
-            for key in 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."""
+        if self._cleanup_task is None:
+            try:
+                self._cleanup_task = asyncio.get_running_loop().create_task(self._auto_cleanup())
+            except RuntimeError:
+                pass  # Yine loop yoksa yapacak bir şey yok
+
+    def remove_if_expired(self, key):
+        """
+        Belirtilen key'in süresi dolduysa, cache ve futures içerisinden temizler.
+        """
+        if self._ttl is not UNLIMITED:
+            t = self._times.get(key)
+            if t is not None and (time.time() - t > self._ttl):
+                # konsol.log(f"[red][-] {key}")
+                self._data.pop(key, None)
+                self._times.pop(key, None)
+                self.futures.pop(key, None)
 
     async def get(self, key):
         """
         Belirtilen key için cache'de saklanan değeri asenkron olarak döndürür.
         Eğer key bulunamazsa, ilgili future üzerinden beklemeyi sağlar.
         """
+        # Cleanup task'in aktif olduğundan emin olun.
+        self.ensure_cleanup_task()
+        # Eğer key'in süresi dolmuşsa, kaldırın.
         self.remove_if_expired(key)
 
         try:
-            return self._data[key]
-        except KeyError as e:
+            # 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:
+            # Eğer key cache'de yoksa, aynı key ile başlatılmış future varsa onu bekle.
             future = self.futures.get(key)
             if future:
                 await future
-                return future.result()
+                # Future tamamlandığında sonucu döndür.
+                value = future.result()
+                # konsol.log(f"[yellow][?] {key}")
+                return value
+            # Eğer future da yoksa, key bulunamadığına dair hata fırlat.
+            raise KeyError(key)
+
+    async def set(self, key, value):
+        """Belirtilen key için cache'e değer ekler."""
+        self.ensure_cleanup_task()
+
+        # 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()
 
-            raise e
+class HybridAsyncCache:
+    """
+    Öncelikle Redis cache kullanılmaya çalışılır.
+    Hata durumunda veya Redis erişilemiyorsa in-memory AsyncCache'e geçilir.
+    """
+    def __init__(self, ttl=UNLIMITED, max_size=10000):
+        self._ttl = ttl
+        self._max_size = max_size
 
-    def remove_if_expired(self, key):
-        """
-        Belirtilen key'in süresi dolduysa, cache ve futures içerisinden temizler.
-        """
-        if self._ttl is not UNLIMITED and self._is_expired(key):
-            self._data.pop(key, None)
-            self._times.pop(key, None)
-            self.futures.pop(key, None)
+        try:
+            self.redis = redisAsync.Redis(
+                host             = REDIS_HOST,
+                port             = REDIS_PORT,
+                db               = REDIS_DB,
+                password         = REDIS_PASS,
+                decode_responses = False
+            )
+        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, max_size=max_size)
+        self.futures = {}
+
+    async def get(self, key):
+        # Eşzamanlı istek yönetimi: aynı key için bir future varsa, direkt bekleyip sonucu döndür.
+        if key in self.futures:
+            # konsol.log(f"[yellow][?] {key}")
+            return await self.futures[key]
+
+        # İlk önce Redis ile deneyelim
+        if self.redis:
+            try:
+                data = await self.redis.get(key)
+            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 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
+                return await self.memory.get(key)
+        else:
+            # Redis kullanılmıyorsa doğrudan in-memory cache'e bak
+            return await self.memory.get(key)
+
+    async def set(self, key, value):
+        # Önce veriyi pickle etmeyi deniyoruz.
+        try:
+            ser = pickle.dumps(value)
+        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
+
+        if self.redis:
+            try:
+                if self._ttl is not UNLIMITED:
+                    await self.redis.set(key, ser, ex=self._ttl)
+                else:
+                    await self.redis.set(key, ser)
+                return
+            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:
+            # Redis yoksa in-memory cache'e yaz
+            await self.memory.set(key, value)
 
+# -----------------------------------------------------
+# Cache'e Hesaplanmış Sonucu Yazma Yardımcı Fonksiyonları
+# -----------------------------------------------------
 
 def _sync_maybe_cache(func, key, result, unless):
-    """Senkron sonuç için cache kaydını oluşturur (unless koşuluna bakarak)."""
+    """Senkron fonksiyon sonucu için cache kaydı oluşturur."""
     if unless is None or not unless(result):
         func.__cache[key] = result
-
+        # konsol.log(f"[green][+] {key}")
 
 async def _async_compute_and_cache(func, key, unless, *args, **kwargs):
     """
-    Asenkron fonksiyon sonucunu hesaplar ve cache'e ekler.
-    Aynı key için işlem devam ediyorsa, mevcut sonucu bekler.
-    Sonuç, unless(result) True değilse cache'e eklenir.
+    Asenkron fonksiyon sonucunu hesaplar ve cache'e yazar.
+    Aynı key için gelen eşzamanlı çağrılar future üzerinden bekletilir.
     """
     # __cache'den cache nesnesini alıyoruz.
     cache = func.__cache
@@ -129,11 +495,12 @@ async def _async_compute_and_cache(func, key, unless, *args, **kwargs):
         # Asenkron fonksiyonu çalıştır ve sonucu elde et.
         result = await func(*args, **kwargs)
         future.set_result(result)
-        
+
         # unless koşuluna göre cache'e ekleme yap.
         if unless is None or not unless(result):
-            cache[key] = result
-        
+            await cache.set(key, result)
+            # konsol.log(f"[green][+] {key}")
+
         return result
     except Exception as exc:
         future.cancel()
@@ -142,61 +509,65 @@ async def _async_compute_and_cache(func, key, unless, *args, **kwargs):
         # İşlem tamamlandığında future'ı temizle.
         cache.futures.pop(key, None)
 
-async def make_cache_key(args, kwargs, is_fastapi=False):
-    """
-    Cache key'ini oluşturur.
-    
-    :param is_fastapi (bool): Eğer True ise, ilk argümanın bir FastAPI Request nesnesi olduğu varsayılır.
-        Bu durumda, cache key, request nesnesinin URL yolunu (request.url.path) ve 
-        isteğe ait verilerden (GET istekleri için query parametreleri; diğer istekler için JSON veya form verileri)
-        elde edilen verinin URL uyumlu halinin md5 hash'inin birleşiminden oluşturulur.
-        Böylece, aynı URL ve aynı istek verileri için her seferinde aynı cache key üretilecektir.
-        Eğer False ise, cache key args ve kwargs değerlerinden, sıralı bir tuple olarak oluşturulur.
-    """
-    if not is_fastapi:
-        return (args, tuple(sorted(kwargs.items())))
-
-    request = args[0] if args else kwargs.get("request")
-
-    if request.method == "GET":
-        veri = dict(request.query_params) if request.query_params else None
-    else:
-        try:
-            veri = await request.json()
-        except Exception:
-            form_data = await request.form()
-            veri = dict(form_data.items())
-
-    args_hash = md5(urlencode(veri).encode()).hexdigest() if veri else ""
-    return f"{request.url.path}?{args_hash}"
-
+# -----------------------------------------------------
+# kekik_cache Dekoratörü (Senkrondan Asenkrona)
+# -----------------------------------------------------
 
-def kekik_cache(ttl=UNLIMITED, unless=None, is_fastapi=False):
+def kekik_cache(ttl=UNLIMITED, unless=None, use_redis=True, max_size=10000, is_fastapi=None, include_auth=False):
     """
-    Bir fonksiyon veya coroutine'in sonucunu cache'ler.
+    Bir fonksiyonun (senkron/asenkron) sonucunu cache'ler.
+    FastAPI endpoint'leri otomatik detekt edilir (is_fastapi=None ise) veya manuel olarak belirtilebilir.
     
-    :param ttl: Cache’in geçerlilik süresi (saniye). UNLIMITED ise süresizdir.
-    :param unless: Fonksiyonun sonucunu argüman olarak alan bir callable. 
-                   Eğer True dönerse, sonuç cache'e alınmaz.
-    :param is_fastapi: Eğer True ise, cache key'i oluştururken FastAPI request nesnesine özel şekilde davranır.
-
-    Örnek kullanım:
+    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/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 res: res is None)
-        async def bakalim(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ıldığında
+    # Parametresiz kullanım durumunda
     if callable(ttl):
-        return kekik_cache(UNLIMITED, unless=unless, is_fastapi=is_fastapi)(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):
-        func.__cache = AsyncCache(ttl)
-
         if asyncio.iscoroutinefunction(func):
+            # Asenkron fonksiyonlar için cache türünü seçelim:
+            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(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)
@@ -205,9 +576,12 @@ def kekik_cache(ttl=UNLIMITED, unless=None, is_fastapi=False):
 
             return async_wrapper
         else:
+            # Senkron fonksiyonlar için
+            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):
-                key = (args, tuple(sorted(kwargs.items())))
+                key = simple_cache_key(func, args, kwargs)
 
                 try:
                     return func.__cache[key]

{Kekik-1.6.7.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.6.7
+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.6.7.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=YrlSJBIaFeI6syURQhkF4M8tv6zr72zny-lnazA2VoI,7858
+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.6.7.dist-info/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-Kekik-1.6.7.dist-info/METADATA,sha256=JLbEAry2cH-qyFJ6Uc5i2-RPC4HI_aO6CYPivbvvhwM,43959
-Kekik-1.6.7.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-Kekik-1.6.7.dist-info/entry_points.txt,sha256=yjBifxtRlqfg8lPkH4Bu-urSa5ecptCHsuth-DcyWcg,59
-Kekik-1.6.7.dist-info/top_level.txt,sha256=NotddscfgxawvuRyAa7xkgnMhyteFDcBxb5aU5GY3BM,6
-Kekik-1.6.7.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.6.7.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