From ab9383cbb4cb2aab688dfd6e4278f8742cb4fa01 Mon Sep 17 00:00:00 2001 From: Adar Ovadia Date: Sun, 30 Jun 2024 12:47:53 +0000 Subject: [PATCH] fix pr comments --- .../async_commands/standalone_commands.py | 3 +- .../glide/async_commands/utils/utils.py | 61 ------- python/python/glide/constants.py | 1 - python/python/glide/glide_client.py | 4 +- python/python/tests/test_async_client.py | 159 +++++++++--------- python/python/tests/utils/utils.py | 68 ++++++-- 6 files changed, 134 insertions(+), 162 deletions(-) delete mode 100644 python/python/glide/async_commands/utils/utils.py diff --git a/python/python/glide/async_commands/standalone_commands.py b/python/python/glide/async_commands/standalone_commands.py index 8405e6add7..7c0cb3224d 100644 --- a/python/python/glide/async_commands/standalone_commands.py +++ b/python/python/glide/async_commands/standalone_commands.py @@ -12,7 +12,6 @@ _build_sort_args, ) from glide.async_commands.transaction import BaseTransaction, Transaction -from glide.async_commands.utils.utils import convert_bytes_to_string_dict from glide.constants import OK, TOK, TResult from glide.protobuf.redis_request_pb2 import RequestType @@ -50,7 +49,7 @@ async def info( Returns: - str: Returns a string containing the information for the sections requested. + bytes: Returns bytes containing the information for the sections requested. """ args = [section.value for section in sections] if sections else [] return cast(bytes, await self._execute_command(RequestType.Info, args)) diff --git a/python/python/glide/async_commands/utils/utils.py b/python/python/glide/async_commands/utils/utils.py deleted file mode 100644 index 88defe0061..0000000000 --- a/python/python/glide/async_commands/utils/utils.py +++ /dev/null @@ -1,61 +0,0 @@ -from typing import Any, Dict, Mapping, Optional, Union - -from glide.constants import TClusterDecodedResponse, TClusterResponse - - -def convert_bytes_to_string_dict( - # TODO: remove the str options - byte_string_dict: Optional[ - Union[Mapping[bytes, Any], Dict[bytes, Any], Mapping[str, Any], Dict[str, Any]] - ] -) -> Optional[Dict[str, Any]]: - """ - Recursively convert the keys and values of a dictionary from byte strings to regular strings, - handling nested dictionaries of any depth. - - Args: - byte_string_dict (Optional[Union[Mapping[bytes, Any], Dict[bytes, Any]]]): - A dictionary where keys and values can be byte strings or nested dictionaries. - - Returns: - Optional[Dict[str, Any]]: - A dictionary with keys and values converted to regular strings, or None if input is None. - """ - if byte_string_dict is None: - return None - - def convert(item: Any) -> Any: - if isinstance(item, dict): - return {convert(key): convert(value) for key, value in item.items()} - elif isinstance(item, bytes): - return item.decode("utf-8") - elif isinstance(item, list): - return [convert(elem) for elem in item] - else: - return item - - return convert(byte_string_dict) - - -def convert_bytes_to_string_cluster_response( - cluster_response: Optional[TClusterResponse], -) -> Optional[TClusterDecodedResponse]: - """ - Convert a TClusterResponse type with byte strings to a TClusterResponse type with regular strings, - handling nested dictionaries of any depth. - - Args: - cluster_response (Optional[Union[T, Dict[bytes, T]]]): - A cluster response which can be of type T or a dictionary with byte string keys and values. - - Returns: - Optional[TClusterResponse]: - A cluster response with all byte strings converted to regular strings. - """ - if cluster_response is None: - return None - - if isinstance(cluster_response, dict): - return convert_bytes_to_string_dict(cluster_response) - - return cluster_response diff --git a/python/python/glide/constants.py b/python/python/glide/constants.py index a527c06cfd..0eacccb040 100644 --- a/python/python/glide/constants.py +++ b/python/python/glide/constants.py @@ -30,7 +30,6 @@ # When routing to a single node, response will be T # Otherwise, response will be : {Address : response , ... } with type of Dict[str, T]. TClusterResponse = Union[T, Dict[bytes, T]] -TClusterDecodedResponse = Union[T, Dict[str, T]] TSingleNodeRoute = Union[RandomNode, SlotKeyRoute, SlotIdRoute, ByAddressRoute] # When specifying legacy path (path doesn't start with `$`), response will be T # Otherwise, (when specifying JSONPath), response will be List[Optional[T]]. diff --git a/python/python/glide/glide_client.py b/python/python/glide/glide_client.py index 57ea40cdfe..3a2c27c1d8 100644 --- a/python/python/glide/glide_client.py +++ b/python/python/glide/glide_client.py @@ -251,8 +251,8 @@ async def _execute_command( request.callback_idx = self._get_callback_index() request.single_command.request_type = request_type request.single_command.args_array.args[:] = [ - bytes(elem, encoding="utf8") for elem in args if isinstance(elem, str) - ] # TODO - use arg pointer + bytes(elem, encoding="utf8") if isinstance(elem, str) else elem for elem in args + ] (encoded_args, args_size) = self._encode_and_sum_size(args) if args_size < MAX_REQUEST_ARGS_LEN: request.single_command.args_array.args[:] = encoded_args diff --git a/python/python/tests/test_async_client.py b/python/python/tests/test_async_client.py index 69b482bfff..7da6c0dc9b 100644 --- a/python/python/tests/test_async_client.py +++ b/python/python/tests/test_async_client.py @@ -91,8 +91,8 @@ check_if_server_version_lt, compare_maps, convert_bytes_to_string_dict, - convert_str_to_bytes_list, - convert_str_to_bytes_set, + convert_string_to_bytes_dict, + convert_string_to_bytes_dict, generate_lua_lib_code, get_first_result, get_random_string, @@ -111,8 +111,6 @@ async def test_register_client_name_and_version(self, redis_client: TGlideClient # TODO: change it to pytest fixture after we'll implement a sync client return pytest.mark.skip(reason=f"Redis version required >= {min_version}") info = await redis_client.custom_command(["CLIENT", "INFO"]) - # We check bytes string because custom_command will always return so. - # To get String, we use redis client's info command. assert isinstance(info, bytes) info_str = info.decode() assert "lib-name=GlidePy" in info_str @@ -394,8 +392,7 @@ async def test_info_server_replication(self, redis_client: TGlideClient): cluster_mode = parse_info_response(info_res)["redis_mode"] expected_cluster_mode = isinstance(redis_client, GlideClusterClient) assert cluster_mode == "cluster" if expected_cluster_mode else "standalone" - info_res = get_first_result(await redis_client.info([InfoSection.REPLICATION])) - info = info_res.decode() + info = get_first_result(await redis_client.info([InfoSection.REPLICATION])).decode() assert "# Replication" in info assert "# Errorstats" not in info @@ -411,7 +408,7 @@ async def test_info_default(self, redis_client: TGlideClient): expected_num_of_results = cluster_nodes.count(b"master") assert len(info_result) == expected_num_of_results info_result = get_first_result(info_result) - assert "# Memory" in info_result.decode() + assert b"# Memory" in info_result @pytest.mark.parametrize("cluster_mode", [False]) @pytest.mark.parametrize("protocol", [ProtocolVersion.RESP2, ProtocolVersion.RESP3]) @@ -1043,10 +1040,10 @@ async def test_lpush_lpop_lrange(self, redis_client: TGlideClient): assert await redis_client.lpush(key, value_list) == 4 assert await redis_client.lpop(key) == value_list[-1].encode("utf-8") - assert await redis_client.lrange(key, 0, -1) == convert_str_to_bytes_list( + assert await redis_client.lrange(key, 0, -1) == convert_string_to_bytes_dict( value_list[-2::-1] ) - assert await redis_client.lpop_count(key, 2) == convert_str_to_bytes_list( + assert await redis_client.lpop_count(key, 2) == convert_string_to_bytes_dict( value_list[-2:0:-1] ) assert await redis_client.lrange("non_existing_key", 0, -1) == [] @@ -1084,7 +1081,7 @@ async def test_lpushx(self, redis_client: TGlideClient): # existing key assert await redis_client.lpush(key1, ["0"]) == 1 assert await redis_client.lpushx(key1, ["1", "2", "3"]) == 4 - assert await redis_client.lrange(key1, 0, -1) == convert_str_to_bytes_list( + assert await redis_client.lrange(key1, 0, -1) == convert_string_to_bytes_dict( ["3", "2", "1", "0"] ) # key exists, but not a list @@ -1105,7 +1102,7 @@ async def test_blpop(self, redis_client: TGlideClient): value_list = [value1, value2] assert await redis_client.lpush(key1, value_list) == 2 - assert await redis_client.blpop([key1, key2], 0.5) == convert_str_to_bytes_list( + assert await redis_client.blpop([key1, key2], 0.5) == convert_string_to_bytes_dict( [key1, value2] ) # ensure that command doesn't time out even if timeout > request timeout (250ms by default) @@ -1231,7 +1228,7 @@ async def test_rpush_rpop(self, redis_client: TGlideClient): assert await redis_client.rpush(key, value_list) == 4 assert await redis_client.rpop(key) == value_list[-1].encode("utf-8") - assert await redis_client.rpop_count(key, 2) == convert_str_to_bytes_list( + assert await redis_client.rpop_count(key, 2) == convert_string_to_bytes_dict( value_list[-2:0:-1] ) assert await redis_client.rpop("non_existing_key") is None @@ -1262,7 +1259,7 @@ async def test_rpushx(self, redis_client: TGlideClient): # existing key assert await redis_client.rpush(key1, ["0"]) == 1 assert await redis_client.rpushx(key1, ["1", "2", "3"]) == 4 - assert await redis_client.lrange(key1, 0, -1) == convert_str_to_bytes_list( + assert await redis_client.lrange(key1, 0, -1) == convert_string_to_bytes_dict( ["0", "1", "2", "3"] ) # key existing, but it is not a list @@ -1284,7 +1281,7 @@ async def test_brpop(self, redis_client: TGlideClient): assert await redis_client.lpush(key1, value_list) == 2 # ensure that command doesn't time out even if timeout > request timeout (250ms by default) - assert await redis_client.brpop([key1, key2], 0.5) == convert_str_to_bytes_list( + assert await redis_client.brpop([key1, key2], 0.5) == convert_string_to_bytes_dict( [key1, value1] ) @@ -1312,7 +1309,7 @@ async def test_linsert(self, redis_client: TGlideClient): assert await redis_client.lpush(key1, ["4", "3", "2", "1"]) == 4 assert await redis_client.linsert(key1, InsertPosition.BEFORE, "2", "1.5") == 5 assert await redis_client.linsert(key1, InsertPosition.AFTER, "3", "3.5") == 6 - assert await redis_client.lrange(key1, 0, -1) == convert_str_to_bytes_list( + assert await redis_client.lrange(key1, 0, -1) == convert_string_to_bytes_dict( [ "1", "1.5", @@ -1351,10 +1348,10 @@ async def test_lmove(self, redis_client: TGlideClient): await redis_client.lmove(key1, key2, ListDirection.LEFT, ListDirection.LEFT) == b"1" ) - assert await redis_client.lrange(key1, 0, -1) == convert_str_to_bytes_list( + assert await redis_client.lrange(key1, 0, -1) == convert_string_to_bytes_dict( ["2"] ) - assert await redis_client.lrange(key2, 0, -1) == convert_str_to_bytes_list( + assert await redis_client.lrange(key2, 0, -1) == convert_string_to_bytes_dict( ["1", "3", "4"] ) @@ -1366,7 +1363,7 @@ async def test_lmove(self, redis_client: TGlideClient): == b"2" ) assert await redis_client.lrange(key1, 0, -1) == [] - assert await redis_client.lrange(key2, 0, -1) == convert_str_to_bytes_list( + assert await redis_client.lrange(key2, 0, -1) == convert_string_to_bytes_dict( ["1", "3", "4", "2"] ) @@ -1377,10 +1374,10 @@ async def test_lmove(self, redis_client: TGlideClient): ) == b"2" ) - assert await redis_client.lrange(key2, 0, -1) == convert_str_to_bytes_list( + assert await redis_client.lrange(key2, 0, -1) == convert_string_to_bytes_dict( ["1", "3", "4"] ) - assert await redis_client.lrange(key1, 0, -1) == convert_str_to_bytes_list( + assert await redis_client.lrange(key1, 0, -1) == convert_string_to_bytes_dict( ["2"] ) @@ -1391,10 +1388,10 @@ async def test_lmove(self, redis_client: TGlideClient): ) == b"4" ) - assert await redis_client.lrange(key2, 0, -1) == convert_str_to_bytes_list( + assert await redis_client.lrange(key2, 0, -1) == convert_string_to_bytes_dict( ["1", "3"] ) - assert await redis_client.lrange(key1, 0, -1) == convert_str_to_bytes_list( + assert await redis_client.lrange(key1, 0, -1) == convert_string_to_bytes_dict( ["2", "4"] ) @@ -1436,10 +1433,10 @@ async def test_blmove(self, redis_client: TGlideClient): ) == b"1" ) - assert await redis_client.lrange(key1, 0, -1) == convert_str_to_bytes_list( + assert await redis_client.lrange(key1, 0, -1) == convert_string_to_bytes_dict( ["2"] ) - assert await redis_client.lrange(key2, 0, -1) == convert_str_to_bytes_list( + assert await redis_client.lrange(key2, 0, -1) == convert_string_to_bytes_dict( ["1", "3", "4"] ) @@ -1451,7 +1448,7 @@ async def test_blmove(self, redis_client: TGlideClient): == b"2" ) assert await redis_client.lrange(key1, 0, -1) == [] - assert await redis_client.lrange(key2, 0, -1) == convert_str_to_bytes_list( + assert await redis_client.lrange(key2, 0, -1) == convert_string_to_bytes_dict( ["1", "3", "4", "2"] ) @@ -1462,10 +1459,10 @@ async def test_blmove(self, redis_client: TGlideClient): ) == b"2" ) - assert await redis_client.lrange(key2, 0, -1) == convert_str_to_bytes_list( + assert await redis_client.lrange(key2, 0, -1) == convert_string_to_bytes_dict( ["1", "3", "4"] ) - assert await redis_client.lrange(key1, 0, -1) == convert_str_to_bytes_list( + assert await redis_client.lrange(key1, 0, -1) == convert_string_to_bytes_dict( ["2"] ) @@ -1476,10 +1473,10 @@ async def test_blmove(self, redis_client: TGlideClient): ) == b"4" ) - assert await redis_client.lrange(key2, 0, -1) == convert_str_to_bytes_list( + assert await redis_client.lrange(key2, 0, -1) == convert_string_to_bytes_dict( ["1", "3"] ) - assert await redis_client.lrange(key1, 0, -1) == convert_str_to_bytes_list( + assert await redis_client.lrange(key1, 0, -1) == convert_string_to_bytes_dict( ["2", "4"] ) @@ -1545,7 +1542,7 @@ async def test_lset(self, redis_client: TGlideClient): assert await redis_client.lset(key, 0, element) == OK values = [element] + values[:-1][::-1] - assert await redis_client.lrange(key, 0, -1) == convert_str_to_bytes_list( + assert await redis_client.lrange(key, 0, -1) == convert_string_to_bytes_dict( values ) @@ -1553,7 +1550,7 @@ async def test_lset(self, redis_client: TGlideClient): assert await redis_client.lset(key, -1, element) == OK values[-1] = element - assert await redis_client.lrange(key, 0, -1) == convert_str_to_bytes_list( + assert await redis_client.lrange(key, 0, -1) == convert_string_to_bytes_dict( values ) @@ -1567,7 +1564,7 @@ async def test_sadd_srem_smembers_scard(self, redis_client: TGlideClient): assert await redis_client.srem(key, ["member4", "nonExistingMember"]) == 1 assert set(await redis_client.smembers(key)) == set( - convert_str_to_bytes_list(value_list[:3]) + convert_string_to_bytes_dict(value_list[:3]) ) assert await redis_client.srem(key, ["member1"]) == 1 @@ -1628,7 +1625,7 @@ async def test_spop(self, redis_client: TGlideClient): member2 = get_random_string(5) member3 = get_random_string(5) assert await redis_client.sadd(key, [member, member2, member3]) == 3 - assert await redis_client.spop_count(key, 4) == convert_str_to_bytes_set( + assert await redis_client.spop_count(key, 4) == convert_string_to_bytes_dict( {member, member2, member3} ) @@ -1651,19 +1648,19 @@ async def test_smove(self, redis_client: TGlideClient): # move an element assert await redis_client.smove(key1, key2, "1") is True - assert await redis_client.smembers(key1) == convert_str_to_bytes_set({"2", "3"}) - assert await redis_client.smembers(key2) == convert_str_to_bytes_set( + assert await redis_client.smembers(key1) == convert_string_to_bytes_dict({"2", "3"}) + assert await redis_client.smembers(key2) == convert_string_to_bytes_dict( {"1", "2", "3"} ) # moved element already exists in the destination set assert await redis_client.smove(key2, key1, "2") is True - assert await redis_client.smembers(key1) == convert_str_to_bytes_set({"2", "3"}) - assert await redis_client.smembers(key2) == convert_str_to_bytes_set({"1", "3"}) + assert await redis_client.smembers(key1) == convert_string_to_bytes_dict({"2", "3"}) + assert await redis_client.smembers(key2) == convert_string_to_bytes_dict({"1", "3"}) # attempt to move from a non-existing key assert await redis_client.smove(non_existing_key, key1, "4") is False - assert await redis_client.smembers(key1) == convert_str_to_bytes_set({"2", "3"}) + assert await redis_client.smembers(key1) == convert_string_to_bytes_dict({"2", "3"}) # move to a new set assert await redis_client.smove(key1, key3, "2") @@ -1705,7 +1702,7 @@ async def test_sunion(self, redis_client: TGlideClient): # non-existing key returns the set of existing keys assert await redis_client.sunion( [key1, non_existing_key] - ) == convert_str_to_bytes_set(set(member1_list)) + ) == convert_string_to_bytes_dict(set(member1_list)) # non-set key assert await redis_client.set(key2, "value") == OK @@ -1728,19 +1725,19 @@ async def test_sunionstore(self, redis_client: TGlideClient): # store union in new key assert await redis_client.sunionstore(key4, [key1, key2]) == 5 - assert await redis_client.smembers(key4) == convert_str_to_bytes_set( + assert await redis_client.smembers(key4) == convert_string_to_bytes_dict( {"a", "b", "c", "d", "e"} ) # overwrite existing set assert await redis_client.sunionstore(key1, [key4, key2]) == 5 - assert await redis_client.smembers(key1) == convert_str_to_bytes_set( + assert await redis_client.smembers(key1) == convert_string_to_bytes_dict( {"a", "b", "c", "d", "e"} ) # overwrite one of the source keys assert await redis_client.sunionstore(key2, [key4, key2]) == 5 - assert await redis_client.smembers(key1) == convert_str_to_bytes_set( + assert await redis_client.smembers(key1) == convert_string_to_bytes_dict( {"a", "b", "c", "d", "e"} ) @@ -1755,7 +1752,7 @@ async def test_sunionstore(self, redis_client: TGlideClient): # overwrite destination when destination is not a set assert await redis_client.sunionstore(string_key, [key1, key3]) == 7 - assert await redis_client.smembers(string_key) == convert_str_to_bytes_set( + assert await redis_client.smembers(string_key) == convert_string_to_bytes_dict( { "a", "b", @@ -1779,7 +1776,7 @@ async def test_sinter(self, redis_client: TGlideClient): # positive test case assert await redis_client.sadd(key1, member1_list) == 3 assert await redis_client.sadd(key2, member2_list) == 3 - assert await redis_client.sinter([key1, key2]) == set([b"c"]) + assert await redis_client.sinter([key1, key2]) == {b"c"} # invalid argument - key list must not be empty with pytest.raises(RequestError): @@ -1895,16 +1892,16 @@ async def test_sdiff(self, redis_client: TGlideClient): assert await redis_client.sadd(key1, ["a", "b", "c"]) == 3 assert await redis_client.sadd(key2, ["c", "d", "e"]) == 3 - assert await redis_client.sdiff([key1, key2]) == convert_str_to_bytes_set( + assert await redis_client.sdiff([key1, key2]) == convert_string_to_bytes_dict( {"a", "b"} ) - assert await redis_client.sdiff([key2, key1]) == convert_str_to_bytes_set( + assert await redis_client.sdiff([key2, key1]) == convert_string_to_bytes_dict( {"d", "e"} ) assert await redis_client.sdiff( [key1, non_existing_key] - ) == convert_str_to_bytes_set({"a", "b", "c"}) + ) == convert_string_to_bytes_dict({"a", "b", "c"}) assert await redis_client.sdiff([non_existing_key, key1]) == set() # invalid argument - key list must not be empty @@ -1930,11 +1927,11 @@ async def test_sdiffstore(self, redis_client: TGlideClient): # Store diff in new key assert await redis_client.sdiffstore(key3, [key1, key2]) == 2 - assert await redis_client.smembers(key3) == convert_str_to_bytes_set({"a", "b"}) + assert await redis_client.smembers(key3) == convert_string_to_bytes_dict({"a", "b"}) # Overwrite existing set assert await redis_client.sdiffstore(key3, [key2, key1]) == 2 - assert await redis_client.smembers(key3) == convert_str_to_bytes_set({"d", "e"}) + assert await redis_client.smembers(key3) == convert_string_to_bytes_dict({"d", "e"}) # Overwrite one of the source sets assert await redis_client.sdiffstore(key3, [key2, key3]) == 1 @@ -1942,7 +1939,7 @@ async def test_sdiffstore(self, redis_client: TGlideClient): # Diff between non-empty set and empty set assert await redis_client.sdiffstore(key3, [key1, non_existing_key]) == 3 - assert await redis_client.smembers(key3) == convert_str_to_bytes_set( + assert await redis_client.smembers(key3) == convert_string_to_bytes_dict( {"a", "b", "c"} ) @@ -1961,7 +1958,7 @@ async def test_sdiffstore(self, redis_client: TGlideClient): # Overwrite a key holding a non-set value assert await redis_client.sdiffstore(string_key, [key1, key2]) == 2 - assert await redis_client.smembers(string_key) == convert_str_to_bytes_set( + assert await redis_client.smembers(string_key) == convert_string_to_bytes_dict( {"a", "b"} ) @@ -1994,7 +1991,7 @@ async def test_ltrim(self, redis_client: TGlideClient): assert await redis_client.lpush(key, value_list) == 4 assert await redis_client.ltrim(key, 0, 1) == OK - assert await redis_client.lrange(key, 0, -1) == convert_str_to_bytes_list( + assert await redis_client.lrange(key, 0, -1) == convert_string_to_bytes_dict( ["value1", "value2"] ) @@ -2017,12 +2014,12 @@ async def test_lrem(self, redis_client: TGlideClient): assert await redis_client.lpush(key, value_list) == 5 assert await redis_client.lrem(key, 2, "value1") == 2 - assert await redis_client.lrange(key, 0, -1) == convert_str_to_bytes_list( + assert await redis_client.lrange(key, 0, -1) == convert_string_to_bytes_dict( ["value2", "value2", "value1"] ) assert await redis_client.lrem(key, -1, "value2") == 1 - assert await redis_client.lrange(key, 0, -1) == convert_str_to_bytes_list( + assert await redis_client.lrange(key, 0, -1) == convert_string_to_bytes_dict( ["value2", "value1"] ) @@ -2370,7 +2367,7 @@ async def test_geosearch_by_box(self, redis_client: TGlideClient): GeospatialData(15, 37), GeoSearchByBox(400, 400, GeoUnit.KILOMETERS), OrderBy.ASC, - ) == convert_str_to_bytes_list(members) + ) == convert_string_to_bytes_dict(members) assert await redis_client.geosearch( key, @@ -2380,7 +2377,7 @@ async def test_geosearch_by_box(self, redis_client: TGlideClient): with_coord=True, with_dist=True, with_hash=True, - ) == convert_str_to_bytes_list(result[::-1]) + ) == convert_string_to_bytes_dict(result[::-1]) assert await redis_client.geosearch( key, @@ -2400,7 +2397,7 @@ async def test_geosearch_by_box(self, redis_client: TGlideClient): GeoSearchByBox(meters, meters, GeoUnit.METERS), OrderBy.DESC, with_dist=True, - ) == convert_str_to_bytes_list( + ) == convert_string_to_bytes_dict( [["edge2", [236529.1799]], ["Palermo", [166274.1516]], ["Catania", [0.0]]] ) @@ -2424,7 +2421,7 @@ async def test_geosearch_by_box(self, redis_client: TGlideClient): OrderBy.ASC, count=GeoSearchCount(1, True), ) - )[0] in convert_str_to_bytes_list(members) + )[0] in convert_string_to_bytes_dict(members) @pytest.mark.parametrize("cluster_mode", [True, False]) @pytest.mark.parametrize("protocol", [ProtocolVersion.RESP2, ProtocolVersion.RESP3]) @@ -2456,7 +2453,7 @@ async def test_geosearch_by_radius(self, redis_client: TGlideClient): "Catania", GeoSearchByRadius(feet, GeoUnit.FEET), OrderBy.ASC, - ) == convert_str_to_bytes_list(members[:2]) + ) == convert_string_to_bytes_dict(members[:2]) # Test search by radius, units: meters, from a member meters = 200 * 1000 @@ -2465,7 +2462,7 @@ async def test_geosearch_by_radius(self, redis_client: TGlideClient): "Catania", GeoSearchByRadius(meters, GeoUnit.METERS), OrderBy.DESC, - ) == convert_str_to_bytes_list(members[:2][::-1]) + ) == convert_string_to_bytes_dict(members[:2][::-1]) # Test search by radius, unit: miles, from a geospatial data assert await redis_client.geosearch( @@ -2473,7 +2470,7 @@ async def test_geosearch_by_radius(self, redis_client: TGlideClient): GeospatialData(15, 37), GeoSearchByRadius(175, GeoUnit.MILES), OrderBy.DESC, - ) == convert_str_to_bytes_list(members[::-1]) + ) == convert_string_to_bytes_dict(members[::-1]) # Test search by radius, unit: kilometers, from a geospatial data, with limited count to 2 assert await redis_client.geosearch( @@ -2485,7 +2482,7 @@ async def test_geosearch_by_radius(self, redis_client: TGlideClient): with_coord=True, with_dist=True, with_hash=True, - ) == convert_str_to_bytes_list(result) + ) == convert_string_to_bytes_dict(result) # Test search by radius, unit: kilometers, from a geospatial data, with limited ANY count to 1 assert ( @@ -2499,7 +2496,7 @@ async def test_geosearch_by_radius(self, redis_client: TGlideClient): with_dist=True, with_hash=True, ) - )[0] in convert_str_to_bytes_list(result) + )[0] in convert_string_to_bytes_dict(result) @pytest.mark.parametrize("cluster_mode", [True, False]) @pytest.mark.parametrize("protocol", [ProtocolVersion.RESP2, ProtocolVersion.RESP3]) @@ -2876,7 +2873,7 @@ async def test_geohash(self, redis_client: TGlideClient): assert await redis_client.geoadd(key, members_coordinates) == 2 assert await redis_client.geohash( key, ["Palermo", "Catania", "Place"] - ) == convert_str_to_bytes_list( + ) == convert_string_to_bytes_dict( [ "sqc8b49rny0", "sqdtr74hyu0", @@ -3655,10 +3652,10 @@ async def test_bzpopmin(self, redis_client: TGlideClient): assert await redis_client.zadd(key2, {"c": 2.0}) == 1 assert await redis_client.bzpopmin( [key1, key2], 0.5 - ) == convert_str_to_bytes_list([key1, "a", 1.0]) + ) == convert_string_to_bytes_dict([key1, "a", 1.0]) assert await redis_client.bzpopmin( [non_existing_key, key2], 0.5 - ) == convert_str_to_bytes_list( + ) == convert_string_to_bytes_dict( [ key2, "c", @@ -3714,10 +3711,10 @@ async def test_bzpopmax(self, redis_client: TGlideClient): assert await redis_client.zadd(key2, {"c": 2.0}) == 1 assert await redis_client.bzpopmax( [key1, key2], 0.5 - ) == convert_str_to_bytes_list([key1, "b", 1.5]) + ) == convert_string_to_bytes_dict([key1, "b", 1.5]) assert await redis_client.bzpopmax( [non_existing_key, key2], 0.5 - ) == convert_str_to_bytes_list( + ) == convert_string_to_bytes_dict( [ key2, "c", @@ -4284,7 +4281,7 @@ async def test_zdiff(self, redis_client: TGlideClient): compare_maps(await redis_client.zdiff_withscores([key1, key3]), {}) is True ) non_exist_res = await redis_client.zdiff_withscores([non_existing_key, key3]) - assert compare_maps(non_exist_res, {}) + assert non_exist_res == {} # invalid argument - key list must not be empty with pytest.raises(RequestError): @@ -4657,7 +4654,7 @@ async def test_sort_and_sort_store_with_get_or_by_args( get_patterns=["user:*->name"], alpha=True, ) - assert result == convert_str_to_bytes_list( + assert result == convert_string_to_bytes_dict( ["Dave", "Bob", "Alice", "Charlie", "Eve"] ) @@ -4669,7 +4666,7 @@ async def test_sort_and_sort_store_with_get_or_by_args( get_patterns=["user:*->name"], alpha=True, ) - assert result == convert_str_to_bytes_list( + assert result == convert_string_to_bytes_dict( [None, "Dave", "Bob", "Alice", "Charlie", "Eve"] ) @@ -4680,7 +4677,7 @@ async def test_sort_and_sort_store_with_get_or_by_args( get_patterns=["user:*->age"], alpha=True, ) - assert result == convert_str_to_bytes_list([None, "30", "25", "35", "20", "40"]) + assert result == convert_string_to_bytes_dict([None, "30", "25", "35", "20", "40"]) # Test Limit with count 0 result = await redis_client.sort( @@ -4839,7 +4836,7 @@ async def test_xadd_xtrim_xlen(self, redis_client: TGlideClient): assert await redis_client.xadd( key, [(field, "foo1"), (field2, "bar1")], StreamAddOptions(id="0-1") - ) == "0-1".encode("utf-8") + ) == b"0-1" assert ( await redis_client.xadd(key, [(field, "foo2"), (field2, "bar2")]) @@ -7861,36 +7858,36 @@ async def test_sscan(self, redis_client: GlideClusterClient): # Empty set result = await redis_client.sscan(key1, initial_cursor) - assert result[result_cursor_index] == initial_cursor + assert result[result_cursor_index] == initial_cursor.encode() assert result[result_collection_index] == [] # Negative cursor result = await redis_client.sscan(key1, "-1") - assert result[result_cursor_index] == initial_cursor + assert result[result_cursor_index] == initial_cursor.encode() assert result[result_collection_index] == [] # Result contains the whole set assert await redis_client.sadd(key1, char_members) == len(char_members) result = await redis_client.sscan(key1, initial_cursor) - assert result[result_cursor_index] == initial_cursor + assert result[result_cursor_index] == initial_cursor.encode() assert len(result[result_collection_index]) == len(char_members) - assert set(result[result_collection_index]).issubset(set(char_members)) + assert set(result[result_collection_index]).issubset(convert_string_to_bytes_dict(char_members)) result = await redis_client.sscan(key1, initial_cursor, match="a") - assert result[result_cursor_index] == initial_cursor - assert set(result[result_collection_index]).issubset(set(["a"])) + assert result[result_cursor_index] == initial_cursor.encode() + assert set(result[result_collection_index]).issubset(set([b"a"])) # Result contains a subset of the key assert await redis_client.sadd(key1, num_members) == len(num_members) result_cursor = "0" result_values = set() # type: set[str] - result = await redis_client.sscan(key1, result_cursor) + result = convert_bytes_to_string_dict(await redis_client.sscan(key1, result_cursor)) result_cursor = str(result[result_cursor_index]) result_values.update(result[result_collection_index]) # 0 is returned for the cursor of the last iteration. while result_cursor != "0": - next_result = await redis_client.sscan(key1, result_cursor) + next_result = convert_bytes_to_string_dict(await redis_client.sscan(key1, result_cursor)) next_result_cursor = str(next_result[result_cursor_index]) assert next_result_cursor != result_cursor diff --git a/python/python/tests/utils/utils.py b/python/python/tests/utils/utils.py index 1d33fce74a..864d75e0a8 100644 --- a/python/python/tests/utils/utils.py +++ b/python/python/tests/utils/utils.py @@ -4,7 +4,6 @@ from typing import Any, Dict, List, Mapping, Optional, TypeVar, Union, cast from glide.async_commands.core import InfoSection -from glide.async_commands.utils.utils import convert_bytes_to_string_dict from glide.constants import TResult from glide.glide_client import TGlideClient from packaging import version @@ -131,21 +130,60 @@ def compare_maps( convert_bytes_to_string_dict(map2) ) - -def convert_str_to_bytes_list(lst): - return [ - ( - elem.encode("utf-8") - if isinstance(elem, str) - else convert_str_to_bytes_list(elem) if isinstance(elem, list) else elem - ) - for elem in lst +def convert_bytes_to_string_dict( + # TODO: remove the str options + byte_string_dict: Optional[ + Union[Mapping[bytes, Any], Dict[bytes, Any], list[bytes, Any], Mapping[str, Any], Dict[str, Any]] ] - - -def convert_str_to_bytes_set(set): - return {elem.encode("utf-8") if isinstance(elem, str) else elem for elem in set} - +) -> Optional[Dict[str, Any]]: + """ + Recursively convert data structure from byte strings to regular strings, + handling nested data structures of any depth. + """ + if byte_string_dict is None: + return None + + def convert(item: Any) -> Any: + if isinstance(item, dict): + return {convert(key): convert(value) for key, value in item.items()} + elif isinstance(item, list): + return [convert(elem) for elem in item] + elif isinstance(item, set): + return {convert(elem) for elem in item} + elif isinstance(item, bytes): + return item.decode("utf-8") + else: + return item + + return convert(byte_string_dict) + + +def convert_string_to_bytes_dict( + # TODO: remove the bytes options + string_structure: Optional[ + Union[Mapping[bytes, Any], Dict[bytes, Any], list[str, Any], Mapping[str, Any], Dict[str, Any]] + ] +) -> Optional[Dict[bytes, Any]]: + """ + Recursively convert the data structure from strings to bytes, + handling nested data structures of any depth. + """ + if string_structure is None: + return None + + def convert(item: Any) -> Any: + if isinstance(item, dict): + return {convert(key): convert(value) for key, value in item.items()} + elif isinstance(item, list): + return [convert(elem) for elem in item] + elif isinstance(item, set): + return {convert(elem) for elem in item} + elif isinstance(item, str): + return item.encode("utf-8") + else: + return item + + return convert(string_structure) def generate_lua_lib_code( lib_name: str, functions: Mapping[str, str], readonly: bool