Skip to content

Build and run agents you can see, understand and trust.

fix(redis_memory): support `decode_response` to be `False` in the given `connection_pool` argument (#1187)

Zheng Dayu734b6d332673
diff --git a/src/agentscope/memory/_working_memory/_redis_memory.py b/src/agentscope/memory/_working_memory/_redis_memory.py
index 512ea4faf..053a56330 100644
--- a/src/agentscope/memory/_working_memory/_redis_memory.py
+++ b/src/agentscope/memory/_working_memory/_redis_memory.py
@@ -125,6 +125,35 @@ class RedisMemory(MemoryBase):
"""
return self._client
+ def _decode_if_bytes(self, data: Any) -> Any:
+ """Helper method to decode bytes to str if needed.
+
+ Args:
+ data (`Any`):
+ The data to decode, which may be bytes, bytearray, or str.
+
+ Returns:
+ `Any`:
+ The decoded string if input was bytes/bytearray, otherwise
+ the original data.
+ """
+ if isinstance(data, (bytes, bytearray)):
+ return data.decode("utf-8")
+ return data
+
+ def _decode_list(self, data_list: list) -> list:
+ """Helper method to decode a list of potential bytes.
+
+ Args:
+ data_list (`list`):
+ A list that may contain bytes, bytearray, or str elements.
+
+ Returns:
+ `list`:
+ A list with all bytes/bytearray elements decoded to str.
+ """
+ return [self._decode_if_bytes(item) for item in data_list]
+
def _get_session_key(self) -> str:
"""Get the Redis key for the current session.
@@ -224,6 +253,8 @@ class RedisMemory(MemoryBase):
match=self._get_session_pattern(),
count=100,
)
+ # Decode keys if they are bytes
+ keys = self._decode_list(keys)
for key in keys:
await pipe.expire(key, self.key_ttl)
if cursor == 0:
@@ -284,6 +315,8 @@ class RedisMemory(MemoryBase):
-1,
)
+ msg_ids = self._decode_list(msg_ids)
+
# Exclude messages by exclude_mark
if exclude_mark:
exclude_msg_ids = await self._client.lrange(
@@ -291,6 +324,7 @@ class RedisMemory(MemoryBase):
0,
-1,
)
+ exclude_msg_ids = self._decode_list(exclude_msg_ids)
msg_ids = [_ for _ in msg_ids if _ not in exclude_msg_ids]
# Use mget for batch retrieval to avoid N+1 queries
@@ -301,8 +335,8 @@ class RedisMemory(MemoryBase):
for msg_data in msg_data_list:
if msg_data is not None:
- if isinstance(msg_data, (bytes, bytearray)):
- msg_data = msg_data.decode("utf-8")
+ # Decode if bytes
+ msg_data = self._decode_if_bytes(msg_data)
msg_dict = json.loads(msg_data)
messages.append(Msg.from_dict(msg_dict))
@@ -365,6 +399,7 @@ class RedisMemory(MemoryBase):
0,
-1,
)
+ existing_msg_ids = self._decode_list(existing_msg_ids)
existing_msg_ids_set = set(existing_msg_ids)
# Filter out messages that already exist
@@ -430,6 +465,8 @@ class RedisMemory(MemoryBase):
match=self._get_mark_pattern(),
count=50,
)
+ # Decode keys if they are bytes
+ keys = self._decode_list(keys)
mark_keys.extend(keys)
if cursor == 0:
break
@@ -488,6 +525,7 @@ class RedisMemory(MemoryBase):
for m in mark:
mark_key = self._get_mark_key(m)
msg_ids = await self._client.lrange(mark_key, 0, -1)
+ msg_ids = self._decode_list(msg_ids)
if not msg_ids:
continue
@@ -509,6 +547,7 @@ class RedisMemory(MemoryBase):
async def clear(self) -> None:
"""Clear all messages belong to this session from the storage."""
msg_ids = await self._client.lrange(self._get_session_key(), 0, -1)
+ msg_ids = self._decode_list(msg_ids)
# Get all mark keys using SCAN
mark_keys = []
@@ -519,6 +558,8 @@ class RedisMemory(MemoryBase):
match=self._get_mark_pattern(),
count=50,
)
+ # Decode keys if they are bytes
+ keys = self._decode_list(keys)
mark_keys.extend(keys)
if cursor == 0:
break
@@ -588,6 +629,7 @@ class RedisMemory(MemoryBase):
0,
-1,
)
+ mark_msg_ids = self._decode_list(mark_msg_ids)
else:
# Get all message IDs from the session
mark_msg_ids = await self._client.lrange(
@@ -595,6 +637,7 @@ class RedisMemory(MemoryBase):
0,
-1,
)
+ mark_msg_ids = self._decode_list(mark_msg_ids)
# Filter by msg_ids if provided
if msg_ids is not None:
@@ -610,6 +653,7 @@ class RedisMemory(MemoryBase):
if new_mark is not None:
new_mark_key = self._get_mark_key(new_mark)
existing_ids = await self._client.lrange(new_mark_key, 0, -1)
+ existing_ids = self._decode_list(existing_ids)
existing_ids_set = set(existing_ids)
# Use pipeline for batch operations
diff --git a/tests/memory_test.py b/tests/memory_test.py
index 473156982..aa068548c 100644
--- a/tests/memory_test.py
+++ b/tests/memory_test.py
@@ -591,3 +591,78 @@ class RedisMemoryTest(ShortTermMemoryTest):
len(msgs),
0,
)
+
+
+class RedisMemoryTestWithBytes(ShortTermMemoryTest):
+ """The Redis short-term memory tests with decode_responses=False."""
+
+ memory: RedisMemory
+ """The Redis memory instance."""
+
+ memory_session: RedisMemory
+ """The Redis memory instance for different session."""
+
+ memory_user: RedisMemory
+ """The Redis memory instance for different user."""
+
+ async def asyncSetUp(self) -> None:
+ """Set up the Redis memory instance for testing."""
+ await super().asyncSetUp()
+ try:
+ import fakeredis.aioredis
+ except ImportError:
+ self.skipTest(
+ "fakeredis is not installed. Install it via "
+ "'pip install fakeredis' to run this test.",
+ )
+
+ # Use fakeredis with decode_responses=False to test bytes handling
+ fake_redis = fakeredis.aioredis.FakeRedis(decode_responses=False)
+ self.memory = RedisMemory(
+ user_id="user_1",
+ session_id="session_1",
+ connection_pool=fake_redis.connection_pool,
+ )
+
+ self.memory_session = RedisMemory(
+ user_id="user_1",
+ session_id="session_2",
+ connection_pool=fake_redis.connection_pool,
+ )
+
+ self.memory_user = RedisMemory(
+ user_id="user_2",
+ session_id="session_2",
+ connection_pool=fake_redis.connection_pool,
+ )
+
+ async def test_memory(self) -> None:
+ """Test the Redis memory functionalities."""
+ await self._basic_tests()
+ await self._mark_tests()
+ await self._test_add_duplicated_msgs()
+ await self._test_delete_nonexistent_msg()
+ await self._multi_tenant_tests()
+ await self._multi_session_tests()
+
+ async def test_ttl(self) -> None:
+ """Test the TTL functionality of the Redis memory."""
+ # Set a short TTL for testing
+ self.memory.key_ttl = 2 # 2 seconds
+
+ # Add messages and verify they exist
+ await self.memory.add(self.msgs[:5])
+ msgs = await self.memory.get_memory()
+ self.assertEqual(
+ len(msgs),
+ 5,
+ )
+
+ # Wait for TTL to expire
+ await asyncio.sleep(3)
+
+ msgs = await self.memory.get_memory()
+ self.assertEqual(
+ len(msgs),
+ 0,
+ )