redis-dict 2.5.1__py3-none-any.whl → 2.7.0__py3-none-any.whl

{redis_dict-2.5.1.dist-info → redis_dict-2.7.0.dist-info}/METADATA

@@ -1,15 +1,24 @@
 Metadata-Version: 2.1
 Name: redis-dict
-Version: 2.5.1
+Version: 2.7.0
 Summary: Dictionary with Redis as storage backend
 Home-page: https://github.com/Attumm/redisdict
 Author: Melvin Bijman
 Author-email: bijman.m.m@gmail.com
 License: MIT
+Keywords: redis python dictionary dict key-value 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
+Platform: any
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Information Technology
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Internet
+Classifier: Topic :: Scientific/Engineering
 Classifier: Topic :: Database
 Classifier: Topic :: System :: Distributed Computing
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Software Development :: Object Brokering
+Classifier: Topic :: Database :: Database Engines/Servers
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.6
@@ -28,34 +37,40 @@ Requires-Dist: redis
 [![codecov](https://codecov.io/gh/Attumm/redis-dict/graph/badge.svg?token=Lqs7McQGEs)](https://codecov.io/gh/Attumm/redis-dict)
 [![Downloads](https://static.pepy.tech/badge/redis-dict/month)](https://pepy.tech/project/redis-dict)
 
-RedisDict is a Python library that provides a convenient and familiar interface for interacting with Redis as if it were a Python dictionary. This simple yet powerful library enables you to manage key-value pairs in Redis using native Python syntax. It supports various data types, including strings, integers, floats, booleans, lists, and dictionaries, and includes additional utility functions for more complex use cases.
-
-By leveraging Redis for efficient key-value storage, RedisDict allows for high-performance data management and is particularly useful for handling large datasets that may exceed local memory capacity.
+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, including strings, integers, floats, booleans, lists, dictionaries, sets, and tuples.
+* 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 and transformations to suit your specific needs.
+* 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.
 
-```python
-from redis_dict import RedisDict
+```bash
+pip install redis-dict
+```
 
-dic = RedisDict()
-dic['foo'] = 42
-print(dic['foo'])  # Output: 42
-print('foo' in dic)  # Output: True
-dic["baz"] = "hello world"
-print(dic)  # Output: {'foo': 42, 'baz': 'hello world'}
+```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.
 ```
@@ -68,12 +83,12 @@ In Redis our example looks like this.
 "str:hello world"
 ```
 
+
 ### 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 accross systems and projects with the same redis instance.
+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
@@ -106,6 +121,8 @@ with dic.expire_at(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'
 
@@ -118,6 +135,7 @@ dic['gone'] = 'gone in 5 seconds'
 Efficiently batch your requests using the Pipeline feature, which can be easily utilized with a context manager.
 
 ```python
+from redis_dict import RedisDict
 dic = RedisDict(namespace="example")
 
 # one round trip to redis
@@ -147,13 +165,14 @@ print(dic["foo"]) # outputs "bar"
 ### Caching made simple
 ```python
 import time
+from datetime import timedelta
 from redis_dict import RedisDict
 
 def expensive_function(x):
-    time.sleep(2)
+    time.sleep(x)
     return x * 2
 
-cache = RedisDict(namespace="cache", expire=10)
+cache = RedisDict(namespace="cache", expire=timedelta(minutes=60))
 
 def cached_expensive_function(x):
     if x not in cache:
@@ -161,7 +180,7 @@ def cached_expensive_function(x):
     return cache[x]
 
 start_time = time.time()
-print(cached_expensive_function(5))  # Takes around 2 seconds to compute and caches the result.
+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()
@@ -181,7 +200,7 @@ dic["name"] = "John Doe"
 dic["age"] = 32
 dic["city"] = "Amsterdam"
 
-# Get value by key
+# 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
@@ -234,10 +253,105 @@ print(dic["d"])  # Output: 4
 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.py#L1) Or take a look at load test for batching [load test](https://github.com/Attumm/redis-dict/blob/main/load_test.py#L1).
 The unit-tests can be as used as a starting point.
 
+## 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` due to its [security vulnerabilities](https://docs.python.org/3/library/pickle.html) in 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 redis_dict import RedisDict
+
+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])
+```
+
+### Extending RedisDict with Custom Types
+
+RedisDict supports custom type serialization. Here's how to add a new type:
+
+
+```python
+import json
+from redis_dict import RedisDict
+
+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
+```
+
+```python
+>>> from datetime import datetime
+>>> redis_dict.extends_type(datetime, datetime.isoformat, datetime.fromisoformat)
+>>> redis_dict["now"] = datetime.now()
+>>> redis_dict
+{'now': datetime.datetime(2024, 10, 14, 18, 41, 53, 493775)}
+>>> redis_dict["now"]
+datetime.datetime(2024, 10, 14, 18, 41, 53, 493775)
+```
+
+For more information on [extending types](https://github.com/Attumm/redis-dict/blob/main/extend_types_tests.py).
 ### Redis Encryption
-Setup guide for configuring and utilizing encrypted Redis for redis-dict.
+Setup guide for configuring and utilizing encrypted Redis TLS for redis-dict.
 [Setup guide](https://github.com/Attumm/redis-dict/blob/main/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/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_dict-2.7.0.dist-info/RECORD

@@ -0,0 +1,6 @@
+redis_dict.py,sha256=LmP5C1lIf3KCG_3pfcnw3CZE5KuUUym2U_UqlbFoiVg,38214
+redis_dict-2.7.0.dist-info/LICENSE,sha256=-QiLwYznh_vNUSz337k0faP9Jl0dgtCIHVZ39Uyl6cA,1070
+redis_dict-2.7.0.dist-info/METADATA,sha256=8SDlje1sUiquUlKvk27LHRhLTsdwr9b5KTsKBa5XhGk,14300
+redis_dict-2.7.0.dist-info/WHEEL,sha256=P9jw-gEje8ByB7_hXoICnHtVCrEwMQh-630tKvQWehc,91
+redis_dict-2.7.0.dist-info/top_level.txt,sha256=Wyp5Xvq_imoxvu-c-Le1rbTZ3pYM5BF440H9YAcgBZ8,11
+redis_dict-2.7.0.dist-info/RECORD,,

{redis_dict-2.5.1.dist-info → redis_dict-2.7.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.1.0)
+Generator: setuptools (75.3.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

redis_dict.py

@@ -1,17 +1,106 @@
+"""
+redis_dict.py
+
+RedisDict is a Python library that provides a convenient and familiar interface for
+interacting with Redis as if it were a Python dictionary. The simple yet powerful library
+enables you to manage key-value pairs in Redis using native Python syntax of dictionary. It supports
+various data types, including strings, integers, floats, booleans, lists, and dictionaries,
+and includes additional utility functions for more complex use cases.
+
+By leveraging Redis for efficient key-value storage, RedisDict allows for high-performance
+data management and is particularly useful for handling large datasets that may exceed local
+memory capacity.
+
+## Features
+
+* **Dictionary-like interface**: Use familiar Python dictionary syntax to interact with Redis.
+* **Data Type Support**: Comprehensive support for various data types, including strings,
+  integers, floats, booleans, lists, dictionaries, sets, and tuples.
+* **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 and transformations to suit your specific needs.
+
+New feature
+
+Custom extendable Validity checks on keys, and values.to support redis-dict base exceptions with messages from
+enabling detailed reporting on the reasons for specific validation failures. This refactor would allow users
+to configure which validity checks to execute, integrate custom validation functions, and specify whether
+to raise an error on validation failures or to drop the operation and log a warning.
+
+For example, in a caching scenario, data should only be cached if it falls within defined minimum and
+maximum size constraints. This approach enables straightforward dictionary set operations while ensuring
+that only meaningful data is cached: values greater than 10 MB and less than 100 MB should be cached;
+otherwise, they will be dropped.
+
+>>> def my_custom_validity_check(value: str) -> None:
+    \"""
+    Validates the size of the input.
+
+    Args:
+        value (str): string to validate.
+
+    Raises:
+        RedisDictValidityException: If the length of the input is not within the allowed range.
+    \"""
+    min_size = 10 * 1024:  # Minimum size: 10 KB
+    max_size = 10 * 1024 * 1024:  # Maximum size: 10 MB
+    if len(value) < min_size
+        raise RedisDictValidityException(f"value is too small: {len(value)} bytes")
+    if len(value) > max_size
+        raise RedisDictValidityException(f"value is too large: {len(value)} bytes")
+
+>>> cache = RedisDict(namespace='cache_valid_results_for_1_minute',
+... expire=60,
+... custom_valid_values_checks=[my_custom_validity_check], # extend with new valid check
+... validity_exception_suppress=True) # when value is invalid, don't store, and don't raise an exception.
+>>> too_small = "too small to cache"
+>>> cache["1234"] = too_small  # Since the value is below 10kb, thus there is no reason to cache the value.
+>>> cache.get("1234") is None
+>>> True
+"""
+# Types imports
 import json
-from datetime import timedelta
-from typing import Any, Callable, Dict, Iterator, Set, List, Tuple, Union, Optional
-from redis import StrictRedis
+from datetime import datetime, time, timedelta, date
+from decimal import Decimal
+from uuid import UUID
+from collections import OrderedDict, defaultdict
+import base64
 
+from typing import Any, Callable, Dict, Iterator, Set, List, Tuple, Union, Optional
 from contextlib import contextmanager
 
+from redis import StrictRedis
+
 SENTINEL = object()
 
-transform_type = Dict[str, Callable[[str], Any]]
-pre_transform_type = Dict[str, Callable[[Any], str]]
+EncodeFuncType = Callable[[Any], str]
+DecodeFuncType = Callable[[str], Any]
 
+EncodeType = Dict[str, EncodeFuncType]
+DecodeType = Dict[str, DecodeFuncType]
 
-def _transform_tuple(val: str) -> Tuple[Any, ...]:
+
+def _create_default_encode(custom_encode_method: str) -> EncodeFuncType:
+    def default_encode(obj: Any) -> str:
+        return getattr(obj, custom_encode_method)()  # type: ignore[no-any-return]
+    return default_encode
+
+
+def _create_default_decode(cls: type, custom_decode_method: str) -> DecodeFuncType:
+    def default_decode(encoded_str: str) -> Any:
+        return getattr(cls, custom_decode_method)(encoded_str)
+    return default_decode
+
+
+def _decode_tuple(val: str) -> Tuple[Any, ...]:
     """
     Deserialize a JSON-formatted string to a tuple.
 
@@ -27,7 +116,7 @@ def _transform_tuple(val: str) -> Tuple[Any, ...]:
     return tuple(json.loads(val))
 
 
-def _pre_transform_tuple(val: Tuple[Any, ...]) -> str:
+def _encode_tuple(val: Tuple[Any, ...]) -> str:
     """
     Serialize a tuple to a JSON-formatted string.
 
@@ -43,7 +132,7 @@ def _pre_transform_tuple(val: Tuple[Any, ...]) -> str:
     return json.dumps(list(val))
 
 
-def _transform_set(val: str) -> Set[Any]:
+def _decode_set(val: str) -> Set[Any]:
     """
     Deserialize a JSON-formatted string to a set.
 
@@ -59,7 +148,7 @@ def _transform_set(val: str) -> Set[Any]:
     return set(json.loads(val))
 
 
-def _pre_transform_set(val: Set[Any]) -> str:
+def _encode_set(val: Set[Any]) -> str:
     """
     Serialize a set to a JSON-formatted string.
 
@@ -75,6 +164,7 @@ def _pre_transform_set(val: Set[Any]) -> str:
     return json.dumps(list(val))
 
 
+# pylint: disable=R0902, R0904
 class RedisDict:
     """
     A Redis-backed dictionary-like data structure with support for advanced features, such as
@@ -92,15 +182,19 @@ class RedisDict:
     It aims to offer a seamless and familiar interface for developers familiar with Python dictionaries,
     enabling a smooth transition to a Redis-backed data store.
 
+    Extendable Types: You can extend RedisDict by adding or overriding encoding and decoding functions.
+    This functionality enables various use cases, such as managing encrypted data in Redis,
+    To implement this, simply create and register your custom encoding and decoding functions.
+    By delegating serialization to redis-dict, reduce complexity and have simple code in the codebase.
+
     Attributes:
-        transform (Dict[str, Callable[[str], Any]]): A dictionary of data type transformation functions for loading data.
-        pre_transform (Dict[str, Callable[[Any], str]]): A dictionary of data type transformation functions for storing data.
+        decoding_registry (Dict[str, DecodeFuncType]): Mapping of decoding transformation functions based on type
+        encoding_registry (Dict[str, EncodeFuncType]): Mapping of encoding transformation functions based on type
         namespace (str): A string used as a prefix for Redis keys to separate data in different namespaces.
         expire (Union[int, None]): An optional expiration time for keys, in seconds.
 
     """
-
-    transform: transform_type = {
+    decoding_registry: DecodeType = {
         type('').__name__: str,
         type(1).__name__: int,
         type(0.1).__name__: float,
@@ -109,15 +203,40 @@ class RedisDict:
 
         "list": json.loads,
         "dict": json.loads,
-        "tuple": _transform_tuple,
-        type(set()).__name__: _transform_set,
+        "tuple": _decode_tuple,
+        type(set()).__name__: _decode_set,
+
+        datetime.__name__: datetime.fromisoformat,
+        date.__name__: date.fromisoformat,
+        time.__name__: time.fromisoformat,
+        timedelta.__name__: lambda x: timedelta(seconds=float(x)),
+
+        Decimal.__name__: Decimal,
+        complex.__name__: lambda x: complex(*map(float, x.split(','))),
+        bytes.__name__: base64.b64decode,
+
+        UUID.__name__: UUID,
+        OrderedDict.__name__: lambda x: OrderedDict(json.loads(x)),
+        defaultdict.__name__: lambda x: defaultdict(type(None), json.loads(x)),
+        frozenset.__name__: lambda x: frozenset(json.loads(x)),
     }
 
-    pre_transform: pre_transform_type = {
+    encoding_registry: EncodeType = {
         "list": json.dumps,
         "dict": json.dumps,
-        "tuple": _pre_transform_tuple,
-        type(set()).__name__: _pre_transform_set,
+        "tuple": _encode_tuple,
+        type(set()).__name__: _encode_set,
+
+        datetime.__name__: datetime.isoformat,
+        date.__name__: date.isoformat,
+        time.__name__: time.isoformat,
+        timedelta.__name__: lambda x: str(x.total_seconds()),
+
+        complex.__name__: lambda x: f"{x.real},{x.imag}",
+        bytes.__name__: lambda x: base64.b64encode(x).decode('ascii'),
+        OrderedDict.__name__: lambda x: json.dumps(list(x.items())),
+        defaultdict.__name__: lambda x: json.dumps(dict(x)),
+        frozenset.__name__: lambda x: json.dumps(list(x)),
     }
 
     def __init__(self,
@@ -134,13 +253,20 @@ class RedisDict:
             preserve_expiration (bool, optional): Preserve the expiration count when the key is updated.
             **redis_kwargs: Additional keyword arguments passed to StrictRedis.
         """
-        self.temp_redis: Optional[StrictRedis[Any]] = None
+
         self.namespace: str = namespace
         self.expire: Union[int, timedelta, None] = expire
         self.preserve_expiration: Optional[bool] = preserve_expiration
         self.redis: StrictRedis[Any] = StrictRedis(decode_responses=True, **redis_kwargs)
         self.get_redis: StrictRedis[Any] = self.redis
 
+        self.custom_encode_method = "encode"
+        self.custom_decode_method = "decode"
+
+        self._iter: Iterator[str] = iter([])
+        self._max_string_size: int = 500 * 1024 * 1024  # 500mb
+        self._temp_redis: Optional[StrictRedis[Any]] = None
+
     def _format_key(self, key: str) -> str:
         """
         Format a key with the namespace prefix.
@@ -151,7 +277,7 @@ class RedisDict:
         Returns:
             str: The formatted key with the namespace prefix.
         """
-        return '{}:{}'.format(self.namespace, str(key))
+        return f'{self.namespace}:{str(key)}'
 
     def _valid_input(self, val: Any, val_type: str) -> bool:
         """
@@ -169,9 +295,17 @@ class RedisDict:
             bool: True if the input value is valid, False otherwise.
         """
         if val_type == "str":
-            return len(val) < (500 * 1024 * 1024)
+            return len(val) < self._max_string_size
         return True
 
+    def _format_value(self, key: str,  value: Any) -> str:
+        store_type, key = type(value).__name__, str(key)
+        if not self._valid_input(value, store_type) or not self._valid_input(key, "str"):
+            raise ValueError("Invalid input value or key size exceeded the maximum limit.")
+        encoded_value = self.encoding_registry.get(store_type, lambda x: x)(value)  # type: ignore
+
+        return f'{store_type}:{encoded_value}'
+
     def _store(self, key: str, value: Any) -> None:
         """
         Store a value in Redis with the given key.
@@ -179,20 +313,21 @@ class RedisDict:
         Args:
             key (str): The key to store the value.
             value (Any): The value to be stored.
-        """
-        store_type, key = type(value).__name__, str(key)
-        if not self._valid_input(value, store_type) or not self._valid_input(key, "str"):
-            # TODO When needed, make valid_input, pass the reason, or throw a exception.
-            raise ValueError("Invalid input value or key size exceeded the maximum limit.")
-        value = self.pre_transform.get(store_type, lambda x: x)(value)  # type: ignore
 
-        store_value = '{}:{}'.format(store_type, value)
-        formatted_key = self._format_key(key)
+        Note: Validity checks could be refactored to allow for custom exceptions that inherit from ValueError,
+        providing detailed information about why a specific validation failed.
+        This would enable users to specify which validity checks should be executed, add custom validity functions,
+        and choose whether to fail on validation errors, or drop the data and only issue a warning and continue.
+        Example use case is caching, to cache data only when it's between min and max sizes.
+        Allowing for simple dict set operation, but only cache data that makes sense.
 
+        """
+        formatted_key = self._format_key(key)
+        formatted_value = self._format_value(key, value)
         if self.preserve_expiration and self.redis.exists(formatted_key):
-            self.redis.set(formatted_key, store_value, keepttl=True)
+            self.redis.set(formatted_key, formatted_value, keepttl=True)
         else:
-            self.redis.set(formatted_key, store_value, ex=self.expire)
+            self.redis.set(formatted_key, formatted_value, ex=self.expire)
 
     def _load(self, key: str) -> Tuple[bool, Any]:
         """
@@ -207,8 +342,7 @@ class RedisDict:
         result = self.get_redis.get(self._format_key(key))
         if result is None:
             return False, None
-        t, value = result.split(':', 1)
-        return True, self.transform.get(t, lambda x: x)(value)
+        return True, self._transform(result)
 
     def _transform(self, result: str) -> Any:
         """
@@ -220,18 +354,118 @@ class RedisDict:
         Returns:
             Any: The transformed Python object.
         """
-        t, value = result.split(':', 1)
-        return self.transform.get(t, lambda x: x)(value)
+        type_, value = result.split(':', 1)
+        return self.decoding_registry.get(type_, lambda x: x)(value)
 
-    def add_type(self, k: str, v: Callable[[str], Any]) -> None:
+    def new_type_compliance(
+            self,
+            class_type: type,
+            encode_method_name: Optional[str] = None,
+            decode_method_name: Optional[str] = None,
+    ) -> None:
         """
-        Add a custom type to the transform mapping.
+        Checks if a class complies with the required encoding and decoding methods.
 
         Args:
-            k (str): The key representing the type.
-            v (Callable): The transformation function for the type.
+            class_type (type): The class to check for compliance.
+            encode_method_name (str, optional): Name of encoding method of the class for redis-dict custom types.
+            decode_method_name (str, optional): Name of decoding method of the class for redis-dict custom types.
+
+        Raises:
+            NotImplementedError: If the class does not implement the required methods when the respective check is True.
+        """
+        if encode_method_name is not None:
+            if not (hasattr(class_type, encode_method_name) and callable(
+                    getattr(class_type, encode_method_name))):
+                raise NotImplementedError(
+                    f"Class {class_type.__name__} does not implement the required {encode_method_name} method.")
+
+        if decode_method_name is not None:
+            if not (hasattr(class_type, decode_method_name) and callable(
+                    getattr(class_type, decode_method_name))):
+                raise NotImplementedError(
+                    f"Class {class_type.__name__} does not implement the required {decode_method_name} class method.")
+
+    def extends_type(
+            self,
+            class_type: type,
+            encode: Optional[EncodeFuncType] = None,
+            decode: Optional[DecodeFuncType] = None,
+            encoding_method_name: Optional[str] = None,
+            decoding_method_name: Optional[str] = None,
+    ) -> None:
+        """
+        Extends RedisDict to support a custom type in the encode/decode mapping.
+
+        This method enables serialization of instances based on their type,
+        allowing for custom types, specialized storage formats, and more.
+        There are three ways to add custom types:
+          1. Have a class with an `encode` instance method and a `decode` class method.
+          2. Have a class and pass encoding and decoding functions, where
+            `encode` converts the class instance to a string, and
+            `decode` takes the string and recreates the class instance.
+          3. Have a class that already has serialization methods, that satisfies the:
+                EncodeFuncType = Callable[[Any], str]
+                DecodeFuncType = Callable[[str], Any]
+
+            `custom_encode_method`
+            `custom_decode_method` attributes.
+
+        Args:
+            class_type (Type[type]): The class `__name__` will become the key for the encoding and decoding functions.
+            encode (Optional[EncodeFuncType]): function that encodes an object into a storable string format.
+                This function should take an instance of `class_type` as input and return a string.
+            decode (Optional[DecodeFuncType]): function that decodes a string back into an object of `class_type`.
+                This function should take a string as input and return an instance of `class_type`.
+            encoding_method_name (str, optional): Name of encoding method of the class for redis-dict custom types.
+            decoding_method_name (str, optional): Name of decoding method of the class for redis-dict custom types.
+
+        If no encoding or decoding function is provided, default to use the `encode` and `decode` methods of the class.
+
+        The `encode` method should be an instance method that converts the object to a string.
+        The `decode` method should be a class method that takes a string and returns an instance of the class.
+
+        The method names for encoding and decoding can be changed by modifying the
+        - `custom_encode_method`
+        - `custom_decode_method`
+        attributes of the RedisDict instance
+
+        Example:
+            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.extends_type(Person)
+
+        Note:
+        You can check for compliance of a class separately using the `new_type_compliance` method:
+
+        This method raises a NotImplementedError if either `encode` or `decode` is `None`
+        and the class does not implement the corresponding method.
         """
-        self.transform[k] = v
+
+        if encode is None or decode is None:
+            encode_method_name = encoding_method_name or self.custom_encode_method
+            if encode is None:
+                self.new_type_compliance(class_type, encode_method_name=encode_method_name)
+                encode = _create_default_encode(encode_method_name)
+
+            if decode is None:
+                decode_method_name = decoding_method_name or self.custom_decode_method
+                self.new_type_compliance(class_type,  decode_method_name=decode_method_name)
+                decode = _create_default_decode(class_type, decode_method_name)
+
+        type_name = class_type.__name__
+        self.decoding_registry[type_name] = decode
+        self.encoding_registry[type_name] = encode
 
     def __eq__(self, other: Any) -> bool:
         """
@@ -327,7 +561,7 @@ class RedisDict:
         Returns:
             Iterator[str]: An iterator over the keys of the RedisDict.
         """
-        self.iter = self.iterkeys()
+        self._iter = self.iterkeys()
         return self
 
     def __repr__(self) -> str:
@@ -358,7 +592,7 @@ class RedisDict:
         Raises:
             StopIteration: If there are no more items.
         """
-        return next(self.iter)
+        return next(self._iter)
 
     def next(self) -> str:
         """
@@ -370,7 +604,29 @@ class RedisDict:
         Raises:
             StopIteration: If there are no more items.
         """
-        return self.__next__()
+        return next(self)
+
+    def _create_iter_query(self, search_term: str) -> str:
+        """
+        Create a Redis query string for iterating over keys based on the given search term.
+
+        This method constructs a query by prefixing the search term with the namespace
+        followed by a wildcard to facilitate scanning for keys that start with the
+        provided search term.
+
+        Args:
+            search_term (str): The term to search for in Redis keys.
+
+        Returns:
+            str: A formatted query string that can be used to find keys in Redis.
+
+        Example:
+            >>> d = RedisDict(namespace='foo')
+            >>> query = self._create_iter_query('bar')
+            >>> print(query)
+            'foo:bar*'
+        """
+        return f'{self.namespace}:{search_term}*'
 
     def _scan_keys(self, search_term: str = '') -> Iterator[str]:
         """
@@ -382,7 +638,8 @@ class RedisDict:
         Returns:
             Iterator[str]: An iterator of matching Redis keys.
         """
-        return self.get_redis.scan_iter(match='{}:{}{}'.format(self.namespace, search_term, '*'))
+        search_query = self._create_iter_query(search_term)
+        return self.get_redis.scan_iter(match=search_query)
 
     def get(self, key: str, default: Optional[Any] = None) -> Any:
         """
@@ -413,7 +670,8 @@ class RedisDict:
         Note: for python2 str is needed
         """
         to_rm = len(self.namespace) + 1
-        cursor, data = self.get_redis.scan(match='{}:{}{}'.format(self.namespace, search_term, '*'), count=1)
+        search_query = self._create_iter_query(search_term)
+        _, data = self.get_redis.scan(match=search_query, count=1)
         for item in data:
             return str(item[to_rm:])
 
@@ -435,7 +693,7 @@ class RedisDict:
         to_rm = len(self.namespace) + 1
         for item in self._scan_keys():
             try:
-                yield (str(item[to_rm:]), self[item[to_rm:]])
+                yield str(item[to_rm:]), self[item[to_rm:]]
             except KeyError:
                 pass
 
@@ -488,11 +746,12 @@ class RedisDict:
         Redis pipelining is employed to group multiple commands into a single request, minimizing
         network round-trip time, latency, and I/O load, thereby enhancing the overall performance.
 
-        It is important to highlight that the clear method can be safely executed within the context of an initiated pipeline operation
+        It is important to highlight that the clear method can be safely executed within
+        the context of an initiated pipeline operation.
         """
         with self.pipeline():
             for key in self:
-                del (self[key])
+                del self[key]
 
     def pop(self, key: str, default: Union[Any, object] = SENTINEL) -> Any:
         """
@@ -516,7 +775,7 @@ class RedisDict:
                 return default
             raise
 
-        del (self[key])
+        del self[key]
         return value
 
     def popitem(self) -> Tuple[str, Any]:
@@ -594,7 +853,8 @@ class RedisDict:
             value (Optional[Any], optional): The value to be assigned to each key in the RedisDict. Defaults to None.
 
         Returns:
-            RedisDict: The current RedisDict instance, now populated with the keys from the iterable and their corresponding values.
+            RedisDict: The current RedisDict instance,populated with the keys from the iterable and their
+            corresponding values.
         """
         for key in iterable:
             self[key] = value
@@ -640,7 +900,7 @@ class RedisDict:
         Args:
             iterable (List[str]): A list of keys representing the chain.
         """
-        return self.__delitem__(':'.join(iterable))
+        del self[':'.join(iterable)]
 
     #  def expire_at(self, sec_epoch: int | timedelta) -> Iterator[None]:
     #  compatibility with Python 3.9 typing
@@ -668,13 +928,13 @@ class RedisDict:
             ContextManager: A context manager to create a Redis pipeline batching all operations within the context.
         """
         top_level = False
-        if self.temp_redis is None:
-            self.redis, self.temp_redis, top_level = self.redis.pipeline(), self.redis, True
+        if self._temp_redis is None:
+            self.redis, self._temp_redis, top_level = self.redis.pipeline(), self.redis, True
         try:
             yield
         finally:
             if top_level:
-                _, self.temp_redis, self.redis = self.redis.execute(), None, self.temp_redis  # type: ignore
+                _, self._temp_redis, self.redis = self.redis.execute(), None, self._temp_redis  # type: ignore
 
     def multi_get(self, key: str) -> List[Any]:
         """
@@ -717,7 +977,9 @@ class RedisDict:
         if len(keys) == 0:
             return {}
         to_rm = keys[0].rfind(':') + 1
-        return dict(zip([i[to_rm:] for i in keys], (self._transform(i) for i in self.redis.mget(keys) if i is not None)))
+        return dict(
+            zip([i[to_rm:] for i in keys], (self._transform(i) for i in self.redis.mget(keys) if i is not None))
+        )
 
     def multi_del(self, key: str) -> int:
         """

redis_dict-2.5.1.dist-info/RECORD

@@ -1,6 +0,0 @@
-redis_dict.py,sha256=ZQSg6bCaV_Ho18x7CtjYgD0kakFeskn3TfJzR3e0I28,25677
-redis_dict-2.5.1.dist-info/LICENSE,sha256=-QiLwYznh_vNUSz337k0faP9Jl0dgtCIHVZ39Uyl6cA,1070
-redis_dict-2.5.1.dist-info/METADATA,sha256=dKyus34pm_rQ-icVu7L53N_QzMSaxbLWhKuVSTh7RfI,10000
-redis_dict-2.5.1.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
-redis_dict-2.5.1.dist-info/top_level.txt,sha256=Wyp5Xvq_imoxvu-c-Le1rbTZ3pYM5BF440H9YAcgBZ8,11
-redis_dict-2.5.1.dist-info/RECORD,,