# Redis-dict
[](https://pypi.org/project/redis-dict/)
[](https://github.com/Attumm/redis-dict/actions/workflows/ci.yml)
[](https://codecov.io/gh/Attumm/redis-dict)
[](https://pepy.tech/project/redis-dict)
RedisDict is a Python library that offers a convenient and familiar interface for interacting with Redis, treating it as if it were a Python dictionary. Its goal is to help developers write clean, Pythonic code while using Redis as a storage solution for seamless distributed computing. This simple yet powerful library utilizes Redis as a key-value store and supports various data types, including strings, integers, floats, booleans, lists, and dictionaries. Additionally, developers can extend RedisDict to work with custom objects.
The library includes utility functions for more complex use cases such as caching, batching, and more. By leveraging Redis for efficient key-value storage, RedisDict enables high-performance data management, maintaining efficiency even with large datasets and Redis instances.
## Features
* Dictionary-like interface: Use familiar Python dictionary syntax to interact with Redis.
* Data Type Support: Comprehensive support for various data types.
* Pipelining support: Use pipelines for batch operations to improve performance.
* Expiration Support: Enables the setting of expiration times either globally or individually per key, through the use of context managers.
* Efficiency and Scalability: RedisDict is designed for use with large datasets and is optimized for efficiency. It retrieves only the data needed for a particular operation, ensuring efficient memory usage and fast performance.
* Namespace Management: Provides simple and efficient namespace handling to help organize and manage data in Redis, streamlining data access and manipulation.
* Distributed Computing: With its ability to seamlessly connect to other instances or servers with access to the same Redis instance, RedisDict enables easy distributed computing.
* Custom data: types: Add custom types encoding/decoding to store your data types.
* Encryption: allows for storing data encrypted, while retaining the simple dictionary interface.
## Example
Redis is an exceptionally fast database when used appropriately. RedisDict leverages Redis for efficient key-value storage, enabling high-performance data management.
```bash
pip install redis-dict
```
```python
>>> from redis_dict import RedisDict
>>> dic = RedisDict()
>>> dic['foo'] = 42
>>> dic['foo']
42
>>> 'foo' in dic
True
>>> dic["baz"] = "hello world"
>>> dic
{'foo': 42, 'baz': 'hello world'}
```
In Redis our example looks like this.
```
127.0.0.1:6379> KEYS "*"
1) "main:foo"
2) "main:baz"
127.0.0.1:6379> GET "main:foo"
"int:42"
127.0.0.1:6379> GET "main:baz"
"str:hello world"
```
## Types
### standard types
RedisDict supports a range of Python data types, from basic types to nested structures.
Basic types are handled natively, while complex data types like lists and dictionaries, RedisDict uses JSON serialization, specifically avoiding [pickle](https://docs.python.org/3/library/pickle.html) due to its security vulnerabilities within distributed computing contexts.
Although the library supports nested structures, the recommended best practice is to use RedisDict as a shallow dictionary.
This approach optimizes Redis database performance and efficiency by ensuring that each set and get operation efficiently maps to Redis's key-value storage capabilities, while still preserving the library's Pythonic interface.
Following types are supported:
`str, int, float, bool, NoneType, list, dict, tuple, set, datetime, date, time, timedelta, Decimal, complex, bytes, UUID, OrderedDict, defaultdict, frozenset`
```python
from uuid import UUID
from decimal import Decimal
from collections import OrderedDict, defaultdict
from datetime import datetime, date, time, timedelta
dic = RedisDict()
dic["string"] = "Hello World"
dic["number"] = 42
dic["float"] = 3.14
dic["bool"] = True
dic["None"] = None
dic["list"] = [1, 2, 3]
dic["dict"] = {"a": 1, "b": 2}
dic["tuple"] = (1, 2, 3)
dic["set"] = {1, 2, 3}
dic["datetime"] = datetime.date(2024, 1, 1, 12, 30, 45)
dic["date"] = date(2024, 1, 1)
dic["time"] = time(12, 30, 45)
dic["delta"] = timedelta(days=1, hours=2)
dic["decimal"] = Decimal("3.14159")
dic["complex"] = complex(1, 2)
dic["bytes"] = bytes([72, 101, 108, 108, 111])
dic["uuid"] = UUID('12345678-1234-5678-1234-567812345678')
dic["ordered"] = OrderedDict([('a', 1), ('b', 2)])
dic["default"] = defaultdict(int, {'a': 1, 'b': 2})
dic["frozen"] = frozenset([1, 2, 3])
```
### Namespaces
Acting as an identifier for your dictionary across different systems, RedisDict employs namespaces for organized data management. When a namespace isn't specified, "main" becomes the default. Thus allowing for data organization across systems and projects with the same redis instance.
This approach also minimizes the risk of key collisions between different applications, preventing hard-to-debug issues. By leveraging namespaces, RedisDict ensures a cleaner and more maintainable data management experience for developers working on multiple projects.
## Advanced Features
### Expiration
Redis provides a valuable feature that enables keys to expire. RedisDict supports this feature in the following ways:
1. Set a default expiration time when creating a RedisDict instance. In this example, the keys will have a default expiration time of 10 seconds. Use seconds with an integer or pass a datetime timedelta.
```python
dic = RedisDict(expire=10)
dic['gone'] = 'in ten seconds'
```
Or, for a more Pythonic approach, use a timedelta.
```python
from datetime import timedelta
dic = RedisDict(expire=timedelta(minutes=1))
dic['gone'] = 'in a minute'
```
2. Temporarily set the default expiration time within the scope using a context manager. In this example, the key 'gone' will expire after 60 seconds. The default expiration time for other keys outside the context manager remains unchanged. Either pass an integer or a timedelta.
```python
dic = RedisDict()
seconds = 60
with dic.expire_at(seconds):
dic['gone'] = 'in sixty seconds'
```
3. Updating keys while preserving the initial timeout In certain situations, there is a need to update the value while keeping the expiration intact. This is achievable by setting the 'preserve_expiration' to true.
```python
import time
dic = RedisDict(expire=10, preserve_expiration=True)
dic['gone'] = 'in ten seconds'
time.sleep(5)
dic['gone'] = 'gone in 5 seconds'
```
### Batching
Efficiently batch your requests using the Pipeline feature, which can be easily utilized with a context manager.
```python
dic = RedisDict(namespace="example")
# one round trip to redis
with dic.pipeline():
for index in range(100):
dic[str(index)] = index
```
### Distributed computing
You can use RedisDict for distributed computing by starting multiple RedisDict instances on different servers or instances that have access to the same Redis instance:
```python
# On server 1
from redis_dict import RedisDict
dic = RedisDict(namespace="example")
dic["foo"] = "bar"
# On server 2
from redis_dict import RedisDict
dic = RedisDict(namespace="example")
print(dic["foo"]) # outputs "bar"
```
## More Examples
### Caching made simple
```python
import time
from datetime import timedelta
from redis_dict import RedisDict
def expensive_function(x):
time.sleep(x)
return x * 2
cache = RedisDict(namespace="cache", expire=timedelta(minutes=60))
def cached_expensive_function(x):
if x not in cache:
cache[x] = expensive_function(x)
return cache[x]
start_time = time.time()
print(cached_expensive_function(5)) # Takes around 5 seconds to compute and caches the result.
print(f"Time taken: {time.time() - start_time:.2f} seconds")
start_time = time.time()
print(cached_expensive_function(5)) # Fetches the result from the cache, taking almost no time.
print(f"Time taken: {time.time() - start_time:.2f} seconds")
```
### Redis-dict as dictionary
```python
from redis_dict import RedisDict
# Create a RedisDict instance with a namespace
dic = RedisDict(namespace="example")
# Set key-value pairs
dic["name"] = "John Doe"
dic["age"] = 32
dic["city"] = "Amsterdam"
# Get value by key, from any instance connected to the same redis/namespace
print(dic["name"]) # Output: John Doe
# Update value by key, got a year older
dic["age"] = 33
# Check if key exists
print("name" in dic) # Output: True
print("country" in dic) # Output: False
# Get value with a default value if the key doesn't exist
print(dic.get("country", "NL")) # Output: NL
# Get the length (number of keys) of the RedisDict
print(len(dic)) # Output: 3
# Iterate over keys
for key in dic:
print(key, dic[key])
# Delete a key-value pair
del dic["city"]
# Clear all key-value pairs in the RedisDict
dic.clear()
# Get the length (number of keys) of the RedisDict
print(len(dic)) # Output: 0
# Update RedisDict with multiple key-value pairs
dic.update({"a": 1, "b": 2, "c": 3})
# Use methods of a normal dict
print(list(dic.keys())) # Output: ['a', 'b', 'c']
print(list(dic.values())) # Output: [1, 2, 3]
print(list(dic.items())) # Output: [('a', 1), ('b', 2), ('c', 3)]
# Using pop() and popitem() methods
value = dic.pop("a")
print(value) # Output: 1
key, value = dic.popitem()
print(key, value) # Output: 'c' 3 (example)
# Using setdefault() method
dic.setdefault("d", 4)
print(dic["d"]) # Output: 4
```
### Additional Examples
For more advanced examples of RedisDict, please refer to the unit-test files in the repository. All features and functionalities are thoroughly tested in [unit tests (here)](https://github.com/Attumm/redis-dict/blob/main/tests/unit/tests.py#L1) Or take a look at load test for batching [load test](https://github.com/Attumm/redis-dict/blob/main/tests/load/load_test.py#L1).
The unit-tests can be as used as a starting point.
### Nested types
Nested Types
RedisDict supports nested structures with mixed types through JSON serialization. The feature works by utilizing JSON encoding and decoding under the hood. While this represents an upgrade in functionality, the feature is not fully implemented and should be used with caution. For optimal performance, using shallow dictionaries is recommended.
```python
from datetime import datetime, timedelta
dic["mixed"] = [1, "foobar", 3.14, [1, 2, 3], datetime.now()]
dic['dic'] = {"elapsed_time": timedelta(hours=60)}
```
### JSON Encoding - Decoding
The nested type support in RedisDict is implemented using custom JSON encoders and decoders. These JSON encoders and decoders are built on top of RedisDict's own encoding and decoding functionality, extending it for JSON compatibility. Since JSON serialization was a frequently requested feature, these enhanced encoders and decoders are available for use in other projects:
```python
import json
from datetime import datetime
from redis_dict import RedisDictJSONDecoder, RedisDictJSONEncoder
data = [1, "foobar", 3.14, [1, 2, 3], datetime.now()]
encoded = json.dumps(data, cls=RedisDictJSONEncoder)
result = json.loads(encoded, cls=RedisDictJSONDecoder)
```
### Extending RedisDict with Custom Types
RedisDict supports custom type serialization. Here's how to add a new type:
```python
import json
class Person:
def __init__(self, name, age):
self.name = name
self.age = age
def encode(self) -> str:
return json.dumps(self.__dict__)
@classmethod
def decode(cls, encoded_str: str) -> 'Person':
return cls(**json.loads(encoded_str))
redis_dict = RedisDict()
# Extend redis dict with the new type
redis_dict.extends_type(Person)
# RedisDict can now seamlessly handle Person instances.
person = Person(name="John", age=32)
redis_dict["person1"] = person
result = redis_dict["person1"]
assert result.name == person.name
assert result.age == person.age
```
### Insertion Order
For insertion order, use the PythonRedisDict. This class is focused on Python dictionary behavior one-to-one.
It will eventually become a drop-in replacement for dictionary. Currently, nested types and typed keys are not yet supported but will be added in the future.
```python
from redis_dict import PythonRedisDict
dic = PythonRedisDict()
dic["1"] = "one"
dic["2"] = "two"
dic["3"] = "three"
assert list(dic.keys()) == ["1", "2", "3"]
```
For more information on [extending types](https://github.com/Attumm/redis-dict/blob/main/tests/unit/extend_types_tests.py).
### Redis Encryption
Setup guide for configuring and utilizing encrypted Redis TLS for redis-dict.
[Setup guide](https://github.com/Attumm/redis-dict/blob/main/docs/tutorials/encrypted_redis.MD)
### Redis Storage Encryption
For storing encrypted data values, it's possible to use extended types. Take a look at this [encrypted test](https://github.com/Attumm/redis-dict/blob/main/tests/unit/encrypt_tests.py).
### Tests
The RedisDict library includes a comprehensive suite of tests that ensure its correctness and resilience. The test suite covers various data types, edge cases, and error handling scenarios. It also employs the Hypothesis library for property-based testing, which provides fuzz testing to evaluate the implementation
### Redis config
To configure RedisDict using your Redis config.
Configure both the host and port. Or configuration with a setting dictionary.
```python
dic = RedisDict(host='127.0.0.1', port=6380)
redis_config = {
'host': '127.0.0.1',
'port': 6380,
}
config_dic = RedisDict(**redis_config)
```
## Installation
```sh
pip install redis-dict
```
### Note
* Please be aware that this project is currently being utilized by various organizations in their production environments. If you have any questions or concerns, feel free to raise issues
* This project only uses redis as dependency
Raw data
{
"_id": null,
"home_page": null,
"name": "redis-dict",
"maintainer": null,
"docs_url": null,
"requires_python": ">=3.8",
"maintainer_email": null,
"keywords": "redis, python, dictionary, dict, key-value, database, caching, distributed-computing, dictionary-interface, large-datasets, scientific-computing, data-persistence, high-performance, scalable, pipelining, batching, big-data, data-types, distributed-algorithms, encryption, data-management",
"author": null,
"author_email": "Melvin Bijman <bijman.m.m@gmail.com>",
"download_url": "https://files.pythonhosted.org/packages/be/52/4def11eb782d48be55e7e0081368ed28205a4b8556f9ddbe0f144f32e6e4/redis_dict-3.2.0.tar.gz",
"platform": null,
"description": "# Redis-dict\n[](https://pypi.org/project/redis-dict/)\n[](https://github.com/Attumm/redis-dict/actions/workflows/ci.yml)\n[](https://codecov.io/gh/Attumm/redis-dict)\n[](https://pepy.tech/project/redis-dict)\n\nRedisDict is a Python library that offers a convenient and familiar interface for interacting with Redis, treating it as if it were a Python dictionary. Its goal is to help developers write clean, Pythonic code while using Redis as a storage solution for seamless distributed computing. This simple yet powerful library utilizes Redis as a key-value store and supports various data types, including strings, integers, floats, booleans, lists, and dictionaries. Additionally, developers can extend RedisDict to work with custom objects.\n\nThe library includes utility functions for more complex use cases such as caching, batching, and more. By leveraging Redis for efficient key-value storage, RedisDict enables high-performance data management, maintaining efficiency even with large datasets and Redis instances.\n\n## Features\n\n* Dictionary-like interface: Use familiar Python dictionary syntax to interact with Redis.\n* Data Type Support: Comprehensive support for various data types.\n* Pipelining support: Use pipelines for batch operations to improve performance.\n* Expiration Support: Enables the setting of expiration times either globally or individually per key, through the use of context managers.\n* Efficiency and Scalability: RedisDict is designed for use with large datasets and is optimized for efficiency. It retrieves only the data needed for a particular operation, ensuring efficient memory usage and fast performance.\n* Namespace Management: Provides simple and efficient namespace handling to help organize and manage data in Redis, streamlining data access and manipulation.\n* Distributed Computing: With its ability to seamlessly connect to other instances or servers with access to the same Redis instance, RedisDict enables easy distributed computing.\n* Custom data: types: Add custom types encoding/decoding to store your data types.\n* Encryption: allows for storing data encrypted, while retaining the simple dictionary interface.\n\n## Example\nRedis is an exceptionally fast database when used appropriately. RedisDict leverages Redis for efficient key-value storage, enabling high-performance data management.\n\n```bash\npip install redis-dict\n```\n\n```python\n>>> from redis_dict import RedisDict\n>>> dic = RedisDict()\n>>> dic['foo'] = 42\n>>> dic['foo']\n42\n>>> 'foo' in dic\nTrue\n>>> dic[\"baz\"] = \"hello world\"\n>>> dic\n{'foo': 42, 'baz': 'hello world'}\n```\nIn Redis our example looks like this.\n```\n127.0.0.1:6379> KEYS \"*\"\n1) \"main:foo\"\n2) \"main:baz\"\n127.0.0.1:6379> GET \"main:foo\"\n\"int:42\"\n127.0.0.1:6379> GET \"main:baz\"\n\"str:hello world\"\n```\n\n## Types\n\n### standard types\nRedisDict supports a range of Python data types, from basic types to nested structures.\nBasic types are handled natively, while complex data types like lists and dictionaries, RedisDict uses JSON serialization, specifically avoiding [pickle](https://docs.python.org/3/library/pickle.html) due to its security vulnerabilities within distributed computing contexts.\nAlthough the library supports nested structures, the recommended best practice is to use RedisDict as a shallow dictionary.\nThis approach optimizes Redis database performance and efficiency by ensuring that each set and get operation efficiently maps to Redis's key-value storage capabilities, while still preserving the library's Pythonic interface.\nFollowing types are supported: \n`str, int, float, bool, NoneType, list, dict, tuple, set, datetime, date, time, timedelta, Decimal, complex, bytes, UUID, OrderedDict, defaultdict, frozenset`\n```python\nfrom uuid import UUID\nfrom decimal import Decimal\nfrom collections import OrderedDict, defaultdict\nfrom datetime import datetime, date, time, timedelta\n\ndic = RedisDict()\n\ndic[\"string\"] = \"Hello World\"\ndic[\"number\"] = 42\ndic[\"float\"] = 3.14\ndic[\"bool\"] = True\ndic[\"None\"] = None\n\ndic[\"list\"] = [1, 2, 3]\ndic[\"dict\"] = {\"a\": 1, \"b\": 2}\ndic[\"tuple\"] = (1, 2, 3)\ndic[\"set\"] = {1, 2, 3}\n\ndic[\"datetime\"] = datetime.date(2024, 1, 1, 12, 30, 45)\ndic[\"date\"] = date(2024, 1, 1)\ndic[\"time\"] = time(12, 30, 45)\ndic[\"delta\"] = timedelta(days=1, hours=2)\n\ndic[\"decimal\"] = Decimal(\"3.14159\")\ndic[\"complex\"] = complex(1, 2)\ndic[\"bytes\"] = bytes([72, 101, 108, 108, 111])\ndic[\"uuid\"] = UUID('12345678-1234-5678-1234-567812345678')\n\ndic[\"ordered\"] = OrderedDict([('a', 1), ('b', 2)])\ndic[\"default\"] = defaultdict(int, {'a': 1, 'b': 2})\ndic[\"frozen\"] = frozenset([1, 2, 3])\n```\n\n### Namespaces\nActing as an identifier for your dictionary across different systems, RedisDict employs namespaces for organized data management. When a namespace isn't specified, \"main\" becomes the default. Thus allowing for data organization across systems and projects with the same redis instance.\nThis approach also minimizes the risk of key collisions between different applications, preventing hard-to-debug issues. By leveraging namespaces, RedisDict ensures a cleaner and more maintainable data management experience for developers working on multiple projects.\n\n## Advanced Features\n\n### Expiration\n\nRedis provides a valuable feature that enables keys to expire. RedisDict supports this feature in the following ways:\n1. Set a default expiration time when creating a RedisDict instance. In this example, the keys will have a default expiration time of 10 seconds. Use seconds with an integer or pass a datetime timedelta.\n\n```python\ndic = RedisDict(expire=10)\ndic['gone'] = 'in ten seconds'\n```\nOr, for a more Pythonic approach, use a timedelta.\n```python\nfrom datetime import timedelta\n\ndic = RedisDict(expire=timedelta(minutes=1))\ndic['gone'] = 'in a minute'\n```\n\n2. Temporarily set the default expiration time within the scope using a context manager. In this example, the key 'gone' will expire after 60 seconds. The default expiration time for other keys outside the context manager remains unchanged. Either pass an integer or a timedelta.\n\n```python\ndic = RedisDict()\n\nseconds = 60\nwith dic.expire_at(seconds):\n dic['gone'] = 'in sixty seconds'\n```\n\n3. Updating keys while preserving the initial timeout In certain situations, there is a need to update the value while keeping the expiration intact. This is achievable by setting the 'preserve_expiration' to true.\n\n```python\nimport time\n\ndic = RedisDict(expire=10, preserve_expiration=True)\ndic['gone'] = 'in ten seconds'\n\ntime.sleep(5)\ndic['gone'] = 'gone in 5 seconds'\n\n```\n\n### Batching\nEfficiently batch your requests using the Pipeline feature, which can be easily utilized with a context manager.\n\n```python\ndic = RedisDict(namespace=\"example\")\n\n# one round trip to redis\nwith dic.pipeline():\n for index in range(100):\n dic[str(index)] = index\n```\n\n### Distributed computing\nYou can use RedisDict for distributed computing by starting multiple RedisDict instances on different servers or instances that have access to the same Redis instance:\n```python\n# On server 1\nfrom redis_dict import RedisDict\n\ndic = RedisDict(namespace=\"example\")\ndic[\"foo\"] = \"bar\"\n\n# On server 2\nfrom redis_dict import RedisDict\n\ndic = RedisDict(namespace=\"example\")\nprint(dic[\"foo\"]) # outputs \"bar\"\n```\n\n## More Examples\n\n### Caching made simple\n```python\nimport time\nfrom datetime import timedelta\nfrom redis_dict import RedisDict\n\ndef expensive_function(x):\n time.sleep(x)\n return x * 2\n\ncache = RedisDict(namespace=\"cache\", expire=timedelta(minutes=60))\n\ndef cached_expensive_function(x):\n if x not in cache:\n cache[x] = expensive_function(x)\n return cache[x]\n\nstart_time = time.time()\nprint(cached_expensive_function(5)) # Takes around 5 seconds to compute and caches the result.\nprint(f\"Time taken: {time.time() - start_time:.2f} seconds\")\n\nstart_time = time.time()\nprint(cached_expensive_function(5)) # Fetches the result from the cache, taking almost no time.\nprint(f\"Time taken: {time.time() - start_time:.2f} seconds\")\n```\n\n### Redis-dict as dictionary\n```python\nfrom redis_dict import RedisDict\n\n# Create a RedisDict instance with a namespace\ndic = RedisDict(namespace=\"example\")\n\n# Set key-value pairs\ndic[\"name\"] = \"John Doe\"\ndic[\"age\"] = 32\ndic[\"city\"] = \"Amsterdam\"\n\n# Get value by key, from any instance connected to the same redis/namespace\nprint(dic[\"name\"]) # Output: John Doe\n\n# Update value by key, got a year older\ndic[\"age\"] = 33\n\n# Check if key exists\nprint(\"name\" in dic) # Output: True\nprint(\"country\" in dic) # Output: False\n\n# Get value with a default value if the key doesn't exist\nprint(dic.get(\"country\", \"NL\")) # Output: NL\n\n# Get the length (number of keys) of the RedisDict\nprint(len(dic)) # Output: 3\n\n# Iterate over keys\nfor key in dic:\n print(key, dic[key])\n\n# Delete a key-value pair\ndel dic[\"city\"]\n\n# Clear all key-value pairs in the RedisDict\ndic.clear()\n\n# Get the length (number of keys) of the RedisDict\nprint(len(dic)) # Output: 0\n\n# Update RedisDict with multiple key-value pairs\ndic.update({\"a\": 1, \"b\": 2, \"c\": 3})\n\n# Use methods of a normal dict\nprint(list(dic.keys())) # Output: ['a', 'b', 'c']\nprint(list(dic.values())) # Output: [1, 2, 3]\nprint(list(dic.items())) # Output: [('a', 1), ('b', 2), ('c', 3)]\n\n# Using pop() and popitem() methods\nvalue = dic.pop(\"a\")\nprint(value) # Output: 1\n\nkey, value = dic.popitem()\nprint(key, value) # Output: 'c' 3 (example)\n\n# Using setdefault() method\ndic.setdefault(\"d\", 4)\nprint(dic[\"d\"]) # Output: 4\n```\n\n### Additional Examples\nFor more advanced examples of RedisDict, please refer to the unit-test files in the repository. All features and functionalities are thoroughly tested in [unit tests (here)](https://github.com/Attumm/redis-dict/blob/main/tests/unit/tests.py#L1) Or take a look at load test for batching [load test](https://github.com/Attumm/redis-dict/blob/main/tests/load/load_test.py#L1).\nThe unit-tests can be as used as a starting point.\n\n### Nested types\nNested Types\nRedisDict supports nested structures with mixed types through JSON serialization. The feature works by utilizing JSON encoding and decoding under the hood. While this represents an upgrade in functionality, the feature is not fully implemented and should be used with caution. For optimal performance, using shallow dictionaries is recommended.\n```python\nfrom datetime import datetime, timedelta\n\ndic[\"mixed\"] = [1, \"foobar\", 3.14, [1, 2, 3], datetime.now()]\n\ndic['dic'] = {\"elapsed_time\": timedelta(hours=60)}\n```\n\n### JSON Encoding - Decoding\nThe nested type support in RedisDict is implemented using custom JSON encoders and decoders. These JSON encoders and decoders are built on top of RedisDict's own encoding and decoding functionality, extending it for JSON compatibility. Since JSON serialization was a frequently requested feature, these enhanced encoders and decoders are available for use in other projects:\n```python\nimport json\nfrom datetime import datetime\nfrom redis_dict import RedisDictJSONDecoder, RedisDictJSONEncoder\n\ndata = [1, \"foobar\", 3.14, [1, 2, 3], datetime.now()]\nencoded = json.dumps(data, cls=RedisDictJSONEncoder)\nresult = json.loads(encoded, cls=RedisDictJSONDecoder)\n```\n\n\n### Extending RedisDict with Custom Types\n\nRedisDict supports custom type serialization. Here's how to add a new type:\n\n\n```python\nimport json\n\nclass Person:\n def __init__(self, name, age):\n self.name = name\n self.age = age\n\n def encode(self) -> str:\n return json.dumps(self.__dict__)\n\n @classmethod\n def decode(cls, encoded_str: str) -> 'Person':\n return cls(**json.loads(encoded_str))\n\nredis_dict = RedisDict()\n\n# Extend redis dict with the new type\nredis_dict.extends_type(Person)\n\n# RedisDict can now seamlessly handle Person instances.\nperson = Person(name=\"John\", age=32)\nredis_dict[\"person1\"] = person\n\nresult = redis_dict[\"person1\"]\n\nassert result.name == person.name\nassert result.age == person.age\n```\n\n### Insertion Order\nFor insertion order, use the PythonRedisDict. This class is focused on Python dictionary behavior one-to-one.\nIt will eventually become a drop-in replacement for dictionary. Currently, nested types and typed keys are not yet supported but will be added in the future.\n\n```python\nfrom redis_dict import PythonRedisDict\n\ndic = PythonRedisDict()\ndic[\"1\"] = \"one\"\ndic[\"2\"] = \"two\"\ndic[\"3\"] = \"three\"\n\nassert list(dic.keys()) == [\"1\", \"2\", \"3\"]\n```\n\nFor more information on [extending types](https://github.com/Attumm/redis-dict/blob/main/tests/unit/extend_types_tests.py).\n### Redis Encryption\nSetup guide for configuring and utilizing encrypted Redis TLS for redis-dict.\n[Setup guide](https://github.com/Attumm/redis-dict/blob/main/docs/tutorials/encrypted_redis.MD)\n\n### Redis Storage Encryption\nFor storing encrypted data values, it's possible to use extended types. Take a look at this [encrypted test](https://github.com/Attumm/redis-dict/blob/main/tests/unit/encrypt_tests.py).\n\n### Tests\nThe RedisDict library includes a comprehensive suite of tests that ensure its correctness and resilience. The test suite covers various data types, edge cases, and error handling scenarios. It also employs the Hypothesis library for property-based testing, which provides fuzz testing to evaluate the implementation\n\n### Redis config\nTo configure RedisDict using your Redis config.\n\nConfigure both the host and port. Or configuration with a setting dictionary.\n```python\ndic = RedisDict(host='127.0.0.1', port=6380)\n\nredis_config = {\n 'host': '127.0.0.1',\n 'port': 6380,\n}\n\nconfig_dic = RedisDict(**redis_config)\n```\n\n## Installation\n```sh\npip install redis-dict\n```\n\n### Note\n* Please be aware that this project is currently being utilized by various organizations in their production environments. If you have any questions or concerns, feel free to raise issues\n* This project only uses redis as dependency\n",
"bugtrack_url": null,
"license": "MIT",
"summary": "Dictionary with Redis as storage backend",
"version": "3.2.0",
"project_urls": {
"Changelog": "https://github.com/Attumm/redisdict/releases",
"Documentation": "https://attumm.github.io/redis-dict/",
"Homepage": "https://github.com/Attumm/redisdict",
"Repository": "https://github.com/Attumm/redisdict.git"
},
"split_keywords": [
"redis",
" python",
" dictionary",
" dict",
" key-value",
" database",
" caching",
" distributed-computing",
" dictionary-interface",
" large-datasets",
" scientific-computing",
" data-persistence",
" high-performance",
" scalable",
" pipelining",
" batching",
" big-data",
" data-types",
" distributed-algorithms",
" encryption",
" data-management"
],
"urls": [
{
"comment_text": "",
"digests": {
"blake2b_256": "f6f65c631a4d0dab3cc4dc63a6f3814f09bd9675a7ab40b24e62b82b533fe53b",
"md5": "9d034c08d5452c1a7e13d3c798abff58",
"sha256": "50e1a61108c3edc5bacee471cfbb885b973263fe9112f7b23d34327965818d39"
},
"downloads": -1,
"filename": "redis_dict-3.2.0-py3-none-any.whl",
"has_sig": false,
"md5_digest": "9d034c08d5452c1a7e13d3c798abff58",
"packagetype": "bdist_wheel",
"python_version": "py3",
"requires_python": ">=3.8",
"size": 22981,
"upload_time": "2024-11-23T21:57:49",
"upload_time_iso_8601": "2024-11-23T21:57:49.734411Z",
"url": "https://files.pythonhosted.org/packages/f6/f6/5c631a4d0dab3cc4dc63a6f3814f09bd9675a7ab40b24e62b82b533fe53b/redis_dict-3.2.0-py3-none-any.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "be524def11eb782d48be55e7e0081368ed28205a4b8556f9ddbe0f144f32e6e4",
"md5": "d03a28d1bd50ce6a7ff0478ab55eb061",
"sha256": "a76e12597c27480e40a50477a46d25fddaff2352d32a4d02e7be415e63f25fa6"
},
"downloads": -1,
"filename": "redis_dict-3.2.0.tar.gz",
"has_sig": false,
"md5_digest": "d03a28d1bd50ce6a7ff0478ab55eb061",
"packagetype": "sdist",
"python_version": "source",
"requires_python": ">=3.8",
"size": 27259,
"upload_time": "2024-11-23T21:57:51",
"upload_time_iso_8601": "2024-11-23T21:57:51.614456Z",
"url": "https://files.pythonhosted.org/packages/be/52/4def11eb782d48be55e7e0081368ed28205a4b8556f9ddbe0f144f32e6e4/redis_dict-3.2.0.tar.gz",
"yanked": false,
"yanked_reason": null
}
],
"upload_time": "2024-11-23 21:57:51",
"github": true,
"gitlab": false,
"bitbucket": false,
"codeberg": false,
"github_user": "Attumm",
"github_project": "redisdict",
"travis_ci": false,
"coveralls": true,
"github_actions": true,
"requirements": [],
"lcname": "redis-dict"
}
JSON
