smartcache-maxximuss 1.0.0__tar.gz

smartcache_maxximuss-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Your Name
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

smartcache_maxximuss-1.0.0/PKG-INFO

@@ -0,0 +1,49 @@
+Metadata-Version: 2.4
+Name: smartcache-maxximuss
+Version: 1.0.0
+Summary: High-performance Python caching library featuring TTL, LRU, async support, and disk/memory backends.
+Author-email: Maxximuss <xxxmaxximussxxx@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/Maxximuss-hub/Smartcache
+Project-URL: Bug Tracker, https://github.com/Maxximuss-hub/Smartcache/issues
+Project-URL: Author Profile, https://github.com/Maxximuss-hub
+Keywords: cache,caching,lru,ttl,async,performance,smartcache
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# SmartCache 🚀
+
+Высокопроизводительная библиотека кэширования для Python.  
+**Создана для реальных задач: экономия ресурсов, ускорение API, работа с асинхронными запросами.**
+
+[![PyPI](https://img.shields.io/pypi/v/smartcache)](https://pypi.org/project/smartcache/)
+[![Python](https://img.shields.io/badge/Python-3.8%2B-blue)]()
+[![License](https://img.shields.io/badge/License-MIT-green)](LICENSE)
+
+## 💡 Зачем это нужно?
+
+Представь, что твой API-запрос стоит $0.01.  
+1000 пользователей одновременно запрашивают погоду → **$10 вместо $0.01**.  
+С `SmartCache` ты экономишь **99.9%** запросов!
+
+## 🚀 Установка
+
+```bash
+# Установка из PyPI (когда будет опубликовано)
+pip install smartcache
+
+# Или локальная установка (в разработке)
+git clone https://github.com/yourusername/smartcache.git
+cd smartcache
+pip install -e .

smartcache_maxximuss-1.0.0/README.md

@@ -0,0 +1,25 @@
+# SmartCache 🚀
+
+Высокопроизводительная библиотека кэширования для Python.  
+**Создана для реальных задач: экономия ресурсов, ускорение API, работа с асинхронными запросами.**
+
+[![PyPI](https://img.shields.io/pypi/v/smartcache)](https://pypi.org/project/smartcache/)
+[![Python](https://img.shields.io/badge/Python-3.8%2B-blue)]()
+[![License](https://img.shields.io/badge/License-MIT-green)](LICENSE)
+
+## 💡 Зачем это нужно?
+
+Представь, что твой API-запрос стоит $0.01.  
+1000 пользователей одновременно запрашивают погоду → **$10 вместо $0.01**.  
+С `SmartCache` ты экономишь **99.9%** запросов!
+
+## 🚀 Установка
+
+```bash
+# Установка из PyPI (когда будет опубликовано)
+pip install smartcache
+
+# Или локальная установка (в разработке)
+git clone https://github.com/yourusername/smartcache.git
+cd smartcache
+pip install -e .

smartcache_maxximuss-1.0.0/pyproject.toml

@@ -0,0 +1,38 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "smartcache-maxximuss"
+version = "1.0.0"
+description = "High-performance Python caching library featuring TTL, LRU, async support, and disk/memory backends."
+readme = "README.md"
+requires-python = ">=3.8"
+license = "MIT"
+
+authors = [
+    {name = "Maxximuss", email = "xxxmaxximussxxx@gmail.com"}
+]
+
+keywords = ["cache", "caching", "lru", "ttl", "async", "performance", "smartcache"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Software Development :: Libraries :: Python Modules"
+]
+
+[project.urls]
+"Homepage" = "https://github.com/Maxximuss-hub/Smartcache"
+"Bug Tracker" = "https://github.com/Maxximuss-hub/Smartcache/issues"
+"Author Profile" = "https://github.com/Maxximuss-hub"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["smartcache*"]
+exclude = ["tests*", "examples*"]

smartcache_maxximuss-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

smartcache_maxximuss-1.0.0/smartcache/__init__.py

@@ -0,0 +1,5 @@
+from .decorators.sync import cache
+from .decorators.async_ import async_cache
+
+__all__ = ["cache", "async_cache"]
+__version__ = "0.2.0"

smartcache_maxximuss-1.0.0/smartcache/backends/base.py

@@ -0,0 +1,35 @@
+from abc import ABC, abstractmethod
+from typing import Any
+
+
+class _NotFound:
+    """Сентинел для отсутствующего значения."""
+    pass
+
+
+class _Expired:
+    """Сентинел для истёкшего значения."""
+    pass
+
+
+NOT_FOUND = _NotFound()
+EXPIRED = _Expired()
+
+
+class StorageBackend(ABC):
+    """Абстрактный интерфейс для любого хранилища."""
+
+    @abstractmethod
+    def get(self, key: str) -> Any:
+        """Возвращает значение или NOT_FOUND/EXPIRED."""
+        pass
+
+    @abstractmethod
+    def set(self, key: str, value: Any, ttl: int | None) -> None:
+        """Сохраняет значение."""
+        pass
+
+    @abstractmethod
+    def clear(self) -> None:
+        """Очищает хранилище."""
+        pass

smartcache_maxximuss-1.0.0/smartcache/backends/disk.py

@@ -0,0 +1,54 @@
+import pickle
+import time
+from pathlib import Path
+from typing import Any
+from .base import StorageBackend, NOT_FOUND, EXPIRED
+
+
+class DiskBackend(StorageBackend):
+    """Хранилище на диске (через pickle)."""
+
+    def __init__(self, cache_dir: str = ".smartcache"):
+        self._cache_dir = Path(cache_dir)
+        self._cache_dir.mkdir(exist_ok=True)
+        self._metadata_file = self._cache_dir / "metadata.pkl"
+        
+        # Загружаем метаданные при инициализации
+        self._store = self._load_metadata()
+
+    def _load_metadata(self) -> dict:
+        """Загружает метаданные кэша с диска."""
+        if self._metadata_file.exists():
+            with open(self._metadata_file, "rb") as f:
+                return pickle.load(f)
+        return {}
+
+    def _save_metadata(self):
+        """Сохраняет метаданные на диск."""
+        with open(self._metadata_file, "wb") as f:
+            pickle.dump(self._store, f)
+
+    def get(self, key: str) -> Any:
+        if key not in self._store:
+            return NOT_FOUND
+        
+        value, expire_at = self._store[key]
+        
+        if expire_at is not None and time.monotonic() >= expire_at:
+            del self._store[key]
+            self._save_metadata()
+            return EXPIRED
+        
+        return value
+
+    def set(self, key: str, value: Any, ttl: int | None) -> None:
+        expire_at = None
+        if ttl is not None:
+            expire_at = time.monotonic() + ttl
+        
+        self._store[key] = (value, expire_at)
+        self._save_metadata()
+
+    def clear(self) -> None:
+        self._store.clear()
+        self._save_metadata()

smartcache_maxximuss-1.0.0/smartcache/backends/memory.py

@@ -0,0 +1,32 @@
+import time
+from typing import Any
+from .base import StorageBackend, NOT_FOUND, EXPIRED
+
+
+class MemoryBackend(StorageBackend):
+    """Хранилище в оперативной памяти."""
+
+    def __init__(self):
+        self._store: dict[str, tuple[Any, float | None]] = {}
+
+    def get(self, key: str) -> Any:
+        if key not in self._store:
+            return NOT_FOUND
+        
+        value, expire_at = self._store[key]
+        
+        if expire_at is not None and time.monotonic() >= expire_at:
+            del self._store[key]
+            return EXPIRED  # ✅ Возвращаем EXPIRED вместо NOT_FOUND
+        
+        return value
+
+    def set(self, key: str, value: Any, ttl: int | None) -> None:
+        expire_at = None
+        if ttl is not None:
+            expire_at = time.monotonic() + ttl
+        
+        self._store[key] = (value, expire_at)
+
+    def clear(self) -> None:
+        self._store.clear()

smartcache_maxximuss-1.0.0/smartcache/core/engine.py

@@ -0,0 +1,72 @@
+from typing import Any
+from collections import OrderedDict
+
+from ..backends.base import StorageBackend, NOT_FOUND, EXPIRED
+from ..utils.keymaker import generate_key
+from .stats import CacheStats
+
+
+class CacheEngine:
+    """Главное ядро кэша."""
+
+    def __init__(
+        self,
+        backend: StorageBackend,
+        max_size: int | None = None,
+        default_ttl: int | None = None,
+    ):
+        self._backend = backend
+        self._max_size = max_size
+        self._default_ttl = default_ttl
+        self._stats = CacheStats()
+        self._access_order: OrderedDict[str, None] = OrderedDict()
+
+    def get(self, func, args: tuple, kwargs: dict) -> Any:
+        """Пытается достать значение из кэша."""
+        key = generate_key((func.__name__, *args), kwargs)
+        
+        if key in self._access_order:
+            self._access_order.move_to_end(key)
+
+        value = self._backend.get(key)
+
+        # ✅ Обрабатываем истечение TTL
+        if isinstance(value, EXPIRED.__class__):
+            self._stats.record_expired()
+            self._stats.record_miss()
+            return NOT_FOUND
+        
+        if isinstance(value, NOT_FOUND.__class__):
+            self._stats.record_miss()
+            return NOT_FOUND
+        
+        self._stats.record_hit()
+        return value
+
+    def set(self, func, args: tuple, kwargs: dict, value: Any, ttl: int | None = None) -> None:
+        """Сохраняет значение в кэш."""
+        key = generate_key((func.__name__, *args), kwargs)
+        
+        if self._max_size is not None and len(self._access_order) >= self._max_size:
+            self._evict_oldest()
+
+        effective_ttl = ttl if ttl is not None else self._default_ttl
+        self._backend.set(key, value, effective_ttl)
+        
+        self._access_order[key] = None
+
+    def _evict_oldest(self):
+        """Удаляет самую старую запись (LRU)."""
+        if self._access_order:
+            oldest_key, _ = self._access_order.popitem(last=False)
+            self._backend._store.pop(oldest_key, None)
+
+    def clear(self):
+        """Очищает весь кэш."""
+        self._backend.clear()
+        self._access_order.clear()
+        self._stats.reset()
+
+    @property
+    def stats(self) -> CacheStats:
+        return self._stats

smartcache_maxximuss-1.0.0/smartcache/core/stats.py

@@ -0,0 +1,39 @@
+class CacheStats:
+    """Сборщик статистики кэша."""
+
+    def __init__(self):
+        self.hits = 0
+        self.misses = 0
+        self.expired = 0
+
+    def record_hit(self):
+        self.hits += 1
+
+    def record_miss(self):
+        self.misses += 1
+
+    def record_expired(self):
+        self.expired += 1
+
+    @property
+    def hit_rate(self) -> float:
+        total = self.hits + self.misses
+        if total == 0:
+            return 0.0
+        return (self.hits / total) * 100
+
+    def __str__(self) -> str:
+        total = self.hits + self.misses
+        return (
+            f"📊 Cache Statistics\n"
+            f"   Hits:     {self.hits}\n"
+            f"   Misses:   {self.misses}\n"
+            f"   Expired:  {self.expired}\n"
+            f"   Hit Rate: {self.hit_rate:.1f}%\n"
+            f"   Total:    {total}"
+        )
+
+    def reset(self):
+        self.hits = 0
+        self.misses = 0
+        self.expired = 0

smartcache_maxximuss-1.0.0/smartcache/decorators/async_.py

@@ -0,0 +1,78 @@
+import functools
+from typing import Callable, Any
+from ..core.engine import CacheEngine
+from ..backends.memory import MemoryBackend
+from ..backends.base import NOT_FOUND
+from ..utils.logger import CacheLogger
+
+
+def async_cache(
+    func: Callable | None = None,
+    *,
+    ttl: int | None = None,
+    max_size: int | None = None,
+    backend: Any = None,
+    log: bool = False,
+):
+    """
+    Асинхронный декоратор кэширования.
+    """
+    
+    if func is not None and callable(func):
+        return _create_async_decorator()(func)
+    else:
+        return _create_async_decorator(
+            ttl=ttl,
+            max_size=max_size,
+            backend=backend,
+            log=log,
+        )
+
+
+def _create_async_decorator(
+    ttl: int | None = None,
+    max_size: int | None = None,
+    backend: Any = None,
+    log: bool = False,
+):
+    """Создаёт асинхронный декоратор."""
+    
+    if backend is None:
+        backend = MemoryBackend()
+    
+    engine = CacheEngine(
+        backend=backend,
+        max_size=max_size,
+        default_ttl=ttl,
+    )
+    
+    logger = CacheLogger() if log else None
+    
+    def decorator(func: Callable) -> Callable:
+        @functools.wraps(func)
+        async def wrapper(*args, **kwargs):
+            if logger:
+                logger.log_attempt(func.__name__)
+            
+            cached_value = engine.get(func, args, kwargs)
+            
+            if cached_value is not NOT_FOUND:
+                if logger:
+                    logger.log_hit(func.__name__)
+                return cached_value
+            
+            if logger:
+                logger.log_miss(func.__name__)
+            
+            result = await func(*args, **kwargs)
+            
+            engine.set(func, args, kwargs, result, ttl=ttl)
+            
+            return result
+        
+        wrapper.cache_clear = engine.clear
+        wrapper.cache_stats = engine.stats
+        
+        return wrapper
+    
+    return decorator

smartcache_maxximuss-1.0.0/smartcache/decorators/sync.py

@@ -0,0 +1,92 @@
+import functools
+from typing import Callable, Any
+from ..core.engine import CacheEngine
+from ..backends.memory import MemoryBackend
+from ..backends.base import NOT_FOUND
+from ..utils.logger import CacheLogger
+
+
+def cache(
+    func: Callable | None = None,
+    *,
+    ttl: int | None = None,
+    max_size: int | None = None,
+    backend: Any = None,
+    log: bool = False,
+):
+    """
+    Умный декоратор кэширования.
+    
+    Работает в двух режимах:
+    - @cache
+    - @cache(ttl=60, max_size=100)
+    """
+    
+    #  МАГИЯ: Определяем, как нас вызвали
+    if func is not None and callable(func):
+        # Вызов без скобок: @cache
+        return _create_decorator()(func)
+    else:
+        # Вызов со скобками: @cache(ttl=60)
+        return _create_decorator(
+            ttl=ttl,
+            max_size=max_size,
+            backend=backend,
+            log=log,
+        )
+
+
+def _create_decorator(
+    ttl: int | None = None,
+    max_size: int | None = None,
+    backend: Any = None,
+    log: bool = False,
+):
+    """Создаёт декоратор с заданными параметрами."""
+    
+    # Создаём движок кэша (или используем предоставленный бэкенд)
+    if backend is None:
+        backend = MemoryBackend()
+    
+    engine = CacheEngine(
+        backend=backend,
+        max_size=max_size,
+        default_ttl=ttl,
+    )
+    
+    logger = CacheLogger() if log else None
+    
+    def decorator(func: Callable) -> Callable:
+        @functools.wraps(func)
+        def wrapper(*args, **kwargs):
+            # 🔥 Логгируем попытку
+            if logger:
+                logger.log_attempt(func.__name__)
+            
+            # Пытаемся достать из кэша
+            cached_value = engine.get(func, args, kwargs)
+            
+            if cached_value is not NOT_FOUND:
+                if logger:
+                    logger.log_hit(func.__name__)
+                return cached_value
+            
+            # Кэш не найден — вызываем функцию
+            if logger:
+                logger.log_miss(func.__name__)
+            
+            result = func(*args, **kwargs)
+            
+            # Сохраняем результат в кэш
+            engine.set(func, args, kwargs, result, ttl=ttl)
+            
+            return result
+        
+        # Добавляем методы для доступа к статистике и очистке
+        wrapper.cache_clear = engine.clear
+        wrapper.cache_stats = engine.stats
+        wrapper.cache_info = lambda: engine.stats  # Для совместимости с lru_cache
+        
+        return wrapper
+    
+    return decorator

smartcache_maxximuss-1.0.0/smartcache/utils/keymaker.py

@@ -0,0 +1,21 @@
+import hashlib
+import pickle
+
+def generate_key(args: tuple, kwargs: dict) -> str:
+    """
+    Превращает ЛЮБЫЕ аргументы функции в уникальную строку-ключ.
+    """
+    # 1. Сортируем kwargs по ключам. 
+    # Зачем? Чтобы вызовы func(a=1, b=2) и func(b=2, a=1) 
+    # сгенерировали ОДИНАКОВЫЙ ключ.
+    sorted_kwargs = tuple(sorted(kwargs.items()))
+    
+    # 2. Собираем всё в единый кортеж
+    data = (args, sorted_kwargs)
+    
+    # 3. Сериализуем через pickle. 
+    # Он умеет превращать в байты вообще всё (списки, словари, кастомные классы).
+    serialized_data = pickle.dumps(data)
+    
+    # 4. Хэшируем байты в MD5, чтобы получить короткую и быструю строку
+    return hashlib.md5(serialized_data).hexdigest()

smartcache_maxximuss-1.0.0/smartcache/utils/logger.py

@@ -0,0 +1,14 @@
+class CacheLogger:
+    """Простой логгер для кэша."""
+    
+    def log_attempt(self, func_name: str):
+        pass  # Можно добавить логирование попыток
+    
+    def log_hit(self, func_name: str):
+        print(f"✅ CACHE HIT  | {func_name}")
+    
+    def log_miss(self, func_name: str):
+        print(f"❌ CACHE MISS | {func_name}")
+    
+    def log_expired(self, func_name: str):
+        print(f"⏰ CACHE EXPIRED | {func_name}")

smartcache_maxximuss-1.0.0/smartcache_maxximuss.egg-info/PKG-INFO

@@ -0,0 +1,49 @@
+Metadata-Version: 2.4
+Name: smartcache-maxximuss
+Version: 1.0.0
+Summary: High-performance Python caching library featuring TTL, LRU, async support, and disk/memory backends.
+Author-email: Maxximuss <xxxmaxximussxxx@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/Maxximuss-hub/Smartcache
+Project-URL: Bug Tracker, https://github.com/Maxximuss-hub/Smartcache/issues
+Project-URL: Author Profile, https://github.com/Maxximuss-hub
+Keywords: cache,caching,lru,ttl,async,performance,smartcache
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# SmartCache 🚀
+
+Высокопроизводительная библиотека кэширования для Python.  
+**Создана для реальных задач: экономия ресурсов, ускорение API, работа с асинхронными запросами.**
+
+[![PyPI](https://img.shields.io/pypi/v/smartcache)](https://pypi.org/project/smartcache/)
+[![Python](https://img.shields.io/badge/Python-3.8%2B-blue)]()
+[![License](https://img.shields.io/badge/License-MIT-green)](LICENSE)
+
+## 💡 Зачем это нужно?
+
+Представь, что твой API-запрос стоит $0.01.  
+1000 пользователей одновременно запрашивают погоду → **$10 вместо $0.01**.  
+С `SmartCache` ты экономишь **99.9%** запросов!
+
+## 🚀 Установка
+
+```bash
+# Установка из PyPI (когда будет опубликовано)
+pip install smartcache
+
+# Или локальная установка (в разработке)
+git clone https://github.com/yourusername/smartcache.git
+cd smartcache
+pip install -e .

smartcache_maxximuss-1.0.0/smartcache_maxximuss.egg-info/SOURCES.txt

@@ -0,0 +1,22 @@
+LICENSE
+README.md
+pyproject.toml
+smartcache/__init__.py
+smartcache/exceptions.py
+smartcache/backends/base.py
+smartcache/backends/disk.py
+smartcache/backends/memory.py
+smartcache/core/engine.py
+smartcache/core/stats.py
+smartcache/decorators/async_.py
+smartcache/decorators/sync.py
+smartcache/utils/keymaker.py
+smartcache/utils/logger.py
+smartcache_maxximuss.egg-info/PKG-INFO
+smartcache_maxximuss.egg-info/SOURCES.txt
+smartcache_maxximuss.egg-info/dependency_links.txt
+smartcache_maxximuss.egg-info/top_level.txt
+tests/test_async_disk.py
+tests/test_final.py
+tests/test_step1.py
+tests/test_step2.py

smartcache_maxximuss-1.0.0/smartcache_maxximuss.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

smartcache_maxximuss-1.0.0/smartcache_maxximuss.egg-info/top_level.txt

@@ -0,0 +1 @@
+smartcache

smartcache_maxximuss-1.0.0/tests/test_async_disk.py

@@ -0,0 +1,57 @@
+import asyncio
+from smartcache import async_cache
+from smartcache.backends.disk import DiskBackend
+
+
+# ТЕСТ 1: Async с TTL
+@async_cache(ttl=3, log=True)
+async def fetch_data(url: str):
+    """Имитация асинхронного запроса."""
+    print(f"  🌐 Запрос к {url}...")
+    await asyncio.sleep(1)
+    return f"Data from {url}"
+
+
+# ТЕСТ 2: Disk Backend (сохранение между запусками)
+disk_backend = DiskBackend("./my_cache")
+
+@async_cache(backend=disk_backend, log=True)
+async def heavy_computation(x: int):
+    """Тяжелое вычисление с сохранением на диск."""
+    print(f"   Вычисляю {x}^2...")
+    await asyncio.sleep(1)
+    return x ** 2
+
+
+async def main():
+    print("=" * 50)
+    print("ТЕСТ 1: Async Cache")
+    print("=" * 50)
+    
+    result1 = await fetch_data("https://api.example.com")
+    print(f"Результат: {result1}")
+    
+    result2 = await fetch_data("https://api.example.com")
+    print(f"Из кэша: {result2}")
+    
+    print("\nЖдём 4 секунды...")
+    await asyncio.sleep(4)
+    
+    result3 = await fetch_data("https://api.example.com")
+    print(f"После TTL: {result3}")
+    
+    print("\n" + "=" * 50)
+    print("ТЕСТ 2: Disk Backend")
+    print("=" * 50)
+    
+    result4 = await heavy_computation(42)
+    print(f"Результат: {result4}")
+    
+    result5 = await heavy_computation(42)
+    print(f"Из кэша: {result5}")
+    
+    print("\n✅ Кэш сохранён на диск! Перезапусти скрипт — он загрузится.")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

smartcache_maxximuss-1.0.0/tests/test_final.py

@@ -0,0 +1,53 @@
+import time
+from smartcache import cache
+
+# 🔥 ТЕСТ 1: Декоратор без скобок
+@cache
+def fibonacci_slow(n):
+    """Медленная функция Фибоначчи."""
+    if n < 2:
+        return n
+    return fibonacci_slow(n-1) + fibonacci_slow(n-2)
+
+# 🔥 ТЕСТ 2: Декоратор со скобками
+@cache(ttl=3, max_size=2, log=True)
+def expensive_calculation(x, y):
+    """Дорогая функция с TTL."""
+    print(f"  🔄 Вычисляю {x} + {y}...")
+    time.sleep(1)
+    return x + y
+
+#  ТЕСТ 3: Функция с нехэшируемыми аргументами
+@cache
+def process_data(data_dict):
+    """Функция со словарём (нехэшируемый аргумент)."""
+    return sum(data_dict.values())
+
+
+if __name__ == "__main__":
+    print("=" * 50)
+    print("ТЕСТ 1: Fibonacci (без скобок)")
+    print("=" * 50)
+    print(f"fib(10) = {fibonacci_slow(10)}")
+    print(f"fib(10) из кэша = {fibonacci_slow(10)}")
+    print(fibonacci_slow.cache_stats)
+    
+    print("\n" + "=" * 50)
+    print("ТЕСТ 2: Expensive Calculation (с TTL и логами)")
+    print("=" * 50)
+    print(f"Результат: {expensive_calculation(5, 10)}")
+    print(f"Результат из кэша: {expensive_calculation(5, 10)}")
+    
+    print("\nЖдём 4 секунды (TTL=3)...")
+    time.sleep(4)
+    
+    print(f"Результат после TTL: {expensive_calculation(5, 10)}")
+    print(expensive_calculation.cache_stats)
+    
+    print("\n" + "=" * 50)
+    print("ТЕСТ 3: Нехэшируемые аргументы")
+    print("=" * 50)
+    data = {"a": 1, "b": 2, "c": 3}
+    print(f"process_data(data) = {process_data(data)}")
+    print(f"process_data(data) из кэша = {process_data(data)}")
+    print(process_data.cache_stats)

smartcache_maxximuss-1.0.0/tests/test_step1.py

@@ -0,0 +1,25 @@
+import time
+from smartcache.utils.keymaker import generate_key
+from smartcache.backends.memory import MemoryBackend, NOT_FOUND
+
+# 1. Тестируем генератор ключей
+key1 = generate_key((1, 2), {'a': 5, 'b': [1, 2]})
+key2 = generate_key((1, 2), {'b': [1, 2], 'a': 5}) # Порядок kwargs другой!
+print(f"Ключи совпадают? {key1 == key2}") # Должно быть True
+
+# 2. Тестируем бэкенд
+cache = MemoryBackend()
+
+# Сохраняем на 2 секунды
+cache.set("test_key", "Hello World", ttl=2)
+
+# Достаем сразу
+val = cache.get("test_key")
+print(f"Сразу: {val}") # Hello World
+
+# Ждем 3 секунды
+time.sleep(3)
+
+# Достаем после истечения TTL
+val_expired = cache.get("test_key")
+print(f"Через 3 сек: {val_expired is NOT_FOUND}") # Должно быть True

smartcache_maxximuss-1.0.0/tests/test_step2.py

@@ -0,0 +1,37 @@
+import time
+from smartcache.backends.memory import MemoryBackend
+from smartcache.core.engine import CacheEngine
+from smartcache.backends.base import NOT_FOUND
+
+# Создаем движок с лимитом 3 записи и TTL по умолчанию 2 сек
+backend = MemoryBackend()
+engine = CacheEngine(backend, max_size=3, default_ttl=2)
+
+def dummy_func():
+    pass
+
+# 1. Сохраняем 3 значения
+engine.set(dummy_func, (1,), {}, "A")
+engine.set(dummy_func, (2,), {}, "B")
+engine.set(dummy_func, (3,), {}, "C")
+print(engine.stats)  # Все misses
+
+# 2. Достаем "A" — оно становится "свежим"
+val = engine.get(dummy_func, (1,), {})
+print(f"Достали A: {val}")  # A
+print(engine.stats)  # 1 hit
+
+# 3. Добавляем 4-е значение — должно вытисниться самое старое ("B")
+engine.set(dummy_func, (4,), {}, "D")
+
+# 4. Пытаемся достать "B" — его уже нет!
+val_b = engine.get(dummy_func, (2,), {})
+print(f"B вытеснен? {val_b is NOT_FOUND}")  # True
+
+# 5. Ждем истечения TTL
+time.sleep(3)
+val_a = engine.get(dummy_func, (1,), {})
+print(f"A истек? {val_a is NOT_FOUND}")  # True
+
+print("\nИтоговая статистика:")
+print(engine.stats)