fixes for

iamsinghrajat#26

Author: doubledare704

LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2020 Rajat Singh
+Copyright (c) 2020 doubledare704
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

README.md

@@ -0,0 +1,131 @@
+# async-cache
+> A high-performance async caching solution for Python
+
+[![PyPI version](https://img.shields.io/pypi/v/async-cache.svg)](https://pypi.python.org/pypi/async-cache)
+[![Downloads](https://static.pepy.tech/personalized-badge/async-cache?period=total&units=international_system&left_color=black&right_color=blue&left_text=Downloads)](https://pepy.tech/project/async-cache)
+[![Security Rating](https://snyk.io/advisor/python/async-cache/badge.svg)](https://snyk.io/advisor/python/async-cache)
+
+A lightweight, efficient caching solution designed specifically for asyncio applications. Supports both LRU (Least Recently Used) and TTL (Time To Live) caching strategies with a clean, decorator-based API.
+
+## Features
+
+- 🚀 **Async-First**: Built specifically for asyncio applications
+- 🔄 **Multiple Cache Types**: 
+  - LRU (Least Recently Used) cache
+  - TTL (Time To Live) cache
+- 🎯 **Flexible Key Generation**: Works with primitive types, custom objects, and ORM models
+- 🛠 **Configurable**: Adjustable cache size and TTL duration
+- 🧹 **Cache Management**: Clear cache on demand
+- 💡 **Smart Argument Handling**: Skip specific arguments in cache key generation
+- 🔍 **Cache Bypass**: Ability to bypass cache for specific calls
+
+## Installation
+
+```bash
+pip install async-cache
+```
+
+## Basic Usage
+
+### LRU Cache
+
+The LRU cache maintains a fixed number of items, removing the least recently used item when the cache is full.
+
+```python
+from cache import AsyncLRU
+
+@AsyncLRU(maxsize=128)
+async def get_user_data(user_id: int) -> dict:
+    # Expensive database operation
+    data = await db.fetch_user(user_id)
+    return data
+```
+
+### TTL Cache
+
+The TTL cache automatically expires entries after a specified time period.
+
+```python
+from cache import AsyncTTL
+
+@AsyncTTL(time_to_live=60, maxsize=1024)
+async def get_weather(city: str) -> dict:
+    # External API call
+    weather = await weather_api.get_data(city)
+    return weather
+```
+
+## Advanced Usage
+
+### Working with Custom Objects
+
+The cache works seamlessly with custom objects and ORM models:
+
+```python
+from dataclasses import dataclass
+from cache import AsyncLRU
+
+@dataclass
+class UserFilter:
+    age: int
+    country: str
+    status: str
+
+@AsyncLRU(maxsize=128)
+async def filter_users(filter_params: UserFilter) -> list:
+    # Complex filtering operation
+    users = await db.filter_users(
+        age=filter_params.age,
+        country=filter_params.country,
+        status=filter_params.status
+    )
+    return users
+```
+
+### Skipping Arguments
+
+Useful for methods where certain arguments shouldn't affect the cache key:
+
+```python
+from cache import AsyncTTL
+
+class UserService:
+    @AsyncTTL(time_to_live=300, maxsize=1000, skip_args=1)
+    async def get_user_preferences(self, user_id: int) -> dict:
+        # 'self' is skipped in cache key generation
+        return await self.db.get_preferences(user_id)
+```
+
+### Cache Management
+
+#### Bypassing Cache
+
+```python
+# Normal cached call
+result = await get_user_data(123)
+
+# Force fresh data
+fresh_result = await get_user_data(123, use_cache=False)
+```
+
+#### Clearing Cache
+
+```python
+# Clear the entire cache
+get_user_data.cache_clear()
+```
+
+## Performance Considerations
+
+- The LRU cache is ideal for frequently accessed data with no expiration requirements
+- The TTL cache is perfect for data that becomes stale after a certain period
+- Choose `maxsize` based on your memory constraints and data access patterns
+- Consider using `skip_args` when caching class methods to avoid instance-specific caching
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request. For major changes, please open an issue first to discuss what you would like to change.
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

README.rst

@@ -1,4 +1,5 @@
 from collections import OrderedDict
+from copy import deepcopy
 
 
 class LRU(OrderedDict):
@@ -7,12 +8,12 @@ def __init__(self, maxsize, *args, **kwargs):
         super().__init__(*args, **kwargs)
 
     def __getitem__(self, key):
-        value = super().__getitem__(key)
+        value = deepcopy(super().__getitem__(key))
         self.move_to_end(key)
         return value
 
     def __setitem__(self, key, value):
-        super().__setitem__(key, value)
+        super().__setitem__(key, deepcopy(value))
         if self.maxsize and len(self) > self.maxsize:
             oldest = next(iter(self))
             del self[oldest]

cache/lru.py

@@ -0,0 +1,79 @@
+[build-system]
+requires = ["setuptools>=79.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "async-cache"
+version = "1.1.1"
+description = "A high-performance async caching solution for Python"
+authors = [
+    {name = "Rajat Singh", email = "iamsinghrajat@gmail.com"},
+]
+readme = "README.md"
+requires-python = ">=3.3"
+keywords = ["asyncio", "lru", "cache", "async", "cache", "lru-cache", "ttl"]
+license = {text = "MIT"}
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]
+
+[tool.ruff]
+line-length = 88
+target-version = "py38"
+
+# Enable all rules by default
+select = ["ALL"]
+ignore = [
+    "D",        # Ignore docstring rules
+    "ANN",      # Ignore type annotation rules
+    "ERA",      # Ignore eradicate rules
+    "UP037",    # Ignore quotes in type annotations
+    "PLR0913",  # Ignore too many arguments
+]
+
+[tool.ruff.format]
+quote-style = "double"
+indent-style = "space"
+skip-magic-trailing-comma = false
+line-ending = "auto"
+
+[tool.pyright]
+include = ["cache", "tests"]
+exclude = ["**/node_modules", "**/__pycache__"]
+pythonVersion = "3.8"
+typeCheckingMode = "basic"
+reportMissingImports = true
+reportMissingTypeStubs = false
+reportUnknownMemberType = false
+reportUnknownVariableType = false
+reportUnknownArgumentType = false
+
+[tool.pytest.ini_options]
+minversion = "8.0.0"
+addopts = """
+    --strict-markers
+    --strict-config
+    --cov=cache
+    --cov-report=term-missing
+    --cov-report=xml
+    --cov-report=html
+    -v
+"""
+testpaths = ["tests"]
+python_files = ["*_test.py"]
+asyncio_mode = "auto"
+
+[tool.coverage.run]
+branch = true
+source = ["cache"]
+
+[tool.coverage.report]
+exclude_lines = [
+    "pragma: no cover",
+    "def __repr__",
+    "if __name__ == .__main__.:",
+    "raise NotImplementedError",
+    "if TYPE_CHECKING:",
+]

pyproject.toml

@@ -0,0 +1,6 @@
+ruff==0.11.6
+pyright==1.1.399
+
+pytest==8.3.5
+pytest-asyncio==0.26.0
+pytest-cov==6.1.1

requirements-dev.txt

@@ -1,15 +1,16 @@
 import setuptools
 
-with open("README.rst", "r") as fh:
-    long_description = fh.read()
-
 setuptools.setup(
     name="async-cache",
     version="1.1.1",
     author="Rajat Singh",
     author_email="iamsinghrajat@gmail.com",
     description="An asyncio Cache",
-    long_description=long_description,
+    long_description="""
+# A high-performance async caching solution for Python
+A lightweight, efficient caching solution designed specifically for asyncio applications. 
+Supports both LRU (Least Recently Used) and TTL (Time To Live) caching strategies with a clean, decorator-based API.
+""",
     long_description_content_type="text/x-rst",
     url="https://github.com/iamsinghrajat/async-cache",
     packages=setuptools.find_packages(),