V2.5.1 (#55)

* Changed small housekeeping

* bump version 2.5.1

* Changed small house keeping

Author: Attumm

.travis.yml

@@ -131,7 +131,7 @@ def __init__(self,
         Args:
             namespace (str, optional): A prefix for keys stored in Redis.
             expire (int, timedelta, optional): Expiration time for keys in seconds.
-            preserve_expiration (bool, optional): Whether or not to preserve the expiration.
+            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
@@ -403,14 +403,14 @@ def get(self, key: str, default: Optional[Any] = None) -> Any:
 
     def iterkeys(self) -> Iterator[str]:
         """
-            Note: for pythone2 str is needed
+            Note: for python2 str is needed
         """
         to_rm = len(self.namespace) + 1
         return (str(item[to_rm:]) for item in self._scan_keys())
 
     def key(self, search_term: str = '') -> Optional[str]:
         """
-        Note: for pythone2 str is needed
+        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)
@@ -546,7 +546,7 @@ def setdefault(self, key: str, default_value: Optional[Any] = None) -> Any:
 
         Args:
             key (str): The key to retrieve the value.
-            default (Optional[Any], optional): The value to set if the key is not found.
+            default_value (Optional[Any], optional): The value to set if the key is not found.
 
         Returns:
             Any: The value associated with the key or the default value.
@@ -575,7 +575,7 @@ def update(self, dic: Dict[str, Any]) -> None:
         Update the RedisDict with key-value pairs from the given mapping, analogous to a dictionary's update method.
 
         Args:
-            other (Mapping[str, Any]): A mapping containing key-value pairs to update the RedisDict.
+            dic (Mapping[str, Any]): A mapping containing key-value pairs to update the RedisDict.
         """
         with self.pipeline():
             for key, value in dic.items():
@@ -746,13 +746,13 @@ def get_redis_info(self) -> Dict[str, Any]:
     def get_ttl(self, key: str) -> Optional[int]:
         """
         Get the Time To Live (TTL) in seconds for a given key. If the key does not exist or does not have an
-        associated expire, return None.
+        associated `expire`, return None.
 
         Args:
             key (str): The key for which to get the TTL.
 
         Returns:
-            Optional[int]: The TTL in seconds if the key exists and has an expire set; otherwise, None.
+            Optional[int]: The TTL in seconds if the key exists and has an expiry set; otherwise, None.
         """
         val = self.redis.ttl(self._format_key(key))
         if val < 0:

redis_dict.py

@@ -17,7 +17,7 @@
     long_description=long_description,
     long_description_content_type='text/markdown',
 
-    version='2.5.0',
+    version='2.5.1',
     py_modules=['redis_dict'],
     install_requires=['redis',],
     license='MIT',

setup.py

@@ -279,7 +279,7 @@ def test_dict_method_pop_default(self):
             self.assertEqual(len(dic), len(input_items) - i)
             self.assertEqual(len(redis_dic), len(input_items) - i)
 
-        expected = "defualt item"
+        expected = "default item"
         self.assertEqual(dic.pop("item", expected), expected)
         self.assertEqual(redis_dic.pop("item", expected), expected)
 
@@ -696,18 +696,18 @@ def test_set_and_get_multiple(self):
         self.assertEqual(self.r['foobar1'], 'barbar1')
         self.assertEqual(self.r['foobar2'], 'barbar2')
 
-    def test_get_nonexisting(self):
+    def test_get_non_existing(self):
         """Test that retrieving a non-existing key raises a KeyError."""
         with self.assertRaises(KeyError):
-            _ = self.r['nonexistingkey']
+            _ = self.r['non_existing_key']
 
     def test_delete(self):
         """Test deleting a key."""
-        self.r['foobargone'] = 'bars'
+        key = 'foobar_gone'
+        self.r[key] = 'bar'
 
-        del self.r['foobargone']
-
-        self.assertEqual(self.redisdb.get('foobargone'), None)
+        del self.r[key]
+        self.assertEqual(self.redisdb.get(key), None)
 
     def test_contains_empty(self):
         """Tests the __contains__ function with no keys set."""
@@ -729,17 +729,21 @@ def test_repr_empty(self):
 
     def test_repr_nonempty(self):
         """Tests the __repr__ function with keys set."""
-        self.r['foobars'] = 'barrbars'
-        expected_repr = str({'foobars': 'barrbars'})
-        actual_repr = repr(self.r)
-        self.assertEqual(actual_repr, expected_repr)
+        key = 'foobar'
+        val = 'bar'
+        self.r[key] = val
+        expected = str({key: val})
+        result = repr(self.r)
+        self.assertEqual(result, expected)
 
     def test_str_nonempty(self):
         """Tests the __repr__ function with keys set."""
-        self.r['foobars'] = 'barrbars'
-        expected_str = str({'foobars': 'barrbars'})
-        actual_str = str(self.r)
-        self.assertEqual(actual_str, expected_str)
+        key = 'foobar'
+        val = 'bar'
+        self.r[key] = val
+        expected = str({key: val})
+        result = str(self.r)
+        self.assertEqual(result, expected)
 
     def test_len_empty(self):
         """Tests the __repr__ function with no keys set."""
@@ -820,15 +824,15 @@ def test_chain_del_2(self):
             _ = self.r.chain_get(['foo', 'bar'])
 
     def test_expire_context(self):
-        """Test adding keys with an expire value by using the contextmanager."""
+        """Test adding keys with an `expire` value by using the contextmanager."""
         with self.r.expire_at(3600):
             self.r['foobar'] = 'barbar'
 
         actual_ttl = self.redisdb.ttl('{}:foobar'.format(TEST_NAMESPACE_PREFIX))
         self.assertAlmostEqual(3600, actual_ttl, delta=2)
 
     def test_expire_context_timedelta(self):
-        """ Test adding keys with an expire value by using the contextmanager. With timedelta as argument. """
+        """ Test adding keys with an `expire` value by using the contextmanager. With timedelta as argument. """
         timedelta_one_hour = timedelta(hours=1)
         timedelta_one_minute = timedelta(minutes=1)
         hour_in_seconds = 60 * 60
@@ -845,15 +849,15 @@ def test_expire_context_timedelta(self):
         self.assertAlmostEqual(minute_in_seconds, actual_ttl, delta=2)
 
     def test_expire_keyword(self):
-        """Test adding keys with an expire value by using the expire config keyword."""
+        """Test adding keys with an `expire` value by using the `expire` config keyword."""
         r = self.create_redis_dict(expire=3600)
 
         r['foobar'] = 'barbar'
         actual_ttl = self.redisdb.ttl('{}:foobar'.format(TEST_NAMESPACE_PREFIX))
         self.assertAlmostEqual(3600, actual_ttl, delta=2)
 
     def test_expire_keyword_timedelta(self):
-        """ Test adding keys with an expire value by using the expire config keyword. With timedelta as argument."""
+        """ Test adding keys with an `expire` value by using the `expire` config keyword. With timedelta as argument."""
         timedelta_one_hour = timedelta(hours=1)
         timedelta_one_minute = timedelta(minutes=1)
         hour_in_seconds = 60 * 60
@@ -1153,13 +1157,13 @@ def setUp(self):
         self.clear_test_namespace()
 
     def test_unicode_key(self):
-        # Test handling of unicode keys
+        # Test handling of Unicode keys
         unicode_key = '你好'
         self.r[unicode_key] = 'value'
         self.assertEqual(self.r[unicode_key], 'value')
 
     def test_unicode_value(self):
-        # Test handling of unicode values
+        # Test handling of Unicode values
         unicode_value = '世界'
         self.r['key'] = unicode_value
         self.assertEqual(self.r['key'], unicode_value)
@@ -1486,7 +1490,7 @@ def test_preserve_expiration(self):
         value = "bar"
         redis_dict[key] = value
 
-        # Ensure the TTL (time-to-live) of the "foo" key is approximately the global expire time.
+        # Ensure the TTL (time-to-live) of the "foo" key is approximately the global `expire` time.
         actual_ttl = redis_dict.get_ttl(key)
         self.assertAlmostEqual(3600, actual_ttl, delta=1)
 
@@ -1502,7 +1506,7 @@ def test_preserve_expiration(self):
         actual_ttl_foo = redis_dict.get_ttl(key)
         self.assertAlmostEqual(3600 - time_sleeping, actual_ttl_foo, delta=1)
 
-        # Ensure the TTL of the "bar" key is also approximately the global expire time.
+        # Ensure the TTL of the "bar" key is also approximately the global `expire` time.
         actual_ttl_bar = redis_dict.get_ttl(new_key)
 
         self.assertAlmostEqual(3600, actual_ttl_bar, delta=1)
@@ -1518,7 +1522,7 @@ def test_preserve_expiration_not_used(self):
         value = "bar"
         redis_dict[key] = value
 
-        # Ensure the TTL (time-to-live) of the "foo" key is approximately the global expire time.
+        # Ensure the TTL (time-to-live) of the "foo" key is approximately the global `expire` time.
         actual_ttl = redis_dict.get_ttl(key)
         self.assertAlmostEqual(3600, actual_ttl, delta=1)
 
@@ -1534,12 +1538,12 @@ def test_preserve_expiration_not_used(self):
         actual_ttl_foo = redis_dict.get_ttl(key)
         self.assertAlmostEqual(3600, actual_ttl_foo, delta=1)
 
-        # Ensure the TTL of the "bar" key is also approximately the global expire time.
+        # Ensure the TTL of the "bar" key is also approximately the global `expire` time.
         actual_ttl_bar = redis_dict.get_ttl(new_key)
 
         self.assertAlmostEqual(3600, actual_ttl_bar, delta=1)
 
-        # Ensure the difference between the TTLs of "foo" and "bar" is no more then 1 seconds.
+        # Ensure the difference between the TTLs of "foo" and "bar" is no more than one second.
         self.assertTrue(abs(actual_ttl_foo - actual_ttl_bar) <= 1)