Metadata-Version: 1.2
Name: redisio
Version: 0.7
Summary: A tiny redis client for script boys with high performance. Optimized especially for massive insertion.
Home-page: https://github.com/cf020031308/redisio
Author: Roy
Author-email: cf020031308@163.com
Maintainer: Roy
Maintainer-email: cf020031308@163.com
License: MIT
Description: A tiny redis client for script boys with high performance. Optimized especially for massive insertion.
        
        # Install
        
        `pip install redisio`
        
        # Usage
        
        **TLDR**: The following is the document but don't read it. Instead read [the code](./redisio/redisio.py). It's much shorter.
        
        ## Initialize
        
        ```python
        import redisio
        rd = redisio.Redis(host='127.0.0.1', port=6379, db=0, password='')
        ```
        
        The arguments above are set as default so can be omitted.
        
        Connecting via unix sockets is also available.
        
        ```python
        import redisio
        rd = redisio.Redis(socket='/tmp/redis.sock')
        ```
        
        ## Commands
        
        See the list of Redis commands at [redis.io](https://redis.io/commands).
        
        Since `redisio` is designed to be implemented strictly in [protocol](https://redis.io/topics/protocol) with little syntax sugar on calling but not any modification on data itself, any future commands of `redis` can be properly supported without update.
        
        ### Write I: Commands and Pipelines
        
        Instance `redisio.Redis` is callable.
        
        Any direct calling on it sends the commands (either single command or multiple in list) to the server and then return the client instance itself immediately without reading replies in order to be called in chain conveniently:
        
        ```python
        assert rd == rd('SET', 'x', 3)('GET', 'x')(['SET', 'x', 3], ['GET', 'x'])
        ```
        
        ### Read I: Single Reply
        
        Method `redisio.Redis.next` returns the first reply in the message queue from the server:
        
        ```python
        assert 'OK' == rd('SET', 'x', 3)('GET', 'x').next()
        assert '3' == next(rd)
        ```
        
        *Note*: It will be blocked to call `next` when the queue is empty.
        
        Reply in the queue can be reached by the index:
        
        ```python
        assert '3' == rd('SET', 'x', 3)('GET', 'x')('SET', 'x', 4)[-2]
        ```
        
        *Note*: It will first iterate the whole queue and then return the specific reply, with of course a side-effect to empty the queue.
        
        Each redis command is mapped to a method with the same name.  
        Calling it in this method-like way will send the command, then read all the replies, and return the last one.
        
        ```python
        assert '3' == rd('SET', 'x', 3).get('x')
        ```
        
        *Note*: It will be blocked to call `rd.shutdown()` because this command will never be answered (Dead Men Tell No Tales). `rd('SHUTDOWN')` should be used.
        
        ### Read II: Multiple Replies
        
        Instance `redisio.Redis` is iterable.
        
        So iterating it to get all the replies.
        
        ```python
        r, = rd("HGET", key, field)
        r1, r2= rd("HGET", key, field)("HGET", key, field2)
        r1, r2= list(rd(["GET", key], ("GET", key2))(["SET", "X", "Y"]))[:2]
        ```
        
        
        ### Write II: Massive Insertion
        
        If you want to insert a large amount of data into redis without the care of the results, you can close the connection after sending it by the use of `del` to avoid parsing the replies.
        
        ```python
        rd(*large_scale_of_cmds).__del__()
        ```
        
        Benefit from this the massive insertion is blazingly fast: sending a million of HSET cost only 5.355 seconds via `redisio` while it costs 23.918 seconds via `redis-py`.
        
        *Note*: Replies are buffered on the server if the client have not read them while the connection keeps alive. This will eventually make the server crash because of the increasing occupied memory. So be aware.
        
        `redisio` will automatically reset the connection before sending a command in the method-like way while there are more than 1024 replies to read.
        
        ```python
        rd(*large_scale_of_cmds).dbsize()
        rd(*large_scale_of_cmds)('DBSIZE')[-1]
        ```
        
        The former is usually faster than the latter because no massive replies need to be read and parsed.
        
        ### Pub/Sub/Monitor
        
        ```python
        rd.monitor()
        # rd.subscribe('channel')
        while 1:
            print next(rd)
        ```
        
        # Q&A
        
        Q: Why not using [redis-py](https://github.com/andymccurdy/redis-py) but redisio?  
        A: To accomplish the majority of tasks [redis-py](https://github.com/andymccurdy/redis-py) is recommended and mostly used even by myself. Frankly speaking You may never need redisio. redisio is written and optimized especially for massive insertion to be memory-saving and much faster.
        
        Q: How to use redisio in bash?  
        A: [redis-cli](https://redis.io/download) is available in bash.
        
        Q: How to use redisio with thread safety?  
        A: [redis-py](https://github.com/andymccurdy/redis-py) is thread safe.
        
        Q: Why the result of hgetall is not a dict but a list?  
        A: This is the original format of replies from redis-server. Once you get used to this original style, you will be able to process results fluently from redis-cli or [Lua Script](https://redis.io/commands/eval) without the mess of confusing types or structures brought by other brilliant libraries. Anyway let's get down to brass tacks. You can get your dict like this:
        
        ```python
        hash_values = rd.hgetall('a_hash_key')
        hash_dict = dict(zip(hash_values[::2], hash_values[1::2]))
        ```
        
Keywords: Redis,key-value store
Platform: UNKNOWN
Classifier: Development Status :: 5 - Production/Stable
Classifier: Intended Audience :: Developers
Classifier: License :: OSI Approved :: MIT License
Classifier: Programming Language :: Python :: 2.7
Classifier: Programming Language :: Python :: 3
Classifier: Topic :: Database
