Metadata-Version: 2.1
Name: mecache
Version: 1.4.0
Summary: An easy-to-use cache module
Home-page: https://github.com/AberSheeran/mecache
Author: AberSheeran
Author-email: AberSheeran@outlook.com
License: MIT
Description: 
        # mecache
        
        An easy-to-use cache module
        
        ## How to use
        
        Run `pip install mecache` or `pipenv install mecache` to install.
        
        Built-in two cache modes, file cache mode, redis cache mode.
        
        You can control the time of cache failure by using the cache parameters.
        
        ### redis modes
        
        ```python
        from mecache import Redis
        
        # Refer to https://redis-py.readthedocs.io/en/latest/ for all parameters
        redis = Redis(host="127.0.0.1", port='6379', db=0, password="password")
        
        # Cache failure after 60 seconds
        @redis.cache(60)
        def do(x, y):
            import time
            time.sleep(2)
            return x+y
        ```
        
        ### asynchronous redis modes
        
        ```python
        from mecache import AioRedis
        
        # Refer to https://aioredis.readthedocs.io/en/latest/api_reference.html#aioredis.create_redis_pool for all parameters
        file = await AioRedis('redis://localhost')
        
        # Cache failure after 60 seconds
        @file.cache(60)
        async def do(x, y):
            return await do.something
        ```
        
        ### file modes
        
        ```python
        from mecache import File
        
        # CACHE_PATH like '/var/tmp/test-cache'
        file = File("CACHE_PATH")
        
        # Cache failure after 60 seconds
        @file.cache(60)
        def do(x, y):
            import time
            time.sleep(2)
            return x+y
        ```
        
        ### asynchronous file modes
        
        ```python
        from mecache import AioFile
        
        # CACHE_PATH like '/var/tmp/test-cache'
        file = AioFile("CACHE_PATH")
        
        # Cache failure after 60 seconds
        @file.cache(60)
        async def do(x, y):
            return await do.something
        ```
        
        ## Advanced usage
        
        If the parameters of a function are difficult to serialize using pickle, you can specify the rules that generate key by customizing `keyf`. The return value of the function `keyf`  must be a string.
        
        ```python
        # a example in django view function
        
        def key_by_user(request):
            return request.user.username
        
        @file.cache(60*60, keyf=key_by_user)
        def home(request):
            return render(request, 'home.html')
        ```
        
        You can also overwrite `keyf` for all cache. This is a example:
        
        ```python
        from mecache import File
        
        class CustomFile(File):
            @staticmethod
            def keyf(*args, **kwargs):
                string = do.something
                return string
        
        file = CustomFile("CACHE_PATH")
        ```
        
        ### Custom made
        
        If you need a custom cache, you can use `BaseCache` or `AioBaseCache` to create your cache class. Like this
        
        ```python
        from mecache import BaseCache
        
        class CustomCache(BaseCache):
        
            def get_cache(self, func, key, max_time):
                qual = func.__qualname__
                return get(qual+":"+key)
        
            def set_cache(self, result, func, key, max_time):
                qual = func.__qualname__
                set(qual+":"+key, result, ex=time.time()+max_time)
        ```
        
Keywords: cache,redis,file,python,asyncio,aiocache
Platform: UNKNOWN
Classifier: License :: OSI Approved :: MIT License
Classifier: Programming Language :: Python :: 3.6
Requires-Python: >=3.6.0
Description-Content-Type: text/markdown
Provides-Extra: redis
