def connect_with_fallback(host, port, password=None):
    """连接 Redis，自动协商协议版本"""
    sock = socket.create_connection((host, port))

    # 先尝试 RESP3
    send_command(sock, "HELLO", "3")
    resp = read_response(sock)

    if isinstance(resp, Exception):
        # 服务器不支持 RESP3，回退到 RESP2
        send_command(sock, "HELLO", "2")
        resp = read_response(sock)
        protocol_version = 2
    else:
        protocol_version = 3

    if password:
        send_command(sock, "AUTH", password)
        read_response(sock)

    return sock, protocol_version

def handle_boolean(value: str) -> bool:
    if value == "t":
        return True
    elif value == "f":
        return False
    else:
        raise ValueError(f"Invalid boolean: {value}")

from decimal import Decimal

def handle_big_number(line: bytes) -> Decimal:
    """解析 Big Number，使用 Decimal 避免精度丢失"""
    return Decimal(line[1:].decode("utf-8"))

def handle_verbatim_string(data: bytes) -> tuple[str, str]:
    """
    解析 Verbatim String
    返回 (encoding, content)
    """
    # data 不包含 = 和长度前缀，如 b"txt:Hello World"
    encoding = data[:3].decode()
    content = data[4:]  # 跳过 "txt:"
    return encoding, content

{
  "user:1": {"name": "Alice", "age": 30},
  "user:2": {"name": "Bob", "age": 25}
}

def parse_response_with_attributes(reader):
    """解析可能带属性的响应"""
    # 预读一个字节判断类型
    first_byte = reader.peek_byte()

    if first_byte == ord("|"):
        # 这是属性，读取并存储
        attrs = reader.parse_map()
        # 继续读取实际响应
        result = reader.parse()
        return result, attrs
    else:
        return reader.parse(), None

class RESP3Parser:
    """支持 RESP2 和 RESP3 的混合解析器"""

    def __init__(self, sock):
        self.sock = sock
        self.buffer = b""

    def _read_line(self) -> bytes:
        while b"\r\n" not in self.buffer:
            chunk = self.sock.recv(4096)
            if not chunk:
                raise ConnectionError("Connection closed")
            self.buffer += chunk
        pos = self.buffer.index(b"\r\n")
        line = self.buffer[:pos]
        self.buffer = self.buffer[pos + 2:]
        return line

    def _read_bytes(self, n: int) -> bytes:
        while len(self.buffer) < n:
            chunk = self.sock.recv(4096)
            if not chunk:
                raise ConnectionError("Connection closed")
            self.buffer += chunk
        result = self.buffer[:n]
        self.buffer = self.buffer[n:]
        return result

    def parse(self):
        line = self._read_line()
        prefix = chr(line[0])

        # RESP2 类型
        if prefix == "+":
            return line[1:].decode("utf-8")
        elif prefix == "-":
            raise RedisError(line[1:].decode("utf-8"))
        elif prefix == ":":
            return int(line[1:])
        elif prefix == "$":
            length = int(line[1:])
            if length == -1:
                return None
            data = self._read_bytes(length + 2)
            return data[:length]
        elif prefix == "*":
            count = int(line[1:])
            if count == -1:
                return None
            return [self.parse() for _ in range(count)]

        # RESP3 新类型
        elif prefix == "_":
            return None
        elif prefix == "#":
            return line[1:] == b"t"
        elif prefix == ",":
            val = line[1:].decode()
            if val == "inf": return float("inf")
            if val == "-inf": return float("-inf")
            if val == "nan": return float("nan")
            return float(val)
        elif prefix == "(":
            return int(line[1:])  # 或使用 Decimal
        elif prefix == "=":
            length = int(line[1:])
            data = self._read_bytes(length + 2)[:length]
            encoding = data[:3].decode()
            content = data[4:]
            return {"encoding": encoding, "content": content}
        elif prefix == "%":
            count = int(line[1:])
            result = {}
            for _ in range(count):
                key = self.parse()
                value = self.parse()
                result[key] = value
            return result
        elif prefix == "~":
            count = int(line[1:])
            return {self.parse() for _ in range(count)}
        elif prefix == "|":
            count = int(line[1:])
            attrs = {}
            for _ in range(count):
                key = self.parse()
                value = self.parse()
                attrs[key] = value
            result = self.parse()
            return {"_attrs": attrs, "_value": result}
        elif prefix == ">":
            count = int(line[1:])
            return {"_type": "push", "data": [self.parse() for _ in range(count)]}
        else:
            raise ValueError(f"Unknown RESP type prefix: {prefix}")