✨ feat: add list and hash

Author: mic1on

src/use_redis/__init__.py

@@ -2,6 +2,8 @@
 from .stream import RedisStreamMessage
 from .stream import RedisStreamStore as useRedisStream
 from .set import RedisSetStore as useRedisSet
+from .list import RedisListStore as useRedisList
+from .hash import RedisHashStore as useRedisHash
 
 useRedisStreamStore = useRedisStream
 useRedisStore = useRedis
@@ -13,4 +15,6 @@
     "useRedisStreamStore",
     "RedisStreamMessage",
     "useRedisStream",
+    "useRedisList",
+    "useRedisHash",
 ]

src/use_redis/hash.py

@@ -0,0 +1,74 @@
+from .store import RedisStore
+
+
+class RedisHashStore(RedisStore):
+    def __init__(self, key, **kwargs):
+        super().__init__(**kwargs)
+        self._key = key
+
+    @property
+    def key(self):
+        return self._key
+
+    def set(self, field, value):
+        """设置哈希表中指定字段的值"""
+        return self.connection.hset(self.key, field, value)
+
+    def set_multiple(self, mapping):
+        """同时将多个 field-value 对设置到哈希表中"""
+        return self.connection.hmset(self.key, mapping)
+
+    def get(self, *fields):
+        """获取哈希表中指定字段的值"""
+        if len(fields) == 1:
+            return self.connection.hget(self.key, fields[0])
+        return self.connection.hmget(self.key, fields)
+
+    def delete(self, *fields):
+        """删除哈希表中的一个或多个字段"""
+        return self.connection.hdel(self.key, *fields)
+
+    def exists(self, field):
+        """检查哈希表中是否存在指定的字段"""
+        return self.connection.hexists(self.key, field)
+
+    def length(self):
+        """获取哈希表中字段的数量"""
+        return self.connection.hlen(self.key)
+
+    def keys(self):
+        """获取哈希表中的所有字段"""
+        return self.connection.hkeys(self.key)
+
+    def values(self):
+        """获取哈希表中所有字段的值"""
+        return self.connection.hvals(self.key)
+
+    def items(self):
+        """获取哈希表中所有的字段和值"""
+        return self.connection.hgetall(self.key)
+
+    def increment(self, field, amount=1):
+        """
+        将哈希表中指定字段的值增加给定的增量
+        
+        :param field: 要增加的字段
+        :param amount: 增加的数量，可以是整数或浮点数
+        :return: 增加后的值
+        """
+        if isinstance(amount, int):
+            return self.connection.hincrby(self.key, field, amount)
+        else:
+            return self.connection.hincrbyfloat(self.key, field, amount)
+
+
+    def scan(self, cursor=0, match=None, count=None):
+        """迭代哈希表中的键值对"""
+        return self.connection.hscan(self.key, cursor, match, count)
+
+    def __getattr__(self, name):
+        """动态处理未实现的方法"""
+        def method(*args, **kwargs):
+            redis_method = getattr(self.connection, name)
+            return redis_method(self.key, *args, **kwargs)
+        return method

src/use_redis/list.py

@@ -0,0 +1,68 @@
+from .store import RedisStore
+
+
+class RedisListStore(RedisStore):
+    def __init__(self, key, **kwargs):
+        super().__init__(**kwargs)
+        self._key = key
+
+    @property
+    def key(self):
+        return self._key
+
+    def lpush(self, *values):
+        """将一个或多个值插入到列表头部"""
+        return self.connection.lpush(self.key, *values)
+
+    def rpush(self, *values):
+        """将一个或多个值插入到列表尾部"""
+        return self.connection.rpush(self.key, *values)
+
+    def lpop(self):
+        """移除并返回列表的第一个元素"""
+        return self.connection.lpop(self.key)
+
+    def rpop(self):
+        """移除并返回列表的最后一个元素"""
+        return self.connection.rpop(self.key)
+
+    def length(self):
+        """返回列表的长度"""
+        return self.connection.llen(self.key)
+
+    def range(self, start, end):
+        """获取列表指定范围内的元素"""
+        return self.connection.lrange(self.key, start, end)
+
+    def set(self, index, value):
+        """通过索引设置列表元素的值"""
+        return self.connection.lset(self.key, index, value)
+
+    def index(self, index):
+        """通过索引获取列表中的元素"""
+        return self.connection.lindex(self.key, index)
+
+    def trim(self, start, end):
+        """修剪列表，只保留指定区间内的元素"""
+        return self.connection.ltrim(self.key, start, end)
+
+    def remove(self, value, count=0):
+        """移除列表中与value相等的元素"""
+        return self.connection.lrem(self.key, count, value)
+
+    def insert_before(self, pivot, value):
+        """在列表的元素前插入元素"""
+        return self.connection.linsert(self.key, 'BEFORE', pivot, value)
+
+    def insert_after(self, pivot, value):
+        """在列表的元素后插入元素"""
+        return self.connection.linsert(self.key, 'AFTER', pivot, value)
+
+    def __getattr__(self, name):
+        """动态处理未实现的方法"""
+
+        def method(*args, **kwargs):
+            redis_method = getattr(self.connection, name)
+            return redis_method(self.key, *args, **kwargs)
+
+        return method

tests/test_hash.py

@@ -0,0 +1,104 @@
+import pytest
+from use_redis.hash import RedisHashStore
+
+
+@pytest.fixture
+def mock_redis(mocker):
+    mock = mocker.patch("redis.Redis")
+    return mock.return_value
+
+
+@pytest.fixture
+def hash_store(mock_redis):
+    return RedisHashStore("test_hash")
+
+
+def test_set(hash_store, mock_redis):
+    hash_store.set("field1", "value1")
+    mock_redis.hset.assert_called_once_with("test_hash", "field1", "value1")
+
+
+def test_set_multiple(hash_store, mock_redis):
+    mapping = {"field1": "value1", "field2": "value2"}
+    hash_store.set_multiple(mapping)
+    mock_redis.hmset.assert_called_once_with("test_hash", mapping)
+
+
+def test_get_single(hash_store, mock_redis):
+    mock_redis.hget.return_value = "value1"
+    result = hash_store.get("field1")
+    assert result == "value1"
+    mock_redis.hget.assert_called_once_with("test_hash", "field1")
+
+
+def test_get_multiple(hash_store, mock_redis):
+    mock_redis.hmget.return_value = ["value1", "value2"]
+    result = hash_store.get("field1", "field2")
+    assert result == ["value1", "value2"]
+    mock_redis.hmget.assert_called_once_with("test_hash", ("field1", "field2"))
+
+
+def test_delete(hash_store, mock_redis):
+    hash_store.delete("field1", "field2")
+    mock_redis.hdel.assert_called_once_with("test_hash", "field1", "field2")
+
+
+def test_exists(hash_store, mock_redis):
+    mock_redis.hexists.return_value = True
+    result = hash_store.exists("field1")
+    assert result is True
+    mock_redis.hexists.assert_called_once_with("test_hash", "field1")
+
+
+def test_length(hash_store, mock_redis):
+    mock_redis.hlen.return_value = 2
+    result = hash_store.length()
+    assert result == 2
+    mock_redis.hlen.assert_called_once_with("test_hash")
+
+
+def test_keys(hash_store, mock_redis):
+    mock_redis.hkeys.return_value = ["field1", "field2"]
+    result = hash_store.keys()
+    assert result == ["field1", "field2"]
+    mock_redis.hkeys.assert_called_once_with("test_hash")
+
+
+def test_values(hash_store, mock_redis):
+    mock_redis.hvals.return_value = ["value1", "value2"]
+    result = hash_store.values()
+    assert result == ["value1", "value2"]
+    mock_redis.hvals.assert_called_once_with("test_hash")
+
+
+def test_items(hash_store, mock_redis):
+    mock_redis.hgetall.return_value = {"field1": "value1", "field2": "value2"}
+    result = hash_store.items()
+    assert result == {"field1": "value1", "field2": "value2"}
+    mock_redis.hgetall.assert_called_once_with("test_hash")
+
+
+def test_increment_int(hash_store, mock_redis):
+    mock_redis.hincrby.return_value = 2
+    result = hash_store.increment("field1", 1)
+    assert result == 2
+    mock_redis.hincrby.assert_called_once_with("test_hash", "field1", 1)
+
+
+def test_increment_float(hash_store, mock_redis):
+    mock_redis.hincrbyfloat.return_value = 2.5
+    result = hash_store.increment("field1", 1.5)
+    assert result == 2.5
+    mock_redis.hincrbyfloat.assert_called_once_with("test_hash", "field1", 1.5)
+
+
+def test_scan(hash_store, mock_redis):
+    mock_redis.hscan.return_value = (0, {"field1": "value1", "field2": "value2"})
+    result = hash_store.scan(cursor=0, match="f*", count=2)
+    assert result == (0, {"field1": "value1", "field2": "value2"})
+    mock_redis.hscan.assert_called_once_with("test_hash", 0, "f*", 2)
+
+
+def test_dynamic_method(hash_store, mock_redis):
+    hash_store.hstrlen("field1")
+    mock_redis.hstrlen.assert_called_once_with("test_hash", "field1")

tests/test_list.py

@@ -0,0 +1,88 @@
+import pytest
+from use_redis.list import RedisListStore
+
+
+@pytest.fixture
+def mock_redis(mocker):
+    mock = mocker.patch("redis.Redis")
+    return mock.return_value
+
+
+@pytest.fixture
+def list_store(mock_redis):
+    return RedisListStore("test_list")
+
+
+def test_lpush(list_store, mock_redis):
+    list_store.lpush("value1", "value2")
+    mock_redis.lpush.assert_called_once_with("test_list", "value1", "value2")
+
+
+def test_rpush(list_store, mock_redis):
+    list_store.rpush("value1", "value2")
+    mock_redis.rpush.assert_called_once_with("test_list", "value1", "value2")
+
+
+def test_lpop(list_store, mock_redis):
+    mock_redis.lpop.return_value = "value1"
+    result = list_store.lpop()
+    assert result == "value1"
+    mock_redis.lpop.assert_called_once_with("test_list")
+
+
+def test_rpop(list_store, mock_redis):
+    mock_redis.rpop.return_value = "value2"
+    result = list_store.rpop()
+    assert result == "value2"
+    mock_redis.rpop.assert_called_once_with("test_list")
+
+
+def test_length(list_store, mock_redis):
+    mock_redis.llen.return_value = 2
+    result = list_store.length()
+    assert result == 2
+    mock_redis.llen.assert_called_once_with("test_list")
+
+
+def test_range(list_store, mock_redis):
+    mock_redis.lrange.return_value = ["value1", "value2"]
+    result = list_store.range(0, -1)
+    assert result == ["value1", "value2"]
+    mock_redis.lrange.assert_called_once_with("test_list", 0, -1)
+
+
+def test_set(list_store, mock_redis):
+    list_store.set(1, "new_value")
+    mock_redis.lset.assert_called_once_with("test_list", 1, "new_value")
+
+
+def test_index(list_store, mock_redis):
+    mock_redis.lindex.return_value = "value1"
+    result = list_store.index(0)
+    assert result == "value1"
+    mock_redis.lindex.assert_called_once_with("test_list", 0)
+
+
+def test_trim(list_store, mock_redis):
+    list_store.trim(0, 1)
+    mock_redis.ltrim.assert_called_once_with("test_list", 0, 1)
+
+
+def test_remove(list_store, mock_redis):
+    list_store.remove("value1", 1)
+    mock_redis.lrem.assert_called_once_with("test_list", 1, "value1")
+
+
+def test_insert_before(list_store, mock_redis):
+    list_store.insert_before("pivot", "new_value")
+    mock_redis.linsert.assert_called_once_with("test_list", 'BEFORE', "pivot", "new_value")
+
+
+def test_insert_after(list_store, mock_redis):
+    list_store.insert_after("pivot", "new_value")
+    mock_redis.linsert.assert_called_once_with("test_list", 'AFTER', "pivot", "new_value")
+
+
+def test_dynamic_method(list_store, mock_redis):
+    list_store.lmove("source", "destination", "LEFT", "RIGHT")
+    mock_redis.lmove.assert_called_once_with("test_list", "source", "destination", "LEFT", "RIGHT")